LunarInfantry/Assets/Scripts/PlayerEntityMovement.cs

using System;
using System.Collections.Generic;
using UnityEngine;

public class PlayerEntityMovement : MonoBehaviour
{
    //unsure if this should also move enemies but who knows!
    #region Statication

    public static PlayerEntityMovement instance;

    private void Awake()
    {
        if (instance != null && instance != this)
        {
            Destroy(gameObject);
            return;
        }
        instance = this;
    }

    #endregion
    [SerializeField] private Grid gameplayGrid;
    
    public Entity selectedEntity;
    public GameObject templateObject;
    public bool isMoving;

    private Vector3 mouseWorldPos;
    private Vector3 mouseGridPos;
    private Camera cam;

    private float debounceTime;
    [SerializeField] private float debounceDuration;
    
    private List<TileObject> currentMovableTiles = new();
    private Queue<TileObject> frontier = new();
    private HashSet<TileObject> visited = new();
    private Dictionary<TileObject, TileObject> currentPaths = new();
    public List<TileObject> pathRequested;
    private TileObject requestedTile;

    private void Start()
    {
        cam = Camera.main;
    }

    private void Update()
    {
        mouseWorldPos = cam.ScreenToWorldPoint(Input.mousePosition);
        mouseGridPos = gameplayGrid.GetCellCenterWorld(gameplayGrid.WorldToCell(mouseWorldPos));
        if (debounceTime > 0)
        {
            debounceTime -= Time.deltaTime;
        }
        if (isMoving)
        {
            if (Input.GetMouseButton(1))
            {
                Deselect();
            }
            TileObject newTile = GridManager.instance.GetTile(mouseGridPos);
            if (requestedTile != newTile)
            {
                requestedTile = newTile;
                foreach (TileObject tile in pathRequested)
                {
                    tile.sprite.color = new Color(137,137,137);
                }
                PathfindToTarget();
            }
            templateObject.transform.position = mouseGridPos;
            if (Input.GetMouseButtonDown(0) && debounceTime <= 0 && SelectLocation())
            {
                isMoving = false;
            }
        }
    }

    public void SelectEntity(Entity entitySelected)
    {
        selectedEntity = entitySelected;
        isMoving = true;
        debounceTime = debounceDuration;
        UncolorGrid();
        frontier.Clear();
        visited.Clear();
        currentPaths.Clear();
        pathRequested.Clear();
        GetAllTiles();
        GetTilesInRange();
        CreateTemplate();
    }

    private void UncolorGrid()
    {
        foreach (TileObject tileObject in currentMovableTiles)
        {
            tileObject.sprite.color = new Color(137,137,137);
        }
    }

    private void GetAllTiles()
    {
        frontier.Enqueue(selectedEntity.currentTile);
        while (frontier.Count > 0)
        {
            TileObject currentTile = frontier.Dequeue();
            foreach (TileObject neighboringTiles in currentTile.neighbors)
            {
                if (!visited.Contains(neighboringTiles))
                {
                    visited.Add(neighboringTiles);
                    frontier.Enqueue(neighboringTiles);
                    currentPaths.TryAdd(neighboringTiles, currentTile);
                }
            }
        }
    }

    private void PathfindToTarget()
    {
        pathRequested.Clear();
        TileObject currentTile = requestedTile; 
        while (currentTile != selectedEntity.currentTile)
        {
            pathRequested.Add(currentTile);
            currentTile = currentPaths[currentTile];
        }
        pathRequested.Reverse();
        foreach (TileObject tile in pathRequested)
        {
            tile.sprite.color = Color.blue;
        }
    }

    private void GetTilesInRange()
    {
        foreach (TileObject neighboringTiles in selectedEntity.currentTile.neighbors)
        {
            if (!neighboringTiles.blocked && !neighboringTiles.hasUnit)
            {
                currentMovableTiles.Add(neighboringTiles);
                neighboringTiles.sprite.color = Color.green;
            }
        }
        for (int i = 0; i < selectedEntity.maxMovement - 1; i++)
        {
            foreach (TileObject tileObject in currentMovableTiles.ToArray())
            {
                foreach (TileObject neighboringTiles in tileObject.neighbors)
                {
                    if (!neighboringTiles.blocked && !neighboringTiles.hasUnit)
                    {
                        currentMovableTiles.Add(neighboringTiles);
                        neighboringTiles.sprite.color = Color.green;
                    }
                }
            }
        }
    }

    private bool SelectLocation()
    {
        if (!requestedTile || requestedTile.blocked || requestedTile.hasUnit || !currentMovableTiles.Contains(requestedTile))
        {
            return false;
        }
        selectedEntity.currentTile.hasUnit = false;
        requestedTile.hasUnit = true;
        StartCoroutine(selectedEntity.MoveToLocation(pathRequested.ToArray()));
        templateObject.SetActive(false);
        UncolorGrid();
        return true;
    }

    private void Deselect()
    {
        isMoving = false;
    }

    private void CreateTemplate()
    {
        templateObject.SetActive(true);
        templateObject.transform.position = mouseGridPos;
    }
}