using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FMOD;
using FMODUnity;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("VoiceGrunts")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("VoiceGrunts")]
[assembly: AssemblyTitle("VoiceGrunts")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace VoiceGrunts
{
internal static class AnnouncerAudio
{
private static PropertyInfo _announcerVolumeProperty;
private static bool _bindSucceeded;
internal static void Initialize()
{
if (_announcerVolumeProperty != null)
{
return;
}
Type nestedType = typeof(GameSettings).GetNestedType("AudioSettings", BindingFlags.Public | BindingFlags.NonPublic);
if (nestedType == null)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogWarning((object)"Could not find GameSettings.AudioSettings for announcer volume routing.");
}
return;
}
_announcerVolumeProperty = AccessTools.Property(nestedType, "AnnouncerVolume");
if (_announcerVolumeProperty == null)
{
ManualLogSource log2 = Plugin.Log;
if (log2 != null)
{
log2.LogWarning((object)"Could not find AnnouncerVolume property for announcer volume routing.");
}
return;
}
_bindSucceeded = true;
ManualLogSource log3 = Plugin.Log;
if (log3 != null)
{
log3.LogInfo((object)"Announcer volume routing bound to GameSettings.All.Audio.AnnouncerVolume.");
}
}
internal static bool TryGetAnnouncerVolume(out float volume)
{
volume = 1f;
if (!_bindSucceeded || _announcerVolumeProperty == null)
{
return false;
}
try
{
AllSettings all = GameSettings.All;
object obj = ((all != null) ? all.Audio : null);
if (obj == null)
{
return false;
}
volume = (float)_announcerVolumeProperty.GetValue(obj);
return true;
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogDebug((object)("Announcer volume unavailable: " + ex.Message));
}
return false;
}
}
internal static void ApplyToChannel(Channel channel)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
if (((Channel)(ref channel)).hasHandle() && TryGetAnnouncerVolume(out var volume))
{
((Channel)(ref channel)).setVolume(volume);
}
}
}
internal static class GameCursor
{
private static readonly MethodInfo SetCursorForceUnlockedMethod = AccessTools.Method(typeof(CursorManager), "SetCursorForceUnlocked", new Type[1] { typeof(bool) }, (Type[])null);
private static readonly MethodInfo UpdateCursorLockMethod = AccessTools.Method(typeof(InputManager), "UpdateCursorLock", (Type[])null, (Type[])null);
private static readonly MethodInfo ApplyCursorLockMethod = AccessTools.Method(typeof(CursorManager), "ApplyCursorLock", (Type[])null, (Type[])null);
internal static void SetOverlayOpen(bool open)
{
try
{
SetCursorForceUnlockedMethod?.Invoke(null, new object[1] { open });
if (!open)
{
UpdateCursorLockMethod?.Invoke(null, null);
if (SingletonBehaviour<CursorManager>.HasInstance)
{
ApplyCursorLockMethod?.Invoke(SingletonBehaviour<CursorManager>.Instance, null);
}
}
}
catch (Exception ex)
{
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogDebug((object)$"GameCursor.SetOverlayOpen({open}) failed: {ex.Message}");
}
}
if (open)
{
Cursor.lockState = (CursorLockMode)0;
Cursor.visible = true;
}
}
internal static void RestoreAfterOverlay(bool wasVisible, CursorLockMode previousLockState)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
SetOverlayOpen(open: false);
if (wasVisible)
{
Cursor.lockState = (CursorLockMode)0;
Cursor.visible = true;
}
else
{
Cursor.lockState = (CursorLockMode)(((int)previousLockState == 0) ? 1 : ((int)previousLockState));
Cursor.visible = false;
}
}
}
internal enum GruntEventKind
{
Jump = 1,
Knocked
}
internal static class GruntClipNetworkSync
{
private static PlayerInfo _knockRpcPlayerInfo;
private static readonly MethodInfo KnockUserCodeRpcMethod = AccessTools.Method(typeof(PlayerMovement), "UserCode_RpcInformKnockedOutOtherPlayer__PlayerInfo__Boolean", (Type[])null, (Type[])null);
private static readonly MethodInfo RememberKnockRpcPlayerInfoMethod = AccessTools.Method(typeof(GruntClipNetworkSync), "RememberKnockRpcPlayerInfo", (Type[])null, (Type[])null);
private static readonly MethodInfo ConsumeKnockClipTrailingByteMethod = AccessTools.Method(typeof(GruntClipNetworkSync), "ConsumeKnockClipTrailingByte", (Type[])null, (Type[])null);
internal static void WriteClipByte(NetworkWriter writer, byte clipIndex)
{
if (writer != null)
{
writer.WriteByte(clipIndex);
}
}
internal static void ReadTrailingClipByte(NetworkReader reader, ulong playerGuid, GruntEventKind kind)
{
if (reader != null && playerGuid != 0L && reader.Remaining >= 1)
{
VoicePackRegistry.SetPendingClipIndex(kind, playerGuid, reader.ReadByte());
}
}
internal static void RememberKnockRpcPlayerInfo(PlayerInfo knockedOutPlayer)
{
_knockRpcPlayerInfo = knockedOutPlayer;
}
internal static void ConsumeKnockClipTrailingByte(NetworkReader reader)
{
if ((Object)(object)_knockRpcPlayerInfo == (Object)null || (Object)(object)_knockRpcPlayerInfo.PlayerId == (Object)null || reader == null || reader.Remaining < 1)
{
_knockRpcPlayerInfo = null;
return;
}
ReadTrailingClipByte(reader, _knockRpcPlayerInfo.PlayerId.Guid, GruntEventKind.Knocked);
_knockRpcPlayerInfo = null;
}
internal static void WriteJumpClipForSend(NetworkWriter writer, PlayerAudio playerAudio, GruntEventKind kind)
{
if (writer != null && !((Object)(object)playerAudio == (Object)null) && kind == GruntEventKind.Jump)
{
int num = 0;
int clipIndex2;
if (VoicePackRegistry.TryTakeRpcJumpClipIndex(((NetworkBehaviour)playerAudio).netId, out var clipIndex))
{
num = clipIndex;
}
else if (VoicePackRegistry.TryPeekPendingClipIndex(GruntEventKind.Jump, Plugin.GetPlayerGuid(playerAudio), out clipIndex2))
{
num = clipIndex2;
}
WriteClipByte(writer, (byte)Mathf.Clamp(num, 0, 255));
}
}
internal static void WriteKnockedClipForSend(NetworkWriter writer, PlayerInfo knockedOutPlayer, GruntEventKind kind)
{
if (writer != null && !((Object)(object)knockedOutPlayer == (Object)null) && kind == GruntEventKind.Knocked)
{
ulong num = (((Object)(object)knockedOutPlayer.PlayerId != (Object)null) ? knockedOutPlayer.PlayerId.Guid : 0);
int num2 = 0;
if (num != 0L && VoicePackRegistry.TryPeekPendingClipIndex(GruntEventKind.Knocked, num, out var clipIndex))
{
num2 = clipIndex;
}
WriteClipByte(writer, (byte)Mathf.Clamp(num2, 0, 255));
}
}
internal static void PrepareJumpRpcClip(PlayerAudio playerAudio)
{
if (NetworkServer.active && !((Object)(object)playerAudio == (Object)null) && VoicePackRegistry.TryPeekPendingClipIndex(GruntEventKind.Jump, Plugin.GetPlayerGuid(playerAudio), out var clipIndex))
{
VoicePackRegistry.SetRpcJumpClipIndex(((NetworkBehaviour)playerAudio).netId, clipIndex);
}
}
internal static IEnumerable<CodeInstruction> TranspileAppendClipByteAfterWriterGet(IEnumerable<CodeInstruction> instructions, MethodInfo writeMethod, GruntEventKind kind, bool passPlayerInfoArg = false)
{
List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
for (int i = 0; i < codes.Count; i++)
{
yield return codes[i];
if (i > 0 && !(codes[i].opcode != OpCodes.Stloc_0) && CodeInstructionExtensions.Calls(codes[i - 1], typeof(NetworkWriterPool).GetMethod("Get", BindingFlags.Static | BindingFlags.Public)))
{
yield return new CodeInstruction(OpCodes.Ldloc_0, (object)null);
if (passPlayerInfoArg)
{
yield return new CodeInstruction(OpCodes.Ldarg_1, (object)null);
}
else
{
yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
}
yield return new CodeInstruction(OpCodes.Ldc_I4, (object)(int)kind);
yield return new CodeInstruction(OpCodes.Call, (object)writeMethod);
}
}
}
private static bool IsReadPlayerInfoFromReader(MethodBase method)
{
if (method == null || method.Name != "ReadNetworkBehaviour" || !method.IsGenericMethod)
{
return false;
}
Type[] genericArguments = method.GetGenericArguments();
if (genericArguments.Length == 1)
{
return genericArguments[0] == typeof(PlayerInfo);
}
return false;
}
internal static IEnumerable<CodeInstruction> TranspileReadKnockedClipBeforeUserCode(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
for (int i = 0; i < codes.Count; i++)
{
if (CodeInstructionExtensions.Calls(codes[i], KnockUserCodeRpcMethod))
{
yield return new CodeInstruction(OpCodes.Ldarg_1, (object)null);
yield return new CodeInstruction(OpCodes.Call, (object)ConsumeKnockClipTrailingByteMethod);
}
yield return codes[i];
if (codes[i].operand is MethodBase method && IsReadPlayerInfoFromReader(method))
{
yield return new CodeInstruction(OpCodes.Dup, (object)null);
yield return new CodeInstruction(OpCodes.Call, (object)RememberKnockRpcPlayerInfoMethod);
}
}
}
}
[HarmonyPatch(typeof(PlayerAudio), "CmdPlayJumpForAllClients")]
internal static class JumpCmdTranspilerPatch
{
private static readonly MethodInfo WriteMethod = AccessTools.Method(typeof(GruntClipNetworkSync), "WriteJumpClipForSend", (Type[])null, (Type[])null);
[HarmonyTranspiler]
internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
return GruntClipNetworkSync.TranspileAppendClipByteAfterWriterGet(instructions, WriteMethod, GruntEventKind.Jump);
}
}
[HarmonyPatch(typeof(PlayerAudio), "RpcPlayJump")]
internal static class JumpRpcTranspilerPatch
{
private static readonly MethodInfo WriteMethod = AccessTools.Method(typeof(GruntClipNetworkSync), "WriteJumpClipForSend", (Type[])null, (Type[])null);
[HarmonyTranspiler]
internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
return GruntClipNetworkSync.TranspileAppendClipByteAfterWriterGet(instructions, WriteMethod, GruntEventKind.Jump);
}
}
[HarmonyPatch(typeof(PlayerAudio), "InvokeUserCode_CmdPlayJumpForAllClients__NetworkConnectionToClient")]
internal static class JumpCmdInvokePatch
{
[HarmonyPrefix]
internal static void Prefix(NetworkBehaviour obj, NetworkReader reader)
{
GruntClipNetworkSync.ReadTrailingClipByte(reader, Plugin.GetPlayerGuid((PlayerAudio)(object)((obj is PlayerAudio) ? obj : null)), GruntEventKind.Jump);
}
}
[HarmonyPatch(typeof(PlayerAudio), "InvokeUserCode_RpcPlayJump__NetworkConnectionToClient")]
internal static class JumpRpcInvokePatch
{
[HarmonyPrefix]
internal static void Prefix(NetworkBehaviour obj, NetworkReader reader)
{
GruntClipNetworkSync.ReadTrailingClipByte(reader, Plugin.GetPlayerGuid((PlayerAudio)(object)((obj is PlayerAudio) ? obj : null)), GruntEventKind.Jump);
}
}
[HarmonyPatch(typeof(PlayerAudio), "UserCode_CmdPlayJumpForAllClients__NetworkConnectionToClient")]
internal static class JumpCmdUserCodePatch
{
[HarmonyPrefix]
internal static void Prefix(PlayerAudio __instance)
{
GruntClipNetworkSync.PrepareJumpRpcClip(__instance);
}
}
[HarmonyPatch(typeof(PlayerAudio), "PlayJumpForAllClients")]
internal static class JumpForAllClientsPatch
{
[HarmonyPrefix]
internal static void Prefix(PlayerAudio __instance)
{
if (!((Object)(object)__instance == (Object)null) && Plugin.IsLocalPlayer(__instance))
{
VoicePackRegistry.SetPendingClipIndex(GruntEventKind.Jump, Plugin.GetPlayerGuid(__instance), Plugin.PickJumpClipIndex(Plugin.GetVoicePackId(__instance)));
}
}
[HarmonyPostfix]
internal static void Postfix(PlayerAudio __instance)
{
if (!((Object)(object)__instance == (Object)null) && Plugin.IsLocalPlayer(__instance))
{
VoicePackRegistry.TryConsumePendingClipIndex(GruntEventKind.Jump, Plugin.GetPlayerGuid(__instance), out var _);
}
}
}
[HarmonyPatch(typeof(PlayerMovement), "CmdInformKnockedOut")]
internal static class KnockCmdTranspilerPatch
{
private static readonly MethodInfo WriteMethod = AccessTools.Method(typeof(KnockCmdClipWritePatch), "WriteFromLocalMovement", (Type[])null, (Type[])null);
[HarmonyTranspiler]
internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
return GruntClipNetworkSync.TranspileAppendClipByteAfterWriterGet(instructions, WriteMethod, GruntEventKind.Knocked);
}
}
internal static class KnockCmdClipWritePatch
{
internal static void WriteFromLocalMovement(NetworkWriter writer, PlayerMovement movement, GruntEventKind kind)
{
if (writer != null && !((Object)(object)movement == (Object)null) && kind == GruntEventKind.Knocked)
{
PlayerInfo playerInfo = movement.PlayerInfo;
ulong num = (((Object)(object)playerInfo != (Object)null && (Object)(object)playerInfo.PlayerId != (Object)null) ? playerInfo.PlayerId.Guid : 0);
int num2 = 0;
if (num != 0L && VoicePackRegistry.TryPeekPendingClipIndex(GruntEventKind.Knocked, num, out var clipIndex))
{
num2 = clipIndex;
}
GruntClipNetworkSync.WriteClipByte(writer, (byte)Mathf.Clamp(num2, 0, 255));
}
}
}
[HarmonyPatch(typeof(PlayerMovement), "RpcInformKnockedOutOtherPlayer")]
internal static class KnockRpcTranspilerPatch
{
private static readonly MethodInfo WriteMethod = AccessTools.Method(typeof(GruntClipNetworkSync), "WriteKnockedClipForSend", (Type[])null, (Type[])null);
[HarmonyTranspiler]
internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
return GruntClipNetworkSync.TranspileAppendClipByteAfterWriterGet(instructions, WriteMethod, GruntEventKind.Knocked, passPlayerInfoArg: true);
}
}
[HarmonyPatch(typeof(PlayerMovement), "InvokeUserCode_CmdInformKnockedOut__PlayerInfo__KnockoutType__Vector3__Single__ItemType__ItemUseId__Boolean")]
internal static class KnockCmdInvokePatch
{
[HarmonyPostfix]
internal static void Postfix(NetworkBehaviour obj, NetworkReader reader)
{
PlayerMovement val = (PlayerMovement)(object)((obj is PlayerMovement) ? obj : null);
PlayerInfo val2 = (((Object)(object)val != (Object)null) ? val.PlayerInfo : null);
ulong playerGuid = (((Object)(object)val2 != (Object)null && (Object)(object)val2.PlayerId != (Object)null) ? val2.PlayerId.Guid : 0);
GruntClipNetworkSync.ReadTrailingClipByte(reader, playerGuid, GruntEventKind.Knocked);
}
}
[HarmonyPatch(typeof(PlayerMovement), "InvokeUserCode_RpcInformKnockedOutOtherPlayer__PlayerInfo__Boolean")]
internal static class KnockRpcInvokeTranspilerPatch
{
[HarmonyTranspiler]
internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
return GruntClipNetworkSync.TranspileReadKnockedClipBeforeUserCode(instructions);
}
}
[BepInPlugin("sbg.voicegrunts", "VoiceGrunts", "1.4.11")]
public class Plugin : BaseUnityPlugin
{
private sealed class SoundVariant
{
public string RelativePath;
public Sound Sound2D;
public Sound Sound3D;
}
internal static class SwingNetworkPatch
{
internal static void EncodeLocalPackPrefix(PlayerAudio __instance, ref float normalizedPower)
{
if (!((Object)(object)__instance == (Object)null) && IsLocalPlayer(__instance) && (((NetworkBehaviour)__instance).isClient || ((NetworkBehaviour)__instance).isServer))
{
int clipIndex = PickSwingClipIndex(SelectedVoicePack, normalizedPower);
VoicePackRegistry.SetPendingSwingClipIndex(GetPlayerGuid(__instance), clipIndex);
normalizedPower = VoicePackRegistry.EncodeSwing(normalizedPower, SelectedVoicePack, clipIndex);
}
}
internal static void CmdPlaySwingPrefix(PlayerAudio __instance, ref float normalizedPower, bool isUsingRocketDriver, NetworkConnectionToClient sender)
{
if (NetworkServer.active && !((Object)(object)__instance == (Object)null) && VoicePackRegistry.LooksEncoded(normalizedPower))
{
VoicePackRegistry.CaptureFromEncodedPower(GetPlayerGuid(__instance), normalizedPower);
normalizedPower = VoicePackRegistry.StripPackFromPower(normalizedPower);
}
}
internal static void DecodeRemotePackPrefix(PlayerAudio __instance, NetworkConnectionToClient connection, ref float normalizedPower, bool isUsingRocketDriver)
{
if ((Object)(object)__instance == (Object)null)
{
return;
}
if (VoicePackRegistry.LooksEncoded(normalizedPower))
{
float encodedPower = normalizedPower;
VoicePackRegistry.CaptureFromEncodedPower(GetPlayerGuid(__instance), normalizedPower);
normalizedPower = VoicePackRegistry.StripPackFromPower(normalizedPower);
if (NetworkServer.active)
{
int pack = VoicePackRegistry.GetPack(GetPlayerGuid(__instance));
int clipIndex = VoicePackRegistry.DecodeClipIndexFromPower(encodedPower);
normalizedPower = VoicePackRegistry.EncodeSwing(normalizedPower, pack, clipIndex);
}
}
else if (NetworkServer.active)
{
ulong playerGuid = GetPlayerGuid(__instance);
int pack2 = VoicePackRegistry.GetPack(playerGuid);
int clipIndex2 = 0;
VoicePackRegistry.TryGetPendingSwingClipIndex(playerGuid, out clipIndex2);
normalizedPower = VoicePackRegistry.EncodeSwing(normalizedPower, pack2, clipIndex2);
}
}
}
internal static class NetworkLifecyclePatch
{
internal static void OnNetworkStoppedPostfix()
{
VoicePackRegistry.Clear();
}
}
internal static class SwingGruntPatch
{
internal static void StripEncodedPackPrefix(PlayerAudio __instance, ref float normalizedPower)
{
if (!((Object)(object)__instance == (Object)null) && VoicePackRegistry.LooksEncoded(normalizedPower))
{
VoicePackRegistry.CaptureFromEncodedPower(GetPlayerGuid(__instance), normalizedPower);
normalizedPower = VoicePackRegistry.StripPackFromPower(normalizedPower);
}
}
internal static void Postfix(PlayerAudio __instance, float normalizedPower)
{
if (_poolsReady && !((Object)(object)__instance == (Object)null))
{
ulong playerGuid = GetPlayerGuid(__instance);
int clipIndex = -1;
if (VoicePackRegistry.TryConsumePendingSwingClipIndex(playerGuid, out var clipIndex2))
{
clipIndex = clipIndex2;
}
PlayGruntForPlayer(__instance, PickSwingGrunt(GetVoicePackId(__instance), normalizedPower, clipIndex));
}
}
}
internal static class JumpGruntPatch
{
internal static void Postfix(PlayerAudio __instance)
{
if (_poolsReady && !((Object)(object)__instance == (Object)null))
{
ulong playerGuid = GetPlayerGuid(__instance);
int clipIndex = -1;
int clipIndex3;
if (!IsLocalPlayer(__instance) && VoicePackRegistry.TryConsumePendingClipIndex(GruntEventKind.Jump, playerGuid, out var clipIndex2))
{
clipIndex = clipIndex2;
}
else if (VoicePackRegistry.TryPeekPendingClipIndex(GruntEventKind.Jump, playerGuid, out clipIndex3))
{
clipIndex = clipIndex3;
}
PlayGruntForPlayer(__instance, PickJumpGrunt(GetVoicePackId(__instance), clipIndex));
}
}
}
internal static class KnockedGruntPatch
{
internal static void Postfix(PlayerAudio __instance)
{
if (_poolsReady && !((Object)(object)__instance == (Object)null))
{
int clipIndex = PickKnockedClipIndexFromMovement(((Component)__instance).GetComponentInParent<PlayerMovement>(), GetVoicePackId(__instance));
PlayGruntForPlayer(__instance, PickKnockedGrunt(GetVoicePackId(__instance), clipIndex));
}
}
}
public const string ModGuid = "sbg.voicegrunts";
public const string ModName = "VoiceGrunts";
public const string ModVersion = "1.4.11";
public const int MaxPackCount = 9;
private const string SoundsFolderName = "Sounds";
private const string VoicePackPrefix = "VoicePack";
private const string KnockedFolderName = "Knocked";
private static readonly string[] SupportedExtensions = new string[3] { ".wav", ".ogg", ".mp3" };
private const float Audio3DMinDistance = 8f;
private const float Audio3DMaxDistance = 60f;
private const float AudioHeightOffset = 0.9f;
internal static ManualLogSource Log;
private static readonly Dictionary<string, List<SoundVariant>> _swingPools = new Dictionary<string, List<SoundVariant>>(StringComparer.OrdinalIgnoreCase);
private static readonly Dictionary<int, List<SoundVariant>> _jumpPools = new Dictionary<int, List<SoundVariant>>();
private static readonly Dictionary<int, List<SoundVariant>> _knockedPools = new Dictionary<int, List<SoundVariant>>();
private static readonly Random _rng = new Random();
private static bool _poolsReady;
private static int _installedPackCount;
private static ConfigEntry<int> _selectedVoicePack;
private static FieldRef<PlayerAudio, PlayerInfo> _playerInfoField;
private static readonly (string TierFolder, float MaxPower)[] SwingPowerTiers = new(string, float)[4]
{
("SwingGrunt/LightTap", 0.25f),
("SwingGrunt/MediumGrunt", 0.5f),
("SwingGrunt/StrongGrunt", 0.75f),
("SwingGrunt/FullPower", 1f)
};
private static readonly PropertyInfo KnockedOutVfxDataProperty = AccessTools.Property(typeof(PlayerMovement), "NetworkknockedOutVfxData");
private static readonly FieldInfo KnockedOutTotalStarCountField = ((KnockedOutVfxDataProperty != null) ? AccessTools.Field(KnockedOutVfxDataProperty.PropertyType, "totalStarCount") : null);
private static readonly FieldInfo KnockedOutColoredStarCountField = ((KnockedOutVfxDataProperty != null) ? AccessTools.Field(KnockedOutVfxDataProperty.PropertyType, "coloredStarCount") : null);
public static int SelectedVoicePack => Mathf.Clamp(_selectedVoicePack.Value, 1, 9);
internal static int InstalledPackCount => _installedPackCount;
internal static void SetSelectedVoicePack(int packId)
{
_selectedVoicePack.Value = Mathf.Clamp(packId, 1, 9);
}
internal static string GetPackDisplayName(int packId)
{
return VoicePackNames.GetDisplayName(packId);
}
private void Awake()
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
_selectedVoicePack = ((BaseUnityPlugin)this).Config.Bind<int>("Voice", "SelectedPack", 1, new ConfigDescription("Your voice pack (1–9) for your own grunts.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 9), Array.Empty<object>()));
_selectedVoicePack.SettingChanged += delegate
{
ManualLogSource log = Log;
if (log != null)
{
log.LogInfo((object)$"Local voice pack set to {SelectedVoicePack} (takes effect immediately for your swings).");
}
};
_playerInfoField = AccessTools.FieldRefAccess<PlayerAudio, PlayerInfo>(AccessTools.Field(typeof(PlayerAudio), "playerInfo"));
AnnouncerAudio.Initialize();
VoicePackNames.Initialize(((BaseUnityPlugin)this).Config);
VoicePackOverlay.Initialize(((BaseUnityPlugin)this).Config);
DiscoverInstalledVoicePacks();
ApplyHarmonyPatches();
Log.LogInfo((object)"VoiceGrunts v1.4.11 loaded (voice pools load in Start).");
}
private void DiscoverInstalledVoicePacks()
{
try
{
string text = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "Sounds");
if (!Directory.Exists(text))
{
Log.LogWarning((object)("Sounds folder missing: " + text));
return;
}
_installedPackCount = 0;
foreach (int item in DiscoverPackIds(text))
{
_installedPackCount = Mathf.Max(_installedPackCount, item);
string packRootPath = Path.Combine(text, "VoicePack" + item);
VoicePackNames.LoadFromPackFolder(item, packRootPath);
}
if (_installedPackCount > 0)
{
Log.LogInfo((object)$"Voice packs discovered: 1–{_installedPackCount}");
}
}
catch (Exception arg)
{
Log.LogError((object)$"Voice pack discovery failed: {arg}");
}
}
internal static int GetVoicePackId(PlayerAudio playerAudio)
{
if (IsLocalPlayer(playerAudio))
{
return SelectedVoicePack;
}
return VoicePackRegistry.GetPack(GetPlayerGuid(playerAudio));
}
internal static ulong GetPlayerGuid(PlayerAudio playerAudio)
{
if ((Object)(object)playerAudio == (Object)null)
{
return 0uL;
}
PlayerInfo val = ((_playerInfoField != null) ? _playerInfoField.Invoke(playerAudio) : null);
if ((Object)(object)val == (Object)null)
{
val = ((Component)playerAudio).GetComponent<PlayerInfo>();
}
if ((Object)(object)val == (Object)null)
{
return 0uL;
}
PlayerId playerId = val.PlayerId;
if (!((Object)(object)playerId != (Object)null))
{
return 0uL;
}
return playerId.Guid;
}
private static void ApplyHarmonyPatches()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Expected O, but got Unknown
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Expected O, but got Unknown
//IL_0091: Expected O, but got Unknown
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_0114: Expected O, but got Unknown
//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
//IL_01c5: Expected O, but got Unknown
//IL_025b: Unknown result type (might be due to invalid IL or missing references)
//IL_0269: Expected O, but got Unknown
//IL_0385: Unknown result type (might be due to invalid IL or missing references)
//IL_0392: Expected O, but got Unknown
//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0406: Expected O, but got Unknown
//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
//IL_030d: Expected O, but got Unknown
Harmony val = new Harmony("sbg.voicegrunts");
int num = 0;
try
{
MethodInfo methodInfo = AccessTools.Method(typeof(PlayerAudio), "PlaySwingInternal", new Type[2]
{
typeof(float),
typeof(bool)
}, (Type[])null);
if (methodInfo == null)
{
Log.LogError((object)"Could not find PlayerAudio.PlaySwingInternal(float, bool)");
}
else
{
val.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(SwingGruntPatch), "StripEncodedPackPrefix", (Type[])null), new HarmonyMethod(typeof(SwingGruntPatch), "Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Log.LogInfo((object)"Patched PlayerAudio.PlaySwingInternal (swing grunt layer)");
num++;
}
}
catch (Exception arg)
{
Log.LogError((object)$"Failed to patch PlayerAudio swing hook: {arg}");
}
try
{
MethodInfo methodInfo2 = AccessTools.Method(typeof(PlayerAudio), "PlayJumpInternal", (Type[])null, (Type[])null);
if (methodInfo2 == null)
{
Log.LogError((object)"Could not find PlayerAudio.PlayJumpInternal()");
}
else
{
val.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(JumpGruntPatch), "Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Log.LogInfo((object)"Patched PlayerAudio.PlayJumpInternal (jump grunt layer)");
num++;
}
}
catch (Exception arg2)
{
Log.LogError((object)$"Failed to patch PlayerAudio jump hook: {arg2}");
}
try
{
MethodInfo methodInfo3 = AccessTools.Method(typeof(PlayerAudio), "CmdPlaySwingForAllClients", new Type[3]
{
typeof(float),
typeof(bool),
typeof(NetworkConnectionToClient)
}, (Type[])null);
if (methodInfo3 == null)
{
Log.LogWarning((object)"Could not find PlayerAudio.CmdPlaySwingForAllClients for voice pack sync");
}
else
{
val.Patch((MethodBase)methodInfo3, new HarmonyMethod(typeof(SwingNetworkPatch), "CmdPlaySwingPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Log.LogInfo((object)"Patched PlayerAudio.CmdPlaySwingForAllClients (voice pack capture on server)");
num++;
}
}
catch (Exception arg3)
{
Log.LogError((object)$"Failed to patch PlayerAudio CmdPlaySwing hook: {arg3}");
}
try
{
MethodInfo methodInfo4 = AccessTools.Method(typeof(PlayerAudio), "PlaySwingForAllClients", new Type[2]
{
typeof(float),
typeof(bool)
}, (Type[])null);
if (methodInfo4 == null)
{
Log.LogWarning((object)"Could not find PlayerAudio.PlaySwingForAllClients(float, bool) for voice pack sync");
}
else
{
val.Patch((MethodBase)methodInfo4, new HarmonyMethod(typeof(SwingNetworkPatch), "EncodeLocalPackPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Log.LogInfo((object)"Patched PlayerAudio.PlaySwingForAllClients (voice pack piggyback)");
num++;
}
}
catch (Exception arg4)
{
Log.LogError((object)$"Failed to patch PlayerAudio swing network hook: {arg4}");
}
try
{
MethodInfo methodInfo5 = typeof(PlayerAudio).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo m) => m.Name == "RpcPlaySwing" && m.GetParameters().Length == 3 && m.GetParameters()[1].ParameterType == typeof(float));
if (methodInfo5 == null)
{
Log.LogWarning((object)"Could not find PlayerAudio.RpcPlaySwing for voice pack sync");
}
else
{
val.Patch((MethodBase)methodInfo5, new HarmonyMethod(typeof(SwingNetworkPatch), "DecodeRemotePackPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Log.LogInfo((object)"Patched PlayerAudio.RpcPlaySwing (voice pack piggyback)");
num++;
}
}
catch (Exception arg5)
{
Log.LogError((object)$"Failed to patch PlayerAudio RpcPlaySwing hook: {arg5}");
}
try
{
MethodInfo methodInfo6 = AccessTools.Method(typeof(PlayerAudio), "StartKnockoutLoopLocalOnly", (Type[])null, (Type[])null);
if (methodInfo6 == null)
{
Log.LogWarning((object)"Could not find PlayerAudio.StartKnockoutLoopLocalOnly for knocked grunt layer");
}
else
{
val.Patch((MethodBase)methodInfo6, (HarmonyMethod)null, new HarmonyMethod(typeof(KnockedGruntPatch), "Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Log.LogInfo((object)"Patched PlayerAudio.StartKnockoutLoopLocalOnly (knocked grunt sync for all clients)");
num++;
}
}
catch (Exception arg6)
{
Log.LogError((object)$"Failed to patch PlayerAudio StartKnockoutLoopLocalOnly hook: {arg6}");
}
try
{
MethodInfo methodInfo7 = AccessTools.Method(typeof(BNetworkManager), "OnStopClient", (Type[])null, (Type[])null);
if (methodInfo7 != null)
{
val.Patch((MethodBase)methodInfo7, (HarmonyMethod)null, new HarmonyMethod(typeof(NetworkLifecyclePatch), "OnNetworkStoppedPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
num++;
Log.LogInfo((object)"Patched BNetworkManager.OnStopClient (voice pack registry reset)");
}
}
catch (Exception arg7)
{
Log.LogError((object)$"Failed to patch BNetworkManager.OnStopClient: {arg7}");
}
Log.LogInfo((object)((num == 0) ? "No Harmony patches were applied." : $"Applied {num} Harmony patch(es)."));
try
{
val.PatchAll(typeof(GruntClipNetworkSync).Assembly);
Log.LogInfo((object)"Applied jump/knock clip sync Harmony patches.");
}
catch (Exception arg8)
{
Log.LogError((object)$"PatchAll failed (swing/jump/knock grunts may be partially broken): {arg8}");
}
}
private void Start()
{
try
{
string text = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "Sounds");
if (!Directory.Exists(text))
{
Log.LogError((object)("Sounds folder missing: " + text));
}
else
{
LoadAllVoicePools(text);
}
}
catch (Exception arg)
{
Log.LogError((object)$"Start failed: {arg}");
}
}
private static void LoadAllVoicePools(string soundsDir)
{
_swingPools.Clear();
_jumpPools.Clear();
_knockedPools.Clear();
_installedPackCount = 0;
foreach (int item2 in DiscoverPackIds(soundsDir))
{
_installedPackCount = Mathf.Max(_installedPackCount, item2);
string text = "VoicePack" + item2;
string text2 = Path.Combine(soundsDir, text);
if (!Directory.Exists(text2))
{
continue;
}
VoicePackNames.LoadFromPackFolder(item2, text2);
(string, float)[] swingPowerTiers = SwingPowerTiers;
for (int i = 0; i < swingPowerTiers.Length; i++)
{
string item = swingPowerTiers[i].Item1;
string path = Path.Combine(text2, item.Replace('/', Path.DirectorySeparatorChar));
if (!Directory.Exists(path))
{
continue;
}
List<string> list = Directory.EnumerateFiles(path, "*.*", SearchOption.AllDirectories).Where(IsSupportedAudioFile).OrderBy<string, string>((string result) => result, StringComparer.OrdinalIgnoreCase)
.ToList();
if (list.Count == 0)
{
continue;
}
string text3 = text + "/" + item;
List<SoundVariant> list2 = new List<SoundVariant>();
foreach (string item3 in list)
{
if (TryLoadVariant(soundsDir, item3, out var variant))
{
list2.Add(variant);
}
}
if (list2.Count <= 0)
{
continue;
}
_swingPools[text3] = list2;
Log.LogInfo((object)$"Loaded {text3} ({list2.Count} clip(s))");
foreach (SoundVariant item4 in list2)
{
Log.LogInfo((object)(" - " + item4.RelativePath));
}
}
LoadSimplePool(soundsDir, text2, text, item2, "JumpGrunt", _jumpPools);
LoadSimplePool(soundsDir, text2, text, item2, "Knocked", _knockedPools);
}
_poolsReady = _swingPools.Count > 0 || _jumpPools.Count > 0 || _knockedPools.Count > 0;
if (!_poolsReady)
{
Log.LogError((object)"No voice pack audio could be loaded.");
}
else
{
Log.LogInfo((object)$"Voice packs installed: 1–{_installedPackCount} (max selectable: {9})");
}
}
private static IEnumerable<int> DiscoverPackIds(string soundsDir)
{
if (!Directory.Exists(soundsDir))
{
yield break;
}
List<int> list = new List<int>();
string[] directories = Directory.GetDirectories(soundsDir);
for (int i = 0; i < directories.Length; i++)
{
string fileName = Path.GetFileName(directories[i]);
if (!fileName.StartsWith("VoicePack", StringComparison.OrdinalIgnoreCase) || !int.TryParse(fileName.Substring("VoicePack".Length), out var result))
{
continue;
}
if (result < 1 || result > 9)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogWarning((object)$"Ignoring {fileName}: pack id must be 1–{9}.");
}
}
else
{
list.Add(result);
}
}
list.Sort();
foreach (int item in list)
{
yield return item;
}
}
private static void LoadSimplePool(string soundsDir, string packRootPath, string packRootName, int packId, string poolFolderName, Dictionary<int, List<SoundVariant>> targetPools)
{
string path = Path.Combine(packRootPath, poolFolderName);
if (!Directory.Exists(path))
{
return;
}
List<string> list = Directory.EnumerateFiles(path, "*.*", SearchOption.AllDirectories).Where(IsSupportedAudioFile).OrderBy<string, string>((string result) => result, StringComparer.OrdinalIgnoreCase)
.ToList();
List<SoundVariant> list2 = new List<SoundVariant>();
foreach (string item in list)
{
if (TryLoadVariant(soundsDir, item, out var variant))
{
list2.Add(variant);
}
}
if (list2.Count <= 0)
{
return;
}
targetPools[packId] = list2;
Log.LogInfo((object)$"Loaded {packRootName}/{poolFolderName} ({list2.Count} clip(s))");
foreach (SoundVariant item2 in list2)
{
Log.LogInfo((object)(" - " + item2.RelativePath));
}
}
private static bool TryLoadVariant(string soundsDir, string audioPath, out SoundVariant variant)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
variant = null;
string relativePath = GetRelativePath(soundsDir, audioPath);
System coreSystem = RuntimeManager.CoreSystem;
Sound sound2D = default(Sound);
RESULT val = ((System)(ref coreSystem)).createSound(audioPath, (MODE)256, ref sound2D);
if ((int)val != 0)
{
Log.LogError((object)$"FMOD createSound (2D) failed for {relativePath}: {val}");
return false;
}
Sound sound3D = default(Sound);
RESULT val2 = ((System)(ref coreSystem)).createSound(audioPath, (MODE)2097424, ref sound3D);
if ((int)val2 != 0)
{
Log.LogError((object)$"FMOD createSound (3D) failed for {relativePath}: {val2}");
((Sound)(ref sound2D)).release();
return false;
}
((Sound)(ref sound3D)).set3DMinMaxDistance(8f, 60f);
variant = new SoundVariant
{
RelativePath = relativePath,
Sound2D = sound2D,
Sound3D = sound3D
};
return true;
}
private static bool IsSupportedAudioFile(string path)
{
string ext = Path.GetExtension(path);
return SupportedExtensions.Any((string supported) => string.Equals(ext, supported, StringComparison.OrdinalIgnoreCase));
}
private static string GetRelativePath(string rootDir, string fullPath)
{
return fullPath.Substring(rootDir.Length).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar).Replace('\\', '/');
}
private static string GetSwingTierFolder(float normalizedPower)
{
float num = Mathf.Clamp01(normalizedPower);
(string, float)[] swingPowerTiers = SwingPowerTiers;
for (int i = 0; i < swingPowerTiers.Length; i++)
{
var (result, num2) = swingPowerTiers[i];
if (num <= num2)
{
return result;
}
}
return SwingPowerTiers[SwingPowerTiers.Length - 1].TierFolder;
}
private static int ResolveVoicePackId(int requestedPackId)
{
int num = Mathf.Clamp(requestedPackId, 1, 9);
if (PackHasAnyClips(num))
{
return num;
}
if (num != 1 && PackHasAnyClips(1))
{
ManualLogSource log = Log;
if (log != null)
{
log.LogWarning((object)$"Voice pack {num} is not installed locally; falling back to VoicePack1.");
}
return 1;
}
return num;
}
private static bool PackHasAnyClips(int packId)
{
if (!_swingPools.Keys.Any((string k) => k.StartsWith("VoicePack" + packId + "/", StringComparison.OrdinalIgnoreCase)) && !_jumpPools.ContainsKey(packId))
{
return _knockedPools.ContainsKey(packId);
}
return true;
}
private static SoundVariant PickSwingGrunt(int voicePackId, float normalizedPower, int clipIndex = -1)
{
string text = "VoicePack" + ResolveVoicePackId(voicePackId) + "/" + GetSwingTierFolder(normalizedPower);
if (_swingPools.TryGetValue(text, out var value) && value.Count > 0)
{
int index = ((clipIndex >= 0) ? (clipIndex % value.Count) : _rng.Next(value.Count));
return value[index];
}
ManualLogSource log = Log;
if (log != null)
{
log.LogDebug((object)("No swing clips for " + text));
}
return null;
}
private static int PickSwingClipIndex(int voicePackId, float normalizedPower)
{
string key = "VoicePack" + ResolveVoicePackId(voicePackId) + "/" + GetSwingTierFolder(normalizedPower);
if (_swingPools.TryGetValue(key, out var value) && value.Count > 0)
{
return _rng.Next(value.Count);
}
return 0;
}
internal static int PickJumpClipIndex(int voicePackId)
{
int key = ResolveVoicePackId(voicePackId);
if (_jumpPools.TryGetValue(key, out var value) && value.Count > 0)
{
return _rng.Next(value.Count);
}
return 0;
}
private static SoundVariant PickJumpGrunt(int voicePackId, int clipIndex = -1)
{
int num = ResolveVoicePackId(voicePackId);
if (_jumpPools.TryGetValue(num, out var value) && value.Count > 0)
{
int index = ((clipIndex >= 0) ? (clipIndex % value.Count) : _rng.Next(value.Count));
return value[index];
}
ManualLogSource log = Log;
if (log != null)
{
log.LogDebug((object)$"No jump clips for VoicePack{num}");
}
return null;
}
internal static int PickKnockedClipIndex(int voicePackId)
{
int key = ResolveVoicePackId(voicePackId);
if (_knockedPools.TryGetValue(key, out var value) && value.Count > 0)
{
return _rng.Next(value.Count);
}
return 0;
}
private static int PickKnockedClipIndexFromMovement(PlayerMovement movement, int voicePackId)
{
if ((Object)(object)movement == (Object)null || KnockedOutVfxDataProperty == null || KnockedOutTotalStarCountField == null || KnockedOutColoredStarCountField == null)
{
return -1;
}
object value = KnockedOutVfxDataProperty.GetValue(movement, null);
if (value == null)
{
return -1;
}
int num = (int)KnockedOutTotalStarCountField.GetValue(value);
int num2 = (int)KnockedOutColoredStarCountField.GetValue(value);
int key = ResolveVoicePackId(voicePackId);
if (!_knockedPools.TryGetValue(key, out var value2) || value2.Count == 0)
{
return 0;
}
return Math.Abs(num * 31 + num2) % value2.Count;
}
private static SoundVariant PickKnockedGrunt(int voicePackId, int clipIndex = -1)
{
int num = ResolveVoicePackId(voicePackId);
if (_knockedPools.TryGetValue(num, out var value) && value.Count > 0)
{
int index = ((clipIndex >= 0) ? (clipIndex % value.Count) : _rng.Next(value.Count));
return value[index];
}
ManualLogSource log = Log;
if (log != null)
{
log.LogDebug((object)$"No knocked clips for VoicePack{num}");
}
return null;
}
private static void PlayGruntForPlayer(PlayerAudio playerAudio, SoundVariant variant)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
if (variant != null && !((Object)(object)playerAudio == (Object)null))
{
Vector3 worldPosition = ((Component)playerAudio).transform.position + Vector3.up * 0.9f;
if (IsLocalPlayer(playerAudio))
{
PlayLocal2D(variant);
}
else
{
PlayLayered3D(variant, worldPosition);
}
}
}
private static void PlayLocal2D(SoundVariant variant)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
if (variant == null)
{
return;
}
try
{
System coreSystem = RuntimeManager.CoreSystem;
Channel channel = default(Channel);
RESULT val = ((System)(ref coreSystem)).playSound(variant.Sound2D, default(ChannelGroup), false, ref channel);
if ((int)val != 0)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogWarning((object)$"playSound 2D ({variant.RelativePath}): {val}");
}
}
else
{
AnnouncerAudio.ApplyToChannel(channel);
}
}
catch (Exception arg)
{
ManualLogSource log2 = Log;
if (log2 != null)
{
log2.LogError((object)$"PlayLocal2D failed: {arg}");
}
}
}
private static void PlayLayered3D(SoundVariant variant, Vector3 worldPosition)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
if (variant == null)
{
return;
}
try
{
System coreSystem = RuntimeManager.CoreSystem;
Channel channel = default(Channel);
RESULT val = ((System)(ref coreSystem)).playSound(variant.Sound3D, default(ChannelGroup), true, ref channel);
if ((int)val != 0)
{
ManualLogSource log = Log;
if (log != null)
{
log.LogWarning((object)$"playSound 3D ({variant.RelativePath}): {val}");
}
}
else
{
((Channel)(ref channel)).setMode((MODE)2097168);
((Channel)(ref channel)).set3DMinMaxDistance(8f, 60f);
VECTOR val2 = RuntimeUtils.ToFMODVector(worldPosition);
VECTOR val3 = RuntimeUtils.ToFMODVector(Vector3.zero);
((Channel)(ref channel)).set3DAttributes(ref val2, ref val3);
AnnouncerAudio.ApplyToChannel(channel);
((Channel)(ref channel)).setPaused(false);
}
}
catch (Exception arg)
{
ManualLogSource log2 = Log;
if (log2 != null)
{
log2.LogError((object)$"PlayLayered3D failed: {arg}");
}
}
}
internal static bool IsLocalPlayer(PlayerAudio playerAudio)
{
if ((Object)(object)playerAudio != (Object)null && ((NetworkBehaviour)playerAudio).isLocalPlayer)
{
return true;
}
PlayerGolfer localPlayerAsGolfer = GameManager.LocalPlayerAsGolfer;
if ((Object)(object)localPlayerAsGolfer != (Object)null && (Object)(object)playerAudio != (Object)null)
{
return (Object)(object)((Component)playerAudio).gameObject == (Object)(object)((Component)localPlayerAsGolfer).gameObject;
}
return false;
}
}
internal static class VoicePackNames
{
private const string DisplayNameFileName = "displayname.txt";
private static readonly Dictionary<int, string> FileNamesByPackId = new Dictionary<int, string>();
private static ConfigEntry<string>[] _configOverrides;
internal static void Initialize(ConfigFile config)
{
_configOverrides = new ConfigEntry<string>[10];
for (int i = 1; i <= 9; i++)
{
int num = i;
_configOverrides[num] = config.Bind<string>("DisplayNames", $"Pack{num}", string.Empty, string.Format("Overlay label for VoicePack{0}. Leave empty to use Sounds/VoicePack{1}/{2} or the default folder name.", num, num, "displayname.txt"));
}
}
internal static void LoadFromPackFolder(int packId, string packRootPath)
{
if (packId < 1 || packId > 9)
{
return;
}
string path = Path.Combine(packRootPath, "displayname.txt");
if (!File.Exists(path))
{
FileNamesByPackId.Remove(packId);
return;
}
string text = File.ReadAllText(path).Trim();
if (string.IsNullOrWhiteSpace(text))
{
FileNamesByPackId.Remove(packId);
return;
}
FileNamesByPackId[packId] = text;
ManualLogSource log = Plugin.Log;
if (log != null)
{
log.LogInfo((object)$"VoicePack{packId} display name: {text}");
}
}
internal static string GetDisplayName(int packId)
{
packId = Math.Max(1, Math.Min(packId, 9));
ConfigEntry<string>[] configOverrides = _configOverrides;
string text = ((configOverrides == null) ? null : configOverrides[packId]?.Value?.Trim());
if (!string.IsNullOrWhiteSpace(text))
{
return text;
}
if (FileNamesByPackId.TryGetValue(packId, out var value) && !string.IsNullOrWhiteSpace(value))
{
return value;
}
return "VoicePack" + packId;
}
}
internal sealed class VoicePackOverlay : MonoBehaviour
{
[CompilerGenerated]
private static class <>O
{
public static WindowFunction <0>__DrawWindow;
}
private static VoicePackOverlay _instance;
private static ConfigEntry<KeyboardShortcut> _overlayHotkey;
private static readonly KeyboardShortcut CloseOverlayKey = new KeyboardShortcut((KeyCode)27, Array.Empty<KeyCode>());
private const int CursorRestoreFrames = 8;
private bool _visible;
private Rect _windowRect = new Rect(20f, 80f, 260f, 0f);
private bool _cursorWasVisible;
private CursorLockMode _previousLockState;
private int _cursorRestoreFramesRemaining;
internal static void Initialize(ConfigFile config)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
_overlayHotkey = config.Bind<KeyboardShortcut>("UI", "OverlayHotkey", new KeyboardShortcut((KeyCode)283, Array.Empty<KeyCode>()), "Toggle the in-game voice pack picker overlay.");
if (!((Object)(object)_instance != (Object)null))
{
GameObject val = new GameObject("VoiceGruntsOverlay");
Object.DontDestroyOnLoad((Object)val);
_instance = val.AddComponent<VoicePackOverlay>();
}
}
private void Update()
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
KeyboardShortcut val;
if (_overlayHotkey != null)
{
val = _overlayHotkey.Value;
if (((KeyboardShortcut)(ref val)).IsDown())
{
SetVisible(!_visible);
}
}
if (_visible)
{
val = CloseOverlayKey;
if (((KeyboardShortcut)(ref val)).IsDown())
{
SetVisible(visible: false);
}
}
}
private void LateUpdate()
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
if (!_visible && _cursorRestoreFramesRemaining > 0)
{
_cursorRestoreFramesRemaining--;
GameCursor.RestoreAfterOverlay(_cursorWasVisible, _previousLockState);
}
}
private void OnDestroy()
{
if (_visible)
{
SetVisible(visible: false);
}
}
private void SetVisible(bool visible)
{
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
if (_visible != visible)
{
_visible = visible;
if (_visible)
{
_cursorRestoreFramesRemaining = 0;
_cursorWasVisible = Cursor.visible;
_previousLockState = Cursor.lockState;
GameCursor.SetOverlayOpen(open: true);
}
else
{
GameCursor.RestoreAfterOverlay(_cursorWasVisible, _previousLockState);
_cursorRestoreFramesRemaining = 8;
}
}
}
private void OnGUI()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
if (_visible)
{
Rect windowRect = _windowRect;
object obj = <>O.<0>__DrawWindow;
if (obj == null)
{
WindowFunction val = DrawWindow;
<>O.<0>__DrawWindow = val;
obj = (object)val;
}
_windowRect = GUILayout.Window(22087, windowRect, (WindowFunction)obj, "uhm — VoiceGrunts", Array.Empty<GUILayoutOption>());
}
}
private static void DrawWindow(int windowId)
{
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
string packDisplayName = Plugin.GetPackDisplayName(Plugin.SelectedVoicePack);
GUILayout.Label("Current pack: " + packDisplayName, Array.Empty<GUILayoutOption>());
GUILayout.Label($"Installed: 1–{Mathf.Max(1, Plugin.InstalledPackCount)}", Array.Empty<GUILayoutOption>());
GUILayout.Space(6f);
int num = Mathf.Max(1, Plugin.InstalledPackCount);
for (int i = 1; i <= num; i++)
{
bool num2 = i == Plugin.SelectedVoicePack;
string packDisplayName2 = Plugin.GetPackDisplayName(i);
GUI.backgroundColor = (Color)(num2 ? new Color(0.55f, 0.85f, 0.55f) : Color.white);
if (GUILayout.Button(num2 ? (packDisplayName2 + " (active)") : packDisplayName2, Array.Empty<GUILayoutOption>()))
{
Plugin.SetSelectedVoicePack(i);
}
}
GUI.backgroundColor = Color.white;
GUILayout.Space(6f);
GUILayout.Label("Press F2 or Esc to close", Array.Empty<GUILayoutOption>());
GUI.DragWindow();
}
}
internal static class VoicePackRegistry
{
private const int PowerScale = 1000;
private const int PackScale = 10;
private const int VariantScale = 100;
private const float EncodeDivisor = 100000f;
private static readonly Dictionary<ulong, int> PackByGuid = new Dictionary<ulong, int>();
private static readonly Dictionary<ulong, int> PendingSwingClipIndexByGuid = new Dictionary<ulong, int>();
private static readonly Dictionary<ulong, int> PendingJumpClipIndexByGuid = new Dictionary<ulong, int>();
private static readonly Dictionary<ulong, int> PendingKnockedClipIndexByGuid = new Dictionary<ulong, int>();
private static readonly Dictionary<uint, int> RpcJumpClipIndexByNetId = new Dictionary<uint, int>();
internal static void Clear()
{
PackByGuid.Clear();
PendingSwingClipIndexByGuid.Clear();
PendingJumpClipIndexByGuid.Clear();
PendingKnockedClipIndexByGuid.Clear();
RpcJumpClipIndexByNetId.Clear();
}
internal static int GetPack(ulong playerGuid)
{
if (playerGuid == 0L)
{
return 1;
}
if (!PackByGuid.TryGetValue(playerGuid, out var value))
{
return 1;
}
return value;
}
internal static void SetPack(ulong playerGuid, int packId)
{
if (playerGuid != 0L)
{
PackByGuid[playerGuid] = Mathf.Clamp(packId, 1, 9);
}
}
internal static void SetPendingClipIndex(GruntEventKind kind, ulong playerGuid, int clipIndex)
{
if (playerGuid != 0L)
{
clipIndex = Mathf.Max(0, clipIndex);
switch (kind)
{
case GruntEventKind.Jump:
PendingJumpClipIndexByGuid[playerGuid] = clipIndex;
break;
case GruntEventKind.Knocked:
PendingKnockedClipIndexByGuid[playerGuid] = clipIndex;
break;
}
}
}
internal static bool TryPeekPendingClipIndex(GruntEventKind kind, ulong playerGuid, out int clipIndex)
{
clipIndex = 0;
if (playerGuid == 0L)
{
return false;
}
return GetPendingMap(kind)?.TryGetValue(playerGuid, out clipIndex) ?? false;
}
internal static bool TryConsumePendingClipIndex(GruntEventKind kind, ulong playerGuid, out int clipIndex)
{
clipIndex = -1;
if (playerGuid == 0L)
{
return false;
}
Dictionary<ulong, int> pendingMap = GetPendingMap(kind);
if (pendingMap != null && pendingMap.TryGetValue(playerGuid, out clipIndex))
{
pendingMap.Remove(playerGuid);
return true;
}
clipIndex = -1;
return false;
}
internal static void SetPendingSwingClipIndex(ulong playerGuid, int clipIndex)
{
if (playerGuid != 0L)
{
PendingSwingClipIndexByGuid[playerGuid] = Mathf.Max(0, clipIndex);
}
}
internal static bool TryGetPendingSwingClipIndex(ulong playerGuid, out int clipIndex)
{
if (playerGuid == 0L)
{
clipIndex = 0;
return false;
}
return PendingSwingClipIndexByGuid.TryGetValue(playerGuid, out clipIndex);
}
internal static bool TryConsumePendingSwingClipIndex(ulong playerGuid, out int clipIndex)
{
if (playerGuid == 0L)
{
clipIndex = -1;
return false;
}
if (PendingSwingClipIndexByGuid.TryGetValue(playerGuid, out clipIndex))
{
PendingSwingClipIndexByGuid.Remove(playerGuid);
return true;
}
clipIndex = -1;
return false;
}
internal static void SetRpcJumpClipIndex(uint netId, int clipIndex)
{
RpcJumpClipIndexByNetId[netId] = Mathf.Max(0, clipIndex);
}
internal static bool TryTakeRpcJumpClipIndex(uint netId, out int clipIndex)
{
if (RpcJumpClipIndexByNetId.TryGetValue(netId, out clipIndex))
{
RpcJumpClipIndexByNetId.Remove(netId);
return true;
}
clipIndex = 0;
return false;
}
internal static bool LooksEncoded(float encodedPower)
{
if (!TryDecode(encodedPower, out var _, out var packId, out var _))
{
return false;
}
if (packId >= 1)
{
return packId <= 9;
}
return false;
}
internal static float EncodeSwing(float normalizedPower, int packId, int clipIndex)
{
int num = Mathf.Clamp(Mathf.RoundToInt(Mathf.Clamp01(normalizedPower) * 1000f), 0, 1000);
packId = Mathf.Clamp(packId, 1, 9);
clipIndex = Mathf.Clamp(clipIndex, 0, 9);
return (float)(num * 100 + clipIndex * 10 + packId) / 100000f;
}
internal static float StripPackFromPower(float encodedPower)
{
TryDecode(encodedPower, out var normalizedPower, out var _, out var _);
return normalizedPower;
}
internal static int DecodeClipIndexFromPower(float encodedPower)
{
TryDecode(encodedPower, out var _, out var _, out var clipIndex);
return clipIndex;
}
internal static void CaptureFromEncodedPower(ulong playerGuid, float encodedPower)
{
if (LooksEncoded(encodedPower))
{
SetPack(playerGuid, DecodePackFromPower(encodedPower));
SetPendingSwingClipIndex(playerGuid, DecodeClipIndexFromPower(encodedPower));
}
}
internal static int DecodePackFromPower(float encodedPower)
{
TryDecode(encodedPower, out var _, out var packId, out var _);
return packId;
}
private static Dictionary<ulong, int> GetPendingMap(GruntEventKind kind)
{
return kind switch
{
GruntEventKind.Jump => PendingJumpClipIndexByGuid,
GruntEventKind.Knocked => PendingKnockedClipIndexByGuid,
_ => null,
};
}
private static bool TryDecode(float encodedPower, out float normalizedPower, out int packId, out int clipIndex)
{
int num = Mathf.RoundToInt(encodedPower * 100000f);
packId = num % 10;
clipIndex = num / 10 % 10;
int num2 = num / 100;
normalizedPower = Mathf.Clamp01((float)num2 / 1000f);
if (packId < 1 || packId > 9)
{
packId = 1;
return false;
}
return true;
}
}
}
