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

public class Generatortrihex : MonoBehaviour
{
    [Tooltip("Prefab for hexagon")]
    [SerializeField] private GameObject HexagonPrefab;
    [Tooltip("Number of hexagonal layers")]
    [SerializeField] private uint Radius;
    [Tooltip("Multiplier for hexagon side length")]
    [SerializeField] private float HexSideMultiplier = 1;

    private const float sq3 = 1.7320508075688772935274463415059f;

    private void Start()
    {
        GenerateHexagonFloor();
    }

    void GenerateHexagonFloor()
    {
        // Point of the next hexagon to be spawned
        Vector2 currentPoint = transform.position;

        // Check if the HexagonPrefab has uniform scale
        if (!Mathf.Approximately(HexagonPrefab.transform.localScale.x, HexagonPrefab.transform.localScale.y))
        {
            Debug.LogError("HexagonPrefab has non-uniform scale: cannot determine its side. Aborting");
            return;
        }

        // Array defining the movement vectors for hexagon spawning
        Vector2[] mv = {
            new Vector2(1.5f, -sq3 * 0.5f),    // Down Right
            new Vector2(0, -sq3),               // Down
            new Vector2(-1.5f, -sq3 * 0.5f),    // Down Left
            new Vector2(-1.5f, sq3 * 0.5f),     // Up Left
            new Vector2(0, sq3),                // Up
            new Vector2(1.5f, sq3 * 0.5f)       // Up Right
        };

        int lmv = mv.Length;  // Length of the movement vector array
        float HexSide = HexagonPrefab.transform.localScale.x * HexSideMultiplier;  // Calculate hexagon side length

        int hn = 1;  // Initialize hexagon number counter

        // Loop through layers of hexagons (from center to outer layers)
        for (int mult = 0; mult <= Radius; mult++)
        {
            // Loop through each movement vector
            for (int j = 0; j < lmv; j++)
            {
                // Loop to instantiate hexagons in the current layer
                for (int i = 0; i < mult; i++, hn++)
                {
                    GameObject hexagon = Instantiate(HexagonPrefab, currentPoint, Quaternion.identity, transform);
                    Tile newTile = hexagon.GetComponent<Tile>();
                    if (newTile != null)
                    {
                        newTile.Init();
                        if (mult == 0) newTile.OnFill();
                    }

                    hexagon.name = string.Format("Hex n: {0}", hn);
                    currentPoint += mv[j] * HexSide;
                }

                // Special case for the last movement vector (Up)
                if (j == 4)
                {
                    GameObject hexagon = Instantiate(HexagonPrefab, currentPoint, Quaternion.identity, transform);
                    Tile newTile = hexagon.GetComponent<Tile>();
                    if (newTile != null)
                    {
                        newTile.Init();
                    }

                    hexagon.name = string.Format("Hex n: {0}", hn);
                    currentPoint += mv[j] * HexSide;
                    hn++;

                    if (mult == Radius)
                        break;  // Finished if it's the last layer
                }
            }
        }
    }
}

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

public class Tile : MonoBehaviour
{
    [SerializeField] private SpriteRenderer spriteRenderer;


    [SerializeField] private Transform[] checkPoint;
    private float radCheckPoint = 0.1f;

 
    [SerializeField] private Color emptyColor;

    [SerializeField] private Color fillColor;

    [SerializeField] private Color checkColor_empty;

    [SerializeField] private Color checkColor_fill;

    [SerializeField] private Color selectColor_empty;

    [SerializeField] private Color selectColor_fill;

    [SerializeField] private Color avaliableColor;
    private bool isAvaliable;
    public int layer;

    public bool isEmpty;

    private List<Tile> checkTiles = new List<Tile>();


    public void Init()
    {

        spriteRenderer.color = emptyColor;
        isEmpty = true;


    }


    public void OnFill()
    {

        if (!isEmpty)
            return;


        spriteRenderer.color = fillColor;

        
        isEmpty = false;
       
    }

  
    public void OnCheck()
    {

        if (isEmpty)
        {
            spriteRenderer.color = checkColor_empty;
        }
        else
        {
            spriteRenderer.color = checkColor_fill;
        }
    }

   
    public void OffCheck()
    {
    
        if (isEmpty)
        {
            spriteRenderer.color = emptyColor;
        }
        else
        {
            spriteRenderer.color = fillColor;
        }
    }


    private bool CheckFillTile()
    {
        if (checkTiles.Count < 1)
            return true;


        foreach (Tile t in checkTiles)
        {
            if (t.GetFill())
                return true;
        }

        return false;
    }

    public void Avaliable()
    {
        if (!isEmpty)
            return;

        spriteRenderer.color = avaliableColor;
        isAvaliable = true;
    }

    public bool GetFill()
    {
        return !isEmpty;
    }

    
    private void OnMouseDown()
    {

        if (isEmpty && !CheckFillTile())
            return;


        OnFill();
    }

   
    private void OnMouseEnter()
    {

        if (isEmpty)
        {
            spriteRenderer.color = selectColor_empty;
        }
        else
        {
            spriteRenderer.color = selectColor_fill;
        }

       
        for (int i = 0; i < checkPoint.Length; i++)
        {
            RaycastHit2D hit = Physics2D.CircleCast(checkPoint[i].position, radCheckPoint, Vector2.zero);

            if (hit.transform != null)
            {
                if (hit.transform.GetComponent<Tile>() != null)
                {

                    var tileScript = hit.transform.GetComponent<Tile>();

                    tileScript.OnCheck();

                    
                    checkTiles.Add(tileScript);
                }
            }
        }
    }

    
    private void OnMouseExit()
    {
        if (isEmpty)
        {
            if (isAvaliable)
                spriteRenderer.color = avaliableColor;
            else
                spriteRenderer.color = emptyColor;
        }
        else
        {
            spriteRenderer.color = fillColor;
        }

        
        if (checkTiles.Count < 1)
            return;

        foreach (Tile t in checkTiles)
        {
            t.OffCheck();
        }
    }
}