*misc

6 files changed, 430 insertions, 0 deletions

diff --git a/_ActiveRagdoll/Handlers/AnimationHandler.cs b/_ActiveRagdoll/Handlers/AnimationHandler.cs
new file mode 100644
index 0000000..382b3a5
--- /dev/null
+++ b/_ActiveRagdoll/Handlers/AnimationHandler.cs
@@ -0,0 +1,15 @@
+using UnityEngine;
+
+//Player AnimationHandler 记录当前动作状态编号
+public class AnimationHandler : MonoBehaviour
+{
+	public int animationState; 
+
+	private void Start()
+	{
+	}
+
+	private void Update()
+	{
+	}
+}
diff --git a/_ActiveRagdoll/Handlers/InputHandler.cs b/_ActiveRagdoll/Handlers/InputHandler.cs
new file mode 100644
index 0000000..27adc82
--- /dev/null
+++ b/_ActiveRagdoll/Handlers/InputHandler.cs
@@ -0,0 +1,120 @@
+using UnityEngine;
+
+public class InputHandler : MonoBehaviour
+{
+	public Vector3 inputMovementDirection;
+
+	public Vector3 lastInputDirection;
+
+	public bool isSpringting;
+
+	private WeaponHandler wepaonHandler;
+
+	private MovementDataHandler movementData;
+
+	private WeaponHandler weaponHandler;
+
+	private CameraMovement cameraMovement;
+
+	private PlayerDeath death;
+
+	private HasControl hasControl;
+
+	private MovementHandler movement;
+
+	public bool allowStrafe = true;
+
+	private void Start()
+	{
+		death = GetComponent<PlayerDeath>();
+		movement = GetComponent<MovementHandler>();
+		wepaonHandler = GetComponent<WeaponHandler>();
+		hasControl = GetComponent<HasControl>();
+		movementData = GetComponent<MovementDataHandler>();
+		weaponHandler = GetComponent<WeaponHandler>();
+		cameraMovement = GetComponentInChildren<CameraMovement>();
+	}
+
+	private void Update()
+	{
+		if ((bool)death && death.dead)
+		{
+			return;
+		}
+		if (!hasControl || hasControl.hasControl)
+		{
+			isSpringting = false;
+			inputMovementDirection = Vector3.zero;
+			if (Input.GetKey(KeyCode.W))
+			{
+				inputMovementDirection += movementData.groundedForward;
+			}
+			if (Input.GetKey(KeyCode.S))
+			{
+				inputMovementDirection += movementData.groundedBack;
+			}
+			if (Input.GetKey(KeyCode.D) && allowStrafe)
+			{
+				inputMovementDirection += movementData.right;
+			}
+			if (Input.GetKey(KeyCode.A) && allowStrafe)
+			{
+				inputMovementDirection += movementData.left;
+			}
+			if (Input.GetKey(KeyCode.LeftShift) && (!cameraMovement || !cameraMovement.ADS))
+			{
+				isSpringting = true;
+			}
+			inputMovementDirection = inputMovementDirection.normalized;
+			if ((bool)movement && Input.GetKeyDown(KeyCode.Space))
+			{
+				movement.Jump();
+			}
+			if ((bool)weaponHandler)
+			{
+				if (weaponHandler.isDualWeilding)
+				{
+					if (Input.GetKey(KeyCode.Mouse1))
+					{
+						weaponHandler.HoldAttack(shootWithRightGun: true, ADS: false);
+					}
+					if (Input.GetKeyDown(KeyCode.Mouse1))
+					{
+						weaponHandler.PressAttack(shootWithRightGun: true, ADS: false);
+					}
+					if (Input.GetKey(KeyCode.Mouse0))
+					{
+						weaponHandler.HoldAttack(shootWithRightGun: false, ADS: false);
+					}
+					if (Input.GetKeyDown(KeyCode.Mouse0))
+					{
+						weaponHandler.PressAttack(shootWithRightGun: false, ADS: false);
+					}
+				}
+				else
+				{
+					if (Input.GetKey(KeyCode.Mouse1))
+					{
+						cameraMovement.ADS = true;
+					}
+					else
+					{
+						cameraMovement.ADS = false;
+					}
+					if (Input.GetKey(KeyCode.Mouse0))
+					{
+						weaponHandler.HoldAttack(shootWithRightGun: true, cameraMovement.ADS);
+					}
+					if (Input.GetKeyDown(KeyCode.Mouse0))
+					{
+						weaponHandler.PressAttack(shootWithRightGun: true, cameraMovement.ADS);
+					}
+				}
+			}
+		}
+		if (inputMovementDirection != Vector3.zero)
+		{
+			lastInputDirection = inputMovementDirection;
+		}
+	}
+}
diff --git a/_ActiveRagdoll/Handlers/MovementDataHandler.cs b/_ActiveRagdoll/Handlers/MovementDataHandler.cs
new file mode 100644
index 0000000..18d43f5
--- /dev/null
+++ b/_ActiveRagdoll/Handlers/MovementDataHandler.cs
@@ -0,0 +1,92 @@
+using UnityEngine;
+
+public class MovementDataHandler : MonoBehaviour
+{
+	[HideInInspector]
+	public Vector3 groundedForward;
+
+	[HideInInspector]
+	public Vector3 right;
+
+	[HideInInspector]
+	public Vector3 left;
+
+	[HideInInspector]
+	public Vector3 groundedBack;
+
+	private Transform hip;
+
+	private Transform torso;
+
+	public Transform rotationTarget;
+
+	[HideInInspector]
+	public float slopeStrenght;
+
+	public float slopeVelocityStrenght;
+
+	[HideInInspector]
+	public float sinceJump = 1f;
+
+	[HideInInspector]
+	public Vector3 groundNormal;
+
+	private InputHandler inputHandler;
+
+	private Transform leftKnee;
+
+	private Transform rightKnee;
+
+	private void Start()
+	{
+		inputHandler = GetComponent<InputHandler>();
+		hip = GetComponentInChildren<Hip>().transform;
+		torso = GetComponentInChildren<Torso>().transform;
+		if (!rotationTarget)
+		{
+			rotationTarget = GetComponentInChildren<RotationTarget>().transform;
+		}
+		KneeLeft componentInChildren = GetComponentInChildren<KneeLeft>();
+		if ((bool)componentInChildren)
+		{
+			leftKnee = componentInChildren.transform;
+		}
+		KneeRight componentInChildren2 = GetComponentInChildren<KneeRight>();
+		if ((bool)componentInChildren2)
+		{
+			rightKnee = componentInChildren2.transform;
+		}
+	}
+
+	private void Update()
+	{
+		sinceJump += Time.deltaTime;
+		groundedForward = rotationTarget.forward;
+		groundedForward.y = slopeStrenght * 1f;
+		groundedForward = groundedForward.normalized;
+		groundedBack = -groundedForward;
+		right = rotationTarget.right;
+		left = -rotationTarget.right;
+		slopeStrenght = Mathf.Lerp(slopeStrenght, 0f, Time.deltaTime * 1f);
+		Debug.DrawLine(hip.position, hip.position + groundedForward * 10f);
+	}
+
+	public void SetSlope(Vector3 normal)
+	{
+		groundNormal = normal;
+		slopeStrenght = Vector3.Cross(rotationTarget.right, normal).y;
+		Vector3 lhs = Vector3.Cross(Vector3.up, inputHandler.inputMovementDirection);
+		slopeVelocityStrenght = Vector3.Cross(lhs, normal).y;
+	}
+
+	public float GetSmallestLegAngle()
+	{
+		float num = Vector3.Angle(leftKnee.forward, Vector3.down);
+		float num2 = Vector3.Angle(rightKnee.forward, Vector3.down);
+		if (num < num2)
+		{
+			return num;
+		}
+		return num2;
+	}
+}
diff --git a/_ActiveRagdoll/Handlers/MovementHandler.cs b/_ActiveRagdoll/Handlers/MovementHandler.cs
new file mode 100644
index 0000000..4579efc
--- /dev/null
+++ b/_ActiveRagdoll/Handlers/MovementHandler.cs
@@ -0,0 +1,86 @@
+using System.Collections;
+using UnityEngine;
+
+//Player MovementHandler 控制移动、跳跃
+public class MovementHandler : MonoBehaviour
+{
+	private InputHandler inputHandler;
+
+	public float friction = 0.9f;
+
+	public Vector3 movementVector;
+
+	public float[] animationForceAmounts;
+
+	private AnimationHandler animationHandler;
+
+	private RigidbodyHolder allRigs;
+
+	public AnimationCurve jumpCurve;
+
+	public float jumpForce;
+
+	private StandingDataHandler standingData;
+
+	private MovementDataHandler data;
+
+	private PlayerDeath death;
+
+	[HideInInspector]
+	public float multiplier = 1f;
+
+	private WobbleShake wobbleShake;
+
+	private void Start()
+	{
+		wobbleShake = GetComponentInChildren<WobbleShake>();
+		death = GetComponent<PlayerDeath>();
+		standingData = GetComponent<StandingDataHandler>();
+		inputHandler = GetComponent<InputHandler>();
+		animationHandler = GetComponent<AnimationHandler>();
+		allRigs = GetComponent<RigidbodyHolder>();
+		data = GetComponent<MovementDataHandler>();
+	}
+
+	private void FixedUpdate()
+	{
+		if (!death.dead)
+		{
+			data.sinceJump += Time.fixedDeltaTime;
+			movementVector += inputHandler.inputMovementDirection * animationForceAmounts[animationHandler.animationState];
+			movementVector *= friction;
+			for (int i = 0; i < allRigs.GetAllRigs().Length; i++)
+			{
+				allRigs.GetAllRigs()[i].AddForce(movementVector * multiplier, ForceMode.Acceleration);
+			}
+		}
+	}
+
+	public void Jump()
+	{
+		if (!(data.sinceJump < 0.5f) && !(standingData.sinceGrounded > 0.3f))
+		{
+			data.sinceJump = 0f;
+			StartCoroutine(AddJumpForce());
+			wobbleShake.AddShake(Vector3.up * 2f, 0.8f);
+		}
+	}
+
+	private IEnumerator AddJumpForce()
+	{
+		float counter = 0f;
+		for (int i = 0; i < allRigs.GetAllRigs().Length; i++)
+		{
+			allRigs.GetAllRigs()[i].velocity = new Vector3(allRigs.GetAllRigs()[i].velocity.x, 0f, allRigs.GetAllRigs()[i].velocity.z);
+		}
+		while (counter < jumpCurve.keys[jumpCurve.length - 1].time && !death.dead)
+		{
+			counter += Time.deltaTime;
+			for (int j = 0; j < allRigs.GetAllRigs().Length; j++)
+			{
+				allRigs.GetAllRigs()[j].AddForce(Vector3.up * multiplier * jumpForce * jumpCurve.Evaluate(counter) * Time.deltaTime, ForceMode.Acceleration);
+			}
+			yield return null;
+		}
+	}
+}
diff --git a/_ActiveRagdoll/Handlers/PickupHandler.cs b/_ActiveRagdoll/Handlers/PickupHandler.cs
new file mode 100644
index 0000000..6a3a249
--- /dev/null
+++ b/_ActiveRagdoll/Handlers/PickupHandler.cs
@@ -0,0 +1,64 @@
+using UnityEngine;
+
+//Player PickupHandler 捡武器
+public class PickupHandler : MonoBehaviour
+{
+	public Pickup setWeapon;
+
+	public Pickup setWeapon2;
+
+	private WeaponHandler weaponHandler;
+
+	private Holding holding; // holding动作
+
+	private float counter;
+
+	private void Start()
+	{
+		weaponHandler = GetComponent<WeaponHandler>();
+		holding = GetComponent<Holding>();
+		if ((bool)setWeapon)
+		{
+			PickUp(setWeapon);
+		}
+		if ((bool)setWeapon2)
+		{
+			PickUp2(setWeapon2);
+		}
+	}
+
+	private void Update()
+	{
+		counter += Time.deltaTime;
+	}
+
+	public void PickUp(Pickup objectToPickUp)
+	{
+		if (!(counter < 1f))
+		{
+			counter = 0f;
+			holding.Drop();
+			Weapon component = objectToPickUp.GetComponent<Weapon>();
+			Gun component2 = component.GetComponent<Gun>();
+			weaponHandler.SetGun(component2, mainHand: true);
+			bool hasOffHand = false;
+			if ((bool)setWeapon2)
+			{
+				hasOffHand = true;
+			}
+			HoldableObject component3 = component.GetComponent<HoldableObject>();
+			component3.holder = base.transform;
+			holding.StartHolding(component3, hasOffHand);
+		}
+	}
+
+	public void PickUp2(Pickup objectToPickUp)
+	{
+		Weapon component = objectToPickUp.GetComponent<Weapon>();
+		Gun component2 = component.GetComponent<Gun>();
+		weaponHandler.SetGun(component2, mainHand: false);
+		HoldableObject component3 = component.GetComponent<HoldableObject>();
+		component3.holder = base.transform;
+		holding.StartHolding(component3, hasOffHand: true);
+	}
+}
diff --git a/_ActiveRagdoll/Handlers/StepHandler.cs b/_ActiveRagdoll/Handlers/StepHandler.cs
new file mode 100644
index 0000000..fd8110b
--- /dev/null
+++ b/_ActiveRagdoll/Handlers/StepHandler.cs
@@ -0,0 +1,53 @@
+using UnityEngine;
+
+public class StepHandler : MonoBehaviour
+{
+	public float staticCounter;
+
+	public Step[] steps;
+
+	public bool isLeft;
+
+	private float counter;
+
+	private Transform leftLeg;
+
+	private Transform rightLeg;
+
+	private AnimationHandler animationHandler;
+
+	private Transform hip;
+
+	private void Start()
+	{
+		if (staticCounter == 0f)
+		{
+			leftLeg = GetComponentInChildren<LegLeft>().transform;
+			rightLeg = GetComponentInChildren<LegRight>().transform;
+			animationHandler = GetComponent<AnimationHandler>();
+			hip = GetComponentInChildren<Hip>().transform;
+		}
+	}
+
+	private void Update()
+	{
+		counter += Time.deltaTime;
+		if (staticCounter != 0f)
+		{
+			if (counter > staticCounter)
+			{
+				Switch();
+			}
+		}
+		else if (counter > steps[animationHandler.animationState].minTime && (steps[animationHandler.animationState].minAngle == 0f || steps[animationHandler.animationState].minAngle < Vector3.Angle(leftLeg.forward, rightLeg.forward)) && isLeft == hip.InverseTransformPoint(leftLeg.position + leftLeg.forward).z > hip.InverseTransformPoint(rightLeg.position + rightLeg.forward).z)
+		{
+			Switch();
+		}
+	}
+
+	private void Switch()
+	{
+		isLeft = !isLeft;
+		counter = 0f;
+	}
+}