BITFALL/Assets/Artists/Scripts/Player/PlayerAnimationController/PlayerMotionBasedAnimationStates.cs

using System;
using System.Collections;
using System.Collections.Generic;
using Animancer;
using BITFALL.Player.Movement;
using BITKit;
using BITKit.Entities;
using BITKit.StateMachine;
using Cysharp.Threading.Tasks;
using UnityEngine;

namespace BITFALL.Player.Animation.States
{
	[Serializable]
	public class Climb : PlayerAnimateStates
	{
		[SerializeField] private AnimationClip clip;
		public override void OnStateEntry(IState old)
		{
			//animationController.animator.Play("Climb");
			self.AnimancerComponent.Play(clip);
		}
		public override void OnMovementStateChanged(IEntityMovementState oldState, IEntityMovementState newState)
		{
			if (newState is IPlayerClimbState or IPlayerLinkState { LinkArea: 4 })
			{
				self.TransitionState<Climb>();
			}
			else if(Enabled)
			{
				Exit();
			}
		}
	}
	[Serializable]
	public class Vault : PlayerAnimateStates
	{
		[SerializeField] private AnimationClip vaultClip;
	 private	AnimancerState state;
	 private IPlayerVaultState _vaultState;
		public override void OnStateEntry(IState old)
		{
			base.OnStateEntry(old);
			self.AnimancerComponent.Stop();
			state =self.AnimancerComponent.Play(vaultClip);
		}

		public override void OnStateExit(IState old, IState newState)
		{
			state?.Stop();
			base.OnStateExit(old, newState);
			state = null;
		}

		public override void OnStateUpdate(float deltaTime)
		{
			base.OnStateUpdate(deltaTime);
			if (_vaultState.Phase is 1)
				_vaultState.NormalizedTime = state.NormalizedTime;
		}

		public override void OnMovementStateChanged(IEntityMovementState oldState, IEntityMovementState newState)
		{
			if (newState is IPlayerVaultState _state)
			{
				_vaultState = _state;
				self.TransitionState<Vault>();
			}
			else if(Enabled)
			{
				Exit();
			}
		}
	}
	[Serializable]
	public class Crawl:PlayerAnimateStates,IPlayerCrawlState
	{
		[SerializeField] private MixerTransition2D mixer;
		[SerializeField] private AnimationClip entryClip;
		[SerializeField] private AnimationClip clip;
		[SerializeField] private AnimationClip exitClip;
		private MixerState<Vector2> state;
		private bool entry;

		[Inject] private IEntityOverride _entityOverride;
		[Inject] private IPlayerMovement _playerMovement;
		public override async void OnStateEntry(IState old)
		{
			base.OnStateEntry(old);
			entry = false;
			await self.AnimancerComponent.Play(entryClip, 0.25f);
			if (!Enabled) return;
			entry = true;
		}
		public override async void OnStateExit(IState old, IState newState)
		{
			base.OnStateExit(old, newState);
			state = null;
			_entityOverride.AddOverride(this);
			var x = self.AnimancerComponent.Layers[1].Play(exitClip);
			await x;
			_entityOverride.RemoveOverride(this);
			x.Stop();
		}
		public override void OnStateUpdate(float deltaTime)
		{
			base.OnStateUpdate(deltaTime);
			if (!entry) return;
			if (self._movement.Velocity.magnitude >= 0.1f && ((Vector2)_playerMovement.InputVector).magnitude>0)
			{
				state = self.AnimancerComponent.Play(mixer,0.2f).As<MixerState<Vector2>>();
				var velocity = self._movement.LocomotionBasedVelocity;
				state.Parameter = new Vector2(velocity.x,velocity.z >=0 ?  Mathf.Max( velocity.z,Mathf.Abs(velocity.x)) : velocity.z);
			}
			else
			{
				self.AnimancerComponent.Play(clip,0.4f);
			}
		}

		public override void OnMovementStateChanged(IEntityMovementState oldState, IEntityMovementState newState)
		{
			base.OnMovementStateChanged(oldState, newState);
			if(newState is IPlayerCrawlState && self.CurrentState is not Crawl)
				self.TransitionState<Crawl>();
			else if(newState is not IPlayerCrawlState && Enabled)
				Exit();
		}
	}
	[Serializable]
	public class EdgeClimb : PlayerAnimateStates
	{
		[SerializeField] private AnimationClip edgeClimbClip;
		[SerializeField] private AnimationClip idleClip;
		[SerializeField] private AnimationClip climbUpClip;
		[SerializeField] private LinearMixerTransition moveMixer;
		[SerializeField] private AnimationClip leftClip;
		[SerializeField] private AnimationClip rightClip;
		private int _phase;
		private AnimancerState state;

		[Inject] private IPlayerMovement _playerMovement;
		public override void OnStateEntry(IState old)
		{
			base.OnStateEntry(old);
			_phase = -1;
		}
		public override void OnStateExit(IState old, IState newState)
		{
			base.OnStateExit(old, newState);
			//state.Stop();
			state = null;
		}
		public override async void OnStateUpdate(float deltaTime)
		{
			if(self._movement.CurrentState is not IPlayerEdgeClimbState edgeClimbState) return;

			switch (edgeClimbState.Phase)
			{
				case 5:
					if (_playerMovement.InputVector.x != 0)
					{
						 var mixState =self.AnimancerComponent.Play(moveMixer,0.2f).As<MixerState<float>>();
						 mixState.Parameter = _playerMovement.InputVector.x;
					}
					else
					{
						self.AnimancerComponent.Play(idleClip,0.2f);
					}
					break;
			}
			
			if(_phase==edgeClimbState.Phase) return;
			_phase = edgeClimbState.Phase;
			switch (edgeClimbState.Phase)
			{
				case 0:
					state?.Stop();
					state = self.AnimancerComponent.Play(edgeClimbClip,0.2f);
					break;
				case 5:
					self.AnimancerComponent.Play(idleClip,0.2f);
					break;
				case 8:
					state?.Stop();
					state = self.AnimancerComponent.Play(climbUpClip,0.2f);
					await state;
					if (!Enabled) return;
					edgeClimbState.ManualCancel();
					break;
			}
		}

		public override void OnMovementStateChanged(IEntityMovementState oldState, IEntityMovementState newState)
		{
			if (newState is IPlayerEdgeClimbState)
			{
				self.TransitionState<EdgeClimb>();
			}
			else if(Enabled)
			{
				Exit();
			}
		}
	}

	[Serializable]
	public sealed class Dodge: PlayerAnimateStates
	{
		[SerializeField] private MixerTransition2D mixer;
		[Inject] private IPlayerMovement _playerMovement;
		
		public override async void OnStateEntry(IState old)
		{
			base.OnStateEntry(old);
			var state =self.AnimancerComponent.Play(mixer).As<MixerState<Vector2>>();
			state.Parameter = _playerMovement.InputVector;
			await state;
			if (!Enabled) return;
			if (self._movement.CurrentState is IPlayerDodgeState dodgeState)
			{
				dodgeState.ManualCancel();
			}
		}
		public override void OnMovementStateChanged(IEntityMovementState oldState, IEntityMovementState newState)
		{
			if (newState is IPlayerDodgeState)
			{
				self.TransitionState<Dodge>();
			}
			else if(Enabled)
			{
				Exit();
			}
		}
	}
}