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(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("LongSorter")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2021")]
[assembly: AssemblyFileVersion("1.3.3.0")]
[assembly: AssemblyInformationalVersion("1.0.0+1d3582f957efb8fb66ae9225fa1380a9af0944c3")]
[assembly: AssemblyProduct("LongSorter")]
[assembly: AssemblyTitle("LongSorter")]
[assembly: AssemblyVersion("1.3.3.0")]
namespace LongSorter;
[BepInPlugin("com.sylf.dsp.LongSorter", "LongSorter", "1.3.3")]
public class LongSorter : BaseUnityPlugin
{
internal static class Patch
{
[CompilerGenerated]
private sealed class <CheckBuildConditions_Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IEnumerator, IDisposable
{
private int <>1__state;
private CodeInstruction <>2__current;
private int <>l__initialThreadId;
private IEnumerable<CodeInstruction> instructions;
public IEnumerable<CodeInstruction> <>3__instructions;
private List<CodeInstruction> <ins>5__2;
private List<int> <patchPos>5__3;
private MethodInfo <m>5__4;
private int <i>5__5;
CodeInstruction IEnumerator<CodeInstruction>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CheckBuildConditions_Transpiler>d__0(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<ins>5__2 = null;
<patchPos>5__3 = null;
<m>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0206: Unknown result type (might be due to invalid IL or missing references)
//IL_0210: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
{
<>1__state = -1;
<ins>5__2 = instructions.ToList();
<patchPos>5__3 = new List<int>(2);
FieldInfo fieldInfo = AccessTools.Field(typeof(BuildPreview), "condition");
<m>5__4 = typeof(Patch).GetMethod("LengthCorrection");
for (int i = 0; i < <ins>5__2.Count; i++)
{
if (!(<ins>5__2[i].opcode != OpCodes.Stfld) && <ins>5__2[i].operand is FieldInfo fieldInfo2 && !(fieldInfo2 != fieldInfo) && !(<ins>5__2[i - 1].opcode != OpCodes.Ldc_I4_S) && <ins>5__2[i - 1].operand is sbyte b && b == 14 && (!(<ins>5__2[i - 3].opcode != OpCodes.Ble_Un) || !(<ins>5__2[i - 3].opcode != OpCodes.Ble_Un_S)))
{
<patchPos>5__3.Add(i - 5);
if (<patchPos>5__3.Count == 2)
{
break;
}
}
}
<i>5__5 = 0;
break;
}
case 1:
<>1__state = -1;
<>2__current = <ins>5__2[<i>5__5 + 1];
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
<>2__current = new CodeInstruction(OpCodes.Call, (object)<m>5__4);
<>1__state = 3;
return true;
case 3:
<>1__state = -1;
<>2__current = <ins>5__2[<i>5__5 + 2];
<>1__state = 4;
return true;
case 4:
<>1__state = -1;
<i>5__5 += 2;
goto IL_0280;
case 5:
{
<>1__state = -1;
goto IL_0280;
}
IL_0280:
<i>5__5++;
break;
}
if (<i>5__5 < <ins>5__2.Count)
{
if (<patchPos>5__3.Contains(<i>5__5))
{
<>2__current = <ins>5__2[<i>5__5];
<>1__state = 1;
return true;
}
<>2__current = <ins>5__2[<i>5__5];
<>1__state = 5;
return 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();
}
[DebuggerHidden]
IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
{
<CheckBuildConditions_Transpiler>d__0 <CheckBuildConditions_Transpiler>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<CheckBuildConditions_Transpiler>d__ = this;
}
else
{
<CheckBuildConditions_Transpiler>d__ = new <CheckBuildConditions_Transpiler>d__0(0);
}
<CheckBuildConditions_Transpiler>d__.instructions = <>3__instructions;
return <CheckBuildConditions_Transpiler>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
}
}
[IteratorStateMachine(typeof(<CheckBuildConditions_Transpiler>d__0))]
private static IEnumerable<CodeInstruction> CheckBuildConditions_Transpiler(IEnumerable<CodeInstruction> instructions)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CheckBuildConditions_Transpiler>d__0(-2)
{
<>3__instructions = instructions
};
}
[HarmonyTranspiler]
[HarmonyPatch(typeof(BuildTool_Inserter), "CheckBuildConditions")]
public static IEnumerable<CodeInstruction> BuildTool_Inserter_Transpiler(IEnumerable<CodeInstruction> instructions)
{
return CheckBuildConditions_Transpiler(instructions);
}
[HarmonyTranspiler]
[HarmonyPatch(typeof(BuildTool_Inserter), "DeterminePreviews")]
public static IEnumerable<CodeInstruction> BuildTool_Inserter_DeterminePreviews_Transpiler(IEnumerable<CodeInstruction> instructions)
{
MethodInfo method = typeof(List<PosePair>).GetMethod("Add");
MethodInfo method2 = typeof(Patch).GetMethod("AngleCorrection11");
MethodInfo method3 = typeof(Patch).GetMethod("AngleCorrection14");
MethodInfo methodInfo = typeof(Patch).GetMethod("AngleCorrection40");
List<CodeInstruction> list = instructions.ToList();
for (int i = 0; i < list.Count; i++)
{
if (list[i].opcode == OpCodes.Callvirt && list[i].operand is MethodInfo methodInfo2 && methodInfo2 == method)
{
for (int num = i - 1; num > i - 22; num--)
{
if (!(list[num].opcode != OpCodes.Ldc_R4) && list[num].operand is float num2)
{
if (Mathf.Approximately(num2, 11f))
{
list[num].opcode = OpCodes.Call;
list[num].operand = method2;
break;
}
if (Mathf.Approximately(num2, 14f))
{
list[num].opcode = OpCodes.Call;
list[num].operand = method3;
break;
}
}
}
}
if (methodInfo != null && list[i].opcode == OpCodes.Ldloc_S && i + 1 < list.Count && list[i + 1].opcode == OpCodes.Ldc_R4 && list[i + 1].operand is float num3 && num3 == 40f)
{
list[i + 1].opcode = OpCodes.Call;
list[i + 1].operand = methodInfo;
methodInfo = null;
}
}
return list.AsEnumerable();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(BuildTool_Inserter), "CheckBuildConditions")]
public static void BuildTool_Inserter_CheckBuildConditions_Postfix(BuildTool_Inserter __instance, ref bool __result)
{
//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_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Invalid comparison between Unknown and I4
//IL_0047: 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_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Invalid comparison between Unknown and I4
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
if (__result || !LongMode() || ((BuildTool)__instance).buildPreviews.Count != 1)
{
return;
}
BuildPreview val = ((BuildTool)__instance).buildPreviews[0];
EBuildCondition condition = val.condition;
if ((int)condition != 13)
{
if ((int)condition == 33 && CanIgnoreCollide(__instance, val))
{
__result = true;
}
}
else if ((double)Vector3.Distance(val.lpos, val.lpos2) > 1.1333332538604737)
{
__result = true;
}
if (__result)
{
val.condition = (EBuildCondition)0;
((BuildTool)__instance).actionBuild.model.cursorText = val.conditionText;
((BuildTool)__instance).actionBuild.model.cursorState = 0;
if (!VFInput.onGUI)
{
UICursor.SetCursor((ECursor)0);
}
}
}
private static bool CanIgnoreCollide(BuildTool_Inserter tool, BuildPreview buildPreview)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
if (!buildPreview.desc.hasBuildCollider)
{
return false;
}
ColliderData val2 = default(ColliderData);
for (int i = 0; i < BuildToolAccess.TmpColsLength(); i++)
{
Collider val = BuildToolAccess.TmpCols()[i];
if (((BuildTool)tool).planet.physics.GetColliderData(val, ref val2) && (int)((ColliderData)(ref val2)).objType == 0)
{
int objId = ((ColliderData)(ref val2)).objId;
if (((BuildTool)tool).planet.factory.entityPool[objId].beltId <= 0)
{
return false;
}
}
}
return true;
}
private static bool LongMode()
{
return VFInput.control;
}
public static float LengthCorrection(float val)
{
if (!LongMode())
{
return val;
}
return val * 5f;
}
public static float AngleCorrection11()
{
if (!LongMode())
{
return 11f;
}
return 1000f;
}
public static float AngleCorrection14()
{
if (!LongMode())
{
return 14f;
}
return 1000f;
}
public static float AngleCorrection40()
{
if (!LongMode())
{
return 40f;
}
if (!VFInput.shift)
{
return 1000f;
}
return 6f;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(PlanetFactory), "OnInserterBuilt")]
public static bool PlanetFactory_OnInserterBuilt_Prefix()
{
return false;
}
}
private class BuildToolAccess : BuildTool
{
public static int TmpColsLength()
{
int num = 0;
Collider[] tmp_cols = BuildTool._tmp_cols;
for (int i = 0; i < tmp_cols.Length && (Object)(object)tmp_cols[i] != (Object)null; i++)
{
num++;
}
return num;
}
public static Collider[] TmpCols()
{
return BuildTool._tmp_cols;
}
}
private const string Name = "LongSorter";
private const string Guid = "com.sylf.dsp.LongSorter";
private static ManualLogSource _logger;
private void Awake()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
_logger = ((BaseUnityPlugin)this).Logger;
new Harmony("com.sylf.dsp.LongSorter").PatchAll(typeof(Patch));
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "LongSorter";
public const string PLUGIN_NAME = "LongSorter";
public const string PLUGIN_VERSION = "1.0.0";
}
