@adatechnology/game-urban 0.1.0 → 0.2.0

package/README.md

@@ -49,6 +49,23 @@ createUrban({
 - `block.fill(b, { cx, cz, size, minHeight, maxHeight, k, gap, lit, shop })`: a `k x k` split of the block less 2 m of street; a building a little smaller than its lot, as tall as `lerp(min, max, random^1.6)` (more low buildings than tall ones), drawn by `createCityBuilding` of game-floorplan with the shared generator. Returns the buildings for the game's bookkeeping. `block.building` places one.
 - `props`: `fence`, `tent`, `pine`, `tree`, `container`, `watchtower` (with a searchlight whose beam circles the ground), `sandbags` (instances), `label` (two lines on a 22 x 4.4 m board) and `wires`.
 
+### Towers
+
+`createUrban({ towers: true })` (off by default; the output is then the same as before, byte for byte) draws a building of the block or of an avenue that is at least `minHeight` (60 m) tall as a **tower** instead of a box: a podium with a taller ground storey, the shaft with a row of windows on every storey of its four faces, darker bands without windows where the plant floors are, the top plant floor set back, the parapet and a mast. Which kind is drawn is chosen by weight among the `presets`, whose numbers are the ones of the typologies of `game-floorplan-commercial` (`office`: 4 m storeys, a plant floor every 20, glass curtain wall) and `game-floorplan-residential` (`residential`: 3.1 m storeys, every 25, masonry with a window in each bay); the tests keep them equal. A game turns them off, changes the cut-off height, the presets and their weights, or draws the tower itself:
+
+```ts
+createUrban({
+  towers: {
+    minHeight: 80,
+    presets: [{ id: 'office', weight: 1, storeyHeight: 4, mechanicalEvery: 20, glass: true, color: 0x3c5a73 }],
+    mast: 0.04,
+    provider: (request, b) => myTower(request, b),   // request: x, z, width, depth, height, color, preset, lit
+  },
+})
+```
+
+The heights come from where the building is drawn: `block.fill`'s `minHeight` and `maxHeight`, or the `buildings` of the `downtown` pattern (raise them with `patch`). The pack `TOWER_PATTERNS` (not in the sample sheet) adds `financial_district`, the avenue with 20 m lots and towers of 70 to 180 m: `createUrban({ packs: { neighbourhoods: TOWER_PATTERNS }, towers: true })`.
+
 ## Neighbourhood patterns
 
 `urban.neighbourhoods` has the ten patterns of the Galeria's sample sheet: `downtown`, `suburb`, `working_class`, `historic_street`, `industrial_port`, `railway_village`, `mountain_resort`, `stilt_village`, `military` and `rural`. A pattern is data (`streetWidth`, `walkWidth`, `typologies`, `pole`, `lightColor`, `spacing`, `lit` = the share of lamps on and the rest burnt out, `marker`, `text` in `pt-BR` and `en`, and the `params` of its composer) plus a `compose` key into the registry of composers, which draw the street. A game changes a number with `patch`, adds a pattern with `packs` and a composer with `composers`, or takes one out with `remove`.
@@ -70,6 +87,55 @@ urban.neighbourhoods.composeSampleSheet(b)   // the ground and the ten cells, in
 
 `createVehicleProvider({ ids?, pick?, paint? })` parks a vehicle of `game-vehicles-fleet` (cars, SUVs, pickups and vans by default) where a pattern parks one, and `createPlantProvider({ region?, contexts?, seed?, pick? })` plants a species of `game-vegetation-species` where a pattern plants (a tree from the region's `sidewalk_tree` table, a pine from `square`). They do not draw: they add a `placement` part (`b.place(kind, id, x, z, { ry, scale, color, seed })`) that says what to put and where. The choice depends on the spot and not on `b.random`, so the scene around it keeps the same draw order. The drawer (`game-urban-three`) asks a resolver for each kind and leaves the spot empty when it has none.
 
+## City plans (zoning)
+
+A **district kind** (`urban.cities.kinds`, 22 shipped) says what a patch of the city is: its map `color`, the `zone` of the floorplan packages (`zt`, `zc`, `zr1`, ...), the neighbourhood `pattern` that dresses it (an id of `urban.neighbourhoods`, or `financial_district` of `TOWER_PATTERNS`), the `floors` `[min, max]`, the share of buildings by `uses` (`commercial`, `residential`, `industrial`, `institutional`, `agricultural`), the `block` size in metres (0 = no blocks) and its `text` in `pt-BR` and `en`. A **city plan** (`urban.cities.plans`) paints kinds on a map of metres (centre 0,0, x east, z south): `districts` (`{ id, kind, rect: [x0, z0, x1, z1], name?, floors?, uses? }`) listed from the outer to the inner one, so the **last district that contains a point wins**; `lines` (avenue, street, highway, rail, river) and `landmarks`. Plans are data: nothing is drawn unless you call `fillBlock`, and existing scenes do not change.
+
+| id | scale | size (m) | what it is |
+|---|---|---|---|
+| `metropolis` | metropolis | 6000 x 6000 | Tower downtown ringed by commerce, high-rise and low-rise neighbourhoods, outskirts and industry on the railway |
+| `regional_city` | city | 4000 x 4000 | Commercial centre with a few tall buildings, house neighbourhoods and an industrial district |
+| `port_city` | city | 4000 x 3000 | Quays and warehouses on the shore, old town behind the port and neighbourhoods up the hill |
+| `rail_town` | town | 3000 x 3000 | A town grown around its station: rail yard, old centre, company village |
+| `country_town` | town | 2400 x 2400 | Main square with the church, ground-floor shops around, houses, a co-op and smallholdings |
+| `mountain_village` | village | 1600 x 1200 | Church square, a street of inns up the slope and chalets scattered on the hill |
+
+```ts
+const urban = createUrban({ towers: true })
+const layout = urban.cities.layout('regional_city', { locale: 'en', maxFloors: 40 })
+layout.districtAt(0, 0)                              // { id, kind, color, zone, pattern, floors, uses, block, name, rect }
+const center = layout.districts.find((d) => d.kind === 'commercial_center')!
+const blocks = layout.blocks(center.id, { street: 10 })   // { x, z, size, district, building: { floors, uses, zone, pattern } }[]
+const b = urban.builder({ seed: 7 })
+for (const block of blocks) urban.cities.fillBlock(b, block)   // block.fill with the block's floors and uses
+urban.cities.stats(layout)                           // [{ kind, area, share, districts }] by kind
+```
+
+`blocks` is the grid of the district's rectangle by the kind's `block` size, less the street, skipping the cells whose centre belongs to another district (one painted over it). `block.building` is the config a building generator takes. `fillBlock` calls `block.fill` with the block's `floors` and `uses` (and `storeyPresets` / `storeyHeight` when you pass them), so each building picks its use by weight and gets `floors x storey height` of that use's tower preset (`office` 4 m, `residential` 3.1 m; a game that changes the presets changes it); with `towers` on, tall commercial buildings become office towers and tall residential ones residential towers, capped by `towers.maxStoreys`. The ground-floor `shop` chance defaults to the commercial share. It draws nothing for kinds with no storeys or no pattern.
+
+**Floors are capped at 60 by default**, after the district's own override: `createUrban({ cities: { maxFloors: 40 } })` or `layout(plan, { maxFloors })` clamp every district to `[0, maxFloors]`. A game raises the cap and the kind together.
+
+A game adds its own city (or kind) with `packs`, changes numbers with `patch` and takes some out with `remove`, under the keys `districtKinds` and `cityPlans`. A plan can start from another with `extends`: its districts, lines and landmarks come first, a district or line with the same id replaces the parent's in place, new ones append (landmarks always append), and `size`, `scale` and `text` are inherited when omitted.
+
+```ts
+createUrban({
+  cities: { maxFloors: 80 },
+  packs: {
+    districtKinds: [{ id: 'harbour_lofts', color: '#5aa0a8', zone: 'zr3_zm', pattern: 'downtown', floors: [3, 9], uses: { residential: 0.7, commercial: 0.3 }, block: 60,
+      text: { 'pt-BR': { name: 'Lofts do cais', description: 'Armazéns reformados.' }, en: { name: 'Harbour lofts', description: 'Converted warehouses.' } } }],
+    cityPlans: [{
+      id: 'my_port',
+      extends: 'port_city',
+      districts: [{ id: 'lofts', kind: 'harbour_lofts', rect: [-400, -200, 0, 300] }],   // painted over what is there
+      lines: [{ id: 'ferry', kind: 'street', width: 12, points: [[-400, 0], [0, 0]] }],
+      landmarks: [{ kind: 'lighthouse', at: [-380, 120], name: 'Old light' }],
+    }],
+  },
+  patch: { districtKinds: { downtown: { floors: [30, 80] } } },
+  remove: { cityPlans: ['rail_town'] },
+})
+```
+
 ## Terrain
 
 `urban.terrain(options)` is a ground made of layers, as the Galeria's Vale: a rolling base (waves), masked relief (mountains, hills: `mask · (level + waves)`), cities levelled flat, rivers carved to a bed, lakes carved to a level, a forest density, and a colour for every point by ordered rules (low ground, ellipses such as a bog, city rectangles, high rock, forest, then open fields picked by a hash of the map cell). It answers `heightAt(px, py)`, `forestAt`, `colorAt`, `nearRiver` and `toWorld`/`fromWorld` (the frame maps the plan to metres: `world = plan · scale + origin`), and hands a drawer `grid(segments)`: the 32-bit coordinates, heights and colours of the square mesh, rows along z. `urban.drawTerrain(b, terrain)` adds the mesh part and the water plane. `custom(px, py, h)` has the last word on a height.
@@ -79,3 +145,27 @@ The numbers of a place are the game's: the Vale Cinzento (4 rivers, 4 lakes, 5 c
 ## Same seed, same city
 
 The page keeps one generator for everything it draws and draws from it in call order. The builder does the same: the facade colour, the shop signs, the lit windows and the heights come from `b.random`, in the page's order, so a scene drawn with the same seed and the same calls has the same parts. The golden test in `game-urban-three` compares 34 parts, the terrain mesh (181 x 181 vertices, heights and colours) and the whole sample sheet (1029 objects, the lists of instances and windows, the light budget left, the next number of the random and the map markers) with the page's scene hash, the lists the page keeps before its flush and the surface of each material.
+
+### Configurar pelo jogo (torres da cidade)
+
+`createUrban({ towers })` aceita `minHeight`, `maxStoreys` (padrão 60: um lote mais alto é desenhado com 60 andares do tipo), `presets` (cada um com `weight`, `storeyHeight`, `mechanicalEvery`, `glass`, `minStoreys`, `maxStoreys`), `mast`, `lit` e `provider`. `towerPresetOf` monta um preset a partir do layout de uma tipologia, para a cidade desenhar a mesma torre que o jogo configurou em `office_tower` / `residential_tower`.
+
+```ts
+const office = officeTowerLayout({ storeys: 50, height: 3.4 })
+const kit = createUrban({
+  packs: { neighbourhoods: TOWER_PATTERNS },
+  towers: {
+    maxStoreys: 70,
+    presets: [
+      towerPresetOf('office', 0.3, office, { mechanicalEvery: 18, minStoreys: 25, maxStoreys: 70 }),
+      { ...DEFAULT_TOWER_PRESETS[1], weight: 0.7, maxStoreys: 40 },
+    ],
+  },
+})
+```
+
+Por prédio, o bloco também aceita os andares e os usos (os mesmos nomes de `building` de um bloco de `urban.cities`): `block.fill(b, { ..., floors: [8, 40], uses: { commercial: 0.6, residential: 0.4 } })`. `floors` é um número ou `[min, max]` e vira altura (andares vezes o pé-direito do preset do uso; sem uso, `storeyHeight`); `uses` sorteia o uso de cada prédio por peso, e `storeyPresets` (padrão `{ commercial: 'office', residential: 'residential' }`) diz que tipo de torre cada uso desenha. Com `towers` ligado, prédios altos comerciais viram `office` e residenciais `residential` (o `TowerRequest` traz `use` e `storeys`); os baixos seguem o prédio comum com a altura dos andares pedidos. Sem `floors` e `uses` a saída não muda.
+
+```ts
+kit.block.fill(b, { cx: 0, cz: 0, size: 100, minHeight: 20, maxHeight: 60, ...block.building })  // block.building = { floors: [10, 40], uses: { commercial: 1 } }
+```

package/dist/index.d.ts

@@ -586,6 +586,83 @@ declare function drawGround(b: UrbanBuilder, color?: number, size?: number): voi
  */
 declare function drawStreetGrid(b: UrbanBuilder, block: number, count: number, width: number, options?: StreetOptions): void;
 
+/**
+ * One kind of tower the city can put on a tall lot: the numbers of a typology of `game-floorplan-commercial` (office) or `game-floorplan-residential`
+ * (residential), which the tests keep equal to theirs. The city only draws the outside; the plan of the inside is the typology's.
+ */
+type TowerPreset = {
+    id: string;
+    /** Chance weight among the presets (the one the random picks). */
+    weight: number;
+    /** Floor to floor in metres: the clear height of the typology plus its slab. */
+    storeyHeight: number;
+    /** A plant floor (darker band, no windows) every this many storeys; `false` none. */
+    mechanicalEvery: number | false;
+    /** A glass curtain wall (a ribbon of tall windows on a tinted skin) or a punched facade (a window in each bay of the masonry). */
+    glass: boolean;
+    /** Fewest and most storeys this preset's towers have (the lot height is raised or cut to it); omitted: no minimum, and `TowerOptions.maxStoreys` for the top. */
+    minStoreys?: number;
+    maxStoreys?: number;
+    /** Colour of the skin; omitted: the facade colour the block drew for the lot (glass: a blue tint of it). */
+    color?: number;
+};
+/** The two typologies: the office tower (4.0 m storeys: 3.6 clear and 0.4 slab, a plant floor every 20, glass) and the residential tower (3.1 m, every 25, masonry). */
+declare const DEFAULT_TOWER_PRESETS: readonly TowerPreset[];
+/**
+ * A preset from the layout of a typology (`officeTowerLayout(opts)`, `residentialTowerLayout(opts)`), so the city draws the tower the game configured:
+ * the storey pitch and the facade come from the layout, the storey range from its `range` when given.
+ */
+declare const towerPresetOf: (id: string, weight: number, layout: {
+    pitch: number;
+    facade: "curtain" | "punched";
+}, extra?: Partial<Omit<TowerPreset, "id" | "weight" | "storeyHeight" | "glass">>) => TowerPreset;
+/** What a game asks a tower provider to put on the ground: the lot, the height, the preset the random chose and the facade colour. */
+type TowerRequest = {
+    x: number;
+    z: number;
+    width: number;
+    depth: number;
+    height: number;
+    color: number;
+    preset: TowerPreset;
+    lit: number;
+    use?: string;
+    storeys?: number;
+};
+/** Draws a tower in place of the default one (the game's own model, or the plan of the typology rendered by `game-floorplan-three`). */
+type TowerProvider = (request: TowerRequest, b: UrbanBuilder) => void;
+type TowerOptions = {
+    /** A building at least this tall (metres) is drawn as a tower. Default 60. */
+    minHeight?: number;
+    /** Kinds of tower and their weights. Default `DEFAULT_TOWER_PRESETS`. */
+    presets?: readonly TowerPreset[];
+    /** Replaces the default drawing. */
+    provider?: TowerProvider;
+    /** The crown: height of the mast over the roof as a share of the tower (default 0.06, at most 25 m), 0 for none. */
+    mast?: number;
+    /** Most storeys a tower may have (default 60, the structural limit of the kit): a taller lot is drawn at this many storeys of its preset. */
+    maxStoreys?: number;
+    /** Chance that a window is lit when the block did not say (default 0.12). */
+    lit?: number;
+};
+declare const TOWER_DEFAULTS: {
+    readonly minHeight: 60;
+    readonly maxStoreys: 60;
+    readonly mast: 0.06;
+    readonly lit: 0.12;
+};
+/** The preset the random picks by weight; draws once. */
+declare function pickTowerPreset(b: UrbanBuilder, presets: readonly TowerPreset[]): TowerPreset;
+/** Storeys of a tower of this height, the podium (a taller ground storey) included. */
+declare const towerStoreys: (height: number, preset: TowerPreset) => number;
+/**
+ * A tower: a podium with a taller ground storey, the shaft with a row of windows on every storey of its four faces, darker bands where the plant
+ * floors are (no windows), the top plant floor set back, the parapet and the mast. Draws one random per window (lit or not), after the preset's.
+ */
+declare function drawTower(b: UrbanBuilder, request: TowerRequest, options?: Pick<TowerOptions, 'mast'>): BlockBuilding;
+/** The drawer a kit uses for a building of the block or the avenue: a tower from the minimum height up, the plain city building under it. */
+declare function createTowerDrawer(towers: TowerOptions, plain: (b: UrbanBuilder, x: number, z: number, width: number, depth: number, height: number, color: number, o?: BuildingOptions) => BlockBuilding): (b: UrbanBuilder, x: number, z: number, width: number, depth: number, height: number, color: number, o?: BuildingOptions) => BlockBuilding;
+
 /** Facade colours of the city buildings (the Galeria's `FAC`). */
 declare const DEFAULT_FACADES: readonly number[];
 type FillBlockOptions = {
@@ -599,6 +676,21 @@ type FillBlockOptions = {
     shop?: number;
     /** Facade colours. Default `DEFAULT_FACADES`. */
     palette?: readonly number[];
+    /**
+     * Storeys of each building, a number or `[min, max]` (the same name and shape as a city block's `building.floors`). Given, the height is storeys times the
+     * storey height of the use's preset instead of `minHeight..maxHeight`; the random draws are the same.
+     */
+    floors?: number | readonly [number, number];
+    /** Share of the buildings by use (`commercial`, `residential`, ...); each building picks one (one more random draw). Needs no `floors`. */
+    uses?: Readonly<Record<string, number>>;
+    /** Which tower preset gives the storey height of a use. Default `{ commercial: 'office', residential: 'residential' }`. */
+    storeyPresets?: Readonly<Record<string, string>>;
+    /** The presets whose storey heights are used (default `DEFAULT_TOWER_PRESETS`; the kit passes its `towers.presets`). */
+    presets?: readonly TowerPreset[];
+    /** Storey height when no preset applies, metres. Default the residential preset's. */
+    storeyHeight?: number;
+    /** Draws each building (default `drawBuilding`): the kit passes its own to put towers on the tall lots. */
+    draw?: (b: UrbanBuilder, x: number, z: number, width: number, depth: number, height: number, color: number, options: BuildingOptions) => BlockBuilding;
 };
 /** A building a block ended up with, for the game's own bookkeeping (collisions, minimap). */
 type BlockBuilding = {
@@ -612,7 +704,14 @@ type BlockBuilding = {
 type BuildingOptions = {
     lit?: number;
     shop?: number;
-};
+    /** Use of the building (`commercial`, `residential`...), when the block gave `uses`. */
+    use?: string;
+    /** Storeys of the building, when the block gave `floors`; the height is already storeys times the storey height. */
+    storeys?: number;
+    /** Id of the tower preset the use maps to; a tower drawer with that preset uses it instead of picking at random. */
+    preset?: string;
+};
+declare const DEFAULT_STOREY_PRESETS: Readonly<Record<string, string>>;
 /** One city building: block, roof slab, maybe a vent on the roof, maybe a shop front on both long faces, windows on the four faces. Draws from the builder's random. */
 declare function drawBuilding(b: UrbanBuilder, x: number, z: number, width: number, depth: number, height: number, color: number, options?: BuildingOptions): BlockBuilding;
 /**
@@ -827,6 +926,202 @@ type ComposeOptions = {
 };
 type SilhouetteFactory = (request: HouseRequest, random: () => number) => Silhouette;
 
+type DistrictKindText = {
+    name: string;
+    description: string;
+};
+/**
+ * A kind of district: what a patch of the city is. Numbers a game can change; the ids of `zone` and `pattern` point into other catalogues.
+ */
+type DistrictKindDef = {
+    id: string;
+    /** Colour on the map (css hex). */
+    color: string;
+    /** Id of a zone of `game-floorplan-residential` / `game-floorplan-commercial` (`zt`, `zc`, `zr1`, ...); null for ground that is not built. */
+    zone: string | null;
+    /** Id of a neighbourhood pattern of `urban.neighbourhoods` (or `financial_district` of `TOWER_PATTERNS`); null for ground that is not built. */
+    pattern: string | null;
+    /** Storeys of the buildings, `[min, max]`. */
+    floors: readonly [number, number];
+    /** Share of the buildings by use (`commercial`, `residential`, `industrial`, `institutional`, `agricultural`, ...). */
+    uses: Readonly<Record<string, number>>;
+    /** Size of a block in metres; 0 means the kind has no blocks. */
+    block: number;
+    text: Record<Locale, DistrictKindText>;
+};
+type PlanRect = readonly [x0: number, z0: number, x1: number, z1: number];
+type PlanPoint = readonly [x: number, z: number];
+type PlanDistrict = {
+    id: string;
+    /** Id of a `DistrictKindDef`. */
+    kind: string;
+    rect: PlanRect;
+    /** Replaces the name of the kind; a string or one string by locale. */
+    name?: string | Partial<Record<Locale, string>>;
+    /** Replaces the storeys of the kind. */
+    floors?: readonly [number, number];
+    /** Replaces the shares of use of the kind. */
+    uses?: Readonly<Record<string, number>>;
+};
+type PlanLine = {
+    id: string;
+    /** `avenue`, `street`, `highway`, `rail`, `river` or any string a drawer knows. */
+    kind: string;
+    width: number;
+    points: readonly PlanPoint[];
+};
+type PlanLandmark = {
+    kind: string;
+    at: PlanPoint;
+    name?: string | Partial<Record<Locale, string>>;
+};
+type CityScale = 'metropolis' | 'city' | 'town' | 'village' | (string & {});
+/**
+ * A city plan: districts painted on a map of metres (centre 0,0; x east, z south), roads, rails and rivers, and landmarks.
+ * Districts are listed from the outer to the inner one: the LAST district that contains a point wins.
+ */
+type CityPlanDef = {
+    id: string;
+    scale: CityScale;
+    /** Width and depth of the map in metres. */
+    size: readonly [w: number, d: number];
+    text: Record<Locale, {
+        name: string;
+        description: string;
+    }>;
+    /** Id of another plan to start from: its districts, lines and landmarks come first; a district or line of the same id replaces, a new one appends. */
+    extends?: string;
+    districts: readonly PlanDistrict[];
+    lines: readonly PlanLine[];
+    landmarks: readonly PlanLandmark[];
+};
+/** A plan as a game writes it: with `extends`, everything but the id is optional and comes from the parent. */
+type CityPlanInput = {
+    id: string;
+    extends?: string;
+} & Partial<Omit<CityPlanDef, 'id' | 'extends'>>;
+type BlockUse = {
+    floors: readonly [number, number];
+    uses: Readonly<Record<string, number>>;
+    zone: string | null;
+    pattern: string | null;
+};
+type ResolvedDistrict = {
+    id: string;
+    kind: string;
+    rect: PlanRect;
+    name: string;
+    description: string;
+    color: string;
+    zone: string | null;
+    pattern: string | null;
+    /** Storeys after the district's override, clamped to `[0, maxFloors]`. */
+    floors: readonly [number, number];
+    uses: Readonly<Record<string, number>>;
+    block: number;
+};
+/** A block of a district: its centre, its dimensions less the street, and the config a building generator takes. */
+type Block = {
+    x: number;
+    z: number;
+    size: readonly [w: number, d: number];
+    district: string;
+    building: BlockUse;
+};
+type CityLayout = {
+    id: string;
+    scale: string;
+    size: readonly [number, number];
+    name: string;
+    description: string;
+    districts: ResolvedDistrict[];
+    lines: PlanLine[];
+    landmarks: (Omit<PlanLandmark, 'name'> & {
+        name?: string;
+    })[];
+    /** The district at a point; the last one in the list that contains it. */
+    districtAt(x: number, z: number): ResolvedDistrict | undefined;
+    /** The grid of blocks of a district (by the kind's block size), less the cells another district was painted over. */
+    blocks(districtId: string, options?: {
+        street?: number;
+    }): Block[];
+};
+type LayoutOptions = {
+    maxFloors?: number;
+    locale?: Locale;
+};
+type KindStats = {
+    kind: string;
+    area: number;
+    share: number;
+    districts: number;
+};
+type FillBlockCityOptions = Omit<FillBlockOptions, 'shop'> & {
+    /** Chance of a ground-floor shop; default the commercial share of the block. */
+    shop?: number;
+    /** Which tower preset gives the storey height of a use: default `{ commercial: 'office', residential: 'residential' }`. */
+    storeyPresets?: Readonly<Record<string, string>>;
+    /** Storey height when no preset applies, metres. Default the residential preset's. */
+    storeyHeight?: number;
+};
+
+/** Highest storey count a district may have unless the game raises it. */
+declare const DEFAULT_MAX_FLOORS = 60;
+declare const DEFAULT_STREET = 10;
+type CitiesOptions = {
+    /** Most storeys any district may have, applied on top of the kinds and the districts' own numbers. Default 60. */
+    maxFloors?: number;
+    packs?: {
+        kinds?: readonly DistrictKindDef[];
+        plans?: readonly CityPlanInput[];
+    };
+    patch?: {
+        kinds?: Record<string, DeepPartial<DistrictKindDef>>;
+        plans?: Record<string, DeepPartial<CityPlanInput>>;
+    };
+    remove?: {
+        kinds?: readonly string[];
+        plans?: readonly string[];
+    };
+    /** Tower presets of the kit (storey heights by use). */
+    presets: readonly TowerPreset[];
+    fill(b: UrbanBuilder, g: {
+        cx: number;
+        cz: number;
+        size: number;
+        minHeight: number;
+        maxHeight: number;
+    } & FillBlockOptions): BlockBuilding[];
+};
+/** City plans as data: district kinds and plans are registries; a plan resolves to a layout with the district at a point and the grid of blocks of a district. */
+declare function createCities(o: CitiesOptions): {
+    maxFloors: number;
+    kinds: {
+        ids: () => string[];
+        list: () => DistrictKindDef[];
+        has: (id: string) => boolean;
+        get(id: string): DistrictKindDef;
+    };
+    plans: {
+        /** The plan with everything inherited from the plans it extends. */
+        resolve: (id: string) => CityPlanDef;
+        ids: () => string[];
+        list: () => CityPlanInput[];
+        has: (id: string) => boolean;
+        get(id: string): CityPlanInput;
+    };
+    layout: (planOrId: string | CityPlanInput, options?: LayoutOptions) => CityLayout;
+    stats: (l: CityLayout) => KindStats[];
+    fillBlock: (b: UrbanBuilder, block: Block, options?: FillBlockCityOptions) => BlockBuilding[];
+};
+type Cities = ReturnType<typeof createCities>;
+
+/** The district kinds of the city plans: colour on the map, zone of the floorplan packages, neighbourhood pattern, storeys, share of buildings by use and block size. */
+declare const DEFAULT_DISTRICT_KINDS: readonly DistrictKindDef[];
+
+/** The six city plans (metropolis, regional city, port city, rail town, country town, mountain village). Districts are listed from the outer to the inner one. */
+declare const DEFAULT_CITY_PLANS: readonly CityPlanDef[];
+
 type Origin = {
     x: number;
     z: number;
@@ -893,21 +1188,31 @@ type UrbanOptions = {
     packs?: {
         poles?: readonly PoleDef[];
         neighbourhoods?: readonly NeighbourhoodPattern<any>[];
+        districtKinds?: readonly DistrictKindDef[];
+        cityPlans?: readonly CityPlanInput[];
     };
     /** Numbers changed on shipped entries, by id (objects merge, arrays replace). */
     patch?: {
         poles?: Record<string, DeepPartial<PoleDef>>;
         neighbourhoods?: Record<string, DeepPartial<NeighbourhoodPattern<any>>>;
+        districtKinds?: Record<string, DeepPartial<DistrictKindDef>>;
+        cityPlans?: Record<string, DeepPartial<CityPlanInput>>;
     };
     /** Ids taken out of the catalogues. */
     remove?: {
         poles?: readonly string[];
         neighbourhoods?: readonly string[];
+        districtKinds?: readonly string[];
+        cityPlans?: readonly string[];
     };
     /** Shape builders for the poles a pack adds; the five of the Galeria are always there. */
     shapes?: Readonly<Record<string, PoleShapeBuilder>>;
     /** Composers for the patterns a pack adds; the ten of the Galeria are always there. */
     composers?: Readonly<Record<string, Composer>>;
+    /** City plans (zoning): district kinds and plans are catalogues (`packs`, `patch` and `remove` above, under `districtKinds` and `cityPlans`). */
+    cities?: {
+        maxFloors?: number;
+    };
     lights?: {
         budget?: number;
     };
@@ -915,6 +1220,11 @@ type UrbanOptions = {
     /** Facade colours of the city buildings. */
     facades?: readonly number[];
     props?: Partial<PropColors>;
+    /**
+     * Towers on the tall lots, off by default. `true` or an object turns them on: a building of the block or of an avenue at least `minHeight` (60 m) tall is drawn as
+     * a tower of one of the `presets` (the office and residential typologies), not as a box; a `provider` replaces the drawing. See `TowerOptions`.
+     */
+    towers?: boolean | TowerOptions;
 };
 type Pole = {
     readonly def: PoleDef;
@@ -935,6 +1245,25 @@ declare function createUrban(options?: UrbanOptions): {
         list: () => PoleDef[];
         get(id: string): Pole;
     };
+    cities: {
+        maxFloors: number;
+        kinds: {
+            ids: () => string[];
+            list: () => DistrictKindDef[];
+            has: (id: string) => boolean;
+            get(id: string): DistrictKindDef;
+        };
+        plans: {
+            resolve: (id: string) => CityPlanDef;
+            ids: () => string[];
+            list: () => CityPlanInput[];
+            has: (id: string) => boolean;
+            get(id: string): CityPlanInput;
+        };
+        layout: (planOrId: string | CityPlanInput, options?: LayoutOptions) => CityLayout;
+        stats: (l: CityLayout) => KindStats[];
+        fillBlock: (b: UrbanBuilder, block: Block, options?: FillBlockCityOptions) => BlockBuilding[];
+    };
     builder: (o?: BuilderOptions) => UrbanBuilder;
     neighbourhoods: {
         ids: () => string[];
@@ -964,6 +1293,10 @@ declare function createUrban(options?: UrbanOptions): {
     };
     terrain: (o: TerrainOptions) => Terrain;
     drawTerrain: typeof drawTerrain;
+    towers: {
+        enabled: boolean;
+        options: TowerOptions | null;
+    };
     streets: {
         road(b: UrbanBuilder, x: number, z: number, w: number, l: number, along: "x" | "z"): void;
         walk(b: UrbanBuilder, x: number, z: number, w: number, d: number): void;
@@ -1425,4 +1758,12 @@ declare const SAMPLE_CELLS: Readonly<Record<string, {
     z: number;
 }>>;
 
-export { type BarSpec, type BlockBuilding, type BuilderOptions, type BuildingOptions, COMPOSERS, type ColorRule, type ComposeContext, type ComposeOptions, type Composer, type ConePart, type CrossarmSpec, type CrownPart, DEFAULT_FACADES, DEFAULT_LIGHT_BUDGET, DEFAULT_PATTERNS, DEFAULT_PLANT_CONTEXTS, DEFAULT_POLES, DEFAULT_PROP_COLORS, DEFAULT_ROAD_STYLE, DEFAULT_URBAN_SEED, DEFAULT_WALK_STYLE, type DoubleArmSpec, type DowntownParams, type FillBlockOptions, type Flatten, type FloodTowerSpec, type ForestOptions, type HistoricParams, type HouseProvider, type HouseRequest, type IndustrialParams, type ItemBox, type LabelPart, type Lake, type LampLightSpec, type LampSpec, type LanternSpec, type LensSpec, type LightBudget, type LightPart, type Locale, type MastSpec, type MilitaryParams, type MountainParams, type NeighbourhoodPattern, type Origin, PARKED_VEHICLE_IDS, POLE_SHAPES, type PartStyle, type PatternText, type PlacementPart, type PlanePart, type PlantProvider, type PlantProviderOptions, type PlantRequest, type Point, type Pole, type PoleDef, type PoleOptions, type PoleShapeBuilder, type PropColors, type Providers, type RailwayParams, type Ramp, type Rect, type River, type RiverBed, type RoadStyle, type RuralParams, SAMPLE_CELLS, SILHOUETTE_TYPOLOGIES, type SampleSheetOptions, type SilhouetteFactory, type SingleArmSpec, type StiltParams, type StreetOptions, type SuburbParams, type Terrain, type TerrainGrid, type TerrainLayer, type TerrainOptions, type TerrainPart, type Trig, type UrbanBuilder, type UrbanBuilderOptions, type UrbanKit, type UrbanKitCore, type UrbanOptions, type UrbanPart, type UrbanPlan, type UrbanScene, type VaultPart, type VehicleProvider, type VehicleProviderOptions, type VehicleRequest, type WalkStyle, type Wave, type WorkingClassParams, type WorldFrame, clamp, composePattern, createLightBudget, createPlantProvider, createSilhouetteHouses, createTerrain, createUrban, createUrbanBuilder, createVehicleProvider, distanceToPolyline, drawBuilding, drawContainer, drawFence, drawGround, drawPine, drawRoad, drawSandbags, drawStreetGrid, drawStripLabel, drawTent, drawTerrain, drawTree, drawWalk, drawWatchtower, drawWires, fillBlock, hash2, insideEllipse, insideRect, lerp, patternMarker, smoothstep };
+/** The patterns of the tower pack. */
+declare const TOWER_PATTERNS: readonly NeighbourhoodPattern<any>[];
+/** Where the sample sheet puts them (pass it as `cells`). */
+declare const TOWER_SAMPLE_CELLS: Readonly<Record<string, {
+    x: number;
+    z: number;
+}>>;
+
+export { type BarSpec, type Block, type BlockBuilding, type BlockUse, type BuilderOptions, type BuildingOptions, COMPOSERS, type Cities, type CitiesOptions, type CityLayout, type CityPlanDef, type CityPlanInput, type CityScale, type ColorRule, type ComposeContext, type ComposeOptions, type Composer, type ConePart, type CrossarmSpec, type CrownPart, DEFAULT_CITY_PLANS, DEFAULT_DISTRICT_KINDS, DEFAULT_FACADES, DEFAULT_LIGHT_BUDGET, DEFAULT_MAX_FLOORS, DEFAULT_PATTERNS, DEFAULT_PLANT_CONTEXTS, DEFAULT_POLES, DEFAULT_PROP_COLORS, DEFAULT_ROAD_STYLE, DEFAULT_STOREY_PRESETS, DEFAULT_STREET, DEFAULT_TOWER_PRESETS, DEFAULT_URBAN_SEED, DEFAULT_WALK_STYLE, type DistrictKindDef, type DistrictKindText, type DoubleArmSpec, type DowntownParams, type FillBlockCityOptions, type FillBlockOptions, type Flatten, type FloodTowerSpec, type ForestOptions, type HistoricParams, type HouseProvider, type HouseRequest, type IndustrialParams, type ItemBox, type KindStats, type LabelPart, type Lake, type LampLightSpec, type LampSpec, type LanternSpec, type LayoutOptions, type LensSpec, type LightBudget, type LightPart, type Locale, type MastSpec, type MilitaryParams, type MountainParams, type NeighbourhoodPattern, type Origin, PARKED_VEHICLE_IDS, POLE_SHAPES, type PartStyle, type PatternText, type PlacementPart, type PlanDistrict, type PlanLandmark, type PlanLine, type PlanPoint, type PlanRect, type PlanePart, type PlantProvider, type PlantProviderOptions, type PlantRequest, type Point, type Pole, type PoleDef, type PoleOptions, type PoleShapeBuilder, type PropColors, type Providers, type RailwayParams, type Ramp, type Rect, type ResolvedDistrict, type River, type RiverBed, type RoadStyle, type RuralParams, SAMPLE_CELLS, SILHOUETTE_TYPOLOGIES, type SampleSheetOptions, type SilhouetteFactory, type SingleArmSpec, type StiltParams, type StreetOptions, type SuburbParams, TOWER_DEFAULTS, TOWER_PATTERNS, TOWER_SAMPLE_CELLS, type Terrain, type TerrainGrid, type TerrainLayer, type TerrainOptions, type TerrainPart, type TowerOptions, type TowerPreset, type TowerProvider, type TowerRequest, type Trig, type UrbanBuilder, type UrbanBuilderOptions, type UrbanKit, type UrbanKitCore, type UrbanOptions, type UrbanPart, type UrbanPlan, type UrbanScene, type VaultPart, type VehicleProvider, type VehicleProviderOptions, type VehicleRequest, type WalkStyle, type Wave, type WorkingClassParams, type WorldFrame, clamp, composePattern, createCities, createLightBudget, createPlantProvider, createSilhouetteHouses, createTerrain, createTowerDrawer, createUrban, createUrbanBuilder, createVehicleProvider, distanceToPolyline, drawBuilding, drawContainer, drawFence, drawGround, drawPine, drawRoad, drawSandbags, drawStreetGrid, drawStripLabel, drawTent, drawTerrain, drawTower, drawTree, drawWalk, drawWatchtower, drawWires, fillBlock, hash2, insideEllipse, insideRect, lerp, patternMarker, pickTowerPreset, smoothstep, towerPresetOf, towerStoreys };