Technical Breakdown

                    
public class GameActorUnit : GameActor<GameActorUnitState>
{
    public UnitCardDataSO unitCardData; // Unit's data (e.g., damage, health)
    public Animator animator;           // Animator for controlling animations
    public SkinnedMeshRenderer skinnedMeshRenderer; // Mesh renderer for visuals

    // Override the base class's Damage property to return unit's damage
    public override int Damage
    {
        get { return unitCardData.unitDamage; }
        set { } // Damage is read-only
    }

    private void Awake()
    {
        Health = unitCardData.unitHealth;
        Damage = unitCardData.unitDamage;
    }

    public override void Alive()
    {
        base.Alive();
        Health = unitCardData.unitHealth;
    }
}

// Enum defining possible states for a GameActorUnit
public enum GameActorUnitState
{
    stored,
    hovering,
    spawning,
    idle,
    moving,
    combat,
    dying
}       
                

                    
[RequireComponent(typeof(GameActorUnit))]
public class GameActorUnitBehaviour : MonoBehaviour
{
    [SerializeField] GameActorDetection gameActorDetection;

    GameActorUnit gameActorUnit;
    public event Action<IDamageable> EnemyFoundEvent;

    bool inCombat = false;

    private void Awake()
    {
        gameActorUnit = GetComponent<GameActorUnit>();
        gameActorUnit.StateChangeEvent += StateChanged;
        gameActorDetection.EnemyTargetsChangedEvent += BehaviourLogic;
        gameActorUnit.DeathEvent += Dying;
    }

    private void Dying(IDamageable damageable)
    {
        gameActorUnit.ChangeState(GameActorUnitState.dying);
    }

    private void StateChanged(GameActorUnitState _gameActorUnitState)
    {
        // Activate detection based on state
        if (_gameActorUnitState != GameActorUnitState.stored && _gameActorUnitState != GameActorUnitState.hovering)
        {
            gameActorDetection.gameObject.SetActive(true);
        }
        else
        {
            gameActorDetection.gameObject.SetActive(false);
        }

        if (_gameActorUnitState == GameActorUnitState.idle)
        {
            BehaviourLogic();
        }
    }

    private void BehaviourLogic()
    {
        // No enemies detected, move the unit
        if (gameActorDetection.targetableEnemies.Count == 0)
        {
            gameActorUnit.ChangeState(GameActorUnitState.moving);
            gameActorUnit.animator.SetBool("isMoving", true);
            return;
        }

        // Engage combat if no ongoing combat
        if (!inCombat)
        {
            EnemyFoundEvent?.Invoke(gameActorDetection.targetableEnemies[0]);
            gameActorUnit.ChangeState(GameActorUnitState.combat);
            gameActorUnit.animator.SetBool("isMoving", false);
        }
    }
}  
                

                    
[RequireComponent(typeof(GameActorUnit))]
public class GameActorUnitStored : MonoBehaviour
{
    GameActorUnit gameActorUnit;
    Vector3 startPosition;

    private void Awake()
    {
        gameActorUnit = GetComponent<GameActorUnit>();
        gameActorUnit.StateChangeEvent += StateChanged;
        startPosition = transform.position;
    }

    private void StateChanged(GameActorUnitState _gameActorUnitState)
    {
        // Store the unit if the state is 'stored'
        if (_gameActorUnitState == GameActorUnitState.stored)
            StoreUnit();
    }

    private void StoreUnit()
    {
        // Reset the unit's position and trigger the stored animation
        transform.position = startPosition;
        gameActorUnit.animator.SetTrigger("isStored");
    }
}                    
                

                    
[RequireComponent(typeof(GameActorUnit))]
public class GameActorUnitHovering : MonoBehaviour
{
    GameActorUnit gameActorUnit;

    private void Awake()
    {
        gameActorUnit = GetComponent<GameActorUnit>();
        gameActorUnit.StateChangeEvent += Hovering;
    }

    private void Hovering(GameActorUnitState _gameActorUnitState)
    {
        // Trigger hovering animation if the unit's state is 'hovering'
        if (_gameActorUnitState == GameActorUnitState.hovering)
            HoverUnit();
    }

    private void HoverUnit()
    {
        // Play the hovering animation
        gameActorUnit.animator.SetTrigger("isHovering");
    }
}                    
                

                    
[RequireComponent(typeof(GameActorUnit))]
public class GameActorUnitSpawning : MonoBehaviour
{
    GameActorUnit gameActorUnit;

    [SerializeField] GameObject modelObject;
    [SerializeField] Vector3 fallingScale;

    [Space(20)]
    [SerializeField] UnityEvent spawnEvent;
    [SerializeField] UnityEvent landEvent;

    private void Awake()
    {
        // Get reference to Game Actor Unit and bind the StateChangeEvent
        gameActorUnit = GetComponent<GameActorUnit>();
        gameActorUnit.StateChangeEvent += StateChanged;
    }

    private void StateChanged(GameActorUnitState _gameActorUnitState)
    {
        // If the unit is spawning, start the spawn process
        if (_gameActorUnitState == GameActorUnitState.spawning)
            SpawnUnit();
    }

    private void SpawnUnit()
    {
        // Trigger spawning animation and set the unit as alive
        gameActorUnit.animator.SetTrigger("isSpawning");
        gameActorUnit.Alive();

        // Drop the unit into the scene
        DropUnit();
    }

    private void DropUnit()
    {
        spawnEvent?.Invoke();

        // Calculate and tween the unit's position to ground level
        Vector3 targetPosition = gameActorUnit.transform.position;
        targetPosition.y = 0;
        LeanTween.move(gameObject, targetPosition, 0.25f).setEaseInExpo();

        // Scale the unit and animate it dropping to the ground
        LeanTween.scale(modelObject.gameObject, new Vector3(0.5f, 2f, 0.5f), 0.25f)
                 .setEaseInCubic()
                 .setOnComplete(Splat);
    }

    private void Splat()
    {
        // Animate the unit's scale back to normal with an elastic ease
        LeanTween.scale(modelObject.gameObject, Vector3.one, 0.25f).setEaseOutElastic();

        // Set the unit to idle state after splat animation
        Invoke("SetStateIdle", 0.5f);
    }

    private void SetStateIdle()
    {
        // Set the unit's state to idle
        gameActorUnit.ChangeState(GameActorUnitState.idle);
    }
}                    
                

                    
[RequireComponent(typeof(GameActorUnit))]
public class GameActorUnitMovement : MonoBehaviour
{
    GameActorUnit gameActorUnit;

    float moveSpeed;

    private void Awake()
    {
        gameActorUnit = GetComponent<GameActorUnit>();

        gameActorUnit.StateChangeEvent += StateChanged;

        moveSpeed = gameActorUnit.unitCardData.unitSpeed;
    }

    public void StateChanged(GameActorUnitState _gameActorUnitState)
    {

        if (_gameActorUnitState == GameActorUnitState.moving)
        {
            StartCoroutine(MovementSequence());

            return;
        }
        else
        {
            StopAllCoroutines();
        }   
    }

    IEnumerator MovementSequence()
    {
        gameActorUnit.animator.SetBool("isMoving", true);


        while (gameObject.activeSelf)
        {
            Vector3 position = transform.position;

            position.z += transform.forward.z * moveSpeed * Time.deltaTime;

            transform.position = position;

            yield return null;
        }

        

        yield return null;
    }
}                    
                

                    
[RequireComponent(typeof(GameActorUnit), typeof(GameActorUnitBehaviour))]
public class GameActorUnitCombat : MonoBehaviour
{
    GameActorUnit gameActorUnit;
    GameActorUnitBehaviour gameActorUnitBehaviour;
    IDamageable targetEnemy;

    private void Awake()
    {
        gameActorUnit = GetComponent<GameActorUnit>();
        gameActorUnitBehaviour = GetComponent<GameActorUnitBehaviour>();

        gameActorUnit.StateChangeEvent += StateChanged;
        gameActorUnitBehaviour.EnemyFoundEvent += AssignEnemy;
    }

    private void AssignEnemy(IDamageable _targetEnemy)
    {
        targetEnemy = _targetEnemy;
    }

    private void StateChanged(GameActorUnitState _gameActorUnitState)
    {
        // Start attacking when the unit enters combat state
        if (_gameActorUnitState == GameActorUnitState.combat)
        {
            StartCoroutine(AttackEnemySequence(targetEnemy));
        }
        else
        {
            StopAllCoroutines(); // Stop attacking when not in combat
        }
    }

    IEnumerator AttackEnemySequence(IDamageable _targetEnemy)
    {
        while (!targetEnemy.IsDead)
        {
            yield return new WaitForSeconds(1f);

            // Trigger attack animation
            gameActorUnit.animator.SetTrigger("isAttacking");

            yield return new WaitForSeconds(0.2f);

            // Wait for the current attack animation to complete
            yield return new WaitForSeconds(gameActorUnit.animator.GetCurrentAnimatorClipInfo(0)[0].clip.length);
        }

        targetEnemy = null;
        yield return null;
    }

    public void DamageEnemy()
    {
        // Apply damage to the target if it's not dead
        if (!targetEnemy.IsDead) gameActorUnit.AttackTarget(targetEnemy);
    }
}                  
                

                    
[RequireComponent(typeof(GameActorUnit))]
public class GameActorUnitDeath : MonoBehaviour
{
    GameActorUnit gameActorUnit;

    [SerializeField] UnityEvent deathEvent;

    private void Awake()
    {
        gameActorUnit = GetComponent<GameActorUnit>();
        gameActorUnit.StateChangeEvent += StateChanged;
    }

    private void StateChanged(GameActorUnitState _gameActorUnitState)
    {
        // Trigger dying process when the unit's state is 'dying'
        if (_gameActorUnitState == GameActorUnitState.dying)
            DyingUnit();
    }

    private void DyingUnit()
    {
        // Move the unit downward and invoke the death event
        Vector3 targetPosition = transform.position;
        targetPosition.y -= 4;
        LeanTween.move(gameObject, targetPosition, 0.25f).setOnComplete(StoreUnit);

        deathEvent?.Invoke();
    }

    private void StoreUnit()
    {
        // Change the unit's state to 'stored' and deposit it
        gameActorUnit.ChangeState(GameActorUnitState.stored);
        SpawnManager.instance.DepositUnit(gameActorUnit);
    }
}