using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LCSoundTool;
using LethalFarts.NetcodePatcher;
using LethalFarts.Patches;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("LethalFarts")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LethalFarts")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("cec75e91-616f-48da-bd7b-e56ab8750399")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: NetcodePatchedAssembly]
internal class <Module>
{
static <Module>()
{
}
}
namespace LethalFarts
{
[BepInPlugin("BradStar879.LethalFarts", "Lethal Farts", "1.0.2")]
public class LethalFartsBase : BaseUnityPlugin
{
private const string PLUGIN_GUID = "BradStar879.LethalFarts";
private const string PLUGIN_NAME = "Lethal Farts";
private const string PLUGIN_VERSION = "1.0.2";
private readonly Harmony harmony = new Harmony("BradStar879.LethalFarts");
internal static LethalFartsBase Instance;
private ManualLogSource mls;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
mls = Logger.CreateLogSource("BradStar879.LethalFarts");
mls.LogInfo((object)"Lethal Farts Initialized");
harmony.PatchAll(typeof(LethalFartsBase));
harmony.PatchAll(typeof(PlayerFartPatch));
harmony.PatchAll(typeof(DeathFartPatch));
harmony.PatchAll(typeof(LethalFartsNetworkObjectManager));
NetcodePatcher();
}
internal static void Log(string message)
{
Instance.mls.LogInfo((object)message);
}
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);
}
}
}
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "BradStar879.LethalFarts";
public const string PLUGIN_NAME = "Lethal Farts";
public const string PLUGIN_VERSION = "1.0.2";
}
}
namespace LethalFarts.Patches
{
[HarmonyPatch(typeof(DeadBodyInfo))]
internal class DeathFartPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void DeathPatch(ref AudioSource ___bodyAudio)
{
if ((Object)(object)___bodyAudio != (Object)null)
{
AudioClip val = PlayerFartPatch.farts[3];
___bodyAudio.PlayOneShot(val);
}
}
}
internal class LethalFartsNetworkHandler : NetworkBehaviour
{
public static LethalFartsNetworkHandler Instance { get; private set; }
public static event Action<string> FartEvent;
public override void OnNetworkSpawn()
{
LethalFartsNetworkHandler.FartEvent = null;
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
LethalFartsNetworkHandler instance = Instance;
if (instance != null)
{
((Component)instance).gameObject.GetComponent<NetworkObject>().Despawn(true);
}
}
Instance = this;
((NetworkBehaviour)this).OnNetworkSpawn();
}
[ServerRpc(RequireOwnership = false)]
public void EventServerRpc(string eventName)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: 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_00ba: 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(4084531423u, val, (RpcDelivery)0);
bool flag = eventName != null;
((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
if (flag)
{
((FastBufferWriter)(ref val2)).WriteValueSafe(eventName, false);
}
((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4084531423u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
{
EventClientRpc(eventName);
}
}
[ClientRpc]
private void EventClientRpc(string eventName)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: 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_00ba: 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(934466365u, val, (RpcDelivery)0);
bool flag = eventName != null;
((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
if (flag)
{
((FastBufferWriter)(ref val2)).WriteValueSafe(eventName, false);
}
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 934466365u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
{
LethalFartsNetworkHandler.FartEvent?.Invoke(eventName);
}
}
protected override void __initializeVariables()
{
((NetworkBehaviour)this).__initializeVariables();
}
[RuntimeInitializeOnLoadMethod]
internal static void InitializeRPCS_LethalFartsNetworkHandler()
{
//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(4084531423u, new RpcReceiveHandler(__rpc_handler_4084531423));
NetworkManager.__rpc_func_table.Add(934466365u, new RpcReceiveHandler(__rpc_handler_934466365));
}
private static void __rpc_handler_4084531423(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_0061: 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)
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);
}
target.__rpc_exec_stage = (__RpcExecStage)1;
((LethalFartsNetworkHandler)(object)target).EventServerRpc(eventName);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_934466365(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_0061: 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)
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);
}
target.__rpc_exec_stage = (__RpcExecStage)2;
((LethalFartsNetworkHandler)(object)target).EventClientRpc(eventName);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
protected internal override string __getTypeName()
{
return "LethalFartsNetworkHandler";
}
}
[HarmonyPatch]
internal class LethalFartsNetworkObjectManager
{
private static GameObject networkPrefab;
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "Start")]
private static void Init()
{
if (!((Object)(object)networkPrefab != (Object)null))
{
LethalFartsBase.Log("Loading assets");
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
AssetBundle val = AssetBundle.LoadFromFile(Path.Combine(directoryName, "LethalFartsAssets"));
networkPrefab = val.LoadAsset<GameObject>("LethalFartsNetworkHandler");
networkPrefab.AddComponent<LethalFartsNetworkHandler>();
LethalFartsBase.Log("Added component");
NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "Awake")]
private static void SpawnNetworkHandler()
{
//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)
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
GameObject val = Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity);
val.GetComponent<NetworkObject>().Spawn(false);
LethalFartsBase.Log("Spawned Network Object");
}
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal class PlayerFartPatch
{
private static float timeToFart;
public static AudioClip[] farts;
private static Dictionary<string, AudioSource> audioSourceMap;
private static GameObject networkPrefab;
private static GameObject networkHandlerHost;
private static readonly string eventDelimiter = ":||:";
private static bool forceFart = false;
[HarmonyPatch("Awake")]
[HarmonyPostfix]
public static void Init()
{
if (farts == null)
{
ResetFartTimer();
farts = (AudioClip[])(object)new AudioClip[21];
audioSourceMap = new Dictionary<string, AudioSource>();
string text = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location).Split(new char[1] { '\\' })[^1];
for (int i = 0; i < 21; i++)
{
string text2 = "Fart-" + (i + 1) + ".wav";
farts[i] = SoundTool.GetAudioClip(text, "Fart_Sounds", text2);
}
LethalFartsBase.Log("Farts Initialized");
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(RoundManager), "GenerateNewFloor")]
private static void SubscribeToHandler()
{
LethalFartsNetworkHandler.FartEvent += ReceivedEventFromServer;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(RoundManager), "DespawnPropsAtEndOfRound")]
private static void UnsubscribeFromHandler()
{
LethalFartsNetworkHandler.FartEvent -= ReceivedEventFromServer;
}
private static void ReceivedEventFromServer(string eventName)
{
string[] array = eventName.Split(new string[1] { eventDelimiter }, StringSplitOptions.None);
string playerName = array[1];
int fartIndex = int.Parse(array[2]);
PlayFartFromPlayer(playerName, fartIndex);
}
private static void SendEventToClients(string eventName)
{
LethalFartsNetworkHandler.Instance.EventServerRpc(eventName);
}
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void FartPatch(ref AudioSource ___movementAudio, ref string ___playerUsername, ref bool ___isCameraDisabled, ref bool ___isInHangarShipRoom, ref StartOfRound ___playersManager, ref Transform ___thisPlayerBody, ref bool ___isCrouching)
{
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
if (!audioSourceMap.ContainsKey(___playerUsername))
{
audioSourceMap[___playerUsername] = ___movementAudio;
}
if (!___isCameraDisabled && !StartOfRound.Instance.inShipPhase && TimeOfDay.Instance.currentDayTimeStarted)
{
float num = (___isCrouching ? (Time.deltaTime * 2f) : Time.deltaTime);
timeToFart -= num;
if (timeToFart <= 0f || forceFart)
{
bool noiseIsInsideClosedShip = ___isInHangarShipRoom && ___playersManager.hangarDoorsClosed;
Fart(___thisPlayerBody.position, noiseIsInsideClosedShip, ___playerUsername);
}
}
}
[HarmonyPatch("Jump_performed")]
[HarmonyPostfix]
private static void JumpPatch(ref bool ___isCameraDisabled)
{
if (!___isCameraDisabled && !StartOfRound.Instance.inShipPhase && TimeOfDay.Instance.currentDayTimeStarted)
{
float num = Random.Range(0, 100);
if (num < 12f)
{
forceFart = true;
}
}
}
private static void Fart(Vector3 position, bool noiseIsInsideClosedShip, string playerName)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
if (audioSourceMap.ContainsKey(playerName))
{
int num = Random.Range(0, 21);
RoundManager.Instance.PlayAudibleNoise(position, 22f, 0.6f, 0, noiseIsInsideClosedShip, 0);
string eventName = "Fart" + eventDelimiter + playerName + eventDelimiter + num;
SendEventToClients(eventName);
}
ResetFartTimer();
forceFart = false;
}
private static void PlayFartFromPlayer(string playerName, int fartIndex)
{
if (audioSourceMap.ContainsKey(playerName))
{
LethalFartsBase.Log("Player: " + playerName + " Farting with fart: " + fartIndex);
AudioClip val = farts[fartIndex];
audioSourceMap[playerName].PlayOneShot(val);
}
}
private static void ResetFartTimer()
{
timeToFart = Random.Range(120, 360);
}
}
}
namespace LethalFarts.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
