using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Chubrel")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.1.6.0")]
[assembly: AssemblyInformationalVersion("1.1.6+a5ea41028b57b7f487ed3a5c8a04bbacc60aba86")]
[assembly: AssemblyProduct("Tierless")]
[assembly: AssemblyTitle("Tierless")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.6.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 Tierless
{
public readonly struct CountAndScore
{
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private readonly int <count>P;
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private readonly float <score>P;
public int Count => <count>P;
public float Score => <score>P;
public CountAndScore RawIncremented => new CountAndScore(<count>P + 1, <score>P);
public CountAndScore RawDecremented => new CountAndScore(<count>P - 1, <score>P);
public CountAndScore(int count, float score)
{
<count>P = count;
<score>P = score;
}
}
public class DefaultDictionary<TK, TV> : Dictionary<TK, TV>
{
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private Func<TV> <defaultFactory>P;
public new TV this[TK key]
{
get
{
if (!TryGetValue(key, out var value))
{
return <defaultFactory>P();
}
return value;
}
set
{
base[key] = value;
}
}
public DefaultDictionary(Func<TV> defaultFactory)
{
<defaultFactory>P = defaultFactory;
base..ctor();
}
}
public record DefaultEnemySetupData(EnemyName Name, int Tier, params Vector2[] Parameters) : IEnemySetupData, IEqualityComparer<IEnemySetupData>
{
public DefaultEnemySetupData(string rawEnemyName, int tier, params Vector2[] parameters)
: this(EnemyName.FromAnyName(rawEnemyName), tier, parameters)
{
}
public static float ScoreWithPoints(Vector2 point1, Vector2 point2, float x)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: 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)
return Mathf.LerpUnclamped(point1.y, point2.y, Mathf.InverseLerp(point1.x, point2.x, x));
}
public float ScoreWithFormula(int count)
{
//IL_003e: 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_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: 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)
//IL_0058: 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_0082: Unknown result type (might be due to invalid IL or missing references)
switch (Parameters.Length)
{
case 0:
return 1f;
case 1:
return Parameters[0].y;
default:
{
Vector2 val = Parameters[0];
int num = 1;
Vector2 point;
do
{
point = val;
val = Parameters[num];
}
while (!((float)count <= val.x) && ++num < Parameters.Length);
return ScoreWithPoints(point, val, count);
}
}
}
public int EvaluateMaxCount(float score)
{
throw new NotImplementedException();
}
public static DefaultEnemySetupData Default(EnemyName enemyName, int tier)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: 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)
float num = Mathf.Pow(2f, (float)(tier - 1));
return new DefaultEnemySetupData(enemyName, tier, new Vector2(1f, num), new Vector2(2f, 2f * num));
}
public static DefaultEnemySetupData Default(string rawEnemyName, int tier)
{
return Default(EnemyName.FromAnyName(rawEnemyName), tier);
}
public Func<EnemyName, IEnemySetupData> GetDefaultFactory(int tier)
{
return (EnemyName enemyName) => Default(enemyName, tier);
}
}
public record DefaultLevelSetupData : ILevelSetupData
{
public int MinLevel { get; }
public int MaxLevel { get; }
public float TargetScore { get; }
public int MinEnemyTypeCount { get; }
public int MaxEnemyTypeCount { get; }
public static readonly DefaultLevelSetupData Default = new DefaultLevelSetupData(0, -1, 20f, -1, -1);
public DefaultLevelSetupData(int MinLevel, int MaxLevel, float TargetScore, int MinEnemyTypeCount, int MaxEnemyTypeCount)
{
this.MinLevel = MinLevel;
this.MaxLevel = MaxLevel;
this.TargetScore = TargetScore;
this.MinEnemyTypeCount = MinEnemyTypeCount;
this.MaxEnemyTypeCount = ((MaxEnemyTypeCount < 0) ? int.MaxValue : MaxEnemyTypeCount);
base..ctor();
}
public bool IsForLevel(int level)
{
return level >= MinLevel && (MaxLevel < 0 || level <= MaxLevel);
}
[CompilerGenerated]
protected DefaultLevelSetupData(DefaultLevelSetupData original)
{
MinLevel = original.MinLevel;
MaxLevel = original.MaxLevel;
TargetScore = original.TargetScore;
MinEnemyTypeCount = original.MinEnemyTypeCount;
MaxEnemyTypeCount = original.MaxEnemyTypeCount;
}
[CompilerGenerated]
public void Deconstruct(out int MinLevel, out int MaxLevel, out float TargetScore, out int MinEnemyTypeCount, out int MaxEnemyTypeCount)
{
MinLevel = this.MinLevel;
MaxLevel = this.MaxLevel;
TargetScore = this.TargetScore;
MinEnemyTypeCount = this.MinEnemyTypeCount;
MaxEnemyTypeCount = this.MaxEnemyTypeCount;
}
}
public class DereferencePreventer
{
private static DereferencePreventer? _instance;
private readonly Dictionary<string, HashSet<object>> _preventDereference = new Dictionary<string, HashSet<object>>();
public static DereferencePreventer Instance => _instance ?? (_instance = new DereferencePreventer());
public bool IsGroupCreated(string group)
{
return _preventDereference.ContainsKey(group);
}
public bool DoesGroupHaveItems(string group)
{
_preventDereference.TryGetValue(group, out HashSet<object> value);
return value != null && value.Count > 0;
}
public void Add(string group, object endangered)
{
_preventDereference.TryGetValue(group, out HashSet<object> value);
if (value == null)
{
value = new HashSet<object>();
_preventDereference[group] = value;
}
value.Add(endangered);
}
public bool Remove(string group, object endangered)
{
_preventDereference.TryGetValue(group, out HashSet<object> value);
return value?.Remove(endangered) ?? false;
}
public void Clear(string group)
{
_preventDereference.TryGetValue(group, out HashSet<object> value);
value?.Clear();
}
}
public record EnemyData(GameObject GameObject, IEnemySetupData Data) : IEqualityComparer<EnemyData>
{
public bool Equals(EnemyData? x, EnemyData? y)
{
if ((object)x == y)
{
return true;
}
if ((object)x == null)
{
return false;
}
if ((object)y == null)
{
return false;
}
return x.GetType() == y.GetType() && x.Data.Equals(y.Data);
}
public int GetHashCode(EnemyData obj)
{
return obj.Data.GetHashCode();
}
}
public class EnemyDataContext : IEqualityComparer<EnemyDataContext>
{
public static readonly EnemyDataContext Empty = new EnemyDataContext();
public IDictionary<EnemyData, CountAndScore> EnemyDataCounter { get; }
public int TypeCount { get; set; }
public float TotalScore { get; set; }
public EnemyDataContext(IDictionary<EnemyData, CountAndScore> enemyDataCounter, int typeCount, float totalScore)
{
EnemyDataCounter = enemyDataCounter;
TypeCount = typeCount;
TotalScore = totalScore;
base..ctor();
}
public EnemyDataContext()
: this(new Dictionary<EnemyData, CountAndScore>(), 0, 0f)
{
}
public bool HasEnemy(EnemyData enemyData)
{
EnemyDataCounter.TryGetValue(enemyData, out var value);
return value.Count > 0;
}
public CountAndScore CountAndScore(EnemyData enemyData)
{
EnemyDataCounter.TryGetValue(enemyData, out var value);
return value;
}
public int Count(EnemyData enemyData)
{
return CountAndScore(enemyData).Count;
}
public float Score(EnemyData enemyData)
{
return CountAndScore(enemyData).Score;
}
public void JustAdd(EnemyData enemyData)
{
EnemyDataCounter.TryGetValue(enemyData, out var value);
EnemyDataCounter[enemyData] = enemyData.Data.IncrementAndCountAndScore(value);
}
public void AddAndUpdate(EnemyData enemyData, int typeCount, float totalScore)
{
JustAdd(enemyData);
UpdateCount();
UpdateScore();
}
public void AddAndUpdate(EnemyData enemyData, int typeCount)
{
JustAdd(enemyData);
TypeCount = typeCount;
UpdateScore();
}
public void AddAndUpdate(EnemyData enemyData, float totalScore)
{
JustAdd(enemyData);
UpdateCount();
TotalScore = totalScore;
}
public void AddAndUpdate(EnemyData enemyData)
{
JustAdd(enemyData);
UpdateCount();
UpdateScore();
}
public void UpdateScore()
{
TotalScore = 0f;
foreach (KeyValuePair<EnemyData, CountAndScore> item in EnemyDataCounter)
{
TotalScore += item.Value.Score;
}
}
public void UpdateCount()
{
TypeCount = 0;
foreach (KeyValuePair<EnemyData, CountAndScore> item in EnemyDataCounter)
{
if (item.Value.Count > 0)
{
TypeCount++;
}
}
}
public EnemyDataContext Copy(int typeCount, float totalScore)
{
return new EnemyDataContext(EnemyDataCounter.ToDictionary<KeyValuePair<EnemyData, CountAndScore>, EnemyData, CountAndScore>((KeyValuePair<EnemyData, CountAndScore> entry) => entry.Key, (KeyValuePair<EnemyData, CountAndScore> entry) => entry.Value), typeCount, totalScore);
}
public EnemyDataContext Copy(int typeCount)
{
return Copy(typeCount, TotalScore);
}
public EnemyDataContext Copy(float totalScore)
{
return Copy(TypeCount, totalScore);
}
public EnemyDataContext Copy()
{
return Copy(TypeCount, TotalScore);
}
public EnemyDataContext CopyAndAdd(EnemyData enemyData)
{
EnemyDataContext enemyDataContext = Copy();
enemyDataContext.AddAndUpdate(enemyData);
return enemyDataContext;
}
public IReadOnlyList<int> Counts()
{
return EnemyDataCounter.Aggregate<KeyValuePair<EnemyData, CountAndScore>, List<int>>(new List<int>(), delegate(List<int> list, KeyValuePair<EnemyData, CountAndScore> entries)
{
list.Add(entries.Value.Count);
return list;
});
}
public override int GetHashCode()
{
return HashCode.Combine(Counts());
}
public bool Equals(EnemyDataContext? x, EnemyDataContext? y)
{
if (x == y)
{
return true;
}
if (x == null)
{
return false;
}
if (y == null)
{
return false;
}
return x.GetType() == y.GetType() && x.Counts().Equals(y.Counts());
}
public int GetHashCode(EnemyDataContext obj)
{
return HashCode.Combine(obj.EnemyDataCounter, obj.TotalScore);
}
public IEnumerable<EnemyData> EnemyDataEnumerable()
{
return EnemyDataCounter.Select<KeyValuePair<EnemyData, CountAndScore>, EnemyData>((KeyValuePair<EnemyData, CountAndScore> entry) => entry.Key);
}
}
[HarmonyPatch(typeof(EnemyDirector))]
public static class EnemyDirectorPatch
{
public static void AddEnemies(ICollection<EnemyData> uniqueEnemies, ICollection<GameObject> directors, int tier, IEnumerable<EnemySetup> enemySetups)
{
foreach (EnemySetup enemySetup in enemySetups)
{
foreach (GameObject spawnObject in enemySetup.spawnObjects)
{
string name = ((Object)spawnObject).name;
if (!EnemyName.IsEnemyGroup(name))
{
EnemyName name2 = EnemyName.FromAnyName(name);
if (EnemyName.IsEnemyDirector(name))
{
directors.Add(spawnObject);
continue;
}
EnemyData item = new EnemyData(spawnObject, EnemySetupDataManager.Instance.GetOrDefault(name2, tier));
uniqueEnemies.Add(item);
}
}
}
}
public static EnemyDataContext ChooseEnemies(ICollection<EnemyData> uniqueEnemies)
{
if (uniqueEnemies.Count == 0)
{
Tierless.Instance.Logger.LogWarning((object)"No enemies were found!");
return EnemyDataContext.Empty;
}
int level = RunManager.instance.levelsCompleted + 1;
ILevelSetupData orDefault = LevelSetupDataManager.Instance.GetOrDefault(level);
int num = orDefault.MaxEnemyTypeCountLimited(uniqueEnemies.Count) + 1;
int num2 = (Random.RandomRangeInt(orDefault.MinEnemyTypeCount, num) + Random.RandomRangeInt(orDefault.MinEnemyTypeCount, num)) / 2;
List<EnemyData> list = uniqueEnemies.ToList();
ListExtension.Shuffle<EnemyData>((IList<EnemyData>)list);
EnemyDataContext enemyDataContext = new EnemyDataContext();
foreach (EnemyData item in list)
{
float num3 = enemyDataContext.TotalScore + item.Data.ScoreWithFormula(1);
if (!(num3 > orDefault.TargetScore))
{
enemyDataContext.AddAndUpdate(item, enemyDataContext.TypeCount + 1, num3);
if (enemyDataContext.TypeCount >= num2)
{
break;
}
}
}
bool flag;
do
{
flag = false;
foreach (EnemyData item2 in enemyDataContext.EnemyDataEnumerable())
{
CountAndScore countAndScore = enemyDataContext.CountAndScore(item2);
float num4 = enemyDataContext.TotalScore - countAndScore.Score + item2.Data.ScoreWithFormula(countAndScore.Count + 1);
if (num4 > orDefault.TargetScore)
{
continue;
}
flag = true;
enemyDataContext.AddAndUpdate(item2, countAndScore.Count + 1, num4);
break;
}
}
while (flag);
if (enemyDataContext.TypeCount == 0)
{
Tierless.Instance.Logger.LogWarning((object)"No enemies were chosen!");
}
return enemyDataContext;
}
[HarmonyPrefix]
[HarmonyPatch("PickEnemies")]
public static bool PickEnemies_Prefix(EnemyDirector __instance, List<EnemySetup> _enemiesList)
{
if (__instance.enemyListCurrent.Count != 0)
{
return false;
}
HashSet<EnemyData> uniqueEnemies = new HashSet<EnemyData>();
List<GameObject> list = new List<GameObject>();
AddEnemies(uniqueEnemies, list, 1, __instance.enemiesDifficulty1);
AddEnemies(uniqueEnemies, list, 2, __instance.enemiesDifficulty2);
AddEnemies(uniqueEnemies, list, 3, __instance.enemiesDifficulty3);
EnemySetup val = ScriptableObject.CreateInstance<EnemySetup>();
EnemyDataContext enemyDataContext = ChooseEnemies(uniqueEnemies);
val.spawnObjects = enemyDataContext.EnemyDataCounter.Aggregate<KeyValuePair<EnemyData, CountAndScore>, List<GameObject>>(new List<GameObject>(), delegate(List<GameObject> result, KeyValuePair<EnemyData, CountAndScore> entry)
{
for (int i = 0; i < entry.Value.Count; i++)
{
result.Add(entry.Key.GameObject);
}
return result;
});
val.spawnObjects.AddRange(list);
__instance.enemyList.Add(val);
__instance.enemyListCurrent.Add(val);
return false;
}
[HarmonyPostfix]
[HarmonyPatch("AmountSetup")]
public static void AmountSetup_Postfix(EnemyDirector __instance)
{
__instance.totalAmount = __instance.enemyListCurrent.Count;
}
}
public record EnemyName(string ShortName) : IEqualityComparer<EnemyName>
{
public string FullName => "Enemy - " + ShortName;
public const string FullNamePrefix = "Enemy - ";
public const string IsEnemyGroupRegex = "((\\bEnemy\\s+Group\\s*-)|(-\\s*((\\d+.+)|(.+\\d+))))";
public const string Director = "Director";
public static EnemyName FromShortName(string shortName)
{
return new EnemyName(shortName.Trim());
}
public static EnemyName FromAnyName(string anyName)
{
int num = anyName.IndexOf('-');
if (num == -1)
{
return FromShortName(anyName);
}
string text = anyName;
int num2 = num + 1;
string text2 = text.Substring(num2, text.Length - num2).TrimEnd();
if (text2.EndsWith("Director"))
{
text = text2;
num2 = "Director".Length;
return FromShortName(text.Substring(0, text.Length - num2));
}
return FromShortName(text2);
}
public static bool IsEnemyGroup(string name)
{
return Regex.IsMatch(name, "((\\bEnemy\\s+Group\\s*-)|(-\\s*((\\d+.+)|(.+\\d+))))", RegexOptions.IgnoreCase);
}
public static bool IsEnemyDirector(string name)
{
return name.Contains("Director");
}
public override int GetHashCode()
{
return ShortName.GetHashCode();
}
public bool Equals(EnemyName? x, EnemyName? y)
{
if ((object)x == y)
{
return true;
}
if ((object)x == null)
{
return false;
}
if ((object)y == null)
{
return false;
}
if (x.GetType() != y.GetType())
{
return false;
}
return x.ShortName == y.ShortName;
}
public int GetHashCode(EnemyName obj)
{
return obj.ShortName.GetHashCode();
}
[CompilerGenerated]
protected EnemyName(EnemyName original)
{
ShortName = original.ShortName;
}
}
public class EnemySetupDataManager
{
private static EnemySetupDataManager? _instance;
private readonly Dictionary<EnemyName, IEnemySetupData> _dataByName = new Dictionary<EnemyName, IEnemySetupData>();
public static EnemySetupDataManager Instance => _instance ?? (_instance = new EnemySetupDataManager());
public void Add(IEnemySetupData enemySetupData)
{
_dataByName[enemySetupData.Name] = enemySetupData;
}
public IEnemySetupData? Get(EnemyName name)
{
_dataByName.TryGetValue(name, out IEnemySetupData value);
return value;
}
public IEnemySetupData? Get(string name)
{
return Get(EnemyName.FromAnyName(name));
}
public IEnemySetupData GetOrDefault(EnemyName name, int tier)
{
return Get(name) ?? GetDefault(name, tier);
}
public IEnemySetupData GetOrDefault(string name, int tier)
{
return Get(name) ?? GetDefault(name, tier);
}
public static IEnemySetupData GetDefault(EnemyName name, int tier)
{
return DefaultEnemySetupData.Default(name, tier);
}
public static IEnemySetupData GetDefault(string name, int tier)
{
return DefaultEnemySetupData.Default(name, tier);
}
public void InitializeDefaults()
{
//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_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
//IL_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: 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_0184: Unknown result type (might be due to invalid IL or missing references)
//IL_0189: Unknown result type (might be due to invalid IL or missing references)
//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
//IL_01de: Unknown result type (might be due to invalid IL or missing references)
//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
//IL_020c: Unknown result type (might be due to invalid IL or missing references)
//IL_0211: Unknown result type (might be due to invalid IL or missing references)
//IL_0222: Unknown result type (might be due to invalid IL or missing references)
//IL_0227: Unknown result type (might be due to invalid IL or missing references)
//IL_0238: Unknown result type (might be due to invalid IL or missing references)
//IL_023d: Unknown result type (might be due to invalid IL or missing references)
//IL_0266: Unknown result type (might be due to invalid IL or missing references)
//IL_026b: Unknown result type (might be due to invalid IL or missing references)
//IL_027c: Unknown result type (might be due to invalid IL or missing references)
//IL_0281: Unknown result type (might be due to invalid IL or missing references)
//IL_0292: Unknown result type (might be due to invalid IL or missing references)
//IL_0297: Unknown result type (might be due to invalid IL or missing references)
//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
//IL_02db: Unknown result type (might be due to invalid IL or missing references)
//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
//IL_031a: Unknown result type (might be due to invalid IL or missing references)
//IL_031f: Unknown result type (might be due to invalid IL or missing references)
//IL_0330: Unknown result type (might be due to invalid IL or missing references)
//IL_0335: Unknown result type (might be due to invalid IL or missing references)
//IL_0346: Unknown result type (might be due to invalid IL or missing references)
//IL_034b: Unknown result type (might be due to invalid IL or missing references)
//IL_0374: Unknown result type (might be due to invalid IL or missing references)
//IL_0379: Unknown result type (might be due to invalid IL or missing references)
//IL_038a: Unknown result type (might be due to invalid IL or missing references)
//IL_038f: Unknown result type (might be due to invalid IL or missing references)
//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0428: Unknown result type (might be due to invalid IL or missing references)
//IL_042d: Unknown result type (might be due to invalid IL or missing references)
//IL_043e: Unknown result type (might be due to invalid IL or missing references)
//IL_0443: Unknown result type (might be due to invalid IL or missing references)
//IL_0454: Unknown result type (might be due to invalid IL or missing references)
//IL_0459: Unknown result type (might be due to invalid IL or missing references)
//IL_046a: Unknown result type (might be due to invalid IL or missing references)
//IL_046f: Unknown result type (might be due to invalid IL or missing references)
//IL_0498: Unknown result type (might be due to invalid IL or missing references)
//IL_049d: Unknown result type (might be due to invalid IL or missing references)
//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
//IL_04c4: Unknown result type (might be due to invalid IL or missing references)
//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
//IL_04da: Unknown result type (might be due to invalid IL or missing references)
//IL_04df: Unknown result type (might be due to invalid IL or missing references)
//IL_0508: Unknown result type (might be due to invalid IL or missing references)
//IL_050d: Unknown result type (might be due to invalid IL or missing references)
//IL_051e: Unknown result type (might be due to invalid IL or missing references)
//IL_0523: Unknown result type (might be due to invalid IL or missing references)
//IL_0534: Unknown result type (might be due to invalid IL or missing references)
//IL_0539: Unknown result type (might be due to invalid IL or missing references)
//IL_054a: Unknown result type (might be due to invalid IL or missing references)
//IL_054f: Unknown result type (might be due to invalid IL or missing references)
//IL_0578: Unknown result type (might be due to invalid IL or missing references)
//IL_057d: Unknown result type (might be due to invalid IL or missing references)
//IL_058e: Unknown result type (might be due to invalid IL or missing references)
//IL_0593: Unknown result type (might be due to invalid IL or missing references)
//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
//IL_05a9: Unknown result type (might be due to invalid IL or missing references)
//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
//IL_05bf: Unknown result type (might be due to invalid IL or missing references)
//IL_05e8: Unknown result type (might be due to invalid IL or missing references)
//IL_05ed: Unknown result type (might be due to invalid IL or missing references)
//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0603: Unknown result type (might be due to invalid IL or missing references)
//IL_0614: Unknown result type (might be due to invalid IL or missing references)
//IL_0619: Unknown result type (might be due to invalid IL or missing references)
//IL_062a: Unknown result type (might be due to invalid IL or missing references)
//IL_062f: Unknown result type (might be due to invalid IL or missing references)
//IL_0658: Unknown result type (might be due to invalid IL or missing references)
//IL_065d: Unknown result type (might be due to invalid IL or missing references)
//IL_066e: Unknown result type (might be due to invalid IL or missing references)
//IL_0673: Unknown result type (might be due to invalid IL or missing references)
//IL_0684: Unknown result type (might be due to invalid IL or missing references)
//IL_0689: Unknown result type (might be due to invalid IL or missing references)
//IL_069a: Unknown result type (might be due to invalid IL or missing references)
//IL_069f: Unknown result type (might be due to invalid IL or missing references)
//IL_06b0: Unknown result type (might be due to invalid IL or missing references)
//IL_06b5: Unknown result type (might be due to invalid IL or missing references)
Add(new DefaultEnemySetupData("Head", 3, new Vector2(1f, 4f), new Vector2(4f, 20f)));
Add(new DefaultEnemySetupData("Robe", 3, new Vector2(1f, 4f), new Vector2(4f, 20f)));
Add(new DefaultEnemySetupData("Runner", 3, new Vector2(1f, 4f), new Vector2(4f, 20f)));
Add(new DefaultEnemySetupData("Hunter", 3, new Vector2(1f, 4f), new Vector2(4f, 20f)));
Add(new DefaultEnemySetupData("Beamer", 3, new Vector2(1f, 4f), new Vector2(4f, 20f)));
Add(new DefaultEnemySetupData("Slow Walker", 3, new Vector2(1f, 4f), new Vector2(4f, 20f)));
Add(new DefaultEnemySetupData("Animal", 2, new Vector2(1f, 2f), new Vector2(3f, 4f), new Vector2(16f, 20f)));
Add(new DefaultEnemySetupData("Bowtie", 2, new Vector2(1f, 2f), new Vector2(3f, 4f), new Vector2(8f, 20f)));
Add(new DefaultEnemySetupData("Floater", 2, new Vector2(1f, 2f), new Vector2(3f, 4f), new Vector2(12f, 20f)));
Add(new DefaultEnemySetupData("Hidden", 2, new Vector2(1f, 2f), new Vector2(2f, 4f), new Vector2(8f, 20f)));
Add(new DefaultEnemySetupData("Tumbler", 2, new Vector2(1f, 2f), new Vector2(3f, 4f), new Vector2(16f, 20f)));
Add(new DefaultEnemySetupData("Upscream", 2, new Vector2(1f, 2f), new Vector2(3f, 4f), new Vector2(12f, 20f)));
Add(new DefaultEnemySetupData("Valuable Thrower", 2, new Vector2(1f, 2f), new Vector2(3f, 4f), new Vector2(10f, 20f)));
Add(new DefaultEnemySetupData("Bang", 2, new Vector2(1f, 2f / 3f), new Vector2(3f, 2f), new Vector2(6f, 4f), new Vector2(24f, 20f)));
Add(new DefaultEnemySetupData("Ceiling Eye", 1, new Vector2(1f, 2f / 3f), new Vector2(3f, 4f), new Vector2(6f, 11f), new Vector2(10f, 20f)));
Add(new DefaultEnemySetupData("Duck", 1, new Vector2(1f, 1f), new Vector2(4f, 4f), new Vector2(12f, 11f), new Vector2(24f, 20f)));
Add(new DefaultEnemySetupData("Slow Mouth", 1, new Vector2(1f, 1f), new Vector2(4f, 4f), new Vector2(8f, 11f), new Vector2(12f, 20f)));
Add(new DefaultEnemySetupData("Thin Man", 1, new Vector2(1f, 1f), new Vector2(4f, 4f), new Vector2(8f, 11f), new Vector2(18f, 20f)));
Add(new DefaultEnemySetupData("Gnome", 1, new Vector2(1f, 0.5f), new Vector2(4f, 1f), new Vector2(10f, 4f), new Vector2(20f, 11f), new Vector2(40f, 20f)));
}
}
public record EnemyWithDirector(GameObject? Enemy, GameObject? Director)
{
public bool IsReady => Enemy != null && Director != null;
public EnemyWithDirector()
: this(null, null)
{
}
public void Set()
{
GameObject? director = Director;
if (director != null)
{
Transform transform = director.transform;
GameObject? enemy = Enemy;
transform.SetParent((enemy != null) ? enemy.transform : null);
}
}
}
public interface IEnemySetupData : IEqualityComparer<IEnemySetupData>
{
EnemyName Name { get; }
int Tier { get; }
float ScoreWithFormula(int count);
float ScoreWithFormula(CountAndScore countAndScore)
{
return ScoreWithFormula(countAndScore.Count);
}
CountAndScore CountAndScoreWithFormula(int count)
{
return new CountAndScore(count, ScoreWithFormula(count));
}
CountAndScore CountAndScoreWithFormula(CountAndScore countAndScore)
{
return CountAndScoreWithFormula(countAndScore.Count);
}
CountAndScore IncrementAndCountAndScore(CountAndScore countAndScore)
{
return CountAndScoreWithFormula(countAndScore.Count + 1);
}
CountAndScore DecrementAndCountAndScoreWithFormula(CountAndScore countAndScore)
{
return CountAndScoreWithFormula(countAndScore.Count - 1);
}
int EvaluateMaxCount(float score);
int EvaluateMaxCount(CountAndScore countAndScore)
{
return EvaluateMaxCount(countAndScore.Score);
}
CountAndScore EvaluateMaxCountAndScore(float score)
{
return CountAndScoreWithFormula(EvaluateMaxCount(score));
}
CountAndScore EvaluateMaxCountAndScore(CountAndScore countAndScore)
{
return EvaluateMaxCountAndScore(countAndScore.Score);
}
bool IEqualityComparer<IEnemySetupData>.Equals(IEnemySetupData? x, IEnemySetupData? y)
{
if (x == y)
{
return true;
}
if (x == null)
{
return false;
}
if (y == null)
{
return false;
}
return x.GetType() == y.GetType() && x.Name.Equals(y.Name);
}
int IEqualityComparer<IEnemySetupData>.GetHashCode(IEnemySetupData obj)
{
return obj.Name.GetHashCode();
}
}
public interface ILevelSetupData
{
float TargetScore { get; }
int MinEnemyTypeCount { get; }
int MaxEnemyTypeCount { get; }
bool IsForLevel(int level);
int MaxEnemyTypeCountLimited(int enemyTypeCount)
{
return Mathf.Min(MaxEnemyTypeCount, enemyTypeCount);
}
}
public class LevelSetupDataManager
{
public const int StartLevelCount = 10;
public const float StartTargetScore = 3.5f;
public const float LastTargetScore = 20f;
private static LevelSetupDataManager? _instance;
private readonly IList<ILevelSetupData> _data = new List<ILevelSetupData>();
public static LevelSetupDataManager Instance => _instance ?? (_instance = new LevelSetupDataManager());
public void Add(ILevelSetupData data)
{
_data.Add(data);
}
public ILevelSetupData? Get(int level)
{
return _data.Reverse().FirstOrDefault((ILevelSetupData levelSetupData) => levelSetupData.IsForLevel(level));
}
public ILevelSetupData GetOrDefault(int level)
{
return Get(level) ?? DefaultLevelSetupData.Default;
}
public void InitializeDefaults()
{
Add(new DefaultLevelSetupData(1, 1, 3.5f, 2, 2));
Add(new DefaultLevelSetupData(2, 2, 5f, 2, 3));
Add(new DefaultLevelSetupData(3, 3, 6.5f, 2, 3));
Add(new DefaultLevelSetupData(4, 4, 8f, 2, 4));
Add(new DefaultLevelSetupData(5, 5, 9.5f, 2, 5));
Add(new DefaultLevelSetupData(6, 6, 11f, 3, 5));
Add(new DefaultLevelSetupData(7, 7, 12.5f, 3, 6));
Add(new DefaultLevelSetupData(8, 8, 14f, 3, 7));
Add(new DefaultLevelSetupData(9, 9, 16f, 2, 7));
Add(new DefaultLevelSetupData(10, 10, 18f, 2, 8));
Add(new DefaultLevelSetupData(11, 0, 20f, 1, -1));
}
}
public record OptimizedEnemyDataContext(CountAndScore[] CountsAndScores, float TotalScore);
public class RandomRemoveCollection<T> : IList, ICollection, IEnumerable, IList<T>, ICollection<T>, IEnumerable<T>, ISet<T>
{
private readonly IList<T> _list = new List<T>();
private readonly IDictionary<T, int> _dictionary = new Dictionary<T, int>();
public int Count => _list.Count;
public bool IsSynchronized => false;
public object SyncRoot
{
get
{
throw new NotImplementedException();
}
}
public T this[int index]
{
get
{
return _list[index];
}
set
{
throw new NotSupportedException("This collection does not support setting values in positions");
}
}
public int this[T key] => _dictionary[key];
public bool IsFixedSize => false;
public bool IsReadOnly => false;
object IList.this[int index]
{
get
{
throw new NotImplementedException();
}
set
{
throw new NotImplementedException();
}
}
public RandomRemoveCollection()
{
}
public RandomRemoveCollection(IEnumerable<T> enumerable)
: this()
{
int num = 0;
foreach (T item in enumerable)
{
_list.Add(item);
_dictionary.Add(item, num++);
}
}
public IEnumerator<T> GetEnumerator()
{
return _list.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
public void CopyTo(Array array, int index)
{
for (int i = index; i < _list.Count; i++)
{
array.SetValue(_list[i], i);
}
}
public bool Remove(T item)
{
if (!_dictionary.TryGetValue(item, out var value))
{
return false;
}
IList<T> list = _list;
int index = value;
IList<T> list2 = _list;
list[index] = list2[list2.Count - 1];
_list.RemoveAt(_list.Count - 1);
_dictionary.Remove(item);
return true;
}
int IList.Add(object? value)
{
if (value == null)
{
throw new ArgumentNullException("value", "This collection does not support null values");
}
return AddNotNull(value);
}
private int AddNotNull(object value)
{
throw new NotImplementedException();
}
public void Add(T item)
{
_dictionary[item] = _dictionary.Count;
_list.Add(item);
}
public void ExceptWith(IEnumerable<T> other)
{
throw new NotImplementedException();
}
public void IntersectWith(IEnumerable<T> other)
{
throw new NotImplementedException();
}
public bool IsProperSubsetOf(IEnumerable<T> other)
{
throw new NotImplementedException();
}
public bool IsProperSupersetOf(IEnumerable<T> other)
{
throw new NotImplementedException();
}
public bool IsSubsetOf(IEnumerable<T> other)
{
throw new NotImplementedException();
}
public bool IsSupersetOf(IEnumerable<T> other)
{
throw new NotImplementedException();
}
public bool Overlaps(IEnumerable<T> other)
{
throw new NotImplementedException();
}
public bool SetEquals(IEnumerable<T> other)
{
throw new NotImplementedException();
}
public void SymmetricExceptWith(IEnumerable<T> other)
{
throw new NotImplementedException();
}
public void UnionWith(IEnumerable<T> other)
{
throw new NotImplementedException();
}
bool ISet<T>.Add(T item)
{
throw new NotImplementedException();
}
void ICollection<T>.Clear()
{
throw new NotImplementedException();
}
public bool Contains(T item)
{
return _dictionary.ContainsKey(item);
}
public void CopyTo(T[] array, int arrayIndex)
{
CopyTo((Array)array, arrayIndex);
}
void IList.Clear()
{
throw new NotImplementedException();
}
bool IList.Contains(object? value)
{
throw new NotImplementedException();
}
public int IndexOf(object value)
{
throw new NotImplementedException();
}
public void Insert(int index, object value)
{
throw new NotImplementedException();
}
void IList.Remove(object value)
{
throw new NotImplementedException();
}
public int IndexOf(T item)
{
throw new NotImplementedException();
}
public void Insert(int index, T item)
{
throw new NotImplementedException();
}
void IList<T>.RemoveAt(int index)
{
throw new NotImplementedException();
}
void IList.RemoveAt(int index)
{
throw new NotImplementedException();
}
public int RandomIndex()
{
return Random.RandomRangeInt(0, Count);
}
public T RandomItem()
{
return _list[RandomIndex()];
}
public void Shuffle()
{
ListExtension.Shuffle<T>(_list);
for (int i = 0; i < Count; i++)
{
_dictionary[_list[i]] = i;
}
}
}
[BepInPlugin("com.github.chubrel.Tierless", "Tierless", "1.1.6")]
public class Tierless : BaseUnityPlugin
{
public const string Version = "1.1.6";
public const string Guid = "com.github.chubrel.Tierless";
public const string Name = "Tierless";
public static readonly string SaveDirectorsID = FullID("SaveDirectors");
public static Tierless Instance { get; private set; } = null;
public ManualLogSource Logger => ((BaseUnityPlugin)this).Logger;
private Harmony? Harmony { get; set; }
private void Awake()
{
Instance = this;
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
LevelSetupDataManager.Instance.InitializeDefaults();
EnemySetupDataManager.Instance.InitializeDefaults();
Patch();
}
public void Patch()
{
//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_0021: Expected O, but got Unknown
//IL_0026: Expected O, but got Unknown
if (Harmony == null)
{
Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
Harmony val2 = val;
Harmony = val;
}
Harmony.PatchAll();
}
public void Unpatch()
{
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
public static string FullID(string suffix)
{
return Utils.FullID("com.github.chubrel.Tierless", suffix);
}
}
public static class Utils
{
public static string FullID(string guid, string suffix)
{
return guid + ":" + suffix;
}
public static void AppendExpression(this StringBuilder stringBuilder, Expression<Func<object>> expression)
{
Expression body = expression.Body;
if (1 == 0)
{
}
string text;
if (!(body is MemberExpression memberExpression))
{
if (body is UnaryExpression unaryExpression)
{
Expression operand = unaryExpression.Operand;
if (operand is MemberExpression memberExpression2)
{
text = memberExpression2.Member.Name;
goto IL_0067;
}
}
text = body.ToString();
}
else
{
text = memberExpression.Member.Name;
}
goto IL_0067;
IL_0067:
if (1 == 0)
{
}
string value = text;
object value2 = expression.Compile()();
stringBuilder.Append(value);
stringBuilder.Append(" = ");
stringBuilder.Append(value2);
}
public static void LogExpressions(this ManualLogSource logger, string logName, params Expression<Func<object>>[] args)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(logName);
stringBuilder.Append(" <");
if (args.Length != 0)
{
stringBuilder.AppendExpression(args[0]);
for (int i = 1; i < args.Length; i++)
{
stringBuilder.Append(", ");
stringBuilder.AppendExpression(args[i]);
}
stringBuilder.Append(">");
}
logger.LogWarning((object)stringBuilder.ToString());
}
public static string ToStringInDetails(this object arg, int maxDepth = 3, string depthIndent = " ", string lineSeparator = "\n")
{
HashSet<object> visited = new HashSet<object>();
StringBuilder stringBuilder = new StringBuilder();
ToStringInDetailsImplementation(arg, stringBuilder, 0, maxDepth, visited, depthIndent, lineSeparator, toIndent: true);
return stringBuilder.ToString();
}
private static void ToStringInDetailsImplementation(object? arg, StringBuilder stringBuilder, int depth, int maxDepth, HashSet<object> visited, string depthIndent, string lineSeparator, bool toIndent)
{
StringBuilder stringBuilder2 = new StringBuilder();
for (int i = 0; i < depth; i++)
{
stringBuilder2.Append(depthIndent);
}
if (toIndent)
{
stringBuilder.Append(stringBuilder2);
}
if (arg == null)
{
stringBuilder.Append("null");
stringBuilder.Append(lineSeparator);
return;
}
Type type = arg.GetType();
if (visited.Contains(arg))
{
stringBuilder.Append("<Circular Reference to ");
stringBuilder.Append(type.Name);
stringBuilder.Append(">");
stringBuilder.Append(lineSeparator);
return;
}
if (type.IsPrimitive || arg is string || arg is DateTime || arg is decimal)
{
stringBuilder.Append(arg);
stringBuilder.Append(lineSeparator);
return;
}
if (depth >= maxDepth)
{
stringBuilder.Append("<");
stringBuilder.Append(type.Name);
stringBuilder.Append("...>");
stringBuilder.Append(lineSeparator);
return;
}
visited.Add(arg);
stringBuilder.Append(type.Name);
stringBuilder.Append(" {");
stringBuilder.Append(lineSeparator);
if (arg is IEnumerable enumerable)
{
foreach (object item in enumerable)
{
ToStringInDetailsImplementation(item, stringBuilder, depth + 1, maxDepth, visited, depthIndent, lineSeparator, toIndent: true);
}
}
else
{
PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (PropertyInfo propertyInfo in properties)
{
object arg2;
try
{
arg2 = propertyInfo.GetValue(arg);
}
catch
{
arg2 = "<error>";
}
stringBuilder.Append(stringBuilder2);
stringBuilder.Append(propertyInfo.Name);
stringBuilder.Append(" = ");
ToStringInDetailsImplementation(arg2, stringBuilder, depth + 1, maxDepth, visited, depthIndent, lineSeparator, toIndent: false);
}
}
stringBuilder.Append(stringBuilder2);
stringBuilder.Append("}");
visited.Remove(arg);
stringBuilder.Append(lineSeparator);
}
}
}
