feat: add persistent live and daily turn timers

Author: Enn3Developer

OpenPolytopia.Common/Gameplay/GameActionResult.cs

@@ -109,5 +109,8 @@ public enum GameActionResult : byte {
   InvalidTroopType = 32,
 
   /// <summary>The tile isn't a valid capture target</summary>
-  NotACaptureTarget = 33
+  NotACaptureTarget = 33,
+
+  /// <summary>The request parameters do not match the current game state.</summary>
+  InvalidParameters = 34
 }

OpenPolytopia.Common/Network/PacketRegistrar.cs

@@ -45,8 +45,6 @@ public static void RegisterAllPackets() {
         return;
       }
 
-      _registered = true;
-
       RegisterPacket<KeepAlivePacket>(0);
       RegisterPacket<HandshakePacket>(1);
       RegisterPacket<HandshakeResponsePacket>(2);
@@ -103,6 +101,7 @@ public static void RegisterAllPackets() {
       RegisterPacket<MembershipResultPacket>(53);
       RegisterPacket<GameClockPacket>(54);
       RegisterPacket<ResolveOverdueTurnPacket>(55);
+      _registered = true;
 
     }
   }

OpenPolytopia.Common/Network/Packets/GamePackets.cs

@@ -96,6 +96,8 @@ public partial class GameStatePacket : IPacket {
 /// </summary>
 [GeneratedPacket]
 public partial class MoveTroopPacket : IPacket {
+  /// <summary>Round shown when the action was issued; required for live games.</summary>
+  [PacketField] public uint ExpectedTurn;
   /// <summary>
   /// Id of the game, i.e. the id of the lobby it started from
   /// </summary>
@@ -168,6 +170,8 @@ public partial class TroopMovedPacket : IPacket {
 /// </summary>
 [GeneratedPacket]
 public partial class AttackPacket : IPacket {
+  /// <summary>Round shown when the action was issued; required for live games.</summary>
+  [PacketField] public uint ExpectedTurn;
   /// <summary>
   /// Id of the game, i.e. the id of the lobby it started from
   /// </summary>
@@ -270,6 +274,8 @@ public partial class CombatPacket : IPacket {
 /// </summary>
 [GeneratedPacket]
 public partial class TrainTroopPacket : IPacket {
+  /// <summary>Round shown when the action was issued; required for live games.</summary>
+  [PacketField] public uint ExpectedTurn;
   /// <summary>
   /// Id of the game, i.e. the id of the lobby it started from
   /// </summary>
@@ -342,6 +348,8 @@ public partial class TroopTrainedPacket : IPacket {
 /// </summary>
 [GeneratedPacket]
 public partial class ResearchTechPacket : IPacket {
+  /// <summary>Round shown when the action was issued; required for live games.</summary>
+  [PacketField] public uint ExpectedTurn;
   /// <summary>
   /// Id of the game, i.e. the id of the lobby it started from
   /// </summary>
@@ -402,6 +410,8 @@ public partial class TechResearchedPacket : IPacket {
 /// </summary>
 [GeneratedPacket]
 public partial class BuildPacket : IPacket {
+  /// <summary>Round shown when the action was issued; required for live games.</summary>
+  [PacketField] public uint ExpectedTurn;
   /// <summary>
   /// Id of the game, i.e. the id of the lobby it started from
   /// </summary>
@@ -474,6 +484,8 @@ public partial class BuildingBuiltPacket : IPacket {
 /// </summary>
 [GeneratedPacket]
 public partial class CapturePacket : IPacket {
+  /// <summary>Round shown when the action was issued; required for live games.</summary>
+  [PacketField] public uint ExpectedTurn;
   /// <summary>
   /// Id of the game, i.e. the id of the lobby it started from
   /// </summary>
@@ -546,6 +558,8 @@ public partial class CityCapturedPacket : IPacket {
 /// </summary>
 [GeneratedPacket]
 public partial class EndTurnPacket : IPacket {
+  /// <summary>Round shown when the action was issued; required for live games.</summary>
+  [PacketField] public uint ExpectedTurn;
   /// <summary>
   /// Id of the game, i.e. the id of the lobby it started from
   /// </summary>

OpenPolytopia.Server/GameManager.cs

@@ -54,7 +54,7 @@ public void Disconnect(uint connectionId) {
   /// <returns>the newly created, started and registered session</returns>
   /// <exception cref="ArgumentException">if the lobby doesn't have 2 to 16 players</exception>
   public async Task<GameSession> CreateGameAsync(LobbyData lobby, GameData data, int? seed = null,
-    IReadOnlyDictionary<uint, uint>? onlineConnections = null) {
+    IReadOnlyDictionary<uint, uint>? onlineConnections = null, DateTimeOffset? startedAt = null) {
     ArgumentNullException.ThrowIfNull(lobby);
     ArgumentNullException.ThrowIfNull(data);
 
@@ -88,7 +88,10 @@ public async Task<GameSession> CreateGameAsync(LobbyData lobby, GameData data, i
       players);
     game.Start();
 
-    var session = new GameSession(lobby.Id, game, connections, names);
+    var session = new GameSession(lobby.Id, game, connections, names) {
+      Clock = new TurnClock((TurnTimerMode)lobby.TimerMode, game.Players.Select(p => p.Id))
+    };
+    session.Clock.Begin(game.CurrentPlayer, startedAt ?? DateTimeOffset.UtcNow);
     if (onlineConnections != null) {
       foreach (var connectionId in session.ConnectionIds.ToArray()) session.RemoveConnection(connectionId);
       foreach (var accountId in connections.Values) {

OpenPolytopia.Server/GameServer.Accounts.cs

@@ -66,6 +66,7 @@ private void RegisterAccountHandlers() {
       var session = _gameManager[p.GameId];
       if (session != null && session.Join(AccountId(c), c.Id)) {
         SendTo(c.Id, session.BuildState());
+        SendClock(session, [c.Id]);
       }
       else SendTo(c.Id, new GameStatePacket { GameId = p.GameId,
         Result = session == null ? GameActionResult.GameNotFound : GameActionResult.NotInGame });

OpenPolytopia.Server/GameServer.Persistence.cs

@@ -15,26 +15,28 @@ public partial class GameServer {
   private readonly Dictionary<uint, string> _pendingRenames = new();
 
   private sealed record SavedSession(ulong Id, GameSnapshot Game, Dictionary<int, uint> Accounts,
-    Dictionary<int, string> Names);
+    Dictionary<int, string> Names, TurnClockState? Clock);
   private sealed record SavedServer(int Version, ulong NextLobbyId, List<LobbyData> Lobbies,
     List<SavedSession> Games);
 
-  private string CaptureState() => JsonSerializer.Serialize(new SavedServer(1, _lobbyManager.LastId,
+  private string CaptureState() => JsonSerializer.Serialize(new SavedServer(2, _lobbyManager.LastId,
     [.. _lobbyManager.Lobbies], [.. _gameManager.Sessions.Select(session => new SavedSession(session.Id,
-      session.Game.ToSnapshot(), new(session.Accounts), new(session.Names)))]), _json);
+      session.Game.ToSnapshot(), new(session.Accounts), new(session.Names), session.Clock?.ToSnapshot()))]), _json);
 
   private void RestoreState(string? json) {
     if (json == null) return;
     var state = JsonSerializer.Deserialize<SavedServer>(json, _json) ?? throw new InvalidDataException("Empty server state");
-    if (state.Version != 1) throw new InvalidDataException("Unsupported server state version");
+    if (state.Version != 2) throw new InvalidDataException("Unsupported server state version");
     var nextLobbies = new LobbyManager();
     nextLobbies.Restore(state.NextLobbyId, state.Lobbies);
     var nextGames = new GameManager();
     foreach (var saved in state.Games) {
       var troops = new TroopManager(saved.Game.GridSize);
       troops.RegisterTroops(_gameData.TroopsSerializedData);
       var game = Game.Restore(saved.Game, troops, _gameData.Tribes, _gameData.Buildings, _gameData.TechTreeDefinition);
-      var session = new GameSession(saved.Id, game, saved.Accounts, saved.Names);
+      var session = new GameSession(saved.Id, game, saved.Accounts, saved.Names) {
+        Clock = TurnClock.FromSnapshot(saved.Clock ?? throw new InvalidDataException("Missing saved turn clock"))
+      };
       foreach (var connection in session.ConnectionIds.ToArray()) session.RemoveConnection(connection);
       nextGames.Restore(session);
     }
@@ -56,8 +58,12 @@ private async Task WithStateAsync(Func<Task> action, bool stateMayChange = true)
     var attachments = _gameManager.Sessions.Where(s => s.Connections.Count != 0).ToDictionary(s => s.Id, s => s.Connections.ToArray());
     try {
       before = _savedState ??= CaptureState();
-      var changes = stateMayChange || _lobbyManager.Lobbies.Any(l => l.Starting);
+      var now = _timeProvider.GetUtcNow();
+      var changes = stateMayChange || _lobbyManager.Lobbies.Any(l => l.Starting) ||
+        _gameManager.Sessions.Any(s => !s.Game.Over && s.Clock?.Mode == TurnTimerMode.Live && s.Clock.IsExpired(now));
+      ProcessTimers(now);
       await action();
+      SynchronizeClocks(_timeProvider.GetUtcNow());
       var after = changes ? CaptureState() : before;
       if (after != before || _pendingRenames.Count != 0) _store.SaveState(after, _pendingRenames);
       _savedState = after;

OpenPolytopia.Server/GameServer.Timers.cs

@@ -0,0 +1,84 @@
+namespace OpenPolytopia.Server;
+
+using OpenPolytopia.Common.Gameplay;
+using OpenPolytopia.Common.Network.Packets;
+
+public partial class GameServer {
+  private readonly TimeProvider _timeProvider = timeProvider ?? TimeProvider.System;
+
+  private void RegisterTimerHandlers() {
+    _dispatcher.Register<ResolveOverdueTurnPacket>((connection, packet) => {
+      var session = _gameManager[packet.GameId];
+      var playerId = session?.PlayerIdOfAccount(AccountId(connection)) ?? 0;
+      var now = _timeProvider.GetUtcNow();
+      var result = session == null ? GameActionResult.GameNotFound :
+        playerId == 0 ? GameActionResult.NotInGame :
+        session.Game.Over ? GameActionResult.GameOver :
+        !session.Game[playerId]!.Alive ? GameActionResult.PlayerEliminated :
+        session.Game.CurrentPlayer == playerId || session.Game.Turn != packet.ExpectedTurn ||
+        session.Game.CurrentPlayer != packet.ExpectedPlayer || session.Clock?.Mode != TurnTimerMode.Daily ||
+        !session.Clock.IsExpired(now) ? GameActionResult.InvalidParameters : GameActionResult.Ok;
+      if (result == GameActionResult.Ok) AdvanceExpired(session!, packet.Kick, now);
+      SendTo(connection.Id, new MembershipResultPacket { GameId = packet.GameId, Result = result });
+    });
+  }
+
+  private static (int Cities, int Units) ClockBonus(GameSession session, int playerId) =>
+    ((int)session.Game.OwnedCities(playerId), session.Game.Troops.Troops().Count(t => t.Troop.Player == playerId));
+
+  private void SendClock(GameSession session, IEnumerable<uint> recipients) {
+    if (session.Clock?.DeadlineUtc is not { } deadline || session.Game.Over) return;
+    BroadcastTo(recipients, new GameClockPacket {
+      GameId = session.Id, TimerMode = (uint)session.Clock.Mode, PlayerId = (uint)session.Game.CurrentPlayer,
+      DeadlineUnixMilliseconds = deadline.ToUnixTimeMilliseconds(),
+      ServerUnixMilliseconds = _timeProvider.GetUtcNow().ToUnixTimeMilliseconds()
+    });
+  }
+
+  // Apply expiry before accepting an action. A late EndTurn cannot erase a timeout.
+  private void ProcessTimers(DateTimeOffset now) {
+    foreach (var session in _gameManager.Sessions) {
+      while (!session.Game.Over && session.Clock is { Mode: TurnTimerMode.Live } clock && clock.IsExpired(now)) {
+        // Advance from the original deadline, so downtime cannot grant a new bank.
+        AdvanceExpired(session, false, clock.DeadlineUtc!.Value);
+      }
+    }
+  }
+
+  private void AdvanceExpired(GameSession session, bool kick, DateTimeOffset at) {
+    var clock = session.Clock!;
+    var playerId = session.Game.CurrentPlayer;
+    var (cities, units) = ClockBonus(session, playerId);
+    var decision = kick ? clock.Kick(at) : clock.Skip(cities, units, at);
+    var eliminated = decision == TurnClockDecision.Eliminated;
+    var result = eliminated ? session.Game.Resign(playerId) : session.Game.EndTurn(playerId);
+    if (result.Result != GameActionResult.Ok) throw new InvalidOperationException("Clock and game disagree on the current turn");
+    if (eliminated) BroadcastTo(session.ConnectionIds, new PlayerEliminatedPacket {
+      GameId = session.Id, PlayerId = (uint)playerId, Update = session.TakeUpdate()
+    });
+    if (session.Game.Over) {
+      EndGame(session);
+      return;
+    }
+    clock.Begin(session.Game.CurrentPlayer, at);
+    BroadcastTo(session.ConnectionIds, new TurnStartedPacket {
+      GameId = session.Id, Turn = session.Game.Turn, PlayerId = (uint)session.Game.CurrentPlayer,
+      Update = session.TakeUpdate()
+    });
+    SendClock(session, session.ConnectionIds);
+  }
+
+  // EndTurn, resignation and capture can all change or end the active turn.
+  private void SynchronizeClocks(DateTimeOffset now) {
+    foreach (var session in _gameManager.Sessions) {
+      var clock = session.Clock;
+      if (clock == null || !clock.Running || (!session.Game.Over && clock.ActivePlayer == session.Game.CurrentPlayer)) continue;
+      var (cities, units) = ClockBonus(session, clock.ActivePlayer);
+      clock.Complete(cities, units, now);
+      if (!session.Game.Over) {
+        clock.Begin(session.Game.CurrentPlayer, now);
+        SendClock(session, session.ConnectionIds);
+      }
+    }
+  }
+}

OpenPolytopia.Server/GameServer.cs

@@ -15,11 +15,12 @@ namespace OpenPolytopia.Server;
 /// </remarks>
 /// <param name="port">the port to listen on</param>
 /// <param name="bindAddress">the ip address to bind to; null to listen on every interface</param>
-public partial class GameServer(int port, string? bindAddress = null, string? databasePath = null) : IDisposable {
+public partial class GameServer(int port, string? bindAddress = null, string? databasePath = null,
+  TimeProvider? timeProvider = null) : IDisposable {
   /// <summary>
   /// How often the server checks for lobbies to start
   /// </summary>
-  private static readonly TimeSpan START_LOBBY_INTERVAL = TimeSpan.FromSeconds(5);
+  private static readonly TimeSpan START_LOBBY_INTERVAL = TimeSpan.FromSeconds(1);
 
   /// <summary>
   /// Max lobbies the server accepts before refusing new ones
@@ -50,6 +51,7 @@ public async Task RunAsync() {
     _server = new ServerConnection(port, bindAddress, _certificate);
     RestoreState(_store.LoadState());
     RegisterHandlers();
+    RegisterTimerHandlers();
 
     _server.OnPacketReceived += ManagePacketAsync;
     _server.OnClientDisconnected += connection => _ = ClientDisconnectedAsync(connection);
@@ -344,13 +346,14 @@ private async Task StartLobbyAsync(LobbyData lobby) {
       .Select(player => online[player.PlayerId]).ToList();
 
     try {
-      var session = await _gameManager.CreateGameAsync(lobby, _gameData, onlineConnections: online);
+      var session = await _gameManager.CreateGameAsync(lobby, _gameData, onlineConnections: online, startedAt: _timeProvider.GetUtcNow());
 
       Console.WriteLine($"Starting game for lobby {lobby.Id} with {lobby.PlayersCount} players");
 
       // notify the players that their game started and send them its full state
       BroadcastTo(connectionIds, new GameStartedPacket { LobbyId = lobby.Id, Players = lobby.Players });
       BroadcastTo(connectionIds, session.BuildState());
+      SendClock(session, connectionIds);
     }
     catch (Exception e) {
       Console.Error.WriteLine($"Couldn't start the game for lobby {lobby.Id}: {e}");
@@ -378,7 +381,7 @@ private async Task StartLobbyAsync(LobbyData lobby) {
   /// </param>
   /// <returns>true if a session was found and the connection is a player in it</returns>
   private bool TryResolveSession(NetworkConnection connection, ulong gameId,
-    [NotNullWhen(true)] out GameSession? session, out int playerId, out GameActionResult result) {
+    [NotNullWhen(true)] out GameSession? session, out int playerId, out GameActionResult result, uint? expectedTurn = null) {
     session = _gameManager[gameId];
     if (session == null) {
       playerId = 0;
@@ -392,6 +395,12 @@ private bool TryResolveSession(NetworkConnection connection, ulong gameId,
       return false;
     }
 
+    if (expectedTurn.HasValue && expectedTurn.Value != session.Game.Turn &&
+        (session.Clock?.Mode == TurnTimerMode.Live || expectedTurn.Value != 0)) {
+      result = GameActionResult.InvalidParameters;
+      return false;
+    }
+
     result = GameActionResult.Ok;
     return true;
   }
@@ -408,7 +417,7 @@ private async Task ManageGetGameStateAsync(NetworkConnection connection, GetGame
 
   private async Task ManageMoveTroopAsync(NetworkConnection connection, MoveTroopPacket packet) {
     {
-      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check)) {
+      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check, packet.ExpectedTurn)) {
         SendTo(connection.Id, new MoveTroopResponsePacket { Result = check });
         return;
       }
@@ -429,7 +438,7 @@ private async Task ManageMoveTroopAsync(NetworkConnection connection, MoveTroopP
 
   private async Task ManageAttackAsync(NetworkConnection connection, AttackPacket packet) {
     {
-      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check)) {
+      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check, packet.ExpectedTurn)) {
         SendTo(connection.Id, new AttackResponsePacket { Result = check });
         return;
       }
@@ -452,7 +461,7 @@ private async Task ManageAttackAsync(NetworkConnection connection, AttackPacket
 
   private async Task ManageTrainTroopAsync(NetworkConnection connection, TrainTroopPacket packet) {
     {
-      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check)) {
+      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check, packet.ExpectedTurn)) {
         SendTo(connection.Id, new TrainTroopResponsePacket { Result = check });
         return;
       }
@@ -473,7 +482,7 @@ private async Task ManageTrainTroopAsync(NetworkConnection connection, TrainTroo
 
   private async Task ManageResearchTechAsync(NetworkConnection connection, ResearchTechPacket packet) {
     {
-      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check)) {
+      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check, packet.ExpectedTurn)) {
         SendTo(connection.Id, new ResearchTechResponsePacket { Result = check });
         return;
       }
@@ -493,7 +502,7 @@ private async Task ManageResearchTechAsync(NetworkConnection connection, Researc
 
   private async Task ManageBuildAsync(NetworkConnection connection, BuildPacket packet) {
     {
-      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check)) {
+      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check, packet.ExpectedTurn)) {
         SendTo(connection.Id, new BuildResponsePacket { Result = check });
         return;
       }
@@ -514,7 +523,7 @@ private async Task ManageBuildAsync(NetworkConnection connection, BuildPacket pa
 
   private async Task ManageCaptureAsync(NetworkConnection connection, CapturePacket packet) {
     {
-      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check)) {
+      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check, packet.ExpectedTurn)) {
         SendTo(connection.Id, new CaptureResponsePacket { Result = check });
         return;
       }
@@ -541,7 +550,7 @@ private async Task ManageCaptureAsync(NetworkConnection connection, CapturePacke
 
   private async Task ManageEndTurnAsync(NetworkConnection connection, EndTurnPacket packet) {
     {
-      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check)) {
+      if (!TryResolveSession(connection, packet.GameId, out var session, out var playerId, out var check, packet.ExpectedTurn)) {
         SendTo(connection.Id, new EndTurnResponsePacket { Result = check });
         return;
       }

OpenPolytopia.Server/GameSession.cs

@@ -30,6 +30,9 @@ public class GameSession {
   /// </summary>
   public Game Game { get; }
 
+  /// <summary>The persistent turn clock, independent of connected clients.</summary>
+  public TurnClock? Clock { get; internal set; }
+
   /// <summary>
   /// Connection id of every player in the game, keyed by player id
   /// </summary>