using System;
using System.Collections;
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 System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using HazardSpam.Config;
using HazardSpam.Level;
using HazardSpam.Level.Biomes;
using HazardSpam.Level.Caldera;
using HazardSpam.Level.Spawner;
using HazardSpam.Networking;
using HazardSpam.Patches;
using HazardSpam.Spawning;
using HazardSpam.StaticData;
using HazardSpam.Types;
using HazardSpam.Util;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.tehUsual.HazardSpam")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0+15af2a5e85aee97ecabc6d4dbc0fc431c567a6a2")]
[assembly: AssemblyProduct("com.github.tehUsual.HazardSpam")]
[assembly: AssemblyTitle("HazardSpam")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.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 BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace HazardSpam
{
[BepInPlugin("com.github.tehUsual.HazardSpam", "HazardSpam", "1.3.0")]
public class Plugin : BaseUnityPlugin
{
[CompilerGenerated]
private sealed class <DelayedInitNetwork>d__10 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Plugin <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <DelayedInitNetwork>d__10(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Expected O, but got Unknown
int num = <>1__state;
Plugin plugin = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
plugin.InitNetwork();
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private const int SpawnerNetworkViewID = 9989;
private bool _isGameStarted;
private readonly TeleportHandler _teleportHandler = new TeleportHandler();
public const string Id = "com.github.tehUsual.HazardSpam";
internal static ManualLogSource Log { get; private set; }
public static string Name => "HazardSpam";
public static string Version => "1.3.0";
private void Awake()
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
ConfigHandler.Init(((BaseUnityPlugin)this).Config);
Harmony val = new Harmony("com.github.tehUsual.HazardSpam");
val.PatchAll(typeof(LevelChangePatches));
val.PatchAll(typeof(EruptionSpawnerPatches));
SceneManager.sceneLoaded += OnSceneLoaded;
LevelState.OnBiomeLoading += OnBiomeLoading;
LevelState.OnBiomeComplete += OnBiomeComplete;
}
private void OnDestroy()
{
SceneManager.sceneLoaded -= OnSceneLoaded;
}
private void InitNetwork()
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Expected O, but got Unknown
if ((Object)(object)GameObject.Find("HS_SpawnerNetwork") != (Object)null)
{
Log.LogDebug((object)"HS_SpawnerNetwork already exists.");
return;
}
GameObject val = new GameObject("HS_SpawnerNetwork");
Object.DontDestroyOnLoad((Object)(object)val);
val.AddComponent<PhotonView>();
PhotonView component = val.GetComponent<PhotonView>();
component.ViewID = 9989;
val.AddComponent<SpawnerNetwork>();
}
[IteratorStateMachine(typeof(<DelayedInitNetwork>d__10))]
private IEnumerator DelayedInitNetwork()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <DelayedInitNetwork>d__10(0)
{
<>4__this = this
};
}
private void CleanupNetwork()
{
GameObject val = GameObject.Find("HS_SpawnerNetwork");
if ((Object)(object)val != (Object)null)
{
Object.Destroy((Object)(object)val);
}
}
private void Update()
{
if (PhotonNetwork.IsMasterClient && _isGameStarted && ConfigHandler.Debug)
{
if (Input.GetKeyDown((KeyCode)55))
{
Player.localPlayer.character.refs.balloons.TieNewBalloon(0);
}
if (Input.GetKeyDown((KeyCode)56) && Player.localPlayer.character.refs.balloons.tiedBalloons.Count > 0)
{
TiedBalloon val = Player.localPlayer.character.refs.balloons.tiedBalloons[0];
Player.localPlayer.character.refs.balloons.RemoveBalloon(val);
}
if (Input.GetKeyDown((KeyCode)257))
{
_teleportHandler.WarpToShoreCampfire();
}
if (Input.GetKeyDown((KeyCode)258))
{
_teleportHandler.WarpToTropicsCampfire();
}
if (Input.GetKeyDown((KeyCode)259))
{
_teleportHandler.WarpToAlpineMesaCampfire();
}
if (Input.GetKeyDown((KeyCode)260))
{
_teleportHandler.WarpToCalderaCampfire();
}
}
}
private void OnBiomeLoading(BiomeType biomeType)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: 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_0042: Expected I4, but got Unknown
if (PhotonNetwork.IsMasterClient)
{
Log.LogInfo((object)$"[Main] Biome loading: {biomeType}");
switch (biomeType - 1)
{
case 0:
LevelManager.ClearBiome((BiomeType)0);
break;
case 1:
case 5:
LevelManager.ClearBiome((BiomeType)1);
break;
case 2:
LevelManager.ClearBiome((BiomeType)2);
LevelManager.ClearBiome((BiomeType)6);
break;
case 3:
case 4:
break;
}
}
}
private void OnBiomeComplete(BiomeType biomeType)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Expected I4, but got Unknown
if ((int)biomeType == 0)
{
LevelManager.Init(LevelState.GetBiomeTypes());
LevelManager.InitCalderaSpawns();
}
if (PhotonNetwork.IsMasterClient)
{
Log.LogInfo((object)$"Biome complete: {biomeType}");
switch ((int)biomeType)
{
case 0:
_teleportHandler.Init(LevelState.GetBiomeTypes());
LevelManager.InitBiome((BiomeType)0);
break;
case 1:
LevelManager.InitBiome((BiomeType)1);
break;
case 2:
LevelManager.InitBiome((BiomeType)2);
break;
case 6:
LevelManager.InitBiome((BiomeType)6);
break;
case 3:
LevelManager.SpawnCalderaSpawns();
break;
case 4:
case 5:
break;
}
}
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
Log.LogInfo((object)("Scene loaded: " + ((Scene)(ref scene)).name));
Match match = new Regex("^Level_(\\d+)$").Match(((Scene)(ref scene)).name);
if ((int)mode == 0 && match.Success && int.TryParse(match.Groups[1].Value, out var _) && PhotonNetwork.IsConnected && PhotonNetwork.InRoom)
{
Log.LogInfo((object)"Game Start detected");
_isGameStarted = true;
}
if (((Scene)(ref scene)).name == "Airport" || ((Scene)(ref scene)).name.ToLower().StartsWith("airp"))
{
StatusMessageHandler.DeInit();
CleanupNetwork();
((MonoBehaviour)this).StartCoroutine(DelayedInitNetwork());
LevelManager.Reset();
}
}
}
public class TeleportHandler
{
private Transform? _shoreCampfire;
private Transform? _tropicsCampfire;
private Transform? _alpineMesaCampfire;
private Transform? _calderaCampfire;
public void Init(List<BiomeType> currentBiomeTypes)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected I4, but got Unknown
foreach (BiomeType currentBiomeType in currentBiomeTypes)
{
switch ((int)currentBiomeType)
{
case 0:
{
GameObject val2 = GameObject.Find("Map/Biome_1/Beach/Beach_Campfire/Campfire");
if ((Object)(object)val2 != (Object)null)
{
_shoreCampfire = val2.transform;
Plugin.Log.LogInfo((object)"Found Shore Campfire");
}
else
{
Plugin.Log.LogDebug((object)"Could not find Shore Campfire.");
}
break;
}
case 1:
{
GameObject val5 = GameObject.Find("Map/Biome_2/Jungle/Jungle_Campfire/Campfire");
if ((Object)(object)val5 != (Object)null)
{
_tropicsCampfire = val5.transform;
Plugin.Log.LogInfo((object)"Found Tropics Campfire");
}
else
{
Plugin.Log.LogDebug((object)"Could not find Tropics Campfire.");
}
break;
}
case 2:
{
GameObject val3 = GameObject.Find("Map/Biome_3/Snow/Snow_Campfire/Campfire");
if ((Object)(object)val3 != (Object)null)
{
_alpineMesaCampfire = val3.transform;
Plugin.Log.LogInfo((object)"Found Alpine Campfire");
}
else
{
Plugin.Log.LogDebug((object)"Could not find Alpine Campfire.");
}
break;
}
case 6:
{
GameObject val4 = GameObject.Find("Map/Biome_3/Desert/Desert_Campfire/Snow_Campfire/Campfire");
if ((Object)(object)val4 != (Object)null)
{
_alpineMesaCampfire = val4.transform;
Plugin.Log.LogInfo((object)"Found Mesa Campfire");
}
else
{
Plugin.Log.LogDebug((object)"Could not find Mesa Campfire.");
}
break;
}
case 3:
{
GameObject val = GameObject.Find("Map/Biome_4/Volcano/Volcano_Campfire/Campfire");
if ((Object)(object)val != (Object)null)
{
_calderaCampfire = val.transform;
Plugin.Log.LogInfo((object)"Found Volcano Campfire");
}
else
{
Plugin.Log.LogDebug((object)"Could not find Volcano Campfire.");
}
break;
}
}
}
}
public void WarpToShoreCampfire()
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_shoreCampfire == (Object)null)
{
return;
}
foreach (Character allPlayerCharacter in PlayerHandler.GetAllPlayerCharacters())
{
((MonoBehaviourPun)allPlayerCharacter).photonView.RPC("WarpPlayerRPC", (RpcTarget)0, new object[2] { _shoreCampfire.position, false });
}
}
public void WarpToTropicsCampfire()
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_tropicsCampfire == (Object)null)
{
return;
}
foreach (Character allPlayerCharacter in PlayerHandler.GetAllPlayerCharacters())
{
((MonoBehaviourPun)allPlayerCharacter).photonView.RPC("WarpPlayerRPC", (RpcTarget)0, new object[2] { _tropicsCampfire.position, false });
}
}
public void WarpToAlpineMesaCampfire()
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_alpineMesaCampfire == (Object)null)
{
return;
}
foreach (Character allPlayerCharacter in PlayerHandler.GetAllPlayerCharacters())
{
((MonoBehaviourPun)allPlayerCharacter).photonView.RPC("WarpPlayerRPC", (RpcTarget)0, new object[2] { _alpineMesaCampfire.position, false });
}
}
public void WarpToCalderaCampfire()
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_calderaCampfire == (Object)null)
{
return;
}
foreach (Character allPlayerCharacter in PlayerHandler.GetAllPlayerCharacters())
{
((MonoBehaviourPun)allPlayerCharacter).photonView.RPC("WarpPlayerRPC", (RpcTarget)0, new object[2] { _calderaCampfire.position, false });
}
}
}
}
namespace HazardSpam.Util
{
public static class StatusMessageHandler
{
private static PlayerConnectionLog? _playerConnectionLog;
public static void Init(PlayerConnectionLog playerConnectionLog)
{
_playerConnectionLog = playerConnectionLog;
}
public static void DeInit()
{
_playerConnectionLog = null;
}
public static void AddMessage(string message)
{
if ((Object)(object)_playerConnectionLog != (Object)null)
{
_playerConnectionLog.AddMessage(message);
}
}
}
}
namespace HazardSpam.Types
{
public enum BiomeArea
{
Plateau,
Wall,
WallLeft,
WallRight
}
public readonly struct BiomeSpawnDefinition
{
public BiomeType BiomeType { get; }
public BiomeArea Area { get; }
public string Path { get; }
public string SearchName { get; }
public SpawnType SpawnType { get; }
public BiomeSpawnDefinition(BiomeType biomeType, string path, BiomeArea area, string searchName, SpawnType spawnType)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
BiomeType = biomeType;
Area = area;
Path = path;
SearchName = searchName;
SpawnType = spawnType;
}
}
public enum BiomeShoreVariants
{
Default,
SnakeBeach,
RedBeach,
BlueBeach,
JellyHell,
BlackSand
}
public enum BiomeTropicVariants
{
Default,
Lava,
Pillars,
Thorny,
Bombs,
Ivy,
SkyJungle
}
public enum BiomeAlpineVariants
{
Default,
Lava,
Spiky,
GeyserHell
}
public class SpawnInfo
{
public Vector3 Position;
public Quaternion Rotation;
public float ScaleGain;
public SpawnInfo(Vector3 position, Quaternion rotation, float scaleGain = 0f)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
Position = position;
Rotation = rotation;
ScaleGain = scaleGain;
base..ctor();
}
}
}
namespace HazardSpam.StaticData
{
public static class SpawnerDefinitions
{
public static readonly List<BiomeSpawnDefinition> All = new List<BiomeSpawnDefinition>
{
new BiomeSpawnDefinition((BiomeType)0, "PlateauProps", BiomeArea.Plateau, "Jellies", SpawnType.Jellies),
new BiomeSpawnDefinition((BiomeType)0, "WallProps", BiomeArea.Wall, "Jellies", SpawnType.Jellies),
new BiomeSpawnDefinition((BiomeType)1, "Props_Wall", BiomeArea.Wall, "ExploShrooms", SpawnType.ExploShrooms),
new BiomeSpawnDefinition((BiomeType)1, "Props_Wall", BiomeArea.Wall, "PoisonShrooms", SpawnType.PoisonShrooms),
new BiomeSpawnDefinition((BiomeType)2, "Rocks/IceRockSpawn_L", BiomeArea.WallLeft, "Geysers", SpawnType.Geysers),
new BiomeSpawnDefinition((BiomeType)2, "Rocks/IceRockSpawn_L", BiomeArea.WallLeft, "FlashPlant", SpawnType.FlashPlant),
new BiomeSpawnDefinition((BiomeType)2, "Rocks/IceRockSpawn_R", BiomeArea.WallRight, "Geysers", SpawnType.Geysers),
new BiomeSpawnDefinition((BiomeType)2, "Rocks/IceRockSpawn_R", BiomeArea.WallRight, "FlashPlant", SpawnType.FlashPlant),
new BiomeSpawnDefinition((BiomeType)2, "", BiomeArea.WallLeft, "LavaRiver", SpawnType.LavaRiver),
new BiomeSpawnDefinition((BiomeType)2, "", BiomeArea.WallRight, "LavaRiver (1)", SpawnType.LavaRiver),
new BiomeSpawnDefinition((BiomeType)6, "Platteau/Props", BiomeArea.Plateau, "Cactus_Balls (1)", SpawnType.CactusBalls),
new BiomeSpawnDefinition((BiomeType)6, "Platteau/Props", BiomeArea.Plateau, "Tumblers", SpawnType.Tumblers),
new BiomeSpawnDefinition((BiomeType)6, "Wall/Props", BiomeArea.Wall, "Cactus_Balls", SpawnType.CactusBalls),
new BiomeSpawnDefinition((BiomeType)6, "Wall/Props", BiomeArea.Wall, "Dynamite", SpawnType.Dynamite),
new BiomeSpawnDefinition((BiomeType)6, "Wall/Props", BiomeArea.Wall, "Dynamite_Outside", SpawnType.DynamiteOutside),
new BiomeSpawnDefinition((BiomeType)6, "Wall/Props", BiomeArea.Wall, "Scorpions", SpawnType.Scorpions)
};
public static readonly BiomeSpawnDefinition AlpineGeyserPlateau = new BiomeSpawnDefinition((BiomeType)2, "PlateauProps", BiomeArea.Plateau, "Geysers", SpawnType.Geysers);
}
}
namespace HazardSpam.Spawning
{
public class SpawnedPropHS : MonoBehaviour
{
}
public enum SpawnType
{
Jellies,
ExploShrooms,
PoisonShrooms,
LavaRiver,
Geysers,
FlashPlant,
CactusBalls,
Tumblers,
Dynamite,
DynamiteOutside,
Scorpions
}
}
namespace HazardSpam.Patches
{
[HarmonyPatch]
public static class EruptionSpawnerPatches
{
[HarmonyPrefix]
[HarmonyPatch(typeof(EruptionSpawner), "Update")]
public static bool ReplaceUpdate(EruptionSpawner __instance)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: 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_00be: Unknown result type (might be due to invalid IL or missing references)
if (!PhotonNetwork.IsMasterClient)
{
return false;
}
float z = __instance.min.position.z;
float z2 = __instance.max.position.z;
if (!HelperFunctions.AnyPlayerInZRange(z, z2))
{
return false;
}
__instance.counter -= Time.deltaTime;
if (__instance.counter < 0f)
{
__instance.counter = Random.Range(ConfigHandler.CalderaEruptSpawnMinTime, ConfigHandler.CalderaEruptSpawnMaxTime);
Vector3 position = ((Component)__instance).transform.position;
position.x += Random.Range(-155f, 155f);
position.z += Random.Range(-140f, 140f);
__instance.photonView.RPC("RPCA_SpawnEruption", (RpcTarget)0, new object[1] { position });
}
return false;
}
}
[HarmonyPatch]
public static class LevelChangePatches
{
public static bool PatchSuccessfull { get; private set; }
public static AirportCheckInKiosk AirportCheckInKioskInstance { get; private set; }
[HarmonyPatch(typeof(MapHandler), "Awake")]
[HarmonyPostfix]
public static void PostfixAwake(MapHandler __instance)
{
LevelState.Initialize(__instance);
PatchSuccessfull = true;
Plugin.Log.LogInfo((object)"[MapHandler.Awake] MapHandler fetched!");
}
[HarmonyPatch(typeof(AirportCheckInKiosk), "BeginIslandLoadRPC")]
[HarmonyPrefix]
public static void PrefixBeginIslandLoadRPC(AirportCheckInKiosk __instance)
{
if (PhotonNetwork.IsMasterClient)
{
Plugin.Log.LogInfo((object)"[AirportCheckInKiosk.BeginIslandLoadRPC] LOADING SHORE");
AirportCheckInKioskInstance = __instance;
LevelState.SetBiomeComplete((BiomeType)0);
}
}
[HarmonyPatch(typeof(RunManager), "StartRun")]
[HarmonyPostfix]
public static void PostfixStart(RunManager __instance)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
if (!(((Scene)(ref activeScene)).name == "Airport"))
{
activeScene = SceneManager.GetActiveScene();
if (((Scene)(ref activeScene)).name.StartsWith("Level_"))
{
Plugin.Log.LogInfo((object)"[RunManager.Start] LOADED SHORE");
LevelState.SetBiomeComplete((BiomeType)0);
}
else
{
SceneManager.sceneLoaded += OnLevelSceneLoaded;
}
}
}
private static void OnLevelSceneLoaded(Scene scene, LoadSceneMode mode)
{
if (((Scene)(ref scene)).name.StartsWith("Level_"))
{
Plugin.Log.LogInfo((object)"[RunManager.Start] LOADED SHORE");
LevelState.SetBiomeComplete((BiomeType)0);
SceneManager.sceneLoaded -= OnLevelSceneLoaded;
}
}
[HarmonyPatch(typeof(MapHandler), "GoToSegment")]
[HarmonyPostfix]
public static void PostfixGoToSegment(Segment s)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
if (PhotonNetwork.IsMasterClient)
{
Plugin.Log.LogInfo((object)$"[MapHandler.GoToSegment] LOADING BIOME: {s}");
LevelState.SetBiomeLoading();
}
}
[HarmonyPatch(typeof(MountainProgressHandler), "SetSegmentComplete")]
[HarmonyPostfix]
public static void PostfixSetSegmentComplete(int segment)
{
if (PhotonNetwork.IsMasterClient)
{
Plugin.Log.LogInfo((object)$"[MountainProgressHandler.SetSegmentComplete] LOADED BIOME: {segment}");
LevelState.SetBiomeComplete();
}
}
}
[HarmonyPatch]
public static class PlayerConnectionLogPatches
{
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerConnectionLog), "Awake")]
public static void PostfixAwake(PlayerConnectionLog __instance)
{
StatusMessageHandler.Init(__instance);
}
}
}
namespace HazardSpam.Networking
{
public class SpawnerNetwork : MonoBehaviourPun
{
[CompilerGenerated]
private sealed class <ClearPropsInWorld>d__12 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public SpawnerData spawnerData;
private int <removed>5__2;
private int <i>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ClearPropsInWorld>d__12(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
goto IL_00af;
}
<>1__state = -1;
<removed>5__2 = 0;
<i>5__3 = ((Component)spawnerData.PropSpawner).transform.childCount - 1;
goto IL_00bf;
IL_00af:
<i>5__3--;
goto IL_00bf;
IL_00bf:
if (<i>5__3 >= 0)
{
GameObject gameObject = ((Component)((Component)spawnerData.PropSpawner).transform.GetChild(<i>5__3)).gameObject;
if ((Object)(object)gameObject.GetComponent<SpawnedPropHS>() != (Object)null)
{
Object.Destroy((Object)(object)gameObject);
<removed>5__2++;
}
if (<i>5__3 % 50 == 0 && <i>5__3 != 0)
{
<>2__current = null;
<>1__state = 1;
return true;
}
goto IL_00af;
}
spawnerData.Clear();
Plugin.Log.LogInfo((object)$"Cleared {<removed>5__2} '{spawnerData.SpawnType}' from {spawnerData.Area}");
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <SpawnPropsInWorld>d__9 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public SpawnerData spawnerData;
public Vector3[] positions;
public Quaternion[] rotations;
public string area;
private int <spawns>5__2;
private int <i>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SpawnPropsInWorld>d__9(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
goto IL_00f0;
}
<>1__state = -1;
<spawns>5__2 = 0;
<i>5__3 = 0;
goto IL_0100;
IL_00f0:
<i>5__3++;
goto IL_0100;
IL_0100:
if (<i>5__3 < positions.Length)
{
GameObject val = Object.Instantiate<GameObject>(spawnerData.Prefab, positions[<i>5__3], rotations[<i>5__3], ((Component)spawnerData.PropSpawner).transform);
if ((Object)(object)val != (Object)null)
{
val.AddComponent<SpawnedPropHS>();
spawnerData.AddSpawnInfo(positions[<i>5__3], rotations[<i>5__3]);
<spawns>5__2++;
}
if (<i>5__3 % 50 == 0 && <i>5__3 != 0)
{
<>2__current = null;
<>1__state = 1;
return true;
}
goto IL_00f0;
}
Plugin.Log.LogInfo((object)$"Spawned {<spawns>5__2}/{positions.Length} '{((Object)spawnerData.Prefab).name}' in {area}");
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <SpawnPropsInWorldCaldera>d__8 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Vector3[] positions;
public Quaternion[] rotations;
private Transform <spawnerTrans>5__2;
private GameObject <prefab>5__3;
private int <spawns>5__4;
private int <i>5__5;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SpawnPropsInWorldCaldera>d__8(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<spawnerTrans>5__2 = null;
<prefab>5__3 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0082: 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)
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -1;
goto IL_00ee;
}
<>1__state = -1;
<spawnerTrans>5__2 = CalderaHandler.GetSpawner;
<prefab>5__3 = CalderaHandler.GetPrefab;
if ((Object)(object)<spawnerTrans>5__2 == (Object)null || (Object)(object)<prefab>5__3 == (Object)null)
{
Plugin.Log.LogError((object)"Could not find Caldera spawner or prefab");
return false;
}
<spawns>5__4 = 0;
<i>5__5 = 0;
goto IL_00fe;
IL_00ee:
<i>5__5++;
goto IL_00fe;
IL_00fe:
if (<i>5__5 < positions.Length)
{
GameObject val = Object.Instantiate<GameObject>(<prefab>5__3, positions[<i>5__5], rotations[<i>5__5], <spawnerTrans>5__2);
if ((Object)(object)val != (Object)null)
{
val.AddComponent<SpawnedPropHS>();
<spawns>5__4++;
}
if (<i>5__5 % 50 == 0 && <i>5__5 != 0)
{
<>2__current = null;
<>1__state = 1;
return true;
}
goto IL_00ee;
}
Plugin.Log.LogInfo((object)$"Spawned {<spawns>5__4}/{positions.Length} '{((Object)<prefab>5__3).name}' in Caldera/Plateau");
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public static SpawnerNetwork Instance { get; private set; }
private void Awake()
{
if ((Object)(object)Instance != (Object)null)
{
Object.Destroy((Object)(object)((Component)this).gameObject);
return;
}
Instance = this;
Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
}
public void SpawnPropsNetwork(SpawnerData spawnData, Vector3[] positions, Quaternion[] rotations, float[] scaleGains)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
if (positions.Length != 0)
{
ManualLogSource log = Plugin.Log;
object[] obj = new object[4] { positions.Length, null, null, null };
BiomeType biomeType = spawnData.BiomeType;
obj[1] = ((object)(BiomeType)(ref biomeType)).ToString();
obj[2] = spawnData.Area.ToString();
obj[3] = spawnData.SpawnType.ToString();
log.LogInfo((object)string.Format("[Network] Sending 'RPC_SpawnProps' for {0} at {1}/{2}/{3}", obj));
((MonoBehaviourPun)this).photonView.RPC("RPC_SpawnProps", (RpcTarget)0, new object[5] { spawnData.BiomeType, spawnData.Area, spawnData.SpawnType, positions, rotations });
}
}
public void SpawnPropsNetworkCaldera(Vector3[] positions, Quaternion[] rotations, float[] scaleGains)
{
if (positions.Length != 0)
{
Plugin.Log.LogInfo((object)string.Format("[Network] Sending 'RPC_SpawnProps' for {0} at {1}/Plateau/SlipperyJellyfish", positions.Length, "Volcano"));
((MonoBehaviourPun)this).photonView.RPC("RPC_SpawnProps", (RpcTarget)0, new object[5]
{
(object)(BiomeType)3,
BiomeArea.Plateau,
SpawnType.Jellies,
positions,
rotations
});
}
}
[PunRPC]
public void RPC_SpawnProps(BiomeType biomeType, BiomeArea area, SpawnType spawnType, Vector3[] positions, Quaternion[] rotations)
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Invalid comparison between Unknown and I4
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
Plugin.Log.LogInfo((object)$"[Network] Received 'RPC_SpawnProps' for {positions.Length} at {((object)(BiomeType)(ref biomeType)).ToString()}/{area.ToString()}/{spawnType.ToString()}");
if ((int)biomeType == 3)
{
((MonoBehaviour)this).StartCoroutine(SpawnPropsInWorldCaldera(positions, rotations));
return;
}
BiomeInfo biomeInfo = LevelManager.GetBiomeInfo(biomeType);
if (biomeInfo == null)
{
return;
}
foreach (SpawnerData spawner in biomeInfo.Spawners)
{
if (spawner.Area == area && spawner.SpawnType == spawnType)
{
BiomeType biomeType2 = spawner.BiomeType;
string area2 = ((object)(BiomeType)(ref biomeType2)).ToString() + "/" + spawner.Area;
((MonoBehaviour)this).StartCoroutine(SpawnPropsInWorld(spawner, positions, rotations, area2));
break;
}
}
}
[IteratorStateMachine(typeof(<SpawnPropsInWorldCaldera>d__8))]
private IEnumerator SpawnPropsInWorldCaldera(Vector3[] positions, Quaternion[] rotations)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SpawnPropsInWorldCaldera>d__8(0)
{
positions = positions,
rotations = rotations
};
}
[IteratorStateMachine(typeof(<SpawnPropsInWorld>d__9))]
private IEnumerator SpawnPropsInWorld(SpawnerData spawnerData, Vector3[] positions, Quaternion[] rotations, string area)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SpawnPropsInWorld>d__9(0)
{
spawnerData = spawnerData,
positions = positions,
rotations = rotations,
area = area
};
}
public void ClearPropsNetwork(SpawnerData spawnData)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: 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)
ManualLogSource log = Plugin.Log;
string[] obj = new string[6] { "[Network] Sending 'RPC_ClearProps' ", null, null, null, null, null };
BiomeType biomeType = spawnData.BiomeType;
obj[1] = ((object)(BiomeType)(ref biomeType)).ToString();
obj[2] = "/";
obj[3] = spawnData.Area.ToString();
obj[4] = "/";
obj[5] = spawnData.SpawnType.ToString();
log.LogInfo((object)string.Concat(obj));
((MonoBehaviourPun)this).photonView.RPC("RPC_ClearProps", (RpcTarget)0, new object[3] { spawnData.BiomeType, spawnData.Area, spawnData.SpawnType });
}
[PunRPC]
public void RPC_ClearProps(BiomeType biomeType, BiomeArea area, SpawnType spawnType)
{
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
Plugin.Log.LogInfo((object)("[Network] Received 'RPC_ClearProps' at " + ((object)(BiomeType)(ref biomeType)).ToString() + "/" + area.ToString() + "/" + spawnType));
BiomeInfo biomeInfo = LevelManager.GetBiomeInfo(biomeType);
if (biomeInfo == null)
{
return;
}
foreach (SpawnerData spawner in biomeInfo.Spawners)
{
if (spawner.Area == area && spawner.SpawnType == spawnType)
{
BiomeType biomeType2 = spawner.BiomeType;
string area2 = ((object)(BiomeType)(ref biomeType2)).ToString() + "/" + spawner.Area;
((MonoBehaviour)this).StartCoroutine(ClearPropsInWorld(spawner, area2));
break;
}
}
}
[IteratorStateMachine(typeof(<ClearPropsInWorld>d__12))]
private IEnumerator ClearPropsInWorld(SpawnerData spawnerData, string area)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ClearPropsInWorld>d__12(0)
{
spawnerData = spawnerData
};
}
}
}
namespace HazardSpam.Level
{
public static class LevelManager
{
[CompilerGenerated]
private sealed class <InvokeClearBiome>d__17 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public BiomeType biomeType;
public float intervalDelay;
private List<SpawnerData>.Enumerator <>7__wrap1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InvokeClearBiome>d__17(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 1)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<>7__wrap1 = default(List<SpawnerData>.Enumerator);
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: 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_0097: Expected O, but got Unknown
try
{
switch (<>1__state)
{
default:
return false;
case 0:
{
<>1__state = -1;
BiomeInfo biomeInfo = GetBiomeInfo(biomeType);
if (biomeInfo == null)
{
Plugin.Log.LogError((object)$"Failed to clear {biomeType}");
return false;
}
<>7__wrap1 = biomeInfo.Spawners.GetEnumerator();
<>1__state = -3;
break;
}
case 1:
<>1__state = -3;
break;
}
if (<>7__wrap1.MoveNext())
{
SpawnerData current = <>7__wrap1.Current;
SpawnerNetwork.Instance.ClearPropsNetwork(current);
<>2__current = (object)new WaitForSeconds(intervalDelay);
<>1__state = 1;
return true;
}
<>m__Finally1();
<>7__wrap1 = default(List<SpawnerData>.Enumerator);
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
((IDisposable)<>7__wrap1).Dispose();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <InvokeInitBiome>d__15 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public BiomeType biomeType;
public float intervalDelay;
private BiomeInfo <biomeInfo>5__2;
private List<SpawnerData>.Enumerator <>7__wrap2;
private SpawnerData <spawner>5__4;
private Vector3[] <pos>5__5;
private Quaternion[] <rot>5__6;
private float[] <scaleGain>5__7;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InvokeInitBiome>d__15(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || (uint)(num - 1) <= 1u)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<biomeInfo>5__2 = null;
<>7__wrap2 = default(List<SpawnerData>.Enumerator);
<spawner>5__4 = null;
<pos>5__5 = null;
<rot>5__6 = null;
<scaleGain>5__7 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
//IL_01fd: Expected O, but got Unknown
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
//IL_01b4: Expected O, but got Unknown
try
{
int spawnRate;
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<biomeInfo>5__2 = GetBiomeInfo(biomeType);
if (<biomeInfo>5__2 == null)
{
Plugin.Log.LogError((object)$"Failed to init {biomeType}");
return false;
}
<>7__wrap2 = <biomeInfo>5__2.Spawners.GetEnumerator();
<>1__state = -3;
goto IL_022c;
case 1:
<>1__state = -3;
goto IL_01ca;
case 2:
{
<>1__state = -3;
<pos>5__5 = null;
<rot>5__6 = null;
<scaleGain>5__7 = null;
<spawner>5__4 = null;
goto IL_022c;
}
IL_01ca:
SpawnerNetwork.Instance.SpawnPropsNetwork(<spawner>5__4, <pos>5__5, <rot>5__6, <scaleGain>5__7);
break;
IL_022c:
while (true)
{
if (<>7__wrap2.MoveNext())
{
<spawner>5__4 = <>7__wrap2.Current;
spawnRate = ConfigHandler.GetSpawnRate(biomeType, <spawner>5__4.Area, <spawner>5__4.SpawnType);
if (spawnRate != 0)
{
break;
}
ManualLogSource log = Plugin.Log;
string[] obj = new string[6] { "Unknown spawn rate for ", null, null, null, null, null };
BiomeType val = <spawner>5__4.BiomeType;
obj[1] = ((object)(BiomeType)(ref val)).ToString();
obj[2] = "/";
obj[3] = <spawner>5__4.Area.ToString();
obj[4] = "/";
obj[5] = <spawner>5__4.SpawnType.ToString();
log.LogWarning((object)string.Concat(obj));
continue;
}
<>m__Finally1();
<>7__wrap2 = default(List<SpawnerData>.Enumerator);
return false;
}
(<pos>5__5, <rot>5__6, <scaleGain>5__7) = <spawner>5__4.GenerateSpawnPoints(spawnRate);
if (<pos>5__5.Length == 0)
{
break;
}
if ((int)<biomeInfo>5__2.BiomeType == 0)
{
Plugin.Log.LogInfo((object)"CRUDE FIX: Delaying shore spawn for 12 seconds");
<>2__current = (object)new WaitForSeconds(12f);
<>1__state = 1;
return true;
}
goto IL_01ca;
}
<>2__current = (object)new WaitForSeconds(intervalDelay);
<>1__state = 2;
return true;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
((IDisposable)<>7__wrap2).Dispose();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public static List<BiomeInfo> BiomeInfo { get; } = new List<BiomeInfo>();
public static BiomeInfo? GetShoreBiome()
{
return BiomeInfo.FirstOrDefault((BiomeInfo b) => (int)b.BiomeType == 0);
}
public static BiomeInfo? GetTropicBiome()
{
return BiomeInfo.FirstOrDefault((BiomeInfo b) => (int)b.BiomeType == 1);
}
public static BiomeInfo? GetAlpineBiome()
{
return BiomeInfo.FirstOrDefault((BiomeInfo b) => (int)b.BiomeType == 2);
}
public static BiomeInfo? GetMesaBiome()
{
return BiomeInfo.FirstOrDefault((BiomeInfo b) => (int)b.BiomeType == 6);
}
public static BiomeInfo? GetBiomeInfo(BiomeType biomeType)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
return BiomeInfo.FirstOrDefault((BiomeInfo b) => b.BiomeType == biomeType);
}
public static void Init(List<BiomeType> currentBiomeTypes)
{
Reset();
GatherBiomesInfo(currentBiomeTypes);
}
public static void Reset()
{
foreach (BiomeInfo item in BiomeInfo)
{
item.Clear();
}
BiomeInfo.Clear();
CalderaHandler.ClearCaldera();
}
private static void GatherBiomesInfo(List<BiomeType> biomeTypes)
{
//IL_002e: 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_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Invalid comparison between Unknown and I4
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
Plugin.Log.LogInfo((object)("Gathering info for BiomeTypes: " + string.Join(", ", LevelState.GetBiomeTypes())));
foreach (BiomeType biomeType2 in biomeTypes)
{
if ((int)biomeType2 != 3)
{
BiomeInfo biomeInfo = BiomeFinder.FindActiveBiome(biomeType2);
if (biomeInfo == null)
{
Plugin.Log.LogError((object)$"Failed to gather biome {biomeType2}");
}
else
{
BiomeInfo.Add(biomeInfo);
}
}
}
foreach (BiomeInfo item in BiomeInfo)
{
ManualLogSource log = Plugin.Log;
BiomeType biomeType = item.BiomeType;
log.LogInfo((object)("Successfully gathered spawners for " + ((object)(BiomeType)(ref biomeType)).ToString() + "/" + item.BiomeVariant));
}
}
public static void InitCalderaLava()
{
CalderaHandler.InitCaldera();
}
public static void InitCalderaSpawns()
{
CalderaHandler.InitSpawns();
}
public static void SpawnCalderaSpawns()
{
var (array, rotations, scaleGains) = CalderaHandler.GenerateSpawnPoints(500);
if (array.Length != 0)
{
SpawnerNetwork.Instance.SpawnPropsNetworkCaldera(array, rotations, scaleGains);
}
}
public static void InitBiome(BiomeType biomeType, float intervalDelay = 0.15f)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
((MonoBehaviour)SpawnerNetwork.Instance).StartCoroutine(InvokeInitBiome(biomeType, intervalDelay));
}
[IteratorStateMachine(typeof(<InvokeInitBiome>d__15))]
private static IEnumerator InvokeInitBiome(BiomeType biomeType, float intervalDelay)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InvokeInitBiome>d__15(0)
{
biomeType = biomeType,
intervalDelay = intervalDelay
};
}
public static void ClearBiome(BiomeType biomeType, float intervalDelay = 0.15f)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
((MonoBehaviour)SpawnerNetwork.Instance).StartCoroutine(InvokeClearBiome(biomeType, intervalDelay));
}
[IteratorStateMachine(typeof(<InvokeClearBiome>d__17))]
private static IEnumerator InvokeClearBiome(BiomeType biomeType, float intervalDelay)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InvokeClearBiome>d__17(0)
{
biomeType = biomeType,
intervalDelay = intervalDelay
};
}
public static string GenSpawnID(BiomeType biomeType, BiomeArea area, SpawnType spawnType, int index)
{
return $"{((object)(BiomeType)(ref biomeType)).ToString()}-{area.ToString()}-{spawnType.ToString()}-{index}";
}
}
public static class LevelState
{
[CompilerGenerated]
private sealed class <InvokeOnBiomeComplete>d__19 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public BiomeType biomeType;
object? IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object? IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InvokeOnBiomeComplete>d__19(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
LevelState.OnBiomeComplete?.Invoke(biomeType);
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <InvokeOnBiomeLoading>d__16 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public BiomeType biomeType;
object? IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object? IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InvokeOnBiomeLoading>d__16(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
LevelState.OnBiomeLoading?.Invoke(biomeType);
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static MapHandler? _mapHandlerInstance;
private static bool _triedToFetchMapHandler;
private static BiomeType _currentBiome;
public static MapHandler MapHandlerInstance => _mapHandlerInstance ?? throw new InvalidOperationException("MapHandler not set yet.");
public static event Action<BiomeType>? OnBiomeLoading;
public static event Action<BiomeType>? OnBiomeComplete;
public static void Initialize(MapHandler instance)
{
if (!((Object)(object)_mapHandlerInstance != (Object)null))
{
_mapHandlerInstance = instance;
}
}
public static List<BiomeType> GetBiomeTypes()
{
if ((Object)(object)_mapHandlerInstance == (Object)null)
{
Plugin.Log.LogError((object)"[LevelState] MapHandler is null, could not trigger GetBiomeTypes()");
return new List<BiomeType>();
}
Plugin.Log.LogInfo((object)("[LevelState] Got biome types: " + string.Join(", ", _mapHandlerInstance.biomes)));
return _mapHandlerInstance.biomes;
}
public static void SetBiomeLoading(BiomeType biomeType)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: 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)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
Plugin.Log.LogInfo((object)$"[LevelState] Biome loading: {biomeType}");
_currentBiome = biomeType;
if ((Object)(object)_mapHandlerInstance != (Object)null)
{
((MonoBehaviour)_mapHandlerInstance).StartCoroutine(InvokeOnBiomeLoading(_currentBiome));
}
else
{
Plugin.Log.LogError((object)$"[LevelState] MapHandler is null, did not trigger SetBiomeLoading() for {biomeType}");
}
}
public static void SetBiomeLoading()
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Invalid comparison between Unknown and I4
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_mapHandlerInstance == (Object)null && !_triedToFetchMapHandler)
{
TryFetchMapHandler();
_triedToFetchMapHandler = true;
}
if ((Object)(object)_mapHandlerInstance != (Object)null)
{
BiomeType currentBiome = _mapHandlerInstance.GetCurrentBiome();
Segment currentSegment = _mapHandlerInstance.GetCurrentSegment();
if ((int)currentSegment == 4)
{
SetBiomeLoading((BiomeType)7);
}
else
{
SetBiomeLoading(currentBiome);
}
}
else
{
Plugin.Log.LogError((object)"[LevelState] MapHandler is null, did not trigger SetBiomeLoading()");
}
}
public static bool TryFetchMapHandler()
{
GameObject val = GameObject.Find("Map");
if ((Object)(object)val == (Object)null)
{
return false;
}
MapHandler component = val.GetComponent<MapHandler>();
if ((Object)(object)component == (Object)null)
{
return false;
}
Initialize(component);
return true;
}
[IteratorStateMachine(typeof(<InvokeOnBiomeLoading>d__16))]
private static IEnumerator InvokeOnBiomeLoading(BiomeType biomeType)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InvokeOnBiomeLoading>d__16(0)
{
biomeType = biomeType
};
}
public static void SetBiomeComplete(BiomeType biomeType)
{
//IL_000a: 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_002c: Unknown result type (might be due to invalid IL or missing references)
Plugin.Log.LogInfo((object)$"[LevelState] Segment complete: {biomeType}");
if ((Object)(object)_mapHandlerInstance != (Object)null)
{
((MonoBehaviour)_mapHandlerInstance).StartCoroutine(InvokeOnBiomeComplete(biomeType));
}
else
{
Plugin.Log.LogError((object)$"[LevelState] MapHandler is null, did not trigger SetBiomeLoading() for {biomeType}");
}
}
public static void SetBiomeComplete()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Invalid comparison between Unknown and I4
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_mapHandlerInstance != (Object)null)
{
BiomeType currentBiome = _mapHandlerInstance.GetCurrentBiome();
Segment currentSegment = _mapHandlerInstance.GetCurrentSegment();
if ((int)currentSegment == 4)
{
SetBiomeComplete((BiomeType)7);
}
else
{
SetBiomeComplete(currentBiome);
}
}
else
{
Plugin.Log.LogError((object)"[LevelState] MapHandler is null, did not trigger SetBiomeComplete()");
}
}
[IteratorStateMachine(typeof(<InvokeOnBiomeComplete>d__19))]
private static IEnumerator InvokeOnBiomeComplete(BiomeType biomeType)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InvokeOnBiomeComplete>d__19(0)
{
biomeType = biomeType
};
}
}
}
namespace HazardSpam.Level.Spawner
{
public class SpawnerData
{
private int _defaultNrOfSpawns;
private readonly List<SpawnInfo> _spawnInfo = new List<SpawnInfo>();
public PropSpawner PropSpawner { get; }
public GameObject Prefab { get; }
public BiomeType BiomeType { get; private set; }
public BiomeArea Area { get; private set; }
public SpawnType SpawnType { get; private set; }
public SpawnerData(PropSpawner propSpawner, GameObject prefab, BiomeType biomeType, BiomeArea area, SpawnType spawnType)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
PropSpawner = propSpawner;
Prefab = prefab;
_defaultNrOfSpawns = PropSpawner.nrOfSpawns;
BiomeType = biomeType;
Area = area;
SpawnType = spawnType;
}
public void Clear()
{
_spawnInfo.Clear();
}
public void AddSpawnInfos(Vector3[] positions, Quaternion[] rotations, float[]? scaleGains)
{
//IL_0043: 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_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
if (positions.Length == _spawnInfo.Count)
{
return;
}
for (int i = 0; i < positions.Length; i++)
{
if (scaleGains != null)
{
_spawnInfo.Add(new SpawnInfo(positions[i], rotations[i], scaleGains[i]));
}
else
{
_spawnInfo.Add(new SpawnInfo(positions[i], rotations[i]));
}
}
}
public void AddSpawnInfo(Vector3 position, Quaternion rotation, float? scaleGain = null)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
if (scaleGain.HasValue)
{
_spawnInfo.Add(new SpawnInfo(position, rotation, scaleGain.Value));
}
else
{
_spawnInfo.Add(new SpawnInfo(position, rotation));
}
}
public (Vector3[] positions, Quaternion[] rotations, float[] scaleGains) GetSpawnInfoArrays()
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: 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_0055: Unknown result type (might be due to invalid IL or missing references)
int count = _spawnInfo.Count;
Vector3[] array = (Vector3[])(object)new Vector3[count];
Quaternion[] array2 = (Quaternion[])(object)new Quaternion[count];
float[] array3 = new float[count];
for (int i = 0; i < count; i++)
{
array[i] = _spawnInfo[i].Position;
array2[i] = _spawnInfo[i].Rotation;
array3[i] = _spawnInfo[i].ScaleGain;
}
return (array, array2, array3);
}
public (Vector3[] positions, Quaternion[] rotations, float[] scaleGains) GenerateSpawnPoints(int attempts, float chance, float scaleGainMin, float scaleGainMax)
{
(Vector3[] positions, Quaternion[] rotations, float[] scaleGains) tuple = GenerateSpawnPoints(attempts);
Vector3[] item = tuple.positions;
Quaternion[] item2 = tuple.rotations;
float[] item3 = tuple.scaleGains;
for (int i = 0; i < item3.Length; i++)
{
if (Random.Range(0f, 1f) < chance)
{
item3[i] = Random.Range(scaleGainMin, scaleGainMax);
}
}
return (item, item2, item3);
}
public (Vector3[] positions, Quaternion[] rotations, float[] scaleGains) GenerateSpawnPoints(int attempts)
{
//IL_0093: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
if (!PhotonNetwork.IsMasterClient)
{
return (Array.Empty<Vector3>(), Array.Empty<Quaternion>(), Array.Empty<float>());
}
int num = 0;
int num2 = 0;
int num3 = 0;
List<Vector3> list = new List<Vector3>();
List<Quaternion> list2 = new List<Quaternion>();
List<float> list3 = new List<float>();
while (num < attempts && num2 < attempts)
{
MethodInfo method = ((object)PropSpawner).GetType().GetMethod("GetRandomPoint", BindingFlags.Instance | BindingFlags.NonPublic);
if (method == null)
{
break;
}
num2++;
try
{
object obj = method.Invoke(PropSpawner, null);
if (obj != null)
{
Vector3 item = (Vector3)obj.GetType().GetField("pos").GetValue(obj);
Vector3 val = (Vector3)obj.GetType().GetField("normal").GetValue(obj);
Quaternion randomRotationWithUp = HelperFunctions.GetRandomRotationWithUp(val);
list.Add(item);
list2.Add(randomRotationWithUp);
list3.Add(0f);
num++;
}
}
catch (Exception)
{
num3++;
}
}
Plugin.Log.LogInfo((object)$"Generated {num} spawn points, {num3} failed (which is fine)");
return (list.ToArray(), list2.ToArray(), list3.ToArray());
}
}
public static class SpawnerFinderAndInit
{
[CompilerGenerated]
private sealed class <GetSpawnersFromPath>d__3 : IEnumerable<SpawnerData>, IEnumerable, IEnumerator<SpawnerData>, IEnumerator, IDisposable
{
private int <>1__state;
private SpawnerData <>2__current;
private int <>l__initialThreadId;
private Transform activeBiome;
public Transform <>3__activeBiome;
private string path;
public string <>3__path;
private List<(string searcName, SpawnType spawnType)> spawnersToSearch;
public List<(string searcName, SpawnType spawnType)> <>3__spawnersToSearch;
private BiomeType biomeType;
public BiomeType <>3__biomeType;
private BiomeArea area;
public BiomeArea <>3__area;
private IEnumerator <>7__wrap1;
private Transform <child>5__3;
private List<(string searcName, SpawnType spawnType)>.Enumerator <>7__wrap3;
SpawnerData IEnumerator<SpawnerData>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <GetSpawnersFromPath>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if ((uint)(num - -4) <= 1u || num == 1)
{
try
{
if (num == -4 || num == 1)
{
try
{
}
finally
{
<>m__Finally2();
}
}
}
finally
{
<>m__Finally1();
}
}
<>7__wrap1 = null;
<child>5__3 = null;
<>7__wrap3 = default(List<(string, SpawnType)>.Enumerator);
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Expected O, but got Unknown
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
try
{
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -4;
goto IL_0192;
}
<>1__state = -1;
Transform val = activeBiome.Find(path);
if ((Object)(object)val == (Object)null)
{
Plugin.Log.LogWarning((object)("Could not find path '" + path + "' in " + ((Object)activeBiome).name));
return false;
}
<>7__wrap1 = val.GetEnumerator();
<>1__state = -3;
goto IL_01bb;
IL_0192:
while (<>7__wrap3.MoveNext())
{
var (text, spawnType) = <>7__wrap3.Current;
if (((Object)<child>5__3).name == text)
{
SpawnerData spawnerFromObject = GetSpawnerFromObject(((Component)<child>5__3).gameObject, biomeType, area, spawnType);
if (spawnerFromObject != null)
{
<>2__current = spawnerFromObject;
<>1__state = 1;
return true;
}
Plugin.Log.LogWarning((object)("Could not find spawner '" + spawnType.ToString() + "' in " + ((Object)<child>5__3).name + " from " + path + ", biome " + ((Object)activeBiome).name));
}
}
<>m__Finally2();
<>7__wrap3 = default(List<(string, SpawnType)>.Enumerator);
<child>5__3 = null;
goto IL_01bb;
IL_01bb:
if (<>7__wrap1.MoveNext())
{
<child>5__3 = (Transform)<>7__wrap1.Current;
<>7__wrap3 = spawnersToSearch.GetEnumerator();
<>1__state = -4;
goto IL_0192;
}
<>m__Finally1();
<>7__wrap1 = null;
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<>7__wrap1 is IDisposable disposable)
{
disposable.Dispose();
}
}
private void <>m__Finally2()
{
<>1__state = -3;
((IDisposable)<>7__wrap3).Dispose();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<SpawnerData> IEnumerable<SpawnerData>.GetEnumerator()
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
<GetSpawnersFromPath>d__3 <GetSpawnersFromPath>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<GetSpawnersFromPath>d__ = this;
}
else
{
<GetSpawnersFromPath>d__ = new <GetSpawnersFromPath>d__3(0);
}
<GetSpawnersFromPath>d__.activeBiome = <>3__activeBiome;
<GetSpawnersFromPath>d__.biomeType = <>3__biomeType;
<GetSpawnersFromPath>d__.path = <>3__path;
<GetSpawnersFromPath>d__.area = <>3__area;
<GetSpawnersFromPath>d__.spawnersToSearch = <>3__spawnersToSearch;
return <GetSpawnersFromPath>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<SpawnerData>)this).GetEnumerator();
}
}
[CompilerGenerated]
private sealed class <HandleAlpinePlateauGeyser>d__1 : IEnumerable<SpawnerData>, IEnumerable, IEnumerator<SpawnerData>, IEnumerator, IDisposable
{
private int <>1__state;
private SpawnerData <>2__current;
private int <>l__initialThreadId;
private Transform activeBiome;
public Transform <>3__activeBiome;
private BiomeSpawnDefinition bsd;
public BiomeSpawnDefinition <>3__bsd;
SpawnerData IEnumerator<SpawnerData>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <HandleAlpinePlateauGeyser>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
{
<>1__state = -1;
Transform val = activeBiome.parent.Find("GeyserHell/PlateauProps/Geysers");
if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).GetComponent<PropSpawner>() == (Object)null)
{
return false;
}
Transform val2 = activeBiome.Find("PlateauProps");
if ((Object)(object)val2 == (Object)null)
{
return false;
}
GameObject val3 = Object.Instantiate<GameObject>(((Component)val).gameObject, val2, true);
val3.SetActive(true);
SpawnerData spawnerFromObject = GetSpawnerFromObject(val3, bsd.BiomeType, bsd.Area, bsd.SpawnType);
if (spawnerFromObject != null)
{
<>2__current = spawnerFromObject;
<>1__state = 1;
return true;
}
break;
}
case 1:
<>1__state = -1;
break;
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<SpawnerData> IEnumerable<SpawnerData>.GetEnumerator()
{
<HandleAlpinePlateauGeyser>d__1 <HandleAlpinePlateauGeyser>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<HandleAlpinePlateauGeyser>d__ = this;
}
else
{
<HandleAlpinePlateauGeyser>d__ = new <HandleAlpinePlateauGeyser>d__1(0);
}
<HandleAlpinePlateauGeyser>d__.activeBiome = <>3__activeBiome;
<HandleAlpinePlateauGeyser>d__.bsd = <>3__bsd;
return <HandleAlpinePlateauGeyser>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<SpawnerData>)this).GetEnumerator();
}
}
public static List<SpawnerData> GetSpawnersFromBiomeType(Transform activeBiome, BiomeType biomeType, string biomeVariant)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Invalid comparison between Unknown and I4
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
List<SpawnerData> list = new List<SpawnerData>();
foreach (BiomeSpawnDefinition item in SpawnerDefinitions.All)
{
if (item.BiomeType == biomeType)
{
list.AddRange(GetSpawnersFromDefinition(activeBiome, item));
}
}
if ((int)biomeType == 2 && biomeVariant != "Geysers")
{
list.AddRange(HandleAlpinePlateauGeyser(activeBiome, SpawnerDefinitions.AlpineGeyserPlateau));
}
foreach (SpawnerData item2 in list)
{
Plugin.Log.LogInfo((object)$"Added spawner '{item2.SpawnType}' from {biomeType}/{biomeVariant}/{item2.Area}");
}
return list;
}
[IteratorStateMachine(typeof(<HandleAlpinePlateauGeyser>d__1))]
private static IEnumerable<SpawnerData> HandleAlpinePlateauGeyser(Transform activeBiome, BiomeSpawnDefinition bsd)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <HandleAlpinePlateauGeyser>d__1(-2)
{
<>3__activeBiome = activeBiome,
<>3__bsd = bsd
};
}
private static IEnumerable<SpawnerData> GetSpawnersFromDefinition(Transform activeBiome, BiomeSpawnDefinition bsd)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
return GetSpawnersFromPath(activeBiome, bsd.BiomeType, bsd.Path, bsd.Area, new List<(string, SpawnType)>(1) { (bsd.SearchName, bsd.SpawnType) });
}
[IteratorStateMachine(typeof(<GetSpawnersFromPath>d__3))]
private static IEnumerable<SpawnerData> GetSpawnersFromPath(Transform activeBiome, BiomeType biomeType, string path, BiomeArea area, List<(string searcName, SpawnType spawnType)> spawnersToSearch)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <GetSpawnersFromPath>d__3(-2)
{
<>3__activeBiome = activeBiome,
<>3__biomeType = biomeType,
<>3__path = path,
<>3__area = area,
<>3__spawnersToSearch = spawnersToSearch
};
}
public static SpawnerData? GetSpawnerFromObject(GameObject go, BiomeType biomeType, BiomeArea area, SpawnType spawnType)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
PropSpawner component = go.GetComponent<PropSpawner>();
if ((Object)(object)component == (Object)null || component.props.Length == 0)
{
return null;
}
return new SpawnerData(component, component.props[0], biomeType, area, spawnType);
}
}
}
namespace HazardSpam.Level.Caldera
{
public static class CalderaHandler
{
private static Transform? _spawner;
private static PropSpawner? _propSpawner;
private static GameObject? _prefab;
private static bool _isSpawnInit;
public static Transform? GetSpawner => _spawner;
public static GameObject? GetPrefab => _prefab;
public static void InitCaldera()
{
GameObject val = GameObject.Find("Map/Biome_4/Volcano/Caldera_Segment/River");
if ((Object)(object)val == (Object)null)
{
Plugin.Log.LogError((object)"[InitCaldera] Could not find LavaRiver in Caldera");
return;
}
LavaRiverSpeedHandler lavaRiverSpeedHandler = val.AddComponent<LavaRiverSpeedHandler>();
if ((Object)(object)lavaRiverSpeedHandler == (Object)null)
{
Plugin.Log.LogError((object)"[InitCaldera] Could not add LavaRiverSpeedHandler to LavaRiver");
}
}
public static void InitSpawns()
{
string text = "Map/Biome_1/Beach/Beach_Segment/Default/PlateauProps/Jellies";
string text2 = "Map/Biome_4/Volcano/Caldera_Segment/Props/Eggs";
GameObject val = GameObject.Find(text);
GameObject val2 = GameObject.Find(text2);
if ((Object)(object)val == (Object)null)
{
Plugin.Log.LogError((object)("[CalderaHandler.InitSpawns] Could not find " + text));
return;
}
if ((Object)(object)val2 == (Object)null)
{
Plugin.Log.LogError((object)("[CalderaHandler.InitSpawns] Could not find " + text2));
return;
}
PropSpawner component = val.GetComponent<PropSpawner>();
PropSpawner component2 = val2.GetComponent<PropSpawner>();
if ((Object)(object)component == (Object)null)
{
Plugin.Log.LogError((object)("[CalderaHandler.InitSpawns] Could not find PropSpawner on " + text));
return;
}
if ((Object)(object)component2 == (Object)null)
{
Plugin.Log.LogError((object)("[CalderaHandler.InitSpawns] Could not find PropSpawner on " + text2));
return;
}
component2.props = component.props;
component2.area.y = 420f;
_spawner = val2.transform;
_propSpawner = component2;
_prefab = component2.props[0];
_isSpawnInit = true;
Plugin.Log.LogInfo((object)("[CalderaHandler.InitSpawns] Initialized spawns for " + text + " -> " + text2));
}
public static void ClearCaldera()
{
GameObject val = GameObject.Find("Map/Biome_4/Volcano/Caldera_Segment/River");
if ((Object)(object)val == (Object)null)
{
Plugin.Log.LogError((object)"[ClearCaldera] Could not find LavaRiver in Caldera");
return;
}
LavaRiverSpeedHandler component = val.GetComponent<LavaRiverSpeedHandler>();
if ((Object)(object)component == (Object)null)
{
Plugin.Log.LogError((object)"[ClearCaldera] Could not clear LavaRiverSpeedHandler from LavaRiver");
}
else
{
((Behaviour)component).enabled = false;
}
_isSpawnInit = false;
_spawner = null;
_propSpawner = null;
_prefab = null;
}
public static (Vector3[] positions, Quaternion[] rotations, float[] scaleGains) GenerateSpawnPoints(int attempts)
{
//IL_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
//IL_0165: Unknown result type (might be due to invalid IL or missing references)
//IL_016a: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
//IL_016e: Unknown result type (might be due to invalid IL or missing references)
//IL_0173: Unknown result type (might be due to invalid IL or missing references)
//IL_0176: Unknown result type (might be due to invalid IL or missing references)
//IL_017f: Unknown result type (might be due to invalid IL or missing references)
if (!PhotonNetwork.IsMasterClient)
{
return (Array.Empty<Vector3>(), Array.Empty<Quaternion>(), Array.Empty<float>());
}
if (!_isSpawnInit || (Object)(object)_propSpawner == (Object)null || (Object)(object)_spawner == (Object)null || (Object)(object)_prefab == (Object)null)
{
Plugin.Log.LogError((object)"[GenerateSpawnPoints] Could not generate spawn points, not initialized");
Plugin.Log.LogError((object)$"_isSpawnInit: {_isSpawnInit}, _propSpawner is null: {(Object)(object)_propSpawner == (Object)null}, _spawner is null: {(Object)(object)_spawner == (Object)null}, _prefab is null: {(Object)(object)_prefab == (Object)null}");
return (Array.Empty<Vector3>(), Array.Empty<Quaternion>(), Array.Empty<float>());
}
int num = 0;
int num2 = 0;
int num3 = 0;
List<Vector3> list = new List<Vector3>();
List<Quaternion> list2 = new List<Quaternion>();
List<float> list3 = new List<float>();
while (num < attempts && num2 < attempts * 4)
{
MethodInfo method = ((object)_propSpawner).GetType().GetMethod("GetRandomPoint", BindingFlags.Instance | BindingFlags.NonPublic);
if (method == null)
{
break;
}
num2++;
try
{
object obj = method.Invoke(_propSpawner, null);
if (obj != null)
{
Vector3 item = (Vector3)obj.GetType().GetField("pos").GetValue(obj);
Vector3 val = (Vector3)obj.GetType().GetField("normal").GetValue(obj);
Quaternion randomRotationWithUp = HelperFunctions.GetRandomRotationWithUp(val);
list.Add(item);
list2.Add(randomRotationWithUp);
list3.Add(0f);
num++;
}
}
catch (Exception)
{
num3++;
}
}
Plugin.Log.LogInfo((object)$"Generated {num} spawn points, {num3} failed (which is fine)");
return (list.ToArray(), list2.ToArray(), list3.ToArray());
}
}
public class LavaRiverSpeedHandler : MonoBehaviourPun
{
private Animator _animator;
private LavaRiverSpeedRandomizer _randomizer;
private PhotonView _view;
private float _targetSpeed;
private float _applyTime;
private void Awake()
{
_animator = ((Component)this).GetComponent<Animator>();
if ((Object)(object)_animator == (Object)null)
{
Debug.LogError((object)"LavaRiverSpeedHandler: No Animator found!");
((Behaviour)this).enabled = false;
}
else
{
_randomizer = new LavaRiverSpeedRandomizer();
}
}
private void Start()
{
_view = ((Component)this).GetComponent<PhotonView>();
}
private void Update()
{
if (PhotonNetwork.IsMasterClient)
{
var (flag, num) = _randomizer.Poll(Time.deltaTime);
if (flag)
{
double num2 = PhotonNetwork.Time + 2.0;
float num3 = (float)num2;
_view.RPC("RPC_SetLavaSpeed", (RpcTarget)3, new object[2] { num, num3 });
}
}
if (_applyTime > 0f && Time.time >= _applyTime)
{
_animator.speed = _targetSpeed;
_applyTime = 0f;
}
}
[PunRPC]
public void RPC_SetLavaSpeed(float speed, float applyAt)
{
_targetSpeed = speed;
_applyTime = applyAt - (float)PhotonNetwork.Time + Time.time;
Plugin.Log.LogInfo((object)$"LavaRiverSpeedHandler: New speed {speed} scheduled to apply at {applyAt} network time ({_applyTime} local Time.time)");
}
}
public class LavaRiverSpeedRandomizer
{
private float _timer;
private float _nextRandomChange;
private float _nextSpikeTime;
private readonly float _randomChangeInterval = 10f;
private readonly float _spikeInterval = 120f;
private readonly float _spikeDurationMin = 8f;
private readonly float _spikeDurationMax = 12f;
private readonly float _minSpeed = 1f;
private readonly float _maxSpeed = 5f;
private readonly float _minSpikeSpeed = 25f;
private readonly float _maxSpikeSpeed = 30f;
public LavaRiverSpeedRandomizer()
{
_timer = 0f;
_nextRandomChange = _randomChangeInterval;
_nextSpikeTime = _spikeInterval;
}
public (bool, float) Poll(float deltaTime)
{
_timer += deltaTime;
if (_timer >= _nextSpikeTime)
{
float num = Random.Range(_spikeDurationMin, _spikeDurationMax);
float item = Random.Range(_minSpikeSpeed, _maxSpikeSpeed);
_nextSpikeTime += _spikeInterval + num;
_nextRandomChange = _timer + num;
return (true, item);
}
if (_timer >= _nextRandomChange)
{
_nextRandomChange += _randomChangeInterval;
float item2 = Random.Range(_minSpeed, _maxSpeed);
return (true, item2);
}
return (false, 0f);
}
}
}
namespace HazardSpam.Level.Biomes
{
public static class BiomeFinder
{
public static BiomeInfo? FindActiveBiome(BiomeType biomeType)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected I4, but got Unknown
//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_0162: Unknown result type (might be due to invalid IL or missing references)
switch ((int)biomeType)
{
case 0:
{
GameObject val4 = GameObject.Find("Map/Biome_1/Beach/Beach_Segment");
if ((Object)(object)val4 == (Object)null)
{
Plugin.Log.LogError((object)"Could not find Beach_Segment for Shore");
return null;
}
Transform val5 = DetermineBiomeVariant(Enum.GetNames(typeof(BiomeShoreVariants)), val4.transform);
if ((Object)(object)val5 == (Object)null)
{
Plugin.Log.LogError((object)"Could not find biome variant for Shore");
return null;
}
return new BiomeInfo(biomeType, ((Object)val5).name, val4.transform, val5);
}
case 1:
{
GameObject val2 = GameObject.Find("Map/Biome_2/Jungle/Jungle_Segment");
if ((Object)(object)val2 == (Object)null)
{
Plugin.Log.LogError((object)"Could not find Jungle_Segment for Tropics");
return null;
}
Transform val3 = DetermineBiomeVariant(Enum.GetNames(typeof(BiomeTropicVariants)), val2.transform);
if ((Object)(object)val3 == (Object)null)
{
Plugin.Log.LogError((object)"Could not find biome variant for Tropics");
return null;
}
return new BiomeInfo(biomeType, ((Object)val3).name, val2.transform, val3);
}
case 2:
{
GameObject val6 = GameObject.Find("Map/Biome_3/Snow/Snow_Segment");
if ((Object)(object)val6 == (Object)null)
{
Plugin.Log.LogError((object)"Could not find Snow_Segment for Alpine");
return null;
}
Transform val7 = DetermineBiomeVariant(Enum.GetNames(typeof(BiomeAlpineVariants)), val6.transform);
if ((Object)(object)val7 == (Object)null)
{
Plugin.Log.LogError((object)"Could not find biome variant for Alpine");
return null;
}
return new BiomeInfo(biomeType, ((Object)val7).name, val6.transform, val7);
}
case 6:
{
GameObject val = GameObject.Find("Map/Biome_3/Desert/Desert_Segment");
if ((Object)(object)val == (Object)null)
{
Plugin.Log.LogError((object)"Could not find Desert_Segment for Mesa");
return null;
}
return new BiomeInfo(biomeType, "", val.transform, val.transform);
}
default:
return null;
}
}
private static Transform? DetermineBiomeVariant(string[] variants, Transform segment)
{
foreach (string text in variants)
{
Transform val = segment.Find(text);
if ((Object)(object)val == (Object)null)
{
Plugin.Log.LogWarning((object)("Biome variant '" + text + "' is null"));
}
else if (((Component)val).gameObject.activeSelf)
{
Plugin.Log.LogInfo((object)("Found biome variant '" + text + "'"));
return val;
}
}
return null;
}
}
public class BiomeInfo
{
public BiomeType BiomeType { get; }
public string BiomeVariant { get; }
public Transform Segment { get; }
public Transform ActiveBiome { get; }
public List<SpawnerData> Spawners { get; } = new List<SpawnerData>();
public BiomeInfo(BiomeType biomeType, string biomeVariant, Transform segment, Transform activeBiome)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
BiomeType = biomeType;
BiomeVariant = biomeVariant;
Segment = segment;
ActiveBiome = activeBiome;
InitSpawners();
}
public void Clear()
{
foreach (SpawnerData spawner in Spawners)
{
spawner.Clear();
}
Spawners.Clear();
}
private void InitSpawners()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
Spawners.AddRange(SpawnerFinderAndInit.GetSpawnersFromBiomeType(ActiveBiome, BiomeType, BiomeVariant));
}
}
}
namespace HazardSpam.Config
{
public static class ConfigHandler
{
private static ConfigEntry<bool> _configDebug = null;
private static ConfigEntry<float> _configCalderaEruptSpawnMinTime = null;
private static ConfigEntry<float> _configCalderaEruptSpawnMaxTime = null;
private static readonly Dictionary<(BiomeType, BiomeArea, SpawnType), ConfigEntry<int>> SpawnRatesDict = new Dictionary<(BiomeType, BiomeArea, SpawnType), ConfigEntry<int>>();
internal static bool Debug => _configDebug.Value;
internal static float CalderaEruptSpawnMinTime => _configCalderaEruptSpawnMinTime.Value;
internal static float CalderaEruptSpawnMaxTime => _configCalderaEruptSpawnMaxTime.Value;
public static void Init(ConfigFile config)
{
_configDebug = config.Bind<bool>("Debug", "Debug", false, "Enabled debug logging and utils");
_configCalderaEruptSpawnMinTime = config.Bind<float>("CalderaEruption", "SpawnMinTime", -5f, "Minimum time between erupts");
_configCalderaEruptSpawnMaxTime = config.Bind<float>("CalderaEruption", "SpawnMaxTime", 15f, "Maximum time between erupts");
InitSpawnRates(config);
}
private static void InitSpawnRates(ConfigFile config)
{
BindSpawnRates(config, (BiomeType)0, BiomeArea.Plateau, SpawnType.Jellies, 1000);
BindSpawnRates(config, (BiomeType)0, BiomeArea.Wall, SpawnType.Jellies, 2000);
BindSpawnRates(config, (BiomeType)1, BiomeArea.Wall, SpawnType.ExploShrooms, 2000);
BindSpawnRates(config, (BiomeType)1, BiomeArea.Wall, SpawnType.PoisonShrooms, 2000);
BindSpawnRates(config, (BiomeType)2, BiomeArea.WallLeft, SpawnType.LavaRiver, 7);
BindSpawnRates(config, (BiomeType)2, BiomeArea.WallRight, SpawnType.LavaRiver, 7);
BindSpawnRates(config, (BiomeType)2, BiomeArea.WallLeft, SpawnType.Geysers, 150);
BindSpawnRates(config, (BiomeType)2, BiomeArea.WallLeft, SpawnType.FlashPlant, 150);
BindSpawnRates(config, (BiomeType)2, BiomeArea.WallRight, SpawnType.Geysers, 150);
BindSpawnRates(config, (BiomeType)2, BiomeArea.WallRight, SpawnType.FlashPlant, 150);
BindSpawnRates(config, (BiomeType)2, BiomeArea.Plateau, SpawnType.Geysers, 200);
BindSpawnRates(config, (BiomeType)6, BiomeArea.Plateau, SpawnType.CactusBalls, 1500);
BindSpawnRates(config, (BiomeType)6, BiomeArea.Plateau, SpawnType.Tumblers, 3);
BindSpawnRates(config, (BiomeType)6, BiomeArea.Wall, SpawnType.CactusBalls, 1500);
BindSpawnRates(config, (BiomeType)6, BiomeArea.Wall, SpawnType.Dynamite, 200);
BindSpawnRates(config, (BiomeType)6, BiomeArea.Wall, SpawnType.DynamiteOutside, 200);
BindSpawnRates(config, (BiomeType)6, BiomeArea.Wall, SpawnType.Scorpions, 5);
}
private static void BindSpawnRates(ConfigFile config, BiomeType biomeType, BiomeArea area, SpawnType spawnType, int defaultValue)
{
//IL_0005: 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)
string text = $"{biomeType}.{area}-{spawnType}";
ConfigEntry<int> value = config.Bind<int>("SpawnRates", text, defaultValue, "Attempted spawn rate, will not guarantee this amount");
SpawnRatesDict[(biomeType, area, spawnType)] = value;
}
public static int GetSpawnRate(BiomeType biomeType, BiomeArea area, SpawnType spawnType)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
if (!SpawnRatesDict.TryGetValue((biomeType, area, spawnType), out ConfigEntry<int> value))
{
return 0;
}
return value.Value;
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
