using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using CSync.Lib;
using CSync.Util;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using YippeeKey.ConfigSync;
using YippeeKey.LocalScripts;
using YippeeKey.NetcodePatcher;
using YippeeKey.Patches;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("YippeeKey")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+4f6ffe2d4f5dee1cc95a5ff47ab3af046ed80b6b")]
[assembly: AssemblyProduct("YippeeKey")]
[assembly: AssemblyTitle("YippeeKey")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: NetcodePatchedAssembly]
internal class <Module>
{
static <Module>()
{
}
}
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace YippeeKey
{
public sealed class NetworkHandlerYP : NetworkBehaviour
{
public static NetworkHandlerYP Instance { get; private set; }
public override void OnNetworkSpawn()
{
YippeeKeyPlugin.Instance.Log("Despawning NetworkObject");
YippeeKeyPlugin.Instance.Log("NetworkManager existant? " + (((Object)(object)NetworkManager.Singleton != (Object)null) ? "Yes!" : "No"));
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
try
{
NetworkObject component = ((Component)this).gameObject.GetComponent<NetworkObject>();
YippeeKeyPlugin.Instance.Log("networkObject existant? " + (((Object)(object)component != (Object)null) ? "Yes!" : "No"));
if (component != null)
{
component.Spawn(false);
}
}
catch (Exception)
{
YippeeKeyPlugin.Instance.Log("networkObject was already spawned.");
}
}
Instance = this;
((NetworkBehaviour)this).OnNetworkSpawn();
}
[ServerRpc(RequireOwnership = false)]
public void ScreamYippeeServerRPC(string eventName, bool isCallerDead)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: 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_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: 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)
//IL_00d5: 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.IsClient || networkManager.IsHost))
{
ServerRpcParams val = default(ServerRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3132667294u, val, (RpcDelivery)0);
bool flag = eventName != null;
((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
if (flag)
{
((FastBufferWriter)(ref val2)).WriteValueSafe(eventName, false);
}
((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isCallerDead, default(ForPrimitives));
((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3132667294u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
{
YippeeKeyPlugin.Instance.Log("Server event received");
YippeeKeyPlugin.Instance.Log("Notifying Clients");
ScreamYippeeClientRPC(eventName, isCallerDead);
}
}
[ClientRpc]
public void ScreamYippeeClientRPC(string eventName, bool isCallerDead)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: 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_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: 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)
//IL_00d5: 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 != 2 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(810594168u, val, (RpcDelivery)0);
bool flag = eventName != null;
((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
if (flag)
{
((FastBufferWriter)(ref val2)).WriteValueSafe(eventName, false);
}
((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isCallerDead, default(ForPrimitives));
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 810594168u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
{
YippeeKeyPlugin.Instance.Log("Event received from Server for " + eventName);
NetworkObjectManagerYK.playYippeeAtPlayer(ref eventName, ref isCallerDead);
}
}
protected override void __initializeVariables()
{
((NetworkBehaviour)this).__initializeVariables();
}
[RuntimeInitializeOnLoadMethod]
internal static void InitializeRPCS_NetworkHandlerYP()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
NetworkManager.__rpc_func_table.Add(3132667294u, new RpcReceiveHandler(__rpc_handler_3132667294));
NetworkManager.__rpc_func_table.Add(810594168u, new RpcReceiveHandler(__rpc_handler_810594168));
}
private static void __rpc_handler_3132667294(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: 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_009a: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
bool flag = default(bool);
((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
string eventName = null;
if (flag)
{
((FastBufferReader)(ref reader)).ReadValueSafe(ref eventName, false);
}
bool isCallerDead = default(bool);
((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isCallerDead, default(ForPrimitives));
target.__rpc_exec_stage = (__RpcExecStage)1;
((NetworkHandlerYP)(object)target).ScreamYippeeServerRPC(eventName, isCallerDead);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_810594168(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: 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_009a: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
bool flag = default(bool);
((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
string eventName = null;
if (flag)
{
((FastBufferReader)(ref reader)).ReadValueSafe(ref eventName, false);
}
bool isCallerDead = default(bool);
((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isCallerDead, default(ForPrimitives));
target.__rpc_exec_stage = (__RpcExecStage)2;
((NetworkHandlerYP)(object)target).ScreamYippeeClientRPC(eventName, isCallerDead);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
protected internal override string __getTypeName()
{
return "NetworkHandlerYP";
}
}
[BepInPlugin("QMLCYipeeKey_plugin", "Yippee key", "1.3.2.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
internal sealed class YippeeKeyPlugin : BaseUnityPlugin
{
public const string GUID = "QMLCYipeeKey_plugin";
public const string Name = "Yippee key";
public const string Version = "1.3.2.0";
public AssetBundle? MainAssetBundle;
public static YippeeKeyPlugin Instance;
public YippeeSyncedConfig GetConfig;
private Harmony harmony = new Harmony("net.quadmesh.yippeekey.plugin");
private void Awake()
{
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
Instance = this;
SetupConfigKeys();
string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
string text = Path.Combine(directoryName, "yippeekey");
MainAssetBundle = AssetBundle.LoadFromFile(text);
if ((Object)(object)MainAssetBundle != (Object)null)
{
((BaseUnityPlugin)this).Logger.LogInfo((object)(((Object)MainAssetBundle).name + " Should be loaded succesfully."));
}
Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "QMLCYipeeKey_plugin");
harmony.PatchAll(typeof(YippeeSyncedConfig));
NetcodePatcher();
((BaseUnityPlugin)this).Logger.LogInfo((object)"Yippe mod ready!");
((BaseUnityPlugin)this).Logger.LogInfo((object)("Debugging? [" + BeautifyBool(SyncedInstance<YippeeSyncedConfig>.Instance.DebugKey.Value) + "]"));
((BaseUnityPlugin)this).Logger.LogInfo((object)$"Key to use Yippe: '{SyncedInstance<YippeeSyncedConfig>.Instance.ConfigKey.Value}'");
}
public void Log(string message)
{
if (SyncedInstance<YippeeSyncedConfig>.Default.DebugKey.Value)
{
((BaseUnityPlugin)this).Logger.LogInfo((object)message);
}
}
public static string BeautifyBool(bool value)
{
return value ? "Yes!" : "Nope.";
}
public void LogError(string message)
{
((BaseUnityPlugin)this).Logger.LogError((object)message);
}
private void SetupConfigKeys()
{
GetConfig = new YippeeSyncedConfig(((BaseUnityPlugin)this).Config);
}
private static void NetcodePatcher()
{
Type[] types = Assembly.GetExecutingAssembly().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)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
methodInfo.Invoke(null, null);
}
}
}
}
}
}
namespace YippeeKey.Patches
{
[HarmonyPatch]
internal class DeadBodyInfoPatch
{
[HarmonyPrefix]
[HarmonyPatch(typeof(DeadBodyInfo), "DeactivateBody")]
private static void ReparentOnRespawn(DeadBodyInfo __instance)
{
foreach (YippeeSoundManager value in NetworkObjectManagerYK.soundManagers.Values)
{
if (value.Player.isPlayerDead)
{
YippeeKeyPlugin.Instance.Log("Reparenting soundmanager to normal body");
((Component)NetworkObjectManagerYK.soundManagers[((Object)((Component)__instance.playerScript).gameObject).name]).transform.SetParent(((Component)__instance.playerScript).transform);
YippeeKeyPlugin.Instance.Log("Reparented " + ((Object)((Component)__instance).gameObject).name);
}
}
}
}
[HarmonyPatch]
public sealed class NetworkObjectManagerYK
{
public static Dictionary<string, YippeeSoundManager> soundManagers = new Dictionary<string, YippeeSoundManager>();
private static GameObject? networkPrefab = null;
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "Start")]
public static void Init()
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Expected O, but got Unknown
if ((Object)(object)networkPrefab != (Object)null)
{
YippeeKeyPlugin.Instance.Log("Networkmanager already exist");
}
YippeeKeyPlugin.Instance.Log("Getting network prefab setup");
networkPrefab = (GameObject)YippeeKeyPlugin.Instance.MainAssetBundle.LoadAsset("NetworkHandlerYippeeKey");
YippeeKeyPlugin.Instance.Log("Adding NetworkHandlerYP");
networkPrefab.AddComponent<NetworkHandlerYP>();
YippeeKeyPlugin.Instance.Log("Adding Networked prefab");
NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "Awake")]
private static void SpawnNetworkHandler()
{
//IL_0075: 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)
YippeeKeyPlugin.Instance.Log("Spawning NetworkHandler");
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
YippeeKeyPlugin.Instance.Log("NetworkHandler spawned!");
YippeeKeyPlugin.Instance.Log("Is networkPrefab existant? " + (((Object)(object)networkPrefab != (Object)null) ? "Yes!" : "Nope"));
GameObject val = Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity);
YippeeKeyPlugin.Instance.Log("Is NetworkHandler existant? " + (((Object)(object)val != (Object)null) ? "Yes!" : "Nope"));
NetworkObject component = val.GetComponent<NetworkObject>();
if (component != null)
{
component.Spawn(false);
}
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")]
private static void UnsubscribeFromHandler()
{
YippeeKeyPlugin.Instance.Log("UnSyncing config & Clearing Body references.");
soundManagers.Clear();
((SyncedInstance<YippeeSyncedConfig>)(object)SyncedInstance<YippeeSyncedConfig>.Instance).RevertSync();
}
public static void SendYippeeEventToServer(string eventName, bool isCallerDead)
{
YippeeKeyPlugin.Instance.Log("Sending event to rest of lobby.");
NetworkHandlerYP.Instance.ScreamYippeeServerRPC(eventName, isCallerDead);
}
public static void playYippeeAtPlayer(ref string playerName, ref bool isCallerDead)
{
//IL_0130: Unknown result type (might be due to invalid IL or missing references)
if (!soundManagers.ContainsKey(playerName))
{
YippeeKeyPlugin.Instance.LogError("Unable to get sound manager for " + playerName + "!");
}
else if (SyncedInstance<YippeeSyncedConfig>.Instance.DeadPlayersYippeeAlivePlayers.Value || GameNetworkManager.Instance.localPlayerController.isPlayerDead)
{
GameObject gameObject = ((Component)soundManagers[playerName]).gameObject;
Transform transform = gameObject.transform;
YippeeKeyPlugin.Instance.Log(playerName + "'s transform gotten from dictionary.");
soundManagers[playerName].Play(isCallerDead);
if (!SyncedInstance<YippeeSyncedConfig>.Instance.NotifyEnemies.Value)
{
YippeeKeyPlugin.Instance.Log("Host-synced config dictates enemies are not alerted.");
return;
}
if ((isCallerDead && !SyncedInstance<YippeeSyncedConfig>.Instance.DeadPlayerAlertsEnemyAI.Value) || !SyncedInstance<YippeeSyncedConfig>.Instance.DeadPlayersYippeeAlivePlayers.Value)
{
YippeeKeyPlugin.Instance.Log("Host-synced config dictates Dead players cannot alert enemies.");
return;
}
YippeeKeyPlugin.Instance.Log("Host-synced config dictates enemies are alerted.");
RoundManager.Instance.PlayAudibleNoise(transform.position, (float)SyncedInstance<YippeeSyncedConfig>.Instance.EnemyAIDetectionRange.Value, SyncedInstance<YippeeSyncedConfig>.Instance.EnemyAIDetectionVolume.Value, 0, false, 0);
}
}
}
[HarmonyPatch]
internal sealed class PlayerControllerBPatch
{
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "OnEnable")]
private static void AddInputter(PlayerControllerB __instance)
{
YippeeInputter yippeeInputter = default(YippeeInputter);
((Component)__instance).gameObject.TryGetComponent<YippeeInputter>(ref yippeeInputter);
if ((Object)(object)yippeeInputter == (Object)null)
{
YippeeKeyPlugin.Instance.Log("YippeInputter added!");
yippeeInputter = ((Component)__instance).gameObject.AddComponent<YippeeInputter>();
}
YippeeKeyPlugin.Instance.Log("Setting SoundManager");
((Component)yippeeInputter).gameObject.SetActive(true);
AddSoundManagerToPlayer(__instance);
}
public static void AddSoundManagerToPlayer(PlayerControllerB playerController)
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Expected O, but got Unknown
//IL_0061: 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_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_00ab: Unknown result type (might be due to invalid IL or missing references)
if (Object.op_Implicit((Object)(object)((Component)playerController).gameObject.GetComponentInChildren<YippeeSoundManager>()))
{
YippeeKeyPlugin.Instance.Log("You already have a soundManager, there is no need to add another.");
return;
}
GameObject val = (GameObject)YippeeKeyPlugin.Instance.MainAssetBundle.LoadAsset("YippeSound");
YippeeKeyPlugin.Instance.Log("Prefab for use, loaded!");
GameObject val2 = Object.Instantiate<GameObject>(val, new Vector3(((Component)playerController).gameObject.transform.position.x, ((Component)playerController).gameObject.transform.position.y + 2f, ((Component)playerController).gameObject.transform.position.z), ((Component)playerController).gameObject.transform.rotation, ((Component)playerController).gameObject.transform);
YippeeSoundManager yippeeSoundManager = val2.AddComponent<YippeeSoundManager>();
yippeeSoundManager.Player = playerController;
NetworkObjectManagerYK.soundManagers.Add(((Object)((Component)playerController).gameObject).name, yippeeSoundManager);
YippeeKeyPlugin.Instance.Log("Soundmanager set for " + ((Object)((Component)playerController).gameObject).name);
}
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "SpawnDeadBody")]
private static void ReparentOnDeath(PlayerControllerB __instance)
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Invalid comparison between Unknown and I4
if (!((Object)(object)__instance.deadBody != (Object)null) || !((Behaviour)__instance.deadBody).enabled)
{
return;
}
YippeeKeyPlugin.Instance.Log("Reparenting soundmanager to dead body");
try
{
if ((int)__instance.causeOfDeath > 0)
{
((Component)NetworkObjectManagerYK.soundManagers[((Object)((Component)__instance).gameObject).name]).transform.SetParent(((Component)__instance.deadBody).transform);
YippeeKeyPlugin.Instance.Log("Reparented " + ((Object)((Component)__instance).gameObject).name);
}
}
catch
{
YippeeKeyPlugin.Instance.LogError("Unable to set the YippeeSoundManager to the dead body, most likey Nullref.");
}
}
}
}
namespace YippeeKey.LocalScripts
{
public class YippeeInputter : MonoBehaviour
{
private PlayerControllerB? _localPlayer;
private bool cooldownActive = false;
private float cooldown = SyncedInstance<YippeeSyncedConfig>.Instance.CooldownTime.Value;
private float CoolDownStartTime => SyncedInstance<YippeeSyncedConfig>.Instance.CooldownTime.Value;
private void Awake()
{
_localPlayer = ((Component)this).GetComponent<PlayerControllerB>();
}
public void Update()
{
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
ManageCooldown();
if ((!SyncedInstance<YippeeSyncedConfig>.Instance.CooldownEnabled.Value || !cooldownActive) && UnityInput.Current.GetKeyDown(SyncedInstance<YippeeSyncedConfig>.Default.ConfigKey.Value) && IsLocal() && !GameNetworkManager.Instance.localPlayerController.inTerminalMenu && !GameNetworkManager.Instance.localPlayerController.quickMenuManager.isMenuOpen && !GameNetworkManager.Instance.localPlayerController.isTypingChat)
{
NetworkObjectManagerYK.SendYippeeEventToServer(((Object)((Component)GameNetworkManager.Instance.localPlayerController).gameObject).name, GameNetworkManager.Instance.localPlayerController.isPlayerDead);
if (SyncedInstance<YippeeSyncedConfig>.Instance.CooldownEnabled.Value)
{
cooldownActive = true;
YippeeKeyPlugin.Instance.Log("Cooldown active");
}
}
}
private void ManageCooldown()
{
if (cooldownActive)
{
cooldown -= Time.deltaTime;
YippeeKeyPlugin.Instance.Log($"{cooldown}");
if (cooldown <= 0f)
{
cooldownActive = false;
cooldown = CoolDownStartTime;
YippeeKeyPlugin.Instance.Log("Cooldown has wore off, time to Yippee!");
}
}
}
private bool IsLocal()
{
return ((object)_localPlayer).Equals((object?)GameNetworkManager.Instance.localPlayerController);
}
}
public sealed class YippeeSoundManager : MonoBehaviour
{
private PlayerControllerB player;
public DeadBodyInfo DeadBody;
public AudioSource YippeeAudio { get; private set; } = null;
public ParticleSystem[] ParticleSystems { get; private set; } = (ParticleSystem[])(object)new ParticleSystem[3];
public PlayerControllerB Player
{
get
{
return player;
}
set
{
player = value;
DeadBody = player.deadBody;
}
}
private bool IsLocalPlayerDead => GameNetworkManager.Instance.localPlayerController.isPlayerDead;
public void Play(bool isCallerDead)
{
if ((Object)(object)YippeeAudio == (Object)null)
{
YippeeAudio = ((Component)this).GetComponent<AudioSource>();
}
ResetEffects();
RandomPitch();
if (isCallerDead)
{
PostMortem();
}
PlayYippee();
WalkieTalkie.TransmitOneShotAudio(YippeeAudio, YippeeAudio.clip, 1f);
if (!SyncedInstance<YippeeSyncedConfig>.Default.AllowVisuals.Value || (isCallerDead && !IsLocalPlayerDead))
{
return;
}
if ((Object)(object)ParticleSystems[0] == (Object)null)
{
GetParticleSystems();
}
ParticleSystem[] particleSystems = ParticleSystems;
foreach (ParticleSystem val in particleSystems)
{
if (SyncedInstance<YippeeSyncedConfig>.Default.AllowParticeSpam.Value)
{
val.Stop(false);
}
else
{
val.Stop(false, (ParticleSystemStopBehavior)0);
}
val.Play();
}
}
public void OnDestroy()
{
NetworkObjectManagerYK.soundManagers.Remove(((Object)((Component)Player).gameObject).name);
PlayerControllerBPatch.AddSoundManagerToPlayer(Player);
}
private void PlayYippee()
{
if (SyncedInstance<YippeeSyncedConfig>.Default.AllowYippeeOverlap.Value)
{
YippeeAudio.PlayOneShot(YippeeAudio.clip);
}
else
{
YippeeAudio.Stop();
YippeeAudio.Play();
}
YippeeKeyPlugin.Instance.Log("Playing Yippee " + YippeeKeyPlugin.BeautifyBool(((Behaviour)YippeeAudio).enabled));
}
private void GetParticleSystems()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
int num = 0;
foreach (Transform item in ((Component)this).transform)
{
Transform val = item;
ParticleSystems[num] = ((Component)val).GetComponent<ParticleSystem>();
num++;
}
}
private void RandomPitch()
{
if (SyncedInstance<YippeeSyncedConfig>.Default.RandomPitchedYippee.Value)
{
YippeeAudio.pitch = Random.Range(0.95f, 1.05f);
}
}
private void PostMortem()
{
if (IsLocalPlayerDead)
{
YippeeAudio.spatialBlend = 0f;
YippeeAudio.reverbZoneMix = 0f;
}
else
{
YippeeAudio.volume *= 0.25f;
YippeeAudio.pitch *= 0.75f;
}
}
private void ResetEffects()
{
YippeeAudio.pitch = 1f;
YippeeAudio.volume = SyncedInstance<YippeeSyncedConfig>.Default.YippeeVolume.Value;
YippeeAudio.spatialBlend = 1f;
YippeeAudio.reverbZoneMix = 1f;
}
}
}
namespace YippeeKey.ConfigSync
{
[DataContract]
public class YippeeSyncedConfig : SyncedInstance<YippeeSyncedConfig>
{
public ConfigEntry<float> DisplayDebugInfo { get; private set; }
[DataMember]
public SyncedEntry<bool> NotifyEnemies { get; private set; }
[DataMember]
public SyncedEntry<int> EnemyAIDetectionRange { get; private set; }
[DataMember]
public SyncedEntry<float> EnemyAIDetectionVolume { get; private set; }
[DataMember]
public SyncedEntry<bool> CooldownEnabled { get; private set; }
[DataMember]
public SyncedEntry<float> CooldownTime { get; private set; }
[DataMember]
public SyncedEntry<bool> DeadPlayersYippeeAlivePlayers { get; private set; }
[DataMember]
public SyncedEntry<bool> DeadPlayerAlertsEnemyAI { get; private set; }
public ConfigEntry<KeyCode> ConfigKey { get; private set; }
public ConfigEntry<bool> DebugKey { get; private set; }
public ConfigEntry<bool> AllowVisuals { get; private set; }
public ConfigEntry<bool> AllowParticeSpam { get; private set; }
public ConfigEntry<bool> AllowYippeeOverlap { get; private set; }
public ConfigEntry<float> YippeeVolume { get; private set; }
public ConfigEntry<bool> RandomPitchedYippee { get; private set; }
public YippeeSyncedConfig(ConfigFile cfg)
{
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Expected O, but got Unknown
base.InitInstance(this);
YippeeVolume = cfg.Bind<float>("Gameplay", "Yippee Audio Volume", 1f, "Volume of the Yippee sound itself.\nNote: This will not affect AI detection, only local sound.");
NotifyEnemies = Extensions.BindSyncedEntry<bool>(cfg, "Gameplay", "Notify Enemy AI (HOST ONLY)", true, "Notify Enemies when someone shouts 'Yippee!'. This setting will only apply if you are the host.");
CooldownEnabled = Extensions.BindSyncedEntry<bool>(cfg, "Gameplay", "Yippee cooldown (HOST ONLY)", false, "Enables cooldowns when you are hosting the instance");
CooldownTime = Extensions.BindSyncedEntry<float>(cfg, "Gameplay", "Yippee cooldown time (HOST ONLY)", 2f, "The time (in seconds) it will take for the cooldown to stop");
DeadPlayersYippeeAlivePlayers = Extensions.BindSyncedEntry<bool>(cfg, "Gameplay", "Dead players can Yippee (HOST ONLY)", true, "Allow dead players to yippee");
EnemyAIDetectionRange = Extensions.ToSyncedEntry<int>(cfg.Bind<int>("Gameplay Advanced", "EnemyAI detection range (HOST ONLY)", 10, new ConfigDescription("DetectionRange for EnemyAI when shouting 'Yippee!' (HOST ONLY)\nDo not mess with this value unless you know what you're doing!", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>())));
EnemyAIDetectionVolume = Extensions.BindSyncedEntry<float>(cfg, "Gameplay Advanced", "EnemyAI detection volume (HOST ONLY)", 1f, "Detection volume for EnemyAI when shouting 'Yippee!' (HOST ONLY)\nNote: This is NOT the volume of the sound, only the volume of which the EnemyAI component hears the sound.\nDo not mess with this value unless you know what you're doing!");
DeadPlayerAlertsEnemyAI = Extensions.BindSyncedEntry<bool>(cfg, "Gameplay Advanced", "Dead players Yippee alerts AI (HOST ONLY)", false, "Dead players can yippe and alert AI (reduced range)");
ConfigKey = cfg.Bind<KeyCode>("Input", "Yippee Key Binding", (KeyCode)105, "The keybind you're using to shout 'Yippee!'");
RandomPitchedYippee = cfg.Bind<bool>("Audio", "Randomly pitched yippee", true, "Makes the pitch of the 'Yippee' when shouting be randomized");
AllowYippeeOverlap = cfg.Bind<bool>("Audio", "Allow overlapping Yippee", false, "Make the audio when spamming Yippe overlap instead of restarting\n(useful with 'Spam Particles')");
AllowVisuals = cfg.Bind<bool>("Visual", "Add visuals", true, "Adds visuals like particles when shouting 'Yippee!'");
AllowParticeSpam = cfg.Bind<bool>("Visual", "Spam particles", false, "Allows particles to be spammed\n(useful with 'Allow Yippee Overlap')");
DebugKey = cfg.Bind<bool>("Misc", "Show Debug Messages", false, "Whether or not debug messages appear inside the log");
RemoveOrphans(cfg);
}
private void RemoveOrphans(ConfigFile config)
{
PropertyInfo property = ((object)config).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)property.GetValue(config, null);
dictionary.Clear();
config.Save();
}
internal static void RequestSync()
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
if (!SyncedInstance<YippeeSyncedConfig>.IsClient)
{
return;
}
YippeeKeyPlugin.Instance.Log("Config Sync requested");
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(ByteSerializer<YippeeSyncedConfig>.IntSize, (Allocator)2, -1);
try
{
Extensions.SendMessage(val, "QMLCYipeeKey_plugin_OnRequestConfigSync", 0uL);
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
internal static void OnRequestSync(ulong clientId, FastBufferReader _)
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: 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)
if (!SyncedInstance<YippeeSyncedConfig>.IsHost)
{
return;
}
YippeeKeyPlugin.Instance.Log("Syncing config");
byte[] array = ByteSerializer<YippeeSyncedConfig>.SerializeToBytes(SyncedInstance<YippeeSyncedConfig>.Instance);
int num = array.Length;
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(num + ByteSerializer<YippeeSyncedConfig>.IntSize, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
Extensions.SendMessage(val, "QMLCYipeeKey_plugin_OnReceiveConfigSync", clientId);
}
catch (Exception arg)
{
YippeeKeyPlugin.Instance.LogError($"Error occurred syncing config with client: {clientId}\n{arg}");
}
finally
{
((IDisposable)(FastBufferWriter)(ref val)).Dispose();
}
}
internal static void OnReceiveSync(ulong _, FastBufferReader reader)
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
YippeeKeyPlugin.Instance.Log("Config file received");
if (!((FastBufferReader)(ref reader)).TryBeginRead(ByteSerializer<YippeeSyncedConfig>.IntSize))
{
YippeeKeyPlugin.Instance.LogError("Config sync error: Could not begin reading buffer.");
return;
}
int num = default(int);
((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
if (!((FastBufferReader)(ref reader)).TryBeginRead(num))
{
YippeeKeyPlugin.Instance.LogError("Config sync error: Host could not sync.");
return;
}
byte[] array = new byte[num];
((FastBufferReader)(ref reader)).ReadBytesSafe(ref array, num, 0);
try
{
((SyncedInstance<YippeeSyncedConfig>)(object)SyncedInstance<YippeeSyncedConfig>.Instance).SyncInstance(array);
YippeeKeyPlugin.Instance.Log("Config Synced succesfully!");
YippeeKeyPlugin.Instance.Log("Default config working? " + ((SyncedInstance<YippeeSyncedConfig>.Default == null) ? "Nope" : "Yes!"));
YippeeKeyPlugin.Instance.Log("Synced config working? " + ((SyncedInstance<YippeeSyncedConfig>.Instance == null) ? "Nope" : "Yes!"));
YippeeKeyPlugin.Instance.Log($"AIdistance:\nlocal:{SyncedInstance<YippeeSyncedConfig>.Default.EnemyAIDetectionRange.Value}\nSynced:{SyncedInstance<YippeeSyncedConfig>.Instance.EnemyAIDetectionRange.Value}");
YippeeKeyPlugin.Instance.Log($"AIVolume:\nlocal:{SyncedInstance<YippeeSyncedConfig>.Default.EnemyAIDetectionVolume.Value}\nSynced:{SyncedInstance<YippeeSyncedConfig>.Instance.EnemyAIDetectionVolume.Value}");
YippeeKeyPlugin.Instance.Log($"NotifyAI:\nlocal:{SyncedInstance<YippeeSyncedConfig>.Default.NotifyEnemies.Value}\nSynced:{SyncedInstance<YippeeSyncedConfig>.Instance.NotifyEnemies.Value}");
YippeeKeyPlugin.Instance.Log($"CooldownEnabled:\nlocal:{SyncedInstance<YippeeSyncedConfig>.Default.CooldownEnabled.Value}\nSynced:{SyncedInstance<YippeeSyncedConfig>.Instance.CooldownEnabled.Value}");
YippeeKeyPlugin.Instance.Log($"CooldownTime:\nlocal:{SyncedInstance<YippeeSyncedConfig>.Default.CooldownTime.Value}\nSynced:{SyncedInstance<YippeeSyncedConfig>.Instance.CooldownTime.Value}");
YippeeKeyPlugin.Instance.Log($"DeadPlayersCanYippee:\nlocal:{SyncedInstance<YippeeSyncedConfig>.Default.DeadPlayersYippeeAlivePlayers.Value}\nSynced:{SyncedInstance<YippeeSyncedConfig>.Instance.DeadPlayersYippeeAlivePlayers.Value}");
YippeeKeyPlugin.Instance.Log($"DeadPlayerAlertEnemyAI:\nlocal:{SyncedInstance<YippeeSyncedConfig>.Default.DeadPlayerAlertsEnemyAI.Value}\nSynced:{SyncedInstance<YippeeSyncedConfig>.Instance.DeadPlayerAlertsEnemyAI.Value}");
}
catch (Exception arg)
{
YippeeKeyPlugin.Instance.LogError($"Error syncing config instance!\n{arg}");
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
public static void InitializeLocalPlayer()
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Expected O, but got Unknown
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
if (SyncedInstance<YippeeSyncedConfig>.IsHost)
{
SyncedInstance<YippeeSyncedConfig>.MessageManager.RegisterNamedMessageHandler("QMLCYipeeKey_plugin_OnRequestConfigSync", new HandleNamedMessageDelegate(OnRequestSync));
SyncedInstance<YippeeSyncedConfig>.Synced = true;
}
else
{
SyncedInstance<YippeeSyncedConfig>.Synced = false;
SyncedInstance<YippeeSyncedConfig>.MessageManager.RegisterNamedMessageHandler("QMLCYipeeKey_plugin_OnReceiveConfigSync", new HandleNamedMessageDelegate(OnReceiveSync));
RequestSync();
}
}
}
}
namespace YippeeKey.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
