当前位置：首页 > news >正文

Godot 4.2 伪随机数完全掌控指南：从种子原理到 Roguelike 实战

news 2026/7/12 4:33:00

1. 项目概述：为什么我们需要“掌控”伪随机数？

在游戏开发里，随机性无处不在。从敌人随机掉落物品，到地图的随机生成，再到角色属性的随机波动，它让每一次游戏体验都独一无二。但如果你用过 Godot 自带的randi()或randf()，可能会遇到一个头疼的问题：每次重启游戏，敌人的掉落、地图的布局都变了样。这对于需要固定关卡种子、或者需要复现特定 Bug 进行调试的开发者来说，简直是灾难。

这就是“伪随机数”的“伪”字带来的核心矛盾：我们既需要它看起来随机，又需要在某些时候，它能完全按照我们的剧本走。Godot 4.2 提供的RandomNumberGenerator类，就是我们解决这个矛盾的钥匙。它允许我们通过一个“种子”来初始化随机序列，从而实现对随机过程的完全复现和精细控制。

简单说，这个项目就是教你如何在 Godot 4.2 中，告别“听天由命”的随机，实现“一切尽在掌握”的伪随机。我们将从种子的原理讲起，一步步深入到如何生成、管理、应用可预测的随机序列，最终让你能在自己的项目中，无论是 Roguelike 地牢、随机事件系统还是程序化生成内容，都能做到收放自如。

2. 核心概念拆解：种子、状态与序列

在深入代码之前，我们必须先理清三个核心概念：种子、状态和序列。很多开发者对它们的理解是模糊的，而这恰恰是掌控随机数的关键。

2.1 种子：一切的起点

种子是一个整数，它是整个伪随机数序列的“总开关”。你可以把它想象成一本无限长小说的第一句话。只要第一句话定了，整本小说的后续情节（随机数序列）就完全确定了。

在 Godot 中，我们通过设置RandomNumberGenerator的seed属性来初始化它。

var rng = RandomNumberGenerator.new() rng.seed = 12345

这里，12345就是种子。此后，从这个rng对象生成的每一个随机数，其顺序都已经被12345这个种子唯一确定了。

注意：Godot 文档明确警告，其 RNG 实现（PCG32）不具备“雪崩效应”。这意味着如果两个种子数值上很接近（比如 12345 和 12346），它们产生的初始随机数序列也可能非常相似。如果你的种子来自用户输入或时间戳等连续值，建议先用哈希函数（如hash()）处理一下，打散其相关性。
rng.seed = hash(str(OS.get_unix_time()) + “my_game_secret_salt”)

2.2 状态：序列的“书签”

如果说种子决定了整本小说，那么状态就是你现在读到哪一页了。RandomNumberGenerator.state属性代表了生成器内部当前的精确位置。

每次你调用randi()或randf()，这个状态都会向前推进（就像翻了一页书）。保存这个状态，就等于保存了当前的阅读进度。

var rng = RandomNumberGenerator.new() rng.seed = 100 print(rng.randi()) # 假设输出 A var saved_state = rng.state # 保存状态 print(rng.randi()) # 输出 B rng.state = saved_state # 回滚状态 print(rng.randi()) # 再次输出 B，而不是 C

这个特性极其有用！比如在一个回合制游戏中，玩家可以在行动前“存档”。如果行动使用了随机数（比如攻击是否暴击），你可以先保存 RNG 状态，让玩家执行行动，如果结果不满意，读档时不仅恢复游戏数据，也恢复 RNG 状态，就能让整个随机过程完全回退，实现真正的“悔棋”。

重要警告：state是一个内部表示，不要试图给它赋一个你自己编的“任意值”。它必须来自之前rng.state的返回值。错误的 state 值会导致 RNG 进入不可预测的混乱状态。初始化请永远使用seed，回滚时才用state。

2.3 序列：可预测的“随机”流

由特定种子确定的一连串随机数，就是一个序列。理解序列的“可预测性”是实战的基础。例如：

var rng1 = RandomNumberGenerator.new() rng1.seed = 777 var a1 = rng1.randi_range(1, 100) var b1 = rng1.randi_range(1, 100) var rng2 = RandomNumberGenerator.new() rng2.seed = 777 # 相同种子 var a2 = rng2.randi_range(1, 100) var b2 = rng2.randi_range(1, 100) print(a1 == a2 and b1 == b2) # 输出：true

a1必然等于a2，b1必然等于b2。这就是序列的可复现性。在多人游戏网络同步、或者需要保证不同客户端生成相同随机环境的场景下，这是基石。

3. 全局随机与局部随机：如何选择与设计

Godot 提供了两套随机数接口：全局作用域的便捷函数（如randi()、randf()）和RandomNumberGenerator类。选择哪一套，取决于你的需求。

3.1 全局随机：简单但不便控制

@GlobalScope中的函数，如randi()、randf_range()，使用一个引擎全局共享的 RNG 实例。它的种子在项目启动时由randomize()自动设置（通常基于系统时间）。

优点：使用极其方便，无需实例化对象。
致命缺点：你无法控制其种子，也无法保存/恢复其状态。它的随机序列是“一次性”的，无法复现。这仅适用于“一次性装饰性随机”，比如菜单粒子飘散的方向，但不适用于任何需要确定性结果的游戏逻辑。

3.2 RandomNumberGenerator：精细控制的利器

这是我们项目的主角。你需要显式创建实例，并管理其生命周期。

优点：
1. 独立控制：每个实例有自己的种子和状态，互不干扰。
2. 状态保存：可实现随机过程的回滚和复现。
3. 序列隔离：可以为游戏的不同系统（如地图生成、战斗计算、物品掉落）创建独立的 RNG 实例，避免一个系统的随机调用影响另一个系统的预期序列。
缺点：需要额外的代码来创建和管理。

3.3 实战架构设计：多RNG实例管理

在一个中型以上项目中，我强烈建议采用“多RNG实例”架构。下面是一个可参考的单例模式实现，用于集中管理不同用途的 RNG：

# RandomManager.gd extends Node # 预定义不同系统使用的RNG键名 enum RNGType { WORLD_GEN, # 世界生成 ENCOUNTER, # 遭遇战 LOOT, # 物品掉落 DIALOGUE, # 对话分支 UI_EFFECT # UI特效 } var _rng_pool: Dictionary = {} func _ready(): # 初始化时，为每种类型创建独立的RNG实例 for type in RNGType.values(): var new_rng = RandomNumberGenerator.new() # 可以使用一个基础种子加上类型的偏移，确保不同系统序列不同但可预测 new_rng.seed = hash(“BaseSeed123”) + type _rng_pool[type] = new_rng # 获取指定类型的RNG实例 func get_rng(type: RNGType) -> RandomNumberGenerator: return _rng_pool.get(type) # 重设所有RNG的种子（例如，载入新游戏时） func reset_all_seeds(base_seed: int): for type in RNGType.values(): _rng_pool[type].seed = base_seed + type # 保存所有RNG的状态（用于游戏存档） func save_states() -> Dictionary: var states = {} for type_name in RNGType.keys(): states[type_name] = _rng_pool[RNGType[type_name]].state return states # 加载所有RNG的状态（用于游戏读档） func load_states(saved_states: Dictionary): for type_name in saved_states.keys(): if RNGType.has(type_name): _rng_pool[RNGType[type_name]].state = saved_states[type_name]

这样，在游戏逻辑中，你可以清晰地隔离随机源：

# 在地图生成中 var world_rng = RandomManager.get_rng(RandomManager.RNGType.WORLD_GEN) var room_type = world_rng.randi_range(0, 3) # 在战斗计算中 var encounter_rng = RandomManager.get_rng(RandomManager.RNGType.ENCOUNTER) var is_critical = encounter_rng.randf() < critical_chance

这种设计让调试变得异常简单。如果发现物品掉落序列有问题，你只需要检查LOOT类型的 RNG 调用记录，而不用在成千上万行代码中寻找是哪个randi()影响了结果。

4. 从理论到实践：核心API详解与避坑指南

现在，我们深入RandomNumberGenerator的每一个方法，并结合实际案例，看看如何正确使用以及如何避开常见的坑。

4.1 基础生成：整型与浮点

randi(): 返回 0 到 4294967295 之间的无符号整数。范围极大，通常需要取模来得到可用范围。
```
var rng = RandomNumberGenerator.new() var massive_num = rng.randi() # 可能是一个非常大的数 var dice_roll = rng.randi() % 6 + 1 # 模拟1-6的骰子
```
注意：使用取模（%）操作来限定范围时，如果模数不是2的幂，会导致轻微的非均匀分布（因为大范围整数域不能被小模数整除）。对于要求严格均匀分布的场景（如抽奖），更推荐使用randi_range。

randi_range(from: int, to: int):这是最常用、最安全的方法。生成[from, to]闭区间内的整数，且保证均匀分布。

var damage = rng.randi_range(25, 35) # 25到35之间的伤害值，包含35 var array_index = rng.randi_range(0, my_array.size() - 1) # 随机数组索引

randf(): 返回[0.0, 1.0]区间的浮点数。这是生成概率和比例的基础。
```
if rng.randf() < 0.3: # 30%的概率触发 spawn_enemy()
```
randf_range(from: float, to: float): 生成[from, to]闭区间内的浮点数。非常适合需要在一定范围内连续随机的情况。
```
var random_scale = rng.randf_range(0.8, 1.2) # 模型缩放 var random_angle = rng.randf_range(0, TAU) # 随机角度（0到2π）
```

4.2 高级分布：正态分布与加权随机

randfn(mean: float, deviation: float): 生成服从正态分布（高斯分布）的随机数。mean是均值（中心点），deviation是标准差（数据离散程度）。
```
# 生成平均身高为1.7米，标准差为0.1米的身高数据 var height = rng.randfn(1.7, 0.1) # 大部分height会落在 [1.6, 1.8] 之间，极端值较少。
```
应用场景：模拟自然现象（如生物属性分布）、武器伤害波动（大部分伤害集中在中值附近）、随机点分布（避免过于均匀）。
rand_weighted(weights: PackedFloat32Array):Godot 4.2 的利器。根据权重数组返回随机索引。这是实现复杂掉落表、技能随机释放的终极工具。
```
var loot_table = [“普通药水”, “魔法戒指”, “传奇宝剑”, “空”] var weights = PackedFloat32Array([50.0, 30.0, 5.0, 15.0]) # 概率权重，无需总和为100 var loot_index = rng.rand_weighted(weights) print(“你获得了：” + loot_table[loot_index])
```
算法解读：该方法内部会将权重数组转换为累积概率分布。例如，权重[50, 30, 5, 15]的总和为100。它会生成一个0-100的随机数，落在0-50则返回索引0，落在50-80返回索引1，以此类推。权重为0的元素永远不会被选中。
实操心得：rand_weighted比手动写循环累加权重然后比较随机数要高效和清晰得多。务必使用PackedFloat32Array而不是普通 Array，以获得最佳性能。

4.3 初始化和重置

randomize(): 基于当前时间（通常是OS.get_ticks_usec()）为 RNG 实例设置一个“随机”的种子。每个 RNG 实例需要单独调用。如果你希望游戏每次启动都有不同的随机体验，可以在主 RNG 初始化时调用。
```
func _ready(): $RandomManager/MainRNG.randomize() # 注意：这会使该RNG的序列不可复现，慎用于核心逻辑RNG。
```
seed和state的设置如前所述，是实现确定性的关键。

5. 实战案例：构建一个可预测的 Roguelike 地牢生成器

让我们用一个完整的、可运行的例子，把上面的知识串起来。目标是创建一个地牢生成器，只要种子相同，生成的地牢布局就完全一致。

5.1 设计思路

整体结构：使用“房间和走廊”的经典模式。
确定性：所有随机决策（房间位置、大小、连接）都基于一个主 RNG。
模块化：将不同步骤（房间生成、走廊连接、装饰放置）的随机调用隔离，但共享同一个 RNG 序列，保证整体可复现。

5.2 代码实现

# DungeonGenerator.gd extends Node2D class_name DungeonGenerator @export var seed_value: int = 0 # 在编辑器中可设置种子 @export var map_width: int = 50 @export var map_height: int = 50 @export var room_count: int = 10 @export var min_room_size: int = 4 @export var max_room_size: int = 8 var _rng: RandomNumberGenerator var _rooms: Array[Rect2i] = [] # 存储房间的矩形区域 var _tilemap: TileMap func _ready(): _tilemap = $TileMap as TileMap generate_dungeon(seed_value if seed_value != 0 else OS.get_unix_time()) func generate_dungeon(used_seed: int): # 1. 初始化RNG _rng = RandomNumberGenerator.new() _rng.seed = used_seed print(“地牢种子: ”, used_seed) # 清空现有数据 _rooms.clear() _tilemap.clear() # 2. 生成房间 _generate_rooms() # 3. 连接房间（使用最小生成树算法，如Prim） _connect_rooms() # 4. 填充TileMap _fill_tilemap() func _generate_rooms(): for i in range(room_count): var attempt = 0 var room_placed = false # 尝试放置房间，避免重叠 while attempt < 100 and not room_placed: var width = _rng.randi_range(min_room_size, max_room_size) var height = _rng.randi_range(min_room_size, max_room_size) var x = _rng.randi_range(1, map_width - width - 1) var y = _rng.randi_range(1, map_height - height - 1) var new_room = Rect2i(x, y, width, height) var overlap = false for existing_room in _rooms: # 扩大一个格子的边界作为缓冲，防止房间贴得太近 if new_room.grow(1).intersects(existing_room): overlap = true break if not overlap: _rooms.append(new_room) room_placed = true attempt += 1 if not room_placed: print(“房间 ”, i, ” 放置失败，尝试次数过多。”) func _connect_rooms(): if _rooms.size() <= 1: return # 简易连接：每个房间连接到下一个房间 for i in range(_rooms.size() - 1): var room_a = _rooms[i] var room_b = _rooms[i + 1] _create_h_tunnel(room_a.position.x, room_b.position.x, room_a.position.y + room_a.size.y / 2) _create_v_tunnel(room_a.position.y + room_a.size.y / 2, room_b.position.y + room_b.size.y / 2, room_b.position.x) func _create_h_tunnel(x1: int, x2: int, y: int): var start_x = min(x1, x2) var end_x = max(x1, x2) for x in range(start_x, end_x + 1): _set_tile(x, y, 1) # 1代表地板图块 func _create_v_tunnel(y1: int, y2: int, x: int): var start_y = min(y1, y2) var end_y = max(y1, y2) for y in range(start_y, end_y + 1): _set_tile(x, y, 1) func _fill_tilemap(): # 先画房间地板 for room in _rooms: for x in range(room.position.x, room.position.x + room.size.x): for y in range(room.position.y, room.position.y + room.size.y): _set_tile(x, y, 1) # 地板 # 然后画墙壁（地板周围是墙壁） var wall_cells = [] for room in _rooms: # 房间顶部和底部的墙 for x in range(room.position.x - 1, room.position.x + room.size.x + 1): _maybe_set_wall(x, room.position.y - 1) _maybe_set_wall(x, room.position.y + room.size.y) # 房间左侧和右侧的墙（不包括角，因为角已经被上下行画了） for y in range(room.position.y, room.position.y + room.size.y): _maybe_set_wall(room.position.x - 1, y) _maybe_set_wall(room.position.x + room.size.x, y) # 走廊的墙壁逻辑类似，这里为简化省略 func _maybe_set_wall(x: int, y: int): if _tilemap.get_cell_source_id(0, Vector2i(x, y)) == -1: # 如果当前格子是空的 _set_tile(x, y, 2) # 2代表墙壁图块 func _set_tile(x: int, y: int, tile_id: int): if x >= 0 and x < map_width and y >= 0 and y < map_height: _tilemap.set_cell(0, Vector2i(x, y), 0, Vector2i(tile_id, 0)) # 保存当前地牢的生成状态（种子和RNG状态），用于精确读档 func save_generation_state() -> Dictionary: return { “seed”: _rng.seed, “state”: _rng.state, “rooms”: _rooms.duplicate(true) # 深度复制房间数据 } # 加载地牢状态（例如，从存档中恢复一个未探索完的地牢） func load_generation_state(saved_state: Dictionary): _rng = RandomNumberGenerator.new() _rng.seed = saved_state[“seed”] _rng.state = saved_state[“state”] _rooms = saved_state[“rooms”] _fill_tilemap() # 重新绘制

代码解读与技巧：

种子驱动一切：generate_dungeon函数入口接受一个种子。所有后续的randi_range调用都依赖于这个种子初始化的_rng。
房间放置算法：使用了简单的随机位置+冲突检测。因为RNG是确定性的，所以只要种子相同，_rng.randi_range产生的宽度、高度、坐标序列就相同，最终房间布局必然相同。
状态保存：save_generation_state不仅保存了种子，还保存了_rng.state。这意味着如果你在地牢生成到一半时保存（比如生成了房间但还没画完走廊），读档时可以精确恢复到那一刻的RNG状态，继续未完成的生成步骤。这是实现“中断-继续”式程序化生成的关键。
性能注意：在_fill_tilemap中，我们遍历所有房间的每个格子来设置地板。对于大型地图，这可能成为性能瓶颈。在实际项目中，可以考虑分帧生成或使用更高效的数据结构（如AStar2D先处理连通性，再批量设置格子）。

5.3 扩展：为地牢添加随机装饰和敌人

有了确定性的基础，添加随机元素就很简单了，而且能保证可复现。

# 在 DungeonGenerator.gd 中新增函数 func _populate_dungeon(): # 使用一个独立的RNG来生成装饰和敌人，但种子与主RNG关联，保证整体可复现 var decor_rng = RandomNumberGenerator.new() decor_rng.seed = _rng.seed + 1 # 与主种子偏移，获得不同但确定的序列 for room in _rooms: # 每个房间随机放置1-3个装饰物（如罐子） var num_decor = decor_rng.randi_range(1, 3) for i in range(num_decor): var decor_x = decor_rng.randi_range(room.position.x + 1, room.position.x + room.size.x - 2) var decor_y = decor_rng.randi_range(room.position.y + 1, room.position.y + room.size.y - 2) # 假设图块集3是装饰物 _set_tile(decor_x, decor_y, 3) # 每个房间有30%概率生成一个敌人 if decor_rng.randf() < 0.3: var enemy_x = decor_rng.randi_range(room.position.x + 1, room.position.x + room.size.x - 2) var enemy_y = decor_rng.randi_range(room.position.y + 1, room.position.y + room.size.y - 2) _spawn_enemy_at(enemy_x, enemy_y) func _spawn_enemy_at(x: int, y: int): var enemy_scene = preload(“res://enemy.tscn”) var enemy = enemy_scene.instantiate() enemy.position = Vector2(x * _tilemap.tile_set.tile_size.x, y * _tilemap.tile_set.tile_size.y) add_child(enemy)

这里的关键是创建了一个新的decor_rng，但其种子来源于主种子加一个固定偏移。这保证了：

装饰和敌人的生成与地牢布局本身是解耦的。
只要主种子不变，装饰和敌人的分布也完全不变。
如果需要单独调整装饰的随机逻辑，不会影响地牢布局的 RNG 状态。

6. 常见问题与排查技巧实录

在实际使用RandomNumberGenerator时，你肯定会遇到一些坑。下面是我从项目中总结出来的典型问题及其解决方案。

6.1 问题：为什么我设置了相同的种子，但两次运行的结果还是不一样？

可能原因及排查：

全局随机函数的干扰：检查你的代码中是否混用了@GlobalScope的randi()和RandomNumberGenerator的randi()。全局函数有自己的独立序列，不受你的 RNG 实例控制。
- 解决：彻底弃用全局随机函数，所有随机逻辑都使用你自己的 RNG 实例。
RNG 调用顺序不一致：这是最常见的原因。假设你的生成逻辑是：先生成房间数，再为每个房间生成大小。如果两次运行中，生成房间数的randi_range被多调用了一次（比如因为某个条件分支不同），那么后续所有随机数的“读取位置”就全错位了。
- 排查：在关键节点打印 RNG 的状态或生成的随机数，进行对比。
- 解决：确保所有可能执行路径上的 RNG 调用次数是严格一致的。对于有分支的逻辑，可以考虑预生成随机数池，或者使用“随机决策点”模式。
使用了randomize()：在初始化你的确定性 RNG 后，不小心又调用了它的randomize()方法，这会用时间重置种子。
- 解决：确保用于确定性逻辑的 RNG 绝不调用randomize()。

6.2 问题：我的游戏存档/读档后，随机事件对不上了。

可能原因及排查：

没有保存 RNG 状态：你只保存了游戏世界的状态（如玩家位置、物品），但没有保存RandomNumberGenerator.state。
- 解决：将每个重要 RNG 实例的state属性纳入存档数据。
保存了错误的 RNG：你可能保存了全局 RNG 的状态，或者保存了某个不相关的 RNG 实例状态。
- 解决：使用前面提到的RandomManager单例来集中管理，并确保存档/读档时处理的是同一个实例。
状态恢复顺序错误：读档时，先恢复了游戏数据，然后才恢复 RNG 状态。但某些游戏数据（如敌人属性）的初始化可能依赖于 RNG，导致恢复状态前已经消费了随机数。
- 解决：在游戏加载的最早期，甚至在场景实例化之前，就恢复所有 RNG 的状态。

6.3 问题：我需要一个“真正随机”的种子，怎么生成？

对于需要不可预测性的场景（如多人游戏的初始同步种子），可以使用系统时间、用户输入等熵源。

func generate_secure_seed() -> int: # 组合多个熵源，增加随机性 var time = Time.get_ticks_usec() var noise = OS.get_unique_id().hash() # 获取设备唯一标识的哈希 var mouse_pos = DisplayServer.mouse_get_position() if DisplayServer.has_feature(DisplayServer.FEATURE_MOUSE) else Vector2i.ZERO return hash(str(time) + str(noise) + str(mouse_pos))

注意：OS.get_unique_id()在不同平台可用性不同。对于网络游戏，更常见的做法是让服务器生成一个种子并分发给所有客户端，以保证所有客户端使用相同的确定性种子。

6.4 性能优化：避免在循环中频繁创建RNG

这是一个新手常犯的错误：

# 错误示范：每帧都新建RNG，开销巨大 func _process(delta): for i in 100: var temp_rng = RandomNumberGenerator.new() # 非常耗性能！ temp_rng.randomize() var x = temp_rng.randf_range(-10, 10)

正确做法：在类初始化时创建 RNG 实例，并重复使用。

var _rng: RandomNumberGenerator func _ready(): _rng = RandomNumberGenerator.new() _rng.seed = 42 func _process(delta): for i in 100: var x = _rng.randf_range(-10, 10) # 复用同一个实例

6.5 随机数质量与分布验证

当你实现了一个复杂的随机系统后，如何验证其分布是否符合预期？一个简单的方法是做蒙特卡洛模拟。

# 测试 rand_weighted 的分布是否合理 func test_weighted_distribution(): var rng = RandomNumberGenerator.new() rng.seed = 123 var items = [“A”, “B”, “C”] var weights = PackedFloat32Array([1.0, 2.0, 1.0]) # 期望比例 A:B:C = 1:2:1 var counts = {“A”: 0, “B”: 0, “C”: 0} var trials = 10000 for i in range(trials): var idx = rng.rand_weighted(weights) counts[items[idx]] += 1 print(“分布结果: ”) for item in items: var percentage = float(counts[item]) / trials * 100.0 print(“%s: %.2f%%” % [item, percentage]) # 理想输出应接近 A:25%, B:50%, C:25%

运行这个测试，可以直观地看到你的权重设置是否产生了预期的概率分布。

7. 进阶应用：噪声与更复杂的随机序列

有时，纯粹的随机数过于“嘈杂”，我们需要具有连续性和自然感的随机，比如地形高度图。这时就需要噪声算法。Godot 4.2 内置了FastNoiseLite资源，它本质也是一种基于种子的伪随机函数，但生成的是连续的噪声图。

7.1 使用 FastNoiseLite 生成地形

# 在场景中添加一个 FastNoiseLite 资源 @onready var noise = $FastNoiseLite func generate_terrain(seed_value: int): noise.seed = seed_value # 噪声也有种子！ noise.frequency = 0.05 # 控制噪声的“缩放”，值越小地形越平滑 noise.fractal_octaves = 4 # 分形层数，增加细节 for x in range(map_width): for y in range(map_height): var noise_value = noise.get_noise_2d(x, y) # 返回值在 -1 到 1 之间 if noise_value > 0.2: _set_tile(x, y, 1) # 草地 elif noise_value > -0.3: _set_tile(x, y, 2) # 泥土 else: _set_tile(x, y, 3) # 水域

关键点：FastNoiseLite.seed同样提供了确定性。相同的种子必然产生完全相同的噪声图。你可以将地形噪声的种子和地牢布局的种子关联起来（例如，地形种子 = 主种子 + 1000），从而构建一个庞大而协调的随机世界。

7.2 结合噪声与离散随机

一个高级技巧是混合使用噪声和离散随机。例如，在地牢房间内用噪声来分布破损的地板：

func _add_room_details(room: Rect2i, detail_seed: int): var detail_noise = FastNoiseLite.new() detail_noise.seed = detail_seed detail_noise.frequency = 0.5 # 较高频率，产生小斑点 for x in range(room.position.x, room.position.x + room.size.x): for y in range(room.position.y, room.position.y + room.size.y): # 使用噪声值作为概率阈值 if detail_noise.get_noise_2d(x, y) > 0.7: _set_tile(x, y, 4) # 破损地板图块

这样，破损地板的分布看起来是随机的，但又具有自然的团簇效果，而不是完全散乱的点。