Ludo-3D/Assets/Scripts/Gameplay/Player/PlayerPawn.cs

using System;
using DG.Tweening;
using UnityEngine;
using UnityEngine.Serialization;

public enum PlayerState
{
    InHome,
    InSafeZone,
    Moving,
    InFinishingPath,
    HasFinished
}

public enum PawnType
{
    User,
    Bot
}

public class PlayerPawn : MonoBehaviour
{
    [SerializeField] private PlayerState playerState;
    [SerializeField] private Animator animator;
    [SerializeField] private PlayerIndicatorCanvas playerIndicatorCanvas;

    private PlayerBase playerBase;
    private GameplayManager gameplayManager;
    
    public PlayerIndicatorCanvas PlayerIndicatorCanvas => playerIndicatorCanvas;
    
    public int PlayerId { get; private set; }
    public int StepsTaken { get; private set; }
    public int CurrentTileIndex { get; private set; }
    public bool IsBotPlayer { get; private set; }
    public bool CanSelectPlayer { get; private set; }
    public PlayerType PlayerType { get; private set; }

    public void AssignBotPlayerState(bool state)
    {
        IsBotPlayer = state;
    }

    public void SetPlayerSelectionState(bool state)
    {
        CanSelectPlayer = state;
        Debug.Log($"### SetPlayerSelectionState: {name} :: {state}, ");
        ShowPlayerSelCanvas(state);
    }

    public void MoveToTile(Vector3 startingPoint, Action onComplete, int tileIndex)
    {
        StepsTaken++;
        CurrentTileIndex = tileIndex;
        animator?.SetTrigger("Jump");

        // SFX
        SoundManager soundManager = InterfaceManager.Instance?.GetInterfaceInstance<SoundManager>();
        soundManager?.PlayGameSoundClip(SoundType.Jump);

        transform.DOMove(startingPoint, 0.6f).onComplete = () =>
        {
            animator?.ResetTrigger("Jump");

            // Rotate Player
            TilesManager tilesManager = InterfaceManager.Instance.GetInterfaceInstance<TilesManager>();
            SetGameplayManager();

            Vector3 lookDirection = Vector3.zero;

            Debug.Log($"nextIndex :: playerState: {playerState}");
            if (playerState == PlayerState.InFinishingPath)
            {
                int nextIndex = CurrentTileIndex + 1;
                int maxIndex = tilesManager.GetFinishingTileDataLength(PlayerType) - 1;

                if (nextIndex <= maxIndex)
                {
                    lookDirection = tilesManager.RetrieveFinishingTileBasedOnIndex(PlayerType, nextIndex).transform.position - transform.position;
                }
            }
            else
            {
                if (gameplayManager.IsGoingInsideFinishingPath(this, out int possibleSteps))
                {
                    lookDirection = tilesManager.RetrieveFinishingTileBasedOnIndex(PlayerType, 0).transform.position - transform.position;
                }
                else
                {
                    int nextIndex = gameplayManager.TilesManager.GetNextGeneralTileIndex(CurrentTileIndex);
                    Debug.Log($"nextIndex :: {nextIndex}, currentIndex: {CurrentTileIndex}");
                    lookDirection = tilesManager.RetrieveTileBasedOnIndex(nextIndex).transform.position - transform.position;
                }
            }

            lookDirection = lookDirection.normalized;
            lookDirection.y = 0;
            
            if (lookDirection != Vector3.zero)
            {
                // transform.LookAt(transform.position + lookDirection);
                transform.DOLookAt(transform.position + lookDirection, 0.2f);
            }
            
            Debug.Log($"Dotween:: MoveToTile.OnComplete {PlayerType}, {transform.position}: {StepsTaken != 0}");
            if (StepsTaken != 0)
                onComplete?.Invoke();
            else
            {
                transform.position = playerBase.GetBasePlacementDataPosition(PlayerId - 1).position;
            }
        };
    }

    public void MoveToCustomTilePosition(Vector3 targetPoint)
    {
        transform.DOMove(targetPoint, 1f);
    }

    // when he is defeated
    public void MoveBackToHome(Transform transformData)
    {
        Debug.Log($"MoveBackToHome");
        transform.position = transformData.position;
        transform.rotation = transformData.rotation;
        SetPlayerState(PlayerState.InHome);
        ShowPlayerSelCanvas(false);
        StepsTaken = 0;
    }

    public PlayerState GetPlayerState() => playerState;

    public void SetPlayerState(PlayerState state)
    {
        playerState = state;
    }

    private void OnMouseDown()
    {
        SetGameplayManager();
        if (gameplayManager.GameManager.CurrentGameState == GameState.IsPaused || IsBotPlayer || !CanSelectPlayer) return;

        gameplayManager.OnPawnSelected(this);
    }

    private void SetGameplayManager()
    {
        gameplayManager = gameplayManager ?? InterfaceManager.Instance.GetInterfaceInstance<GameplayManager>();
    }

    public void Init(PlayerBase playerBase, BasePlacementData basePlacementData, PlayerType playerType)
    {
        this.playerBase = playerBase;
        PlayerId = basePlacementData.playerBaseId;
        PlayerType = playerType;
        
        MoveBackToHome(basePlacementData.placementTransform);
    }

    public void ShowPlayerCountCanvas(bool show)
    {
        // add the player count canvas to the object and show from here.
        // playerIndicatorCanvas.gameObject.SetActive(show);
    }
    
    public void ShowPlayerSelCanvas(bool show)
    {
        playerIndicatorCanvas.gameObject.SetActive(show);
    }

    public void ResetData()
    {
        SetPlayerState(PlayerState.InHome);
        StepsTaken = 0;
        PlayerId = 0;
        if (playerIndicatorCanvas.gameObject.activeInHierarchy)
            ShowPlayerSelCanvas(false);
    }
}