using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using MenuLib;
using MenuLib.MonoBehaviors;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Larsielol")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("RepoSeeded")]
[assembly: AssemblyTitle("RepoSeeded")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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 RepoSeeded
{
[HarmonyPatch(typeof(EnemyDirector))]
internal static class EnemyRNGPatch
{
[HarmonyPrefix]
[HarmonyPatch("PickEnemies")]
private static bool EnemyTypeRNGSeeder(List<EnemySetup> _enemiesList)
{
Random.InitState(RepoSeeded.EnemyTypeRandom.Next());
int num = DataDirector.instance.SettingValueFetch((Setting)31);
ListExtension.Shuffle<EnemySetup>((IList<EnemySetup>)_enemiesList);
EnemySetup item = null;
float num2 = -1f;
foreach (EnemySetup _enemies in _enemiesList)
{
if (_enemies.levelsCompletedCondition && (RunManager.instance.levelsCompleted < _enemies.levelsCompletedMin || RunManager.instance.levelsCompleted > _enemies.levelsCompletedMax))
{
continue;
}
int num3 = 0;
foreach (EnemySetup item2 in RunManager.instance.enemiesSpawned)
{
if ((Object)(object)item2 == (Object)(object)_enemies)
{
num3++;
}
}
float num4 = 100f;
if (Object.op_Implicit((Object)(object)_enemies.rarityPreset))
{
num4 = _enemies.rarityPreset.chance;
}
float num5 = Mathf.Max(0f, num4 - 30f * (float)num3);
float num6 = Random.Range(0f, num5);
if (num6 > num2)
{
item = _enemies;
num2 = num6;
}
}
EnemyDirector.instance.enemyList.Add(item);
RepoSeeded.EnemyOrbRandoms.Clear();
return false;
}
[HarmonyPrefix]
[HarmonyPatch("Start")]
private static bool EnemyIdleRNGGSeeder()
{
Random.InitState(RepoSeeded.LevelRandom.Next());
return true;
}
[HarmonyPostfix]
[HarmonyPatch("Start")]
private static void EnemyIdleRNGGChecker()
{
Debug.LogError((object)("Current idle timer: " + EnemyDirector.instance.spawnIdlePauseTimer));
}
}
[HarmonyPatch(typeof(RunManager))]
internal static class LevelAreaRNGPatch
{
[HarmonyPrefix]
[HarmonyPatch("SetRunLevel")]
private static void LevelAreaRNGSeeder(ref Level ___previousRunLevel, ref Level ___levelCurrent, int ___levelsCompleted)
{
Debug.LogWarning((object)"LevelAreaRngpatch");
if (___levelsCompleted == 0)
{
___previousRunLevel = null;
___levelCurrent = null;
}
if (!RepoSeeded.JustHijackedTheSave)
{
RepoSeeded.saveRandoms();
Debug.LogError((object)"Didnt just hijack");
}
else
{
RepoSeeded.JustHijackedTheSave = false;
}
Debug.LogWarning((object)"Randoms right now:");
Debug.LogWarning((object)RepoSeeded.ValuableTypeSeed);
Debug.LogWarning((object)RepoSeeded.LevelSeed);
Debug.LogWarning((object)RepoSeeded.ShopSeed);
Debug.LogWarning((object)RepoSeeded.EnemyTypeSeed);
Debug.LogWarning((object)RepoSeeded.EnemyOrbSeed);
Random.InitState(RepoSeeded.LevelRandom.Next());
}
}
[HarmonyPatch(typeof(LevelGenerator))]
internal static class LevelLayoutRNGPatch
{
[HarmonyPrefix]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
private static void LevelGenerationRNGSeederTiles()
{
_ = RepoSeeded.JustHijackedTheSave;
Random.InitState(RepoSeeded.LevelRandom.Next());
RepoSeeded.TruckTextRandom = new Random(RepoSeeded.LevelRandom.Next());
}
[HarmonyPrefix]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
private static void LevelGenerationRNGSeederModules()
{
Random.InitState(RepoSeeded.LevelRandom.Next());
}
}
[HarmonyPatch(typeof(EnemyParent))]
internal static class OrbValueRNGPatch
{
[HarmonyPrefix]
[HarmonyPatch("Despawn")]
private static bool RemoveValueRNG(EnemyParent __instance)
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_0184: Unknown result type (might be due to invalid IL or missing references)
//IL_018a: Invalid comparison between Unknown and I4
//IL_019a: Unknown result type (might be due to invalid IL or missing references)
//IL_01a0: Invalid comparison between Unknown and I4
//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
//IL_01db: Unknown result type (might be due to invalid IL or missing references)
Debug.LogError((object)"RemoveValueRNG");
Random.InitState(RepoSeeded.EnemyOrbRandom.Next());
Debug.LogWarning((object)("Set the orb of a thing called " + ((Object)((Component)__instance).gameObject).name));
if (GameManager.Multiplayer() && !PhotonNetwork.IsMasterClient)
{
return false;
}
__instance.Enemy.CurrentState = (EnemyState)11;
__instance.DespawnedTimer = Random.Range(__instance.DespawnedTimeMin, __instance.DespawnedTimeMax) * EnemyDirector.instance.despawnedDecreaseMultiplier * EnemyDirector.instance.despawnedTimeMultiplier;
__instance.DespawnedTimer = Mathf.Max(__instance.DespawnedTimer, 1f);
if (__instance.Enemy.HasRigidbody)
{
__instance.Enemy.Rigidbody.grabbed = false;
__instance.Enemy.Rigidbody.grabStrengthTimer = 0f;
__instance.Enemy.Rigidbody.GrabRelease(true, 0.1f);
}
if (GameManager.Multiplayer())
{
((MonoBehaviourPun)__instance).photonView.RPC("DespawnRPC", (RpcTarget)0, Array.Empty<object>());
}
else
{
__instance.DespawnRPC(default(PhotonMessageInfo));
}
if (!__instance.Enemy.HasHealth || __instance.Enemy.Health.healthCurrent > 0)
{
return false;
}
if (__instance.Enemy.Health.spawnValuable && __instance.valuableSpawnTimer > 0f && __instance.Enemy.Health.spawnValuableCurrent < __instance.Enemy.Health.spawnValuableMax)
{
GameObject val = AssetManager.instance.enemyValuableSmall;
if ((int)__instance.difficulty == 1)
{
val = AssetManager.instance.enemyValuableMedium;
}
else if ((int)__instance.difficulty == 2)
{
val = AssetManager.instance.enemyValuableBig;
}
Transform val2 = __instance.Enemy.CustomValuableSpawnTransform;
if (!Object.op_Implicit((Object)(object)val2))
{
val2 = __instance.Enemy.CenterTransform;
}
GameObject val3 = (SemiFunc.IsMultiplayer() ? PhotonNetwork.InstantiateRoomObject("Valuables/" + ((Object)val).name, val2.position, Quaternion.identity, (byte)0, (object[])null) : Object.Instantiate<GameObject>(val, val2.position, Quaternion.identity));
EnemyHealth health = __instance.Enemy.Health;
health.spawnValuableCurrent++;
ValuableObject component = val3.GetComponent<ValuableObject>();
Random.InitState(RepoSeeded.EnemyOrbRandoms[__instance].Next());
component.DollarValueSetLogic();
Debug.LogError((object)("Set value of orb to $" + component.dollarValueCurrent + "\nEnding at random " + RepoSeeded.EnemyOrbRandoms[__instance].Next()));
}
__instance.DespawnedTimer *= 3f;
return false;
}
}
[HarmonyPatch(typeof(LevelGenerator))]
internal static class AddEnemiesToOrbRNG
{
[HarmonyPrefix]
[HarmonyPatch("EnemySpawn")]
private static bool getAllEnemiesIntoList(ref EnemySetup enemySetup, ref Vector3 position)
{
//IL_0045: 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_002d: 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)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
foreach (PrefabRef spawnObject in enemySetup.spawnObjects)
{
GameObject val = ((GameManager.instance.gameMode != 0) ? PhotonNetwork.InstantiateRoomObject(spawnObject.ResourcePath, position, Quaternion.identity, (byte)0, (object[])null) : Object.Instantiate<GameObject>(spawnObject.Prefab, position, Quaternion.identity));
EnemyParent component = val.GetComponent<EnemyParent>();
if (Object.op_Implicit((Object)(object)component))
{
RepoSeeded.EnemyOrbRandoms.Add(component, new Random(RepoSeeded.EnemyOrbRandom.Next()));
component.SetupDone = true;
val.GetComponentInChildren<Enemy>().EnemyTeleported(position);
LevelGenerator instance = LevelGenerator.Instance;
instance.EnemiesSpawnTarget++;
EnemyDirector.instance.FirstSpawnPointAdd(component);
}
}
return false;
}
}
[BepInPlugin("Larsielol.RepoSeeded", "RepoSeeded", "2.3.0")]
public class RepoSeeded : BaseUnityPlugin
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static Action<string> <>9__31_3;
public static ScrollViewBuilderDelegate <>9__31_2;
public static Action <>9__31_1;
public static BuilderDelegate <>9__31_0;
internal void <Awake>b__31_0(Transform parent)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
REPOButton val = MenuAPI.CreateREPOButton("Input Seed", (Action)delegate
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
REPOPopupPage val3 = MenuAPI.CreateREPOPopupPage("Seed Menu", (PresetSide)0, false, true, 1.5f);
object obj = <>9__31_2;
if (obj == null)
{
ScrollViewBuilderDelegate val4 = delegate(Transform scrollView)
{
//IL_002d: 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)
Action<string> obj2 = delegate(string newSeed)
{
setSeed(newSeed);
};
string currentSeed = RepoSeeded.currentSeed;
REPOInputField val5 = MenuAPI.CreateREPOInputField("Seed", obj2, scrollView, default(Vector2), false, "", currentSeed);
return ((REPOElement)val5).rectTransform;
};
<>9__31_2 = val4;
obj = (object)val4;
}
val3.AddElementToScrollView((ScrollViewBuilderDelegate)obj, 0f, 0f);
val3.OpenPage(false);
}, parent, new Vector2(50f, 95f));
Transform val2 = parent.Find("Menu Button - Tutorial");
((Component)val2).gameObject.SetActive(false);
}
internal void <Awake>b__31_1()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
REPOPopupPage val = MenuAPI.CreateREPOPopupPage("Seed Menu", (PresetSide)0, false, true, 1.5f);
object obj = <>9__31_2;
if (obj == null)
{
ScrollViewBuilderDelegate val2 = delegate(Transform scrollView)
{
//IL_002d: 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)
Action<string> obj2 = delegate(string newSeed)
{
setSeed(newSeed);
};
string currentSeed = RepoSeeded.currentSeed;
REPOInputField val3 = MenuAPI.CreateREPOInputField("Seed", obj2, scrollView, default(Vector2), false, "", currentSeed);
return ((REPOElement)val3).rectTransform;
};
<>9__31_2 = val2;
obj = (object)val2;
}
val.AddElementToScrollView((ScrollViewBuilderDelegate)obj, 0f, 0f);
val.OpenPage(false);
}
internal RectTransform <Awake>b__31_2(Transform scrollView)
{
//IL_002d: 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)
Action<string> obj = delegate(string newSeed)
{
setSeed(newSeed);
};
string currentSeed = RepoSeeded.currentSeed;
REPOInputField val = MenuAPI.CreateREPOInputField("Seed", obj, scrollView, default(Vector2), false, "", currentSeed);
return ((REPOElement)val).rectTransform;
}
internal void <Awake>b__31_3(string newSeed)
{
setSeed(newSeed);
}
}
internal static bool JustHijackedTheSave = true;
internal static Random ValuableTypeRandom = new Random(1);
internal static Random ValuableCostRandom = new Random(1);
internal static Random LevelRandom = new Random(1);
internal static Random ShopRandom = new Random(1);
internal static Random EnemyTypeRandom = new Random(1);
internal static Random EnemyOrbRandom = new Random(1);
internal static Random TruckTextRandom = new Random(1);
internal static Dictionary<EnemyParent, Random> EnemyOrbRandoms = new Dictionary<EnemyParent, Random>();
internal static int ValuableTypeSeed = 1;
internal static int ValuableCostSeed = 1;
internal static int LevelSeed = 1;
internal static int ShopSeed = 1;
internal static int EnemyTypeSeed = 1;
internal static int EnemyOrbSeed = 1;
internal static int TruckTextSeed = 1;
public static string currentSeed = "1";
internal static RepoSeeded Instance { get; private set; } = null;
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal Harmony? Harmony { get; set; }
public static void setSeed(string seed)
{
SHA256 sHA = SHA256.Create();
seed = seed.Replace(" ", "");
int num = 1;
try
{
num = int.Parse(seed);
}
catch (FormatException)
{
byte[] array = sHA.ComputeHash(Encoding.UTF8.GetBytes(seed));
num = BitConverter.ToInt32(array);
}
ValuableTypeRandom = new Random(num);
ValuableCostRandom = new Random(num + 1);
LevelRandom = new Random(num + 2);
ShopRandom = new Random(num + 3);
EnemyTypeRandom = new Random(num + 4);
EnemyOrbRandom = new Random(num + 5);
TruckTextRandom = new Random(num + 6);
if (Object.op_Implicit((Object)(object)RunManager.instance))
{
RunManager.instance.enemiesSpawned = new List<EnemySetup>();
}
currentSeed = seed;
Debug.LogError((object)("Set the new seed to: " + seed + "\n"));
}
public static void saveRandoms()
{
ValuableTypeSeed = ValuableTypeRandom.Next();
ValuableTypeRandom = new Random(ValuableTypeSeed);
ValuableCostSeed = ValuableCostRandom.Next();
ValuableCostRandom = new Random(ValuableCostSeed);
LevelSeed = LevelRandom.Next();
LevelRandom = new Random(LevelSeed);
ShopSeed = ShopRandom.Next();
ShopRandom = new Random(ShopSeed);
EnemyTypeSeed = EnemyTypeRandom.Next();
EnemyTypeRandom = new Random(EnemyTypeSeed);
EnemyOrbSeed = EnemyOrbRandom.Next();
EnemyOrbRandom = new Random(EnemyOrbSeed);
}
private void Awake()
{
//IL_0048: 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_0053: Expected O, but got Unknown
Instance = this;
setSeed(currentSeed);
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
Patch();
object obj = <>c.<>9__31_0;
if (obj == null)
{
BuilderDelegate val = delegate(Transform parent)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
REPOButton val2 = MenuAPI.CreateREPOButton("Input Seed", (Action)delegate
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
REPOPopupPage val4 = MenuAPI.CreateREPOPopupPage("Seed Menu", (PresetSide)0, false, true, 1.5f);
object obj2 = <>c.<>9__31_2;
if (obj2 == null)
{
ScrollViewBuilderDelegate val5 = delegate(Transform scrollView)
{
//IL_002d: 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)
Action<string> obj3 = delegate(string newSeed)
{
setSeed(newSeed);
};
string text = currentSeed;
REPOInputField val6 = MenuAPI.CreateREPOInputField("Seed", obj3, scrollView, default(Vector2), false, "", text);
return ((REPOElement)val6).rectTransform;
};
<>c.<>9__31_2 = val5;
obj2 = (object)val5;
}
val4.AddElementToScrollView((ScrollViewBuilderDelegate)obj2, 0f, 0f);
val4.OpenPage(false);
}, parent, new Vector2(50f, 95f));
Transform val3 = parent.Find("Menu Button - Tutorial");
((Component)val3).gameObject.SetActive(false);
};
<>c.<>9__31_0 = val;
obj = (object)val;
}
MenuAPI.AddElementToMainMenu((BuilderDelegate)obj);
Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
}
internal void Patch()
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
//IL_0025: Expected O, but got Unknown
if (Harmony == null)
{
Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
Harmony val2 = val;
Harmony = val;
}
Harmony.PatchAll();
}
internal void Unpatch()
{
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private void Update()
{
}
}
[HarmonyPatch(typeof(MenuPageSaves))]
internal static class RNGSetterOnGameStart
{
[HarmonyPrefix]
[HarmonyPatch("OnNewGame")]
private static void setSeedOnNewGame()
{
RepoSeeded.setSeed(RepoSeeded.currentSeed);
}
}
[HarmonyPatch(typeof(StatsManager))]
internal static class SaveHijack
{
private const string saveName = "R.E.P.O. SEEDED";
private static StatsManager sm = StatsManager.instance;
[HarmonyPostfix]
[HarmonyPatch("SaveGame")]
private static void InjectOwnRNGSaveData(ref string fileName)
{
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Expected O, but got Unknown
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
if (string.IsNullOrEmpty(fileName) || !SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
sm.dateAndTime = DateTime.Now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
string text = Application.persistentDataPath + "/saves";
if (!Directory.Exists(text))
{
Directory.CreateDirectory(text);
}
string text2 = text + "/" + fileName;
if (!Directory.Exists(text2))
{
Directory.CreateDirectory(text2);
}
string text3 = text2 + "/" + fileName + ".es3";
if (File.Exists(text3))
{
StatsManager obj = sm;
obj.backupIndex++;
string destFileName = text2 + "/" + fileName + "_BACKUP" + sm.backupIndex + ".es3";
File.Move(text3, destFileName);
}
ES3Settings val = new ES3Settings(new Enum[1] { (Enum)(object)(Location)4 });
val.encryptionType = (EncryptionType)1;
val.encryptionPassword = sm.totallyNormalString;
val.path = text3;
ES3.Save<string>("teamName", "R.E.P.O. SEEDED", val);
ES3.Save<string>("dateAndTime", "Seed: " + RepoSeeded.currentSeed, val);
ES3.Save<float>("timePlayed", sm.timePlayed, val);
ES3.Save<Dictionary<string, string>>("playerNames", sm.playerNames, val);
Debug.LogWarning((object)"Saving:");
Debug.LogWarning((object)RepoSeeded.ValuableTypeSeed);
Debug.LogWarning((object)RepoSeeded.LevelSeed);
Debug.LogWarning((object)RepoSeeded.ShopSeed);
Debug.LogWarning((object)RepoSeeded.EnemyTypeSeed);
Debug.LogWarning((object)RepoSeeded.EnemyOrbSeed);
ES3.Save<int>("ValuableTypeRandom", RepoSeeded.ValuableTypeSeed, val);
ES3.Save<int>("ValuableCostRandom", RepoSeeded.ValuableCostSeed, val);
ES3.Save<int>("LevelRandom", RepoSeeded.LevelSeed, val);
ES3.Save<int>("ShopRandom", RepoSeeded.ShopSeed, val);
ES3.Save<int>("EnemyTypeRandom", RepoSeeded.EnemyTypeSeed, val);
ES3.Save<int>("EnemyOrbRandom", RepoSeeded.EnemyOrbSeed, val);
ES3.Save<int>("TruckTextRandom", RepoSeeded.TruckTextSeed, val);
Dictionary<string, Dictionary<string, int>> dictionary = new Dictionary<string, Dictionary<string, int>>();
foreach (KeyValuePair<string, Dictionary<string, int>> dictionaryOfDictionary in sm.dictionaryOfDictionaries)
{
if (sm.doNotSaveTheseDictionaries.Contains(dictionaryOfDictionary.Key))
{
continue;
}
if (sm.stripTheseDictionaries.Contains(dictionaryOfDictionary.Key))
{
dictionary[dictionaryOfDictionary.Key] = dictionaryOfDictionary.Value.Where<KeyValuePair<string, int>>((KeyValuePair<string, int> x) => x.Value != 0).ToDictionary<KeyValuePair<string, int>, string, int>((KeyValuePair<string, int> x) => x.Key, (KeyValuePair<string, int> x) => x.Value);
}
else
{
dictionary[dictionaryOfDictionary.Key] = dictionaryOfDictionary.Value;
}
}
ES3.Save<Dictionary<string, Dictionary<string, int>>>("dictionaryOfDictionaries", dictionary, val);
ES3.StoreCachedFile(val);
sm.PlayersAddAll();
sm.saveFileReady = true;
}
[HarmonyPostfix]
[HarmonyPatch("LoadGame")]
public static void GetInjectedSaveData(string fileName, ref List<string> backupList)
{
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Expected O, but got Unknown
if (!SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
string text = Application.persistentDataPath + "/saves/" + fileName + "/" + fileName + ".es3";
if (File.Exists(text))
{
sm.saveFileCurrent = fileName;
ES3Settings val = new ES3Settings(text, (EncryptionType)1, sm.totallyNormalString, (ES3Settings)null);
sm.teamName = ES3.Load<string>("teamName", (string)null, "R.E.P.O.", val);
sm.dateAndTime = ES3.Load<string>("dateAndTime", (string)null, DateTime.Now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture), val);
sm.timePlayed = ES3.Load<float>("timePlayed", (string)null, 0f, val);
sm.playerNames = ES3.Load<Dictionary<string, string>>("playerNames", (string)null, new Dictionary<string, string>(), val);
if (sm.teamName == "R.E.P.O. SEEDED")
{
RepoSeeded.currentSeed = sm.dateAndTime.Substring(6);
RepoSeeded.ValuableTypeSeed = ES3.Load<int>("ValuableTypeRandom", (string)null, -1, val);
RepoSeeded.ValuableTypeRandom = new Random(RepoSeeded.ValuableTypeSeed);
RepoSeeded.ValuableCostSeed = ES3.Load<int>("ValuableCostRandom", (string)null, -1, val);
RepoSeeded.ValuableCostRandom = new Random(RepoSeeded.ValuableCostSeed);
RepoSeeded.LevelSeed = ES3.Load<int>("LevelRandom", (string)null, -1, val);
RepoSeeded.LevelRandom = new Random(RepoSeeded.LevelSeed);
RepoSeeded.ShopSeed = ES3.Load<int>("ShopRandom", (string)null, -1, val);
RepoSeeded.ShopRandom = new Random(RepoSeeded.ShopSeed);
RepoSeeded.EnemyTypeSeed = ES3.Load<int>("EnemyTypeRandom", (string)null, -1, val);
RepoSeeded.TruckTextSeed = ES3.Load<int>("TruckTextRandom", (string)null, -1, val);
RepoSeeded.TruckTextRandom = new Random(RepoSeeded.TruckTextSeed);
if (RepoSeeded.EnemyTypeSeed == -1)
{
Debug.LogError((object)"ITS NEGATIVE ONE!! ENEMYTYPE SEED IS -1");
}
RepoSeeded.EnemyTypeRandom = new Random(RepoSeeded.EnemyTypeSeed);
RepoSeeded.EnemyOrbSeed = ES3.Load<int>("EnemyOrbRandom", (string)null, -1, val);
RepoSeeded.EnemyOrbRandom = new Random(RepoSeeded.EnemyOrbSeed);
RunManager.instance.enemiesSpawned = new List<EnemySetup>();
RepoSeeded.JustHijackedTheSave = true;
Debug.LogWarning((object)"Loaded:");
Debug.LogWarning((object)RepoSeeded.ValuableTypeSeed);
Debug.LogWarning((object)RepoSeeded.LevelSeed);
Debug.LogWarning((object)RepoSeeded.ShopSeed);
Debug.LogWarning((object)RepoSeeded.EnemyTypeSeed);
Debug.LogWarning((object)RepoSeeded.EnemyOrbSeed);
Debug.LogWarning((object)RepoSeeded.TruckTextSeed);
}
foreach (KeyValuePair<string, Dictionary<string, int>> item in ES3.Load<Dictionary<string, Dictionary<string, int>>>("dictionaryOfDictionaries", (string)null, new Dictionary<string, Dictionary<string, int>>(), val))
{
if (sm.dictionaryOfDictionaries.TryGetValue(item.Key, out var value))
{
foreach (KeyValuePair<string, int> item2 in item.Value)
{
value[item2.Key] = item2.Value;
}
}
else
{
sm.dictionaryOfDictionaries.Add(item.Key, new Dictionary<string, int>(item.Value));
}
}
}
else
{
Debug.LogWarning((object)("Save file not found in " + text));
}
RunManager.instance.levelsCompleted = sm.GetRunStatLevel();
RunManager.instance.runLives = sm.GetRunStatLives();
RunManager.instance.loadLevel = sm.GetRunStatSaveLevel();
sm.PlayersAddAll();
if (backupList == null)
{
backupList = sm.SaveFileGetBackups(fileName, Application.persistentDataPath + "/saves");
}
if (backupList.Count > 0)
{
Match match = Regex.Match(backupList[0], "_BACKUP(\\d+)$");
sm.backupIndex = (match.Success ? int.Parse(match.Groups[1].Value) : 0);
}
else
{
sm.backupIndex = 0;
}
sm.saveFileReady = true;
}
}
[HarmonyPatch(typeof(RunManager))]
internal static class SetNewSeedToPreviousSeed
{
[HarmonyPostfix]
[HarmonyPatch("ResetProgress")]
private static void setSeedOnNewAutoRun()
{
RepoSeeded.setSeed(RepoSeeded.currentSeed);
RepoSeeded.JustHijackedTheSave = true;
}
[HarmonyPostfix]
[HarmonyPatch("LeaveToMainMenu")]
private static void setSeedWhenBackToMenu()
{
RepoSeeded.setSeed(RepoSeeded.currentSeed);
RepoSeeded.JustHijackedTheSave = true;
}
}
[HarmonyPatch(typeof(ShopManager))]
internal static class ShopRNGPatch
{
private const string placeholderName = "REPOSEEDED PLACEHOLDER";
private static ShopManager sm = ShopManager.instance;
[HarmonyPatch("GetAllItemsFromStatsManager")]
[HarmonyPrefix]
private static bool GetAlllItemsPrefix()
{
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Invalid comparison between Unknown and I4
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Invalid comparison between Unknown and I4
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Invalid comparison between Unknown and I4
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_012c: Invalid comparison between Unknown and I4
//IL_0131: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Invalid comparison between Unknown and I4
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_0142: Invalid comparison between Unknown and I4
//IL_0207: Unknown result type (might be due to invalid IL or missing references)
//IL_022b: Unknown result type (might be due to invalid IL or missing references)
//IL_025c: Unknown result type (might be due to invalid IL or missing references)
//IL_0242: Unknown result type (might be due to invalid IL or missing references)
Debug.LogError((object)"ShouPGet");
Random.InitState(RepoSeeded.ShopRandom.Next());
if (SemiFunc.IsNotMasterClient())
{
return false;
}
sm.potentialItems.Clear();
sm.potentialItemConsumables.Clear();
sm.potentialItemUpgrades.Clear();
sm.potentialItemHealthPacks.Clear();
sm.potentialSecretItems.Clear();
sm.itemConsumablesAmount = Random.Range(4, 6);
Item[] array = sortItemsOnName(StatsManager.instance.itemDictionary.Values);
foreach (Item val in array)
{
Item val2 = val;
int num = SemiFunc.StatGetItemsPurchased(((Object)val2).name);
float num2 = val2.value.valueMax / 1000f * sm.itemValueMultiplier;
if ((int)val2.itemType == 3)
{
num2 = sm.UpgradeValueGet(num2, val2);
}
else if ((int)val2.itemType == 8)
{
num2 = sm.HealthPackValueGet(num2);
}
else if ((int)val2.itemType == 5)
{
num2 = sm.CrystalValueGet(num2);
}
float num3 = Mathf.Clamp(num2, 1f, num2);
bool flag = (int)val2.itemType == 5;
bool flag2 = (int)val2.itemType == 3;
bool flag3 = (int)val2.itemType == 8;
int maxAmountInShop = val2.maxAmountInShop;
if (num >= maxAmountInShop || (val2.maxPurchase && StatsManager.instance.GetItemsUpgradesPurchasedTotal(((Object)val2).name) >= val2.maxPurchaseAmount))
{
RepoSeeded.Logger.LogInfo((object)val2.itemName);
val2 = null;
}
for (int j = 0; j < maxAmountInShop; j++)
{
if ((Object)(object)val2 != (Object)null && j >= maxAmountInShop - num)
{
RepoSeeded.Logger.LogInfo((object)"PLACEHOLDERED item: ");
RepoSeeded.Logger.LogInfo((object)val2.itemName);
val2 = null;
}
if (flag2)
{
sm.potentialItemUpgrades.Add(val2);
continue;
}
if (flag3)
{
sm.potentialItemHealthPacks.Add(val2);
continue;
}
if (flag)
{
sm.potentialItemConsumables.Add(val2);
continue;
}
if ((int)val.itemSecretShopType == 0)
{
sm.potentialItems.Add(val2);
continue;
}
if (!sm.potentialSecretItems.ContainsKey(val.itemSecretShopType))
{
sm.potentialSecretItems.Add(val.itemSecretShopType, new List<Item>());
}
sm.potentialSecretItems[val.itemSecretShopType].Add(val2);
}
}
ListExtension.Shuffle<Item>((IList<Item>)sm.potentialItems);
for (int num4 = sm.potentialItems.Count - 1; num4 >= 0; num4--)
{
if ((Object)(object)sm.potentialItems[num4] == (Object)null)
{
RepoSeeded.Logger.LogInfo((object)"Removed item");
sm.potentialItems.RemoveAt(num4);
}
}
ListExtension.Shuffle<Item>((IList<Item>)sm.potentialItemConsumables);
for (int num5 = sm.potentialItemConsumables.Count - 1; num5 >= 0; num5--)
{
if ((Object)(object)sm.potentialItemConsumables[num5] == (Object)null)
{
RepoSeeded.Logger.LogInfo((object)"Removed item");
sm.potentialItemConsumables.RemoveAt(num5);
}
}
ListExtension.Shuffle<Item>((IList<Item>)sm.potentialItemUpgrades);
for (int num6 = sm.potentialItemUpgrades.Count - 1; num6 >= 0; num6--)
{
if ((Object)(object)sm.potentialItemUpgrades[num6] == (Object)null)
{
RepoSeeded.Logger.LogInfo((object)"Removed item");
sm.potentialItemUpgrades.RemoveAt(num6);
}
}
ListExtension.Shuffle<Item>((IList<Item>)sm.potentialItemHealthPacks);
for (int num7 = sm.potentialItemHealthPacks.Count - 1; num7 >= 0; num7--)
{
if ((Object)(object)sm.potentialItemHealthPacks[num7] == (Object)null)
{
RepoSeeded.Logger.LogInfo((object)"Removed item");
sm.potentialItemHealthPacks.RemoveAt(num7);
}
}
foreach (List<Item> value in sm.potentialSecretItems.Values)
{
ListExtension.Shuffle<Item>((IList<Item>)value);
for (int num8 = value.Count - 1; num8 >= 0; num8--)
{
if ((Object)(object)value[num8] == (Object)null)
{
RepoSeeded.Logger.LogInfo((object)"Removed item");
value.RemoveAt(num8);
}
}
}
RepoSeeded.Logger.LogInfo((object)("Items in queue: " + sm.potentialItems.Count));
return false;
}
[HarmonyPatch("GetAllItemVolumesInScene")]
[HarmonyPrefix]
private static bool GetAllVolumesPrefix()
{
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: 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)
Debug.LogError((object)"ShoupGetVols");
Random.InitState(RepoSeeded.ShopRandom.Next());
if (SemiFunc.IsNotMasterClient())
{
return false;
}
sm.itemVolumes.Clear();
sm.secretItemVolumes.Clear();
ItemVolume[] array = Object.FindObjectsByType<ItemVolume>((FindObjectsSortMode)0);
sortVolumesOnLocation(array);
ItemVolume[] array2 = array;
foreach (ItemVolume val in array2)
{
if ((int)val.itemSecretShopType == 0)
{
sm.itemVolumes.Add(val);
continue;
}
if (!sm.secretItemVolumes.ContainsKey(val.itemSecretShopType))
{
sm.secretItemVolumes.Add(val.itemSecretShopType, new List<ItemVolume>());
}
sm.secretItemVolumes[val.itemSecretShopType].Add(val);
}
foreach (List<ItemVolume> value in sm.secretItemVolumes.Values)
{
ListExtension.Shuffle<ItemVolume>((IList<ItemVolume>)value);
}
ListExtension.Shuffle<ItemVolume>((IList<ItemVolume>)sm.itemVolumes);
return false;
}
public static void sortVolumesOnLocation(ItemVolume[] volumes)
{
Array.Sort(volumes, delegate(ItemVolume a, ItemVolume b)
{
//IL_000f: 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)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = new Vector3(0f, 0f, 0f) - ((Component)a).transform.position;
float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
val = new Vector3(0f, 0f, 0f) - ((Component)b).transform.position;
return sqrMagnitude.CompareTo(((Vector3)(ref val)).sqrMagnitude);
});
}
public static Item[] sortItemsOnName(IEnumerable<Item> items)
{
Item[] array = items.ToArray();
if (array.Any((Item item) => (Object)(object)item == (Object)null))
{
RepoSeeded.Logger.LogError((object)"fuck");
}
Array.Sort(array, (Item a, Item b) => a.itemName.CompareTo(b.itemName));
return array;
}
}
[HarmonyPatch(typeof(TruckScreenText))]
internal static class TruckTextRNGPatch
{
[HarmonyPrefix]
[HarmonyPatch("NextLine")]
private static bool RemoveTruckTextRNG(TruckScreenText __instance, ref int _currentLineIndex)
{
Random.InitState(RepoSeeded.TruckTextRandom.Next());
return true;
}
}
internal static class ValuableCostsRNGPatch
{
[HarmonyPatch("DollarValueSetLogic")]
[HarmonyPrefix]
private static bool RemoveValueRNG(ref Rigidbody ___rb)
{
return true;
}
}
[HarmonyPatch(typeof(ValuableDirector))]
internal static class ValuableTypesRNGPatch
{
[CompilerGenerated]
private sealed class <newSetupHost>d__1 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
private ValuableDirector <vd>5__2;
private string[] <_names>5__3;
private int[] <_maxAmount>5__4;
private List<ValuableVolume>[] <_volumes>5__5;
private string[] <_path>5__6;
private int[] <_chance>5__7;
private List<PrefabRef>[] <_valuables>5__8;
private int[] <_volumeIndex>5__9;
private int <_i>5__10;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <newSetupHost>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<vd>5__2 = null;
<_names>5__3 = null;
<_maxAmount>5__4 = null;
<_volumes>5__5 = null;
<_path>5__6 = null;
<_chance>5__7 = null;
<_valuables>5__8 = null;
<_volumeIndex>5__9 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0b64: Unknown result type (might be due to invalid IL or missing references)
//IL_0b6e: Expected O, but got Unknown
//IL_0bb5: Unknown result type (might be due to invalid IL or missing references)
//IL_0bbf: Expected O, but got Unknown
//IL_05e5: Unknown result type (might be due to invalid IL or missing references)
//IL_05eb: Invalid comparison between Unknown and I4
//IL_06d4: Unknown result type (might be due to invalid IL or missing references)
//IL_06da: Invalid comparison between Unknown and I4
ValuableDirector obj9;
switch (<>1__state)
{
default:
return false;
case 0:
{
<>1__state = -1;
<vd>5__2 = ValuableDirector.instance;
if (SemiFunc.RunGetDifficultyMultiplier2() > 0f && !SemiFunc.RunIsArena())
{
float num = SemiFunc.RunGetDifficultyMultiplier2();
<vd>5__2.totalMaxValue = Mathf.RoundToInt(<vd>5__2.totalMaxValueCurve2.Evaluate(num));
<vd>5__2.tinyMaxAmount = Mathf.RoundToInt(<vd>5__2.tinyMaxAmountCurve2.Evaluate(num));
<vd>5__2.smallMaxAmount = Mathf.RoundToInt(<vd>5__2.smallMaxAmountCurve2.Evaluate(num));
<vd>5__2.mediumMaxAmount = Mathf.RoundToInt(<vd>5__2.mediumMaxAmountCurve2.Evaluate(num));
<vd>5__2.bigMaxAmount = Mathf.RoundToInt(<vd>5__2.bigMaxAmountCurve2.Evaluate(num));
<vd>5__2.wideMaxAmount = Mathf.RoundToInt(<vd>5__2.wideMaxAmountCurve2.Evaluate(num));
<vd>5__2.tallMaxAmount = Mathf.RoundToInt(<vd>5__2.tallMaxAmountCurve2.Evaluate(num));
<vd>5__2.veryTallMaxAmount = Mathf.RoundToInt(<vd>5__2.veryTallMaxAmountCurve2.Evaluate(num));
}
else
{
float num2 = SemiFunc.RunGetDifficultyMultiplier1();
if (SemiFunc.RunIsArena())
{
num2 = 0.75f;
}
<vd>5__2.totalMaxValue = Mathf.RoundToInt(<vd>5__2.totalMaxValueCurve1.Evaluate(num2));
<vd>5__2.tinyMaxAmount = Mathf.RoundToInt(<vd>5__2.tinyMaxAmountCurve1.Evaluate(num2));
<vd>5__2.smallMaxAmount = Mathf.RoundToInt(<vd>5__2.smallMaxAmountCurve1.Evaluate(num2));
<vd>5__2.mediumMaxAmount = Mathf.RoundToInt(<vd>5__2.mediumMaxAmountCurve1.Evaluate(num2));
<vd>5__2.bigMaxAmount = Mathf.RoundToInt(<vd>5__2.bigMaxAmountCurve1.Evaluate(num2));
<vd>5__2.wideMaxAmount = Mathf.RoundToInt(<vd>5__2.wideMaxAmountCurve1.Evaluate(num2));
<vd>5__2.tallMaxAmount = Mathf.RoundToInt(<vd>5__2.tallMaxAmountCurve1.Evaluate(num2));
<vd>5__2.veryTallMaxAmount = Mathf.RoundToInt(<vd>5__2.veryTallMaxAmountCurve1.Evaluate(num2));
}
if (SemiFunc.RunIsArena())
{
ValuableDirector obj = <vd>5__2;
obj.totalMaxAmount /= 2;
ValuableDirector obj2 = <vd>5__2;
obj2.tinyMaxAmount /= 3;
ValuableDirector obj3 = <vd>5__2;
obj3.smallMaxAmount /= 3;
ValuableDirector obj4 = <vd>5__2;
obj4.mediumMaxAmount /= 3;
ValuableDirector obj5 = <vd>5__2;
obj5.bigMaxAmount /= 3;
ValuableDirector obj6 = <vd>5__2;
obj6.wideMaxAmount /= 2;
ValuableDirector obj7 = <vd>5__2;
obj7.tallMaxAmount /= 2;
ValuableDirector obj8 = <vd>5__2;
obj8.veryTallMaxAmount /= 2;
}
foreach (LevelValuables valuablePreset in LevelGenerator.Instance.Level.ValuablePresets)
{
<vd>5__2.tinyValuables.AddRange(valuablePreset.tiny);
<vd>5__2.smallValuables.AddRange(valuablePreset.small);
<vd>5__2.mediumValuables.AddRange(valuablePreset.medium);
<vd>5__2.bigValuables.AddRange(valuablePreset.big);
<vd>5__2.wideValuables.AddRange(valuablePreset.wide);
<vd>5__2.tallValuables.AddRange(valuablePreset.tall);
<vd>5__2.veryTallValuables.AddRange(valuablePreset.veryTall);
}
List<ValuableVolume> list = Object.FindObjectsByType<ValuableVolume>((FindObjectsInactive)0, (FindObjectsSortMode)0).ToList();
sortVolumesOnLocation(list);
Random.InitState(RepoSeeded.ValuableTypeRandom.Next());
<vd>5__2.tinyVolumes = list.FindAll((ValuableVolume x) => (int)x.VolumeType == 0);
ListExtension.Shuffle<ValuableVolume>((IList<ValuableVolume>)<vd>5__2.tinyVolumes);
<vd>5__2.smallVolumes = list.FindAll((ValuableVolume x) => (int)x.VolumeType == 1);
ListExtension.Shuffle<ValuableVolume>((IList<ValuableVolume>)<vd>5__2.smallVolumes);
<vd>5__2.mediumVolumes = list.FindAll((ValuableVolume x) => (int)x.VolumeType == 2);
ListExtension.Shuffle<ValuableVolume>((IList<ValuableVolume>)<vd>5__2.mediumVolumes);
<vd>5__2.bigVolumes = list.FindAll((ValuableVolume x) => (int)x.VolumeType == 3);
ListExtension.Shuffle<ValuableVolume>((IList<ValuableVolume>)<vd>5__2.bigVolumes);
<vd>5__2.wideVolumes = list.FindAll((ValuableVolume x) => (int)x.VolumeType == 4);
ListExtension.Shuffle<ValuableVolume>((IList<ValuableVolume>)<vd>5__2.wideVolumes);
<vd>5__2.tallVolumes = list.FindAll((ValuableVolume x) => (int)x.VolumeType == 5);
ListExtension.Shuffle<ValuableVolume>((IList<ValuableVolume>)<vd>5__2.tallVolumes);
<vd>5__2.veryTallVolumes = list.FindAll((ValuableVolume x) => (int)x.VolumeType == 6);
ListExtension.Shuffle<ValuableVolume>((IList<ValuableVolume>)<vd>5__2.veryTallVolumes);
if ((int)<vd>5__2.valuableDebug == 1)
{
<vd>5__2.totalMaxAmount = list.Count;
<vd>5__2.totalMaxValue = 99999f;
<vd>5__2.tinyMaxAmount = <vd>5__2.tinyVolumes.Count;
<vd>5__2.smallMaxAmount = <vd>5__2.smallVolumes.Count;
<vd>5__2.mediumMaxAmount = <vd>5__2.mediumVolumes.Count;
<vd>5__2.bigMaxAmount = <vd>5__2.bigVolumes.Count;
<vd>5__2.wideMaxAmount = <vd>5__2.wideVolumes.Count;
<vd>5__2.tallMaxAmount = <vd>5__2.tallVolumes.Count;
<vd>5__2.veryTallMaxAmount = <vd>5__2.veryTallVolumes.Count;
}
if ((int)<vd>5__2.valuableDebug == 2 || LevelGenerator.Instance.Level.ValuablePresets.Count <= 0)
{
<vd>5__2.totalMaxAmount = 0;
<vd>5__2.tinyMaxAmount = 0;
<vd>5__2.smallMaxAmount = 0;
<vd>5__2.mediumMaxAmount = 0;
<vd>5__2.bigMaxAmount = 0;
<vd>5__2.wideMaxAmount = 0;
<vd>5__2.tallMaxAmount = 0;
<vd>5__2.veryTallMaxAmount = 0;
}
<vd>5__2.valuableTargetAmount = 0;
<_names>5__3 = new string[7] { "Tiny", "Small", "Medium", "Big", "Wide", "Tall", "Very Tall" };
<_maxAmount>5__4 = new int[7] { <vd>5__2.tinyMaxAmount, <vd>5__2.smallMaxAmount, <vd>5__2.mediumMaxAmount, <vd>5__2.bigMaxAmount, <vd>5__2.wideMaxAmount, <vd>5__2.tallMaxAmount, <vd>5__2.veryTallMaxAmount };
<_volumes>5__5 = new List<ValuableVolume>[7] { <vd>5__2.tinyVolumes, <vd>5__2.smallVolumes, <vd>5__2.mediumVolumes, <vd>5__2.bigVolumes, <vd>5__2.wideVolumes, <vd>5__2.tallVolumes, <vd>5__2.veryTallVolumes };
<_path>5__6 = new string[7] { <vd>5__2.tinyPath, <vd>5__2.smallPath, <vd>5__2.mediumPath, <vd>5__2.bigPath, <vd>5__2.widePath, <vd>5__2.tallPath, <vd>5__2.veryTallPath };
<_chance>5__7 = new int[7] { <vd>5__2.tinyChance, <vd>5__2.smallChance, <vd>5__2.mediumChance, <vd>5__2.bigChance, <vd>5__2.wideChance, <vd>5__2.tallChance, <vd>5__2.veryTallChance };
<_valuables>5__8 = new List<PrefabRef>[7] { <vd>5__2.tinyValuables, <vd>5__2.smallValuables, <vd>5__2.mediumValuables, <vd>5__2.bigValuables, <vd>5__2.wideValuables, <vd>5__2.tallValuables, <vd>5__2.veryTallValuables };
<_volumeIndex>5__9 = new int[7];
<_i>5__10 = 0;
goto IL_0af7;
}
case 1:
<>1__state = -1;
<_i>5__10++;
goto IL_0af7;
case 2:
<>1__state = -1;
goto IL_0b7e;
case 3:
{
<>1__state = -1;
break;
}
IL_0af7:
if (<_i>5__10 < <vd>5__2.totalMaxAmount)
{
Random.InitState(RepoSeeded.ValuableTypeRandom.Next());
float num3 = -1f;
int num4 = -1;
for (int i = 0; i < <_names>5__3.Length; i++)
{
if (<_volumeIndex>5__9[i] < <_maxAmount>5__4[i] && <_volumeIndex>5__9[i] < <_volumes>5__5[i].Count)
{
int num5 = Random.Range(0, <_chance>5__7[i]);
if ((float)num5 > num3)
{
num3 = num5;
num4 = i;
}
}
}
if (num4 != -1)
{
ValuableVolume val = <_volumes>5__5[num4][<_volumeIndex>5__9[num4]];
PrefabRef val2 = <_valuables>5__8[num4][Random.Range(0, <_valuables>5__8[num4].Count)];
<vd>5__2.Spawn(val2, val, <_path>5__6[num4]);
<_volumeIndex>5__9[num4]++;
<>2__current = null;
<>1__state = 1;
return true;
}
}
if (GameManager.instance.gameMode == 1)
{
<vd>5__2.PhotonView.RPC("ValuablesTargetSetRPC", (RpcTarget)0, new object[1] { <vd>5__2.valuableTargetAmount });
}
obj9 = <vd>5__2;
obj9.valuableSpawnPlayerReady++;
goto IL_0b7e;
IL_0b7e:
if (GameManager.instance.gameMode == 1 && <vd>5__2.valuableSpawnPlayerReady < PhotonNetwork.CurrentRoom.PlayerCount)
{
<>2__current = (object)new WaitForSeconds(0.1f);
<>1__state = 2;
return true;
}
<vd>5__2.VolumesAndSwitchSetup();
break;
}
if (GameManager.instance.gameMode == 1 && <vd>5__2.switchSetupPlayerReady < PhotonNetwork.CurrentRoom.PlayerCount)
{
<>2__current = (object)new WaitForSeconds(0.1f);
<>1__state = 3;
return true;
}
<vd>5__2.setupComplete = true;
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();
}
}
[HarmonyPrefix]
[HarmonyPatch("SetupHost")]
private static bool ValuablesRNGSeeder(ref IEnumerator __result)
{
__result = newSetupHost();
return false;
}
[IteratorStateMachine(typeof(<newSetupHost>d__1))]
private static IEnumerator newSetupHost()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <newSetupHost>d__1(0);
}
[HarmonyPatch("Spawn")]
[HarmonyPrefix]
private static bool RemoveStartRandomizing(ref PrefabRef _valuable, ref ValuableVolume _volume, ref string _path)
{
//IL_0049: 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_0022: 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)
ValuableDirector instance = ValuableDirector.instance;
GameObject prefab = _valuable.Prefab;
GameObject val = ((GameManager.instance.gameMode != 0) ? PhotonNetwork.InstantiateRoomObject(_valuable.resourcePath, ((Component)_volume).transform.position, ((Component)_volume).transform.rotation, (byte)0, (object[])null) : Object.Instantiate<GameObject>(prefab, ((Component)_volume).transform.position, ((Component)_volume).transform.rotation));
ValuableObject component = val.GetComponent<ValuableObject>();
Random.InitState(RepoSeeded.ValuableCostRandom.Next());
component.DollarValueSetLogic();
instance.valuableTargetAmount++;
instance.totalCurrentValue += component.dollarValueCurrent * 0.001f;
if (instance.totalCurrentValue > instance.totalMaxValue)
{
instance.totalMaxAmount = instance.valuableTargetAmount;
}
return false;
}
public static void sortVolumesOnLocation(List<ValuableVolume> volumes)
{
volumes.Sort(delegate(ValuableVolume a, ValuableVolume b)
{
//IL_000f: 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)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = new Vector3(0f, 0f, 0f) - ((Component)a).transform.position;
float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
val = new Vector3(0f, 0f, 0f) - ((Component)b).transform.position;
return sqrMagnitude.CompareTo(((Vector3)(ref val)).sqrMagnitude);
});
}
}
}
