maint: final tweaks and cleanups

Assets/Player/Graphs/GroundedCheckBT.asset

@@ -12,13 +12,13 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 7a686a47eee2fa44cb0a34b5d86e4d5e, type: 3}
   m_Name: GroundedCheckBT
   m_EditorClassIdentifier: 
-  _serializedGraph: '{"type":"NodeCanvas.BehaviourTrees.BehaviourTree","nodes":[{"repeaterMode":2,"repeatTimes":{"_value":1},"_position":{"x":476.0,"y":327.0},"$type":"NodeCanvas.BehaviourTrees.Repeater","$id":"0"},{"_position":{"x":550.0,"y":433.0},"$type":"NodeCanvas.BehaviourTrees.Sequencer","$id":"1"},{"_condition":{"valueA":{"_name":"isGrounded","_targetVariableID":"09b3259f-8b50-439a-ab86-ea3d8a4916f1"},"valueB":{},"$type":"NodeCanvas.Tasks.Conditions.CheckBoolean"},"_position":{"x":458.0,"y":522.0},"$type":"NodeCanvas.BehaviourTrees.WaitUntil","$id":"2"},{"_position":{"x":522.0,"y":632.0},"$type":"NodeCanvas.BehaviourTrees.Sequencer","$id":"3"},{"_action":{"airMoveDirection":{"_name":"airMoveDirection","_targetVariableID":"2fc91db6-09dd-4a1f-9195-426a0c44de31"},"inputVector3":{"_name":"groundMoveDirection","_targetVariableID":"a2c4fe25-9549-4bdd-8cec-2dbfc4a8856f"},"$type":"NodeCanvas.Tasks.Actions.SetAirMovement"},"_position":{"x":399.0,"y":775.0},"$type":"NodeCanvas.BehaviourTrees.ActionNode","$id":"4"},{"_action":{"airMoveDirection":{"_name":"groundMoveDirection","_targetVariableID":"a2c4fe25-9549-4bdd-8cec-2dbfc4a8856f"},"inputVector3":{},"$type":"NodeCanvas.Tasks.Actions.SetAirMovement"},"_position":{"x":576.0,"y":776.0},"$type":"NodeCanvas.BehaviourTrees.ActionNode","$id":"5"},{"_condition":{"valueA":{"_name":"isGrounded","_targetVariableID":"09b3259f-8b50-439a-ab86-ea3d8a4916f1"},"valueB":{"_value":true},"$type":"NodeCanvas.Tasks.Conditions.CheckBoolean"},"_position":{"x":715.0,"y":523.0},"$type":"NodeCanvas.BehaviourTrees.WaitUntil","$id":"6"}],"connections":[{"_sourceNode":{"$ref":"0"},"_targetNode":{"$ref":"1"},"$type":"NodeCanvas.BehaviourTrees.BTConnection"},{"_sourceNode":{"$ref":"1"},"_targetNode":{"$ref":"2"},"$type":"NodeCanvas.BehaviourTrees.BTConnection"},{"_sourceNode":{"$ref":"1"},"_targetNode":{"$ref":"6"},"$type":"NodeCanvas.BehaviourTrees.BTConnection"},{"_sourceNode":{"$ref":"2"},"_targetNode":{"$ref":"3"},"$type":"NodeCanvas.BehaviourTrees.BTConnection"},{"_sourceNode":{"$ref":"3"},"_targetNode":{"$ref":"4"},"$type":"NodeCanvas.BehaviourTrees.BTConnection"},{"_sourceNode":{"$ref":"3"},"_targetNode":{"$ref":"5"},"$type":"NodeCanvas.BehaviourTrees.BTConnection"}],"canvasGroups":[],"localBlackboard":{"_variables":{}},"derivedData":{"repeat":true,"$type":"NodeCanvas.BehaviourTrees.BehaviourTree+DerivedSerializationData"}}'
+  _serializedGraph: '{"type":"NodeCanvas.BehaviourTrees.BehaviourTree","nodes":[{"repeaterMode":2,"repeatTimes":{"_value":1},"_position":{"x":476.0,"y":327.0},"$type":"NodeCanvas.BehaviourTrees.Repeater","$id":"0"},{"_position":{"x":550.0,"y":433.0},"$type":"NodeCanvas.BehaviourTrees.Sequencer","$id":"1"},{"_condition":{"valueA":{"_name":"isGrounded","_targetVariableID":"09b3259f-8b50-439a-ab86-ea3d8a4916f1"},"valueB":{},"$type":"NodeCanvas.Tasks.Conditions.CheckBoolean"},"_position":{"x":458.0,"y":521.0},"$type":"NodeCanvas.BehaviourTrees.WaitUntil","$id":"2"},{"_position":{"x":478.0,"y":709.0},"$type":"NodeCanvas.BehaviourTrees.Sequencer","$id":"3"},{"_action":{"airMoveDirection":{"_name":"airMoveDirection","_targetVariableID":"2fc91db6-09dd-4a1f-9195-426a0c44de31"},"inputVector3":{"_name":"groundMoveDirection","_targetVariableID":"a2c4fe25-9549-4bdd-8cec-2dbfc4a8856f"},"$type":"NodeCanvas.Tasks.Actions.SetAirMovement"},"_position":{"x":294.0,"y":816.0},"$type":"NodeCanvas.BehaviourTrees.ActionNode","$id":"4"},{"_action":{"airMoveDirection":{"_name":"groundMoveDirection","_targetVariableID":"a2c4fe25-9549-4bdd-8cec-2dbfc4a8856f"},"inputVector3":{},"$type":"NodeCanvas.Tasks.Actions.SetAirMovement"},"_position":{"x":471.0,"y":817.0},"$type":"NodeCanvas.BehaviourTrees.ActionNode","$id":"5"},{"_condition":{"valueA":{"_name":"isGrounded","_targetVariableID":"09b3259f-8b50-439a-ab86-ea3d8a4916f1"},"valueB":{"_value":true},"$type":"NodeCanvas.Tasks.Conditions.CheckBoolean"},"_position":{"x":715.0,"y":523.0},"$type":"NodeCanvas.BehaviourTrees.WaitUntil","$id":"6"}],"connections":[{"_sourceNode":{"$ref":"0"},"_targetNode":{"$ref":"1"},"$type":"NodeCanvas.BehaviourTrees.BTConnection"},{"_sourceNode":{"$ref":"1"},"_targetNode":{"$ref":"2"},"$type":"NodeCanvas.BehaviourTrees.BTConnection"},{"_sourceNode":{"$ref":"1"},"_targetNode":{"$ref":"6"},"$type":"NodeCanvas.BehaviourTrees.BTConnection"},{"_sourceNode":{"$ref":"2"},"_targetNode":{"$ref":"3"},"_isDisabled":true,"$type":"NodeCanvas.BehaviourTrees.BTConnection"},{"_sourceNode":{"$ref":"3"},"_targetNode":{"$ref":"4"},"_isDisabled":true,"$type":"NodeCanvas.BehaviourTrees.BTConnection"},{"_sourceNode":{"$ref":"3"},"_targetNode":{"$ref":"5"},"$type":"NodeCanvas.BehaviourTrees.BTConnection"}],"canvasGroups":[],"localBlackboard":{"_variables":{}},"derivedData":{"repeat":true,"$type":"NodeCanvas.BehaviourTrees.BehaviourTree+DerivedSerializationData"}}'
   _objectReferences: []
   _graphSource:
     _version: 3.31
     _category: 
     _comments: 
-    _translation: {x: 150, y: -43}
+    _translation: {x: 444, y: -12}
     _zoomFactor: 1
   _haltSerialization: 0
   _externalSerializationFile: {fileID: 0}

Assets/Player/Graphs/PlayerLocomotionFSM.asset

@@ -1,30 +0,0 @@
-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!114 &11400000
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 0}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: f945e777233a59f4aba40aeca29093a6, type: 3}
-  m_Name: PlayerLocomotionFSM
-  m_EditorClassIdentifier: 
-  _serializedGraph: '{"type":"NodeCanvas.StateMachines.FSM","nodes":[{"_actionList":{"executionMode":1,"actions":[{"moveSpeed":{"_value":12.0},"moveDirection":{"_name":"groundMoveDirection","_targetVariableID":"16ae5ce4-097a-4c21-94a5-2c5d9ce73eb6"},"$type":"NodeCanvas.Tasks.Actions.CalculateGroundedLocomotion"},{"valueA":{"_name":"rotationSpeed","_targetVariableID":"d888730f-97df-4288-bb99-1f6c8a34a7c5"},"valueB":{"_value":10.0},"$type":"NodeCanvas.Tasks.Actions.SetFloat"},{"valueA":{"_name":"facingDirection","_targetVariableID":"c713d622-aafb-43e7-ae0e-ac0b86a85a37"},"valueB":{"_value":1},"$type":"NodeCanvas.Tasks.Actions.SetVariable`1[[Reset.Player.Movement.PlayerFacingDirection,
-    Core, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]]"}]},"_repeatStateActions":true,"_color":{"r":1.0,"g":0.42,"b":0.32,"a":1.0},"_position":{"x":559.9924,"y":711.7622},"$type":"NodeCanvas.StateMachines.ActionState","$id":"0"},{"_actionList":{"executionMode":1,"actions":[{"moveSpeed":{"_value":30.0},"moveDirection":{"_name":"groundMoveDirection","_targetVariableID":"16ae5ce4-097a-4c21-94a5-2c5d9ce73eb6"},"$type":"NodeCanvas.Tasks.Actions.CalculateGroundedLocomotion"},{"valueA":{"_name":"rotationSpeed","_targetVariableID":"d888730f-97df-4288-bb99-1f6c8a34a7c5"},"valueB":{"_value":1.0},"$type":"NodeCanvas.Tasks.Actions.SetFloat"},{"valueA":{"_name":"facingDirection","_targetVariableID":"c713d622-aafb-43e7-ae0e-ac0b86a85a37"},"valueB":{"_value":2},"$type":"NodeCanvas.Tasks.Actions.SetVariable`1[[Reset.Player.Movement.PlayerFacingDirection,
-    Core, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]]"}]},"_repeatStateActions":true,"_color":{"r":1.0,"g":0.42,"b":0.32,"a":1.0},"_position":{"x":916.0607,"y":852.7302},"$type":"NodeCanvas.StateMachines.ActionState","$id":"1"},{"_actionList":{"executionMode":1,"actions":[{"moveSpeed":{"_value":20.0},"moveDirection":{"_name":"groundMoveDirection","_targetVariableID":"16ae5ce4-097a-4c21-94a5-2c5d9ce73eb6"},"$type":"NodeCanvas.Tasks.Actions.CalculateGroundedLocomotion"},{"valueA":{"_name":"rotationSpeed","_targetVariableID":"d888730f-97df-4288-bb99-1f6c8a34a7c5"},"valueB":{"_value":2.0},"$type":"NodeCanvas.Tasks.Actions.SetFloat"}]},"_repeatStateActions":true,"_color":{"r":1.0,"g":0.42,"b":0.32,"a":1.0},"_position":{"x":1161.288,"y":522.152},"$type":"NodeCanvas.StateMachines.ActionState","$id":"2"},{"_position":{"x":383.6569,"y":483.1322},"$type":"NodeCanvas.StateMachines.AnyState","$id":"3"},{"_position":{"x":419.0,"y":609.0},"$type":"NodeCanvas.StateMachines.EmptyState","$id":"4"}],"connections":[{"_condition":{"actionName":{"_value":"Sprint"},"actionPhase":{"_value":3},"$type":"NodeCanvas.Tasks.Conditions.CheckInput"},"_sourceNode":{"$ref":"0"},"_targetNode":{"$ref":"1"},"$type":"NodeCanvas.StateMachines.FSMConnection"},{"_condition":{"timeout":{"_value":0.1},"$type":"NodeCanvas.Tasks.Conditions.Timeout"},"_sourceNode":{"$ref":"1"},"_targetNode":{"$ref":"2"},"$type":"NodeCanvas.StateMachines.FSMConnection"},{"_condition":{"checkAgainst":2,"checkAgainstValue":{"_value":{"z":1.0}},"desiredValue":{"_value":1.0},"tolerance":{"_value":0.32},"considerCameraRotation":{},"negate":{},"$type":"NodeCanvas.Tasks.Conditions.GetMovementInputDotProduct"},"_sourceNode":{"$ref":"2"},"_targetNode":{"$ref":"0"},"$type":"NodeCanvas.StateMachines.FSMConnection"},{"_condition":{"valueA":{"_name":"isGrounded","_targetVariableID":"321e55c7-f93e-4667-a0dc-559eb61c6898"},"valueB":{},"$type":"NodeCanvas.Tasks.Conditions.CheckBoolean"},"_sourceNode":{"$ref":"3"},"_targetNode":{"$ref":"4"},"$type":"NodeCanvas.StateMachines.FSMConnection"},{"_condition":{"valueA":{"_name":"isGrounded","_targetVariableID":"321e55c7-f93e-4667-a0dc-559eb61c6898"},"valueB":{"_value":true},"$type":"NodeCanvas.Tasks.Conditions.CheckBoolean"},"_sourceNode":{"$ref":"4"},"_targetNode":{"$ref":"0"},"$type":"NodeCanvas.StateMachines.FSMConnection"}],"canvasGroups":[],"localBlackboard":{"_variables":{"isGrounded":{"_propertyPath":"UnityEngine.CharacterController.isGrounded","_name":"isGrounded","_id":"321e55c7-f93e-4667-a0dc-559eb61c6898","$type":"NodeCanvas.Framework.Variable`1[[System.Boolean,
-    mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]"},"groundMoveDirection":{"_name":"groundMoveDirection","_id":"16ae5ce4-097a-4c21-94a5-2c5d9ce73eb6","_isPublic":true,"$type":"NodeCanvas.Framework.Variable`1[[UnityEngine.Vector3,
-    UnityEngine.CoreModule, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]]"},"rotationSpeed":{"_name":"rotationSpeed","_id":"d888730f-97df-4288-bb99-1f6c8a34a7c5","_isPublic":true,"$type":"NodeCanvas.Framework.Variable`1[[System.Single,
-    mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]"},"facingDirection":{"_name":"facingDirection","_id":"c713d622-aafb-43e7-ae0e-ac0b86a85a37","_isPublic":true,"$type":"NodeCanvas.Framework.Variable`1[[Reset.Player.Movement.PlayerFacingDirection,
-    Core, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]]"}}}}'
-  _objectReferences: []
-  _graphSource:
-    _version: 3.31
-    _category: 
-    _comments: 
-    _translation: {x: -258, y: -69}
-    _zoomFactor: 1
-  _haltSerialization: 0
-  _externalSerializationFile: {fileID: 0}

Assets/Player/Graphs/PlayerLocomotionFSM.asset.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: b307c218c1a404548afe65e66737fa80
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 11400000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Scripts/Core/GenericLockOnTarget.cs

@@ -1,14 +1,14 @@
+using System;
 using UnityEngine;
 
 public class GenericLockOnTarget : MonoBehaviour, ILockOnTarget{
     public float lockonTargetRadius{ get; set; } = 1f;
-
+    
-    // Start is called once before the first execution of Update after the MonoBehaviour is created
+    public void OnTargetDelete(){
-    void Start(){
+        GetComponent<ILockOnTarget>().SafelyDeleteTarget();
-
     }
 
-    void Update(){
+    void OnDestroy(){
-        
+        OnTargetDelete();
     }
 }

Assets/Scripts/Core/Graph Tasks/AddJump.cs

@@ -1,121 +0,0 @@
-using System;
-using System.Linq;
-using NodeCanvas.Framework;
-using ParadoxNotion;
-using ParadoxNotion.Design;
-using UnityEngine;
-using UnityEngine.InputSystem;
-using Reset.Player.Movement;
-
-namespace NodeCanvas.Tasks.Actions {
-	[Category("Reset/Movement")]
-	public class AddJump : ActionTask<CharacterController> {
-        public BBParameter<Vector3> airMoveDirection;
-        public BBParameter<float> jumpPower;
-        
-        [Space(5)]
-        public BBParameter<float> jumpStrength;
-        
-        [SliderField(0, 1)]
-        public BBParameter<float> standStillJumpStrength;
-
-        [Tooltip("Determines how much current movement vectors into jump direction")]
-        [SliderField(0, 1)]
-        public BBParameter<float> currentVelocityInheritence;
-        public BBParameter<Vector3> directionalForce;
-        
-        [SliderField(0, 1)]
-        public BBParameter<float> directionalForceStrength;
-        
-		protected override string info {
-			get{
-				string dirStrength = "";
-				
-				if (directionalForce.value != Vector3.zero && directionalForceStrength.value > 0f) {
-					dirStrength = $", towards <i>{directionalForce.value}</i> * {directionalForceStrength.value}";
-				}
-
-				return string.Format($"<b>Start Jump</b>, <i>{jumpStrength.value}</i> strength" + dirStrength);
-			}
-		}
-
-		//Use for initialization. This is called only once in the lifetime of the task.
-		//Return null if init was successfull. Return an error string otherwise
-		protected override string OnInit(){
-			return null;
-		}
-
-		//This is called once each time the task is enabled.
-		//Call EndAction() to mark the action as finished, either in success or failure.
-		//EndAction can be called from anywhere.
-		protected override void OnExecute(){
-			// Set jump power
-			jumpPower.value = jumpStrength.value;
-			
-			// Save current velocity and get current input direction
-			Vector3 currentVelocityVector3 = new Vector3(agent.velocity.x, 0f, agent.velocity.z);
-			Vector2 currentInput = agent.GetComponent<PlayerControls>().rawMoveInput;
-			Vector3 currentInputVector3 = new Vector3(currentInput.x, 0f, currentInput.y);
-			
-			// Ignore rotation for the current velocity
-			Vector3 currentVelocityWorld = agent.transform.InverseTransformDirection(currentVelocityVector3.normalized);
-			
-			// Get the dot product between current velocity's direction and current input (UNUSED FOR NOW)
-			float velocityInputDot = Vector3.Dot(currentVelocityWorld, currentInputVector3);
-			
-			// Set air move direction
-			if (agent.isGrounded) {
-				airMoveDirection.value = currentVelocityVector3;
-			} else {
-				// Hold new desired air direction and Dot against the existing air moving directioin
-				Vector3 desiredAirMoveDirection = currentInputVector3;
-				float airMoveDirectionDot = Vector3.Dot(desiredAirMoveDirection.normalized, airMoveDirection.value.normalized);
-				
-				// Check threshold of current XZ velocity- if it's too close to zero, use the jumpStrength for jumping velocity. If it's not, use the current velocity
-				float velocityThreshold = 4f;
-				float magnitudeZeroDifference = Mathf.Clamp(currentVelocityVector3.magnitude - velocityThreshold, 0f, Mathf.Infinity) / velocityThreshold; // Divided by maximum to return a 0-1 value. Clamping not required.
-				float outputHoritontalVelocity = Mathf.Lerp(jumpStrength.value, currentVelocityVector3.magnitude, Math.Clamp(magnitudeZeroDifference, 0f, 1f));
-				
-				outputHoritontalVelocity = Mathf.Min(outputHoritontalVelocity, Mathf.Lerp(standStillJumpStrength.value * jumpStrength.value, jumpStrength.value * .4f, magnitudeZeroDifference));
-
-				// Do the same for directional jump strength
-				outputHoritontalVelocity = Mathf.Lerp(outputHoritontalVelocity, jumpStrength.value, directionalForceStrength.value);
-				
-				// Remap the dot to  set -1 (opposing direction) to -.5f, and 1 (same direciton) to 1.2f
-				// This is done to allow some sideways jumping direction change, but none backwards, and all forwards
-				float remappedAirDirectionDot = Mathf.Lerp(.1f, 1.2f, airMoveDirectionDot);
-				remappedAirDirectionDot = Mathf.Clamp(remappedAirDirectionDot, 0f, 1f);
-				
-				// Lerp between the current direction and the inputted direction based on the previous dot product
-				Vector3 outputDirection = Vector3.Lerp(currentInputVector3.normalized, currentVelocityVector3.normalized, remappedAirDirectionDot);
-				
-				// If there is a directional force (such as the Wall Climb jump going straight upward) supplied in the task, lean into that based on it's strength
-				outputDirection = Vector3.Lerp(outputDirection, directionalForce.value.normalized, directionalForceStrength.value).normalized;
-				
-				// Extra math to degrade current air move direction by velocity inheritence, before applying new air direction
-				airMoveDirection.value *= currentVelocityInheritence.value;
-				
-				// Account for the camera's rotation before setting it as the air move direction
-				outputDirection = Camera.main.transform.rotation.Flatten(0, null, 0) * outputDirection;
-				
-				// Set air move direction
-				airMoveDirection.value += outputDirection * outputHoritontalVelocity;
-			}
-			EndAction(true);
-		}
-		
-		//Called once per frame while the action is active.
-		protected override void OnUpdate(){
-		}
-
-		//Called when the task is disabled.
-		protected override void OnStop() {
-			
-		}
-
-		//Called when the task is paused.
-		protected override void OnPause() {
-			
-		}
-	}
-}

Assets/Scripts/Core/Graph Tasks/AddJump.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 86e5b037e41d5bb4b8805890ee72ad29

Assets/Scripts/Core/Graph Tasks/CalculateAirMovement.cs

@@ -1,56 +0,0 @@
-using NodeCanvas.Framework;
-using ParadoxNotion.Design;
-using UnityEngine;
-using Reset.Player.Movement;
-
-namespace NodeCanvas.Tasks.Actions {
-	
-	[Category("Reset/Movement")]
-	public class CalculateAirMovement : ActionTask<Transform>{
-		public BBParameter<Vector3> airMoveDirection;
-		public BBParameter<Vector3> groundMoveDirection; // Unused on 7/29/25, delete if still unusued later
-		
-		private float airControlPower = 1f;
-		
-		//Use for initialization. This is called only once in the lifetime of the task.
-		//Return null if init was successfull. Return an error string otherwise
-		protected override string OnInit() {
-			return null;
-		}
-
-		//This is called once each time the task is enabled.
-		//Call EndAction() to mark the action as finished, either in success or failure.
-		//EndAction can be called from anywhere.
-		protected override void OnExecute(){
-			airControlPower = 1f;
-		}
-
-		//Called once per frame while the action is active.
-		protected override void OnUpdate() {
-			// Decay Current Air Movement
-			airMoveDirection.value = Vector3.Lerp(airMoveDirection.value, Vector3.zero, .7f * Time.deltaTime);
-			
-			// Decay Air Control power
-			airControlPower = Mathf.Lerp(airControlPower, 0f, 2f * Time.deltaTime);
-			
-			// Add air control
-			Vector3 inputVector3 = new(agent.GetComponent<PlayerControls>().rawMoveInput.x, 0f, agent.GetComponent<PlayerControls>().rawMoveInput.y);
-			float originalMagnitude = airMoveDirection.value.magnitude;
-			airMoveDirection.value += Camera.main.transform.rotation.Flatten(0, null, 0) *
-			                          inputVector3 * airControlPower;
-
-			airMoveDirection.value = Vector3.ClampMagnitude(airMoveDirection.value, originalMagnitude);
-		}
-
-		//Called when the task is disabled.
-		protected override void OnStop() {
-			// groundMoveDirection.value = agent.GetComponent<CharacterController>().velocity;
-			EndAction(true);
-		}
-
-		//Called when the task is paused.
-		protected override void OnPause() {
-			
-		}
-	}
-}

Assets/Scripts/Core/Graph Tasks/CalculateAirMovement.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 38d61a72cc7757448b3db6c04395cf91

Assets/Scripts/Core/Graph Tasks/CalculateGroundedLocomotion.cs

@@ -1,78 +0,0 @@
-using NodeCanvas.Framework;
-using ParadoxNotion.Design;
-using UnityEngine;
-
-
-namespace NodeCanvas.Tasks.Actions {
-
-	[Category("Reset/Movement")]
-	[Description("Unit flat ground movement")]
-	public class CalculateGroundedLocomotion : ActionTask<CharacterController>{
-		public BBParameter<float> moveSpeed;
-
-		
-		public BBParameter<Vector3> moveDirection;
-		
-		protected override string info {
-			get{
-				return string.Format($"<b>Set ground movement</b>, <i>{moveSpeed.value}</i> speed");
-			}
-		}
-		
-		private float sprintPower;
-		private bool sprinting;
-
-		//Use for initialization. This is called only once in the lifetime of the task.
-		//Return null if init was successfull. Return an error string otherwise
-		protected override string OnInit() {
-			return null;
-		}
-
-		//This is called once each time the task is enabled.
-		//Call EndAction() to mark the action as finished, either in success or failure.
-		//EndAction can be called from anywhere.
-		protected override void OnExecute() {
-			
-		}
-
-		//Called once per frame while the action is active.
-		protected override void OnUpdate() {
-			// Get current input direction
-			Vector3 flatSurfaceDirection = Vector3.zero;
-        
-			if (agent.isGrounded) {
-				Vector2 rawInput = agent.transform.GetComponent<PlayerControls>().rawMoveInput;
-				flatSurfaceDirection = new(rawInput.x, 0, rawInput.y);
-			}
-			
-			float CalculateSpeed(){
-				// Calculate sprinting speed
-				float outputSpeed = 0f;
-
-				// Add base speed
-				outputSpeed += moveSpeed.value;
-				
-				return outputSpeed;
-			}
-        
-			// Rotate input to forward direction for flat surface
-			// flatSurfaceDirection = agent.transform.rotation * flatSurfaceDirection;
-        
-			// Finalize flat surface direction by adding speed
-			flatSurfaceDirection *= CalculateSpeed();
-
-			moveDirection.value = flatSurfaceDirection;
-			EndAction(true);
-		}
-
-		//Called when the task is disabled.
-		protected override void OnStop() {
-			
-		}
-
-		//Called when the task is paused.
-		protected override void OnPause() {
-			
-		}
-	}
-}

Assets/Scripts/Core/Graph Tasks/CalculateGroundedLocomotion.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: 808dc54c4ce75e846890125a4f87e516

Assets/Scripts/Core/Graph Tasks/ChangeAgentTransform.cs

@@ -1,121 +0,0 @@
-using System;
-using NodeCanvas.Framework;
-using ParadoxNotion.Design;
-using ParadoxNotion.Serialization.FullSerializer;
-using Sirenix.OdinInspector;
-using UnityEngine;
-
-namespace NodeCanvas.Tasks.Actions {
-
-	[Category("Reset")]
-	[Description("Update the agent's position and rotation (scale too, sure whynot) either instantly or over time.")]
-	public class ChangeAgentTransform : ActionTask<CharacterController>{
-		public enum TransformProperty{
-			Position,
-			Rotation,
-			Scale
-		}
-
-		protected override string info {
-			get{
-				string basicText = string.Format($"Player {targetProperty.ToString()} to {(targetValue.isPresumedDynamic ? targetValue.name : targetValue.value)}");
-				basicText += relativeToSelf.value ? ", relative to Self" : "";
-				
-				return basicText;
-			}
-		}
-
-		public TransformProperty targetProperty;
-
-		[ParadoxNotion.Design.ShowIf("targetProperty", 0), Space(5)]
-		public BBParameter<bool> forcePositionChange;
-
-		public BBParameter<Vector3> targetValue;
-		
-		public BBParameter<bool> relativeToSelf;
-		
-		[Tooltip("Set this to the current position if you're trying to rotate by 'this much'. Keep it zero for world space values.")]
-		public BBParameter<Vector3> relativeValue;
-
-		public BBParameter<bool> changeInstantly;
-		public BBParameter<float> smoothing;
-
-		private Vector3 currentVel;
-		
-		
-		//Use for initialization. This is called only once in the lifetime of the task.
-		//Return null if init was successfull. Return an error string otherwise
-		protected override string OnInit() {
-			return null;
-		}
-
-		//This is called once each time the task is enabled.
-		//Call EndAction() to mark the action as finished, either in success or failure.
-		//EndAction can be called from anywhere.
-		protected override void OnExecute() {
-			switch (targetProperty) {
-				case TransformProperty.Position:
-					Vector3 relativeUseValue = relativeValue.value;
-					if (relativeToSelf.value) {
-						relativeUseValue = agent.transform.position;
-					}
-
-					if (changeInstantly.value) {
-						agent.Move(agent.transform.position.DirectionTo(relativeUseValue + targetValue.value));
-					} 
-					
-					break;
-				case TransformProperty.Rotation:
-					agent.transform.rotation = Quaternion.LookRotation(relativeValue.value) * Quaternion.Euler(targetValue.value);
-					break;
-				case TransformProperty.Scale:
-					break;
-				default:
-					throw new ArgumentOutOfRangeException();
-			}
-
-			if (changeInstantly.value) {
-				EndAction(true);
-			}
-		}
-
-		//Called once per frame while the action is active.
-		protected override void OnUpdate() {
-			switch (targetProperty) {
-				case TransformProperty.Position:
-					Vector3 relativeUseValue = relativeValue.value;
-					if (relativeToSelf.value) {
-						relativeUseValue = agent.transform.position;
-					}
-
-					if (!changeInstantly.value) {
-						Vector3 targetPosition = relativeUseValue + targetValue.value;
-						// agent.transform.position = Vector3.SmoothDamp(agent.transform.position, targetPosition,
-						// 	ref currentVel, smoothing.value * Time.deltaTime);
-						
-						agent.Move((agent.transform.position.DirectionTo(targetPosition)).normalized * .5f * Mathf.Lerp(0, 1, Vector3.Distance(agent.transform.position, targetPosition)) * smoothing.value * Time.deltaTime);
-						EndAction();
-					} 
-					
-					break;
-				case TransformProperty.Rotation:
-					agent.transform.rotation = Quaternion.Euler(relativeValue.value) * Quaternion.Euler(targetValue.value);
-					break;
-				case TransformProperty.Scale:
-					break;
-				default:
-					throw new ArgumentOutOfRangeException();
-			}
-		}
-
-		//Called when the task is disabled.
-		protected override void OnStop() {
-			
-		}
-
-		//Called when the task is paused.
-		protected override void OnPause() {
-			
-		}
-	}
-}

Assets/Scripts/Core/Graph Tasks/ChangeAgentTransform.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: b77e2b9ac9aad644480508d5a86f4006

Assets/Scripts/Core/Graph Tasks/ChangeCameraSettings.cs

@@ -1,343 +1,36 @@
 using NodeCanvas.Framework;
 using ParadoxNotion.Design;
+using Reset.Core;
 using Unity.Cinemachine;
 using UnityEditor;
 using UnityEngine;
 
-// Individual bool setting for each ring. Three of these will be used. 
-public struct OrbitalFollowValueGroup{
-	public string label;
-	
-	public CameraSettingsToggle changeHeight;
-	public float height;
-	
-	public CameraSettingsToggle changeRadius;
-	public float radius;
-
-	public OrbitalFollowValueGroup(string newLabel){
-		label = newLabel;
-		changeHeight = CameraSettingsToggle.NoChange;
-		height = 0f;
-		changeRadius = CameraSettingsToggle.NoChange;
-		radius = 0f;
-	}
-}
-
-// Setting for any X and Y based values
-public struct CinemachineVectorValueGroup{
-	public CameraSettingsToggle changeX;
-	public float xValue;
-	public CameraSettingsToggle changeY;
-	public float yValue;
-}
-
-// Enum options for individual camera settings
-public enum CameraSettingsToggle{
-	NoChange,
-	NewValue,
-	ResetValue,
-}
-
-public struct Vector3CameraValueGroup{
-	public string label;
-	public Vector3 newValue;
-	
-	public CameraSettingsToggle changeX;
-	public CameraSettingsToggle changeY;
-	public CameraSettingsToggle changeZ;
-	
-	public Vector3CameraValueGroup(string newLabel){
-		changeX = CameraSettingsToggle.NoChange;
-		changeY = CameraSettingsToggle.NoChange;
-		changeZ = CameraSettingsToggle.NoChange;
-
-		newValue = Vector3.zero;
-		label = newLabel;
-	}
-}
-
-public struct Vector2CameraValueGroup{
-	public string label;
-	public Vector2 newValue;
-	
-	public CameraSettingsToggle changeX;
-	public CameraSettingsToggle changeY;
-	
-	public Vector2CameraValueGroup(string newLabel){
-		changeX = CameraSettingsToggle.NoChange;
-		changeY = CameraSettingsToggle.NoChange;
-
-		newValue = Vector2.zero;
-		label = newLabel;
-	}
-}
-
-public struct FloatCameraValueGroup{
-	public string label;
-	public float value;
-
-	public CameraSettingsToggle changeValue;
-
-	public FloatCameraValueGroup(string newLabel){
-		label = newLabel;
-		value = 0f;
-		changeValue = CameraSettingsToggle.NoChange;
-	}
-}
-
-#if UNITY_EDITOR
-public class FloatCameraValueGroupDrawer : ObjectDrawer<FloatCameraValueGroup>  {
-	public override FloatCameraValueGroup OnGUI(GUIContent _content, FloatCameraValueGroup _instance){
-		// Remove label for floats
-		EditorGUIUtility.labelWidth = 50;
-		
-		// Set layout options for the label and the float fields
-		GUILayoutOption[] floatOptions = new GUILayoutOption[] {
-			GUILayout.Width(80.0f), 
-			GUILayout.MinWidth(20.0f), 
-			GUILayout.ExpandWidth(true), 
-		};
-
-		GUILayoutOption[] labelOptions = new GUILayoutOption[]{
-			GUILayout.Width(200.0f),
-		};
-		
-		// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
-		GUILayout.BeginVertical();
-		GUILayout.Label(_instance.ToString(), labelOptions);
-		GUILayout.BeginHorizontal();
-		
-		// Create the x settings enum
-		_instance.changeValue = (CameraSettingsToggle)EditorGUILayout.EnumPopup("", instance.changeValue);
-		
-		// Create the value/disabled information field
-		if (_instance.changeValue == CameraSettingsToggle.NewValue){
-			_instance.value = EditorGUILayout.FloatField(_instance.value, floatOptions);
-		} else {
-			EditorGUI.BeginDisabledGroup(true);
-			EditorGUILayout.TextField(_instance.changeValue == CameraSettingsToggle.NoChange ? "Unchanged" : "Reset", floatOptions);
-			EditorGUI.EndDisabledGroup();
-		}
-		
-		// Close this line up
-		GUILayout.EndHorizontal();
-		GUILayout.EndVertical();
-		
-		// Reset to default so the rest of things don't get messed up
-		EditorGUIUtility.labelWidth = 0;
-		return _instance;
-	}
-}
-
-public class Vector3CameraValueGroupDrawer : ObjectDrawer<Vector3CameraValueGroup>  {
-	public override Vector3CameraValueGroup OnGUI(GUIContent _content, Vector3CameraValueGroup _instance){
-		// Remove label for floats
-		EditorGUIUtility.labelWidth = 20;
-		
-		// Set layout options for the label and the float fields
-		GUILayoutOption[] floatOptions = new GUILayoutOption[] {
-			GUILayout.Width(300.0f), 
-			GUILayout.MinWidth(20.0f), 
-			GUILayout.ExpandWidth(true), 
-		};
-
-		GUILayoutOption[] labelOptions = new GUILayoutOption[]{
-			GUILayout.Width(200.0f),
-		};
-		
-		// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
-		GUILayout.BeginVertical();
-		GUILayout.Label(_instance.label, labelOptions);
-		GUILayout.BeginHorizontal();
-		
-		// Create the x settings enum
-		_instance.changeX = (CameraSettingsToggle)EditorGUILayout.EnumPopup("", instance.changeX);
-		
-		// Create the value/disabled information field
-		if (_instance.changeX == CameraSettingsToggle.NewValue){
-			_instance.newValue.x = EditorGUILayout.FloatField(_instance.newValue.x, floatOptions);
-		} else {
-			EditorGUI.BeginDisabledGroup(true);
-			EditorGUILayout.TextField(_instance.changeX == CameraSettingsToggle.NoChange ? "Unchanged" : "Reset", floatOptions);
-			EditorGUI.EndDisabledGroup();
-		}
-		  
-		// It do what it do.
-		GUILayout.Space(5);
-		
-		// Create the y settings enum
-		_instance.changeY = (CameraSettingsToggle)EditorGUILayout.EnumPopup("", _instance.changeY);
-		
-		// Create the value/disabled information field
-		if (_instance.changeY == CameraSettingsToggle.NewValue){
-			_instance.newValue.y = EditorGUILayout.FloatField(_instance.newValue.y, floatOptions);
-		} else {
-			EditorGUI.BeginDisabledGroup(true);
-			EditorGUILayout.TextField(_instance.changeY == CameraSettingsToggle.NoChange ? "Unchanged" : "Reset", floatOptions);
-			EditorGUI.EndDisabledGroup();
-		}
-		
-		// It do what it do.
-		GUILayout.Space(5);
-		
-		// Create the y settings enum
-		_instance.changeZ = (CameraSettingsToggle)EditorGUILayout.EnumPopup("", _instance.changeZ);
-		
-		// Create the value/disabled information field
-		if (_instance.changeZ == CameraSettingsToggle.NewValue){
-			_instance.newValue.z = EditorGUILayout.FloatField(_instance.newValue.z, floatOptions);
-		} else {
-			EditorGUI.BeginDisabledGroup(true);
-			EditorGUILayout.TextField(_instance.changeZ == CameraSettingsToggle.NoChange ? "Unchanged" : "Reset", floatOptions);
-			EditorGUI.EndDisabledGroup();
-		}
-		
-		// Close this line up
-		GUILayout.EndHorizontal();
-		GUILayout.EndVertical();
-		
-		// Reset to default so the rest of things don't get messed up
-		EditorGUIUtility.labelWidth = 0;
-		return _instance;
-	}
-}
-
-public class Vector2CameraValueGroupDrawer : ObjectDrawer<Vector2CameraValueGroup>  {
-	public override Vector2CameraValueGroup OnGUI(GUIContent _content, Vector2CameraValueGroup _instance){
-		// Remove label for floats
-		EditorGUIUtility.labelWidth = 50;
-		
-		// Set layout options for the label and the float fields
-		GUILayoutOption[] floatOptions = new GUILayoutOption[] {
-			GUILayout.Width(300.0f), 
-			GUILayout.MinWidth(20.0f), 
-			GUILayout.ExpandWidth(true), 
-		};
-
-		GUILayoutOption[] labelOptions = new GUILayoutOption[]{
-			GUILayout.Width(200.0f),
-		};
-		
-		// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
-		GUILayout.BeginVertical();
-		GUILayout.Label(_instance.label, labelOptions);
-		GUILayout.BeginHorizontal();
-		
-		// Create the x settings enum
-		_instance.changeX = (CameraSettingsToggle)EditorGUILayout.EnumPopup("", instance.changeX);
-		
-		// Create the value/disabled information field
-		if (_instance.changeX == CameraSettingsToggle.NewValue){
-			_instance.newValue.x = EditorGUILayout.FloatField(_instance.newValue.x, floatOptions);
-		} else {
-			EditorGUI.BeginDisabledGroup(true);
-			EditorGUILayout.TextField(_instance.changeX == CameraSettingsToggle.NoChange ? "Unchanged" : "Reset", floatOptions);
-			EditorGUI.EndDisabledGroup();
-		}
-		  
-		// It do what it do.
-		GUILayout.Space(5);
-		
-		// Create the y settings enum
-		_instance.changeY = (CameraSettingsToggle)EditorGUILayout.EnumPopup("", _instance.changeY);
-		
-		// Create the value/disabled information field
-		if (_instance.changeY == CameraSettingsToggle.NewValue){
-			_instance.newValue.y = EditorGUILayout.FloatField(_instance.newValue.y, floatOptions);
-		} else {
-			EditorGUI.BeginDisabledGroup(true);
-			EditorGUILayout.TextField(_instance.changeY == CameraSettingsToggle.NoChange ? "Unchanged" : "Reset", floatOptions);
-			EditorGUI.EndDisabledGroup();
-		}
-		
-		// Close this line up
-		GUILayout.EndHorizontal();
-		GUILayout.EndVertical();
-		
-		// Reset to default so the rest of things don't get messed up
-		EditorGUIUtility.labelWidth = 0;
-		return _instance;
-	}
-}
-
-// Custom editor for each orbital follow ring setting
-public class OrbitalFollowValueGroupDrawer : ObjectDrawer<OrbitalFollowValueGroup>{
-	public override OrbitalFollowValueGroup OnGUI(GUIContent _content, OrbitalFollowValueGroup _instance){
-		// Remove label for floats
-		EditorGUIUtility.labelWidth = 1;
-		
-		// Set layout options for the label and the float fields
-		GUILayoutOption[] floatOptions = new GUILayoutOption[] {
-			GUILayout.Width(300.0f), 
-			GUILayout.MinWidth(20.0f), 
-			GUILayout.ExpandWidth(true), 
-		};
-
-		GUILayoutOption[] labelOptions = new GUILayoutOption[]{
-			GUILayout.Width(60.0f),
-		};
-		
-		// Start a Horiztonal Section
-		GUILayout.BeginHorizontal();
-		
-		// Add the left side label
-		GUILayout.Label(_instance.label, labelOptions);
-		
-		// Create the height settings enum
-		_instance.changeHeight = (CameraSettingsToggle)EditorGUILayout.EnumPopup("", _instance.changeHeight);
-		
-		// Create the value/disabled information field
-		if (_instance.changeHeight == CameraSettingsToggle.NewValue){
-			_instance.height = EditorGUILayout.FloatField(_instance.height, floatOptions);
-		} else {
-			EditorGUI.BeginDisabledGroup(true);
-			EditorGUILayout.TextField(_instance.changeHeight == CameraSettingsToggle.NoChange ? "Unchanged" : "Reset", floatOptions);
-			EditorGUI.EndDisabledGroup();
-		}
-		  
-		// It do what it do.
-		GUILayout.Space(5);
-		
-		// Create the radius settings enum
-		_instance.changeRadius = (CameraSettingsToggle)EditorGUILayout.EnumPopup("", _instance.changeRadius);
-		
-		// Create the value/disabled information field
-		if (_instance.changeRadius == CameraSettingsToggle.NewValue){
-			_instance.radius = EditorGUILayout.FloatField(_instance.radius, floatOptions);
-		} else {
-			EditorGUI.BeginDisabledGroup(true);
-			EditorGUILayout.TextField(_instance.changeRadius == CameraSettingsToggle.NoChange ? "Unchanged" : "Reset", floatOptions);
-			EditorGUI.EndDisabledGroup();
-		}
-		
-		// Close this line up
-		GUILayout.EndHorizontal();
-		
-		// Reset to default so the rest of things don't get messed up
-		EditorGUIUtility.labelWidth = 0;
-		return _instance;
-	}
-}
-#endif
-
 namespace NodeCanvas.Tasks.Actions {
 	[Category("Reset")]
 	[Description("Change Cinemachine camera settings for the player")]
 	public class ChangeCameraSettings : ActionTask{
 		[ParadoxNotion.Design.Header("Main Settings")]
-		public FloatCameraValueGroup fieldOfView = new (newLabel: "FOV");
+		public FloatValueGroup fieldOfView = new (newLabel: "FOV");
 
 		[ParadoxNotion.Design.Header("Orbit Follow Ring Settings"), Space (5)]
-		public Vector3CameraValueGroup orbitPositionDamping = new(newLabel: "Position Damping");
+		public Vector3ValueGroup orbitTargetOffset = new(newLabel: "Target Offset");
+		[Space(5)]public Vector3ValueGroup orbitPositionDamping = new(newLabel: "Position Damping");
+		
 		public OrbitalFollowValueGroup orbitFollowTop = new (newLabel: "Top");
 		public OrbitalFollowValueGroup orbitFollowCenter = new (newLabel: "Center");
 		public OrbitalFollowValueGroup orbitFollowBottom = new (newLabel: "Bottom");
+
+		public BoolValueGroup enableXAxis = new (newLabel: "Input Axis X Enabled");
+		public BoolValueGroup enableYAxis = new (newLabel: "Input Axis Y Enabled");
+		
+		public FloatValueGroup axisLookXGain = new (newLabel: "Look Orbit X Gain");
+		public FloatValueGroup axisLookYGain = new (newLabel: "Look Orbit Y Gain");
 		
 		[ParadoxNotion.Design.Header("Rotation Composer Settings")]
-		public Vector2CameraValueGroup screenPosition = new (newLabel: "Screen Position");
+		public Vector2ValueGroup screenPosition = new (newLabel: "Screen Position");
 		
 		[ParadoxNotion.Design.Header("Camera Offset Settings")]
-		public Vector3CameraValueGroup cameraOffset = new (newLabel: "Offset");
+		public Vector3ValueGroup cameraOffset = new (newLabel: "Offset");
 		
 		//Use for initialization. This is called only once in the lifetime of the task.
 		//Return null if init was successfull. Return an error string otherwise
@@ -349,150 +42,119 @@ namespace NodeCanvas.Tasks.Actions {
 		//Call EndAction() to mark the action as finished, either in success or failure.
 		//EndAction can be called from anywhere.
 		protected override void OnExecute(){
-			// Switch case farm for checking if values should be changed and what to
+			UpdateOrbitFollowValue(orbitFollowTop, ref CameraSettingsProcessor.values.orbitFollowTopHeight, ref CameraSettingsProcessor.values.orbitFollowTopRadius);
-			// Field of view
+			UpdateOrbitFollowValue(orbitFollowCenter, ref CameraSettingsProcessor.values.orbitFollowCenterHeight, ref CameraSettingsProcessor.values.orbitFollowCenterRadius);
-			switch (fieldOfView.changeValue) {
+			UpdateOrbitFollowValue(orbitFollowBottom, ref CameraSettingsProcessor.values.orbitFollowBottomHeight, ref CameraSettingsProcessor.values.orbitFollowBottomRadius);
-				case CameraSettingsToggle.NewValue:
-					CameraSettingsProcessor.values.mainFieldOfView.targetValue = fieldOfView.value;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.mainFieldOfView.Reset();
-					break;
-			}
 			
-			// Orbit follow rings
+			UpdateVector3Value(cameraOffset, ref CameraSettingsProcessor.values.cameraOffsetOffset);
-			switch (orbitFollowTop.changeHeight) {
-				case CameraSettingsToggle.NewValue:
-					CameraSettingsProcessor.values.orbitFollowTopHeight.targetValue = orbitFollowTop.height;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.orbitFollowTopHeight.Reset();
-					break;
-			}
 			
-			switch (orbitFollowTop.changeRadius) {
+			UpdateVector3Value(orbitPositionDamping, ref CameraSettingsProcessor.values.orbitPositionDamping);
-				case CameraSettingsToggle.NewValue:
+			UpdateVector3Value(orbitTargetOffset, ref CameraSettingsProcessor.values.orbitTargetOffset);
-					CameraSettingsProcessor.values.orbitFollowTopRadius.targetValue = orbitFollowTop.radius;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.orbitFollowTopRadius.Reset();
-					break;
-			}
 			
-			switch (orbitFollowCenter.changeHeight) {
+			UpdateVector2Value(screenPosition, ref CameraSettingsProcessor.values.rotationComposerScreenPos);
-				case CameraSettingsToggle.NewValue:
+			UpdateFloatValue(fieldOfView, ref CameraSettingsProcessor.values.mainFieldOfView);
-					CameraSettingsProcessor.values.orbitFollowCenterHeight.targetValue = orbitFollowCenter.height;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.orbitFollowCenterHeight.Reset();
-					break;
-			}
 			
-			switch (orbitFollowCenter.changeRadius) {
+			UpdateFloatValue(axisLookXGain, ref CameraSettingsProcessor.values.axisLookGainX);
-				case CameraSettingsToggle.NewValue:
+			UpdateFloatValue(axisLookYGain, ref CameraSettingsProcessor.values.axisLookGainY);
-					CameraSettingsProcessor.values.orbitFollowCenterRadius.targetValue = orbitFollowCenter.radius;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.orbitFollowCenterRadius.Reset();
-					break;
-			}
 			
-			switch (orbitFollowBottom.changeHeight) {
+			UpdateBoolValue(enableXAxis, ref CameraSettingsProcessor.values.axisLookEnabledX);
-				case CameraSettingsToggle.NewValue:
+			UpdateBoolValue(enableYAxis, ref CameraSettingsProcessor.values.axisLookEnabledY);
-					CameraSettingsProcessor.values.orbitFollowBottomHeight.targetValue = orbitFollowBottom.height;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.orbitFollowBottomHeight.Reset();
-					break;
-			}
 			
-			switch (orbitFollowBottom.changeRadius) {
-				case CameraSettingsToggle.NewValue:
-					CameraSettingsProcessor.values.orbitFollowBottomRadius.targetValue = orbitFollowBottom.radius;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.orbitFollowBottomRadius.Reset();
-					break;
-			}
-
-			// Screen Position
-			switch (screenPosition.changeX) {
-				case CameraSettingsToggle.NewValue:
-					CameraSettingsProcessor.values.rotationComposerScreenPos.targetValue.x = screenPosition.newValue.x;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.rotationComposerScreenPos.targetValue.x = CameraSettingsProcessor.values.rotationComposerScreenPos.originalValue.x;
-					break;
-			}
-			
-			switch (screenPosition.changeY) {
-				case CameraSettingsToggle.NewValue:
-					CameraSettingsProcessor.values.rotationComposerScreenPos.targetValue.y = screenPosition.newValue.y;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.rotationComposerScreenPos.targetValue.y = CameraSettingsProcessor.values.rotationComposerScreenPos.originalValue.y;
-					break;
-			}
-			
-			// Camera Offset
-			switch (cameraOffset.changeX) {
-				case CameraSettingsToggle.NewValue:
-					CameraSettingsProcessor.values.cameraOffsetOffset.targetValue.x = cameraOffset.newValue.x;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.cameraOffsetOffset.targetValue.x = CameraSettingsProcessor.values.cameraOffsetOffset.originalValue.x;
-					break;
-			}
-			
-			switch (cameraOffset.changeY) {
-				case CameraSettingsToggle.NewValue:
-					CameraSettingsProcessor.values.cameraOffsetOffset.targetValue.y = cameraOffset.newValue.y;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.cameraOffsetOffset.targetValue.y = CameraSettingsProcessor.values.cameraOffsetOffset.originalValue.y;
-					break;
-			}
-			
-			switch (cameraOffset.changeZ) {
-				case CameraSettingsToggle.NewValue:
-					CameraSettingsProcessor.values.cameraOffsetOffset.targetValue.z = cameraOffset.newValue.z;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.cameraOffsetOffset.targetValue.z = CameraSettingsProcessor.values.cameraOffsetOffset.originalValue.z;
-					break;
-			}
-			
-			// Position Damping
-			switch (orbitPositionDamping.changeX) {
-				case CameraSettingsToggle.NewValue:
-					CameraSettingsProcessor.values.orbitPositionDamping.targetValue.x = orbitPositionDamping.newValue.x;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.orbitPositionDamping.targetValue.x = CameraSettingsProcessor.values.orbitPositionDamping.originalValue.x;
-					break;
-			}
-			
-			switch (orbitPositionDamping.changeY) {
-				case CameraSettingsToggle.NewValue:
-					CameraSettingsProcessor.values.orbitPositionDamping.targetValue.y = orbitPositionDamping.newValue.y;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.orbitPositionDamping.targetValue.y = CameraSettingsProcessor.values.orbitPositionDamping.originalValue.y;
-					break;
-			}
-			
-			switch (orbitPositionDamping.changeZ) {
-				case CameraSettingsToggle.NewValue:
-					CameraSettingsProcessor.values.orbitPositionDamping.targetValue.z = orbitPositionDamping.newValue.z;
-					break;
-				case CameraSettingsToggle.ResetValue:
-					CameraSettingsProcessor.values.orbitPositionDamping.targetValue.z = CameraSettingsProcessor.values.orbitPositionDamping.originalValue.z;
-					break;
-			}
 			
 			EndAction(true);
 		}
 
+		public void UpdateVector3Value(Vector3ValueGroup valueGroup, ref CameraSettingSingleValue<Vector3> targetProperty){
+			switch (valueGroup.changeX) {
+				case ValueChangeAction.NewValue:
+					targetProperty.targetValue.x = valueGroup.newValue.x;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty.targetValue.x = targetProperty.originalValue.x;
+					break;
+			}
+			
+			switch (valueGroup.changeY) {
+				case ValueChangeAction.NewValue:
+					targetProperty.targetValue.y = valueGroup.newValue.y;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty.targetValue.y = targetProperty.originalValue.y;
+					break;
+			}
+			
+			switch (valueGroup.changeZ) {
+				case ValueChangeAction.NewValue:
+					targetProperty.targetValue.z = valueGroup.newValue.z;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty.targetValue.z = targetProperty.originalValue.z;
+					break;
+			}
+		}
+		
+		public void UpdateVector2Value(Vector2ValueGroup valueGroup, ref CameraSettingSingleValue<Vector2> targetProperty){
+			switch (valueGroup.changeX) {
+				case ValueChangeAction.NewValue:
+					targetProperty.targetValue.x = valueGroup.newValue.x;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty.targetValue.x = targetProperty.originalValue.x;
+					break;
+			}
+			
+			switch (valueGroup.changeY) {
+				case ValueChangeAction.NewValue:
+					targetProperty.targetValue.y = valueGroup.newValue.y;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty.targetValue.y = targetProperty.originalValue.y;
+					break;
+			}
+		}
+		
+		public void UpdateOrbitFollowValue(OrbitalFollowValueGroup valueGroup, ref CameraSettingSingleValue<float> targetHeight, ref CameraSettingSingleValue<float> targetRadius){
+			switch (valueGroup.changeHeight) {
+				case ValueChangeAction.NewValue:
+					targetHeight.targetValue = valueGroup.height;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetHeight.targetValue = targetHeight.originalValue;
+					break;
+			}
+			
+			switch (valueGroup.changeRadius) {
+				case ValueChangeAction.NewValue:
+					targetRadius.targetValue = valueGroup.radius;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetRadius.targetValue = targetRadius.originalValue;
+					break;
+			}
+		}
+		
+		public void UpdateBoolValue(BoolValueGroup valueGroup, ref CameraSettingSingleValue<bool> targetProperty){
+			switch (valueGroup.changeValue) {
+				case ValueChangeAction.NewValue:
+					targetProperty.targetValue = valueGroup.value;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty.targetValue = targetProperty.originalValue;
+					break;
+			}
+		}
+		
+		public void UpdateFloatValue(FloatValueGroup valueGroup, ref CameraSettingSingleValue<float> targetProperty){
+			switch (valueGroup.changeValue) {
+				case ValueChangeAction.NewValue:
+					targetProperty.targetValue = valueGroup.value;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty.targetValue = targetProperty.originalValue;
+					break;
+			}
+		}
+
 		//Called once per frame while the action is active.
 		protected override void OnUpdate() {
 			

Assets/Scripts/Core/Graph Tasks/ChangeMovementSettings.cs

@@ -0,0 +1,233 @@
+using System;
+using NodeCanvas.Framework;
+using ParadoxNotion.Design;
+using Reset.Units;
+using UnityEngine;
+
+namespace Reset.Core {
+	[Category("Reset")]
+	[Description("Commits movement unit changes to the handler.")]
+	public class ChangeMovementSettings : ActionTask<UnitMovementHandler> {
+		// Move Speed
+		[ParadoxNotion.Design.Header("Speed")]
+		public FloatValueGroup moveSpeed = new (newLabel: "Move Speed");
+		public FloatValueGroup moveSpeedSoothing = new (newLabel: "Move Speed Smoothing");
+
+		[ParadoxNotion.Design.Header("Direction")]
+		public FloatValueGroup airDirectionDecay = new FloatValueGroup("Air Direction Decay");
+		public FloatValueGroup accelerationSmoothing = new (newLabel: "Acceleration Smoothing");
+		public FloatValueGroup deaccelerationSmoothing = new (newLabel: "Deacceleration Smoothing");
+		// public CurveValueGroup deaccelerationCurve = new (newLabel: "Deacceleration Curve"); // Currently unused, may return
+
+		// Direction
+		[Space(5)]
+		public Vector3ValueGroup feedNewDirection = new Vector3ValueGroup("Feed New Direction");
+		public float newDirectionStrength;
+		[Space(5)]
+		public Vector2 addDirectionFromInput;
+		public float addInputStrength;
+		[SliderField(0,1)]
+		public float addInputPriorty;
+		
+		// Jumping
+		[ParadoxNotion.Design.Header("Jumping")]
+		public FloatValueGroup jumpPower = new (newLabel: "Jump Power");
+		public FloatValueGroup jumpPowerDecay = new (newLabel: "Jump Decay Speed");
+    
+		// Gravity
+		[ParadoxNotion.Design.Header("Gravity")]
+		public FloatValueGroup gravityPower = new (newLabel: "Gravity Power");
+		public FloatValueGroup gravityMax = new (newLabel: "Gravity Max");
+		public FloatValueGroup gravityAcceleration = new (newLabel: "Gravity Acceleration Speed");
+		public FloatValueGroup gravityScale = new (newLabel: "Gravity Scale");
+        
+		// Rotation
+		[ParadoxNotion.Design.Header("Rotation")]
+		public EnumValueGroup rotateFacing = new EnumValueGroup("Facing Direction", PlayerFacingDirection.TowardsTarget);
+		public FloatValueGroup rotationSpeed = new (newLabel: "Rotation Speed");
+		public FloatValueGroup rotationSmoothing = new (newLabel: "Rotation Smoothing");
+		public FloatValueGroup rotationInputBlending = new("Rotation Input Blending");
+		[Space(5)]
+		public BBParameter<Vector3> feedNewRotation;
+		public BBParameter<Vector3> feedRelativeTo;
+		public Space rotationRelativeSpace;
+
+		private Vector3 feedDir;
+
+		protected override string OnInit() {
+			return null;
+		}
+
+		//This is called once each time the task is enabled.
+		//Call EndAction() to mark the action as finished, either in success or failure.
+		//EndAction can be called from anywhere.
+		protected override void OnExecute() {
+			// Direction 
+			UpdateFloatValue(airDirectionDecay, ref agent.data.airDirectionDecay, ref agent.data.airDirectionDecay);
+			UpdateFloatValue(accelerationSmoothing, ref agent.data.accelerationSmoothing, ref agent.defaultData.accelerationSmoothing);
+			UpdateFloatValue(deaccelerationSmoothing, ref agent.data.deaccelerationSmoothing, ref agent.defaultData.deaccelerationSmoothing);
+			// UpdateCurveProperty(deaccelerationCurve, ref agent.data.deaccelerationCurve, ref agent.defaultData.deaccelerationCurve); // Currently unused, may return
+			
+			// Direction from value
+			// Check that feedDir is not changed
+			UpdateVector3Value(feedNewDirection, ref feedDir, ref feedDir); 
+
+			// If there's a direciton add it to the player for a frame
+			if (feedDir != Vector3.zero) {
+				agent.AddToCurrentDirection(agent.transform.rotation * feedDir.normalized, newDirectionStrength);
+				// Reset the fed direction after it's added so future runs don't have
+				feedDir = Vector3.zero;
+			}
+			
+			// Direction from controller input
+			if (addDirectionFromInput != Vector2.zero){
+				agent.OverwriteDirectionFromInput(new Vector3(addDirectionFromInput.x, addDirectionFromInput.y), addInputPriorty, addInputStrength);
+			}
+			
+			// Move Speed
+			UpdateFloatValue(moveSpeed, ref agent.data.moveSpeed, ref agent.defaultData.moveSpeed);
+			UpdateFloatValue(moveSpeedSoothing, ref agent.data.moveSpeedSoothing, ref agent.defaultData.moveSpeedSoothing);
+			
+			// Jump
+			UpdateFloatValue(jumpPower, ref agent.data.jumpPower, ref agent.defaultData.jumpPower);
+			UpdateFloatValue(jumpPowerDecay, ref agent.data.jumpPowerDecay, ref agent.defaultData.jumpPowerDecay);
+			
+			// Gravity
+			UpdateFloatValue(gravityPower, ref agent.data.gravityPower, ref agent.defaultData.gravityPower);
+			UpdateFloatValue(gravityMax, ref agent.data.gravityMax, ref agent.defaultData.gravityMax);
+			UpdateFloatValue(gravityAcceleration, ref agent.data.gravityAcceleration, ref agent.defaultData.gravityAcceleration);
+			UpdateFloatValue(gravityScale, ref agent.data.gravityScale, ref agent.defaultData.gravityScale);
+
+			// Rotation
+			UpdateEnumValue(rotateFacing, ref agent.data.rotateFacing, ref agent.defaultData.rotateFacing);
+			UpdateFloatValue(rotationSpeed, ref agent.data.rotationSpeed, ref agent.defaultData.rotationSpeed);
+			UpdateFloatValue(rotationSmoothing, ref agent.data.rotationSmoothing, ref agent.defaultData.rotationSmoothing);
+			UpdateFloatValue(rotationInputBlending, ref agent.data.rotationInputBlending, ref agent.defaultData.rotationInputBlending);
+			
+			// Rotation from value
+			if (feedNewRotation.value != Vector3.zero) {
+				if (rotationRelativeSpace == Space.World) {
+					Debug.Log(Quaternion.LookRotation(feedRelativeTo.value));
+					agent.SetSpecifiedRotation(Quaternion.Euler(feedNewRotation.value) * Quaternion.LookRotation(feedRelativeTo.value));
+				} else {
+					agent.SetSpecifiedRotation(agent.transform.rotation * Quaternion.Euler(feedNewRotation.value) * Quaternion.LookRotation(feedRelativeTo.value));
+				}
+			}
+			
+			EndAction(true);
+		}
+
+		//Called once per frame while the action is active.
+		protected override void OnUpdate() {
+			
+		}
+
+		//Called when the task is disabled.
+		protected override void OnStop() {
+			
+		}
+
+		//Called when the task is paused.
+		protected override void OnPause() {
+			
+		}
+
+		public void UpdateCurveProperty(CurveValueGroup valueGroup, ref AnimationCurve targetProperty, ref AnimationCurve defaultProperty){
+			switch (valueGroup.changeValue) {
+				case ValueChangeAction.NoChange:
+					break;
+				case ValueChangeAction.NewValue:
+					targetProperty = valueGroup.newValue;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty = defaultProperty;
+					break;
+				default:
+					throw new ArgumentOutOfRangeException();
+			}
+		}
+		
+		public void UpdateVector3Value(Vector3ValueGroup valueGroup, ref Vector3 targetProperty, ref Vector3 defaultProperty){
+			switch (valueGroup.changeX) {
+				case ValueChangeAction.NewValue:
+					targetProperty.x = valueGroup.newValue.x;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty.x = defaultProperty.x;
+					break;
+			}
+			
+			switch (valueGroup.changeY) {
+				case ValueChangeAction.NewValue:
+					targetProperty.y = valueGroup.newValue.y;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty.y = defaultProperty.y;
+					break;
+			}
+			
+			switch (valueGroup.changeZ) {
+				case ValueChangeAction.NewValue:
+					targetProperty.z = valueGroup.newValue.z;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty.z = defaultProperty.z;
+					break;
+			}
+		}
+		
+		public void UpdateVector2Value(Vector2ValueGroup valueGroup, ref Vector2 targetProperty, ref Vector2 defaultProperty){
+			switch (valueGroup.changeX) {
+				case ValueChangeAction.NewValue:
+					targetProperty.x = valueGroup.newValue.x;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty.x = defaultProperty.x;
+					break;
+			}
+			
+			switch (valueGroup.changeY) {
+				case ValueChangeAction.NewValue:
+					targetProperty.y = valueGroup.newValue.y;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty.y = defaultProperty.y;
+					break;
+			}
+		}
+
+		
+		public void UpdateBoolValue(BoolValueGroup valueGroup, ref bool targetProperty, ref bool defaultProperty){
+			switch (valueGroup.changeValue) {
+				case ValueChangeAction.NewValue:
+					targetProperty = valueGroup.value;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty = defaultProperty;
+					break;
+			}
+		}
+		
+		public void UpdateEnumValue(EnumValueGroup valueGroup, ref Enum targetProperty, ref Enum defaultProperty){
+			switch (valueGroup.changeValue) {
+				case ValueChangeAction.NewValue:
+					targetProperty = valueGroup.newValue;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty = defaultProperty;
+					break;
+			}
+		}
+		
+		public void UpdateFloatValue(FloatValueGroup valueGroup, ref float targetProperty, ref float defaultProperty){
+			switch (valueGroup.changeValue) {
+				case ValueChangeAction.NewValue:
+					targetProperty = valueGroup.value;
+					break;
+				case ValueChangeAction.ResetValue:
+					targetProperty = defaultProperty;
+					break;
+			}
+		}
+	}
+}

Assets/Scripts/Core/Graph Tasks/ChangeMovementSettings.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5132a76af4f722e49bc7fbbc75edcaf1

Assets/Scripts/Core/Graph Tasks/CheckGenericObserver.cs

@@ -34,6 +34,8 @@ namespace Reset {
 		
 		private EnvironmentObserver observer;
 
+		public BBParameter<RaycastHit> outputHit;
+
 #if UNITY_EDITOR
 		protected override void OnTaskInspectorGUI(){
 			BBParameterEditor.ParameterField("Cast Type", castType);
@@ -60,6 +62,8 @@ namespace Reset {
 			if (drawGizmos) {
 				drawGizmosOnlyWhenActive = EditorGUILayout.Toggle("Draw Gizmos Only When Active", drawGizmosOnlyWhenActive);
 			}
+
+			BBParameterEditor.ParameterField("Output Hit", outputHit);
 		}
 #endif
 		
@@ -100,6 +104,9 @@ namespace Reset {
 				observer.DrawObserverGizmo(agent.gameObject, true);
 			}
 
+			if (check && !outputHit.isNoneOrNull) {
+				outputHit.value = observer.hit;
+			}
 			return check;
 		}
 	}

Assets/Scripts/Core/Graph Tasks/CheckInputValue.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using NodeCanvas.Framework;
+using ParadoxNotion;
+using ParadoxNotion.Design;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+namespace NodeCanvas.Tasks.Actions {
+	[Category("Reset/Input")]
+	[Description("Check if input condition was matched this frame by phase.")]
+	public class CheckInputValue<T> : ActionTask<PlayerInput> where T : struct{
+		public BBParameter<string> actionName;
+		public BBParameter<T> outputTo;
+
+		private T value;
+		
+		private SignalDefinition signalDefinition;
+		protected override string info {
+			get { return $"Get Value of <b>Input:</b> \"{actionName.value}\""; }
+		}
+		
+		protected override string OnInit(){
+			try {
+				signalDefinition = Resources.Load<SignalDefinition>("InputSignal");
+			} catch (Exception e) {
+				Debug.LogError($"Error finding the Input Signal defintion: {e.Message}");
+				throw;
+			}
+			
+			return null;
+		}
+
+		protected override void OnExecute(){
+			// Debug.Log($"{outputTo.value}, {agent.actions[actionName.value].ReadValue<T>()}");
+
+			outputTo.value = agent.actions[actionName.value].ReadValue<T>();
+			EndAction();
+		}
+	}
+}
+

Assets/Scripts/Core/Graph Tasks/CheckInputValue.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 055df0fbf696a3149a2d49a8a5392aba

Assets/Scripts/Core/Graph Tasks/DecomposeRaycastHit.cs

@@ -19,6 +19,11 @@ namespace NodeCanvas.Tasks.Actions {
 		
 		//Use for initialization. This is called only once in the lifetime of the task.
 		//Return null if init was successfull. Return an error string otherwise
+
+		protected override string info{
+			get{ return $"Decompose RaycastHit <b>{raycastHit}</b>"; }
+		}
+
 		protected override string OnInit() {
 			return null;
 		}

Assets/Scripts/Core/Graph Tasks/DoGrapplePull.cs

@@ -0,0 +1,127 @@
+using Drawing;
+using NodeCanvas.Framework;
+using ParadoxNotion.Design;
+using ParadoxNotion.Services;
+using UnityEngine;
+
+
+namespace NodeCanvas.Tasks.Actions {
+
+	[Category("Reset/Movement")]
+	[Description("Pulls the agent towards a position with a spring-like effect")]
+	public class DoGrapplePull : ActionTask<CharacterController>{
+		public BBParameter<Vector3> grapplePoint;
+		public BBParameter<Vector3> offset;
+
+		public BBParameter<float> pullAccelerationSpeed;
+		public BBParameter<float> pullDeaccelerationSpeed;
+		
+		[Tooltip("X is minimum speed, Y is maximum speed")]
+		public BBParameter<Vector2> pullTimeRange;
+		[Tooltip("X is the distance where the curve will first be evaluated, Y is the distance where the curve will last be evaluated")]
+		public BBParameter<Vector2> pullSpeedRange;
+
+		public BBParameter<float> slowdownDistance;
+
+		public BBParameter<AnimationCurve> pullSpeedCurve;
+		public BBParameter<AnimationCurve> endDeaccelerationCurve;
+		
+
+		private float startTime;
+			
+		private float currentSpeed;
+		private Vector3 smoothedInput;
+		private Vector3 smoothedInputRefVelocity;
+		
+	//Use for initialization. This is called only once in the lifetime of the task.
+		//Return null if init was successfull. Return an error string otherwise
+		protected override string OnInit(){
+			MonoManager.current.onLateUpdate += DrawGrappleGizmo;
+			return null;
+		}
+
+		//This is called once each time the task is enabled.
+		//Call EndAction() to mark the action as finished, either in success or failure.
+		//EndAction can be called from anywhere.
+		protected override void OnExecute(){
+			startTime = Time.time;
+			currentSpeed = pullSpeedCurve.value[0].value * pullSpeedRange.value.y;
+		}
+
+		//Called once per frame while the action is active.
+		protected override void OnUpdate(){
+			// Create the distance variables
+			Vector3 dirToPoint = agent.transform.position.DirectionTo(grapplePoint.value);
+				
+			float evaluatedSpeed = pullSpeedCurve.value.Evaluate(Mathf.Clamp((Time.time - startTime) / 6f, 0f, Mathf.Infinity));
+
+			float speedAgainstCurve = Mathf.Lerp(pullSpeedRange.value.x, pullSpeedRange.value.y, evaluatedSpeed);
+			
+			// Find how far from 0-1 the player is from the max and minimum distance
+			// Get the base distance then account for the minimum distance to the point so that being the minimum away will Lerp to 1
+			float currentDist = Vector3.Distance(agent.transform.position, grapplePoint.value); 
+			// float currentDistMinimumAccounted = (currentDist - pullSpeedDistances.value.x); 
+
+			if (currentDist < slowdownDistance.value) {
+				float change = endDeaccelerationCurve.value.Evaluate((slowdownDistance.value - currentDist) / slowdownDistance.value);
+				speedAgainstCurve = speedAgainstCurve * change;
+				
+				// Debug.Log($"prev: {speedAgainstCurve}, norm: {(slowdownDistance.value - currentDist) / slowdownDistance.value}, change: {change}, output: {speedAgainstCurve * change} ");
+			}
+
+			// Evaluate the normalized value
+			// float normaled = Mathf.Lerp(0, 1f, 1f - elapsedTime / (pullSpeedDistances.value.y - pullSpeedDistances.value.x)); 
+			
+			// Use the curve evaluation to set the speed
+			// float outputSpeed = Mathf.Lerp(pullTimeRange.value.x, pullTimeRange.value.y, evaluatedSpeed);
+
+			// Soften the speed changes
+			currentSpeed = Mathf.Lerp(currentSpeed, speedAgainstCurve, 10f * Time.deltaTime);
+			
+			// Add input changes
+			Vector2 rawInput = agent.GetComponent<PlayerControls>().rawMoveInput;
+			Vector3 input = Quaternion.LookRotation(dirToPoint) * new Vector3(rawInput.x, rawInput.y, 0f);
+
+			smoothedInput = Vector3.SmoothDamp(smoothedInput, input, ref smoothedInputRefVelocity, 30f * Time.deltaTime); 
+			
+			Debug.Log(input);
+
+			dirToPoint.y *= 2.5f;
+
+			agent.Move((dirToPoint.normalized + smoothedInput) * currentSpeed * Time.deltaTime);
+			// Debug.Log( $"{ endDeaccelerationCurve.value.Evaluate(((slowdownDistance.value - currentDist)) )}");
+
+			// EndAction(true);
+		}
+
+		public void DrawGrappleGizmo(){
+			// Vector3 dirToPoint = agent.transform.position.DirectionTo(grapplePoint.value);
+			//
+			// using (Draw.WithColor(Color.yellow)){
+			// 	Draw.Line(agent.transform.position + Vector3.up, grapplePoint.value);
+			//
+			// 	// Draw Gizmo for minimum distance
+			// 	Vector3 minLocation = agent.transform.position + (Vector3.up * 1) + (dirToPoint * pullSpeedDistances.value.x);
+			// 	Vector3 minToScreen = minLocation.DirectionTo(Camera.main.transform.position);
+			//
+			// 	Draw.SolidCircle(minLocation,minToScreen , .2f);
+			// 	
+			// 	// Draw Gizmo for minimum distance
+			// 	Vector3 maxLocation = agent.transform.position + (Vector3.up * .8f) + (dirToPoint * pullSpeedDistances.value.y);
+			// 	Vector3 maxToScreen = maxLocation.DirectionTo(Camera.main.transform.position);
+			//
+			// 	Draw.SolidCircle(maxLocation,maxToScreen , .2f);
+			// }
+		}
+		
+		//Called when the task is disabled.
+		protected override void OnStop() {
+			
+		}
+
+		//Called when the task is paused.
+		protected override void OnPause() {
+			
+		}
+	}
+}

Assets/Scripts/Core/Graph Tasks/DoGrapplePull.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 75673b361693d854abb6e3b24a62d734

Assets/Scripts/Core/Graph Tasks/GetMovementInputDotProduct.cs

@@ -62,7 +62,7 @@ namespace NodeCanvas.Tasks.Conditions {
 			// Calculate dor product
 			float dotProduct = Vector3.Dot(valueToCheck, rawInputVector3);
 			
-			Debug.Log(dotProduct);
+			// Debug.Log(dotProduct);
 			
 			// Compare against the desired tolerance and output result
 			if (tolerance.value > Mathf.Abs(dotProduct - tolerance.value)) {

Assets/Scripts/Core/Graph Tasks/ProcessMovement.cs

@@ -1,169 +0,0 @@
-using System;
-using System.Collections;
-using NodeCanvas.Framework;
-using ParadoxNotion.Design;
-using ParadoxNotion.Services;
-using Unity.Cinemachine;
-using Unity.Mathematics;
-using UnityEngine;
-using Reset.Player.Movement;
-
-namespace Reset.Player.Movement{
-	public enum PlayerFacingDirection{
-		Target = 0,
-		Movement,
-		MatchCamera,
-		Static
-	}
-}
-
-
-namespace NodeCanvas.Tasks.Actions {
-
-	[Category("Reset/Movement")]
-	[Description("Finalizes movement and sends the final move commands to the controller")]
-	public class ProcessMovement : ActionTask<CharacterController>{
-		public BBParameter<Vector3> groundMoveDirection;
-		public BBParameter<Vector3> airMoveDirection;
-		[Space(5)]
-		public BBParameter<float> gravityAcceleration = 1f;
-		public BBParameter<float> gravityMax = 8f;
-
-		public BBParameter<float> jumpPower;
-		public BBParameter<float> jumpPowerDecay;
-		
-		// Rotation
-		public BBParameter<PlayerFacingDirection> playerFacingDirection;
-
-		[ShowIf("playerFacingDirection", 0)]
-		public Vector3 rotationTargetPosition;
-		
-		public BBParameter<float> rotationSpeed = 5f;
-		public BBParameter<float> rotationSmoothing;
-
-		private float currentRotSpeed;
-		private float lastLookMagnitude;
-		private Quaternion targetRotation;
-		private Vector3 currentMoveDir;
-		
-		// References
-		private PlayerControls controls;
-		
-		public BBParameter<float> gravityPower;
-
-		//Use for initialization. This is called only once in the lifetime of the task.
-		//Return null if init was successfull. Return an error string otherwise
-		protected override string OnInit() {
-			// Append the late update method to actually happen on late update
-			MonoManager.current.onLateUpdate += LateUpdate;
-			
-			// Set ingitial rotation power
-			currentRotSpeed = rotationSpeed.value;
-			
-			// Reference to controls
-			controls = agent.GetComponent<PlayerControls>();
-			
-			return null;
-		}
-
-		//This is called once each time the task is enabled.
-		//Call EndAction() to mark the action as finished, either in success or failure.
-		//EndAction can be called from anywhere.
-		protected override void OnExecute(){
-			currentMoveDir = groundMoveDirection.value;
-		}
-
-		//Called once per frame while the action is active.
-		protected override void OnUpdate(){
-			// Accelerate gravity
-			gravityPower.value += gravityAcceleration.value * Time.deltaTime;
-			gravityPower.value = Mathf.Min(gravityPower.value, gravityMax.value);
-			
-			// Calculate rotation speed
-			currentRotSpeed = Mathf.Lerp(currentRotSpeed, rotationSpeed.value, rotationSmoothing.value * Time.deltaTime);
-			
-			switch (playerFacingDirection.value) {
-				case PlayerFacingDirection.Target:
-					// Set rotation to just the direction of the target
-					targetRotation = Quaternion.LookRotation((agent.transform.position.DirectionTo(rotationTargetPosition)).Flatten(null, 0, null));
-					
-					break;
-				case PlayerFacingDirection.Movement:
-					// Check magnitude to avoid the "Look rotation viewing vector is zero" debug
-
-					// Set desired rotation to input direction, with respect to camera rotation
-					if (agent.isGrounded){
-						if (controls.rawMoveInput.magnitude == 0) { break; }
-
-						targetRotation = Quaternion.LookRotation(currentMoveDir) *
-						                 Quaternion.Euler(Camera.main.transform.rotation.eulerAngles.Flatten(0f, null, 0f));
-					} else {
-						if (airMoveDirection.value.magnitude == 0) { break; }
-
-						targetRotation = Quaternion.LookRotation(airMoveDirection.value);
-					}
-					break;
-				case PlayerFacingDirection.MatchCamera:
-					// Craft a new rotation that flattens the camera's rotation to the ground
-					// Needed to keep the character from inheriting the camera's height-rotation
-					targetRotation = Quaternion.Euler(Camera.main.transform.rotation.eulerAngles.Flatten(0, null, 0));
-					break;
-				case PlayerFacingDirection.Static:
-					targetRotation = agent.transform.rotation;
-					break;
-			}
-			
-	        // Construct move direction
-	        Vector3 finalMoveDir = Vector3.zero;
-			Vector3 gravityMoveDirection;
-
-			// Change how input is managed based on facing state
-			currentMoveDir = Vector3.Slerp(currentMoveDir, groundMoveDirection.value, currentRotSpeed * Time.deltaTime);
-			
-			// Add input movement
-			if (agent.isGrounded){
-				finalMoveDir += currentMoveDir +  Vector3.down * .03f;
-				gravityMoveDirection = new(0f, jumpPower.value + (Physics.gravity.y *.3f), 0f);
-			} else {
-				finalMoveDir += airMoveDirection.value;
-				gravityMoveDirection = new(0f, jumpPower.value + Physics.gravity.y * gravityPower.value, 0f);
-			}
-			
-			// Reset gravity power when grounded
-			if (agent.isGrounded) {
-				gravityPower.value = 0f;
-			}
-			
-			// Do final movement
-			if (agent.isGrounded) {
-				agent.Move((Quaternion.Euler(Camera.main.transform.rotation.eulerAngles.Flatten(0f, null, 0f)) * finalMoveDir + gravityMoveDirection) * Time.deltaTime);
-			} else {
-				agent.Move((finalMoveDir + gravityMoveDirection) * Time.deltaTime);
-			}
-			
-			// Set final rotation
-			agent.transform.rotation = Quaternion.Lerp(agent.transform.rotation, targetRotation, 10f * Time.deltaTime).Flatten(0, null, 0);
-			
-			// ???? Moved this above but don't remember if this needs to be here still
-			if (agent.isGrounded) {
-				jumpPower.value = 0f;
-			}
-		}
-		
-		// Gravity is processed in LateUpdate (added to MonoManager's onLateUpdate in OnInit())
-		public void LateUpdate(){
-			// Decay jump power
-			jumpPower.value = Mathf.Lerp(jumpPower.value, 0f, jumpPowerDecay.value * Time.deltaTime);
-		}
-
-		//Called when the task is disabled.
-		protected override void OnStop() {
-			EndAction(true);
-		}
-
-		//Called when the task is paused.
-		protected override void OnPause() {
-			
-		}
-	}
-}

Assets/Scripts/Core/Graph Tasks/SetAirMovement.cs

@@ -1,56 +0,0 @@
-using NodeCanvas.Framework;
-using ParadoxNotion.Design;
-using UnityEngine;
-
-
-namespace NodeCanvas.Tasks.Actions {
-
-	[Category("Reset")]
-	[Description("Hard set the air direction to a certain direction")]
-	public class SetAirMovement : ActionTask<Transform>{
-		public BBParameter<Vector3> airMoveDirection;
-
-		public BBParameter<Vector3> inputVector3;
-		public Space fromSpace;
-		public Space toSpace;
-		
-		//Use for initialization. This is called only once in the lifetime of the task.
-		//Return null if init was successfull. Return an error string otherwise
-		protected override string OnInit() {
-			return null;
-		}
-
-		//This is called once each time the task is enabled.
-		//Call EndAction() to mark the action as finished, either in success or failure.
-		//EndAction can be called from anywhere.
-		protected override void OnExecute(){
-
-		}
-
-		//Called once per frame while the action is active.
-		protected override void OnUpdate() {
-			if (fromSpace == toSpace) {
-				airMoveDirection.value = inputVector3.value;
-			}
-			
-			// NOTE: I swear to God these absolutely do not work and nobody could convince me otherwise
-			if (fromSpace == Space.World){
-				airMoveDirection.value = Camera.main.transform.rotation.Flatten(0, null, 0) * inputVector3.value;
-			} else {
-				airMoveDirection.value = Camera.main.transform.rotation.Flatten(0, null, 0) * agent.InverseTransformVector(inputVector3.value);
-			}
-			
-			EndAction(true);
-		}
-
-		//Called when the task is disabled.
-		protected override void OnStop() {
-			
-		}
-
-		//Called when the task is paused.
-		protected override void OnPause() {
-			
-		}
-	}
-}

Assets/Scripts/Core/Graph Tasks/SetAirMovement.cs.meta

@@ -1,2 +0,0 @@
-fileFormatVersion: 2
-guid: f1db555b92ed94543beab7a2106bc2a3

Assets/Scripts/Core/Graph Tasks/StartLaunchJump.cs

@@ -0,0 +1,71 @@
+using System;
+using NodeCanvas.Framework;
+using ParadoxNotion.Design;
+using Reset.Movement;
+using UnityEngine;
+
+namespace NodeCanvas.Tasks.Actions {
+
+	[Category("Reset/Movement")]
+	[Description("Launch the agent towards a specific point with respect to distance.")]
+	public class StartLaunchJump : ActionTask<CharacterController>{
+		public BBParameter<Vector3> airDirection;
+		public BBParameter<float> jumpPower;
+		
+		public BBParameter<Vector3> targetLocation;
+		public BBParameter<Vector3> offset;
+
+		public BBParameter<Vector3> relativeRotation;
+
+		public BBParameter<PlayerFacingDirection> launchRelativeTo;
+
+		
+		public BBParameter<bool> useRelativeForce;
+		[ShowIf("useRelativeForce", 1)] public BBParameter<float> minimumForce;
+		[ShowIf("useRelativeForce", 1)] public BBParameter<float> maximumForce;
+		[ShowIf("useRelativeForce", 1)] public BBParameter<float> forceRelativeToDistance;
+		public BBParameter<float> force;
+
+		//Use for initialization. This is called only once in the lifetime of the task.
+		//Return null if init was successfull. Return an error string otherwise
+		protected override string OnInit() {
+			return null;
+		}
+
+		//This is called once each time the task is enabled.
+		//Call EndAction() to mark the action as finished, either in success or failure.
+		//EndAction can be called from anywhere.
+		protected override void OnExecute(){
+			Vector3 launchDir = agent.transform.position.DirectionTo(targetLocation.value).normalized;
+			launchDir = Quaternion.Euler(relativeRotation.value) * launchDir;
+			
+			Debug.Log(launchDir);
+			
+			float distanceToTarget = Vector3.Distance(agent.transform.position, targetLocation.value);
+			
+			float outputForce = (useRelativeForce.value ? distanceToTarget * forceRelativeToDistance.value : force.value);
+
+			outputForce = Mathf.Clamp(outputForce, minimumForce.value, maximumForce.value);
+			jumpPower.value = outputForce;
+
+			airDirection.value = (launchDir * outputForce);
+			
+			EndAction(true);
+		}
+
+		//Called once per frame while the action is active.
+		protected override void OnUpdate() {
+			
+		}
+
+		//Called when the task is disabled.
+		protected override void OnStop() {
+			
+		}
+
+		//Called when the task is paused.
+		protected override void OnPause() {
+			
+		}
+	}
+}

Assets/Scripts/Core/Graph Tasks/StartLaunchJump.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8f32fe451feb2ca4e8159d4aa8919cd2

Assets/Scripts/Core/Graph Tasks/UpdateGravityDirection.cs

@@ -0,0 +1,73 @@
+using NodeCanvas.Framework;
+using ParadoxNotion.Design;
+using ParadoxNotion.Services;
+using UnityEngine;
+
+namespace Reset.Movement {
+
+	[Category("Reset/Movement")]
+	[Description("Process Y-axis movement for the agent")]
+	// TODO: Rename to UpdateGravitytDirection
+	public class UpdateGravityDirection : ActionTask<CharacterController>{
+		public BBParameter<Vector3> moveDirection;
+		public BBParameter<float> jumpPower;
+		public BBParameter<float> jumpPowerDecay;
+		
+		[Space(5)]
+		public BBParameter<float> gravityAcceleration = 1f;
+		public BBParameter<float> gravityMax = 8f;
+		
+		public BBParameter<float> gravityPower;
+		
+		//Use for initialization. This is called only once in the lifetime of the task.
+		//Return null if init was successfull. Return an error string otherwise
+		protected override string OnInit() {
+			MonoManager.current.onLateUpdate += LateUpdate;
+			return null;
+		}
+
+		//This is called once each time the task is enabled.
+		//Call EndAction() to mark the action as finished, either in success or failure.
+		//EndAction can be called from anywhere.
+		protected override void OnExecute() {
+		}
+
+		//Called once per frame while the action is active.
+		protected override void OnUpdate() {
+			// Accelerate gravity
+			gravityPower.value += gravityAcceleration.value * Time.deltaTime;
+			gravityPower.value = Mathf.Min(gravityPower.value, gravityMax.value);
+			
+			// Apply a constant gravity if the player is grounded
+			if (agent.isGrounded) {
+				gravityPower.value = .1f;
+			}
+			
+			// Create the gravity direction
+			float gravityMoveDirection = jumpPower.value + Physics.gravity.y * gravityPower.value;
+			
+			// Commit gravity to move direction, ignoring XZ since those are done in UpdateMovementDirection
+			moveDirection.value = new Vector3(moveDirection.value.x, gravityMoveDirection, moveDirection.value.z);
+
+			Debug.Log("Gravity Done");
+
+			EndAction(true);
+			
+		}
+		public void LateUpdate(){
+			// Decay jump power
+			jumpPower.value = Mathf.Lerp(jumpPower.value, 0f, jumpPowerDecay.value * Time.deltaTime);
+		}
+
+
+		//Called when the task is disabled.
+		protected override void OnStop() {
+			
+		}
+
+		//Called when the task is paused.
+		protected override void OnPause() {
+			
+		}
+	}
+}

Assets/Scripts/Core/Graph Tasks/UpdateGravityDirection.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5531fbd949d33204690c98dd89a5e97f

Assets/Scripts/Core/Graph Tasks/UpdateMovementDirection.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Collections;
+using NodeCanvas.Framework;
+using ParadoxNotion.Design;
+using ParadoxNotion.Services;
+using Unity.Cinemachine;
+using Unity.Mathematics;
+using UnityEngine;
+using Reset.Movement;
+using Reset.Units;
+
+namespace NodeCanvas.Tasks.Actions {
+
+	[Category("Reset/Movement")]
+	[Description("Finalizes movement and sends the final move commands to the controller")]
+	// TODO: Rename to UpdateMovementDirection
+	public class UpdateMovementDirection : ActionTask<CharacterController>{
+		[ParadoxNotion.Design.Header("References")]
+		public BBParameter<Vector3> moveDirection;
+		// TODO: Remove this reference and let each copy of this use their own settings.
+		public BBParameter<PlayerFacingDirection> playerFacingDirection;
+		
+		[ParadoxNotion.Design.Header("Settings")]
+		public BBParameter<float> accelerationSmoothing = 5f;
+		public BBParameter<float> deaccelerationSmoothing = 5f;
+		public BBParameter<AnimationCurve> deaccelerationCurve;
+
+		public BBParameter<float> directionChangeMinimumMagnitude; // Unused. Use to only make input change if it's over a certain input threshold. Maybe smoothing can affect this?
+		
+		private float lastLookMagnitude;
+		private Vector3 currentMoveDir;
+	
+		// References
+		private PlayerControls controls;
+		
+		//Use for initialization. This is called only once in the lifetime of the task.
+		//Return null if init was successfull. Return an error string otherwise
+		protected override string OnInit() {
+			// Reference to controls
+			controls = agent.GetComponent<PlayerControls>();
+			
+			return null;
+		}
+
+		//This is called once each time the task is enabled.
+		//Call EndAction() to mark the action as finished, either in success or failure.
+		//EndAction can be called from anywhere.
+		protected override void OnExecute(){
+			// Initialize the smoothed direction with the value as is on input
+			// currentMoveDir = new Vector3(moveDirection.value.x, moveDirection.value.y, moveDirection.value.z);
+		}
+
+		//Called once per frame while the action is active.
+		protected override void OnUpdate(){
+	        // Construct move direction
+	        Vector3 targetDirection = moveDirection.value;
+	        
+	        // Get input value
+	        Vector3 inputMovement = new Vector3(controls.rawMoveInput.x, 0f, controls.rawMoveInput.y);
+
+	        if (inputMovement.magnitude < .1f) {
+		        inputMovement = Vector3.zero;
+	        }
+
+			// Change how movement is managed based on facing state
+			switch (playerFacingDirection.value) {
+				case PlayerFacingDirection.TowardsTarget:
+					break;
+				case PlayerFacingDirection.MatchForward: // TODO: Recomment
+					// targetDirection = agent.transform.forward * inputMovement.magnitude;
+					targetDirection = inputMovement;
+					break;
+				case PlayerFacingDirection.MatchCamera:
+					targetDirection = Quaternion.Euler(Camera.main.transform.forward.DirectionTo(agent.transform.forward)) * inputMovement;	// NOTE: This used to be t: currentRotSpeed * Time.deltaTime.
+					// See how it feels with a hard set value and go fro there.
+					break;
+				case PlayerFacingDirection.Static:
+					break;
+				default:
+					throw new ArgumentOutOfRangeException();
+			}
+
+			// Remove Y from variables
+			Vector3 targetNoY = new Vector3(targetDirection.x, 0f, targetDirection.z);
+			Vector3 currentNoY = new Vector3(currentMoveDir.x, 0f, currentMoveDir.z);
+			
+			// Smooth movement 
+			if (targetNoY.magnitude > currentNoY.magnitude) {
+				currentMoveDir = Vector3.Lerp(currentMoveDir, targetNoY,accelerationSmoothing.value * Time.deltaTime);	
+
+			} else {
+				float deaccelValue = deaccelerationCurve.value.Evaluate(inputMovement.magnitude); 
+				
+				currentMoveDir = Vector3.Lerp(currentMoveDir, targetNoY, deaccelerationSmoothing.value * Time.deltaTime);	
+			}
+			
+			
+			currentMoveDir.y = moveDirection.value.y;
+			// Commit move direction
+			moveDirection.value = currentMoveDir;
+			// Debug.Log(moveDirection.value);
+			EndAction(true);
+		}
+		
+		// Gravity is processed in LateUpdate (added to MonoManager's onLateUpdate in OnInit())
+
+
+		//Called when the task is disabled.
+		protected override void OnStop() {
+			EndAction(true);
+		}
+
+		//Called when the task is paused.
+		protected override void OnPause() {
+			
+		}
+	}
+}

Assets/Scripts/Core/Graph Tasks/UpdateMovementSpeed.cs

@@ -0,0 +1,60 @@
+using System;
+using NodeCanvas.Framework;
+using ParadoxNotion.Design;
+using UnityEngine;
+
+
+namespace Reset.Movement {
+
+	[Category("Reset/Movement")]
+	[Description("Updates the movespeed for this agent")]
+	public class UpdateMovementSpeed : ActionTask{
+		public BBParameter<float> target;
+		public BBParameter<float> speed;
+		public BBParameter<float> smoothing = 10f;
+
+		private float currentSpeed;
+		
+		//Use for initialization. This is called only once in the lifetime of the task.
+		//Return null if init was successfull. Return an error string otherwise
+		protected override string OnInit() {
+			if (!speed.useBlackboard) {
+				Debug.LogError("This <b>Update Movement Speed</b> does not have it's current value attached to a Blackboard variable. Nothing will happen.", agent.gameObject);
+			}
+			
+			return null;
+		}
+
+		//This is called once each time the task is enabled.
+		//Call EndAction() to mark the action as finished, either in success or failure.
+		//EndAction can be called from anywhere.
+		protected override void OnExecute(){
+			// currentSpeed = speed.value;
+
+		}
+
+		//Called once per frame while the action is active.
+		protected override void OnUpdate(){
+			currentSpeed = Mathf.Lerp(currentSpeed, target.value, smoothing.value * Time.deltaTime);
+			
+			speed.value = currentSpeed;
+
+			if (Mathf.Abs(currentSpeed - speed.value) < .01f) {
+				
+			}
+			
+			Debug.Log("Speed Done");
+			EndAction(true);
+		}
+
+		//Called when the task is disabled.
+		protected override void OnStop() {
+			
+		}
+
+		//Called when the task is paused.
+		protected override void OnPause() {
+			
+		}
+	}
+}

Assets/Scripts/Core/Graph Tasks/UpdateMovementSpeed.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6a4c5896d783ad845861edd0c9eea14b

Assets/Scripts/Core/Graph Tasks/UpdateObjectCameraTracking.cs

@@ -0,0 +1,65 @@
+using NodeCanvas.Framework;
+using ParadoxNotion.Design;
+using ParadoxNotion.Serialization.FullSerializer;
+using UnityEngine;
+using Logger = ParadoxNotion.Services.Logger;
+
+namespace NodeCanvas.Tasks.Actions {
+	[Category("Reset")]
+	public class UpdateObjectCameraTracking : ActionTask<LockOnManager> {
+
+		public BBParameter<GameObject> relatedObject;
+
+		enum CameraTrackingTaskAction{
+			AddOrUpdate,
+			Remove
+		}
+
+		[ExposeField, fsSerializeAs, Space(5)]
+		CameraTrackingTaskAction action;
+
+		[ParadoxNotion.Design.ShowIf("action", 0)]
+		public BBParameter<float> weight;
+
+		[ParadoxNotion.Design.ShowIf("action", 0)]
+		public BBParameter<bool> isMain;
+
+		//Return null if init was successfull. Return an error string otherwise
+		protected override string OnInit() {
+			return null;
+		}
+
+		//This is called once each time the task is enabled.
+		//Call EndAction() to mark the action as finished, either in success or failure.
+		//EndAction can be called from anywhere.
+		protected override void OnExecute() {
+			if (relatedObject.isNull) {
+				Logger.LogError("There is no object for the camera to add to tracking. May have forgotten a reference/object probably destroyed?");
+				EndAction(false);
+				return;
+			}
+
+			if (action == CameraTrackingTaskAction.AddOrUpdate) {
+				agent.AddNewTarget(relatedObject.value, weight.value, isMain.value);
+			} else {
+				agent.QueueTargetRemoval(relatedObject.value);
+			}
+			EndAction(true);
+		}
+
+		//Called once per frame while the action is active.
+		protected override void OnUpdate() {
+			
+		}
+
+		//Called when the task is disabled.
+		protected override void OnStop() {
+			
+		}
+
+		//Called when the task is paused.
+		protected override void OnPause() {
+			
+		}
+	}
+}

Assets/Scripts/Core/Graph Tasks/UpdateObjectCameraTracking.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: c187e5f8e4ad16b42b10c10ea9fb8fd4

Assets/Scripts/Core/LockOnManager.cs

@@ -5,91 +5,167 @@ using System.Numerics;
 using Sirenix.OdinInspector;
 using Unity.Cinemachine;
 using UnityEngine;
+using UnityEngine.Serialization;
 using UnityEngine.UIElements;
 using Vector2 = UnityEngine.Vector2;
 using Vector3 = UnityEngine.Vector3;
 
 public class LockOnManager : MonoBehaviour{
+    public class ActiveLockOnTarget{
+        public GameObject gameObject;
+        public float targetWeight;
+        public float refVelocity;
+        public CinemachineTargetGroup.Target cinemachineTarget;
+    }
 
-    private CinemachineTargetGroup.Target playerTarget;
+    public static LockOnManager Instance;
-
-    // Lock On settings
-    [Space(5)]
-    public float lockOnRange = 40f;
-    public float lockOnMaxAngle = 70f;
     
+    // Lock On settings
+    [Space(5)] public float lockOnRange = 40f;
+    public float lockOnMaxAngle = 70f;
+    [Range(0,1)] public float mainTargetWeight = .15f;
+    [FormerlySerializedAs("smoothing")] public float smoothTime = 1f;
+
     // Lock On Tracking
-    [Space(10)] public GameObject lockonGameObject; // Needed because nulling the Target below doesn't actually empty it out
+    [Space(10)]
+    
+    public ActiveLockOnTarget mainTarget;
+    
+    public List<ActiveLockOnTarget> activeTargets = new List<ActiveLockOnTarget>();
+
     [ReadOnly] public CinemachineTargetGroup.Target lockonTarget;
     public CinemachineTargetGroup targetGroup;
-    
+
-    [Space(5)]
+    private List<GameObject> acceptedTargets = new List<GameObject>();
-    public List<GameObject> lockOnTargets = new List<GameObject>(); 
 
     // UI
-    [ShowInInspector]
+    [ShowInInspector] public UIDocument lockOnDocument;
-    public UIDocument lockOnDocument;
     private Label elementLabelName;
-    private VisualElement elementRoot; 
+    private VisualElement elementRoot;
-    
+
     // Start is called once before the first execution of Update after the MonoBehaviour is created
     void Start(){
-        // Save the player target object to track later
+        // Register as singleton
-        playerTarget = targetGroup.Targets[0];
+        if (Instance == null) {
-        
+            Instance = this;
-        // Quick check for things in lock-on target that aren't lock-onable
+        } else {
-        if (lockonGameObject != null && lockonTarget.Object.GetComponent<ILockOnTarget>() == null) {
+            this.enabled = false;
-            Debug.LogError($"Game Object {lockonTarget.Object.name} does not implement the ILockOnTarget interface!");
+            return;
         }
-        
+
+        // Quick check for things in lock-on target that aren't lock-onable
+        if (mainTarget != null && mainTarget.gameObject.GetComponent<ILockOnTarget>() == null) {
+            mainTarget.gameObject.AddComponent<GenericLockOnTarget>();
+            Debug.LogWarning($"The object <b>{mainTarget.gameObject.name}</b> has no ILockOnTarget interface. This isn't hyper critical, but adding one as a GenericLockOnTarget anyways.");
+        }
+
         elementRoot = lockOnDocument.rootVisualElement.Query<VisualElement>("LockOnGroup");
         elementLabelName = lockOnDocument.rootVisualElement.Query<Label>("LockOnName").First();
-        
+
         // Add all nearby game objects to lock-on eligible list
         GameObject[] allGameObjects = GameObject.FindObjectsByType<GameObject>(0, 0);
-        
+
-        foreach (GameObject thisObject in allGameObjects)
+        foreach (GameObject thisObject in allGameObjects) {
-        {
+            if (thisObject.GetComponent<ILockOnTarget>() != null) {
-            if (Vector3.Distance(transform.position, thisObject.transform.position) < lockOnRange) {
+                acceptedTargets.Add(thisObject);
-                if (thisObject.GetComponent<ILockOnTarget>() != null) {
-                    lockOnTargets.Add(thisObject);
-                }
             }
         }
     }
 
     void Update(){
-        if (lockonGameObject && lockonTarget.Object.GetComponent<ILockOnTarget>() == null) {
+        if (mainTarget != null && mainTarget.gameObject.GetComponent<ILockOnTarget>() == null) {
-            Debug.LogError($"Game Object {lockonTarget.Object.name} does not implement the ILockOnTarget interface!");
+            mainTarget.gameObject.AddComponent<GenericLockOnTarget>();
+            Debug.LogWarning($"The object <b>{mainTarget.gameObject.name}</b> has no ILockOnTarget interface. This isn't hyper critical, but adding one as a GenericLockOnTarget anyways.");
+        }
+
+        // Iterate through targets, pushing their Target Group weight towards their goal weight, or removing them if they get too low.
+        for (int i = 0; i < activeTargets.Count; i++) {
+            if (activeTargets[i].gameObject == this.gameObject) {
+                continue;
+            }
+
+            activeTargets[i].cinemachineTarget.Weight =
+                Mathf.SmoothDamp(
+                    activeTargets[i].cinemachineTarget.Weight,
+                    activeTargets[i].targetWeight,
+                    ref activeTargets[i].refVelocity,
+                    smoothTime * Time.deltaTime);
+            
+            if (activeTargets[i].cinemachineTarget.Weight < 0.0001f) {
+                StartCoroutine(RemoveFromTargetAtFrameEnd(activeTargets[i]));
+            }
+        }
+    }
+
+    IEnumerator RemoveFromTargetAtFrameEnd(ActiveLockOnTarget target){
+        yield return new WaitForEndOfFrame();
+
+        activeTargets.Remove(target);
+        targetGroup.Targets.Remove(target.cinemachineTarget);
+    }
+
+    public void AddNewTarget(GameObject targetObject, float targetWeight, bool isMain = false){
+        // Check that the target doesn't already exist- if it does, just change it's weight/make it main
+        foreach (ActiveLockOnTarget target in activeTargets) {
+            if (target.gameObject == targetObject) {
+                target.targetWeight = targetWeight;
+                
+                if (isMain) {
+                    mainTarget = target;
+                }
+                
+                return;
+            }            
         }
         
-        // Find the current lock-on target and increase it's weight to the .15f max slowly
+        // If it doesn't exist in the list of targets, add it
-        // They start at 0 weight when the lock-on adds them to the group
+        ActiveLockOnTarget newTarget = new ActiveLockOnTarget{
-        if (lockonGameObject) {
+            gameObject = targetObject, 
-            CinemachineTargetGroup.Target currentTarget = targetGroup.Targets.Find(target => target == lockonTarget);
+            targetWeight = mainTargetWeight,
-            currentTarget.Weight = Mathf.MoveTowards(currentTarget.Weight, .15f, .5f * Time.deltaTime);
+            cinemachineTarget = new CinemachineTargetGroup.Target{
+                Object = targetObject.transform,
+                Radius = 1f,
+                Weight = 0f
+            }
+        };
+
+        //Set as main
+        if (isMain) {
+            mainTarget = newTarget;
         }
 
-        // If a target is not the current lock on target, lower their targeting weight. When low enough to not cause a sharp jitter, remove them.
+        // Finalize
-        for (int i = 1; i < targetGroup.Targets.Count; i++) {
+        activeTargets.Add(newTarget);
-            if (targetGroup.Targets[i] == lockonTarget || targetGroup.Targets[i] == playerTarget){
+        targetGroup.Targets.Add(newTarget.cinemachineTarget);
-                continue;
+    }
-            }
-            
-            if (targetGroup.Targets[i].Weight < 0.001f) {
-                StartCoroutine(RemoveFromTargetAtFrameEnd(targetGroup.Targets[i]));
-                continue;
-            }
 
-            targetGroup.Targets[i].Weight = Mathf.MoveTowards(targetGroup.Targets[i].Weight, 0f, 1f * Time.deltaTime);
+    public void QueueTargetRemoval(GameObject targetObject, bool deleteAfterRemoved = false){
+        // Ostensibly removes targest by setting their target weight to 0. Update loop finds targets with no weight and reduces their impact on the camera
+        // After it smooths their current weight to 0, it removes them
+        activeTargets.Find(target => target.gameObject == targetObject).targetWeight = 0f;
+
+        if (deleteAfterRemoved) {
+            StartCoroutine(DeleteGameObjectPostRemoval(targetObject));
+        }
+
+        // Remove as main target if it is
+        if (mainTarget == activeTargets.Find(target => target.gameObject == targetObject)) {
+            mainTarget = null;
         }
     }
 
-    IEnumerator RemoveFromTargetAtFrameEnd(CinemachineTargetGroup.Target indexOf){
+    IEnumerator DeleteGameObjectPostRemoval(GameObject targetObject){
+        ActiveLockOnTarget thisTarget = activeTargets.Find(target => target.gameObject == targetObject);
+        
         yield return new WaitForEndOfFrame();
-        targetGroup.Targets.Remove(indexOf);
+        
+        while (activeTargets.Contains(thisTarget)) {
+            yield return null;
+        }
+        
+        Destroy(thisTarget.gameObject);
     }
-
+    
     public void ChangeLockOnTarget(){
         Transform cameraTransform = Camera.main.transform;
     
@@ -97,9 +173,9 @@ public class LockOnManager : MonoBehaviour{
         GameObject closestTarget = null;
         float lowestDistanceToCenter = Mathf.Infinity;
         
-        foreach (GameObject target in lockOnTargets) {
+        foreach (GameObject target in acceptedTargets) {
             // Skip the current target if one exists
-            if (lockonGameObject != null && lockonTarget.Object.gameObject == target) {
+            if (mainTarget != null && mainTarget.gameObject == target) {
                 continue;
             }
             
@@ -110,7 +186,12 @@ public class LockOnManager : MonoBehaviour{
             if (hit.transform != target.transform) {
                 continue;
             }
-
+            
+            // Skips targets too far
+            if (Vector3.Distance(transform.position, target.transform.position) > lockOnRange) {
+                continue;
+            }
+            
             // Skip targets outside lock on angle 
             float angleFromCameraForward = Vector3.Angle(cameraTransform.forward, cameraTransform.position.DirectionTo(target.transform.position));
             if (angleFromCameraForward > lockOnMaxAngle) {
@@ -137,37 +218,32 @@ public class LockOnManager : MonoBehaviour{
             return;
         }
         
-        // Create a new Target for the Target Group
+        // Remove the main target that currently exists, if there is one.
-        var newTarget = new CinemachineTargetGroup.Target{
+        if (mainTarget != null) {
-            Object = closestTarget.transform,
+            QueueTargetRemoval(mainTarget.gameObject);
-            Radius = 1f,
+        }
-            Weight = 0f
-        };
         
-        // Set the new target variables
+        // Begin tracking target, set as main 
-        lockonTarget = newTarget;
+        AddNewTarget(closestTarget.gameObject, mainTargetWeight, true);
-        lockonGameObject = closestTarget.gameObject;
-
-        targetGroup.Targets.Add(newTarget);
     }
 
-    public void RemoveLockOnTarget(){
+    // Used by outside sources such as input to cancel lock-on.
-        lockonTarget = null;
+    public void RemoveMainTarget(){
-        lockonGameObject = null;
+        QueueTargetRemoval(mainTarget.gameObject);
     }
 
     void LateUpdate(){
-        if (lockonGameObject) {
+        if (mainTarget != null) {
             // This is just test logic to get an image above a lock on.
             // TODO: Replace with something less silly
             Vector2 screenPos = RuntimePanelUtils.CameraTransformWorldToPanel(
                 lockOnDocument.rootVisualElement.panel,
-                lockonTarget.Object.GetComponent<ILockOnTarget>().GetReticlePosition(),
+                mainTarget.gameObject.GetComponent<ILockOnTarget>().GetReticlePosition(),
                 Camera.main
             );
 
             // Set name
-            elementLabelName.text = lockonTarget.Object.name;
+            elementLabelName.text = mainTarget.gameObject.name;
 
             // Set position (add the width/height of the element)
             elementRoot.style.top = new StyleLength(screenPos.y - 25f); // Was elementRoot.resolvedStyle.height * .7f

Assets/Scripts/Core/ValueGroup.cs

@@ -0,0 +1,487 @@
+using System;
+using ParadoxNotion.Design;
+using UnityEditor;
+using UnityEngine;
+
+namespace Reset.Core{
+	// Individual bool setting for each ring. Three of these will be used. 
+	public struct OrbitalFollowValueGroup{
+		public string label;
+		
+		public ValueChangeAction changeHeight;
+		public float height;
+		
+		public ValueChangeAction changeRadius;
+		public float radius;
+
+		public OrbitalFollowValueGroup(string newLabel){
+			label = newLabel;
+			changeHeight = ValueChangeAction.NoChange;
+			height = 0f;
+			changeRadius = ValueChangeAction.NoChange;
+			radius = 0f;
+		}
+	}
+
+	// Enum options for individual camera settings
+	public enum ValueChangeAction{
+		NoChange,
+		NewValue,
+		ResetValue,
+		RelativeValue, // Placeholder for using as altering existing value
+	}
+
+	public struct CurveValueGroup{
+		public string label;
+		public AnimationCurve newValue;
+
+		public ValueChangeAction changeValue;
+
+		public CurveValueGroup(string newLabel){
+			changeValue = ValueChangeAction.NoChange;
+
+			newValue = new AnimationCurve();
+			label = newLabel;
+		}
+	}
+
+	public struct EnumValueGroup{
+		public string label;
+		public Enum newValue;
+
+		public ValueChangeAction changeValue;
+
+		public EnumValueGroup(string newLabel, Enum enumType){
+			changeValue = ValueChangeAction.NoChange;
+
+			newValue = enumType;
+			label = newLabel;
+
+
+		}
+	}
+
+	public struct Vector3ValueGroup{
+		public string label;
+		public Vector3 newValue;
+		
+		public ValueChangeAction changeX;
+		public ValueChangeAction changeY;
+		public ValueChangeAction changeZ;
+		
+		public Vector3ValueGroup(string newLabel){
+			changeX = ValueChangeAction.NoChange;
+			changeY = ValueChangeAction.NoChange;
+			changeZ = ValueChangeAction.NoChange;
+
+			newValue = Vector3.zero;
+			label = newLabel;
+		}
+	}
+
+	public struct Vector2ValueGroup{
+		public string label;
+		public Vector2 newValue;
+		
+		public ValueChangeAction changeX;
+		public ValueChangeAction changeY;
+		
+		public Vector2ValueGroup(string newLabel){
+			changeX = ValueChangeAction.NoChange;
+			changeY = ValueChangeAction.NoChange;
+
+			newValue = Vector2.zero;
+			label = newLabel;
+		}
+	}
+
+	public struct FloatValueGroup{
+		public string label;
+		public float value;
+
+		public ValueChangeAction changeValue;
+
+		public FloatValueGroup(string newLabel){
+			label = newLabel;
+			value = 0f;
+			changeValue = ValueChangeAction.NoChange;
+		}
+	}
+
+	public struct BoolValueGroup{
+		public string label;
+		public bool value;
+
+		public ValueChangeAction changeValue;
+
+		public BoolValueGroup(string newLabel){
+			label = newLabel;
+			value = true;
+			changeValue = ValueChangeAction.NoChange;
+		}
+	}
+
+#if UNITY_EDITOR
+	public class BoolValueGroupDrawer : ObjectDrawer<BoolValueGroup>  {
+		public override BoolValueGroup OnGUI(GUIContent content, BoolValueGroup _instance){
+			// Remove label for floats
+			EditorGUIUtility.labelWidth = 50;
+			
+			// Set layout options for the label and the float fields
+			GUILayoutOption[] floatOptions = new GUILayoutOption[] {
+				GUILayout.Width(80.0f), 
+				GUILayout.MinWidth(20.0f), 
+				GUILayout.ExpandWidth(true), 
+			};
+
+			GUILayoutOption[] labelOptions = new GUILayoutOption[]{
+				GUILayout.Width(200.0f),
+			};
+			
+			// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
+			GUILayout.BeginVertical();
+			GUILayout.Label(_instance.label, labelOptions);
+			GUILayout.BeginHorizontal();
+			
+			// Create the x settings enum
+			_instance.changeValue = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeValue);
+			
+			// Create the value/disabled information field
+			if (_instance.changeValue == ValueChangeAction.NewValue){
+				_instance.value = EditorGUILayout.Toggle(_instance.value, floatOptions);
+			} else {
+				EditorGUI.BeginDisabledGroup(true);
+				EditorGUILayout.TextField(_instance.changeValue == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
+				EditorGUI.EndDisabledGroup();
+			}
+			
+			// Close this line up
+			GUILayout.EndHorizontal();
+			GUILayout.EndVertical();
+			
+			// Reset to default so the rest of things don't get messed up
+			EditorGUIUtility.labelWidth = 0;
+			return _instance;
+		}
+	}
+	
+	public class CurveVlueGroupDrawer : ObjectDrawer<CurveValueGroup>  {
+		public override CurveValueGroup OnGUI(GUIContent _content, CurveValueGroup _instance){
+			// Remove label for floats
+			EditorGUIUtility.labelWidth = 50;
+			
+			// Set layout options for the label and the float fields
+			GUILayoutOption[] floatOptions = new GUILayoutOption[] {
+				GUILayout.Width(80.0f), 
+				GUILayout.MinWidth(20.0f), 
+				GUILayout.ExpandWidth(true), 
+			};
+
+			GUILayoutOption[] labelOptions = new GUILayoutOption[]{
+				GUILayout.Width(200.0f),
+			};
+			
+			// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
+			GUILayout.BeginVertical();
+			GUILayout.Label(_instance.label, labelOptions);
+			GUILayout.BeginHorizontal();
+			
+			// Create the x settings enum
+			_instance.changeValue = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeValue);
+			
+			// Create the value/disabled information field
+			if (_instance.changeValue == ValueChangeAction.NewValue){
+				_instance.newValue = EditorGUILayout.CurveField(_instance.newValue, floatOptions);
+			} else {
+				EditorGUI.BeginDisabledGroup(true);
+				EditorGUILayout.TextField(_instance.changeValue == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
+				EditorGUI.EndDisabledGroup();
+			}
+			
+			// Close this line up
+			GUILayout.EndHorizontal();
+			GUILayout.EndVertical();
+			
+			// Reset to default so the rest of things don't get messed up
+			EditorGUIUtility.labelWidth = 0;
+			return _instance;
+		}
+	}
+
+	public class EnumValueGroupDrawer : ObjectDrawer<EnumValueGroup>{
+		public override EnumValueGroup OnGUI(GUIContent _content, EnumValueGroup _instance){
+			// Set layout options for the label and the float fields
+			GUILayoutOption[] floatOptions = new GUILayoutOption[] {
+				GUILayout.Width(200.0f), 
+				GUILayout.MinWidth(100.0f), 
+				GUILayout.ExpandWidth(true), 
+			};
+
+			GUILayoutOption[] labelOptions = new GUILayoutOption[]{
+				GUILayout.Width(200.0f),
+			};
+			
+			// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
+			GUILayout.BeginVertical();
+			GUILayout.Label(_instance.label, labelOptions);
+			GUILayout.BeginHorizontal();
+			
+			// Create the x settings enum
+			_instance.changeValue = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeValue);
+			
+			// Create the value/disabled information field
+			if (_instance.changeValue == ValueChangeAction.NewValue){
+				_instance.newValue = EditorGUILayout.EnumPopup("", instance.newValue, floatOptions);
+			} else {
+				EditorGUI.BeginDisabledGroup(true);
+				EditorGUILayout.TextField(_instance.changeValue == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
+				EditorGUI.EndDisabledGroup();
+			}
+			
+			// Close this line up
+			GUILayout.EndHorizontal();
+			GUILayout.EndVertical();
+			
+			// Reset to default so the rest of things don't get messed up
+			EditorGUIUtility.labelWidth = 0;
+			return _instance;
+		}
+
+		
+	}
+
+	public class FloatValueGroupDrawer : ObjectDrawer<FloatValueGroup>  {
+		public override FloatValueGroup OnGUI(GUIContent _content, FloatValueGroup _instance){
+			// Remove label for floats
+			EditorGUIUtility.labelWidth = 50;
+			
+			// Set layout options for the label and the float fields
+			GUILayoutOption[] floatOptions = new GUILayoutOption[] {
+				GUILayout.Width(80.0f), 
+				GUILayout.MinWidth(20.0f), 
+				GUILayout.ExpandWidth(true), 
+			};
+
+			GUILayoutOption[] labelOptions = new GUILayoutOption[]{
+				GUILayout.Width(200.0f),
+			};
+			
+			// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
+			GUILayout.BeginVertical();
+			GUILayout.Label(_instance.label, labelOptions);
+			GUILayout.BeginHorizontal();
+			
+			// Create the x settings enum
+			_instance.changeValue = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeValue);
+			
+			// Create the value/disabled information field
+			if (_instance.changeValue == ValueChangeAction.NewValue){
+				_instance.value = EditorGUILayout.FloatField(_instance.value, floatOptions);
+			} else {
+				EditorGUI.BeginDisabledGroup(true);
+				EditorGUILayout.TextField(_instance.changeValue == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
+				EditorGUI.EndDisabledGroup();
+			}
+			
+			// Close this line up
+			GUILayout.EndHorizontal();
+			GUILayout.EndVertical();
+			
+			// Reset to default so the rest of things don't get messed up
+			EditorGUIUtility.labelWidth = 0;
+			return _instance;
+		}
+	}
+
+	public class Vector3ValueGroupDrawer : ObjectDrawer<Vector3ValueGroup>  {
+		public override Vector3ValueGroup OnGUI(GUIContent _content, Vector3ValueGroup _instance){
+			// Remove label for floats
+			EditorGUIUtility.labelWidth = 20;
+			
+			// Set layout options for the label and the float fields
+			GUILayoutOption[] floatOptions = new GUILayoutOption[] {
+				GUILayout.Width(300.0f), 
+				GUILayout.MinWidth(20.0f), 
+				GUILayout.ExpandWidth(true), 
+			};
+
+			GUILayoutOption[] labelOptions = new GUILayoutOption[]{
+				GUILayout.Width(200.0f),
+			};
+			
+			// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
+			GUILayout.BeginVertical();
+			GUILayout.Label(_instance.label, labelOptions);
+			GUILayout.BeginHorizontal();
+			
+			// Create the x settings enum
+			_instance.changeX = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeX);
+			
+			// Create the value/disabled information field
+			if (_instance.changeX == ValueChangeAction.NewValue){
+				_instance.newValue.x = EditorGUILayout.FloatField(_instance.newValue.x, floatOptions);
+			} else {
+				EditorGUI.BeginDisabledGroup(true);
+				EditorGUILayout.TextField(_instance.changeX == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
+				EditorGUI.EndDisabledGroup();
+			}
+			  
+			// It do what it do.
+			GUILayout.Space(5);
+			
+			// Create the y settings enum
+			_instance.changeY = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeY);
+			
+			// Create the value/disabled information field
+			if (_instance.changeY == ValueChangeAction.NewValue){
+				_instance.newValue.y = EditorGUILayout.FloatField(_instance.newValue.y, floatOptions);
+			} else {
+				EditorGUI.BeginDisabledGroup(true);
+				EditorGUILayout.TextField(_instance.changeY == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
+				EditorGUI.EndDisabledGroup();
+			}
+			
+			// It do what it do.
+			GUILayout.Space(5);
+			
+			// Create the y settings enum
+			_instance.changeZ = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeZ);
+			
+			// Create the value/disabled information field
+			if (_instance.changeZ == ValueChangeAction.NewValue){
+				_instance.newValue.z = EditorGUILayout.FloatField(_instance.newValue.z, floatOptions);
+			} else {
+				EditorGUI.BeginDisabledGroup(true);
+				EditorGUILayout.TextField(_instance.changeZ == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
+				EditorGUI.EndDisabledGroup();
+			}
+			
+			// Close this line up
+			GUILayout.EndHorizontal();
+			GUILayout.EndVertical();
+			
+			// Reset to default so the rest of things don't get messed up
+			EditorGUIUtility.labelWidth = 0;
+			return _instance;
+		}
+	}
+
+	public class Vector2ValueGroupDrawer : ObjectDrawer<Vector2ValueGroup>  {
+		public override Vector2ValueGroup OnGUI(GUIContent _content, Vector2ValueGroup _instance){
+			// Remove label for floats
+			EditorGUIUtility.labelWidth = 50;
+			
+			// Set layout options for the label and the float fields
+			GUILayoutOption[] floatOptions = new GUILayoutOption[] {
+				GUILayout.Width(300.0f), 
+				GUILayout.MinWidth(20.0f), 
+				GUILayout.ExpandWidth(true), 
+			};
+
+			GUILayoutOption[] labelOptions = new GUILayoutOption[]{
+				GUILayout.Width(200.0f),
+			};
+			
+			// Start the Vertical layout then add the label before adding a horizontal so the label will be on top of side-by-side options
+			GUILayout.BeginVertical();
+			GUILayout.Label(_instance.label, labelOptions);
+			GUILayout.BeginHorizontal();
+			
+			// Create the x settings enum
+			_instance.changeX = (ValueChangeAction)EditorGUILayout.EnumPopup("", instance.changeX);
+			
+			// Create the value/disabled information field
+			if (_instance.changeX == ValueChangeAction.NewValue){
+				_instance.newValue.x = EditorGUILayout.FloatField(_instance.newValue.x, floatOptions);
+			} else {
+				EditorGUI.BeginDisabledGroup(true);
+				EditorGUILayout.TextField(_instance.changeX == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
+				EditorGUI.EndDisabledGroup();
+			}
+			  
+			// It do what it do.
+			GUILayout.Space(5);
+			
+			// Create the y settings enum
+			_instance.changeY = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeY);
+			
+			// Create the value/disabled information field
+			if (_instance.changeY == ValueChangeAction.NewValue){
+				_instance.newValue.y = EditorGUILayout.FloatField(_instance.newValue.y, floatOptions);
+			} else {
+				EditorGUI.BeginDisabledGroup(true);
+				EditorGUILayout.TextField(_instance.changeY == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
+				EditorGUI.EndDisabledGroup();
+			}
+			
+			// Close this line up
+			GUILayout.EndHorizontal();
+			GUILayout.EndVertical();
+			
+			// Reset to default so the rest of things don't get messed up
+			EditorGUIUtility.labelWidth = 0;
+			return _instance;
+		}
+	}
+
+	// Custom editor for each orbital follow ring setting
+	public class OrbitalFollowValueGroupDrawer : ObjectDrawer<OrbitalFollowValueGroup>{
+		public override OrbitalFollowValueGroup OnGUI(GUIContent _content, OrbitalFollowValueGroup _instance){
+			// Remove label for floats
+			EditorGUIUtility.labelWidth = 1;
+			
+			// Set layout options for the label and the float fields
+			GUILayoutOption[] floatOptions = new GUILayoutOption[] {
+				GUILayout.Width(300.0f), 
+				GUILayout.MinWidth(20.0f), 
+				GUILayout.ExpandWidth(true), 
+			};
+
+			GUILayoutOption[] labelOptions = new GUILayoutOption[]{
+				GUILayout.Width(60.0f),
+			};
+			
+			// Start a Horiztonal Section
+			GUILayout.BeginHorizontal();
+			
+			// Add the left side label
+			GUILayout.Label(_instance.label, labelOptions);
+			
+			// Create the height settings enum
+			_instance.changeHeight = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeHeight);
+			
+			// Create the value/disabled information field
+			if (_instance.changeHeight == ValueChangeAction.NewValue){
+				_instance.height = EditorGUILayout.FloatField(_instance.height, floatOptions);
+			} else {
+				EditorGUI.BeginDisabledGroup(true);
+				EditorGUILayout.TextField(_instance.changeHeight == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
+				EditorGUI.EndDisabledGroup();
+			}
+			  
+			// It do what it do.
+			GUILayout.Space(5);
+			
+			// Create the radius settings enum
+			_instance.changeRadius = (ValueChangeAction)EditorGUILayout.EnumPopup("", _instance.changeRadius);
+			
+			// Create the value/disabled information field
+			if (_instance.changeRadius == ValueChangeAction.NewValue){
+				_instance.radius = EditorGUILayout.FloatField(_instance.radius, floatOptions);
+			} else {
+				EditorGUI.BeginDisabledGroup(true);
+				EditorGUILayout.TextField(_instance.changeRadius == ValueChangeAction.NoChange ? "Unchanged" : "Reset", floatOptions);
+				EditorGUI.EndDisabledGroup();
+			}
+			
+			// Close this line up
+			GUILayout.EndHorizontal();
+			
+			// Reset to default so the rest of things don't get messed up
+			EditorGUIUtility.labelWidth = 0;
+			return _instance;
+		}
+	}
+#endif
+
+}

Assets/Scripts/Core/ValueGroup.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 111e95d8d161f7d4887fa7ccfa6d1454

Assets/Scripts/Player/CameraSettingsProcessor.cs

@@ -11,7 +11,7 @@ public struct CameraSettingSingleValue<T>{
     public Vector2 velocityRefV2;
     public Vector3 velocityRefV3;
 
-    public CameraSettingSingleValue(float defaultSmoothing, T original = default(T)){
+    public CameraSettingSingleValue(float defaultSmoothing = .2f, T original = default(T)){
         originalValue = original;
         targetValue = original;
         smoothing = defaultSmoothing;
@@ -30,6 +30,13 @@ public struct CameraSettingValues{
     public CameraSettingSingleValue<float> mainFieldOfView;
 
     public CameraSettingSingleValue<Vector3> orbitPositionDamping;
+    public CameraSettingSingleValue<Vector3> orbitTargetOffset;
+    
+    public CameraSettingSingleValue<bool> axisLookEnabledX;
+    public CameraSettingSingleValue<bool> axisLookEnabledY;
+
+    public CameraSettingSingleValue<float> axisLookGainX;
+    public CameraSettingSingleValue<float> axisLookGainY;
     
     public CameraSettingSingleValue<float> orbitFollowTopHeight;
     public CameraSettingSingleValue<float> orbitFollowTopRadius;
@@ -46,6 +53,13 @@ public struct CameraSettingValues{
         mainFieldOfView = new CameraSettingSingleValue<float>(defaultSmoothing);
         
         orbitPositionDamping = new CameraSettingSingleValue<Vector3>(defaultSmoothing);
+        orbitTargetOffset = new CameraSettingSingleValue<Vector3>(defaultSmoothing);
+
+        axisLookEnabledX = new CameraSettingSingleValue<bool>();
+        axisLookEnabledY = new CameraSettingSingleValue<bool>();
+        
+        axisLookGainX = new CameraSettingSingleValue<float>(defaultSmoothing);
+        axisLookGainY = new CameraSettingSingleValue<float>(defaultSmoothing);
         
         orbitFollowTopHeight = new CameraSettingSingleValue<float>(defaultSmoothing);
         orbitFollowTopRadius = new CameraSettingSingleValue<float>(defaultSmoothing);
@@ -70,6 +84,7 @@ public class CameraSettingsProcessor : MonoBehaviour{
     private CinemachineOrbitalFollow orbit;
     private CinemachineRotationComposer rotComp;
     private CinemachineCameraOffset offset;
+    private CinemachineInputAxisController axisCont;
     
     public void Awake(){
         // Singleton management
@@ -85,12 +100,18 @@ public class CameraSettingsProcessor : MonoBehaviour{
         orbit = mainCamera.GetComponent<CinemachineOrbitalFollow>();
         rotComp = mainCamera.GetComponent<CinemachineRotationComposer>();
         offset = mainCamera.GetComponent<CinemachineCameraOffset>();
+        axisCont = mainCamera.GetComponent<CinemachineInputAxisController>();
 
         // Initialize camera settings values
         values = new CameraSettingValues{
             cameraOffsetOffset = new CameraSettingSingleValue<Vector3>(defaultSmoothing: .2f, offset.Offset),
             mainFieldOfView = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, main.Lens.FieldOfView),
+            axisLookEnabledX = new CameraSettingSingleValue<bool>(0, axisCont.Controllers[0].Enabled),
+            axisLookEnabledY = new CameraSettingSingleValue<bool>(0, axisCont.Controllers[1].Enabled),
+            axisLookGainX = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, axisCont.Controllers[0].Input.Gain),
+            axisLookGainY = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, axisCont.Controllers[1].Input.Gain),
             orbitPositionDamping = new CameraSettingSingleValue<Vector3>(defaultSmoothing: .2f, orbit.TrackerSettings.PositionDamping),
+            orbitTargetOffset = new CameraSettingSingleValue<Vector3>(defaultSmoothing: .1f, orbit.TargetOffset),
             orbitFollowTopHeight = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, orbit.Orbits.Top.Height),
             orbitFollowTopRadius = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, orbit.Orbits.Top.Radius),
             orbitFollowCenterHeight = new CameraSettingSingleValue<float>(defaultSmoothing: .2f, orbit.Orbits.Center.Height),
@@ -105,6 +126,22 @@ public class CameraSettingsProcessor : MonoBehaviour{
         main.Lens.FieldOfView = Mathf.SmoothDamp(main.Lens.FieldOfView,
             values.mainFieldOfView.targetValue, ref values.mainFieldOfView.velocityRef,
             values.mainFieldOfView.smoothing);
+
+        axisCont.Controllers[0].Enabled = values.axisLookEnabledX.targetValue;
+        
+        axisCont.Controllers[1].Enabled = values.axisLookEnabledY.targetValue;
+        
+        axisCont.Controllers[0].Input.Gain = Mathf.SmoothDamp(axisCont.Controllers[0].Input.Gain,
+            values.axisLookGainX.targetValue, ref values.axisLookGainX.velocityRef,
+            values.axisLookGainX.smoothing);
+        
+        axisCont.Controllers[1].Input.Gain = Mathf.SmoothDamp(axisCont.Controllers[1].Input.Gain,
+            values.axisLookGainY.targetValue, ref values.axisLookGainY.velocityRef,
+            values.axisLookGainY.smoothing);
+        
+        orbit.TargetOffset = Vector3.SmoothDamp(orbit.TargetOffset,
+            values.orbitTargetOffset.targetValue, ref values.orbitTargetOffset.velocityRefV3,
+            values.orbitTargetOffset.smoothing);
         
         orbit.TrackerSettings.PositionDamping = Vector3.SmoothDamp(orbit.TrackerSettings.PositionDamping,
             values.orbitPositionDamping.targetValue, ref values.orbitPositionDamping.velocityRefV3,
@@ -122,8 +159,6 @@ public class CameraSettingsProcessor : MonoBehaviour{
             values.orbitFollowCenterHeight.targetValue, ref values.orbitFollowCenterHeight.velocityRef,
             values.orbitFollowCenterHeight.smoothing);
         
-        
-        
         orbit.Orbits.Center.Radius = Mathf.SmoothDamp(orbit.Orbits.Center.Radius,
             values.orbitFollowCenterRadius.targetValue, ref values.orbitFollowCenterRadius.velocityRef,
             values.orbitFollowCenterRadius.smoothing);
@@ -143,6 +178,8 @@ public class CameraSettingsProcessor : MonoBehaviour{
         offset.Offset = Vector3.SmoothDamp(offset.Offset,
             values.cameraOffsetOffset.targetValue, ref values.cameraOffsetOffset.velocityRefV3,
             values.cameraOffsetOffset.smoothing);
+        
+        
     }
     
     void Update(){

Assets/Scripts/Player/Player.cs

@@ -5,12 +5,10 @@ using Sirenix.OdinInspector;
 
 public class Player : MonoBehaviour{
     [HideInInspector] public PlayerControls controls;
-    [HideInInspector] public PlayerMovement movement;
     [HideInInspector] public new PlayerCamera camera;
 
     void Awake(){
         controls = GetComponent<PlayerControls>();
-        movement = GetComponent<PlayerMovement>();
     }
 
     void Start()

Assets/Scripts/Player/PlayerCamera.cs

@@ -6,14 +6,43 @@ public interface ILockOnTarget {
     
     Transform transform {get;}
     GameObject gameObject{ get; }
+
+    abstract void OnTargetDelete();
+
+    void Help(){
+        SafelyDeleteTarget();
+    }
     
     public Vector3 GetReticlePosition(){
-        Bounds objectBounds = gameObject.GetComponent<Renderer>().bounds;
+        float upValue = 0f;
+        
+        if (gameObject.GetComponent<Renderer>()){
+            Bounds objectBounds = gameObject.GetComponent<Renderer>().bounds;
+            upValue =  objectBounds.size.y;
+        }
 
-        Vector3 reticlePosition = new Vector3(transform.position.x, transform.position.y + objectBounds.size.y, transform.position.z);
+        Vector3 reticlePosition = new Vector3(transform.position.x, transform.position.y + upValue, transform.position.z);
 
         return reticlePosition;
     }
+
+    public void OnEnable(){
+        Debug.Log("hewwo");
+    }
+
+    public void SafelyDeleteTarget(){
+        // gameObject.
+        foreach (LockOnManager.ActiveLockOnTarget target in LockOnManager.Instance.activeTargets) {
+            if (target.gameObject == this.gameObject) {
+                GameObject clone = new GameObject{name = $"Target Clone of {gameObject.name}",  transform = { position = transform.position}};
+
+                target.gameObject = clone;
+                target.cinemachineTarget.Object = clone.transform;
+                
+                LockOnManager.Instance.QueueTargetRemoval(clone, true);
+            }            
+        }
+    }
 }
 
 public class PlayerCamera : MonoBehaviour{

Assets/Scripts/Player/PlayerControls.cs

@@ -76,7 +76,7 @@ public class PlayerControls : MonoBehaviour{
     }
 
     public void OnCancelLockOn(){
-        GetComponent<LockOnManager>().RemoveLockOnTarget();
+        GetComponent<LockOnManager>().RemoveMainTarget();
         graph.SendEvent<string>("InputEvent", "CancelLockOn", null);
     }
 

Assets/Scripts/Player/PlayerEnvironmentManager.cs

@@ -145,11 +145,23 @@ public class EnvironmentObserver{
         
         // Setup the variables for boxcast, spherecast, etc
         // Create an offset start point for the center of the wirebox, since gizmos are drawn with their pivot in the center.
-        Vector3 offsetWithRotationAndLength = (Quaternion.LookRotation(direction) * Quaternion.Euler(rotation)) * (Vector3.forward * (length / 2));
+        Vector3 offsetWithRotationAndLength;
+        if (direction == Vector3.zero) {
+            offsetWithRotationAndLength = Quaternion.Euler(rotation) * (Vector3.forward * (length / 2));
+        } else {
+            offsetWithRotationAndLength = Quaternion.LookRotation(direction) * Quaternion.Euler(rotation) * (Vector3.forward * (length / 2));
+        }
+        
         Vector3 offsetFromCenter = relativeStartWithRotation + source.transform.rotation * offsetWithRotationAndLength;
-            
+
         // Also create a rotation for use with the gizmos. Mainly just to shorten the lines
-        Quaternion gizmosRotation = source.transform.rotation * Quaternion.LookRotation(direction) * Quaternion.Euler(rotation);
+        Quaternion gizmosRotation;
+                                    
+        if (direction == Vector3.zero) {
+            gizmosRotation = source.transform.rotation *  Quaternion.Euler(rotation);
+        } else {
+            gizmosRotation = source.transform.rotation *  Quaternion.LookRotation(direction) * Quaternion.Euler(rotation);
+        }
         Vector3 firstBoxOffset = gizmosRotation * (Vector3.forward * size.z);
 
         Color gizmoColor = Evaluate(source) ? Color.green : Color.red;

Assets/Scripts/Player/PlayerMovement.cs

@@ -1,56 +0,0 @@
-using UnityEngine;
-using Drawing;
-
-public class PlayerMovement : MonoBehaviour
-{
-    // Raycasts
-    public RaycastHit forwardRay;
-    public RaycastHit leftRay;
-    public RaycastHit rightRay;
-    
-    // References
-    private Player thisPlayer;
-    
-    void Awake(){
-        thisPlayer = GetComponent<Player>();
-    }
-
-    // void Update(){
-    //     // Create Ray Colors
-    //     Color forwardRayStatus = Color.red;
-    //     Color leftRayStatus = Color.red;
-    //     Color rightRayStatus = Color.red;
-    //     
-    //     if (forwardRay.collider&& forwardRay.transform.gameObject.layer == LayerMask.NameToLayer("Environment")){ forwardRayStatus = Color.green;}
-    //     if (leftRay.collider&& leftRay.transform.gameObject.layer == LayerMask.NameToLayer("Environment")){ leftRayStatus = Color.green;}
-    //     if (rightRay.collider&& rightRay.transform.gameObject.layer == LayerMask.NameToLayer("Environment")){ rightRayStatus = Color.green;}
-    //     
-    //     using (Draw.WithColor(forwardRayStatus)) {
-    //         Draw.Line(transform.position + transform.up, transform.position + transform.forward * 2.5f + transform.up);
-    //     }
-    //
-    //     using (Draw.WithColor(leftRayStatus)) {
-    //         Draw.Line(transform.position + transform.up, transform.position + -transform.right * 2f + transform.up);
-    //     }
-    //     
-    //     using (Draw.WithColor(rightRayStatus)) {
-    //         Draw.Line(transform.position + transform.up, transform.position + transform.right * 2f + 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("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);
-    //     }
-    // }
-}

Assets/Scripts/Player/UnitMovementHandler.cs

@@ -0,0 +1,320 @@
+using System;
+using UnityEngine;
+using ParadoxNotion.Design;
+using Sirenix.OdinInspector;
+using UnityEngine.Serialization;
+
+public enum PlayerFacingDirection{
+    TowardsTarget = 0,
+    MatchForward,
+    MatchCamera,
+    Static,
+    Momentum,
+    SpecifiedDirection
+}
+
+namespace Reset.Units{
+    // public interface IBuffSource{ - Unused good idea?
+    //     public Object sourceObject();
+    //     public 
+    // }
+
+    [Serializable]
+    public class UnitMovementData : ICloneable{
+        // Movement Direction
+        public float accelerationSmoothing = 5f;
+        public float deaccelerationSmoothing = 5f;
+        // public AnimationCurve deaccelerationCurve; // Currently unused, may return
+
+        [SliderField(0,1)]
+        public float airDirectionDecay;
+        
+        // Move Speed
+        public float moveSpeed = 15f;
+        public float moveSpeedSoothing = 10f;
+        
+        // Jumping
+        [ShowInInspector, ReadOnly] public float jumpPower;
+        public float jumpPowerDecay = 3f;
+    
+        // Gravity
+        [ShowInInspector, ReadOnly] public float gravityPower;
+        public float gravityMax = 8f;
+        public float gravityAcceleration = 1f;
+        public float gravityScale = 1f;
+        
+        // Rotation
+        [ShowInInspector, SerializeReference]
+        public Enum rotateFacing;
+        [FormerlySerializedAs("rotationSpeedTarget")] public float rotationSpeed = 5f;
+        public float rotationSmoothing = 1f;
+        public float rotationInputBlending = .3f;
+
+        public object Clone(){
+            return MemberwiseClone();
+        }
+    }
+    
+    public class UnitMovementHandler : MonoBehaviour{
+        // class MovementFloatModifier{
+        //     // IBuffSource source 
+        //     public float value;
+        // }
+        
+        // Debug viewing
+        [ShowInInspector, ReadOnly] private float outputSpeed;
+        [ShowInInspector, ReadOnly] private float additionalSpeed;
+        [ShowInInspector, ReadOnly] public Vector3 outputMoveDirection;
+        [ShowInInspector, ReadOnly] private Vector3 additionalMoveDirection;
+        [ShowInInspector, ReadOnly] private Quaternion outputRotation;
+        [ShowInInspector, ReadOnly] private Quaternion specifiedRotation;
+        [ShowInInspector, ReadOnly] private float outputRotationSpeed;
+
+        private float directionChangeDot;
+        
+        private CharacterController controller;
+        private PlayerControls controls;
+        private LockOnManager lockOnManager;
+
+        [ShowInInspector, PropertyOrder(2)]
+        public UnitMovementData data = new();
+
+        [HideInInspector]
+        public UnitMovementData defaultData;
+        
+        void Awake(){
+            controller = GetComponent<CharacterController>();
+            controls = GetComponent<PlayerControls>();
+            lockOnManager = GetComponent<LockOnManager>();
+        }
+
+        private void Start(){
+            defaultData = (UnitMovementData)data.Clone();
+        }
+
+        void Update(){
+            UpdateCurrentDirection();
+            UpdateCurrentSpeed();
+            UpdateCurrentGravity();
+            UpdateCurrentRotation();
+            
+            DoMovement();
+        }
+
+        // Add directly to the direction
+        public void AddToCurrentDirection(Vector3 inputDirection, float power){
+            additionalMoveDirection += inputDirection.normalized;
+            additionalSpeed = power;
+        }
+
+        // Hold a new rotation to be moved to during PlayerFacingDirection.SpecifiedRotation
+        public void SetSpecifiedRotation(Quaternion inputRotation){
+            specifiedRotation = inputRotation;
+        }
+
+        // Blend between the current direction and an input direction, based on the current controller input
+        public void OverwriteDirectionFromInput(Vector2 value, float priority, float speed = Mathf.Infinity){
+            // Create a new direction that is the current controller input * the amount of power they should have
+            Vector3 dirToAdd = new Vector3(controls.rawMoveInput.x * value.x, 0f, controls.rawMoveInput.y * value.y);
+            
+            // Multiply it by the current magnitude (why? i forgor)
+            dirToAdd *= controls.rawMoveInput.magnitude;
+            
+            // Blend the existing direction into it
+            dirToAdd = Vector3.Lerp(outputMoveDirection, dirToAdd, priority * controls.rawMoveInput.magnitude);
+            
+            // Set the new direction
+            outputMoveDirection = new Vector3(dirToAdd.x, outputMoveDirection.y, dirToAdd.z);
+
+            // Everthing under here is for the speed now. If it's not set do...nothing. Otherwise set it to the max value between move speed and the new speed
+            if (float.IsPositiveInfinity(speed)) {
+                return;
+            }
+
+            outputSpeed = Mathf.Lerp(outputSpeed, Mathf.Max(data.moveSpeed, speed), priority);
+        }
+        
+        // Update the direction, called every frame
+        private void UpdateCurrentDirection(){
+            // Get input value
+            Vector3 inputMovement = new Vector3(controls.rawMoveInput.x, 0f, controls.rawMoveInput.y);
+            
+            // Construct move direction
+            Vector3 targetDirection = inputMovement;
+            
+            // Deadzone
+            if (inputMovement.magnitude < .05f) {
+                targetDirection = Vector3.zero;
+            }
+
+            // Remove Y from variables
+            Vector3 targetNoY = new Vector3(targetDirection.x, 0f, targetDirection.z);
+            Vector3 currentNoY = new Vector3(outputMoveDirection.x, 0f, outputMoveDirection.z);
+			
+            // Also need to find the dot value of the current input versus the current move direction
+            Vector3 slerpedValue;
+            Vector3 lerpedValue;
+            
+            float switchedDirection = Vector3.Dot(inputMovement, outputMoveDirection);
+            float switchedDirectionRemapped = Mathf.Lerp(0, 1, switchedDirection);
+
+            directionChangeDot = Mathf.Lerp(switchedDirection, switchedDirectionRemapped, 5f * Time.deltaTime) ; // turn that .5f into a variable
+            
+            // Smooth movement. Use deaccel smoothing if the input magnitude is lower, and accel smoothing if it's higher
+            // Also checks when grounded to only use Slerp on the ground            
+            
+            if (targetNoY.magnitude > currentNoY.magnitude) {
+                if (controller.isGrounded){
+                    slerpedValue = Vector3.Slerp(currentNoY, targetNoY, data.accelerationSmoothing * Time.deltaTime);
+                    lerpedValue = Vector3.Lerp(currentNoY, targetNoY, data.accelerationSmoothing * Time.deltaTime);
+
+                    currentNoY = Vector3.Lerp(lerpedValue, slerpedValue, directionChangeDot);
+                } else {
+                    currentNoY = Vector3.Lerp(currentNoY, targetNoY, data.accelerationSmoothing * Time.deltaTime);
+                }
+            } else {
+                if (controller.isGrounded){
+                    slerpedValue = Vector3.Slerp(currentNoY, targetNoY, data.deaccelerationSmoothing * Time.deltaTime);
+                    lerpedValue = Vector3.Lerp(currentNoY, targetNoY, data.deaccelerationSmoothing * Time.deltaTime);
+                    
+                    currentNoY = Vector3.Lerp(lerpedValue, slerpedValue, directionChangeDot);
+                } else {
+                    currentNoY = Vector3.Lerp(currentNoY, targetNoY, data.deaccelerationSmoothing * data.airDirectionDecay * Time.deltaTime);
+                }
+            }
+            
+            // Commit move direction
+            outputMoveDirection = new Vector3(currentNoY.x, outputMoveDirection.y, currentNoY.z);
+        }
+
+        // Update the speed, called every frame
+        private void UpdateCurrentSpeed(){
+            outputSpeed = Mathf.Lerp(outputSpeed, data.moveSpeed, data.moveSpeedSoothing * Time.deltaTime);
+        }
+
+        // Update the gravity, called every frame
+        private void UpdateCurrentGravity(){
+            // Accelerate gravity
+            data.gravityPower += data.gravityAcceleration * Time.deltaTime;
+            data.gravityPower = Mathf.Min(data.gravityPower, data.gravityMax);
+            
+            // Apply a constant gravity if the player is grounded
+            if (controller.isGrounded) {
+                data.gravityPower = .1f;
+            }
+            
+            // Create the final gravity value
+            float gravityMoveDirection = data.jumpPower + (Physics.gravity.y * data.gravityPower);
+            
+            // Commit gravity to move direction, ignoring XZ since those are done in UpdateMovementDirection
+            outputMoveDirection.y = gravityMoveDirection;
+        }
+
+        // Update the rotation, called every frame
+        private void UpdateCurrentRotation(){
+            // Get input value
+            Vector3 inputMovement = new Vector3(controls.rawMoveInput.x, 0f, controls.rawMoveInput.y);
+			
+            // Switch the desired rotation based on current movement setting
+            switch (data.rotateFacing) {
+                // Just look at target
+                case PlayerFacingDirection.TowardsTarget:
+                    // Look directly at the target
+                    outputRotation = Quaternion.LookRotation(transform.position.DirectionTo(lockOnManager.mainTarget.gameObject.transform.position));
+                    break;
+                case PlayerFacingDirection.Momentum:
+                    // Look towards the current direction the agent is moving 
+                    if (inputMovement.magnitude > .05f){
+                        outputRotation = Camera.main.transform.rotation * Quaternion.LookRotation(outputMoveDirection);
+                    }
+                    break;
+                case PlayerFacingDirection.MatchForward:
+                    // Look towards the input direction....why??? I guess cause move direction is PlayerFacingDirection.Momentum.
+                    if (controls.rawMoveInput.magnitude < 0.05f) { break; }
+                    
+                    outputRotation = Camera.main.transform.rotation * Quaternion.LookRotation(inputMovement);
+                    break;
+                case PlayerFacingDirection.MatchCamera:
+                    // Look the same direction as the camera
+                    outputRotation = Quaternion.Euler(Camera.main.transform.rotation.eulerAngles.Flatten(0, null, 0));
+                    break;
+                case PlayerFacingDirection.Static:
+                    // Don't change
+                    outputRotation  = transform.rotation;
+                    break;
+                case PlayerFacingDirection.SpecifiedDirection:
+                    // Look at an inputed rotation
+                    outputRotation = specifiedRotation;
+                    break;
+            }
+            
+            // Add the current input into the created rotation
+            if (inputMovement.magnitude > .05){
+                outputRotation = Quaternion.Lerp(outputRotation, Camera.main.transform.rotation * Quaternion.LookRotation(inputMovement), data.rotationInputBlending);
+            }
+           
+            // Calculate rotation speed, as in how fast the fella rotates. This value has it's own smoothing to allow for gradual increasing/decreasing of the speed till it reaches the target
+            outputRotationSpeed = Mathf.Lerp(outputRotationSpeed, data.rotationSpeed, data.rotationSmoothing * Time.deltaTime);
+			
+            // Set final rotation
+            transform.rotation = Quaternion.Slerp(transform.rotation, outputRotation, outputRotationSpeed * Time.deltaTime).Flatten(0, null, 0);
+        }
+
+        // Move with default settings
+        public void DoMovement(){
+            DoMovement(outputMoveDirection, outputSpeed, data.gravityScale);
+        }
+        
+        // Custom move from input
+        public void DoMovement(Vector3 moveDir, float speed, float gravity){
+            // Seperate the different move directions. Additonal becomes it's own because it needs to be added independently of the other two
+            Vector3 moveXZDir = new Vector3(moveDir.x, 0f, moveDir.z);
+            Vector3 moveYDir = new Vector3(0f, moveDir.y, 0f);
+            Vector3 addDir = additionalMoveDirection;
+
+            // Add their related speeds
+            moveXZDir *= speed * Time.deltaTime;
+            moveYDir *= gravity * Time.deltaTime;
+            addDir *= additionalSpeed * Time.deltaTime;
+
+            // Construct the direction and move
+            Vector3 finalDir = moveXZDir + moveYDir;
+            
+            controller.Move((Camera.main.transform.rotation.Flatten(0, null, 0) * finalDir) + addDir);
+        }
+
+        void LateUpdate(){
+            UpdateGravityLate();
+            DecayAdditionalDirection();
+        }
+
+        void DecayAdditionalDirection(){
+            // Get input value
+            Vector3 inputMovement = new Vector3(controls.rawMoveInput.x, 0f, controls.rawMoveInput.y);
+            
+            // Ignore values under deadzone
+            if (inputMovement.magnitude < .1f) {
+                inputMovement = Vector3.zero;
+            }
+            
+            // Remove Y from variables
+            Vector3 currentNoY = new Vector3(additionalMoveDirection.x, 0f, additionalMoveDirection.z);
+            
+            // Decay the direction
+            if (inputMovement.magnitude < currentNoY.magnitude) {
+                additionalMoveDirection = Vector3.Slerp(additionalMoveDirection, Vector3.zero,data.accelerationSmoothing * Time.deltaTime);	
+
+            } else {
+                // float deaccelValue = data.deaccelerationCurve.Evaluate(inputMovement.magnitude);
+                additionalMoveDirection = Vector3.Lerp(additionalMoveDirection, Vector3.zero, data.deaccelerationSmoothing * Time.deltaTime);	
+            }
+        }
+        
+        private void UpdateGravityLate(){
+            // Decay jump power
+            data.jumpPower -= data.jumpPowerDecay * Time.deltaTime;
+            data.jumpPower = Mathf.Max(0f, data.jumpPower);
+        }
+    }
+}
+