games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2025-11-06 09:09:40 +02:00
Code Issues Releases Activity

Fix battle timer logic

Browse Source
This commit is contained in:
nordsoft
2023-08-26 05:39:29 +04:00
parent fdaf05514a
commit 0bc2302f1f
3 changed files with 55 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
server/CGameHandler.cpp
View File

@@ -604,7 +604,7 @@ void CGameHandler::setPortalDwelling(const CGTownInstance * town, bool forced=fa
void CGameHandler::onPlayerTurnStarted(PlayerColor which) void CGameHandler::onPlayerTurnStarted(PlayerColor which)
{ {
events::PlayerGotTurn::defaultExecute(serverEventBus.get(), which); events::PlayerGotTurn::defaultExecute(serverEventBus.get(), which);
turnTimerHandler.onPlayerGetTurn(gs->players[which]); turnTimerHandler.onPlayerGetTurn(which);
} }
void CGameHandler::onPlayerTurnEnded(PlayerColor which) void CGameHandler::onPlayerTurnEnded(PlayerColor which)
@@ -991,7 +991,7 @@ void CGameHandler::run(bool resume)
onNewTurn(); onNewTurn();
events::TurnStarted::defaultExecute(serverEventBus.get()); events::TurnStarted::defaultExecute(serverEventBus.get());
for(auto & player : gs->players) for(auto & player : gs->players)
turnTimerHandler.onGameplayStart(player.second); turnTimerHandler.onGameplayStart(player.first);
} }
else else
events::GameResumed::defaultExecute(serverEventBus.get()); events::GameResumed::defaultExecute(serverEventBus.get());

98
server/TurnTimerHandler.cpp
View File

@@ -26,63 +26,65 @@ TurnTimerHandler::TurnTimerHandler(CGameHandler & gh):
} }
void TurnTimerHandler::onGameplayStart(PlayerState & state) void TurnTimerHandler::onGameplayStart(PlayerColor player)
{ {
if(const auto * si = gameHandler.getStartInfo()) if(const auto * si = gameHandler.getStartInfo())
{ {
if(si->turnTimerInfo.isEnabled()) if(si->turnTimerInfo.isEnabled())
{ {
state.turnTimer = si->turnTimerInfo; timers[player] = si->turnTimerInfo;
state.turnTimer.turnTimer = 0; timers[player].turnTimer = 0;
} }
} }
} }
void TurnTimerHandler::onPlayerGetTurn(PlayerState & state) void TurnTimerHandler::onPlayerGetTurn(PlayerColor player)
{ {
if(const auto * si = gameHandler.getStartInfo()) if(const auto * si = gameHandler.getStartInfo())
{ {
if(si->turnTimerInfo.isEnabled()) if(si->turnTimerInfo.isEnabled())
{ {
state.turnTimer.baseTimer += state.turnTimer.turnTimer; timers[player].baseTimer += timers[player].turnTimer;
state.turnTimer.turnTimer = si->turnTimerInfo.turnTimer; timers[player].turnTimer = si->turnTimerInfo.turnTimer;
TurnTimeUpdate ttu; TurnTimeUpdate ttu;
ttu.player = state.color; ttu.player = player;
ttu.turnTimer = state.turnTimer; ttu.turnTimer = timers[player];
gameHandler.sendAndApply(&ttu); gameHandler.sendAndApply(&ttu);
} }
} }
} }
void TurnTimerHandler::onPlayerMakingTurn(PlayerState & state, int waitTime) void TurnTimerHandler::onPlayerMakingTurn(PlayerColor player, int waitTime)
{ {
const auto * gs = gameHandler.gameState(); const auto * gs = gameHandler.gameState();
const auto * si = gameHandler.getStartInfo(); const auto * si = gameHandler.getStartInfo();
if(!si || !gs) if(!si || !gs)
return; return;
auto & state = gs->players.at(player);
if(state.human && si->turnTimerInfo.isEnabled() && !gs->curB) if(state.human && si->turnTimerInfo.isEnabled() && !gs->curB)
{ {
if(state.turnTimer.turnTimer > 0) if(timers[player].turnTimer > 0)
{ {
state.turnTimer.turnTimer -= waitTime; timers[player].turnTimer -= waitTime;
int frequency = (state.turnTimer.creatureTimer > turnTimePropagateThreshold ? turnTimePropagateFrequency : turnTimePropagateFrequencyCrit); int frequency = (timers[player].turnTimer > turnTimePropagateThreshold ? turnTimePropagateFrequency : turnTimePropagateFrequencyCrit);
if(state.status == EPlayerStatus::INGAME //do not send message if player is not active already if(state.status == EPlayerStatus::INGAME //do not send message if player is not active already
&& state.turnTimer.turnTimer % frequency == 0) && timers[player].turnTimer % frequency == 0)
{ {
TurnTimeUpdate ttu; TurnTimeUpdate ttu;
ttu.player = state.color; ttu.player = state.color;
ttu.turnTimer = state.turnTimer; ttu.turnTimer = timers[player];
gameHandler.sendAndApply(&ttu); gameHandler.sendAndApply(&ttu);
} }
} }
else if(state.turnTimer.baseTimer > 0) else if(timers[player].baseTimer > 0)
{ {
state.turnTimer.turnTimer = state.turnTimer.baseTimer; timers[player].turnTimer = timers[player].baseTimer;
state.turnTimer.baseTimer = 0; timers[player].baseTimer = 0;
onPlayerMakingTurn(state, waitTime); onPlayerMakingTurn(player, 0);
} }
else if(!gameHandler.queries->topQuery(state.color)) //wait for replies to avoid pending queries else if(!gameHandler.queries->topQuery(state.color)) //wait for replies to avoid pending queries
gameHandler.turnOrder->onPlayerEndsTurn(state.color); gameHandler.turnOrder->onPlayerEndsTurn(state.color);
@@ -103,12 +105,12 @@ void TurnTimerHandler::onBattleStart()
{ {
if(i.isValidPlayer()) if(i.isValidPlayer())
{ {
const auto & state = gs->players.at(i); timers[i].battleTimer = si->turnTimerInfo.battleTimer;
timers[i].creatureTimer = si->turnTimerInfo.creatureTimer;
TurnTimeUpdate ttu; TurnTimeUpdate ttu;
ttu.player = state.color; ttu.player = i;
ttu.turnTimer = state.turnTimer; ttu.turnTimer = timers[i];
ttu.turnTimer.battleTimer = si->turnTimerInfo.battleTimer;
ttu.turnTimer.creatureTimer = si->turnTimerInfo.creatureTimer;
gameHandler.sendAndApply(&ttu); gameHandler.sendAndApply(&ttu);
} }
} }
@@ -118,24 +120,22 @@ void TurnTimerHandler::onBattleNextStack(const CStack & stack)
{ {
const auto * gs = gameHandler.gameState(); const auto * gs = gameHandler.gameState();
const auto * si = gameHandler.getStartInfo(); const auto * si = gameHandler.getStartInfo();
if(!si || !gs || !gs->curB) if(!si || !gs || !gs->curB || !si->turnTimerInfo.isBattleEnabled())
return; return;
if(!stack.getOwner().isValidPlayer()) auto player = stack.getOwner();
if(!player.isValidPlayer())
return; return;
const auto & state = gs->players.at(stack.getOwner()); if(timers[player].battleTimer < si->turnTimerInfo.battleTimer)
timers[player].battleTimer = timers[player].creatureTimer;
if(si->turnTimerInfo.isBattleEnabled()) timers[player].creatureTimer = si->turnTimerInfo.creatureTimer;
{
TurnTimeUpdate ttu; TurnTimeUpdate ttu;
ttu.player = state.color; ttu.player = player;
ttu.turnTimer = state.turnTimer; ttu.turnTimer = timers[player];
if(state.turnTimer.battleTimer < si->turnTimerInfo.battleTimer) gameHandler.sendAndApply(&ttu);
ttu.turnTimer.battleTimer = ttu.turnTimer.creatureTimer;
ttu.turnTimer.creatureTimer = si->turnTimerInfo.creatureTimer;
gameHandler.sendAndApply(&ttu);
}
} }
void TurnTimerHandler::onBattleLoop(int waitTime) void TurnTimerHandler::onBattleLoop(int waitTime)
@@ -151,20 +151,19 @@ void TurnTimerHandler::onBattleLoop(int waitTime)
auto & state = gs->players.at(gs->curB->getSidePlayer(stack->unitSide())); auto & state = gs->players.at(gs->curB->getSidePlayer(stack->unitSide()));
auto turnTimerUpdateApplier = [&](const TurnTimerInfo & tTimer) auto turnTimerUpdateApplier = [&](TurnTimerInfo & tTimer, int waitTime)
{ {
TurnTimerInfo turnTimerUpdate = tTimer;
if(tTimer.creatureTimer > 0) if(tTimer.creatureTimer > 0)
{ {
turnTimerUpdate.creatureTimer -= waitTime; tTimer.creatureTimer -= waitTime;
int frequency = (turnTimerUpdate.creatureTimer > turnTimePropagateThreshold ? turnTimePropagateFrequency : turnTimePropagateFrequencyCrit); int frequency = (tTimer.creatureTimer > turnTimePropagateThreshold ? turnTimePropagateFrequency : turnTimePropagateFrequencyCrit);
if(state.status == EPlayerStatus::INGAME //do not send message if player is not active already if(state.status == EPlayerStatus::INGAME //do not send message if player is not active already
&& turnTimerUpdate.creatureTimer % frequency == 0) && tTimer.creatureTimer % frequency == 0)
{ {
TurnTimeUpdate ttu; TurnTimeUpdate ttu;
ttu.player = state.color; ttu.player = state.color;
ttu.turnTimer = turnTimerUpdate; ttu.turnTimer = tTimer;
gameHandler.sendAndApply(&ttu); gameHandler.sendAndApply(&ttu);
} }
return true; return true;
@@ -174,14 +173,13 @@ void TurnTimerHandler::onBattleLoop(int waitTime)
if(state.human && si->turnTimerInfo.isBattleEnabled()) if(state.human && si->turnTimerInfo.isBattleEnabled())
{ {
TurnTimerInfo turnTimer = state.turnTimer; if(!turnTimerUpdateApplier(timers[state.color], waitTime))
if(!turnTimerUpdateApplier(turnTimer))
{ {
if(turnTimer.battleTimer > 0) if(timers[state.color].battleTimer > 0)
{ {
turnTimer.creatureTimer = turnTimer.battleTimer; timers[state.color].creatureTimer = timers[state.color].battleTimer;
turnTimer.battleTimer = 0; timers[state.color].battleTimer = 0;
turnTimerUpdateApplier(turnTimer); turnTimerUpdateApplier(timers[state.color], 0);
} }
else else
{ {

9
server/TurnTimerHandler.h
View File

@@ -14,7 +14,7 @@ VCMI_LIB_NAMESPACE_BEGIN
class CStack; class CStack;
class PlayerColor; class PlayerColor;
struct PlayerState; struct TurnTimerInfo;
VCMI_LIB_NAMESPACE_END VCMI_LIB_NAMESPACE_END
@@ -26,13 +26,14 @@ class TurnTimerHandler
const int turnTimePropagateFrequency = 5000; const int turnTimePropagateFrequency = 5000;
const int turnTimePropagateFrequencyCrit = 1000; const int turnTimePropagateFrequencyCrit = 1000;
const int turnTimePropagateThreshold = 3000; const int turnTimePropagateThreshold = 3000;
std::map<PlayerColor, TurnTimerInfo> timers;
public: public:
TurnTimerHandler(CGameHandler &); TurnTimerHandler(CGameHandler &);
void onGameplayStart(PlayerState & state); void onGameplayStart(PlayerColor player);
void onPlayerGetTurn(PlayerState & state); void onPlayerGetTurn(PlayerColor player);
void onPlayerMakingTurn(PlayerState & state, int waitTime); void onPlayerMakingTurn(PlayerColor player, int waitTime);
void onBattleStart(); void onBattleStart();
void onBattleNextStack(const CStack & stack); void onBattleNextStack(const CStack & stack);
void onBattleLoop(int waitTime); void onBattleLoop(int waitTime);