using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using AIGraph;
using Agents;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Unity.IL2CPP;
using Enemies;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using LevelGeneration;
using Microsoft.CodeAnalysis;
using SNetwork;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("MushroomSeedFix")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MushroomSeedFix")]
[assembly: AssemblyTitle("MushroomSeedFix")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 MushroomSeedFix
{
internal static class ConfigBindings
{
private static ConfigEntry<int>? sessionSeed;
private static ConfigEntry<int>? enemySeed;
private static ConfigEntry<int>? enemyRotationSeed;
private static ConfigEntry<int>? scoutPathSeed;
private static ConfigEntry<int>? placementSeed;
public static int SessionSeed => sessionSeed?.Value ?? 0;
public static int EnemySeed => enemySeed?.Value ?? 0;
public static int EnemyRotationSeed => enemyRotationSeed?.Value ?? 0;
public static int ScoutPathSeed => scoutPathSeed?.Value ?? 0;
public static int PlacementSeed => placementSeed?.Value ?? 0;
public static void Init(ConfigFile file)
{
sessionSeed = file.Bind<int>("Setup", "SessionSeed", 0, "Session seed. Not used if <= 0");
enemySeed = file.Bind<int>("Setup", "EnemySeed", 0, "Custom fixed seed to use for generating the random seeds for individual enemies which is used for SizeMultiplier. Not used if <= 0");
enemyRotationSeed = file.Bind<int>("Setup", "EnemyRotationSeed", 0, "Custom fixed seed to use for rotating placed enemies. Not used if <= 0");
scoutPathSeed = file.Bind<int>("Setup", "ScoutPathSeed", 0, "Custom fixed seed to use for generating random scout pathing. Not used if <= 0");
placementSeed = file.Bind<int>("Setup", "PlacementSeed", 0, "Custom fixed seed to use for generating the random placements. Not used if <= 0");
}
}
[BepInPlugin("Mushroom.Seed", "MushroomSeed", "1.2.0")]
internal sealed class EntryPoint : BasePlugin
{
private Harmony? harmony;
public override void Load()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
harmony = new Harmony("Mushroom.Seed");
harmony.PatchAll();
ConfigBindings.Init(((BasePlugin)this).Config);
}
public override bool Unload()
{
return ((BasePlugin)this).Unload();
}
}
public static class FixedSeedManager
{
private static Random? enemyRandom;
private static Random? enemyRotationRandom;
private static Random? scoutPathRandom;
private static Random? placementRandom;
internal static void Initialize()
{
int enemySeed = ConfigBindings.EnemySeed;
if (enemySeed > 0)
{
enemyRandom = new Random(enemySeed);
}
else
{
enemyRandom = null;
}
int enemyRotationSeed = ConfigBindings.EnemyRotationSeed;
if (enemyRotationSeed > 0)
{
enemyRotationRandom = new Random(enemyRotationSeed);
}
else
{
enemyRotationRandom = null;
}
int scoutPathSeed = ConfigBindings.ScoutPathSeed;
if (scoutPathSeed > 0)
{
scoutPathRandom = new Random(scoutPathSeed);
}
else
{
scoutPathRandom = null;
}
int placementSeed = ConfigBindings.PlacementSeed;
if (placementSeed > 0)
{
placementRandom = new Random(placementSeed);
}
else
{
placementRandom = null;
}
}
public static Vector3 GetRandomScoutPathPosition(AIG_NodeCluster nodeCluster)
{
//IL_0059: 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)
if (scoutPathRandom == null)
{
Debug.Log(Object.op_Implicit("No RandomScoutPathRandom"));
return nodeCluster.m_nodes[Random.Range(0, nodeCluster.m_nodes.Count)].Position;
}
return nodeCluster.m_nodes[scoutPathRandom.Next(0, nodeCluster.m_nodes.Count)].Position;
}
public static Vector2 GetRandomEnemyRotation()
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
if (enemyRotationRandom == null)
{
Debug.Log(Object.op_Implicit("No EnemyRotationRandom"));
return Random.insideUnitCircle;
}
(double Sin, double Cos) tuple = Math.SinCos((double)enemyRotationRandom.NextInt64(0L, long.MaxValue) / 9.223372036854776E+18 * Math.PI * 2.0);
var (num, _) = tuple;
return new Vector2((float)tuple.Cos, (float)num);
}
public static ushort GetRandomEnemySeed()
{
if (enemyRandom == null)
{
Debug.Log(Object.op_Implicit("No EnemyRandom"));
return (ushort)Random.Range(0, 65535);
}
return (ushort)enemyRandom.Next(0, 65535);
}
public static float GetRandomPlacementHeat()
{
if (placementRandom == null)
{
Debug.Log(Object.op_Implicit("No PlacementRandom"));
return Random.value;
}
return (float)placementRandom.Next(0, int.MaxValue) / 2.1474836E+09f;
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "Mushroom.Seed";
public const string PLUGIN_NAME = "MushroomSeed";
public const string PLUGIN_VERSION = "1.2.0";
public const string AUTHOR = "time1pm & flaff";
public const string BRANCH = "beta";
public const string INTERNAL_VERSION = "000011";
}
}
namespace MushroomSeedFix.Patches
{
[HarmonyPatch]
internal static class EnemyGroup_RandomRotationPatch
{
[HarmonyPatch(typeof(EnemyGroup), "GetRandomRotation")]
[HarmonyPrefix]
[HarmonyWrapSafe]
public static bool Patch(ref Quaternion __result)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: 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_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_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)
EnemyGroup.s_randomRot2D = FixedSeedManager.GetRandomEnemyRotation();
__result = Quaternion.LookRotation(new Vector3(EnemyGroup.s_randomRot2D.x, 0f, EnemyGroup.s_randomRot2D.y), Vector3.up);
return false;
}
}
[HarmonyPatch]
internal static class InLobbyPatch
{
[HarmonyPatch(typeof(GS_Lobby), "Enter")]
[HarmonyPrefix]
[HarmonyWrapSafe]
public static void EnterLobby()
{
FixedSeedManager.Initialize();
}
}
[HarmonyPatch]
internal static class Scorer_ValidNodePatch
{
[HarmonyPatch(typeof(AIG_NodeCluster), "Scorer_ValidNode")]
[HarmonyPrefix]
public static bool Patch(AIG_NodeCluster __instance, AIG_INode node, ref float __result)
{
if (node.HasSpecialTraversal || node.BelongsToGate)
{
__instance.m_nodesToSpreadFrom.Enqueue(node);
__result = -10f;
return false;
}
if (!node.IsVoxelNode)
{
__result = -10f;
return false;
}
int count = node.Links.Count;
float num = 1f - Mathf.Clamp01((float)count / 3f);
float randomPlacementHeat = FixedSeedManager.GetRandomPlacementHeat();
node.PlacementHeat = num + randomPlacementHeat;
__result = node.PlacementHeat;
return false;
}
}
[HarmonyPatch]
internal static class ScoutPatrolPathPatch
{
private static bool patch;
[HarmonyPatch(typeof(EnemyGroup), "GetScoutPath")]
[HarmonyPrefix]
[HarmonyWrapSafe]
public static void PrefixScoutPath()
{
patch = true;
}
[HarmonyPatch(typeof(EnemyGroup), "GetScoutPath")]
[HarmonyPostfix]
[HarmonyWrapSafe]
public static void PostfixScoutPath()
{
patch = false;
}
[HarmonyPatch(typeof(AIG_NodeCluster), "GetRandomPosition")]
[HarmonyPrefix]
[HarmonyWrapSafe]
public static bool GetRandomPosition(AIG_NodeCluster __instance, ref Vector3 __result)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
if (patch)
{
__result = FixedSeedManager.GetRandomScoutPathPosition(__instance);
return false;
}
return true;
}
}
[HarmonyPatch]
internal static class SerialGeneratorPatch
{
[HarmonyPatch(typeof(SerialGenerator), "Generate")]
[HarmonyPrefix]
[HarmonyWrapSafe]
public static bool Generate()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
SeedRandom val = new SeedRandom("SerialGeneratorSeed")
{
Seed = RundownManager.ActiveExpedition.SessionSeed
};
Debug.Log(Object.op_Implicit(Deb.LG("SerialGenerator GENERATE! SessionRandom.seed: " + val.Seed, 0f)));
SerialGenerator.m_serialStep = 0;
SerialGenerator.m_codeWordStep = 0;
SerialGenerator.m_ipStep = 0;
for (int i = 0; i < SerialGenerator.m_maxCount; i++)
{
((Il2CppArrayBase<int>)(object)SerialGenerator.m_serials)[i] = 100 + i;
}
int length = ((Il2CppArrayBase<string>)(object)SerialGenerator.m_codeWords).Length;
SerialGenerator.m_codeWordIndex = Il2CppStructArray<int>.op_Implicit(new int[length]);
for (int j = 0; j < length; j++)
{
((Il2CppArrayBase<int>)(object)SerialGenerator.m_codeWordIndex)[j] = j;
}
int length2 = ((Il2CppArrayBase<string>)(object)SerialGenerator.m_codeWordPrefixes).Length;
SerialGenerator.m_codeWordPrefixIndex = Il2CppStructArray<int>.op_Implicit(new int[length2]);
for (int k = 0; k < length2; k++)
{
((Il2CppArrayBase<int>)(object)SerialGenerator.m_codeWordPrefixIndex)[k] = k;
}
SerialGenerator.m_ips = Il2CppStringArray.op_Implicit(new string[99]);
for (int l = 0; l < ((Il2CppArrayBase<string>)(object)SerialGenerator.m_ips).Length; l++)
{
int num = val.Range(100, 255, "NO_TAG");
int num2 = val.Range(50, 255, "NO_TAG");
int num3 = val.Range(0, 255, "NO_TAG");
int num4 = val.Range(0, 255, "NO_TAG");
((Il2CppArrayBase<string>)(object)SerialGenerator.m_ips)[l] = num + "." + num2 + "." + num3 + "." + num4;
}
val.ShuffleArray<int>((Il2CppArrayBase<int>)(object)SerialGenerator.m_serials);
val.ShuffleArray<int>((Il2CppArrayBase<int>)(object)SerialGenerator.m_codeWordIndex);
val.ShuffleArray<int>((Il2CppArrayBase<int>)(object)SerialGenerator.m_codeWordPrefixIndex);
return false;
}
}
[HarmonyPatch]
internal static class SessionSeedPatch
{
[HarmonyPatch(typeof(Builder), "SetSessionIDSeed")]
[HarmonyPrefix]
[HarmonyWrapSafe]
public static void SetSessionSeed(ref int forcedSeed)
{
forcedSeed = ConfigBindings.SessionSeed;
}
}
[HarmonyPatch]
internal static class SpawnEnemyPatch
{
[HarmonyPatch(typeof(EnemyAllocator), "SpawnEnemy")]
[HarmonyPrefix]
[HarmonyWrapSafe]
public static bool SpawnEnemy(EnemyAllocator __instance, uint persistantID, AIG_CourseNode courseNode, AgentMode mode, Vector3 position, Quaternion rotation, EnemyGroup? group, int placementIndex, ref EnemyAgent? __result)
{
//IL_0002: 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_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: 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)
pEnemySpawnData val = default(pEnemySpawnData);
val.HealthRel = 1f;
val.AttachedGlueRel = 0f;
val.placementIndex = placementIndex;
GameObject val2;
if (!__instance.m_enemyTypeLookup.ContainsKey(persistantID) || (Object)(object)(val2 = __instance.m_enemyTypeLookup[persistantID]) == (Object)null)
{
Debug.LogError(Object.op_Implicit("No prefabs with ID " + persistantID));
__result = null;
return false;
}
((pEnemySpawnData)(ref val)).Position = position;
((pEnemySpawnData)(ref val)).Rotation = rotation;
((pCourseNode)(ref val.courseNode)).Set(courseNode);
val.mode = mode;
val.seed = FixedSeedManager.GetRandomEnemySeed();
if ((Object)(object)group != (Object)null)
{
val.groupReplicatorKey = group.Replicator.Key;
}
else
{
val.groupReplicatorKey = 0;
}
((SNet_ReplicationManager<pEnemySpawnData, EnemyReplicator>)(object)__instance.m_enemyReplicationManager).Spawn(val2, val);
__result = __instance.m_spawnedEnemyAgent;
return false;
}
}
}
