Runahead fixes (#50)

* skip runahead rewind load when limited saving reloads too

RewindRunahead only skipped the rewind load when a rollback was coming.
with limited saving HandleSavingConfirmedFrame also does a load+resim of
the current frame, so the rewind load got overwritten there too.

extract RollbackPending and ConfirmedSaveDue so the handlers and
RewindRunahead share one firing condition, then skip the rewind load
when either is due.

Author: HeatXD

GekkoLib/include/session.h

@@ -82,6 +82,10 @@ namespace Gekko {
 
 		void RewindRunahead();
 
+		bool RollbackPending();
+
+		bool ConfirmedSaveDue();
+
         void SendSessionHealthCheck();
 
         void SendNetworkHealthCheck();

GekkoLib/src/game_session.cpp

@@ -221,18 +221,12 @@ void Gekko::GameSession::NetworkPoll()
 
 void Gekko::GameSession::HandleSavingConfirmedFrame()
 {
-    if (IsLockstepActive() || !_config.limited_saving ||
-        IsPlayingLocally()) {
+    if (!ConfirmedSaveDue()) {
         return;
     }
 
     const Frame confirmed_frame = _sync.GetMinReceivedFrame();
     const Frame current = _sync.GetCurrentFrame();
-    const Frame diff = current - (_last_saved_frame + 1);
-
-    if (diff <= _config.input_prediction_window) {
-        return;
-    }
 
     assert(_last_saved_frame < confirmed_frame);
 
@@ -361,18 +355,13 @@ void Gekko::GameSession::HandleRollback()
         _sync.IncrementFrame();
     }
 
-    if (IsLockstepActive() || IsPlayingLocally()) {
+    if (!RollbackPending()) {
         return;
     }
 
     current = _sync.GetCurrentFrame();
     const Frame min = _sync.GetMinIncorrectFrame();
 
-    // dont allow rollbacks starting before the null frame
-    if (min == GameInput::NULL_FRAME) {
-        return;
-    }
-
     const Frame sync_frame = _config.limited_saving ? _last_saved_frame : min - 1;
     const Frame frame_to_save = std::min(current - 1, min);
 
@@ -521,21 +510,39 @@ bool Gekko::GameSession::IsLockstepActive() const
     return _config.input_prediction_window == 0;
 }
 
+bool Gekko::GameSession::RollbackPending()
+{
+    if (IsLockstepActive() || IsPlayingLocally()) {
+        return false;
+    }
+
+    return _sync.GetMinIncorrectFrame() != GameInput::NULL_FRAME;
+}
+
+bool Gekko::GameSession::ConfirmedSaveDue()
+{
+    if (IsLockstepActive() || !_config.limited_saving || IsPlayingLocally()) {
+        return false;
+    }
+
+    const Frame diff = _sync.GetCurrentFrame() - (_last_saved_frame + 1);
+    return diff > _config.input_prediction_window;
+}
+
 void Gekko::GameSession::RewindRunahead()
 {
     if (_runahead_start_frame == GameInput::NULL_FRAME) {
         return;
     }
 
-    // rollback is coming so dont load the state twice.
-    // its get overwritten anyways
-    if (_sync.GetMinIncorrectFrame() != GameInput::NULL_FRAME) {
-        _runahead_start_frame = GameInput::NULL_FRAME;
+    _runahead_start_frame = GameInput::NULL_FRAME;
+
+    // a rollback or confirmed save will load+resim this frame, so dont load twice.
+    if (RollbackPending() || ConfirmedSaveDue()) {
         return;
     }
 
     _game_events.AddRunaheadLoadEvent(_storage);
-    _runahead_start_frame = GameInput::NULL_FRAME;
 }
 
 void Gekko::GameSession::HandleRunahead()