siege-song/Data/Assets/_SiegeSong/Scripts/Entities/Motor.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine.UI;
using UnityEngine;
using SiegeSong;

namespace SiegeSong
{
    public class Motor : MonoBehaviour
    {
        public Animator Animator;
        public EquipmentManager EquipmentManager;
        public StatisticsManager Actor;

        public float BaseSpeed = 1.0f;
        public bool Swimming;
        //public float TopSpeed;
        //public float Acceleration;

        public float NonAnimatedSpeedMult = 0.1f;
        public bool Animated = true;
        public bool Sprinting = false;
        public bool Moving = false;

        public bool UsingStation;
        public Station TargetStation;

        public bool DriveForward;
        public bool DriveBackward;
        public bool DriveLeft;
        public bool DriveRight;
        public bool DriveRotateLeft;
        public bool DriveRotateRight;

        #region Animation Fields

        private string AnimationStaggerField = "Stagger";
        private string AnimationVerticalField = "InputVertical";
        private string AnimationHorizontalField = "InputHorizontal";
        private string AnimationMagnitudeField = "InputMagnitude";

        private string MountingAnimationIdVariableName = "MountType";
        private string MountingStartVariableName = "MountingStart";
        private string MountingEndVariableName = "MountingEnd";
        private string MountingActiveVariableName = "Mounted";

        #endregion


        private float sprintMagnitude = 1.5f;

        private float currentMoveSpeed;


        void Start()
        {

        }

        void Update()
        {
            Animator.enabled = Actor.Stats.Alive;
            Animated = Actor.Stats.Alive;
            if (Actor.Stats.Alive)
            {
                if (Actor.Stats.Staggered)
                {
                    Animator.SetTrigger(AnimationStaggerField);
                    Actor.Stats.Staggered = false;
                }
                if (Sprinting)
                {
                    Animator.SetFloat(AnimationMagnitudeField, 1.5f);
                    if (Actor.Stats.Stamina <= 0)
                        Sprinting = false;
                    else
                        Actor.ExpendStamina(Actor.Stats.StaminaRecoveryRate + Actor.Stats.SprintCost);
                }
            }

            if (DriveForward)
                Run(BaseSpeed / 2.0f);

            if (DriveBackward)
                Run(-BaseSpeed);

            if (DriveLeft)
                Strafe(-BaseSpeed);

            if (DriveRight)
                Strafe(BaseSpeed);

            if (DriveRotateLeft)
                Rotate(-BaseSpeed);

            if (DriveRotateRight)
                Rotate(BaseSpeed);
        }

        public void Stop()
        {
            currentMoveSpeed = 0.0f;
            Animator.SetFloat(AnimationMagnitudeField, 0);
            Moving = false;
        }

        public void Run(float value)
        {
            if (!UsingStation)
            {
                Moving = true;
                transform.Translate(Vector3.forward * value * BaseSpeed * Time.deltaTime);
                if (Animated)
                {
                    Animator.SetFloat(AnimationVerticalField, value);
                    Animator.SetFloat(AnimationMagnitudeField, BaseSpeed);
                }
            }
        }

        public void StartSprint()
        {
            if (Actor.Stats.Stamina > 0)
            {
                Sprinting = true;
            }
        }

        public void Strafe(float value, bool rotateInPlace = false)
        {
            if (!UsingStation)
            {
                Moving = true;
                if (!rotateInPlace)
                    transform.Translate(-Vector3.left * value * BaseSpeed * Time.deltaTime);
                if (Animated)
                {
                    Animator.SetFloat(AnimationHorizontalField, rotateInPlace ? 1 : value);
                    Animator.SetFloat(AnimationMagnitudeField, BaseSpeed);
                }
            }
        }

        public void Jump()
        {

        }

        public void Crouch()
        {

        }

        public void Rotate(float value)
        {
            RotateToDirection(new Vector3(transform.eulerAngles.x, transform.eulerAngles.y + value, transform.eulerAngles.z));
        }

        public void RotateToDirection(Vector3 direction, bool onlyHead = true)
        {
            if (!UsingStation)
            {
                transform.rotation = Quaternion.Euler(new Vector3(transform.eulerAngles.x, direction.y, transform.eulerAngles.z));
                if (Animated)
                {
                    Animator.SetFloat(AnimationHorizontalField, direction.x > 0 ? 1 : -1);
                    Animator.SetFloat(AnimationMagnitudeField, BaseSpeed);
                }
            }
        }

        public void StartUsingStation(Station target)
        {
            TargetStation = target;
            
            UsingStation = true;

            transform.position = target.MountingAnchor.position;
            transform.rotation = target.MountingAnchor.rotation;

            Animator.SetInteger(MountingAnimationIdVariableName, target.MountingAnimationID);
            Animator.SetTrigger(MountingStartVariableName);
            Animator.SetBool(MountingActiveVariableName, true);

            if (target.StartMounting != null)
                target.StartMounting.Invoke();
        }

        public void StopUsingStation(Station target)
        {
            UsingStation = false;

            Animator.SetInteger(MountingAnimationIdVariableName, 0);
            Animator.SetTrigger(MountingEndVariableName);
            Animator.SetBool(MountingActiveVariableName, false);

            transform.eulerAngles = new Vector3(0.0f, 0.0f, 0.0f);

            if (TargetStation.EndMounting != null)
                TargetStation.EndMounting.Invoke();
            TargetStation = null;
        }

        public void NextLeftEquip()
        {
            EquipmentManager.NextLeftEquip();
        }

        public void NextLeftTechnique()
        {
            EquipmentManager.NextLeftTechnique();
        }

        public void NextRightEquip()
        {
            EquipmentManager.NextRightEquip();
        }

        public void NextRightTechnique()
        {
            EquipmentManager.NextRightTechnique();
        }

        public void NextAbilityEquip()
        {
            EquipmentManager.NextAbilityEquip();
        }

        public void NextAbilityTechnique()
        {
            EquipmentManager.NextAbilityTechnique();
        }

        public void UseLeft()
        {
            EquipmentManager.UseLeft();
        }

        public void UseAbility()
        {
            EquipmentManager.UseAbility();
        }

        public void UseRight()
        {
            EquipmentManager.UseRight();
        }
    }
}