MovementTests/player_controller/Scripts/PlayerController.cs

using System;
using Godot;
using GodotStateCharts;
using Movementtests.addons.godot_state_charts.csharp;
using Movementtests.systems;
using Movementtests.player_controller.Scripts;
using RustyOptions;

public partial class PlayerController : CharacterBody3D
{
	// Enums
	public enum AllowedInputs
	{
		All,
		MoveCamera,
		None,
	}
	private bool _isUsingGamepad;
	public AllowedInputs CurrentlyAllowedInputs { get; set; } = AllowedInputs.All;
	
	public enum BufferedActions
	{
		None,
		Jump,
		MantleJump,
		Dash,
		MantleDash
	}
	private BufferedActions _bufferedAction = BufferedActions.None;
	
	///////////////////////////
	// Public stuff //
	///////////////////////////
	public HeadSystem       HeadSystem;
	public Bobbing          Bobbing;
	public FieldOfView      FieldOfView;
	public StairsSystem     StairsSystem;
	public MantleSystem     MantleSystem;
	public DashSystem       DashSystem;
	public CapsuleCollider  CapsuleCollider;
	public Node3D           WeaponRoot;
	public WeaponSystem     WeaponSystem;
	public WallHugSystem    WallHugSystem;
	public PlayerUi		    PlayerUi;
	public TextureRect      DashIndicator;
	public ColorRect        PowerCooldownIndicator;
	public Node3D           DashIndicatorNode;
	public MeshInstance3D   DashIndicatorMesh;
	public CylinderMesh     DashIndicatorMeshCylinder;
	public RayCast3D        WallRunSnapper;
	public ShapeCast3D      GroundDetector;

	// Inspector stuff
	[Export] public Marker3D TutorialWeaponTarget;
	[Export] public bool TutorialDone { get; set; }
	
	[ExportCategory("Movement")]
	[ExportGroup("Ground")]
	[Export(PropertyHint.Range, "0,20,0.1,or_greater")]
	public float WalkSpeed             { get; set; } = 7.0f;
	[Export(PropertyHint.Range, "0,10,0.1,or_greater")]
	public float AccelerationFloor                   = 5.0f;
	[Export(PropertyHint.Range, "0,10,0.1,or_greater")]
	public float DecelerationFloor                   = 5.0f;
	[ExportGroup("Air")]
	[Export(PropertyHint.Range, "0,10,0.1,or_greater")]
	public float AccelerationAir                     = 3.0f;
	[Export(PropertyHint.Range, "0,10,0.01,or_greater")]
	public float DecelerationAir                     = 1.0f;
	[Export(PropertyHint.Range, "0,10,0.01,or_greater")]
	public float Weight        { get; set; } = 3.0f;
	
	// Mantle
	[ExportGroup("Mantle")]
	[Export(PropertyHint.Range, "0,1,0.01,or_greater")]
	public float MantleTime { get; set; } = 0.1f;
	[Export]
	public PackedScene MantlePath { get; set; }
	
	[Export(PropertyHint.Range, "0,50,0.1")]
	public float MantleDashStrength { get; set; } = 15f;
	[Export(PropertyHint.Range, "0,100,1,or_greater")]
	public float MantleJumpStartVelocity { get; set; } = 20.0f;
	
	// Jump
	[ExportGroup("Jump")] 
	[Export(PropertyHint.Range, "0,1,0.01")]
	public float CoyoteTime { get; set; } = 0.2f;
	[Export(PropertyHint.Range, "0,10,1,or_greater")]
	public int InputBufferFrames { get; set; } = 3;
	
	// Simple jump
	[ExportSubgroup("Simple jump")]
	[Export(PropertyHint.Range, "0,100,1,or_greater")]
	public float SimpleJumpStartVelocity { get; set; } = 3.0f;
	[Export(PropertyHint.Range, "0,10,1,or_greater")]
	public int SimpleJumpHangTimeInFrames { get; set; } = 5;
	[Export(PropertyHint.Range, "1,10,0.1,or_greater")]
	public float SimpleJumpGravityLesseningFactor { get; set; } = 3f;
	
	// Double jump
	[ExportSubgroup("Double jump")]
	[Export(PropertyHint.Range, "0,100,1,or_greater")]
	public float DoubleJumpStartVelocity { get; set; } = 10.0f;
	[Export(PropertyHint.Range, "0,10,1,or_greater")]
	public int DoubleJumpHangTimeInFrames { get; set; } = 5;
	[Export(PropertyHint.Range, "1,10,0.1,or_greater")]
	public float DoubleJumpGravityLesseningFactor { get; set; } = 3f;
	
	// Wall jump
	[ExportSubgroup("Wall jump")]
	[Export(PropertyHint.Range, "0,100,1,or_greater")]
	public float WallJumpStartVelocity { get; set; } = 10.0f;
	
	// Dash
	[ExportGroup("Dash")]
	[Export(PropertyHint.Range, "0,5,1,or_greater")]
	public int MaxNumberOfEmpoweredActions { get; set; } = 1;
	// Simple dash
	[ExportSubgroup("Simple")]
	[Export(PropertyHint.Range, "0,50,0.1")]
	public float SimpleDashStrength { get; set; } = 10f;
	// Aimed Dash
	[ExportSubgroup("Special")]
	[Export(PropertyHint.Range, "0,1,0.01,or_greater")]
	public float AimedDashTime { get; set; } = 0.1f;
	[Export(PropertyHint.Range, "0,100,1,or_greater")]
	public float PostDashSpeed { get; set; } = 100f;
	[Export(PropertyHint.Range, "0,1,0.01,or_greater")]
	public float TimeScaleAimInAir { get; set; } = 0.05f;
	// Slam
	[ExportSubgroup("Slam")]
	[Export(PropertyHint.Range, "0,100,1,or_greater")]
	public float SlamSpeed { get; set; } = 50.0f;
	
	// Sliding and gliding
	[ExportGroup("Slide")]
	[ExportSubgroup("Ground slide")]
	[Export(PropertyHint.Range, "0,1,0.01,or_greater")]
	public float AccelerationGroundSlide = 1.0f;
	[Export(PropertyHint.Range, "0,1,0.01,or_greater")]
	public float DecelerationGroundSlide = 0.1f;

	[ExportSubgroup("Air glide")]
	[Export(PropertyHint.Range, "0,10,0.01,or_greater")]
	public float AirGlideVSpeed { get; set; } = 1.0f;
	[Export(PropertyHint.Range, "0,1,0.01,or_greater")]
	public float AccelerationAirGlide = 1.0f;
	[Export(PropertyHint.Range, "0,1,0.01,or_greater")]
	public float DecelerationAirGlide = 0.1f;
	
	// Wall hug
	[ExportGroup("Wall hug")]
	[Export(PropertyHint.Range, "0,50,0.1,or_greater")]
	public float WallHugGravityLesseningFactor { get; set; } = 2f;
	[Export(PropertyHint.Range, "0.1,50,0.1,or_greater")]
	public float WallHugDownwardMaxSpeed { get; set; } = 2f;
	[Export(PropertyHint.Range, "0.1,10,0.1,or_greater")]
	public float WallHugHorizontalDeceleration { get; set; } = 5f;
	
	// Wall run
	[ExportGroup("Wall run")]
	[Export(PropertyHint.Range, "1,20,0.1,or_greater")]
	public float WallRunUpwardVelocity { get; set; } = 10f;
	[Export(PropertyHint.Range, "1,20,0.1,or_greater")]
	public float WallRunAltitudeLossSpeed { get; set; } = 10f;
	
	[Export(PropertyHint.Range, "1,20,0.1,or_greater")]
	public float WallRunSpeedThreshold  { get; set; } = 8f;

		
	///////////////////////////
	// Private stuff //
	///////////////////////////
	// Stairs and shit
	private float _lastFrameWasOnFloor = -Mathf.Inf;
	private const int NUM_OF_HEAD_COLLISION_DETECTORS = 4;
	private RayCast3D[] _headCollisionDetectors;

	// Basic movement
	private bool _movementEnabled = true;
	private Vector3 _inputMove = Vector3.Zero;
	private Vector3 _inputMoveKeyboard = Vector3.Zero;
	private float _inputRotateY;
	private float _inputRotateFloorplane;
	
	// Basic falling
	private float _targetSpeed;
	private float _gravity;

	// Jump stuff
	private int _currentInputBufferFrames;
	private bool _isJumpInputPressed;
	private int _framesSinceJumpAtApex;
	private bool _isWallJumpAvailable = true;
	
	// Mantle stuff
	private bool _shouldMantleOnDashEnded;
	private Path _mantlePath; 
	private bool _customMantle;
	private Transform3D _customMantleStartTransform;
	private Curve3D _customMantleCurve;
	private Vector3 _mantleStartPosition;
	private Vector3 _velocityOnMantleStarted = Vector3.Zero;
	
	// Wall stuff
	private Vector3 _wallHugStartLocation = Vector3.Zero;
	private Vector3 _wallHugStartNormal = Vector3.Zero;
	private Vector3 _wallHugStartProjectedVelocity = Vector3.Zero;
	private Vector3 _currentWallContactPoint = Vector3.Zero;
	
	// Dash stuff
	private bool _canDash = true;
	private bool _canDashAirborne = true;
	private float _playerHeight;
	private float _playerRadius;
	private Vector3 _dashDirection = Vector3.Zero;
	private Vector3 _preDashVelocity = Vector3.Zero;
	private int _empoweredActionsLeft;
	public int EmpoweredActionsLeft
	{
		get => _empoweredActionsLeft;
		set
		{
			_empoweredActionsLeft = value;
			PlayerUi.SetNumberOfDashesLeft(value);
		}
	}
	
	// Settings
	private float _lookSensitivityMultiplier = 1.0f;
	private float _mouseSensitivityMultiplier = 1.0f;
	private float _headBobbingMultiplier = 1.0f;
	private float _fovChangeMultiplier = 1.0f;

	// Timers
	private Timer _timeScaleAimInAirTimer;
	private Timer _simpleDashCooldownTimer;
	private Timer _airborneDashCooldownTimer;
	private Timer _powerCooldownTimer;
	
	// State chart
	private StateChart       _playerState;
	
	private StateChartState  _aiming;
	private StateChartState  _powerExpired;
	private StateChartState  _powerRecharging;
	private StateChartState  _powerFull;
	
	private StateChartState  _grounded;
	private StateChartState  _airborne;
	private StateChartState  _coyoteEnabled;
	private StateChartState  _simpleJump;
	private StateChartState  _doubleJump;
	private StateChartState  _mantling;
	private StateChartState  _simpleDash;
	private StateChartState  _aimedDash;
	private StateChartState  _sliding;
	private StateChartState  _groundSliding;
	private StateChartState  _airGliding;
	private StateChartState  _slamming;
	private StateChartState  _onWall;
	private StateChartState  _onWallHugging;
	private StateChartState  _onWallHanging;
	private StateChartState  _onWallRunning;
	
	private Transition       _onJumpFromWall;
	private Transition       _onJumpFromWallFalling;
	private Transition       _onLeaveWallFromRun;

	public override void _Ready()
	{
		LoadSettings();
		
		///////////////////////////
		// Getting components /////
		///////////////////////////
		
		// General use stuff
		PlayerUi = GetNode<PlayerUi>("UI");
		// DashIndicator = GetNode<TextureRect>("%DashIndicator");
		PowerCooldownIndicator = GetNode<ColorRect>("%DashCooldownIndicator");
		PowerCooldownIndicator.Visible = false;
		EmpoweredActionsLeft = MaxNumberOfEmpoweredActions;
		_targetSpeed = WalkSpeed;
		DashIndicatorNode = GetNode<Node3D>("DashIndicator");
		DashIndicatorMesh = GetNode<MeshInstance3D>("DashIndicator/DashIndicatorMesh");
		DashIndicatorMeshCylinder = DashIndicatorMesh.Mesh as CylinderMesh;
		DashIndicatorMesh.Visible = false;
		
		// Camera stuff
		HeadSystem = GetNode<HeadSystem>("HeadSystem");
		Bobbing = GetNode<Bobbing>("Bobbing");
		FieldOfView = GetNode<FieldOfView>("FieldOfView");
		Camera3D camera = GetNode<Camera3D>("HeadSystem/CameraSmooth/Camera3D");
		Node3D cameraSmooth = GetNode<Node3D>("HeadSystem/CameraSmooth");
		
		// Movement stuff
		WeaponRoot = GetNode<Node3D>("WeaponRoot");	
		WeaponSystem = GetNode<WeaponSystem>("WeaponRoot/WeaponSystem");
		MantleSystem = GetNode<MantleSystem>("HeadSystem/MantleSystem");
		CapsuleCollider = GetNode<CapsuleCollider>("CapsuleCollider");
		DashSystem = GetNode<DashSystem>("DashSystem");
		StairsSystem = GetNode<StairsSystem>("StairsSystem");
		WallHugSystem = GetNode<WallHugSystem>("WallHugSystem");
		WallRunSnapper = GetNode<RayCast3D>("%WallRunSnapper");
		GroundDetector = GetNode<ShapeCast3D>("GroundDetector");
		RayCast3D stairsBelowRayCast3D = GetNode<RayCast3D>("StairsBelowRayCast3D");
		RayCast3D stairsAheadRayCast3D = GetNode<RayCast3D>("StairsAheadRayCast3D");
		_headCollisionDetectors = new RayCast3D[NUM_OF_HEAD_COLLISION_DETECTORS];
		for (int i = 0; i < NUM_OF_HEAD_COLLISION_DETECTORS; i++)
		{
			_headCollisionDetectors[i] = GetNode<RayCast3D>(
				"HeadCollisionDetectors/HeadCollisionDetector" + i);
		}
		
		var playerShape = CapsuleCollider.GetShape() as CapsuleShape3D;
		_playerHeight = playerShape!.Height;
		_playerRadius = playerShape.Radius;
		
		// State management
		_playerState = StateChart.Of(GetNode("StateChart"));
		
		_aiming = StateChartState.Of(GetNode("StateChart/Root/Aim/On"));
		_simpleDash = StateChartState.Of(GetNode("StateChart/Root/Movement/Dashing/Dash"));
		_aimedDash = StateChartState.Of(GetNode("StateChart/Root/Movement/Dashing/AimedDash"));
		
		_sliding = StateChartState.Of(GetNode("StateChart/Root/Movement/Sliding"));
		_groundSliding = StateChartState.Of(GetNode("StateChart/Root/Movement/Sliding/GroundSlide"));
		_airGliding = StateChartState.Of(GetNode("StateChart/Root/Movement/Sliding/AirGlide"));
		_slamming = StateChartState.Of(GetNode("StateChart/Root/Movement/Slamming"));
		
		// _actionHanging = StateChartState.Of(GetNode("StateChart/Root/Actions/Hanging"));
		_powerExpired = StateChartState.Of(GetNode("StateChart/Root/PowerReserve/Expired"));
		_powerRecharging = StateChartState.Of(GetNode("StateChart/Root/PowerReserve/AtLeastOneCharge"));
		_powerFull = StateChartState.Of(GetNode("StateChart/Root/PowerReserve/Full")); 
		
		_grounded = StateChartState.Of(GetNode("StateChart/Root/Movement/Grounded"));
		_airborne = StateChartState.Of(GetNode("StateChart/Root/Movement/Airborne"));
		_coyoteEnabled = StateChartState.Of(GetNode("StateChart/Root/Movement/Airborne/CoyoteEnabled"));
		// _doubleJumpEnabled = StateChartState.Of(GetNode("StateChart/Root/Movement/Airborne/DoubleJumpEnabled"));
		_simpleJump = StateChartState.Of(GetNode("StateChart/Root/Movement/Jump/SimpleJump"));
		_doubleJump = StateChartState.Of(GetNode("StateChart/Root/Movement/Jump/DoubleJump"));
		_mantling = StateChartState.Of(GetNode("StateChart/Root/Movement/Mantling"));
		_onJumpFromWall = Transition.Of(GetNode("StateChart/Root/Movement/OnWall/OnJump"));
		_onJumpFromWallFalling = Transition.Of(GetNode("StateChart/Root/Movement/Airborne/Falling/OnWallJump"));
		_onWall = StateChartState.Of(GetNode("StateChart/Root/Movement/OnWall"));
		_onWallHugging = StateChartState.Of(GetNode("StateChart/Root/Movement/OnWall/Hugging"));
		_onWallHanging = StateChartState.Of(GetNode("StateChart/Root/Movement/OnWall/Hanging"));
		_onWallRunning = StateChartState.Of(GetNode("StateChart/Root/Movement/OnWall/Running"));
		_onLeaveWallFromRun = Transition.Of(GetNode("StateChart/Root/Movement/OnWall/Running/OnLeaveWall"));
		
		// State timers
		_powerCooldownTimer = GetNode<Timer>("PowerCooldown");
		_timeScaleAimInAirTimer = GetNode<Timer>("TimeScaleAimInAir");
		_simpleDashCooldownTimer = GetNode<Timer>("DashCooldown");
		_airborneDashCooldownTimer = GetNode<Timer>("AirborneDashCooldown");
		
		///////////////////////////
		// Initialize components //
		///////////////////////////

		// Camera stuff
		HeadSystem.Init();
		Bobbing.Init(camera);
		FieldOfView.Init(camera);
		
		// Movement stuff
		// Getting universal setting from GODOT editor to be in sync
		_gravity = (float)ProjectSettings.GetSetting("physics/3d/default_gravity");
		MantleSystem.Init();
		StairsSystem.Init(stairsBelowRayCast3D, stairsAheadRayCast3D, cameraSmooth);
		DashSystem.Init(HeadSystem, camera);
		WeaponSystem.Init(HeadSystem, camera);
		WallHugSystem.Init();
		
		EmpoweredActionsLeft = MaxNumberOfEmpoweredActions;
		
		if (!TutorialDone)
			PlaceWeaponForTutorial();
		
		///////////////////////////
		// Signal setup ///////////
		///////////////////////////
		_aiming.StatePhysicsProcessing += HandleAiming;
		_aiming.StateEntered += OnAimingEntered;
		_aiming.StateExited += ResetTimeScale;
		_aiming.StateExited += OnAimingExited;

		_grounded.StateEntered += OnGrounded;
		_grounded.StatePhysicsProcessing += HandleGrounded;
		_airborne.StatePhysicsProcessing += HandleAirborne;
		_onWall.StatePhysicsProcessing += HandleOnWall;
		
		_coyoteEnabled.StateEntered += StartCoyoteTime;
		_timeScaleAimInAirTimer.Timeout += ResetTimeScale;

		_powerFull.StateEntered += StopPowerCooldown;
		_powerFull.StateExited += StartPowerCooldown;
		_powerRecharging.StateEntered += StartPowerCooldown;
		_powerCooldownTimer.Timeout += PowerCooldownExpired;
		_powerRecharging.StateProcessing += PowerRecharging;
		_powerExpired.StateProcessing += PowerRecharging;

		_simpleJump.StateEntered += OnSimpleJumpStarted;
		_simpleJump.StatePhysicsProcessing += HandleSimpleJump;
		
		_doubleJump.StateEntered += OnDoubleJumpStarted;
		_doubleJump.StatePhysicsProcessing += HandleDoubleJump;
		
		_mantling.StateEntered += OnMantleStarted;
		_mantling.StatePhysicsProcessing += HandleMantling;

		_simpleDash.StateEntered += OnSimpleDashStarted;
		_simpleDash.StatePhysicsProcessing += HandleSimpleDash;
		
		_aimedDash.StateEntered += OnAimedDashStarted;
		_aimedDash.StateExited += OnAimedDashFinished;

		_sliding.StateEntered += SlideStarted;
		_sliding.StateExited += SlideEnded;
		_groundSliding.StatePhysicsProcessing += HandleGroundSlide;
		_airGliding.StatePhysicsProcessing += HandleAirGlide;

		_slamming.StateEntered += SlamStarted;
		_slamming.StateExited += SlamEnded;
		_slamming.StatePhysicsProcessing += HandleSlam;

		_simpleDashCooldownTimer.Timeout += DashCooldownTimeout;
		_airborneDashCooldownTimer.Timeout += AirborneDashCooldownTimeout;
		
		_onWall.StateEntered += OnWallStarted;
		_onWall.StateExited += OnWallStopped;
		_onWallHugging.StatePhysicsProcessing += HandleWallHugging;
		_onWallHanging.StatePhysicsProcessing += HandleWallHanging;
		_onWallRunning.StatePhysicsProcessing += HandleWallRunning;
		
		_onJumpFromWall.Taken += OnJumpFromWall;
		_onJumpFromWallFalling.Taken += OnJumpFromWall;
		_onLeaveWallFromRun.Taken += OnLeaveWallFromRun;
	}
	
	///////////////////////////
	// Settings & tutorial //
	///////////////////////////
	public void SetAllowedInputsAll()
	{
		CurrentlyAllowedInputs = AllowedInputs.All;
	}
	public void SetAllowedInputsMoveCamera()
	{
		CurrentlyAllowedInputs = AllowedInputs.MoveCamera;
	}
	public void SetAllowedInputsNone()
	{
		CurrentlyAllowedInputs = AllowedInputs.None;
	}
	public void LoadSettings()
	{
		var config = new ConfigFile();
		
		// Load data from a file.
		Error err = config.Load("user://config.cfg");
		
		// If the file didn't load, ignore it.
		if (err != Error.Ok)
		{
			throw new Exception("Couldn't load config.cfg");
		}
		
		_lookSensitivityMultiplier = (float) config.GetValue("InputSettings", "LookSensitivity", 1.0f);
		_mouseSensitivityMultiplier  = (float) config.GetValue("InputSettings", "MouseSensitivity", 1.0f);
		_headBobbingMultiplier = (float) config.GetValue("InputSettings", "HeadBobbingWhileWalking", 1.0f);
		_fovChangeMultiplier = (float) config.GetValue("InputSettings", "FovChangeWithSpeed", 1.0f);
	}
	public void OnTutorialDone(Node3D _)
	{
		TutorialDone = true;
	}
	public void PlaceWeaponForTutorial()
	{
		if (TutorialDone)
			return;
		
		RemoveChild(WeaponRoot);
		GetTree().GetRoot().CallDeferred(Node.MethodName.AddChild, WeaponRoot);
		WeaponRoot.CallDeferred(Node3D.MethodName.SetGlobalPosition, TutorialWeaponTarget.GlobalPosition);
		WeaponSystem.CallDeferred(WeaponSystem.MethodName.PlaceWeaponForTutorial, TutorialWeaponTarget.GlobalPosition);
	}
	
	///////////////////////////
	// Grounded management //
	///////////////////////////
	public void OnGrounded()
	{
		_isWallJumpAvailable = true;
		_canDashAirborne = true;
		
		if (_simpleDashCooldownTimer.IsStopped())
			_simpleDashCooldownTimer.Start();
		
		if (_bufferedAction == BufferedActions.Jump && _currentInputBufferFrames > 0)
		{
			_currentInputBufferFrames = 0;
			PerformJump();
		}
		if (_bufferedAction == BufferedActions.Dash && _currentInputBufferFrames > 0)
		{
			_currentInputBufferFrames = 0;
			SimpleDash();
		}

		if (_bufferedAction == BufferedActions.MantleJump)
		{
			SimpleDash();
			OnJumpStarted(MantleJumpStartVelocity);
		}
		if (_bufferedAction == BufferedActions.MantleDash)
		{
			SimpleDash(MantleDashStrength);
		}

		_bufferedAction = BufferedActions.None;
	}

	public bool IsGroundLike()
	{
		return GroundDetector.GetCollisionResult().Count > 0;
	}
	
	public void HandleGrounded(float delta)
	{
		MoveOnGround(delta);
		// if (IsTryingToMantle()) _playerState.SendEvent("mantle");
		if (!isOnFloorCustom())
			_playerState.SendEvent("start_falling");
	}
	public void MoveOnGround(double delta)
	{
		var horizontalVelocity = ComputeHVelocityGround((float) delta);
		Velocity = new Vector3(horizontalVelocity.X, Velocity.Y, horizontalVelocity.Z);
	}
	
	private void MoveSlideAndHandleStairs(float delta)
	{
		StairsSystem.UpStairsCheckParams upStairsCheckParams = new StairsSystem.UpStairsCheckParams
		{
			IsOnFloorCustom = isOnFloorCustom(),
			IsCapsuleHeightLessThanNormal = CapsuleCollider.IsCapsuleHeightLessThanNormal(),
			CurrentSpeedGreaterThanWalkSpeed = false,
			IsCrouchingHeight = CapsuleCollider.IsCrouchingHeight(),
			Delta = delta,
			FloorMaxAngle = FloorMaxAngle,
			GlobalPositionFromDriver = GlobalPosition,
			Velocity = Velocity,
			GlobalTransformFromDriver = GlobalTransform,
			Rid = GetRid()
		};
		StairsSystem.UpStairsCheckResult upStairsCheckResult = StairsSystem.SnapUpStairsCheck(upStairsCheckParams);

		if (upStairsCheckResult.UpdateRequired)
		{
			upStairsCheckResult.Update(this);
		}
		else
		{
			MoveAndSlide();
		
			StairsSystem.DownStairsCheckParams downStairsCheckParams = new StairsSystem.DownStairsCheckParams
			{
				IsOnFloor = IsOnFloor(),
				IsCrouchingHeight = CapsuleCollider.IsCrouchingHeight(),
				LastFrameWasOnFloor = _lastFrameWasOnFloor,
				CapsuleDefaultHeight = CapsuleCollider.GetDefaultHeight(),
				CurrentCapsuleHeight = CapsuleCollider.GetCurrentHeight(),
				FloorMaxAngle = FloorMaxAngle,
				VelocityY = Velocity.Y,
				GlobalTransformFromDriver = GlobalTransform,
				Rid = GetRid()
			};
		
			StairsSystem.DownStairsCheckResult downStairsCheckResult = StairsSystem.SnapDownStairsCheck(
				downStairsCheckParams);

			if (downStairsCheckResult.UpdateIsRequired)
			{
				downStairsCheckResult.Update(this);
			}
		}
		
		StairsSystem.SlideCameraParams slideCameraParams = new StairsSystem.SlideCameraParams
		{
			IsCapsuleHeightLessThanNormal = CapsuleCollider.IsCapsuleHeightLessThanNormal(),
			CurrentSpeedGreaterThanWalkSpeed = false,
			BetweenCrouchingAndNormalHeight  = CapsuleCollider.IsBetweenCrouchingAndNormalHeight(),
			Delta = delta
		};
		StairsSystem.SlideCameraSmoothBackToOrigin(slideCameraParams);
	}
	private bool IsHeadTouchingCeiling()
	{
		for (int i = 0; i < NUM_OF_HEAD_COLLISION_DETECTORS; i++)
		{
			if (_headCollisionDetectors[i].IsColliding())
			{
				return true;
			}
		}

		return false;
	}
	private bool isOnFloorCustom()
	{
		return IsOnFloor() || StairsSystem.WasSnappedToStairsLastFrame();
	}
	
	///////////////////////////
	// Airborne management //
	///////////////////////////
	public void HandleAirborne(float delta)
	{
		MoveInAir(delta, IsGroundLike());
		if (isOnFloorCustom())
			_playerState.SendEvent("grounded");
		
		if (IsTryingToMantle()) _playerState.SendEvent("mantle");

		if (!WallHugSystem.IsWallHugging())
		{
			_isWallJumpAvailable = true; // reset wall jump if we left the wall 
			return;
		}
		
		// Going upwards, we stay simply airborne
		if (Velocity.AngleTo(Vector3.Up) < Math.PI / 4)
			return;
		
		// Should we start a wall run
		var wallNormal = WallHugSystem.WallHugNormal.UnwrapOr(Vector3.Zero);
		var isIndeedWall = wallNormal.Y < 0.1;
		var hvel = new Vector3(Velocity.X, 0, Velocity.Z);
		var hvelProjected = hvel.Slide(_wallHugStartNormal);
		var haveEnoughSpeed = hvelProjected.Length() > WallRunSpeedThreshold;
		var isCoplanarEnough = Velocity.AngleTo(wallNormal) > Math.PI/4 && Velocity.AngleTo(wallNormal) < 3*Math.PI/4;
		var isGoingDownwards = Velocity.AngleTo(Vector3.Down) < Math.PI/4;
		if (haveEnoughSpeed && isCoplanarEnough && !isGoingDownwards && isIndeedWall && !_coyoteEnabled.Active)
		{
			SetVerticalVelocity(WallRunUpwardVelocity);
			_playerState.SendEvent("wall_run");
			return;
		}
		
		// If all else fail and we go down, we hug
		if (Velocity.Y < 0 && IsInputTowardsWall(wallNormal))
		{
			_playerState.SendEvent("wall_hug");
		}
	}

	public float ComputeVerticalSpeedGravity(float delta)
	{
		return Velocity.Y - CalculateGravityForce() * delta;
	}
	public void MoveInAir(double delta, bool isGroundLike = false)
	{
		var horizontalVelocity = isGroundLike ? ComputeHVelocityGround((float) delta) : ComputeHVelocityAir((float) delta);
		var verticalVelocity = ComputeVerticalSpeedGravity((float) delta);
		Velocity = new Vector3(horizontalVelocity.X, verticalVelocity, horizontalVelocity.Z);
	}
	
	///////////////////////////
	// Movement input //
	///////////////////////////
	public bool IsPlayerInputtingForward()
	{
		return GetMoveInput().Z < -0.5f;
	}
	public void InputDeviceChanged(bool isUsingGamepad)
	{
		_isUsingGamepad = isUsingGamepad;
	}
	
	public Vector3 GetMoveInput()
	{
		if (_isUsingGamepad)
			return _inputMove;
		return _inputMoveKeyboard;
	}
	public Vector3 GetGlobalMoveInput()
	{
		return Transform.Basis * HeadSystem.Transform.Basis * GetMoveInput();
	}
	public Vector3 GetInputGlobalHDirection()
	{
		var direction = Transform.Basis * HeadSystem.Transform.Basis * GetMoveInput();
		return new Vector3(direction.X, 0, direction.Z).Normalized();
	}
	public Vector3 GetInputLocalHDirection()
	{
		var direction = GetMoveInput();
		return new Vector3(direction.X, 0, direction.Z).Normalized();
	}
	
	public void OnInputMoveKeyboard(Vector3 value)
	{
		_inputMoveKeyboard = value;
	}
	public void OnInputMove(Vector3 value)
	{
		_inputMove = value;
	}
	public void OnInputRotateY(float value)
	{
		_inputRotateY = value;
	}
	public void OnInputRotateFloorplane(float value)
	{
		_inputRotateFloorplane = value;
	}
	
	public bool IsTryingToMantle()
	{
		return MantleSystem.IsMantlePossible && IsPlayerInputtingForward() && _isJumpInputPressed;
	}
	
	///////////////////////////
	// Utilities //
	///////////////////////////
	
	public float CalculateGravityForce() => _gravity * Weight;
	
	// Camera stuff
	private void LookAround(double delta)
	{
		Vector2 inputLookDir = new Vector2(_inputRotateY, _inputRotateFloorplane);
		var lookSensitivity = _isUsingGamepad ? _lookSensitivityMultiplier : _mouseSensitivityMultiplier;
		
		var wallHugContactPoint = _onWallRunning.Active ? _currentWallContactPoint : Vector3.Zero;
		var playerVelocity = GetGlobalMoveInput();
		HeadSystem.LookAround(delta, inputLookDir, playerVelocity, wallHugContactPoint, lookSensitivity);
	}
	public void RotateWeaponWithPlayer()
	{
		WeaponRoot.SetRotation(HeadSystem.Rotation);
	}
	public Vector3 GetGlobalForwardFacingVector()
	{
		return Transform.Basis * HeadSystem.Transform.Basis * Vector3.Forward;
	}
	private void CameraModifications(float delta)
	{
		Bobbing.CameraBobbingParams cameraBobbingParams = new Bobbing.CameraBobbingParams
		{
			Delta = delta,
			IsOnFloorCustom = isOnFloorCustom() || _onWallRunning.Active,
			Velocity = Velocity, 
			SettingsMultiplier = _headBobbingMultiplier
		};
		Bobbing.PerformCameraBobbing(cameraBobbingParams);

		FieldOfView.FovParameters fovParams = new FieldOfView.FovParameters
		{
			IsCrouchingHeight = CapsuleCollider.IsCrouchingHeight(),
			Delta = delta,
			SprintSpeed = WalkSpeed,
			Velocity = Velocity,
			FOVMultiplier = _fovChangeMultiplier
		};
		FieldOfView.PerformFovAdjustment(fovParams);
	}
	
	// Horizontal velocity computing
	public Vector3 ComputeHVelocity(float delta, float accelerationFactor, float decelerationFactor, Vector3? direction = null)
	{
		var dir = direction ?? GetGlobalMoveInput();
		
		var acceleration = dir.Length() > 0 ? accelerationFactor : decelerationFactor;
        
		float xAcceleration = Mathf.Lerp(Velocity.X, dir.X * _targetSpeed, delta * acceleration);
		float zAcceleration = Mathf.Lerp(Velocity.Z, dir.Z * _targetSpeed, delta * acceleration);
		return new Vector3(xAcceleration, 0, zAcceleration);
	}
	public Vector3 ComputeHVelocityGround(float delta)
	{
		return ComputeHVelocity(delta, AccelerationFloor, DecelerationFloor);
	}
	public Vector3 ComputeHVelocityAir(float delta)
	{
		return ComputeHVelocity(delta, AccelerationAir, DecelerationAir);
	}

	// Velocity setters
	public void SetVerticalVelocity(float verticalVelocity)
	{
		Velocity = new Vector3(
			x: Velocity.X,
			y: verticalVelocity,
			z: Velocity.Z);
	}
	public void SetHorizontalVelocity(Vector2 velocity)
	{
		Velocity = new Vector3(
			x: velocity.X,
			y: Velocity.Y,
			z: velocity.Y);
	}
	
	// Tweens
	Tween CreatePositionTween(Vector3 targetLocation, float tweenTime)
	{
		var tween = GetTree().CreateTween();
		tween.SetParallel();
		tween.SetTrans(Tween.TransitionType.Cubic);
		tween.SetEase(Tween.EaseType.InOut);
		tween.TweenProperty(this, "global_position", targetLocation, tweenTime);

		return tween;
	}
	
	// Child management 
	public void RemoveChildNode(Node3D node)
	{
		RemoveChild(node);
		GetTree().GetRoot().AddChild(node);
		node.SetGlobalPosition(GlobalPosition);
	}
	public void RecoverChildNode(Node3D node)
	{
		GetTree().GetRoot().RemoveChild(node);
		AddChild(node);
		node.SetGlobalPosition(GlobalPosition);
	}
	
	///////////////////////////
	// Dash management //
	///////////////////////////
	public void DashCooldownTimeout()
	{
		_canDash = true;
	}
	public void AirborneDashCooldownTimeout()
	{
		_canDashAirborne = true;
	}
	
	public void OnInputDashPressed()
	{
		if (_aiming.Active && CanPerformEmpoweredAction())
		{
			PerformEmpoweredAction();
			_playerState.SendEvent("aimed_dash");
			_playerState.SendEvent("cancel_aim");
			return;
		}

		if (_airborne.Active)
		{
			if (!_canDashAirborne)
				return;
			_canDashAirborne = false;
		}
		
		_currentInputBufferFrames = InputBufferFrames;
		_bufferedAction = _mantling.Active ? BufferedActions.MantleDash : BufferedActions.Dash;
		_playerState.SendEvent("dash");
	}
	public void SimpleDashInDirection(Vector3 direction, float strength = -1)
	{
		if (strength < 0) strength = SimpleDashStrength;
		SetVelocity(direction * strength);
	}
	public void SimpleDash(float strength = -1)
	{
		SimpleDashInDirection(GetInputGlobalHDirection(), strength);
	}

	public void OnSimpleDashStarted()
	{
		if (!_canDash)
			return;
		_canDash = false;
		SimpleDash();
	}
	public void HandleSimpleDash(float delta)
	{
		_playerState.SendEvent("dash_finished");
	}
	
	///////////////////////////
	// On wall management //
	///////////////////////////

	public bool IsInputTowardsWall(Vector3 wallNormal)
	{
		return wallNormal.Dot(GetInputGlobalHDirection()) < -0.5;
	}
	public void HandleOnWall(float delta)
	{
		if (IsTryingToMantle()) _playerState.SendEvent("mantle");
	}
	public void OnWallDetected()
	{
		if (!_onWall.Active)
			return;
		
		var newWallNormal = WallHugSystem.WallHugNormal.UnwrapOr(Vector3.Up);
		if (newWallNormal.AngleTo(_wallHugStartNormal) > Mathf.Pi/4) return;
		_wallHugStartNormal = newWallNormal;
	}
	public void OnWallStarted()
	{
		if (!WallHugSystem.IsWallHugging())
			return;
		
		_wallHugStartNormal = WallHugSystem.WallHugNormal.UnwrapOr(Vector3.Up);
		_currentWallContactPoint = WallHugSystem.WallHugLocation.UnwrapOr(Vector3.Zero);
		_wallHugStartLocation = _currentWallContactPoint + _wallHugStartNormal * _playerRadius;
		_wallHugStartProjectedVelocity = Velocity.Slide(_wallHugStartNormal);
	}
	public void OnWallStopped()
	{
	}
	public void OnLeaveWallFromRun()
	{
		SimpleDashInDirection(Velocity.Normalized());
	}
	public void HandleWallHugging(float delta)
	{
		_canDash = true;
		_canDashAirborne = true;
		
		WallHug(delta);
		if (isOnFloorCustom())
			_playerState.SendEvent("grounded");
		if (!WallHugSystem.IsWallHugging() || !IsInputTowardsWall(_wallHugStartNormal))
			_playerState.SendEvent("start_falling");
	}
	public void HandleWallHanging(float delta)
	{
		WallHang(delta);
	}
	public void HandleWallRunning(float delta)
	{
		_canDash = false;
		_canDashAirborne = false;
		
		// Find horizontal velocity projected on the current wall
		var hvel = new Vector3(Velocity.X, 0, Velocity.Z);
		var hvelProjected = hvel.Slide(_wallHugStartNormal);
		
		// Reorient horizontal velocity so we keep it coplanar with the wall without losing speed
		var finalHVel = hvelProjected.Normalized() * hvel.Length();
		
		// Adapt vertical speed
		var verticalSpeed = Velocity.Y - WallRunAltitudeLossSpeed * delta;
		Velocity = finalHVel + Vector3.Up*verticalSpeed;
		Velocity *= 0.999f;

		_currentWallContactPoint = WallHugSystem.WallHugLocation.UnwrapOr(Vector3.Zero);
		
		if (isOnFloorCustom())
			_playerState.SendEvent("grounded");
		if (!WallHugSystem.IsWallHugging())
			_playerState.SendEvent("start_falling");
	}
	public void WallHug(float delta)
	{
		var hvel = ComputeHVelocity(delta, WallHugHorizontalDeceleration, WallHugHorizontalDeceleration);
		var hvelProjected = hvel.Slide(_wallHugStartNormal);
		var vvel = Velocity.Y - (CalculateGravityForce() * delta / WallHugGravityLesseningFactor);
		vvel = Math.Abs(vvel) > WallHugDownwardMaxSpeed ? -WallHugDownwardMaxSpeed : vvel;
		Velocity = hvelProjected + vvel*Vector3.Up;
	}
	public void WallHang(float delta)
	{
		Velocity = Vector3.Zero;
		GlobalPosition = _wallHugStartLocation;
	}
	public bool IsFacingWall()
	{
		return _wallHugStartNormal.Dot(GetGlobalForwardFacingVector()) < -0.5f;
	}
	
	///////////////////////////
	// Jump management //
	///////////////////////////
	public void StartCoyoteTime()
	{
		GetTree().CreateTimer(CoyoteTime).Timeout += CoyoteExpired;
	}
	public void CoyoteExpired()
	{
		_playerState.SendEvent("coyote_expired");
	}
	
	public void OnInputJumpStarted()
	{
		_currentInputBufferFrames = InputBufferFrames;
		_bufferedAction = _mantling.Active ? BufferedActions.MantleJump : BufferedActions.Jump;
		_isJumpInputPressed = true;
		
		PerformJump();
	}
	public void OnInputJumpOngoing()
	{
	}
	public void OnInputJumpEnded()
	{
		_isJumpInputPressed = false;
		_playerState.SendEvent("jump_ended");
	}

	public void PerformJump()
	{
		if (MantleSystem.IsMantlePossible)
		{
			_playerState.SendEvent("mantle");
			return;
		}
		
		_playerState.SendEvent("jump");
	}

	public void OnJumpStarted(float verticalVelocity)
	{
		_framesSinceJumpAtApex = 0;
		SetVerticalVelocity(verticalVelocity);
	}
	public void OnSimpleJumpStarted()
	{
		OnJumpStarted(SimpleJumpStartVelocity);
	}
	public void OnDoubleJumpStarted()
	{
		_canDash = true;
		// _canDashAirborne = true;
		OnJumpStarted(DoubleJumpStartVelocity);
	}
	
	public void HandleJump(float delta, float gravityFactor, int hangFrames)
	{
		if (IsTryingToMantle()) _playerState.SendEvent("mantle");
		
		// Update horizontal velocity
		var horizontalVelocity = ComputeHVelocityAir(delta);
		Velocity = new Vector3(horizontalVelocity.X, Velocity.Y, horizontalVelocity.Z);
		
		// Hang time at the top of the jump
		if (Velocity.Y <= Mathf.Epsilon)
		{
			_framesSinceJumpAtApex++;
			SetVerticalVelocity(0);
		}
		
		// Cancel gravity on jump apex
		var gravity = CalculateGravityForce() / gravityFactor;
		var isAtApex = _framesSinceJumpAtApex > 0;
		if (isAtApex)
		{
			gravity = 0;
		}
		// Update velocity accordingly
		var newVerticalSpeed = Velocity.Y - gravity * delta;
		SetVerticalVelocity(newVerticalSpeed);
		if (IsHeadTouchingCeiling())
		{
			SetVerticalVelocity(Velocity.Y - 2.0f);
		}
		
		// Move back to Airborne state when starting to go down again or if input isn't held anymore (buffered jump) 
		if (_framesSinceJumpAtApex > hangFrames || !_isJumpInputPressed)
			_playerState.SendEvent("jump_ended");
	}
	public void HandleSimpleJump(float delta)
	{
		HandleJump(delta, SimpleJumpGravityLesseningFactor, SimpleJumpHangTimeInFrames);
	}
	public void HandleDoubleJump(float delta)
	{
		HandleJump(delta, DoubleJumpGravityLesseningFactor, DoubleJumpHangTimeInFrames);
	}
	
	// Jump and wall stuff
	public void ComputeJumpFromWallHSpeed(float jumpStrength)
	{
		var wallNormal = WallHugSystem.WallHugNormal.UnwrapOr(Vector3.Up);
		var jumpVector = wallNormal * jumpStrength;
		
		var currentHorizontalVelocity = new Vector2(Velocity.X, Velocity.Z);
		var wallJumpHorizontalVelocity = new Vector2(jumpVector.X, jumpVector.Z);
		
		SetHorizontalVelocity(currentHorizontalVelocity + wallJumpHorizontalVelocity);
	}
	public void OnJumpFromWall()
	{
		if (!IsFacingWall() || (!_isWallJumpAvailable && IsFacingWall()))
		{
			ComputeJumpFromWallHSpeed(WallJumpStartVelocity);
		}
		// Remove the ability to dash straight away so you cannot scale up the wall
		_canDashAirborne = false;
		_airborneDashCooldownTimer.Start();
		_isWallJumpAvailable = false;
	}
	
	///////////////////////////
	// Mantle management //
	///////////////////////////
	public void OnMantleStarted()
	{
		HeadSystem.OnMantle();

		_mantlePath = MantlePath.Instantiate() as Path;
		if (_mantlePath == null)
		{
			GD.PrintErr("Failed to instantiate MantlePath");
			return;
		}
		
		_velocityOnMantleStarted = Velocity;

		var transform = _customMantle ? _customMantleStartTransform : MantleSystem.GlobalTransform;
		var curve = _customMantle ? _customMantleCurve : MantleSystem.MantleCurve;
		GetTree().GetRoot().AddChild(_mantlePath);
		_mantlePath.Setup(transform, curve);
		_mantleStartPosition = GlobalPosition;

		var curveLength = curve.GetBakedLength();
		var tween = GetTree().CreateTween();
		tween.SetTrans(Tween.TransitionType.Linear);
		tween.SetEase(Tween.EaseType.In);
		tween.TweenProperty(_mantlePath.PathFollow, "progress_ratio", 1, MantleTime*curveLength);
		tween.Finished += MantleFinished;
	}
	public void HandleMantling(float delta)
	{
		GlobalPosition = _mantlePath.Target.GlobalPosition;
	}
	public void MantleFinished()
	{
		_mantlePath.Teardown();
		
		// SetVelocity(_finalCurveDirection.Normalized() * _speedOverCurve);
		
		var isThereMovementInput = GetMoveInput().Length() > 0;
		if (isThereMovementInput)
		{
			// If there's a movement input on Mantle, we dash in the direction the mantle ended with
			var positionDifference = GlobalPosition - _mantleStartPosition;
			var directionHorizontal = new Vector3(positionDifference.X, 0, positionDifference.Z);
			// SimpleDashInDirection(directionHorizontal.Normalized());
			SetVelocity(directionHorizontal.Normalized() * WalkSpeed);
		}

		_customMantle = false;
		_playerState.SendEvent("grounded");
	}
	
	///////////////////////////
	// Slide management //
	///////////////////////////
	public void OnInputSlideStarted()
	{
		_playerState.SendEvent("slide");
	}
	public void OnInputSlideEnded()
	{
		_playerState.SendEvent("slide_released");
	}

	public void SlideStarted()
	{
		_targetSpeed = Velocity.Length();
	}
	public void SlideOnGround(float delta)
	{
		var horizontalVelocity = ComputeHVelocity(delta, AccelerationGroundSlide, DecelerationGroundSlide);
		Velocity = new Vector3(horizontalVelocity.X, Velocity.Y, horizontalVelocity.Z);
	}
	public void HandleGroundSlide(float delta)
	{
		SlideOnGround(delta);
		if (MantleSystem.IsMantlePossible && IsPlayerInputtingForward()) _playerState.SendEvent("mantle");
		
		if (!isOnFloorCustom())
			_playerState.SendEvent("start_falling");
	}
	public void GlideInAir(float delta)
	{
		var horizontalVelocity = ComputeHVelocity(delta, AccelerationAirGlide, DecelerationAirGlide);

		float verticalSpeed;
		if (Velocity.Y < -AirGlideVSpeed) verticalSpeed = -AirGlideVSpeed;
		else if (Velocity.Y > 0) verticalSpeed = ComputeVerticalSpeedGravity(delta);
		else verticalSpeed = Mathf.Lerp(Velocity.Y, -AirGlideVSpeed, delta);
		
		Velocity = new Vector3(horizontalVelocity.X, verticalSpeed, horizontalVelocity.Z);
	}
	public void HandleAirGlide(float delta)
	{
		GlideInAir(delta);
		if (MantleSystem.IsMantlePossible && IsPlayerInputtingForward()) _playerState.SendEvent("mantle");
		
		if (isOnFloorCustom())
			_playerState.SendEvent("grounded");
	}
	public void SlideEnded()
	{
		_targetSpeed = WalkSpeed;
	}
	
	///////////////////////////
	// Slam Management ///////
	///////////////////////////
	public void OnInputSlamPressed()
	{
		_playerState.SendEvent("slam");
	}

	public void SlamStarted()
	{
		SetHorizontalVelocity(Vector2.Zero);
		SetVerticalVelocity(-SlamSpeed);
	}
	public void HandleSlam(float delta)
	{
		if (isOnFloorCustom()) _playerState.SendEvent("grounded");
	}
	public void SlamEnded()
	{
	}
	
	///////////////////////////
	// Empowerement management //
	///////////////////////////
	public void PowerRecharging(float delta)
	{
		var progress = (float) (_powerCooldownTimer.TimeLeft / _powerCooldownTimer.WaitTime);
		PowerCooldownIndicator.SetCustomMinimumSize(new Vector2(100 * progress, 10));
	}
	public void StartPowerCooldown()
	{
		_powerCooldownTimer.Start();
		PowerCooldownIndicator.Visible = true;
	}
	public void StopPowerCooldown()
	{
		_powerCooldownTimer.Stop();
		PowerCooldownIndicator.Visible = false;
	}
	public void PowerCooldownExpired()
	{
		EmpoweredActionsLeft += 1;
		var eventToSend = EmpoweredActionsLeft == MaxNumberOfEmpoweredActions ? "fully_charged" : "recharge";
		_playerState.SendEvent(eventToSend);
	}
	
	public bool CanPerformEmpoweredAction()
	{
		return EmpoweredActionsLeft > 0 && TutorialDone;
	}
	public void PerformEmpoweredAction()
	{
		_isWallJumpAvailable = true;
		EmpoweredActionsLeft--;
		_playerState.SendEvent(EmpoweredActionsLeft <= 0 ? "expired" : "power_used");
	}
	
	///////////////////////////
	// Aim Management ///////
	///////////////////////////
	public void OnInputAimPressed()
	{
		_playerState.SendEvent("aim_pressed");
	}
	public void OnInputAimDown()
	{
		_playerState.SendEvent("aim_down");
	}
	public void OnInputAimReleased()
	{
		_playerState.SendEvent("aim_released");
	}
	public void OnInputAimCanceled()
	{
		_playerState.SendEvent("cancel");
		DashSystem.StopPreparingDash();
	}	
	
	public void ReduceTimeScaleWhileAiming()
	{
		Engine.SetTimeScale(TimeScaleAimInAir);
		_timeScaleAimInAirTimer.Start();
	}
	public void ResetTimeScale()
	{
		Engine.SetTimeScale(1);
	}
	
	public void OnAimingEntered()
	{
		if (!CanPerformEmpoweredAction())
			return;
		
		DashSystem.StartPreparingDash();
		DashIndicatorMesh.Visible = true;
		if (!isOnFloorCustom())
			ReduceTimeScaleWhileAiming();
	}
	public void HandleAiming(float delta)
	{
		RotateWeaponWithPlayer();
		
		DashIndicatorMeshCylinder.Height = DashSystem.PlannedLocation.DistanceTo(GlobalPosition);
		DashIndicatorNode.LookAt(DashSystem.PlannedLocation);
		
		if (CanPerformEmpoweredAction())
			DashSystem.PrepareDash();
	}
	public void OnAimingExited()
	{
		DashSystem.StopPreparingDash();
		
		DashIndicatorMesh.Visible = false;
	}
	
	///////////////////////////
	// Hit Management ///////
	///////////////////////////
	public void OnInputHitPressed()
	{
		if (_aiming.Active)
		{
			ThrowWeapon();
		}
	}
	
	///////////////////////////
	// Parry Management ///////
	///////////////////////////
	public void OnInputParryPressed()
	{
		if (WeaponSystem.FlyingState.Active)
		{
			DashToFlyingWeapon();
			return;
		}

		if (WeaponSystem.PlantedState.Active)
		{
			DashToPlantedWeapon();
		}
	}
	
	///////////////////////////
	// Powered dash ///////
	///////////////////////////
	public void OnAimedDashStarted()
	{
		// Adjusting for player height, where the middle of the capsule should get to the dash location instead of the 
		// feet of the capsule
		var correction = DashSystem.CollisionNormal == Vector3.Down ? _playerHeight : DashSystem.DashCastRadius;
		var correctedLocation = DashSystem.PlannedLocation + Vector3.Down * correction;

		_preDashVelocity = Velocity;
		_dashDirection = (correctedLocation - GlobalPosition).Normalized();

		var dashTween = CreatePositionTween(correctedLocation, AimedDashTime);
		// dashTween.TweenMethod(Callable.From<float>(AimedDashTweenOngoing), 0.0f, 1.0f, AimedDashTime);
		dashTween.Finished += AimedDashTweenEnded;
		
		_customMantle = DashSystem.ShouldMantle;
		_customMantleCurve = DashSystem.MantleSystem.MantleCurve;
		_customMantleStartTransform = DashSystem.MantleSystem.GlobalTransform;
	}
	public void AimedDashTweenEnded()
	{
		_playerState.SendEvent("dash_finished");
	}
	public void OnAimedDashFinished()
	{
		var postDashVelocity = _preDashVelocity.Length() > PostDashSpeed ? PostDashSpeed : _preDashVelocity.Length();
		Velocity = _dashDirection * postDashVelocity;
		if (_customMantle) _playerState.SendEvent("mantle");
	}
	
	// Weapon dashing
	public void ThrowWeapon()
	{
		_playerState.SendEvent("cancel_aim");
		RemoveChildNode(WeaponRoot);

		var weaponTargetLocation = DashSystem.HasHit ? DashSystem.CollisionPoint : DashSystem.PlannedLocation;
		WeaponSystem.ThrowWeapon(
			weaponTargetLocation,
			DashSystem.HasHit,
			DashSystem.CollisionPoint,
			DashSystem.CollisionNormal);
	}
	public void RecoverWeapon()
	{
		RecoverChildNode(WeaponRoot);
		WeaponSystem.ResetWeapon();
	}
	
	public void DashToFlyingWeapon()
	{
		_playerState.SendEvent("cancel_aim");
		_playerState.SendEvent("weapon_dash");
		PerformEmpoweredAction();
	
		DashSystem.ShouldMantle = false;
		_dashDirection = (WeaponSystem.GlobalPosition - GlobalPosition).Normalized();
		
		var dashTween = CreatePositionTween(WeaponSystem.GlobalPosition, AimedDashTime);
		dashTween.Finished += DashToFlyingWeaponTweenEnded;
	}
	public void DashToFlyingWeaponTweenEnded()
	{
		RecoverWeapon();
		
		var vel = _dashDirection * PostDashSpeed;
		SetVelocity(vel);
		_playerState.SendEvent("dash_finished");
	}

	public void DashToPlantedWeapon()
	{
		_playerState.SendEvent("cancel_aim");
		_playerState.SendEvent("weapon_dash");
		PerformEmpoweredAction();
		
		DashSystem.ShouldMantle = false;
		var dashLocation = WeaponSystem.PlantLocation;
		if (WeaponSystem.IsPlantedInWall())
			dashLocation += WeaponSystem.PlantNormal * _playerRadius;
		if (WeaponSystem.IsPlantedUnderPlatform())
			dashLocation += Vector3.Down * _playerHeight;
		
		_wallHugStartNormal = WeaponSystem.PlantNormal;
		_currentWallContactPoint = WeaponSystem.PlantLocation;
		_wallHugStartLocation = dashLocation;
		_wallHugStartProjectedVelocity = Velocity.Slide(_wallHugStartNormal);
		
		var dashTween = CreatePositionTween(dashLocation, AimedDashTime);
		dashTween.Finished += DashToPlantedWeaponTweenEnded;
	}
	public void DashToPlantedWeaponTweenEnded()
	{
		// Store the weapon state before resetting it
		var isPlantedOnWall = WeaponSystem.IsPlantedInWall();
		var isPlantedUnderPlatform = WeaponSystem.IsPlantedUnderPlatform();
		var shouldDashToHanging = isPlantedOnWall || isPlantedUnderPlatform;
		
		RecoverWeapon();
		
		var resultingEvent = shouldDashToHanging ? "dash_to_planted" : "dash_finished";
		_playerState.SendEvent(resultingEvent);
	}
	
	///////////////////////////
	// Processes //////////////
	///////////////////////////
	public override void _PhysicsProcess(double delta)
	{
		if (_currentInputBufferFrames > 0) _currentInputBufferFrames -= 1;
		
		LookAround(delta);
		CameraModifications((float) delta);
		MoveSlideAndHandleStairs((float) delta);
		MantleSystem.ProcessMantle(_grounded.Active);
		if (WeaponSystem.InHandState.Active)
			RotateWeaponWithPlayer();
		
		if (WeaponSystem.InHandState.Active && !_aiming.Active && TutorialDone)
		{
			DashIndicatorMesh.Visible = false;
		}
		
		if (!WeaponSystem.InHandState.Active && TutorialDone)
		{
			DashIndicatorMesh.Visible = true;
			
			DashIndicatorMeshCylinder.Height = WeaponSystem.GlobalPosition.DistanceTo(GlobalPosition) * 2;
			DashIndicatorNode.LookAt(WeaponSystem.GlobalPosition);
		}
	}


}