using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using InfestOnly;
using Microsoft.CodeAnalysis;
using OreoM.InfestOnly.NetcodePatcher;
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: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: AssemblyCompany("OreoM.InfestOnly")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.6.0")]
[assembly: AssemblyInformationalVersion("1.0.6")]
[assembly: AssemblyProduct("InfestOnly")]
[assembly: AssemblyTitle("OreoM.InfestOnly")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.6.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
static <Module>()
{
NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<InfestConfig.infestModeConfig>();
NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals<InfestConfig.infestModeConfig>();
NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<InfestConfig.fogConfig>();
NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals<InfestConfig.fogConfig>();
}
}
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 InfestOnly
{
internal class InfestConfig
{
public enum fogConfig
{
None,
Vanilla,
Infestation,
Always
}
public enum infestModeConfig
{
Vanilla,
All,
Chaotic
}
public readonly ConfigEntry<fogConfig> fog;
public readonly ConfigEntry<infestModeConfig> infestMode;
public readonly ConfigEntry<int> chaoticSpawnCap;
public InfestConfig(ConfigFile cfg)
{
cfg.SaveOnConfigSet = false;
fog = cfg.Bind<fogConfig>("General", "Fog rarity", fogConfig.Infestation, "None: disables indoor fog.\nVanilla: vanilla behavior (2% chance with a ~2.5% chance of 20% chance).\nInfestation: 20% as if infestation has been triggered every day\nAlways: 100%");
infestMode = cfg.Bind<infestModeConfig>("General.Mode", "Infestation mode", infestModeConfig.Vanilla, "Vanilla: vanilla behavior *25/75 split for Nutcracker/Hoarding Bug).\nAll: all enemies can be choosen for infestation except ones with a max count of 1\nChaotic: all enemies can be choosen including those with a max count of 1 (also changes their max spawn)");
chaoticSpawnCap = cfg.Bind<int>("General.Mode", "Chaotic mode spawn cap", 3, "What spawn cap will be choosen for enemies with max count of 1 if chaotic mode is enabled");
ClearOrphanedEntries(cfg);
cfg.Save();
cfg.SaveOnConfigSet = true;
}
private static void ClearOrphanedEntries(ConfigFile cfg)
{
PropertyInfo propertyInfo = AccessTools.Property(typeof(ConfigFile), "OrphanedEntries");
Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)propertyInfo.GetValue(cfg);
dictionary.Clear();
}
}
internal class InfestNetworkHandler : NetworkBehaviour
{
private static GameObject prefab;
internal static InfestNetworkHandler Instance { get; private set; }
internal NetworkVariable<InfestConfig.infestModeConfig> netInfestModeConfig { get; private set; } = new NetworkVariable<InfestConfig.infestModeConfig>(InfestConfig.infestModeConfig.Vanilla, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal NetworkVariable<InfestConfig.fogConfig> netFogConfig { get; private set; } = new NetworkVariable<InfestConfig.fogConfig>(InfestConfig.fogConfig.None, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal NetworkVariable<int> netChaoticSpawnCap { get; private set; } = new NetworkVariable<int>(0, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
internal static void Init()
{
//IL_0014: 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_0026: Expected O, but got Unknown
if ((Object)(object)prefab != (Object)null)
{
return;
}
try
{
prefab = new GameObject("InfestNetworkHandler")
{
hideFlags = (HideFlags)61
};
NetworkObject val = prefab.AddComponent<NetworkObject>();
val.GlobalObjectIdHash = XXHash.Hash32("OreoM.InfestOnly" + ((Object)prefab).name);
prefab.AddComponent<InfestNetworkHandler>();
NetworkManager.Singleton.AddNetworkPrefab(prefab);
InfestOnly.Logger.LogInfo((object)"Network handler initilized");
}
catch (Exception ex)
{
InfestOnly.Logger.LogError((object)("Network handler init handler error\n" + ex));
}
}
internal static void Create()
{
try
{
if (NetworkManager.Singleton.IsServer && (Object)(object)prefab != (Object)null)
{
Object.Instantiate<GameObject>(prefab).GetComponent<NetworkObject>().Spawn(false);
}
}
catch
{
InfestOnly.Logger.LogError((object)"Encountered some fatal error while spawning network handler. It is likely that registration failed earlier on start-up, please consult your logs.");
}
}
private void Awake()
{
Instance = this;
}
public override void OnNetworkSpawn()
{
((NetworkBehaviour)this).OnNetworkSpawn();
if ((Object)(object)Instance != (Object)(object)this)
{
NetworkObject val = default(NetworkObject);
if (((Component)Instance).TryGetComponent<NetworkObject>(ref val) && !val.IsSpawned && (Object)(object)Instance != (Object)(object)prefab)
{
Object.Destroy((Object)(object)Instance);
}
InfestOnly.Logger.LogWarning((object)"There are 2 InfestOnlys instantiated, and the wrong one was assigned as Instance. This shouldn't happen, but is recoverable");
Instance = this;
}
InfestOnly.Logger.LogDebug((object)"Successfully spawned network handler.");
}
private void Start()
{
//IL_0030: 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)
if (!((Object)(object)this != (Object)(object)Instance) && ((NetworkBehaviour)this).IsSpawned)
{
if (((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost)
{
SetServerValues();
}
else
{
RetrieveConfigServerRpc();
}
}
}
private void SetServerValues()
{
netInfestModeConfig.Set(InfestOnly.config.infestMode.Value);
netFogConfig.Set(InfestOnly.config.fog.Value);
netChaoticSpawnCap.Set(InfestOnly.config.chaoticSpawnCap.Value);
}
[ServerRpc(RequireOwnership = false)]
private void RetrieveConfigServerRpc(ServerRpcParams serverRpcParams = default(ServerRpcParams))
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: 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)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
{
FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2969615009u, serverRpcParams, (RpcDelivery)0);
((NetworkBehaviour)this).__endSendServerRpc(ref val, 2969615009u, serverRpcParams, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
{
ulong senderClientId = serverRpcParams.Receive.SenderClientId;
ClientRpcParams val2 = default(ClientRpcParams);
val2.Send = new ClientRpcSendParams
{
TargetClientIds = new ulong[1] { senderClientId }
};
ClientRpcParams clientRpcParams = val2;
RecieveConfigClientRpc(netFogConfig.Value, netInfestModeConfig.Value, netChaoticSpawnCap.Value, clientRpcParams);
}
}
}
[ClientRpc]
private void RecieveConfigClientRpc(InfestConfig.fogConfig fogConfig, InfestConfig.infestModeConfig infestMode, int chaoticSpawnCap, ClientRpcParams clientRpcParams = default(ClientRpcParams))
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: 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_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
{
FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3450000209u, clientRpcParams, (RpcDelivery)0);
((FastBufferWriter)(ref val)).WriteValueSafe<InfestConfig.fogConfig>(ref fogConfig, default(ForEnums));
((FastBufferWriter)(ref val)).WriteValueSafe<InfestConfig.infestModeConfig>(ref infestMode, default(ForEnums));
BytePacker.WriteValueBitPacked(val, chaoticSpawnCap);
((NetworkBehaviour)this).__endSendClientRpc(ref val, 3450000209u, clientRpcParams, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
{
netInfestModeConfig.Set(infestMode);
netFogConfig.Set(fogConfig);
netChaoticSpawnCap.Set(chaoticSpawnCap);
}
}
}
protected override void __initializeVariables()
{
if (netInfestModeConfig == null)
{
throw new Exception("InfestNetworkHandler.<netInfestModeConfig>k__BackingField cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)netInfestModeConfig).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)netInfestModeConfig, "netInfestModeConfig");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)netInfestModeConfig);
if (netFogConfig == null)
{
throw new Exception("InfestNetworkHandler.<netFogConfig>k__BackingField cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)netFogConfig).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)netFogConfig, "netFogConfig");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)netFogConfig);
if (netChaoticSpawnCap == null)
{
throw new Exception("InfestNetworkHandler.<netChaoticSpawnCap>k__BackingField cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)netChaoticSpawnCap).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)netChaoticSpawnCap, "netChaoticSpawnCap");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)netChaoticSpawnCap);
((NetworkBehaviour)this).__initializeVariables();
}
[RuntimeInitializeOnLoadMethod]
internal static void InitializeRPCS_InfestNetworkHandler()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
NetworkManager.__rpc_func_table.Add(2969615009u, new RpcReceiveHandler(__rpc_handler_2969615009));
NetworkManager.__rpc_func_table.Add(3450000209u, new RpcReceiveHandler(__rpc_handler_3450000209));
}
private static void __rpc_handler_2969615009(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: 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)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
ServerRpcParams server = rpcParams.Server;
target.__rpc_exec_stage = (__RpcExecStage)1;
((InfestNetworkHandler)(object)target).RetrieveConfigServerRpc(server);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_3450000209(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//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)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: 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_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
InfestConfig.fogConfig fogConfig = default(InfestConfig.fogConfig);
((FastBufferReader)(ref reader)).ReadValueSafe<InfestConfig.fogConfig>(ref fogConfig, default(ForEnums));
InfestConfig.infestModeConfig infestMode = default(InfestConfig.infestModeConfig);
((FastBufferReader)(ref reader)).ReadValueSafe<InfestConfig.infestModeConfig>(ref infestMode, default(ForEnums));
int chaoticSpawnCap = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref chaoticSpawnCap);
ClientRpcParams client = rpcParams.Client;
target.__rpc_exec_stage = (__RpcExecStage)2;
((InfestNetworkHandler)(object)target).RecieveConfigClientRpc(fogConfig, infestMode, chaoticSpawnCap, client);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
protected internal override string __getTypeName()
{
return "InfestNetworkHandler";
}
}
[BepInPlugin("OreoM.InfestOnly", "InfestOnly", "1.0.6")]
public class InfestOnly : BaseUnityPlugin
{
public static InfestOnly Instance { get; private set; }
internal static ManualLogSource Logger { get; private set; }
internal static Harmony? Harmony { get; set; }
internal static InfestConfig config { get; private set; }
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
Instance = this;
config = new InfestConfig(((BaseUnityPlugin)this).Config);
Patch();
NetcodePatch();
Logger.LogInfo((object)"OreoM.InfestOnly v1.0.6 has loaded!");
}
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("OreoM.InfestOnly");
}
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!");
}
private static void NetcodePatch()
{
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
Type[] array = types;
foreach (Type type in array)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array2 = methods;
foreach (MethodInfo methodInfo in array2)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
methodInfo.Invoke(null, null);
}
}
}
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "OreoM.InfestOnly";
public const string PLUGIN_NAME = "InfestOnly";
public const string PLUGIN_VERSION = "1.0.6";
}
}
namespace InfestOnly.Patches
{
[HarmonyPatch(typeof(GameNetworkManager))]
public class GameNetworkManagerPatches
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void StartPostPatch()
{
InfestNetworkHandler.Init();
}
}
[HarmonyPatch(typeof(RoundManager))]
public class RoundManagerPatches
{
private static int enemyTypeCap = -1;
private static int enemyIndex = -1;
private static SelectableLevel currMoon = null;
[HarmonyPatch("RefreshEnemiesList")]
[HarmonyPostfix]
private static void RefreshEnemiesListPrePatch(RoundManager __instance)
{
Random random = new Random(StartOfRound.Instance.randomMapSeed + 5781);
enemyTypeCap = -1;
enemyIndex = -1;
currMoon = null;
if (!__instance.currentLevel.spawnEnemiesAndScrap)
{
return;
}
switch (InfestNetworkHandler.Instance.netFogConfig.Value)
{
case InfestConfig.fogConfig.None:
((Component)__instance.indoorFog).gameObject.SetActive(false);
break;
case InfestConfig.fogConfig.Vanilla:
if (random.Next(0, 210) < 4 || random.Next(0, 1000) < 7)
{
((Component)__instance.indoorFog).gameObject.SetActive(random.Next(0, 100) < 20);
}
else
{
((Component)__instance.indoorFog).gameObject.SetActive(random.Next(0, 150) < 3);
}
break;
case InfestConfig.fogConfig.Infestation:
((Component)__instance.indoorFog).gameObject.SetActive(random.Next(0, 100) < 20);
break;
case InfestConfig.fogConfig.Always:
((Component)__instance.indoorFog).gameObject.SetActive(true);
break;
}
switch (InfestNetworkHandler.Instance.netInfestModeConfig.Value)
{
case InfestConfig.infestModeConfig.Vanilla:
{
if (random.Next(0, 100) < 25)
{
for (int i = 0; i < __instance.currentLevel.Enemies.Count; i++)
{
if (__instance.currentLevel.Enemies[i].enemyType.enemyName == "Nutcracker")
{
__instance.enemyRushIndex = i;
break;
}
}
if (__instance.enemyRushIndex != -1)
{
break;
}
for (int j = 0; j < __instance.currentLevel.Enemies.Count; j++)
{
if (__instance.currentLevel.Enemies[j].enemyType.enemyName == "Hoarding bug")
{
__instance.enemyRushIndex = j;
break;
}
}
break;
}
for (int k = 0; k < __instance.currentLevel.Enemies.Count; k++)
{
if (__instance.currentLevel.Enemies[k].enemyType.enemyName == "Hoarding bug")
{
__instance.enemyRushIndex = k;
break;
}
}
break;
}
case InfestConfig.infestModeConfig.All:
do
{
__instance.enemyRushIndex = random.Next(0, __instance.currentLevel.Enemies.Count);
}
while (__instance.currentLevel.Enemies[__instance.enemyRushIndex].enemyType.MaxCount == 1 || __instance.currentLevel.Enemies[__instance.enemyRushIndex].enemyType.enemyName == "Lasso");
if (__instance.currentLevel.Enemies[__instance.enemyRushIndex].enemyType.MaxCount < 8)
{
currMoon = __instance.currentLevel;
enemyIndex = __instance.enemyRushIndex;
enemyTypeCap = currMoon.Enemies[enemyIndex].enemyType.MaxCount;
currMoon.Enemies[enemyIndex].enemyType.MaxCount = 8;
}
break;
case InfestConfig.infestModeConfig.Chaotic:
do
{
__instance.enemyRushIndex = random.Next(0, __instance.currentLevel.Enemies.Count);
}
while (__instance.currentLevel.Enemies[__instance.enemyRushIndex].enemyType.enemyName == "Lasso");
if (__instance.currentLevel.Enemies[__instance.enemyRushIndex].enemyType.MaxCount == 1)
{
currMoon = __instance.currentLevel;
enemyIndex = __instance.enemyRushIndex;
enemyTypeCap = currMoon.Enemies[enemyIndex].enemyType.MaxCount;
currMoon.Enemies[enemyIndex].enemyType.MaxCount = InfestNetworkHandler.Instance.netChaoticSpawnCap.Value;
}
else if (__instance.currentLevel.Enemies[__instance.enemyRushIndex].enemyType.MaxCount < 8)
{
currMoon = __instance.currentLevel;
enemyIndex = __instance.enemyRushIndex;
enemyTypeCap = currMoon.Enemies[enemyIndex].enemyType.MaxCount;
currMoon.Enemies[enemyIndex].enemyType.MaxCount = 8;
}
break;
}
__instance.currentMaxOutsidePower = __instance.currentLevel.maxOutsideEnemyPowerCount;
__instance.currentMaxInsidePower = 25f;
}
[HarmonyPatch("DespawnPropsAtEndOfRound")]
[HarmonyPrefix]
private static void DespawnPropsAtEndOfRoundPrePatch(RoundManager __instance)
{
if (enemyTypeCap != -1 && enemyIndex != -1 && (Object)(object)currMoon != (Object)null)
{
InfestOnly.Logger.LogInfo((object)("Reseting extra spawns for: " + currMoon.Enemies[enemyIndex].enemyType.enemyName));
currMoon.Enemies[enemyIndex].enemyType.MaxCount = enemyTypeCap;
}
}
}
[HarmonyPatch(typeof(StartOfRound))]
public class StartOfRoundPatches
{
[HarmonyPatch("Awake")]
[HarmonyPostfix]
private static void AwakePostPatch()
{
InfestNetworkHandler.Create();
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
namespace OreoM.InfestOnly.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
