// Unity C# 示例
public class SeededRandom
{
    private System.Random _rng;
    public int CurrentSeed { get; private set; }

    public SeededRandom(int? seed = null)
    {
        // 如果没提供种子，用时间戳或随机生成
        CurrentSeed = seed ?? GenerateRandomSeed();
        _rng = new System.Random(CurrentSeed);
    }

    private int GenerateRandomSeed()
    {
        // 用时间戳生成种子
        return (int)(System.DateTime.Now.Ticks % int.MaxValue);
    }

    // 基础随机数方法
    public float Range(float min, float max)
    {
        return (float)(_rng.NextDouble() * (max - min) + min);
    }

    public int Range(int min, int max)
    {
        return _rng.Next(min, max + 1);
    }

    // 种子字符串化（方便分享）
    public static string SeedToString(int seed)
    {
        return seed.ToString("X8"); // 16 进制字符串
    }

    public static int StringToSeed(string seedStr)
    {
        return Convert.ToInt32(seedStr, 16);
    }

    // 重置到初始状态
    public void Reset()
    {
        _rng = new System.Random(CurrentSeed);
    }
}

// 均匀分布：每个值概率相同
float uniform = Random.Range(0f, 1f);

// Box-Muller 变换生成正态分布
public float NextGaussian(float mean = 0f, float stdDev = 1f)
{
    double u1 = 1.0 - _rng.NextDouble(); // 避免 log(0)
    double u2 = _rng.NextDouble();
    double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) *
                           Math.Sin(2.0 * Math.PI * u2);
    return mean + stdDev * (float)randStdNormal;
}

// 泊松分布
public int NextPoisson(double lambda)
{
    double L = Math.Exp(-lambda);
    double p = 1.0;
    int k = 0;
    do
    {
        k++;
        p *= _rng.NextDouble();
    } while (p > L);
    return k - 1;
}

public class RandomWalkGenerator
{
    private int _width, _height;
    private int[,] _map; // 0 = 墙, 1 = 地板
    private SeededRandom _rng;

    // 四个方向：上、下、左、右
    private static readonly Vector2Int[] Directions = {
        new Vector2Int(0, 1),   // 上
        new Vector2Int(0, -1),  // 下
        new Vector2Int(-1, 0),  // 左
        new Vector2Int(1, 0)    // 右
    };

    public int[,] Generate(int width, int height, int seed,
                           int targetFloorCount = 500)
    {
        _width = width;
        _height = height;
        _rng = new SeededRandom(seed);
        _map = new int[width, height]; // 默认全墙

        // 从中心开始
        Vector2Int current = new Vector2Int(width / 2, height / 2);
        int floorCount = 0;

        while (floorCount < targetFloorCount)
        {
            // 标记当前位置为地板
            if (_map[current.x, current.y] == 0)
            {
                _map[current.x, current.y] = 1;
                floorCount++;
            }

            // 随机选择一个方向
            Vector2Int dir = Directions[_rng.Range(0, 3)];
            current += dir;

            // 边界检查
            current.x = Mathf.Clamp(current.x, 1, width - 2);
            current.y = Mathf.Clamp(current.y, 1, height - 2);
        }

        return _map;
    }
}

extends Node

class_name RandomWalkGenerator

var width: int
var height: int
var map: Array
var rng: RandomNumberGenerator

const DIRECTIONS = [
    Vector2i(0, 1),   # 上
    Vector2i(0, -1),  # 下
    Vector2i(-1, 0),  # 左
    Vector2i(1, 0)    # 右
]

func generate(p_width: int, p_height: int, seed_val: int,
              target_floors: int = 500) -> Array:
    width = p_width
    height = p_height
    rng = RandomNumberGenerator.new()
    rng.seed = seed_val

    # 初始化地图为全墙
    map = []
    for x in range(width):
        map.append([])
        for y in range(height):
            map[x].append(0)

    var current = Vector2i(width / 2, height / 2)
    var floor_count = 0

    while floor_count < target_floors:
        if map[current.x][current.y] == 0:
            map[current.x][current.y] = 1
            floor_count += 1

        var dir = DIRECTIONS[rng.randi_range(0, 3)]
        current += dir
        current.x = clampi(current.x, 1, width - 2)
        current.y = clampi(current.y, 1, height - 2)

    return map

public class BSPNode
{
    public RectInt Area { get; set; }
    public RectInt? Room { get; set; }
    public BSPNode Left { get; set; }
    public BSPNode Right { get; set; }
    public bool IsLeaf => Left == null && Right == null;

    public BSPNode(RectInt area)
    {
        Area = area;
    }
}

public class BSPDungeonGenerator
{
    private int _minLeafSize = 8;    // 叶节点最小尺寸
    private int _maxLeafSize = 18;   // 叶节点最大尺寸
    private int _minRoomSize = 4;    // 房间最小尺寸
    private int _maxRoomSize = 10;   // 房间最大尺寸
    private SeededRandom _rng;
    private int[,] _map;

    public int[,] Generate(int width, int height, int seed)
    {
        _rng = new SeededRandom(seed);
        _map = new int[width, height];

        // 1. 递归分割空间
        var root = new BSPNode(new RectInt(0, 0, width, height));
        Split(root);

        // 2. 在每个叶节点中创建房间
        CreateRooms(root);

        // 3. 连接房间（走廊）
        ConnectRooms(root);

        return _map;
    }

    private void Split(BSPNode node)
    {
        if (node.Area.width <= _maxLeafSize &&
            node.Area.height <= _maxLeafSize)
            return;

        // 随机选择水平或垂直分割
        bool splitHorizontally = _rng.Range(0, 1) == 0;

        if (node.Area.width > node.Area.height * 1.25f)
            splitHorizontally = false;
        else if (node.Area.height > node.Area.width * 1.25f)
            splitHorizontally = true;

        int splitPos;
        if (splitHorizontally)
        {
            splitPos = _rng.Range(_minLeafSize,
                                  node.Area.height - _minLeafSize);
            node.Left = new BSPNode(new RectInt(
                node.Area.x, node.Area.y,
                node.Area.width, splitPos));
            node.Right = new BSPNode(new RectInt(
                node.Area.x, node.Area.y + splitPos,
                node.Area.width, node.Area.height - splitPos));
        }
        else
        {
            splitPos = _rng.Range(_minLeafSize,
                                  node.Area.width - _minLeafSize);
            node.Left = new BSPNode(new RectInt(
                node.Area.x, node.Area.y,
                splitPos, node.Area.height));
            node.Right = new BSPNode(new RectInt(
                node.Area.x + splitPos, node.Area.y,
                node.Area.width - splitPos, node.Area.height));
        }

        Split(node.Left);
        Split(node.Right);
    }

    private void CreateRooms(BSPNode node)
    {
        if (node.IsLeaf)
        {
            int roomW = _rng.Range(_minRoomSize,
                                   Mathf.Min(_maxRoomSize, node.Area.width - 2));
            int roomH = _rng.Range(_minRoomSize,
                                   Mathf.Min(_maxRoomSize, node.Area.height - 2));
            int roomX = node.Area.x + _rng.Range(1,
                                                  node.Area.width - roomW - 1);
            int roomY = node.Area.y + _rng.Range(1,
                                                  node.Area.height - roomH - 1);

            node.Room = new RectInt(roomX, roomY, roomW, roomH);

            // 在地图上画房间
            for (int x = roomX; x < roomX + roomW; x++)
                for (int y = roomY; y < roomY + roomH; y++)
                    if (x >= 0 && x < _map.GetLength(0) &&
                        y >= 0 && y < _map.GetLength(1))
                        _map[x, y] = 1;
        }
        else
        {
            if (node.Left != null) CreateRooms(node.Left);
            if (node.Right != null) CreateRooms(node.Right);
        }
    }

    private void ConnectRooms(BSPNode node)
    {
        if (node.IsLeaf) return;

        if (node.Left != null) ConnectRooms(node.Left);
        if (node.Right != null) ConnectRooms(node.Right);

        if (node.Left?.Room != null && node.Right?.Room != null)
        {
            var leftCenter = new Vector2Int(
                node.Left.Value.Room.Value.center.x,
                node.Left.Value.Room.Value.center.y);
            var rightCenter = new Vector2Int(
                node.Right.Value.Room.Value.center.x,
                node.Right.Value.Room.Value.center.y);

            CarveCorridor(leftCenter, rightCenter);
        }
    }

    private void CarveCorridor(Vector2Int from, Vector2Int to)
    {
        // L 形走廊
        if (_rng.Range(0, 1) == 0)
        {
            // 先水平后垂直
            for (int x = Mathf.Min(from.x, to.x);
                 x <= Mathf.Max(from.x, to.x); x++)
                _map[x, from.y] = 1;
            for (int y = Mathf.Min(from.y, to.y);
                 y <= Mathf.Max(from.y, to.y); y++)
                _map[to.x, y] = 1;
        }
        else
        {
            // 先垂直后水平
            for (int y = Mathf.Min(from.y, to.y);
                 y <= Mathf.Max(from.y, to.y); y++)
                _map[from.x, y] = 1;
            for (int x = Mathf.Min(from.x, to.x);
                 x <= Mathf.Max(from.x, to.x); x++)
                _map[x, to.y] = 1;
        }
    }
}

public class CellularAutomataGenerator
{
    private int _width, _height;
    private bool[,] _map;
    private SeededRandom _rng;

    public bool[,] Generate(int width, int height, int seed,
                            float wallDensity = 0.45f,
                            int iterations = 5)
    {
        _width = width;
        _height = height;
        _rng = new SeededRandom(seed);
        _map = new bool[width, height];

        // 1. 初始化随机噪声
        for (int x = 0; x < width; x++)
        {
            for (int y = 0; y < height; y++)
            {
                if (x == 0 || x == width - 1 ||
                    y == 0 || y == height - 1)
                {
                    _map[x, y] = true; // 边界为墙
                }
                else
                {
                    _map[x, y] = _rng.Range(0f, 1f) < wallDensity;
                }
            }
        }

        // 2. 迭代平滑
        for (int i = 0; i < iterations; i++)
        {
            SmoothMap();
        }

        return _map;
    }

    private void SmoothMap()
    {
        bool[,] newMap = new bool[_width, _height];

        for (int x = 0; x < _width; x++)
        {
            for (int y = 0; y < _height; y++)
            {
                int wallNeighbors = CountWallNeighbors(x, y);

                if (wallNeighbors > 4)
                    newMap[x, y] = true;  // 变成墙
                else if (wallNeighbors < 4)
                    newMap[x, y] = false; // 变成地板
                else
                    newMap[x, y] = _map[x, y]; // 保持不变
            }
        }

        _map = newMap;
    }

    private int CountWallNeighbors(int x, int y)
    {
        int count = 0;
        for (int dx = -1; dx <= 1; dx++)
        {
            for (int dy = -1; dy <= 1; dy++)
            {
                if (dx == 0 && dy == 0) continue;
                int nx = x + dx, ny = y + dy;
                if (nx < 0 || nx >= _width || ny < 0 || ny >= _height)
                    count++; // 越界算墙
                else if (_map[nx, ny])
                    count++;
            }
        }
        return count;
    }
}

public class TerrainGenerator : MonoBehaviour
{
    [Header("地图参数")]
    public int mapWidth = 256;
    public int mapHeight = 256;
    public float heightScale = 20f;

    [Header("噪声参数")]
    public float baseScale = 0.02f;    // 基础频率
    public int octaves = 6;            // 叠加层数
    public float persistence = 0.5f;   // 振幅衰减
    public float lacunarity = 2.0f;    // 频率倍增

    [Header("种子")]
    public int seed = 42;

    public float[,] GenerateHeightMap()
    {
        float[,] heightMap = new float[mapWidth, mapHeight];
        System.Random rng = new System.Random(seed);
        int[] octaveOffsets = new int[octaves];
        for (int i = 0; i < octaves; i++)
            octaveOffsets[i] = rng.Next(-100000, 100000);

        float maxNoiseHeight = float.MinValue;
        float minNoiseHeight = float.MaxValue;

        for (int x = 0; x < mapWidth; x++)
        {
            for (int y = 0; y < mapHeight; y++)
            {
                float amplitude = 1f;
                float frequency = 1f;
                float noiseHeight = 0f;

                // 多层噪声叠加（Fractal Brownian Motion）
                for (int o = 0; o < octaves; o++)
                {
                    float sampleX = x * baseScale * frequency
                                    + octaveOffsets[o];
                    float sampleY = y * baseScale * frequency
                                    + octaveOffsets[o];

                    // Unity 内置 Perlin Noise
                    float perlinValue = Mathf.PerlinNoise(
                        sampleX, sampleY);

                    noiseHeight += perlinValue * amplitude;
                    amplitude *= persistence;
                    frequency *= lacunarity;
                }

                heightMap[x, y] = noiseHeight;
                if (noiseHeight > maxNoiseHeight)
                    maxNoiseHeight = noiseHeight;
                if (noiseHeight < minNoiseHeight)
                    minNoiseHeight = noiseHeight;
            }
        }

        // 归一化到 [0, 1]
        for (int x = 0; x < mapWidth; x++)
            for (int y = 0; y < mapHeight; y++)
                heightMap[x, y] = Mathf.InverseLerp(
                    minNoiseHeight, maxNoiseHeight,
                    heightMap[x, y]);

        return heightMap;
    }
}

public enum BiomeType
{
    DeepWater,   // 深水
    ShallowWater,// 浅水
    Sand,        // 沙滩
    Grass,       // 草地
    Forest,      // 森林
    Mountain,    // 山地
    Snow         // 雪山
}

public BiomeType GetBiome(float height, float moisture)
{
    // 基于高度和湿度的生物群落判定
    if (height < 0.2f)
        return BiomeType.DeepWater;
    if (height < 0.3f)
        return BiomeType.ShallowWater;
    if (height < 0.35f)
        return BiomeType.Sand;
    if (height < 0.6f)
    {
        if (moisture > 0.6f) return BiomeType.Forest;
        return BiomeType.Grass;
    }
    if (height < 0.8f)
        return BiomeType.Mountain;
    return BiomeType.Snow;
}

public class BiomeGenerator
{
    private float _temperatureScale = 0.01f;
    private float _moistureScale = 0.015f;

    public BiomeType GetBiome(float height, int x, int y)
    {
        float temperature = Mathf.PerlinNoise(
            x * _temperatureScale + 500,
            y * _temperatureScale + 500);
        float moisture = Mathf.PerlinNoise(
            x * _moistureScale + 1000,
            y * _moistureScale + 1000);

        // 温度 + 湿度组合决定生物群落
        if (height < 0.3f) return BiomeType.DeepWater;
        if (height < 0.35f)
        {
            if (temperature > 0.7f) return BiomeType.Sand; // 沙漠海滩
            return BiomeType.Sand;
        }
        if (height < 0.6f)
        {
            if (temperature > 0.7f && moisture < 0.3f)
                return BiomeType.Sand;   // 沙漠
            if (moisture > 0.6f)
                return BiomeType.Forest; // 森林
            return BiomeType.Grass;      // 草原
        }
        if (height < 0.8f)
            return BiomeType.Mountain;
        return BiomeType.Snow;
    }
}

public enum Rarity { Common, Uncommon, Rare, Epic, Legendary }

[System.Serializable]
public class LootEntry
{
    public string itemId;
    public Rarity rarity;
    public float weight;     // 权重
    public int minCount;
    public int maxCount;
}

public class LootTable
{
    public List<LootEntry> entries = new List<LootEntry>();
    private System.Random _rng;

    public LootTable(int seed) { _rng = new System.Random(seed); }

    public LootEntry Roll()
    {
        float totalWeight = 0f;
        foreach (var entry in entries)
            totalWeight += entry.weight;

        float roll = (float)(_rng.NextDouble() * totalWeight);
        float cumulative = 0f;

        foreach (var entry in entries)
        {
            cumulative += entry.weight;
            if (roll <= cumulative)
                return entry;
        }
        return entries[entries.Count - 1];
    }
}

public class PitySystem
{
    private int _rollsSinceLastRare = 0;
    private int _pityThreshold;        // 保底阈值
    private float _pityRateBonus;      // 每多抽一次增加的稀有概率
    private LootTable _lootTable;

    public PitySystem(int threshold = 50, float rateBonus = 0.02f)
    {
        _pityThreshold = threshold;
        _pityRateBonus = rateBonus;
    }

    public LootEntry RollWithPity()
    {
        _rollsSinceLastRare++;

        // 硬保底：超过阈值必定出稀有
        if (_rollsSinceLastRare >= _pityThreshold)
        {
            _rollsSinceLastRare = 0;
            return GetGuaranteedRare();
        }

        // 软保底：超过阈值一半后逐步增加概率
        if (_rollsSinceLastRare > _pityThreshold / 2)
        {
            int bonusRolls = _rollsSinceLastRare - _pityThreshold / 2;
            float bonus = bonusRolls * _pityRateBonus;
            // 临时提升稀有物品权重
            // ...
        }

        var result = _lootTable.Roll();
        if (result.rarity >= Rarity.Rare)
            _rollsSinceLastRare = 0;
        return result;
    }

    private LootEntry GetGuaranteedRare() { /* 返回保底稀有物品 */ return null; }
}

public class EnemySpawner
{
    [System.Serializable]
    public class EnemyConfig
    {
        public string enemyId;
        public int minFloor;       // 最早出现的层数
        public int maxFloor;       // 最晚出现的层数
        public float baseWeight;   // 基础权重
        public float hpScale;      // 每层血量增长系数
        public float dmgScale;     // 每层伤害增长系数
    }

    public List<EnemyConfig> enemyPool;

    public EnemyConfig SpawnEnemy(int currentFloor, SeededRandom rng)
    {
        // 筛选当前层可用的敌人
        var available = enemyPool.FindAll(e =>
            currentFloor >= e.minFloor && currentFloor <= e.maxFloor);

        // 计算权重
        float totalWeight = 0f;
        foreach (var e in available) totalWeight += e.baseWeight;

        // 随机选择
        float roll = rng.Range(0f, totalWeight);
        float cumulative = 0f;
        foreach (var e in available)
        {
            cumulative += e.baseWeight;
            if (roll <= cumulative) return e;
        }
        return available[available.Count - 1];
    }

    // 敌人属性随层数增长
    public float GetScaledHP(EnemyConfig config, int floor)
    {
        return 100f * Mathf.Pow(1f + config.hpScale, floor);
    }
}

public class EliteSpawner
{
    public bool ShouldSpawnElite(int floor, SeededRandom rng)
    {
        // 精英出现概率随层数递增
        float baseChance = 0.05f;       // 基础 5%
        float perFloorBonus = 0.02f;    // 每层 +2%
        float chance = baseChance + floor * perFloorBonus;
        return rng.Range(0f, 1f) < Mathf.Min(chance, 0.5f); // 上限 50%
    }

    // 精英怪词缀系统（参考 Diablo）
    public string[] RollEliteAffixes(int floor, SeededRandom rng)
    {
        string[] allAffixes = {
            "快速", "强韧", "火焰强化", "冰冻光环",
            "传送", "分裂", "吸血", "反射"
        };
        int affixCount = Mathf.Min(1 + floor / 5, 4); // 1-4 个词缀
        string[] result = new string[affixCount];
        for (int i = 0; i < affixCount; i++)
        {
            result[i] = allAffixes[rng.Range(0, allAffixes.Length - 1)];
        }
        return result;
    }
}

public class GameEvent
{
    public string id;
    public string title;
    public string description;
    public List<EventChoice> choices;
    public EventCondition condition;
    public float weight;
    public bool isUnique;     // 是否只出现一次
    public string[] requiredTags; // 前置条件标签
}

public class EventChoice
{
    public string text;          // 选项文字
    public string tooltip;       // 提示信息
    public EventOutcome outcome; // 结果
    public bool requiresCrew;    // 需要特定船员
    public bool requiresItem;    // 需要特定物品
}

public class EventOutcome
{
    public int hullDamage;       // 船体损伤
    public int crewLoss;         // 船员损失
    public int scrapGain;        // 获得废料
    public int fuelChange;       // 燃料变化
    public string itemId;        // 获得物品
    public string nextEventId;   // 触发后续事件
}

public class EventSystem
{
    private List<GameEvent> _eventPool;
    private HashSet<string> _usedEvents = new HashSet<string>();
    private SeededRandom _rng;
    private Dictionary<string, int> _gameState;

    public GameEvent GetNextEvent(string locationTag)
    {
        var available = _eventPool.FindAll(e => {
            if (e.isUnique && _usedEvents.Contains(e.id))
                return false;
            if (e.requiredTags != null &&
                !e.requiredTags.Contains(locationTag))
                return false;
            if (e.condition != null && !CheckCondition(e.condition))
                return false;
            return true;
        });

        // 加权随机
        float totalWeight = 0f;
        foreach (var e in available) totalWeight += e.weight;
        float roll = _rng.Range(0f, totalWeight);
        float cumulative = 0f;

        foreach (var e in available)
        {
            cumulative += e.weight;
            if (roll <= cumulative)
            {
                if (e.isUnique) _usedEvents.Add(e.id);
                return e;
            }
        }
        return available[0];
    }

    private bool CheckCondition(EventCondition c) { /* 检查条件 */ return true; }
}

public class QuestTemplate
{
    public string id;
    public string namePattern;      // "击败{enemy}首领"
    public string descPattern;      // "{npc}请求你前往{location}..."
    public QuestType type;          // Kill / Fetch / Escort / Explore
    public Dictionary<string, string[]> paramOptions;
}

public class QuestGenerator
{
    public Quest GenerateQuest(QuestTemplate template, SeededRandom rng)
    {
        var quest = new Quest();
        quest.name = FillPattern(template.namePattern, template.paramOptions, rng);
        quest.description = FillPattern(template.descPattern, template.paramOptions, rng);

        // 生成数值参数（随玩家等级缩放）
        switch (template.type)
        {
            case QuestType.Kill:
                quest.killTarget = template.paramOptions["enemy"][
                    rng.Range(0, template.paramOptions["enemy"].Length - 1)];
                quest.killCount = rng.Range(3, 10);
                break;
            case QuestType.Fetch:
                quest.fetchItem = template.paramOptions["item"][
                    rng.Range(0, template.paramOptions["item"].Length - 1)];
                quest.fetchCount = rng.Range(1, 5);
                break;
        }

        // 奖励计算
        quest.goldReward = quest.killCount * 20 + rng.Range(0, 50);
        quest.xpReward = quest.killCount * 15;

        return quest;
    }

    private string FillPattern(string pattern,
        Dictionary<string, string[]> options, SeededRandom rng)
    {
        string result = pattern;
        foreach (var kvp in options)
        {
            string value = kvp.Value[rng.Range(0, kvp.Value.Length - 1)];
            result = result.Replace($"{{{kvp.Key}}}", value);
        }
        return result;
    }
}

public class RoomBasedGenerator
{
    [System.Serializable]
    public class RoomTemplate
    {
        public string id;
        public int width, height;
        public int[,] layout;           // 房间布局数据
        public DoorPosition[] doors;    // 可用的门位置
        public RoomType type;           // 普通/宝箱/Boss/商店
        public int minFloor, maxFloor;  // 适用层数
        public float weight;
    }

    public int[,] GenerateDungeon(int seed, int floor,
                                   List<RoomTemplate> templates)
    {
        var rng = new SeededRandom(seed);

        // 1. 筛选当前层可用的房间模板
        var available = templates.FindAll(t =>
            floor >= t.minFloor && floor <= t.maxFloor);

        // 2. 随机选择并放置房间
        int roomCount = rng.Range(5, 8);
        List<PlacedRoom> placedRooms = new List<PlacedRoom>();

        // 第一个房间（起始房间，固定）
        var startRoom = available.Find(t => t.type == RoomType.Start);
        placedRooms.Add(PlaceRoom(startRoom, 0, 0));

        // 3. 逐个放置后续房间
        for (int i = 1; i < roomCount; i++)
        {
            var template = WeightedRandom(available, rng);
            var lastRoom = placedRooms[placedRooms.Count - 1];
            // 连接到上一个房间的某个门
            var connection = TryConnect(lastRoom, template, rng);
            if (connection != null)
                placedRooms.Add(connection);
        }

        // 4. 最后一个房间放置 Boss/楼梯
        var bossRoom = available.Find(t => t.type == RoomType.Boss);
        // ...

        return RenderToMap(placedRooms);
    }

    private RoomTemplate WeightedRandom(
        List<RoomTemplate> list, SeededRandom rng) { return null; }
    private PlacedRoom PlaceRoom(RoomTemplate t, int x, int y) { return null; }
    private PlacedRoom TryConnect(PlacedRoom from, RoomTemplate to,
        SeededRandom rng) { return null; }
    private int[,] RenderToMap(List<PlacedRoom> rooms) { return null; }
}

public class DungeonValidator
{
    public ValidationResult Validate(int[,] map)
    {
        var result = new ValidationResult();

        // 1. 连通性检查：BFS 确保所有可达区域连通
        result.isFullyConnected = CheckConnectivity(map);

        // 2. 可达性：确保从起点到终点存在路径
        result.isReachable = CheckPathExists(
            map, FindStart(map), FindExit(map));

        // 3. 最小面积：确保地图不会太小
        result.hasEnoughSpace = CountFloorTiles(map) > 200;

        // 4. 死胡同检查：确保没有过长的死胡同
        result.noExcessiveDeadEnds = CheckDeadEnds(map) < 3;

        // 5. 敌人放置点：确保有足够的空间放敌人
        result.hasEnemySpawnPoints = CountEnemySpawns(map) > 5;

        return result;
    }
}

public class SafeGenerator
{
    private const int MAX_ATTEMPTS = 10;

    public int[,] GenerateSafe(int width, int height, int seed)
    {
        var validator = new DungeonValidator();

        for (int attempt = 0; attempt < MAX_ATTEMPTS; attempt++)
        {
            // 每次尝试用不同的种子偏移
            var map = GenerateDungeon(seed + attempt, width, height);
            var result = validator.Validate(map);

            if (result.IsValid)
            {
                Debug.Log($"地图在第 {attempt + 1} 次尝试后通过验证");
                return map;
            }
        }

        // 多次失败后使用后备方案（预设计的安全地图）
        Debug.LogWarning("多次生成失败，使用后备地图");
        return LoadFallbackMap();
    }
}

public class AsyncMapGenerator : MonoBehaviour
{
    public async Task<int[,]> GenerateMapAsync(
        int width, int height, int seed)
    {
        // 在后台线程生成地图
        return await Task.Run(() =>
        {
            var generator = new BSPDungeonGenerator();
            return generator.Generate(width, height, seed);
        });
    }

    // 分块生成（Chunk-based）
    public class ChunkGenerator
    {
        private const int CHUNK_SIZE = 32;

        public Dictionary<Vector2Int, ChunkData> loadedChunks
            = new Dictionary<Vector2Int, ChunkData>();

        public void UpdateChunks(Vector2Int playerChunkPos,
                                  int renderDistance)
        {
            // 加载周围的 Chunk
            for (int dx = -renderDistance; dx <= renderDistance; dx++)
            {
                for (int dy = -renderDistance; dy <= renderDistance; dy++)
                {
                    var chunkPos = new Vector2Int(
                        playerChunkPos.x + dx,
                        playerChunkPos.y + dy);

                    if (!loadedChunks.ContainsKey(chunkPos))
                    {
                        // 用确定性种子生成 Chunk
                        int chunkSeed = HashChunkPosition(chunkPos);
                        loadedChunks[chunkPos] =
                            GenerateChunk(chunkPos, chunkSeed);
                    }
                }
            }

            // 卸载远处的 Chunk
            var toRemove = new List<Vector2Int>();
            foreach (var kvp in loadedChunks)
            {
                if (Vector2Int.Distance(kvp.Key, playerChunkPos)
                    > renderDistance + 2)
                {
                    toRemove.Add(kvp.Key);
                }
            }
            foreach (var pos in toRemove)
                loadedChunks.Remove(pos);
        }

        private int HashChunkPosition(Vector2Int pos)
        {
            unchecked
            {
                int hash = 17;
                hash = hash * 31 + pos.x;
                hash = hash * 31 + pos.y;
                return hash;
            }
        }

        private ChunkData GenerateChunk(Vector2Int pos, int seed)
        {
            return null; // 实际生成逻辑
        }
    }
}

// 对象池：复用生成对象，减少 GC
public class MapTilePool
{
    private Stack<MapTile> _pool = new Stack<MapTile>();

    public MapTile Get()
    {
        if (_pool.Count > 0)
            return _pool.Pop();
        return new MapTile();
    }

    public void Return(MapTile tile)
    {
        tile.Reset();
        _pool.Push(tile);
    }

    public void WarmUp(int count)
    {
        for (int i = 0; i < count; i++)
            _pool.Push(new MapTile());
    }
}

public class GenerationTester : MonoBehaviour
{
    // 用固定种子复现问题
    public void TestSpecificSeed(int seed)
    {
        var generator = new BSPDungeonGenerator();
        var map = generator.Generate(100, 100, seed);

        var validator = new DungeonValidator();
        var result = validator.Validate(map);

        if (!result.IsValid)
        {
            Debug.LogError($"种子 {seed} 生成失败: {result.ErrorMessage}");
            RenderDebugMap(map); // 可视化问题地图
        }
    }

    // 批量测试
    public void StressTest(int seedCount = 1000)
    {
        int passCount = 0;
        int failCount = 0;
        var failures = new List<int>();

        for (int i = 0; i < seedCount; i++)
        {
            var generator = new BSPDungeonGenerator();
            var map = generator.Generate(100, 100, i);
            var result = validator.Validate(map);

            if (result.IsValid)
                passCount++;
            else
            {
                failCount++;
                failures.Add(i);
            }
        }

        Debug.Log($"压力测试完成: {passCount}/{seedCount} 通过 " +
                  $"({(float)passCount / seedCount * 100:F1}%)");
        if (failures.Count > 0)
            Debug.Log($"失败种子: {string.Join(", ", failures)}");
    }
}

public class MapDebugVisualizer : MonoBehaviour
{
    public Texture2D RenderDebugMap(int[,] map, bool showPath = false)
    {
        int w = map.GetLength(0);
        int h = map.GetLength(1);
        var tex = new Texture2D(w, h);

        for (int x = 0; x < w; x++)
        {
            for (int y = 0; y < h; y++)
            {
                tex.SetPixel(x, y, map[x, y] == 1
                    ? Color.white   // 地板
                    : Color.black); // 墙壁
            }
        }

        // 标记起点（绿色）和终点（红色）
        var start = FindStart(map);
        var end = FindEnd(map);
        tex.SetPixel(start.x, start.y, Color.green);
        tex.SetPixel(end.x, end.y, Color.red);

        // 显示最短路径（黄色）
        if (showPath)
        {
            var path = FindShortestPath(map, start, end);
            foreach (var p in path)
                tex.SetPixel(p.x, p.y, Color.yellow);
        }

        tex.filterMode = FilterMode.Point;
        tex.Apply();
        return tex;
    }

    private Vector2Int FindStart(int[,] map) { return Vector2Int.zero; }
    private Vector2Int FindEnd(int[,] map) { return Vector2Int.zero; }
    private List<Vector2Int> FindShortestPath(int[,] map,
        Vector2Int start, Vector2Int end) { return null; }
    private DungeonValidator validator = new DungeonValidator();
}