ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make new startup boost and penalty working in network

Browse Source
This commit is contained in:
Benau 2018-09-14 22:23:37 +08:00
parent 641998be69
commit b613c2c989
7 changed files with 100 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/karts/controller/local_player_controller.cpp
View File

@ -170,6 +170,12 @@ bool LocalPlayerController::action(PlayerAction action, int value,
World::getWorld()->getAuxiliaryTicks());
m_kart->setStartupBoost(f);
}
else if (NetworkConfig::get()->isClient())
{
auto ge = RaceEventManager::getInstance()->getProtocol();
assert(ge);
ge->sendStartupBoost((uint8_t)m_kart->getWorldKartId());
}
}
// If this event does not change the control state (e.g.
@ -282,6 +288,7 @@ void LocalPlayerController::update(int ticks)
*/
void LocalPlayerController::displayPenaltyWarning()
{
PlayerController::displayPenaltyWarning();
RaceGUIBase* m=World::getWorld()->getRaceGUI();
if (m)
{

7
src/karts/controller/player_controller.cpp
View File

@ -335,7 +335,6 @@ void PlayerController::update(int ticks)
World::getWorld()->getPhase() == WorldStatus::READY_PHASE)
{
displayPenaltyWarning();
m_penalty_ticks = stk_config->m_penalty_ticks;
} // if penalty_time = 0
m_controls->setBrake(false);
} // if key pressed
@ -405,3 +404,9 @@ core::stringw PlayerController::getName() const
}
return name;
} // getName
// ----------------------------------------------------------------------------
void PlayerController::displayPenaltyWarning()
{
m_penalty_ticks = stk_config->m_penalty_ticks;
} // displayPenaltyWarning

7
src/karts/controller/player_controller.hpp
View File

@ -36,10 +36,6 @@ protected:
int m_penalty_ticks;
virtual void steer(int ticks, int steer_val);
// ------------------------------------------------------------------------
/** Called when this kart started too early and got a start penalty. */
virtual void displayPenaltyWarning() {}
// ------------------------------------------------------------------------
public:
PlayerController(AbstractKart *kart);
@ -95,6 +91,9 @@ public:
// ------------------------------------------------------------------------
/** Returns the name of the player profile. */
core::stringw getName() const OVERRIDE;
// ------------------------------------------------------------------------
/** Called when this kart started too early and got a start penalty. */
virtual void displayPenaltyWarning();
}; // class PlayerController

48
src/network/protocols/game_events_protocol.cpp
View File

@ -1,11 +1,13 @@
#include "network/protocols/game_events_protocol.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/player_controller.hpp"
#include "modes/capture_the_flag.hpp"
#include "modes/soccer_world.hpp"
#include "network/event.hpp"
#include "network/game_setup.hpp"
#include "network/network_config.hpp"
#include "network/protocols/server_lobby.hpp"
#include "network/rewind_manager.hpp"
#include "network/stk_host.hpp"
#include "network/stk_peer.hpp"
@ -89,6 +91,42 @@ bool GameEventsProtocol::notifyEvent(Event* event)
ctf->resetFlag(data);
break;
}
case GE_STARTUP_BOOST:
{
if (NetworkConfig::get()->isServer())
{
uint8_t kart_id = data.getUInt8();
if (!event->getPeer()->availableKartID(kart_id))
{
Log::warn("GameProtocol", "Wrong kart id %d from %s.",
kart_id, event->getPeer()->getAddress().toString().c_str());
return true;
}
float f = LobbyProtocol::get<ServerLobby>()
->getStartupBoostOrPenaltyForKart(
event->getPeer()->getAveragePing(), kart_id);
NetworkString *ns = getNetworkString();
ns->setSynchronous(true);
ns->addUInt8(GE_STARTUP_BOOST).addUInt8(kart_id).addFloat(f);
sendMessageToPeers(ns, true);
delete ns;
}
else
{
uint8_t kart_id = data.getUInt8();
float boost = data.getFloat();
AbstractKart* k = World::getWorld()->getKart(kart_id);
if (boost < 0.0f)
{
PlayerController* pc =
dynamic_cast<PlayerController*>(k->getController());
pc->displayPenaltyWarning();
}
else
k->setStartupBoost(boost);
}
break;
}
default:
Log::warn("GameEventsProtocol", "Unkown message type.");
break;
@ -146,3 +184,13 @@ void GameEventsProtocol::kartFinishedRace(const NetworkString &ns)
World::getWorld()->getKart(kart_id)->finishedRace(time,
/*from_server*/true);
} // kartFinishedRace
// ----------------------------------------------------------------------------
void GameEventsProtocol::sendStartupBoost(uint8_t kart_id)
{
NetworkString *ns = getNetworkString();
ns->setSynchronous(true);
ns->addUInt8(GE_STARTUP_BOOST).addUInt8(kart_id);
sendToServer(ns, /*reliable*/true);
delete ns;
} // sendStartupBoost

4
src/network/protocols/game_events_protocol.hpp
View File

@ -17,7 +17,8 @@ public:
GE_PLAYER_GOAL = 4,
GE_BATTLE_KART_SCORE = 5,
GE_CTF_ATTACH = 6,
GE_CTF_RESET = 7
GE_CTF_RESET = 7,
GE_STARTUP_BOOST = 8,
}; // GameEventType
private:
void eliminatePlayer(const NetworkString &ns);
@ -29,6 +30,7 @@ public:
virtual bool notifyEvent(Event* event) OVERRIDE;
void kartFinishedRace(AbstractKart *kart, float time);
void kartFinishedRace(const NetworkString &ns);
void sendStartupBoost(uint8_t kart_id);
virtual void setup() OVERRIDE {}
virtual void update(int ticks) OVERRIDE {};
virtual void asynchronousUpdate() OVERRIDE{}

32
src/network/protocols/server_lobby.cpp
View File

@ -20,6 +20,8 @@
#include "config/user_config.hpp"
#include "items/item_manager.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/player_controller.hpp"
#include "karts/kart_properties_manager.hpp"
#include "modes/linear_world.hpp"
#include "network/crypto.hpp"
@ -228,7 +230,7 @@ void ServerLobby::setup()
m_peers_votes.clear();
m_timeout.store(std::numeric_limits<int64_t>::max());
m_waiting_for_reset = false;
m_server_started_at = m_server_delay = 0;
Log::info("ServerLobby", "Reset server to initial state.");
} // setup
@ -2279,7 +2281,9 @@ void ServerLobby::configPeersStartTime()
Log::info("ServerLobby", "Max ping from peers: %d, jitter tolerance: %d",
max_ping, jitter_tolerance);
// Delay server for max ping / 2 from peers and jitter tolerance.
start_time += (uint64_t)(max_ping / 2) + (uint64_t)jitter_tolerance;
m_server_delay = (uint64_t)(max_ping / 2) + (uint64_t)jitter_tolerance;
start_time += m_server_delay;
m_server_started_at = start_time;
delete ns;
m_state = WAIT_FOR_RACE_STARTED;
@ -2410,3 +2414,27 @@ bool ServerLobby::isBannedForIP(const TransportAddress& addr) const
}
return is_banned;
} // isBannedForIP
//-----------------------------------------------------------------------------
float ServerLobby::getStartupBoostOrPenaltyForKart(uint32_t ping,
unsigned kart_id)
{
AbstractKart* k = World::getWorld()->getKart(kart_id);
if (k->getStartupBoost() != 0.0f)
return k->getStartupBoost();
uint64_t now = STKHost::get()->getNetworkTimer();
uint64_t client_time = now - ping / 2;
uint64_t server_time = client_time + m_server_delay;
int ticks = stk_config->time2Ticks(
(float)(server_time - m_server_started_at) / 1000.0f);
if (ticks < stk_config->time2Ticks(1.0f))
{
PlayerController* pc =
dynamic_cast<PlayerController*>(k->getController());
pc->displayPenaltyWarning();
return -1.0f;
}
float f = k->getStartupBoostFromStartTicks(ticks);
k->setStartupBoost(f);
return f;
} // getStartupBoostOrPenaltyForKart

3
src/network/protocols/server_lobby.hpp
View File

@ -148,6 +148,8 @@ private:
std::atomic<uint32_t> m_waiting_players_counts;
uint64_t m_server_started_at, m_server_delay;
unsigned m_server_id_online;
bool m_registered_for_once_only;
@ -275,6 +277,7 @@ public:
bool isBannedForIP(const TransportAddress& addr) const;
bool allowJoinedPlayersWaiting() const;
void setSaveServerConfig(bool val) { m_save_server_config = val; }
float getStartupBoostOrPenaltyForKart(uint32_t ping, unsigned kart_id);
}; // class ServerLobby
#endif // SERVER_LOBBY_HPP