Sync footstep audio

Nitrox.Assets.Subnautica/Resources/SoundWhitelist_Subnautica.csv

@@ -281,9 +281,9 @@ event:/player/enzyme_cure;false;false;0
 event:/player/food_critical;false;false;0
 event:/player/food_low;false;false;0
 event:/player/food_very_low;false;false;0
-event:/player/footstep_dirt;false;false;0
-event:/player/footstep_metal;false;false;0
-event:/player/footstep_precursor_base;false;false;0
+event:/player/footstep_dirt;false;false;20
+event:/player/footstep_metal;false;false;20
+event:/player/footstep_precursor_base;false;false;20
 event:/player/goal_airsack;false;false;0
 event:/player/goal_BiomeKelpForest;false;false;0
 event:/player/goal_BiomePrecursorGunUpper;false;false;0

NitroxClient/Communication/Packets/Processors/FootstepPacketProcessor.cs

@@ -0,0 +1,57 @@
+using FMOD;
+using FMOD.Studio;
+using FMODUnity;
+using NitroxClient.Communication.Packets.Processors.Abstract;
+using NitroxClient.GameLogic;
+using NitroxClient.GameLogic.FMOD;
+using NitroxModel.DataStructures.Util;
+using NitroxModel.GameLogic.FMOD;
+using NitroxModel.Packets;
+
+namespace NitroxClient.Communication.Packets.Processors;
+
+public class FootstepPacketProcessor : ClientPacketProcessor<FootstepPacket>
+{
+    private readonly PlayerManager remotePlayerManager;
+    private readonly FootstepSounds localFootstepSounds;
+    private PARAMETER_ID fmodIndexSpeed = FMODUWE.invalidParameterId;
+    private readonly float footstepAudioRadius; // To modify this value, modify the last value in the SoundWhitelist_Subnautica.csv file
+    private const float footstepAudioMaxVolume = 0.5f;
+
+    public FootstepPacketProcessor(PlayerManager remotePlayerManager, FMODWhitelist whitelist)
+    {
+        this.remotePlayerManager = remotePlayerManager;
+        localFootstepSounds = Player.mainObject.GetComponent<FootstepSounds>();
+        whitelist.TryGetSoundData("event:/player/footstep_precursor_base", out SoundData soundData);
+        footstepAudioRadius = soundData.Radius;
+    }
+
+    public override void Process(FootstepPacket packet)
+    {
+        Optional<RemotePlayer> player = remotePlayerManager.Find(packet.PlayerID);
+        if (player.HasValue)
+        {
+            FMODAsset asset = packet.AssetIndex switch
+            {
+                FootstepPacket.StepSounds.PRECURSOR_STEP_SOUND => localFootstepSounds.precursorInteriorSound,
+                FootstepPacket.StepSounds.METAL_STEP_SOUND => localFootstepSounds.metalSound,
+                FootstepPacket.StepSounds.LAND_STEP_SOUND => localFootstepSounds.landSound,
+                _ => null
+            };
+            EventInstance evt = FMODUWE.GetEvent(asset);
+            if (evt.isValid())
+            {
+                if (FMODUWE.IsInvalidParameterId(fmodIndexSpeed))
+                {
+                    fmodIndexSpeed = FMODUWE.GetEventInstanceParameterIndex(evt, "speed");
+                }
+                ATTRIBUTES_3D attributes = player.Value.Body.To3DAttributes();
+                evt.set3DAttributes(attributes);
+                evt.setParameterValueByIndex(fmodIndexSpeed, player.Value.AnimationController.Velocity.magnitude);
+                evt.setVolume(FMODSystem.CalculateVolume(Player.mainObject.transform.position, player.Value.Body.transform.position, footstepAudioRadius, footstepAudioMaxVolume));
+                evt.start();
+                evt.release();
+            }
+        }
+    }
+}

NitroxModel/Packets/FootstepPacket.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace NitroxModel.Packets;
+
+[Serializable]
+public class FootstepPacket : Packet
+{
+    public ushort PlayerID { get; }
+    public StepSounds AssetIndex { get; }
+
+    public FootstepPacket(ushort playerID, StepSounds assetIndex)
+    {
+        this.PlayerID = playerID;
+        this.AssetIndex = assetIndex;
+    }
+
+    public enum StepSounds : byte
+    {
+        PRECURSOR_STEP_SOUND,
+        METAL_STEP_SOUND,
+        LAND_STEP_SOUND
+    }
+}

NitroxPatcher/Patches/Dynamic/FootstepSounds_OnStep_Patch.cs

@@ -1,32 +1,43 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Reflection.Emit;
 using FMOD.Studio;
 using HarmonyLib;
+using NitroxClient.Communication.Abstract;
+using NitroxClient.GameLogic;
 using NitroxClient.GameLogic.FMOD;
 using NitroxModel.GameLogic.FMOD;
 using NitroxModel.Helper;
+using NitroxModel.Packets;
 using UnityEngine;
 
 namespace NitroxPatcher.Patches.Dynamic;
 
 public sealed partial class FootstepSounds_OnStep_Patch : NitroxPatch, IDynamicPatch
 {
     private const string EXO_STEP_SOUND_PATH = "event:/sub/exo/step";
+    private const string PRECURSOR_STEP_SOUND_PATH = "event:/player/footstep_precursor_base";
+    private const string METAL_STEP_SOUND_PATH = "event:/player/footstep_metal";
 
     internal static readonly MethodInfo TARGET_METHOD = Reflect.Method((FootstepSounds t) => t.OnStep(default));
 
     public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
     {
         /*
         From:
-
             evt.setVolume(volume);
 
         To:
-
             evt.setVolume(CalculateVolume(volume, this, asset, xform));
+
+
+        From:
+            event.release();
+
+        To:
+            event.release();
+            SendFootstepPacket(asset);
          */
 
         return new CodeMatcher(instructions)
@@ -40,6 +51,13 @@ public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructio
                    new CodeInstruction(OpCodes.Ldarg_1),
                    new CodeInstruction(OpCodes.Call, Reflect.Method(() => CalculateVolume(default, default, default, default)))
                )
+               .MatchEndForward(
+                   new CodeMatch(OpCodes.Call, Reflect.Method((EventInstance evt) => evt.release())),
+                   new CodeMatch(OpCodes.Pop)
+               )
+               .Advance(1)
+               .InsertAndAdvance(new CodeInstruction(OpCodes.Ldloc_0))
+               .Insert(new CodeInstruction(OpCodes.Call, Reflect.Method(() => SendFootstepPacket(default))))
                .InstructionEnumeration();
     }
 
@@ -61,4 +79,26 @@ private static float CalculateVolume(float originalVolume, FootstepSounds instan
         Resolve<FMODWhitelist>().TryGetSoundData(EXO_STEP_SOUND_PATH, out SoundData soundData);
         return soundData.Radius;
     });
+
+    private static void SendFootstepPacket(FMODAsset asset)
+    {
+        if (Resolve<LocalPlayer>().PlayerId.HasValue)
+        {
+            FootstepPacket.StepSounds assetIndex;
+            switch (asset.path)
+            {
+                case PRECURSOR_STEP_SOUND_PATH:
+                    assetIndex = FootstepPacket.StepSounds.PRECURSOR_STEP_SOUND;
+                    break;
+                case METAL_STEP_SOUND_PATH:
+                    assetIndex = FootstepPacket.StepSounds.METAL_STEP_SOUND;
+                    break;
+                default:
+                    assetIndex = FootstepPacket.StepSounds.LAND_STEP_SOUND;
+                    break;
+            }
+            FootstepPacket footstepPacket = new(Resolve<LocalPlayer>().PlayerId.Value, assetIndex);
+            Resolve<IPacketSender>().Send(footstepPacket);
+        }
+    }
 }

NitroxServer/Communication/Packets/Processors/FootstepPacketProcessor.cs

@@ -0,0 +1,45 @@
+using NitroxModel.DataStructures.Unity;
+using NitroxModel.GameLogic.FMOD;
+using NitroxModel.Packets;
+using NitroxServer.Communication.Packets.Processors.Abstract;
+using NitroxServer.GameLogic;
+
+namespace NitroxServer.Communication.Packets.Processors;
+
+public class FootstepPacketProcessor : AuthenticatedPacketProcessor<FootstepPacket>
+{
+    private readonly float footstepAudioRange; // To modify this value, modify the last value in the SoundWhitelist_Subnautica.csv file
+    private readonly PlayerManager playerManager;
+
+    public FootstepPacketProcessor(PlayerManager playerManager, FMODWhitelist whitelist)
+    {
+        this.playerManager = playerManager;
+        whitelist.TryGetSoundData("event:/player/footstep_precursor_base", out SoundData soundData);
+        footstepAudioRange = soundData.Radius;
+    }
+
+    public override void Process(FootstepPacket footstepPacket, Player sendingPlayer)
+    {
+        foreach (Player player in playerManager.GetAllPlayers())
+        {
+            if(NitroxVector3.Distance(player.Position, sendingPlayer.Position) >= footstepAudioRange)
+            {
+                continue;
+            }
+            if(player != sendingPlayer)
+            {
+                continue;
+            }
+            if (player.SubRootId.HasValue && sendingPlayer.SubRootId.HasValue &&
+                player.SubRootId.Value == sendingPlayer.SubRootId.Value)
+            {
+                player.SendPacket(footstepPacket);
+            }
+            else if (NitroxVector3.Distance(player.Position, sendingPlayer.Position) <= footstepAudioRange &&
+                    !player.SubRootId.HasValue)
+            {
+                player.SendPacket(footstepPacket);
+            }
+        }
+    }
+}