VelocityMovement

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

//Need to fix Jump Run
//When going down and jumping it gives you greater height
public class Velocity : MonoBehaviour
{
    public CameraMovement cameraController;

    //this is for the SphereCast it will create a sphere under the player to check if it touches anything 
    public LayerMask groundLayerMask;

    //we will use this for the Raycast on walls to wall run
    public LayerMask wallLayerMask;

    //Checks if the player is in certain conditions
    public bool isGrounded;
    public bool isOnWall;
    public bool isRunning;
    public bool isWallRunningLeft;
    public bool isWallRunningRight;
    public bool tiltedLeft;
    public bool tiltedRight;
    //the speed and movement direction of the player
    public float walkingSpeed = 5;
    public float runningSpeed = 10;
    public float wallRunningSpeed = 7.5f;
    public float wallJumpPower;
    private float moveNS;
    private float moveEW;
    public float wallGravityForce;
    //takes the rigid component of an object
    private Rigidbody rb;

    //the force of the players jump
    public float jumpForce = 6.5f;
    public float airjumpForce = 5f;

    //Can the player air jump?
    public bool airJump;


    //we save the directions the player move at so we can change their speed
    Vector3 movedirection;
    Vector3 wallJumpRight;
    Vector3 wallJumpLeft;
    Vector3 wallGravityPush;
    Vector3 yFallVect;
    //happens before the first frame
    private void Awake()
    {
        //we take in the rigidbody compnent of the player
        rb = GetComponent<Rigidbody>();
        cameraController = GetComponentInChildren<CameraMovement>();
    }

    // Start is called before the first frame update
    void Start()
    {

    }

    // Update is called once per frame
    void Update()
    {
        
        //the input value of the x and z axises
        moveNS = Input.GetAxisRaw("Horizontal");
        moveEW = Input.GetAxisRaw("Vertical");
        //we now make a vector of where the player can move to and normalize it, which means it can go from 0 to 1
        movedirection = (moveNS * transform.right + moveEW * transform.forward).normalized;
        


        if (isGrounded || isWallRunningLeft || isWallRunningRight)
        {
            airJump = true;

        }

        if (transform.position.y < -2) // where -10 is the lowest the player can fall before reset
        {
            transform.position = Vector3.zero; // same as new Vector3(0, 0, 0);
            GetComponent<Rigidbody>().velocity = Vector3.zero;
        }

        wallJumpRight = transform.right.normalized;
        wallJumpLeft = -transform.right.normalized;

        jump();


    }

    //Called every physics update
    private void FixedUpdate()
    {
        yFallVect = new Vector3(0, rb.velocity.y, 0);
        //checks whether the gameobject is grounded or not
        isGrounded = Grounded();
        isOnWall = againstWall();

        
        Movement();
        wallRun();

    }

    //In movement() and jump() I have not made it to the players movement are limited when jumping, may want to add it later
    public void Movement()
    {
        //We save the previous y velocity of the player, we need this so the players y velocity doesn't always reset to 0 and stops physics acting weird
        //to change how fast the player falls we need to go to edit  -> Project Settings -> Gravity and change the "- value"
        //Vector3 yFallVect = new Vector3(0, rb.velocity.y, 0);
        
        
        //Checks whether the object is grounded and if no inputs are given, basically not moving 
        if ((isGrounded == true && !Input.GetButton("Vertical") && !Input.GetButton("Horizontal") && !Input.GetButtonDown("Jump")))
        {
            
            //if player does not move change the vector to 0     
            rb.velocity = yFallVect;
            isRunning = false;


        }

        //Running input
        else if (Input.GetKey(KeyCode.W) && Input.GetKey(KeyCode.LeftShift) && !Input.GetButtonDown("Jump") && isGrounded == true)
        {

           
            //the velocity of the players direction and resetting y to the players y previous value so it doesnt glitch
            rb.velocity = movedirection * runningSpeed + yFallVect;
            isRunning = true;
            

        }

        //Walking input
        //Added not jumping so while we moving forward as the button first gets pressed down at least it can perform a jump
        else if ((Input.GetButton("Vertical") || Input.GetButton("Horizontal")) && !Input.GetButtonDown("Jump") && isGrounded == true)
        {

            
            //Adds force relative to the rotation of object
            rb.velocity = movedirection * walkingSpeed + yFallVect;
            //player is not running anymore
            isRunning = false;

        }
     
      

    }



    private void jump()
    {

        
        Vector3 moveForce = new Vector3(moveNS, 0f, moveEW).normalized;
        Vector3 currentXZVel = new Vector3(rb.velocity.x, 0f, rb.velocity.z);
        //checks if player is grounded if so it can do part one of the jump
        if ((isGrounded == true || isWallRunningLeft == true || isWallRunningRight == true) && Input.GetButtonDown("Jump"))
        {

            if (isWallRunningLeft == true)
            {
             
                rb.velocity = wallJumpRight * wallJumpPower + new Vector3(0f, airjumpForce, 0f) + currentXZVel;
            }

            else if (isWallRunningRight == true)
            {
                rb.velocity = wallJumpLeft * wallJumpPower + new Vector3(0f, airjumpForce, 0f) + currentXZVel;
            }

            //force of the jump
            else if (isGrounded == true)
            {


                if (isRunning == true)
                {
                    rb.velocity = movedirection * runningSpeed + new Vector3(0f, jumpForce, 0f);
                }

                else
                {
                    rb.velocity = movedirection * walkingSpeed + new Vector3(0f, jumpForce, 0f);
                }

            }
        }

        //if no more grounded and still has an airjump the player can jump again
        else if (!isWallRunningRight && !isWallRunningLeft && !isGrounded && airJump == true && Input.GetButtonDown("Jump"))
        {

            if (isRunning == true)
            {
                rb.velocity = movedirection * runningSpeed * 1.02f + new Vector3(0f, airjumpForce, 0f);
            }


            else
            {
                rb.velocity = movedirection * walkingSpeed * 1.02f + new Vector3(0f, airjumpForce, 0f);

            }

            airJump = false;

        }
    }

    private void wallRun()
    {


        RaycastHit hit;
        if (((isWallRunningLeft == true || isWallRunningRight == true) && isOnWall == false) || Input.GetKey(KeyCode.S) || (!Input.GetKey(KeyCode.W) && !Input.GetButton("Horizontal")) || ((Physics.Raycast(transform.position, -transform.right, out hit, 0.7f, wallLayerMask) && Input.GetKey(KeyCode.D) || Physics.Raycast(transform.position, transform.right, out hit, 0.7f, wallLayerMask) && Input.GetKey(KeyCode.A))))
        {
            
            rb.useGravity = true;
            isWallRunningLeft = false;
            isWallRunningRight = false;

            if(tiltedLeft == true || tiltedRight == true)
            {
                cameraController.resetCameraAfterWallRun();
                tiltedLeft = false;
                tiltedRight = false;
            }
            
        }

        else if (isOnWall == true && isGrounded == false && !Input.GetButton("Jump"))
        {

            rb.useGravity = false;

            if (Physics.Raycast(transform.position, -transform.right, out hit, 0.7f, wallLayerMask))
            {
                if((Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.A)))
                {

                    
                    
                    wallGravityPush = -hit.normal * wallGravityForce;

                    if(tiltedRight == false)
                    {
                        tiltedLeft = false;
                        cameraController.leftWallRunCamera();
                        tiltedRight = true;
                    }
                    

                    isWallRunningLeft = true;
                }   
               

            }

            if (Physics.Raycast(transform.position, transform.right, out hit, 0.7f, wallLayerMask))
            {
                if ((Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.D)))
                {

                    wallGravityPush = -hit.normal * wallGravityForce;

                    if (tiltedLeft == false)
                    {
                        tiltedRight = false;
                        cameraController.righttWallRunCamera();
                        tiltedLeft = true;
                    }
                    


                    isWallRunningRight = true;
                }

               
            }
            rb.velocity = movedirection * wallRunningSpeed + wallGravityPush;
        }


    }

    private bool Grounded()
    {
        //Stores the value of what the raycast has hit
        RaycastHit hit;

        //if the return value is true then it returns true
        //basically creates a sphrere to check beneath it
        //transorm position takes in the position of set object
        //GetComponentInChildren takes the component we ask for of any children
        //0.55f and 0.49f are: one of them moves where the spheres is and the other sets the radius of the sphere outside of the hitbox which stops character from being grounded 1m high
        //then vector3.down checks downwards
        //and groundlayermask is the layer which is the floor
        return Physics.SphereCast(transform.position + GetComponentInChildren<CapsuleCollider>().center, 0.55f, Vector3.down, out hit, 0.49f);
    }

    private bool againstWall()
    {
        RaycastHit hit;
        //Different from spheres as we don need the radius anymore we only need the max distance, I used or because we need to check multiple sides to wallrun
        return Physics.Raycast(transform.position, -transform.right, out hit, 0.7f, wallLayerMask) || Physics.Raycast(transform.position, transform.right, out hit, 0.7f, wallLayerMask);
    }

}