Implemented Item Scripts into objects

Implemented Ragdoll kinda
There are some issues with getting hit while ragdolling that need to be
fixed
Adjusted Dash
Dash still needs some adjustments before being fully implemented

Assets/Scripts/PlayerScripts/MovementAbilities/Blink.cs

@@ -0,0 +1,99 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+
+public class Blink : MonoBehaviour{
+
+    // Start is called before the first frame update
+
+    private Camera cam;
+    public CharacterController controller;
+    //Blink Variables
+    private LineRenderer beam;
+    private Vector3 origin;
+    private Vector3 endPoint;
+    private Vector3 mousePos;
+    private RaycastHit hit;
+
+    LayerMask ignoreP;
+    /////
+
+    private void Awake()
+    {
+        beam = gameObject.AddComponent<LineRenderer>();
+        beam.startWidth = 0.2f;
+        beam.endWidth = 0.2f;
+        beam.enabled = false;
+
+        ignoreP = LayerMask.GetMask("Player");
+
+        controller = GetComponent<CharacterController>();
+    }
+    void Start(){
+
+        // Grab the main camera.
+        //camera transform
+        cam =  GetComponentInChildren<Camera>();
+    }
+
+    //ADJUST SO DISTANCE IS DETERMINED BY SCROLL WHEEL
+    //blinks the player forwards
+    private void BlinkMove()
+    {
+        if (Input.GetMouseButton(1))
+        {
+            // Finding the origin and end point of laser.
+            origin = transform.position + transform.forward * transform.lossyScale.z;
+
+            // Finding mouse pos in 3D space.
+            mousePos = Input.mousePosition;
+            mousePos.z = 20f;
+            endPoint = cam.ScreenToWorldPoint(mousePos);
+
+            // Find direction of beam.
+            Vector3 dir = endPoint - origin;
+            dir.Normalize();
+
+            // Are we hitting any colliders?
+            if (Physics.Raycast(origin, dir, out hit, 20f))
+            {
+                // If yes, then set endpoint to hit-point.
+                endPoint = hit.point;
+            }
+
+            // Set end point of laser.
+            beam.SetPosition(0, origin);
+            beam.SetPosition(1, endPoint);
+            // Draw the laser!
+            beam.enabled = true;
+            /*Ray ray = camera.ScreenPointToRay(Input.mousePosition);
+            RaycastHit raycastHit;
+
+            if (Physics.Raycast(ray, out raycastHit, 5.0f)){
+            LineRenderer.SetPosition(1, raycastHit.point);
+            }*/
+
+        }
+
+        else if (!Input.GetMouseButton(1) && beam.enabled == true)
+        {
+            beam.enabled = false;
+            //if teleporting due to hit to object, bump them a bit outside normal
+            if (hit.point != null)
+            {
+                transform.position = endPoint + hit.normal * 1.25f;
+
+            }
+            //if teleporting in the air or something, just spawn at endpoint
+            else
+            {
+
+                transform.position = endPoint;
+            }
+            //reenable character controller
+        }
+    }
+    
+}

Assets/Scripts/PlayerScripts/MovementAbilities/Blink.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5162a84172831f4449df60b9ad0ce22f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/PlayerScripts/MovementAbilities/Dash.cs

@@ -0,0 +1,39 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+public class Dash : MonoBehaviour{
+    public Vector3 moveDirection;
+ 
+    public const float maxDashTime = 1.0f;
+    public float dashDistance = 10;
+    public float dashStoppingSpeed = 0.1f;
+    float currentDashTime = maxDashTime;
+    float dashSpeed = 12;
+
+    CharacterController characterController;
+
+    void Start(){
+        characterController = this.gameObject.GetComponent<CharacterController>();
+    }
+
+    //UPDATE CHECK FOR MOVEMENT ONLY WHEN DASHING
+    void FixedUpdate(){
+        if (Input.GetKeyDown(KeyCode.E))
+        {
+            currentDashTime = 0;                
+        }
+        if(currentDashTime < maxDashTime)
+        {
+            moveDirection = transform.forward * dashDistance;
+            currentDashTime += dashStoppingSpeed;
+        }
+        else
+        {
+            moveDirection = Vector3.zero;
+        }
+        characterController.Move(moveDirection * Time.deltaTime * dashSpeed);
+    }
+
+}

Assets/Scripts/PlayerScripts/MovementAbilities/Dash.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 980b3f40ede2d8a4c96587100cf71d02
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/PlayerScripts/MovementAbilities/GrapplingHook.cs

@@ -0,0 +1,67 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class GrapplingHook : MonoBehaviour
+{
+    public float maxGrappleDistance = 25;
+
+    private bool isGrappled;
+    private int hookPointIndex;
+    private GameObject hookPoint;
+    private GameObject[] hookPoints;
+    private float distance;
+
+    // Start is called before the first frame update
+    void Start()
+    {
+        isGrappled = false; 
+        hookPoints = GameObject.FindGameObjectsWithTag("HookPoint");
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        if (Input.GetKeyDown(KeyCode.E)) //If grapple button is hit
+        {
+            if (!isGrappled) //If we are not grappling
+            {
+                hookPointIndex = FindHookPoint(); //Find the nearest hook point within max distance
+                if (hookPointIndex != -1) //If there is a hookpoint
+                {
+                    hookPoint = hookPoints[hookPointIndex]; //The point we are grappling from
+                    //physics set up?
+                    isGrappled = true; //toggle grappling state
+                }
+            } 
+            else //Else we are grappling
+            {
+                //physics tear down?
+                isGrappled = false; //toggle grappling state to release
+            }
+        }
+    }
+
+    private void FixedUpdate()
+    {
+        if (isGrappled)
+        {
+            //Do grappling physics based on hookPoint
+        }
+    }
+
+    int FindHookPoint()
+    {
+        float least = maxGrappleDistance;
+        int index = -1;
+        for(int i = 0; i<hookPoints.Length; i++)
+        {
+            distance = Vector3.Distance(gameObject.transform.position, hookPoints[i].transform.position);
+            if (distance <= least)
+            {
+                index = i;
+            }
+        }
+        return index;
+    }
+}

Assets/Scripts/PlayerScripts/MovementAbilities/GrapplingHook.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cee70ea30de57ec43a325c1ca6257526
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/PlayerScripts/MovementAbilities/Kick.cs

@@ -0,0 +1,25 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class Kick : MonoBehaviour
+{
+    private float kickForce = 50f;
+    // Start is called before the first frame update
+    void Start(){
+    }
+
+    // Update is called once per frame
+    void Update(){
+        
+    }
+
+    private void OnCollisionEnter(Collision collision)
+    {
+        if (collision.transform.CompareTag("kickable")){
+            Vector3 direction = this.transform.forward;
+            Debug.Log(direction);
+            collision.rigidbody.AddForce(direction * kickForce, ForceMode.Impulse);
+        }
+    }
+}

Assets/Scripts/PlayerScripts/MovementAbilities/Kick.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f9b52b0ade3c44e47a3a4dc48c47ec1c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/PlayerScripts/MovementAbilities/KickController.cs

@@ -0,0 +1,55 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class KickController : MonoBehaviour
+{
+    //Important, may want to change blink code to only work for trigger collider 
+    // so that the player doesn't teleport to their leg
+    public GameObject leg;
+    private bool isKicking = false;
+    //slightly bad practice, when merging find a better work around
+    private bool isDiveKicking = false;
+    private CharacterController characterController;
+
+    void Start(){
+        characterController = this.gameObject.GetComponent<CharacterController>();
+            
+    }
+
+    void Update(){
+        //Note: when we merge this into PlayerMovement, we may want to change isgrounded to our 
+        //custom is grounded
+        if (Input.GetKeyDown(KeyCode.F) && isKicking == false && characterController.isGrounded == false)
+        {
+            Debug.Log("dive");
+            // if kicking in air, kick until grounded (maybe add some foward momentum if needeD)
+            isKicking = true;
+            isDiveKicking = true;
+            leg.SetActive(true);
+        }
+        //otherwise do ground kick for .3 seconds
+        else if (Input.GetKeyDown(KeyCode.F) && isKicking == false){
+            Debug.Log("kick");
+            StartCoroutine(Kicking(.3f));
+        }
+
+        //once dive kick touches ground, set back to normal state
+        if(characterController.isGrounded == true && isDiveKicking == true){
+            isDiveKicking = false;
+            isKicking = false;
+            leg.SetActive(false);
+
+        }
+    }
+
+    private IEnumerator Kicking(float waitTime){
+        isKicking = true;
+        leg.SetActive(true);
+        yield return new WaitForSeconds(waitTime);
+        isKicking = false;
+        leg.SetActive(false);
+
+    }
+
+}

Assets/Scripts/PlayerScripts/MovementAbilities/KickController.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0c0aad94b3b1332408ef8e7d07f3b321
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/PlayerScripts/MovementAbilities/Nitro.cs

@@ -0,0 +1,20 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class Nitro : MonoBehaviour
+{
+    private PlayerStats playerStats;
+    // Start is called before the first frame update
+    void Start(){
+        playerStats = this.gameObject.GetComponent<PlayerStats>();
+    }
+
+    // Update is called once per frame
+    void Update(){
+        //once cooldowns are implemented, put this on one (a long one)
+        if (Input.GetKeyDown(KeyCode.LeftShift)){
+            playerStats.CurVel = playerStats.MaxVel;
+        }
+    }
+}

Assets/Scripts/PlayerScripts/MovementAbilities/Nitro.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1a8c22589436d2449a89cf3a40b6d252
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/PlayerScripts/MovementAbilities/Slide.cs

@@ -0,0 +1,74 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+//Mote: This should be refactored at some point
+public class Slide : MonoBehaviour{
+    //this may be deprecated at some poiint later in development if we start ussing a rigid bod
+    public Camera playerCam;
+    private bool isSliding = false;
+    private CharacterController charController;
+    private PlayerStats playerStats;
+    private float orignalTraction;
+    private RaycastHit ray;
+    private Vector3 up;
+    // Start is called before the first frame update
+    void Start(){
+        
+    }
+    private void Awake(){
+        charController = this.gameObject.GetComponentInParent<CharacterController>();
+        playerStats = this.gameObject.GetComponentInParent<PlayerStats>();
+        up = this.gameObject.GetComponentInParent<Transform>().up;
+    }
+    // Update is called once per frame
+    void Update(){
+        //Debug.DrawRay(this.gameObject.transform.position, up, Color.red, 5.0f);
+        //NOTE::
+        //if button is held down, start sliding
+
+        if (Input.GetKey(KeyCode.Q)){
+            if (isSliding == false){
+                orignalTraction = playerStats.Traction;
+                this.gameObject.transform.eulerAngles = new Vector3(this.transform.eulerAngles.x - 90, this.transform.eulerAngles.y, this.transform.eulerAngles.z);
+                isSliding = true;
+                charController.height = 1.0f;
+                playerStats.Traction = 0.01f;
+          
+            }
+        }
+        //NOTE: potentialy change this to only allow player back up if there is nothing above them
+        if (Input.GetKeyUp(KeyCode.Q)) {
+            //if nothing is above the object, stop slidding
+            if (Physics.Raycast(this.gameObject.transform.position, up, out ray, 5f) == false)
+            {
+                this.gameObject.transform.eulerAngles = new Vector3(this.transform.eulerAngles.x - 90, this.transform.eulerAngles.y, this.transform.eulerAngles.z);
+                isSliding = false;
+                charController.height = 2.0f;
+                playerStats.Traction = orignalTraction;
+
+            }
+            else{
+                Debug.Log("Object above you");
+
+            }
+        }
+        //if button is not held down, and still slidding (if they let go but something was above them) check to see if something is still above them, if not 
+        else if (Input.GetKey(KeyCode.Q) == false && isSliding==true){
+            //if nothing is above the object, stop slidding
+            if (Physics.Raycast(this.gameObject.transform.position, up, out ray, 5f) == false)
+            {
+                this.gameObject.transform.eulerAngles = new Vector3(this.transform.eulerAngles.x - 90, this.transform.eulerAngles.y, this.transform.eulerAngles.z);
+                isSliding = false;
+                charController.height = 2.0f;
+                playerStats.Traction = orignalTraction;
+
+            }
+            else
+            {
+                Debug.Log("Object above you");
+
+            }
+
+        }
+    }
+}

Assets/Scripts/PlayerScripts/MovementAbilities/Slide.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: aa419fd069f632e479eda138a7764362
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/PlayerScripts/MovementAbilities/WallRun.cs

@@ -0,0 +1,189 @@
+using UnityEngine;
+using System.Linq;
+using UnityEngine.Rendering;
+
+[RequireComponent (typeof(PlayerMovement))]
+public class WallRun : MonoBehaviour
+{
+
+    public float wallMaxDistance = 1;
+    public float wallSpeedMultiplier = 1.2f;
+    public float minimumHeight = 1.2f;
+    public float maxAngleRoll = 20;
+    [Range(0.0f, 1.0f)]
+    public float normalizedAngleThreshold = 0.1f;
+    
+    public float jumpDuration = 1;
+    public float wallBouncing = 3;
+    public float cameraTransitionDuration = 1;
+
+    public float wallGravityDownForce = 20f;
+
+    [Space]
+    PlayerMovement playerMovementController;
+
+    Vector3[] directions;
+    RaycastHit[] hits;
+
+    bool isWallRunning = false;
+    Vector3 lastWallPosition;
+    Vector3 lastWallNormal;
+    float elapsedTimeSinceJump = 0;
+    float elapsedTimeSinceWallAttach = 0;
+    float elapsedTimeSinceWallDetatch = 0;
+    bool jumping;
+
+    bool isPlayergrounded() => playerMovementController.isGrounded;
+
+    public bool IsWallRunning() => isWallRunning;
+
+    bool CanWallRun()
+    {
+        float verticalAxis = Input.GetAxisRaw("Vertical");
+        
+        return !isPlayergrounded() && verticalAxis > 0 && VerticalCheck();
+    }
+
+    bool VerticalCheck()
+    {
+        return !Physics.Raycast(transform.position, Vector3.down, minimumHeight);
+    }
+
+
+    void Start()
+    {
+        playerMovementController = GetComponent<PlayerMovement>();
+
+         directions = new Vector3[]{ 
+            Vector3.right, 
+            Vector3.right + Vector3.forward,
+            Vector3.forward, 
+            Vector3.left + Vector3.forward, 
+            Vector3.left
+        };
+    }
+
+
+    public void WallRunRoutine()
+    {  
+        isWallRunning = false;
+
+        if(playerMovementController.GetJumpPressed())
+        {
+            jumping = true;
+        }
+
+        if(CanAttach())
+        {
+            hits = new RaycastHit[directions.Length];
+
+            for(int i=0; i<directions.Length; i++)
+            {
+                Vector3 dir = transform.TransformDirection(directions[i]);
+                Physics.Raycast(transform.position, dir, out hits[i], wallMaxDistance);
+                //if(hits[i].collider != null)
+                //{
+                    //Debug.DrawRay(transform.position, dir * hits[i].distance, Color.green);
+                //}
+                //else
+                //{
+                    //Debug.DrawRay(transform.position, dir * wallMaxDistance, Color.red);
+                //}
+            }
+
+            if(CanWallRun())
+            {   
+                hits = hits.ToList().Where(h => h.collider != null).OrderBy(h => h.distance).ToArray();
+                if(hits.Length > 0)
+                {
+                    if(hits[0].collider.tag == "WallRun")
+                    {
+                        OnWall(hits[0]);
+                        lastWallPosition = hits[0].point;
+                        lastWallNormal = hits[0].normal;
+                    }
+                }
+            }
+        }
+
+        if(isWallRunning)
+        {
+            elapsedTimeSinceWallDetatch = 0;
+            elapsedTimeSinceWallAttach += Time.deltaTime;
+            playerMovementController.AddPlayerVelocity((Vector3.down * wallGravityDownForce * Time.deltaTime));
+        }
+        else
+        {   
+            elapsedTimeSinceWallAttach = 0;
+            elapsedTimeSinceWallDetatch += Time.deltaTime;
+        }
+    }
+
+    bool CanAttach()
+    {
+        if(jumping)
+        {
+            elapsedTimeSinceJump += Time.deltaTime;
+            if(elapsedTimeSinceJump > jumpDuration)
+            {
+                elapsedTimeSinceJump = 0;
+                jumping = false;
+            }
+            return false;
+        }
+        return true;
+    }
+
+    void OnWall(RaycastHit hit){
+        float d = Vector3.Dot(hit.normal, Vector3.up);
+        if(d >= -normalizedAngleThreshold && d <= normalizedAngleThreshold)
+        {
+            // Vector3 alongWall = Vector3.Cross(hit.normal, Vector3.up);
+            float vertical = Input.GetAxisRaw("Vertical");
+            Vector3 alongWall = transform.TransformDirection(Vector3.forward);
+
+            //Debug.DrawRay(transform.position, alongWall.normalized * 10, Color.green);
+            //Debug.DrawRay(transform.position, lastWallNormal * 10, Color.magenta);
+
+            Vector3 moveToSet = alongWall * vertical * playerMovementController.PlayerSpeed() *Time.deltaTime;// * wallSpeedMultiplier;
+            moveToSet.y = 0;
+
+            playerMovementController.SetPlayerVelocity(moveToSet);
+            //Debug.Log("On Wall");
+            isWallRunning = true;
+        }
+    }
+
+    float CalculateSide()
+    {
+        if(isWallRunning)
+        {
+            Vector3 heading = lastWallPosition - transform.position;
+            Vector3 perp = Vector3.Cross(transform.forward, heading);
+            float dir = Vector3.Dot(perp, transform.up);
+            return dir;
+        }
+        return 0;
+    }
+
+    public float GetCameraRoll() //Cause camera to roll when wall running - call to this is player movement
+    {
+        float dir = CalculateSide();
+        float cameraAngle = playerMovementController.GetPlayerCamera().transform.eulerAngles.z;
+        float targetAngle = 0;
+        if(dir != 0)
+        {
+            targetAngle = Mathf.Sign(dir) * maxAngleRoll;
+        }
+        return Mathf.LerpAngle(cameraAngle, targetAngle, Mathf.Max(elapsedTimeSinceWallAttach, elapsedTimeSinceWallDetatch) / cameraTransitionDuration);
+    } 
+
+    public Vector3 GetWallJumpDirection() //Add call in jump where if we are wallrunning and jump, the jump vector is multiplied by this
+    {
+        if(isWallRunning)
+        {
+            return lastWallNormal * wallBouncing + Vector3.up;
+        }
+        return Vector3.zero;
+    } 
+}

Assets/Scripts/PlayerScripts/MovementAbilities/WallRun.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 535009eaa735a4c4e95c6fc270e32741
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: