using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("gg.amgg.PeakLobbyParkour")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+c08623690b90249f9f99465e2c5aa2b4a743f542")]
[assembly: AssemblyProduct("gg.amgg.PeakLobbyParkour")]
[assembly: AssemblyTitle("LobbyParkour")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.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 BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace LobbyParkour
{
[BepInPlugin("gg.amgg.PeakLobbyParkour", "LobbyParkour", "0.1.0")]
public class Plugin : BaseUnityPlugin
{
private static class Util
{
public static IEnumerable<GameObject> GetChildrenOf(GameObject target)
{
Transform component = target.GetComponent<Transform>();
if (component == null)
{
return Array.Empty<GameObject>();
}
return from Transform childTransform in (IEnumerable)component
select ((Component)childTransform).gameObject;
}
public static Mesh EnsureMeshReadable(Mesh mesh)
{
if (!mesh.isReadable)
{
return MakeReadableMeshCopy(mesh);
}
return mesh;
}
public static Mesh MakeReadableMeshCopy(Mesh nonReadableMesh)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Expected O, but got Unknown
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
Mesh val = new Mesh();
val.indexFormat = nonReadableMesh.indexFormat;
GraphicsBuffer vertexBuffer = nonReadableMesh.GetVertexBuffer(0);
int num = vertexBuffer.stride * vertexBuffer.count;
byte[] array = new byte[num];
vertexBuffer.GetData((Array)array);
val.SetVertexBufferParams(nonReadableMesh.vertexCount, nonReadableMesh.GetVertexAttributes());
val.SetVertexBufferData<byte>(array, 0, 0, num, 0, (MeshUpdateFlags)0);
vertexBuffer.Release();
val.subMeshCount = nonReadableMesh.subMeshCount;
GraphicsBuffer indexBuffer = nonReadableMesh.GetIndexBuffer();
int num2 = indexBuffer.stride * indexBuffer.count;
byte[] array2 = new byte[num2];
indexBuffer.GetData((Array)array2);
val.SetIndexBufferParams(indexBuffer.count, nonReadableMesh.indexFormat);
val.SetIndexBufferData<byte>(array2, 0, 0, num2, (MeshUpdateFlags)0);
indexBuffer.Release();
uint num3 = 0u;
for (int i = 0; i < val.subMeshCount; i++)
{
uint indexCount = nonReadableMesh.GetIndexCount(i);
val.SetSubMesh(i, new SubMeshDescriptor((int)num3, (int)indexCount, (MeshTopology)0), (MeshUpdateFlags)0);
num3 += indexCount;
}
val.RecalculateNormals();
val.RecalculateBounds();
return val;
}
}
private class SceneTreeQueryNode
{
public class Epsilon : SceneTreeQueryNode
{
protected override void Run(GameObject target, int depth)
{
foreach (SceneTreeQueryNode child in Children)
{
child.Run(target, depth);
}
}
}
[CompilerGenerated]
private Predicate<GameObject>? <Predicate>P;
[CompilerGenerated]
private Action<GameObject>? <Action>P;
private readonly List<SceneTreeQueryNode> Children;
public SceneTreeQueryNode(Predicate<GameObject>? Predicate = null, Action<GameObject>? Action = null)
{
<Predicate>P = Predicate;
<Action>P = Action;
Children = new List<SceneTreeQueryNode>();
base..ctor();
}
public bool Matches(GameObject target)
{
return <Predicate>P?.Invoke(target) ?? true;
}
protected virtual void Run(GameObject target, int depth)
{
<Action>P?.Invoke(target);
foreach (var (target2, sceneTreeQueryNode) in from GameObject childGameObject in Util.GetChildrenOf(target)
from childNode in Children.Cast<SceneTreeQueryNode>()
where childNode.Matches(childGameObject)
select (childGameObject, childNode))
{
sceneTreeQueryNode.Run(target2);
}
}
public void Run(GameObject target)
{
Run(target, 0);
}
public void Run(IEnumerable<GameObject> targets)
{
foreach (GameObject target in targets)
{
Run(target);
}
}
public SceneTreeQueryNode Tap(Action<SceneTreeQueryNode> f)
{
f(this);
return this;
}
public SceneTreeQueryNode Child(SceneTreeQueryNode child)
{
Children.Add(child);
return child;
}
public SceneTreeQueryNode Child(Predicate<GameObject> predicate)
{
return Child(new SceneTreeQueryNode(predicate));
}
public SceneTreeQueryNode Child(Predicate<GameObject> predicate, Action<GameObject> action)
{
return Child(new SceneTreeQueryNode(predicate, action));
}
public void Tee(params Action<SceneTreeQueryNode>[] tees)
{
foreach (Action<SceneTreeQueryNode> action in tees)
{
action(this);
}
}
}
private Coroutine? AirportLoadCompleteCoroutine;
public const string Id = "gg.amgg.PeakLobbyParkour";
internal static ManualLogSource Log { get; private set; }
public static string Name => "LobbyParkour";
public static string Version => "0.1.0";
private void Awake()
{
Log = ((BaseUnityPlugin)this).Logger;
SceneManager.sceneLoaded += OnSceneLoaded;
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
if (((Scene)(ref scene)).path == "Assets/8_SCENES/Airport.unity")
{
Log.LogInfo((object)"started loading airport scene...");
if (AirportLoadCompleteCoroutine != null)
{
((MonoBehaviour)this).StopCoroutine(AirportLoadCompleteCoroutine);
AirportLoadCompleteCoroutine = null;
}
AirportLoadCompleteCoroutine = ((MonoBehaviour)this).StartCoroutine(PatchAfterLoadFinished());
}
IEnumerator PatchAfterLoadFinished()
{
while (LoadingScreenHandler.loading)
{
yield return null;
}
PatchAirportScene(scene);
}
}
private void PatchAirportScene(Scene scene)
{
Log.LogInfo((object)"finished loading airport scene, patching it now");
int num = LayerMask.NameToLayer("Terrain");
int? num2 = ((num != -1) ? new int?(num) : null);
int? terrainLayer = num2;
new SceneTreeQueryNode.Epsilon().Tap(delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "Map").Tee(delegate(SceneTreeQueryNode n)
{
n.Child(delegate(GameObject o)
{
if (o != null)
{
switch (((Object)o).name)
{
case "Flight Board":
case "Flight Board (1)":
case "Flight Board (2)":
case "Flight Board (3)":
case "Boarding Sign":
return true;
}
}
return false;
}, makeClimbable);
}, delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "BL_Airport").Tee(delegate(SceneTreeQueryNode n)
{
n.Child(delegate(GameObject o)
{
if (o != null)
{
string name3 = ((Object)o).name;
if (name3 == "OutofBoundsBlockers" || name3 == "OutofBoundsBlockers (1)")
{
return true;
}
}
return false;
}, delegate(GameObject o)
{
o.SetActive(false);
});
}, delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "Main Meshes").Tee(delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "Schaffold", makeClimbable);
}, delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "Climbing wall blockers").Child((GameObject _) => true, delegate(GameObject o)
{
o.SetActive(false);
});
}, delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "Airport (1)Roof").Child((GameObject _) => true, makeClimbable);
}, delegate(SceneTreeQueryNode n)
{
n.Child(delegate(GameObject o)
{
if (o != null)
{
string name2 = ((Object)o).name;
if (name2 == "Cube" || name2 == "Cube (1)")
{
return true;
}
}
return false;
}, makeClimbable);
}, delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "Carpet", makeClimbable);
}, delegate(SceneTreeQueryNode n)
{
n.Child(delegate(GameObject o)
{
if (o != null)
{
string name = ((Object)o).name;
if (name == "Outside grid" || name == "Outside grid (1)")
{
return true;
}
}
return false;
}, makeClimbable);
});
}, delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "Lights").Child((GameObject _) => true, makeClimbable);
}, delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "Displays").Child((GameObject _) => true, makeClimbable);
}, delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "GlassFence", makeClimbable);
}, delegate(SceneTreeQueryNode n)
{
n.Child(delegate(GameObject o)
{
if (o != null)
{
switch (((Object)o).name)
{
case "Plane":
case "Plane (1)":
case "Plane (2)":
return true;
}
}
return false;
}, makeClimbable).Child((GameObject _) => true, makeClimbable);
});
}, delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "Mirror (1)").Tee(delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "Mirror").Child((GameObject o) => o != null && ((Object)o).name == "Mirror Collider", makeClimbable);
}, delegate(SceneTreeQueryNode n)
{
n.Child((GameObject o) => o != null && ((Object)o).name == "Details").Child(delegate(GameObject o)
{
if (o != null)
{
switch (((Object)o).name)
{
case "Cube (10)":
case "Cube (9)":
case "Cube (2)":
case "Cube (1)":
return true;
}
}
return false;
}, makeClimbable);
});
});
}).Run((IEnumerable<GameObject>)((Scene)(ref scene)).GetRootGameObjects());
void makeClimbable(GameObject target)
{
if (terrainLayer.HasValue)
{
int valueOrDefault = terrainLayer.GetValueOrDefault();
target.layer = valueOrDefault;
}
Log.LogInfo((object)$"makeClimbable({target})");
if (target.GetComponent<MeshCollider>() == null)
{
MeshFilter component = target.GetComponent<MeshFilter>();
if (component != null)
{
Mesh sharedMesh = component.sharedMesh;
if (sharedMesh != null)
{
MeshCollider val = target.AddComponent<MeshCollider>();
Log.LogInfo((object)$"adding collider to {target} with mesh {component.sharedMesh}, which is (readable?{sharedMesh.isReadable})");
val.sharedMesh = Util.EnsureMeshReadable(sharedMesh);
}
}
}
}
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
