Decompiled source of Rope Carabiner v1.2.2
plugins/RopeCarabiner.dll
Decompiled 3 weeks ago
The result has been truncated due to the large size, download it to view full contents!
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