Merge pull request #489 from starfi5h/pr-dysonSphereStatus

Author: PhantomGamers

CHANGELOG.md

@@ -1,5 +1,11 @@
 ## Changelog
 
+0.7.6:
+
+- @starfi5h: Added syncing of ray receiver output
+- @starfi5h: Fixed lighting of remote players
+- @starfi5h: Fixed clients receiving duplicate items when cancelling manual research
+
 0.7.5:
 
 - @sp00ktober: Fixed error caused by warning system introduced in previous update

NebulaModel/DataStructures/DataStructureExtensions.cs

@@ -0,0 +1,19 @@
+namespace NebulaModel.Packets.Universe
+{
+    public class DysonSphereStatusPacket
+    {
+        public int StarIndex { get; set; }
+        public float GrossRadius { get; set; }
+        public long EnergyReqCurrentTick { get; set; }
+        public long EnergyGenCurrentTick { get; set; }
+
+        public DysonSphereStatusPacket() {}
+        public DysonSphereStatusPacket(DysonSphere dysonSphere) 
+        {
+            StarIndex = dysonSphere.starData.index;
+            GrossRadius = dysonSphere.grossRadius;
+            EnergyReqCurrentTick = dysonSphere.energyReqCurrentTick;
+            EnergyGenCurrentTick = dysonSphere.energyGenCurrentTick;
+        }
+    }
+}

NebulaModel/DataStructures/NebulaAnimationState.cs

@@ -0,0 +1,23 @@
+using NebulaAPI;
+using NebulaModel.Networking;
+using NebulaModel.Packets;
+using NebulaModel.Packets.Universe;
+
+namespace NebulaNetwork.PacketProcessors.Universe
+{
+    [RegisterPacketProcessor]
+    internal class DysonSphereStatusProcessor : PacketProcessor<DysonSphereStatusPacket>
+    {
+        public override void ProcessPacket(DysonSphereStatusPacket packet, NebulaConnection conn)
+        {
+            DysonSphere dysonSphere = GameMain.data.dysonSpheres[packet.StarIndex];
+            if (IsHost || dysonSphere == null)
+            {
+                return;
+            }            
+            dysonSphere.grossRadius = packet.GrossRadius;
+            dysonSphere.energyReqCurrentTick = packet.EnergyReqCurrentTick;
+            dysonSphere.energyGenCurrentTick = packet.EnergyGenCurrentTick;
+        }
+    }
+}

NebulaModel/Packets/Universe/DysonSphereStatusPacket.cs

@@ -6,6 +6,7 @@
 using NebulaModel.Networking.Serialization;
 using NebulaModel.Packets.GameHistory;
 using NebulaModel.Packets.GameStates;
+using NebulaModel.Packets.Universe;
 using NebulaModel.Utils;
 using NebulaWorld;
 using System.Net.Sockets;
@@ -22,11 +23,13 @@ public class Server : NetworkProvider
         private const float GAME_RESEARCH_UPDATE_INTERVAL = 2;
         private const float STATISTICS_UPDATE_INTERVAL = 1;
         private const float LAUNCH_UPDATE_INTERVAL = 2;
+        private const float DYSONSPHERE_UPDATE_INTERVAL = 5;
 
         private float gameStateUpdateTimer = 0;
         private float gameResearchHashUpdateTimer = 0;
         private float productionStatisticsUpdateTimer = 0;
-        private float dysonLaunchUpateTimer = 0;
+        private float dysonLaunchUpateTimer = 1;
+        private float dysonSphereUpdateTimer = 0;
 
         private WebSocketServer socket;
 
@@ -125,6 +128,7 @@ public override void Update()
             gameResearchHashUpdateTimer += Time.deltaTime;
             productionStatisticsUpdateTimer += Time.deltaTime;
             dysonLaunchUpateTimer += Time.deltaTime;
+            dysonSphereUpdateTimer += Time.deltaTime;            
 
             if (gameStateUpdateTimer > GAME_STATE_UPDATE_INTERVAL)
             {
@@ -154,6 +158,19 @@ public override void Update()
                 Multiplayer.Session.Launch.SendBroadcastIfNeeded();
             }
 
+            if (dysonSphereUpdateTimer > DYSONSPHERE_UPDATE_INTERVAL)
+            {
+                dysonSphereUpdateTimer = 0;
+                DysonSphere[] dysonSpheres = GameMain.data.dysonSpheres;
+                for (int i = 0; i < dysonSpheres.Length; i++)
+                {
+                    if (dysonSpheres[i] != null)
+                    {
+                        SendPacketToStar(new DysonSphereStatusPacket(dysonSpheres[i]), dysonSpheres[i].starData.id);
+                    }
+                }
+            }
+
             PacketProcessor.ProcessPacketQueue();
         }
 

NebulaNetwork/PacketProcessors/Universe/DysonSphereStatusProcessor.cs

@@ -9,6 +9,47 @@ namespace NebulaPatcher.Patches.Dynamic
     [HarmonyPatch(typeof(DysonSphere))]
     internal class DysonSphere_Patch
     {
+        [HarmonyPrefix]
+        [HarmonyPatch(nameof(DysonSphere.BeforeGameTick))]
+        public static bool BeforeGameTick_Prefix(DysonSphere __instance, long times)
+        {
+            if (!Multiplayer.IsActive || Multiplayer.Session.LocalPlayer.IsHost)
+            {
+                return true;
+            }
+            //Update swarm and layer energy generation stats every 120 frames
+            if (times % 120 == 0)
+            {
+                __instance.swarm.energyGenCurrentTick = __instance.swarm.sailCount * __instance.energyGenPerSail;
+                for (int i = 0; i < 10; i++)
+                {
+                    DysonSphereLayer dysonSphereLayer = __instance.layersSorted[i];
+                    if (dysonSphereLayer != null)
+                    {
+                        dysonSphereLayer.energyGenCurrentTick = 0L;
+                        DysonNode[] nodePool = dysonSphereLayer.nodePool;
+                        DysonShell[] shellPool = dysonSphereLayer.shellPool;
+                        for (int j = 1; j < dysonSphereLayer.nodeCursor; j++)
+                        {
+                            if (nodePool[j] != null && nodePool[j].id == j)
+                            {
+                                dysonSphereLayer.energyGenCurrentTick += nodePool[j].EnergyGenCurrentTick(__instance.energyGenPerNode, __instance.energyGenPerFrame, 0L);
+                            }
+                        }
+                        for (int k = 1; k < dysonSphereLayer.shellCursor; k++)
+                        {
+                            if (shellPool[k] != null && shellPool[k].id == k)
+                            {
+                                dysonSphereLayer.energyGenCurrentTick += shellPool[k].cellPoint * __instance.energyGenPerShell;
+                            }
+                        }
+                    }
+                }
+            }
+            //Sync other Dyson sphere status related to ray receivers on client side by DysonSphereStatusPacket
+            return false;
+        }
+
         [HarmonyPrefix]
         [HarmonyPatch(nameof(DysonSphere.AddLayer))]
         public static bool AddLayer_Prefix(DysonSphere __instance, float orbitRadius, Quaternion orbitRotation, float orbitAngularSpeed)

NebulaNetwork/Server.cs

@@ -148,18 +148,5 @@ public static bool UnlockTech_Prefix()
             //Wait for the authoritative packet for unlocking tech features in multiplayer for clients
             return !Multiplayer.IsActive || Multiplayer.Session.LocalPlayer.IsHost || Multiplayer.Session.History.IsIncomingRequest;
         }
-
-        [HarmonyPrefix]
-        [HarmonyPatch(nameof(GameHistoryData.RemoveTechInQueue))]
-        public static void RemoveTechInQueue_Prefix(int index, out int __state)
-        {
-            __state = GameMain.history.techQueue[index];
-            if (Multiplayer.IsActive && Multiplayer.Session.LocalPlayer.IsHost)
-            {
-                //we need to know which itemtypes are currently needed for refunds, so trigger refund before cancelling own research
-                Multiplayer.Session.Network.PlayerManager.SendTechRefundPackagesToClients(__state);
-            }
-            Log.Info($"RemoveTechInQueue: remove tech at index {index} with techId { __state}");
-        }
     }
 }

NebulaPatcher/Patches/Dynamic/DysonSphere_Patch.cs

@@ -1,6 +1,7 @@
 using HarmonyLib;
 using NebulaModel.Packets.Factory.PowerTower;
 using NebulaWorld;
+using System;
 using System.Collections.Generic;
 using System.Reflection.Emit;
 
@@ -126,5 +127,36 @@ public static IEnumerable<CodeInstruction> PowerSystem_GameTick_Transpiler(IEnum
                 })
                 .InstructionEnumeration();
         }
+
+        [HarmonyTranspiler]
+        [HarmonyPatch(nameof(PowerSystem.RequestDysonSpherePower))]
+        public static IEnumerable<CodeInstruction> PowerSystem_RequestDysonSpherePower_Transpiler(IEnumerable<CodeInstruction> instructions)
+        {
+            //Prevent dysonSphere.energyReqCurrentTick from changing on the client side
+            //Change: if (this.dysonSphere != null)
+            //To:     if (this.dysonSphere != null && (!Multiplayer.IsActive || Multiplayer.Session.LocalPlayer.IsHost))
+            try
+            {
+                CodeMatcher codeMatcher = new CodeMatcher(instructions)
+                    .MatchForward(true,
+                        new CodeMatch(OpCodes.Ldarg_0),
+                        new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(PowerSystem), "dysonSphere")),
+                        new CodeMatch(OpCodes.Brfalse) //IL #93
+                    );
+                object label = codeMatcher.Instruction.operand;
+                codeMatcher.Advance(1)
+                    .InsertAndAdvance(HarmonyLib.Transpilers.EmitDelegate<Func<bool>>(() =>
+                    {
+                        return !Multiplayer.IsActive || Multiplayer.Session.LocalPlayer.IsHost;
+                    }))
+                    .InsertAndAdvance(new CodeInstruction(OpCodes.Brfalse_S, label));
+                return codeMatcher.InstructionEnumeration();
+            }
+            catch
+            {
+                NebulaModel.Logger.Log.Error("PowerSystem.RequestDysonSpherePower_Transpiler failed. Mod version not compatible with game version.");
+                return instructions;
+            }
+        }
     }
 }

NebulaPatcher/Patches/Dynamic/GameHistoryData_Patch.cs

@@ -128,6 +128,8 @@ public void AnimateSailState(PlayerAnimator animator)
         public void AnimateRenderers(PlayerAnimator animator)
         {
             animator.player.mechaArmorModel.inst_armor_mat.SetVector("_InitPositionSet", transform.position);
+            animator.player.mechaArmorModel.inst_part_ar_mat.SetVector("_InitPositionSet", transform.position);
+            animator.player.mechaArmorModel.inst_part_sk_mat.SetVector("_InitPositionSet", transform.position);
         }
     }
 }