using System.Collections.Generic;
using System.Diagnostics;
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 MCMP_Patch.Patches;
using TooManyEmotes;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("MCMP_Patch")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("MCMP_Patch")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("8a2b7984-d984-496c-b2dd-30d38fee4b73")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MCMP_Patch
{
internal class CustomLogging
{
private static ManualLogSource logger;
public static void InitLogger()
{
try
{
logger = Logger.CreateLogSource($"{((BaseUnityPlugin)Plugin.instance).Info.Metadata.Name}-{((BaseUnityPlugin)Plugin.instance).Info.Metadata.Version}");
}
catch
{
logger = Plugin.defaultLogger;
}
}
public static void Log(string message)
{
logger.LogInfo((object)message);
}
public static void LogError(string message)
{
logger.LogError((object)message);
}
public static void LogWarning(string message)
{
logger.LogWarning((object)message);
}
public static bool Assert(bool condition, string failMessage)
{
if (!condition)
{
LogWarning(failMessage);
}
return condition;
}
}
[HarmonyPatch]
public static class EmoteAchievementManager
{
public enum Achievements
{
DominoEffect,
SpaceIsTheBest,
ItIsWhatItIs,
FallGuy,
GenerationalCrashout,
CheddahLaden,
JiggleJiggle,
DoNotRedeem,
ShouldNotHaveSaidThat,
SixThirtyTustinAvenue,
BirdIsTheWord,
Firework,
Scrambled,
NewWheels,
LeaveTheDoorOpen,
LookinGood,
CreditDreams,
TheShipGuy,
HotToGo,
SleepDialysisDemon,
SeeYaLater,
XmasInHarlem
}
public static Dictionary<Achievements, (string, string)> EmoteAchievements = new Dictionary<Achievements, (string, string)>();
public static void RegisterEmoteAchievement(Achievements achievementName, string emoteName, string achievementText)
{
EmoteAchievements.Add(achievementName, (emoteName, achievementText));
}
private static (string, string) GetAchievementData(Achievements achievementName)
{
if (EmoteAchievements.TryGetValue(achievementName, out var value))
{
return value;
}
return (null, null);
}
public static void RegisterAchievements()
{
RegisterEmoteAchievement(Achievements.DominoEffect, "dancin'_domino", "Domino Effect");
RegisterEmoteAchievement(Achievements.SpaceIsTheBest, "planetary_vibes", "Space Is the Best");
RegisterEmoteAchievement(Achievements.ItIsWhatItIs, "go_with_the_flow", "It Is What It Is");
RegisterEmoteAchievement(Achievements.FallGuy, "smug_dance", "Fall Guy");
RegisterEmoteAchievement(Achievements.GenerationalCrashout, "get_down", "Generational Crashout");
RegisterEmoteAchievement(Achievements.CheddahLaden, "hit_it", "Cheddah Laden");
RegisterEmoteAchievement(Achievements.JiggleJiggle, "jiggle_jiggle", "Jiggle Jiggle");
RegisterEmoteAchievement(Achievements.DoNotRedeem, "sad_trombone", "Do Not Redeem!");
RegisterEmoteAchievement(Achievements.ShouldNotHaveSaidThat, "socks", "Should Not Have Said That");
RegisterEmoteAchievement(Achievements.SixThirtyTustinAvenue, "stuck", "Welcome to 630 Tustin Ave.");
RegisterEmoteAchievement(Achievements.BirdIsTheWord, "bird_is_the_word", "Bird Is the Word");
RegisterEmoteAchievement(Achievements.Scrambled, "chicken_wing_it", "Scrambled!");
RegisterEmoteAchievement(Achievements.NewWheels, "freedom_wheels", "New Wheels");
RegisterEmoteAchievement(Achievements.LeaveTheDoorOpen, "leave_the_door_open", "Leave The Door Open");
RegisterEmoteAchievement(Achievements.LookinGood, "looking_good", "Lookin' Good!");
RegisterEmoteAchievement(Achievements.HotToGo, "get_hot", "Hot To Go!");
RegisterEmoteAchievement(Achievements.SleepDialysisDemon, "boo'd_up_groove", "Sleep Dialysis Demon");
RegisterEmoteAchievement(Achievements.SeeYaLater, "bye_bye_bye", "See Ya Later!");
RegisterEmoteAchievement(Achievements.XmasInHarlem, "all_i_want_for_christmas", "Christmas in Harlem");
RegisterEmoteAchievement(Achievements.CreditDreams, "lucid_dreams", "Credit Dreams...");
RegisterEmoteAchievement(Achievements.TheShipGuy, "smooth_operator", "The Ship Guy");
CustomLogging.Log("Registered " + EmoteAchievements.Count + " emote achievements");
}
[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
[HarmonyPostfix]
public static void Init()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
if (HelperTools.IsClient)
{
HelperTools.PatchNetworkManager.CustomMessagingManager.RegisterNamedMessageHandler("MCMP_Patch.OnUnlockEmoteClientRpc", new HandleNamedMessageDelegate(OnUnlockEmoteClientRpc));
}
}
public static void SyncEmoteUnlockWithClients(int emoteId)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
int num = 2;
FastBufferWriter val = default(FastBufferWriter);
((FastBufferWriter)(ref val))..ctor(num, (Allocator)2, -1);
short num2 = (short)emoteId;
((FastBufferWriter)(ref val)).WriteValue<short>(ref num2, default(ForPrimitives));
PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
foreach (PlayerControllerB val2 in allPlayerScripts)
{
HelperTools.PatchNetworkManager.CustomMessagingManager.SendNamedMessage("MCMP_Patch.OnUnlockEmoteClientRpc", val2.playerClientId, val, (NetworkDelivery)3);
}
}
private static void OnUnlockEmoteClientRpc(ulong clientId, FastBufferReader reader)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
if (HelperTools.IsClient)
{
short num = default(short);
((FastBufferReader)(ref reader)).ReadValue<short>(ref num, default(ForPrimitives));
if (!SessionManager.IsEmoteUnlocked(EmotesManager.allUnlockableEmotes[num], HelperTools.LocalPlayerController.playerUsername))
{
SessionManager.UnlockEmoteLocal((int)num, false, HelperTools.LocalPlayerController.playerUsername);
}
}
}
public static void TryUnlockEmoteAchievement(Achievements achievement, string playerUsername, bool serverUnlock = false)
{
var (text, achievementName) = GetAchievementData(achievement);
if (text == null)
{
CustomLogging.LogWarning("Invalid emote ID for achievement " + achievement);
return;
}
UnlockableEmote val = EmotesManager.allUnlockableEmotesDict[text];
if (!SessionManager.IsEmoteUnlocked(text, playerUsername))
{
SessionManager.UnlockEmoteLocal(val, false, playerUsername);
AddAchievement(achievementName, serverUnlock ? "All employees" : playerUsername);
HelperTools.AddChatMessage(val.displayNameColorCoded + " emote unlocked!");
}
if (serverUnlock)
{
SyncEmoteUnlockWithClients(val.emoteId);
}
}
private static void AddAchievement(string achievementName, string playerUsername)
{
HelperTools.AddChatMessage(string.Concat("<color=yellow>" + playerUsername + " unlocked an achievement:</color> ", achievementName));
}
}
internal static class HelperTools
{
public static NetworkManager PatchNetworkManager => NetworkManager.Singleton;
public static bool IsClient => PatchNetworkManager.IsClient;
public static bool IsServer => PatchNetworkManager.IsServer;
public static bool IsHost => PatchNetworkManager.IsHost;
public static PlayerControllerB LocalPlayerController => StartOfRound.Instance?.localPlayerController;
public static void AddChatMessage(string text)
{
HUDManager.Instance.AddTextToChatOnServer(text, -1);
}
}
[BepInPlugin("Vijuhas.MCMP_Patch", "MCMP_Patch", "1.1.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
private readonly Harmony harmony = new Harmony("Vijuhas.MCMP_Patch");
public static Plugin instance;
public static ManualLogSource defaultLogger => ((BaseUnityPlugin)instance).Logger;
private void Awake()
{
if ((Object)(object)instance == (Object)null)
{
instance = this;
}
CustomLogging.InitLogger();
EmoteAchievementManager.RegisterAchievements();
harmony.PatchAll(typeof(Plugin));
harmony.PatchAll(typeof(EmoteAchievementManager));
harmony.PatchAll(typeof(CauseOfDeathPatch));
harmony.PatchAll(typeof(TerminalPatch));
harmony.PatchAll(typeof(GrabbableObjectGrabItemPatch));
harmony.PatchAll(typeof(GrabbableObjectBroughtToShipPatch));
harmony.PatchAll(typeof(MouthDogAIPatch));
harmony.PatchAll(typeof(EntranceTeleportPatch));
harmony.PatchAll(typeof(DepositItemsDeskPatch));
harmony.PatchAll(typeof(GiantKiwiAIPatch));
harmony.PatchAll(typeof(VehicleControllerPatch));
harmony.PatchAll(typeof(DressGirlAIPatch));
CustomLogging.Log("Vijuhas.MCMP_Patch has loaded successfully.");
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "Vijuhas.MCMP_Patch";
public const string PLUGIN_NAME = "MCMP_Patch";
public const string PLUGIN_VERSION = "1.1.1";
}
}
namespace MCMP_Patch.Patches
{
[HarmonyPatch(typeof(DepositItemsDesk), "Attack")]
internal class DepositItemsDeskPatch
{
[HarmonyPostfix]
private static void Postfix()
{
string playerUsername = GameNetworkManager.Instance.localPlayerController.playerUsername;
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.DoNotRedeem, playerUsername);
}
}
[HarmonyPatch(typeof(DressGirlAI), "BeginChasing")]
internal class DressGirlAIPatch
{
[HarmonyPostfix]
private static void Postfix(DressGirlAI __instance)
{
if ((Object)(object)__instance.hauntingPlayer != (Object)null)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.SleepDialysisDemon, __instance.hauntingPlayer.playerUsername);
}
}
}
[HarmonyPatch(typeof(EntranceTeleport), "TeleportPlayer")]
internal class EntranceTeleportPatch
{
[HarmonyPostfix]
private static void Postfix(EntranceTeleport __instance)
{
int num = 1;
if (__instance.isEntranceToBuilding && RoundManager.Instance.currentDungeonType == num)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.SixThirtyTustinAvenue, HelperTools.LocalPlayerController.playerUsername);
}
}
}
[HarmonyPatch(typeof(GiantKiwiAI), "FinishPryOpenDoor")]
internal class GiantKiwiAIPatch
{
[HarmonyPostfix]
private static void Postfix()
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.BirdIsTheWord, HelperTools.LocalPlayerController.playerUsername, serverUnlock: true);
}
}
[HarmonyPatch(typeof(GrabbableObject), "GrabItem")]
internal class GrabbableObjectGrabItemPatch
{
[HarmonyPostfix]
private static void Postfix(GrabbableObject __instance)
{
if (105f * __instance.playerHeldBy.carryWeight - 105f > 100f)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.CheddahLaden, __instance.playerHeldBy.playerUsername);
}
}
}
[HarmonyPatch(typeof(GrabbableObject), "OnBroughtToShip")]
internal class GrabbableObjectBroughtToShipPatch
{
private static readonly string cashRegisterItemName = "Cash register";
private static readonly string eggItemName = "Egg";
private static readonly string giftBoxItemName = "Gift Box";
[HarmonyPostfix]
private static void Postfix(GrabbableObject __instance)
{
if ((Object)(object)__instance.playerHeldBy != (Object)null)
{
if (__instance.itemProperties.itemName == cashRegisterItemName)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.JiggleJiggle, __instance.playerHeldBy.playerUsername);
}
else if (__instance.itemProperties.itemName == eggItemName)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.Scrambled, __instance.playerHeldBy.playerUsername);
}
else if (__instance.itemProperties.itemName == giftBoxItemName)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.XmasInHarlem, __instance.playerHeldBy.playerUsername);
}
}
}
}
[HarmonyPatch(typeof(Terminal), "RunTerminalEvents")]
internal class InfiniteCreditsPatch
{
[HarmonyPostfix]
private static void Postfix(ref int ___groupCredits)
{
___groupCredits = 69420;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
internal class CauseOfDeathPatch
{
[HarmonyPostfix]
private static void Postfix(CauseOfDeath causeOfDeath, PlayerControllerB __instance)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Invalid comparison between Unknown and I4
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Invalid comparison between Unknown and I4
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Invalid comparison between Unknown and I4
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Invalid comparison between Unknown and I4
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Invalid comparison between Unknown and I4
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Invalid comparison between Unknown and I4
string playerUsername = __instance.playerUsername;
if ((int)causeOfDeath == 1)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.ItIsWhatItIs, playerUsername);
}
else if ((int)causeOfDeath == 2)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.FallGuy, playerUsername);
}
else if ((int)causeOfDeath == 16)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.GenerationalCrashout, playerUsername);
}
else if ((int)causeOfDeath == 3)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.Firework, playerUsername);
}
else if ((int)causeOfDeath == 13)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.HotToGo, playerUsername);
}
else if ((int)causeOfDeath == 10)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.SeeYaLater, playerUsername);
}
}
}
[HarmonyPatch(typeof(MouthDogAI), "KillPlayer")]
internal class MouthDogAIPatch
{
[HarmonyPostfix]
private static void Postfix(int playerId)
{
PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[playerId];
if ((Object)(object)val != (Object)null)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.ShouldNotHaveSaidThat, val.playerUsername);
}
}
}
[HarmonyPatch(typeof(Terminal), "ParsePlayerSentence")]
internal class TerminalPatch
{
private static readonly int inverseTpUnlockableID = 19;
private static readonly int purpleSuitUnlockableID = 24;
[HarmonyPostfix]
private static void Postfix(ref TerminalNode __result, Terminal __instance)
{
if (__instance.screenText.text.Length <= 0)
{
return;
}
string text = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded).ToLower();
if (text.Split(new char[1] { ' ' }).Length != 0 && "confirm".StartsWith(text))
{
string playerUsername = GetPlayerUsingTerminal()?.playerUsername;
if (__result.shipUnlockableID == inverseTpUnlockableID)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.DominoEffect, playerUsername, serverUnlock: true);
}
else if (__result.shipUnlockableID == purpleSuitUnlockableID)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.LookinGood, playerUsername, serverUnlock: true);
}
else if (__result.buyRerouteToMoon != -1 && __result.buyRerouteToMoon != -2 && __result.itemCost > 0 && StartOfRound.Instance.inShipPhase && !StartOfRound.Instance.travellingToNewLevel)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.SpaceIsTheBest, playerUsername);
}
}
}
public static PlayerControllerB GetPlayerUsingTerminal()
{
PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
foreach (PlayerControllerB val in allPlayerScripts)
{
if (val.inTerminalMenu)
{
return val;
}
}
return null;
}
}
[HarmonyPatch(typeof(VehicleController), "SetIgnition")]
internal class VehicleControllerPatch
{
[HarmonyPostfix]
private static void Postfix(VehicleController __instance)
{
if ((Object)(object)__instance.currentDriver != (Object)null)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.NewWheels, __instance.currentDriver.playerUsername);
}
if ((Object)(object)__instance.currentPassenger != (Object)null)
{
EmoteAchievementManager.TryUnlockEmoteAchievement(EmoteAchievementManager.Achievements.NewWheels, __instance.currentPassenger.playerUsername);
}
}
}
}
