Working rollback for spawning

Includes debug messages

Author: proepkes

Engine/Client/Simulation.cs

@@ -73,7 +73,9 @@ public void Update(float deltaTime)
             _accumulatedTime += deltaTime; 
 
             while (_accumulatedTime >= _tickDt)
-            {        
+            {
+
+                _logger.Warn(" ========= " + (_systems.CurrentTick + 1) + " ========= ");
 
                 Tick();
 
@@ -82,20 +84,20 @@ public void Update(float deltaTime)
         }
 
         private void Tick()
-        {           
+        {            
             ICommand[] frameCommands;
             lock (_temporaryCommandBuffer)
             {
                 frameCommands = _temporaryCommandBuffer.ToArray();
                 _temporaryCommandBuffer.Clear();
-            }                    
-                                                                                                                     
+            }
+
             if (frameCommands.Length > 0)
             {
                 LocalCommandBuffer.Insert(_systems.CurrentTick + LagCompensation, LocalPlayerId, frameCommands);
                 RemoteCommandBuffer.Insert(_systems.CurrentTick + LagCompensation, LocalPlayerId,  frameCommands);     
             }
-                                     
+
             _systems.Tick(LocalCommandBuffer.GetMany(_systems.CurrentTick));
 
             Ticked?.Invoke(_systems.CurrentTick);      
@@ -106,26 +108,31 @@ private void SyncCommandBuffer()
             var currentRemoteFrame = RemoteCommandBuffer.LastInsertedFrame;
 
             if (LastValidatedFrame < currentRemoteFrame)
-            {                  
-                var revertTick = currentRemoteFrame;
+            {   
+                _logger.Warn("Catching up: " + LastValidatedFrame + " -> " + currentRemoteFrame + " of " + _systems.CurrentTick);
+
+                var revertFrame = currentRemoteFrame; //We guess everything was predicted correctly
 
                 for (var remoteFrame = LastValidatedFrame + 1; remoteFrame <= currentRemoteFrame; remoteFrame++)
                 {
+                    //All frames that have no commands were predicted correctly => increase remote frame
                     var allPlayerCommands = RemoteCommandBuffer.Get(remoteFrame);
                     if (allPlayerCommands.Count <= 0)
                     {
                         continue;
                     }
 
-                    if (remoteFrame < revertTick)
+                    if (remoteFrame < revertFrame)
                     {
-                        //Save the first tick which contains remote commands
-                        revertTick = remoteFrame;
+                        //Store the first frame where predicion was false (frame has commands)
+                        revertFrame = remoteFrame;
                     }
 
                     //Merge commands into the local command buffer
                     foreach (var commandPerPlayer in allPlayerCommands)
                     {
+
+                        _logger.Warn("Insert remote commands from " + remoteFrame);
                         LocalCommandBuffer.Insert(remoteFrame, commandPerPlayer.Key, commandPerPlayer.Value.ToArray());
                     }
                 }
@@ -135,11 +142,22 @@ private void SyncCommandBuffer()
                 {      
                     var targetTick = _systems.CurrentTick;  
 
-                    _systems.RevertToTick(revertTick); 
-                                                                         
-                    while (_systems.CurrentTick < targetTick)
-                    {            
-                        _systems.Tick(LocalCommandBuffer.GetMany(_systems.CurrentTick));
+                    //Revert everything that happened one tick after the last validated input
+                    _systems.RevertFromTick(revertFrame + 1);
+
+                    //Execute all commands again, beginning from the first frame that contains remote input
+                    while (revertFrame <= targetTick)
+                    {
+                        if (LocalCommandBuffer.GetMany(_systems.CurrentTick).Length > 0)
+                        {
+
+                            _logger.Warn("Execute " +  LocalCommandBuffer.GetMany(revertFrame).Length + " commands from tick " + revertFrame);
+                        }
+
+                        _logger.Warn(">>>>========= " + (revertFrame) + " ========= ");
+                        _systems.Tick(LocalCommandBuffer.GetMany(revertFrame));
+
+                        revertFrame++;
                     }
                 }
 

Engine/Core/GameSystems.cs

@@ -24,7 +24,7 @@ public GameSystems(Contexts contexts, params IService[] additionalServices)
             {
                 Services.Register(service);
             }
-                                                    
+                                 
             Add(new IncrementTick(Contexts));
 
             Add(new InputFeature(Contexts, Services));
@@ -34,6 +34,7 @@ public GameSystems(Contexts contexts, params IService[] additionalServices)
             Add(new GameEventSystems(Contexts));
 
             Add(new HashCodeFeature(Contexts, Services));
+
         }
 
         public void Tick(ICommand[] input)
@@ -44,7 +45,7 @@ public void Tick(ICommand[] input)
             Cleanup();
         }
 
-        public void RevertToTick(uint tick)
+        public void RevertFromTick(uint tick)
         {
             foreach (var system in _executeSystems)
             {
@@ -53,8 +54,8 @@ public void RevertToTick(uint tick)
                     stateSystem.RevertToTick(tick);
                 }
             }
-
-            Contexts.gameState.ReplaceTick(tick);   
+                                                        
+            Contexts.gameState.ReplaceTick(tick - 1);   
         }
     }
 }     

Engine/Core/Interfaces/ILogService.cs

@@ -2,6 +2,6 @@
 {
     public interface ILogService : IService
     {
-        void Warn(string message);
+        void Warn(object message);
     }
 }

Engine/Core/Interfaces/ISystems.cs

@@ -11,6 +11,6 @@ public interface ISystems
 
         void Tick(ICommand[] input);
 
-        void RevertToTick(uint tick);
+        void RevertFromTick(uint tick);
     }
 }

Engine/Core/Systems/Input/OnSpawnInputCreateEntity.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 using BEPUutilities;
 using Entitas;
 using Lockstep.Core.Interfaces;
@@ -51,28 +52,33 @@ protected override void Execute(List<InputEntity> inputs)
                     _createdEntities.Add(_gameStateContext.tick.value, new List<uint>());
                 }
 
-                _createdEntities[_gameStateContext.tick.value].Add(_nextEntityId);
-
-                _nextEntityId++;
+                _createdEntities[_gameStateContext.tick.value].Add(_nextEntityId);      
+                _nextEntityId++;  
             }
+
+            _logger?.Warn(_gameStateContext.tick.value + ": " + inputs.Count + " added");
         }
 
         public void RevertToTick(uint tick)
-        {                                                                                                                                  
+        {
+            var t = tick;
+            var count = 0;
             for (;tick <= _gameStateContext.tick.value; tick++)
             {                             
                 if (_createdEntities.ContainsKey(tick))
                 {
-                    _logger?.Warn("Destroying " + _createdEntities[tick].Count + " Entities from tick " + tick);
                     foreach (var entityId in _createdEntities[tick])
                     {
-                        _gameContext.GetEntityWithId(entityId).Destroy();
+                        _gameContext.GetEntities().First(entity => entity.id.value == entityId).Destroy();
                         _nextEntityId--;
+                        count++;
                     }
 
                     _createdEntities[tick].Clear();
                 }
             }
+
+            _logger?.Warn(t + " -> " + tick + ": " + count + " destroyed");
         }
     }
 }

Engine/Server/Room.cs

@@ -16,8 +16,7 @@ public class Room
 
         private byte _nextPlayerId;
         private readonly int _size;
-
-        private InputBuffer _inputBuffer; 
+                                            
         private readonly IServer _server;
 
         public bool Running { get; private set; } 

Engine/Test/Converter.cs

@@ -33,7 +33,7 @@ public TestLogger(ITestOutputHelper outputHelper)
         {
             _outputHelper = outputHelper;
         }
-        public void Warn(string message)
+        public void Warn(object message)
         {
             _outputHelper.WriteLine($"Warn: {message}");
         }