# gridKit.board The board model as plain data, the same on every peer: placement with multi-cell rotated footprints and refusals (`overlap`, `off_board`, `blocked`), move/rotate/remove, step-by-step `undo` (turn state included), `save`/`load` to a string, movement range (`reach`), paths around blocked cells (the engine's A* from `@builtin::systems.pathfinding`), `line`, `canSee` and directional `cover`, and turn-checked `act` for the four turn models. `GridBoard` holds one of these as its authoritative state; games and tests can use it directly via `GK.Board`.

# gridKit.tokens What pieces look like, in two looks: `classic` (lacquered turned pawns, kings and discs with brass collars, stone walls, wooden crates) and `neon` (smoked glass with glowing seat colours). `build(parent, piece, geo, look, top)` spawns one piece's entities; seat colours live in `SEAT_COLORS`.

# gridKit.registry This peer's shared gridKit runtime: the live boards, the pointer resolved once per frame (the board and cell under the mouse, screen centre or finger, and this frame's clicks and taps), keys and pad buttons, the focused board, the open cell cursor, the event bus behind `GK.on`, the per-player HUD, and the listener that carries other peers' board requests to the board's owner. Per-peer by design: one player's hover never reaches another's screen.

# gridKit.pieces The catalog of piece kinds: footprint, whether a kind blocks movement or sight, how much cover it gives and whether it belongs to a seat. Ships pawn, king, disc, domino, ell, wall, long_wall and crate; `define(id, def)` (or `GK.definePiece`) adds more.

# gridKit.shapes The geometry of the four grid shapes in a board's own space: `geometry(shape, cols, rows, size, diagonal?)` returns cell-to-position and back (`toLocal`, `fromLocal`), cell corners, neighbours, distance, footprint rotation, bounds and the list of cells. Square and iso use columns and rows; the hex shapes use axial coordinates in a rectangular (offset) layout. Pure math, used by `gridKit.board` and `GridBoard`.

# gridKit.styles The eight highlight looks (outline, fill, decal, glow, pixel, hologram, dotted, pulse) and the layer colours. `build(style, geo, layer, cells, color, t)` turns a set of cells into mesh parts, decal projectors and lights; `GridBoard` draws them and swaps looks when its `style` field changes.

# gridKit.turns The four turn models (alternating, initiative, simultaneous, action points, plus `none`) as state tables: who is active, whether a seat may act and at what cost, spending, ending turns, and committing plans for simultaneous rounds. Initiative is rolled deterministically per round so every peer agrees. Used by `gridKit.board`.

# gridKit.mesh A small procedural geometry builder (filled polygons, outline bands, walls, boxes, discs, strips and lathed surfaces of revolution) that uploads one runtime mesh per layer with `renderer.mesh.create`/`update`. Used by `gridKit.styles`, `gridKit.tokens` and `GridBoard` for tiles, highlights and turned pieces.

# gridKit.materials Runtime materials created once per session and shared by every board: flat unlit colours (opaque or see-through), emissive glow, lit lacquer, glass, decal colours and a per-layer pulsing tint the pulse look animates. Colours are passed as arrays, the form the renderer reads.

# gridKit Square, hex and isometric boards for any multiplayer world: picking, multi-cell pieces, movement range and paths, line of sight and cover, undo, save/load, four turn models and eight swappable highlight looks, behind one interface. Version **1.0.12** (`GK.VERSION`; the version in this README, `package.yaml` and `GK.VERSION` move together). ## Quick start ```lua Grid { shape = "hex" } ``` That one line, inside `content()` of a scene's `build.luau`, gives a working hex board 6 m in front of the default spawn: the cell under the pointer lights up, a click or tap places a token (seats alternate red and blue), and **Z** (or the on-screen **Undo** button) takes it away again. ### Install and use, step by step 1. Install the `gridKit.package` asset into `/source` (search ZeroMind for "gridKit", or `zeromind_install guid=<gridKit package guid> at=/source`). It needs nothing else: it builds on engine packages every world already has. 2. In `scenes/main.scene/build.luau`, add this at the very top of the file: ```lua local Grid = require("gridKit.api").Grid ``` 3. Inside `function content()`, before its `end`, add: ```lua Grid { shape = "hex" } ``` 4. Press play. Walk up to the board, aim at a cell (the screen centre aims while the mouse steers the camera; a free mouse or a finger points directly) and click or tap. Press **Z** to undo, **G** to steer a cell cursor with the arrow keys or a gamepad, **Esc** to put the cursor away and walk on. Change one setting to change the board: `shape = "square" | "hex_flat" | "hex_pointy" | "iso"`, `highlight = "holo"`, `turns = "action_points"`, `tokenLook = "neon"`. A running board swaps any of them live (`board:setHighlight("pixel")`), from any player. Every choice, with tags to pick by, is in the [variant catalog](#variant-catalog). A tactics board with a starting position: ```lua local GK = require("gridKit.api") -- inside content(): GK.Grid { name = "Skirmish", shape = "square", cols = 8, rows = 8, position = { 0, 0, 10 }, turns = "action_points", actionPoints = 4, highlight = "holo", theme = "night", tokenLook = "neon", placeKind = "", -- clicks select and move; nothing new is placed label = "Skirmish", -- a sign behind the board (text or a translation key) pieces = { { kind = "pawn", q = 1, r = 0, seat = 1 }, { kind = "king", q = 6, r = 7, seat = 2 } }, walls = { { kind = "long_wall", q = 2, r = 3 }, { kind = "crate", q = 5, r = 4 } }, } ``` Reacting to what happens, in code that runs in play (a scene's `entrypoint.luau`): ```lua local GK = require("gridKit.api") local conn function onLoad() conn = GK.on("moved", function(e) print(e.piece.kind .. " moved to " .. e.q .. "," .. e.r) end) end function onUnload() if conn then conn.Disconnect() end end ``` ## Guides Two guides come with the package and open in the Docs panel once gridKit is installed: - [How to make a turn based grid board game: square, hex or isometric boards with movement, line of sight and undo](gridKit.package/guides/how-to-make-a-turn-based-grid-board-game-with-movement-undo-and-line-of-sight) teaches the kit: picking a shape, pointing at cells, the eight looks, multi-cell pieces, move ranges and paths, line of sight and cover, undo, turns and seats, save and load, and the shared multiplayer board. - [How to make a hex grid tactics game, step by step](gridKit.package/guides/how-to-make-a-hex-grid-tactics-game-step-by-step) builds a two-sided hex skirmish from an empty world: move ranges and paths, attacks only on enemies a piece can see, undo, turns and a winner. This README stays the short reference for every option. ## What you get | part | what it is | |---|---| | `gridKit.api` | the one interface: `local GK = require("gridKit.api")` | | `GridBoard` component | one board: tiles, pieces, highlights, picking, turns, the authoritative state | | `GridHud` component | each player's panel for the board they stand at (made automatically): on a wide screen the status card starts top-centre and, when that spot covers a sign or board on that player's screen, moves to a spot that covers no sign and the least board, shrinking (fewer lines, smaller text) when nothing fits at full size; on a phone held upright it docks above the touch controls; once the board's `result` is set, its big line shows the result instead of whose turn it is | | `cursor` input map | stands walking down while a cell cursor is open | | `shapes`, `board`, `turns`, `pieces` modules | the pure rules, usable without a board in the world | | `styles`, `tokens`, `materials`, `mesh` modules | the looks | | `registry` module | this player's pointer, focus, cursor and event bus | | `locales/en`, `locales/pt-BR` | every word a player reads, English and Brazilian Portuguese | | `gridKit` test suite | checks the public features | | `guides/` | the how-to guide and the hex tactics example (see Guides above) | ## Grid shapes | shape | cells | neighbours | distance | |---|---|---|---| | `square` | columns and rows | 4 (8 with `diagonal = true`) | steps (diagonal: king moves) | | `hex_flat` (alias `hex`) | axial q, r, flat tops | 6 | hex steps | | `hex_pointy` | axial q, r, pointy tops | 6 | hex steps | | `iso` (alias `diamond`) | columns and rows on a 45° diamond | 4 (8 with `diagonal`) | steps | ## Highlight looks (`highlight`) Pick the look when you make a board, `Grid { shape = "hex", highlight = "holo" }`, or change it while it runs, `board:setHighlight("pulse")`. Every name in the second column works too; case, spaces and hyphens do not matter. (`style` is the same setting under its older name.) An unknown name is an error listing every look and its names; an option `Grid` does not know is a warning, never silently dropped. | look | also answers to | what it looks like | |---|---|---| | `outline` | crisp, crisp outline, line, border, edge | a crisp bright line around each cell (the default) | | `fill` | solid, solid fill, tint, flat | a solid see-through tint over the cell | | `decal` | stamp, stamped, stamped decal, projected | a colour stamped onto the board by a `DecalProjector` | | `glow` | soft, soft glow, neon, emissive, bloom | an emissive core with a soft halo and a small light under hover and selection | | `pixel` | chunky, chunky pixel, pixel art, retro, 8bit | a chunky blocky border snapped to a pixel grid | | `hologram` | holo, holographic, sci-fi, scifi, sci-fi hologram | a translucent sci-fi column with a rim and a rising scanline | | `dotted` | dots, dot, dotted border, stipple | a border of evenly spaced dots | | `pulse` | pulsing, animated, animated pulse, breathe | a breathing tint with a ripple ring | Each look draws every layer in its own colour: hover (gold), selected (orange), move range (blue), path (green), line of sight (white), blocked (red), cursor (magenta), committed plans (violet). On top of any look, three guides read at a glance: a bright outline around the whole move range, a green path ribbon with a dot per step and an arrowhead, and a raised sight beam that turns red and dashed past the wall that blocks it, with a flat red ✕ lying on top of that wall (it never rises above the wall, so it cannot hide anything behind it). Token looks (`tokenLook`): `classic` (lacquered turned pieces with brass collars, stone walls, crates) and `neon` (smoked glass with glowing seat colours). Board colours (`theme`): `slate`, `walnut`, `night`, `sand`. Piece kinds: `pawn`, `king`, `disc`, `domino` (2 cells), `ell` (3 cells), `wall` (blocks sight, full cover), `long_wall` (3 cells), `crate` (half cover). Add your own with `GK.definePiece(id, { footprint = { {0,0}, {1,0} }, blocksSight = false, cover = 1, neutral = false })`. ## Turn models (`turns`) | model | how it plays | |---|---| | `alternating` | seats take one action each, in turn | | `initiative` | each round seats act once, highest initiative first; initiative is re-rolled every round (the same on every peer) | | `simultaneous` | every seat commits one planned action; when the last seat commits, all plans happen together (two plans ending on one cell both bounce) | | `action_points` | the active seat spends points (moving costs the path length, placing costs 1) until they run out or it ends its turn (**T**) | | `none` | free play, no turns | Any number of seats (`seats = 4`). Seats are played hot-seat: whoever acts plays for the seat whose turn it is, unless a player claims a seat with `board:claimSeat(n)`; a claimed seat's actions and end of turn are then taken only from that player, and anyone else is refused with `"not_your_seat"`. Undo stays shared. ## Variant catalog `GK.CATALOG` lists every choice a board has: the 4 shapes, the 8 highlight looks and the 4 turn models, 16 in all. Each entry is `{ kind, setting, id, aliases, name, nameKey, tags, description }`: `setting` is the `Grid { }` option it goes in and `id` the value to write. Filter it with `GK.variants{ kind = "look" | "shape" | "turns", tag = "sci-fi", search = "hex tactics" }`; `GK.catalog.tags()` lists every tag and `GK.catalog.describe()` prints the whole list. ```lua local GK = require("gridKit.api") for _, v in GK.variants({ tag = "retro" }) do print(v.setting, v.id) end -- shape iso, highlight pixel Grid { shape = "hex", highlight = GK.variants({ tag = "sci-fi" })[1].id } ``` | setting | id | name | tags | |---|---|---|---| | `shape` | `square` | Square grid | square, classic, chess, 4-neighbour, city-builder, puzzle | | `shape` | `hex_flat` | Hex grid, flat tops | hex, flat-top, 6-neighbour, wargame, strategy | | `shape` | `hex_pointy` | Hex grid, pointy tops | hex, pointy-top, 6-neighbour, board-game, tactics | | `shape` | `iso` | Isometric diamond grid | isometric, diamond, square, 4-neighbour, city-builder, retro | | `highlight` | `outline` | Crisp outline | minimal, clean, outline, readable, default | | `highlight` | `fill` | Solid fill | minimal, solid, bold, board-game, readable | | `highlight` | `decal` | Stamped decal | decal, tabletop, grounded, subtle, physical | | `highlight` | `glow` | Soft glow | glow, neon, atmospheric, night, animated | | `highlight` | `pixel` | Chunky pixel | retro, pixel-art, 8-bit, chunky, arcade | | `highlight` | `hologram` | Sci-fi hologram | sci-fi, hologram, futuristic, tech, animated | | `highlight` | `dotted` | Dotted border | minimal, dotted, light, sketch, puzzle | | `highlight` | `pulse` | Animated pulse | animated, pulse, attention, playful, mobile | | `turns` | `alternating` | Alternating turns | classic, turn-based, chess, 2-player, simple | | `turns` | `initiative` | Initiative order | tactics, rpg, initiative, multi-seat, random | | `turns` | `simultaneous` | Simultaneous turns | simultaneous, we-go, strategy, party, multi-seat | | `turns` | `action_points` | Action points | tactics, action-points, xcom-like, resource, turn-based | ## API `local GK = require("gridKit.api")` | call | does | |---|---| | `GK.Grid(opts) -> board` | spawns a board entity (synced) with a `GridBoard`; `opts` takes every field below plus `name`, `position` (default `{0,0,6}`), `rotation`, `scale`, `pieces`, `walls`, `blocked`, `state` (a saved string), `synced = false` for a board only this peer has | | `GK.board(x) -> board?` | finds a board by entity, id, name or component | | `GK.boards()`, `GK.focused()` | every board here; the board this player stands at | | `GK.on(event, fn) -> conn` | listens on every board (`"*"` for all events); `conn.Disconnect()` | | `GK.definePiece(id, def)` | adds a piece kind | | `GK.SHAPES`, `GK.STYLES`, `GK.TURNS`, `GK.TOKEN_LOOKS`, `GK.THEMES`, `GK.EVENTS` | the names | | `GK.CATALOG`, `GK.variants{ kind?, tag?, search? }` | every shape, look and turn model with aliases, tags and a description (see [Variant catalog](#variant-catalog)); `GK.catalog.tags()`, `GK.catalog.describe()` | | `GK.Styles.resolve(name)` | the look id a name stands for (`"holo"` -> `"hologram"`), or nil | | `GK.Board`, `GK.Shapes`, `GK.Turns`, `GK.Pieces` | the pure rules: `GK.Board.new{ shape, cols, rows, turns, seats }` has every query and change below on plain data | `GridBoard` fields (all settable in `Grid { }` and live): `shape`, `cols`, `rows`, `cellSize`, `diagonal`, `style` (in `Grid { }` also `highlight`, which reads better and takes every alias), `turns`, `seats`, `actionPoints`, `tokenLook`, `theme`, `label`, `subtitle`, `result` (when set, e.g. "Red wins!", each player's status card shows it as its big line in place of whose turn it is and hides End turn; `""` while the game runs), `labelHeight`, `labelSize`, `labelMaxWidth`, `labelTilt` (degrees the sign and legend lean back; 40-60 reads from above too; in play a sign or legend that comes between a player's camera and them or the board they are at steps out of that player's view until the line is clear), `placeKind` (what a click on an empty cell places; `""` for none), `autoPlay` (built-in click behaviour; `false` leaves clicks to your `selected` handler, and a handler that sets `e.handled = true` takes over just that click), `moveBudget`, `showReach`, `showPath`, `showSight`, `showcase` (keeps a sample range, path and sight line drawn while idle), `legend` (a colour key for range, path, sight and blocked along the front edge), `range`. Signs word-wrap to two lines and shrink to fit `labelMaxWidth`, so neighbouring signs never touch. Board methods (a cell is `q, r` or `{ q = , r = }`): | method | returns | |---|---| | `toCell(worldPos)` / `toWorld(q, r)` | the cell under a world point (nil off the board) / a cell's centre in the world | | `neighbours(q, r)`, `distance(a, b)`, `inBounds(q, r)`, `cells()` | grid queries | | `place{ kind, q, r, rot, seat }`, `move(id, q, r, rot?)`, `rotate(id, steps?)`, `remove(id)` | changes, each undoable; refused with `"overlap"`, `"off_board"`, `"blocked"` ... | | `act{ op = "place" \| "move" \| "rotate" \| "remove", ... }` | the same, checked against the turn model and spent from it; `act{ op = "remove", id = enemy, by = mine }` is a capture, allowed when the acting seat owns `by`, one undo step with the turn | | `undo()`, `canUndo()`, `endTurn()`, `clear()` | step back one change (turn state included) / pass the turn | | `canPlace(kind, q, r, rot?)`, `pieceAt(q, r)`, `pieces()` | placement check and pieces | | `reach(q, r, budget?)` | every cell reachable within the budget around blocked cells: `{ q, r, cost }` | | `path(a, b)` | the cells from a to b around blocked cells, and its cost (the engine's A*) | | `canSee(a, b)` | whether a sees b, and the blocking cell | | `cover(q, r, from)` | cover value 0..2, `"none" \| "half" \| "full"`, the covering piece; `from` is a cell or a direction `{ x, z }` | | `save()` / `load(s)` | the board as a string / back exactly as it was | | `activeSeat()`, `turnState()`, `claimSeat(n)` | turns | | `setShape`, `setHighlight` (same as `setStyle`), `setTokenLook`, `setTurns`, `setTheme` | live swaps, from any player; each takes any name the catalog lists | | `select(q, r)`, `hoveredCell()`, `selectedPiece()`, `openCursor()`, `closeCursor()`, `moveCursor(dx, dy)`, `cursorCell()` | this player's pointer and cursor | | `isAuthority()` | whether this peer holds the board's authoritative copy | ## Events `GK.on(name, fn)`; every handler gets `{ board, entity, boardId, q?, r?, piece?, seat?, round?, ... }`. | event | when | seen by | |---|---|---| | `hovered` | the cell under this player's pointer or cursor changed | this player | | `selected` | this player clicked, tapped or pressed Enter/A on a cell; `selectedPiece` is the id of the piece they had selected; set `e.handled = true` and the built-in click step stands aside (the selection clears) | this player | | `placed`, `moved`, `removed` | a piece was placed, moved, removed | everyone | | `undone` | a change was undone (`op` says which) | everyone | | `turnStarted`, `turnEnded` | a seat's turn began / ended (`seat`, `round`) | everyone | | `committed`, `bounced` | simultaneous turns: a seat committed / two plans collided | everyone | | `refused` | an action was refused (`reason`) | everyone | | `loaded`, `cleared` | the board was loaded / cleared | everyone | | `cursorOpened`, `cursorClosed` | this player's cell cursor opened / closed | this player | ## Controls | | mouse and keyboard | touch | gamepad | |---|---|---|---| | point | screen centre while the camera holds the mouse; the mouse once freed (Esc) | finger | cell cursor | | select / place / move | left click | tap | A (south) in cursor mode | | undo | Z | Undo button | X (west) in cursor mode | | end turn | T | End turn button | Y (north) in cursor mode | | rotate placement or piece | R | Rotate button | shoulders in cursor mode | | cell cursor | G opens, arrows/WASD move, Enter selects, Esc/G closes | Cursor button | Y (north) opens, d-pad/stick move, B (east) closes | While the cursor is open the player's walking and camera controls stand down; they come back the moment it closes. ## Multiplayer The board's state (pieces, turns, undo history) lives in one synced field written only by the peer that owns the board entity (the room host for a scene board, which claims it when play starts). Every other player's clicks and key presses are sent to that peer, so everyone sees the same tokens appear and disappear and undo is shared. Hover, selection previews, the cell cursor and the HUD stay on each player's own screen. Place boards on synced entities (`Grid` does); `synced = false` makes a board only one peer sees. ## Known limits - Seats are hot-seat by default: any player acts for the seat whose turn it is unless seats are claimed with `claimSeat`. - Boards lie flat (a board can be moved, turned about its vertical axis and scaled; tilted boards are not picked correctly). - The decal look stamps flat colour rectangles turned to the cell (no per-shape decal textures), so on hex boards the stamp is a square inside each hex (see #19880 / #10827 for why no textured or emissive decal is used). - 3D sign text is rasterised at scale 1, since scale 2 clips glyph tops (#19525), and a sign is respawned rather than edited when its text changes (#7781). - Two engines signed in to the same account collide as one player (#14448), so a two-player check needs two accounts. - In the browser the engine runs scripts several times slower than on desktop, so a gallery of many boards costs far more of each frame there (#20750). - The kit and its guides are checked in the desktop app; an agent cannot start a browser engine itself, so the web check is done separately (#20946). - The pointer's world position is found from `screenToRay` and the board's plane, since picking a world position from the pointer is not covered in the guides (#8987). - Mouse and touch events arrive in window pixels while the pointer position and `screenToRay` use viewport pixels (#21604); gridKit measures the offset each frame, so this only matters if you pick cells yourself. - An entity made around an empty mesh keeps that empty extent after the mesh is filled, so a player's camera culls it and only a camera looking far down past it draws it (#4560). gridKit's guide drawings (the range outline, path ribbon, sight beam and the red cross on a blocking wall) have no entity while they are empty and get a fresh one whenever their extent changes, so they show from any camera; this only matters if you draw your own meshes that start out empty. ## Versions - **1.0.12**: the guide drawings show for a player in every game set up from the kit. The range outline, the green path ribbon with its arrowhead, the sight beam and the red cross on a blocking wall started out as empty meshes parked out of sight, and the engine kept that empty extent after they were filled (#4560), so a player's camera at normal height culled them and only a camera looking far down past the board drew them; the gallery's showcase boards were spared because they draw from the first frame. Each guide now has no entity while it is empty and a fresh one (on the same mesh) whenever its extent changes. Checked in play from the player's own camera at normal height on a freshly made board: before the fix the guides were missing, after it the range outline, path ribbon, sight beam, dashed blocked beam and red cross all show; per-cell highlights and blocked cells are unchanged. New test "guides" (suite now 10 tests), passed twice in a row. - **1.0.11**: the hex tactics example guide matches what a player sees. Red now starts on the left edge as seen from the spawn (column 6) and Blue on the right. Step 3 says how you aim: with the middle of the screen while the camera has the mouse, with the pointer once Esc frees it, or by tapping. Step 4 is now a turn-by-turn sequence: a blocked shot, a step into a gap, Blue passes, the shot, undo. Step 5 says exactly where its code goes and quotes the three lines to replace. New board setting `result`: when set (for example "Red wins!"), each player's status card shows it as its big line in place of whose turn it is and hides End turn; the example sets it, and the sign's second line, when a side has no pieces left. Checked by following the guide from an empty world with this release's files over a fresh install, with real mouse clicks: sides from the spawn, the blocked and seen shots, a whole game to "Red wins!" on the card and back with undo, and the claimed seat refusal; test suite (9 tests) twice in a row. - **1.0.10**: two guides come with the package, a how-to that teaches the kit and a step-by-step hex grid tactics example (listed under Guides). Three things the example needed and the kit lacked: a `selected` handler can set `e.handled = true` to take a click over from the built-in play (and reads the piece the player had selected as `e.selectedPiece`); `act{ op = "remove", id = enemy, by = mine }` takes an enemy off as one turn-checked, undoable step; and a seat claimed with `claimSeat` is now really held, so only its player can act for it or end its turn (before, the claim was recorded but never checked). On the frame of a window resize the screen size can read wrong (#16264), so the status card now skips that frame instead of placing itself against the wrong size. The world moves to the current built-in library. Checked on the current engine: gridKit 1.0.9 installed on its own from ZeroMind into a new empty world, where the README's first example ran exactly as written (a click placed a token on the board at 0, 0, 6 and Z took it away); this release's files laid over that install, where the example guide's code, taken straight from the guide, ran from step 2 to the winner and back with undo; the board entity synced and owned by the room's host; and the test suite (9 tests) twice in a row. - **1.0.9**: the status card on wide screens keeps off every board's title sign from the arrival overview too, where all sixteen boards fill the screen and no corner is free. It now searches the whole screen rather than six corners, treats each sign's plate as something it must not cover and the boards as something to avoid, and when nothing fits at full size it first drops its header and key-hint lines with smaller text, then shows only whose turn it is (and any message). Checked standing at each front-row board, with the camera on the arrival overview and with the camera following the player, at 2560x1440, 2097x1409, 1024x640 and 840x632, in English and Portuguese: in all 64 cases the card covers no sign plate and no board. - **1.0.8**: the status card on wide screens moves off the boards, signs and legends it would cover, to a free top or bottom corner or edge, measured against its own size, so a longer Portuguese line counts too. Checked only with the camera following the player (24 cases at 2560x1440, 2097x1409 and 1024x640, English and Portuguese, nothing covered). From the arrival overview, where no corner is free, the card could still sit on a sign's title (in Portuguese at 2097x1409, and at small windows); 1.0.9 fixes that. - **1.0.7**: the upright-phone HUD is sized in phone points: the UI space is normalised far wider than a phone is in points (664 units across a 390-point phone), so 1.0.6's buttons came out about 33 points tall. They are now about 56 points tall and 64 wide, with the text scaled to match, and the bar's lower edge stays 31% up the screen, clear of the move stick and the jump/sprint buttons. - **1.0.6**: idle boards cost much less: the moving parts of the hologram and pulse looks are baked once into a short loop of frames and only swapped while they play, and glow (which moves through its material) is no longer rebuilt at all. On a phone held upright the HUD buttons are thumb-sized, in one row with a compact status card just above the touch stick and jump/sprint buttons, so the top of the screen (the far boards and their signs) stays clear. Signs, legends, HUD and messages checked in English and Brazilian Portuguese after load, in play and across repeated language switches. - **1.0.5**: signs and legends step out of the way: when one stands between a player's camera and that player, or the board they are walking up to, it is taken out of that player's view (on their screen only) until the line is clear, so walking up to a board behind another row never puts the camera inside a sign; the board a player is at always keeps its own sign. README release history corrected. - **1.0.4**: every look answers to the names a creator would write (`holo`, `sci-fi`, `soft glow`, `retro`, `animated` ...), `Grid { highlight = ... }` picks the look at creation, and `Grid` warns about options it does not know instead of dropping them; the variant catalog (`GK.CATALOG`, `GK.variants`) lists the 16 shapes, looks and turn models with tags; signs and legends follow a language change live; the board you control is the one at your feet (measured from your body, on your own level), and the pointer no longer picks a board hidden behind scenery; `labelTilt` leans signs back; `setHighlight`. - **1.0.3**: the red ✕ that marks a wall blocking line of sight now lies flat on top of the wall instead of standing in the air, where it hid the letters of signs behind it. - **1.0.2**: touch picking fixed (a tap's emulated mouse click no longer overrides it, and a cell next to the board's centre line no longer reads as "-0" and refuses moves); range outline, path ribbon and sight beam guides on every look; `legend` field; signs wrap and fit their width; neon walls darker. - **1.0.1**: first release. Four grid shapes, picking by mouse, screen centre, touch and keyboard/gamepad cursor, multi-cell pieces, movement range and paths, line of sight and cover, undo, save/load, four turn models, eight highlight looks, two token looks, host-authoritative multiplayer, English and Brazilian Portuguese. Translation catalogs also travel inside `gridKit.strings`, since an asset install leaves a package's plain `locales/` folder behind. - **1.0.0**: a pre-release snapshot published from a side branch for the fresh-install check; superseded by 1.0.1 (its translations did not survive an install). Release history note: 1.0.0, 1.0.1-rc.1 and 1.0.3-rc.1 were published from a side branch called `prerelease` while proving fresh installs. That branch was removed from this world's working copy, but it still exists on the ZeroMind server: the engine's version control (`zm`) can publish a branch but has no way to delete one there, so only the world's owner can remove it from the website (#21020), and side-branch pushes claim release versions too (#21038). Nothing has been released from it since 1.0.3-rc.1; from 1.0.4 on every release is made from `main`, one version per push.