# text-maps DSL — Hex map reference Information-oriented, exhaustive syntax reference for hexcrawl maps (`map hexcrawl`): every declaration, property, accepted value and default. For what both map kinds share (syntax, comments, icon imports, the editor's tools), see the [DSL reference index](dsl-reference.md.txt). For a guided walkthrough, see the [hex map tutorial](dsl-tutorial-hex.md.txt). For dungeons and buildings, see the [dungeon reference](dsl-reference-dungeon.md.txt). ## Map header ``` map hexcrawl "Borderlands" ``` [Try it live](https://text-maps.tyrcho.com/#map/LYQwDgBAFgpgHgYwE4gO4BsICIBCB7JAExiXRADtCBnLAKCA) Just `map hexcrawl`, optionally followed by a quoted (or bare) title. As with dungeon/building maps, this title (if given) becomes the page title, a cosmetic URL hint, and the default export/download filename — see the [dungeon/building reference](dsl-reference-dungeon.md.txt#map-header). Indented lines right under the header are map-wide properties, with the same syntax as a dungeon/building map's header: ``` map hexcrawl "Borderlands" compass: top-right scale: 10 km ``` | Property | Value | Default | Effect | |---|---|---|---| | `compass:` | a corner (`top-left`, `top-right`, `bottom-left`, `bottom-right`, or `tl`/`tr`/`bl`/`br`), optionally followed by an angle in degrees | none (no compass) | a compass rose in that corner; an empty value means `top-right`. The angle turns north clockwise from straight up | | `scale:` | ` `, e.g. `10 km`, `6 miles`, `24 km`, optionally followed by a corner | none (no scale bar) | one hex is that far from its neighbor (centre to centre): draws a scale bar (default corner `top-left`), see below | | `blur:` | `on` or `off` (also `true`/`false`, `yes`/`no`; anything else is a parse error) | `on` | `on` draws each terrain region with a soft, hand-drawn outline (a blurred halo around a slightly wobbly edge) and blurs the country border bands; `off` fills regions along the exact hex edges, with crisp border bands | | `coords:` | `on` or `off` | `off` | `on` names the hexes like a chessboard, so a hex reads `B7`: rows numbered down the left, 1 the topmost; columns lettered along the top, `A` the leftmost (then `B` ... `Z`, `AA`, `AB`). A column is a vertical zigzag of hexes — every other row is shifted half a hex to the right — and its letter sits over its hex in the top row. These name hexes on the picture; they are not the `q,r` coordinates. The editor's **Map settings** → Grid coordinates toggles it | | `turn:` | an angle in degrees, like `90` or `-45` | `0` | on a `sphere` or `torus` map, draws the world turned that far eastward around its axis (ignored on a flat map), see [World maps](#world-maps-topology-sphere-and-torus) below | | `line-width:` | a factor from `0.01` to `100` (any decimal), or a percentage (`150%`) | `1` | how thick roads, rivers, paths and country borders draw. Every road, path and border also draws over a translucent parchment-coloured casing, so it reads on any terrain colour. A road or a country can set its own `line-width:` too, see [Element sizes](#element-sizes-line-width-and-text-size) | | `text-size:` | a factor from `0.01` to `100` (any decimal), or a percentage (`150%`) | `1` | how big every name on the map draws: hex and zone labels, road and river names, country names. Each of them can set its own `text-size:` too, see [Element sizes](#element-sizes-line-width-and-text-size) | | `topology:` | `plane`, `sphere` or `torus` (anything else is a parse error) | `plane` | what the map is a picture of: a flat map, or a whole round world. On a `sphere` or a `torus` each row of hexes is a circle that closes on itself (its left and right ends touch), see [World maps](#world-maps-topology-sphere-and-torus) below | The scale bar spans a round distance. For example `scale: 10 km` draws 5 hexes labelled `50 km`; `scale: 6 miles` draws 5 hexes labelled `30 miles`. A compass or scale bar in a top corner adds a strip above the hexes (a bottom corner, one below), so it never covers any terrain. In the visual editor, the ![Map settings](tool-icons/map-settings.svg) **Map settings** tool toggles these header properties — the compass rose, the scale bar and its length, the grid coordinates and (hexcrawl only) the soft outlines and the **Line width** and **Text size** controls (`line-width:`, `text-size:`: a slider from 10% to 1000% with − and + buttons) — by editing the header lines above; it works the same for dungeon/building maps' `compass:`, `scale:` and `coords:`. ### World maps (`topology: sphere` and `torus`) ``` map hexcrawl "Ring world" topology: torus turn: 90 ``` A world map draws a whole round world flat. Each row of hexes is a circle of latitude: it runs from its leftmost to its rightmost hex with a terrain, and those two ends touch. Rows may differ in length: an equal-area world draws a row shorter where the world is narrower. - **`sphere`**: the top row is the north pole, the bottom row the south pole. - **`torus`**: the middle row is the outer equator (the longest circle); the top and bottom rows are the same circle, the inner equator (the shortest, around the hole). The upper half of the map is the top of the ring. How thick the ring's tube is comes from the map: the longer the outer equator is than the inner one, the thicker the tube. **`turn:`** (degrees, eastward; `0` by default, ignored on a `plane` map) draws the world turned around its axis: every row moves by the same share of its own length, and wraps around, so any place can be brought to the middle of the map. Every terrain and country keeps its number of hexes, and a turn of 360° gives the same map back. A road, river or path step that would cross the row's seam isn't drawn. The hexes keep the coordinates they are written with: `turn:` only changes where they are drawn, so turning the map changes this one line of the text, and turning it back gives exactly the map you started from. A row's share is reckoned from its length (its leftmost to its rightmost hex with a terrain), so give every row its full length, ocean included. The editor does two things with a world map: - **Turn** (in **Map settings**, next to World) sets `turn:`: drag it to spin the world, let go to write the angle (0° removes the line). The map tools work on the turned map: they edit the hex drawn under the pointer, at the coordinates the text gives it (the coordinates tooltip shows those), and their previews are drawn where those hexes are shown. A line or rectangle a tool draws is reckoned in the text's coordinates, so where rows of different lengths have moved by different amounts, its preview can step sideways by a hex: what it shows is what it writes. The badge over the map says the view is turned and turns it back to 0°. - **File ▸ Open as globe in new tab** wraps the map, as drawn, around a 3D sphere or torus. Drag to turn it, use the wheel to zoom. Each row goes once around, so the globe draws the terrain with every row stretched to the same length: regions keep smooth outlines where rows of different lengths meet, and the hex outlines aren't drawn. Labels and icons stay upright, where their hex is. Zoomed in, the part in view is drawn again at a finer scale by the editor tab (as long as it stays open), in tiles: coarser ones first, then as fine as the view needs, then the tiles around it while nothing else is asked. The globe keeps moving meanwhile, and keeps the last tiles drawn, so coming back to a place is instant. A `plane` map (the default) never turns and has no globe view. Coordinates throughout are **pointy-top axial** `(q, r)` — see [Red Blob Games' hex grid reference](https://www.redblobgames.com/grids/hexagons/) for the scheme. They're author-supplied, not auto-laid-out: a hex grid *is* the geography. ## `hex ,` ``` hex 0,0 terrain: plains label: "Kingsport" ``` One hex. Properties: | Property | Values | Default | |---|---|---| | `terrain:` | see **Terrain vocabulary** below | none (no fill/decoration — a bare grid cell) | | `label:` | any string | none — see note below on what it names | | `country:` | any string (a territory name), or `none` | none, or the enclosing `country:` block's name | | `layer:` | any string (a named grouping) | none, or the enclosing `layer:` block's name | | `text-size:` | a factor from `0.01` to `100`, or a percentage | `1` — the hex's label size, times the header's `text-size:` (see [Element sizes](#element-sizes-line-width-and-text-size)) | | `.: ` | size only (`x`/bare number/empty) — a single hex has no sub-grid, so the icon is always centred | — | A later `hex`/`zone` declared at the same coordinate is simply appended after and paints over the earlier one for whichever properties it sets — no special override syntax needed. Properties it doesn't set (e.g. a terrain-only re-declaration) leave the earlier declaration's other properties (label, POI, country) in place. `terrain: none` is not a thing — omit the property entirely to leave a hex without terrain. A `terrain:` value that isn't in the vocabulary below (e.g. a typo like `forrest`) is a parse error on its own line, naming the valid values. **`label:` names whatever else is on the same hex** — a `.:` POI, if the hex has one; otherwise the hex/settlement itself (as in the `hex 0,0` example above, a plain named place with no icon). It is not a property of the terrain. This matters for the visual editor's Select tool: dragging a POI to a new hex carries its `label:` along with it (the destination's own label, if any, is overwritten) — the terrain and `country:`/`layer:` assignment are left exactly where they were, since those describe the *hex*, not the thing standing on it. A POI is an icon, a name or both: a `hex` with a `label:` and no icon is a POI that is a name alone, and one with an icon and no `label:` is an icon alone. In the editor, ![Place POI](tool-icons/place.svg) **Place POI** ▸ **Text only** (in its flyout's Tools) writes a name with no icon on the hex you click, in a new `hex q,r` block when the hex isn't declared yet, and ![Select](tool-icons/select.svg) **Select** picks up either kind of POI to rename, resize, move or delete it (deleting a name alone removes its `label:` and `text-size:`). Its selection bar's **Icon…** button changes the POI's icon, and **Remove icon** (or **No icon** in that picker) removes it (a POI left with no name goes too). ## `zone (q1,r1)-(q2,r2)` (and other corner forms) A zone is to hexes what a room is to a dungeon: a bounded area with its own top-left-relative frame for placing one label/icon set, not a batch-repeat stamp. ``` zone (2,-2)-(4,0) terrain: forest label: "Whispering Woods" gi.cave-entrance: north ``` `terrain:`/`country:`/`hide-*:` fill **every** hex in the zone's range. `label:` and icon properties belong to the zone **as a whole** and resolve to exactly one hex via the same position grammar a room feature's value uses (see **Icon features** above), but relative to the zone's own bounding box: | Position value | Resolves to | |---|---| | empty / a bare size | the zone's center hex | | a wall word (`north`/`south`/`east`/`west`) | that edge of the box, centered along the other axis | | `,` | `(minQ+col, minR+row)` — that many hexes in from the zone's own top-left corner | When the resolved hex isn't part of the zone itself (a concave polygon, a `rectangle`-axis zone, or a `,` past its edge), the label or icon moves to the zone's nearest hex instead of disappearing. Zone properties: | Property | Values | Default | Notes | |---|---|---|---| | `terrain:` | see **Terrain vocabulary** | none | | | `label:` | any string | none | one label, at the zone's centre hex; large zones get a larger label, see below. The editor's **Select** tool picks it up on that hex to rename it, size it, give it an icon (centred under it, an `.:` with no position) or delete it; it stays at the zone's centre | | `country:` | any string, or `none` | none / enclosing `country:` block | | | `layer:` | any string | none / enclosing `layer:` block | | | `text-size:` | a factor from `0.01` to `100`, or a percentage | `1` | the zone's label size, times the header's `text-size:` | | `axis:` | `qr` \| `qs` \| `rs` \| `rectangle` | `rectangle` | only meaningful for a **2-corner** zone — see below; any other value is a parse error | | `hide-terrain:` | `true` \| `false` | `true` | merge-order knob — see **Declaration-order semantics** | | `hide-poi:` | `true` \| `false` | `false` | ditto (any other value on a `hide-*` flag is a parse error) | | `hide-paths:` | `true` \| `false` | `false` | ditto | | `.: ` | a position (table above) | — | | A zone more than 3 hexes across in both directions gets a larger `label:` that grows with the zone (up to 64 px, never wider than ~70% of the zone), so a big region's name stays readable when zoomed out. **Corner forms** (the part between `zone` and the properties): 1. **2 absolute corners**, default axis (`rectangle`) — the two corners' pixel centers define an axis-aligned rectangle *on screen*; every hex whose center falls inside it is included, either corner order works: ``` zone (2,-2)-(4,0) terrain: forest ``` 2. **2 absolute corners + `axis: qr`/`axis: qs`/`axis: rs`** — an axial parallelogram bounded on one pair of hex-grid axes (`q`/`r`, or `s = -q-r`) instead of screen pixels. The q/r/s axes aren't perpendicular in pixel space, so all three of these render as a skewed parallelogram, not a rectangle — pick one when you want the zone's edges to follow the hex grid's own diagonals rather than a true on-screen rectangle: ``` zone (0,0)-(3,3) terrain: hills axis: qs ``` 3. **3+ corners** — an arbitrary polygon, filled by point-in-polygon test (works for convex and non-convex shapes). Hexes on the outline, corners included, are part of the zone, so this one covers the same 20 hexes as `zone (0,0)-(4,3)` with `axis: qr`: ``` zone (0,0)-(4,0)-(4,3)-(0,3) terrain: swamp ``` 4. **Relative moves** after the first (absolute) corner — instead of spelling out every corner's absolute coordinate, `( )` moves `n` hexes from the previous point: `r`/`l` (right/left), `br`/`bl` (bottom-right/bottom-left), `tr`/`tl` (top-right/top-left): ``` zone (0,0)-(r 4)-(br 2)-(l 4) terrain: desert ``` The first point must always be absolute; later points may freely mix absolute `(q,r)` and relative `(dir n)` forms. A point that is neither (e.g. `(a,b)`, `(r x)`, or a relative move as the first point) is a parse error, and so is a zone with fewer than 2 corners, or one whose bounding box spans more than 100000 hexes. A hex or waypoint coordinate that doesn't fit a 32-bit integer is a parse error too, and so is a `road:`/`river:`/`path:` longer than 20000 hexes. ## Roads, rivers & paths One line per declaration — the keyword itself is the kind: ``` road: (0,0)-(2,-2) color: gray name: "Old King's Road" river: (0,0)-(-1,0) name: "River Ash" path: (0,0)-(2,0)-(2,2)-(4,2) ``` - `road:`/`river:`/`path: (q1,r1)-(q2,r2)-...` — 2 or more waypoints. Every hex between each consecutive pair is filled in automatically (standard cube-coordinate hex line-drawing), so a bent route across many hexes only needs its turning points. - The whole chain draws as one continuous shape: interior waypoints get a small deterministic wobble off their exact hex center (rivers wobble more than roads/paths), every joint is rounded, and a river tapers wider from its first waypoint (source) to its last (mouth). - `color:` (optional, indented property) — a keyword or any CSS color, applied to every hop of that one declaration: | Keyword | | Keyword | | Keyword | |---|---|---|---|---| | `black` | `white` | `gray`/`grey` | `brown` | `red` | | `blue` | `green` | `yellow` | `orange` | `purple` | Any other CSS color (`#2f6f4f`, `rgb(...)`/`hsl(...)`, a CSS color name) is passed through as-is; a value that isn't a color (e.g. one containing quotes or spaces) is ignored. Omitted or ignored → each kind's own default (road: dark brown dashed, river: blue tapering ribbon, path: gray dotted). - `layer:` (optional, indented property) — same named-grouping concept as `Hex.layer`. - In the editor, the ![Select](tool-icons/select.svg) **Select** tool's bar shows, for a selected road, river or path, a kind list that rewrites its `road:`/`river:`/`path:` keyword, and a **Name** field and **Color** list that write its `name:` and `color:` (empty or Default removes them). - The visual editor keeps the waypoint list short: every edit of a route (dragging or adding a point, deleting one, drawing it) drops each waypoint the straight line between its two neighbors already passes through, and a waypoint repeating the previous one — the route crosses exactly the same hexes, in the same order, as before (the same rule as merging zones: never a hex more or less). The waypoint just dragged stays. `road: (0,0)-(1,0)-(2,0)-(2,3)` becomes `road: (0,0)-(2,0)-(2,3)`. - `name:` (optional, indented property, quoted or bare) — the route's name, written once along it in italics and in the line's own color: beside the middle hop of the chain, turned to its direction (never upside down). See [`rivers_and_roads.dsl`](../examples/hex/rivers_and_roads.dsl). - `line-width:` / `text-size:` (optional, indented properties) — this route's own line thickness and name size, times the header's (see [Element sizes](#element-sizes-line-width-and-text-size)). ## Element sizes (`line-width:` and `text-size:`) The header's `line-width:` and `text-size:` size every line and every name on the map. Each element can also carry its own: | Where | `line-width:` sizes | `text-size:` sizes | |---|---|---| | a `hex` | — | its label | | a `zone` | — | its label | | a `road:`/`river:`/`path:` | the line | its `name:` | | a `country:` block | its border | its name | The size drawn is the element's factor times the header's: with `text-size: 2` in the header and `text-size: 1.5` on a hex, that hex's label draws three times its normal size. Each factor is any decimal from `0.01` to `100`, or a percentage (`150%`); anything else is a parse error on its line. ``` map hexcrawl text-size: 1.25 hex 0,0 label: "Kingsport" text-size: 2 road: (0,0)-(3,0) name: "King's Way" line-width: 2.5 country: "Duskvale" line-width: 2 zone (0,0)-(1,1) terrain: plains ``` In the editor, select a road, river or path, a POI or a country with the ![Select](tool-icons/select.svg) **Select** tool: the selection bar's **Line** and **Text** controls (a slider from 10% to 1000% with − and + buttons that step through 125%, 160%, 200%, 250%, 300%, 400%, 500%, 600%, 800% and 1000%) write that element's own factor; 100% removes it. A country without a block gets one at the end of the map, holding just the setting. ## Terrain vocabulary (`terrain:`) `plains` | `grassland` | `forest` | `jungle` | `hills` | `mountains` | `desert` | `badlands` | `wasteland` | `swamp` | `marsh` | `water` | `ocean` | `coast` | `tundra` | `glacier` | `volcanic` | `farmland` | `mists` — 19 values total, case-insensitive, each with its own fill color and a faint fixed decoration icon. Terrain isn't a flat per-hex fill: every connected same-terrain region (hexes of that terrain touching edge-to-edge) is traced as one hand-drawn organic shape with a soft bleed halo where a "denser" terrain (forest, mountains, ...) overlaps an "open" one (water, plains, ...). A region below 6 hexes gets one decoration icon; at or above that size, an evenly-spaced sample instead of one per hex. ## `country: ` — as a property or a block As a plain property on a `hex`/`zone` (fills that one hex, or the whole zone): ``` hex 0,0 country: Duskvale ``` As a **block** — since a country is usually the sum of several zones, not just one — every `hex`/`zone` indented under it defaults to that country (one can still override with its own `country:` property, an enclave): ``` country: Duskvale zone (0,0)-(0,2) terrain: mountains zone (1,0)-(1,2) terrain: hills hex 0,1 terrain: mountains label: "Stonehold" ``` A country is never drawn as its own line/shape — the border is computed at render time wherever two adjacent hexes (or a hex and no hex at all) disagree on `country`, the same way a coastline is implied rather than authored. A `country:` block can also set the country's own `line-width:` (its border) and `text-size:` (its name) on lines of their own, at the block's first indent: ``` country: "Duskvale" line-width: 2 text-size: 1.6 zone (0,0)-(0,2) terrain: mountains ``` A border between two countries takes the larger of their two `line-width:`s. See [Element sizes](#element-sizes-line-width-and-text-size). `country: none` takes hexes back out of any country — the last declaration wins, so a later `hex`/`zone` with `country: none` cuts a hole in a country declared earlier, or pulls its border in, without touching that hex's terrain, icon or label (a declaration that only sets `country:` never does): ``` zone (0,0)-(4,4) terrain: plains country: Duskvale hex 2,2 country: none ``` The visual editor's ![Select](tool-icons/select.svg) Select tool *transfers* hexes when you add them to a selected country or remove them from it, rather than piling overrides on top (![Country](tool-icons/country.svg) Country paint, hex by hex or by zone, does the same): - a declaration with its own `country:` property gets that property changed in place (a zone is split around the hex, which keeps the zone's terrain); - a declaration that gets its country from a `country:` block leaves that block: a `hex` moves whole, a zone is split into `axis: qr` rectangles and the hex takes the zone's terrain along. It joins the target country's first `country:` block (a new one at the end of the document if there is none), or, when taken out of every country, sits right after the block it left. Moved hexes with the same terrain are regrouped into one zone; - a top-level `hex`/`zone` with no country at all moves into the target country's block the same way (terrain, label and icon along), and a hex declared nowhere gets a bare entry there. For example, adding `0,3` to Solmere here: ``` country: Duskvale zone (0,0)-(0,3) terrain: mountains axis: qr country: Solmere zone (5,0)-(7,0) terrain: desert axis: qr ``` gives: ``` country: Duskvale zone (0,0)-(0,2) terrain: mountains axis: qr country: Solmere zone (5,0)-(7,0) terrain: desert axis: qr hex 0,3 terrain: mountains ``` Only a hex that a later declaration would still override (one that resets its country) falls back to a `country: ""` / `country: none` block at the end of the document. Moving a whole country (the Select tool's ![Move](tool-icons/move.svg) Move) shifts the bare `hex`/`zone` entries of its own `country:` block in place, and transfers any other hex it covers as above (e.g. one it got from a `country:` property on a zone that also sets terrain, which stays where it is). ## `layer: ` — as a property or a block Same two forms as `country:` (plain property, or a block wrapping several declarations), and the two can nest inside each other (a `layer:` block inside a `country:` block or vice versa — whichever is innermost wins for its own default, independently of the other). The block may also be spelled `layer ""`, like on dungeon maps: ``` layer: "Political Overlay" zone (0,0)-(2,0) country: Duskvale ``` `layer:` groups content for the visual editor's show/hide panel. A hex/edge with no `layer:` is always visible, regardless of any layer's hidden state. A top-level block with nothing in it declares an empty layer, which the Layers panel lists all the same. A block may set its layer's `opacity:` (`40%` or `0.4`, default `100%`), as on dungeon maps: ``` layer "Political Overlay" opacity: 50% zone (0,0)-(2,0) country: Duskvale ``` A translucent layer is drawn on its own, over the rest of the map, so what lies underneath shows through — in the CLI's render too. A fully opaque layer is drawn with the rest of the map, painting over earlier declarations as usual. The panel works as on dungeon maps (see the [dungeon `layer ""` block](dsl-reference-dungeon.md.txt#layer-name--a-layer-block-its-content-stacking-and-opacity)): create a layer with Enter or **+**, pick the active layer (◉) that new paint/stamps/zones/paths go on, tick to show/hide, slide a layer's opacity (a view setting starting from its `opacity:`; the DSL is left alone), 🗑 to delete a layer — with everything on it, or moving its content to another layer or to none. Painted content is appended with its own `layer:` property rather than filed into the block, since a hexcrawl's later declarations paint over earlier ones. ## Moving and copying an area The visual editor's ![Area](tool-icons/area.svg) **Area** tool works on an area of hexes you drag: by default a rectangle (the hexes whose centres lie in it, like a zone's default `rectangle` axis). Right-click cycles the shape, as with the Zone tool: `rectangle`, `qr`, `qs`, `rs`, then **freehand**, where you draw the outline and the area is the hexes it goes through and those it encloses. Then: - dragging the selection **moves** what is in it: terrain, labels and icons, and the stretch of each road, river or path inside it (a route crossing the edge is cut there). It paints over the hexes it lands on; - Ctrl/Cmd+C **copies** it, Ctrl/Cmd+X **cuts** it, and Ctrl/Cmd+V **pastes** the copy with its top-left hex under the pointer (beside the original if the pointer is off the map); the pasted copy is selected, ready to be dragged; - Delete clears it, Escape drops the selection. The hexes an area leaves (moved, cut or cleared) are emptied — unless the area is set in a uniform background: when every hex bordering it from outside has the same terrain (an island cut out of an ocean), its hexes are filled back with that terrain (on that layer, when they share one). Each element keeps its layer: a moved or pasted declaration is written at the end of the text with its layer as a `layer:` property, the way the paint tools write. Country borders are not affected: a hex keeps its country when its content leaves, and pasted content takes the country already there. Only a country lying entirely inside the rectangle travels with it — moved, it keeps its name; copied, the copy is a new country ("Isle" gives "Isle 2"). In the text, a declaration only partly inside is split into `axis: qr` rectangles, its label and icons staying on the hex they are drawn on (like the terrain eraser). ## Declaration-order semantics (`hide-terrain:`/`hide-poi:`/`hide-paths:`) Two declarations at the same coordinate merge in source order, later wins — but a **zone**'s `hide-*:` properties change exactly how: - `hide-terrain: true` (the default) — this zone's `terrain:`, if set, wins over an earlier declaration's; if this zone has **no** `terrain:` set, an earlier one's terrain still shows through (`hide-terrain` only arbitrates between two *present* values — it can never force a hex back to bare/no-terrain). - `hide-terrain: false` — the opposite: this zone's `terrain:` only fills hexes that have no terrain yet. Where an earlier declaration already set a terrain, that terrain stays, so a zone can paint a background underneath what is already there. - `hide-poi: true` — force-clears any earlier declaration's POI icons at this zone's coordinates, even if this zone sets none of its own. - `hide-paths: true` — suppresses any road/river/path edge whose endpoint falls in this zone's footprint, if that edge was declared *before* this zone (an edge declared after is never affected). These three are independent and all default as shown; a plain `hex` declaration always keeps their defaults (they're zone-only knobs). ## Full worked examples A three-country continent (terrain bands, roads, rivers, borders): [`continent.dsl`](../examples/hex/continent.dsl). An archipelago split into layers (an ocean fill under the islands, sea routes and realms on their own layers): [`jade_isles.dsl`](../examples/hex/jade_isles.dsl). Large generated worlds that show the same syntax at scale, and how far the editor stretches: [`large_world.dsl`](../examples/hex/large_world.dsl) (64×40) and [`huge_world.dsl`](../examples/hex/huge_world.dsl) (128×80), in the same directory. [`worldgen_continent.dsl`](../examples/hex/worldgen_continent.dsl) is the output of the geographer skill's generator (`skills/text-maps-geographer/scripts/worldgen.py`): relief, drainage and rain turned into rows of terrain zones and `river:` chains. See also the [hex map tutorial](dsl-tutorial-hex.md.txt) for a guided, step-by-step introduction, and `doc/hexmap-z-order.md` in the repository for the exact bottom-to-top hexcrawl render order.