[TIL] 타일 맵 구현하기(1)

public enum Sides
{
    None = -1,
    Top, // 3
    Left,  // 2
    Right,   // 1
    Bottom,    // 0
}

public int id;
public Tile[] adjacents = new Tile[4];

public int autoTileId;
public int autoFowTileId;

// 맵이 열려있는지 판단
public bool isVisited = false;

public bool CanMove => autoTileId != (int)TileTypes.Empty;

public void UpdateAutoFowTileId()
{
    autoFowTileId = 0;
    for (int i = 0; i < adjacents.Length; i++)
    {
        if (adjacents[i] == null || !adjacents[i].isVisited)
        {
            autoFowTileId |= 1 << i;
        }
    }
}

public void UpdateAutoTileId()
{
    autoTileId = 0;

    for (int i = 0; i < adjacents.Length; i++)
    {
        if (adjacents[i] != null)
        {
            autoTileId |= 1 << i;
        }
    }
}

public void RemoveAdjacents(Tile tile)
{
    for (int i = 0; i < adjacents.Length; i++)
    {
        if (adjacents[i] == null) continue;

        if (adjacents[i].id == tile.id)
        {
            adjacents[i] = null;
            UpdateAutoTileId();
            UpdateAutoFowTileId();
            break;
        }
    }
}

public void ClearAdjacents()
{
    for (int i = 0; i < adjacents.Length; i++)
    {
        if (adjacents[i] == null) continue;

        adjacents[i].RemoveAdjacents(this);
        adjacents[i] = null;
    }

    UpdateAutoTileId();
    UpdateAutoFowTileId();
}

public enum TileTypes
{
    Empty = -1,
    // 0 ~ 14
    Grass = 15,
    Tree,
    Hill,
    Mountain,
    Towns,
    Castle,
    Monster,
}

    public int rows = 0;
    public int cols = 0;

    public Tile[] tiles;

    public Tile[] CoastTiles => tiles.Where(t => t.autoTileId >= 0 
                                && t.autoTileId < (int)TileTypes.Grass).ToArray();
    public Tile[] LandTiles => tiles.Where(t => t.autoTileId == (int)TileTypes.Grass).ToArray();

    public Tile startTile;
    public Tile castleTile;

    public void Init(int rows, int cols)
    {
        this.rows = rows;
        this.cols = cols;

        tiles = new Tile[rows * cols];
        for (int i = 0; i < tiles.Length; i++)
        {
            tiles[i] = new Tile();
            tiles[i].id = i;
        }

        for (int r = 0; r < rows; r++)
        {
            for (int c = 0; c < cols; c++)
            {
                int index = r * cols + c;
                var adjacents = tiles[index].adjacents;

                if ((r - 1) >= 0)
                {
                    adjacents[(int)Sides.Top] = tiles[index - cols];
                }

                if ((c + 1) < cols)
                {
                    adjacents[(int)Sides.Right] = tiles[index + 1];
                }

                if ((c - 1) >= 0)
                {
                    adjacents[(int)Sides.Left] = tiles[index - 1];
                }

                if ((r + 1) < rows)
                {
                    adjacents[(int)Sides.Bottom] = tiles[index + cols];
                }
            }
        }

        for (int i = 0; i < tiles.Length; i++)
        {
            tiles[i].UpdateAutoTileId();
        }
    }

    public void ShuffleTiles(Tile[] tiles)
    {
        for (int i = tiles.Length - 1; i > 0; i--)
        {
            int rand = Random.Range(0, i + 1);
            (tiles[rand], tiles[i]) = (tiles[i], tiles[rand]);
        }
    }

    public void DecorateTiles(Tile[] tiles, float percent, TileTypes tileTypes)
    {
        ShuffleTiles(tiles);

        int total = Mathf.FloorToInt(tiles.Length * percent);
        // Debug.Log($"{tileTypes}: {total}/{tiles.Length}");
        for (int i = 0; i < total; i++)
        {
            if (tileTypes == TileTypes.Empty)
            {
                tiles[i].ClearAdjacents();
            }

            tiles[i].autoTileId = (int)tileTypes;
        }
    }

    public bool CreateIsland(
    float erodePercent,
    int erodeIterations,
    float lakePercent,
    float treePercent,
    float hillPercent,
    float mountainPercent,
    float townPercent,
    float monsterPercent)
    {
        for (int i = 0; i < erodeIterations; i++)
        {
            DecorateTiles(CoastTiles, erodePercent, TileTypes.Empty);
        }

        DecorateTiles(LandTiles, lakePercent, TileTypes.Empty);
        DecorateTiles(LandTiles, treePercent, TileTypes.Tree);
        DecorateTiles(LandTiles, hillPercent, TileTypes.Hill);
        DecorateTiles(LandTiles, mountainPercent, TileTypes.Mountain);
        DecorateTiles(LandTiles, townPercent, TileTypes.Towns);
        DecorateTiles(LandTiles, monsterPercent, TileTypes.Monster);

        var towns = tiles.Where(x => x.autoTileId == (int)TileTypes.Towns).ToArray();
        ShuffleTiles(towns);

        startTile = towns[0];
        castleTile = towns[1];
        castleTile.autoTileId = (int)TileTypes.Castle;

        return true;
    }

    public GameObject tilePrefabs;
    private GameObject[] tileObjs;

    public PlayerMovement playerPrefab;
    private PlayerMovement player;

    public int mapWidth = 20;
    public int mapHeight = 20;

    private float startX;
    private float startY;

    [Range(0f, 0.9f)]
    public float erodePercent = 0.5f;
    public int erodeIterations = 2;
    public float lakePercent = 0.01f;
    public float treePercent = 0.2f;
    public float hillPercent = 0.2f;
    public float mountainPercent = 0.1f;
    public float townPercent = 0.1f;
    public float monsterPercent = 0.1f;

    public Vector2 tileSize = new Vector2(16, 16);

    public Sprite[] islandSprites;
    public Sprite[] isFowSprites;

    private Map map;
    public Map Map => map;

    private int lastHoveredTileId = -1;

    private void Start()
    {
        startX = transform.position.x - mapWidth * tileSize.x * 0.5f + tileSize.x * 0.5f;
        startY = transform.position.y + mapHeight * tileSize.y * 0.5f - tileSize.y * 0.5f;
    }

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            ResetStage();
        }
    }

    private void ResetStage()
    {
        map = new Map();
        map.Init(mapHeight, mapWidth);
        //map.CreateIsland(coastErodePercent, coastErodeIterations);
        map.CreateIsland(erodePercent, erodeIterations, lakePercent,
        treePercent, hillPercent, mountainPercent, townPercent, monsterPercent);
        CreateGrid();
        CreatePlayer(); // 여기서 오픈해주는걸 필요함
    }

    private void CreateGrid()
    {
        if (tileObjs != null)
        {
            foreach (var tile in tileObjs)
            {
                Destroy(tile.gameObject);
            }
        }

        tileObjs = new GameObject[mapWidth * mapHeight];

        var position = new Vector3(startX, startY, 0f);

        for (int i = 0; i < mapHeight; i++)
        {
            for (int j = 0; j < mapWidth; j++)
            {
                var tileId = i * mapWidth + j;
                var newGo = Instantiate(tilePrefabs, transform);
                newGo.transform.position = position;
                position.x += tileSize.x;

                tileObjs[tileId] = newGo;
                DecorateTile(tileId);
            }
            position.x = startX;
            position.y -= tileSize.y;
        }
    }

    public void DecorateTile(int tileId)
    {
        var tile = map.tiles[tileId]; // 데이터
        var tileGo = tileObjs[tileId]; // 게임 오브젝트
        var ren = tileGo.GetComponent<SpriteRenderer>();

        tile.UpdateAutoFowTileId();

        // 여기서 분기해서 fow 설정
        if (tile.isVisited)
        {
            if (tile.autoTileId != (int)TileTypes.Empty)
            {
                ren.sprite = islandSprites[tile.autoTileId];
            }
            else
            {
                ren.sprite = null;
            }
        }
        else
        {
            ren.sprite = isFowSprites[tile.autoFowTileId];
        }
    }