Some refactoring, replacement of prefix by transpiler, added a synced creature type whitelist

tornac1234 · tornac1234 · commit 1a987e9606ff · 2024-02-19T02:08:19.000+01:00
diff --git a/Nitrox.Test/Patcher/Patches/Dynamic/Vehicle_TorpedoShot_PatchTest.cs b/Nitrox.Test/Patcher/Patches/Dynamic/Vehicle_TorpedoShot_PatchTest.cs
@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using System.Linq;
+using FluentAssertions;
+using HarmonyLib;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NitroxTest.Patcher;
+
+namespace NitroxPatcher.Patches.Dynamic;
+
+[TestClass]
+public class Vehicle_TorpedoShot_PatchTest
+{
+    [TestMethod]
+    public void Sanity()
+    {
+        IEnumerable<CodeInstruction> originalIl = PatchTestHelper.GetInstructionsFromMethod(Vehicle_TorpedoShot_Patch.TARGET_METHOD);
+        IEnumerable<CodeInstruction> transformedIl = Vehicle_TorpedoShot_Patch.Transpiler(originalIl);
+        transformedIl.Count().Should().Be(originalIl.Count() + 3);
+    }
+}
diff --git a/NitroxClient/GameLogic/AI.cs b/NitroxClient/GameLogic/AI.cs
@@ -25,6 +25,15 @@ public class AI
         typeof(AttackLastTarget), typeof(AttackCyclops)
     ];
 
+    /// <summary>
+    /// In the future, ensure all creatures are synced. We want each of them to be individually
+    /// checked (that all their actions are synced) before marking them as synced.
+    /// </summary>
+    private readonly HashSet<Type> syncedCreatureWhitelist =
+    [
+        typeof(ReaperLeviathan), typeof(SeaDragon)
+    ];
+
     public AI(IPacketSender packetSender)
     {
         this.packetSender = packetSender;
@@ -36,7 +45,7 @@ public AI(IPacketSender packetSender)
 
     public void BroadcastNewAction(NitroxId creatureId, Creature creature, CreatureAction newAction)
     {
-        if (creature is not ReaperLeviathan)
+        if (!syncedCreatureWhitelist.Contains(creature.GetType()))
         {
             return;
         }
@@ -119,4 +128,9 @@ public bool IsCreatureActionWhitelisted(CreatureAction creatureAction)
     {
         return creatureActionWhitelist.Contains(creatureAction.GetType());
     }
+
+    public bool IsCreatureWhitelisted(Creature creature)
+    {
+        return syncedCreatureWhitelist.Contains(creature.GetType());
+    }
 }
diff --git a/NitroxClient/GameLogic/BulletManager.cs b/NitroxClient/GameLogic/BulletManager.cs
@@ -8,6 +8,10 @@
 
 namespace NitroxClient.GameLogic;
 
+/// <summary>
+/// Registers one stasis sphere per connected remote player, and syncs their behaviour.<br/>
+/// Also syncs remote torpedo (of all types) shots and hits.
+/// </summary>
 public class BulletManager
 {
     private readonly PlayerManager playerManager;
@@ -77,10 +81,7 @@ public void TorpedoTargetAcquired(NitroxId bulletId, NitroxId targetId, Vector3
 
     public void ShootStasisSphere(ushort playerId, Vector3 position, Quaternion rotation, float speed, float lifeTime, float chargeNormalized)
     {
-        if (!stasisSpherePerPlayerId.TryGetValue(playerId, out StasisSphere cloneSphere) || !cloneSphere)
-        {
-            cloneSphere = EnsurePlayerHasSphere(playerId);
-        }
+        StasisSphere cloneSphere = EnsurePlayerHasSphere(playerId);
 
         cloneSphere.Shoot(position, rotation, speed, lifeTime, chargeNormalized);
     }
@@ -89,15 +90,15 @@ public void StasisSphereHit(ushort playerId, Vector3 position, Quaternion rotati
     {
         StasisSphere cloneSphere = EnsurePlayerHasSphere(playerId);
 
-        // Setup the sphere in case it the shot was sent earlier
+        // Setup the sphere in case the shot was sent earlier
         cloneSphere.Shoot(position, rotation, 0, 0, chargeNormalized);
         // We override this field (set by .Shoot) with the right data
         cloneSphere._consumption = consumption;
 
         // Code from Bullet.Update when finding an object to hit
         cloneSphere._visible = true;
         cloneSphere.OnMadeVisible();
-        cloneSphere.OnHit(default);
+        cloneSphere.EnableField();
         cloneSphere.Deactivate();
     }
 
diff --git a/NitroxClient/GameLogic/RemotePlayer.cs b/NitroxClient/GameLogic/RemotePlayer.cs
@@ -421,7 +421,7 @@ static void CopyEmitter(FMOD_CustomEmitter src, FMOD_CustomEmitter dst)
     private void SetupMixins()
     {
         InfectedMixin = Body.AddComponent<InfectedMixin>();
-        InfectedMixin.shaderKeyWord = "UWE_PLAYERINFECTION";
+        InfectedMixin.shaderKeyWord = InfectedMixin.uwe_playerinfection;
         Renderer renderer = PlayerModel.transform.Find("male_geo/diveSuit/diveSuit_hands_geo").GetComponent<Renderer>();
         InfectedMixin.renderers = [renderer];
 
@@ -432,7 +432,7 @@ private void SetupMixins()
             broadcastKillOnDeath = false
         };
         LiveMixin.health = 100;
-        // We set the remote player to invincible because we only want this component to detectable but not to work
+        // We set the remote player to invincible because we only want this component to be detectable but not to work
         LiveMixin.invincible = true;
     }
 
diff --git a/NitroxPatcher/Patches/Dynamic/AggressiveWhenSeeTarget_ScanForAggressionTarget_Patch.cs b/NitroxPatcher/Patches/Dynamic/AggressiveWhenSeeTarget_ScanForAggressionTarget_Patch.cs
@@ -23,7 +23,6 @@ public static bool Prefix(AggressiveWhenSeeTarget __instance)
             return true;
         }
 
-
         return false;
     }
 
@@ -47,6 +46,11 @@ public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructio
 
     public static void BroadcastTargetChange(AggressiveWhenSeeTarget aggressiveWhenSeeTarget, GameObject aggressionTarget)
     {
+        if (!Resolve<AI>().IsCreatureWhitelisted(aggressiveWhenSeeTarget.creature))
+        {
+            return;
+        }
+
         // If the function was called to this point, either it'll return because it doesn't have an id or it'll be evident that we have ownership over the aggressive creature
         LastTarget lastTarget = aggressiveWhenSeeTarget.lastTarget;
         // If there's already (likely another) locked target, we get its id over aggressionTarget
diff --git a/NitroxPatcher/Patches/Dynamic/AttackCyclops_OnCollisionEnter_Patch.cs b/NitroxPatcher/Patches/Dynamic/AttackCyclops_OnCollisionEnter_Patch.cs
@@ -17,6 +17,12 @@ public sealed partial class AttackCyclops_OnCollisionEnter_Patch : NitroxPatch,
 {
     public static readonly MethodInfo TARGET_METHOD = Reflect.Method((AttackCyclops t) => t.OnCollisionEnter(default));
 
+    public static bool Prefix(AttackCyclops __instance)
+    {
+        return !__instance.TryGetNitroxId(out NitroxId creatureId) ||
+               Resolve<SimulationOwnership>().HasAnyLockType(creatureId);
+    }
+
     /*
      * REPLACE:
      * if (Player.main != null && Player.main.currentSub != null && Player.main.currentSub.isCyclops && Player.main.currentSub.gameObject == collision.gameObject)
@@ -41,10 +47,4 @@ public static bool ShouldCollisionAnnoyCreature(Collision collision)
     {
         return AttackCyclops_UpdateAggression_Patch.IsTargetAValidInhabitedCyclops(collision.gameObject);
     }
-
-    public static bool Prefix(AttackCyclops __instance)
-    {
-        return !__instance.TryGetNitroxId(out NitroxId creatureId) ||
-               Resolve<SimulationOwnership>().HasAnyLockType(creatureId);
-    }
 }
diff --git a/NitroxPatcher/Patches/Dynamic/AttackCyclops_UpdateAggression_Patch.cs b/NitroxPatcher/Patches/Dynamic/AttackCyclops_UpdateAggression_Patch.cs
@@ -88,13 +88,13 @@ public static bool IsTargetAValidInhabitedCyclops(IEcoTarget target)
     public static bool IsTargetAValidInhabitedCyclops(GameObject targetObject)
     {
         // Is a Cyclops
-        if (!targetObject.GetComponent<CyclopsNoiseManager>())
+        if (!targetObject.TryGetComponent(out SubRoot subRoot) || !subRoot.isCyclops)
         {
             return false;
         }
 
         // Has the local player inside
-        if (Player.main && Player.main.currentSub && Player.main.currentSub.gameObject == targetObject)
+        if (Player.main && Player.main.currentSub == subRoot)
         {
             return true;
         }
diff --git a/NitroxPatcher/Patches/Dynamic/Creature_ChooseBestAction_Patch.cs b/NitroxPatcher/Patches/Dynamic/Creature_ChooseBestAction_Patch.cs
@@ -14,7 +14,6 @@ public static bool Prefix(Creature __instance, out NitroxId __state, ref Creatur
     {
         if (!__instance.TryGetIdOrWarn(out __state, true))
         {
-            Log.WarnOnce($"[{nameof(Creature_ChooseBestAction_Patch)}] Couldn't find an id on {__instance.GetFullHierarchyPath()}");
             return true;
         }
         if (Resolve<SimulationOwnership>().HasAnyLockType(__state))
diff --git a/NitroxPatcher/Patches/Dynamic/SeamothTorpedoWhirlpool_Register_Patch.cs b/NitroxPatcher/Patches/Dynamic/SeamothTorpedoWhirlpool_Register_Patch.cs
@@ -12,7 +12,7 @@ public sealed partial class SeamothTorpedoWhirlpool_Register_Patch : NitroxPatch
 {
     private static readonly MethodInfo TARGET_METHOD = Reflect.Method((SeamothTorpedoWhirlpool t) => t.Register(default, ref Reflect.Ref<Rigidbody>.Field));
 
-    public static bool Prefix(Collider other, ref bool __result)
+    public static bool Prefix(Collider other)
     {
         return !other.GetComponentInParent<RemotePlayerIdentifier>(true);
     }
diff --git a/NitroxPatcher/Patches/Dynamic/StasisSphere_OnHit_Patch.cs b/NitroxPatcher/Patches/Dynamic/StasisSphere_OnHit_Patch.cs
@@ -9,27 +9,27 @@
 namespace NitroxPatcher.Patches.Dynamic;
 
 /// <summary>
-/// Prevents remote stasis sphere from triggering hit effets (they're triggered with packets)
+/// Prevents remote stasis sphere from triggering hit effets (they're triggered with packets).
+/// Broadcasts local player's stasis sphere hits
 /// </summary>
 public sealed partial class StasisSphere_OnHit_Patch : NitroxPatch, IDynamicPatch
 {
     private static readonly MethodInfo TARGET_METHOD = Reflect.Method((StasisSphere t) => t.OnHit(default));
 
-    private static ushort LocalPlayerId => Resolve<LocalPlayer>().PlayerId;
-
-    public static void Prefix(StasisSphere __instance)
+    public static bool Prefix(StasisSphere __instance)
     {
         if (__instance.GetComponent<BulletManager.RemotePlayerBullet>())
         {
-            return;
+            return false;
         }
 
+        ushort localPlayerId = Resolve<LocalPlayer>().PlayerId;
         NitroxVector3 position = __instance.tr.position.ToDto();
         NitroxQuaternion rotation = __instance.tr.rotation.ToDto();
         // Calculate the chargeNormalized value which was passed to StasisSphere.Shoot
         float chargeNormalized = Mathf.Unlerp(__instance.minRadius, __instance.maxRadius, __instance.radius);
 
-        Resolve<IPacketSender>().Send(new StasisSphereHit(LocalPlayerId, position, rotation, chargeNormalized, __instance._consumption));
-        return;
+        Resolve<IPacketSender>().Send(new StasisSphereHit(localPlayerId, position, rotation, chargeNormalized, __instance._consumption));
+        return true;
     }
 }
diff --git a/NitroxPatcher/Patches/Dynamic/Vehicle_TorpedoShot_Patch.cs b/NitroxPatcher/Patches/Dynamic/Vehicle_TorpedoShot_Patch.cs
@@ -1,7 +1,11 @@
+using System.Collections.Generic;
 using System.Reflection;
+using System.Reflection.Emit;
+using HarmonyLib;
 using NitroxClient.Communication.Abstract;
 using NitroxClient.MonoBehaviours;
 using NitroxModel.DataStructures;
+using NitroxModel.DataStructures.Unity;
 using NitroxModel.Helper;
 using NitroxModel.Packets;
 using NitroxModel_Subnautica.DataStructures;
@@ -11,31 +15,53 @@ namespace NitroxPatcher.Patches.Dynamic;
 
 public sealed partial class Vehicle_TorpedoShot_Patch : NitroxPatch, IDynamicPatch
 {
-    private static readonly MethodInfo TARGET_METHOD = Reflect.Method(() => Vehicle.TorpedoShot(default, default, default));
+    internal static readonly MethodInfo TARGET_METHOD = Reflect.Method(() => Vehicle.TorpedoShot(default, default, default));
 
-    public static bool Prefix(Vehicle __instance, ref bool __result, ItemsContainer container, TorpedoType torpedoType, Transform muzzle)
+    /*
+     * Inserts a DUP instruction after the SeamothTorpedo object is pushed onto the stack so we can use it later on
+     * in the inserted callback.
+     * NB: Ldarg_0 refers to the 1st parameter (ItemsContainer) and Ldarg_1 refers to the 2nd parameter (TorpedoType) as this method is static
+     * 
+     * MODIFICATION:
+     * component.Shoot(muzzle.position, aimingTransform.rotation, num, -1f);
+     * Vehicle_TorpedoShot_Patch.TorpedoShotCallback(dupped object, torpedoType);    <--- INSERTED LINE
+     * return true;
+     * 
+     * "dupped object" is the SeamothTorpedo object from the line:
+     * gameObject.GetComponent<SeamothTorpedo>();
+     */
+    public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
     {
-        // (almost) Exact code copy from Vehicle.TorpedoShot because it's impossible to make a transpiler for it without modifying most of the instructions
-        // (the transpiler wouldn't be readable at all) so the best possibility is to copy the exact and out the created torpedo GameObject
-        if (torpedoType == null || !container.DestroyItem(torpedoType.techType))
-        {
-            return false;
-        }
-        GameObject gameObject = GameObject.Instantiate(torpedoType.prefab);
-        Bullet component = gameObject.GetComponent<SeamothTorpedo>();
-        Transform aimingTransform = Player.main.camRoot.GetAimingTransform();
-        Rigidbody componentInParent = muzzle.GetComponentInParent<Rigidbody>();
-        Vector3 vector = componentInParent ? componentInParent.velocity : Vector3.zero;
-        float num = Vector3.Dot(aimingTransform.forward, vector);
-        component.Shoot(muzzle.position, aimingTransform.rotation, num, -1f);
-        __result = true;
+        // Always match for one more instruction after the searched one because the cursor will be moved right before it
+        return new CodeMatcher(instructions).MatchEndForward([
+                                                new CodeMatch(OpCodes.Pop),
+                                                new CodeMatch(OpCodes.Callvirt, Reflect.Method((GameObject t) => t.GetComponent<SeamothTorpedo>())),
+                                                new CodeMatch(OpCodes.Call),
+                                            ])
+                                            .InsertAndAdvance([
+                                                new CodeInstruction(OpCodes.Dup),
+                                            ])
+                                            .MatchEndForward([
+                                                new CodeMatch(OpCodes.Callvirt, Reflect.Method((Bullet t) => t.Shoot(default, default, default, default))),
+                                                new CodeMatch(OpCodes.Ldc_I4_1),
+                                            ])
+                                            .InsertAndAdvance([
+                                                new CodeInstruction(OpCodes.Ldarg_1),
+                                                new CodeInstruction(OpCodes.Call, Reflect.Method(() => TorpedoShotCallback(default, default)))
+                                            ])
+                                            .InstructionEnumeration();
+    }
+
+    public static void TorpedoShotCallback(SeamothTorpedo seamothTorpedo, TorpedoType torpedoType)
+    {
+        NitroxId bulletId = NitroxEntity.GenerateNewId(seamothTorpedo.gameObject);
 
-        // Broadcast code
+        NitroxVector3 position = seamothTorpedo.transform.position.ToDto();
+        NitroxQuaternion rotation = seamothTorpedo.transform.rotation.ToDto();
 
-        NitroxId bulletId = new();
-        NitroxEntity.SetNewId(gameObject, bulletId);
+        // In Bullet.Shoot, _consumption = f(lifeTime), lifeTime = g(_consumption), this is g:
+        float lifeTime = seamothTorpedo._consumption > 0 ? 1f / seamothTorpedo._consumption : 0f;
 
-        Resolve<IPacketSender>().Send(new TorpedoShot(bulletId, torpedoType.techType.ToDto(), muzzle.position.ToDto(), aimingTransform.rotation.ToDto(), num, -1));
-        return false;
+        Resolve<IPacketSender>().Send(new TorpedoShot(bulletId, torpedoType.techType.ToDto(), position, rotation, seamothTorpedo.speed, lifeTime));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,15 @@ public class AI`
`25`	`25`	`typeof(AttackLastTarget), typeof(AttackCyclops)`
`26`	`26`	`];`
`27`	`27`
	`28`	`+ /// <summary>`
	`29`	`+ /// In the future, ensure all creatures are synced. We want each of them to be individually`
	`30`	`+ /// checked (that all their actions are synced) before marking them as synced.`
	`31`	`+ /// </summary>`
	`32`	`+ private readonly HashSet<Type> syncedCreatureWhitelist =`
	`33`	`+ [`
	`34`	`+ typeof(ReaperLeviathan), typeof(SeaDragon)`
	`35`	`+ ];`
	`36`	`+`
`28`	`37`	`public AI(IPacketSender packetSender)`
`29`	`38`	`{`
`30`	`39`	`this.packetSender = packetSender;`
`@@ -36,7 +45,7 @@ public AI(IPacketSender packetSender)`
`36`	`45`
`37`	`46`	`public void BroadcastNewAction(NitroxId creatureId, Creature creature, CreatureAction newAction)`
`38`	`47`	`{`
`39`		`- if (creature is not ReaperLeviathan)`
	`48`	`+ if (!syncedCreatureWhitelist.Contains(creature.GetType()))`
`40`	`49`	`{`
`41`	`50`	`return;`
`42`	`51`	`}`
`@@ -119,4 +128,9 @@ public bool IsCreatureActionWhitelisted(CreatureAction creatureAction)`
`119`	`128`	`{`
`120`	`129`	`return creatureActionWhitelist.Contains(creatureAction.GetType());`
`121`	`130`	`}`
	`131`	`+`
	`132`	`+ public bool IsCreatureWhitelisted(Creature creature)`
	`133`	`+ {`
	`134`	`+ return syncedCreatureWhitelist.Contains(creature.GetType());`
	`135`	`+ }`
`122`	`136`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,6 @@ public static bool Prefix(AggressiveWhenSeeTarget __instance)`
`23`	`23`	`return true;`
`24`	`24`	`}`
`25`	`25`
`26`		`-`
`27`	`26`	`return false;`
`28`	`27`	`}`
`29`	`28`
`@@ -47,6 +46,11 @@ public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructio`
`47`	`46`
`48`	`47`	`public static void BroadcastTargetChange(AggressiveWhenSeeTarget aggressiveWhenSeeTarget, GameObject aggressionTarget)`
`49`	`48`	`{`
	`49`	`+ if (!Resolve<AI>().IsCreatureWhitelisted(aggressiveWhenSeeTarget.creature))`
	`50`	`+ {`
	`51`	`+ return;`
	`52`	`+ }`
	`53`	`+`
`50`	`54`	`// If the function was called to this point, either it'll return because it doesn't have an id or it'll be evident that we have ownership over the aggressive creature`
`51`	`55`	`LastTarget lastTarget = aggressiveWhenSeeTarget.lastTarget;`
`52`	`56`	`// If there's already (likely another) locked target, we get its id over aggressionTarget`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,12 @@ public sealed partial class AttackCyclops_OnCollisionEnter_Patch : NitroxPatch,`
`17`	`17`	`{`
`18`	`18`	`public static readonly MethodInfo TARGET_METHOD = Reflect.Method((AttackCyclops t) => t.OnCollisionEnter(default));`
`19`	`19`
	`20`	`+ public static bool Prefix(AttackCyclops __instance)`
	`21`	`+ {`
	`22`	`+ return !__instance.TryGetNitroxId(out NitroxId creatureId) \|\|`
	`23`	`+ Resolve<SimulationOwnership>().HasAnyLockType(creatureId);`
	`24`	`+ }`
	`25`	`+`
`20`	`26`	`/*`
`21`	`27`	`* REPLACE:`
`22`	`28`	`* if (Player.main != null && Player.main.currentSub != null && Player.main.currentSub.isCyclops && Player.main.currentSub.gameObject == collision.gameObject)`
`@@ -41,10 +47,4 @@ public static bool ShouldCollisionAnnoyCreature(Collision collision)`
`41`	`47`	`{`
`42`	`48`	`return AttackCyclops_UpdateAggression_Patch.IsTargetAValidInhabitedCyclops(collision.gameObject);`
`43`	`49`	`}`
`44`		`-`
`45`		`- public static bool Prefix(AttackCyclops __instance)`
`46`		`- {`
`47`		`- return !__instance.TryGetNitroxId(out NitroxId creatureId) \|\|`
`48`		`- Resolve<SimulationOwnership>().HasAnyLockType(creatureId);`
`49`		`- }`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -88,13 +88,13 @@ public static bool IsTargetAValidInhabitedCyclops(IEcoTarget target)`
`88`	`88`	`public static bool IsTargetAValidInhabitedCyclops(GameObject targetObject)`
`89`	`89`	`{`
`90`	`90`	`// Is a Cyclops`
`91`		`- if (!targetObject.GetComponent<CyclopsNoiseManager>())`
	`91`	`+ if (!targetObject.TryGetComponent(out SubRoot subRoot) \|\| !subRoot.isCyclops)`
`92`	`92`	`{`
`93`	`93`	`return false;`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`// Has the local player inside`
`97`		`- if (Player.main && Player.main.currentSub && Player.main.currentSub.gameObject == targetObject)`
	`97`	`+ if (Player.main && Player.main.currentSub == subRoot)`
`98`	`98`	`{`
`99`	`99`	`return true;`
`100`	`100`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,6 @@ public static bool Prefix(Creature __instance, out NitroxId __state, ref Creatur`
`14`	`14`	`{`
`15`	`15`	`if (!__instance.TryGetIdOrWarn(out __state, true))`
`16`	`16`	`{`
`17`		`- Log.WarnOnce($"[{nameof(Creature_ChooseBestAction_Patch)}] Couldn't find an id on {__instance.GetFullHierarchyPath()}");`
`18`	`17`	`return true;`
`19`	`18`	`}`
`20`	`19`	`if (Resolve<SimulationOwnership>().HasAnyLockType(__state))`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public sealed partial class SeamothTorpedoWhirlpool_Register_Patch : NitroxPatch`
`12`	`12`	`{`
`13`	`13`	`private static readonly MethodInfo TARGET_METHOD = Reflect.Method((SeamothTorpedoWhirlpool t) => t.Register(default, ref Reflect.Ref<Rigidbody>.Field));`
`14`	`14`
`15`		`- public static bool Prefix(Collider other, ref bool __result)`
	`15`	`+ public static bool Prefix(Collider other)`
`16`	`16`	`{`
`17`	`17`	`return !other.GetComponentInParent<RemotePlayerIdentifier>(true);`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,27 +9,27 @@`
`9`	`9`	`namespace NitroxPatcher.Patches.Dynamic;`
`10`	`10`
`11`	`11`	`/// <summary>`
`12`		`-/// Prevents remote stasis sphere from triggering hit effets (they're triggered with packets)`
	`12`	`+/// Prevents remote stasis sphere from triggering hit effets (they're triggered with packets).`
	`13`	`+/// Broadcasts local player's stasis sphere hits`
`13`	`14`	`/// </summary>`
`14`	`15`	`public sealed partial class StasisSphere_OnHit_Patch : NitroxPatch, IDynamicPatch`
`15`	`16`	`{`
`16`	`17`	`private static readonly MethodInfo TARGET_METHOD = Reflect.Method((StasisSphere t) => t.OnHit(default));`
`17`	`18`
`18`		`- private static ushort LocalPlayerId => Resolve<LocalPlayer>().PlayerId;`
`19`		`-`
`20`		`- public static void Prefix(StasisSphere __instance)`
	`19`	`+ public static bool Prefix(StasisSphere __instance)`
`21`	`20`	`{`
`22`	`21`	`if (__instance.GetComponent<BulletManager.RemotePlayerBullet>())`
`23`	`22`	`{`
`24`		`- return;`
	`23`	`+ return false;`
`25`	`24`	`}`
`26`	`25`
	`26`	`+ ushort localPlayerId = Resolve<LocalPlayer>().PlayerId;`
`27`	`27`	`NitroxVector3 position = __instance.tr.position.ToDto();`
`28`	`28`	`NitroxQuaternion rotation = __instance.tr.rotation.ToDto();`
`29`	`29`	`// Calculate the chargeNormalized value which was passed to StasisSphere.Shoot`
`30`	`30`	`float chargeNormalized = Mathf.Unlerp(__instance.minRadius, __instance.maxRadius, __instance.radius);`
`31`	`31`
`32`		`- Resolve<IPacketSender>().Send(new StasisSphereHit(LocalPlayerId, position, rotation, chargeNormalized, __instance._consumption));`
`33`		`- return;`
	`32`	`+ Resolve<IPacketSender>().Send(new StasisSphereHit(localPlayerId, position, rotation, chargeNormalized, __instance._consumption));`
	`33`	`+ return true;`
`34`	`34`	`}`
`35`	`35`	`}`