using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EggFixes.Patches;
using GameNetcodeStuff;
using HarmonyLib;
using Unity.Collections;
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("Egg")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("EasterEggFixes")]
[assembly: AssemblyCopyright("Spookybuddy 2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("28f2f16b-6471-4c7e-b0a4-007e3a2450d4")]
[assembly: AssemblyFileVersion("2.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("2.0.0.0")]
namespace EggFixes
{
internal class ConfigControl : SyncedInstance<ConfigControl>
{
public ConfigEntry<bool> cfgEnabled;
public ConfigEntry<EasterEggFixesModBase.EggSettings> cfgExplodeWhen;
public ConfigEntry<int> cfgChance;
internal bool Enabled
{
get
{
if (cfgEnabled != null)
{
return cfgEnabled.Value;
}
return true;
}
set
{
cfgEnabled.Value = value;
}
}
internal EasterEggFixesModBase.EggSettings ExplodeWhen
{
get
{
if (cfgExplodeWhen == null)
{
return (EasterEggFixesModBase.EggSettings)((ConfigEntryBase)cfgExplodeWhen).DefaultValue;
}
return cfgExplodeWhen.Value;
}
set
{
cfgExplodeWhen.Value = value;
}
}
internal int Chance
{
get
{
if (cfgChance.Value > 0 && cfgChance.Value < 100)
{
return cfgChance.Value;
}
return (int)((ConfigEntryBase)cfgChance).DefaultValue;
}
set
{
cfgChance.Value = value;
}
}
public ConfigControl(ConfigFile cfg)
{
InitInstance(this);
cfgEnabled = cfg.Bind<bool>("Eggs", "Enabled", true, "Turn the mod on.");
cfgExplodeWhen = cfg.Bind<EasterEggFixesModBase.EggSettings>("Eggs", "Explode When", EasterEggFixesModBase.EggSettings.ExplodeOnThrow, "When should the eggs explode?");
cfgChance = cfg.Bind<int>("Eggs", "Chance to Explode", 16, "The percent chance for the eggs to explode when set to 'ChanceToExplode'. \nRanges from 1 - 99");
}
}
[Serializable]
public class SyncedInstance<T>
{
[NonSerialized]
protected static int IntSize = 4;
internal static CustomMessagingManager MessageManager => NetworkManager.Singleton.CustomMessagingManager;
internal static bool IsClient => NetworkManager.Singleton.IsClient;
internal static bool IsHost => NetworkManager.Singleton.IsHost;
public static T Default { get; private set; }
public static T Instance { get; private set; }
public static bool Synced { get; internal set; }
protected void InitInstance(T instance)
{
Default = instance;
Instance = instance;
IntSize = 4;
}
internal static void SyncInstance(byte[] data)
{
Instance = DeserializeFromBytes(data);
Synced = true;
}
internal static void RevertSync()
{
Instance = Default;
Synced = false;
}
public static byte[] SerializeToBytes(T val)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
MemoryStream memoryStream = new MemoryStream();
try
{
binaryFormatter.Serialize(memoryStream, val);
return memoryStream.ToArray();
}
catch (Exception arg)
{
EasterEggFixesModBase.mls.LogError((object)$"Error serializing instance: {arg}");
return null;
}
}
public static T DeserializeFromBytes(byte[] data)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
MemoryStream serializationStream = new MemoryStream(data);
try
{
return (T)binaryFormatter.Deserialize(serializationStream);
}
catch (Exception arg)
{
EasterEggFixesModBase.mls.LogError((object)$"Error deserializing instance: {arg}");
return default(T);
}
}
public static void RequestSync()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (IsClient)
{
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(IntSize, (Allocator)2, -1);
MessageManager.SendNamedMessage("EasterEggFixes_OnRequestConfigSync", 0uL, val, (NetworkDelivery)3);
}
}
public static void OnRequestSync(ulong clientId, FastBufferReader _)
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
if (!IsHost)
{
return;
}
EasterEggFixesModBase.mls.LogInfo((object)$"Config sync request received from client: {clientId}");
byte[] array = SerializeToBytes(Instance);
int num = array.Length;
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(num + IntSize, (Allocator)2, -1);
try
{
((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
MessageManager.SendNamedMessage("EasterEggFixes_OnReceiveConfigSync", clientId, val, (NetworkDelivery)3);
}
catch (Exception arg)
{
EasterEggFixesModBase.mls.LogInfo((object)$"Error occurred syncing config with client: {clientId}\n{arg}");
}
}
public static void OnReceiveSync(ulong _, FastBufferReader reader)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
if (!((FastBufferReader)(ref reader)).TryBeginRead(IntSize))
{
EasterEggFixesModBase.mls.LogError((object)"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))
{
EasterEggFixesModBase.mls.LogError((object)"Config sync error: Host could not sync.");
return;
}
byte[] data = new byte[num];
((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
SyncInstance(data);
EasterEggFixesModBase.mls.LogInfo((object)"Successfully synced config with host.");
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "SteamMatchmaking_OnLobbyMemberJoined")]
public static void InitializeLocalPlayer()
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: 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 (IsHost)
{
MessageManager.RegisterNamedMessageHandler("EasterEggFixes_OnRequestConfigSync", new HandleNamedMessageDelegate(OnRequestSync));
Synced = true;
}
else
{
Synced = false;
MessageManager.RegisterNamedMessageHandler("EasterEggFixes_OnReceiveConfigSync", new HandleNamedMessageDelegate(OnReceiveSync));
RequestSync();
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")]
public static void PlayerLeave()
{
SyncedInstance<ConfigControl>.RevertSync();
}
}
[BepInPlugin("EasterEggFixes", "EasterEggFixes", "2.0.1")]
public class EasterEggFixesModBase : BaseUnityPlugin
{
internal enum EggSettings
{
ExplodeOnThrow,
AlwaysExplode,
NeverExplode,
ChanceToExplode
}
public const string modGUID = "EasterEggFixes";
private const string modName = "EasterEggFixes";
private const string modVersion = "2.0.1";
private readonly Harmony harmony = new Harmony("EasterEggFixes");
internal ConfigControl Configuration;
internal static EasterEggFixesModBase Instance;
internal static ManualLogSource mls;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
mls = Logger.CreateLogSource("EasterEggFixes");
Configuration = new ConfigControl(((BaseUnityPlugin)this).Config);
harmony.PatchAll(typeof(EasterEggFixesModBase));
harmony.PatchAll(typeof(StunGrenadeItemPatch));
harmony.PatchAll(typeof(PlayerControllerBPatch));
mls.LogInfo((object)"Easter Egg Fixes was loaded.");
}
}
}
namespace EggFixes.Patches
{
[HarmonyPatch(typeof(PlayerControllerB))]
internal class PlayerControllerBPatch
{
[HarmonyPatch("DiscardHeldObject")]
[HarmonyPrefix]
private static bool ThrowPrep(bool placeObject, NetworkObject parentObjectTo, Vector3 placePosition, PlayerControllerB __instance)
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: Unknown result type (might be due to invalid IL or missing references)
//IL_015d: Unknown result type (might be due to invalid IL or missing references)
//IL_0167: Unknown result type (might be due to invalid IL or missing references)
//IL_018d: Unknown result type (might be due to invalid IL or missing references)
if (!SyncedInstance<ConfigControl>.Instance.Enabled || SyncedInstance<ConfigControl>.Instance.ExplodeWhen != 0)
{
return true;
}
if (__instance.currentlyHeldObjectServer.itemProperties.itemName.Equals("Easter egg") && placeObject && (Object)(object)parentObjectTo == (Object)null && placePosition != default(Vector3))
{
EasterEggFixesModBase.mls.LogWarning((object)"Egg Thrown!");
__instance.playerBodyAnimator.SetBool("cancelHolding", true);
__instance.playerBodyAnimator.SetTrigger("Throw");
((Behaviour)HUDManager.Instance.itemSlotIcons[__instance.currentItemSlot]).enabled = false;
((Behaviour)HUDManager.Instance.holdingTwoHandedItem).enabled = false;
placePosition = ((!__instance.isInElevator) ? StartOfRound.Instance.propsContainer.InverseTransformPoint(placePosition) : StartOfRound.Instance.elevatorTransform.InverseTransformPoint(placePosition));
__instance.SetObjectAsNoLongerHeld(__instance.isInElevator, __instance.isInHangarShipRoom, placePosition, __instance.currentlyHeldObjectServer, (int)((Component)__instance).transform.localEulerAngles.y);
__instance.currentlyHeldObjectServer.DiscardItemOnClient();
MethodInfo method = typeof(PlayerControllerB).GetMethod("ThrowObjectServerRpc", BindingFlags.Instance | BindingFlags.NonPublic);
NetworkObjectReference val = NetworkObjectReference.op_Implicit(((Component)__instance.currentlyHeldObjectServer).gameObject.GetComponent<NetworkObject>());
object[] parameters = new object[5] { val, __instance.isInElevator, __instance.isInHangarShipRoom, placePosition, -211 };
method.Invoke(__instance, parameters);
return false;
}
return true;
}
[HarmonyPatch("ThrowObjectServerRpc")]
[HarmonyPrefix]
private static void ThrowFix(NetworkObjectReference grabbedObject, bool droppedInElevator, bool droppedInShipRoom, Vector3 targetFloorPosition, int floorYRot, PlayerControllerB __instance)
{
if ((Object)(object)__instance.currentlyHeldObjectServer == (Object)null || !SyncedInstance<ConfigControl>.Instance.Enabled || SyncedInstance<ConfigControl>.Instance.ExplodeWhen != 0 || !__instance.currentlyHeldObjectServer.itemProperties.itemName.Equals("Easter egg"))
{
return;
}
if (floorYRot == -211)
{
EasterEggFixesModBase.mls.LogInfo((object)"BOOM!");
StunGrenadeItem val = default(StunGrenadeItem);
if (((Component)__instance.currentlyHeldObjectServer).TryGetComponent<StunGrenadeItem>(ref val))
{
val.chanceToExplode = 111f;
val.SetExplodeOnThrowServerRpc();
}
else
{
EasterEggFixesModBase.mls.LogError((object)"Threw an egg that did not have the StunGrenadeItem script!");
}
}
else
{
EasterEggFixesModBase.mls.LogInfo((object)"Dropped Egg!");
}
}
}
[HarmonyPatch(typeof(StunGrenadeItem))]
internal class StunGrenadeItemPatch
{
[HarmonyPatch("Start")]
[HarmonyPrefix]
private static void StartFix(StunGrenadeItem __instance)
{
if (SyncedInstance<ConfigControl>.Instance.Enabled && __instance.chanceToExplode != 100f)
{
switch (SyncedInstance<ConfigControl>.Instance.ExplodeWhen)
{
case EasterEggFixesModBase.EggSettings.AlwaysExplode:
__instance.chanceToExplode = 111f;
EasterEggFixesModBase.mls.LogInfo((object)"Eggs Always Explode");
break;
case EasterEggFixesModBase.EggSettings.ChanceToExplode:
__instance.chanceToExplode = SyncedInstance<ConfigControl>.Instance.Chance;
EasterEggFixesModBase.mls.LogInfo((object)"Eggs Sometimes Explode");
break;
default:
__instance.chanceToExplode = -1f;
EasterEggFixesModBase.mls.LogInfo((object)"Fixed an Egg");
break;
}
}
}
[HarmonyPatch("EquipItem")]
[HarmonyPostfix]
private static void EquipFix(StunGrenadeItem __instance)
{
if (SyncedInstance<ConfigControl>.Instance.Enabled && __instance.chanceToExplode != 100f)
{
switch (SyncedInstance<ConfigControl>.Instance.ExplodeWhen)
{
case EasterEggFixesModBase.EggSettings.AlwaysExplode:
__instance.chanceToExplode = 111f;
EasterEggFixesModBase.mls.LogInfo((object)"Egg will Always Explode");
break;
case EasterEggFixesModBase.EggSettings.ChanceToExplode:
__instance.chanceToExplode = SyncedInstance<ConfigControl>.Instance.Chance;
EasterEggFixesModBase.mls.LogInfo((object)("Egg will explode " + SyncedInstance<ConfigControl>.Instance.Chance + "%"));
break;
default:
__instance.chanceToExplode = -1f;
EasterEggFixesModBase.mls.LogInfo((object)"Picked up an Egg");
break;
}
__instance.SetExplodeOnThrowServerRpc();
}
}
}
}
