Fix naming of rollback netcode functions

Author: Atlinx

addons/FracturalCommons

@@ -1,57 +1,56 @@
 using GDDictionary = Godot.Collections.Dictionary;
-using GDArray = Godot.Collections.Array;
 
 namespace GodotRollbackNetcode
 {
     public interface INetworkSync { }
     public interface IGetLocalInput : INetworkSync
     {
-        GDDictionary _GetLocalInput();
+        GDDictionary _get_local_input();
     }
 
     public interface INetworkProcess : INetworkSync
     {
-        void _NetworkProcess(GDDictionary input);
+        void _network_process(GDDictionary input);
     }
 
     public interface INetworkPreProcess : INetworkSync
     {
-        void _NetworkPreprocess(GDDictionary input);
+        void _network_preprocess(GDDictionary input);
     }
 
     public interface INetworkPostProcess : INetworkSync
     {
-        void _NetworkPostprocess(GDDictionary input);
+        void _network_postprocess(GDDictionary input);
     }
 
     public interface IInterpolateState : INetworkSync
     {
-        void _InterpolateState(GDDictionary oldState, GDDictionary newState, float weight);
+        void _interpolate_state(GDDictionary oldState, GDDictionary newState, float weight);
     }
 
     public interface IPredictRemoteInput : INetworkSync
     {
-        GDDictionary _PredictRemoteInput(GDDictionary previousInput, int ticksSinceRealInput);
+        GDDictionary _predict_remote_input(GDDictionary previousInput, int ticksSinceRealInput);
     }
 
     public interface INetworkSerializable : INetworkSync
     {
-        GDDictionary _SaveState();
-        void _LoadState(GDDictionary state);
+        GDDictionary _save_state();
+        void _load_state(GDDictionary state);
     }
 
     public interface INetworkSpawnPreProcess
     {
-        void _NetworkSpawnPreProcess(GDDictionary data);
+        void _network_spawn_preprocess(GDDictionary data);
     }
 
     public interface INetworkSpawn
     {
-        void _NetworkSpawn(GDDictionary data);
+        void _network_spawn(GDDictionary data);
     }
 
     public interface INetworkDespawn
     {
-        void _NetworkDespawn();
+        void _network_despawn();
     }
 }

addons/GodotRollbackNetcodeMono/GDScriptWrapper.cs

@@ -1,9 +1,7 @@
-using Fractural;
-using Fractural.Commons;
+using Fractural.Commons;
 using Fractural.Utils;
 using Godot;
 using Godot.Collections;
-using System;
 
 namespace GodotRollbackNetcode
 {
@@ -20,13 +18,13 @@ public override void _Ready()
             AddToGroup(SyncManager.NetworkSyncGroup);
         }
 
-        public void _NetworkProcess(Dictionary input)
+        public void _network_process(Dictionary input)
         {
             if (IsPlaying())
                 Advance(SyncManager.Global.TickTime);
         }
 
-        public Dictionary _SaveState()
+        public Dictionary _save_state()
         {
             if (IsPlaying() && (!AutoReset || CurrentAnimation != "RESET"))
                 return new Dictionary()
@@ -46,7 +44,7 @@ public Dictionary _SaveState()
                 };
         }
 
-        public void _LoadState(Dictionary state)
+        public void _load_state(Dictionary state)
         {
             if (state.Get<bool>(nameof(IsPlaying)))
             {

addons/GodotRollbackNetcodeMono/Interfaces.cs

@@ -0,0 +1,12 @@
+using Fractural;
+using Fractural.Utils;
+using Godot;
+
+namespace GodotRollbackNetcode
+{
+    public class NetworkAnimationPlayerWrapper : GDScriptWrapper
+    {
+        public bool AutoReset { get => Source.Get<bool>("auto_reset"); set => Source.Set("auto_reset", value); }
+        public new AnimationPlayer Source => base.Source as AnimationPlayer;
+    }
+}

addons/GodotRollbackNetcodeMono/NetworkAnimationPlayer.cs

@@ -1,5 +1,4 @@
-using Fractural;
-using Fractural.Commons;
+using Fractural.Commons;
 using Fractural.Utils;
 using Godot;
 using Godot.Collections;
@@ -12,34 +11,37 @@ public class NetworkRandomNumberGenerator : Node, INetworkSerializable
         private RandomNumberGenerator generator;
 
         private ulong seed;
+        [Export]
         public ulong Seed
         {
             get => seed;
             set
             {
                 seed = value;
-                generator.Seed = value;
+                if (generator != null)
+                    generator.Seed = value;
             }
         }
 
         public override void _Ready()
         {
             generator = new RandomNumberGenerator();
+            Seed = seed;
         }
 
         public void Randomize() => generator.Randomize();
         public uint Randi() => generator.Randi();
         public int RandiRange(int from, int to) => generator.RandiRange(from, to);
 
-        public Dictionary _SaveState()
+        public Dictionary _save_state()
         {
             return new Dictionary()
             {
                 ["state"] = generator.State.Serialize()
             };
         }
 
-        public void _LoadState(Dictionary state)
+        public void _load_state(Dictionary state)
         {
             generator.State = state.Get<byte[]>("state").DeserializePrimitive<ulong>();
         }

addons/GodotRollbackNetcodeMono/NetworkAnimationPlayerWrapper.cs

@@ -0,0 +1,16 @@
+using Fractural;
+using Fractural.Utils;
+using Godot;
+
+namespace GodotRollbackNetcode
+{
+    public class NetworkRandomNumberGeneratorWrapper : GDScriptWrapper
+    {
+        public RandomNumberGenerator Generator => Source.Get<RandomNumberGenerator>("generator");
+        public ulong Seed { get => Generator.Seed; set => Generator.Seed = value; }
+
+        public void Randomize() => Generator.Randomize();
+        public uint Randi() => Generator.Randi();
+        public int RandiRange(int from, int to) => Generator.RandiRange(from, to);
+    }
+}

addons/GodotRollbackNetcodeMono/NetworkRandomNumberGenerator.cs

@@ -1,5 +1,4 @@
-using Fractural;
-using Fractural.Commons;
+using Fractural.Commons;
 using Godot;
 using Godot.Collections;
 using System;
@@ -9,15 +8,21 @@ namespace GodotRollbackNetcode
     [RegisteredType(nameof(NetworkTimer), "res://addons/GodotRollbackNetcodeMono/Assets/NetworkTimer.svg")]
     public class NetworkTimer : Node, INetworkSerializable, INetworkProcess
     {
+        [Export]
         public bool Autostart { get; set; }
+        [Export]
         public bool OneShot { get; set; }
+        [Export]
         public int WaitTicks { get; set; }
+        [Export]
         public bool HashState { get; set; }
         public bool IsRunning { get; private set; }
         public bool IsStopped => !IsRunning;
         public int TicksLeft { get; private set; }
 
         public event Action Timeout;
+        [Signal]
+        public delegate void TimeoutSignal();
 
         public override void _Ready()
         {
@@ -44,7 +49,7 @@ public void Stop()
             TicksLeft = 0;
         }
 
-        public void _NetworkProcess(Dictionary input)
+        public void _network_process(Dictionary input)
         {
             if (!IsRunning) return;
             if (TicksLeft <= 0)
@@ -60,10 +65,11 @@ public void _NetworkProcess(Dictionary input)
                 if (!OneShot)
                     TicksLeft = WaitTicks;
                 Timeout?.Invoke();
+                EmitSignal(nameof(TimeoutSignal));
             }
         }
 
-        public Dictionary _SaveState()
+        public Dictionary _save_state()
         {
             var state = new Dictionary()
             {
@@ -76,7 +82,7 @@ public Dictionary _SaveState()
             return state.IgnoreState();
         }
 
-        public void _LoadState(Dictionary state)
+        public void _load_state(Dictionary state)
         {
             IsRunning = state.GetStateValue<bool>(nameof(IsRunning));
             WaitTicks = state.GetStateValue<int>(nameof(WaitTicks));

addons/GodotRollbackNetcodeMono/NetworkRandomNumberGeneratorWrapper.cs

@@ -0,0 +1,30 @@
+using Fractural;
+using Fractural.Utils;
+using System;
+
+namespace GodotRollbackNetcode
+{
+    public class NetworkTimerWrapper : GDScriptWrapper
+    {
+        public bool Autostart { get => Source.Get<bool>("auto_start"); set => Source.Set("auto_start", value); }
+        public bool OneShot { get => Source.Get<bool>("one_shot"); set => Source.Set("one_shot", value); }
+        public int WaitTicks { get => Source.Get<int>("wait_ticks"); set => Source.Set("wait_ticks", value); }
+        public bool HashState { get => Source.Get<bool>("hash_state"); set => Source.Set("hash_state", value); }
+        public bool IsRunning => Source.Get<bool>("_running");
+        public bool IsStopped => !IsRunning;
+        public int TicksLeft => Source.Get<int>("ticks_left");
+
+        public event Action Timeout;
+
+        public void Start(int ticks = -1) => Source.Call("start", ticks);
+
+        public void Stop() => Source.Call("stop");
+
+        private void OnTimeout() => Timeout?.Invoke();
+
+        protected override void ForwardSignalsToEvents()
+        {
+            Source.Connect("timeout", this, nameof(OnTimeout));
+        }
+    }
+}

addons/GodotRollbackNetcodeMono/NetworkTimer.cs

@@ -1,5 +1,9 @@
 extends Reference
 
+static func is_type(obj: Object):
+	return obj.has_method("serialize") \
+		and obj.has_method("unserialize")
+
 func serialize(value):
 	if value is Dictionary:
 		return serialize_dictionary(value)
@@ -9,7 +13,7 @@ func serialize(value):
 		return serialize_resource(value)
 	elif value is Object:
 		return serialize_object(value)
-	
+
 	return serialize_other(value)
 
 func serialize_dictionary(value: Dictionary) -> Dictionary:
@@ -65,19 +69,19 @@ func serialize_other(value):
 			z = {x = value.basis.z.x, y = value.basis.z.y, z = value.basis.z.z},
 			origin = {x = value.origin.x, y = value.origin.y, z = value.origin.z},
 		}
-	
+
 	return value
 
 func unserialize(value):
 	if value is Dictionary:
 		if not value.has('_'):
 			return unserialize_dictionary(value)
-		
+
 		if value['_'] == 'resource':
 			return unserialize_resource(value)
 		elif value['_'] in ['Vector2', 'Vector3', 'Transform2D', 'Transform']:
 			return unserialize_other(value)
-		
+
 		return unserialize_object(value)
 	elif value is Array:
 		return unserialize_array(value)
@@ -122,5 +126,5 @@ func unserialize_other(value: Dictionary):
 				Vector3(value.z.x, value.z.y, value.z.z),
 				Vector3(value.origin.x, value.origin.y, value.origin.z)
 			)
-	
+
 	return null