企业官网建设流程全解析

做仿元气骑士这类 Roguelike 随机地图时，最容易判断失误的地方不是画地图的算法，而是“地图到底由谁生成”。我们在服务器联机版里先做了客户端生成，结果几个客户端各跑各的，房间布局完全不同，怪物刷新逻辑也各自为政。后来改成由服务器统一生成并下发地图，问题才转移到“如何让生成过程稳定、可复现，并且能通过种子回放复盘”。本文记录的正是这个版本的第一份开发日志：仿元气骑士随机地图生成的模块设计与实现。

如果你以为随机地图生成就是“随机撒房间，然后画几扇门”，可以把期望放低一点。真正落地时，要同时解决四个问题：房间不会重叠、所有房间彼此可达、入口和出口位置明确、同一种子能复现同一张地图。这四个问题分别对应布局采样、连通图构造、门标记和随机数确定性，环环相扣，少一个都会在后续联机同步时暴露出来。

这篇文章会从服务器端开发的角度，把这套随机地图生成方案完整拆开：核心概念、数据结构、生成算法、Java 代码实现、验证方法以及踩坑记录。读完你可以直接把这套流程搬到自己的项目里，先跑通最小可用版本，再按项目需要扩展房间类型、楼层主题和怪物分布。

1. 地图生成模块为什么放在服务器端

先聊一个基础问题：明明是客户端游戏，为什么地图生成要放在服务器端？

传统单机 Roguelike 游戏在客户端生成地图是非常正常的做法，因为不存在多人同步问题。但一旦上服务器联机，地图生成的位置就变成架构决策。如果让每个客户端自己生成地图，会出现三种典型问题。

第一种是地图不一致。相同种子在不同客户端上未必产生相同结果，尤其当生成代码依赖浮点运算、哈希遍历顺序或本地配置时，两个设备可能生成完全不同的房间布局。第二种是安全不可控。客户端掌握地图数据，等于把所有房间类型、宝箱位置、Boss 房间都暴露给玩家，恶意客户端可以直接改内存看穿全图。第三种是逻辑可信度低。服务器要做怪物寻路、掉落校验和房间状态管理，如果地图是客户端给的，服务器只能选择信任客户端数据，这在对抗性场景里是灾难。

所以我们的结论很明确：服务器是地图数据的权威来源。客户端只负责接收地图快照并渲染，服务器在开局前生成完整地图结构，之后把序列化结果下发。这个决定并不复杂，但它直接影响后续的算法选择。因为服务器端生成意味着我们不能依赖任何图形化编辑器，生成逻辑必须是纯函数式的：种子加参数进入，地图数据结构出来，中间不读外部状态。

这篇文章主要写给三类读者：正在做 Roguelike 或房间式随机地图的原生开发者；想了解服务器端程序化生成如何落地的后端同学；以及已经做好第一版地图但被“房间重叠”“入口不可达”折腾过的人。看到最后你会明白，随机地图生成不是单纯算法题，它更像一套需要服务意识的数据管线。

2. 房间式随机地图的核心概念与生成流程

元气骑士这类游戏的地图与以洞穴挖掘为主的迷宫地图不同，它属于典型的“房间式地图”。玩家看到的是一个个独立房间，房间之间通过门和走廊相连。每个房间有明确功能：战斗房、宝箱房、Boss 房、入口和出口。

2.1 房间式地图与迷宫地图的区别

迷宫式地图通常基于 DFS 回溯算法或普里姆算法生成，特征是通道密集、墙体和地面互相交织，地图呈网状。而房间式地图更像在画建筑设计图：先确定房间数量和大小，然后摆放矩形区域，最后在房间之间铺设走廊并生成门。

这里有个容易混淆的点：房间式地图并不排斥迷宫算法。很多成熟方案会在房间之间用挖洞算法连接，或者用迷宫算法填充房间之间的空白。关键区别在于“地图的基本单位”。迷宫的基本单位是格子，房间式地图的基本单位是房间对象。房间元数据比地形更重要，因为游戏逻辑需要知道哪里刷怪、哪里放宝箱、哪里是 Boss 区。只依赖二维数组的格子类型很难承载这些信息。

2.2 门、走廊与出入口

在房间式地图里，走廊负责连接房间，门负责标识房间边界。很多第一次实现的人会把门设计成“在墙上随机打洞”，这会导致房间入口太多或者走廊形同虚设。比较稳的做法是：走廊生成完毕后，统一扫描地图，凡是“两侧都是地板”的墙格，就标记为门。这样门一定出现在走廊和房间的交界位置，不会出现在房间内部。

入口和出口通常不是特殊的房间，而是房间内某个位置。入口房间可以是第一间房，出口房间可以是最后一间房。我们在地图上用单独的枚举值标记这两个点，方便玩家出生和关卡结束判定。

2.3 随机种子与可复现性

服务器生成地图必须支持“输入同一种子，输出同一张图”。这要求所有随机操作都使用同一个Random实例，且调用顺序固定。一旦中间插入一个不稳定的随机调用，比如依赖系统时间或集合迭代顺序，同一种子就会产出不同地图。

可复现性的价值不只是测试方便，它还让问题反馈变得可靠。玩家线上遇到某张地图有问题，只要上报种子和服务端参数，开发本地就能用相同种子复现问题，比让玩家截图高效得多。

2.4 整体生成流程

一个最小可用的房间式随机地图生成流程如下：

1. 根据种子创建随机数发生器。
2. 初始化二维网格，全部填充为墙体。
3. 在网格上随机尝试放置房间，要求房间之间不重叠且保留间距。
4. 对所有房间按坐标排序，依次用 L 型走廊连接相邻房间。
5. 扫描地图，把走廊与房间交界处的墙体标记为门。
6. 指定第一间房为入口房间，最后一间房为出口房间。

这套流程没有使用复杂的空间分割，但已经能稳定产出可玩的房间地图。它的缺陷是房间分布不够均匀，联机体验可以接受，后面再升级 BSP 或泊松盘采样。

2.5 客户端生成与服务端生成的对比

对我们这个联机项目来说，服务器端生成的收益明显大于网络成本，所以在架构上采用了服务端生成方案。

3. 开发环境与项目结构

这篇日志的示例代码使用 Java 实现，主要考虑是后续要复用同一套地图生成器到游戏服务端，Java 的天然可移植性和稳定随机数实现比较合适。本文不依赖任何游戏引擎或第三方地图库，只有 JDK 自带的集合和随机工具类。

3.1 环境版本说明

建议使用 JDK 8 或更高版本，本文代码用到了泛型、枚举和 Lambda 表达式，JDK 8 以上都能编译。没有引入 Spring 等框架，避免干扰对地图生成核心逻辑的理解。Maven 不是必须的，你完全可以用javac编译，或者直接新建一个 IDE 工程。

3.2 项目目录结构

src/main/java/com/example/mapgen/ ├── Main.java ├── generator/ │ └── RandomMapGenerator.java ├── model/ │ ├── MapGenerateResult.java │ ├── Room.java │ ├── RoomType.java │ └── TileType.java └── printer/ └── MapPrinter.java

目录划分参考：

• model：地图相关的数据对象和枚举。
• generator：地图生成核心算法，包含放置房间、连接走廊、标记门等逻辑。
• printer：控制台输出工具，用于调试时预览地图。
• Main：演示入口。

这个结构足够小，也便于后续继续加楼层生成器、房间类型分配器等模块。

3.3 是否引入第三方依赖

不引入第三方依赖。Random足够做房间布局，ArrayList足够管理房间列表。如果后续要做复杂的不规则多边形房间，再考虑jts这类几何库。过早引入依赖会让最核心的生成逻辑变得难以调试，尤其是我们还要保证“同种子同输出”，第三方库的内部迭代顺序可能成为不确定源。

4. 地图数据结构设计

数据结构决定了生成算法的表达成本。我们选择“二维网格 + 房间对象列表”双轨制：网格负责记录每个格子的地形类别，房间对象列表负责记录每个房间的功能属性和坐标范围。

4.1 地形单元格枚举 TileType

package com.example.mapgen.model; public enum TileType { WALL(0), FLOOR(1), DOOR(2), ENTRY(3), EXIT(4); private final int code; TileType(int code) { this.code = code; } public int getCode() { return code; } public static TileType fromCode(int code) { for (TileType type : values()) { if (type.code == code) { return type; } } throw new IllegalArgumentException("未知的地图格子类型: " + code); } }

TileType用枚举比直接用数字更安全。后续序列化时把code写入协议，客户端拿到后调用fromCode解析即可。WALL和FLOOR是最基础的两类，DOOR用于门，ENTRY和EXIT用于入口和出口。

4.2 房间对象 Room

package com.example.mapgen.model; public class Room { private final int id; private final int x; private final int y; private final int width; private final int height; private final int centerX; private final int centerY; private final RoomType type; public Room(int id, int x, int y, int width, int height, RoomType type) { this.id = id; this.x = x; this.y = y; this.width = width; this.height = height; this.centerX = x + width / 2; this.centerY = y + height / 2; this.type = type; } public boolean intersects(Room other, int padding) { return this.x < other.x + other.width + padding && other.x < this.x + this.width + padding && this.y < other.y + other.height + padding && other.y < this.y + this.height + padding; } public int getId() { return id; } public int getX() { return x; } public int getY() { return y; } public int getWidth() { return width; } public int getHeight() { return height; } public int getCenterX() { return centerX; } public int getCenterY() { return centerY; } public RoomType getType() { return type; } }

Room记录房间左上角坐标和宽高。centerX和centerY是房间中心，走廊连接时直接使用中心点计算路径。intersects方法带了一个padding参数，用来控制房间之间最少保留几格间距，这个参数可以避免出现两个房间贴在一起导致门的位置混乱。

4.3 房间类型 RoomType

package com.example.mapgen.model; public enum RoomType { BATTLE, TREASURE, BOSS, ENTRANCE, EXIT }

当前版本所有房间默认都是BATTLE，入口和出口在地图生成完成后单独指定。后续要生成特殊房间时，可以在放置阶段给房间赋不同类型，然后在连接走廊时优先保证 Boss 房和其他房间连通。

4.4 生成结果 MapGenerateResult

package com.example.mapgen.model; import java.util.List; public class MapGenerateResult { private final TileType[][] grid; private final List<Room> rooms; private final long seed; public MapGenerateResult(TileType[][] grid, List<Room> rooms, long seed) { this.grid = grid; this.rooms = rooms; this.seed = seed; } public TileType[][] getGrid() { return grid; } public List<Room> getRooms() { return rooms; } public long getSeed() { return seed; } }

生成器返回的结果同时包含网格和房间列表。后续怪物刷新、宝箱生成、侦探房间遍历都可以从这两个对象中取数据。seed保留下来是为了日志回放。

4.5 为什么不用纯二维数组

如果只用二维数组，房间边界信息会丢失。比如你知道了某个格子是地板，但不知道它属于哪个房间，就无法判断玩家是否已经进入 Boss 房。所以必须维护一份房间列表，并且让网格和房间列表指向同一份数据。这也是“房间式地图”和“格子式地图”在代码层面的最大差异。

5. 生成算法拆解：放置、连通、门与出入口

这一节把生成过程拆成独立步骤，每个步骤都有明确的输入输出和失败模式。

5.1 初始化网格

生成器创建时并不初始化地图，而是在generate方法被调用时才执行initGrid。这样做是为了让同一个生成器实例能够多次调用，每次传入不同种子生成不同地图。初始化就是把二维数组全部设为WALL，这是所有后续操作的地基。

5.2 随机放置房间

放置房间采用“随机采样 + 碰撞检测 + 尝试次数上限”的方案。每次循环随机生成房间的宽、高和左上角坐标，然后和已有房间做重叠检测。如果重叠，就放弃本次尝试并继续。为了避免极端情况下无限循环，我们设置了最大尝试次数。

放置阶段的坑集中在两点。第一是地图尺寸和房间尺寸比例不协调，地图太小而房间太大，会导致几乎无法找到空闲位置。第二是坐标范围计算不严谨，房间可能贴边甚至越界。我的做法是让坐标范围从 1 开始，并且减去房间宽高和边界保留值。

5.3 连通房间

房间放置完成后，地图上有若干个独立的矩形区域，彼此没有通路。连接方案采用“排序后相邻连接”：先按房间中心的 X 坐标排序，X 相同则按 Y 坐标排序，然后顺序连接相邻两间房。

连接方式选用 L 型走廊。所谓 L 型走廊，就是从房间中心先水平走到另一个房间中心所在的列，再垂直走到目标房间中心。由于走廊从房间中心出发，相当于在房间里也画出了一条地板通道，虽然视觉上不那么完美，但功能上能保证房间之间的连通性。

5.4 标记门

走廊打通后，房间和走廊交界的位置会出现“两侧都是地板，中间夹一个墙体”的形态。此时扫描整个网格，如果某个墙格的上方和下方都是地板，或者左侧和右侧都是地板，就把它标记为DOOR。

这个方案简单，但会产生少量误判。比如两条走廊并排经过一个墙格，也可能被标记成门。生产环境如果要严格控制门的数量和位置，可以在生成走廊时记录边界点坐标，再基于边界点标记门。本文先采用扫描法，因为它的代码最直观，也能满足最小版本需求。

5.5 设置入口和出口

房间放置时是有顺序的，第一个放下的房间作为入口房间，最后一个放下的房间作为出口房间。在地图网格上，把这两个房间的中心点分别标记为ENTRY和EXIT。

入口出口的选择不一定要依赖房间顺序，后续可以按离地图中心距离、房间类型规则等条件选择。但在最小实现里，顺序是最可靠也最容易解释的选择。

6. 完整 Java 代码实现

下面给出所有核心代码文件，请按项目目录结构放到你的工程里。

6.1 地图生成器 RandomMapGenerator

package com.example.mapgen.generator; import com.example.mapgen.model.MapGenerateResult; import com.example.mapgen.model.Room; import com.example.mapgen.model.RoomType; import com.example.mapgen.model.TileType; import java.util.ArrayList; import java.util.Comparator; import java.util.List; import java.util.Random; public class RandomMapGenerator { private final int rows; private final int cols; private final TileType[][] grid; private final List<Room> rooms; private Random random; public RandomMapGenerator(int rows, int cols) { this.rows = rows; this.cols = cols; this.grid = new TileType[rows][cols]; this.rooms = new ArrayList<>(); } public MapGenerateResult generate(long seed, int maxRoomCount) { this.random = new Random(seed); this.rooms.clear(); initGrid(); placeRooms(maxRoomCount); connectRooms(); markDoors(); setEntryAndExit(); return new MapGenerateResult(grid, rooms, seed); } private void initGrid() { for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { grid[i][j] = TileType.WALL; } } } private void placeRooms(int maxRoomCount) { int maxAttempts = 200; int attempts = 0; while (rooms.size() < maxRoomCount && attempts < maxAttempts) { attempts++; int width = 5 + random.nextInt(6); int height = 4 + random.nextInt(5); int x = 1 + random.nextInt(Math.max(1, cols - width - 2)); int y = 1 + random.nextInt(Math.max(1, rows - height - 2)); Room candidate = new Room(rooms.size(), x, y, width, height, RoomType.BATTLE); if (canPlace(candidate)) { rooms.add(candidate); paintRoom(candidate); } } } private boolean canPlace(Room candidate) { for (Room room : rooms) { if (room.intersects(candidate, 2)) { return false; } } return true; } private void paintRoom(Room room) { for (int i = room.getY(); i < room.getY() + room.getHeight(); i++) { for (int j = room.getX(); j < room.getX() + room.getWidth(); j++) { grid[i][j] = TileType.FLOOR; } } } private void connectRooms() { if (rooms.size() <= 1) { return; } List<Room> sorted = new ArrayList<>(rooms); sorted.sort(Comparator.comparingInt(Room::getCenterX) .thenComparingInt(Room::getCenterY)); for (int i = 0; i < sorted.size() - 1; i++) { Room from = sorted.get(i); Room to = sorted.get(i + 1); buildCorridor(from, to); } } private void buildCorridor(Room from, Room to) { int x1 = from.getCenterX(); int y1 = from.getCenterY(); int x2 = to.getCenterX(); int y2 = to.getCenterY(); if (random.nextBoolean()) { buildHorizontalCorridor(x1, x2, y1); buildVerticalCorridor(y1, y2, x2); } else { buildVerticalCorridor(y1, y2, x1); buildHorizontalCorridor(x1, x2, y2); } } private void buildHorizontalCorridor(int x1, int x2, int row) { for (int col = Math.min(x1, x2); col <= Math.max(x1, x2); col++) { setFloor(row, col); } } private void buildVerticalCorridor(int y1, int y2, int col) { for (int row = Math.min(y1, y2); row <= Math.max(y1, y2); row++) { setFloor(row, col); } } private void setFloor(int row, int col) { if (row >= 0 && row < rows && col >= 0 && col < cols) { grid[row][col] = TileType.FLOOR; } } private void markDoors() { for (int i = 1; i < rows - 1; i++) { for (int j = 1; j < cols - 1; j++) { if (grid[i][j] != TileType.WALL) { continue; } boolean verticalDoor = grid[i - 1][j] == TileType.FLOOR && grid[i + 1][j] == TileType.FLOOR; boolean horizontalDoor = grid[i][j - 1] == TileType.FLOOR && grid[i][j + 1] == TileType.FLOOR; if (verticalDoor || horizontalDoor) { grid[i][j] = TileType.DOOR; } } } } private void setEntryAndExit() { if (rooms.isEmpty()) { return; } Room entry = rooms.get(0); Room exit = rooms.get(rooms.size() - 1); grid[entry.getCenterY()][entry.getCenterX()] = TileType.ENTRY; grid[exit.getCenterY()][exit.getCenterX()] = TileType.EXIT; } }

这段代码的关键逻辑集中在placeRooms和connectRooms。placeRooms保证房间不重叠，connectRooms保证所有房间在逻辑上连通。这里的连通不是实时计算出来的，而是构造出来的：因为相邻房间之间必然有走廊，而排序后的房间链覆盖所有房间，所以整张地图一定是连通的。

6.2 控制台打印器 MapPrinter

package com.example.mapgen.printer; import com.example.mapgen.model.TileType; public class MapPrinter { public static void print(TileType[][] grid) { for (TileType[] row : grid) { StringBuilder sb = new StringBuilder(); for (TileType tile : row) { switch (tile) { case WALL: sb.append('#'); break; case FLOOR: sb.append(' '); break; case DOOR: sb.append('+'); break; case ENTRY: sb.append('E'); break; case EXIT: sb.append('B'); break; default: sb.append('?'); break; } } System.out.println(sb.toString()); } } }

打印器的作用是快速验证生成结果。每次修改算法后，在本地看一眼俯视地图，比盯着调试器高效得多。字符含义：#墙，空格表示地板，+门，E入口，B出口英文 Boss 首字母也可以理解为终点。

6.3 演示入口 Main

package com.example.mapgen; import com.example.mapgen.generator.RandomMapGenerator; import com.example.mapgen.model.MapGenerateResult; import com.example.mapgen.printer.MapPrinter; public class Main { public static void main(String[] args) { RandomMapGenerator generator = new RandomMapGenerator(45, 60); long seed = 20240810L; MapGenerateResult result = generator.generate(seed, 12); MapPrinter.print(result.getGrid()); System.out.println("生成房间数量: " + result.getRooms().size()); System.out.println("使用种子: " + result.getSeed()); } }

运行Main后，控制台会打印一张字符地图。字符地图中可以看到若干矩形空白区域，那就是房间；连接这些区域的细长空白是走廊；边界上的加号是门。入口标记为E，出口标记为B。

7. 运行效果与连通性验证

7.1 运行方式

直接在 IDE 中运行Main，或者在命令行执行：

javac -d out src/main/java/com/example/mapgen/**/*.java src/main/java/com/example/mapgen/Main.java java -cp out com.example.mapgen.Main

如果是 Maven 工程，执行mvn compile后再运行Main即可。

7.2 示意输出

下面是一张 45 行 x 60 列地图的示意输出，不同种子会得到不同结果：

############################################################ #### #### #################### #### E #### + + #################### #### #### ################ #################### #### #### ################ #################### ########## ######++################ #################### ########## ######+################ #################### ########## #### #################### ########## + #### + #################### ########## ######### ############################### ########## ######### ############################### ########## ############################### #### + #### ######################### #### #################### ######################### #### #################### + ######################### #### #################### ########################### #### ############################ ############################################################

只看字符输出，足以判断房间是否重叠、走廊是否连通、门是否出现在合理位置。

7.3 连通性自动验证

人工看字符地图只能解决浅层问题，无法保证 10000 张地图都连通。更可靠的方案是写一个广度优先遍历验证器：从入口位置出发，统计能到达的所有非墙格子数量。如果这个数量等于地图中所有非墙格子数量，说明地图连通。

public int countReachableTiles(TileType[][] map, int startRow, int startCol) { int rows = map.length; int cols = map[0].length; boolean[][] visited = new boolean[rows][cols]; int[] dr = {-1, 1, 0, 0}; int[] dc = {0, 0, -1, 1}; int reachable = 0; Deque<int[]> queue = new ArrayDeque<>(); queue.add(new int[]{startRow, startCol}); visited[startRow][startCol] = true; while (!queue.isEmpty()) { int[] current = queue.poll(); reachable++; for (int k = 0; k < 4; k++) { int nr = current[0] + dr[k]; int nc = current[1] + dc[k]; if (nr < 0 || nr >= rows || nc < 0 || nc >= cols) { continue; } if (visited[nr][nc]) { continue; } if (map[nr][nc] == TileType.WALL) { continue; } visited[nr][nc] = true; queue.add(new int[]{nr, nc}); } } return reachable; }

调用上面方法时，传入入口坐标和地图。如果结果等于地图非墙格子总数，说明从入口可以到达所有地板、门和出口，这张地图是合格的。建议在服务端启动时对种子池做批量验证，把不满足连通性的种子直接剔除。

7.4 如何判断生成成功

判断成功的标准很简单：

1. 地图中没有明显重叠房间。
2. 入口房间、出口房间都存在于地图中。
3. 从入口位置出发能到达出口位置。
4. 同一种子重复生成两次，地图内容完全一致。

前三条可以通过 BFS 验证器自动化完成；最后一条需要在测试里固定种子生成两次并比较数据。

8. 常见问题与排查思路

每张表里的问题都不是理论问题，而是我们迭代过程中真实碰到过的。最常见的是“房间放不下”和“门数量异常”。房间放不下通常是地图尺寸和房间尺寸配比不合理，门数量异常则是标记算法太粗糙。

9. 最佳实践与工程建议

9.1 把生成器写成纯函数

生成器的推荐形态是：MapGenerateResult generate(long seed, int maxRoomCount)。同一种子加同样的参数，返回完全一致的结果。不要在生成过程中读取当前时间、读取系统变量或者依赖外部单例状态，否则一切排查都会变成无底洞。

9.2 日志记录种子和关键参数

服务器每次生成地图时，至少记录以下字段：种子、地图宽高、期望房间数、实际房间数、生成耗时。这些日志是线上问题排查的第一手资料。玩家反馈地图异常时，可以直接用日志里的种子本地生成，比对问题是否复现。

9.3 失败重试而不是返回错误地图

如果实际生成的房间数量低于期望值，说明本次随机布局质量较差。比起返回一张只有几个房间的地图，不如换一个种子重新生成。可以在服务端维护一个种子序列，生成失败时顺序取下一个种子，重试三次仍失败才报错。

9.4 地图序列化与协议设计

服务器生成地图后，不能直接把二维数组下发，因为原始数组体积大且结构不清晰。需要设计紧凑协议：先写宽高、种子，再写房间数量，然后逐个房间写坐标和类型，最后写门列表。客户端根据这些信息重建房间对象和地形网格。

9.5 防线：边界检查和数组越界

房间坐标和走廊坐标都必须做边界检查。尤其当走廊从地图边缘穿过时，越界访问会产生数组异常。一个好的习惯是封装setFloor方法，在方法内部统一做边界判断，而不是在调用处散落判断逻辑。

9.6 性能规划

地图生成的耗时一般不会是瓶颈，但要注意规模变化。如果地图扩大到 200 x 200，且放置房间尝试次数为 5000，单次生成耗时会有明显上涨。可以把这个生成过程放到服务器启动预热阶段完成，而不是等玩家上线时现场生成。

9.7 版本兼容

地图生成算法一旦上线，不要轻易改变同一种子下的生成结果。如果算法升级，要使用新的种子命名空间，比如种子后面加版本号。否则同一关在旧版本和新版本中生成不同地图，玩家会感到困惑，线上记录也会失配。

10. 总结与后续扩展方向

这篇日志从服务器端视角，完整记录了一个仿元气骑士随机地图生成模块的设计与实现。核心收获可以总结为四点：地图生成必须由权威服务器完成，才不会在联机场景出现一致性问题；房间式地图要用“网格加房间对象”双轨结构，才能同时承载地形和游戏逻辑；连通性不是靠运气，而是靠有序连接构造出来；可复现性是服务器生成的基本要求，它让调试和反馈闭环成为可能。

当前版本虽然可玩，但距离完整关卡体验还有不少路要走。比较自然的下一步是按楼层扩展主题：第一层普通战斗房偏多，第二层增加宝箱房和特殊事件房，第三层让 Boss 房固定在出口附近。算法层面可以用 BSP 二叉树分割替代当前的随机采样，让房间分布更均匀。连通关系上也可以引入最小生成树控制走廊数量，让地图有主路和支路的区别。如果你正在做同类项目，建议先跑通本文这套最小代码，再加自己的特殊房间和敌人刷新逻辑。

顺带提醒一句：字符打印器不要丢，它会在后续几个月的地图调试里一直陪着你。每当算法调不明白，先把地图打印出来看看，往往几分钟就能定位问题。