Getting Started With Godot Tile Maps: TileMapLayer, TileSet, Collisions, and Codex

1
2
3
4
5
6

World (Node2D)
├─ Ground (TileMapLayer)       # Grass, roads, floors
├─ Decoration (TileMapLayer)   # Flowers, cracks, shadows
├─ Walls (TileMapLayer)        # Walls and obstacles
├─ Objects (Node2D)            # Chests, doors, NPCs, coins
└─ Player (CharacterBody2D)

1

tileset.png

1
2
3

16 × 16
32 × 32
64 × 64

1
2

Node2D
└─ TileMapLayer

1

Ground

1

Tile Set

1
2

<empty>
→ New TileSet

1

32 × 32

1

Physics Layers

1

Add Element

1
2

Collision Layer: 1
Collision Mask: 1

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()

1
2

Debug
→ Visible Collision Shapes

1
2
3
4

World
├─ Ground
├─ Walls
└─ Decoration

1
2
3
4

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

1
2

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
	)

1

place_grass(Vector2i(5, 3))

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)

1
2
3

Coin (Area2D)
├─ Sprite2D
└─ CollisionShape2D

1
2

World
└─ Objects

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

This is a Godot 4.x project.

Scene structure:

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

Please write a script for World:

1. Convert the mouse world position to Ground cell coordinates;
2. Left-click places a grass tile;
3. Right-click clears a tile;
4. SOURCE_ID and atlas coordinates should use @export configuration;
5. Use Godot 4.x TileMapLayer API;
6. Use static types;
7. Do not modify the TileSet or scene node names.

1
2
3
4
5

TileSet stores tile art and rules
TileMapLayer draws one map layer
Collision is configured on tiles inside the TileSet
Objects with behavior should be independent scenes
Codex writes scripts around the real node structure

 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

Generate a top-down pixel art tile atlas suitable for Godot 4 TileSet.

Requirements:
- Strict top-down view
- Logical tile size: 32×32
- 6 columns × 3 rows regular grid
- Transparent background
- Every cell has exactly the same size
- No text, no labels, no UI, no characters
- Do not generate a complete map
- Keep style and lighting consistent

First row:
Normal grass, dark grass, sparse grass, dirt, sand, stone ground

Second row:
Fine grass, pebbles, flowers, fallen leaves, ground cracks, small mushrooms

Third row:
Light grass variation, dark dirt variation, wet dirt, mossy stone ground, dry sand, cobblestone ground

Technical requirements:
- All ground tiles must tile seamlessly in all four directions
- Tile edges must not show obvious seams
- Details must not cross into neighboring cells
- Output as a single PNG atlas

 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

Generate a top-down pixel art grass and dirt transition tileset suitable for the Godot 4 Terrain system.

Specifications:
- Logical tile size: 32×32
- Strict top-down view
- Regular grid layout
- Transparent background
- Consistent pixel density
- Consistent lighting direction
- No text, no UI, no characters, no complete scene

Required tiles:
- Pure grass center
- Pure dirt center
- Top edge where grass surrounds dirt
- Bottom edge
- Left edge
- Right edge
- Upper-left outer corner
- Upper-right outer corner
- Lower-left outer corner
- Lower-right outer corner
- Upper-left inner corner
- Upper-right inner corner
- Lower-left inner corner
- Lower-right inner corner
- Narrow horizontal dirt road
- Narrow vertical dirt road
- Cross connection
- T-shaped connection

All edge pixels must match strictly and connect seamlessly.
Do not omit inner corners or outer corners.
Each transition tile must occupy one complete grid 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

Generate a top-down pixel art water tile atlas suitable for Godot 4 TileSet.

Requirements:
- Logical tile size: 32×32
- Regular grid layout
- Transparent background
- Strict top-down view
- Consistent water color and wave style
- No text, no labels, no UI, no complete map

Content:
- Water center
- Water variation tile 1
- Water variation tile 2
- Top shoreline
- Bottom shoreline
- Left shoreline
- Right shoreline
- Upper-left outer corner
- Upper-right outer corner
- Lower-left outer corner
- Lower-right outer corner
- Upper-left inner corner
- Upper-right inner corner
- Lower-left inner corner
- Lower-right inner corner
- Small water ripple
- Floating leaf
- Stone in water

Use natural dirt and a small amount of grass for shorelines.
All edges must connect seamlessly in all four directions.
No tile content may cross its own grid cell boundary.

 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

Generate a top-down pixel art dungeon tile atlas suitable for Godot 4.

Specifications:
- Logical tile size: 32×32
- 6 columns × 5 rows regular grid
- Transparent background
- Strict top-down view
- Dark gray stone dungeon style
- Consistent pixel density and lighting direction
- No characters, no complete room, no UI, no text

Content:
- Normal stone floor
- Cracked stone floor
- Mossy stone floor
- Blood-stained stone floor
- Stone wall center
- Stone wall top
- Stone wall left and right edges
- Wall inner corner
- Wall outer corner
- Door opening
- Iron door
- Stone pillar
- Torch base
- Wooden crate
- Wooden barrel
- Rubble
- Bones
- Chains
- Floor trap

All floor tiles must tile seamlessly.
Wall edges and corners must connect correctly.
Every object must stay completely inside its own grid cell.

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

Generate a top-down hand-drawn cartoon style tile atlas suitable for Godot 4 TileSet.

Requirements:
- Logical tile size: 64×64
- Strict top-down view
- Soft hand-drawn style
- Clear outlines
- Consistent brush strokes
- Consistent lighting
- Regular grid layout
- Transparent background
- Do not generate a complete map scene
- No text, no UI, no characters

Content:
Grass, dirt, sand, stone path, water, road edges, grass-to-dirt transition edges, small flowers, small stones, grass bushes.

All base ground tiles must tile seamlessly.
Edge patterns must connect with neighboring tiles.
Each tile must remain independent and must not cross into another cell.

 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

Logical tile size: 32×32
Atlas layout: 6×4 or 6×5
Final generated image: 1024×1024 or higher
Background: transparent
Style: pixel art

1
2

Keep exactly the same colors, brush strokes, pixel density,
view angle, lighting direction, and outline style as the previous asset set.

 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

Generate a top-down pixel art base ground tile atlas suitable for Godot 4 TileSet.

Logical tile size: 32×32.
Atlas uses a 6 columns × 3 rows regular grid.
Transparent background.
Strict top-down view, no perspective, no isometric angle.
All tiles have exactly the same size and are neatly aligned.
Consistent pixel density, color style, and lighting direction.

First row:
Normal grass, dark grass, light grass, normal dirt, dark dirt, sand.

Second row:
Gray stone ground, mossy stone ground, cobblestone ground, wet dirt, dry grass, gravel ground.

Third row:
Small flower decoration, grass bush decoration, small stone decoration, fallen leaf decoration,
ground crack decoration, small mushroom decoration.

All base ground tiles must tile seamlessly in all four directions.
Decorations must stay completely inside their own tile.
Do not generate a complete map.
No characters.
No text, numbers, labels, UI, borders, or preview notes.
Do not let any pattern cross into neighboring tiles.
Output as a single transparent PNG atlas.

 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

Strictly reference the tileset image I provided. Use only the existing ground, road, water, stone wall, and decoration elements from the tileset to assemble a complete, reasonable forest village scene suitable for a top-down RPG.

Scene specifications:

Strict top-down view.
Do not use perspective or isometric view.
Logical map size: 24×18 tiles.
Logical tile size: 32×32.
Preserve the original art style, colors, textures, lighting direction, and proportions of the reference tileset.
Do not redesign the tiles.
Do not add buildings, characters, or large objects that are not present in the reference image.
Do not generate UI, text, borders, or grid lines.
Output a complete scene, not a tileset atlas.

Map structure:

Use normal grass as the main base layer, mixed with a small amount of dark grass and sparse grass to avoid large fully repetitive areas.
Place a clear entrance at the bottom center of the map.
Build a vertical main road from the entrance to the center of the map.
At the center, split the main road into left and right branches. All roads must connect. Do not create broken roads or meaningless road fragments.
Place a natural-looking small pond in the upper-right area.
The pond must be assembled correctly from water center tiles, top/bottom/left/right edges, and corners. Do not create abruptly cut water or shorelines facing the wrong direction.
Place a connected stone wall area in the upper-left region.
Wall edges and corners must connect correctly.
Keep at least one walkable tile between the pond, walls, and the map border.
Leave a relatively open activity area in the center for character movement.
Do not let the pond or walls completely block the main road.

Decoration rules:

Small flowers mainly appear on grass, not on roads or water.
Small stones may appear sparingly on dirt, road edges, or sparse grass.
Grass bushes are concentrated near map edges, the pond, and wall corners.
Tree stumps should appear only sparingly as visual points of interest, and must not block the main road.
Ground cracks appear only on dirt or dry areas.
Fallen leaves are concentrated near map corners and walls.
Keep the middle of roads clean. Put most decorations on both sides of roads.
Use fewer decorations near the map center and denser decorations near the edges.
Do not decorate every cell. Leave natural empty space.

Reasonableness requirements:

All roads must have a clear purpose and connect to each other.
All walkable areas must be reachable from the entrance.
Water, walls, and roads must connect in the correct direction.
Do not create isolated single water tiles, isolated wall tiles, or incorrect corners.
Do not create tiny enclosed spaces that cannot be entered.
The map should feel like a deliberately designed game level, not random tile placement.
The composition needs hierarchy: the entrance guides the player in, the main road leads to the center, and the pond and wall area act as secondary visual focal points.

Only generate one complete top-down map scene.

 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

Design a 24×18 top-down RPG forest map layout using the rules below.

Map symbols:
G = normal grass
D = dark grass
S = sparse grass
R = road
W = water
A = stone wall
F = small flower
K = small stone
B = grass bush
U = tree stump
C = ground crack
L = fallen leaves
P = player entrance

Design requirements:

P is located at the bottom center of the map.
There must be a road starting from P and leading to the center of the map.
The road splits into left and right branches near the center. All roads must connect.
Place a natural-looking pond of about 4×5 tiles in the upper-right area.
Place a reasonably connected stone wall segment in the upper-left area.
Keep at least a 7×5 open activity area in the center.
Keep at least one walkable tile between the pond, walls, and map border.
The player must be able to reach all main roads and open areas from P.
Do not create enclosed single-tile grass areas.
Do not create meaningless single-tile fragments of roads, water, or walls.
Decorations must not block main roads.
Use more decorations near the map edges and fewer near the center.
Small flowers can only appear on grass.
Ground cracks can only appear on dirt or sparse grass.
Fallen leaves mainly appear near corners and walls.
Keep the overall map natural, not perfectly symmetrical, but structurally clear.

Output requirements:

First section: output only the complete 24×18 character grid.
Each row must contain exactly 24 characters.
There must be exactly 18 rows.
Second section: list the entrance coordinate, road nodes, pond range, and wall range.
Third section: check whether the map has broken roads, enclosed areas, or unreachable areas.
Do not generate an image.

1
2
3
4
5
6
7
8
9

Check the character map above:
1. Whether P can reach all R road tiles;
2. Whether there are isolated W water tiles;
3. Whether there are isolated A wall tiles;
4. Whether any walkable area is blocked by water or walls;
5. Whether every row contains exactly 24 characters;
6. Whether the map has exactly 18 rows.

If you find problems, output a corrected complete 24×18 map.

 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

This is a Godot 4.x project. I need to create a complete map using the existing TileSet.

Scene structure:

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

The tileset atlas has 6 columns × 5 rows. Coordinates are defined as:

First row:
(0,0) normal grass
(1,0) dark grass
(2,0) sparse grass
(3,0) dirt ground
(4,0) stone floor
(5,0) sand ground

Second row:
(0,1) horizontal road
(1,1) vertical road
(2,1) upper-left road corner
(3,1) upper-right road corner
(4,1) lower-left road corner
(5,1) lower-right road corner

Third row:
(0,2) water center
(1,2) water top edge
(2,2) water bottom edge
(3,2) water left edge
(4,2) water right edge
(5,2) water outer corner

Fourth row:
(0,3) stone wall center
(1,3) stone wall top
(2,3) stone wall bottom
(3,3) stone wall left side
(4,3) stone wall right side
(5,3) stone wall corner

Fifth row:
(0,4) small flower
(1,4) small stone
(2,4) grass bush
(3,4) tree stump
(4,4) ground crack
(5,4) fallen leaves

Task:

Create a 24×18 forest village map.
Place the player entrance at the bottom center.
Create a main road from the entrance to the center, then split it into left and right branches.
Create a reasonably connected small pond in the upper-right.
Create a reasonably connected stone wall segment in the upper-left.
Keep the center open.
All roads must connect.
Water and walls must not block the path.
Place decorations mainly near map edges, the pond, and wall corners.
Do not place decorations in the middle of roads.
Do not create isolated water tiles, isolated wall tiles, or wrong-direction corners.
Use @export for source_id.
Use Godot 4 TileMapLayer.set_cell().
Use static types.
Separate map data from drawing logic.
Add map size checks and reachability checks in code.
If the existing tileset is missing tiles required for a connection, do not guess or use wrong tiles. Clearly report what is missing.

First read the current project, scene, and TileSet resource. Confirm the real source_id and atlas coordinates before editing code. Do not assume source_id equals 0.

1

First read the current project, scene, and TileSet resource. Confirm the real source_id and atlas coordinates before editing code. Do not assume source_id equals 0.

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

This is a Godot 4.x project.

Do not modify any files yet.

Please perform these checks:

1. Read the current scene structure;
2. Find all TileMapLayer nodes;
3. Find the TileSet used by each layer;
4. Confirm the real source_id;
5. List which tile each atlas coordinate represents;
6. Decide whether the tileset is sufficient for a 24×18 forest village map;
7. If road, water, or wall connection tiles are missing, list them clearly;
8. Propose the map data structure;
9. Propose the reachability check approach;
10. Do not write code yet.

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

Now implement the map generation script.

Requirements:

1. Only modify the World script;
2. Do not modify the TileSet;
3. Do not rename scene nodes;
4. Map size is 24×18;
5. Store map data in arrays or dictionaries;
6. Draw with TileMapLayer.set_cell();
7. Use @export for source_id and key atlas coordinates;
8. Add map size checks;
9. Add road connectivity checks;
10. Add reachability checks from PlayerSpawn to major areas;
11. If a check fails, use push_error() to output the reason;
12. After editing, explain how to test it in Godot.

1
2
3
4
5
6

All roads must connect to each other and have a clear purpose.
Do not create isolated single water, wall, or road tiles.
Keep the map center readable and increase decoration density near the edges.
Every major area must be reachable from the player entrance.
Decorations must not block the main traversal route.
Design the map structure first, then add decorations.

1

Structure first, decoration second.