gg.easy.airship 0.1.2136 → 0.1.2138

package/Runtime/Code/{RemoteConsole → Network}/ServerConsole.cs

@@ -1,155 +1,160 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
-using Airship.DevConsole;
-using Mirror;
-using UnityEngine;
-
-namespace Code.RemoteConsole {
-    struct ServerConsoleBroadcast : NetworkMessage {
-        public string message;
-        public string stackTrace;
-        public LogType logType;
-        public string time;
-        public bool startup;
-    }
-
-    struct RequestServerConsoleStartupLogs : NetworkMessage {
-        
-    }
-
-    [LuauAPI]
-    public class ServerConsole : MonoBehaviour {
-        private List<ServerConsoleBroadcast> startupMessages = new(100);
-        private const int maxStartupMessages = 100;
-        private static readonly ConcurrentQueue<string> logQueue = new();
-
-        private string logPath;
-        private string prevLogPath;
-        private StreamWriter writer;
-
-        private bool shuttingDown = false;
-        private Task writeTask;
-
-        private void Awake() {
-            writeTask = Task.Run(ProcessQueue);
-        }
-
-        private async Task ProcessQueue() {
-            while (!shuttingDown) {
-                while (logQueue.TryDequeue(out string msg)) {
-                    try {
-                        await writer.WriteLineAsync(msg);
-                    } catch (Exception e) {
-                        Debug.LogError("ServerLogger write failed: " + e);
-                    }
-                }
-
-                await Task.Delay(1); // tune as needed
-            }
-        }
-
-        private void OnDestroy() {
-            shuttingDown = true;
-            // writeTask?.Wait();
-        }
-
-        /// <summary>
-        /// Called on client when client receives a remote log from server.
-        /// </summary>
-        /// <param name="args"></param>
-        private void OnServerConsoleBroadcast(ServerConsoleBroadcast args) {
-            if (!DevConsole.console.loggingEnabled) return;
-            DevConsole.console.OnLogMessageReceived(args.message, args.stackTrace, args.logType, LogContext.Server, args.time);
-
-            string timeStamped = $"[{DateTime.Now:HH:mm:ss}] {args.message}";
-            logQueue.Enqueue(timeStamped);
-        }
-
-        public void OnStartServer() {
-            if (!RunCore.IsClient()) {
-                Application.logMessageReceived += LogCallback;
-            }
-            NetworkServer.RegisterHandler<RequestServerConsoleStartupLogs>((conn, data) => {
-                foreach (var startupMessage in startupMessages) {
-                    conn.Send(startupMessage);
-                }
-            }, false);
-        }
-
-        public void OnClientConnectedToServer() {
-            if (!RunCore.IsServer()) {
-                NetworkClient.RegisterHandler<ServerConsoleBroadcast>(OnServerConsoleBroadcast, false);
-                NetworkClient.Send(new RequestServerConsoleStartupLogs());
-            }
-
-            // Setup logs
-            if (RunCore.IsClient()) {
-                string logDir = Path.GetDirectoryName(Application.consoleLogPath);
-                logPath = Path.Combine(logDir, "Server.log");
-                prevLogPath = Path.Combine(logDir, "Server-prev.log");
-
-                // Rotate logs
-                try {
-                    if (File.Exists(prevLogPath)) File.Delete(prevLogPath);
-                    if (File.Exists(logPath)) File.Move(logPath, prevLogPath);
-                } catch (Exception e) {
-                    Debug.LogError("Failed rotating server logs: " + e);
-                }
-
-                if (writer != null) {
-                    writer.Close();
-                }
-                writer = new StreamWriter(logPath, false); // overwrite existing
-                writer.AutoFlush = true;
-            }
-        }
-
-        public void OnStopClient() {
-            NetworkClient.UnregisterHandler<ServerConsoleBroadcast>();
-            if (writer != null) {
-                writer.Close();
-                writer = null;
-            }
-        }
-
-        void LogCallback(string message, string stackTrace, LogType logType) {
-            SendServerLogMessage(message, logType, stackTrace);
-        }
-
-        private void OnDisable() {
-            if (RunCore.IsServer()) {
-                Application.logMessageReceived -= LogCallback;
-            }
-        }
-
-        private void SendServerLogMessage(string message, LogType logType = LogType.Log, string stackTrace = "") {
-            if (RunCore.IsServer() && !RunCore.IsEditor()) {
-                var time = DateTime.Now.ToString("HH:mm:ss");
-                if (this.startupMessages.Count < maxStartupMessages) {
-                    this.startupMessages.Add(new ServerConsoleBroadcast() {
-                        message = message,
-                        logType = logType,
-                        startup = true,
-                        time = time,
-                        stackTrace = stackTrace,
-                    });
-                }
-
-                if (NetworkServer.active) {
-                    var packet = new ServerConsoleBroadcast() {
-                        message = message,
-                        logType = logType,
-                        startup = false,
-                        stackTrace = stackTrace,
-                        time = time,
-                    };
-                    bool sendToReadyOnly = Application.isEditor;
-                    NetworkServer.SendToAll(packet, Channels.Reliable, sendToReadyOnly);
-                }
-            }
-        }
-    }
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using Airship.DevConsole;
+using Code.Player;
+using Mirror;
+using UnityEngine;
+
+namespace Code.RemoteConsole {
+    struct ServerConsoleBroadcast : NetworkMessage {
+        public string message;
+        public string stackTrace;
+        public LogType logType;
+        public string time;
+        public bool startup;
+    }
+
+    struct RequestServerConsoleStartupLogs : NetworkMessage {
+        
+    }
+
+    [LuauAPI]
+    public class ServerConsole : MonoBehaviour {
+        private List<ServerConsoleBroadcast> startupMessages = new(100);
+        private const int maxStartupMessages = 100;
+        private static readonly ConcurrentQueue<string> logQueue = new();
+
+        private string logPath;
+        private string prevLogPath;
+        private StreamWriter writer;
+
+        private bool shuttingDown = false;
+        private Task writeTask;
+
+        private void Awake() {
+            writeTask = Task.Run(ProcessQueue);
+        }
+
+        private async Task ProcessQueue() {
+            while (!shuttingDown) {
+                while (logQueue.TryDequeue(out string msg)) {
+                    try {
+                        await writer.WriteLineAsync(msg);
+                    } catch (Exception e) {
+                        Debug.LogError("ServerLogger write failed: " + e);
+                    }
+                }
+
+                await Task.Delay(1); // tune as needed
+            }
+        }
+
+        private void OnDestroy() {
+            shuttingDown = true;
+            // writeTask?.Wait();
+        }
+
+        /// <summary>
+        /// Called on client when client receives a remote log from server.
+        /// </summary>
+        /// <param name="args"></param>
+        private void OnServerConsoleBroadcast(ServerConsoleBroadcast args) {
+            if (!DevConsole.console.loggingEnabled) return;
+            DevConsole.console.OnLogMessageReceived(args.message, args.stackTrace, args.logType, LogContext.Server, args.time);
+
+            string timeStamped = $"[{DateTime.Now:HH:mm:ss}] {args.message}";
+            logQueue.Enqueue(timeStamped);
+        }
+
+        public void OnStartServer() {
+            if (!RunCore.IsClient()) {
+                Application.logMessageReceived += LogCallback;
+            }
+            NetworkServer.RegisterHandler<RequestServerConsoleStartupLogs>((conn, data) => {
+                foreach (var startupMessage in startupMessages) {
+                    conn.Send(startupMessage);
+                }
+            }, false);
+        }
+
+        public void OnClientConnectedToServer() {
+            if (!RunCore.IsServer()) {
+                NetworkClient.RegisterHandler<ServerConsoleBroadcast>(OnServerConsoleBroadcast, false);
+                NetworkClient.Send(new RequestServerConsoleStartupLogs());
+            }
+
+            // Setup logs
+            if (RunCore.IsClient()) {
+                string logDir = Path.GetDirectoryName(Application.consoleLogPath);
+                logPath = Path.Combine(logDir, "Server.log");
+                prevLogPath = Path.Combine(logDir, "Server-prev.log");
+
+                // Rotate logs
+                try {
+                    if (File.Exists(prevLogPath)) File.Delete(prevLogPath);
+                    if (File.Exists(logPath)) File.Move(logPath, prevLogPath);
+                } catch (Exception e) {
+                    Debug.LogError("Failed rotating server logs: " + e);
+                }
+
+                if (writer != null) {
+                    writer.Close();
+                }
+                writer = new StreamWriter(logPath, false); // overwrite existing
+                writer.AutoFlush = true;
+            }
+        }
+
+        public void OnStopClient() {
+            NetworkClient.UnregisterHandler<ServerConsoleBroadcast>();
+            if (writer != null) {
+                writer.Close();
+                writer = null;
+            }
+        }
+
+        void LogCallback(string message, string stackTrace, LogType logType) {
+            SendServerLogMessage(message, logType, stackTrace);
+        }
+
+        private void OnDisable() {
+            if (RunCore.IsServer()) {
+                Application.logMessageReceived -= LogCallback;
+            }
+        }
+
+        private void SendServerLogMessage(string message, LogType logType = LogType.Log, string stackTrace = "") {
+            if (RunCore.IsServer() && !RunCore.IsEditor()) {
+                var time = DateTime.Now.ToString("HH:mm:ss");
+                if (this.startupMessages.Count < maxStartupMessages) {
+                    this.startupMessages.Add(new ServerConsoleBroadcast() {
+                        message = message,
+                        logType = logType,
+                        startup = true,
+                        time = time,
+                        stackTrace = stackTrace,
+                    });
+                }
+
+                if (NetworkServer.active) {
+                    var packet = new ServerConsoleBroadcast() {
+                        message = message,
+                        logType = logType,
+                        startup = false,
+                        stackTrace = stackTrace,
+                        time = time,
+                    };
+                    // bool sendToReadyOnly = Application.isEditor;
+                    foreach (var player in PlayerManagerBridge.Instance.players) {
+                        if (!string.IsNullOrEmpty(player.orgRoleName)) {
+                            player.connectionToClient.Send(packet, Channels.Reliable);
+                        }
+                    }
+                }
+            }
+        }
+    }
 }

package/Runtime/Code/{RemoteConsole → Network}/ServerConsole.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 8d4b051ef8784e61bc03cc11c9eef05b
+fileFormatVersion: 2
+guid: 8d4b051ef8784e61bc03cc11c9eef05b
 timeCreated: 1677178638

package/Runtime/Code/Network/Simulation/AirshipSimulationManager.cs

@@ -102,12 +102,10 @@ namespace Code.Network.Simulation
          */
         public event Action<int, double, double> OnLagCompensationCheck;
 
-        /**
-         * This action tells all watching components that they need to perform a tick.
-         * A Physics.Simulate() call will be made after PerformTick completes.
-         */
-        public event Action<double, bool> OnPerformTick;
-
+        /// <summary>
+        /// This action tells all watching components that they need to perform a tick.
+        /// A Physics.Simulate() call will be made after PerformTick completes.
+        /// </summary>
         public event Action<object, object> OnTick;
 
         /**
@@ -184,7 +182,6 @@ namespace Code.Network.Simulation
             if (resimBackTo != time) this.PerformResimulation(resimBackTo);
 
             // Perform the standard tick behavior
-            OnPerformTick?.Invoke(time, false);
             OnTick?.Invoke(time, false);
             // Debug.Log("Simulate call. Main Tick: " + NetworkTime.time);
             Physics.Simulate(Time.fixedDeltaTime);
@@ -310,13 +307,14 @@ namespace Code.Network.Simulation
             this.ScheduleResimulation((resim => resim(time)));
         }
 
-        /**
-         * Requests a simulation based on the provided time. Requesting a simulation will roll back the physics
-         * world to the snapshot just before or at the base time provided. Calling the returned tick function
-         * will advance the simulation and re-simulate the calls to OnPerformTick, Physics.Simulate(), and OnCaptureSnapshot
-         *
-         * This function is used internally to implement the scheduled resimulations.
-         */
+        /// <summary>
+        /// Requests a simulation based on the provided time. Requesting a simulation will roll back the physics
+        /// world to the snapshot just before or at the base time provided. Calling the returned tick function
+        /// will advance the simulation and re-simulate the calls to <see cref="OnTick"/>, Physics.Simulate,
+        /// and <see cref="OnCaptureSnapshot"/>
+        /// 
+        /// This function is used internally to implement the scheduled resimulations.
+        /// </summary>
         private void PerformResimulation(double baseTime)
         {
             Debug.Log($"T:{Time.unscaledTimeAsDouble} Resimulating from {baseTime}");
@@ -343,7 +341,7 @@ namespace Code.Network.Simulation
 
                 while (tickIndex < this.tickTimes.Count)
                 {
-                    OnPerformTick?.Invoke(this.tickTimes[tickIndex], true);
+                    OnTick?.Invoke(this.tickTimes[tickIndex], true);
                     // Debug.Log("Simulate call. Replay Tick: " + this.tickTimes[tickIndex]);
                     Physics.Simulate(Time.fixedDeltaTime);
                     OnCaptureSnapshot?.Invoke(this.tickTimes[tickIndex], true);

package/Runtime/Code/Network/StateSystem/AirshipNetworkedStateManager.cs

@@ -1,15 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using Code.Network.Simulation;
 using Code.Network.StateSystem.Structures;
 using Code.Player.Character.Net;
 using Mirror;
-using RSG.Promises;
-using Unity.Mathematics;
-using Unity.VisualScripting;
 using UnityEngine;
-using UnityEngine.Serialization;
 
 namespace Code.Network.StateSystem
 {
@@ -92,7 +87,7 @@ namespace Code.Network.StateSystem
         // Observer history stores authoritative state and uses the server's times. This data can be interpolated
         // with NetworkTime.time. It is converted into state history on the local clients physics timeline
         // in the observer snapshot function.
-        private History<State> observerHistory;
+        public History<State> observerHistory;
         private double lastReceivedSnapshotTime = 0;
 
         // Client interpolation fields
@@ -165,7 +160,7 @@ namespace Code.Network.StateSystem
         private void Awake()
         {
             AirshipSimulationManager.Instance.ActivateSimulationManager();
-            AirshipSimulationManager.Instance.OnPerformTick += this.OnPerformTick;
+            AirshipSimulationManager.Instance.OnTick += this.OnTick;
             AirshipSimulationManager.Instance.OnSetSnapshot += this.OnSetSnapshot;
             AirshipSimulationManager.Instance.OnCaptureSnapshot += this.OnCaptureSnapshot;
             AirshipSimulationManager.Instance.OnLagCompensationCheck += this.OnLagCompensationCheck;
@@ -195,13 +190,13 @@ namespace Code.Network.StateSystem
 
         public void OnDestroy()
         {
-            AirshipSimulationManager.Instance.OnPerformTick -= this.OnPerformTick;
+            AirshipSimulationManager.Instance.OnTick -= this.OnTick;
             AirshipSimulationManager.Instance.OnSetSnapshot -= this.OnSetSnapshot;
             AirshipSimulationManager.Instance.OnCaptureSnapshot -= this.OnCaptureSnapshot;
             AirshipSimulationManager.Instance.OnLagCompensationCheck -= this.OnLagCompensationCheck;
         }
 
-        private void Update()
+        private void SendNetworkMessages()
         {
             if (isClient && isServer)
             {
@@ -256,8 +251,7 @@ namespace Code.Network.StateSystem
             }
 
             // We are operating as a server
-            if (isServer &&
-                AccurateInterval.Elapsed(NetworkTime.localTime, NetworkClient.sendInterval, ref lastServerSend))
+            if (isServer && AccurateInterval.Elapsed(NetworkTime.localTime, NetworkClient.sendInterval, ref lastServerSend))
             {
                 // No matter what mode the server is operating in, we send our latest state to clients.
                 // If we have no state yet, don't send
@@ -276,14 +270,17 @@ namespace Code.Network.StateSystem
             {
                 this.Interpolate();
             }
+
+            SendNetworkMessages();
         }
 
         #endregion
 
         #region Top Level Event Functions
 
-        private void OnPerformTick(double time, bool replay)
-        {
+        private void OnTick(object timeObj, object replayObj) {
+            if (timeObj is not double time || replayObj is not bool replay) return;
+            
             // We are in shared mode
             if (isServer && isClient)
             {
@@ -976,8 +973,7 @@ namespace Code.Network.StateSystem
             }
 
             lastReceivedSnapshotTime = state.time;
-
-            // Debug.Log("Client receive snapshot" + state);
+            
             // The client is a non-authoritative owner and should update
             // their local state with the authoritative state from the server.
             if (isOwned && serverAuth)