using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using DunGen;
using DunGen.Graph;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MonoMod.Utils;
using Unity.Netcode;
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: AssemblyCompany("LegalCompany")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Legal Company")]
[assembly: AssemblyFileVersion("0.0.0.0")]
[assembly: AssemblyInformationalVersion("0.0.0")]
[assembly: AssemblyProduct("LegalCompany")]
[assembly: AssemblyTitle("LegalCompany")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace LegalCompany
{
[BepInPlugin("butterystancakes.lethalcompany.legalcompany", "Legal Company", "0.0.0")]
public class Plugin : BaseUnityPlugin
{
private const string PLUGIN_GUID = "butterystancakes.lethalcompany.legalcompany";
private const string PLUGIN_NAME = "Legal Company";
private const string PLUGIN_VERSION = "0.0.0";
internal static ManualLogSource Logger;
private void Awake()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
Logger = ((BaseUnityPlugin)this).Logger;
new Harmony("butterystancakes.lethalcompany.legalcompany").PatchAll();
Logger.LogInfo((object)"Legal Company v0.0.0 loaded");
}
}
[HarmonyPatch]
internal class Patches
{
private static StartMatchLever startMatchLever;
private static float tempNodeDistance = -1f;
[HarmonyPatch(typeof(StartOfRound), "Start")]
[HarmonyPostfix]
[HarmonyPriority(100)]
private static void StartOfRoundPostStart(StartOfRound __instance)
{
//IL_0720: Unknown result type (might be due to invalid IL or missing references)
//IL_0725: Unknown result type (might be due to invalid IL or missing references)
//IL_0736: Unknown result type (might be due to invalid IL or missing references)
//IL_073b: Unknown result type (might be due to invalid IL or missing references)
//IL_074c: Unknown result type (might be due to invalid IL or missing references)
//IL_0751: Unknown result type (might be due to invalid IL or missing references)
//IL_0756: Unknown result type (might be due to invalid IL or missing references)
//IL_0760: Expected O, but got Unknown
//IL_0dc0: Unknown result type (might be due to invalid IL or missing references)
//IL_0dc5: Unknown result type (might be due to invalid IL or missing references)
//IL_0dd2: Unknown result type (might be due to invalid IL or missing references)
//IL_0de4: Expected O, but got Unknown
//IL_0c05: Unknown result type (might be due to invalid IL or missing references)
//IL_0c0a: Unknown result type (might be due to invalid IL or missing references)
//IL_0c12: Unknown result type (might be due to invalid IL or missing references)
//IL_0c26: Expected O, but got Unknown
startMatchLever = Object.FindObjectOfType<StartMatchLever>();
if (__instance.isChallengeFile)
{
return;
}
Dictionary<string, EnemyType> dictionary = new Dictionary<string, EnemyType>();
QuickMenuManager val = Object.FindObjectOfType<QuickMenuManager>();
if ((Object)(object)val != (Object)null)
{
List<SpawnableEnemyWithRarity>[] array = new List<SpawnableEnemyWithRarity>[3]
{
val.testAllEnemiesLevel.Enemies,
val.testAllEnemiesLevel.OutsideEnemies,
val.testAllEnemiesLevel.DaytimeEnemies
};
for (int i = 0; i < array.Length; i++)
{
foreach (SpawnableEnemyWithRarity item3 in array[i])
{
if (!dictionary.ContainsKey(((Object)item3.enemyType).name))
{
dictionary.Add(((Object)item3.enemyType).name, item3.enemyType);
}
}
}
}
RoundManager val2 = RoundManager.Instance ?? Object.FindObjectOfType<RoundManager>();
Dictionary<string, int> dictionary2 = new Dictionary<string, int>();
Dictionary<string, int> dictionary3 = new Dictionary<string, int>();
Dictionary<string, int> dictionary4 = new Dictionary<string, int>();
SpawnableMapObject val3 = null;
AnimationCurve val4 = null;
SelectableLevel[] levels = __instance.levels;
foreach (SelectableLevel val5 in levels)
{
switch (((Object)val5).name)
{
case "ExperimentationLevel":
val5.minScrap = 11;
val5.maxScrap = 16;
break;
case "AssuranceLevel":
val5.minScrap = 11;
Extensions.AddRange<string, int>(dictionary3, new Dictionary<string, int>
{
{ "Cog1", 94 },
{ "EnginePart1", 80 },
{ "BigBolt", 89 },
{ "ToyCube", 18 },
{ "StopSign", 27 },
{ "YieldSign", 28 },
{ "ToiletPaperRolls", 18 },
{ "MetalSheet", 100 }
});
break;
case "VowLevel":
Extensions.AddRange<string, int>(dictionary3, new Dictionary<string, int>
{
{ "Cog1", 30 },
{ "EnginePart1", 31 },
{ "BottleBin", 58 },
{ "Flask", 49 },
{ "ToiletPaperRolls", 32 },
{ "PlasticCup", 27 }
});
dictionary4.Add("Level3Flow", 300);
break;
case "MarchLevel":
val5.minScrap = 16;
val5.maxScrap = 21;
val5.factorySizeMultiplier = 1.8f;
dictionary2.Add("RedLocustBees", 72);
Extensions.AddRange<string, int>(dictionary3, new Dictionary<string, int>
{
{ "Cog1", 25 },
{ "EnginePart1", 25 },
{ "BottleBin", 30 },
{ "ToiletPaperRolls", 34 },
{ "PlasticCup", 22 },
{ "Bell", 40 },
{ "MoldPan", 13 }
});
val5.maxEnemyPowerCount = 11;
val5.overrideWeather = true;
break;
case "OffenseLevel":
Extensions.AddRange<string, int>(dictionary3, new Dictionary<string, int>
{
{ "Cog1", 30 },
{ "EnginePart1", 40 },
{ "MetalSheet", 23 },
{ "BigBolt", 59 },
{ "ToyCube", 31 },
{ "StopSign", 34 },
{ "YieldSign", 17 },
{ "ToiletPaperRolls", 19 },
{ "Bell", 28 }
});
val5.maxScrap = 19;
dictionary4.Add("Level3Flow", 300);
break;
case "AdamanceLevel":
val5.minScrap = 19;
val5.maxScrap = 24;
dictionary4.Add("Level2Flow", 17);
break;
case "RendLevel":
val5.factorySizeMultiplier = 1.6f;
Extensions.AddRange<string, int>(dictionary2, new Dictionary<string, int>
{
{ "SpringMan", 70 },
{ "Jester", 69 },
{ "SandWorm", 18 }
});
break;
case "DineLevel":
val5.maxScrap = 28;
Extensions.AddRange<string, int>(dictionary3, new Dictionary<string, int>
{
{ "Cog1", 15 },
{ "EnginePart1", 14 },
{ "FancyLamp", 54 },
{ "Ring", 26 },
{ "RobotToy", 26 },
{ "PillBottle", 14 },
{ "PerfumeBottle", 34 },
{ "BottleBin", 30 },
{ "Hairdryer", 22 },
{ "7Ball", 30 },
{ "Airhorn", 16 },
{ "ClownHorn", 17 },
{ "FancyPainting", 50 },
{ "CashRegister", 12 },
{ "Candy", 16 },
{ "GiftBox", 21 },
{ "TragedyMask", 64 }
});
Extensions.AddRange<string, int>(dictionary2, new Dictionary<string, int>
{
{ "DressGirl", 3 },
{ "SandSpider", 7 },
{ "Blob", 3 },
{ "HoarderBug", 8 },
{ "Jester", 5 },
{ "Centipede", 6 },
{ "ForestGiant", 28 },
{ "Butler", 14 }
});
val5.outsideEnemySpawnChanceThroughDay = new AnimationCurve((Keyframe[])(object)new Keyframe[3]
{
new Keyframe(-7.7369623E-07f, -2.8875f),
new Keyframe(0.47669196f, 0.6959345f),
new Keyframe(1.0052626f, 5.3594007f)
});
Plugin.Logger.LogDebug((object)(((Object)val5).name + ".outsideEnemySpawnChanceThroughDay"));
val5.maxEnemyPowerCount = 15;
break;
case "TitanLevel":
val5.maxScrap = 36;
Extensions.AddRange<string, int>(dictionary3, new Dictionary<string, int>
{
{ "Cog1", 19 },
{ "EnginePart1", 19 },
{ "FancyLamp", 29 },
{ "FancyPainting", 44 },
{ "PerfumeBottle", 16 },
{ "Mug", 44 },
{ "7Ball", 24 },
{ "DiyFlashbang", 10 },
{ "WhoopieCushion", 18 }
});
Extensions.AddRange<string, int>(dictionary2, new Dictionary<string, int>
{
{ "Blob", 29 },
{ "ForestGiant", 20 },
{ "DressGirl", 28 },
{ "RadMech", 13 }
});
dictionary4.Add("Level2Flow", 69);
val5.canSpawnMold = false;
break;
case "ArtificeLevel":
val5.minScrap = 31;
val5.maxScrap = 38;
val5.factorySizeMultiplier = 2f;
Extensions.AddRange<string, int>(dictionary3, new Dictionary<string, int> { { "GoldBar", 36 } });
Extensions.AddRange<string, int>(dictionary4, new Dictionary<string, int>
{
{ "Level1Flow", 94 },
{ "Level2Flow", 300 }
});
val3 = ((IEnumerable<SpawnableMapObject>)val5.spawnableMapObjects).FirstOrDefault((Func<SpawnableMapObject, bool>)delegate(SpawnableMapObject spawnableMapObject)
{
GameObject prefabToSpawn = spawnableMapObject.prefabToSpawn;
return ((prefabToSpawn != null) ? ((Object)prefabToSpawn).name : null) == "TurretContainer";
});
break;
case "EmbrionLevel":
val5.minScrap = 20;
val5.maxScrap = 25;
Extensions.AddRange<string, int>(dictionary3, new Dictionary<string, int>
{
{ "YieldSign", 12 },
{ "GiftBox", 64 },
{ "EasterEgg", 17 },
{ "ControlPad", 52 },
{ "SoccerBall", 45 },
{ "MetalSheet", 65 },
{ "Cog1", 37 },
{ "EnginePart1", 40 },
{ "BigBolt", 55 },
{ "FlashLaserPointer", 10 },
{ "BottleBin", 42 },
{ "RobotToy", 49 },
{ "MagnifyingGlass", 37 },
{ "TeaKettle", 23 },
{ "Dentures", 37 },
{ "Phone", 45 },
{ "Airhorn", 39 },
{ "ClownHorn", 31 }
});
val5.canSpawnMold = false;
break;
case "LiquidationLevel":
val4 = ((IEnumerable<SpawnableMapObject>)val5.spawnableMapObjects).FirstOrDefault((Func<SpawnableMapObject, bool>)delegate(SpawnableMapObject spawnableMapObject)
{
GameObject prefabToSpawn2 = spawnableMapObject.prefabToSpawn;
return ((prefabToSpawn2 != null) ? ((Object)prefabToSpawn2).name : null) == "TurretContainer";
})?.numberToSpawn;
break;
}
if (dictionary3.Count > 0)
{
foreach (SpawnableItemWithRarity item4 in val5.spawnableScrap)
{
if (dictionary3.ContainsKey(((Object)item4.spawnableItem).name))
{
Plugin.Logger.LogDebug((object)$"{((Object)val5).name}.spawnableScrap: {item4.spawnableItem.itemName} - {item4.rarity} => {dictionary3[((Object)item4.spawnableItem).name]}");
item4.rarity = dictionary3[((Object)item4.spawnableItem).name];
dictionary3.Remove(((Object)item4.spawnableItem).name);
}
if (((Object)item4.spawnableItem).name == "GiftBox" && val5.levelIncludesSnowFootprints && ((Object)val5).name != "ArtificeLevel")
{
Plugin.Logger.LogDebug((object)$"{((Object)val5).name}.spawnableScrap: \"GiftBox\" - {item4.rarity} => {item4.rarity + 30}");
item4.rarity += 30;
}
}
if (dictionary3.Count > 0)
{
foreach (KeyValuePair<string, int> itemID in dictionary3)
{
Item val6 = ((IEnumerable<Item>)__instance.allItemsList.itemsList).FirstOrDefault((Func<Item, bool>)((Item item) => ((Object)item).name == itemID.Key));
if ((Object)(object)val6 != (Object)null)
{
SpawnableItemWithRarity item2 = new SpawnableItemWithRarity
{
spawnableItem = val6,
rarity = itemID.Value
};
val5.spawnableScrap.Add(item2);
Plugin.Logger.LogDebug((object)$"{((Object)val5).name}.spawnableScrap: +({val6.itemName}, {itemID.Value})");
}
}
}
dictionary3.Clear();
}
if (dictionary2.Count > 0)
{
foreach (KeyValuePair<string, int> item5 in dictionary2)
{
if (dictionary.TryGetValue(item5.Key, out var enemy))
{
List<SpawnableEnemyWithRarity> list = null;
string empty = string.Empty;
if (enemy.isDaytimeEnemy)
{
list = val5.DaytimeEnemies;
empty = "DaytimeEnemies";
}
else if (enemy.isOutsideEnemy && ((Object)enemy).name != "MaskedPlayerEnemy")
{
list = val5.OutsideEnemies;
empty = "OutsideEnemies";
}
else
{
list = val5.Enemies;
empty = "Enemies";
}
SpawnableEnemyWithRarity val7 = ((IEnumerable<SpawnableEnemyWithRarity>)list).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity spawnableEnemyWithRarity) => (Object)(object)spawnableEnemyWithRarity.enemyType == (Object)(object)enemy));
if (val7 != null)
{
Plugin.Logger.LogDebug((object)$"{((Object)val5).name}.{empty}: {val7.enemyType.enemyName} - {val7.rarity} => {item5.Value}");
val7.rarity = item5.Value;
}
else
{
list.Add(new SpawnableEnemyWithRarity
{
enemyType = enemy,
rarity = item5.Value
});
Plugin.Logger.LogDebug((object)$"{((Object)val5).name}.{empty}: +({enemy.enemyName}, {item5.Value})");
}
}
}
dictionary2.Clear();
}
if (dictionary4.Count <= 0)
{
continue;
}
if (val5.dungeonFlowTypes.Length != 0 && (Object)(object)val2 != (Object)null)
{
IntWithRarity[] dungeonFlowTypes = val5.dungeonFlowTypes;
foreach (IntWithRarity val8 in dungeonFlowTypes)
{
DungeonFlow dungeonFlow = val2.dungeonFlowTypes[val8.id].dungeonFlow;
if (dictionary4.TryGetValue((dungeonFlow != null) ? ((Object)dungeonFlow).name : null, out var value))
{
Plugin.Logger.LogDebug((object)$"{((Object)val5).name}.dungeonFlowTypes: {((Object)val2.dungeonFlowTypes[val8.id].dungeonFlow).name}, {val8.rarity} -> {value}");
val8.rarity = value;
}
}
}
dictionary4.Clear();
}
if (val3 != null && val4 != null)
{
val3.numberToSpawn = val4;
Plugin.Logger.LogDebug((object)"ArtificeLevel.spawnableMapObjects.TurretContainer");
}
foreach (Item items in __instance.allItemsList.itemsList)
{
switch (((Object)items).name)
{
case "Jetpack":
Plugin.Logger.LogDebug((object)$"{((Object)items).name}.batteryUsage: {items.batteryUsage}s -> 40s");
items.batteryUsage = 40f;
break;
case "ZapGun":
Plugin.Logger.LogDebug((object)$"{((Object)items).name}.creditsWorth: {items.creditsWorth} -> $200");
items.creditsWorth = 200;
break;
case "StunGrenade":
Plugin.Logger.LogDebug((object)$"{((Object)items).name}.creditsWorth: {items.creditsWorth} -> $40");
items.creditsWorth = 40;
break;
case "RadarBooster":
Plugin.Logger.LogDebug((object)$"{((Object)items).name}.creditsWorth: {items.creditsWorth} -> $50");
items.creditsWorth = 50;
break;
}
}
foreach (KeyValuePair<string, EnemyType> item6 in dictionary)
{
if (item6.Key == "Butler")
{
item6.Value.increasedChanceInterior = 1;
Plugin.Logger.LogDebug((object)"Butler.increasedChanceInterior: 1");
}
}
IndoorMapType val9 = ((IEnumerable<IndoorMapType>)val2?.dungeonFlowTypes).FirstOrDefault((Func<IndoorMapType, bool>)((IndoorMapType dungeonFlowType) => ((Object)dungeonFlowType.dungeonFlow).name == "Level3Flow"));
if (val9 != null)
{
Plugin.Logger.LogDebug((object)$"Level3Flow.MapTileSize: {val9.MapTileSize} -> 1.1");
val9.MapTileSize = 1.111111f;
}
}
[HarmonyPatch(typeof(NutcrackerEnemyAI), "GrabGun")]
[HarmonyPostfix]
private static void PostGrabGun(NutcrackerEnemyAI __instance, int ___randomSeedNumber)
{
if (!StartOfRound.Instance.isChallengeFile && !((NetworkBehaviour)__instance).IsServer && ((GrabbableObject)__instance.gun).scrapValue == 60)
{
((GrabbableObject)__instance.gun).SetScrapValue(new Random(___randomSeedNumber).Next(25, 90));
}
}
[HarmonyPatch(typeof(NutcrackerEnemyAI), "InitializeNutcrackerValuesClientRpc")]
[HarmonyPostfix]
private static void PostInitializeNutcrackerValuesClientRpc(NutcrackerEnemyAI __instance, int ___randomSeedNumber)
{
if (!StartOfRound.Instance.isChallengeFile && (Object)(object)__instance.gun != (Object)null)
{
((GrabbableObject)__instance.gun).SetScrapValue(new Random(___randomSeedNumber).Next(25, 90));
}
}
[HarmonyPatch(typeof(LungProp), "Start")]
[HarmonyPostfix]
private static void LungPropPostStart(LungProp __instance)
{
if (!StartOfRound.Instance.isChallengeFile && (Object)(object)startMatchLever != (Object)null && startMatchLever.leverHasBeenPulled && ((GrabbableObject)__instance).scrapValue == 80)
{
((GrabbableObject)__instance).scrapValue = new Random(StartOfRound.Instance.randomMapSeed).Next(40, 120);
}
}
[HarmonyPatch(typeof(GrabbableObject), "Start")]
[HarmonyPostfix]
private static void GrabbableObjectPostStart(GrabbableObject __instance)
{
if (!StartOfRound.Instance.isChallengeFile && (Object)(object)startMatchLever != (Object)null && startMatchLever.leverHasBeenPulled && __instance is KnifeItem)
{
__instance.SetScrapValue((int)((float)new Random(StartOfRound.Instance.randomMapSeed + (int)((NetworkBehaviour)__instance).NetworkObjectId).Next(70, 210) * RoundManager.Instance.scrapValueMultiplier));
}
}
[HarmonyPatch(typeof(TetraChemicalItem), "Update")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> TZPUpdate(IEnumerable<CodeInstruction> instructions)
{
List<CodeInstruction> list = instructions.ToList();
for (int i = 0; i < list.Count; i++)
{
if (list[i].opcode == OpCodes.Ldc_R4 && (float)list[i].operand == 22f)
{
list[i].operand = 24f;
Plugin.Logger.LogDebug((object)"Transpiler (TZP capacity): Increase to 24");
return list;
}
}
return instructions;
}
[HarmonyPatch(typeof(RuntimeDungeon), "Generate")]
[HarmonyPrefix]
private static void RuntimeDungeonPreGenerate(RuntimeDungeon __instance)
{
if (!StartOfRound.Instance.isChallengeFile && RoundManager.Instance.currentDungeonType == 4)
{
if (((Object)StartOfRound.Instance.currentLevel).name == "ArtificeLevel")
{
DungeonGenerator generator = __instance.Generator;
generator.LengthMultiplier *= 0.9f;
}
else if (((Object)StartOfRound.Instance.currentLevel).name == "DineLevel")
{
DungeonGenerator generator2 = __instance.Generator;
generator2.LengthMultiplier *= Mathf.Min(new float[3]
{
StartOfRound.Instance.levels[6].factorySizeMultiplier / StartOfRound.Instance.currentLevel.factorySizeMultiplier * 1.0833333f,
0.923077f,
1f
});
}
}
}
[HarmonyPatch(typeof(FlowermanAI), "Start")]
[HarmonyPostfix]
private static void PostChooseFarthestNodeFromPosition(FlowermanAI __instance)
{
tempNodeDistance = -1f;
}
[HarmonyPatch(typeof(EnemyAI), "ChooseFarthestNodeFromPosition")]
[HarmonyPostfix]
private static void PostChooseFarthestNodeFromPosition(EnemyAI __instance, Transform __result)
{
if ((Object)(object)__result != (Object)null && __instance is FlowermanAI)
{
tempNodeDistance = __instance.mostOptimalDistance;
}
}
[HarmonyPatch(typeof(FlowermanAI), "AvoidClosestPlayer")]
[HarmonyPrefix]
private static void FlowermanAIPreAvoidClosestPlayer(FlowermanAI __instance, ref float __state)
{
__state = ((EnemyAI)__instance).mostOptimalDistance;
if (tempNodeDistance >= 0f)
{
((EnemyAI)__instance).mostOptimalDistance = tempNodeDistance;
}
}
[HarmonyPatch(typeof(FlowermanAI), "AvoidClosestPlayer")]
[HarmonyPostfix]
private static void FlowermanAIPostAvoidClosestPlayer(FlowermanAI __instance, float __state)
{
((EnemyAI)__instance).mostOptimalDistance = __state;
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "LegalCompany";
public const string PLUGIN_NAME = "LegalCompany";
public const string PLUGIN_VERSION = "0.0.0";
}
}
