Decompiled source of Rope Carabiner v1.2.2

plugins/RopeCarabiner.dll

Decompiled 3 weeks ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Peak.UI;
using Photon.Pun;
using Photon.Realtime;
using Repkarbinhake.Core.Data;
using Repkarbinhake.Core.Interaction;
using Repkarbinhake.Core.Links;
using Repkarbinhake.Core.Physics;
using Repkarbinhake.Core.Visual;
using Repkarbinhake.Plugin.Data;
using Repkarbinhake.Plugin.Debugging;
using Repkarbinhake.Plugin.Handling;
using Repkarbinhake.Plugin.Input;
using Repkarbinhake.Plugin.Links;
using Repkarbinhake.Plugin.Network;
using Repkarbinhake.Plugin.Patches;
using Repkarbinhake.Plugin.Visual;
using Repkarbinhake.Unity;
using TMPro;
using UnityEngine;
using UnityEngine.Animations.Rigging;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Zorro.Core;

[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("RopeCarabiner")]
[assembly: AssemblyConfiguration("Public")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+ac76b6777b459940e35cb375d55fd2d252e755a4")]
[assembly: AssemblyProduct("RopeCarabiner")]
[assembly: AssemblyTitle("RopeCarabiner")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 Repkarbinhake.Unity
{
	public interface IColliderFilter
	{
		bool Ignores(Collider collider);

		ShellShape ShellOf(Collider collider);
	}
	public sealed class NoColliderFilter : IColliderFilter
	{
		public bool Ignores(Collider collider)
		{
			return false;
		}

		public ShellShape ShellOf(Collider collider)
		{
			return ShellShape.None;
		}
	}
	public sealed class PhysicsRopeObstacles : IRopeObstacles
	{
		private const float MinimumTravel = 0.0001f;

		private const int MaxOverlaps = 16;

		private const float ShellProbe = 0.75f;

		private const float ShellReachScale = 2f;

		private const int MaxHits = 16;

		private const string ProbeName = "Repkarbinhake Rope Probe";

		private const string ProbeLayer = "Ignore Raycast";

		private static readonly Vector3 ProbeParkingPosition = new Vector3(0f, -10000f, 0f);

		private readonly int _layerMask;

		private readonly IColliderFilter _filter;

		private readonly SphereCollider _probe;

		private readonly Collider[] _overlaps = (Collider[])(object)new Collider[16];

		private readonly RaycastHit[] _hits = (RaycastHit[])(object)new RaycastHit[16];

		public PhysicsRopeObstacles(int layerMask, Transform parent, IColliderFilter filter)
		{
			//IL_0033: 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_0049: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			_layerMask = layerMask;
			_filter = filter;
			GameObject val = new GameObject("Repkarbinhake Rope Probe")
			{
				layer = LayerMask.NameToLayer("Ignore Raycast")
			};
			val.transform.SetParent(parent, false);
			val.transform.position = ProbeParkingPosition;
			_probe = val.AddComponent<SphereCollider>();
			((Collider)_probe).isTrigger = true;
		}

		public Vector3 Resolve(Vector3 from, Vector3 to, float radius)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			Vector3 point = Sweep(from.ToUnity(), to.ToUnity(), radius);
			return Depenetrate(point, radius).ToNumerics();
		}

		public bool TryHit(Vector3 from, Vector3 to, float radius, out Vector3 point, out Vector3 normal)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			point = Vector3.Zero;
			normal = Vector3.Zero;
			if (!TryCast(from.ToUnity(), to.ToUnity(), radius, out var nearest))
			{
				return false;
			}
			point = ((RaycastHit)(ref nearest)).point.ToNumerics();
			normal = ((RaycastHit)(ref nearest)).normal.ToNumerics();
			return true;
		}

		private bool TryCast(Vector3 start, Vector3 end, float radius, out RaycastHit nearest)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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)
			//IL_0022: 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_0026: 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)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			nearest = default(RaycastHit);
			Vector3 val = end - start;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 0.0001f)
			{
				return false;
			}
			int num = Physics.SphereCastNonAlloc(start, radius, val / magnitude, _hits, magnitude, _layerMask, (QueryTriggerInteraction)1);
			bool flag = false;
			for (int i = 0; i < num; i++)
			{
				RaycastHit val2 = _hits[i];
				if ((!(((RaycastHit)(ref val2)).distance <= 0f) || !(((RaycastHit)(ref val2)).point == Vector3.zero)) && (!flag || !(((RaycastHit)(ref val2)).distance >= ((RaycastHit)(ref nearest)).distance)) && !_filter.Ignores(((RaycastHit)(ref val2)).collider))
				{
					nearest = val2;
					flag = true;
				}
			}
			return flag;
		}

		private Vector3 Sweep(Vector3 start, Vector3 end, float radius)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_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)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!TryCast(start, end, radius, out var nearest))
			{
				return end;
			}
			Vector3 val = ((RaycastHit)(ref nearest)).point + ((RaycastHit)(ref nearest)).normal * radius;
			return val + Vector3.ProjectOnPlane(end - val, ((RaycastHit)(ref nearest)).normal);
		}

		private Vector3 Depenetrate(Vector3 point, float radius)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			_probe.radius = radius;
			int num = Physics.OverlapSphereNonAlloc(point, Mathf.Max(radius, 0.75f), _overlaps, _layerMask, (QueryTriggerInteraction)1);
			Vector3 val2 = default(Vector3);
			float num2 = default(float);
			for (int i = 0; i < num; i++)
			{
				Collider val = _overlaps[i];
				if (!_filter.Ignores(val))
				{
					ShellShape shellShape = _filter.ShellOf(val);
					if (shellShape != ShellShape.None)
					{
						point = KeepOutside(point, radius, val, shellShape);
					}
					else if (Physics.ComputePenetration((Collider)(object)_probe, point, Quaternion.identity, val, ((Component)val).transform.position, ((Component)val).transform.rotation, ref val2, ref num2))
					{
						point += val2 * num2;
					}
				}
			}
			return point;
		}

		private Vector3 KeepOutside(Vector3 point, float radius, Collider shell, ShellShape shape)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0047: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			Bounds bounds = shell.bounds;
			if (shape == ShellShape.Top && point.y < ((Bounds)(ref bounds)).min.y - radius)
			{
				return point;
			}
			Vector3 val = (Vector3)(shape switch
			{
				ShellShape.Slab => SlabOutward(point, bounds), 
				ShellShape.Top => Vector3.up, 
				_ => RoundOutward(point, bounds), 
			});
			Vector3 extents = ((Bounds)(ref bounds)).extents;
			float num = ((Vector3)(ref extents)).magnitude * 2f + radius;
			bool queriesHitBackfaces = Physics.queriesHitBackfaces;
			Physics.queriesHitBackfaces = true;
			RaycastHit val2 = default(RaycastHit);
			bool num2 = shell.Raycast(new Ray(point + val * num, -val), ref val2, num + radius);
			Physics.queriesHitBackfaces = queriesHitBackfaces;
			if (!num2)
			{
				return point;
			}
			return ((RaycastHit)(ref val2)).point + val * radius;
		}

		private Vector3 RoundOutward(Vector3 point, Bounds bounds)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0024: 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)
			Vector3 val = point - ((Bounds)(ref bounds)).center;
			if (!(((Vector3)(ref val)).sqrMagnitude < 0.0001f))
			{
				return ((Vector3)(ref val)).normalized;
			}
			return Vector3.up;
		}

		private Vector3 SlabOutward(Vector3 point, Bounds bounds)
		{
			//IL_0002: 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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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)
			//IL_0062: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			Vector3 extents = ((Bounds)(ref bounds)).extents;
			Vector3 val = ((extents.y <= extents.x && extents.y <= extents.z) ? Vector3.up : ((extents.x <= extents.z) ? Vector3.right : Vector3.forward));
			if (!(Vector3.Dot(point - ((Bounds)(ref bounds)).center, val) < 0f))
			{
				return val;
			}
			return -val;
		}
	}
	[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))]
	public sealed class RopeTubeView : MonoBehaviour
	{
		private const int Sides = 6;

		private const float FullTurn = MathF.PI * 2f;

		private const float NearlyVertical = 0.9f;

		private static readonly int InteractableProperty = Shader.PropertyToID("_Interactable");

		private static readonly int EmissionColorProperty = Shader.PropertyToID("_EmissionColor");

		private readonly List<Vector3> _vertices = new List<Vector3>();

		private readonly List<Vector3> _normals = new List<Vector3>();

		private readonly List<Vector2> _uvs = new List<Vector2>();

		private readonly List<int> _triangles = new List<int>();

		private Mesh _mesh;

		private MeshRenderer _renderer;

		private MaterialPropertyBlock _properties;

		private Color _highlightEmission;

		private float _radius;

		private int _builtRings;

		public void Initialize(MeshFilter filter, MeshRenderer meshRenderer, Material material, float radius, Color highlightEmission)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_004c: 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)
			_mesh = new Mesh
			{
				name = "RopeTubeView"
			};
			_mesh.MarkDynamic();
			filter.sharedMesh = _mesh;
			_renderer = meshRenderer;
			((Renderer)_renderer).sharedMaterial = material;
			_properties = new MaterialPropertyBlock();
			_highlightEmission = highlightEmission;
			_radius = radius;
		}

		public void Render(IReadOnlyList<Vector3> points)
		{
			if (points.Count >= 2)
			{
				if (points.Count != _builtRings)
				{
					RebuildTopology(points.Count);
				}
				WriteRings(points);
				_mesh.SetVertices(_vertices);
				_mesh.SetNormals(_normals);
				_mesh.RecalculateBounds();
			}
		}

		public void Highlight()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			ApplyHighlight(1f, _highlightEmission);
		}

		public void Unhighlight()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ApplyHighlight(0f, Color.black);
		}

		public void ChangeMaterial(Material material)
		{
			((Renderer)_renderer).sharedMaterial = material;
		}

		private void ApplyHighlight(float interactable, Color emission)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			((Renderer)_renderer).GetPropertyBlock(_properties);
			_properties.SetFloat(InteractableProperty, interactable);
			_properties.SetColor(EmissionColorProperty, emission);
			((Renderer)_renderer).SetPropertyBlock(_properties);
		}

		private void RebuildTopology(int rings)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			_builtRings = rings;
			_triangles.Clear();
			_uvs.Clear();
			_vertices.Clear();
			_normals.Clear();
			for (int i = 0; i < rings; i++)
			{
				for (int j = 0; j <= 6; j++)
				{
					_uvs.Add(new Vector2((float)j / 6f, (float)i));
					_vertices.Add(Vector3.zero);
					_normals.Add(Vector3.up);
				}
			}
			int num = 7;
			for (int k = 0; k < rings - 1; k++)
			{
				for (int l = 0; l < 6; l++)
				{
					int num2 = k * num + l;
					int num3 = num2 + num;
					_triangles.Add(num2);
					_triangles.Add(num3);
					_triangles.Add(num2 + 1);
					_triangles.Add(num2 + 1);
					_triangles.Add(num3);
					_triangles.Add(num3 + 1);
				}
			}
			_mesh.Clear();
			_mesh.SetVertices(_vertices);
			_mesh.SetNormals(_normals);
			_mesh.SetUVs(0, _uvs);
			_mesh.SetTriangles(_triangles, 0);
		}

		private void WriteRings(IReadOnlyList<Vector3> points)
		{
			//IL_0002: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			int num = 7;
			Vector3 val = Vector3.zero;
			for (int i = 0; i < points.Count; i++)
			{
				Vector3 val2 = ((Component)this).transform.InverseTransformPoint(points[i].ToUnity());
				Vector3 val3 = Tangent(points, i);
				Vector3 val5;
				if (i != 0)
				{
					Vector3 val4 = Vector3.ProjectOnPlane(val, val3);
					val5 = ((Vector3)(ref val4)).normalized;
				}
				else
				{
					val5 = Perpendicular(val3);
				}
				Vector3 val6 = val5;
				if (((Vector3)(ref val6)).sqrMagnitude < Mathf.Epsilon)
				{
					val6 = Perpendicular(val3);
				}
				val = val6;
				Vector3 val7 = Vector3.Cross(val3, val6);
				for (int j = 0; j <= 6; j++)
				{
					float num2 = (float)j / 6f * (MathF.PI * 2f);
					Vector3 val8 = val6 * Mathf.Cos(num2) + val7 * Mathf.Sin(num2);
					_vertices[i * num + j] = val2 + val8 * _radius;
					_normals[i * num + j] = val8;
				}
			}
		}

		private Vector3 Tangent(IReadOnlyList<Vector3> points, int index)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			int index2 = Mathf.Max(index - 1, 0);
			int index3 = Mathf.Min(index + 1, points.Count - 1);
			Vector3 val = ((Component)this).transform.InverseTransformDirection((points[index3] - points[index2]).ToUnity());
			if (!(((Vector3)(ref val)).sqrMagnitude < Mathf.Epsilon))
			{
				return ((Vector3)(ref val)).normalized;
			}
			return Vector3.up;
		}

		private Vector3 Perpendicular(Vector3 tangent)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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)
			Vector3 val = ((Mathf.Abs(Vector3.Dot(tangent, Vector3.up)) > 0.9f) ? Vector3.right : Vector3.up);
			Vector3 val2 = Vector3.Cross(tangent, val);
			return ((Vector3)(ref val2)).normalized;
		}
	}
	public enum ShellShape
	{
		None,
		Round,
		Slab,
		Top
	}
	public static class VectorConversion
	{
		public static Vector3 ToNumerics(this Vector3 vector)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(vector.x, vector.y, vector.z);
		}

		public static Vector3 ToUnity(this Vector3 vector)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(vector.X, vector.Y, vector.Z);
		}
	}
}
namespace Repkarbinhake.Core.Visual
{
	public interface IRopeObstacles
	{
		Vector3 Resolve(Vector3 from, Vector3 to, float radius);

		bool TryHit(Vector3 from, Vector3 to, float radius, out Vector3 point, out Vector3 normal);
	}
	public readonly struct RopeLengthState
	{
		public float Total { get; }

		public float FirstReel { get; }

		public float SecondReel { get; }

		public RopeLengthState(float total, float firstReel, float secondReel)
		{
			Total = total;
			FirstReel = firstReel;
			SecondReel = secondReel;
		}
	}
	public sealed class RopeLooseness
	{
		public const float Damping = 0.97f;

		public const int Iterations = 8;

		private const float LengthAllowance = 1.02f;

		private const float SharedCorrection = 0.5f;

		private const float MaxStep = 1f / 30f;

		private readonly List<Vector3> _positions = new List<Vector3>();

		private readonly List<Vector3> _previous = new List<Vector3>();

		public IReadOnlyList<Vector3> Positions => _positions;

		public void Step(IReadOnlyList<Vector3> targets, IReadOnlyList<float> freedoms, IReadOnlyList<float> spacings, Vector3 gravity, float deltaTime, float radius, IRopeObstacles obstacles)
		{
			if (_positions.Count != targets.Count)
			{
				Reset(targets);
			}
			float num = Math.Clamp(deltaTime, 0f, 1f / 30f);
			Vector3 vector = gravity * num * num;
			int num2 = _positions.Count - 1;
			for (int i = 0; i <= num2; i++)
			{
				Vector3 vector2 = _positions[i];
				Vector3 value = ((freedoms[i] <= 0f) ? targets[i] : (vector2 + (vector2 - _previous[i]) * 0.97f + vector));
				_previous[i] = ((freedoms[i] <= 0f) ? targets[i] : vector2);
				_positions[i] = value;
			}
			for (int j = 0; j < 8; j++)
			{
				KeepSpacing(spacings, freedoms);
				Tether(targets, freedoms);
			}
			Collide(targets, freedoms, radius, obstacles);
		}

		public void Clear()
		{
			_positions.Clear();
			_previous.Clear();
		}

		public void Reset(IReadOnlyList<Vector3> targets)
		{
			_positions.Clear();
			_previous.Clear();
			_positions.AddRange(targets);
			_previous.AddRange(targets);
		}

		private void KeepSpacing(IReadOnlyList<float> spacings, IReadOnlyList<float> freedoms)
		{
			for (int i = 0; i < _positions.Count - 1; i++)
			{
				float num = spacings[i] * 1.02f;
				Vector3 vector = _positions[i + 1] - _positions[i];
				float num2 = vector.Length();
				if (num2 <= num || num2 < float.Epsilon)
				{
					continue;
				}
				Vector3 vector2 = vector * ((num2 - num) / num2);
				bool flag = freedoms[i] <= 0f;
				bool flag2 = freedoms[i + 1] <= 0f;
				if (!(flag && flag2))
				{
					if (flag)
					{
						_positions[i + 1] -= vector2;
						continue;
					}
					if (flag2)
					{
						_positions[i] += vector2;
						continue;
					}
					_positions[i] += vector2 * 0.5f;
					_positions[i + 1] -= vector2 * 0.5f;
				}
			}
		}

		private void Tether(IReadOnlyList<Vector3> targets, IReadOnlyList<float> freedoms)
		{
			for (int i = 0; i < _positions.Count; i++)
			{
				Vector3 vector = _positions[i] - targets[i];
				float num = vector.Length();
				if (num > freedoms[i])
				{
					_positions[i] = ((num < float.Epsilon) ? targets[i] : (targets[i] + vector * (freedoms[i] / num)));
				}
			}
		}

		private void Collide(IReadOnlyList<Vector3> targets, IReadOnlyList<float> freedoms, float radius, IRopeObstacles obstacles)
		{
			if (obstacles == null)
			{
				return;
			}
			for (int i = 0; i < _positions.Count; i++)
			{
				if (freedoms[i] > 0f)
				{
					_positions[i] = obstacles.Resolve(targets[i], _positions[i], radius);
				}
			}
		}
	}
	public sealed class RopePathCodec
	{
		private const int Axes = 3;

		public float[] Encode(IReadOnlyList<Vector3> points, IReadOnlyList<float> materials)
		{
			int num = points.Count - 2;
			float[] array = new float[1 + num * 3 + materials.Count];
			array[0] = num;
			int num2 = 1;
			for (int i = 1; i <= num; i++)
			{
				array[num2++] = points[i].X;
				array[num2++] = points[i].Y;
				array[num2++] = points[i].Z;
			}
			foreach (float material in materials)
			{
				array[num2++] = material;
			}
			return array;
		}

		public bool TryDecode(float[] data, List<Vector3> contacts, List<float> materials)
		{
			contacts.Clear();
			materials.Clear();
			if (data == null || data.Length < 1)
			{
				return false;
			}
			int num = (int)data[0];
			if (num < 0 || num > 24 || data.Length != 1 + num * 3 + num + 1)
			{
				return false;
			}
			int num2 = 1;
			for (int i = 0; i < num; i++)
			{
				contacts.Add(new Vector3(data[num2], data[num2 + 1], data[num2 + 2]));
				num2 += 3;
			}
			for (int j = 0; j <= num; j++)
			{
				materials.Add(data[num2++]);
			}
			return true;
		}
	}
	public sealed class RopeRayPicker
	{
		private const float ParallelThreshold = 1E-06f;

		public bool TryPick(Vector3 origin, Vector3 direction, float maxDistance, float tolerance, IReadOnlyList<Vector3> points, out float hitDistance)
		{
			hitDistance = float.MaxValue;
			bool result = false;
			float num = tolerance * tolerance;
			for (int i = 1; i < points.Count; i++)
			{
				ClosestBetweenRayAndSegment(origin, direction, points[i - 1], points[i], out var rayDistance, out var gapSquared);
				if (!(gapSquared > num) && !(rayDistance < 0f) && !(rayDistance > maxDistance) && !(rayDistance >= hitDistance))
				{
					hitDistance = rayDistance;
					result = true;
				}
			}
			return result;
		}

		private void ClosestBetweenRayAndSegment(Vector3 origin, Vector3 direction, Vector3 start, Vector3 end, out float rayDistance, out float gapSquared)
		{
			Vector3 vector = end - start;
			Vector3 vector2 = origin - start;
			float num = Vector3.Dot(vector, vector);
			float num2 = Vector3.Dot(direction, vector);
			float num3 = Vector3.Dot(direction, vector2);
			float num4 = Vector3.Dot(vector, vector2);
			float num5 = num - num2 * num2;
			float value = ((num5 > 1E-06f) ? ((num4 - num2 * num3) / num5) : 0f);
			value = ((num > 1E-06f) ? Math.Clamp(value, 0f, 1f) : 0f);
			Vector3 vector3 = start + vector * value;
			rayDistance = Vector3.Dot(vector3 - origin, direction);
			Vector3 value2 = origin + direction * rayDistance;
			gapSquared = Vector3.DistanceSquared(value2, vector3);
		}
	}
	public sealed class RopeSag
	{
		public const float MaxFreedom = 0.45f;

		public const float TautFreedom = 0.03f;

		private const float MinSideways = 0.1f;

		private const float PeakFactor = 4f;

		private const float FreedomPerDepth = 0.8f;

		private const int DepthSearchSteps = 20;

		public void Build(RopeWrapPath path, Vector3 down, int bones, float radius, IRopeObstacles obstacles, List<Vector3> points, List<float> freedoms, List<float> spacings)
		{
			points.Clear();
			freedoms.Clear();
			spacings.Clear();
			IReadOnlyList<Vector3> points2 = path.Points;
			if (points2.Count < 2)
			{
				return;
			}
			float num = path.PathLength();
			points.Add(points2[0]);
			freedoms.Add(0f);
			for (int i = 0; i < points2.Count - 1; i++)
			{
				float num2 = path.Chord(i);
				float num3 = ((num < float.Epsilon) ? 1f : (num2 / num));
				int num4 = Math.Max(1, (int)MathF.Round((float)bones * num3));
				float slack = MathF.Max(path.Materials[i] - num2, 0f);
				AddSegment(points2[i], points2[i + 1], slack, down, num4, radius, obstacles, points, freedoms);
				for (int j = 0; j < num4; j++)
				{
					spacings.Add(path.Materials[i] / (float)num4);
				}
			}
		}

		public static float SagDepth(float chord, float material)
		{
			if (material <= chord || chord < float.Epsilon)
			{
				return 0f;
			}
			float num = 0f;
			float num2 = material;
			for (int i = 0; i < 20; i++)
			{
				float num3 = (num + num2) * 0.5f;
				if (ParabolaLength(chord, num3) < material)
				{
					num = num3;
				}
				else
				{
					num2 = num3;
				}
			}
			return (num + num2) * 0.5f;
		}

		public static float ParabolaLength(float chord, float depth)
		{
			if (depth < float.Epsilon)
			{
				return chord;
			}
			float num = 4f * depth / chord;
			float num2 = MathF.Sqrt(1f + num * num);
			return chord * 0.5f * num2 + chord * chord / (8f * depth) * MathF.Log(num + num2);
		}

		private void AddSegment(Vector3 from, Vector3 to, float slack, Vector3 down, int count, float radius, IRopeObstacles obstacles, List<Vector3> points, List<float> freedoms)
		{
			Vector3 vector = to - from;
			float num = vector.Length();
			Vector3 vector2 = ((num < float.Epsilon) ? Vector3.Zero : (vector / num));
			Vector3 vector3 = down - vector2 * Vector3.Dot(down, vector2);
			float num2 = 0f;
			if (vector3.Length() >= 0.1f && slack > 0f)
			{
				vector3 = Vector3.Normalize(vector3);
				num2 = SagDepth(num, num + slack);
			}
			float num3 = MathF.Min(0.45f, 0.03f + MathF.Max(num2, slack) * 0.8f);
			for (int i = 1; i < count; i++)
			{
				float num4 = (float)i / (float)count;
				Vector3 vector4 = Vector3.Lerp(from, to, num4);
				Vector3 vector5 = vector4 + vector3 * (num2 * 4f * num4 * (1f - num4));
				if (obstacles != null && obstacles.TryHit(vector4, vector5, radius, out var point, out var normal))
				{
					vector5 = point + normal * radius;
				}
				points.Add(vector5);
				freedoms.Add(num3 * MathF.Sin(MathF.PI * num4));
			}
			points.Add(to);
			freedoms.Add(0f);
		}
	}
	public sealed class RopeSegmentation
	{
		public const int MinSegments = 4;

		private const float MinSegmentLength = 0.01f;

		private readonly ISegmentSettings _settings;

		public RopeSegmentation(ISegmentSettings settings)
		{
			_settings = settings;
		}

		public int Count(float length, int ropeCount)
		{
			return Math.Clamp((int)MathF.Ceiling(length / MathF.Max(_settings.SegmentLength, 0.01f)), 4, Cap(ropeCount));
		}

		public int Cap(int ropeCount)
		{
			if (_settings.SegmentMode == SegmentMode.Fixed)
			{
				return Math.Max(_settings.FixedSegments, 4);
			}
			return Math.Clamp(_settings.SegmentBudget / Math.Max(ropeCount, 1), 4, Math.Max(_settings.AutoMaxSegments, 4));
		}
	}
	public sealed class RopeWrapPath
	{
		public const int MaxContacts = 24;

		public const float ContactLift = 2f;

		public const float TautTolerance = 0.01f;

		public const float MaxEndJump = 3f;

		private const float MinGap = 2f;

		private const int EdgeSearchSteps = 10;

		private const float SlackFlowRate = 4f;

		private const float MinMaterial = 0.01f;

		private const float FollowRate = 10f;

		private const float ClimbFriction = 0.36f;

		private const float ClimbSpeed = 2f;

		private const float ClimbClearance = 0.5f;

		private const float TightenReach = 0.5f;

		private const int TightenSteps = 6;

		private static readonly Vector3[] ClimbBlends = new Vector3[7]
		{
			new Vector3(1f, 1f, 0f),
			new Vector3(1f, 1f, 1f),
			new Vector3(1f, 1f, -1f),
			new Vector3(0f, 1f, 1f),
			new Vector3(0f, 1f, -1f),
			new Vector3(1f, 2f, 0f),
			new Vector3(1f, 0f, 0f)
		};

		private readonly List<Vector3> _points = new List<Vector3>();

		private readonly List<float> _materials = new List<float>();

		private readonly List<Vector3> _remoteContacts = new List<Vector3>();

		private readonly List<float> _remoteMaterials = new List<float>();

		private Vector3 _lastStart;

		private Vector3 _lastEnd;

		private float _lastFirstReel;

		private float _lastSecondReel;

		private int _climbTurn;

		public IReadOnlyList<Vector3> Points => _points;

		public IReadOnlyList<float> Materials => _materials;

		public int ContactCount
		{
			get
			{
				if (_points.Count >= 2)
				{
					return _points.Count - 2;
				}
				return 0;
			}
		}

		public int Version { get; private set; }

		public bool IsFollowing { get; private set; }

		public void Update(Vector3 start, Vector3 end, RopeLengthState length, float radius, float deltaTime, IRopeObstacles obstacles)
		{
			if (_points.Count < 2 || Vector3.Distance(start, _lastStart) > 3f || Vector3.Distance(end, _lastEnd) > 3f)
			{
				Begin(start, end, length);
			}
			_points[0] = start;
			_points[_points.Count - 1] = end;
			if (IsFollowing)
			{
				FollowRemote(length, deltaTime);
			}
			else
			{
				Simulate(length, radius, deltaTime, obstacles);
			}
			_lastStart = start;
			_lastEnd = end;
			_lastFirstReel = length.FirstReel;
			_lastSecondReel = length.SecondReel;
		}

		public void Follow(IReadOnlyList<Vector3> contacts, IReadOnlyList<float> materials)
		{
			_remoteContacts.Clear();
			_remoteContacts.AddRange(contacts);
			_remoteMaterials.Clear();
			_remoteMaterials.AddRange(materials);
			IsFollowing = true;
		}

		public void Lead()
		{
			IsFollowing = false;
		}

		public float Chord(int segment)
		{
			return Vector3.Distance(_points[segment], _points[segment + 1]);
		}

		public bool IsTaut(int segment)
		{
			return _materials[segment] <= Chord(segment) * 1.01f;
		}

		public float PathLength()
		{
			float num = 0f;
			for (int i = 1; i < _points.Count; i++)
			{
				num += Vector3.Distance(_points[i - 1], _points[i]);
			}
			return num;
		}

		public bool TrySpan(bool fromStart, out RopeSpan span)
		{
			span = default(RopeSpan);
			if (_points.Count < 2)
			{
				return false;
			}
			int num = _points.Count - 1;
			Vector3 vector = (fromStart ? _points[0] : _points[num]);
			Vector3 vector2 = (fromStart ? _points[1] : _points[num - 1]) - vector;
			float num2 = vector2.Length();
			if (num2 < float.Epsilon)
			{
				return false;
			}
			span = new RopeSpan(vector2 / num2, PathLength());
			return true;
		}

		public void Clear()
		{
			_points.Clear();
			_materials.Clear();
		}

		private void Simulate(RopeLengthState length, float radius, float deltaTime, IRopeObstacles obstacles)
		{
			ApplyReel(length);
			Climb(radius, deltaTime, obstacles);
			Unwrap(radius, obstacles);
			WrapStart(radius, obstacles);
			WrapEnd(radius, obstacles);
			SeatLowerLip(radius, obstacles);
			FlowSlack(deltaTime);
		}

		private void FollowRemote(RopeLengthState length, float deltaTime)
		{
			Vector3 item = _points[0];
			Vector3 item2 = _points[_points.Count - 1];
			if (ContactCount != _remoteContacts.Count)
			{
				_points.Clear();
				_points.Add(item);
				_points.AddRange(_remoteContacts);
				_points.Add(item2);
				Version++;
			}
			else
			{
				float amount = Math.Clamp(10f * deltaTime, 0f, 1f);
				for (int i = 0; i < _remoteContacts.Count; i++)
				{
					_points[i + 1] = Vector3.Lerp(_points[i + 1], _remoteContacts[i], amount);
				}
			}
			_materials.Clear();
			if (_remoteMaterials.Count == _points.Count - 1)
			{
				_materials.AddRange(_remoteMaterials);
			}
			else
			{
				SpreadByChords(length.Total);
			}
			int index = _materials.Count - 1;
			_materials[index] = MathF.Max(_materials[index] + length.Total - Sum(), 0.01f);
		}

		private void Climb(float radius, float deltaTime, IRopeObstacles obstacles)
		{
			float radius2 = radius * 2f;
			Vector3 vector = ClimbBlends[_climbTurn];
			_climbTurn = (_climbTurn + 1) % ClimbBlends.Length;
			for (int i = 1; i < _points.Count - 1; i++)
			{
				if (!IsTaut(i - 1) || !IsTaut(i))
				{
					continue;
				}
				Vector3 vector2 = _points[i];
				Vector3 value = Direction(vector2, _points[i - 1]) + Direction(vector2, _points[i + 1]);
				if (value.LengthSquared() < float.Epsilon)
				{
					continue;
				}
				Vector3 vector3 = Vector3.Normalize(value);
				Vector3 value2 = Vector3.Cross(vector3, Vector3.UnitY);
				if (!(value2.LengthSquared() < float.Epsilon))
				{
					Vector3 vector4 = Vector3.Normalize(vector3 * vector.X + Vector3.UnitY * vector.Y + Vector3.Normalize(value2) * vector.Z);
					Vector3 vector5 = obstacles.Resolve(vector2, vector2 + vector4 * 2f * deltaTime, radius2);
					if (CanClimb(i, vector2, vector5, value.Length(), radius, obstacles))
					{
						_points[i] = vector5;
					}
				}
			}
		}

		private void SeatLowerLip(float radius, IRopeObstacles obstacles)
		{
			if (ContactCount != 0)
			{
				int num = _points.Count - 1;
				bool flag = _points[0].Y <= _points[num].Y;
				int index = ((!flag) ? num : 0);
				int index2 = (flag ? 1 : (num - 1));
				if (ContactCount < 24 && TryFindLipEdge(_points[index], _points[index2], radius, obstacles, out var edge))
				{
					Split(flag ? 1 : num, edge);
					index2 = (flag ? 1 : (_points.Count - 2));
				}
				Tighten(index2, radius, obstacles);
			}
		}

		private bool TryFindLipEdge(Vector3 end, Vector3 lip, float radius, IRopeObstacles obstacles, out Vector3 edge)
		{
			edge = Vector3.Zero;
			if (!obstacles.TryHit(end, lip, radius, out var point, out var normal))
			{
				return false;
			}
			Vector3 vector = end + Vector3.UnitY * Vector3.Distance(end, lip);
			if (!obstacles.TryHit(end, vector, radius, out normal, out point))
			{
				return TryFindEdge(end, vector, end, lip, radius, obstacles, out edge);
			}
			return false;
		}

		private void Tighten(int index, float radius, IRopeObstacles obstacles)
		{
			if (!IsTaut(index - 1) || !IsTaut(index))
			{
				return;
			}
			Vector3 vector = _points[index];
			Vector3 value = Direction(vector, _points[index - 1]) + Direction(vector, _points[index + 1]);
			if (value.LengthSquared() < float.Epsilon)
			{
				return;
			}
			Vector3 vector2 = Vector3.Normalize(value);
			if (vector2.Y < 0f)
			{
				return;
			}
			float num = 0f;
			float num2 = 0.5f;
			for (int i = 0; i < 6; i++)
			{
				float num3 = (num + num2) * 0.5f;
				if (IsSeatClear(index, vector, vector + vector2 * num3, radius, obstacles))
				{
					num = num3;
				}
				else
				{
					num2 = num3;
				}
			}
			if (num > 0f)
			{
				_points[index] = vector + vector2 * num;
			}
		}

		private bool IsSeatClear(int index, Vector3 contact, Vector3 candidate, float radius, IRopeObstacles obstacles)
		{
			if (!obstacles.TryHit(contact, candidate, radius * 2f, out var point, out var normal) && !obstacles.TryHit(_points[index - 1], candidate, radius, out normal, out point))
			{
				return !obstacles.TryHit(candidate, _points[index + 1], radius, out point, out normal);
			}
			return false;
		}

		private bool CanClimb(int index, Vector3 contact, Vector3 candidate, float pull, float radius, IRopeObstacles obstacles)
		{
			float num = Vector3.Distance(contact, candidate);
			if (num < float.Epsilon || candidate.Y < contact.Y)
			{
				return false;
			}
			float num2 = (SpanThrough(index, contact) - SpanThrough(index, candidate)) / num;
			float num3 = MathF.Sqrt(MathF.Max(pull * pull - num2 * num2, 0f));
			if (num2 <= 0.36f * num3)
			{
				return false;
			}
			float radius2 = radius * 0.5f;
			if (!obstacles.TryHit(_points[index - 1], candidate, radius2, out var point, out var normal))
			{
				return !obstacles.TryHit(candidate, _points[index + 1], radius2, out normal, out point);
			}
			return false;
		}

		private void SpreadByChords(float total)
		{
			float num = PathLength();
			for (int i = 0; i < _points.Count - 1; i++)
			{
				_materials.Add((num < float.Epsilon) ? (total / (float)(_points.Count - 1)) : (total * Chord(i) / num));
			}
		}

		private void Begin(Vector3 start, Vector3 end, RopeLengthState length)
		{
			_points.Clear();
			_materials.Clear();
			_points.Add(start);
			_points.Add(end);
			_materials.Add(length.Total);
			_lastStart = start;
			_lastEnd = end;
			_lastFirstReel = length.FirstReel;
			_lastSecondReel = length.SecondReel;
			Version++;
		}

		private void ApplyReel(RopeLengthState length)
		{
			int segment = _materials.Count - 1;
			Take(segment, -1, length.FirstReel - _lastFirstReel);
			Take(0, 1, length.SecondReel - _lastSecondReel);
			_lastFirstReel = length.FirstReel;
			_lastSecondReel = length.SecondReel;
			float num = length.Total - Sum();
			if (MathF.Abs(num) > 0.01f)
			{
				Take(segment, -1, 0f - num);
			}
		}

		private void Take(int segment, int inward, float amount)
		{
			if (amount < 0f)
			{
				_materials[segment] -= amount;
				return;
			}
			for (int i = segment; i >= 0 && i < _materials.Count; i += inward)
			{
				if (!(amount > 0f))
				{
					break;
				}
				float num = MathF.Min(amount, MathF.Max(_materials[i] - 0.01f, 0f));
				_materials[i] -= num;
				amount -= num;
			}
		}

		private void FlowSlack(float deltaTime)
		{
			float num = Math.Clamp(4f * deltaTime, 0f, 1f);
			for (int i = 1; i < _points.Count - 1; i++)
			{
				int num2 = i - 1;
				if (!IsTaut(num2) || !IsTaut(i))
				{
					float num3 = Chord(num2);
					float num4 = Chord(i);
					float num5 = num3 + num4;
					if (!(num5 < float.Epsilon))
					{
						float num6 = ((_materials[num2] + _materials[i]) * num3 / num5 - _materials[num2]) * num;
						_materials[num2] += num6;
						_materials[i] -= num6;
					}
				}
			}
		}

		private void Unwrap(float radius, IRopeObstacles obstacles)
		{
			int num = 1;
			while (num < _points.Count - 1)
			{
				if (obstacles.TryHit(_points[num - 1], _points[num + 1], radius, out var _, out var _))
				{
					num++;
					continue;
				}
				_materials[num - 1] += _materials[num];
				_materials.RemoveAt(num);
				_points.RemoveAt(num);
				Version++;
				num = 1;
			}
		}

		private void WrapStart(float radius, IRopeObstacles obstacles)
		{
			while (ContactCount < 24)
			{
				Vector3 oldTo = ((ContactCount == 0) ? _lastEnd : _points[1]);
				if (!TryFindEdge(_lastStart, oldTo, _points[0], _points[1], radius, obstacles, out var contact) || IsCrowded(contact, 0, 1, radius))
				{
					break;
				}
				Split(1, contact);
			}
		}

		private void WrapEnd(float radius, IRopeObstacles obstacles)
		{
			while (ContactCount < 24)
			{
				int num = _points.Count - 1;
				if (!TryFindEdge(_points[num - 1], _lastEnd, _points[num - 1], _points[num], radius, obstacles, out var contact) || IsCrowded(contact, num - 1, num, radius))
				{
					break;
				}
				Split(num, contact);
			}
		}

		private void Split(int index, Vector3 contact)
		{
			int index2 = index - 1;
			float num = Vector3.Distance(_points[index2], contact);
			float num2 = Vector3.Distance(contact, _points[index]);
			float num3 = _materials[index2];
			float num4 = ((num + num2 < float.Epsilon) ? 0.5f : (num / (num + num2)));
			_points.Insert(index, contact);
			_materials[index2] = num3 * num4;
			_materials.Insert(index, num3 * (1f - num4));
			Version++;
		}

		private bool TryFindEdge(Vector3 oldFrom, Vector3 oldTo, Vector3 from, Vector3 to, float radius, IRopeObstacles obstacles, out Vector3 contact)
		{
			contact = Vector3.Zero;
			if (!obstacles.TryHit(from, to, radius, out var point, out var normal))
			{
				return false;
			}
			Vector3 vector = normal;
			if (!obstacles.TryHit(oldFrom, oldTo, radius, out var _, out var _))
			{
				float num = 0f;
				float num2 = 1f;
				for (int i = 0; i < 10; i++)
				{
					float num3 = (num + num2) * 0.5f;
					if (obstacles.TryHit(Vector3.Lerp(oldFrom, from, num3), Vector3.Lerp(oldTo, to, num3), radius, out var point3, out var normal3))
					{
						num2 = num3;
						point = point3;
						normal = normal3;
					}
					else
					{
						num = num3;
					}
				}
				Vector3 value = ClosestOnSegment(Vector3.Lerp(oldFrom, from, num), Vector3.Lerp(oldTo, to, num), point) - point;
				vector = ((value.LengthSquared() > float.Epsilon) ? Vector3.Normalize(value) : normal);
			}
			Vector3 vector2 = point + vector * (radius * 2f);
			contact = obstacles.Resolve(vector2, vector2, radius * 2f);
			return true;
		}

		private bool IsCrowded(Vector3 contact, int before, int after, float radius)
		{
			float num = radius * 2f;
			if (!(Vector3.Distance(contact, _points[before]) < num))
			{
				return Vector3.Distance(contact, _points[after]) < num;
			}
			return true;
		}

		private float Sum()
		{
			float num = 0f;
			foreach (float material in _materials)
			{
				num += material;
			}
			return num;
		}

		private float SpanThrough(int contact, Vector3 position)
		{
			return Vector3.Distance(_points[contact - 1], position) + Vector3.Distance(position, _points[contact + 1]);
		}

		private static Vector3 Direction(Vector3 from, Vector3 to)
		{
			Vector3 value = to - from;
			if (!(value.LengthSquared() < float.Epsilon))
			{
				return Vector3.Normalize(value);
			}
			return Vector3.Zero;
		}

		private static Vector3 ClosestOnSegment(Vector3 a, Vector3 b, Vector3 point)
		{
			Vector3 vector = b - a;
			float num = vector.LengthSquared();
			if (num < float.Epsilon)
			{
				return a;
			}
			float num2 = Math.Clamp(Vector3.Dot(point - a, vector) / num, 0f, 1f);
			return a + vector * num2;
		}
	}
}
namespace Repkarbinhake.Core.Physics
{
	public sealed class AnchorLength
	{
		public const float Slack = 0.2f;

		private bool _locked;

		private float _length = -1f;

		public bool IsLocked => _locked;

		public float Next(float pathLength, bool supported, bool falling, float minLength, float maxLength)
		{
			if (!_locked && falling && _length >= 0f)
			{
				_locked = true;
			}
			if (_locked && supported)
			{
				_locked = false;
			}
			if (!_locked)
			{
				_length = Math.Clamp(pathLength + 0.2f, minLength, maxLength);
			}
			return _length;
		}

		public float Retract(float amount, float closest)
		{
			if (_locked && _length > closest)
			{
				_length = Math.Max(_length - amount, closest);
			}
			return _length;
		}

		public void Reset()
		{
			_locked = false;
			_length = -1f;
		}
	}
	public sealed class LedgeAssist
	{
		public const float StuckSpeed = 0.3f;

		public const float StuckSeconds = 0.3f;

		public const float ProbeDistance = 0.6f;

		public const float ProbeRadius = 0.2f;

		public float StuckFor { get; private set; }

		public bool IsPushing { get; private set; }

		public Vector3 Adjust(Vector3 pull, Vector3 center, Vector3 velocity, bool canAssist, float push, float deltaTime, IRopeObstacles obstacles)
		{
			IsPushing = false;
			if (!canAssist || pull.LengthSquared() < float.Epsilon)
			{
				StuckFor = 0f;
				return pull;
			}
			Vector3 vector = Vector3.Normalize(pull);
			if (Vector3.Dot(velocity, vector) > 0.3f)
			{
				StuckFor = 0f;
				return pull;
			}
			StuckFor += deltaTime;
			if (StuckFor < 0.3f || !obstacles.TryHit(center, center + vector * 0.6f, 0.2f, out var _, out var normal))
			{
				return pull;
			}
			float num = Vector3.Dot(pull, normal);
			if (num >= 0f)
			{
				return pull;
			}
			IsPushing = true;
			return pull - normal * num + normal * push;
		}
	}
	public sealed class MantleAssist
	{
		public const float MaxLipHeight = 1.5f;

		public const float MinLipHeight = -0.5f;

		public const float StuckSpeed = 0.5f;

		public const float StuckSeconds = 0.4f;

		public const float PushSeconds = 2f;

		public const float ProbeHeight = 1.5f;

		public const float ProbeDepth = 3f;

		public const float ProbeRadius = 0.2f;

		public const float WalkableNormal = 0.7f;

		public const float StandHeight = 1f;

		public const float ArriveDistance = 0.3f;

		private float _pushedFor;

		public float StuckFor { get; private set; }

		public bool IsPushing { get; private set; }

		public Vector3 Target { get; private set; }

		public Vector3 Push(Vector3 center, Vector3 velocity, Vector3 lip, Vector3 beyondLip, bool canAssist, float step, float push, float deltaTime, IRopeObstacles obstacles)
		{
			if (!canAssist || step <= 0f || push <= 0f)
			{
				Reset();
				return Vector3.Zero;
			}
			if (IsPushing)
			{
				return KeepPushing(center, push, deltaTime);
			}
			float num = lip.Y - center.Y;
			if (num > 1.5f || num < -0.5f || velocity.Length() > 0.5f)
			{
				StuckFor = 0f;
				return Vector3.Zero;
			}
			StuckFor += deltaTime;
			if (StuckFor < 0.4f || !TryFindFooting(lip, beyondLip, step, obstacles, out var target))
			{
				return Vector3.Zero;
			}
			Target = target;
			IsPushing = true;
			_pushedFor = 0f;
			return KeepPushing(center, push, deltaTime);
		}

		public void Reset()
		{
			StuckFor = 0f;
			IsPushing = false;
			_pushedFor = 0f;
		}

		private Vector3 KeepPushing(Vector3 center, float push, float deltaTime)
		{
			_pushedFor += deltaTime;
			Vector3 value = Target - center;
			if (_pushedFor > 2f || value.Length() < 0.3f)
			{
				Reset();
				return Vector3.Zero;
			}
			return Vector3.Normalize(value) * push;
		}

		private bool TryFindFooting(Vector3 lip, Vector3 beyondLip, float step, IRopeObstacles obstacles, out Vector3 target)
		{
			target = Vector3.Zero;
			Vector3 value = beyondLip - lip;
			value.Y = 0f;
			if (value.LengthSquared() < float.Epsilon)
			{
				return false;
			}
			Vector3 vector = lip + Vector3.Normalize(value) * step + Vector3.UnitY * 1.5f;
			if (!obstacles.TryHit(vector, vector - Vector3.UnitY * 3f, 0.2f, out var point, out var normal) || normal.Y < 0.7f)
			{
				return false;
			}
			target = point + Vector3.UnitY * 1f;
			return true;
		}
	}
	public readonly struct ReelStep
	{
		public float Reel { get; }

		public float StaminaCost { get; }

		public ReelStep(float reel, float staminaCost)
		{
			Reel = reel;
			StaminaCost = staminaCost;
		}
	}
	public sealed class RopeReel
	{
		public const float MinReelInFactor = 0.15f;

		public const float AirborneReelOutFactor = 0.3f;

		private readonly IRopeSettings _settings;

		private readonly RopeHandPolicy _policy;

		public float FullLength => _settings.MaxLength;

		public RopeReel(IRopeSettings settings, RopeHandPolicy policy)
		{
			_settings = settings;
			_policy = policy;
		}

		public float EffectiveLength(RopeLink link)
		{
			return Math.Clamp(_settings.MaxLength - link.TotalReel, _settings.MinLength, _settings.MaxLength);
		}

		public ReelStep StepReel(RopeLink link, int actor, float scrollInput, float deltaTime, float load, Footing footing, float stamina)
		{
			float reel = link.EndOf(actor).Reel;
			if (scrollInput >= 0f)
			{
				return ReelOut(reel, scrollInput, deltaTime, footing);
			}
			if (!_policy.CanReelIn(footing))
			{
				return new ReelStep(reel, 0f);
			}
			float num = (0f - scrollInput) * _settings.ReelSpeed * ReelInFactor(load) * deltaTime;
			float num2 = StaminaPerMeter(load);
			if (num2 > 0f)
			{
				num = Math.Min(num, Math.Max(stamina, 0f) / num2);
			}
			float num3 = Math.Clamp(reel + num, 0f, MaxReel(link, actor));
			float num4 = Math.Max(num3 - reel, 0f);
			return new ReelStep(num3, num4 * num2);
		}

		public float ReelForLength(RopeLink link, int actor, float length)
		{
			float heldReel = link.EndOf(link.Partner(actor)).HeldReel;
			return Math.Clamp(_settings.MaxLength - heldReel - length, 0f, MaxReel(link, actor));
		}

		public float ReelInFactor(float load)
		{
			if (load <= 0f)
			{
				return 1f;
			}
			if (_settings.ArmStrength <= 0f)
			{
				return 0f;
			}
			return Math.Clamp(1f - load / _settings.ArmStrength, 0.15f, 1f);
		}

		public float StaminaPerMeter(float load)
		{
			if (load <= 0f)
			{
				return 0f;
			}
			float num = ((_settings.ArmStrength <= 0f) ? 1f : Math.Min(load / _settings.ArmStrength, 1f));
			return _settings.ReelStaminaPerMeter * num;
		}

		private ReelStep ReelOut(float current, float scrollInput, float deltaTime, Footing footing)
		{
			if (!_policy.CanReelOut(footing))
			{
				return new ReelStep(current, 0f);
			}
			float num = ((footing == Footing.Airborne) ? (_settings.ReelSpeed * 0.3f) : _settings.ReelSpeed);
			return new ReelStep(Math.Max(current - scrollInput * num * deltaTime, 0f), 0f);
		}

		private float MaxReel(RopeLink link, int actor)
		{
			float heldReel = link.EndOf(link.Partner(actor)).HeldReel;
			return Math.Max(_settings.MaxLength - _settings.MinLength - heldReel, 0f);
		}
	}
	public sealed class RopeSnatch
	{
		public const float MaxStepGrowth = 2f;

		private readonly Dictionary<string, float> _lastStretch = new Dictionary<string, float>();

		public float Measure(string linkKey, float stretch, float ownSeparatingSpeed, float deltaTime)
		{
			float value;
			bool num = _lastStretch.TryGetValue(linkKey, out value);
			_lastStretch[linkKey] = stretch;
			if (!num || stretch <= 0f || deltaTime <= 0f)
			{
				return 0f;
			}
			float num2 = stretch - MathF.Max(value, 0f);
			if (num2 > 2f)
			{
				return 0f;
			}
			return MathF.Max(num2 / deltaTime - ownSeparatingSpeed, 0f);
		}

		public void Forget(string linkKey)
		{
			_lastStretch.Remove(linkKey);
		}

		public void Clear()
		{
			_lastStretch.Clear();
		}
	}
	public readonly struct RopeSpan
	{
		public Vector3 Direction { get; }

		public float PathLength { get; }

		public RopeSpan(Vector3 direction, float pathLength)
		{
			Direction = direction;
			PathLength = pathLength;
		}

		public static RopeSpan Straight(Vector3 self, Vector3 partner)
		{
			Vector3 vector = partner - self;
			float num = vector.Length();
			return new RopeSpan((num > 0f) ? (vector / num) : Vector3.Zero, num);
		}
	}
	public sealed class StabilityResolver
	{
		private readonly IRopeSettings _settings;

		private readonly RopeHandPolicy _policy;

		private readonly IFootingSource _footing;

		private readonly HashSet<int> _visited = new HashSet<int>();

		private readonly HashSet<int> _group = new HashSet<int>();

		private readonly Queue<int> _frontier = new Queue<int>();

		public StabilityResolver(IRopeSettings settings, RopeHandPolicy policy, IFootingSource footing)
		{
			_settings = settings;
			_policy = policy;
			_footing = footing;
		}

		public float Resolve(int actor, IReadOnlyCollection<RopeLink> links)
		{
			if (!IsBracing(actor, links))
			{
				return 0f;
			}
			int num = CountBracingInGroup(actor, links) - 1;
			float num2 = MathF.Pow(1f - _settings.GroupBonus, num);
			_visited.Clear();
			float num3 = (1f - ResolveChain(actor, links)) * num2;
			return MathF.Min(1f - num3, _settings.MaxStability);
		}

		private float ResolveChain(int actor, IReadOnlyCollection<RopeLink> links)
		{
			_visited.Add(actor);
			float num = 1f - _settings.BraceResistance;
			foreach (RopeLink link in links)
			{
				if (link.Contains(actor))
				{
					int num2 = link.Partner(actor);
					if (link.IsHeldBy(num2) && _policy.CanBrace(_footing.FootingOf(num2)) && !_visited.Contains(num2))
					{
						num *= 1f - _settings.ChainSupport * ResolveChain(num2, links);
					}
				}
			}
			return 1f - num;
		}

		private int CountBracingInGroup(int actor, IReadOnlyCollection<RopeLink> links)
		{
			_group.Clear();
			_frontier.Clear();
			_group.Add(actor);
			_frontier.Enqueue(actor);
			while (_frontier.Count > 0)
			{
				int actor2 = _frontier.Dequeue();
				foreach (RopeLink link in links)
				{
					if (link.Contains(actor2) && _group.Add(link.Partner(actor2)))
					{
						_frontier.Enqueue(link.Partner(actor2));
					}
				}
			}
			int num = 0;
			foreach (int item in _group)
			{
				if (IsBracing(item, links))
				{
					num++;
				}
			}
			return num;
		}

		private bool IsBracing(int actor, IReadOnlyCollection<RopeLink> links)
		{
			if (!_policy.CanBrace(_footing.FootingOf(actor)))
			{
				return false;
			}
			foreach (RopeLink link in links)
			{
				if (link.IsHeldBy(actor))
				{
					return true;
				}
			}
			return false;
		}
	}
	public sealed class TeamPull
	{
		public const float FirstHelperBonus = 0.6f;

		public const float HelperFalloff = 2f / 3f;

		private readonly RopeHandPolicy _policy;

		private readonly IFootingSource _footing;

		public TeamPull(RopeHandPolicy policy, IFootingSource footing)
		{
			_policy = policy;
			_footing = footing;
		}

		public int HelpersFor(RopeLink link, int actor, IReadOnlyCollection<RopeLink> links)
		{
			int actor2 = link.Partner(actor);
			int num = 0;
			foreach (RopeLink link2 in links)
			{
				if (link2 != link && link2.Contains(actor2))
				{
					int num2 = link2.Partner(actor2);
					if (num2 != actor && link2.IsHeldBy(num2) && _policy.CanBrace(_footing.FootingOf(num2)))
					{
						num++;
					}
				}
			}
			return num;
		}

		public float Multiplier(int helpers)
		{
			if (helpers <= 0)
			{
				return 1f;
			}
			return 1f + 0.6f * (1f - MathF.Pow(2f / 3f, helpers)) / 0.3333333f;
		}

		public float SharedLoad(RopeLink link, int actor, IReadOnlyCollection<RopeLink> links, float load)
		{
			return load / Multiplier(HelpersFor(link, actor, links));
		}
	}
	public sealed class TensionSolver
	{
		private readonly IRopeSettings _settings;

		public TensionSolver(IRopeSettings settings)
		{
			_settings = settings;
		}

		public Vector3 Solve(RopeSpan span, Vector3 selfVelocity, float length, float stability)
		{
			float num = span.PathLength - length;
			if (num <= 0f)
			{
				return Vector3.Zero;
			}
			float num2 = MathF.Max(0f - Vector3.Dot(selfVelocity, span.Direction), 0f);
			float x = _settings.Stiffness * num + _settings.Damping * num2;
			x = MathF.Min(x, _settings.MaxPull) * (1f - stability);
			return span.Direction * x;
		}

		public float Load(RopeSpan span, float length)
		{
			float num = span.PathLength - length;
			if (!(num <= 0f))
			{
				return MathF.Min(_settings.Stiffness * num, _settings.MaxPull);
			}
			return 0f;
		}

		public bool IsSnapped(Vector3 selfPosition, Vector3 partnerPosition)
		{
			return Vector3.DistanceSquared(selfPosition, partnerPosition) > _settings.SnapDistance * _settings.SnapDistance;
		}
	}
}
namespace Repkarbinhake.Core.Links
{
	public sealed class AnchorPayloadCodec
	{
		public const string KeyPrefix = "rkb.anchor.";

		private const char Separator = '|';

		private const int Fields = 9;

		private const string Number = "R";

		public string KeyOf(int owner)
		{
			return "rkb.anchor." + owner.ToString(CultureInfo.InvariantCulture);
		}

		public bool TryParseKey(string key, out int owner)
		{
			owner = 0;
			if (key.StartsWith("rkb.anchor.") && int.TryParse(key.Substring("rkb.anchor.".Length), NumberStyles.Integer, CultureInfo.InvariantCulture, out owner))
			{
				return owner > 0;
			}
			return false;
		}

		public string Encode(AnchorPlacement placement)
		{
			float[] array = new float[9]
			{
				placement.Position.X,
				placement.Position.Y,
				placement.Position.Z,
				placement.Forward.X,
				placement.Forward.Y,
				placement.Forward.Z,
				placement.Up.X,
				placement.Up.Y,
				placement.Up.Z
			};
			string[] array2 = new string[9];
			for (int i = 0; i < 9; i++)
			{
				array2[i] = array[i].ToString("R", CultureInfo.InvariantCulture);
			}
			return string.Join('|'.ToString(), array2);
		}

		public bool TryDecode(string payload, out AnchorPlacement placement)
		{
			placement = default(AnchorPlacement);
			if (string.IsNullOrEmpty(payload))
			{
				return false;
			}
			string[] array = payload.Split('|');
			if (array.Length != 9)
			{
				return false;
			}
			float[] array2 = new float[9];
			for (int i = 0; i < 9; i++)
			{
				if (!float.TryParse(array[i], NumberStyles.Float, CultureInfo.InvariantCulture, out array2[i]))
				{
					return false;
				}
			}
			placement = new AnchorPlacement(new Vector3(array2[0], array2[1], array2[2]), new Vector3(array2[3], array2[4], array2[5]), new Vector3(array2[6], array2[7], array2[8]));
			return true;
		}
	}
	public sealed class DeathUntieRule
	{
		private readonly IActorLifeSource _lives;

		public DeathUntieRule(IActorLifeSource lives)
		{
			_lives = lives;
		}

		public void Collect(IReadOnlyCollection<RopeLink> links, int localActor, bool isHost, List<RopeLink> result)
		{
			result.Clear();
			foreach (RopeLink link in links)
			{
				if (ShouldUntie(link.FirstActor, localActor, isHost) || ShouldUntie(link.SecondActor, localActor, isHost))
				{
					result.Add(link);
				}
			}
		}

		private bool ShouldUntie(int actor, int localActor, bool isHost)
		{
			if (_lives.IsDead(actor))
			{
				return actor == localActor || isHost;
			}
			return false;
		}
	}
	public sealed class DepartedUntieRule
	{
		public void Collect(IReadOnlyCollection<RopeLink> links, ICollection<int> presentActors, List<RopeLink> result)
		{
			result.Clear();
			foreach (RopeLink link in links)
			{
				if (!presentActors.Contains(link.FirstActor) || !presentActors.Contains(link.SecondActor))
				{
					result.Add(link);
				}
			}
		}
	}
	public interface ILinkTransport
	{
		bool EchoesOwnUpdates { get; }

		void Publish(LinkUpdate update);

		void PublishEnd(EndUpdate update);

		void DeleteIfUnchanged(LinkUpdate expected);
	}
	public sealed class LinkPayloadCodec
	{
		private const char Separator = '|';

		private const string Version = "1";

		private const string True = "1";

		private const string False = "0";

		private const int LinkParts = 5;

		private const int EndParts = 4;

		public string EncodeLink(LinkUpdate update)
		{
			return string.Join('|'.ToString(), "1", update.State.IsTied ? "1" : "0", update.State.TieId.ToString(CultureInfo.InvariantCulture), update.WriterActor.ToString(CultureInfo.InvariantCulture), update.Sequence.ToString(CultureInfo.InvariantCulture));
		}

		public bool TryDecodeLink(string key, string payload, out LinkUpdate update)
		{
			update = default(LinkUpdate);
			string[] array = payload?.Split('|');
			if (array == null || array.Length != 5 || array[0] != "1")
			{
				return false;
			}
			if (!long.TryParse(array[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !int.TryParse(array[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) || !int.TryParse(array[4], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3))
			{
				return false;
			}
			update = new LinkUpdate(key, new LinkState(array[1] == "1", result), result2, result3);
			return true;
		}

		public string EncodeEnd(EndState state)
		{
			return string.Join('|'.ToString(), "1", state.TieId.ToString(CultureInfo.InvariantCulture), state.IsHeld ? "1" : "0", state.Reel.ToString("R", CultureInfo.InvariantCulture));
		}

		public bool TryDecodeEnd(string key, string payload, out EndUpdate update)
		{
			update = default(EndUpdate);
			string[] array = payload?.Split('|');
			if (array == null || array.Length != 4 || array[0] != "1")
			{
				return false;
			}
			if (!long.TryParse(array[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || !float.TryParse(array[3], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				return false;
			}
			update = new EndUpdate(key, new EndState(result, array[2] == "1", result2));
			return true;
		}
	}
	public sealed class LinkRegistry
	{
		private readonly ILinkTransport _transport;

		private readonly Dictionary<long, RopeLink> _links = new Dictionary<long, RopeLink>();

		private readonly Dictionary<string, EndUpdate> _orphanEnds = new Dictionary<string, EndUpdate>();

		private readonly Dictionary<string, int> _sentSequences = new Dictionary<string, int>();

		private readonly Dictionary<string, int> _echoedSequences = new Dictionary<string, int>();

		private readonly List<RopeLink> _removalBuffer = new List<RopeLink>();

		private int _localActor;

		private int _sequence;

		public IReadOnlyCollection<RopeLink> Links => _links.Values;

		public int PendingEndCount => _orphanEnds.Count;

		public int LocalActor => _localActor;

		public event Action<RopeLink> LinkAdded;

		public event Action<RopeLink> LinkRemoved;

		public LinkRegistry(ILinkTransport transport)
		{
			_transport = transport;
		}

		public void Bind(int localActor)
		{
			_localActor = localActor;
		}

		public bool TryGet(int firstActor, int secondActor, out RopeLink link)
		{
			return _links.TryGetValue(LinkKeys.PairId(firstActor, secondActor), out link);
		}

		public bool TryGetHeld(int actor, out RopeLink held)
		{
			foreach (RopeLink value in _links.Values)
			{
				if (value.IsHeldBy(actor))
				{
					held = value;
					return true;
				}
			}
			held = null;
			return false;
		}

		public void Receive(LinkUpdate update)
		{
			if (!LinkKeys.TryParse(update.Key, out var firstActor, out var secondActor))
			{
				return;
			}
			if (update.WriterActor == _localActor)
			{
				_echoedSequences[update.Key] = update.Sequence;
				if (!HasPendingWrite(update.Key))
				{
					Apply(firstActor, secondActor, update.State);
				}
			}
			else if (!HasPendingWrite(update.Key))
			{
				Apply(firstActor, secondActor, update.State);
			}
		}

		public void ReceiveEnd(EndUpdate update)
		{
			if (LinkKeys.TryParseEnd(update.Key, out var firstActor, out var secondActor, out var endActor) && endActor != _localActor)
			{
				if (!TryGet(firstActor, secondActor, out var link) || link.TieId != update.State.TieId)
				{
					_orphanEnds[update.Key] = update;
				}
				else
				{
					ApplyEnd(link.EndOf(endActor), update.State);
				}
			}
		}

		public void Tie(int firstActor, int secondActor)
		{
			int sequence = NextSequence();
			LinkState state = new LinkState(isTied: true, LinkState.ComposeTieId(_localActor, sequence));
			Apply(firstActor, secondActor, state);
			Send(LinkKeys.Build(firstActor, secondActor), state, sequence);
		}

		public void Untie(RopeLink link)
		{
			Remove(link.FirstActor, link.SecondActor);
			Send(link.Key, LinkState.Untied, NextSequence());
		}

		public void Grab(RopeLink link)
		{
			RopeEnd ropeEnd = link.EndOf(_localActor);
			ropeEnd.IsHeld = true;
			ropeEnd.Reel = 0f;
			PublishEnd(link, ropeEnd);
		}

		public void Release(RopeLink link)
		{
			RopeEnd ropeEnd = link.EndOf(_localActor);
			ropeEnd.Reset();
			PublishEnd(link, ropeEnd);
		}

		public void SetReel(RopeLink link, float reel)
		{
			ReelLocally(link, reel);
			PublishOwnEnd(link);
		}

		public void ReelLocally(RopeLink link, float reel)
		{
			link.EndOf(_localActor).Reel = reel;
		}

		public void PublishOwnEnd(RopeLink link)
		{
			PublishEnd(link, link.EndOf(_localActor));
		}

		public void ReleaseAllHeld()
		{
			foreach (RopeLink value in _links.Values)
			{
				if (value.IsHeldBy(_localActor))
				{
					Release(value);
				}
			}
		}

		public void UntieActor(int actor)
		{
			_removalBuffer.Clear();
			foreach (RopeLink value in _links.Values)
			{
				if (value.Contains(actor))
				{
					_removalBuffer.Add(value);
				}
			}
			foreach (RopeLink item in _removalBuffer)
			{
				Untie(item);
			}
		}

		public void Clear()
		{
			_removalBuffer.Clear();
			_removalBuffer.AddRange(_links.Values);
			foreach (RopeLink item in _removalBuffer)
			{
				Remove(item.FirstActor, item.SecondActor);
			}
			_orphanEnds.Clear();
			_sentSequences.Clear();
			_echoedSequences.Clear();
		}

		private bool HasPendingWrite(string key)
		{
			if (!_sentSequences.TryGetValue(key, out var value))
			{
				return false;
			}
			_echoedSequences.TryGetValue(key, out var value2);
			return value > value2;
		}

		private int NextSequence()
		{
			_sequence++;
			return _sequence;
		}

		private void Send(string key, LinkState state, int sequence)
		{
			if (_transport.EchoesOwnUpdates)
			{
				_sentSequences[key] = sequence;
			}
			_transport.Publish(new LinkUpdate(key, state, _localActor, sequence));
		}

		private void PublishEnd(RopeLink link, RopeEnd end)
		{
			_transport.PublishEnd(new EndUpdate(link.EndKey(end.Actor), new EndState(link.TieId, end.IsHeld, end.Reel)));
		}

		private void Apply(int firstActor, int secondActor, LinkState state)
		{
			long key = LinkKeys.PairId(firstActor, secondActor);
			RopeLink value;
			if (!state.IsTied)
			{
				Remove(firstActor, secondActor);
			}
			else if (_links.TryGetValue(key, out value))
			{
				if (value.TieId != state.TieId)
				{
					value.Retie(state.TieId);
					AdoptOrphans(value);
				}
			}
			else
			{
				RopeLink ropeLink = new RopeLink(firstActor, secondActor, state.TieId);
				_links.Add(key, ropeLink);
				AdoptOrphans(ropeLink);
				this.LinkAdded?.Invoke(ropeLink);
			}
		}

		private void AdoptOrphans(RopeLink link)
		{
			AdoptOrphan(link, link.First);
			AdoptOrphan(link, link.Second);
		}

		private void AdoptOrphan(RopeLink link, RopeEnd end)
		{
			string key = link.EndKey(end.Actor);
			if (_orphanEnds.TryGetValue(key, out var value))
			{
				_orphanEnds.Remove(key);
				if (value.State.TieId == link.TieId)
				{
					ApplyEnd(end, value.State);
				}
			}
		}

		private void ApplyEnd(RopeEnd end, EndState state)
		{
			end.IsHeld = state.IsHeld;
			end.Reel = (state.IsHeld ? state.Reel : 0f);
		}

		private void Remove(int firstActor, int secondActor)
		{
			long key = LinkKeys.PairId(firstActor, secondActor);
			if (_links.TryGetValue(key, out var value))
			{
				_links.Remove(key);
				_orphanEnds.Remove(value.EndKey(value.FirstActor));
				_orphanEnds.Remove(value.EndKey(value.SecondActor));
				this.LinkRemoved?.Invoke(value);
			}
		}
	}
	public sealed class RopePathAuthority
	{
		public bool IsShared(RopeLink link)
		{
			if (link.FirstActor > 0)
			{
				return link.SecondActor > 0;
			}
			return false;
		}

		public int OwnerOf(RopeLink link)
		{
			if (link.First.IsHeld != link.Second.IsHeld)
			{
				if (!link.First.IsHeld)
				{
					return link.SecondActor;
				}
				return link.FirstActor;
			}
			return link.FirstActor;
		}

		public bool Owns(RopeLink link, int localActor)
		{
			if (IsShared(link))
			{
				return OwnerOf(link) == localActor;
			}
			return true;
		}
	}
	public sealed class UntiedKeySweeper
	{
		private readonly struct UntiedEntry
		{
			public LinkUpdate Update { get; }

			public float ObservedAt { get; }

			public UntiedEntry(LinkUpdate update, float observedAt)
			{
				Update = update;
				ObservedAt = observedAt;
			}
		}

		private readonly Dictionary<string, UntiedEntry> _untied = new Dictionary<string, UntiedEntry>();

		private readonly List<string> _expiredKeys = new List<string>();

		public int TrackedCount => _untied.Count;

		public void Observe(LinkUpdate update, float now)
		{
			if (update.State.IsTied)
			{
				_untied.Remove(update.Key);
			}
			else
			{
				_untied[update.Key] = new UntiedEntry(update, now);
			}
		}

		public void Forget(string key)
		{
			_untied.Remove(key);
		}

		public void Collect(float now, float maxAge, List<LinkUpdate> result)
		{
			result.Clear();
			_expiredKeys.Clear();
			foreach (KeyValuePair<string, UntiedEntry> item in _untied)
			{
				if (!(now - item.Value.ObservedAt < maxAge))
				{
					result.Add(item.Value.Update);
					_expiredKeys.Add(item.Key);
				}
			}
			foreach (string expiredKey in _expiredKeys)
			{
				_untied.Remove(expiredKey);
			}
		}

		public void Clear()
		{
			_untied.Clear();
		}
	}
}
namespace Repkarbinhake.Core.Interaction
{
	public sealed class HoldAction
	{
		public const int NoTarget = 0;

		private float _elapsed;

		private float _duration;

		public int Target { get; private set; }

		public bool IsActive => Target != 0;

		public float Progress
		{
			get
			{
				if (!IsActive || !(_duration > 0f))
				{
					return 0f;
				}
				return Math.Min(_elapsed / _duration, 1f);
			}
		}

		public void Begin(int target, float duration)
		{
			Target = target;
			_duration = duration;
			_elapsed = 0f;
		}

		public void Cancel()
		{
			Target = 0;
			_elapsed = 0f;
		}

		public bool Advance(bool isHeld, int currentTarget, float deltaTime)
		{
			if (!IsActive)
			{
				return false;
			}
			if (!isHeld || currentTarget != Target)
			{
				Cancel();
				return false;
			}
			_elapsed += deltaTime;
			if (_elapsed < _duration)
			{
				return false;
			}
			Cancel();
			return true;
		}
	}
	public sealed class RopeHandPolicy
	{
		public bool CanHold(Footing footing)
		{
			if (footing != Footing.Grounded)
			{
				return footing == Footing.Airborne;
			}
			return true;
		}

		public bool CanBrace(Footing footing)
		{
			return footing == Footing.Grounded;
		}

		public bool CanReelIn(Footing footing)
		{
			return footing == Footing.Grounded;
		}

		public bool CanReelOut(Footing footing)
		{
			return CanHold(footing);
		}
	}
}
namespace Repkarbinhake.Core.Data
{
	public static class AnchorActors
	{
		public const int MaxOwner = 9999;

		public static int Of(int owner)
		{
			return -owner;
		}

		public static bool IsAnchor(int actor)
		{
			if (actor < 0)
			{
				return actor >= -9999;
			}
			return false;
		}

		public static int OwnerOf(int anchor)
		{
			return -anchor;
		}
	}
	public readonly struct AnchorPlacement
	{
		public Vector3 Position { get; }

		public Vector3 Forward { get; }

		public Vector3 Up { get; }

		public AnchorPlacement(Vector3 position, Vector3 forward, Vector3 up)
		{
			Position = position;
			Forward = forward;
			Up = up;
		}
	}
	public readonly struct EndState
	{
		public long TieId { get; }

		public bool IsHeld { get; }

		public float Reel { get; }

		public EndState(long tieId, bool isHeld, float reel)
		{
			TieId = tieId;
			IsHeld = isHeld;
			Reel = reel;
		}
	}
	public readonly struct EndUpdate
	{
		public string Key { get; }

		public EndState State { get; }

		public EndUpdate(string key, EndState state)
		{
			Key = key;
			State = state;
		}
	}
	public enum Footing
	{
		Grounded,
		Airborne,
		Climbing,
		Unconscious
	}
	public interface IActorLifeSource
	{
		bool IsDead(int actor);
	}
	public interface IFootingSource
	{
		Footing FootingOf(int actor);
	}
	public interface IRopeSettings
	{
		float MinLength { get; }

		float MaxLength { get; }

		float ReelSpeed { get; }

		float ArmStrength { get; }

		float ReelStaminaPerMeter { get; }

		float Stiffness { get; }

		float Damping { get; }

		float MaxPull { get; }

		float SnapDistance { get; }

		float BraceResistance { get; }

		float GroupBonus { get; }

		float ChainSupport { get; }

		float MaxStability { get; }

		float TieHoldSeconds { get; }

		float UntieHoldSeconds { get; }
	}
	public interface ISegmentSettings
	{
		SegmentMode SegmentMode { get; }

		int FixedSegments { get; }

		int SegmentBudget { get; }

		int AutoMaxSegments { get; }

		float SegmentLength { get; }
	}
	public static class LinkKeys
	{
		public const string Prefix = "rkb.link.";

		public const string EndPrefix = "rkb.end.";

		private const char PairSeparator = '_';

		private const char ActorSeparator = '.';

		public static string Build(int firstActor, int secondActor)
		{
			return "rkb.link." + Pair(firstActor, secondActor);
		}

		public static string BuildEnd(int firstActor, int secondActor, int endActor)
		{
			return "rkb.end." + Pair(firstActor, secondActor) + "." + endActor;
		}

		public static long PairId(int firstActor, int secondActor)
		{
			int num = ((firstActor < secondActor) ? firstActor : secondActor);
			int num2 = ((firstActor < secondActor) ? secondActor : firstActor);
			return ((long)num << 32) | (uint)num2;
		}

		public static bool TryParse(string key, out int firstActor, out int secondActor)
		{
			firstActor = 0;
			secondActor = 0;
			if (key == null || !key.StartsWith("rkb.link."))
			{
				return false;
			}
			return TryParsePair(key.Substring("rkb.link.".Length), out firstActor, out secondActor);
		}

		public static bool TryParseEnd(string key, out int firstActor, out int secondActor, out int endActor)
		{
			firstActor = 0;
			secondActor = 0;
			endActor = 0;
			if (key == null || !key.StartsWith("rkb.end."))
			{
				return false;
			}
			string[] array = key.Substring("rkb.end.".Length).Split('.');
			if (array.Length != 2 || !TryParsePair(array[0], out firstActor, out secondActor))
			{
				return false;
			}
			if (int.TryParse(array[1], out endActor))
			{
				if (endActor != firstActor)
				{
					return endActor == secondActor;
				}
				return true;
			}
			return false;
		}

		private static string Pair(int firstActor, int secondActor)
		{
			return ((firstActor < secondActor) ? firstActor : secondActor) + "_" + ((firstActor < secondActor) ? secondActor : firstActor);
		}

		private static bool TryParsePair(string pair, out int firstActor, out int secondActor)
		{
			firstActor = 0;
			secondActor = 0;
			string[] array = pair.Split('_');
			if (array.Length != 2)
			{
				return false;
			}
			if (int.TryParse(array[0], out firstActor) && int.TryParse(array[1], out secondActor))
			{
				return firstActor != secondActor;
			}
			return false;
		}
	}
	public readonly struct LinkState
	{
		public const long NoTie = 0L;

		private const int WriterShift = 32;

		public bool IsTied { get; }

		public long TieId { get; }

		public static LinkState Untied => new LinkState(isTied: false, 0L);

		public LinkState(bool isTied, long tieId)
		{
			IsTied = isTied;
			TieId = tieId;
		}

		public static long ComposeTieId(int writerActor, int sequence)
		{
			return ((long)writerActor << 32) | (uint)sequence;
		}
	}
	public readonly struct LinkUpdate
	{
		public string Key { get; }

		public LinkState State { get; }

		public int WriterActor { get; }

		public int Sequence { get; }

		public LinkUpdate(string key, LinkState state, int writerActor, int sequence)
		{
			Key = key;
			State = state;
			WriterActor = writerActor;
			Sequence = sequence;
		}
	}
	public sealed class RopeEnd
	{
		public int Actor { get; }

		public bool IsHeld { get; set; }

		public float Reel { get; set; }

		public float HeldReel
		{
			get
			{
				if (!IsHeld)
				{
					return 0f;
				}
				return Reel;
			}
		}

		public RopeEnd(int actor)
		{
			Actor = actor;
		}

		public void Reset()
		{
			IsHeld = false;
			Reel = 0f;
		}
	}
	public sealed class RopeLink
	{
		public int FirstActor { get; }

		public int SecondActor { get; }

		public RopeEnd First { get; }

		public RopeEnd Second { get; }

		public long TieId { get; private set; }

		public string Key { get; }

		public bool IsHeld
		{
			get
			{
				if (!First.IsHeld)
				{
					return Second.IsHeld;
				}
				return true;
			}
		}

		public float TotalReel => First.HeldReel + Second.HeldReel;

		public RopeLink(int firstActor, int secondActor, long tieId)
		{
			FirstActor = ((firstActor < secondActor) ? firstActor : secondActor);
			SecondActor = ((firstActor < secondActor) ? secondActor : firstActor);
			First = new RopeEnd(FirstActor);
			Second = new RopeEnd(SecondActor);
			TieId = tieId;
			Key = LinkKeys.Build(FirstActor, SecondActor);
		}

		public bool Contains(int actor)
		{
			if (actor != FirstActor)
			{
				return actor == SecondActor;
			}
			return true;
		}

		public int Partner(int actor)
		{
			if (actor != FirstActor)
			{
				return FirstActor;
			}
			return SecondActor;
		}

		public RopeEnd EndOf(int actor)
		{
			if (actor != FirstActor)
			{
				return Second;
			}
			return First;
		}

		public bool IsHeldBy(int actor)
		{
			if (Contains(actor))
			{
				return EndOf(actor).IsHeld;
			}
			return false;
		}

		public string EndKey(int actor)
		{
			return LinkKeys.BuildEnd(FirstActor, SecondActor, actor);
		}

		public void Retie(long tieId)
		{
			TieId = tieId;
			First.Reset();
			Second.Reset();
		}
	}
	public enum SegmentMode
	{
		Auto,
		Fixed
	}
}
namespace Repkarbinhake.Plugin
{
	public sealed class RepkaBack : MonoBehaviour
	{
		private const float MaxVisualDeltaTime = 1f / 30f;

		private readonly List<RopeLink> _deadLinks = new List<RopeLink>();

		private RepkaConfig _config;

		private LinkRegistry _registry;

		private DeathUntieRule _deathRule;

		private RopeHandPolicy _policy;

		private CharacterDirectory _characters;

		private ActorStates _actors;

		private KeyBinding _linkKey;

		private KeyBinding _anchorKey;

		private KeyBinding _pullKey;

		private KeyBinding _unwindKey;

		private HostSwitchInput _hookSwitch;

		private HostSwitchInput _lockSwitch;

		private TestDummies _dummies;

		private LinkHoldInput _linkHold;

		private AnchorInput _anchorInput;

		private AnchorSync _anchorSync;

		private AnchorRopes _anchorRopes;

		private RopeHands _hands;

		private ReelDriver _reelDriver;

		private AutoHandUp _handUp;

		private RopeHoldPoses _poses;

		private LinkColors _colors;

		private SpoolProps _spools;

		private RopeForces _forces;

		private RopeRescue _rescue;

		private HangRecovery _hangRecovery;

		private RopeKnockdown _knockdown;

		private RepkaHookFeed _hookFeed;

		private RopePresenterPool _ropes;

		private BeltCarabiners _belts;

		private RoomLinkSync _sync;

		private ModVersionCheck _versionCheck;

		private RopePathSync _pathSync;

		private RopeColliderFilter _colliderFilter;

		private LinkSoundFeedback _sounds;

		private HostFlag _linkLock;

		private HostFlag _hookRule;

		private UntieWitness _untieWitness;

		private RopeEventLog _eventLog;

		private IDebugTools _debug;

		private ConfigWindowInput _configWindow;

		private void OnEnable()
		{
			_registry.LinkAdded += OnLinkAdded;
			_registry.LinkRemoved += OnLinkRemoved;
			_ropes.RopeInteracted += OnRopeInteracted;
			_linkHold.Untied += OnLocalUntied;
			_linkLock.Changed += OnLinkLockChanged;
			_hookRule.Changed += OnHookRuleChanged;
			_sync.Enable();
			_anchorSync.Enable();
			_versionCheck.Enable();
			_pathSync.Enable();
		}

		private void OnDisable()
		{
			if (_registry != null)
			{
				_registry.LinkAdded -= OnLinkAdded;
				_registry.LinkRemoved -= OnLinkRemoved;
			}
			if (_ropes != null)
			{
				_ropes.RopeInteracted -= OnRopeInteracted;
			}
			if (_linkHold != null)
			{
				_linkHold.Untied -= OnLocalUntied;
			}
			if (_linkLock != null)
			{
				_linkLock.Changed -= OnLinkLockChanged;
			}
			if (_hookRule != null)
			{
				_hookRule.Changed -= OnHookRuleChanged;
			}
			_sync?.Disable();
			_anchorSync?.Disable();
			_versionCheck?.Disable();
			_pathSync?.Disable();
			_hookFeed.Clear();
		}

		private void OnDestroy()
		{
			_linkKey?.Dispose();
			_anchorKey?.Dispose();
			_pullKey?.Dispose();
			_unwindKey?.Dispose();
			_hookSwitch?.Dispose();
			_lockSwitch?.Dispose();
			_debug?.Dispose();
			_configWindow?.Dispose();
		}

		private void Update()
		{
			_configWindow.Tick();
			_sync.Tick(Time.deltaTime, Time.time);
			Character localCharacter = Character.localCharacter;
			if (!PhotonNetwork.InRoom || (Object)(object)localCharacter == (Object)null || (Object)(object)MainCamera.instance == (Object)null)
			{
				_linkHold.Cancel();
				_poses.Clear();
				_anchorInput.Cancel();
				_handUp.Stop();
				_knockdown.Clear();
				_colliderFilter.Clear();
				_spools.Clear();
				_hookFeed.Clear();
				_belts.Clear();
				_eventLog.Clear();
				_debug.Hide();
				return;
			}
			_characters.Refresh();
			int localActor = _registry.LocalActor;
			Footing footing = _actors.FootingOf(localActor);
			Transform transform = ((Component)MainCamera.instance).transform;
			bool pulling = false;
			bool unwinding = false;
			bool flag = _hands.IsHolding(localActor);
			if (_configWindow.IsOpen)
			{
				_anchorInput.Cancel();
				_linkHold.Cancel();
			}
			else
			{
				_anchorInput.Tick(localCharacter, localActor, footing, transform, flag && _config.UnwindKey.Value == _config.AnchorKey.Value);
				_debug.TickInput(localActor, transform);
				_hookSwitch.Tick();
				_lockSwitch.Tick();
				_linkHold.Tick(localCharacter, localActor, footing, transform, flag, Time.deltaTime);
				pulling = _pullKey.IsPressed && !_linkHold.HasAction;
				unwinding = _unwindKey.IsPressed;
			}
			_hands.Enforce(localCharacter, localActor, footing, Time.deltaTime);
			_anchorRopes.Tick(localCharacter, localActor, footing, Time.deltaTime);
			if (_hands.IsHolding(localActor))
			{
				_reelDriver.Tick(localCharacter, localActor, footing, pulling, unwinding, Time.deltaTime);
			}
			else
			{
				_reelDriver.Stop();
			}
			_handUp.Tick(localCharacter, localActor, _reelDriver.IsReelingIn, Time.deltaTime);
			_pathSync.Tick(localActor, Time.deltaTime);
			_knockdown.Tick(localCharacter, localActor, Time.deltaTime);
			_poses.Refresh(Time.deltaTime);
			UntieDead(localActor);
			_hookFeed.Publish(localActor, footing, transform, _hangRecovery.IsHanging);
			_eventLog.Flush();
			_debug.ShowOverlay(localCharacter, localActor);
		}

		private void FixedUpdate()
		{
			Character localCharacter = Character.localCharacter;
			if (PhotonNetwork.InRoom && !((Object)(object)localCharacter == (Object)null) && !localCharacter.data.dead)
			{
				_forces.Apply(localCharacter, _registry.LocalActor);
				_rescue.Tick(localCharacter, _forces.IsPulledByTeammate);
				_hangRecovery.Tick(localCharacter, _actors.FootingOf(_registry.LocalActor), _forces.IsOnTautRope, _forces.IsPulledByTeammate);
				_forces.ApplyToDummies(_dummies);
			}
		}

		private void LateUpdate()
		{
			if (PhotonNetwork.InRoom)
			{
				_spools.Render();
				_belts.Tick(Mathf.Min(Time.deltaTime, 1f / 30f));
				_ropes.Render(Mathf.Min(Time.deltaTime, 1f / 30f));
			}
		}

		public void Initialize(RepkaConfig config, RepkaAssets assets, ManualLogSource log)
		{
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			_config = config;
			LobbyRopeSettings lobbyRopeSettings = new LobbyRopeSettings(config);
			_policy = new RopeHandPolicy();
			PhotonLinkTransport transport = new PhotonLinkTransport();
			_registry = new LinkRegistry(transport);
			_colors = new LinkColors(_registry);
			RepkaHooks.Badges = new PlayerListBadges(_colors, assets.ReticleSprite, log);
			RepkaHooks.HangingCamera = new HangingCamera();
			RepkaHooks.Hud = new CarabinerHud(assets.ReticleSprite, new HookIndicatorView(assets.HookIndicatorSprite, assets.HookRetractSprite), log);
			_characters = new CharacterDirectory();
			_dummies = new TestDummies();
			VanillaRopeSpool spool = (RepkaHooks.Spool = new VanillaRopeSpool());
			AnchorVisuals visuals = new AnchorVisuals(spool);
			AnchorBoard anchorBoard = new AnchorBoard(_registry, visuals);
			_poses = new RopeHoldPoses(_registry, _characters);
			RepkaHooks.HoldPoses = _poses.Poses;
			_spools = new SpoolProps(((Component)this).transform, spool, _poses, _registry, _colors, config);
			_actors = new ActorStates(_characters, anchorBoard, _spools, _dummies);
			_deathRule = new DeathUntieRule(_actors);
			StabilityResolver stability = new StabilityResolver(lobbyRopeSettings, _policy, _actors);
			TensionSolver tension = new TensionSolver(lobbyRopeSettings);
			RopeSettingsOverride ropeSettingsOverride = new RopeSettingsOverride(lobbyRopeSettings, config.AnchorStiffness, config.AnchorDamping, config.AnchorMaxPull);
			TensionSolver anchorTension = new TensionSolver(ropeSettingsOverride);
			TensionSolver haulTension = new TensionSolver(new RopeSettingsOverride(lobbyRopeSettings, config.HaulStiffness, null, null));
			RopeReel reel = new RopeReel(lobbyRopeSettings, _policy);
			_colliderFilter = new RopeColliderFilter();
			PhysicsRopeObstacles obstacles = new PhysicsRopeObstacles(LayerMask.op_Implicit(HelperFunctions.GetMask((LayerType)1)), ((Component)this).transform, _colliderFilter);
			HookLengths hookLengths = new HookLengths();
			LinkLengths lengths = new LinkLengths(reel, hookLengths);
			_belts = new BeltCarabiners(((Component)this).transform, assets.Carabiner, new CarabinerMaterials(assets.KnurlTexture), _registry, _characters, _colors, config.BeltCarabiners, config.ShowOwnCarabiners);
			_ropes = new RopePresenterPool(((Component)this).transform, config, lengths, new RopeSegmentation(config), _actors, _registry, _policy, obstacles, spool, _belts);
			_linkKey = new KeyBinding(config.LinkKey);
			_anchorKey = new KeyBinding(config.AnchorKey);
			_pullKey = new KeyBinding(config.PullKey);
			_unwindKey = new KeyBinding(config.UnwindKey);
			_hookSwitch = new HostSwitchInput(new KeyBinding(config.AllowHooksKey), config.AllowHooks);
			_lockSwitch = new HostSwitchInput(new KeyBinding(config.LockLinksKey), config.LockLinks);
			_linkLock = new HostFlag("rkb.cfg.lockLinks", config.LockLinks, fallback: false);
			_linkHold = new LinkHoldInput(_registry, new LinkTargetPicker(config, _dummies), _linkKey, lobbyRopeSettings, _linkLock);
			_hookRule = new HostFlag("rkb.cfg.allowHooks", config.AllowHooks, fallback: true);
			_anchorSync = new AnchorSync(anchorBoard, _hookRule);
			_anchorInput = new AnchorInput(anchorBoard, _anchorSync, visuals, spool, _anchorKey, lobbyRopeSettings, _hookRule);
			_anchorRopes = new AnchorRopes(_registry, anchorBoard, _ropes, lobbyRopeSettings, config.HookRetractSpeed, config.HookLength, hookLengths);
			_hands = new RopeHands(_registry, _policy, _actors);
			TeamPull team = new TeamPull(_policy, _actors);
			_reelDriver = new ReelDriver(_registry, reel, tension, _ropes, team);
			_handUp = new AutoHandUp(_registry, _characters, _actors, _policy, config.AutoHandUp);
			LedgeAssist ledge = new LedgeAssist();
			MantleAssist mantle = new MantleAssist();
			_forces = new RopeForces(_registry, stability, tension, anchorTension, haulTension, lengths, _actors, _ropes, config, obstacles, ledge, mantle);
			_rescue = new RopeRescue(config.FreeWhenPulled);
			_hangRecovery = new HangRecovery(config.RecoverWhenHeld);
			_knockdown = new RopeKnockdown(_registry, reel, _ropes, config);
			_sync = new RoomLinkSync(transport, _registry, new UntiedKeySweeper(), new DepartedUntieRule(), lobbyRopeSettings, new HostFlag[2] { _hookRule, _linkLock }, config);
			_versionCheck = new ModVersionCheck("1.2.2", log);
			_pathSync = new RopePathSync(_registry, _ropes);
			_sounds = new LinkSoundFeedback(new CarabinerSounds(assets, config), _actors);
			_untieWitness = new UntieWitness(transport, _actors, _characters, lobbyRopeSettings);
			_eventLog = new RopeEventLog(log);
			HudFeed hud = new HudFeed(_registry, _linkHold, anchorBoard, _anchorRopes, config.LinkKey, config.PullKey, config.UnwindKey);
			HeldRopeFeed heldRope = new HeldRopeFeed(_registry, reel, _policy, _ropes, _linkHold, _colors, config.RopeColor);
			_hookFeed = new RepkaHookFeed(hud, heldRope, new AssistFeed(_registry, _handUp, config.StableCamera));
			RepkaHooks.GaugeTint = new RopeGaugeTint();
			ConfigEditorWindow configEditorWindow = ((Component)this).gameObject.AddComponent<ConfigEditorWindow>();
			configEditorWindow.Initialize(config.File);
			_configWindow = new ConfigWindowInput(configEditorWindow, new KeyBinding(config.ConfigEditorKey));
			IDebugTools debug;
			if (!BuildFlavor.HasDebugTools)
			{
				IDebugTools debugTools = new NoDebugTools();
				debug = debugTools;
			}
			else
			{
				debug = CreateDebugTools(config, log, new RopeDebugReport(_registry, _actors, stability, tension, reel, lengths, team, ledge, mantle, _ropes, lobbyRopeSettings, ropeSettingsOverride));
			}
			_debug = debug;
		}

		private void UntieDead(int actor)
		{
			_deathRule.Collect(_registry.Links, actor, PhotonNetwork.IsMasterClient, _deadLinks);
			foreach (RopeLink deadLink in _deadLinks)
			{
				if (!AnchorActors.IsAnchor(deadLink.FirstActor))
				{
					_registry.Untie(deadLink);
				}
			}
		}

		private IDebugTools CreateDebugTools(RepkaConfig config, ManualLogSource log, RopeDebugReport report)
		{
			KeyBinding keyBinding = new KeyBinding(config.TestDummyKey);
			TestDummyInput dummyInput = new TestDummyInput(_registry, _dummies, keyBinding, config.TestDummyCount, log);
			return new DebugTools(config, report, ((Component)this).gameObject.AddComponent<RopeDebugOverlay>(), keyBinding, dummyInput);
		}

		private void OnLocalUntied(int partner)
		{
			_eventLog.Untied(_registry.LocalActor, partner);
		}

		private void OnLinkLockChanged(bool locked)
		{
			_eventLog.TiesChanged(locked);
		}

		private void OnHookRuleChanged(bool allowed)
		{
			_eventLog.HooksChanged(allowed);
		}

		private void OnRopeInteracted(RopeLink link)
		{
			_hands.Toggle(Character.localCharacter, link);
		}

		private void OnLinkAdded(RopeLink link)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			_colors.Assign(link);
			_ropes.Add(link);
			if (_colors.TryGetColor(link, out var color))
			{
				_ropes.Tint(link, color);
			}
			if (!_sync.IsReadingSnapshot)
			{
				_sounds.Tied(link);
			}
		}

		private void OnLinkRemoved(RopeLink link)
		{
			if (_untieWitness.TryGetUntier(link, out var untier))
			{
				_eventLog.Untied(untier, link.Partner(untier));
			}
			_pathSync.Forget(link);
			_knockdown.Forget(link);
			_colors.Release(link);
			_sounds.Untied(link);
			_ropes.Remove(link);
		}
	}
	[BepInPlugin("repkarbinhake", "Rope Carabiner", "1.2.2")]
	public sealed class RepkaPlugin : BaseUnityPlugin
	{
		public const string Guid = "repkarbinhake";

		public const string Name = "Rope Carabiner";

		public const string Version = "1.2.2";

		private Harmony _harmony;

		private void Awake()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			RepkaConfig config = new RepkaConfig(((BaseUnityPlugin)this).Config);
			RepkaAssets assets = new RepkaAssets(typeof(RepkaPlugin).Assembly);
			_harmony = new Harmony("repkarbinhake");
			_harmony.PatchAll(typeof(RepkaPlugin).Assembly);
			GameObject val = new GameObject("Rope Carabiner");
			val.SetActive(false);
			Object.DontDestroyOnLoad((Object)val);
			((Object)val).hideFlags = (HideFlags)61;
			val.AddComponent<RepkaBack>().Initialize(config, assets, ((BaseUnityPlugin)this).Logger);
			val.SetActive(true);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"RepkaPlugin 1.2.2 loaded");
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "RopeCarabiner";

		public const string PLUGIN_NAME = "RopeCarabiner";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace Repkarbinhake.Plugin.Visual
{
	public sealed class AnchorVisuals
	{
		private const string AnchorName = "Repkarbinhake Anchor ";

		private const string GhostName = "Repkarbinhake Anchor Ghost";

		private readonly VanillaRopeSpool _spool;

		private readonly Dictionary<int, RopeAnchor> _anchors = new Dictionary<int, RopeAnchor>();

		private RopeAnchor _ghost;

		public AnchorVisuals(VanillaRopeSpool spool)
		{
			_spool = spool;
		}

		public void Show(int owner, AnchorPlacement placement)
		{
			if (!_anchors.TryGetValue(owner, out var value) || (Object)(object)value == (Object)null)
			{
				value = CreateSolid("Repkarbinhake Anchor " + owner);
				_anchors[owner] = value;
			}
			Place(((Component)value).transform, placement);
		}

		public void Hide(int owner)
		{
			if (_anchors.TryGetValue(owner, out var value) && (Object)(object)value != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)value).gameObject);
			}
			_anchors.Remove(owner);
		}

		public bool TryGetRopePoint(int o