using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using ArcadiaMoonPlugin.NetcodePatcher;
using BepInEx;
using BepInEx.Configuration;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Rendering;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ArcadiaMoonPlugin")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A plugin for the LC Arcadia Moon mod")]
[assembly: AssemblyFileVersion("1.4.0.0")]
[assembly: AssemblyInformationalVersion("1.4.0+8faa2f5e59c480f6c5c80095c065afdd200b746b")]
[assembly: AssemblyProduct("ArcadiaMoonPlugin")]
[assembly: AssemblyTitle("ArcadiaMoonPlugin")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.4.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
static <Module>()
{
}
}
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ArcadiaMoonPlugin
{
[BepInPlugin("ArcadiaMoonPlugin", "ArcadiaMoonPlugin", "1.4.0")]
public class ArcadiaMoonPlugin : BaseUnityPlugin
{
private Harmony harmony;
public static ArcadiaMoonPlugin instance;
public static ConfigEntry<bool> ForceSpawnFlowerman { get; private set; }
public static ConfigEntry<bool> ForceSpawnBaboon { get; private set; }
public static ConfigEntry<bool> ForceSpawnRadMech { get; private set; }
private void Awake()
{
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Expected O, but got Unknown
instance = this;
((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin ArcadiaMoonPlugin is loaded!");
ForceSpawnFlowerman = ((BaseUnityPlugin)this).Config.Bind<bool>("Spawning", "ForceSpawnFlowerman", true, "Enable custom deterministic spawner for Bracken");
ForceSpawnBaboon = ((BaseUnityPlugin)this).Config.Bind<bool>("Spawning", "ForceSpawnBaboon", true, "Enable custom deterministic spawner for Baboon hawk");
ForceSpawnRadMech = ((BaseUnityPlugin)this).Config.Bind<bool>("Spawning", "ForceSpawnRadMech", true, "Enable custom deterministic spawner for Old Bird");
harmony = new Harmony("ArcadiaMoonPlugin");
harmony.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin ArcadiaMoonPlugin patched PlayerControllerB!");
}
}
public class TimeAnimSyncronizer : MonoBehaviour
{
private Animator timeSyncAnimator;
private void Start()
{
timeSyncAnimator = ((Component)this).GetComponent<Animator>();
if ((Object)(object)timeSyncAnimator == (Object)null)
{
Debug.LogError((object)"There is no Animator component attached to this object!");
}
}
private void FixedUpdate()
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)timeSyncAnimator != (Object)null && TimeOfDay.Instance.timeHasStarted)
{
timeSyncAnimator.SetFloat("timeOfDay", Mathf.Clamp(TimeOfDay.Instance.normalizedTimeOfDay, 0f, 0.99f));
if ((int)TimeOfDay.Instance.currentLevelWeather == 0)
{
timeSyncAnimator.SetBool("dusty", true);
}
}
}
}
internal class HeatwaveZoneInteract : MonoBehaviour
{
[SerializeField]
private float timeInHeatZoneMax = 10f;
[SerializeField]
private Volume exhaustionFilter;
public bool CheckConditionsForHeatingPause(PlayerControllerB playerController)
{
if (!playerController.inSpecialInteractAnimation && !Object.op_Implicit((Object)(object)playerController.inAnimationWithEnemy) && !playerController.isClimbingLadder)
{
return (Object)(object)playerController.physicsParent != (Object)null;
}
return true;
}
public bool CheckConditionsForHeatingStop(PlayerControllerB playerController)
{
if (!playerController.beamUpParticle.isPlaying && !playerController.isInElevator)
{
return playerController.isInHangarShipRoom;
}
return true;
}
private void OnTriggerEnter(Collider other)
{
if (((Component)other).CompareTag("Player"))
{
PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
if (!((Object)(object)component != (Object)(object)GameNetworkManager.Instance.localPlayerController))
{
PlayerHeatManager.SetEffectsVolume(exhaustionFilter);
}
}
}
private void OnTriggerStay(Collider other)
{
if (!((Component)other).CompareTag("Player"))
{
return;
}
PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
if ((Object)(object)component != (Object)(object)GameNetworkManager.Instance.localPlayerController)
{
return;
}
if (component.isPlayerDead)
{
PlayerHeatManager.heatSeverityMultiplier = 1f;
PlayerHeatManager.isInHeatZone = false;
PlayerHeatManager.SetHeatSeverity(0f - PlayerHeatManager.heatSeverity);
return;
}
if (CheckConditionsForHeatingStop(component))
{
PlayerHeatManager.heatSeverityMultiplier = 1f;
PlayerHeatManager.isInHeatZone = false;
return;
}
if (CheckConditionsForHeatingPause(component))
{
PlayerHeatManager.heatSeverityMultiplier = 0.33f;
}
else
{
PlayerHeatManager.heatSeverityMultiplier = 1f;
}
if (PlayerHeatManager.isInHeatZone)
{
PlayerHeatManager.SetHeatSeverity(Time.deltaTime / timeInHeatZoneMax);
}
else
{
PlayerHeatManager.isInHeatZone = true;
}
}
private void OnTriggerExit(Collider other)
{
if (((Component)other).CompareTag("Player"))
{
PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
if (!((Object)(object)component != (Object)(object)GameNetworkManager.Instance.localPlayerController))
{
PlayerHeatManager.heatSeverityMultiplier = 1f;
PlayerHeatManager.isInHeatZone = false;
}
}
}
private void OnDestroy()
{
PlayerHeatManager.heatSeverityMultiplier = 1f;
PlayerHeatManager.isInHeatZone = false;
PlayerHeatManager.SetEffectsVolume(null);
}
}
internal class PlayerHeatManager : MonoBehaviour
{
public static bool isInHeatZone = false;
public static float heatSeverityMultiplier = 1f;
public static float heatSeverity = 0f;
private static Volume heatEffectVolume;
public static void SetEffectsVolume(Volume volume)
{
if ((Object)(object)volume != (Object)null)
{
heatEffectVolume = volume;
}
}
internal static void SetHeatSeverity(float heatSeverityDelta)
{
heatSeverity = Mathf.Clamp01(heatSeverity + heatSeverityDelta * heatSeverityMultiplier);
if ((Object)(object)heatEffectVolume != (Object)null)
{
heatEffectVolume.weight = heatSeverity;
}
}
}
public class EnemySpawner : MonoBehaviour
{
[SerializeField]
private string enemyName = "RadMech";
[SerializeField]
private float timer = 0.5f;
private EnemyType enemyType;
private GameObject nestPrefab;
private List<GameObject> spawnedNests = new List<GameObject>();
private Random random = new Random(StartOfRound.Instance.randomMapSeed + 42);
private void LoadResources(string enemyName)
{
IEnumerable<EnemyType> source = Resources.FindObjectsOfTypeAll<EnemyType>().Distinct();
enemyType = source.FirstOrDefault((Func<EnemyType, bool>)((EnemyType e) => e.enemyName == enemyName));
if ((Object)(object)enemyType != (Object)null)
{
nestPrefab = enemyType.nestSpawnPrefab;
Debug.Log((object)(enemyType.enemyName + " and its prefab loaded successfully!"));
}
else
{
Debug.LogError((object)"Failed to load EnemyType!");
}
}
private void Start()
{
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Expected O, but got Unknown
//IL_0081: 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_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
if (!GameNetworkManager.Instance.isHostingGame)
{
return;
}
LoadResources(enemyName);
if (!IsSpawningEnabled())
{
Debug.Log((object)("Forced spawning for " + enemyName + " is disabled in the config."));
((Behaviour)this).enabled = false;
return;
}
foreach (Transform item in ((Component)this).transform)
{
Transform val = item;
if ((Object)(object)nestPrefab != (Object)null)
{
Debug.Log((object)"Started nest prefab spawning routine!");
Vector3 randomNavMeshPositionInBoxPredictable = RoundManager.Instance.GetRandomNavMeshPositionInBoxPredictable(val.position, 10f, default(NavMeshHit), random, RoundManager.Instance.GetLayermaskForEnemySizeLimit(enemyType));
randomNavMeshPositionInBoxPredictable = RoundManager.Instance.PositionEdgeCheck(randomNavMeshPositionInBoxPredictable, enemyType.nestSpawnPrefabWidth);
GameObject val2 = Object.Instantiate<GameObject>(nestPrefab, randomNavMeshPositionInBoxPredictable, Quaternion.identity);
val2.transform.Rotate(Vector3.up, (float)random.Next(-180, 180), (Space)0);
spawnedNests.Add(val2);
if (Object.op_Implicit((Object)(object)val2.GetComponentInChildren<NetworkObject>()))
{
val2.GetComponentInChildren<NetworkObject>().Spawn(true);
Debug.Log((object)("Spawned an " + enemyName + " nest prefab!"));
}
else
{
Debug.LogError((object)("Nest prefab of " + enemyName + " does not have a NetworkObject component. Desync possible!"));
}
}
}
}
private void Update()
{
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Expected O, but got Unknown
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: 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_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
if (!(TimeOfDay.Instance.normalizedTimeOfDay > timer) || !TimeOfDay.Instance.timeHasStarted || !GameNetworkManager.Instance.isHostingGame)
{
return;
}
if ((Object)(object)nestPrefab != (Object)null)
{
foreach (GameObject spawnedNest in spawnedNests)
{
Vector3 position = spawnedNest.transform.position;
Quaternion rotation = spawnedNest.transform.rotation;
float y = ((Quaternion)(ref rotation)).eulerAngles.y;
Object.Destroy((Object)(object)spawnedNest);
SpawnEnemyAtPosition(position, y);
Debug.Log((object)("Spawned enemy " + enemyName + " in place of a nest prefab!"));
}
spawnedNests.Clear();
Debug.Log((object)("Destroyed all spawned enemy nest prefabs of " + enemyType.enemyName + "!"));
}
else
{
foreach (Transform item in ((Component)this).transform)
{
Transform val = item;
SpawnEnemyAtPosition(val.position);
Debug.Log((object)"Force spawned an enemy!");
}
}
((Behaviour)this).enabled = false;
}
private void SpawnEnemyAtPosition(Vector3 position, float yRot = 0f)
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
Debug.Log((object)("Current enemy type for force spawn is " + enemyType.enemyName));
if ((Object)(object)enemyType.enemyPrefab == (Object)null)
{
Debug.LogError((object)(enemyType.enemyName + " does not have a valid enemy prefab to spawn."));
}
else
{
RoundManager.Instance.SpawnEnemyGameObject(position, yRot, -1, enemyType);
}
}
private bool IsSpawningEnabled()
{
return enemyName.ToLower() switch
{
"flowerman" => ArcadiaMoonPlugin.ForceSpawnFlowerman.Value,
"baboon hawk" => ArcadiaMoonPlugin.ForceSpawnBaboon.Value,
"radmech" => ArcadiaMoonPlugin.ForceSpawnRadMech.Value,
_ => true,
};
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "ArcadiaMoonPlugin";
public const string PLUGIN_NAME = "ArcadiaMoonPlugin";
public const string PLUGIN_VERSION = "1.4.0";
}
}
namespace ArcadiaMoonPlugin.Patches
{
[HarmonyPatch]
internal class PlayerControllerBHeatStrokePatch
{
private static float prevSprintMeter;
private static float severityInfluenceMultiplier = 1.25f;
private static float timeToCool = 17f;
[HarmonyPatch(typeof(PlayerControllerB), "Update")]
[HarmonyPrefix]
[HarmonyPriority(600)]
private static void HeatStrokePatchPrefix(PlayerControllerB __instance)
{
if (((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerControlled)
{
prevSprintMeter = __instance.sprintMeter;
}
}
[HarmonyPatch(typeof(PlayerControllerB), "LateUpdate")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void HeatStrokePatchLatePostfix(PlayerControllerB __instance)
{
if (!((NetworkBehaviour)__instance).IsOwner || !__instance.isPlayerControlled)
{
return;
}
if (__instance.isInsideFactory)
{
PlayerHeatManager.heatSeverityMultiplier = 1f;
PlayerHeatManager.isInHeatZone = false;
}
if (!PlayerHeatManager.isInHeatZone)
{
PlayerHeatManager.SetHeatSeverity((0f - Time.deltaTime) / timeToCool);
}
float heatSeverity = PlayerHeatManager.heatSeverity;
if (heatSeverity > 0f)
{
float num = __instance.sprintMeter - prevSprintMeter;
if ((double)num < 0.0)
{
__instance.sprintMeter = Mathf.Max(prevSprintMeter + num * (1f + heatSeverity * severityInfluenceMultiplier), 0f);
}
else if ((double)num > 0.0)
{
__instance.sprintMeter = Mathf.Min(prevSprintMeter + num / (1f + heatSeverity * severityInfluenceMultiplier), 1f);
}
}
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
namespace ArcadiaMoonPlugin.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
