Sync cyclops destruction beacon, removed virtual cyclops logs, shut virtual cyclops lights, removed debug logs

Author: tornac1234

Nitrox.Test/Patcher/Patches/PatchesTranspilerTest.cs

@@ -14,6 +14,10 @@ public class PatchesTranspilerTest
     // Add "true" to any of those elements to have its transformed IL printed.
     public static IEnumerable<object[]> TranspilerPatchClasses =>
     [
+        [typeof(AggressiveWhenSeeTarget_ScanForAggressionTarget_Patch), 3],
+        [typeof(AttackCyclops_OnCollisionEnter_Patch), -17],
+        [typeof(AttackCyclops_UpdateAggression_Patch), -23],
+        [typeof(Bullet_Update_Patch), 3],
         [typeof(BaseDeconstructable_Deconstruct_Patch), BaseDeconstructable_Deconstruct_Patch.InstructionsToAdd(true).Count() * 2],
         [typeof(BaseHullStrength_CrushDamageUpdate_Patch), 3],
         [typeof(BreakableResource_SpawnResourceFromPrefab_Patch), 2],
@@ -28,13 +32,15 @@ public class PatchesTranspilerTest
         [typeof(CrashHome_Update_Patch), -5],
         [typeof(CreatureDeath_OnKillAsync_Patch), 9],
         [typeof(CreatureDeath_SpawnRespawner_Patch), 2],
+        [typeof(CyclopsDestructionEvent_DestroyCyclops_Patch), 3],
         [typeof(CyclopsDestructionEvent_SpawnLootAsync_Patch), 7],
         [typeof(CyclopsShieldButton_OnClick_Patch), -6],
         [typeof(CyclopsSonarButton_Update_Patch), 3],
         [typeof(CyclopsSonarDisplay_NewEntityOnSonar_Patch), 3],
         [typeof(DevConsole_Update_Patch), 0],
         [typeof(Eatable_IterateDespawn_Patch), 2],
         [typeof(EnergyMixin_SpawnDefaultAsync_Patch), -64],
+        [typeof(EntityCell_AwakeAsync_Patch), 2],
         [typeof(EntityCell_SleepAsync_Patch), 2],
         [typeof(Equipment_RemoveItem_Patch), 7],
         [typeof(EscapePod_Start_Patch), 43],
@@ -48,9 +54,11 @@ public class PatchesTranspilerTest
         [typeof(IngameMenu_QuitSubscreen_Patch), -24],
         [typeof(Inventory_LoseItems_Patch), -2],
         [typeof(ItemsContainer_DestroyItem_Patch), 2],
+        [typeof(LargeWorldEntity_UpdateCell_Patch), 1],
         [typeof(LaunchRocket_OnHandClick_Patch), -9],
         [typeof(LeakingRadiation_Update_Patch), 0],
         [typeof(MainGameController_StartGame_Patch), 1],
+        [typeof(MeleeAttack_CanDealDamageTo_Patch), 4],
         [typeof(PDAScanner_Scan_Patch), 3],
         [typeof(Player_OnKill_Patch), 0],
         [typeof(Respawn_Start_Patch), 3],
@@ -66,10 +74,6 @@ public class PatchesTranspilerTest
         [typeof(uGUI_SceneIntro_IntroSequence_Patch), 8],
         [typeof(uSkyManager_SetVaryingMaterialProperties_Patch), 0],
         [typeof(Welder_Weld_Patch), 1],
-        [typeof(AggressiveWhenSeeTarget_ScanForAggressionTarget_Patch), 3],
-        [typeof(AttackCyclops_OnCollisionEnter_Patch), -17],
-        [typeof(AttackCyclops_UpdateAggression_Patch), -23],
-        [typeof(Bullet_Update_Patch), 3],
         [typeof(Poop_Perform_Patch), 1],
         [typeof(SeaDragonMeleeAttack_OnTouchFront_Patch), 9],
         [typeof(SeaDragonMeleeAttack_SwatAttack_Patch), 4],
@@ -79,10 +83,7 @@ public class PatchesTranspilerTest
         [typeof(SeaTreader_UpdatePath_Patch), 0],
         [typeof(SeaTreader_UpdateTurning_Patch), 0],
         [typeof(SeaTreader_Update_Patch), 0],
-        [typeof(EntityCell_AwakeAsync_Patch), 2],
         [typeof(StasisSphere_LateUpdate_Patch), 0],
-        [typeof(MeleeAttack_CanDealDamageTo_Patch), 4],
-        [typeof(LargeWorldEntity_UpdateCell_Patch), 1],
     ];
 
     [TestMethod]

NitroxClient/GameLogic/AI.cs

@@ -51,7 +51,6 @@ public void BroadcastNewAction(NitroxId creatureId, Creature creature, CreatureA
             return;
         }
 
-        ErrorMessage.AddMessage($"[SEND] synced action: {newAction.GetType().FullName}");
         packetSender.Send(new CreatureActionChanged(creatureId, newAction.GetType().FullName));
     }
 
@@ -63,7 +62,6 @@ public void CreatureActionChanged(NitroxId id, string creatureActionTypeName)
         }
         if (cachedCreatureActionTypeByFullName.TryGetValue(creatureActionTypeName, out Type creatureActionType))
         {
-            ErrorMessage.AddMessage($"[GET] {creatureActionType}");
             if (creature.TryGetComponent(creatureActionType, out Component component) && component is CreatureAction creatureAction)
             {
                 actions[creature] = creatureAction;
@@ -79,8 +77,6 @@ public static void AggressiveWhenSeeTargetChanged(NitroxId creatureId, NitroxId
             return;
         }
 
-        ErrorMessage.AddMessage($"[GET] {aggressiveWhenSeeTarget.gameObject.name} chases {targetObject.name}");
-
         Creature creature = aggressiveWhenSeeTarget.creature;
 
         // Code from AggressiveWhenSeeTarget.ScanForAggressionTarget
@@ -109,8 +105,6 @@ public static void AttackCyclopsTargetChanged(NitroxId creatureId, NitroxId targ
             return;
         }
 
-        ErrorMessage.AddMessage($"[GET] {attackCyclops.gameObject.name} attacks {targetObject.name}");
-
         // Kinda stuff from AttackCyclops.UpdateAggression
         attackCyclops.aggressiveToNoise.Value = aggressiveToNoiseAmount;
         // Force currentTarget to null to ensure SetCurrentTarget detects a change
@@ -134,11 +128,9 @@ public static void RangedAttackLastTargetUpdate(NitroxId creatureId, NitroxId ta
         {
             case ActionState.CHARGING:
                 rangedAttackLastTarget.StartCharging(attackType);
-                ErrorMessage.AddMessage($"[GET] {rangedAttackLastTarget.name} charges against {targetObject.name}");
                 break;
             case ActionState.CASTING:
                 rangedAttackLastTarget.StartCasting(attackType);
-                ErrorMessage.AddMessage($"[GET] {rangedAttackLastTarget.name} casts against {targetObject.name}");
                 break;
         }
     }

NitroxClient/MonoBehaviours/Cyclops/VirtualCyclops.cs

@@ -56,7 +56,6 @@ public static void CreateVirtualCyclops()
             SubConsoleCommand.main.OnSubPrefabLoaded(cyclopsPrefab);
             GameObject model = SubConsoleCommand.main.GetLastCreatedSub();
             model.name = NAME;
-            LargeWorldEntity.Register(model);
             Vector3 position = Vector3.up * 500;
             Quaternion rotation = Quaternion.identity;
             model.transform.position = position;
@@ -69,6 +68,7 @@ public static void CreateVirtualCyclops()
             GameObject.Destroy(model.GetComponent<EcoTarget>());
             GameObject.Destroy(model.GetComponent<PingInstance>());
             GameObject.Destroy(model.GetComponent<CyclopsDestructionEvent>());
+            GameObject.Destroy(model.GetComponent<VFXConstructing>());
 
             Instance.InitialPosition = position;
             Instance.InitialRotation = rotation;
@@ -83,6 +83,8 @@ public static void CreateVirtualCyclops()
 
             Instance.RegisterVirtualOpenables();
             Instance.ToggleRenderers(false);
+            Instance.DisableBadComponents();
+
             model.SetActive(true);
         });
     }
@@ -165,14 +167,35 @@ public void ToggleRenderers(bool toggled)
         }
     }
 
-    public void RegisterVirtualOpenables()
+    private void RegisterVirtualOpenables()
     {
         foreach (Openable openable in transform.GetComponentsInChildren<Openable>(true))
         {
             virtualOpenableByName.Add(openable.name, openable);
         }
     }
 
+    private void DisableBadComponents()
+    {
+        CyclopsLightingPanel cyclopsLightingPanel = GetComponentInChildren<CyclopsLightingPanel>(true);
+        cyclopsLightingPanel.floodlightsOn = false;
+        cyclopsLightingPanel.lightingOn = false;
+        cyclopsLightingPanel.SetExternalLighting(false);
+        cyclopsLightingPanel.cyclopsRoot.ForceLightingState(false);
+        cyclopsLightingPanel.enabled = false;
+        Destroy(cyclopsLightingPanel);
+
+        // Disable a source of useless logs
+        foreach (FMOD_CustomEmitter customEmitter in GetComponentsInChildren<FMOD_CustomEmitter>(true))
+        {
+            customEmitter.enabled = false;
+        }
+        foreach (PlayerCinematicController cinematicController in GetComponentsInChildren<PlayerCinematicController>(true))
+        {
+            cinematicController.enabled = false;
+        }
+    }
+
     public void ReplicateOpening(Openable openable, bool openState)
     {
         if (virtualOpenableByName.TryGetValue(openable.name, out Openable virtualOpenable))

NitroxClient/MonoBehaviours/PlayerDeathBroadcaster.cs

@@ -1,5 +1,4 @@
 using NitroxClient.GameLogic;
-using NitroxModel.Core;
 using UnityEngine;
 
 namespace NitroxClient.MonoBehaviours;
@@ -10,7 +9,7 @@ public class PlayerDeathBroadcaster : MonoBehaviour
 
     public void Awake()
     {
-        localPlayer = NitroxServiceLocator.LocateService<LocalPlayer>();
+        localPlayer = this.Resolve<LocalPlayer>();
 
         Player.main.playerDeathEvent.AddHandler(this, PlayerDeath);
     }

NitroxPatcher/Patches/Dynamic/AggressiveWhenSeeTarget_ScanForAggressionTarget_Patch.cs

@@ -62,7 +62,6 @@ public static void BroadcastTargetChange(AggressiveWhenSeeTarget aggressiveWhenS
             float aggressionAmount = aggressiveWhenSeeTarget.creature.Aggression.Value;
 
             Resolve<IPacketSender>().Send(new AggressiveWhenSeeTargetChanged(creatureId, targetId, lastTarget.targetLocked, aggressionAmount));
-            ErrorMessage.AddMessage($"[SEND] {aggressiveWhenSeeTarget.gameObject.name} chases {realTarget.name}");
         }
     }
 }

NitroxPatcher/Patches/Dynamic/AttackCyclops_UpdateAggression_Patch.cs

@@ -64,7 +64,6 @@ public static void Postfix(AttackCyclops __instance)
             float aggressiveToNoise = __instance.aggressiveToNoise.Value;
 
             Resolve<IPacketSender>().Send(new AttackCyclopsTargetChanged(creatureId, targetId, aggressiveToNoise));
-            ErrorMessage.AddMessage($"[SEND] {__instance.gameObject.name} attacks {__instance.currentTarget.name}");
         }
     }
 

NitroxPatcher/Patches/Dynamic/CyclopsDestructionEvent_DestroyCyclops_Patch.cs

@@ -1,27 +1,24 @@
+using System.Collections.Generic;
 using System.Reflection;
+using System.Reflection.Emit;
+using HarmonyLib;
 using NitroxClient.GameLogic;
-using NitroxClient.MonoBehaviours;
 using NitroxClient.MonoBehaviours.Cyclops;
 using NitroxModel.DataStructures;
 using NitroxModel.Helper;
+using UnityEngine;
 
 namespace NitroxPatcher.Patches.Dynamic;
 
 /// <summary>
-/// Broadcasts the cyclops destruction, and safely removes every player from it.
+/// Broadcasts the cyclops destruction, and safely removes every player from it. Also broadcasts the creation of the beacon.
 /// </summary>
 public sealed partial class CyclopsDestructionEvent_DestroyCyclops_Patch : NitroxPatch, IDynamicPatch
 {
     private static readonly MethodInfo TARGET_METHOD = Reflect.Method((CyclopsDestructionEvent t) => t.DestroyCyclops());
 
     public static void Prefix(CyclopsDestructionEvent __instance)
     {
-        if (__instance.TryGetNitroxId(out NitroxId nitroxId))
-        {
-            Resolve<SimulationOwnership>().StopSimulatingEntity(nitroxId);
-            EntityPositionBroadcaster.StopWatchingEntity(nitroxId);
-        }
-
         bool wasInCyclops = Player.main.currentSub == __instance.subRoot;
 
         // Before the cyclops destruction, we move out the remote players so that they aren't stuck in its hierarchy
@@ -46,4 +43,37 @@ public static void Postfix(CyclopsDestructionEvent __instance)
             Resolve<Vehicles>().BroadcastDestroyedCyclops(__instance.gameObject, nitroxId);
         }
     }
+
+    /*
+     * ADD at the end of the method:
+     * CyclopsDestructionEvent_DestroyCyclops_Patch.ManageBeacon(component, this);
+     */
+    public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
+    {
+        return new CodeMatcher(instructions).End() // Move before Ret
+                                            .InsertAndAdvance([
+                                                new CodeInstruction(OpCodes.Ldloc_2),
+                                                new CodeInstruction(OpCodes.Ldarg_0),
+                                                new CodeInstruction(OpCodes.Call, Reflect.Method(() => ManageBeacon(default, default)))
+                                            ]).InstructionEnumeration();
+    }
+
+    public static void ManageBeacon(Beacon beacon, CyclopsDestructionEvent cyclopsDestructionEvent)
+    {
+        if (!cyclopsDestructionEvent.TryGetNitroxId(out NitroxId nitroxId))
+        {
+            return;
+        }
+
+        // We let the simulating player spawn it for everyone
+        if (!Resolve<SimulationOwnership>().HasAnyLockType(nitroxId))
+        {
+            Object.Destroy(beacon.gameObject);
+            return;
+        }
+
+        // We need to force this state for beaconLabel to wear the correct tag
+        beacon.Start();
+        Resolve<Items>().Dropped(beacon.gameObject, TechType.Beacon);
+    }
 }

NitroxPatcher/Patches/Dynamic/Floater_FixedUpdate_Patch.cs

@@ -0,0 +1,23 @@
+using System.Reflection;
+using NitroxClient.GameLogic;
+using NitroxModel.DataStructures;
+using NitroxModel.Helper;
+
+namespace NitroxPatcher.Patches.Dynamic;
+
+public sealed partial class Floater_FixedUpdate_Patch : NitroxPatch, IDynamicPatch
+{
+    private static readonly MethodInfo TARGET_METHOD = Reflect.Method((Floater t) => t.FixedUpdate());
+
+    public static bool Prefix(Floater __instance)
+    {
+        if (!__instance.fixedJoint || !__instance.fixedJoint.connectedBody ||
+            !__instance.fixedJoint.connectedBody.TryGetNitroxId(out NitroxId jointId))
+        {
+            return true;
+        }
+
+        // If target has an id, we only apply the FixedUpdate when we have a lock type on it (true)
+        return Resolve<SimulationOwnership>().HasAnyLockType(jointId);
+    }
+}

NitroxPatcher/Patches/Dynamic/RangedAttackLastTarget_StartCasting_Patch.cs

@@ -14,10 +14,7 @@ public sealed partial class RangedAttackLastTarget_StartCasting_Patch : NitroxPa
 
     public static void Prefix(RangedAttackLastTarget __instance)
     {
-        if (RangedAttackLastTarget_StartCharging_Patch.BroadcastRangedAttack(__instance, RangedAttackLastTargetUpdate.ActionState.CASTING))
-        {
-            ErrorMessage.AddMessage($"[SEND] {__instance.name} casts against {__instance.currentTarget.name}");
-        }
+        RangedAttackLastTarget_StartCharging_Patch.BroadcastRangedAttack(__instance, RangedAttackLastTargetUpdate.ActionState.CASTING);
     }
 }
 

NitroxPatcher/Patches/Dynamic/RangedAttackLastTarget_StartCharging_Patch.cs

@@ -17,10 +17,7 @@ public sealed partial class RangedAttackLastTarget_StartCharging_Patch : NitroxP
 
     public static void Prefix(RangedAttackLastTarget __instance)
     {
-        if (BroadcastRangedAttack(__instance, RangedAttackLastTargetUpdate.ActionState.CHARGING))
-        {
-            ErrorMessage.AddMessage($"[SEND] {__instance.name} charges against {__instance.currentTarget.name}");
-        }
+        BroadcastRangedAttack(__instance, RangedAttackLastTargetUpdate.ActionState.CHARGING);
     }
 
     /// <summary>