Gen_Hack-and-Slash-Roguelite/Client/Assets/Scripts/Map/Landform.cs

using UnityEngine;
using UnityEngine.Tilemaps;
using Data; // For TileDef
using System.Collections.Generic;
using Managers; // For Dictionary

namespace Map
{
    public class Landform : MonoBehaviour
    {
        public Tilemap baseTilemap;
        public Tilemap buildingTilemap;
        public Tilemap plantTilemap;

        public Dimension dimension;

        // 定义瓦片状态结构体
        public struct TileState
        {
            public Vector3Int position; // 瓦片的世界坐标
            public Tile.ColliderType colliderType;
            public float travelCost;

            public TileState(Vector3Int pos, Tile.ColliderType collider, float cost)
            {
                position = pos;
                colliderType = collider;
                travelCost = cost;
            }
        }

        public void Init()
        {

        }

        public string GetDimensionID()
        {
            return dimension.DimensionId;
        }

        public Vector3Int GetSize()
        {
            return baseTilemap.size;
        }

        public Vector3 GetWorldCoordinates(Vector3Int coord)
        {
            return baseTilemap.CellToWorld(coord);
        }

        public void Clear()
        {
            baseTilemap.ClearAllTiles();
            buildingTilemap.ClearAllTiles();
            plantTilemap.ClearAllTiles();
        }

        /// <summary>
        /// 获取指定格子坐标上的瓦片状态，包括碰撞体类型和通行成本。
        /// 优先级：buildingTilemap > plantTilemap > baseTilemap。
        /// </summary>
        /// <param name="cellPosition">要查询的格子坐标。</param>
        /// <returns>包含瓦片碰撞体类型和通行成本的TileState结构。</returns>
        public TileState GetTileState(Vector3Int cellPosition)
        {
            Tile.ColliderType finalColliderType = Tile.ColliderType.None;
            float finalTravelCost = 0f; // 默认通行成本

            // 瓦片层级优先级：Building > Plant > Base
            // 存储查询到的瓦片定义及其所属Tilemap，用于后续决定通行成本
            Dictionary<Tilemap, (TileBase tile, TileDef def)> activeTiles = new Dictionary<Tilemap, (TileBase, TileDef)>();

            // 1. 尝试从 Building 层获取瓦片信息
            TileBase buildingTile = buildingTilemap.GetTile(cellPosition);
            if (buildingTile != null && DefineManager.Instance != null) // 确保DefineManager已实例化
            {
                TileDef buildingTileDef = DefineManager.Instance.FindDefine<TileDef>(buildingTile.name);
                if (buildingTileDef != null)
                {
                    activeTiles[buildingTilemap] = (buildingTile, buildingTileDef);
                    if (buildingTileDef.collider != Tile.ColliderType.None)
                    {
                        finalColliderType = buildingTileDef.collider; // Building层的碰撞体优先级最高
                    }
                }
            }

            // 2. 尝试从 Plant 层获取瓦片信息 (只有当 Building 层没有提供碰撞体时才考虑)
            if (finalColliderType == Tile.ColliderType.None)
            {
                TileBase plantTile = plantTilemap.GetTile(cellPosition);
                if (plantTile != null && DefineManager.Instance != null)
                {
                    TileDef plantTileDef = DefineManager.Instance.FindDefine<TileDef>(plantTile.name);
                    if (plantTileDef != null)
                    {
                        activeTiles[plantTilemap] = (plantTile, plantTileDef);
                        if (plantTileDef.collider != Tile.ColliderType.None)
                        {
                            finalColliderType = plantTileDef.collider; // Plant层的碰撞体优先级次之
                        }
                    }
                }
            }

            // 3. 尝试从 Base 层获取瓦片信息 (只有当 Building 和 Plant 层都没有提供碰撞体时才考虑)
            if (finalColliderType == Tile.ColliderType.None)
            {
                TileBase baseTile = baseTilemap.GetTile(cellPosition);
                if (baseTile != null && DefineManager.Instance != null)
                {
                    TileDef baseTileDef = DefineManager.Instance.FindDefine<TileDef>(baseTile.name);
                    if (baseTileDef != null)
                    {
                        activeTiles[baseTilemap] = (baseTile, baseTileDef);
                        if (baseTileDef.collider != Tile.ColliderType.None)
                        {
                            finalColliderType = baseTileDef.collider; // Base层的碰撞体优先级最低
                        }
                    }
                }
            }

            // 根据最终碰撞体类型确定通行成本
            if (finalColliderType != Tile.ColliderType.None)
            {
                finalTravelCost = 1f; // 有碰撞体时，通行成本为1（不可通过）
            }
            else
            {
                // 如果没有碰撞体，则取优先级最高的瓦片的tileCost作为最终通行成本。
                // 优先级 Building > Plant > Base
                TileDef highestPriorityDefWithCost = null;

                if (activeTiles.ContainsKey(buildingTilemap))
                {
                    highestPriorityDefWithCost = activeTiles[buildingTilemap].def;
                }
                else if (activeTiles.ContainsKey(plantTilemap))
                {
                    highestPriorityDefWithCost = activeTiles[plantTilemap].def;
                }
                else if (activeTiles.ContainsKey(baseTilemap))
                {
                    highestPriorityDefWithCost = activeTiles[baseTilemap].def;
                }

                if (highestPriorityDefWithCost != null)
                {
                    finalTravelCost = highestPriorityDefWithCost.tileCost;
                }
                // 如果任何层都没有有效瓦片（或DefineManager未实例化），则保持 finalTravelCost 为默认值 0f
            }

            return new TileState(cellPosition, finalColliderType, finalTravelCost);
        }
    }
}