first commit

This commit is contained in:
Chris
2025-03-12 14:22:16 -04:00
commit 0ad0c01249
1999 changed files with 189708 additions and 0 deletions

View File

@@ -0,0 +1,250 @@
using System;
using Sirenix.OdinInspector;
using UnityEditor;
using UnityEngine;
using Unity.Mathematics;
using NodeCanvas.Framework;
using Drawing;
public class PlayerMovement : MonoBehaviour
{
// Speed
public float baseMoveSpeed = 5f;
public bool sprinting;
public float sprintAddtnlSpeed = 3f;
public float sprintAcceleration = 5f;
private float sprintPower;
// Gravity
private float gravityScale = 0f;
public float gravityAcceleration = 1f;
public float groundJumpGravity; // TODO: If I add more types of jumps, turn this into a class that contains the gravity, strenghth, and deaccel of each jump
public float airJumpGravity;
// Rotation
public float rotationSpeed = 5f;
public bool justATest;
// Jumping
public float jumpHeight;
public float jumpDeacceleration;
public int airJumpsCount;
public float airJumpStrength;
public float airJumpDeacceleration;
public float groundJumpStrength;
public float groundJumpDeacceleration;
[SerializeField] private float jumpPower;
public int airJumpsRemaining;
public JumpProfile groundJumpParams;
public JumpProfile initialAirJumpParams;
public JumpProfile followupAirJumpParams;
public JumpProfile currentJump;
// Raycasts
public RaycastHit forwardRay;
public RaycastHit leftRay;
public RaycastHit rightRay;
[Serializable]
public class JumpProfile{
public float jumpGravityMultiplier;
public float jumpHeightMultiplier;
public float jumpDeaccelMultiplier;
public bool active;
public void UpdateActive(JumpProfile _active){
// if (Mathf.Approximately(_active.jumpHeightMultiplier, jumpHeightMultiplier)) {
// return;
// }
active = true;
}
}
// References
private Player thisPlayer;
private CharacterController controller;
void Awake(){
thisPlayer = GetComponent<Player>();
controller = GetComponent<CharacterController>();
}
void OnDrawGizmos(){
}
void Update(){
//CheckContinuedSprinting();
//ProcessFlatSurfaceMovement();
//ProcessRotation();
// // Debug Visualization Tools
// groundJumpParams.UpdateActive(currentJump);
// initialAirJumpParams.UpdateActive(currentJump);
// followupAirJumpParams.UpdateActive(currentJump);
Color forwardRayStatus = Color.red;
if (forwardRay.collider&& forwardRay.transform.gameObject.layer == LayerMask.NameToLayer("Environment")){ forwardRayStatus = Color.green;}
using (Draw.WithColor(forwardRayStatus)) {
Draw.Line(transform.position + transform.up, transform.position + transform.forward * 2.5f + transform.up);
}
}
void FixedUpdate(){
LayerMask environmentLayer = LayerMask.NameToLayer("Environment");
if (Physics.Raycast(transform.position + Vector3.up, transform.forward, out forwardRay, 2.5f, ~environmentLayer)){
thisPlayer.controls.graph.SendEvent<bool>("ForwardRay", true, null);
}
if (Physics.Raycast(transform.position + Vector3.up, transform.position + Vector3.left, out leftRay, maxDistance: 2f, ~environmentLayer )) {
thisPlayer.controls.graph.SendEvent("LeftRay", true, null);
}
if (Physics.Raycast(transform.position + Vector3.up, transform.position + Vector3.right, out rightRay, maxDistance: 2f, ~environmentLayer )) {
thisPlayer.controls.graph.SendEvent("RightRay", true, null);
}
}
public void ProcessFlatSurfaceMovement(){
// Get current input direction
Vector3 flatSurfaceDirection = Vector3.zero;
if (controller.isGrounded) {
Vector2 rawInput = thisPlayer.controls.rawMoveInput;
flatSurfaceDirection = new(rawInput.x, 0, rawInput.y);
}
// Rotate input to forward direction for flat surface
flatSurfaceDirection = transform.rotation * flatSurfaceDirection;
// Finalize flat surface direction by adding speed
flatSurfaceDirection *= CalculateSpeed();
// Calculate gravity
if (!controller.isGrounded) {
gravityScale = Mathf.Lerp(gravityScale, Physics.gravity.y, gravityAcceleration * Time.deltaTime);
} else {
gravityScale = -.01f;
}
Vector3 gravityDirection = -Physics.gravity * gravityScale;
// Add and deteriorate jump
Vector3 jumpDirection = Vector3.zero;
jumpPower = Mathf.Lerp(jumpPower, 0f, jumpDeacceleration * Time.deltaTime);
jumpDirection = new Vector3(0, jumpPower, 0);
// Move character
// controller.Move((flatSurfaceDirection + gravityDirection) * Time.deltaTime);
// Reset Air Jumps and Jump Power on Grounded
if (controller.isGrounded) {
airJumpsRemaining = airJumpsCount;
jumpPower = 0f;
currentJump = null;
}
// Reset Gravity Scale upon gaining air
if (!controller.isGrounded) {
//gravityScale = 0;
}
}
public void AllocationTest(){
justATest = !justATest;
}
public void ProcessRotation(){
// Get current input direction
Vector2 rawInput = thisPlayer.controls.rawLookInput;
// Rotate character (times 360 to account for a full rotation taking 360 seconds otherwise)
// transform.Rotate(new Vector3(0, rawInput.x * rotationSpeed * 360f * Time.deltaTime));
}
public void StartSprint(){
sprinting = true;
}
public float CalculateSpeed(){
// Calculate sprinting speed
float outputSpeed = 0f;
// Add base speed
outputSpeed += baseMoveSpeed;
// Add sprinting speed
if (sprinting) {
sprintPower = Mathf.Lerp(sprintPower, 1, sprintAcceleration * Time.deltaTime);
outputSpeed += (sprintAddtnlSpeed * sprintPower);
} else {
outputSpeed += (sprintAddtnlSpeed * sprintPower);
sprintPower = Mathf.Lerp(sprintPower, 0, sprintAcceleration * Time.deltaTime);
}
return outputSpeed;
}
void CheckContinuedSprinting(){
if (sprinting) {
// Disable sprinting if analog stick is released too far
if (thisPlayer.controls.rawMoveInput.sqrMagnitude < .5f) {
sprinting = false;
return;
}
// Disable sprinting if analog stick direction is not forward
Vector2 rawInput = thisPlayer.controls.rawMoveInput;
Vector3 rawInputToVector3 = new(rawInput.x, 0, rawInput.y);
float sprintVectorDot = Vector3.Dot(transform.InverseTransformVector(transform.forward), rawInputToVector3);
if (sprintVectorDot < 0.3f) {
sprinting = false;
}
}
}
void StartJump(){
// Replaced with Jump Type System
// if (controller.isGrounded) {
// jumpPower = jumpHeight * groundJumpStrength;
// } else if (!controller.isGrounded && airJumpsRemaining > 0) {
// Debug.Log(controller.isGrounded);
// jumpPower = jumpHeight * airJumpStrength;
// airJumpsRemaining--;
// }
// if (controller.isGrounded) {
// currentJump = groundJumpParams;
// } else if (airJumpsRemaining > 2){
// currentJump = initialAirJumpParams;
// airJumpsRemaining--;
// } else if (airJumpsRemaining > 0) {
// currentJump = followupAirJumpParams;
// }
//
// if (currentJump != null) {
// jumpPower = currentJump.jumpHeightMultiplier;
// }
}
}