EVERYTHING

Assets/Scripts/Assembly-CSharp/GorillaLocomotion/Player.cs

@@ -0,0 +1,421 @@
+using System.Collections.Generic;
+using BlockSpace.Voxels;
+using UnityEngine;
+
+namespace GorillaLocomotion
+{
+	public class Player : MonoBehaviour
+	{
+		private static Player _instance;
+
+		public SphereCollider headCollider;
+
+		public CapsuleCollider bodyCollider;
+
+		public Transform leftHandFollower;
+
+		public Transform rightHandFollower;
+
+		public Transform rightHandTransform;
+
+		public Transform leftHandTransform;
+
+		private Vector3 lastLeftHandPosition;
+
+		private Vector3 lastRightHandPosition;
+
+		private Vector3 lastHeadPosition;
+
+		private Rigidbody playerRigidBody;
+
+		public int velocityHistorySize;
+
+		public float maxArmLength = 1.5f;
+
+		public float unStickDistance = 1f;
+
+		public float velocityLimit;
+
+		public float maxJumpSpeed;
+
+		public float jumpMultiplier;
+
+		public float minimumRaycastDistance = 0.05f;
+
+		public float defaultSlideFactor = 0.03f;
+
+		public float defaultPrecision = 0.995f;
+
+		private Vector3[] velocityHistory;
+
+		private int velocityIndex;
+
+		private Vector3 currentVelocity;
+
+		private Vector3 denormalizedVelocityAverage;
+
+		private bool jumpHandIsLeft;
+
+		private Vector3 lastPosition;
+
+		public Vector3 rightHandOffset;
+
+		public Vector3 leftHandOffset;
+
+		public LayerMask locomotionEnabledLayers;
+
+		public bool wasLeftHandTouching;
+
+		public bool wasRightHandTouching;
+
+		public bool disableMovement;
+
+		private readonly Dictionary<Collider, bool> editPhaseColliderStates = new Dictionary<Collider, bool>();
+
+		private readonly Dictionary<CharacterController, bool> editPhaseControllerEnabledStates = new Dictionary<CharacterController, bool>();
+
+		private readonly Dictionary<CharacterController, bool> editPhaseControllerStates = new Dictionary<CharacterController, bool>();
+
+		private bool editPhaseActive;
+
+		public static Player Instance => _instance;
+
+		private void Awake()
+		{
+			if (_instance != null && _instance != this)
+			{
+				Object.Destroy(base.gameObject);
+			}
+			else
+			{
+				_instance = this;
+			}
+			InitializeValues();
+		}
+
+		private void OnDisable()
+		{
+			RestoreEditPhaseCollisionGate();
+			editPhaseActive = false;
+		}
+
+		public void InitializeValues()
+		{
+			playerRigidBody = GetComponent<Rigidbody>();
+			velocityHistory = new Vector3[velocityHistorySize];
+			lastLeftHandPosition = leftHandFollower.transform.position;
+			lastRightHandPosition = rightHandFollower.transform.position;
+			lastHeadPosition = headCollider.transform.position;
+			velocityIndex = 0;
+			lastPosition = base.transform.position;
+		}
+
+		private Vector3 CurrentLeftHandPosition()
+		{
+			if ((PositionWithOffset(leftHandTransform, leftHandOffset) - headCollider.transform.position).magnitude < maxArmLength)
+			{
+				return PositionWithOffset(leftHandTransform, leftHandOffset);
+			}
+			return headCollider.transform.position + (PositionWithOffset(leftHandTransform, leftHandOffset) - headCollider.transform.position).normalized * maxArmLength;
+		}
+
+		private Vector3 CurrentRightHandPosition()
+		{
+			if ((PositionWithOffset(rightHandTransform, rightHandOffset) - headCollider.transform.position).magnitude < maxArmLength)
+			{
+				return PositionWithOffset(rightHandTransform, rightHandOffset);
+			}
+			return headCollider.transform.position + (PositionWithOffset(rightHandTransform, rightHandOffset) - headCollider.transform.position).normalized * maxArmLength;
+		}
+
+		private Vector3 PositionWithOffset(Transform transformToModify, Vector3 offsetVector)
+		{
+			return transformToModify.position + transformToModify.rotation * offsetVector;
+		}
+
+		private void Update()
+		{
+			if (VoxelGroupManager.Instance != null && !VoxelGroupManager.Instance.EditingLocked && VoxelGroupManager.Instance.CreatorMode)
+			{
+				SetEditPhase(active: true);
+				SyncHandsWithoutCollision();
+				return;
+			}
+			SetEditPhase(active: false);
+			bool flag = false;
+			bool flag2 = false;
+			Vector3 zero = Vector3.zero;
+			Vector3 vector = Vector3.zero;
+			Vector3 vector2 = Vector3.zero;
+			bodyCollider.transform.eulerAngles = new Vector3(0f, headCollider.transform.eulerAngles.y, 0f);
+			Vector3 movementVector = CurrentLeftHandPosition() - lastLeftHandPosition + Vector3.down * 2f * 9.8f * Time.deltaTime * Time.deltaTime;
+			if (IterativeCollisionSphereCast(lastLeftHandPosition, minimumRaycastDistance, movementVector, defaultPrecision, out var endPosition, singleHand: true))
+			{
+				vector = ((!wasLeftHandTouching) ? (endPosition - CurrentLeftHandPosition()) : (lastLeftHandPosition - CurrentLeftHandPosition()));
+				playerRigidBody.linearVelocity = Vector3.zero;
+				flag = true;
+			}
+			movementVector = CurrentRightHandPosition() - lastRightHandPosition + Vector3.down * 2f * 9.8f * Time.deltaTime * Time.deltaTime;
+			if (IterativeCollisionSphereCast(lastRightHandPosition, minimumRaycastDistance, movementVector, defaultPrecision, out endPosition, singleHand: true))
+			{
+				vector2 = ((!wasRightHandTouching) ? (endPosition - CurrentRightHandPosition()) : (lastRightHandPosition - CurrentRightHandPosition()));
+				playerRigidBody.linearVelocity = Vector3.zero;
+				flag2 = true;
+			}
+			zero = (((!flag && !wasLeftHandTouching) || (!flag2 && !wasRightHandTouching)) ? (vector + vector2) : ((vector + vector2) / 2f));
+			RaycastHit hitInfo;
+			if (IterativeCollisionSphereCast(lastHeadPosition, headCollider.radius, headCollider.transform.position + zero - lastHeadPosition, defaultPrecision, out endPosition, singleHand: false))
+			{
+				zero = endPosition - lastHeadPosition;
+				if (Physics.Raycast(lastHeadPosition, headCollider.transform.position - lastHeadPosition + zero, out hitInfo, (headCollider.transform.position - lastHeadPosition + zero).magnitude + headCollider.radius * defaultPrecision * 0.999f, locomotionEnabledLayers.value))
+				{
+					zero = lastHeadPosition - headCollider.transform.position;
+				}
+			}
+			if (zero != Vector3.zero)
+			{
+				base.transform.position = base.transform.position + zero;
+			}
+			lastHeadPosition = headCollider.transform.position;
+			movementVector = CurrentLeftHandPosition() - lastLeftHandPosition;
+			if (IterativeCollisionSphereCast(lastLeftHandPosition, minimumRaycastDistance, movementVector, defaultPrecision, out endPosition, (!flag && !wasLeftHandTouching) || (!flag2 && !wasRightHandTouching)))
+			{
+				lastLeftHandPosition = endPosition;
+				flag = true;
+			}
+			else
+			{
+				lastLeftHandPosition = CurrentLeftHandPosition();
+			}
+			movementVector = CurrentRightHandPosition() - lastRightHandPosition;
+			if (IterativeCollisionSphereCast(lastRightHandPosition, minimumRaycastDistance, movementVector, defaultPrecision, out endPosition, (!flag && !wasLeftHandTouching) || (!flag2 && !wasRightHandTouching)))
+			{
+				lastRightHandPosition = endPosition;
+				flag2 = true;
+			}
+			else
+			{
+				lastRightHandPosition = CurrentRightHandPosition();
+			}
+			StoreVelocities();
+			if ((flag2 || flag) && !disableMovement && denormalizedVelocityAverage.magnitude > velocityLimit)
+			{
+				if (denormalizedVelocityAverage.magnitude * jumpMultiplier > maxJumpSpeed)
+				{
+					playerRigidBody.linearVelocity = denormalizedVelocityAverage.normalized * maxJumpSpeed;
+				}
+				else
+				{
+					playerRigidBody.linearVelocity = jumpMultiplier * denormalizedVelocityAverage;
+				}
+			}
+			if (flag && (CurrentLeftHandPosition() - lastLeftHandPosition).magnitude > unStickDistance && !Physics.SphereCast(headCollider.transform.position, minimumRaycastDistance * defaultPrecision, CurrentLeftHandPosition() - headCollider.transform.position, out hitInfo, (CurrentLeftHandPosition() - headCollider.transform.position).magnitude - minimumRaycastDistance, locomotionEnabledLayers.value))
+			{
+				lastLeftHandPosition = CurrentLeftHandPosition();
+				flag = false;
+			}
+			if (flag2 && (CurrentRightHandPosition() - lastRightHandPosition).magnitude > unStickDistance && !Physics.SphereCast(headCollider.transform.position, minimumRaycastDistance * defaultPrecision, CurrentRightHandPosition() - headCollider.transform.position, out hitInfo, (CurrentRightHandPosition() - headCollider.transform.position).magnitude - minimumRaycastDistance, locomotionEnabledLayers.value))
+			{
+				lastRightHandPosition = CurrentRightHandPosition();
+				flag2 = false;
+			}
+			leftHandFollower.position = lastLeftHandPosition;
+			rightHandFollower.position = lastRightHandPosition;
+			wasLeftHandTouching = flag;
+			wasRightHandTouching = flag2;
+		}
+
+		private void SetEditPhase(bool active)
+		{
+			if (editPhaseActive == active)
+			{
+				if (active)
+				{
+					ApplyEditPhaseCollisionGate();
+				}
+				return;
+			}
+			editPhaseActive = active;
+			if (active)
+			{
+				ApplyEditPhaseCollisionGate();
+				wasLeftHandTouching = false;
+				wasRightHandTouching = false;
+				if (playerRigidBody != null)
+				{
+					playerRigidBody.linearVelocity = Vector3.zero;
+				}
+			}
+			else
+			{
+				RestoreEditPhaseCollisionGate();
+			}
+		}
+
+		private void ApplyEditPhaseCollisionGate()
+		{
+			Transform transform = ((base.transform.root != null) ? base.transform.root : base.transform);
+			Collider[] componentsInChildren = transform.GetComponentsInChildren<Collider>(includeInactive: true);
+			foreach (Collider collider in componentsInChildren)
+			{
+				if (!(collider == null) && !collider.isTrigger && !(collider is CharacterController))
+				{
+					if (!editPhaseColliderStates.ContainsKey(collider))
+					{
+						editPhaseColliderStates.Add(collider, collider.enabled);
+					}
+					collider.enabled = false;
+				}
+			}
+			CharacterController[] componentsInChildren2 = transform.GetComponentsInChildren<CharacterController>(includeInactive: true);
+			foreach (CharacterController characterController in componentsInChildren2)
+			{
+				if (!(characterController == null))
+				{
+					if (!editPhaseControllerStates.ContainsKey(characterController))
+					{
+						editPhaseControllerEnabledStates.Add(characterController, characterController.enabled);
+						editPhaseControllerStates.Add(characterController, characterController.detectCollisions);
+					}
+					characterController.enabled = false;
+					characterController.detectCollisions = false;
+				}
+			}
+		}
+
+		private void RestoreEditPhaseCollisionGate()
+		{
+			foreach (KeyValuePair<Collider, bool> editPhaseColliderState in editPhaseColliderStates)
+			{
+				if (editPhaseColliderState.Key != null)
+				{
+					editPhaseColliderState.Key.enabled = editPhaseColliderState.Value;
+				}
+			}
+			foreach (KeyValuePair<CharacterController, bool> editPhaseControllerState in editPhaseControllerStates)
+			{
+				if (editPhaseControllerState.Key != null)
+				{
+					if (editPhaseControllerEnabledStates.TryGetValue(editPhaseControllerState.Key, out var value))
+					{
+						editPhaseControllerState.Key.enabled = value;
+					}
+					editPhaseControllerState.Key.detectCollisions = editPhaseControllerState.Value;
+					EnsureCharacterControllerUsableAfterEdit(editPhaseControllerState.Key);
+				}
+			}
+			editPhaseColliderStates.Clear();
+			editPhaseControllerEnabledStates.Clear();
+			editPhaseControllerStates.Clear();
+		}
+
+		private static void EnsureCharacterControllerUsableAfterEdit(CharacterController controller)
+		{
+			if (!(controller == null))
+			{
+				controller.enabled = true;
+				controller.detectCollisions = true;
+			}
+		}
+
+		private void SyncHandsWithoutCollision()
+		{
+			lastLeftHandPosition = CurrentLeftHandPosition();
+			lastRightHandPosition = CurrentRightHandPosition();
+			lastHeadPosition = ((headCollider != null) ? headCollider.transform.position : base.transform.position);
+			if (leftHandFollower != null)
+			{
+				leftHandFollower.position = lastLeftHandPosition;
+			}
+			if (rightHandFollower != null)
+			{
+				rightHandFollower.position = lastRightHandPosition;
+			}
+			StoreVelocities();
+		}
+
+		private bool IterativeCollisionSphereCast(Vector3 startPosition, float sphereRadius, Vector3 movementVector, float precision, out Vector3 endPosition, bool singleHand)
+		{
+			if (CollisionsSphereCast(startPosition, sphereRadius * precision, movementVector, precision, out endPosition, out var hitInfo))
+			{
+				Vector3 vector = endPosition;
+				Surface component = hitInfo.collider.GetComponent<Surface>();
+				float num = ((component != null) ? component.slipPercentage : ((!singleHand) ? defaultSlideFactor : 0.001f));
+				Vector3 vector2 = Vector3.ProjectOnPlane(startPosition + movementVector - vector, hitInfo.normal) * num;
+				if (CollisionsSphereCast(endPosition, sphereRadius, vector2, precision * precision, out endPosition, out hitInfo))
+				{
+					return true;
+				}
+				if (CollisionsSphereCast(vector2 + vector, sphereRadius, startPosition + movementVector - (vector2 + vector), precision * precision * precision, out endPosition, out hitInfo))
+				{
+					return true;
+				}
+				endPosition = vector;
+				return true;
+			}
+			if (CollisionsSphereCast(startPosition, sphereRadius * precision * 0.66f, movementVector.normalized * (movementVector.magnitude + sphereRadius * precision * 0.34f), precision * 0.66f, out endPosition, out hitInfo))
+			{
+				endPosition = startPosition;
+				return true;
+			}
+			endPosition = Vector3.zero;
+			return false;
+		}
+
+		private bool CollisionsSphereCast(Vector3 startPosition, float sphereRadius, Vector3 movementVector, float precision, out Vector3 finalPosition, out RaycastHit hitInfo)
+		{
+			if (Physics.SphereCast(startPosition, sphereRadius * precision, movementVector, out hitInfo, movementVector.magnitude + sphereRadius * (1f - precision), locomotionEnabledLayers.value))
+			{
+				finalPosition = hitInfo.point + hitInfo.normal * sphereRadius;
+				if (Physics.SphereCast(startPosition, sphereRadius * precision * precision, finalPosition - startPosition, out var hitInfo2, (finalPosition - startPosition).magnitude + sphereRadius * (1f - precision * precision), locomotionEnabledLayers.value))
+				{
+					finalPosition = startPosition + (finalPosition - startPosition).normalized * Mathf.Max(0f, hitInfo.distance - sphereRadius * (1f - precision * precision));
+					hitInfo = hitInfo2;
+				}
+				else if (Physics.Raycast(startPosition, finalPosition - startPosition, out hitInfo2, (finalPosition - startPosition).magnitude + sphereRadius * precision * precision * 0.999f, locomotionEnabledLayers.value))
+				{
+					finalPosition = startPosition;
+					hitInfo = hitInfo2;
+					return true;
+				}
+				return true;
+			}
+			if (Physics.Raycast(startPosition, movementVector, out hitInfo, movementVector.magnitude + sphereRadius * precision * 0.999f, locomotionEnabledLayers.value))
+			{
+				finalPosition = startPosition;
+				return true;
+			}
+			finalPosition = Vector3.zero;
+			return false;
+		}
+
+		public bool IsHandTouching(bool forLeftHand)
+		{
+			if (forLeftHand)
+			{
+				return wasLeftHandTouching;
+			}
+			return wasRightHandTouching;
+		}
+
+		public void Turn(float degrees)
+		{
+			base.transform.RotateAround(headCollider.transform.position, base.transform.up, degrees);
+			denormalizedVelocityAverage = Quaternion.Euler(0f, degrees, 0f) * denormalizedVelocityAverage;
+			for (int i = 0; i < velocityHistory.Length; i++)
+			{
+				velocityHistory[i] = Quaternion.Euler(0f, degrees, 0f) * velocityHistory[i];
+			}
+		}
+
+		private void StoreVelocities()
+		{
+			velocityIndex = (velocityIndex + 1) % velocityHistorySize;
+			Vector3 vector = velocityHistory[velocityIndex];
+			currentVelocity = (base.transform.position - lastPosition) / Time.deltaTime;
+			denormalizedVelocityAverage += (currentVelocity - vector) / velocityHistorySize;
+			velocityHistory[velocityIndex] = currentVelocity;
+			lastPosition = base.transform.position;
+		}
+	}
+}

Assets/Scripts/Assembly-CSharp/GorillaLocomotion/Player.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 0a8196cc2c14f036bba087c1fb69faf2
+timeCreated: 1780325055
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  externalObjects: {}
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

Assets/Scripts/Assembly-CSharp/GorillaLocomotion/Surface.cs

@@ -0,0 +1,9 @@
+using UnityEngine;
+
+namespace GorillaLocomotion
+{
+	public class Surface : MonoBehaviour
+	{
+		public float slipPercentage;
+	}
+}

Assets/Scripts/Assembly-CSharp/GorillaLocomotion/Surface.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 32f6cd50b3dff203bd109c49418a41c5
+timeCreated: 1780325055
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  externalObjects: {}
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant: