using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("DesignTo90")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+60623339197025533f4bb54762eb818a80795c44")]
[assembly: AssemblyProduct("DesignTo90")]
[assembly: AssemblyTitle("DesignTo90")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace DesignTo90;
[BepInPlugin("com.voidchicken.DesignTo90", "DesignTo90", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
[HarmonyPatch]
public static class EnableFullBuild
{
[CompilerGenerated]
private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
{
private int <>1__state;
private MethodBase <>2__current;
private int <>l__initialThreadId;
MethodBase IEnumerator<MethodBase>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TargetMethods>d__0(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = AccessTools.Method(typeof(UIDysonBrush_Frame), "CheckCondition", (Type[])null, (Type[])null);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<>2__current = AccessTools.Method(typeof(UIDysonBrush_Node), "_OnUpdate", (Type[])null, (Type[])null);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
<>2__current = AccessTools.Method(typeof(DysonBlueprintData), "CheckLatLimit", (Type[])null, (Type[])null);
<>1__state = 3;
return true;
case 3:
<>1__state = -1;
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
{
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
return this;
}
return new <TargetMethods>d__0(0);
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<MethodBase>)this).GetEnumerator();
}
}
[CompilerGenerated]
private sealed class <Transpiler>d__2 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
{
private int <>1__state;
private CodeInstruction <>2__current;
private int <>l__initialThreadId;
private IEnumerable<CodeInstruction> instructions;
public IEnumerable<CodeInstruction> <>3__instructions;
private IEnumerator<CodeInstruction> <>7__wrap1;
CodeInstruction IEnumerator<CodeInstruction>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Transpiler>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || (uint)(num - 1) <= 2u)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<>7__wrap1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Expected O, but got Unknown
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Expected O, but got Unknown
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>7__wrap1 = instructions.GetEnumerator();
<>1__state = -3;
break;
case 1:
<>1__state = -3;
<>2__current = new CodeInstruction(OpCodes.Ldc_R4, (object)90f);
<>1__state = 2;
return true;
case 2:
<>1__state = -3;
break;
case 3:
<>1__state = -3;
break;
}
if (<>7__wrap1.MoveNext())
{
CodeInstruction current = <>7__wrap1.Current;
if (CodeInstructionExtensions.LoadsField(current, dysonNodeLatitude, false))
{
<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
<>1__state = 1;
return true;
}
<>2__current = current;
<>1__state = 3;
return true;
}
<>m__Finally1();
<>7__wrap1 = null;
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<>7__wrap1 != null)
{
<>7__wrap1.Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
{
<Transpiler>d__2 <Transpiler>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<Transpiler>d__ = this;
}
else
{
<Transpiler>d__ = new <Transpiler>d__2(0);
}
<Transpiler>d__.instructions = <>3__instructions;
return <Transpiler>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
}
}
private static readonly FieldInfo dysonNodeLatitude = AccessTools.Field(typeof(GameHistoryData), "dysonNodeLatitude");
[IteratorStateMachine(typeof(<TargetMethods>d__0))]
public static IEnumerable<MethodBase> TargetMethods()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TargetMethods>d__0(-2);
}
[IteratorStateMachine(typeof(<Transpiler>d__2))]
public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <Transpiler>d__2(-2)
{
<>3__instructions = instructions
};
}
}
[HarmonyPatch]
public static class NodeLimiter
{
public static MethodBase TargetMethod()
{
return AccessTools.PropertyGetter(typeof(DysonNode), "spReqOrder");
}
public static void Postfix(ref int __result, DysonNode __instance)
{
if (DSPGame.IsMenuDemo)
{
return;
}
lock (__instance)
{
if (__result > 0 && !AllowedByLatitiude(__instance))
{
__result = 0;
}
}
}
}
[HarmonyPatch]
public static class FrameLimiter
{
[CompilerGenerated]
private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
{
private int <>1__state;
private MethodBase <>2__current;
private int <>l__initialThreadId;
MethodBase IEnumerator<MethodBase>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TargetMethods>d__0(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = AccessTools.Method(typeof(DysonNode), "ConstructSp", (Type[])null, (Type[])null);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<>2__current = AccessTools.Method(typeof(DysonNode), "RecalcSpReq", (Type[])null, (Type[])null);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
{
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
return this;
}
return new <TargetMethods>d__0(0);
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<MethodBase>)this).GetEnumerator();
}
}
[CompilerGenerated]
private sealed class <Transpiler>d__3 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
{
private int <>1__state;
private CodeInstruction <>2__current;
private int <>l__initialThreadId;
private IEnumerable<CodeInstruction> instructions;
public IEnumerable<CodeInstruction> <>3__instructions;
private IEnumerator<CodeInstruction> <>7__wrap1;
CodeInstruction IEnumerator<CodeInstruction>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Transpiler>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || (uint)(num - 1) <= 1u)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<>7__wrap1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>7__wrap1 = instructions.GetEnumerator();
<>1__state = -3;
break;
case 1:
<>1__state = -3;
break;
case 2:
<>1__state = -3;
break;
}
if (<>7__wrap1.MoveNext())
{
CodeInstruction current = <>7__wrap1.Current;
if (CodeInstructionExtensions.LoadsField(current, spMax, false))
{
<>2__current = CodeInstruction.Call(typeof(FrameLimiter), "CheckSpMax", (Type[])null, (Type[])null);
<>1__state = 1;
return true;
}
<>2__current = current;
<>1__state = 2;
return true;
}
<>m__Finally1();
<>7__wrap1 = null;
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<>7__wrap1 != null)
{
<>7__wrap1.Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
{
<Transpiler>d__3 <Transpiler>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<Transpiler>d__ = this;
}
else
{
<Transpiler>d__ = new <Transpiler>d__3(0);
}
<Transpiler>d__.instructions = <>3__instructions;
return <Transpiler>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
}
}
private static readonly FieldInfo spMax = AccessTools.Field(typeof(DysonFrame), "spMax");
[IteratorStateMachine(typeof(<TargetMethods>d__0))]
public static IEnumerable<MethodBase> TargetMethods()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TargetMethods>d__0(-2);
}
private static int CheckSpMax(DysonFrame dysonFrame)
{
if (DSPGame.IsMenuDemo)
{
return dysonFrame.spMax;
}
if (!AllowedByLatitiude(dysonFrame.nodeA) || !AllowedByLatitiude(dysonFrame.nodeB))
{
return 0;
}
return dysonFrame.spMax;
}
[IteratorStateMachine(typeof(<Transpiler>d__3))]
public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <Transpiler>d__3(-2)
{
<>3__instructions = instructions
};
}
}
[HarmonyPatch]
public static class ShellLimiter
{
[CompilerGenerated]
private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
{
private int <>1__state;
private MethodBase <>2__current;
private int <>l__initialThreadId;
MethodBase IEnumerator<MethodBase>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TargetMethods>d__0(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = AccessTools.Method(typeof(DysonNode), "ConstructCp", (Type[])null, (Type[])null);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<>2__current = AccessTools.Method(typeof(DysonNode), "RecalcCpReq", (Type[])null, (Type[])null);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
{
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
return this;
}
return new <TargetMethods>d__0(0);
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<MethodBase>)this).GetEnumerator();
}
}
[CompilerGenerated]
private sealed class <Transpiler>d__3 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
{
private int <>1__state;
private CodeInstruction <>2__current;
private int <>l__initialThreadId;
private IEnumerable<CodeInstruction> instructions;
public IEnumerable<CodeInstruction> <>3__instructions;
private IEnumerator<CodeInstruction> <>7__wrap1;
CodeInstruction IEnumerator<CodeInstruction>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Transpiler>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || (uint)(num - 1) <= 1u)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<>7__wrap1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>7__wrap1 = instructions.GetEnumerator();
<>1__state = -3;
break;
case 1:
<>1__state = -3;
break;
case 2:
<>1__state = -3;
break;
}
if (<>7__wrap1.MoveNext())
{
CodeInstruction current = <>7__wrap1.Current;
if (CodeInstructionExtensions.LoadsField(current, cpPerVertex, false))
{
<>2__current = CodeInstruction.Call(typeof(ShellLimiter), "CheckCpPerVertex", (Type[])null, (Type[])null);
<>1__state = 1;
return true;
}
<>2__current = current;
<>1__state = 2;
return true;
}
<>m__Finally1();
<>7__wrap1 = null;
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<>7__wrap1 != null)
{
<>7__wrap1.Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
{
<Transpiler>d__3 <Transpiler>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<Transpiler>d__ = this;
}
else
{
<Transpiler>d__ = new <Transpiler>d__3(0);
}
<Transpiler>d__.instructions = <>3__instructions;
return <Transpiler>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
}
}
private static readonly FieldInfo cpPerVertex = AccessTools.Field(typeof(DysonShell), "cpPerVertex");
[IteratorStateMachine(typeof(<TargetMethods>d__0))]
public static IEnumerable<MethodBase> TargetMethods()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TargetMethods>d__0(-2);
}
private static int CheckCpPerVertex(DysonShell dysonShell)
{
if (DSPGame.IsMenuDemo)
{
return dysonShell.cpPerVertex;
}
List<DysonNode> nodes = dysonShell.nodes;
if (nodes != null && nodes.Any((DysonNode node) => !AllowedByLatitiude(node)))
{
return 0;
}
return dysonShell.cpPerVertex;
}
[IteratorStateMachine(typeof(<Transpiler>d__3))]
public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <Transpiler>d__3(-2)
{
<>3__instructions = instructions
};
}
}
[HarmonyPatch]
public static class HandleNewLimit
{
private const int latitudeTechUnlock = 26;
public static MethodBase TargetMethod()
{
return AccessTools.Method(typeof(GameHistoryData), "UnlockTechFunction", (Type[])null, (Type[])null);
}
private static void CheckRecalculation(DysonNode node, HashSet<DysonNode> recalculateSet)
{
int newLimit = Mathf.RoundToInt(GameMain.history.dysonNodeLatitude);
int num = newLimit - 15;
int num2 = NodeLatitude(node);
if (num2 > newLimit || num2 <= num)
{
return;
}
recalculateSet.Add(node);
foreach (DysonFrame item in node.frames?.Where((DysonFrame frame) => frame != null) ?? Enumerable.Empty<DysonFrame>())
{
if (item.nodeA != null && NodeLatitude(item.nodeA) <= num)
{
recalculateSet.Add(item.nodeA);
}
if (item.nodeB != null && NodeLatitude(item.nodeB) <= num)
{
recalculateSet.Add(item.nodeB);
}
}
IEnumerable<DysonShell> shells = node.shells;
foreach (DysonShell item2 in shells ?? Enumerable.Empty<DysonShell>())
{
if (!(item2?.nodes?.Any((DysonNode shellNode) => NodeLatitude(shellNode) > newLimit)).GetValueOrDefault(true))
{
recalculateSet.UnionWith(item2.nodes);
}
}
}
public static void Postfix(int func)
{
if (func != 26)
{
return;
}
foreach (DysonSphere item in GameMain.data.dysonSpheres?.Where((DysonSphere sphere) => sphere != null && sphere.layerCount > 0) ?? Enumerable.Empty<DysonSphere>())
{
HashSet<DysonNode> hashSet = new HashSet<DysonNode>();
DysonSphereLayer[] layersIdBased = item.layersIdBased;
for (int i = 0; i < layersIdBased.Length; i++)
{
foreach (DysonNode item2 in layersIdBased[i]?.nodePool?.Where((DysonNode node) => node != null) ?? Enumerable.Empty<DysonNode>())
{
CheckRecalculation(item2, hashSet);
}
}
hashSet.Remove(null);
foreach (DysonNode item3 in hashSet)
{
item3.RecalcSpReq();
item3.RecalcCpReq();
}
int num = Mathf.Clamp(item.totalConstructedNodeCount / 2, 1, 8) - item.autoNodeCount;
for (int j = 0; j < num; j++)
{
item.PickAutoNode();
}
}
}
}
public const string GUID = "com.voidchicken.DesignTo90";
public const string NAME = "DesignTo90";
public const string VERSION = "1.0.0";
private Harmony harmony;
private static ManualLogSource logger;
private void Awake()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
logger = ((BaseUnityPlugin)this).Logger;
harmony = new Harmony("com.voidchicken.DesignTo90");
harmony.PatchAll(typeof(EnableFullBuild));
harmony.PatchAll(typeof(NodeLimiter));
harmony.PatchAll(typeof(FrameLimiter));
harmony.PatchAll(typeof(ShellLimiter));
harmony.PatchAll(typeof(HandleNewLimit));
}
private void OnDestroy()
{
harmony.UnpatchSelf();
}
private static int NodeLatitude(DysonNode node)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return Mathf.RoundToInt(Mathf.Asin(Mathf.Clamp01(Mathf.Abs(((Vector3)(ref node.pos)).normalized.y))) * 57.29578f);
}
private static bool AllowedByLatitiude(DysonNode node)
{
if (node == null)
{
return true;
}
return NodeLatitude(node) <= Mathf.RoundToInt(GameMain.history.dysonNodeLatitude);
}
}
