Merge pull request #575 from starfi5h/pr-ux

Enhance user experience + bump version

Author: starfi5h

.github/scripts/thunderstore_bundle.js

@@ -123,8 +123,8 @@ function generateManifest() {
       BEPINEX_DEPENDENCY,
       `nebula-${apiPluginInfo.name}-${apiPluginInfo.version}`,
       "PhantomGamers-IlLine-1.0.0",
-      "CommonAPI-CommonAPI-1.5.1",
-      "starfi5h-BulletTime-1.2.5",
+      "CommonAPI-CommonAPI-1.5.4",
+      "starfi5h-BulletTime-1.2.6",
     ],
     website_url: "https://github.com/hubastard/nebula"
   };

CHANGELOG.md

@@ -1,5 +1,11 @@
 ## Changelog
 
+0.8.10:
+
+- @starfi5h: Fix compilation with 0.9.26.13034
+- @starfi5h: Fix a bug that makes advance miner power usage abnormal
+- @starfi5h: Add new chat settings NotificationDuration
+
 0.8.9:
 
 - @PhantomGamers: Fixed compilation with 0.9.26

NebulaModel/MultiplayerOptions.cs

@@ -102,6 +102,9 @@ public bool StreamerMode {
         [DisplayName("Default chat size"), Category("Chat")]
         public ChatSize DefaultChatSize { get; set; } = ChatSize.Medium;
 
+        [DisplayName("Notification duration"), Category("Chat")]
+        public int NotificationDuration { get; set; } = 15;
+
         [DisplayName("Cleanup inactive sessions"), Category("Network")]
         [Description("If disabled the underlying networking library will not cleanup inactive connections. This might solve issues with clients randomly disconnecting and hosts having a 'System.ObjectDisposedException'.")]
         public bool CleanupInactiveSessions { get; set; } = true;

NebulaModel/Packets/GameStates/FragmentInfo.cs

@@ -0,0 +1,13 @@
+namespace NebulaModel.Packets.GameStates
+{
+    public class FragmentInfo
+    {
+        public int Size { get; set; }
+
+        public FragmentInfo() { }
+        public FragmentInfo(int size)
+        {
+            Size = size;
+        }
+    }
+}

NebulaNetwork/Client.cs

@@ -9,7 +9,8 @@
 using NebulaModel.Packets.Session;
 using NebulaModel.Utils;
 using NebulaWorld;
-using NebulaWorld.SocialIntegration;
+using NebulaWorld.GameStates;
+using System.IO;
 using System.Net;
 using System.Net.Sockets;
 using System.Reflection;
@@ -21,6 +22,7 @@ namespace NebulaNetwork
 {
     public class Client : NetworkProvider, IClient
     {
+        private const float FRAGEMENT_UPDATE_INTERVAL = 0.1f;
         private const float GAME_STATE_UPDATE_INTERVAL = 1f;
         private const float MECHA_SYNCHONIZATION_INTERVAL = 30f;
 
@@ -32,7 +34,7 @@ public class Client : NetworkProvider, IClient
         private NebulaConnection serverConnection;
         private bool websocketAuthenticationFailure;
 
-
+        private float fragmentUpdateTimer = 0f;
         private float mechaSynchonizationTimer = 0f;
         private float gameStateUpdateTimer = 0f;
 
@@ -186,13 +188,23 @@ public override void Update()
                     gameStateUpdateTimer = 0f;
                 }
             }
+
+            fragmentUpdateTimer += Time.deltaTime;
+            if (fragmentUpdateTimer >= FRAGEMENT_UPDATE_INTERVAL)
+            {
+                if (GameStatesManager.FragmentSize > 0)
+                {
+                    GameStatesManager.UpdateBufferLength(GetFragmentBufferLength());
+                }
+                fragmentUpdateTimer = 0f;
+            }
         }
 
         private void ClientSocket_OnMessage(object sender, MessageEventArgs e)
         {
             if (!Multiplayer.IsLeavingGame)
             {
-                PacketProcessor.EnqueuePacketForProcessing(e.RawData, new NebulaConnection(clientSocket, serverEndpoint, PacketProcessor));
+                PacketProcessor.EnqueuePacketForProcessing(e.RawData, serverConnection);
             }
         }
 
@@ -322,5 +334,18 @@ private static void DisableNagleAlgorithm(WebSocket socket)
                 tcpClient.NoDelay = true;
             }
         }
+
+        private int GetFragmentBufferLength()
+        {
+            MemoryStream buffer = (MemoryStream)AccessTools.Field(typeof(WebSocket), "_fragmentsBuffer").GetValue(clientSocket);
+            if (buffer != null)
+            {
+                return (int)buffer.Length;
+            }
+            else
+            {
+                return 0;
+            }
+        }
     }
 }

NebulaNetwork/PacketProcessors/GameStates/FragmentInfoProcessor.cs

@@ -0,0 +1,20 @@
+using NebulaAPI;
+using NebulaModel.Networking;
+using NebulaModel.Packets;
+using NebulaModel.Packets.GameStates;
+using NebulaWorld.GameStates;
+
+namespace NebulaNetwork.PacketProcessors.GameStates
+{
+    [RegisterPacketProcessor]
+    public class FragmentInfoProcessor : PacketProcessor<FragmentInfo>
+    {
+        public override void ProcessPacket(FragmentInfo packet, NebulaConnection conn)
+        {
+            if (IsClient)
+            {
+                GameStatesManager.FragmentSize = packet.Size;
+            }
+        }
+    }
+}

NebulaNetwork/PacketProcessors/GameStates/GameStateUpdateProcessor.cs

@@ -14,8 +14,6 @@ namespace NebulaNetwork.PacketProcessors.GameStates
     [RegisterPacketProcessor]
     public class GameStateUpdateProcessor : PacketProcessor<GameStateUpdate>
     {
-        public float MaxUPS = 240f;
-        public float MinUPS = 30f;
         public float BUFFERING_TIME = 30f;
         public float BUFFERING_TICK = 60f;
 
@@ -68,23 +66,23 @@ public override void ProcessPacket(GameStateUpdate packet, NebulaConnection conn
             // Adjust client's UPS to match game tick with server, range 30~120 UPS
             float UPS = diff / 1f + avaerageUPS;
             long skipTick = 0;
-            if (UPS > MaxUPS)
+            if (UPS > GameStatesManager.MaxUPS)
             {
                 // Try to disturbute game tick difference into BUFFERING_TIME (seconds)
-                if (diff / BUFFERING_TIME + avaerageUPS > MaxUPS)
+                if (diff / BUFFERING_TIME + avaerageUPS > GameStatesManager.MaxUPS)
                 {
                     // The difference is too large, need to skip ticks to catch up
-                    skipTick = (long)(UPS - MaxUPS);
+                    skipTick = (long)(UPS - GameStatesManager.MaxUPS);
                 }
-                UPS = MaxUPS;
+                UPS = GameStatesManager.MaxUPS;
             }
-            else if (UPS < MinUPS)
+            else if (UPS < GameStatesManager.MinUPS)
             {
-                if (diff + avaerageUPS - MinUPS < -BUFFERING_TICK)
+                if (diff + avaerageUPS - GameStatesManager.MinUPS < -BUFFERING_TICK)
                 {
-                    skipTick = (long)(UPS - MinUPS);
+                    skipTick = (long)(UPS - GameStatesManager.MinUPS);
                 }
-                UPS = MinUPS;
+                UPS = GameStatesManager.MinUPS;
             }
             if (skipTick != 0)
             {

NebulaNetwork/PacketProcessors/Planet/FactoryDataProcessor.cs

@@ -4,6 +4,7 @@
 using NebulaModel.Packets;
 using NebulaModel.Packets.Planet;
 using NebulaWorld;
+using NebulaWorld.GameStates;
 
 namespace NebulaNetwork.PacketProcessors.Planet
 {
@@ -16,6 +17,9 @@ public override void ProcessPacket(FactoryData packet, NebulaConnection conn)
             {
                 return;
             }
+            // The whole fragment is received
+            GameStatesManager.FragmentSize = 0;
+
             // Stop packet processing until factory is imported and loaded
             ((NebulaModel.NetworkProvider)Multiplayer.Session.Network).PacketProcessor.Enable = false;
             Log.Info($"Pause PacketProcessor (FactoryDataProcessor)");

NebulaNetwork/PacketProcessors/Planet/FactoryLoadRequestProcessor.cs

@@ -3,6 +3,7 @@
 using NebulaModel.Networking;
 using NebulaModel.Packets;
 using NebulaModel.Packets.Planet;
+using NebulaModel.Packets.GameStates;
 using NebulaWorld;
 
 namespace NebulaNetwork.PacketProcessors.Planet
@@ -25,6 +26,7 @@ public override void ProcessPacket(FactoryLoadRequest packet, NebulaConnection c
                 factory.Export(writer.BinaryWriter);
                 byte[] data = writer.CloseAndGetBytes();
                 Log.Info($"Sent {data.Length} bytes of data for PlanetFactory {planet.name} (ID: {planet.id})");
+                conn.SendPacket(new FragmentInfo(data.Length + planet.data.modData.Length));
                 conn.SendPacket(new FactoryData(packet.PlanetID, data, planet.data.modData));
             }
 

NebulaNetwork/PacketProcessors/Universe/DysonSphereDataProcessor.cs

@@ -4,6 +4,7 @@
 using NebulaModel.Packets;
 using NebulaModel.Packets.Universe;
 using NebulaWorld;
+using NebulaWorld.GameStates;
 using System.Collections.Generic;
 using System.IO;
 
@@ -41,6 +42,8 @@ public override void ProcessPacket(DysonSphereData packet, NebulaConnection conn
                     break;
 
                 case DysonSphereRespondEvent.Load:
+                    // The whole fragment is received
+                    GameStatesManager.FragmentSize = 0;
                     //Failsafe, if client does not have instantiated sphere for the star, it will create dummy one that will be replaced during import
                     GameMain.data.dysonSpheres[packet.StarIndex] = new DysonSphere();
                     GameMain.data.statistics.production.Init(GameMain.data);