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 AIGraph;
using Agents;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using CellMenu;
using GTFO.API;
using GTFO.API.Utilities;
using GTFODoorMod.CustomWorldEvents;
using GTFODoorMod.Temperature;
using GameData;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem.Collections.Generic;
using LevelGeneration;
using Microsoft.CodeAnalysis;
using ModifierAPI;
using Player;
using SNetwork;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("GTFODoorMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Giginss's first plugin, designed to modify door controls")]
[assembly: AssemblyFileVersion("0.0.1.0")]
[assembly: AssemblyInformationalVersion("0.0.1+ca5b1ddcc1b95e777b8d1ad8b2ba1642c13d9564")]
[assembly: AssemblyProduct("GTFODoorMod")]
[assembly: AssemblyTitle("GTFODoorMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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 GTFODoorMod
{
public class AllowNegativeInfectionFogPatch
{
private static ManualLogSource logger;
public AllowNegativeInfectionFogPatch(Harmony harmony, ManualLogSource loggerParent)
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Expected O, but got Unknown
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Expected O, but got Unknown
logger = loggerParent;
MethodInfo method = typeof(LocalPlayerAgentSettings).GetMethod("UpdateBlendTowardsTargetFogSetting");
harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(typeof(AllowNegativeInfectionFogPatch), "AllowBlendNegativeInfectionPlane", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
harmony.Patch((MethodBase)typeof(LocalPlayerAgentSettings).GetMethod("SetFogSettings"), (HarmonyMethod)null, new HarmonyMethod(typeof(AllowNegativeInfectionFogPatch), "AllowSetNegativeInfectionPlane", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
logger.LogInfo((object)"Patched infection plane functions!");
}
private static void AllowSetNegativeInfectionPlane(LocalPlayerAgentSettings __instance, ref FogSettingsDataBlock fogSettings)
{
if (fogSettings != null && (double)fogSettings.Infection < 0.0)
{
logger.LogInfo((object)"Set infection plane to one that has negative infection.");
((EffectVolume)LocalPlayerAgentSettings.Current.infectionPlane).invert = (double)fogSettings.DensityHeightMaxBoost > (double)fogSettings.FogDensity;
((EffectVolume)LocalPlayerAgentSettings.Current.infectionPlane).contents = (eEffectVolumeContents)2;
((EffectVolume)LocalPlayerAgentSettings.Current.infectionPlane).modification = (eEffectVolumeModification)0;
((EffectVolume)LocalPlayerAgentSettings.Current.infectionPlane).modificationScale = fogSettings.Infection;
LocalPlayerAgentSettings.Current.infectionPlane.lowestAltitude = fogSettings.DensityHeightAltitude;
LocalPlayerAgentSettings.Current.infectionPlane.highestAltitude = fogSettings.DensityHeightAltitude + fogSettings.DensityHeightRange;
EffectVolumeManager.RegisterVolume((EffectVolume)(object)LocalPlayerAgentSettings.Current.infectionPlane);
LocalPlayerAgentSettings.Current.isInfectionPlaneRegistered = true;
}
}
private static void AllowBlendNegativeInfectionPlane(LocalPlayerAgentSettings __instance, float amount)
{
float currentInfection = LocalPlayerAgentSettings.Current.currentInfection;
if ((double)currentInfection < 0.0 && !LocalPlayerAgentSettings.Current.isInfectionPlaneRegistered)
{
EffectVolumeManager.RegisterVolume((EffectVolume)(object)LocalPlayerAgentSettings.Current.infectionPlane);
LocalPlayerAgentSettings.Current.isInfectionPlaneRegistered = true;
}
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("com.giginss.rundownmod", "Giginss's Rundown Mod", "1.0.0")]
public class DoorPlugin : BasePlugin
{
private ConfigEntry<bool> lurkerNerf;
private ConfigEntry<bool> psychoBuff;
private ConfigEntry<bool> rajNerf;
public override void Load()
{
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Expected O, but got Unknown
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Expected O, but got Unknown
//IL_01be: Unknown result type (might be due to invalid IL or missing references)
//IL_01c5: Expected O, but got Unknown
//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
//IL_02bc: Expected O, but got Unknown
//IL_0221: Unknown result type (might be due to invalid IL or missing references)
//IL_0228: Expected O, but got Unknown
((BasePlugin)this).Log.LogInfo((object)"Plugin Giginss's Rundown Mod is loading!");
((BasePlugin)this).Log.LogInfo((object)"Hello Complex!");
lurkerNerf = ((BasePlugin)this).Config.Bind<bool>("Easter Egg", "LurkerNerf", true, "Easter Egg to prevent anyone named Lurker from picking a hammer");
psychoBuff = ((BasePlugin)this).Config.Bind<bool>("Easter Egg", "PsychoBuff", true, "Easter Egg to allow anyone named PsychoMadEye to gain enough ammo on D3.");
rajNerf = ((BasePlugin)this).Config.Bind<bool>("Easter Egg", "RajNerf", true, "Easter Egg to prevent anyone named Raj from picking a spear");
Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("GTFODoorMod.resources.red-x.png");
Texture2D val = new Texture2D(2, 2);
if (manifestResourceStream != null)
{
byte[] array = new byte[32768];
using MemoryStream memoryStream = new MemoryStream();
int count;
while ((count = manifestResourceStream.Read(array, 0, array.Length)) > 0)
{
memoryStream.Write(array, 0, count);
}
byte[] array2 = memoryStream.ToArray();
ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(array2));
}
Harmony val2 = new Harmony("com.giginss.rundownmod");
WorldEventsPatcher worldEventsPatcher = new WorldEventsPatcher(val2, val);
DoorPatcher doorPatcher = new DoorPatcher(val2);
PabloHeavyHitreactPatch pabloHeavyHitreactPatch = new PabloHeavyHitreactPatch(val2, ((BasePlugin)this).Log);
AllowNegativeInfectionFogPatch allowNegativeInfectionFogPatch = new AllowNegativeInfectionFogPatch(val2, ((BasePlugin)this).Log);
FixWardenObjectiveManager fixWardenObjectiveManager = new FixWardenObjectiveManager(val2, ((BasePlugin)this).Log);
OnlyBreakLocksPatch onlyBreakLocksPatch = new OnlyBreakLocksPatch(val2, ((BasePlugin)this).Log);
FixProgressionPuzzleNotUsingDimensionIndexPatch fixProgressionPuzzleNotUsingDimensionIndexPatch = new FixProgressionPuzzleNotUsingDimensionIndexPatch(val2, ((BasePlugin)this).Log);
FixBaseGameBugs fixBaseGameBugs = new FixBaseGameBugs(val2, ((BasePlugin)this).Log);
if (psychoBuff.Value)
{
InfiniteAmmoEasterEgg infiniteAmmoEasterEgg = new InfiniteAmmoEasterEgg(val2, ((BasePlugin)this).Log);
}
bool flag = default(bool);
if (lurkerNerf.Value)
{
ManualLogSource log = ((BasePlugin)this).Log;
BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(22, 0, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("Lurker Nerf is enabled");
}
log.LogInfo(val3);
EventAPI.OnManagersSetup += CheckAndDisableHammers;
}
if (rajNerf.Value)
{
ManualLogSource log2 = ((BasePlugin)this).Log;
BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(19, 0, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("Raj Nerf is enabled");
}
log2.LogInfo(val3);
EventAPI.OnManagersSetup += CheckAndDisableSpears;
}
MethodInfo method = typeof(SNet_Replication).GetMethod("AllocateKey", new Type[2]
{
typeof(SNet_ReplicatorType),
typeof(ushort)
});
val2.Patch((MethodBase)method, new HarmonyMethod(typeof(ReplicationPatch), "Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
ClassInjector.RegisterTypeInIl2Cpp<TemperatureUpdater>();
((BasePlugin)this).Log.LogInfo((object)"Giginss' Rundown Mod finished Loading");
}
private static void CheckAndDisableHammers()
{
if (SteamManager.LocalPlayerName.Equals("Lurker", StringComparison.OrdinalIgnoreCase))
{
((GameDataBlockBase<PlayerOfflineGearDataBlock>)(object)GameDataBlockBase<PlayerOfflineGearDataBlock>.GetBlock(9u)).internalEnabled = false;
((GameDataBlockBase<PlayerOfflineGearDataBlock>)(object)GameDataBlockBase<PlayerOfflineGearDataBlock>.GetBlock(26u)).internalEnabled = false;
((GameDataBlockBase<PlayerOfflineGearDataBlock>)(object)GameDataBlockBase<PlayerOfflineGearDataBlock>.GetBlock(27u)).internalEnabled = false;
((GameDataBlockBase<PlayerOfflineGearDataBlock>)(object)GameDataBlockBase<PlayerOfflineGearDataBlock>.GetBlock(28u)).internalEnabled = false;
((GameDataBlockBase<PlayerOfflineGearDataBlock>)(object)GameDataBlockBase<PlayerOfflineGearDataBlock>.GetBlock(57u)).internalEnabled = false;
}
}
private static void CheckAndDisableSpears()
{
if (SteamManager.LocalPlayerName.Equals("RAJ", StringComparison.OrdinalIgnoreCase))
{
((GameDataBlockBase<PlayerOfflineGearDataBlock>)(object)GameDataBlockBase<PlayerOfflineGearDataBlock>.GetBlock(54u)).internalEnabled = false;
((GameDataBlockBase<PlayerOfflineGearDataBlock>)(object)GameDataBlockBase<PlayerOfflineGearDataBlock>.GetBlock(70u)).internalEnabled = false;
}
}
}
public class FixBaseGameBugs
{
private static ManualLogSource logger;
public FixBaseGameBugs(Harmony harmony, ManualLogSource loggerParent)
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Expected O, but got Unknown
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Expected O, but got Unknown
logger = loggerParent;
MethodInfo method = typeof(LocalPlayerAgentSettings).GetMethod("UpdateBlendTowardsTargetFogSetting");
harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(typeof(FixBaseGameBugs), "FixInfectionPlanesInDimensions", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
harmony.Patch((MethodBase)typeof(LG_LightCollection).GetMethod("ResetUpdateValues"), new HarmonyMethod(typeof(FixBaseGameBugs), "FixEmptyLightCollection", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
logger.LogInfo((object)"Patched blend method for dimensions and for empty light collection!");
}
private static void FixInfectionPlanesInDimensions(LocalPlayerAgentSettings __instance, float amount)
{
PlayerAgent localPlayerAgent = PlayerManager.GetLocalPlayerAgent();
if ((Object)(object)localPlayerAgent != (Object)null)
{
Dimension dimension = ((Agent)localPlayerAgent).Dimension;
if (dimension != null && !dimension.IsMainDimension)
{
float groundY = dimension.GroundY;
EV_Plane infectionPlane = LocalPlayerAgentSettings.Current.infectionPlane;
infectionPlane.highestAltitude -= groundY;
EV_Plane infectionPlane2 = LocalPlayerAgentSettings.Current.infectionPlane;
infectionPlane2.lowestAltitude -= groundY;
}
}
}
private static bool FixEmptyLightCollection(LG_LightCollection __instance, bool toStart)
{
if (__instance.collectedLights.Count == 0 && !toStart)
{
logger.LogWarning((object)"Light collection has an empty light array! Skipping Reset...");
return false;
}
return true;
}
}
public class FixProgressionPuzzleNotUsingDimensionIndexPatch
{
private static ManualLogSource logger;
private static LG_Layer lgLayer;
public FixProgressionPuzzleNotUsingDimensionIndexPatch(Harmony harmony, ManualLogSource loggerParent)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Expected O, but got Unknown
//IL_0055: Expected O, but got Unknown
logger = loggerParent;
harmony.Patch((MethodBase)typeof(LG_Distribute_ProgressionPuzzles).GetMethod("CreateKeyItemDistribution"), new HarmonyMethod(typeof(FixProgressionPuzzleNotUsingDimensionIndexPatch), "OverrideLayerIfNeededPrefix", (Type[])null), new HarmonyMethod(typeof(FixProgressionPuzzleNotUsingDimensionIndexPatch), "ResetProgressionPuzzleMainLayer", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
logger.LogInfo((object)"Patched progression puzzle distribution function!");
}
private static bool OverrideLayerIfNeededPrefix(LG_Distribute_ProgressionPuzzles __instance, GateKeyItem keyItem, ZonePlacementData placementData)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: 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_0035: Expected O, but got Unknown
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Invalid comparison between I4 and Unknown
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Expected O, but got Unknown
//IL_019e: Unknown result type (might be due to invalid IL or missing references)
//IL_01a4: Expected O, but got Unknown
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Expected O, but got Unknown
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Unknown result type (might be due to invalid IL or missing references)
if (__instance.m_layer.m_dimension.DimensionIndex != placementData.DimensionIndex)
{
ManualLogSource val = logger;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(101, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Found dimension mismatch between layer dimension and placement data dimension for Keycard ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(keyItem.m_keyName);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", fixing...");
}
val.LogInfo(val2);
Dimension val3 = default(Dimension);
Dimension.GetDimension(placementData.DimensionIndex, ref val3);
if (val3 == null)
{
ManualLogSource val4 = logger;
BepInExErrorLogInterpolatedStringHandler val5 = new BepInExErrorLogInterpolatedStringHandler(33, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val5).AppendLiteral("Dimension ");
((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<eDimensionIndex>(placementData.DimensionIndex);
((BepInExLogInterpolatedStringHandler)val5).AppendLiteral(" not found! Aborting...");
}
val4.LogError(val5);
return true;
}
if (val3.MainLayer.m_zones._size <= (int)placementData.LocalIndex)
{
ManualLogSource val6 = logger;
val2 = new BepInExInfoLogInterpolatedStringHandler(101, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Cannot place keycard in ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<eDimensionIndex>(val3.DimensionIndex);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("! Not enough zones, dimension has ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(val3.MainLayer.m_zones._size);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" zones and Placement Index is ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<eLocalZoneIndex>(placementData.LocalIndex);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(". Aborting...");
}
val6.LogInfo(val2);
return true;
}
lgLayer = __instance.m_layer;
__instance.m_layer = val3.MainLayer;
ManualLogSource val7 = logger;
val2 = new BepInExInfoLogInterpolatedStringHandler(27, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Replaced with ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<eDimensionIndex>(val3.DimensionIndex);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("'s MainLayer.");
}
val7.LogInfo(val2);
}
return true;
}
private static void ResetProgressionPuzzleMainLayer(LG_Distribute_ProgressionPuzzles __instance)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Expected O, but got Unknown
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
if (lgLayer != null)
{
ManualLogSource val = logger;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(67, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Resetting LG_Layer in Distribute Progression Puzzles to Dimension ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<eDimensionIndex>(lgLayer.m_dimension.DimensionIndex);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(".");
}
val.LogInfo(val2);
__instance.m_layer = lgLayer;
lgLayer = null;
}
}
}
public class FixWardenObjectiveManager
{
private static ManualLogSource logger;
public FixWardenObjectiveManager(Harmony harmony, ManualLogSource loggerParent)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
logger = loggerParent;
harmony.Patch((MethodBase)typeof(WardenObjectiveManager).GetMethod("OnLevelCleanup"), (HarmonyMethod)null, new HarmonyMethod(typeof(FixWardenObjectiveManager), "OnLevelCleanupPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
logger.LogInfo((object)"Patched Level Cleanup function!");
}
private static void OnLevelCleanupPostfix(WardenObjectiveManager __instance)
{
logger.LogInfo((object)"Resetting value of exitEventsTriggered.");
WardenObjectiveManager.m_exitEventsTriggered = false;
}
}
public class InfiniteAmmoEasterEgg
{
private static ManualLogSource logger;
public InfiniteAmmoEasterEgg(Harmony harmony, ManualLogSource loggerParent)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
logger = loggerParent;
harmony.Patch((MethodBase)typeof(CommunicationMenu).GetMethod("BroadcastDialog"), (HarmonyMethod)null, new HarmonyMethod(typeof(InfiniteAmmoEasterEgg), "InfiniteAmmoPatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
logger.LogInfo((object)"Setup easter egg!");
}
private static void InfiniteAmmoPatch(PlayerAgent src, uint textUID, PlayerAgent dst)
{
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Expected O, but got Unknown
if (!GameStateManager.IsInExpedition || !RundownManager.ActiveExpedition.Descriptive.PublicName.Equals("Breach"))
{
return;
}
uint num = 1309u;
if (textUID != num || !SteamManager.LocalPlayerName.Equals("PsychoMadEye", StringComparison.OrdinalIgnoreCase) || !SNet.IsMaster)
{
return;
}
PlayerBackpack backpack = PlayerBackpackManager.GetBackpack(src.Owner);
if (backpack != null)
{
PlayerAmmoStorage ammoStorage = backpack.AmmoStorage;
ammoStorage.StandardAmmo.AddAmmo(ammoStorage.StandardAmmo.AmmoMaxCap);
ammoStorage.SpecialAmmo.AddAmmo(ammoStorage.SpecialAmmo.AmmoMaxCap);
ManualLogSource val = logger;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(21, 0, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Gave easter egg ammo.");
}
val.LogInfo(val2);
}
}
}
public class OnlyBreakLocksPatch
{
public OnlyBreakLocksPatch(Harmony harmony, ManualLogSource loggerParent)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Expected O, but got Unknown
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Expected O, but got Unknown
MethodInfo method = typeof(LG_WeakResourceContainer).GetMethod("SetupWeakLock");
harmony.Patch((MethodBase)method, new HarmonyMethod(typeof(OnlyBreakLocksPatch), "SetBreakLock", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
MethodInfo method2 = typeof(LG_ResourceContainerBuilder).GetMethod("SetupFunctionGO");
harmony.Patch((MethodBase)method2, new HarmonyMethod(typeof(OnlyBreakLocksPatch), "ForceAllLocks", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
loggerParent.LogInfo((object)"Patched weak lock setup function!");
}
[HarmonyPrefix]
[HarmonyPatch(typeof(LG_ResourceContainerBuilder), "SetupFunctionGO")]
private static bool ForceAllLocks(LG_ResourceContainerBuilder __instance, LG_LayerType layer, GameObject GO)
{
uint persistentID = ((GameDataBlockBase<ExpeditionBalanceDataBlock>)(object)RundownManager.ActiveExpeditionBalanceData).persistentID;
if (persistentID == 5)
{
__instance.m_locked = true;
}
return true;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(LG_WeakResourceContainer), "SetupWeakLock")]
private static bool SetBreakLock(LG_WeakResourceContainer __instance, ref eWeakLockType type)
{
uint persistentID = ((GameDataBlockBase<ExpeditionBalanceDataBlock>)(object)RundownManager.ActiveExpeditionBalanceData).persistentID;
if (persistentID == 5)
{
type = (eWeakLockType)1;
}
return true;
}
}
public class PabloHeavyHitreactPatch
{
private static ManualLogSource logger;
public PabloHeavyHitreactPatch(Harmony harmony, ManualLogSource loggerParent)
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Expected O, but got Unknown
logger = loggerParent;
MethodInfo method = typeof(Dam_EnemyDamageBase).GetMethod("ProcessReceivedDamage");
harmony.Patch((MethodBase)method, new HarmonyMethod(typeof(PabloHeavyHitreactPatch), "HavePabloStagger", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
logger.LogInfo((object)"Patched damage received function!");
}
[HarmonyPrefix]
private static bool HavePabloStagger(Dam_EnemyDamageBase __instance, ref ES_HitreactType hitreact, ref bool tryForceHitreact, float damage, float staggerDamageMulti)
{
if (__instance.Owner.EnemyDataID == 47)
{
hitreact = (ES_HitreactType)4;
tryForceHitreact = true;
}
return true;
}
}
internal static class ReplicationPatch
{
public static bool OverrideSelfManaged => OverrideCount != 0;
public static uint OverrideCount { get; internal set; }
public static bool Prefix(SNet_ReplicatorType type, ushort key, ref ushort __result)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Invalid comparison between Unknown and I4
if (!OverrideSelfManaged)
{
return true;
}
if ((int)type != 2)
{
return true;
}
__result = (ushort)SNet_Replication.s_highestSlotUsed_SelfManaged;
SNet_Replication.s_highestSlotUsed_SelfManaged += 1;
return false;
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "GTFODoorMod";
public const string PLUGIN_NAME = "GTFODoorMod";
public const string PLUGIN_VERSION = "0.0.1";
}
}
namespace GTFODoorMod.Temperature
{
public class TemperatureManager
{
private GameObject temperatureTracker;
public static bool IsTemperatureActive = false;
private static readonly ManualLogSource Logger = new ManualLogSource("giginss.rundownmod.temperature");
private readonly string SYNC_TEMP = "SyncTemperature";
public TemperatureManager(Harmony harmony)
{
Logger.Sources.Add((ILogSource)(object)Logger);
Logger.LogInfo((object)"Initializing Temperature Manager");
LevelAPI.OnLevelCleanup += OnLevelCleanup;
RegisterNetworkEvents();
RegisterPatches(harmony);
Logger.LogInfo((object)"Temperature Manager initialized");
}
public void ActivateTemperature(float startingValue, float increaseRate)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
if ((Object)(object)temperatureTracker == (Object)null)
{
temperatureTracker = new GameObject("TemperatureTracker");
temperatureTracker.AddComponent<TemperatureUpdater>();
temperatureTracker.GetComponent<TemperatureUpdater>().SetupCallbacks(UpdateTemperatureDisplay, SyncCurrentTemperature);
}
temperatureTracker.GetComponent<TemperatureUpdater>().StartTemperatureTicking(startingValue, increaseRate);
GuiManager.PlayerLayer.m_objectiveTimer.SetTimerActive(true, true);
((TMP_Text)GuiManager.PlayerLayer.m_objectiveTimer.m_titleText).SetText("Temperature Status", true);
IsTemperatureActive = true;
}
public void AddTemporaryCooling(float duration, float coolingRate)
{
if ((Object)(object)temperatureTracker != (Object)null)
{
temperatureTracker.GetComponent<TemperatureUpdater>().AddTemporaryCooling(duration, coolingRate);
}
}
public void DeactivateTemperature()
{
if ((Object)(object)temperatureTracker != (Object)null)
{
temperatureTracker.GetComponent<TemperatureUpdater>().StopTemperatureTicking();
GuiManager.PlayerLayer.m_objectiveTimer.SetTimerActive(false, true);
}
IsTemperatureActive = false;
}
public void OnLevelCleanup()
{
if ((Object)(object)temperatureTracker != (Object)null)
{
Object.Destroy((Object)(object)temperatureTracker);
temperatureTracker = null;
}
IsTemperatureActive = false;
}
private void UpdateTemperatureDisplay(float currentTemp, Color textColor, string status)
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
if (IsTemperatureActive)
{
((TMP_Text)GuiManager.PlayerLayer.m_objectiveTimer.m_timerText).SetText($"{currentTemp:0.00} °C, Condition: <color=#{ColorUtility.ToHtmlStringRGBA(textColor)}>{status}</color>", true);
}
}
private void SyncCurrentTemperature(float currentTemp)
{
if (SNet.IsMaster && IsTemperatureActive)
{
NetworkAPI.InvokeEvent<float>(SYNC_TEMP, currentTemp, (SNet_ChannelType)2);
}
}
public void SetTemperatureBounds(float lower, float upper)
{
if ((Object)(object)temperatureTracker != (Object)null)
{
temperatureTracker.GetComponent<TemperatureUpdater>().SetTemperatureBounds(lower, upper);
}
}
private void RegisterNetworkEvents()
{
NetworkAPI.RegisterEvent<float>(SYNC_TEMP, (Action<ulong, float>)SyncTemperature);
}
public void SyncTemperature(ulong id, float temperature)
{
if ((Object)(object)temperatureTracker != (Object)null)
{
temperatureTracker.GetComponent<TemperatureUpdater>().SetTemperatureFromSync(temperature);
}
}
private void RegisterPatches(Harmony harmony)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Expected O, but got Unknown
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Expected O, but got Unknown
MethodInfo method = typeof(PUI_LocalPlayerStatus).GetMethod("SetInfectionbar");
harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(typeof(TemperaturePatches), "SetInfectionBarPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
MethodInfo method2 = typeof(PUI_LocalPlayerStatus).GetMethod("UpdateInfection");
harmony.Patch((MethodBase)method2, (HarmonyMethod)null, new HarmonyMethod(typeof(TemperaturePatches), "UpdateInfectionPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
MethodInfo method3 = typeof(CM_PageMap).GetMethod("UpdatePlayerInventory");
harmony.Patch((MethodBase)method3, (HarmonyMethod)null, new HarmonyMethod(typeof(TemperaturePatches), "UpdatePlayerInventoryPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
}
public class TemperaturePatches
{
private static readonly Color TempColorBarLow = new Color(1f, 0.8f, 0.32f);
private static readonly Color TempColorBarHigh = new Color(1f, 0.7f, 0f);
public static void SetInfectionBarPostfix(ref SpriteRenderer bar, float val)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: 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)
if (TemperatureManager.IsTemperatureActive)
{
bar.color = Color.Lerp(TempColorBarLow, TempColorBarHigh, val);
}
}
public static void UpdateInfectionPostfix(PUI_LocalPlayerStatus __instance, float infection, float infectionHealthRel)
{
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
if (TemperatureManager.IsTemperatureActive && ((Behaviour)__instance.m_infectionText).enabled)
{
((TMP_Text)__instance.m_infectionText).text = $"OVERHEAT : {(object)Mathf.Floor(infection * 100f)}%";
((Graphic)__instance.m_infectionText).color = Color.Lerp(TempColorBarLow, TempColorBarHigh, infection);
}
}
public static void UpdatePlayerInventoryPostfix(CM_PageMap __instance, ref SNet_Player player, int count)
{
//IL_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
if (!TemperatureManager.IsTemperatureActive || !player.IsInSlot)
{
return;
}
int num = player.PlayerSlotIndex();
PlayerAgent val = default(PlayerAgent);
if (PlayerManager.TryGetPlayerAgent(ref num, ref val))
{
string text = " <color=orange>(" + (((Dam_SyncedDamageBase)val.Damage).GetHealthRel() * 100f).ToString("N0") + "%)</color>";
if (val.Damage.Infection > 0.1f)
{
text += $"<color=#{ColorUtility.ToHtmlStringRGBA(Color.Lerp(TempColorBarLow, TempColorBarHigh, val.Damage.Infection))}>({Mathf.Floor(val.Damage.Infection * 100f)}%)</color>";
}
((Il2CppArrayBase<PUI_Inventory>)(object)__instance.m_inventory)[num].SetHeader(player.NickName + text, player.PlayerColor);
}
}
}
public class TemperatureUpdater : MonoBehaviour
{
private float tempRate;
private float currentTemp;
private bool currentlyTicking;
private float coolingRate;
private float coolingDuration;
private readonly float TEMP_SYNC_TIMER = 10f;
private float currentSyncTimer;
private readonly float TEMP_INFECTION_RATE = 0.02f;
private readonly Color TEMP_OKAY_COLOR = new Color(0.5f, 0.5f, 0.5f);
private readonly float TEMP_WARN_THRESHOLD = 37f;
private readonly Color TEMP_WARN_THRESHOLD_COLOR = Color.yellow;
private readonly float TEMP_DAMAGE_THRESHOLD = 40f;
private readonly Color TEMP_DAMAGE_THRESHOLD_COLOR = Color.red;
private static float DEFAULT_MINIMUM_TEMPERATURE = 30f;
private float currentMinumumTemperature = DEFAULT_MINIMUM_TEMPERATURE;
private static float DEFAULT_MAXIMUM_TEMPERATURE = 50f;
private float currentMaximumTemperature = DEFAULT_MAXIMUM_TEMPERATURE;
private Action<float, Color, string> displayCallback;
private Action<float> syncCallback;
public void SetupCallbacks(Action<float, Color, string> displayCallback, Action<float> syncCallback)
{
this.displayCallback = displayCallback;
this.syncCallback = syncCallback;
}
public void StartTemperatureTicking(float startTemp, float tempRate)
{
currentTemp = startTemp;
this.tempRate = tempRate;
currentlyTicking = true;
}
public void StopTemperatureTicking()
{
currentlyTicking = false;
}
public void SetTemperatureFromSync(float temp)
{
currentTemp = temp;
}
public void SetTemperatureBounds(float lower, float upper)
{
currentMinumumTemperature = lower;
currentMaximumTemperature = upper;
}
public void AddTemporaryCooling(float duration, float rate)
{
coolingDuration = duration;
coolingRate = rate;
}
private void Update()
{
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_0206: Unknown result type (might be due to invalid IL or missing references)
//IL_0218: Unknown result type (might be due to invalid IL or missing references)
//IL_0220: Unknown result type (might be due to invalid IL or missing references)
//IL_0225: Unknown result type (might be due to invalid IL or missing references)
//IL_023c: Unknown result type (might be due to invalid IL or missing references)
//IL_019c: Unknown result type (might be due to invalid IL or missing references)
//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
if (!currentlyTicking)
{
return;
}
float deltaTime = Time.deltaTime;
if (coolingDuration > 0f)
{
coolingDuration -= deltaTime;
currentTemp -= coolingRate * deltaTime;
if (coolingDuration <= 0f)
{
coolingDuration = 0f;
}
}
else
{
currentTemp += tempRate * deltaTime;
currentSyncTimer += deltaTime;
}
currentTemp = Mathf.Clamp(currentTemp, currentMinumumTemperature, currentMaximumTemperature);
if (currentSyncTimer >= TEMP_SYNC_TIMER)
{
currentSyncTimer = 0f;
syncCallback(currentTemp);
}
if (currentTemp >= TEMP_DAMAGE_THRESHOLD)
{
float amount = deltaTime * TEMP_INFECTION_RATE;
PlayerAgent localPlayerAgent = PlayerManager.GetLocalPlayerAgent();
localPlayerAgent.Damage.ModifyInfection(new pInfection
{
amount = amount,
effect = (pInfectionEffect)0,
mode = (pInfectionMode)1
}, false, false);
displayCallback(currentTemp, TEMP_DAMAGE_THRESHOLD_COLOR, "OVERHEATING");
}
else if (currentTemp >= TEMP_WARN_THRESHOLD)
{
float amount2 = deltaTime * TEMP_INFECTION_RATE * -1.5f;
PlayerAgent localPlayerAgent2 = PlayerManager.GetLocalPlayerAgent();
localPlayerAgent2.Damage.ModifyInfection(new pInfection
{
amount = amount2,
effect = (pInfectionEffect)0,
mode = (pInfectionMode)1
}, false, false);
displayCallback(currentTemp, TEMP_WARN_THRESHOLD_COLOR, "WARMING");
}
else
{
float amount3 = deltaTime * TEMP_INFECTION_RATE * -3f;
PlayerAgent localPlayerAgent3 = PlayerManager.GetLocalPlayerAgent();
localPlayerAgent3.Damage.ModifyInfection(new pInfection
{
amount = amount3,
effect = (pInfectionEffect)0,
mode = (pInfectionMode)1
}, false, false);
displayCallback(currentTemp, TEMP_OKAY_COLOR, "ACCEPTABLE");
}
}
}
}
namespace GTFODoorMod.CustomWorldEvents
{
public abstract class AbstractWorldEvent
{
protected static readonly ManualLogSource eventLogger;
public abstract string Identifier { get; }
static AbstractWorldEvent()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Expected O, but got Unknown
eventLogger = new ManualLogSource("giginss-doormod-events");
Logger.Sources.Add((ILogSource)(object)eventLogger);
}
public abstract void OnEventTrigger(ref WardenObjectiveEventData eventData);
protected bool TryGetZone(WardenObjectiveEventData eventData, out LG_Zone zone)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
if (!Builder.Current.m_currentFloor.TryGetZoneByLocalIndex(eventData.DimensionIndex, eventData.Layer, eventData.LocalIndex, ref zone))
{
zone = null;
return false;
}
return true;
}
public bool CheckWorldEventCondition(WardenObjectiveEventData eventData)
{
int conditionIndex = eventData.Condition.ConditionIndex;
if (conditionIndex == -1)
{
return true;
}
bool isTrue = eventData.Condition.IsTrue;
bool condition = WorldEventManager.GetCondition(conditionIndex);
return isTrue == condition;
}
protected LG_WeakDoor[] GetAllWeakDoorsInZone(LG_Zone zone)
{
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Invalid comparison between Unknown and I4
Dictionary<uint, LG_WeakDoor> dictionary = new Dictionary<uint, LG_WeakDoor>();
Enumerator<AIG_CourseNode> enumerator = zone.m_courseNodes.GetEnumerator();
while (enumerator.MoveNext())
{
AIG_CourseNode current = enumerator.Current;
Enumerator<AIG_CoursePortal> enumerator2 = current.m_portals.GetEnumerator();
while (enumerator2.MoveNext())
{
AIG_CoursePortal current2 = enumerator2.Current;
iLG_Door_Core door = current2.m_door;
if (door != null && (int)door.DoorType == 1)
{
LG_WeakDoor val = ((Il2CppObjectBase)current2.m_door).TryCast<LG_WeakDoor>();
if ((Object)(object)val != (Object)null)
{
dictionary.TryAdd(val.MapperDataID, val);
}
}
}
}
return dictionary.Values.ToArray();
}
}
public class ActivateTemperature : AbstractWorldEvent
{
private TemperatureManager TemperatureManager;
public override string Identifier => "ActivateTemperature";
public ActivateTemperature(TemperatureManager temperatureManager)
{
TemperatureManager = temperatureManager;
}
public override void OnEventTrigger(ref WardenObjectiveEventData eData)
{
TemperatureManager.ActivateTemperature(eData.Duration, eData.FogTransitionDuration);
}
}
public class AddMovementSpeed : AbstractWorldEvent
{
public override string Identifier => "AddMovementSpeed";
public override void OnEventTrigger(ref WardenObjectiveEventData eventData)
{
MoveSpeedAPI.AddModifier(eventData.Duration, (StackLayer)1, "Maintenance");
}
}
public class ChangeLastKnownMainDimPosition : AbstractWorldEvent
{
public override string Identifier => "ForgetLastKnownMainDimPosition";
public override void OnEventTrigger(ref WardenObjectiveEventData eData)
{
//IL_014e: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Expected O, but got Unknown
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Expected O, but got Unknown
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Expected O, but got Unknown
Il2CppArrayBase<PlayerAgent> items = PlayerManager.PlayerAgentsInLevel._items;
TryGetZone(eData, out var zone);
bool flag = default(bool);
for (int i = 0; i < items.Count; i++)
{
PlayerAgent val = items[i];
if (!((Object)(object)val != (Object)null))
{
continue;
}
if (eData.Enabled)
{
if (zone.m_courseNodes._items.Count > 0)
{
AIG_CourseNode val2 = zone.m_courseNodes._items[0];
val.HasLastKnownMainDimensionPosition = true;
val.LastKnownMainDimensionPosition = val2.GetRandomPositionInside();
val.LastKnownMainDimensionCourseNode = val2;
BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(99, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(val.PlayerName);
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" has had their last known dimension position changed to a random position inside courseNode 0 for ");
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(((Object)zone).name);
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(".");
}
AbstractWorldEvent.eventLogger.LogInfo(val3);
}
else
{
BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(81, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("No course nodes found for zone ");
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(((Object)zone).name);
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("! Resetting last known dimension position instead.");
}
AbstractWorldEvent.eventLogger.LogInfo(val3);
val.HasLastKnownMainDimensionPosition = false;
}
}
else
{
val.HasLastKnownMainDimensionPosition = false;
BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(45, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(val.PlayerName);
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" has forgotten their last known dim position!");
}
AbstractWorldEvent.eventLogger.LogInfo(val3);
}
}
}
}
public class CloseAllWeakDoorsInZone : AbstractWorldEvent
{
public override string Identifier => "CloseAllWeakDoorsInZone";
public override void OnEventTrigger(ref WardenObjectiveEventData eData)
{
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Expected O, but got Unknown
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
if (!SNet.IsMaster)
{
return;
}
if (TryGetZone(eData, out var zone))
{
LG_WeakDoor[] allWeakDoorsInZone = GetAllWeakDoorsInZone(zone);
LG_WeakDoor[] array = allWeakDoorsInZone;
foreach (LG_WeakDoor val in array)
{
val.m_sync.AttemptDoorInteraction((eDoorInteractionType)6, 0f, 0f, default(Vector3), (Agent)null);
}
}
else
{
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(33, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(Identifier);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" event failed to get target zone!");
}
AbstractWorldEvent.eventLogger.LogError(val2);
}
}
}
public class DeactivateTemperature : AbstractWorldEvent
{
private TemperatureManager TemperatureManager;
public override string Identifier => "DeactivateTemperature";
public DeactivateTemperature(TemperatureManager temperatureManager)
{
TemperatureManager = temperatureManager;
}
public override void OnEventTrigger(ref WardenObjectiveEventData eData)
{
TemperatureManager.DeactivateTemperature();
}
}
public class DoorLockTracker
{
private static readonly HashSet<uint> LockedDoors = new HashSet<uint>();
public static bool IsDoorLocked(uint doorId)
{
return LockedDoors.Contains(doorId);
}
public static void LockDoor(uint doorId)
{
LockedDoors.Add(doorId);
}
public static void UnlockDoor(uint doorId)
{
LockedDoors.Remove(doorId);
}
public static void ClearLockedDoors()
{
LockedDoors.Clear();
}
}
public class DoorPatcher
{
private static readonly ManualLogSource DoorLogger = new ManualLogSource("giginss-doormod-door-patcher");
public DoorPatcher(Harmony harmony)
{
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Expected O, but got Unknown
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Expected O, but got Unknown
Logger.Sources.Add((ILogSource)(object)DoorLogger);
DoorLogger.LogInfo((object)"Patching door method");
MethodInfo method = typeof(LG_WeakDoor).GetMethod("AttemptOpenCloseInteraction");
MethodInfo methodInfo = typeof(LG_WeakDoor).GetProperty("InteractionAllowed")?.GetGetMethod();
harmony.Patch((MethodBase)method, new HarmonyMethod(typeof(DoorPatcher), "OpenCloseInteractionPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
if (methodInfo != null)
{
harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(DoorPatcher), "InteractionAllowedPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
DoorLogger.LogInfo((object)"Patching successful!");
}
private static bool OpenCloseInteractionPrefix(LG_WeakDoor __instance, bool onlyUnlock)
{
if (DoorLockTracker.IsDoorLocked(__instance.MapperDataID))
{
return false;
}
return true;
}
private static bool InteractionAllowedPrefix(LG_WeakDoor __instance)
{
if (DoorLockTracker.IsDoorLocked(__instance.MapperDataID))
{
return false;
}
return true;
}
}
public class ForceSolveUplink : AbstractWorldEvent
{
public override string Identifier => "ForceSolveUplink";
public override void OnEventTrigger(ref WardenObjectiveEventData eData)
{
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Expected O, but got Unknown
if (TryGetZone(eData, out var zone))
{
bool flag = false;
Enumerator<LG_ComputerTerminal> enumerator = zone.TerminalsSpawnedInZone.GetEnumerator();
while (enumerator.MoveNext())
{
LG_ComputerTerminal current = enumerator.Current;
if (current.UplinkPuzzle.Connected)
{
flag = true;
current.UplinkPuzzle.Solved = true;
current.UplinkPuzzle.UpdateGUI(false);
current.AddLine((TerminalLineType)5, "Forcefully terminating uplink", 3f);
if (current.UplinkPuzzle.OnPuzzleSolved != null)
{
current.UplinkPuzzle.OnPuzzleSolved.Invoke();
}
}
}
if (!flag)
{
bool flag2 = default(bool);
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(45, 1, ref flag2);
if (flag2)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Failed to find any active uplink terminal in ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(zone.m_navInfo.GetFormattedText((LG_NavInfoFormat)6));
}
AbstractWorldEvent.eventLogger.LogError(val);
}
}
else
{
AbstractWorldEvent.eventLogger.LogError((object)"Failed to find zone for ForceSolveUplink!");
}
}
}
public class LockAllDoorsInZone : AbstractWorldEvent
{
public override string Identifier => "LockAllDoorsInZone";
public override void OnEventTrigger(ref WardenObjectiveEventData eData)
{
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
//IL_0195: Expected O, but got Unknown
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
if (TryGetZone(eData, out var zone))
{
LG_WeakDoor[] allWeakDoorsInZone = GetAllWeakDoorsInZone(zone);
Texture2D redXTexture = WorldEventsPatcher.GetRedXTexture();
Sprite sprite = Sprite.Create(redXTexture, new Rect(0f, 0f, (float)((Texture)redXTexture).width, (float)((Texture)redXTexture).height), new Vector2(0.5f, 0.5f), 100f);
LG_WeakDoor[] array = allWeakDoorsInZone;
foreach (LG_WeakDoor val in array)
{
DoorLockTracker.LockDoor(val.MapperDataID);
foreach (LG_DoorButton item in (Il2CppArrayBase<LG_DoorButton>)(object)val.m_buttons)
{
foreach (SpriteRenderer componentsInChild in ((Component)item).gameObject.GetComponentsInChildren<SpriteRenderer>())
{
if (((Object)componentsInChild).name.Equals("DoorFrame"))
{
SpriteRenderer val2 = Object.Instantiate<SpriteRenderer>(componentsInChild, ((Component)((Component)componentsInChild).transform.parent).gameObject.transform);
((Object)val2).name = WorldEventsPatcher.SpriteName;
val2.sprite = sprite;
((Renderer)val2).enabled = true;
}
if (WorldEventsPatcher.DoorSpriteRenderers.Contains(((Object)componentsInChild).name))
{
((Component)componentsInChild).gameObject.SetActive(false);
}
}
}
}
}
else
{
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(33, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(Identifier);
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" event failed to get target zone!");
}
AbstractWorldEvent.eventLogger.LogError(val3);
}
}
}
public class OpenAllWeakDoorsInZone : AbstractWorldEvent
{
public override string Identifier => "OpenAllWeakDoorsInZone";
public override void OnEventTrigger(ref WardenObjectiveEventData eData)
{
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Expected O, but got Unknown
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
if (!SNet.IsMaster)
{
return;
}
if (TryGetZone(eData, out var zone))
{
LG_WeakDoor[] allWeakDoorsInZone = GetAllWeakDoorsInZone(zone);
LG_WeakDoor[] array = allWeakDoorsInZone;
foreach (LG_WeakDoor val in array)
{
val.m_sync.AttemptDoorInteraction((eDoorInteractionType)0, 0f, 0f, default(Vector3), (Agent)null);
}
}
else
{
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(33, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(Identifier);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" event failed to get target zone!");
}
AbstractWorldEvent.eventLogger.LogError(val2);
}
}
}
public class ReplaceZoneDoorAlarm : AbstractWorldEvent
{
public override string Identifier => "ReplaceZoneDoorAlarm";
public override void OnEventTrigger(ref WardenObjectiveEventData eData)
{
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Expected O, but got Unknown
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: 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_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Expected I4, but got Unknown
TryGetZone(eData, out var zone);
LG_SecurityDoor val = ((Il2CppObjectBase)zone.m_sourceGate.SpawnedDoor).TryCast<LG_SecurityDoor>();
if ((Object)(object)val != (Object)null)
{
ReplicationPatch.OverrideCount++;
eDoorStatus lastStatus = val.LastStatus;
eDoorStatus val2 = lastStatus;
switch ((int)val2)
{
case 8:
case 9:
case 10:
case 16:
AbstractWorldEvent.eventLogger.LogWarning((object)"Set up chained puzzle on potentially invalid door state.");
val.SetupChainedPuzzleLock(eData.ChainPuzzle);
break;
case 1:
case 3:
case 4:
case 5:
case 6:
case 7:
case 15:
val.SetupChainedPuzzleLock(eData.ChainPuzzle);
break;
case 0:
case 2:
case 11:
case 12:
case 13:
case 14:
AbstractWorldEvent.eventLogger.LogError((object)"Tried to setup chained puzzle on invalid door state");
break;
}
ReplicationPatch.OverrideCount--;
}
else
{
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(38, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(Identifier);
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" event failed to read a security door!");
}
AbstractWorldEvent.eventLogger.LogError(val3);
}
}
}
public class SetTemperatureBounds : AbstractWorldEvent
{
private TemperatureManager temperatureManager;
public override string Identifier => "SetTemperatureBounds";
public SetTemperatureBounds(TemperatureManager manager)
{
temperatureManager = manager;
}
public override void OnEventTrigger(ref WardenObjectiveEventData eData)
{
temperatureManager.SetTemperatureBounds(eData.Duration, eData.FogTransitionDuration);
}
}
public class StartTemperatureCooling : AbstractWorldEvent
{
private TemperatureManager TemperatureManager;
public override string Identifier => "StartTemperatureCooling";
public StartTemperatureCooling(TemperatureManager temperatureManager)
{
TemperatureManager = temperatureManager;
}
public override void OnEventTrigger(ref WardenObjectiveEventData eData)
{
TemperatureManager.AddTemporaryCooling(eData.Duration, eData.FogTransitionDuration);
}
}
public class TeleportPocketItems : AbstractWorldEvent
{
public override string Identifier => "TeleportPocketItems";
public override void OnEventTrigger(ref WardenObjectiveEventData eventData)
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Expected O, but got Unknown
//IL_0263: Unknown result type (might be due to invalid IL or missing references)
//IL_026a: Expected O, but got Unknown
int count = eventData.Count;
int enemyID = (int)eventData.EnemyID;
List<PlayerAgent> playerAgentsInLevel = PlayerManager.PlayerAgentsInLevel;
bool flag = default(bool);
if (count >= playerAgentsInLevel.Count || enemyID >= playerAgentsInLevel.Count)
{
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(95, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Either ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(count);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" or ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(enemyID);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" are out of range when trying to teleport pocket items. Number of player agents is ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(playerAgentsInLevel.Count);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
}
AbstractWorldEvent.eventLogger.LogWarning(val);
return;
}
PlayerAgent val2 = playerAgentsInLevel[count];
PlayerAgent val3 = playerAgentsInLevel[enemyID];
PlayerBackpack val4 = default(PlayerBackpack);
bool flag2 = PlayerBackpackManager.TryGetBackpack(val2.Owner, ref val4);
PlayerBackpack val5 = default(PlayerBackpack);
bool flag3 = PlayerBackpackManager.TryGetBackpack(val3.Owner, ref val5);
if (!flag2 || !flag3)
{
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(67, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Failed to get source and/or destination backpack for indices ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(count);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" and ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(enemyID);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("!");
}
AbstractWorldEvent.eventLogger.LogWarning(val);
return;
}
List<List<PocketItem>> pocketItemsGroups = val4.PocketItemsGroups;
for (int i = 0; i < pocketItemsGroups.Count; i++)
{
List<PocketItem> val6 = pocketItemsGroups._items[i];
for (int j = 0; j < val6.Count; j++)
{
if (val6.Count > 0)
{
PocketItem val7 = val6._items[0];
if (!val5.ItemIDToPocketItemGroup.ContainsKey(val7.itemID))
{
val5.ItemIDToPocketItemGroup.Add(val7.itemID, new List<PocketItem>());
val5.PocketItemsGroups.Add(val5.ItemIDToPocketItemGroup[val7.itemID]);
}
val5.ItemIDToPocketItemGroup[val7.itemID].Add(val7);
}
}
val6.Clear();
}
pocketItemsGroups.Clear();
val4.ItemIDToPocketItemGroup.Clear();
BepInExInfoLogInterpolatedStringHandler val8 = new BepInExInfoLogInterpolatedStringHandler(35, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val8).AppendLiteral("Transferred pocket items from ");
((BepInExLogInterpolatedStringHandler)val8).AppendFormatted<int>(count);
((BepInExLogInterpolatedStringHandler)val8).AppendLiteral(" to ");
((BepInExLogInterpolatedStringHandler)val8).AppendFormatted<int>(enemyID);
((BepInExLogInterpolatedStringHandler)val8).AppendLiteral(".");
}
AbstractWorldEvent.eventLogger.LogInfo(val8);
PlayerBackpackManager.UpdatePocketItemGUI();
}
}
public class TeleportResourcePack : AbstractWorldEvent
{
public override string Identifier => "TeleportResourcePack";
public override void OnEventTrigger(ref WardenObjectiveEventData eventData)
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Expected O, but got Unknown
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_010e: Expected O, but got Unknown
//IL_0180: Unknown result type (might be due to invalid IL or missing references)
//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
//IL_01aa: Expected O, but got Unknown
//IL_0200: Unknown result type (might be due to invalid IL or missing references)
//IL_0223: Unknown result type (might be due to invalid IL or missing references)
//IL_022a: Expected O, but got Unknown
//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
//IL_02cc: Expected O, but got Unknown
//IL_026b: Unknown result type (might be due to invalid IL or missing references)
//IL_023d: Unknown result type (might be due to invalid IL or missing references)
//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
//IL_03af: Expected O, but got Unknown
//IL_034b: Unknown result type (might be due to invalid IL or missing references)
//IL_0352: Expected O, but got Unknown
int count = eventData.Count;
int enemyID = (int)eventData.EnemyID;
if (!SNet.IsMaster)
{
return;
}
List<PlayerAgent> playerAgentsInLevel = PlayerManager.PlayerAgentsInLevel;
bool flag = default(bool);
if (count >= playerAgentsInLevel.Count || enemyID >= playerAgentsInLevel.Count)
{
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(95, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Either ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(count);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" or ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(enemyID);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" are out of range when trying to teleport pocket items. Number of player agents is ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(playerAgentsInLevel.Count);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(".");
}
AbstractWorldEvent.eventLogger.LogWarning(val);
return;
}
PlayerAgent val2 = playerAgentsInLevel[count];
PlayerAgent val3 = playerAgentsInLevel[enemyID];
PlayerBackpack val4 = default(PlayerBackpack);
bool flag2 = PlayerBackpackManager.TryGetBackpack(val2.Owner, ref val4);
PlayerBackpack val5 = default(PlayerBackpack);
bool flag3 = PlayerBackpackManager.TryGetBackpack(val3.Owner, ref val5);
if (!flag2 || !flag3)
{
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(67, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Failed to get source and/or destination backpack for indices ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(count);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" and ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(enemyID);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("!");
}
AbstractWorldEvent.eventLogger.LogWarning(val);
return;
}
BackpackItem val6 = default(BackpackItem);
bool flag4 = val4.TryGetBackpackItem((InventorySlot)4, ref val6);
BackpackItem val7 = default(BackpackItem);
bool flag5 = val5.TryGetBackpackItem((InventorySlot)4, ref val7);
if (flag4)
{
pItemData_Custom val8 = new pItemData_Custom
{
ammo = val4.AmmoStorage.ResourcePackAmmo.AmmoInPack
};
BepInExInfoLogInterpolatedStringHandler val9 = new BepInExInfoLogInterpolatedStringHandler(27, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral("Set source custom.ammo to ");
((BepInExLogInterpolatedStringHandler)val9).AppendFormatted<float>(val8.ammo);
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral(".");
}
AbstractWorldEvent.eventLogger.LogInfo(val9);
val6.Instance.SetCustomData(val8, false);
}
if (flag5)
{
pItemData_Custom val10 = new pItemData_Custom
{
ammo = val5.AmmoStorage.ResourcePackAmmo.AmmoInPack
};
BepInExInfoLogInterpolatedStringHandler val9 = new BepInExInfoLogInterpolatedStringHandler(32, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral("Set destination custom.ammo to ");
((BepInExLogInterpolatedStringHandler)val9).AppendFormatted<float>(val10.ammo);
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral(".");
}
AbstractWorldEvent.eventLogger.LogInfo(val9);
val7.Instance.SetCustomData(val10, false);
}
if (flag5 && flag4)
{
PlayerBackpackManager.MasterRemoveItem(val6.Instance, val4);
PlayerBackpackManager.MasterRemoveItem(val7.Instance, val5);
PlayerBackpackManager.MasterAddItem(val7.Instance, val4);
PlayerBackpackManager.MasterAddItem(val6.Instance, val5);
BepInExInfoLogInterpolatedStringHandler val9 = new BepInExInfoLogInterpolatedStringHandler(45, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral("Swapped resource packs between indices ");
((BepInExLogInterpolatedStringHandler)val9).AppendFormatted<int>(count);
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral(" and ");
((BepInExLogInterpolatedStringHandler)val9).AppendFormatted<int>(enemyID);
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral(".");
}
AbstractWorldEvent.eventLogger.LogInfo(val9);
}
else if (!flag5)
{
PlayerBackpackManager.MasterRemoveItem(val6.Instance, val4);
PlayerBackpackManager.MasterAddItem(val6.Instance, val5);
BepInExInfoLogInterpolatedStringHandler val9 = new BepInExInfoLogInterpolatedStringHandler(29, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral("Sent resource pack from ");
((BepInExLogInterpolatedStringHandler)val9).AppendFormatted<int>(count);
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral(" to ");
((BepInExLogInterpolatedStringHandler)val9).AppendFormatted<int>(enemyID);
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral(".");
}
AbstractWorldEvent.eventLogger.LogInfo(val9);
}
else
{
BepInExInfoLogInterpolatedStringHandler val9 = new BepInExInfoLogInterpolatedStringHandler(49, 4, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral("Failed to teleport resource packs from ");
((BepInExLogInterpolatedStringHandler)val9).AppendFormatted<int>(count);
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral(" to ");
((BepInExLogInterpolatedStringHandler)val9).AppendFormatted<int>(enemyID);
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral("! (");
((BepInExLogInterpolatedStringHandler)val9).AppendFormatted<bool>(flag4);
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral(", ");
((BepInExLogInterpolatedStringHandler)val9).AppendFormatted<bool>(flag5);
((BepInExLogInterpolatedStringHandler)val9).AppendLiteral(")");
}
AbstractWorldEvent.eventLogger.LogInfo(val9);
}
}
}
public class UnlockAllDoorsInZone : AbstractWorldEvent
{
public override string Identifier => "UnlockAllDoorsInZone";
public override void OnEventTrigger(ref WardenObjectiveEventData eData)
{
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_011c: Expected O, but got Unknown
if (TryGetZone(eData, out var zone))
{
LG_WeakDoor[] allWeakDoorsInZone = GetAllWeakDoorsInZone(zone);
LG_WeakDoor[] array = allWeakDoorsInZone;
foreach (LG_WeakDoor val in array)
{
DoorLockTracker.UnlockDoor(val.MapperDataID);
foreach (LG_DoorButton item in (Il2CppArrayBase<LG_DoorButton>)(object)val.m_buttons)
{
foreach (SpriteRenderer componentsInChild in ((Component)item).gameObject.GetComponentsInChildren<SpriteRenderer>(true))
{
if (((Object)componentsInChild).name.Equals(WorldEventsPatcher.SpriteName))
{
Object.Destroy((Object)(object)((Component)componentsInChild).gameObject);
}
if (WorldEventsPatcher.DoorSpriteRenderers.Contains(((Object)componentsInChild).name))
{
((Component)componentsInChild).gameObject.SetActive(true);
}
}
}
}
}
else
{
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(33, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(Identifier);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" event failed to get target zone!");
}
AbstractWorldEvent.eventLogger.LogError(val2);
}
}
}
public class WorldEventsPatcher
{
private static Dictionary<int, AbstractWorldEvent> _customWorldEvents = new Dictionary<int, AbstractWorldEvent>();
private Dictionary<string, object> _enumMapping = new Dictionary<string, object>();
private static readonly ManualLogSource EventsLogger = new ManualLogSource("giginss.rundownmod.events-patcher");
private static Texture2D RedXTexture;
public static readonly List<string> DoorSpriteRenderers = new List<string>
{
"DoorFrame", "Door_Blade_1", "Door_Blade_2", "Door_Blade_3", "Door_Blade_4", "Door_Blade_5", "Door_Blade_6", "Door_Blade_7", "Door_Blade_Broken", "DoorEnterArrow_1",
"DoorEnterArrow_2", "DoorEnterArrow_3", "DoorExitArrow"
};
private static readonly int eWardenObjectiveEventTypeOffset = 50;
private int currentCount = 0;
private TemperatureManager TemperatureManager;
public static string SpriteName => "DoorRedX";
public WorldEventsPatcher(Harmony harmony, Texture2D redX)
{
//IL_0211: Unknown result type (might be due to invalid IL or missing references)
//IL_021f: Expected O, but got Unknown
//IL_024a: Unknown result type (might be due to invalid IL or missing references)
//IL_0257: Expected O, but got Unknown
Logger.Sources.Add((ILogSource)(object)EventsLogger);
TemperatureManager = new TemperatureManager(harmony);
RedXTexture = redX;
Object.DontDestroyOnLoad((Object)(object)RedXTexture);
((Object)RedXTexture).hideFlags = (HideFlags)61;
EventsLogger.LogDebug((object)"Creating door events");
LockAllDoorsInZone worldEvent = new LockAllDoorsInZone();
UnlockAllDoorsInZone worldEvent2 = new UnlockAllDoorsInZone();
OpenAllWeakDoorsInZone worldEvent3 = new OpenAllWeakDoorsInZone();
CloseAllWeakDoorsInZone worldEvent4 = new CloseAllWeakDoorsInZone();
ReplaceZoneDoorAlarm worldEvent5 = new ReplaceZoneDoorAlarm();
ChangeLastKnownMainDimPosition worldEvent6 = new ChangeLastKnownMainDimPosition();
TeleportResourcePack worldEvent7 = new TeleportResourcePack();
TeleportPocketItems worldEvent8 = new TeleportPocketItems();
AddMovementSpeed worldEvent9 = new AddMovementSpeed();
ActivateTemperature worldEvent10 = new ActivateTemperature(TemperatureManager);
DeactivateTemperature worldEvent11 = new DeactivateTemperature(TemperatureManager);
StartTemperatureCooling worldEvent12 = new StartTemperatureCooling(TemperatureManager);
SetTemperatureBounds worldEvent13 = new SetTemperatureBounds(TemperatureManager);
ForceSolveUplink worldEvent14 = new ForceSolveUplink();
EventsLogger.LogDebug((object)"Registering events");
AddToCustomWorldEvents(worldEvent);
AddToCustomWorldEvents(worldEvent2);
AddToCustomWorldEvents(worldEvent3);
AddToCustomWorldEvents(worldEvent4);
AddToCustomWorldEvents(worldEvent5);
AddToCustomWorldEvents(worldEvent6);
AddToCustomWorldEvents(worldEvent7);
AddToCustomWorldEvents(worldEvent8);
AddToCustomWorldEvents(worldEvent9);
AddToCustomWorldEvents(worldEvent10);
AddToCustomWorldEvents(worldEvent11);
AddToCustomWorldEvents(worldEvent12);
AddToCustomWorldEvents(worldEvent13);
AddToCustomWorldEvents(worldEvent14);
EventsLogger.LogDebug((object)"Injecting events into enum...");
foreach (KeyValuePair<int, AbstractWorldEvent> customWorldEvent in _customWorldEvents)
{
_enumMapping[customWorldEvent.Value.Identifier] = customWorldEvent.Key;
}
EnumInjector.InjectEnumValues<eWardenObjectiveEventType>(_enumMapping);
EventsLogger.LogDebug((object)"Injection complete, patching...");
MethodInfo method = typeof(WorldEventManager).GetMethod("ExecuteEvent");
harmony.Patch((MethodBase)method, new HarmonyMethod(typeof(WorldEventsPatcher), "ExecuteEventPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
MethodInfo method2 = typeof(GS_AfterLevel).GetMethod("CleanupAfterExpedition");
harmony.Patch((MethodBase)method2, (HarmonyMethod)null, new HarmonyMethod(typeof(WorldEventsPatcher), "CleanupLevelPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
EventsLogger.LogDebug((object)"Patching successful!");
}
private void AddToCustomWorldEvents(AbstractWorldEvent worldEvent)
{
int key = eWardenObjectiveEventTypeOffset + currentCount;
currentCount++;
_customWorldEvents.Add(key, worldEvent);
}
private static bool ExecuteEventPrefix(ref WardenObjectiveEventData eData, float currentDuration)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected I4, but got Unknown
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Expected I4, but got Unknown
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Expected O, but got Unknown
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
if (_customWorldEvents.ContainsKey((int)eData.Type))
{
bool flag = default(bool);
if (_customWorldEvents.TryGetValue((int)eData.Type, out var value))
{
BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(11, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Triggering ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(value.Identifier);
}
EventsLogger.LogDebug(val);
if (!value.CheckWorldEventCondition(eData))
{
return false;
}
float delay = eData.Delay;
if (delay > 0f)
{
CoroutineDispatcher.StartCoroutine(ExecuteEventCoroutine(value, eData, delay));
}
else
{
ExecuteEvent(value, eData);
}
}
else
{
BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(81, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Key ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<eWardenObjectiveEventType>(eData.Type);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" exists in the custom world events dictionary but failed to retrieve it!?!?!?");
}
EventsLogger.LogError(val2);
}
return false;
}
return true;
}
[HarmonyPostfix]
private static void CleanupLevelPostfix()
{
DoorLockTracker.ClearLockedDoors();
}
public static Texture2D GetRedXTexture()
{
return RedXTexture;
}
private static IEnumerator ExecuteEventCoroutine(AbstractWorldEvent abstractWorldEvent, WardenObjectiveEventData eData, float delay)
{
yield return (object)new WaitForSeconds(delay);
ExecuteEvent(abstractWorldEvent, eData);
}
private static void ExecuteEvent(AbstractWorldEvent abstractWorldEvent, WardenObjectiveEventData eData)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
abstractWorldEvent.OnEventTrigger(ref eData);
WardenObjectiveManager.DisplayWardenIntel(eData.Layer, eData.WardenIntel);
}
}
}
