NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/GameWrapper/Map/MapUtils.cs

using Cysharp.Threading.Tasks;
using System;
using Gameplay;
using PhxhSDK;
using TGS;
using UnityEngine;
using Constants = Framework.Constants;
using System.Collections.Generic;
using Object = UnityEngine.Object;

public static class MapUtils
{
    public static Map LoadMap(TerrainGridSystem tgs, MapData mapData, bool isLegionMap = false)
    {
        var map = Map.Create(tgs, mapData, isLegionMap);
        map.TerrainGridSystem.highlightEffect = HighlightEffect.None;

        Dictionary<int, TerrainTypeProperty> terrainTypeConfig = TerrainTypeConfig.DicTerrainTypePropertie;
        if (null == terrainTypeConfig)
            return map;

        for (int i = 0; i < map.MapData.BlocksData.Count; i++)
        {
            map.TerrainGridSystem.CellSetBorderVisible(i, true);
        }

        return map;
    }

    public static async UniTask<Map> LoadMap(MapData mapData, bool isLegionMap = false)
    {
        TerrainGridSystem tgs = UnityEngine.Object.FindObjectOfType<TerrainGridSystem>();
        Map map = Map.Create(tgs, mapData, isLegionMap);
        map.TerrainGridSystem.highlightEffect = HighlightEffect.None;

        for (int i = 0; i < map.MapData.BlocksData.Count; i++)
        {
            map.TerrainGridSystem.CellSetBorderVisible(i, true);
        }

        SetGroundBoxCollider(map);

        return map;
    }

    public static async UniTask<MapData> LoadMapData(string mapFileName)
    {
        if (string.IsNullOrEmpty(mapFileName))
            return null;
        string mapPath = string.Format(Constants.MAP_CONFIG_FORMAT_PATH, mapFileName);
        TextAsset textAsset = await AssetManager.Instance.LoadAssetAsync<TextAsset>(mapPath);
        MapData mapData = null;
        try
        {
            // 这里可能会抛异常，捕获一下避免程序崩溃
            if (textAsset is not null)
            {
                mapData = JsonUtility.FromJson<MapData>(textAsset.text);
            }
        }
        catch (Exception e)
        {
            DebugUtil.LogError("LoadMap.LoadMap failed, exception:{0}", e.ToString());
        }

        if (null == mapData)
            DebugUtil.LogError("LoadMap.LoadMap failed, can not find map config: {0}", mapPath);

        AssetManager.Instance.Unload(mapPath);

        return mapData;
    }

    public static void UnLoadMap(Map map)
    {
        map?.Destroy();
    }

    public static void BindCameraController(Camera camera, Map map)
    {
        var cameraController = camera.gameObject.GetComponent<CameraController>();
        if (!cameraController)
        {
            cameraController = camera.gameObject.AddComponent<CameraController>();
        }

        if (cameraController)
        {
            cameraController.CameraBounds = map.TerrainGridSystem.bounds;
            cameraController.enabled = true;
        }

        cameraController.InitializeCameraPosition(
            map.BlockPosition2WorldPosition(map.MapData.initialCameraPosition),
            map.MapData.cameraMarginInfo);
    }

    public static int Distance(Map map, int cellIndex1, int cellIndex2)
    {
        return map.TerrainGridSystem.CellGetHexagonDistance(cellIndex1, cellIndex2);
    }
    
    public static Color GetRGBAColor(string strColor)
    {
        var color = Convert.ToUInt32(strColor, 16);
        return new Color((color >> 24 & 0xFF) / 255f, (color >> 16 & 0xFF) / 255f,
            (color >> 8 & 0xFF) / 255f, (color & 0xFF) / 255f);
    }

    private static void SetGroundBoxCollider(Map map)
    {
        if (map?.TerrainGridSystem == null)
            return;

        // 查找和 TerrainGridSystem 在同一场景下的 Ground 物体
        var scene = map.TerrainGridSystem.gameObject.scene;
        GameObject ground = null;

        foreach (var rootGameObject in scene.GetRootGameObjects())
        {
            var foundGround = FindGroundInHierarchy(rootGameObject.transform, "Ground");
            if (foundGround != null)
            {
                ground = foundGround;
                break;
            }
        }

        if (ground != null)
        {
            RemoveCollider(ground);
        }

        var parentTransform = ground?.transform.parent;
        if (parentTransform == null)
            return;

        GameObject searchColliderObj = null;

        foreach (var rootGameObject in scene.GetRootGameObjects())
        {
            var foundCollider = FindGroundInHierarchy(rootGameObject.transform, "BoxCollider");
            if (foundCollider != null)
            {
                searchColliderObj = foundCollider;
                break;
            }
        }

        if (searchColliderObj != null)
        {
            DebugUtil.Log($"已有BoxCollider节点, 删除重建");
            Object.DestroyImmediate(searchColliderObj);
        }

        var boxColliderObj = new GameObject("BoxCollider");
        boxColliderObj.layer = LayerMask.NameToLayer(Constants.Layer.GROUND_NAME);

        // 添加 BoxCollider 组件
        var boxCollider = boxColliderObj.AddComponent<BoxCollider>();
        boxCollider.size = new Vector3(1, 1, 1);
        boxCollider.center = new Vector3(0, 0, 0.5f);
        boxColliderObj.transform.localScale = new Vector3(300, 300, 1f);
        boxColliderObj.transform.localRotation = Quaternion.Euler(90f, 0f, 0f);
        boxColliderObj.transform.SetParent(parentTransform, false);
        DebugUtil.Log($"在{parentTransform.gameObject.name}下添加BoxCollider");
    }

    private static GameObject FindGroundInHierarchy(Transform root, string name)
    {
        if (root.name.Equals(name))
            return root.gameObject;

        for (int i = 0; i < root.childCount; i++)
        {
            var result = FindGroundInHierarchy(root.GetChild(i), name);
            if (result != null)
                return result;
        }

        return null;
    }

    private static void RemoveCollider(GameObject obj)
    {
        if (obj == null)
            return;

        var colliders = obj.GetComponents<Collider>();
        foreach (var collider in colliders)
        {
            UnityEngine.Object.Destroy(collider);
        }
    }
}