Godot 瓦片地图入门:TileMapLayer、TileSet、碰撞和 Codex 辅助开发

面向 Godot 4.x 初学者的瓦片地图教程,讲清 TileSet、TileMapLayer、分层地图、瓦片碰撞、Terrain 自动连接,以及如何让 Codex 辅助编写地图交互代码。

Godot 系列导航

想按顺序学习,可以先看合集,再根据当前任务跳到对应主题:

  • 使用 AI Codex 开发 Godot 游戏入门:从环境搭建到瓦片地图的文章合集
  • DeepSeek V4 Flash 做 Godot 游戏 Demo:几毛钱能跑通到什么程度?
  • Godot 游戏开发入门:从节点、场景到第一个 2D 小游戏
  • GodotPrompter:给 AI 编码助手补上 Godot 项目经验
  • gd-agentic-skills:把 Godot 开发经验拆成 AI 可调用的技能
  • Godot 新手起步:用 VS Code 和 Codex 扩展开发 2D 游戏
  • Godot Agent Skill 对比:haxqer/godot-skill、agent-skill-godot 与 GD-Agentic-Skills 该装哪个
  • Godot 标准版和 .NET 版怎么选:GDScript、C# 与导出平台对比
  • Godot 渲染器怎么选:Forward+、Mobile 和 Compatibility 对比
  • Godot 信号是什么:signal、connect 和 emit 用法详解
  • Godot 瓦片地图入门:TileMapLayer、TileSet、碰撞和 Codex 辅助开发
  • Godot Tileset AI 生成提示词:可直接复制的瓦片素材图集 Prompt
  • 如何让 AI 用 tileset 拼出完整场景:结构合理、道路连通、可导入 Godot 的提示词 Godot 的瓦片地图,可以理解成把一张包含草地、道路、墙壁、水面等小图片的素材表,切成规则格子,再像画画一样拼出关卡。

在 Godot 4.x,尤其是 4.3 之后的新项目中,建议使用 TileMapLayer。旧的 TileMap 节点已经被标记为弃用;现在更推荐一个地图层对应一个 TileMapLayer 节点。这样层级更清楚,也更符合 Godot 的节点组织方式。

官方文档也明确说明:TileMapLayer 是用于 2D tile-based maps 的节点,它使用 TileSet 创建网格地图;如果需要多层效果,可以使用多个 TileMapLayer

官方文档:

https://docs.godotengine.org/en/stable/classes/class_tilemaplayer.html

https://docs.godotengine.org/en/latest/tutorials/2d/using_tilemaps.html

先理解两个核心概念

瓦片地图最重要的是两个东西:

  1. TileSet
  2. TileMapLayer

TileSet 相当于瓦片素材库,里面保存:

  1. 草地、土地、墙壁、水面、道路等瓦片。
  2. 每个瓦片的碰撞形状。
  3. Terrain 自动连接规则。
  4. 导航、遮挡和自定义数据。

TileMapLayer 相当于画布。它使用 TileSet 里的瓦片来绘制地图。

推荐从这种节点结构开始:

1
2
3
4
5
6
World (Node2D)
├─ Ground (TileMapLayer)       # 草地、道路、地板
├─ Decoration (TileMapLayer)   # 花草、裂纹、阴影
├─ Walls (TileMapLayer)        # 墙壁、障碍物
├─ Objects (Node2D)            # 宝箱、门、NPC、金币
└─ Player (CharacterBody2D)

分层的好处很明显:

  1. 地面不会和墙壁混在一起。
  2. 可以单独设置显示顺序。
  3. 可以单独隐藏某一层。
  4. 只给墙壁层添加碰撞,地面层保持简单。
  5. 后续让 Codex 写脚本时,节点职责更清楚。

创建第一张瓦片地图

先准备一张瓦片图片,例如:

1
tileset.png

图片内部每个格子大小要一致,常见尺寸有:

1
2
3
16 × 16
32 × 32
64 × 64

假设素材每个瓦片是 32 × 32,那么 TileSetTile Size 也应该设置成 32 × 32

添加 TileMapLayer

在场景里添加:

1
2
Node2D
└─ TileMapLayer

TileMapLayer 改名为:

1
Ground

选中 Ground,在 Inspector 中找到:

1
Tile Set

点击:

1
2
<empty>
→ New TileSet

然后点击刚创建的 TileSet 资源,把 Tile Size 设置为素材格子大小,例如:

1
32 × 32

加入瓦片素材

选中 Ground 后,底部会出现 TileMap / TileSet 编辑面板。

tileset.png 拖到 TileSet 面板中,选择自动创建瓦片。Godot 会按照 Tile Size 把图片切成一块块小瓦片。

这一步完成后,TileSet 就拥有了可绘制的瓦片,Ground 这个 TileMapLayer 就可以使用它来画地图。

绘制地图

切换到底部的 TileMap 面板:

  1. 选择一个草地瓦片。
  2. 使用铅笔工具绘制。
  3. 用橡皮擦删除。
  4. 用矩形工具快速铺一片区域。
  5. 用填充工具快速铺满连续区域。

刚开始不要急着做大地图。先画一个 20 × 15 的小地图,只要有草地、墙壁和玩家出生点就够了。

给墙壁添加碰撞

不要给所有地面瓦片都加碰撞。通常只给这些不可通行内容添加碰撞:

  1. 墙壁。
  2. 石头。
  3. 栅栏。
  4. 水域边界。
  5. 悬崖。

选中 TileSet 资源,在 Inspector 中找到:

1
Physics Layers

点击:

1
Add Element

常见配置是:

1
2
Collision Layer: 1
Collision Mask: 1

然后在底部 TileSet 面板中:

  1. 切换到碰撞或物理绘制相关工具。
  2. 选择墙壁瓦片。
  3. 给墙壁区域绘制矩形或多边形碰撞。

这样,同一个 TileSet 中的不同瓦片就可以拥有不同碰撞形状。

玩家如何被瓦片墙挡住

玩家场景可以这样搭:

1
2
3
Player (CharacterBody2D)
├─ Sprite2D
└─ CollisionShape2D

玩家移动脚本可以从最小版本开始:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
extends CharacterBody2D

@export var speed: float = 200.0


func _physics_process(_delta: float) -> void:
	var direction := Input.get_vector(
		"move_left",
		"move_right",
		"move_up",
		"move_down"
	)

	velocity = direction * speed
	move_and_slide()

只要 Player 的碰撞层、遮罩与 TileSet 的物理层匹配,玩家移动时就会被墙壁瓦片挡住。

运行游戏时可以打开:

1
2
调试
→ 可见碰撞形状

这样能直接看到墙壁和玩家的碰撞形状,排错会轻松很多。

地图建议分成三层

初学阶段,推荐使用三层:

1
2
3
4
World
├─ Ground
├─ Walls
└─ Decoration

每个节点都是独立的 TileMapLayer

Ground 放:

  1. 草地。
  2. 泥土。
  3. 道路。
  4. 地板。

通常没有碰撞。

Walls 放:

  1. 墙壁。
  2. 悬崖。
  3. 水域边界。
  4. 不可穿越的石头。

通常有碰撞。

Decoration 放:

  1. 小花。
  2. 草叶。
  3. 地面裂纹。
  4. 阴影。

通常没有碰撞。

可以使用 z_index 控制基本显示顺序:

1
2
3
4
Ground: 0
Walls: 1
Decoration: 2
Player: 3

如果有树木、屋顶、桥洞这类需要遮挡玩家的对象,后面再考虑 Y Sort,或者把对象拆成上下两部分。第一张地图不必一开始就把遮挡系统做复杂。

使用 Terrain 自动连接道路和墙壁

如果你希望画地图时自动生成边缘和转角,例如:

  1. 草地自动连接泥土边缘。
  2. 道路自动生成转角。
  3. 墙壁自动判断上下左右。
  4. 水面自动生成岸边。

就需要使用 Godot 的 Terrain Set

基本流程是:

  1. TileSet 中添加 Terrain Set
  2. 设置匹配模式,例如按边和角匹配。
  3. 创建 Terrain,例如 GrassDirtWater
  4. 给各个瓦片标注对应的地形连接位置。
  5. TileMapLayer 中切换到 Terrains 绘制模式。
  6. 使用 ConnectPath 工具画地图。

Godot 会根据周围格子自动选择直线、转角、边缘瓦片。官方文档中也提到,Terrain 连接模式包括 ConnectPathConnect 更容易上手,Path 更适合需要更多人工控制的道路或路径。

刚开始不必立刻学习 Terrain。先手动画一张小地图,理解 TileSetTileMapLayer 和碰撞之后,再做自动连接。

在代码中操作瓦片

假设场景结构是:

1
2
World
└─ Ground

可以在 World 脚本中引用 Ground

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
extends Node2D

@onready var ground: TileMapLayer = $Ground

const SOURCE_ID: int = 0
const GRASS_TILE: Vector2i = Vector2i(0, 0)


func place_grass(cell: Vector2i) -> void:
	ground.set_cell(
		cell,
		SOURCE_ID,
		GRASS_TILE
	)

这里的 cell 是地图格子坐标。例如:

1
place_grass(Vector2i(5, 3))

表示在第 5 列、第 3 行放置一个草地瓦片。

注意:SOURCE_IDGRASS_TILE 的 atlas 坐标必须以你实际的 TileSet 为准,不能直接照搬示例。

世界坐标和格子坐标互转

鼠标点击的位置是世界坐标,而瓦片地图使用格子坐标。通常需要先转成本层的局部坐标,再转成地图格子。

世界坐标转格子坐标:

1
2
var local_position := ground.to_local(get_global_mouse_position())
var cell := ground.local_to_map(local_position)

格子坐标转回地图位置:

1
var position_in_layer := ground.map_to_local(cell)

如果要做鼠标点击放置瓦片,可以这样写:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
extends Node2D

@onready var ground: TileMapLayer = $Ground

const SOURCE_ID: int = 0
const GRASS_TILE: Vector2i = Vector2i(0, 0)


func _unhandled_input(event: InputEvent) -> void:
	if event is InputEventMouseButton:
		if event.button_index == MOUSE_BUTTON_LEFT and event.pressed:
			var local_position := ground.to_local(
				get_global_mouse_position()
			)
			var cell := ground.local_to_map(local_position)

			ground.set_cell(
				cell,
				SOURCE_ID,
				GRASS_TILE
			)

如果还想支持右键删除瓦片,可以使用:

1
ground.erase_cell(cell)

set_cell()erase_cell()local_to_map()map_to_local() 都是 TileMapLayer 常用 API。

宝箱、门、金币不要都画成普通瓦片

这些对象通常不适合只画成普通瓦片:

  1. 金币。
  2. 宝箱。
  3. 可以打开的门。
  4. NPC。
  5. 敌人。
  6. 传送点。
  7. 机关。
  8. 可以破坏的箱子。

它们有脚本、动画、碰撞和信号,更适合做成独立场景。

例如金币:

1
2
3
Coin (Area2D)
├─ Sprite2D
└─ CollisionShape2D

然后放进:

1
2
World
└─ Objects

普通瓦片适合静态地图;有行为的对象适合独立 Scene。Godot 也支持 Scene Collection 类型的瓦片,但初学阶段手动放置独立场景更容易理解,也更容易排错。

Codex 最适合帮你做什么

Codex 很适合辅助这些工作:

  1. 写玩家移动脚本。
  2. 读取地图格子。
  3. 程序化生成地图。
  4. 随机铺地面。
  5. 鼠标放置和删除瓦片。
  6. 寻找出生点。
  7. 读取自定义瓦片数据。
  8. 检查 TileMapLayer API 用法。
  9. 实现金币、门、宝箱逻辑。

可以这样给 Codex 提示:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
这是一个 Godot 4.x 项目。

场景结构:

World:Node2D
├─ Ground:TileMapLayer
├─ Walls:TileMapLayer
├─ Objects:Node2D
└─ Player:CharacterBody2D

请为 World 编写脚本:

1. 把鼠标世界坐标转换成 Ground 的格子坐标;
2. 左键放置草地瓦片;
3. 右键清除瓦片;
4. SOURCE_ID 和 atlas 坐标使用 @export 配置;
5. 使用 Godot 4.x TileMapLayer API;
6. 使用静态类型;
7. 不修改 TileSet 和场景节点名称。

Codex 不太适合这些工作:

  1. 判断素材应该切成多少像素。
  2. 视觉化绘制整张地图。
  3. 精细配置 Terrain 位掩码。
  4. 凭空猜 source_id
  5. 凭空猜 atlas 坐标。
  6. 大规模手写 .tscn 地图数据。

更合理的分工是:你在 Godot 编辑器中创建 TileSet、配置碰撞并绘制地图;Codex 负责编写地图交互、生成逻辑和 gameplay 脚本。

第一个练习怎么做

建议第一个练习只做一张 20 × 15 的小地图:

  1. Ground 铺草地。
  2. Walls 画一圈墙。
  3. 给墙壁瓦片配置碰撞。
  4. 放一个 Player
  5. 让玩家移动时被墙挡住。
  6. 再加入一个 Coin 场景。

这个练习做完,你就会真正理解 Godot 瓦片地图的基本工作流:

1
2
3
4
5
TileSet 负责瓦片素材和规则
TileMapLayer 负责绘制某一层地图
碰撞写在 TileSet 的瓦片上
有行为的对象做成独立场景
Codex 负责围绕真实节点结构写脚本

先把这个最小地图跑通,再去研究 Terrain、Y Sort、程序化生成和大地图加载,会稳很多。

用 AI 生成 Godot TileSet 的提示词

通用专用提示词

这一版覆盖范围最完整,适合尝试一次生成基础地面、道路、水面、墙体和装饰。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
生成一张适合 Godot 4 TileSet 使用的顶视角 2D 瓦片素材图集。

画面要求:
- 风格:统一的像素艺术风格
- 视角:严格顶视角,不要透视,不要等距视角
- 单个瓦片逻辑尺寸:32×32 像素
- 所有瓦片按照规则网格整齐排列
- 每个瓦片占用完全相同的正方形区域
- 瓦片之间不要重叠
- 瓦片之间不要留不规则空隙
- 透明背景
- 无文字、无数字、无标签、无 UI、无边框
- 不要展示游戏角色
- 不要生成完整地图场景
- 不要使用倾斜镜头
- 不要添加整张图统一的光照或阴影
- 每个瓦片的光照方向保持一致

素材内容:
第一行:
1. 普通草地
2. 深色草地
3. 稀疏草地
4. 泥土地面
5. 石板地面
6. 沙土地面

第二行:
1. 横向道路
2. 纵向道路
3. 左上转角道路
4. 右上转角道路
5. 左下转角道路
6. 右下转角道路

第三行:
1. 水面中心
2. 水面上边缘
3. 水面下边缘
4. 水面左边缘
5. 水面右边缘
6. 水面外角

第四行:
1. 石墙中心
2. 石墙顶部
3. 石墙底部
4. 石墙左侧
5. 石墙右侧
6. 石墙转角

第五行:
1. 小花
2. 小石头
3. 草丛
4. 树桩
5. 地面裂纹
6. 落叶

技术要求:
- 所有地面瓦片必须能够无缝重复平铺
- 道路、水面和墙体的边缘必须能相互连接
- 图案不能跨越到相邻瓦片
- 每个瓦片边缘像素必须与连接方向保持一致
- 输出为一张完整 PNG 图集
- 图集布局为 6 列 × 5 行
- 不要生成预览场景,只生成瓦片素材表

这版信息完整,但也更容易出错。如果模型经常把图集画成“地图截图”,或者瓦片没有严格对齐,就改用下面的简化版。

更适合 AI 出图的简化版

AI 一次生成太多连接块,容易出错。第一次建议只生成基础地面:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
生成一张适合 Godot 4 TileSet 使用的顶视角像素风瓦片图集。

要求:
- 严格顶视角
- 单个瓦片逻辑尺寸为 32×32
- 6 列 × 3 行规则网格
- 透明背景
- 所有格子大小完全一致
- 无文字、无标签、无 UI、无角色
- 不要生成完整地图
- 风格和光照保持统一

第一行:
普通草地、深色草地、稀疏草地、泥土、沙地、石地

第二行:
细草、碎石、花朵、落叶、地面裂纹、小蘑菇

第三行:
浅色草地变化、深色泥土变化、湿润泥土、苔藓石地、干燥沙地、鹅卵石地面

技术要求:
- 所有地面瓦片能够上下左右无缝重复平铺
- 瓦片边缘不能出现明显断层
- 细节不能跨越相邻格子
- 输出为单张 PNG 图集

这个版本成功率通常更高。先生成基础地面,确认风格和网格没问题,再继续做道路、水面和墙体。

草地和泥土自动连接版

这种适合之后配置 Godot Terrain:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
生成一套适合 Godot 4 Terrain 系统的顶视角像素风草地与泥土连接瓦片。

规格:
- 单个瓦片逻辑尺寸:32×32
- 严格顶视角
- 规则网格排列
- 透明背景
- 统一像素密度
- 统一光照方向
- 无文字、无 UI、无角色、无完整场景

需要包含:
- 纯草地中心
- 纯泥土中心
- 草地包围泥土的上边缘
- 下边缘
- 左边缘
- 右边缘
- 左上外角
- 右上外角
- 左下外角
- 右下外角
- 左上内角
- 右上内角
- 左下内角
- 右下内角
- 横向窄泥土道路
- 纵向窄泥土道路
- 十字连接
- T 形连接

要求所有边缘像素能够严格对应和无缝连接。
不要省略内角和外角。
每个连接瓦片必须单独占据一个完整网格。

这一类 AI 最容易画错。生成后通常要用 Aseprite、Krita 或 Photoshop 手工补角,尤其是内角、外角和 T 形连接。

水面 tileset 提示词

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
生成一套适合 Godot 4 TileSet 的顶视角像素风水面瓦片图集。

要求:
- 单个瓦片逻辑尺寸:32×32
- 规则网格排列
- 透明背景
- 严格顶视角
- 水面颜色和波纹风格统一
- 无文字、无标签、无 UI、无完整地图

内容包括:
- 水面中心
- 水面变化块 1
- 水面变化块 2
- 上岸边
- 下岸边
- 左岸边
- 右岸边
- 左上外角
- 右上外角
- 左下外角
- 右下外角
- 左上内角
- 右上内角
- 左下内角
- 右下内角
- 小型水波
- 漂浮树叶
- 水中石块

岸边使用自然泥土和少量青草。
所有边缘必须能够上下左右无缝连接。
每个瓦片内容不能越过自己的网格区域。

水面素材要重点检查两件事:

  1. 水面中心能否无缝平铺。
  2. 岸边上下左右和内外角是否真的能接上。

地牢 tileset 提示词

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
生成一张适合 Godot 4 的顶视角像素风地牢瓦片素材图集。

规格:
- 单个瓦片逻辑尺寸:32×32
- 6 列 × 5 行规则网格
- 透明背景
- 严格顶视角
- 暗灰色石头地牢风格
- 统一像素密度和统一光照方向
- 不要角色,不要完整房间,不要 UI 和文字

内容包括:
- 普通石地板
- 裂纹石地板
- 苔藓石地板
- 血迹石地板
- 石墙中心
- 石墙顶部
- 石墙左右边缘
- 墙体内角
- 墙体外角
- 门洞
- 铁门
- 石柱
- 火把底座
- 木箱
- 木桶
- 碎石
- 骨头
- 铁链
- 地面陷阱

所有地板必须能够无缝平铺。
墙体边缘和转角必须能够正确连接。
每个物件必须完整位于自己的格子中。

地牢素材最容易出现的问题是:墙壁被画成侧视角,或者整张图变成一间完整房间。提示词里一定要反复强调“顶视角”“不要完整房间”“只生成瓦片素材表”。

手绘卡通风版本

不想做像素风,可以改成手绘卡通风:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
生成一张适合 Godot 4 TileSet 使用的顶视角手绘卡通风瓦片图集。

要求:
- 单个瓦片逻辑尺寸为 64×64
- 严格顶视角
- 柔和手绘风格
- 清晰轮廓
- 统一笔触
- 统一光照
- 规则网格排列
- 透明背景
- 不要完整地图场景
- 无文字、无 UI、无人物

内容:
草地、泥土、沙地、石路、水面、道路边缘、草地与泥土连接边缘、小花、小石头、草丛。

所有基础地面必须能够无缝平铺。
边缘图案必须能与相邻瓦片连接。
每个瓦片保持独立,不能跨格。

手绘风比像素风更容易出现边缘不齐的问题。生成后最好用图片软件重新对齐网格,再导入 Godot。

负面限制词

支持负面提示词的模型,可以加入:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
no perspective view,
no isometric view,
no complete map,
no characters,
no text,
no labels,
no UI,
no irregular grid,
no overlapping tiles,
no inconsistent tile sizes,
no borders,
no mockup,
no screenshot,
no realistic photography,
no shadows crossing tile boundaries,
no objects cut off by tile edges

中文版本:

1
2
3
4
不要透视,不要等距视角,不要完整地图,不要角色,
不要文字,不要标签,不要 UI,不要预览边框,
不要不规则网格,不要瓦片重叠,不要尺寸不一致,
不要跨格阴影,不要让物体被网格边缘截断。

如果模型经常生成“漂亮预览图”而不是素材表,负面词里一定要加强:

1
2
3
4
5
no preview scene,
no game screenshot,
no map mockup,
only a tile atlas,
only separate tiles in a regular grid

实际生成时的关键参数

推荐从下面的规格开始:

1
2
3
4
5
瓦片逻辑尺寸:32×32
图集布局:6×4 或 6×5
最终生成图:1024×1024 或更高
背景:透明
风格:像素风

这里要注意:AI 通常不会真正严格输出每格 32×32 像素。

“32×32”更多是在告诉 AI 瓦片的设计比例。生成后仍然需要在图片软件里:

  1. 裁剪画布。
  2. 建立规则网格。
  3. 把每块瓦片重新对齐。
  4. 缩放到真正的 32×32
  5. 修正边缘。
  6. 导出 PNG。

如果你希望 Godot 的 TileSet 自动切割更顺利,最终图集应该保证:

  1. 画布尺寸能被瓦片尺寸整除。
  2. 每个瓦片在固定网格内。
  3. 没有外边框。
  4. 没有不规则间距。
  5. 没有跨格内容。

最稳的分批生成法

不要一次生成完整大图集。建议按下面顺序:

  1. 第一张:基础地面。
  2. 第二张:道路连接。
  3. 第三张:水面和岸边。
  4. 第四张:墙壁和悬崖。
  5. 第五张:花草和碎石装饰。

生成第二批以后,可以在提示词里加入:

1
2
保持与上一套素材完全相同的颜色、笔触、像素密度、
视角、光照方向和轮廓风格。

不过不同批次仍可能出现风格漂移,正式项目最好统一做后期调色。

最推荐你先用的版本

如果你只想先跑通 Godot 的 TileSet 流程,直接复制这一段生成第一张:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
生成一张适合 Godot 4 TileSet 使用的顶视角像素风基础地面瓦片图集。

单个瓦片逻辑尺寸为 32×32。
图集使用 6 列 × 3 行规则网格。
透明背景。
严格顶视角,无透视,无等距角度。
所有瓦片大小完全相同,整齐对齐。
统一像素密度、颜色风格和光照方向。

第一行:
普通草地、深色草地、浅色草地、普通泥土、深色泥土、沙地。

第二行:
灰色石地、苔藓石地、鹅卵石地面、湿润泥土、枯草地、碎石地。

第三行:
小花草装饰、草丛装饰、小石头装饰、落叶装饰、
地面裂纹装饰、小蘑菇装饰。

所有基础地面必须能够上下左右无缝重复平铺。
装饰物必须完整位于自己的瓦片内部。
不要生成完整地图。
不要人物。
不要文字、数字、标签、UI、边框或预览说明。
不要让任何图案跨越相邻瓦片。
输出为单张透明 PNG 图集。

这版最适合作为第一张测试素材。生成后只要能在 Godot 里按规则网格切割,并且基础地面能平铺,就已经够用了。后面再慢慢补道路、水面、墙壁和装饰,不要一开始就追求完整图集。

让 AI 使用 TileSet 拼出完整场景

适合图片生成 AI 的场景提示词

这种方式适合生成场景概念图或视觉预览。使用时,先上传你的 tileset 图片作为参考图,再使用下面这段提示词。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
请严格参考我提供的 tileset 图集,使用图集中已有的地面、道路、水面、石墙和装饰元素,拼成一张完整、合理、可用于俯视角 RPG 的森林村庄场景。

场景规格:

严格顶视角
不使用透视或等距视角
地图逻辑尺寸为 24×18 个瓦片
每个瓦片逻辑尺寸为 32×32
保持参考 tileset 的原始画风、颜色、纹理、光照方向和比例
不改变瓦片的设计
不新增参考图中不存在的建筑、角色或大型物体
不生成 UI、文字、边框或网格线
输出完整场景,不输出 tileset 图集

地图结构:

地图底层主要使用普通草地,少量混合深色草地和稀疏草地,避免大面积完全重复。
地图下方中央设置一个清晰的入口。
从入口开始铺设一条纵向主路,延伸到地图中央。
主路在地图中央分成左右两条支路,所有道路必须连通,不能出现断路或无意义的道路碎片。
地图右上区域设置一个自然形状的小水池。
水池必须由水面中心、上下左右边缘和转角正确拼接,不能出现水面直接截断或岸边方向错误。
地图左上区域设置一段石墙围合区域,墙体边缘和转角必须正确连接。
水池、石墙和地图边缘之间必须保留至少一个瓦片宽的可通行区域。
地图中央保留一个较开阔的活动区域,方便角色移动。
不要让水池或石墙完全堵住主路。

装饰规则:

小花主要分布在草地区域,不能铺在道路和水面上。
小石头可以少量放在泥土、道路边缘或稀疏草地上。
草丛集中放在地图边缘、水池附近和墙角。
树桩只能少量出现,作为视觉兴趣点,不要堵塞主路。
地面裂纹只放在泥土或干燥区域。
落叶集中在地图角落和墙边。
道路中央保持干净,装饰主要放在道路两侧。
地图中心装饰较少,地图四周装饰密度较高。
不要在每个格子都放装饰,保留自然留白。

合理性要求:

所有道路必须有明确用途并互相连通。
所有可通行区域必须从入口到达。
水面、墙体和道路连接方向必须正确。
不出现孤立的单块水面、单块墙体或错误转角。
不出现无法进入的狭小封闭空间。
地图应像真实设计过的游戏关卡,而不是随机堆放瓦片。
画面需要有主次关系:入口引导玩家进入,主路引向中心,水池和石墙作为次要视觉焦点。

只生成一张完整的俯视角地图场景。

这段提示词的目标是让图片模型先考虑结构,而不是只做装饰。但要注意:即使写了“严格参考 tileset”,图片生成模型仍可能重绘瓦片细节,不能保证像素完全一致。

如果你需要可导入游戏的精确地图,不要只依赖图片生成结果。

让 AI 先输出地图布局

这种方式更适合保持地图合理性。先让 AI 不画图,只输出一张 24×18 的字符地图。得到布局后,再让 Codex 或脚本把字符转换成 Godot 的 TileMapLayer.set_cell()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
请根据以下规则设计一张 24×18 的俯视角 RPG 森林地图布局。

地图符号:
G = 普通草地
D = 深色草地
S = 稀疏草地
R = 道路
W = 水面
A = 石墙
F = 小花
K = 小石头
B = 草丛
U = 树桩
C = 地面裂纹
L = 落叶
P = 玩家入口

设计要求:

P 位于地图下方中央。
从 P 开始必须有一条道路通向地图中央。
道路在中央分成左右支路,所有道路必须连通。
右上区域设置一个面积约为 4×5 的自然形状水池。
左上区域设置一段合理连接的石墙。
地图中央保留至少 7×5 的开阔活动区。
水池、墙体和地图边缘之间至少保留一格可通行空间。
玩家必须能从 P 到达所有主要道路和开阔区域。
不允许出现封闭的单格草地区域。
不允许道路、水面或墙体出现无意义的单格碎片。
装饰不能阻挡主要道路。
地图边缘装饰较多,中央区域装饰较少。
小花只放在草地上。
地面裂纹只放在泥土或稀疏草地区域。
落叶主要放在角落和墙体附近。
保持整体自然、不完全对称,但结构清晰。

输出要求:

第一部分只输出完整的 24×18 字符网格。
每行必须正好包含 24 个字符。
总共必须正好输出 18 行。
第二部分列出入口坐标、道路节点、水池范围和墙体范围。
第三部分检查地图是否存在断路、封闭区域或无法到达区域。
不生成图片。

这种方式的好处是可检查、可修正、可程序化转换。你可以让 AI 先给出布局,再继续要求它自检:

1
2
3
4
5
6
7
8
9
请检查上面的字符地图:
1. P 是否能到达所有 R 道路;
2. 是否存在孤立的 W 水面;
3. 是否存在孤立的 A 石墙;
4. 是否存在被水面或墙体封死的可通行区域;
5. 每一行是否正好 24 个字符;
6. 总行数是否正好 18 行。

如果发现问题,请输出修正后的完整 24×18 地图。

比起直接出图,这种流程更像在做关卡设计。先验证地图结构,再考虑视觉细节。

让 Codex 严格使用 tileset 拼 Godot 地图

这是最可靠的方式,因为它真的会使用图集里的瓦片坐标,而不是重新绘制。

下面这段提示词适合在 VS Code 的 Codex 面板里使用。前提是你的 Godot 项目已经有 TileMapLayer 节点,并且 TileSet 已经导入。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
这是一个 Godot 4.x 项目,需要使用现有 TileSet 创建一张完整地图。

场景结构:

World:Node2D
├─ Ground:TileMapLayer
├─ Roads:TileMapLayer
├─ Water:TileMapLayer
├─ Walls:TileMapLayer
├─ Decorations:TileMapLayer
└─ PlayerSpawn:Marker2D

tileset 图集为 6 列 × 5 行,坐标定义如下:

第一行:
(0,0) 普通草地
(1,0) 深色草地
(2,0) 稀疏草地
(3,0) 泥土地面
(4,0) 石板地面
(5,0) 沙土地面

第二行:
(0,1) 横向道路
(1,1) 纵向道路
(2,1) 左上转角道路
(3,1) 右上转角道路
(4,1) 左下转角道路
(5,1) 右下转角道路

第三行:
(0,2) 水面中心
(1,2) 水面上边缘
(2,2) 水面下边缘
(3,2) 水面左边缘
(4,2) 水面右边缘
(5,2) 水面外角

第四行:
(0,3) 石墙中心
(1,3) 石墙顶部
(2,3) 石墙底部
(3,3) 石墙左侧
(4,3) 石墙右侧
(5,3) 石墙转角

第五行:
(0,4) 小花
(1,4) 小石头
(2,4) 草丛
(3,4) 树桩
(4,4) 地面裂纹
(5,4) 落叶

任务:

创建一张 24×18 的森林村庄地图。
地图下方中央设置玩家入口。
主路从入口通向中央,并在中央分成左右支路。
右上角创建一个合理连接的小水池。
左上角创建一段合理连接的石墙。
中央保留开阔区域。
所有道路必须连通。
水面和墙体不能堵死通路。
装饰主要放在地图边缘、水池附近和墙角。
道路中央不要放装饰。
不出现孤立水块、孤立墙块或错误方向的转角。
source_id 使用 @export 配置。
使用 Godot 4 TileMapLayer.set_cell()。
使用静态类型。
地图数据和绘制逻辑分开。
在代码中加入地图尺寸检查和可达性检查。
如果现有 tileset 缺少完成某种连接所需的瓦片,不要猜测或用错误瓦片替代,应明确指出缺失项。

先读取当前项目、场景和 TileSet 资源,确认真实 source_id 和 atlas 坐标,再修改代码。不要直接假设 source_id 等于 0。

这段提示词里最重要的是最后一句:

1
先读取当前项目、场景和 TileSet 资源,确认真实 source_id 和 atlas 坐标,再修改代码。不要直接假设 source_id 等于 0。

因为 Godot 的 source_id、atlas 坐标、TileSet Source 顺序都可能与你想象的不一样。AI 如果直接猜,很容易写出能运行但铺错瓦片的代码。

更适合 Codex 的二阶段提示词

如果项目已经比较复杂,不建议让 Codex 一次完成所有内容。可以先让它只做设计和检查,不改文件:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
这是一个 Godot 4.x 项目。

请先不要修改任何文件。

请完成以下检查:

1. 读取当前场景结构;
2. 找到所有 TileMapLayer 节点;
3. 找到它们使用的 TileSet;
4. 确认真实 source_id;
5. 列出 tileset 中每个 atlas 坐标对应的瓦片;
6. 判断是否足够拼出 24×18 森林村庄地图;
7. 如果缺少道路、水面或墙体连接瓦片,请明确列出缺失项;
8. 给出地图数据结构设计;
9. 给出可达性检查方案;
10. 暂时不要写代码。

确认分析没有问题后,再让它实现:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
现在开始实现地图生成脚本。

要求:

1. 只修改 World 的脚本;
2. 不修改 TileSet;
3. 不修改场景节点名称;
4. 地图尺寸为 24×18;
5. 使用数组或字典保存地图数据;
6. 使用 TileMapLayer.set_cell() 绘制;
7. 使用 @export 配置 source_id 和关键 atlas 坐标;
8. 添加地图尺寸检查;
9. 添加道路连通性检查;
10. 添加从 PlayerSpawn 到主要区域的可达性检查;
11. 如果检查失败,push_error() 输出原因;
12. 修改完成后说明如何在 Godot 中测试。

这种两阶段方式更稳。先让 AI 理解项目,再让它动手。

提示词中最重要的几句

以后无论生成什么场景,最好都加入下面这些规则:

1
2
3
4
5
6
所有道路必须互相连通,并具有明确用途。
不要出现孤立的单块水面、墙体或道路。
地图中心保持可读,地图边缘增加装饰密度。
每个主要区域必须能够从玩家入口到达。
装饰物不能阻挡主要通行路线。
先设计地图结构,再添加装饰。

最后一句特别重要:

1
先结构,后装饰。

如果不写这句,AI 很容易先追求“看起来丰富”,最后得到道路杂乱、装饰堵路、区域无法到达的场景。

推荐工作流

最稳的流程是:

  1. 先用 AI 生成或整理 tileset。
  2. 在 Godot 中创建 TileSet,确认每个瓦片的 atlas 坐标。
  3. 让 AI 先输出字符地图或 JSON 布局。
  4. 检查道路连通、入口可达、水面和墙体是否合理。
  5. 再让 Codex 把布局转换成 TileMapLayer.set_cell()
  6. 在 Godot 里运行,打开碰撞和调试显示。
  7. 最后再微调装饰密度。

一句话总结:

不要让 AI 一上来就“画漂亮场景”。先让它设计结构,再让脚本按真实 tileset 坐标拼图。这样得到的地图才更容易进入 Godot 项目,而不是停留在一张好看的概念图。