using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
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 BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using JollyLethal.HatActions;
using JollyLethal.HatConfigs;
using JollyLethal.Helper;
using LobbyCompatibility.Attributes;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("mishelin.JollyLethal")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.2.1.0")]
[assembly: AssemblyInformationalVersion("1.2.1+c1ec449fee9f0aabe62c567aed112ee3aaa579f0")]
[assembly: AssemblyProduct("JollyLethal")]
[assembly: AssemblyTitle("mishelin.JollyLethal")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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;
}
}
[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 JollyLethal
{
[BepInPlugin("mishelin.JollyLethal", "JollyLethal", "1.2.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[LobbyCompatibility(/*Could not decode attribute arguments.*/)]
public class JollyLethal : BaseUnityPlugin
{
internal static AssetBundle? myCustomAssets;
internal static GameObject mySantaHat;
internal const string myJollyHatSpawnedObjName = "mishelin.JollyLethal.JollyHatParent";
public static JollyLethal Instance { get; private set; }
internal static ManualLogSource Logger { get; private set; }
internal static Harmony? Harmony { get; set; }
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
Instance = this;
LoadAssets();
Patch();
Logger.LogInfo((object)"mishelin.JollyLethal v1.2.1 has loaded!");
}
internal void LoadAssets()
{
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
myCustomAssets = AssetLoader.AssetsAwake(directoryName);
if (myCustomAssets != null)
{
mySantaHat = AssetLoader.LoadSantaHat(myCustomAssets);
}
}
internal static void Patch()
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Expected O, but got Unknown
if (Harmony == null)
{
Harmony = new Harmony("mishelin.JollyLethal");
}
Logger.LogDebug((object)"Patching...");
Harmony.PatchAll();
Logger.LogDebug((object)"Finished patching!");
}
internal static void Unpatch()
{
Logger.LogDebug((object)"Unpatching...");
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
Logger.LogDebug((object)"Finished unpatching!");
}
internal static void PluginLogInfoWithPrefix(string content)
{
Logger.LogInfo((object)("[EVIL] " + content));
}
internal static void PluginLogErrorWithPrefix(string content)
{
Logger.LogError((object)("[EVIL] " + content));
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "mishelin.JollyLethal";
public const string PLUGIN_NAME = "JollyLethal";
public const string PLUGIN_VERSION = "1.2.1";
}
}
namespace JollyLethal.Helper
{
internal static class AssetLoader
{
private const string ASSET_BUNDLE_NAME = "lethal-mod-asset";
public static AssetBundle? AssetsAwake(string assemblyPath)
{
if (string.IsNullOrEmpty(assemblyPath))
{
JollyLethal.PluginLogErrorWithPrefix("Invalid assebmly path!!!");
return null;
}
AssetBundle val = AssetBundle.LoadFromFile(Path.Combine(assemblyPath, "lethal-mod-asset"));
if (val == null)
{
JollyLethal.PluginLogErrorWithPrefix("Failed to load custom assets !!!");
return null;
}
JollyLethal.PluginLogInfoWithPrefix("Successfully loaded custom assets.");
return val;
}
public static GameObject LoadSantaHat(AssetBundle customAssets)
{
GameObject result = customAssets.LoadAsset<GameObject>("assets/hatparent.prefab");
JollyLethal.PluginLogInfoWithPrefix("Successfully loaded in santa hat");
return result;
}
}
}
namespace JollyLethal.HatFixes
{
[HarmonyPatch(typeof(EnemyAI))]
internal class FixHatPositionOnEnemyStateChange
{
[CompilerGenerated]
private sealed class <HandleManeaterStateChange>d__2 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public int state;
public Transform enemy;
public Transform hat;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <HandleManeaterStateChange>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
//IL_00f8: 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_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: 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_00a3: 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)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(2.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
JollyLethal.PluginLogInfoWithPrefix("Handling Maneaters change of state");
if (state != 2 && IsManeaterInBabyState(enemy))
{
JollyLethal.PluginLogInfoWithPrefix("Changing hat position due to change of maneater appearance to smol");
var (pathToNewObj, pos, rot, scale) = EnemyHatConfigs.GetManeaterSantaHatConfig();
JollyHatActions.HatChangeParent(enemy, hat, pathToNewObj);
JollyHatActions.ApplyOffsetsToHat(hat, pos, rot, scale);
}
else
{
JollyLethal.PluginLogInfoWithPrefix("Changing hat position due to change of maneater appearance to big");
var (pathToNewObj2, pos2, rot2, scale2) = EnemyHatConfigs.GetManeaterBigSantaHatConfig();
JollyHatActions.HatChangeParent(enemy, hat, pathToNewObj2);
JollyHatActions.ApplyOffsetsToHat(hat, pos2, rot2, scale2);
}
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();
}
}
[HarmonyPatch("SwitchToBehaviourStateOnLocalClient")]
[HarmonyPostfix]
private static void FixEnemyHatPosition(EnemyAI __instance, int stateIndex)
{
Transform val = RecursiveFindChild(((Component)__instance).transform, "mishelin.JollyLethal.JollyHatParent");
if (val == null)
{
return;
}
string enemyName = __instance.enemyType.enemyName;
if (!(enemyName == "Jester"))
{
if (enemyName == "Maneater")
{
((MonoBehaviour)__instance).StartCoroutine(HandleManeaterStateChange(((Component)__instance).transform, val, stateIndex));
}
}
else
{
HandleJesterStateChange(((Component)__instance).transform, val, stateIndex);
}
}
private static void HandleJesterStateChange(Transform enemy, Transform hat, int state)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: 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)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: 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_0064: 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_0078: Unknown result type (might be due to invalid IL or missing references)
JollyLethal.PluginLogInfoWithPrefix("Handling Jesters change of state");
switch (state)
{
case 0:
case 1:
{
JollyLethal.PluginLogInfoWithPrefix("Changing hat position due to change of jester state to winding/chilling");
(string?, Vector3, Vector3, float) jesterSantaHatConfig = EnemyHatConfigs.GetJesterSantaHatConfig();
Vector3 item = jesterSantaHatConfig.Item2;
Vector3 item2 = jesterSantaHatConfig.Item3;
float item3 = jesterSantaHatConfig.Item4;
JollyHatActions.ApplyOffsetsToHat(hat, item, item2, item3);
break;
}
case 2:
JollyLethal.PluginLogInfoWithPrefix("Changing hat position due to change of jester state to popped");
var (pathToNewObj, pos, rot, scale) = EnemyHatConfigs.GetJesterPoppedSantaHatConfig();
JollyHatActions.HatChangeParent(enemy, hat, pathToNewObj);
JollyHatActions.ApplyOffsetsToHat(hat, pos, rot, scale);
break;
}
}
[IteratorStateMachine(typeof(<HandleManeaterStateChange>d__2))]
private static IEnumerator HandleManeaterStateChange(Transform enemy, Transform hat, int state)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <HandleManeaterStateChange>d__2(0)
{
enemy = enemy,
hat = hat,
state = state
};
}
internal static bool IsManeaterInBabyState(Transform maneater)
{
if (((Component)maneater.Find("BabyMeshContainer")).gameObject.activeSelf)
{
return !((Component)maneater.Find("MeshContainer")).gameObject.activeSelf;
}
return false;
}
internal static Transform? RecursiveFindChild(Transform parent, string childName)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Expected O, but got Unknown
foreach (Transform item in parent)
{
Transform val = item;
if (((Object)val).name == childName)
{
return val;
}
Transform val2 = RecursiveFindChild(val, childName);
if (val2 != null)
{
return val2;
}
}
return null;
}
}
[HarmonyPatch(typeof(RoundManager))]
internal class PutHatOnDormantOldBird
{
[HarmonyPatch("SpawnNestObjectForOutsideEnemy")]
[HarmonyPostfix]
private static void AddHatToDormantOldBird(RoundManager __instance)
{
foreach (EnemyAINestSpawnObject enemyNestSpawnObject in __instance.enemyNestSpawnObjects)
{
string enemyName = enemyNestSpawnObject.enemyType.enemyName;
JollyLethal.PluginLogInfoWithPrefix("NestSpawn: " + enemyName);
if (enemyName == "RadMech")
{
PlaceHatOnDormantOldBird(enemyNestSpawnObject);
}
}
}
private static void PlaceHatOnDormantOldBird(EnemyAINestSpawnObject enemy)
{
JollyLethal.PluginLogInfoWithPrefix("Dormant birdo");
PlaceHatsOnEnemiesPatch.PlaceHatOnEnemyTransform(((Component)enemy).transform, enemy.enemyType);
}
}
}
namespace JollyLethal.HatConfigs
{
internal class EnemyHatConfigs
{
internal static (string?, Vector3, Vector3, float) GetBrackenSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("FlowermanModel/AnimContainer/metarig/Torso1/Torso2/Torso3/Neck1/Neck2/Head1/Head2", new Vector3(0f, 0f, 0f), new Vector3(0f, 115f, 0f), 2f);
}
internal static (string?, Vector3, Vector3, float) GetHoardingBugSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("HoarderBugModel/AnimContainer/Armature/Abdomen/Chest/Head", new Vector3(0.25f, 2.2f, 0.1f), new Vector3(15f, 20f, 330f), 3f);
}
internal static (string?, Vector3, Vector3, float) GetSnareFleaSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("CentipedeModel/AnimContainer/Armature/Head", new Vector3(0f, 0.4f, 0.25f), new Vector3(0f, 90f, 90f), 1.5f);
}
internal static (string?, Vector3, Vector3, float) GetThumperSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("CrawlerModel/AnimContainer/metarig/spine/spine.003/spine.004", new Vector3(0f, 0.2635f, -0.02f), new Vector3(64f, 168f, 341f), 0.3f);
}
internal static (string?, Vector3, Vector3, float) GetBunkerSpiderSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("MeshContainer/AnimContainer/Armature/Head", new Vector3(0f, 0.9101f, 0.5545f), new Vector3(19f, 274f, 252f), 1.7525f);
}
internal static (string?, Vector3, Vector3, float) GetJesterSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("MeshContainer/AnimContainer/metarig/BoxContainer/spine.004/spine.005", new Vector3(-2.32f, -8.6f, 2.75f), new Vector3(344f, 292f, 181f), 18f);
}
internal static (string?, Vector3, Vector3, float) GetJesterPoppedSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("MeshContainer/AnimContainer/metarig/BoxContainer/spine.004/spine.005/spine.006/UpperJaw", new Vector3(0f, 0.1f, 1.2f), new Vector3(0f, 115f, 0f), 3f);
}
internal static (string?, Vector3, Vector3, float) GetNutcrackerSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("MeshContainer/AnimContainer/metarig/spinecontainer/spine/spine.001/head", new Vector3(0f, 0.5f, 0f), new Vector3(0f, 115f, 0f), 0.668f);
}
internal static (string?, Vector3, Vector3, float) GetSpringSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("SpringManModel/AnimContainer/metarig/spine/spine.001/spine.002/spine.003/springBone/springBone.001/springBone.002", new Vector3(0f, 0.3f, 0f), new Vector3(0f, 115f, 0f), 0.25f);
}
internal static (string?, Vector3, Vector3, float) GetMaskedSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("ScavengerModel/metarig/spine/spine.001/spine.002/spine.003/spine.004", new Vector3(0f, 0.27f, 0.05f), new Vector3(0f, 115f, 0f), 0.55f);
}
internal static (string?, Vector3, Vector3, float) GetButlerSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("MeshContainer/metarig/spine/spine.001/NeckContainer/spine.004/face", new Vector3(0f, 0.3f, 0f), new Vector3(0f, 115f, 0f), 0.8f);
}
internal static (string?, Vector3, Vector3, float) GetManeaterSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("BabyMeshContainer/BabyAnimContainer/Spine1/Spine3", new Vector3(-0.0067f, 0.4368f, 0.0076f), new Vector3(302f, 358f, 1f), 2f);
}
internal static (string?, Vector3, Vector3, float) GetManeaterBigSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("MeshContainer/AnimContainer/Spine/Spine1/Spine2/Bone.003", new Vector3(0f, 0f, -0.5f), new Vector3(280f, 180f, 180f), 3f);
}
internal static (string?, Vector3, Vector3, float) GetSporeLizardSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("PufferModel/AnimContainer/Armature/Base/Chest/Neck", new Vector3(0.5f, 0.5f, 0f), new Vector3(30f, 10f, 290f), 1f);
}
internal static (string?, Vector3, Vector3, float) GetMouthDogSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("MouthDogModel/AnimContainer/Armature/Neck1Container/Neck1/Neck2/JawUpper/", new Vector3(0f, 0.233f, -0.5545f), new Vector3(20f, 80f, 240f), 2.5f);
}
internal static (string?, Vector3, Vector3, float) GetBaboonHawkSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("BaboonBirdModel/AnimContainer/metarig/spine/spine.001/spine.003/spine.004/HeadBoneContainer", new Vector3(0f, 0.3f, 0.25f), new Vector3(0f, 90f, 0f), 0.7f);
}
internal static (string?, Vector3, Vector3, float) GetForestGiantSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("FGiantModelContainer/AnimContainer/metarig/spine/spine.003", new Vector3(0f, 0.5f, 0.05f), new Vector3(0f, 115f, 0f), 0.6f);
}
internal static (string?, Vector3, Vector3, float) GetOldBirdSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("MeshContainer/AnimContainer/metarig/TorsoContainer/Torso", new Vector3(0f, 4.4f, 0f), new Vector3(0f, 25f, 0f), 2.5f);
}
internal static (string?, Vector3, Vector3, float) GetTulipSnakeSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("FlowerLizardModel/AnimContainer/Armature/Belly/LowerChest/Chest/Chest.001/JawUpper/", new Vector3(0f, 0.6f, 0.4f), new Vector3(48f, 270f, 270f), 2f);
}
internal static (string?, Vector3, Vector3, float) GetGirlSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("DressGirlModel/AnimContainer/metarig/spine/spine.002/spine.003/spine.004", new Vector3(0f, 0.27f, -0.035f), new Vector3(10f, 115f, 340f), 0.4f);
}
internal static (string?, Vector3, Vector3, float) GetBlobSantaHatConfig()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
return ("Armature/Center", new Vector3(0f, 1.6f, 0f), new Vector3(0f, 170f, 0f), 3f);
}
internal static (string?, Vector3, Vector3, float) GetKidnapperFoxSantaHatConfig()
{
return GetIncompatibleSantaHatConfig();
}
internal static (string?, Vector3, Vector3, float) GetBarberSantaHatConfig()
{
return GetIncompatibleSantaHatConfig();
}
internal static (string?, Vector3, Vector3, float) GetIncompatibleSantaHatConfig()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return (null, Vector3.zero, Vector3.zero, 0f);
}
internal static (string?, Vector3, Vector3, float) GetDefaultSantaHatConfig()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return (null, Vector3.zero, Vector3.zero, 0f);
}
}
internal class ObjectHatConfigs
{
internal const string CatBonePath = "Cat_Simple_anim_IP/Arm_Cat/root_bone/Spine_base/spine_02/spine_03/spine_04/spine_05/neck/head";
internal const string TeethBonePath = "AnimContainer/MeshContainer/JawUpper";
internal static (bool, Vector3, Vector3, float) GetRubberDuckySantaHatConfig()
{
//IL_0010: 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)
return (true, new Vector3(0f, -0.2f, 2f), new Vector3(0f, 0f, 180f), 1f);
}
internal static (bool, Vector3, Vector3, float) GetGiftSantaHatConfig()
{
//IL_0010: 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)
return (true, new Vector3(0.7f, 1.5f, 2.2f), new Vector3(0f, 0f, 200f), 1f);
}
internal static (bool, Vector3, Vector3, float) GetTeethSantaHatConfig()
{
//IL_0010: 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)
return (true, new Vector3(0.7f, 1.5f, 2.2f), new Vector3(10f, 120f, 0f), 6f);
}
internal static (bool, Vector3, Vector3, float) GetCatSantaHatConfig()
{
//IL_0010: 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)
return (true, new Vector3(0f, 0.035f, 0.06f), new Vector3(80f, 0f, 0f), 0.11f);
}
internal static (bool, Vector3, Vector3, float) GetBeeHiveSantaHatConfig()
{
//IL_0010: 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)
return (true, new Vector3(0f, 1f, 0.2f), new Vector3(0f, 225f, 0f), 1.75f);
}
internal static (bool, Vector3, Vector3, float) GetFancyLampSantaHatConfig()
{
//IL_0010: 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)
return (true, new Vector3(0f, 0f, 2.25f), new Vector3(270f, 180f, 0f), 1f);
}
internal static (bool, Vector3, Vector3, float) GetPlasticCupSantaHatConfig()
{
//IL_0010: 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)
return (true, new Vector3(0f, 0f, 0.4f), new Vector3(270f, 180f, 0f), 0.9f);
}
internal static (bool, Vector3, Vector3, float) GetPicklesSantaHatConfig()
{
//IL_0010: 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)
return (true, new Vector3(0f, 0f, 2f), new Vector3(90f, 0f, 0f), 3f);
}
internal static (bool, Vector3, Vector3, float) GetToyRobotSantaHatConfig()
{
//IL_0010: 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)
return (true, new Vector3(0f, 0f, 2.35f), new Vector3(90f, 0f, 0f), 1.25f);
}
internal static (bool, Vector3, Vector3, float) GetOldPhoneSantaHatConfig()
{
//IL_0010: 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)
return (true, new Vector3(0f, 0.85f, 0f), new Vector3(0f, 115f, 0f), 1f);
}
internal static (bool, Vector3, Vector3, float) GetPlasticFishSantaHatConfig()
{
//IL_0010: 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)
return (true, new Vector3(0f, -0.7f, 1.3f), new Vector3(270f, 180f, 0f), 1f);
}
internal static (bool, Vector3, Vector3, float) GetDefaultSantaHatConfig()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return (true, Vector3.zero, Vector3.zero, 1f);
}
internal static (bool, Vector3, Vector3, float) GetIncompatibleSantaHatConfig()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return (false, Vector3.zero, Vector3.zero, 0f);
}
}
}
namespace JollyLethal.HatActions
{
internal class JollyHatActions
{
internal static bool DoesTransformAlreadyContainJollyHat(Transform parent, string pathToObject)
{
return parent.Find(pathToObject + "/mishelin.JollyLethal.JollyHatParent") != null;
}
internal static bool DoesTransformRootAlreadyContainJollyHat(Transform parent)
{
return parent.Find("mishelin.JollyLethal.JollyHatParent") != null;
}
internal static void HatChangeParent(Transform objParent, Transform hatParent, string pathToNewObj)
{
Transform val = objParent.Find(pathToNewObj);
if (val != null)
{
hatParent.SetParent(val, false);
}
}
internal static void FixHatParentChildPosScale(Transform parent)
{
//IL_0009: 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)
Transform child = parent.GetChild(0);
ApplyOffsetsToHat(child, Vector3.zero, Vector3.zero, 1f);
}
internal static void FixHatsScaleBasedOnSquishedParent(Transform objParent, Transform hatParent, float targetScale = 1f)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
Vector3 localScale = objParent.localScale;
hatParent.localScale = new Vector3(targetScale / localScale.x, targetScale / localScale.y, targetScale / localScale.z);
}
internal static void ApplyOffsetsToHat(Transform obj, Vector3 pos, Vector3 rot, float scale)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: 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)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
obj.localPosition = pos;
obj.localEulerAngles = rot;
obj.localScale = Vector3.one * scale;
}
internal static void ChangeRotOfHatParentChild(Transform hatParent, Vector3 newRot)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
Transform child = hatParent.GetChild(0);
child.localEulerAngles = newRot;
}
internal static Transform PlaceHatOnTransform(Transform targetBone, Vector3 posOffset, Vector3 rotOffset, float scale)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
GameObject val = Object.Instantiate<GameObject>(JollyLethal.mySantaHat, targetBone);
((Object)val).name = "mishelin.JollyLethal.JollyHatParent";
Transform transform = val.transform;
FixHatParentChildPosScale(transform);
ApplyOffsetsToHat(transform, posOffset, rotOffset, scale);
return transform;
}
}
[HarmonyPatch(typeof(MaskedPlayerEnemy))]
internal class PlaceHatOnMaskedPatch
{
[CompilerGenerated]
private sealed class <GiveHatToMaskedCoroutine>d__2 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public MaskedPlayerEnemy enemy;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <GiveHatToMaskedCoroutine>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(1.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
JollyLethal.PluginLogInfoWithPrefix("Placing santa hat on masked");
PlaceHatsOnEnemiesPatch.PlaceHatOnEnemyTransform(((Component)enemy).transform, ((EnemyAI)enemy).enemyType);
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 const float myWaitForSeconds = 1.5f;
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void GiveHatToMasked(MaskedPlayerEnemy __instance)
{
((MonoBehaviour)__instance).StartCoroutine(GiveHatToMaskedCoroutine(__instance));
}
[IteratorStateMachine(typeof(<GiveHatToMaskedCoroutine>d__2))]
private static IEnumerator GiveHatToMaskedCoroutine(MaskedPlayerEnemy enemy)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <GiveHatToMaskedCoroutine>d__2(0)
{
enemy = enemy
};
}
}
[HarmonyPatch(typeof(GrabbableObject))]
internal class PlaceHatsOnItemsPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void GiveEnemySantaHat(GrabbableObject __instance)
{
if (JollyLethal.myCustomAssets == null)
{
JollyLethal.PluginLogErrorWithPrefix("AssetBundle not loaded!!!");
}
else
{
PlaceHatOnObjectTransform(((Component)__instance).transform, __instance.itemProperties);
}
}
private static void FixAdditionalChildrenPositions(string itemName, Transform objParent, Transform hatParent)
{
//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
//IL_0138: Unknown result type (might be due to invalid IL or missing references)
//IL_015f: Unknown result type (might be due to invalid IL or missing references)
//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
if (itemName == null)
{
return;
}
switch (itemName.Length)
{
case 12:
switch (itemName[0])
{
case 'P':
if (itemName == "Plastic fish")
{
JollyHatActions.FixHatsScaleBasedOnSquishedParent(objParent, hatParent, 0.2f);
JollyHatActions.ChangeRotOfHatParentChild(hatParent, new Vector3(0f, 290f, 0f));
}
break;
case 'R':
if (itemName == "Rubber Ducky")
{
JollyHatActions.FixHatsScaleBasedOnSquishedParent(objParent, hatParent, 0.15f);
JollyHatActions.ChangeRotOfHatParentChild(hatParent, new Vector3(90f, 0f, 0f));
}
break;
}
break;
case 10:
if (itemName == "Fancy lamp")
{
JollyHatActions.ChangeRotOfHatParentChild(hatParent, new Vector3(0f, 25f, 0f));
}
break;
case 11:
if (itemName == "Plastic cup")
{
JollyHatActions.ChangeRotOfHatParentChild(hatParent, new Vector3(0f, 25f, 0f));
}
break;
case 14:
if (itemName == "Jar of pickles")
{
JollyHatActions.ChangeRotOfHatParentChild(hatParent, new Vector3(0f, 225f, 0f));
}
break;
case 9:
if (itemName == "Toy robot")
{
JollyHatActions.ChangeRotOfHatParentChild(hatParent, new Vector3(0f, 25f, 0f));
}
break;
case 3:
if (itemName == "Cat")
{
JollyHatActions.HatChangeParent(objParent, hatParent, "Cat_Simple_anim_IP/Arm_Cat/root_bone/Spine_base/spine_02/spine_03/spine_04/spine_05/neck/head");
JollyHatActions.ChangeRotOfHatParentChild(hatParent, new Vector3(0f, 250f, 0f));
}
break;
case 5:
if (itemName == "Teeth")
{
JollyHatActions.HatChangeParent(objParent, hatParent, "AnimContainer/MeshContainer/JawUpper");
}
break;
case 4:
if (itemName == "Gift")
{
JollyHatActions.FixHatsScaleBasedOnSquishedParent(objParent, hatParent, 0.5f);
JollyHatActions.ChangeRotOfHatParentChild(hatParent, new Vector3(90f, 0f, 0f));
}
break;
case 6:
case 7:
case 8:
case 13:
break;
}
}
internal static void PlaceHatOnObjectTransform(Transform itemTransform, Item itemProp)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
string itemName = itemProp.itemName;
var (flag, posOffset, rotOffset, scale) = GetItemHatConfig(itemName);
if (flag && !JollyHatActions.DoesTransformRootAlreadyContainJollyHat(itemTransform))
{
Transform hatParent = JollyHatActions.PlaceHatOnTransform(itemTransform, posOffset, rotOffset, scale);
FixAdditionalChildrenPositions(itemName, itemTransform, hatParent);
}
}
internal static (bool, Vector3, Vector3, float) GetItemHatConfig(string itemName)
{
return itemName switch
{
"Fancy lamp" => ObjectHatConfigs.GetFancyLampSantaHatConfig(),
"Plastic cup" => ObjectHatConfigs.GetPlasticCupSantaHatConfig(),
"Jar of pickles" => ObjectHatConfigs.GetPicklesSantaHatConfig(),
"Toy robot" => ObjectHatConfigs.GetToyRobotSantaHatConfig(),
"Old phone" => ObjectHatConfigs.GetOldPhoneSantaHatConfig(),
"Plastic fish" => ObjectHatConfigs.GetPlasticFishSantaHatConfig(),
"Hive" => ObjectHatConfigs.GetBeeHiveSantaHatConfig(),
"Rubber Ducky" => ObjectHatConfigs.GetRubberDuckySantaHatConfig(),
"Cat" => ObjectHatConfigs.GetCatSantaHatConfig(),
"Teeth" => ObjectHatConfigs.GetTeethSantaHatConfig(),
"Gift" => ObjectHatConfigs.GetGiftSantaHatConfig(),
_ => ObjectHatConfigs.GetIncompatibleSantaHatConfig(),
};
}
}
[HarmonyPatch(typeof(EnemyAI))]
internal class PlaceHatsOnEnemiesPatch
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void GiveEnemySantaHat(EnemyAI __instance)
{
if (JollyLethal.myCustomAssets == null)
{
JollyLethal.PluginLogErrorWithPrefix("AssetBundle not loaded!!!");
}
else
{
PlaceHatOnEnemyTransform(((Component)__instance).transform, __instance.enemyType);
}
}
internal static void PlaceHatOnEnemyTransform(Transform enemyTransform, EnemyType enemyType)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: 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)
string enemyName = enemyType.enemyName;
var (text, posOffset, rotOffset, scale) = GetEnemyHatConfig(enemyName);
if (text != null && !JollyHatActions.DoesTransformAlreadyContainJollyHat(enemyTransform, text))
{
Transform hatPlaceTransform = GetHatPlaceTransform(enemyTransform, text);
Transform hatParent = JollyHatActions.PlaceHatOnTransform(hatPlaceTransform, posOffset, rotOffset, scale);
FixAdditionalChildrenPositions(enemyName, hatParent);
}
}
private static void FixAdditionalChildrenPositions(string enemyName, Transform hatParent)
{
//IL_002b: 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)
if (!(enemyName == "Crawler"))
{
if (enemyName == "Maneater")
{
JollyHatActions.ChangeRotOfHatParentChild(hatParent, new Vector3(0f, 115f, 0f));
}
}
else
{
JollyHatActions.ChangeRotOfHatParentChild(hatParent, new Vector3(0f, 285f, 0f));
}
}
internal static Transform GetHatPlaceTransform(Transform enemyTransform, string? bonePath)
{
Transform val = ((Component)enemyTransform).transform.Find(bonePath);
if (val != null)
{
return val;
}
return ((Component)enemyTransform).transform;
}
internal static (string?, Vector3, Vector3, float) GetEnemyHatConfig(string enemyName)
{
JollyLethal.PluginLogInfoWithPrefix("Placing hat on: " + enemyName);
switch (enemyName)
{
case "Flowerman":
return EnemyHatConfigs.GetBrackenSantaHatConfig();
case "Hoarding bug":
return EnemyHatConfigs.GetHoardingBugSantaHatConfig();
case "Centipede":
return EnemyHatConfigs.GetSnareFleaSantaHatConfig();
case "Crawler":
return EnemyHatConfigs.GetThumperSantaHatConfig();
case "Bunker Spider":
return EnemyHatConfigs.GetBunkerSpiderSantaHatConfig();
case "Jester":
return EnemyHatConfigs.GetJesterSantaHatConfig();
case "Nutcracker":
return EnemyHatConfigs.GetNutcrackerSantaHatConfig();
case "Spring":
return EnemyHatConfigs.GetSpringSantaHatConfig();
case "Masked":
return EnemyHatConfigs.GetMaskedSantaHatConfig();
case "Butler":
return EnemyHatConfigs.GetButlerSantaHatConfig();
case "Maneater":
return EnemyHatConfigs.GetManeaterSantaHatConfig();
case "Puffer":
return EnemyHatConfigs.GetSporeLizardSantaHatConfig();
case "Blob":
return EnemyHatConfigs.GetBlobSantaHatConfig();
case "Girl":
return EnemyHatConfigs.GetGirlSantaHatConfig();
case "MouthDog":
return EnemyHatConfigs.GetMouthDogSantaHatConfig();
case "Baboon hawk":
return EnemyHatConfigs.GetBaboonHawkSantaHatConfig();
case "ForestGiant":
return EnemyHatConfigs.GetForestGiantSantaHatConfig();
case "RadMech":
return EnemyHatConfigs.GetOldBirdSantaHatConfig();
case "Tulip Snake":
return EnemyHatConfigs.GetTulipSnakeSantaHatConfig();
case "Bush Wolf":
return EnemyHatConfigs.GetKidnapperFoxSantaHatConfig();
case "Clay Surgeon":
JollyLethal.PluginLogInfoWithPrefix("Skipping hat for incompatible enemy: " + enemyName);
return EnemyHatConfigs.GetBarberSantaHatConfig();
case "Manticoil":
case "GiantKiwi":
case "Red pill":
case "Butler Bees":
case "Earth Leviathan":
case "Red Locust Bees":
case "Docile Locust Bees":
case "Lasso":
JollyLethal.PluginLogInfoWithPrefix("Skipping hat for incompatible enemy: " + enemyName);
return EnemyHatConfigs.GetIncompatibleSantaHatConfig();
default:
JollyLethal.PluginLogErrorWithPrefix("Enemy '" + enemyName + "' not in config. Defaulting to 'Head'.");
return EnemyHatConfigs.GetDefaultSantaHatConfig();
}
}
}
}
namespace JollyLethal.DebugScripts
{
[HarmonyPatch(typeof(RoundManager))]
internal class EnemyDumper
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void DumpEveryEnemy()
{
JollyLethal.PluginLogInfoWithPrefix("=== STARTING ENEMY NAME DUMP ===");
EnemyType[] source = Resources.FindObjectsOfTypeAll<EnemyType>();
IOrderedEnumerable<string> orderedEnumerable = from n in source.Select((EnemyType e) => e.enemyName).Distinct()
orderby n
select n;
foreach (string item in orderedEnumerable)
{
JollyLethal.PluginLogInfoWithPrefix("Found Enemy Name: \"" + item + "\"");
}
JollyLethal.PluginLogInfoWithPrefix("=== DUMP FINISHED ===");
}
}
[HarmonyPatch(typeof(GrabbableObject))]
internal class GetItemName
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void PrintItemName(GrabbableObject __instance)
{
JollyLethal.PluginLogInfoWithPrefix("Item name " + __instance.itemProperties.itemName);
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
