using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using Microsoft.CodeAnalysis;
using Steamworks;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using com.github.zehsteam.MilkButton.Dependencies.LethalConfigMod;
using com.github.zehsteam.MilkButton.Extensions;
using com.github.zehsteam.MilkButton.Helpers;
using com.github.zehsteam.MilkButton.Managers;
using com.github.zehsteam.MilkButton.MonoBehaviours;
using com.github.zehsteam.MilkButton.NetcodePatcher;
using com.github.zehsteam.MilkButton.Objects;
using com.github.zehsteam.MilkButton.Patches;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Zehs")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2026 Zehs")]
[assembly: AssemblyDescription("Adds the milk button from Insym's dream.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+d033e691eb7af52fb51a646888802e90380aa897")]
[assembly: AssemblyProduct("MilkButton")]
[assembly: AssemblyTitle("com.github.zehsteam.MilkButton")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.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 com.github.zehsteam.MilkButton
{
internal static class Assets
{
public static readonly string AssetBundleFileName = "milkbutton_assets";
public static AssetBundle AssetBundle { get; private set; }
public static GameObject PluginNetworkHandlerPrefab { get; private set; }
public static GameObject VoiceControllerPrefab { get; private set; }
public static GameObject PluginCanvasPrefab { get; private set; }
public static void Load()
{
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string text = Path.Combine(directoryName, AssetBundleFileName);
if (!File.Exists(text))
{
Logger.LogFatal("Failed to load assets. AssetBundle file could not be found at path \"" + text + "\". Make sure the \"" + AssetBundleFileName + "\" file is in the same folder as the mod's DLL file.");
}
else
{
AssetBundle = AssetBundle.LoadFromFile(text);
if ((Object)(object)AssetBundle == (Object)null)
{
Logger.LogFatal("Failed to load assets. AssetBundle is null.");
}
else
{
OnAssetBundleLoaded(AssetBundle);
}
}
}
private static void OnAssetBundleLoaded(AssetBundle assetBundle)
{
PluginNetworkHandlerPrefab = LoadAsset<GameObject>("PluginNetworkHandler", assetBundle);
VoiceControllerPrefab = LoadAsset<GameObject>("VoiceController", assetBundle);
PluginCanvasPrefab = LoadAsset<GameObject>("PluginCanvas", assetBundle);
}
private static T LoadAsset<T>(string name, AssetBundle assetBundle) where T : Object
{
if (string.IsNullOrWhiteSpace(name))
{
Logger.LogError("Failed to load asset of type \"" + typeof(T).Name + "\" from AssetBundle. Name is null or whitespace.");
return default(T);
}
if ((Object)(object)assetBundle == (Object)null)
{
Logger.LogError("Failed to load asset of type \"" + typeof(T).Name + "\" with name \"" + name + "\" from AssetBundle. AssetBundle is null.");
return default(T);
}
T val = assetBundle.LoadAsset<T>(name);
if ((Object)(object)val == (Object)null)
{
Logger.LogError("Failed to load asset of type \"" + typeof(T).Name + "\" with name \"" + name + "\" from AssetBundle. No asset found with that type and name.");
return default(T);
}
return val;
}
private static bool TryLoadAsset<T>(string name, AssetBundle assetBundle, out T asset) where T : Object
{
asset = LoadAsset<T>(name, assetBundle);
return (Object)(object)asset != (Object)null;
}
}
internal static class Logger
{
public static ManualLogSource ManualLogSource { get; private set; }
public static bool IsExtendedLoggingEnabled => ConfigManager.Misc_ExtendedLogging?.Value ?? false;
public static void Initialize(ManualLogSource manualLogSource)
{
ManualLogSource = manualLogSource;
}
public static void LogDebug(object data)
{
Log((LogLevel)32, data);
}
public static void LogInfo(object data, bool extended = false)
{
Log((LogLevel)16, data, extended);
}
public static void LogMessage(object data, bool extended = false)
{
Log((LogLevel)8, data, extended);
}
public static void LogWarning(object data, bool extended = false)
{
Log((LogLevel)4, data, extended);
}
public static void LogError(object data, bool extended = false)
{
Log((LogLevel)2, data, extended);
}
public static void LogFatal(object data, bool extended = false)
{
Log((LogLevel)1, data, extended);
}
public static void Log(LogLevel logLevel, object data, bool extended = false)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
if (!extended || IsExtendedLoggingEnabled)
{
ManualLogSource manualLogSource = ManualLogSource;
if (manualLogSource != null)
{
manualLogSource.Log(logLevel, data);
}
}
}
}
[BepInPlugin("com.github.zehsteam.MilkButton", "MilkButton", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
internal class Plugin : BaseUnityPlugin
{
private readonly Harmony _harmony = new Harmony("com.github.zehsteam.MilkButton");
internal static Plugin Instance { get; private set; }
private void Awake()
{
Instance = this;
Logger.Initialize(Logger.CreateLogSource("com.github.zehsteam.MilkButton"));
Logger.LogInfo("MilkButton has awoken!");
_harmony.PatchAll(typeof(GameNetworkManager_Patches));
_harmony.PatchAll(typeof(StartOfRound_Patches));
_harmony.PatchAll(typeof(HUDManager_Patches));
_harmony.PatchAll(typeof(PlayerControllerB_Patches));
Assets.Load();
ConfigManager.Initialize(((BaseUnityPlugin)this).Config);
NetworkUtils.NetcodePatcherAwake();
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "com.github.zehsteam.MilkButton";
public const string PLUGIN_NAME = "MilkButton";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace com.github.zehsteam.MilkButton.Patches
{
[HarmonyPatch(typeof(GameNetworkManager))]
internal static class GameNetworkManager_Patches
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void Start_Patch()
{
AddNetworkPrefabs();
}
private static void AddNetworkPrefabs()
{
NetworkUtils.AddNetworkPrefab(Assets.PluginNetworkHandlerPrefab);
NetworkUtils.AddNetworkPrefab(Assets.VoiceControllerPrefab);
}
}
[HarmonyPatch(typeof(HUDManager))]
internal static class HUDManager_Patches
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void Start_Patch()
{
PluginCanvas.Spawn();
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal static class PlayerControllerB_Patches
{
private static bool _wasLocalPlayerDead;
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void Start_Patch(PlayerControllerB __instance)
{
if (NetworkUtils.IsServer)
{
VoiceController.Spawn_Server(__instance);
}
}
[HarmonyPatch("OnDestroy")]
[HarmonyPrefix]
private static void OnDestroy_Patch(PlayerControllerB __instance)
{
if (NetworkUtils.IsServer)
{
VoiceController.Despawn_Server(__instance);
}
}
[HarmonyPatch("KillPlayer")]
[HarmonyPrefix]
private static void KillPlayer_Prefix_Patch(PlayerControllerB __instance)
{
if (PlayerUtils.IsLocalPlayer(__instance))
{
_wasLocalPlayerDead = __instance.isPlayerDead;
}
}
[HarmonyPatch("KillPlayer")]
[HarmonyPostfix]
private static void KillPlayer_Postfix_Patch(PlayerControllerB __instance)
{
if (PlayerUtils.IsLocalPlayer(__instance) && !_wasLocalPlayerDead && __instance.isPlayerDead)
{
OnLocalPlayerDeath();
}
}
private static void OnLocalPlayerDeath()
{
if (ConfigManager.Button_Enabled.Value && CanActivateButton())
{
float value = ConfigManager.Button_ActivateChance.Value;
if (Utils.RollPercentChance(value))
{
PluginNetworkHandler.Instance?.ShowPanel_ServerRpc();
}
}
}
private static bool CanActivateButton()
{
if (NetworkUtils.IsServer && ConfigManager.Button_ActivateFromHost.Value)
{
return true;
}
if (ConfigManager.Button_ActivateFromEveryone.Value)
{
return true;
}
string name = SteamClient.Name;
if (ConfigManager.Button_ActivateFromPlayers_Collection.Contains(name.ToLower()))
{
return true;
}
return false;
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal static class StartOfRound_Patches
{
[HarmonyPatch("Awake")]
[HarmonyPostfix]
private static void Awake_Patch()
{
if (NetworkUtils.IsServer)
{
PluginNetworkHandler.Spawn_Server();
}
}
[HarmonyPatch("OnClientConnect")]
[HarmonyPostfix]
private static void OnClientConnect_Patch(ulong clientId)
{
if (NetworkUtils.IsServer)
{
VoiceController.OnClientConnect_Server(clientId);
}
}
[HarmonyPatch("ShipHasLeft")]
[HarmonyPostfix]
private static void ShipHasLeft_Patch()
{
if (NetworkUtils.IsServer)
{
PluginNetworkHandler.Instance?.HidePanel_ServerRpc();
}
}
}
}
namespace com.github.zehsteam.MilkButton.Objects
{
public class PlayerAudioGroup
{
public AudioSource VoiceAudio { get; private set; }
public AudioSource DeadAudio { get; private set; }
public bool IsPlaying => VoiceAudio.isPlaying;
public float Volume01
{
get
{
return VoiceAudio.volume;
}
set
{
VoiceAudio.volume = value;
DeadAudio.volume = value;
}
}
public float Pitch
{
get
{
return VoiceAudio.pitch;
}
set
{
VoiceAudio.pitch = value;
DeadAudio.pitch = value;
}
}
public float MaxDistance
{
get
{
return VoiceAudio.maxDistance;
}
set
{
VoiceAudio.maxDistance = value;
DeadAudio.maxDistance = value;
}
}
public AudioClip Clip
{
get
{
return VoiceAudio.clip;
}
set
{
VoiceAudio.clip = value;
DeadAudio.clip = value;
}
}
public bool Mute
{
get
{
if (VoiceAudio.mute)
{
return DeadAudio.mute;
}
return false;
}
set
{
VoiceAudio.mute = value;
DeadAudio.mute = value;
}
}
public PlayerAudioGroup(AudioSource voiceAudio, AudioSource deadAudio)
{
VoiceAudio = voiceAudio;
DeadAudio = deadAudio;
}
public void Play()
{
AudioSource voiceAudio = VoiceAudio;
if (voiceAudio != null)
{
voiceAudio.Play();
}
AudioSource deadAudio = DeadAudio;
if (deadAudio != null)
{
deadAudio.Play();
}
}
public void Pause()
{
AudioSource voiceAudio = VoiceAudio;
if (voiceAudio != null)
{
voiceAudio.Pause();
}
AudioSource deadAudio = DeadAudio;
if (deadAudio != null)
{
deadAudio.Pause();
}
}
public void Stop()
{
AudioSource voiceAudio = VoiceAudio;
if (voiceAudio != null)
{
voiceAudio.Stop();
}
AudioSource deadAudio = DeadAudio;
if (deadAudio != null)
{
deadAudio.Stop();
}
}
public void PlayOneShot(AudioClip clip)
{
AudioSource voiceAudio = VoiceAudio;
if (voiceAudio != null)
{
AudioSource voiceAudio2 = VoiceAudio;
voiceAudio.PlayOneShot(clip, (voiceAudio2 != null) ? voiceAudio2.volume : 1f);
}
AudioSource deadAudio = DeadAudio;
if (deadAudio != null)
{
AudioSource deadAudio2 = DeadAudio;
deadAudio.PlayOneShot(clip, (deadAudio2 != null) ? deadAudio2.volume : 1f);
}
}
public void PlayOneShot(AudioClip clip, float volumeScale)
{
AudioSource voiceAudio = VoiceAudio;
if (voiceAudio != null)
{
voiceAudio.PlayOneShot(clip, volumeScale);
}
AudioSource deadAudio = DeadAudio;
if (deadAudio != null)
{
deadAudio.PlayOneShot(clip, volumeScale);
}
}
}
}
namespace com.github.zehsteam.MilkButton.MonoBehaviours
{
public class ButtonController : MonoBehaviour
{
[CompilerGenerated]
private sealed class <PressAnimation>d__9 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public ButtonController <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <PressAnimation>d__9(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0030: 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)
//IL_0048: 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)
int num = <>1__state;
ButtonController buttonController = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
((Component)buttonController).transform.localScale = buttonController._originalScale;
<>2__current = buttonController.ScaleTo(buttonController._originalScale * buttonController._pressedScale, buttonController._animationDuration);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<>2__current = buttonController.ScaleTo(buttonController._originalScale, buttonController._animationDuration);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <ScaleTo>d__10 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public ButtonController <>4__this;
public float duration;
public Vector3 targetScale;
private Vector3 <startScale>5__2;
private float <elapsed>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ScaleTo>d__10(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
int num = <>1__state;
ButtonController buttonController = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
<startScale>5__2 = ((Component)buttonController).transform.localScale;
<elapsed>5__3 = 0f;
break;
case 1:
<>1__state = -1;
break;
}
if (<elapsed>5__3 < duration)
{
<elapsed>5__3 += Time.deltaTime;
float num2 = Mathf.SmoothStep(0f, 1f, <elapsed>5__3 / duration);
((Component)buttonController).transform.localScale = Vector3.Lerp(<startScale>5__2, targetScale, num2);
<>2__current = null;
<>1__state = 1;
return true;
}
((Component)buttonController).transform.localScale = targetScale;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private Vector3 _originalScale;
private float _pressedScale = 0.9f;
private float _animationDuration = 0.1f;
private InputAction _keyAction;
private void Awake()
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Expected O, but got Unknown
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
_keyAction = new InputAction((string)null, (InputActionType)0, "<Keyboard>/f", (string)null, (string)null, (string)null);
_keyAction.performed += delegate
{
OnClick();
};
_originalScale = ((Component)this).transform.localScale;
}
private void OnEnable()
{
_keyAction.Enable();
}
private void OnDisable()
{
_keyAction.Disable();
}
private void OnDestroy()
{
_keyAction.Disable();
_keyAction.Dispose();
}
private void OnClick()
{
VoiceController.LocalInstance?.PlaySound();
((MonoBehaviour)this).StopAllCoroutines();
((MonoBehaviour)this).StartCoroutine(PressAnimation());
}
[IteratorStateMachine(typeof(<PressAnimation>d__9))]
private IEnumerator PressAnimation()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <PressAnimation>d__9(0)
{
<>4__this = this
};
}
[IteratorStateMachine(typeof(<ScaleTo>d__10))]
private IEnumerator ScaleTo(Vector3 targetScale, float duration)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ScaleTo>d__10(0)
{
<>4__this = this,
targetScale = targetScale,
duration = duration
};
}
}
public class PluginCanvas : MonoBehaviour
{
[SerializeField]
private GameObject _panelObject;
public static PluginCanvas Instance { get; private set; }
public static void Spawn()
{
if (!((Object)(object)Instance != (Object)null))
{
Object.Instantiate<GameObject>(Assets.PluginCanvasPrefab);
}
}
private void Awake()
{
if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
{
Object.Destroy((Object)(object)((Component)this).gameObject);
return;
}
Instance = this;
((Object)((Component)this).gameObject).name = "MilkButton PluginCanvas";
Logger.LogInfo("Instantiated \"" + ((Object)((Component)this).gameObject).name + "\"", extended: true);
HidePanel();
}
public void ShowPanel()
{
if (ConfigManager.Button_Enabled.Value)
{
GameObject panelObject = _panelObject;
if (panelObject != null)
{
panelObject.SetActive(true);
}
}
}
public void HidePanel()
{
GameObject panelObject = _panelObject;
if (panelObject != null)
{
panelObject.SetActive(false);
}
}
public static void OnConfigSettingsChanged()
{
if (!ConfigManager.Button_Enabled.Value)
{
Instance?.HidePanel();
}
}
}
public class PluginNetworkHandler : NetworkBehaviour
{
public static PluginNetworkHandler Instance { get; private set; }
public static void Spawn_Server()
{
if (!((Object)(object)Instance != (Object)null))
{
GameObject val = Object.Instantiate<GameObject>(Assets.PluginNetworkHandlerPrefab);
val.GetComponent<NetworkObject>().Spawn(false);
}
}
private void Awake()
{
if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
{
Object.Destroy((Object)(object)((Component)this).gameObject);
return;
}
Instance = this;
((Object)((Component)this).gameObject).name = "MilkButton PluginNetworkHandler";
Logger.LogInfo("Instantiated \"" + ((Object)((Component)this).gameObject).name + "\"", extended: true);
}
public override void OnNetworkSpawn()
{
((NetworkBehaviour)this).OnNetworkSpawn();
if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
{
if (((NetworkBehaviour)this).IsServer)
{
((NetworkBehaviour)this).NetworkObject.Despawn(true);
}
}
else
{
Instance = this;
}
}
[ServerRpc(RequireOwnership = false)]
public void ShowPanel_ServerRpc()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
{
ServerRpcParams val = default(ServerRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4070705722u, val, (RpcDelivery)0);
((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4070705722u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
{
base.__rpc_exec_stage = (__RpcExecStage)0;
ShowPanel_ClientRpc();
}
}
}
[ClientRpc]
private void ShowPanel_ClientRpc()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(685052383u, val, (RpcDelivery)0);
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 685052383u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
{
base.__rpc_exec_stage = (__RpcExecStage)0;
PluginCanvas.Instance?.ShowPanel();
}
}
}
[ServerRpc(RequireOwnership = false)]
public void HidePanel_ServerRpc()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
{
ServerRpcParams val = default(ServerRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2874192403u, val, (RpcDelivery)0);
((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2874192403u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
{
base.__rpc_exec_stage = (__RpcExecStage)0;
HidePanel_ClientRpc();
}
}
}
[ClientRpc]
private void HidePanel_ClientRpc()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1854803255u, val, (RpcDelivery)0);
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1854803255u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
{
base.__rpc_exec_stage = (__RpcExecStage)0;
PluginCanvas.Instance?.HidePanel();
}
}
}
protected override void __initializeVariables()
{
((NetworkBehaviour)this).__initializeVariables();
}
protected override void __initializeRpcs()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Expected O, but got Unknown
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Expected O, but got Unknown
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Expected O, but got Unknown
((NetworkBehaviour)this).__registerRpc(4070705722u, new RpcReceiveHandler(__rpc_handler_4070705722), "ShowPanel_ServerRpc");
((NetworkBehaviour)this).__registerRpc(685052383u, new RpcReceiveHandler(__rpc_handler_685052383), "ShowPanel_ClientRpc");
((NetworkBehaviour)this).__registerRpc(2874192403u, new RpcReceiveHandler(__rpc_handler_2874192403), "HidePanel_ServerRpc");
((NetworkBehaviour)this).__registerRpc(1854803255u, new RpcReceiveHandler(__rpc_handler_1854803255), "HidePanel_ClientRpc");
((NetworkBehaviour)this).__initializeRpcs();
}
private static void __rpc_handler_4070705722(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0029: 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)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
target.__rpc_exec_stage = (__RpcExecStage)1;
((PluginNetworkHandler)(object)target).ShowPanel_ServerRpc();
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_685052383(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0029: 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)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
target.__rpc_exec_stage = (__RpcExecStage)1;
((PluginNetworkHandler)(object)target).ShowPanel_ClientRpc();
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_2874192403(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0029: 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)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
target.__rpc_exec_stage = (__RpcExecStage)1;
((PluginNetworkHandler)(object)target).HidePanel_ServerRpc();
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_1854803255(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0029: 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)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
target.__rpc_exec_stage = (__RpcExecStage)1;
((PluginNetworkHandler)(object)target).HidePanel_ClientRpc();
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
protected internal override string __getTypeName()
{
return "PluginNetworkHandler";
}
}
public class VoiceController : NetworkBehaviour
{
private static readonly List<VoiceController> _instances = new List<VoiceController>();
[SerializeField]
private AudioSource _voiceAudio;
[SerializeField]
private AudioSource _deadAudio;
[SerializeField]
private AudioClip _sound;
private static bool _generatedPitch;
private static float _localPitch = 1f;
public static IReadOnlyList<VoiceController> Instances => _instances;
public static VoiceController LocalInstance => Instances.FirstOrDefault((VoiceController x) => x.IsLocal);
public PlayerAudioGroup PlayerAudioGroup { get; private set; }
public PlayerControllerB PlayerScript { get; private set; }
public bool IsLocal => PlayerUtils.IsLocalPlayer(PlayerScript);
public static void Spawn_Server(PlayerControllerB playerScript)
{
GameObject val = Object.Instantiate<GameObject>(Assets.VoiceControllerPrefab, ((Component)playerScript).transform);
NetworkObject val2 = default(NetworkObject);
if (val.TryGetComponent<NetworkObject>(ref val2))
{
val2.DontDestroyWithOwner = true;
val2.SpawnWithOwnership(playerScript.actualClientId, false);
val2.TrySetParent(((Component)playerScript).transform, true);
}
}
public static void Despawn_Server(PlayerControllerB playerScript)
{
VoiceController componentInChildren = ((Component)playerScript).GetComponentInChildren<VoiceController>();
NetworkObject val = default(NetworkObject);
if (!((Object)(object)componentInChildren == (Object)null) && ((Component)componentInChildren).TryGetComponent<NetworkObject>(ref val) && val.IsSpawned)
{
val.Despawn(true);
}
}
public static void OnClientConnect_Server(ulong clientId)
{
PlayerControllerB playerScriptByClientId = PlayerUtils.GetPlayerScriptByClientId(clientId);
if (!((Object)(object)playerScriptByClientId == (Object)null))
{
VoiceController componentInChildren = ((Component)playerScriptByClientId).GetComponentInChildren<VoiceController>();
NetworkObject val = default(NetworkObject);
if (!((Object)(object)componentInChildren == (Object)null) && ((Component)componentInChildren).TryGetComponent<NetworkObject>(ref val) && val.IsSpawned)
{
val.ChangeOwnership(playerScriptByClientId.actualClientId);
}
}
}
private void OnEnable()
{
if (!_instances.Contains(this))
{
_instances.Add(this);
}
}
private void OnDisable()
{
_instances.Remove(this);
}
private void Awake()
{
if (!_generatedPitch)
{
_generatedPitch = true;
GenerateLocalPitch();
}
}
private void Start()
{
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
PlayerControllerB playerScript = default(PlayerControllerB);
if ((Object)(object)((Component)this).transform.parent == (Object)null)
{
LogError("Failed to initialize. Transform parent is null.");
if (NetworkUtils.IsServer)
{
((Component)this).GetComponent<NetworkObject>().Despawn(true);
}
}
else if (!((Component)((Component)this).transform.parent).TryGetComponent<PlayerControllerB>(ref playerScript))
{
LogError("Failed to initialize. PlayerControllerB is null.");
if (NetworkUtils.IsServer)
{
((Component)this).GetComponent<NetworkObject>().Despawn(true);
}
}
else
{
PlayerScript = playerScript;
((Component)this).transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
PlayerAudioGroup = new PlayerAudioGroup(_voiceAudio, _deadAudio);
PlayerAudioGroup.Volume01 = 1f;
ApplySettings();
LogInfo("Initialized.", extended: true);
}
}
public void PlaySound()
{
//IL_0008: 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)
PlaySound_ServerRpc(_localPitch);
PlaySound_Local(_localPitch);
}
[ServerRpc]
private void PlaySound_ServerRpc(float pitch, ServerRpcParams serverRpcParams = default(ServerRpcParams))
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Invalid comparison between Unknown and I4
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_0127: Unknown result type (might be due to invalid IL or missing references)
//IL_0128: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Invalid comparison between Unknown and I4
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
{
if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
{
if ((int)networkManager.LogLevel <= 1)
{
Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
}
return;
}
FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3947782144u, serverRpcParams, (RpcDelivery)0);
((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref pitch, default(ForPrimitives));
((NetworkBehaviour)this).__endSendServerRpc(ref val, 3947782144u, serverRpcParams, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
{
base.__rpc_exec_stage = (__RpcExecStage)0;
ulong senderClientId = serverRpcParams.Receive.SenderClientId;
if (((NetworkBehaviour)this).NetworkManager.ConnectedClients.ContainsKey(senderClientId))
{
PlaySound_ClientRpc(senderClientId, pitch);
}
}
}
[ClientRpc]
private void PlaySound_ClientRpc(ulong senderClientId, float pitch)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: 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_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2296604842u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, senderClientId);
((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref pitch, default(ForPrimitives));
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2296604842u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
{
base.__rpc_exec_stage = (__RpcExecStage)0;
if (!NetworkUtils.IsLocalClientId(senderClientId))
{
PlaySound_Local(pitch);
}
}
}
private void PlaySound_Local(float pitch)
{
if (PlayerAudioGroup != null && !((Object)(object)_sound == (Object)null))
{
UpdateVoiceMute();
PlayerAudioGroup.Pitch = pitch;
PlayerAudioGroup.PlayOneShot(_sound);
MakeNoiseForEnemies();
}
}
private void UpdateVoiceMute()
{
if ((Object)(object)PlayerScript == (Object)null || PlayerAudioGroup == null)
{
return;
}
if (IsLocal)
{
PlayerAudioGroup.VoiceAudio.mute = PlayerScript.isPlayerDead;
PlayerAudioGroup.DeadAudio.mute = !PlayerScript.isPlayerDead;
return;
}
PlayerAudioGroup.VoiceAudio.mute = PlayerScript.isPlayerDead;
PlayerControllerB localPlayerScript = PlayerUtils.LocalPlayerScript;
if ((Object)(object)localPlayerScript == (Object)null || !localPlayerScript.isPlayerDead)
{
PlayerAudioGroup.DeadAudio.mute = true;
}
else
{
PlayerAudioGroup.DeadAudio.mute = !PlayerScript.isPlayerDead;
}
}
private void MakeNoiseForEnemies()
{
//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_0022: Unknown result type (might be due to invalid IL or missing references)
Vector3 position = ((Component)PlayerScript).transform.position;
float num = 30f;
float num2 = 0.7f;
RoundManager.Instance.PlayAudibleNoise(position, num, num2, 0, PlayerScript.isInHangarShipRoom && StartOfRound.Instance.hangarDoorsClosed, 75);
}
private void ApplySettings()
{
if (PlayerAudioGroup != null)
{
UpdateVoiceMute();
PlayerAudioGroup.Volume01 = (float)ConfigManager.Voice_Volume.Value * 0.01f;
}
}
public static void GenerateLocalPitch()
{
if (ConfigManager.Voice_RandomizePitch.Value)
{
float value = ConfigManager.Voice_PitchMin.Value;
float value2 = ConfigManager.Voice_PitchMax.Value;
_localPitch = Random.Range(value, value2);
LocalInstance?.LogInfo($"Set voice pitch to {_localPitch}");
}
}
public static void OnConfigSettingsChanged()
{
foreach (VoiceController instance in _instances)
{
instance.ApplySettings();
}
}
private void LogInfo(object data, bool extended = false)
{
Log((LogLevel)16, data, extended);
}
private void LogWarning(object data, bool extended = false)
{
Log((LogLevel)4, data, extended);
}
private void LogError(object data, bool extended = false)
{
Log((LogLevel)2, data, extended);
}
private void Log(LogLevel logLevel, object data, bool extended = false)
{
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
string arg = (((Object)(object)PlayerScript == (Object)null) ? ("[" + ((object)this).GetType().Name + "]") : ("[" + ((object)this).GetType().Name + " : " + PlayerScript.playerUsername + "]"));
Logger.Log(logLevel, $"{arg} {data}", extended);
}
protected override void __initializeVariables()
{
((NetworkBehaviour)this).__initializeVariables();
}
protected override void __initializeRpcs()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Expected O, but got Unknown
((NetworkBehaviour)this).__registerRpc(3947782144u, new RpcReceiveHandler(__rpc_handler_3947782144), "PlaySound_ServerRpc");
((NetworkBehaviour)this).__registerRpc(2296604842u, new RpcReceiveHandler(__rpc_handler_2296604842), "PlaySound_ClientRpc");
((NetworkBehaviour)this).__initializeRpcs();
}
private static void __rpc_handler_3947782144(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: 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_0029: 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_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: 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_0055: Invalid comparison between Unknown and I4
NetworkManager networkManager = target.NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
{
if ((int)networkManager.LogLevel <= 1)
{
Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
}
}
else
{
float pitch = default(float);
((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref pitch, default(ForPrimitives));
ServerRpcParams server = rpcParams.Server;
target.__rpc_exec_stage = (__RpcExecStage)1;
((VoiceController)(object)target).PlaySound_ServerRpc(pitch, server);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_2296604842(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: 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_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
ulong senderClientId = default(ulong);
ByteUnpacker.ReadValueBitPacked(reader, ref senderClientId);
float pitch = default(float);
((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref pitch, default(ForPrimitives));
target.__rpc_exec_stage = (__RpcExecStage)1;
((VoiceController)(object)target).PlaySound_ClientRpc(senderClientId, pitch);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
protected internal override string __getTypeName()
{
return "VoiceController";
}
}
}
namespace com.github.zehsteam.MilkButton.Managers
{
internal static class ConfigManager
{
public static ConfigFile ConfigFile { get; private set; }
public static ConfigEntry<bool> Button_Enabled { get; private set; }
public static ConfigEntry<float> Button_ActivateChance { get; private set; }
public static ConfigEntry<bool> Button_ActivateFromHost { get; private set; }
public static ConfigEntry<bool> Button_ActivateFromEveryone { get; private set; }
public static ConfigEntry<string> Button_ActivateFromPlayers { get; private set; }
public static IEnumerable<string> Button_ActivateFromPlayers_Collection => Button_ActivateFromPlayers.Value.ToLower().StringToCollection<string>();
public static ConfigEntry<int> Voice_Volume { get; private set; }
public static ConfigEntry<bool> Voice_RandomizePitch { get; private set; }
public static ConfigEntry<float> Voice_PitchMin { get; private set; }
public static ConfigEntry<float> Voice_PitchMax { get; private set; }
public static ConfigEntry<bool> Misc_ExtendedLogging { get; private set; }
public static void Initialize(ConfigFile configFile)
{
ConfigFile = configFile;
BindConfigs();
}
private static void BindConfigs()
{
ConfigHelper.SkipAutoGen();
Button_Enabled = ConfigHelper.Bind("Button", "Enabled", defaultValue: true, "If enabled, the milk button will be able to appear and activate from you if allowed.");
Button_ActivateChance = ConfigHelper.Bind("Button", "ActivateChance", 30f, "The chance for the milk button to appear after you die if activation is allowed from you.", requiresRestart: false, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f));
Button_ActivateFromHost = ConfigHelper.Bind("Button", "ActivateFromHost", defaultValue: true, "If enabled, will allow the host to make the milk button appear after they die.");
Button_ActivateFromEveryone = ConfigHelper.Bind("Button", "ActivateFromEveryone", defaultValue: false, "If enabled, will allow anyone to make the milk button appear after they die.");
Button_ActivateFromPlayers = ConfigHelper.Bind("Button", "ActivateFromPlayers", "Insym, CritHaxXoG", "List of player Steam names separated by a comma.\nWill allow anyone on the list to make the milk button appear after they die.");
Button_Enabled.SettingChanged += delegate
{
PluginCanvas.OnConfigSettingsChanged();
};
ConfigHelper.AddButton("Button", "Show Button For You", "Show", "Will show the milk button for only you.", delegate
{
PluginCanvas.Instance?.ShowPanel();
});
ConfigHelper.AddButton("Button", "Hide Button For You", "Hide", "Will hide the milk button for only you.", delegate
{
PluginCanvas.Instance?.HidePanel();
});
ConfigHelper.AddButton("Button", "Show Button For Everyone", "Show", "Will show the milk button for everyone.", delegate
{
PluginNetworkHandler.Instance?.ShowPanel_ServerRpc();
});
ConfigHelper.AddButton("Button", "Hide Button For Everyone", "Hide", "Will hide the milk button for everyone.", delegate
{
PluginNetworkHandler.Instance?.HidePanel_ServerRpc();
});
Voice_Volume = ConfigHelper.Bind("Voice", "Volume", 100, "The volume of your voice from pressing the milk button.", requiresRestart: false, (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100));
Voice_RandomizePitch = ConfigHelper.Bind("Voice", "RandomizePitch", defaultValue: true, "If enabled, will set a random pitch to your voice based on the min/max pitch values.");
Voice_PitchMin = ConfigHelper.Bind("Voice", "PitchMin", 0.9f, "The minimum value your voice pitch can be.", requiresRestart: false, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.7f, 1.3f));
Voice_PitchMax = ConfigHelper.Bind("Voice", "PitchMax", 1.1f, "The maximum value your voice pitch can be.", requiresRestart: false, (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.7f, 1.3f));
Voice_Volume.SettingChanged += delegate
{
VoiceController.OnConfigSettingsChanged();
};
ConfigHelper.AddButton("Voice", "Regenerate Voice Pitch", "Regenerate", "Will regenerate your voice's pitch.", delegate
{
VoiceController.GenerateLocalPitch();
});
Misc_ExtendedLogging = ConfigHelper.Bind("Misc", "ExtendedLogging", defaultValue: false, "Enable extended logging.");
}
}
}
namespace com.github.zehsteam.MilkButton.Helpers
{
internal static class ConfigHelper
{
public static void SkipAutoGen()
{
if (LethalConfigProxy.IsInstalled)
{
LethalConfigProxy.SkipAutoGen();
}
}
public static void AddButton(string section, string name, string buttonText, string description, Action callback)
{
if (LethalConfigProxy.IsInstalled)
{
LethalConfigProxy.AddButton(section, name, buttonText, description, callback);
}
}
public static ConfigEntry<T> Bind<T>(string section, string key, T defaultValue, string description, bool requiresRestart = false, AcceptableValueBase acceptableValues = null, Action<T> settingChanged = null, ConfigFile configFile = null)
{
if (configFile == null)
{
configFile = ConfigManager.ConfigFile;
}
ConfigEntry<T> configEntry = configFile.Bind(section, key, defaultValue, description, acceptableValues);
if (settingChanged != null)
{
configEntry.SettingChanged += delegate
{
settingChanged?.Invoke(configEntry.Value);
};
}
if (LethalConfigProxy.IsInstalled)
{
LethalConfigProxy.AddConfig<T>(configEntry, requiresRestart);
}
return configEntry;
}
}
internal static class NetworkUtils
{
public static bool IsConnected
{
get
{
NetworkManager singleton = NetworkManager.Singleton;
if (singleton == null)
{
return false;
}
return singleton.IsConnectedClient;
}
}
public static bool IsServer
{
get
{
NetworkManager singleton = NetworkManager.Singleton;
if (singleton == null)
{
return false;
}
return singleton.IsServer;
}
}
public static ulong LocalClientId
{
get
{
NetworkManager singleton = NetworkManager.Singleton;
if (singleton == null)
{
return 0uL;
}
return singleton.LocalClientId;
}
}
public static int ConnectedPlayerCount => GameNetworkManager.Instance?.connectedPlayers ?? 0;
public static bool IsLocalClientId(ulong clientId)
{
return clientId == LocalClientId;
}
public static bool IsNetworkPrefab(GameObject prefab)
{
IReadOnlyList<NetworkPrefab> prefabs = NetworkManager.Singleton.NetworkConfig.Prefabs.Prefabs;
return prefabs.Any((NetworkPrefab x) => (Object)(object)x.Prefab == (Object)(object)prefab);
}
public static bool AddNetworkPrefab(GameObject prefab)
{
if ((Object)(object)prefab == (Object)null)
{
Logger.LogError("Failed to register network prefab. GameObject is null.");
return false;
}
if ((Object)(object)NetworkManager.Singleton == (Object)null)
{
Logger.LogError("Failed to register network prefab. NetworkManager Singleton is null.");
return false;
}
NetworkManager.Singleton.AddNetworkPrefab(prefab);
Logger.LogInfo("Registered \"" + ((Object)prefab).name + "\" network prefab.");
return true;
}
public static void NetcodePatcherAwake()
{
try
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
Type[] types = executingAssembly.GetTypes();
Type[] array = types;
foreach (Type type in array)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array2 = methods;
foreach (MethodInfo methodInfo in array2)
{
try
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
try
{
methodInfo.Invoke(null, null);
}
catch (TargetInvocationException ex)
{
Logger.LogWarning("Failed to invoke method " + methodInfo.Name + ": " + ex.Message);
}
}
}
catch (Exception ex2)
{
Logger.LogWarning("Error processing method " + methodInfo.Name + " in type " + type.Name + ": " + ex2.Message);
}
}
}
}
catch (Exception ex3)
{
Logger.LogError("An error occurred in NetcodePatcherAwake: " + ex3.Message);
}
}
}
internal static class PlayerIdentityUtils
{
public static PlayerIdentity InsymIdentity = new PlayerIdentity("Insym", 76561198008109303uL);
public static bool IsPlayer(PlayerControllerB playerScript, PlayerIdentity identity)
{
if ((Object)(object)playerScript == (Object)null)
{
return false;
}
if (playerScript.playerUsername.Equals(identity.Username, StringComparison.OrdinalIgnoreCase))
{
return true;
}
if (playerScript.playerSteamId == identity.SteamId)
{
return true;
}
return false;
}
public static bool IsLocalPlayer(PlayerIdentity identity)
{
return IsPlayer(PlayerUtils.LocalPlayerScript, identity);
}
public static bool TryGetPlayer(PlayerIdentity identity, out PlayerControllerB playerScript)
{
playerScript = ((IEnumerable<PlayerControllerB>)PlayerUtils.PlayerScripts).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB x) => IsPlayer(x, identity)));
return (Object)(object)playerScript != (Object)null;
}
public static bool HasPlayer(PlayerIdentity identity)
{
PlayerControllerB playerScript;
return TryGetPlayer(identity, out playerScript);
}
}
public struct PlayerIdentity
{
public string Username { get; set; }
public ulong SteamId { get; set; }
public PlayerIdentity(string username, ulong steamId)
{
Username = username;
SteamId = steamId;
}
}
internal static class PlayerUtils
{
public static PlayerControllerB LocalPlayerScript => GameNetworkManager.Instance?.localPlayerController ?? null;
public static PlayerControllerB[] PlayerScripts => StartOfRound.Instance?.allPlayerScripts ?? Array.Empty<PlayerControllerB>();
public static bool IsLocalPlayer(PlayerControllerB playerScript)
{
return (Object)(object)playerScript == (Object)(object)LocalPlayerScript;
}
public static PlayerControllerB GetPlayerScriptByClientId(ulong clientId)
{
return ((IEnumerable<PlayerControllerB>)PlayerScripts).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB playerScript) => playerScript.actualClientId == clientId));
}
public static PlayerControllerB GetPlayerScriptByPlayerId(int playerId)
{
if (playerId < 0 || playerId > PlayerScripts.Length - 1)
{
return null;
}
return PlayerScripts[playerId];
}
}
internal static class Utils
{
public static bool RollPercentChance(float percent)
{
if (percent <= 0f)
{
return false;
}
if (percent >= 100f)
{
return true;
}
return Random.value * 100f <= percent;
}
}
}
namespace com.github.zehsteam.MilkButton.Extensions
{
internal static class CollectionExtensions
{
public static IEnumerable<T> StringToCollection<T>(this string s, string separator = ",")
{
if (string.IsNullOrEmpty(s))
{
return Array.Empty<T>();
}
T result;
return from x in s.Split(separator, StringSplitOptions.RemoveEmptyEntries)
where !string.IsNullOrWhiteSpace(x)
select x.Trim() into x
select (!x.TryConvertTo<T>(out result)) ? default(T) : result into x
where x != null
select x;
}
public static string CollectionToString<T>(this IEnumerable<T> value, string separator = ", ")
{
if (value == null || !value.Any())
{
return string.Empty;
}
return string.Join(separator, from x in value
where x != null && !string.IsNullOrWhiteSpace(x.ToString())
select x.ToString().Trim());
}
}
internal static class ConfigFileExtensions
{
public static ConfigEntry<T> Bind<T>(this ConfigFile configFile, string section, string key, T defaultValue, string description, AcceptableValueBase acceptableValues)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
if (acceptableValues == null)
{
return configFile.Bind<T>(section, key, defaultValue, description);
}
return configFile.Bind<T>(section, key, defaultValue, new ConfigDescription(description, acceptableValues, Array.Empty<object>()));
}
}
internal static class StringExtensions
{
public static T ConvertTo<T>(this string s)
{
Type typeFromHandle = typeof(T);
if ((object)typeFromHandle != null)
{
Type type = typeFromHandle;
object obj;
if (type == typeof(int) && int.TryParse(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var result))
{
obj = result;
}
else
{
Type type2 = typeFromHandle;
if (type2 == typeof(float) && float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
{
obj = result2;
}
else
{
Type type3 = typeFromHandle;
if (type3 == typeof(double) && double.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
{
obj = result3;
}
else
{
Type type4 = typeFromHandle;
if (type4 == typeof(bool) && bool.TryParse(s, out var result4))
{
obj = result4;
}
else
{
Type type5 = typeFromHandle;
if (type5 == typeof(string))
{
obj = s;
}
else
{
Type type6 = typeFromHandle;
if (!type6.IsEnum || !Enum.TryParse(type6, s, ignoreCase: true, out object result5))
{
goto IL_0121;
}
obj = result5;
}
}
}
}
}
object obj2 = obj;
return (T)obj2;
}
goto IL_0121;
IL_0121:
throw new NotSupportedException($"Unsupported value type: {typeof(T)}");
}
public static bool TryConvertTo<T>(this string s, out T result)
{
try
{
result = s.ConvertTo<T>();
return true;
}
catch
{
result = default(T);
return false;
}
}
public static bool IsHexColor(this string value)
{
return Regex.IsMatch(value, "^#?([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$");
}
}
}
namespace com.github.zehsteam.MilkButton.Dependencies.LethalConfigMod
{
internal static class LethalConfigProxy
{
public const string PLUGIN_GUID = "ainavt.lc.lethalconfig";
public static bool IsInstalled => Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig");
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static void SkipAutoGen()
{
LethalConfigManager.SkipAutoGen();
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static BaseConfigItem AddConfig<T>(ConfigEntry<T> configEntry, bool requiresRestart = false)
{
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Expected O, but got Unknown
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Expected O, but got Unknown
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Expected O, but got Unknown
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Expected O, but got Unknown
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Expected O, but got Unknown
if (typeof(T).IsEnum)
{
MethodInfo methodInfo = AccessTools.Method(typeof(LethalConfigProxy), "AddEnumDropdown", (Type[])null, (Type[])null);
MethodInfo methodInfo2 = methodInfo.MakeGenericMethod(typeof(T));
object? obj = methodInfo2.Invoke(null, new object[2] { configEntry, requiresRestart });
return (BaseConfigItem)((obj is BaseConfigItem) ? obj : null);
}
AcceptableValueBase acceptableValues = ((ConfigEntryBase)configEntry).Description.AcceptableValues;
if (acceptableValues != null)
{
if (acceptableValues is AcceptableValueRange<float> || acceptableValues is AcceptableValueRange<int>)
{
return AddConfigSlider<T>(configEntry, requiresRestart);
}
if (acceptableValues is AcceptableValueList<string>)
{
return AddConfigDropdown<T>(configEntry, requiresRestart);
}
}
if (configEntry is ConfigEntry<string> val && IsConfigEntryForHexColor(val))
{
return AddConfigItem((BaseConfigItem)new HexColorInputFieldConfigItem(val, requiresRestart));
}
if (!(configEntry is ConfigEntry<int> val2))
{
if (!(configEntry is ConfigEntry<float> val3))
{
if (!(configEntry is ConfigEntry<bool> val4))
{
if (configEntry is ConfigEntry<string> val5)
{
return AddConfigItem((BaseConfigItem)new TextInputFieldConfigItem(val5, requiresRestart));
}
throw new NotSupportedException($"Unsupported type: {typeof(T)}");
}
return AddConfigItem((BaseConfigItem)new BoolCheckBoxConfigItem(val4, requiresRestart));
}
return AddConfigItem((BaseConfigItem)new FloatInputFieldConfigItem(val3, requiresRestart));
}
return AddConfigItem((BaseConfigItem)new IntInputFieldConfigItem(val2, requiresRestart));
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private static BaseConfigItem AddConfigSlider<T>(ConfigEntry<T> configEntry, bool requiresRestart = false)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
if (!(configEntry is ConfigEntry<float> val))
{
if (configEntry is ConfigEntry<int> val2)
{
return AddConfigItem((BaseConfigItem)new IntSliderConfigItem(val2, requiresRestart));
}
throw new NotSupportedException($"Slider not supported for type: {typeof(T)}");
}
return AddConfigItem((BaseConfigItem)new FloatSliderConfigItem(val, requiresRestart));
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private static BaseConfigItem AddConfigDropdown<T>(ConfigEntry<T> configEntry, bool requiresRestart = false)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected O, but got Unknown
if (configEntry is ConfigEntry<string> val)
{
return AddConfigItem((BaseConfigItem)new TextDropDownConfigItem(val, requiresRestart));
}
throw new NotSupportedException($"Dropdown not supported for type: {typeof(T)}");
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private static BaseConfigItem AddEnumDropdown<T>(ConfigEntry<T> configEntry, bool requiresRestart = false) where T : Enum
{
return AddConfigItem((BaseConfigItem)(object)new EnumDropDownConfigItem<T>(configEntry, requiresRestart));
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static BaseConfigItem AddButton(string section, string name, string buttonText, string description, Action callback)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
BaseConfigItem configItem = (BaseConfigItem)new GenericButtonConfigItem(section, name, description, buttonText, (GenericButtonHandler)delegate
{
callback?.Invoke();
});
return AddConfigItem(configItem);
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private static bool IsConfigEntryForHexColor(ConfigEntry<string> configEntry)
{
if (!(((ConfigEntryBase)configEntry).DefaultValue is string value))
{
return false;
}
return value.IsHexColor();
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private static BaseConfigItem AddConfigItem(BaseConfigItem configItem)
{
LethalConfigManager.AddConfigItem(configItem);
return configItem;
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
namespace __GEN
{
internal class NetworkVariableSerializationHelper
{
[RuntimeInitializeOnLoadMethod]
internal static void InitializeSerialization()
{
}
}
}
namespace com.github.zehsteam.MilkButton.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
