ludic/examples/library/grid.ludic
Orkuncakilkaya bc301c8d17
All checks were successful
bootstrap / cfree-fixpoint (push) Successful in 20s
ci / build-and-test (push) Successful in 1m48s
commit-lint / conventional-commits (push) Successful in 3s
docs / build-and-deploy (push) Successful in 27s
feat(engine): Tiled P1 — rt_tmap model + GID resolver + render + projection (#69)
The heart of Tiled support: load a map and draw it.

- rt_tmap model (Tmap/TmLayer/TmTileset in tiled.ludic): map header + ordered
  layers (dense int32 GID arrays, heap-allocated to w*h, lifting the 96x64 cap)
  + tilesets. Built from the intermediate Value tree, so the TMX and TMJ paths
  both feed it.
- GID resolver (Tiled.resolve): gid -> (tileset, localId, flipH/V/D); the three
  flip flags masked off before the local-id lookup, returned alongside. gid==0
  is empty.
- Image-backed render (Tiled.draw): every visible tile layer in file order,
  blitting each tile from its tileset image with flips applied at draw.
- Compatibility projection (Tiled.project / auto on load): a designated
  collision layer projects to the legacy byte tilemap ('#' solid, '=' one-way
  via the oneway property, ' ' empty) so Grid.*/Path.*/esys_move are unchanged.
- Tiled.load resolves external tilesets + images relative to the map file and
  auto-projects a collision/solids/walls layer.
- The grid and physics_tiles demos now run off a loaded map (grid_maze.tmx /
  physics_map.tmx) instead of hand-authored Map.row strings, byte-identically.

Two compiler fixes fell out of this (see the changeset):
- emit_index_addr set g_addr_ty before evaluating the index, so slice[obj.field]
  came back mis-typed; set it last, like the raw-pointer branches.
- @strcmp was declared by both the world table and the fs prelude; centralise
  it in the head prelude so a game that uses Fs/Path links.

Proven by library/tiled_p1.ludic (14 assertions: loads+renders Kenney map
identically from .tmx and .tmj, flip mirroring) + the converted grid/
physics_tiles demos. x test: 92 passed; self-host bootstrap fixpoint intact.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-09-01 14:43:29 +03:00

65 lines
2.3 KiB
Text

# grid.ludic — Grid.* tile geometry and pathfinding over the Map tilemap. A
# tiny map with a wall maze; each assertion that holds prints its number, so a
# full run prints: 1 2 3 4 5 6 7 8 9 10 11 12 13
# Pathfinding is A* (runtime/native/grid.ludic), 4-connected, `'#'` = wall.
program Grid {
property Tag { v: int = 0 }
model Marker { Tag }
handler Boot phase Start {
# The maze is now a loaded Tiled map (issue #69): its `collision` layer —
# 1 = wall, 0 = open — projects to the same byte tilemap Map.row used to fill,
# so every Grid.* / Path.* query below is byte-identical.
# 01234567
# row 0 ########
# row 1 #......#
# row 2 #.####.#
# row 3 #....#.#
# row 4 ########
Tiled.load("assets/tiled-fixtures/grid_maze.tmx")
# --- Bresenham line ---
let hl = Grid.line(1, 1, 6, 1)
if len(hl) == 6 { print(1) }
let dl = Grid.line(0, 0, 3, 3)
if len(dl) == 4 { print(2) }
# --- line of sight (a clear corridor vs one crossing a wall) ---
if Grid.line_of_sight(1, 1, 6, 1, '#') { print(3) }
if not Grid.line_of_sight(1, 1, 4, 3, '#') { print(4) }
# --- flood fill: every floor cell reachable from (1,1) ---
if len(Grid.flood(1, 1, '#')) == 13 { print(5) }
# --- A* shortest path around the maze ---
let p = Grid.a_star(1, 1, 6, 3, '#')
if len(p) == 8 { print(6) }
if p[0].x == 1 and p[0].y == 1 { print(7) }
let last = p[len(p) - 1]
if last.x == 6 and last.y == 3 { print(8) }
# the path is contiguous (each step 4-adjacent) and never crosses a wall
var ok = true
var i = 1
while i < len(p) {
let dx = p[i].x - p[i - 1].x
let dy = p[i].y - p[i - 1].y
var ad = dx
if ad < 0 { ad = 0 - ad }
var ay = dy
if ay < 0 { ay = 0 - ay }
if ad + ay != 1 { ok = false }
if Grid.blocked(p[i].x, p[i].y, '#') { ok = false }
i = i + 1
}
if ok { print(9) }
# --- unreachable / blocked cases ---
if len(Grid.a_star(1, 1, 3, 2, '#')) == 0 { print(10) } # (3,2) is a wall
if Grid.blocked(3, 2, '#') { print(11) }
if not Grid.blocked(1, 1, '#') { print(12) }
if Grid.blocked(0 - 1, 0, '#') { print(13) } # out of bounds
}
handler Run phase Update { quit() }
}