From 1a85014bb336c61cb0b634523e69d2c8c4b54b86 Mon Sep 17 00:00:00 2001 From: "nori-sessions[bot]" <264258699+nori-sessions[bot]@users.noreply.github.com> Date: Sun, 1 Nov 2026 08:06:43 +0000 Subject: [PATCH 01/18] Scenario land parcels, terrain shapes, tree stands; remix hard parks and add Mossgrove Isle Co-authored-by: Nori --- src/save/scenario-remix-saves.test.ts | 64 ++++ src/sim/scenario/hard-scenarios.test.ts | 239 +++++++++++++++ src/sim/scenario/scenario-file.ts | 148 +++++++++- src/sim/scenario/scenario-layout.ts | 19 +- src/sim/scenario/scenario-map.ts | 207 +++++++++---- src/sim/scenario/scenario-shapes.test.ts | 274 ++++++++++++++++++ src/sim/scenario/scenario-shapes.ts | 57 ++++ src/sim/scenario/scenario.ts | 47 ++- src/sim/scenario/scenarios/copper-ridge.json | 140 ++++++--- src/sim/scenario/scenarios/glacier-point.json | 224 ++++++++------ .../scenario/scenarios/mossgrove-isle.json | 254 ++++++++++++++++ .../scenario/scenarios/thunderhead-mesa.json | 176 +++++++++-- .../scenario/scenarios/tidewater-docks.json | 116 ++++++-- 13 files changed, 1721 insertions(+), 244 deletions(-) create mode 100644 src/save/scenario-remix-saves.test.ts create mode 100644 src/sim/scenario/hard-scenarios.test.ts create mode 100644 src/sim/scenario/scenario-shapes.test.ts create mode 100644 src/sim/scenario/scenario-shapes.ts create mode 100644 src/sim/scenario/scenarios/mossgrove-isle.json diff --git a/src/save/scenario-remix-saves.test.ts b/src/save/scenario-remix-saves.test.ts new file mode 100644 index 000000000..8b674609a --- /dev/null +++ b/src/save/scenario-remix-saves.test.ts @@ -0,0 +1,64 @@ +import { describe, expect, it } from 'vitest'; +import { World } from '../sim/core/world'; +import { OWNED } from '../sim/map/tile-map'; +import { SCENARIOS } from '../sim/scenario/catalog'; +import { parseScenarioFile } from '../sim/scenario/scenario-file'; +import { prepareScenarioPark } from '../sim/scenario/scenario-layout'; +import { deserialize, serialize } from './save'; + +/** Copper Ridge's map recipe before the hard-park remix: an inset owned rectangle. */ +const LEGACY_COPPER_RIDGE = parseScenarioFile({ + id: 'copper-ridge', + name: 'Copper Ridge', + category: 'challenging', + seed: 2101, + map: { width: 96, height: 96 }, + finance: { + startingCash: 3_000_000, + startingLoan: 2_500_000, + maxLoan: 9_000_000, + annualInterestBps: 900, + }, + pricing: { mode: 'perRide' }, + objective: { kind: 'completeCoasters', target: 5, minimumExcitement: 460, byYear: 1 }, + entrance: { side: 'south', length: 4 }, + land: { ownedMarginPercent: 22, saleMarginPercent: 3 }, + terrain: { + seaLevel: 3, + baseLevel: 8, + relief: 5, + cell: 10, + surface: 'grass', + buildLevel: 9, + buildLength: 48, + buildWidth: 35, + lakes: [{ x: 15, y: 20, rx: 9, ry: 7, depth: 2 }], + hills: [ + { x: 80, y: 25, radius: 12, height: 5 }, + { x: 20, y: 70, radius: 10, height: 4 }, + ], + highland: { surface: 'dirt', level: 10 }, + }, + trees: { count: 150, groves: 8 }, +}); + +function newGame(def: typeof LEGACY_COPPER_RIDGE): World { + const w = new World({ seed: def.seed, width: def.mapWidth, height: def.mapHeight }); + prepareScenarioPark(w, def); + return w; +} + +describe('saves from before the hard-park remix', () => { + it('load with their own land, terrain and scenery rather than the remixed map', () => { + const legacy = newGame(LEGACY_COPPER_RIDGE); + const loaded = deserialize(serialize(legacy)); + expect(Array.from(loaded.map.ownership)).toEqual(Array.from(legacy.map.ownership)); + expect(Array.from(loaded.map.vertexHeights)).toEqual(Array.from(legacy.map.vertexHeights)); + expect(Array.from(loaded.map.waterLevel)).toEqual(Array.from(legacy.map.waterLevel)); + expect(Array.from(loaded.map.elData)).toEqual(Array.from(legacy.map.elData)); + + const remix = newGame(SCENARIOS.find((s) => s.id === 'copper-ridge')!); + const ownedCount = (w: World) => w.map.ownership.reduce((n, o) => n + (o & OWNED ? 1 : 0), 0); + expect(ownedCount(loaded)).not.toBe(ownedCount(remix)); + }); +}); diff --git a/src/sim/scenario/hard-scenarios.test.ts b/src/sim/scenario/hard-scenarios.test.ts new file mode 100644 index 000000000..1cf87aacb --- /dev/null +++ b/src/sim/scenario/hard-scenarios.test.ts @@ -0,0 +1,239 @@ +import { describe, expect, it } from 'vitest'; +import { World } from '../core/world'; +import { applyMapCommand } from '../map/map-commands'; +import { ElementType, OWNED, RIGHTS_OWNED, SALE_LAND, SALE_RIGHTS } from '../map/tile-map'; +import type { TileMap } from '../map/tile-map'; +import { deserialize, serialize } from '../../save/save'; +import { SCENARIOS } from './catalog'; +import { prepareScenarioPark } from './scenario-layout'; +import type { ScenarioDef } from './scenario'; + +const HARD = [ + 'copper-ridge', + 'tidewater-docks', + 'thunderhead-mesa', + 'glacier-point', + 'mossgrove-isle', +] as const; + +const cache = new Map(); + +function def(id: string): ScenarioDef { + const found = SCENARIOS.find((s) => s.id === id); + if (!found) throw new Error(`no scenario ${id}`); + return found; +} + +function park(id: string): World { + let w = cache.get(id); + if (!w) { + const d = def(id); + w = new World({ seed: d.seed, width: d.mapWidth, height: d.mapHeight }); + prepareScenarioPark(w, d); + cache.set(id, w); + } + return w; +} + +function ownedTiles(m: TileMap): number[] { + const out: number[] = []; + for (let i = 0; i < m.width * m.height; i++) if (m.ownership[i]! & OWNED) out.push(i); + return out; +} + +function bounds(m: TileMap, tiles: readonly number[]) { + let x0 = Infinity; + let y0 = Infinity; + let x1 = -1; + let y1 = -1; + for (const i of tiles) { + const x = i % m.width; + const y = Math.floor(i / m.width); + x0 = Math.min(x0, x); + y0 = Math.min(y0, y); + x1 = Math.max(x1, x); + y1 = Math.max(y1, y); + } + return { x0, y0, x1, y1, area: (x1 - x0 + 1) * (y1 - y0 + 1) }; +} + +/** Tiles reachable from `start` through 4-neighbours that satisfy `keep`. */ +function region(m: TileMap, start: number, keep: (i: number) => boolean): Set { + const seen = new Set([start]); + const queue = [start]; + while (queue.length > 0) { + const i = queue.pop()!; + const x = i % m.width; + const y = Math.floor(i / m.width); + for (const [nx, ny] of [ + [x + 1, y], + [x - 1, y], + [x, y + 1], + [x, y - 1], + ] as const) { + if (!m.inBounds(nx, ny)) continue; + const n = m.index(nx, ny); + if (!seen.has(n) && keep(n)) { + seen.add(n); + queue.push(n); + } + } + } + return seen; +} + +const hasScenery = (m: TileMap, i: number): boolean => { + for (let e = m.firstElement(i); e >= 0; e = m.nextElement(e)) + if (m.elType[e] === ElementType.SmallScenery) return true; + return false; +}; +const dry = (m: TileMap, i: number): boolean => m.waterLevel[i]! <= m.heights[i]!; +const owned = (m: TileMap, i: number): boolean => (m.ownership[i]! & OWNED) !== 0; + +/** Flat, dry, empty pockets on owned or purchasable land, of at least `min` tiles, as [size, height] pairs. */ +function flatPockets(m: TileMap, min: number): Array<[number, number]> { + const ownable = (i: number) => (m.ownership[i]! & (OWNED | SALE_LAND)) !== 0; + const seen = new Set(); + const out: Array<[number, number]> = []; + const usable = (i: number) => + ownable(i) && dry(m, i) && m.slope[i] === 0 && m.firstElement(i) < 0; + for (let i = 0; i < m.width * m.height; i++) { + if (seen.has(i) || !usable(i)) continue; + const h = m.heights[i]!; + const r = region(m, i, (n) => usable(n) && m.heights[n] === h); + for (const n of r) seen.add(n); + if (r.size >= min) out.push([r.size, h]); + } + return out; +} + +describe.each(HARD)('%s', (id) => { + it('owns one connected, clearly non-rectangular piece of land', () => { + const m = park(id).map; + const tiles = ownedTiles(m); + const b = bounds(m, tiles); + expect(tiles.length / b.area).toBeLessThan(0.8); + expect(region(m, tiles[0]!, (i) => owned(m, i)).size).toBe(tiles.length); + }); + + it('keeps unsellable parcels inside its outline after every sale is bought', () => { + const w = deserialize(serialize(park(id))); + const m = w.map; + w.economy.cash = Number.MAX_SAFE_INTEGER; + const ownedBefore = ownedTiles(m).length; + const before = bounds(m, ownedTiles(m)); + applyMapCommand(w, { + type: 'buyLand', + x: 0, + y: 0, + width: m.width, + height: m.height, + rights: false, + }); + applyMapCommand(w, { + type: 'buyLand', + x: 0, + y: 0, + width: m.width, + height: m.height, + rights: true, + }); + let locked = 0; + for (let y = before.y0; y <= before.y1; y++) + for (let x = before.x0; x <= before.x1; x++) + if ((m.ownership[m.index(x, y)]! & (OWNED | RIGHTS_OWNED)) === 0) locked++; + expect(ownedTiles(m).length).toBeGreaterThan(ownedBefore); + expect(locked).toBeGreaterThan(before.area * 0.1); + }); + + it('starts from a small flat clearing at the gate', () => { + const w = park(id); + const m = w.map; + const gate = m.index(w.park.entranceX, w.park.entranceY); + const level = m.heights[gate]!; + const clearing = region( + m, + gate, + (i) => + owned(m, i) && dry(m, i) && m.slope[i] === 0 && m.heights[i] === level && !hasScenery(m, i), + ); + expect(clearing.size).toBeGreaterThanOrEqual(60); + expect(clearing.size).toBeLessThanOrEqual(420); + }); + + it('varies in height across the land the player owns', () => { + const m = park(id).map; + const heights = ownedTiles(m) + .filter((i) => dry(m, i)) + .map((i) => m.heights[i]!); + expect(Math.max(...heights) - Math.min(...heights)).toBeGreaterThanOrEqual(5); + }); + + it('describes its terrain and challenge for the scenario list', () => { + const d = def(id); + expect(d.landscape?.length ?? 0).toBeGreaterThan(10); + expect(d.challenge?.length ?? 0).toBeGreaterThan(20); + }); +}); + +describe('hard park identities', () => { + it('Copper Ridge has several narrow flat benches at different heights', () => { + const pockets = flatPockets(park('copper-ridge').map, 24); + expect(pockets.length).toBeGreaterThanOrEqual(4); + expect(new Set(pockets.map(([, h]) => h)).size).toBeGreaterThanOrEqual(3); + }); + + it('Tidewater Docks wraps water and sells only construction rights over its inlets', () => { + const m = park('tidewater-docks').map; + const b = bounds(m, ownedTiles(m)); + let water = 0; + let rightsOverWater = 0; + for (let y = b.y0; y <= b.y1; y++) + for (let x = b.x0; x <= b.x1; x++) { + const i = m.index(x, y); + if (dry(m, i)) continue; + water++; + if (m.ownership[i]! & SALE_RIGHTS) rightsOverWater++; + expect(m.ownership[i]! & SALE_LAND).toBe(0); + } + expect(water).toBeGreaterThan(b.area * 0.2); + expect(rightsOverWater).toBeGreaterThan(40); + }); + + it('Thunderhead Mesa splits its land into shelves well apart in height', () => { + const pockets = flatPockets(park('thunderhead-mesa').map, 30); + const levels = pockets.map(([, h]) => h); + expect(pockets.length).toBeGreaterThanOrEqual(3); + expect(Math.max(...levels) - Math.min(...levels)).toBeGreaterThanOrEqual(6); + }); + + it('Glacier Point climbs from a lake shore into mountains', () => { + const m = park('glacier-point').map; + const tiles = ownedTiles(m); + const heights = tiles.filter((i) => dry(m, i)).map((i) => m.heights[i]!); + expect(Math.max(...heights) - Math.min(...heights)).toBeGreaterThanOrEqual(9); + expect(tiles.some((i) => !dry(m, i))).toBe(true); + }); + + it('Mossgrove Isle is a wooded island with open clearings', () => { + const w = park('mossgrove-isle'); + const m = w.map; + const tiles = ownedTiles(m).filter((i) => dry(m, i)); + const wooded = tiles.filter((i) => hasScenery(m, i)).length; + expect(wooded / tiles.length).toBeGreaterThan(0.4); + const gate = m.index(w.park.entranceX, w.park.entranceY); + const open = region(m, gate, (i) => owned(m, i) && dry(m, i) && !hasScenery(m, i)); + expect(open.size).toBeGreaterThan(250); + const b = bounds(m, ownedTiles(m)); + const midX = (b.x0 + b.x1) >> 1; + const midY = (b.y0 + b.y1) >> 1; + const ring = [ + [b.x0 - 2, midY], + [b.x1 + 2, midY], + [midX, b.y0 - 2], + [midX, b.y1 + 2], + ].filter(([x, y]) => m.inBounds(x!, y!)); + expect(ring.length).toBe(4); + expect(ring.filter(([x, y]) => !dry(m, m.index(x!, y!))).length).toBeGreaterThanOrEqual(3); + }); +}); diff --git a/src/sim/scenario/scenario-file.ts b/src/sim/scenario/scenario-file.ts index 4c1c6ff0c..59d8f459a 100644 --- a/src/sim/scenario/scenario-file.ts +++ b/src/sim/scenario/scenario-file.ts @@ -8,12 +8,14 @@ import { SANDBOX_ID, TREE_SPECIES, } from './scenario'; -import { MAX_HEIGHT } from '../map/tile-map'; -import { buildApron, DEFAULT_LAND, ownedBounds } from './scenario-map'; +import { MAX_HEIGHT, OWNED } from '../map/tile-map'; +import { buildApron, DEFAULT_LAND, landOwnership } from './scenario-map'; import { PREBUILT_TYPES } from './scenario-prebuilt'; import { parseRestrictions } from './restrictions'; import type { EntranceSide, + LandParcel, + ParcelKind, PrebuiltRide, ScenarioCategory, ScenarioDef, @@ -22,10 +24,13 @@ import type { ScenarioHill, ScenarioLake, ScenarioLand, + ScenarioShape, ScenarioTerrain, ScenarioTrees, + TerrainShape, TerrainSurface, TreeSpecies, + TreeStand, } from './scenario'; type Json = Record; @@ -105,7 +110,22 @@ const TREE_SPECIES_BY_NAME = Object.fromEntries(TREE_SPECIES.map((s) => [s, s])) TreeSpecies >; +const PARCEL_KINDS: Record = { + owned: 'owned', + land: 'land', + rights: 'rights', + none: 'none', +}; + +const SHAPE_MODES: Record = { + raise: 'raise', + lower: 'lower', +}; + const MAX_TREES = 2000; +const MAX_SHAPES = 64; +const MAX_BAND_HALF_WIDTH = 32; +const MAX_SHAPE_RUN = 8; const MAX_PREBUILT = 40; const MAX_PREBUILT_ROW = 60; const MIN_MAP_SIZE = 8; @@ -140,6 +160,10 @@ export function parseScenarioFile(raw: unknown): ScenarioDef { const name = check(() => text(root.name, 'name')); const description = root.description === undefined ? undefined : check(() => text(root.description, 'description')); + const landscape = + root.landscape === undefined ? undefined : check(() => text(root.landscape, 'landscape')); + const challenge = + root.challenge === undefined ? undefined : check(() => text(root.challenge, 'challenge')); const map = check(() => object(root.map, 'map')); const finance = check(() => object(root.finance, 'finance')); @@ -152,6 +176,8 @@ export function parseScenarioFile(raw: unknown): ScenarioDef { name, category: check(() => oneOf(root.category ?? 'beginner', 'category', SCENARIO_CATEGORIES)), ...(description === undefined ? {} : { description }), + ...(landscape === undefined ? {} : { landscape }), + ...(challenge === undefined ? {} : { challenge }), ...(root.climate === undefined ? {} : { climate: check(() => oneOf(root.climate, 'climate', CLIMATES)) }), @@ -200,9 +226,9 @@ export function parseScenarioFile(raw: unknown): ScenarioDef { }; if (def.startingLoan > def.maxLoan) fail('finance.startingLoan must not exceed finance.maxLoan'); if (root.entrance !== undefined) def.entrance = check(() => entrance(root.entrance)); - if (root.land !== undefined) def.land = check(() => land(root.land)); + if (root.land !== undefined) def.land = check(() => land(root.land, def)); if (root.terrain !== undefined) def.terrain = check(() => terrain(root.terrain, def)); - if (root.trees !== undefined) def.trees = check(() => trees(root.trees)); + if (root.trees !== undefined) def.trees = check(() => trees(root.trees, def)); if (root.prebuilt !== undefined) def.prebuilt = check(() => prebuilt(root.prebuilt, def)); if (root.restrictions !== undefined) { def.restrictions = check(() => parseRestrictions(root.restrictions)); @@ -291,9 +317,9 @@ function entrance(v: unknown): ScenarioEntrance { }; } -function land(v: unknown): ScenarioLand { +function land(v: unknown, def: ScenarioDef): ScenarioLand { const l = object(v, 'land'); - return { + const out: ScenarioLand = { ownedMarginPercent: integer( l.ownedMarginPercent ?? DEFAULT_LAND.ownedMarginPercent, 'land.ownedMarginPercent', @@ -307,6 +333,70 @@ function land(v: unknown): ScenarioLand { 20, ), }; + if (l.parcels === undefined) return out; + out.parcels = list(l.parcels, 'land.parcels').map((p, i): LandParcel => { + const path = `land.parcels[${i}]`; + const parcel = object(p, path); + return { + kind: oneOf(parcel.kind, `${path}.kind`, PARCEL_KINDS), + ...shape(parcel, path, def), + }; + }); + const flags = landOwnership(def.mapWidth, def.mapHeight, out); + if (!connectedOwnership(flags, def.mapWidth)) + throw new Error('owned land must be one connected piece'); + return out; +} + +/** True when the owned tiles exist and join through edge-sharing neighbours. */ +function connectedOwnership(flags: Uint8Array, width: number): boolean { + const start = flags.findIndex((f) => (f & OWNED) !== 0); + if (start < 0) return false; + const seen = new Uint8Array(flags.length); + const queue = [start]; + seen[start] = 1; + let reached = 0; + while (queue.length > 0) { + const i = queue.pop()!; + reached++; + const x = i % width; + for (const n of [x > 0 ? i - 1 : -1, x < width - 1 ? i + 1 : -1, i - width, i + width]) { + if (n < 0 || n >= flags.length || seen[n] || !(flags[n] & OWNED)) continue; + seen[n] = 1; + queue.push(n); + } + } + return reached === flags.reduce((count, f) => count + (f & OWNED ? 1 : 0), 0); +} + +/** Reads the one shape key of `o` (rect, ellipse or band), in tiles inside the map. */ +function shape(o: Json, path: string, def: ScenarioDef): ScenarioShape { + const keys = ['rect', 'ellipse', 'band'].filter((k) => o[k] !== undefined); + if (keys.length !== 1) throw new Error(`${path} must set exactly one of rect, ellipse or band`); + const key = keys[0]; + const values = array(o[key], `${path}.${key}`); + const at = (k: number, max: number, min = 0): number => + integer(values[k], `${path}.${key}[${k}]`, min, max); + const w = def.mapWidth - 1; + const h = def.mapHeight - 1; + if (key === 'rect') { + if (values.length !== 4) throw new Error(`${path}.rect must list x0, y0, x1, y1`); + const x0 = at(0, w); + const y0 = at(1, h); + return { rect: [x0, y0, at(2, w, x0), at(3, h, y0)] }; + } + if (key === 'ellipse') { + if (values.length !== 4) throw new Error(`${path}.ellipse must list cx, cy, rx, ry`); + return { ellipse: [at(0, w), at(1, h), at(2, MAX_MAP_SIZE, 1), at(3, MAX_MAP_SIZE, 1)] }; + } + if (values.length !== 5) throw new Error(`${path}.band must list x0, y0, x1, y1, halfWidth`); + return { band: [at(0, w), at(1, h), at(2, w), at(3, h), at(4, MAX_BAND_HALF_WIDTH)] }; +} + +function list(v: unknown, path: string): unknown[] { + const items = array(v, path); + if (items.length > MAX_SHAPES) throw new Error(`${path} may list at most ${MAX_SHAPES} shapes`); + return items; } function terrain(v: unknown, def: ScenarioDef): ScenarioTerrain { @@ -324,14 +414,36 @@ function terrain(v: unknown, def: ScenarioDef): ScenarioTerrain { lakes: array(t.lakes ?? [], 'terrain.lakes').map((l, i) => lake(l, `terrain.lakes[${i}]`)), hills: array(t.hills ?? [], 'terrain.hills').map((h, i) => hill(h, `terrain.hills[${i}]`)), }; + if (t.apronOffset !== undefined) + out.apronOffset = integer(t.apronOffset, 'terrain.apronOffset', -MAX_MAP_SIZE, MAX_MAP_SIZE); + if (t.shapes !== undefined) + out.shapes = list(t.shapes, 'terrain.shapes').map((v, i): TerrainShape => { + const path = `terrain.shapes[${i}]`; + const o = object(v, path); + return { + mode: oneOf(o.mode, `${path}.mode`, SHAPE_MODES), + level: integer(o.level, `${path}.level`, 0, MAX_HEIGHT), + run: o.run === undefined ? 1 : integer(o.run, `${path}.run`, 1, MAX_SHAPE_RUN), + ...shape(o, path, def), + }; + }); if (t.highland !== undefined) out.highland = highland(t.highland); if (def.entrance === undefined) throw new Error('terrain needs an entrance to orient the build apron'); - const owned = ownedBounds(def.mapWidth, def.mapHeight, def.land); + const flags = landOwnership(def.mapWidth, def.mapHeight, def.land); const apron = buildApron(def.mapWidth, def.mapHeight, def.entrance.side, out, def.land); - if (apron.x0 < owned.x0 || apron.x1 > owned.x1 || apron.y0 < owned.y0 || apron.y1 > owned.y1) { - throw new Error('terrain build apron must fit inside the owned land'); - } + const owned = (x: number, y: number): boolean => + x >= 0 && + y >= 0 && + x < def.mapWidth && + y < def.mapHeight && + (flags[y * def.mapWidth + x] & OWNED) !== 0; + for (let y = apron.y0; y <= apron.y1; y++) + for (let x = apron.x0; x <= apron.x1; x++) + if (!owned(x, y)) + throw new Error( + `terrain build apron (${apron.x0},${apron.y0})-(${apron.x1},${apron.y1}) must fit inside the owned land; tile (${x},${y}) is not owned`, + ); return out; } @@ -364,7 +476,7 @@ function hill(v: unknown, path: string): ScenarioHill { }; } -function trees(v: unknown): ScenarioTrees { +function trees(v: unknown, def: ScenarioDef): ScenarioTrees { const t = object(v, 'trees'); const out: ScenarioTrees = { count: integer(t.count, 'trees.count', 0, MAX_TREES), @@ -382,6 +494,20 @@ function trees(v: unknown): ScenarioTrees { if (species.length === 0) throw new Error('trees.species must list at least one species'); out.species = species.map((s) => oneOf(s, 'trees.species', TREE_SPECIES_BY_NAME)); } + if (t.stands !== undefined) + out.stands = list(t.stands, 'trees.stands').map((v, i): TreeStand => { + const path = `trees.stands[${i}]`; + const o = object(v, path); + return { + density: integer(o.density, `${path}.density`, 1, 100), + rocks: o.rocks === undefined ? 0 : integer(o.rocks, `${path}.rocks`, 0, 100), + ...shape(o, path, def), + }; + }); + if (t.clearings !== undefined) + out.clearings = list(t.clearings, 'trees.clearings').map((v, i) => + shape(object(v, `trees.clearings[${i}]`), `trees.clearings[${i}]`, def), + ); return out; } diff --git a/src/sim/scenario/scenario-layout.ts b/src/sim/scenario/scenario-layout.ts index 019a683b2..631b427a4 100644 --- a/src/sim/scenario/scenario-layout.ts +++ b/src/sim/scenario/scenario-layout.ts @@ -3,7 +3,7 @@ import { placePath } from '../map/paths'; import type { TileMap } from '../map/tile-map'; import { applyScenario } from './scenario'; import { materializeAmbientTrees } from '../map/ambient-trees'; -import { buildApron, DEFAULT_LAND, generateScenarioMap, ownedBounds } from './scenario-map'; +import { DEFAULT_LAND, generateScenarioMap, ownedBounds, treeClearAreas } from './scenario-map'; import type { TileRect } from './scenario-map'; import { placePrebuilt } from './scenario-prebuilt'; import type { ScenarioDef, ScenarioEntrance } from './scenario'; @@ -20,6 +20,7 @@ export function layOutEntrance( world: World, entrance: ScenarioEntrance, owned: TileRect = ownedBounds(world.map.width, world.map.height, DEFAULT_LAND), + start?: number, ): number { const m = world.map; const x0 = owned.x0; @@ -28,7 +29,7 @@ export function layOutEntrance( const y1 = owned.y1 + 1; const horizontal = entrance.side === 'north' || entrance.side === 'south'; const [lo, hi] = horizontal ? [x0, x1 - 1] : [y0, y1 - 1]; - const mid = (lo + hi) >> 1; + const mid = start ?? (lo + hi) >> 1; const gate = (along: number): [number, number] => { switch (entrance.side) { case 'north': @@ -87,7 +88,10 @@ export function prepareScenario(world: World, def: ScenarioDef): void { const economy = world.economy; economy.cash = Number.MAX_SAFE_INTEGER; if (def.entrance) { - layOutEntrance(world, def.entrance, ownedBounds(world.map.width, world.map.height, def.land)); + const owned = ownedBounds(world.map.width, world.map.height, def.land); + const horizontal = def.entrance.side === 'north' || def.entrance.side === 'south'; + const mid = horizontal ? (owned.x0 + owned.x1) >> 1 : (owned.y0 + owned.y1) >> 1; + layOutEntrance(world, def.entrance, owned, mid + (def.terrain?.apronOffset ?? 0)); if (def.prebuilt) placePrebuilt(world, def.entrance.side, def.prebuilt); } applyScenario(world, def); @@ -102,12 +106,5 @@ export function prepareScenarioPark(world: World, def: ScenarioDef): void { prepareScenario(world, def); if (def.entrance && world.park.entranceX >= 0) layOutApproach(world, def.entrance.side, world.park.entranceX, world.park.entranceY); - const apron = buildApron( - world.map.width, - world.map.height, - def.entrance?.side ?? 'south', - def.terrain ?? { buildLength: 10, buildWidth: 18 }, - def.land, - ); - materializeAmbientTrees(world, [apron]); + materializeAmbientTrees(world, treeClearAreas(def, world.map.width, world.map.height)); } diff --git a/src/sim/scenario/scenario-map.ts b/src/sim/scenario/scenario-map.ts index 03d7bc9d3..80086193a 100644 --- a/src/sim/scenario/scenario-map.ts +++ b/src/sim/scenario/scenario-map.ts @@ -1,17 +1,31 @@ import { Prng } from '../core/prng'; import { relaxTerrain } from '../map/land'; -import { ElementType, expansionOwnership, MAP_BORDER, MAX_HEIGHT, Surface } from '../map/tile-map'; +import { + ElementType, + expansionOwnership, + MAP_BORDER, + MAX_ELEMENT_BASE, + MAX_HEIGHT, + OWNED, + SALE_LAND, + SALE_RIGHTS, + Surface, +} from '../map/tile-map'; import type { TileMap } from '../map/tile-map'; -import { SceneryItem } from '../map/scenery'; +import { SCENERY_CATALOG, SceneryItem } from '../map/scenery'; import type { EntranceSide, + ParcelKind, ScenarioDef, ScenarioLand, + ScenarioShape, ScenarioTerrain, ScenarioTrees, TerrainSurface, TreeSpecies, + TreeStand, } from './scenario'; +import { shapeBounds, shapeContains, shapeDistance } from './scenario-shapes'; const SURFACES: Record = { grass: Surface.Grass, @@ -30,29 +44,89 @@ export interface TileRect { y1: number; } -/** The land the player owns at the start: an inset rectangle of the map. */ -export function ownedBounds( +const PARCEL_FLAGS: Record = { + owned: OWNED, + land: SALE_LAND, + rights: SALE_RIGHTS, + none: 0, +}; + +/** + * Starting ownership flags for every tile. Margin land owns an inset rectangle with a land-sale + * ring and rights beyond it; parcel land paints each parcel's kind in order. The map border is + * never owned or for sale. + */ +export function landOwnership( width: number, height: number, land: ScenarioLand = DEFAULT_LAND, -): TileRect { +): Uint8Array { + const out = new Uint8Array(width * height); + const parcels = land.parcels; + const owned = parcels ? null : marginBounds(width, height, land); + const saleX = Math.floor((width * land.saleMarginPercent) / 100); + const saleY = Math.floor((height * land.saleMarginPercent) / 100); + for (let y = MAP_BORDER; y < height - MAP_BORDER; y++) { + for (let x = MAP_BORDER; x < width - MAP_BORDER; x++) { + let flags = 0; + if (parcels) { + for (const parcel of parcels) + if (shapeContains(parcel, x, y)) flags = PARCEL_FLAGS[parcel.kind]; + } else if (!(x < saleX || y < saleY || x >= width - saleX || y >= height - saleY)) { + flags = expansionOwnership(x, y, owned!); + } + out[y * width + x] = flags; + } + } + return out; +} + +function marginBounds(width: number, height: number, land: ScenarioLand): TileRect { const mx = Math.floor((width * land.ownedMarginPercent) / 100); const my = Math.floor((height * land.ownedMarginPercent) / 100); return { x0: mx, y0: my, x1: width - mx - 1, y1: height - my - 1 }; } -/** The flat apron in front of the gate: `buildLength` tiles inward and `buildWidth` across, centred on the gate edge. */ +/** + * The rectangle around the land the player owns at the start: an inset of the map for margin + * land, or the bounds of the owned parcels. + */ +export function ownedBounds( + width: number, + height: number, + land: ScenarioLand = DEFAULT_LAND, +): TileRect { + if (!land.parcels) return marginBounds(width, height, land); + const flags = landOwnership(width, height, land); + const out = { x0: width, y0: height, x1: -1, y1: -1 }; + for (let i = 0; i < flags.length; i++) { + if (!(flags[i] & OWNED)) continue; + const x = i % width; + const y = (i / width) | 0; + out.x0 = Math.min(out.x0, x); + out.y0 = Math.min(out.y0, y); + out.x1 = Math.max(out.x1, x); + out.y1 = Math.max(out.y1, y); + } + return out; +} + +/** + * The flat apron in front of the gate: `buildLength` tiles inward and `buildWidth` across, flush + * with the owned edge and centred `apronOffset` tiles from its midpoint. + */ export function buildApron( width: number, height: number, side: EntranceSide, - terrain: Pick, + terrain: Pick, land: ScenarioLand = DEFAULT_LAND, ): TileRect { const o = ownedBounds(width, height, land); const half = terrain.buildWidth >> 1; - const midX = (o.x0 + o.x1) >> 1; - const midY = (o.y0 + o.y1) >> 1; + const shift = terrain.apronOffset ?? 0; + const midX = ((o.x0 + o.x1) >> 1) + shift; + const midY = ((o.y0 + o.y1) >> 1) + shift; switch (side) { case 'south': return { @@ -148,6 +222,14 @@ function shapeHeights(map: TileMap, t: ScenarioTerrain, apron: TileRect, rng: Pr } } + for (const shape of t.shapes ?? []) { + const fall = Math.floor(shapeDistance(shape, vx, vy) / shape.run); + h = + shape.mode === 'raise' + ? Math.max(h, shape.level - fall) + : Math.min(h, shape.level + fall); + } + const gap = Math.max( apron.x0 - vx, vx - (apron.x1 + 1), @@ -163,23 +245,14 @@ function shapeHeights(map: TileMap, t: ScenarioTerrain, apron: TileRect, rng: Pr } function paintTiles(map: TileMap, t: ScenarioTerrain, land: ScenarioLand): void { - const owned = ownedBounds(map.width, map.height, land); - const saleX = Math.floor((map.width * land.saleMarginPercent) / 100); - const saleY = Math.floor((map.height * land.saleMarginPercent) / 100); + const ownership = landOwnership(map.width, map.height, land); for (let y = 0; y < map.height; y++) { for (let x = 0; x < map.width; x++) { const i = map.index(x, y); const h = map.heights[i]; map.terrain[i] = groundSurface(map, t, x, y); map.waterLevel[i] = h < t.seaLevel ? t.seaLevel : 0; - const border = - x < MAP_BORDER || - y < MAP_BORDER || - x >= map.width - MAP_BORDER || - y >= map.height - MAP_BORDER; - const unsellable = - x < saleX || y < saleY || x >= map.width - saleX || y >= map.height - saleY; - map.ownership[i] = border || unsellable ? 0 : expansionOwnership(x, y, owned); + map.ownership[i] = ownership[i]; map.refreshTile(i); } } @@ -249,6 +322,13 @@ function scatterTrees( land: ScenarioLand, ): void { const pool = trees.species ?? []; + const clearings = trees.clearings ?? []; + const keepClear = (x: number, y: number): boolean => + nearApron(x, y, apron) || + insideClearCorridor(x, y, map, side, land, trees.clearWidth ?? 0, trees.clearLength ?? 0) || + clearings.some((c) => shapeContains(c, x, y)); + for (const stand of trees.stands ?? []) fillStand(map, stand, pool, rng, keepClear); + const centres: Array<[number, number]> = []; for (let g = 0; g < trees.groves; g++) { centres.push([ @@ -271,12 +351,7 @@ function scatterTrees( const y = solitary ? cy : cy + rng.int(2 * TREE_RADIUS + 1) - TREE_RADIUS; if (!map.inBounds(x, y)) continue; const i = map.index(x, y); - if ( - nearApron(x, y, apron) || - insideClearCorridor(x, y, map, side, land, trees.clearWidth ?? 0, trees.clearLength ?? 0) || - !isFreeGround(map, i) - ) - continue; + if (keepClear(x, y) || !isFreeGround(map, i)) continue; const allowed = (GROUND_SPECIES[map.terrain[i]] ?? []).filter( (s) => pool.length === 0 || pool.includes(s), ); @@ -300,17 +375,54 @@ function scatterTrees( placed++; } - scatterGroundScenery(map, trees.shrubs ?? 0, SceneryItem.Shrub, apron, rng, side, land, trees); - scatterGroundScenery( - map, - trees.flowerBeds ?? 0, - SceneryItem.FlowerBed, - apron, - rng, - side, - land, - trees, + scatterGroundScenery(map, trees.shrubs ?? 0, SceneryItem.Shrub, rng, keepClear); + scatterGroundScenery(map, trees.flowerBeds ?? 0, SceneryItem.FlowerBed, rng, keepClear); +} + +/** + * Fills a stand: every dry, empty tile in the shape, sloped or flat, gets a tree that suits its + * ground (or a rock) with the stand's percent chance. + */ +function fillStand( + map: TileMap, + stand: TreeStand, + pool: readonly TreeSpecies[], + rng: Prng, + keepClear: (x: number, y: number) => boolean, +): void { + const b = shapeBounds(stand); + for (let y = Math.max(MAP_BORDER, b.y0); y <= Math.min(map.height - MAP_BORDER - 1, b.y1); y++) { + for (let x = Math.max(MAP_BORDER, b.x0); x <= Math.min(map.width - MAP_BORDER - 1, b.x1); x++) { + if (!shapeContains(stand, x, y) || rng.int(100) >= stand.density) continue; + const i = map.index(x, y); + if (keepClear(x, y) || !isOpenGround(map, i)) continue; + let item: SceneryItem; + if (rng.int(100) < stand.rocks) { + item = rng.int(2) === 0 ? SceneryItem.Boulder : SceneryItem.RockCluster; + } else { + const allowed = (GROUND_SPECIES[map.terrain[i]] ?? []).filter( + (s) => pool.length === 0 || pool.includes(s), + ); + if (allowed.length === 0) continue; + item = SPECIES_ITEM[allowed[rng.int(allowed.length)]]; + } + const base = map.heights[i] + (map.slope[i] !== 0 ? 1 : 0); + const top = Math.min(MAX_ELEMENT_BASE, base + Math.max(1, SCENERY_CATALOG[item].height)); + map.addElement(i, ElementType.SmallScenery, base, top, 0, item); + } + } +} + +/** Tiles kept free of generated scenery: the apron and gate margin plus the recipe's clearings. */ +export function treeClearAreas(def: ScenarioDef, width: number, height: number): TileRect[] { + const apron = buildApron( + width, + height, + def.entrance?.side ?? 'south', + def.terrain ?? { buildLength: 10, buildWidth: 18 }, + def.land, ); + return [apron, ...(def.trees?.clearings ?? []).map((c: ScenarioShape) => shapeBounds(c))]; } function insideClearCorridor( @@ -341,21 +453,14 @@ function scatterGroundScenery( map: TileMap, count: number, item: SceneryItem, - apron: TileRect, rng: Prng, - side: EntranceSide, - land: ScenarioLand, - trees: ScenarioTrees, + keepClear: (x: number, y: number) => boolean, ): void { let placed = 0; for (let attempt = 0; attempt < count * 12 && placed < count; attempt++) { const x = MAP_BORDER + rng.int(map.width - 2 * MAP_BORDER); const y = MAP_BORDER + rng.int(map.height - 2 * MAP_BORDER); - if ( - nearApron(x, y, apron) || - insideClearCorridor(x, y, map, side, land, trees.clearWidth ?? 0, trees.clearLength ?? 0) - ) - continue; + if (keepClear(x, y)) continue; const index = map.index(x, y); if (!isFreeGround(map, index) || map.terrain[index] !== Surface.Grass) continue; const base = map.heights[index]; @@ -373,10 +478,10 @@ function nearApron(x: number, y: number, apron: TileRect): boolean { } function isFreeGround(map: TileMap, i: number): boolean { - return ( - map.ownership[i] !== 0 && - map.waterLevel[i] === 0 && - map.slope[i] === 0 && - map.firstElement(i) < 0 - ); + return map.slope[i] === 0 && isOpenGround(map, i); +} + +/** Dry, empty tile that is owned or for sale, flat or sloped. */ +function isOpenGround(map: TileMap, i: number): boolean { + return map.ownership[i] !== 0 && map.waterLevel[i] === 0 && map.firstElement(i) < 0; } diff --git a/src/sim/scenario/scenario-shapes.test.ts b/src/sim/scenario/scenario-shapes.test.ts new file mode 100644 index 000000000..2f01d826a --- /dev/null +++ b/src/sim/scenario/scenario-shapes.test.ts @@ -0,0 +1,274 @@ +import { describe, expect, it } from 'vitest'; +import { World } from '../core/world'; +import { hashWorld } from '../core/hash'; +import { applyMapCommand } from '../map/map-commands'; +import { ElementType, OWNED, RIGHTS_OWNED, SALE_LAND, SALE_RIGHTS } from '../map/tile-map'; +import { SceneryItem } from '../map/scenery'; +import { parseScenarioFile } from './scenario-file'; +import { prepareScenario, prepareScenarioPark } from './scenario-layout'; +import type { ScenarioDef } from './scenario'; + +const BASE = { + id: 'shape-test', + name: 'Shape Test', + seed: 5, + map: { width: 64, height: 64 }, + finance: { + startingCash: 4_000_000, + startingLoan: 0, + maxLoan: 5_000_000, + annualInterestBps: 800, + }, + pricing: { mode: 'admission', admissionPrice: 300 }, + entrance: { side: 'south', length: 4 }, + objective: { kind: 'guests', target: 50, byYear: 1 }, +}; + +const TERRAIN = { + seaLevel: 3, + baseLevel: 6, + relief: 0, + cell: 8, + buildLevel: 6, + buildLength: 10, + buildWidth: 9, +}; + +/** An L of owned land: a southern strip across the map plus a western arm running north. */ +const L_PARCELS = [ + { kind: 'rights', rect: [4, 4, 59, 59] }, + { kind: 'land', rect: [8, 8, 55, 55] }, + { kind: 'owned', rect: [10, 44, 53, 53] }, + { kind: 'owned', rect: [10, 10, 21, 43] }, + { kind: 'none', rect: [30, 14, 50, 36] }, +]; + +function recipe(overrides: Record = {}): ScenarioDef { + return parseScenarioFile({ + ...BASE, + land: { parcels: L_PARCELS }, + terrain: TERRAIN, + ...overrides, + }); +} + +function parkWorld(def: ScenarioDef): World { + const w = new World({ seed: def.seed, width: def.mapWidth, height: def.mapHeight }); + prepareScenarioPark(w, def); + return w; +} + +function own(w: World, x: number, y: number): number { + return w.map.ownership[w.map.index(x, y)]!; +} + +function scenery(w: World, x: number, y: number): SceneryItem | null { + const m = w.map; + const i = m.index(x, y); + for (let e = m.firstElement(i); e >= 0; e = m.nextElement(e)) + if (m.elType[e] === ElementType.SmallScenery) return m.elData[e] as SceneryItem; + return null; +} + +describe('land parcels', () => { + it('owns exactly the painted owned shapes, and sells land and rights where painted', () => { + const w = parkWorld(recipe()); + expect(own(w, 15, 20) & OWNED).toBe(OWNED); + expect(own(w, 40, 50) & OWNED).toBe(OWNED); + expect(own(w, 40, 30) & OWNED).toBe(0); + expect(own(w, 26, 30) & SALE_LAND).toBe(SALE_LAND); + expect(own(w, 6, 30) & SALE_RIGHTS).toBe(SALE_RIGHTS); + expect(own(w, 2, 30)).toBe(0); + }); + + it('keeps no-sale parcels unowned after buying every tile and right on the map', () => { + const w = parkWorld(recipe()); + w.economy.cash = Number.MAX_SAFE_INTEGER; + const m = w.map; + applyMapCommand(w, { + type: 'buyLand', + x: 0, + y: 0, + width: m.width, + height: m.height, + rights: false, + }); + applyMapCommand(w, { + type: 'buyLand', + x: 0, + y: 0, + width: m.width, + height: m.height, + rights: true, + }); + expect(own(w, 26, 30) & OWNED).toBe(OWNED); + expect(own(w, 6, 30) & RIGHTS_OWNED).toBe(RIGHTS_OWNED); + for (const [x, y] of [ + [30, 14], + [40, 25], + [50, 36], + ] as const) + expect(own(w, x, y)).toBe(0); + }); + + it('puts the gate and a flat owned apron at the offset along the owned edge', () => { + const w = parkWorld(recipe({ terrain: { ...TERRAIN, apronOffset: -12 } })); + const m = w.map; + expect(own(w, w.park.entranceX, w.park.entranceY) & OWNED).toBe(OWNED); + expect(w.park.entranceY).toBe(53); + expect(w.park.entranceX).toBeGreaterThanOrEqual(15); + expect(w.park.entranceX).toBeLessThanOrEqual(23); + for (let y = 44; y <= 53; y++) + for (let x = 15; x <= 23; x++) { + const i = m.index(x, y); + expect(own(w, x, y) & OWNED).toBe(OWNED); + expect(m.heights[i]).toBe(TERRAIN.buildLevel); + expect(m.slope[i]).toBe(0); + } + }); + + it('rejects owned land in more than one piece', () => { + expect(() => + recipe({ + land: { + parcels: [ + { kind: 'owned', rect: [10, 44, 53, 53] }, + { kind: 'owned', rect: [10, 10, 20, 30] }, + ], + }, + }), + ).toThrow(/owned land must be one connected piece/); + }); + + it('rejects an apron that leaves the owned shape', () => { + expect(() => recipe({ terrain: { ...TERRAIN, apronOffset: 20 } })).toThrow( + /apron must fit inside the owned land/, + ); + expect(() => recipe({ terrain: { ...TERRAIN, apronOffset: 15 } })).not.toThrow(); + }); + + it('rejects shapes outside the map and unknown parcel kinds', () => { + expect(() => + recipe({ land: { parcels: [{ kind: 'owned', rect: [10, 44, 70, 53] }] } }), + ).toThrow(/land.parcels\[0\]/); + expect(() => + recipe({ land: { parcels: [{ kind: 'castle', rect: [10, 44, 53, 53] }] } }), + ).toThrow(/land.parcels\[0\].kind/); + }); + + it('accepts ellipses and bands as parcel shapes', () => { + const w = parkWorld( + recipe({ + land: { + parcels: [ + { kind: 'owned', rect: [16, 44, 48, 53] }, + { kind: 'owned', ellipse: [32, 30, 12, 8] }, + { kind: 'owned', band: [32, 44, 32, 8, 1] }, + ], + }, + }), + ); + expect(own(w, 32, 10) & OWNED).toBe(OWNED); + expect(own(w, 36, 10) & OWNED).toBe(0); + expect(own(w, 22, 30) & OWNED).toBe(OWNED); + expect(own(w, 22, 22) & OWNED).toBe(0); + }); +}); + +describe('terrain shapes', () => { + it('raises a ridge along a band and keeps every tile within one level of slope', () => { + const w = parkWorld( + recipe({ + terrain: { ...TERRAIN, shapes: [{ mode: 'raise', level: 15, band: [12, 12, 52, 12, 1] }] }, + }), + ); + const m = w.map; + expect(m.heights[m.index(32, 12)]).toBeGreaterThanOrEqual(14); + expect(m.heights[m.index(32, 30)]).toBeLessThanOrEqual(8); + for (let vy = 0; vy < m.height; vy++) + for (let vx = 0; vx < m.width; vx++) { + const v = m.vertexHeights[m.vertexIndex(vx, vy)]!; + expect(Math.abs(v - m.vertexHeights[m.vertexIndex(vx + 1, vy)]!)).toBeLessThanOrEqual(1); + expect(Math.abs(v - m.vertexHeights[m.vertexIndex(vx, vy + 1)]!)).toBeLessThanOrEqual(1); + } + }); + + it('fills ground cut below sea level with water, even inland, and leaves the banks dry', () => { + const w = parkWorld( + recipe({ + terrain: { ...TERRAIN, shapes: [{ mode: 'lower', level: 1, band: [12, 20, 52, 20, 2] }] }, + }), + ); + const m = w.map; + const inChannel = m.index(40, 20); + const beside = m.index(40, 30); + expect(m.waterLevel[inChannel]).toBeGreaterThan(m.heights[inChannel]!); + expect(m.waterLevel[beside]).toBeLessThanOrEqual(m.heights[beside]!); + }); +}); + +describe('tree stands and clearings', () => { + const forest = { + count: 400, + groves: 6, + stands: [{ density: 70, rect: [10, 10, 21, 43] }], + clearings: [{ rect: [12, 20, 19, 27] }], + }; + + it('fills a stand densely, at random rather than on a grid', () => { + const w = parkWorld(recipe({ trees: forest })); + let trees = 0; + let free = 0; + const rows = new Set(); + for (let y = 30; y <= 43; y++) { + let row = ''; + for (let x = 10; x <= 21; x++) { + const s = scenery(w, x, y); + row += s === null ? '.' : 'T'; + if (s === null) free++; + else trees++; + } + rows.add(row); + } + expect(trees / (trees + free)).toBeGreaterThan(0.45); + expect(rows.size).toBeGreaterThan(8); + }); + + it('keeps clearings and the gate area free of trees, including ambient trees', () => { + const w = parkWorld(recipe({ trees: forest })); + for (let y = 20; y <= 27; y++) + for (let x = 12; x <= 19; x++) expect(scenery(w, x, y)).toBeNull(); + for (let y = 44; y <= 53; y++) + for (let x = 27; x <= 35; x++) expect(scenery(w, x, y)).toBeNull(); + let beside = 0; + for (let y = 30; y <= 43; y++) for (let x = 10; x <= 21; x++) if (scenery(w, x, y)) beside++; + expect(beside).toBeGreaterThan(30); + }); + + it('mixes boulders into a stand when asked', () => { + const w = parkWorld( + recipe({ + trees: { ...forest, stands: [{ density: 60, rocks: 50, rect: [10, 10, 21, 43] }] }, + }), + ); + let rocks = 0; + for (let y = 10; y <= 43; y++) + for (let x = 10; x <= 21; x++) { + const s = scenery(w, x, y); + if (s === SceneryItem.Boulder || s === SceneryItem.RockCluster) rocks++; + } + expect(rocks).toBeGreaterThan(20); + }); + + it('is deterministic for a seed and differs between seeds', () => { + const def = recipe({ trees: forest }); + const a = new World({ seed: 3, width: 64, height: 64 }); + const b = new World({ seed: 3, width: 64, height: 64 }); + prepareScenario(a, def); + prepareScenario(b, def); + expect(hashWorld(a)).toBe(hashWorld(b)); + const c = new World({ seed: 4, width: 64, height: 64 }); + prepareScenario(c, def); + expect(hashWorld(c)).not.toBe(hashWorld(a)); + }); +}); diff --git a/src/sim/scenario/scenario-shapes.ts b/src/sim/scenario/scenario-shapes.ts new file mode 100644 index 000000000..aa27d42a8 --- /dev/null +++ b/src/sim/scenario/scenario-shapes.ts @@ -0,0 +1,57 @@ +import type { ScenarioShape } from './scenario'; +import type { TileRect } from './scenario-map'; + +/** + * Distance in tiles from the point (`px`, `py`) to the shape, 0 inside it. Tile (x, y) covers + * [x, x + 1] × [y, y + 1], so its centre is (x + 0.5, y + 0.5) and terrain vertex (vx, vy) is the + * point (vx, vy). Ellipse distances outside the rim are scaled by the smaller radius. + */ +export function shapeDistance(shape: ScenarioShape, px: number, py: number): number { + if ('rect' in shape) { + const [x0, y0, x1, y1] = shape.rect; + const dx = Math.max(x0 + 0.5 - px, px - (x1 + 0.5), 0); + const dy = Math.max(y0 + 0.5 - py, py - (y1 + 0.5), 0); + return Math.sqrt(dx * dx + dy * dy); + } + if ('ellipse' in shape) { + const [cx, cy, rx, ry] = shape.ellipse; + const nx = (px - (cx + 0.5)) / rx; + const ny = (py - (cy + 0.5)) / ry; + const n = Math.sqrt(nx * nx + ny * ny); + return n <= 1 ? 0 : (n - 1) * Math.min(rx, ry); + } + const [x0, y0, x1, y1, half] = shape.band; + const ax = x0 + 0.5; + const ay = y0 + 0.5; + const sx = x1 - x0; + const sy = y1 - y0; + const len2 = sx * sx + sy * sy; + const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, ((px - ax) * sx + (py - ay) * sy) / len2)); + const dx = px - (ax + t * sx); + const dy = py - (ay + t * sy); + return Math.max(0, Math.sqrt(dx * dx + dy * dy) - half); +} + +/** True when the centre of tile (x, y) lies in the shape. */ +export function shapeContains(shape: ScenarioShape, x: number, y: number): boolean { + return shapeDistance(shape, x + 0.5, y + 0.5) === 0; +} + +/** Inclusive tile rectangle around the shape. */ +export function shapeBounds(shape: ScenarioShape): TileRect { + if ('rect' in shape) { + const [x0, y0, x1, y1] = shape.rect; + return { x0, y0, x1, y1 }; + } + if ('ellipse' in shape) { + const [cx, cy, rx, ry] = shape.ellipse; + return { x0: cx - rx, y0: cy - ry, x1: cx + rx, y1: cy + ry }; + } + const [x0, y0, x1, y1, half] = shape.band; + return { + x0: Math.min(x0, x1) - half, + y0: Math.min(y0, y1) - half, + x1: Math.max(x0, x1) + half, + y1: Math.max(y0, y1) + half, + }; +} diff --git a/src/sim/scenario/scenario.ts b/src/sim/scenario/scenario.ts index 05b2b428b..31eeca967 100644 --- a/src/sim/scenario/scenario.ts +++ b/src/sim/scenario/scenario.ts @@ -85,6 +85,26 @@ export interface ScenarioHill { height: number; } +/** + * A region of the map in tile coordinates. `rect` is inclusive `[x0, y0, x1, y1]`; `ellipse` is + * `[cx, cy, rx, ry]` around a tile centre; `band` is a thick line `[x0, y0, x1, y1, halfWidth]` + * between two tile centres. + */ +export type ScenarioShape = + | { rect: [number, number, number, number] } + | { ellipse: [number, number, number, number] } + | { band: [number, number, number, number, number] }; + +/** + * Ground pushed up to (`raise`) or down to (`lower`) an absolute level inside the shape, falling + * away by one level every `run` tiles outside it, so ridges, shelves and channels keep legal slopes. + */ +export type TerrainShape = ScenarioShape & { + mode: 'raise' | 'lower'; + level: number; + run: number; +}; + /** * Hand-authored terrain recipe. The generator layers coarse seeded noise, hills and lakes over a * base level, then flattens a build apron in front of the gate. @@ -102,8 +122,12 @@ export interface ScenarioTerrain { /** Apron extent inward from the gate edge, and across it, in tiles. */ buildLength: number; buildWidth: number; + /** Tiles the apron and gate shift along the gate edge from the owned land's midpoint. */ + apronOffset?: number; lakes: ScenarioLake[]; hills: ScenarioHill[]; + /** Applied in order after noise, hills and lakes, before the apron is levelled. */ + shapes?: TerrainShape[]; /** Ground above `level` takes this surface instead of `surface`, for themed uplands. */ highland?: ScenarioHighland; } @@ -114,11 +138,21 @@ export interface ScenarioHighland { level: number; } -/** Share of the map inset (percent per side) that is owned at the start, and how much of the rest is for sale. */ +export type ParcelKind = 'owned' | 'land' | 'rights' | 'none'; + +/** One painted region of the ownership map: owned, land for sale, rights for sale, or not for sale. */ +export type LandParcel = ScenarioShape & { kind: ParcelKind }; + +/** + * Share of the map inset (percent per side) that is owned at the start, and how much of the rest is + * for sale. When `parcels` is set it replaces the margins: each parcel paints its kind over the + * previous ones, and unpainted tiles are not for sale. + */ export interface ScenarioLand { ownedMarginPercent: number; /** Percent of each side, from the border, that is not for sale. */ saleMarginPercent: number; + parcels?: LandParcel[]; } export const TREE_SPECIES = [ @@ -142,8 +176,15 @@ export interface ScenarioTrees { flowerBeds?: number; /** Species the trees may use. Defaults by ground: broadleaf and conifer on grass, cactus on sand. */ species?: TreeSpecies[]; + /** Woods filled at random: each dry, empty tile in the shape gets a tree with `density` percent chance. */ + stands?: TreeStand[]; + /** Shapes kept free of generated and ambient trees. */ + clearings?: ScenarioShape[]; } +/** `rocks` percent of a stand's pieces are boulders or rock clusters instead of trees. */ +export type TreeStand = ScenarioShape & { density: number; rocks: number }; + /** A ride or stall already standing at the start, placed on the gate's park grid. */ export interface PrebuiltRide { type: string; @@ -158,6 +199,10 @@ export interface ScenarioDef { name: string; category?: ScenarioCategory; description?: string; + /** Short description of the park's terrain and land, for the scenario list. */ + landscape?: string; + /** What makes the park hard and a way to approach it, for the scenario list. */ + challenge?: string; seed: number; mapWidth: number; mapHeight: number; diff --git a/src/sim/scenario/scenarios/copper-ridge.json b/src/sim/scenario/scenarios/copper-ridge.json index fde8a30b7..6a59e07cc 100644 --- a/src/sim/scenario/scenarios/copper-ridge.json +++ b/src/sim/scenario/scenarios/copper-ridge.json @@ -3,7 +3,9 @@ "name": "Copper Ridge", "category": "challenging", "climate": "hotAndDry", - "description": "Dry red hills with a mine-cart past. Build five coasters rated 4.60 excitement or better before the end of the first year.", + "description": "Dry red ridges with a mine-cart past. Build five coasters rated 4.60 excitement or better before the end of the second year.", + "landscape": "Red ridges split by a dry gulch. The gate opens onto a narrow bench, with more benches higher up.", + "challenge": "Landscaping is forbidden, so the ridges stay. Run coasters along the slopes and through the rock, and buy rights over the gulch to bridge it.", "seed": 2101, "map": { "width": 96, @@ -124,54 +126,122 @@ "length": 4 }, "terrain": { - "seaLevel": 3, - "baseLevel": 8, - "relief": 5, + "seaLevel": 2, + "baseLevel": 14, + "relief": 4, "cell": 10, - "surface": "grass", - "buildLevel": 9, - "buildLength": 48, - "buildWidth": 35, - "lakes": [ - { - "x": 15, - "y": 20, - "rx": 9, - "ry": 7, - "depth": 2 - } - ], - "hills": [ + "surface": "dirt", + "buildLevel": 8, + "buildLength": 12, + "buildWidth": 17, + "lakes": [], + "hills": [], + "highland": { + "surface": "rock", + "level": 17 + }, + "shapes": [ + { + "mode": "lower", + "level": 8, + "ellipse": [46, 80, 15, 6] + }, { - "x": 80, - "y": 25, - "radius": 12, - "height": 5 + "mode": "lower", + "level": 8, + "rect": [37, 76, 55, 88] }, { - "x": 20, - "y": 70, - "radius": 10, - "height": 4 + "mode": "lower", + "level": 5, + "band": [10, 62, 88, 58, 1] + }, + { + "mode": "lower", + "level": 11, + "ellipse": [30, 42, 14, 6] + }, + { + "mode": "lower", + "level": 13, + "ellipse": [68, 34, 14, 6] + }, + { + "mode": "lower", + "level": 16, + "ellipse": [46, 16, 16, 5] + }, + { + "mode": "raise", + "level": 22, + "ellipse": [82, 14, 5, 4] } ], - "highland": { - "surface": "dirt", - "level": 10 - } + "apronOffset": 8 }, "land": { - "ownedMarginPercent": 22, - "saleMarginPercent": 3 + "parcels": [ + { + "kind": "rights", + "band": [10, 62, 88, 58, 5] + }, + { + "kind": "rights", + "band": [44, 40, 56, 36, 4] + }, + { + "kind": "land", + "ellipse": [68, 34, 15, 7] + }, + { + "kind": "land", + "band": [54, 74, 64, 40, 2] + }, + { + "kind": "land", + "ellipse": [46, 16, 17, 6] + }, + { + "kind": "land", + "band": [38, 38, 44, 20, 2] + }, + { + "kind": "owned", + "ellipse": [46, 80, 16, 7] + }, + { + "kind": "owned", + "band": [36, 76, 30, 46, 2] + }, + { + "kind": "owned", + "ellipse": [30, 42, 15, 7] + }, + { + "kind": "owned", + "rect": [37, 76, 55, 88] + } + ] }, "trees": { - "count": 150, - "groves": 8 + "count": 40, + "groves": 5, + "species": ["conifer", "oak"], + "stands": [ + { + "density": 7, + "rocks": 80, + "rect": [8, 8, 88, 88] + } + ] }, "objective": { "kind": "completeCoasters", "target": 5, "minimumExcitement": 460, - "byYear": 1 + "byYear": 2 + }, + "restrictions": { + "forbidLandscaping": true } } diff --git a/src/sim/scenario/scenarios/glacier-point.json b/src/sim/scenario/scenarios/glacier-point.json index 53a33e884..806a5f092 100644 --- a/src/sim/scenario/scenarios/glacier-point.json +++ b/src/sim/scenario/scenarios/glacier-point.json @@ -3,7 +3,9 @@ "name": "Glacier Point", "category": "expert", "climate": "cold", - "description": "A frozen shelf above the lake and almost no time. Have six coasters rated 4.90 excitement or better standing within a month and a half.", + "description": "A cold mountain resort where only roller coasters are allowed. Have five coasters rated 4.70 excitement or better by the end of the second year.", + "landscape": "Mountain shelves above a glacial lake, linked by steep trails, with conifers on the slopes.", + "challenge": "Only roller coasters may be built, along with stalls, toilets and the chairlift. Lay coasters on the mountainside and buy the higher shelves as you grow.", "seed": 3202, "map": { "width": 96, @@ -20,58 +22,8 @@ "mode": "perRide" }, "research": { - "availableItemIds": [1, 3, 5, 6, 7, 8, 9, 10, 12, 25, 26, 27, 28], + "availableItemIds": [5, 6, 7, 8, 9, 10, 25, 26, 27, 28], "inventions": [ - { - "itemId": 2, - "category": 0, - "workUnits": 180 - }, - { - "itemId": 4, - "category": 3, - "workUnits": 360 - }, - { - "itemId": 11, - "category": 3, - "workUnits": 675 - }, - { - "itemId": 13, - "category": 3, - "workUnits": 765 - }, - { - "itemId": 14, - "category": 3, - "workUnits": 810 - }, - { - "itemId": 15, - "category": 3, - "workUnits": 855 - }, - { - "itemId": 16, - "category": 4, - "workUnits": 900 - }, - { - "itemId": 17, - "category": 4, - "workUnits": 945 - }, - { - "itemId": 18, - "category": 0, - "workUnits": 990 - }, - { - "itemId": 19, - "category": 0, - "workUnits": 1035 - }, { "itemId": 20, "category": 0, @@ -87,11 +39,6 @@ "category": 2, "workUnits": 1170 }, - { - "itemId": 23, - "category": 1, - "workUnits": 1215 - }, { "itemId": 24, "category": 5, @@ -124,49 +71,148 @@ "length": 4 }, "terrain": { - "seaLevel": 3, - "baseLevel": 9, + "seaLevel": 4, + "baseLevel": 12, "relief": 5, "cell": 10, "surface": "grass", - "buildLevel": 10, - "buildLength": 52, - "buildWidth": 37, - "lakes": [ - { - "x": 20, - "y": 65, - "rx": 14, - "ry": 10, - "depth": 3 - } - ], - "hills": [ - { - "x": 78, - "y": 30, - "radius": 12, - "height": 6 - } - ], + "buildLevel": 12, + "buildLength": 8, + "buildWidth": 11, + "apronOffset": -9, + "lakes": [], + "hills": [], "highland": { "surface": "rock", - "level": 11 - } + "level": 17 + }, + "shapes": [ + { + "mode": "lower", + "level": 1, + "ellipse": [28, 60, 24, 20] + }, + { + "mode": "raise", + "level": 25, + "ellipse": [56, 12, 14, 8] + }, + { + "mode": "raise", + "level": 21, + "ellipse": [86, 26, 7, 9] + }, + { + "mode": "raise", + "level": 19, + "band": [20, 30, 44, 18, 2] + }, + { + "mode": "raise", + "level": 12, + "ellipse": [80, 52, 10, 7] + }, + { + "mode": "lower", + "level": 12, + "ellipse": [80, 52, 10, 7] + }, + { + "mode": "raise", + "level": 12, + "rect": [84, 46, 91, 58] + }, + { + "mode": "lower", + "level": 12, + "rect": [84, 46, 91, 58] + }, + { + "mode": "raise", + "level": 10, + "ellipse": [62, 52, 10, 5] + }, + { + "mode": "lower", + "level": 10, + "ellipse": [62, 52, 10, 5] + }, + { + "mode": "raise", + "level": 18, + "ellipse": [58, 30, 10, 4] + }, + { + "mode": "lower", + "level": 18, + "ellipse": [58, 30, 10, 4] + }, + { + "mode": "lower", + "level": 6, + "ellipse": [52, 72, 11, 5] + } + ] }, "land": { - "ownedMarginPercent": 22, - "saleMarginPercent": 2 + "parcels": [ + { + "kind": "rights", + "ellipse": [70, 40, 18, 12] + }, + { + "kind": "rights", + "band": [50, 70, 40, 80, 4] + }, + { + "kind": "land", + "ellipse": [62, 52, 11, 6] + }, + { + "kind": "land", + "ellipse": [58, 30, 11, 5] + }, + { + "kind": "land", + "band": [64, 46, 60, 34, 2] + }, + { + "kind": "owned", + "ellipse": [80, 52, 11, 8] + }, + { + "kind": "owned", + "rect": [84, 46, 91, 58] + }, + { + "kind": "owned", + "band": [76, 58, 58, 70, 2] + }, + { + "kind": "owned", + "ellipse": [52, 72, 12, 6] + } + ] }, "trees": { - "count": 200, - "groves": 9, - "species": ["conifer", "birch"] + "count": 120, + "groves": 8, + "species": ["conifer", "birch"], + "stands": [ + { + "density": 14, + "rocks": 30, + "rect": [40, 20, 92, 86] + } + ] }, "objective": { "kind": "completeCoasters", - "target": 6, - "minimumExcitement": 490, - "byTick": 22528 + "target": 5, + "minimumExcitement": 470, + "byYear": 2 + }, + "restrictions": { + "forbiddenRideTypeIds": [1, 2, 3, 4, 11, 12, 13, 14, 15, 16, 17, 18, 19, 23] } } diff --git a/src/sim/scenario/scenarios/mossgrove-isle.json b/src/sim/scenario/scenarios/mossgrove-isle.json new file mode 100644 index 000000000..d049bb61b --- /dev/null +++ b/src/sim/scenario/scenarios/mossgrove-isle.json @@ -0,0 +1,254 @@ +{ + "id": "mossgrove-isle", + "name": "Mossgrove Isle", + "category": "challenging", + "climate": "coolAndWet", + "description": "A thickly wooded island where the old trees are protected. Reach $900 a month in ride ticket income by the end of year three.", + "landscape": "A thickly wooded island in a cold lake, with a few small clearings and a protected grove on the knoll.", + "challenge": "Trees may not be removed. Build in the clearings, lift track above the treetops, and buy rights over the shallows for water rides.", + "seed": 3307, + "map": { + "width": 72, + "height": 72 + }, + "finance": { + "startingCash": 3500000, + "startingLoan": 2000000, + "maxLoan": 6000000, + "annualInterestBps": 900 + }, + "difficultRating": false, + "pricing": { + "mode": "perRide" + }, + "research": { + "availableItemIds": [1, 2, 3, 5, 6, 7, 8, 9, 12, 25, 26, 27, 28], + "inventions": [ + { + "itemId": 4, + "category": 3, + "workUnits": 360 + }, + { + "itemId": 10, + "category": 2, + "workUnits": 630 + }, + { + "itemId": 11, + "category": 3, + "workUnits": 675 + }, + { + "itemId": 13, + "category": 3, + "workUnits": 765 + }, + { + "itemId": 14, + "category": 3, + "workUnits": 810 + }, + { + "itemId": 15, + "category": 3, + "workUnits": 855 + }, + { + "itemId": 16, + "category": 4, + "workUnits": 900 + }, + { + "itemId": 17, + "category": 4, + "workUnits": 945 + }, + { + "itemId": 18, + "category": 0, + "workUnits": 990 + }, + { + "itemId": 19, + "category": 0, + "workUnits": 1035 + }, + { + "itemId": 20, + "category": 0, + "workUnits": 1080 + }, + { + "itemId": 21, + "category": 2, + "workUnits": 1125 + }, + { + "itemId": 22, + "category": 2, + "workUnits": 1170 + }, + { + "itemId": 23, + "category": 1, + "workUnits": 1215 + }, + { + "itemId": 24, + "category": 5, + "workUnits": 1260 + }, + { + "itemId": 29, + "category": 5, + "workUnits": 1485 + }, + { + "itemId": 30, + "category": 5, + "workUnits": 1530 + }, + { + "itemId": 31, + "category": 5, + "workUnits": 1575 + }, + { + "itemId": 32, + "category": 5, + "workUnits": 1620 + } + ] + }, + "entrance": { + "side": "south", + "length": 4 + }, + "terrain": { + "seaLevel": 4, + "baseLevel": 3, + "relief": 0, + "cell": 8, + "surface": "grass", + "buildLevel": 6, + "buildLength": 8, + "buildWidth": 11, + "lakes": [], + "hills": [], + "shapes": [ + { + "mode": "raise", + "level": 6, + "run": 2, + "ellipse": [35, 30, 14, 10] + }, + { + "mode": "raise", + "level": 7, + "run": 1, + "ellipse": [42, 23, 4, 3] + }, + { + "mode": "raise", + "level": 9, + "ellipse": [24, 28, 3, 3], + "run": 1 + }, + { + "mode": "raise", + "level": 6, + "rect": [30, 44, 40, 50] + }, + { + "mode": "raise", + "level": 6, + "band": [35, 50, 35, 70, 1] + }, + { + "mode": "raise", + "level": 6, + "run": 2, + "ellipse": [60, 12, 4, 3] + } + ] + }, + "land": { + "parcels": [ + { + "kind": "rights", + "band": [12, 36, 28, 52, 5] + }, + { + "kind": "rights", + "band": [42, 52, 58, 36, 5] + }, + { + "kind": "land", + "ellipse": [60, 12, 6, 5] + }, + { + "kind": "owned", + "ellipse": [35, 30, 21, 16] + }, + { + "kind": "owned", + "rect": [30, 44, 40, 50] + }, + { + "kind": "none", + "ellipse": [42, 23, 5, 4] + } + ] + }, + "trees": { + "count": 60, + "groves": 4, + "species": ["oak", "conifer", "birch", "autumn"], + "stands": [ + { + "density": 85, + "rocks": 4, + "ellipse": [35, 30, 21, 16] + }, + { + "density": 60, + "ellipse": [60, 12, 6, 5] + } + ], + "clearings": [ + { + "ellipse": [25, 36, 6, 4] + }, + { + "ellipse": [47, 37, 5, 4] + }, + { + "ellipse": [28, 20, 5, 4] + }, + { + "ellipse": [50, 26, 4, 3] + }, + { + "band": [35, 44, 25, 36, 1] + }, + { + "band": [35, 44, 47, 37, 1] + }, + { + "band": [25, 36, 28, 20, 1] + }, + { + "band": [47, 37, 50, 26, 1] + } + ] + }, + "objective": { + "kind": "monthlyRideIncome", + "target": 90000, + "byYear": 3 + }, + "restrictions": { + "forbidTreeRemoval": true + } +} diff --git a/src/sim/scenario/scenarios/thunderhead-mesa.json b/src/sim/scenario/scenarios/thunderhead-mesa.json index f900ed768..4cf2867e2 100644 --- a/src/sim/scenario/scenarios/thunderhead-mesa.json +++ b/src/sim/scenario/scenarios/thunderhead-mesa.json @@ -4,6 +4,8 @@ "category": "expert", "climate": "hotAndDry", "description": "A scorched mesa and a hard-to-please crowd. Hold 460 guests and a park rating of 700 through the end of year four.", + "landscape": "A scorched mesa top dotted with buttes, dropping to lower shelves across a dry canyon.", + "challenge": "Nothing may stand more than 6 levels above the ground, and marketing is banned. Build low and let coasters dive off the cliffs to the shelves below.", "seed": 3101, "map": { "width": 96, @@ -125,54 +127,174 @@ }, "terrain": { "seaLevel": 2, - "baseLevel": 8, + "baseLevel": 10, "relief": 6, "cell": 12, - "surface": "sand", - "buildLevel": 9, - "buildLength": 60, - "buildWidth": 25, + "surface": "dirt", + "buildLevel": 16, + "buildLength": 8, + "buildWidth": 15, + "apronOffset": 6, "lakes": [ { - "x": 80, - "y": 75, - "rx": 7, - "ry": 6, + "x": 84, + "y": 80, + "rx": 6, + "ry": 5, "depth": 2 } ], - "hills": [ + "hills": [], + "highland": { + "surface": "sand", + "level": 15 + }, + "shapes": [ + { + "mode": "raise", + "level": 16, + "ellipse": [40, 18, 14, 7] + }, + { + "mode": "raise", + "level": 16, + "ellipse": [62, 24, 9, 5] + }, + { + "mode": "raise", + "level": 16, + "band": [44, 20, 60, 24, 1] + }, + { + "mode": "raise", + "level": 16, + "rect": [39, 9, 53, 16] + }, + { + "mode": "raise", + "level": 19, + "ellipse": [32, 20, 2, 2] + }, + { + "mode": "raise", + "level": 18, + "ellipse": [50, 22, 1, 2] + }, + { + "mode": "raise", + "level": 19, + "ellipse": [66, 26, 2, 1] + }, { - "x": 20, - "y": 25, - "radius": 14, - "height": 6 + "mode": "raise", + "level": 22, + "ellipse": [82, 14, 7, 6] }, { - "x": 75, - "y": 22, - "radius": 10, - "height": 4 + "mode": "raise", + "level": 21, + "ellipse": [12, 24, 6, 8] + }, + { + "mode": "lower", + "level": 4, + "band": [8, 44, 88, 42, 1] + }, + { + "mode": "raise", + "level": 11, + "ellipse": [22, 56, 12, 7] + }, + { + "mode": "lower", + "level": 11, + "ellipse": [22, 56, 12, 7] + }, + { + "mode": "raise", + "level": 13, + "ellipse": [72, 58, 12, 7] + }, + { + "mode": "lower", + "level": 13, + "ellipse": [72, 58, 12, 7] + }, + { + "mode": "lower", + "level": 7, + "ellipse": [46, 80, 17, 5] } - ], - "highland": { - "surface": "rock", - "level": 10 - } + ] }, "land": { - "ownedMarginPercent": 16, - "saleMarginPercent": 0 + "parcels": [ + { + "kind": "rights", + "band": [8, 46, 88, 42, 4] + }, + { + "kind": "land", + "ellipse": [72, 58, 13, 8] + }, + { + "kind": "land", + "band": [60, 30, 70, 52, 2] + }, + { + "kind": "land", + "ellipse": [46, 80, 18, 6] + }, + { + "kind": "land", + "band": [30, 58, 40, 76, 2] + }, + { + "kind": "owned", + "ellipse": [40, 18, 15, 8] + }, + { + "kind": "owned", + "ellipse": [62, 24, 10, 6] + }, + { + "kind": "owned", + "band": [44, 20, 60, 24, 3] + }, + { + "kind": "owned", + "rect": [39, 9, 53, 16] + }, + { + "kind": "owned", + "band": [34, 24, 24, 50, 2] + }, + { + "kind": "owned", + "ellipse": [22, 56, 13, 8] + } + ] }, "trees": { - "count": 60, + "count": 30, "groves": 3, - "species": ["cactus"] + "species": ["cactus"], + "stands": [ + { + "density": 7, + "rocks": 80, + "rect": [6, 6, 90, 90] + } + ] }, "objective": { "kind": "guestsAndRating", "target": 460, "rating": 700, "byYear": 4 + }, + "restrictions": { + "maxConstructionHeight": 6, + "forbidMarketing": true } } diff --git a/src/sim/scenario/scenarios/tidewater-docks.json b/src/sim/scenario/scenarios/tidewater-docks.json index e23808cbc..1f24ed6ad 100644 --- a/src/sim/scenario/scenarios/tidewater-docks.json +++ b/src/sim/scenario/scenarios/tidewater-docks.json @@ -4,6 +4,8 @@ "category": "challenging", "climate": "cold", "description": "An old dockyard park with a loan to clear. Pay off the debt and lift the park's value past $5,500 by the end of year four.", + "landscape": "An old harbour: a hook of quays wrapped around a basin, with three narrow finger piers.", + "challenge": "The basin is never for sale; you can only buy construction rights over it. Squeeze rides onto the piers, link them with footbridges, and use the water for water rides.", "seed": 2202, "map": { "width": 80, @@ -126,37 +128,113 @@ "terrain": { "seaLevel": 4, "baseLevel": 6, - "relief": 3, + "relief": 2, "cell": 8, "surface": "grass", - "buildLevel": 7, - "buildLength": 50, - "buildWidth": 25, - "lakes": [ - { - "x": 55, - "y": 8, - "rx": 30, - "ry": 8, - "depth": 3 - } - ], + "buildLevel": 6, + "buildLength": 10, + "buildWidth": 13, + "lakes": [], "hills": [ { - "x": 25, - "y": 70, + "x": 20, + "y": 84, "radius": 9, "height": 3 } + ], + "shapes": [ + { + "mode": "lower", + "level": 1, + "rect": [1, 1, 78, 8] + }, + { + "mode": "lower", + "level": 1, + "band": [44, 40, 44, 1, 6] + }, + { + "mode": "lower", + "level": 2, + "ellipse": [44, 42, 19, 14] + }, + { + "mode": "raise", + "level": 6, + "band": [34, 58, 34, 40, 2] + }, + { + "mode": "raise", + "level": 6, + "band": [45, 58, 45, 44, 2] + }, + { + "mode": "raise", + "level": 6, + "band": [56, 58, 56, 40, 2] + }, + { + "mode": "raise", + "level": 7, + "band": [66, 60, 68, 22, 3] + } ] }, "land": { - "ownedMarginPercent": 16, - "saleMarginPercent": 2 + "parcels": [ + { + "kind": "rights", + "ellipse": [44, 40, 20, 15] + }, + { + "kind": "rights", + "rect": [30, 27, 62, 33] + }, + { + "kind": "land", + "band": [66, 60, 68, 22, 3] + }, + { + "kind": "land", + "band": [56, 58, 56, 40, 2] + }, + { + "kind": "land", + "rect": [8, 14, 22, 28] + }, + { + "kind": "owned", + "rect": [8, 30, 22, 62] + }, + { + "kind": "owned", + "band": [18, 61, 62, 61, 3] + }, + { + "kind": "owned", + "band": [34, 58, 34, 40, 2] + }, + { + "kind": "owned", + "band": [45, 58, 45, 44, 2] + }, + { + "kind": "none", + "band": [44, 26, 44, 1, 7] + } + ] }, "trees": { - "count": 90, - "groves": 5 + "count": 50, + "groves": 4, + "stands": [ + { + "density": 10, + "rocks": 25, + "rect": [8, 30, 22, 62] + } + ] }, "prebuilt": [ { From ae445af4a783c098a0081ab55621e1fce3c2ae10 Mon Sep 17 00:00:00 2001 From: "nori-sessions[bot]" <264258699+nori-sessions[bot]@users.noreply.github.com> Date: Sun, 1 Nov 2026 08:07:09 +0000 Subject: [PATCH 02/18] Scenario previews from the real park map; show terrain and challenge notes Co-authored-by: Nori --- .../bramblewood-hollow@1x.png | Bin 2033 -> 1735 bytes .../bramblewood-hollow@2x.png | Bin 2572 -> 2209 bytes public/scenario-previews/copper-ridge@1x.png | Bin 2464 -> 2689 bytes public/scenario-previews/copper-ridge@2x.png | Bin 3241 -> 3489 bytes public/scenario-previews/glacier-point@1x.png | Bin 2349 -> 2949 bytes public/scenario-previews/glacier-point@2x.png | Bin 3153 -> 3777 bytes public/scenario-previews/lantern-bay@1x.png | Bin 1088 -> 1099 bytes public/scenario-previews/lantern-bay@2x.png | Bin 1484 -> 1488 bytes public/scenario-previews/manifest.json | 17 ++++++++++----- public/scenario-previews/meadowbrook@1x.png | Bin 1572 -> 1455 bytes public/scenario-previews/meadowbrook@2x.png | Bin 2027 -> 1886 bytes .../scenario-previews/mossgrove-isle@1x.png | Bin 0 -> 991 bytes .../scenario-previews/mossgrove-isle@2x.png | Bin 0 -> 1342 bytes public/scenario-previews/open-grounds@1x.png | Bin 1252 -> 1359 bytes public/scenario-previews/open-grounds@2x.png | Bin 1748 -> 1937 bytes .../riverside-fairground@1x.png | Bin 1719 -> 1631 bytes .../riverside-fairground@2x.png | Bin 2338 -> 2197 bytes .../seaside-promenade@1x.png | Bin 1028 -> 1109 bytes .../seaside-promenade@2x.png | Bin 1426 -> 1524 bytes public/scenario-previews/starter@1x.png | Bin 766 -> 796 bytes public/scenario-previews/starter@2x.png | Bin 1066 -> 1089 bytes .../scenario-previews/thunderhead-mesa@1x.png | Bin 2285 -> 3321 bytes .../scenario-previews/thunderhead-mesa@2x.png | Bin 3058 -> 4215 bytes .../scenario-previews/tidewater-docks@1x.png | Bin 1404 -> 1420 bytes .../scenario-previews/tidewater-docks@2x.png | Bin 1865 -> 1853 bytes .../scenario/scenario-preview-assets.test.ts | 4 ++-- src/sim/scenario/scenario-preview.ts | 2 +- src/ui/title-screen.test.ts | 20 +++++++++++++++++- src/ui/title-screen.ts | 12 +++++++++++ src/ui/ui.css | 5 +++++ tools/scenario-previews/generate.ts | 4 ++-- 31 files changed, 53 insertions(+), 11 deletions(-) create mode 100644 public/scenario-previews/mossgrove-isle@1x.png create mode 100644 public/scenario-previews/mossgrove-isle@2x.png diff --git a/public/scenario-previews/bramblewood-hollow@1x.png b/public/scenario-previews/bramblewood-hollow@1x.png index ac0d13ab86b8eead8cd1522e28d81aba31fefce2..93fd1bfffeb6c40b565f2bef21dc1e931eaef4a9 100644 GIT binary patch delta 1699 zcmV;U23+~^562CVIDZCtNkl2j^#k#VQW})w zS8ugC{Pp^Rj(=`_GpQAog6j;3E+#lsVG@S|X%$#Dph)k0a@~~|=u?1j5q*;701g1H z+`QCE-UncG{n)XJDhdEzz$S4}g8-5)CE=X7_Fb!~0CDT!71bmmNuVJhe31l1v4sEt z1_}54cJFla>)lhW=03z`oGzUc@v*mBhvz`(-5>n)z(ycfcXlLh88zwj;4hw)n z3*xOd)Wd+}^^4yENBd;6)p`p*F=4m;&+5l-n=MiHuhyzMZ9BPw?xYPcbh<~SAIi#8ZQQXT|&|rY9)=RqB(*j6?)ChDYYcAc9N5LL)JKd1#+*2Axn7DRCV`Ez4bK-5CPN<2t|1Co%Q20$Fr=zt_7 z`kQ77Y6oQXq?c|%H334IBp`37F$f?I2~fONtTsS=JZ4osHJbMTl?*iq(C-KL&wn+w zi)99@UaHky{*nbG2dh&8@+J%-K;BwLbA?%?8UXQfd$S&%dqoRDXWm-oQb1$(q&+a% zX5LB;h8CoyTx-ZlXNDRQUdiJ26d-T?UrnK3);ektcILrji$kS0it}6+<&hTSrFxSDbK4dTF7XK6=>1@r7$_x~(X1ipWOo{bySO`7tmP~8SkOZ`E^RX)pkd{04ays5Hf`1=p;mC2A z1XTn`j#tRtN&(Te0A#@_g_RBRQQfr3(G(zUk{|J?)WrZO3n!CG)gbi+1Qh|o+G4)h z1wooB4rPLLS3rG~O?U85OsLKxI5JVj0d-LgJDD@-oFYKn&G>$@l0B_`_qPtc^LlB3 zXpMAcvurKfIHTrWbF&bTHh-%j7ch*qEqj@8w2dqwAZyx3Tj627iOl*UtFYevQAalO z()hD^8B`ZrbpUB@ra_V|KqmidfzoyxS&O}`4xabR402rQy&No$PS1<+&yraItJTmz zX>g*KlLcgL_$>y+FVqTYO(tfWSA2SI>^jRe#d&(BNo=vtCGv z6-Aj*YoHp&pv+tC0?7M~46T3}EAoPM$xl_tXVbCSibbtS7ZsI26UEK4Y+=(R@aT_L`!5k=7)kKzMWB_eLr$ t=lq#Zgt80*$b0xyfE@Vq)7Kk-{spR_sh3Sc(z5^n002ovPDHLkV1gAf4~qZ* delta 1999 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 diff --git a/public/scenario-previews/copper-ridge@1x.png b/public/scenario-previews/copper-ridge@1x.png index 09e1169df9f6d9d5f9b8bdac15ab141a50c6abb6..f96a1f3227da5e91de1826c1fb80ae12930722d8 100644 GIT binary patch delta 2660 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 yw(VqQRH5GqNcey8?<+$9 diff --git a/public/scenario-previews/glacier-point@1x.png b/public/scenario-previews/glacier-point@1x.png index 858c90dbbc64bfb3d92256b80fd68ab19632855c..06c5eefb460dd630f8a59fb886904ef3313076f7 100644 GIT binary patch delta 2922 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 U$lpxB0RR9107*qoM6N<$g1;A1%>V!Z delta 2318 zcmV+p3Gw!Y7p)SIIDZJ=NklhAn1Yp<*|FYa15 z@o3BTEuq46U)cG0qvv~s}`oE3GZu>B|Yzb*1*fZ@_+TmF6}vUDNLB=_LckE zwtS?~juR`Bt>+I{3DeSq_qE899_W$1kDBgN3?LE&O;38!8W8gWV7*T@fCvy00PST* z07T$w5is!D-KW1Xzx3b%pz+~5ss;qTRsyl}ezs zG)G23$TfMR+UL1v^+2%RBOHKa0PV#*MGbFNr2v$|D1QN9y@%x)s{xd{wx#LGo3p$K zis-po0eB#Io~r=>U%ZLbmapD+zf|n;)|mHMJ;q1vI(4y8ME$4&kRH@h=}G0G20=4E zuWWe*oN5kRA!q<#C?q9>UdtMVI~)Gj?diYK zYal%_4RZaj-yP^kOP}lRm3@<6uI_IH*Zy|xV1J|Ezkj16_?*I!Jj3FV)gHi&P6dWP zc;U%Lhb}$U>aEqMTfKetnO5|36umBY{ikP+cSQf5x(Dd!iKC5+ zMyFR!wSwOP0(b<9gGd3uB9qo%A^^)|b8aAt0?;5(K^n6LK#h+8!1xFN4S(k17wyk~ zTz`Lavj5y_BMu_hr*ZWIEER657}5Y}5HwFn8Q%(kLqOxh=UVOu<5T^45@|6|> zf}mc2{ROT6f|=O`AXVgW7?A)ZMFHT~OSzwmdH@GNJwO6Ljqd^=<$4JK{>%YL5K2Kv zhP49FuBFD;#OnYK0P6q_Kr()3EXWE#%769r=bu*hOg=pR!IUHb2!WUXn(^U(tpKF| zm99nOTSQwyDFD2ethFSk0B}ON3O7{;0DzRiOT56Ei)%c6OIDW_Y60HVwKzJ#qHi=eN-0q|xh0&vZUNxelZerfZOmu%fbLk3wF1rp;N$S# zWq2@XHUt3DXeiD7?m1yT*`X~o)ieYE+60YfTC!Q33tyyZztW{1iwppUxA~x(cZyO3 zP%;6Z`hOT>pLJV)R{aI=04djFxqok27e(gpaMYY zD!?!g&>##EK(6es0$|-wHBR4 zk@toh0GqdM7Q59T+TOJahNBk+z~6t}YW2^twNn7RJ3^)5i2nd=>KLCI^wrP5a%qtO zXdd9*c$gdu0svC3pEB&yvVTnj0Z_8*GYMeR%Nx_Vo)~xgXXjN70>Hf{cImcT6@ZrO zsgbuGKPPGg5CA~S_0-sFPv4!=kO7p|0aKOm#;pW^lIywQM*#k~7-ByF0MOiT$@L=u zJ&1`FK+_X$0g&8pG5iRi%o9`qH1}JKKV$%w9&rwW2*8v3hYG+tG=HC~50U_^#vdYp z$jC4wfM5W8LM8_QLN|{9Dgcy3h8Y0_4aU{X36B6C5CCHxPzWGuWyAkfXSWdM&DQC6Q64RpqyrFqaV?mKa5t?fD4fhEkwbvNagS`(q0NN78 znGMGAo${WY^O|r234h&T&%fu4Z{3uQyX|S32q1N;hc`@HFT>G4Ufw-<|JZv;mBx?Y zK|*+_n;Zb|u6UaJ@tz2vHbPhjK-h%LJ^gTb*W}%!?{suv<%vcb01E`k8%m?9JwaeCg~*lk3;kPxhT(*AX>72w%zyf`5BJD(6R5z&v(Q2>@-I z(iDKGN%1Cautc>~YQsoztPRr&%jH7SoF%OaPhU=HVTgGvCPXpZMU z=Zd2e&yb>bl>$fwaGe5xYd<3vW@&~m1<+Sh)e}Cg20(I~DhCj;G?9j`Oo@i0^e7jG zGFm)zrllWXg?}&w057UtoEvcjVeaKD?(I2gqa;|l6vizCfCR##Xrq^uucfj6tp_e> zA)8C!wg9}FFj5;h<^iDQ$dS@u{0qx89=4*iTYycvKs@KCh8t$(1>vnHkVOJXEho=u9i(dh?x z6P<HVRU~Rr@r4J0asaKOkp_+K0AYA6>!MctFh| zr%3>P9EKdJ$d*+pfQVCORR9(UQ9(Xx0YndVXzvzz%x@MzO*cF0p(C1^Q2=sF(0cGXc=YiQMx5P;)4$Rn6jD1W3s(6I>=<2`mzBSIH!LBg0t1GwhMRh00000Ne4wvM6N<$f{igYV*mgE diff --git a/public/scenario-previews/glacier-point@2x.png b/public/scenario-previews/glacier-point@2x.png index 3d519c6e3bb5c59b9397867f78c901d0a21cb472..7cdaaab9e98f312de425ab42dc4105e82b9d0ed3 100644 GIT binary patch literal 3777 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 Q4E+R7c5b%!Yyva>2Q{4}g8%>k literal 3153 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 QrT_o{07*qoM6N<$f`gvsZ2$lO diff --git a/public/scenario-previews/lantern-bay@2x.png b/public/scenario-previews/lantern-bay@2x.png index 8535ac2ad6dada3933c80ba7b39953730c64f863..7625570dfa6e99f98c0c739e9dbeddb58de4271c 100644 GIT binary patch literal 1488 zcmX9;X;4#15T5sv5E5Vw3Wky^;sMAJRt%sBgiApKNWcX-G{|!7Y62?(0>tGl9te~g zVGBgv6)lWL4gn!q!xf+e3l(BXltb{~PKlxd76E17!yhwKJ>Bz7f8F0q-hsfqdgKjc z0DzvqpAQ>d%dnxXh0X=N33lj0O7=UH0sw9b8&E?Q`xpR(9Dg6rP{H8LaN{upPk?+{ zb}mkv=BmQS|2j>Zcw_Oi54@gK$YeF`pUcOSOo&=+yoKkfGlK(on_5c4{o2|FDck7s z(Jtfo`1G`Nvm>7jw~p~XPFSYME)L|`6ojoz^mh3}J7r|L|^Aw;}pNzCds9?Axh3V`Pf0&n7^@lAT7 zcnl1>f9$#Q(obqXw$S?|r~qgy(x7hdU{FacqbL7ft=xLOsgkktLweepF0lsCKnH9^ z1jwI2b2h>C;S0T|jCDQ$cHkls)4~)t?W9bTR3djk;s%9Wt z7}cO2%3W&c>-+NGf}qAuGslxCI~OuGwRFm6W4x?!OV+JO!icpw_#-nbirrWLp zpck%1FT&=K*ZO+cx zM4q;%xprCzMD1GPspPb1b#Ysg_^b21ygyI6=?}m=R30P7#(;!2)sob^o|CZhXj_>1 zD!KmME+MVv0r^oYJq)xCJVe|oi{5O4%r8t%R{J@R?{OvIC`d5;EBS&Br=~FmOO+i9 zPPrNo(ISa95RINPHeyI9IG$5c5?8lLUi!R(g|X9xXdw>NEs*GQ`Di^i>efcr6kpU9YbC9bNaUYqXuS(Gy>NiHVsN)^Zs_3y$;<2)`+;W2KP6A^BUkQ`^s^E9RUJl=>$$c z2uO}98m&6UjoXL)F9aojdk&d$E{4^tc3Iq)&Vf-~uPa-YkuMb)r~^)B9~7uvQi&b4 z)9yzfps##_bRa#V*qU+>H@VAw?X{T_7AjG0p({<*?QW)AzR>Zi{rC;J8=xRn@G^0^ WiI?Z*@|uKx(ZJs~(5Kpqlk-3Pw?yjz literal 1484 zcmYjRX;c$e6n-;VKmtvGNRTy(LZDF;kSI$Dt56VAR76=!6%+&v$Rf)DN35u9Qcy&w zHb6z-V3b9WC28=eX{d8nw}Z} zK*P(^%@5uA*it2;HoN=yW^`K<<9RR+0NgmXp!=zQkpK|Vz1*DlB@N1lg^^TeUF73G ztfIt;Xzkrs$uiXryw;`l&Yqf@xQ{09Bx~1bsX{n&{HAcv*So^BYaeZ>I?p|NG%|Xv zR2(>!G&Vi;Y+7i&O5JlSwEO9vkv3sVOIfM+foH^?_npNxL6_r_V{NJ%?<`UPR0WR~ zo|EJ@&9~pS=o_1wcFL(IHPChooQ&sEa1^8!>U842KOgL5ri0YEGW7tYDz?oF0Smn8 z9^ZV~BJ0&qm(6y^2$&9rAkNqAHDLDU)CIk?YKTY&3E+y^xxurKzR7Y`>?$HKQ-)Jh zOLP6HZ{3c+#IpgsH4G^e4=lUrr+=vLmDyP@Hm@FY3IQ+$F~_NE+#SDoN56!($516H|xHRyd7a86k9BuJvY;4?m1kDTS;@GKs-HqDYyA1Zfj!?Nq!-}+`H0F%f zFF!0ao2eEz;OO85eo3M5sTK*ZFIddHlQPs3gdAZ?qT`E+ShE+|!!1759ca`L^g$wd zH7qB?ucm|_Fz+f-0mO-`z zCY2o$4=Bhsm}y_&dYQXs;a`2sUrmyyRRbYQN~oU)T$P#%MkWXVr;ODOsT#IQ7~fte}KO|r>s;Adyj zzgQKh^Xv7IU{UDG{2Q@S7ooQ$hT0&(^aGYF6W>34CLHFUj7e6A9HU_ReG+$IXp0EQ zT^~XLyff(|tQHSJiKaRmd@@j0cS=7K`|y*$0fZ8Wr(-tfl=nBR^3s8jtC&348em;V zlvIWOvCijz&tU5qBVc3RaTCl3WRZuKTm1oi&k;;^68H8ctfa})o?>88F!wJPS2e{_ z(4EsWRnsxNk^gx3jLIatmDUz#ibJ_>u2WMPs znlytJr0GoME3~+^#@`-sMsc&qe1m0*nqD@Vq97evC}W961DF8L{~O1UZaaKia>M86 z!-wVi**LUk?Lhw4NM0< zu(L?~sBw1%ONy87KGvp$u=~Hh;r+bFdfP#UQ^7I!s478v{k@H0CUJ;=f+`O5Mu?h+nmI$Wm>*X9S((|Qa7v7O z9}S_h#2hI(aTAL!mvu$h4>XNs<=*)6Me!j0t{|bf!@=uc9+w7kQt Q(BCuga`$x;xNtN61)xtxegFUf diff --git a/public/scenario-previews/manifest.json b/public/scenario-previews/manifest.json index 78d4e0b51..a39623437 100644 --- a/public/scenario-previews/manifest.json +++ b/public/scenario-previews/manifest.json @@ -1,5 +1,5 @@ { - "rendererVersion": 1, + "rendererVersion": 2, "scenarios": { "bramblewood-hollow": { "sourceHash": "eb0f4926a53fb8864702efeb662ad7794d3c4763c871dd7ea05b9e5438240daa", @@ -9,14 +9,14 @@ "height": 72 }, "copper-ridge": { - "sourceHash": "88dbd63ed7d4144bc1ba366ec50ea2a3fb53664e8866ba03837a95e4af3c9585", + "sourceHash": "7f475bc59ede013079af165f710cbd1954f0b4c30d39c619f20b7ca71fbdaf05", "oneX": "copper-ridge@1x.png", "twoX": "copper-ridge@2x.png", "width": 96, "height": 96 }, "glacier-point": { - "sourceHash": "3273b068b7294cc77735afe33d157316ef4d0cbb2a96b133e89dce6ef4b5fd73", + "sourceHash": "5863dba5fd44051e61a4ae01ae2ac4714c57e8f86993d0a1ce5fa883e1631677", "oneX": "glacier-point@1x.png", "twoX": "glacier-point@2x.png", "width": 96, @@ -36,6 +36,13 @@ "width": 72, "height": 72 }, + "mossgrove-isle": { + "sourceHash": "c11540903258e443e3661f9a782bcf603230694b39ea61329eab77a029e38178", + "oneX": "mossgrove-isle@1x.png", + "twoX": "mossgrove-isle@2x.png", + "width": 72, + "height": 72 + }, "open-grounds": { "sourceHash": "32e0313e90d14269e569d45813af079b25792e1ba85a4786119e7a05161746e5", "oneX": "open-grounds@1x.png", @@ -65,14 +72,14 @@ "height": 64 }, "thunderhead-mesa": { - "sourceHash": "ca675056243ba99b6d28eaf418ee6d36d4a16e5e7caa974a3cd081fc14321abd", + "sourceHash": "839255fdc885bf70c6cec9acef8cecbd2b91b6342247f559ff05feda9ce86732", "oneX": "thunderhead-mesa@1x.png", "twoX": "thunderhead-mesa@2x.png", "width": 96, "height": 96 }, "tidewater-docks": { - "sourceHash": "52274bddf82bfefdb4c379fac4eec68084fb111339a844dc73c6069343fc1c0d", + "sourceHash": "ea55308c76e78a0881755e82eac0c622fab371301d48715c2a5e4e6df882a0a7", "oneX": "tidewater-docks@1x.png", "twoX": "tidewater-docks@2x.png", "width": 80, diff --git a/public/scenario-previews/meadowbrook@1x.png b/public/scenario-previews/meadowbrook@1x.png index 89db5409248ae8e694a1b36b4fc539b89f633a02..5d188c88537d88ddd54c06ad81c9f454b11a7777 100644 GIT binary patch delta 1416 zcmV;31$X+S46h52Ie%eEL_t(|+U=Z6PZU8A$M@TK^u`s9F+TBRG@_y+YB-=#1Gu6A z6;V|18DfkQ!B>dJs~^Nq;Ki$FPh)D5+SE2x)zy!g9aawiFwCQO`Zv|p)ivGI+A+Gb z=(UcV-Bk>Y40b8B40`S1)4b?8@SB?OyjBwckD-R2 zwYvoS+%o$X5LTA{^@%If1jr@rQg?60eR|wJ`c%1Nk}MVFD$Q-X_a0?I8XV3vvBIEfgbSz&X)x&haTX#qJrf`+7{5@xeJW|J(#81{#!|A{P$r zK-_H+P)w`w$Sr6yMP zmKuMtrxgAV!gE~RUbt1X@3xDn*~#MC%+*qtrzc8T;h;tr2aDCW`%5cANRoqQ0pYOT z0?55s0)GUe6{b*pa5zA*a8Ll~=)*}75C<#^pvm<^9chqq0E&f!qJTKRlg)y#xBC8W zybBNq%3?)ORxbc?F&aD6umVE=L%VYh5C!D}Bw13`fI>Q<7N#S8BjgZ3^Go+k%}fGS z1t941IY8dQsud8%HWbi<=L<#q^H3>YGvlB@8Gjt4x&WC*^D%%hFhn2#3giN^T8|5< z4nXE~M<^f^IB94~k`NG7GzXv*NDwSiK;SN<6iF~3H_ZX*14|r~6A*=@iGu_C0T2X= zI5vz1WJz7p;Q&;G3c7Vfs>q*wg5s%IRIGz zS}Y6zNm)g2pqK)P8==y;@+<&$LYKjlyAVGedwt(6!s7X*XNdGk;&4Llo zhxLP|H#dC^NQ%ceALIh!tSSqj*a2x(fFw(@zWb{bP_H1x0`fr;0fh`TwmKjUQg%R1 z^g)#a@}&Z{N-vfjkTqB0zL{uJY@|ifNq|C-u<-J&A0oBoq zX-lhu0Qn|-Zv!#{%H^>C%nZ~LD1S=+Cp(}Jt-U{33KHm&z=E{nsMM9w*(@l>q7?V3 zY1sk*Bu%{uSoENP0-Aa4a7lFaxqoUWftY{tn#+K)#$*45XN) z<57T8eG_fx+_G%Wf-K9vtt*;NG0px=eQXvjdtOfbH`bsS*p=S*SLJ!;p+KPXD^MFvcf?PPxlv#FSnOggpgbg zIvEhHJ{lkpEii@RgChZog@Xb>`|poC0nyhifWY4Xpz-Bhl{82>0L8*VQ9#`9WVIk@ ztpL#1SEF5kBv2MBg3R>-kQBi3t_Cz<|S`UZR1R!5IqXA*`3{D!Vl1m5(3Yr5@3M2>?DInTkbPbW10r4AQ_yC)E zEq@Nm35Y_{B*B620T2xoqXAh4pHR>pfPzpV7S<>#(W|5JJiU$O6z}VE~B3v3~@LU4TNzodJ;4LvI?8Mc@uJIOZ{FoF1{v zeZklc0+Jy0O1$9!!NaspZ=-@|HTWNJK)r^fjSj#dTqq!Hy!!T?7$`s(0D=`sGZy~= zv2kW;N=K_=ZK-CB0YXc%IO#U|APG`q7G#No+6bvpKnSTVfHVt6K)e;RKuQ7xf`6yd zCP1!u%mPT72G0U0wnJJMAeSZe%!0TxTuXp_kSaj2%U{+5APrJ>KyCCvwFAn%fP8U6n>wo+ zoNRzX`zrqdtua8_+?)i+x5~B)kbh+f-g*OMj-;(?6fJ;aA${9DQ2hM9RLb=`DiK)7No29UZ0&o?*kO4J7^1`@R-u2dgnbbu=fPxoLNqsQ{0Tz}6(66hTY6}!Y{7)7@xPP@ERD3H! z4oTY?xUyJK%D(iR8*)=O_i5u=t_^jjRjy3}vTm-$MHRTPLR(-FGUyi!DCAUvTw5un z{p-GMQn5fn)iXe;Cn8w#mmLs~q%F%|a`_;-Zz2{_%yAX11?0;h|2@UZw4Kqube)Sh ztqZ7fA0rWKMV79S@0<>G8Fp}60Hsz5Un^xjw<8On5JL7_4Z|uxF^f2xt}ZDjS4rEywT7S;Ky?*73V+v7UNbzX)YXG00000NkvXXu0mjfzmc5P diff --git a/public/scenario-previews/meadowbrook@2x.png b/public/scenario-previews/meadowbrook@2x.png index 048835be3c1e6157c2e16d9774c14ff7f9c19480..dc0c9604b4d0aac8b40ef52a1297ca539cf92a87 100644 GIT binary patch delta 1850 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 Q1+d|_BVhYI#=&!c0YHgyuK)l5 diff --git a/public/scenario-previews/mossgrove-isle@1x.png b/public/scenario-previews/mossgrove-isle@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..e0545b4b6e8bac9ca9a07c6959d3aaa1718bd880 GIT binary patch literal 991 zcmV<510ei~P)Q{K@b4o`8OWD<>(`bNJ121kRYPy#e?9%S2RI_ z#1}{q!HWkENkH)T_#eFb6CyQGOKojccUPuoy0cw}Vm6z}GV@VY{n$yj^5OTXhaR0H zIFJK5(7;%~cS((AfkG%2tgaQDjr*4uA_b{iW*iCS!lR2(tfd9gZ~*1xWW5h~O(TZX zwSa?xKpZNB)U}Aiq2Qx_&AjOmK*ZSY%QHmFDpNpYkX-L)0 zq$L=DkiwEdaDEJ`>a`fZp%Bc|AJ_Ycq3pfiJ>A^i?2l4*N#$4NY99LuUU&$FhlaCt z_x3E{XMlo8L8@v$i1&+Bn3N3CpeT}c)SGlik>b35w=;_niUyRLQM4ynN4rUZBpm1! z82g|1`=IZIvPZ+Y_3-Kf(#;1~=Aa<3%u~u|QXr0lFc5Igv!6Hmz~85!#7YkTmX^OMzPe9t=bGiAR2rYjWBeANO973YSNkjb5?8&kg<2WhX8=;katS`l8 z(79LigMoN2vLIRJLMb>odr$WLAPFdCqb!s)mZilQEBWj@idHDg{3iyJYvw%ap0tD{ z?fS)#wB{`BagT{J%C{P^F9NNNTx!7hnt%CtuAXuo6KJgc=OPbrYTuLby=g7rJgJn% zhAHw0-cX>aP>MdpIRvPQC+%SZw|%%{0)q2%P5jO^(BD5t4&*=%ln;of282(ba-dufKsk^DIgkUT zY^YJ7DL2F%$blTlfg~Vr(mskgkOO&>t~i4n$VcaTa()7Bes~zW`yzt<^!<3=AwE zJY5_^DsH{KdpavPP~_OheZ9`}RsW32dIIQMS7dzG3F7E7=2;?y^oonNM z`Xr@V@6)cSK^_c1^$o>#QWMy<#D#!56(0O3un8!d!^H_yc|nWGt5xXs4mOaP3epo; z4>V2UI?=?U05aB2Wqsh=y?&g`K*^AMz5cQuEI`(lo)fKAU%q;El)l-!F8KHFr%qkE zky28@k_=1%;sHsGPnKzW$Sruhc&)&+Vg?Qe(}hQ#ef+*!@zeKT7G~$~+j)CwtqJka z$z&C1_{HGnaAa91=j6}Rn;vbGV_;n2Z4g#;(B@}huHMpsZ};|d&OEnFu}CKRSCaJo zJGXcg7<83)Rj<{r&=b*LS&(;s?^c6P`x+))X*%*v4`})6NvWn*+083M4+S|!PKffK z+EdqU4K!41PWbyWaW!!-tp&GK&%JuKeV!B}$VW`>yN+7@p8x%MQmx+hlBI`s{(Ml> z!T$2tUvEV*jm~#ISF-*v0Yfv2`S@3=G0v<_R*{4!c4!4d(BwopZYT@!Fj)PM(W# z*xGQEPy2`yC>}#L**NKog@~0sK`4!+vA?ly?rLj7+Dr1 zGH=pbVzOxImkf`%$Cg{A?@PI@eyRjY4Mk=_n|6J?rn2hl-02YoQH)up8zicwg+YFq zbLZzLqa(9VeNYQ6{qkgGTX444;%`&fRe2m3UI|SQ&DUJbmaMC=`9Xwz#9H|)R{rlE z)nyxnu2To;ofJL&Yim~N?{k~jxuWa$PmSdVhC!%qs@#foj7R4!|5AO_Z&6w7E}+W7 zJJ%i`T)DN<>7DM`rFZ{cQe9KK|EQz`gOr)V`sn*yL90_`w?6o?^)??c46CcBM>uRX zn{rAwbgkG~{-@K@7#K6|MBmxUb~Wp#o92vtx{<)32;&aWT5@CUBQM3Jd@{%KoNYoZ zfQfqtV6Z8F;3&ncynD8m}LS^HEq55FwaBVq3GW}-5;P> zG;wiA-{0>9%t4@R1JVFxnle=W+`L^*=yxSp;uB*eFxR&Eq+b@$Of1rQU;P}E5Lp&{ zZrH=Yz&(NO5i3~pqsF7tHiR-Wp_{hcSFS;v+ry3@m{m}$f!MepF+U)cQR+2YAd(A^ znNd6)jV>UqKB>SU0Lp-E2iwA<0tyDEfZIZBV7|#BMogTe~DWM4fXJY}z literal 0 HcmV?d00001 diff --git a/public/scenario-previews/open-grounds@1x.png b/public/scenario-previews/open-grounds@1x.png index cca594ce44e962a9f1049d0dcc40d6e80c4e452a..6c75e3dd31c53593a14ceffbc34e759756d2fb45 100644 GIT binary patch delta 1320 zcmV+@1=srI3C{|UIDZ8JNkl4gqW+aFb3)!o%IeJB!UcV}z=zwYYk&l=8cpC41~ z#`eXvrGB1j*Y95ln)a`xpDEurq<-1m!xw9-A^z=8i>PV;On)ok8}_?M0BV(f$pEl6 zNOA@$QYrw65C&}3ikV9cQ#36C<$e?ZRO5~e>;OWd+0L~HfV)Oz0bo0r`Z`o>S6C_q zfC?cy0H4@qb>%Mo9e~F{`~MuFXOaLoO1kB?@m}!;0SlFaoe&ZxVp-2}oiH3Wc4T07$zeq5XiC8(rJfBtCTO z6@PR!M)4XTeX<@3fNMES6#$FXrZ{U3Kx!jA6#&&kP-;J*WdIzFa0k!K#bwM2fGXU3a#W@4OLii5= z_DoIJw$TotLJgQY0QEb>0f64L*8m{^Tz@d;2Ecwj%b9U=9gH)zfo@jMa$?rp0Z>lv z9dg9A4gh|B^?;4_9RP0o7At^W1Jbtfq5)8k{F)K~*OEpG1TX-~0Z6fuBozQ;g&p-s zee{G(2LJ;Ag^=as+zuf9SO@S~5zxcA)#9Z&1Hf)-M;+GD0q}2XN1v7w3qd6T{C_$9 zKD`>ik)5amU;+S54blNHHo`5{fWLbi9YC(L_aR44su}=!pQHqH*#K}ufOG&A04a$X zFd3h+0pR?xvjrd}?@DU`*g_CzdJ?J-TmU3NC{hC?0g#sQRV;we@J1>CNm)}x14zAJ z2tbaU$mZ&YDru~80HEB@1t2xFaeu9gWe0#=_kx8$xsL+C^@LTcCM2h^stG`Uwlsj) zn%FD=q@^n{eN6?B+6K77P&NQka>j(5rvjir%T@zg%HLiCK=x#wlJfVq1OU?M0;jX( zfWS4ZQ3C*0NYh`;Fa&s~ywpU>(g4^6k8M((YZ)H26hUp0Z2%XD63)*a03p}e5*7}UB63Bz5t8>Ow|UAE_@62O)CTOW6#!UX~9giE)zrIW7{dGF2V;m&*? z6zc!j5Fh|f9bT#A+lgO&`!gt95c;@509@}nsM~$Jrm(DidTCthbLdI4%@ri`2etzZvt>e@Fm{_c(i{d4}kiI z3Vs+VB!TJL-N%fT~h$ATU2fUp(S5x0CD0&O1}VPF6~nQm*MHUDa8P4iIBpf<_|C@fz(KJHvsxp)qlKYHGhTxK)ztoJ%H;OL9a=LHj`2V zkO1t@1t24WUGfEhai?1afITNL1;Bl>K05%_s)#Xw*FLzmKa1i29D00AvJ+*&0LuI;sJGcUM^fKwt4m22g9*uds9l`x;Qg_EDIn zSO7A-3ZDuk`xYkLBFAn{AOMUn9$pwB7bz< z2SB$~v;oYHIkuCo8X&Zy3+gHPSYt!zZ%yPnBtbEZ;Cr4Z z3Xr2FKw+uIaYD|o2mq(%h;k$o<278!05~8}Po`j;7b!q#1g-$)xh(-GL*3?<2=3RV akMj?Ju2ZSIAP+YH0000=j@D diff --git a/public/scenario-previews/open-grounds@2x.png b/public/scenario-previews/open-grounds@2x.png index 2627e7001bb155549e7aca9eec803e0356c2aa3a..484a0d3e77c2ab1565ce5fcf2d481919296b40a2 100644 GIT binary patch literal 1937 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 diff --git a/public/scenario-previews/riverside-fairground@2x.png b/public/scenario-previews/riverside-fairground@2x.png index 105152430d5972d813c41b1ad1851f66726adb96..6a949ad44d9d4f5cf2761a8ea7d0cbf19801a9f9 100644 GIT binary patch literal 2197 zcmX9<3s@3q7oK4RFF<6bnfmKb`Hh) zRWrM|Y*A5ZowqvDVTx(sqWO=b8EDnK|b@?|I)d-yDqD7(uji zu>$~rxIS_%8(HP(X@f(qmlZ?F$YLvsOvnZRXcRrcmI8JL0N6yVU%Mu5*RyebmoO>N zt@E9l7?rE9Zf4s2BqREIM?cjr;6zgF@KvQYF>woS^aPYIv;rP(XY=xoj-q=0Q>K_g6)_;~irJu|C zu#g;o1{&-niuS? z?!QT21Q3jkK!#E#UX)2WuK|u%O2Gl@R;rvWmd^F0Lloj77%(}!EuZL*V?M7-7%04y zWquS}-PJcK)9D8}UBomb>y56kiBZjcs1Bkp_oKxXDl!W^vfCx*Ev6&B>InxI08;wF z+g|!E;ye7M0n3tu93sceZ9u0fMFu#-MVP*FS{mHSWrumUE|Ukp-gl{M?QzGCV1-o*S{a}hYSgq3_yj^lCj zj`fO}6u$TTmJ^*lD4-*B=$tq>Y^L3G}i z^^L1zX8s;@f@Ta#uEzV7C-OFfI^>yJk0F=FQIX#Mwuk*ySrN0)U;l=bkb| zo4EAEw7ZY>TT%EZ+HmQq!#^ix^{!SiRT&E`oZC$);xf?UZsKsS`u#Y#sWJ!nx3lmys9m}h zM$Npb9&ScHG*<9Q65cKO6)iR$$GmkXSCVhdYda%~UV=d)!`8v6zU0zU3zf32FhnAX zelvu;AsF8aC4*jfNJNx`KO%o>=4&f7WgDEo#Q{(R%R!XCHLThghMI#wlu=FAMy2U@ z&7?El1EqdMEIn#Jer>1x+S&c6(*)yVDP#%lUX|qpk3h6vT>lysT5t(Q0lwoF4lPz5 z1hl(kqnaTZgDhKAlnujMLOd<0q}7rl0cit;nA=R+4f=~!G6#6ynu?+xG8!I0@eQmg zyIO@i@ll?MCZ=vqOur;b^=gZny?$;lZ}%0+3v-MJeFK;jRW|x$A&mcJarI2-XG?7{ zIELR0<$MLv(1}$Z*h2ui|3@Wm{(OQcFU6yeh7p+!1WU z?zwjQ4TOr|PUgpZld(aq_VhZ(XNZDS_W=Kzv?`gnsQoD`dWVAOiG~SZ*+W1Lb_{PB z2Qlbox7mws?7>D`CQn%cx2Dxt9J`P4Y5*7^b+L#wpbp|Y&2&SWoF6xh-B{)#Z#Yib z8O%Xj4mQ?c1pDqspKKB(iHojdkP_5{kSdITX>ydSdNnB;;- z5p4LgM|2|6^wQWz+M;V67qULRRv((E=y%c=ojL8d^-ZTevd<$#Fvup%%$fT zjUT(*!@^|F<84G}LF~I(n+MgscMebNb#KI;N^O_0{s#6{bV0{SNE6PfQZny`vqlb5APF4RgS zE1r$sOA3hug^tMH7)FKJm7mQ&Gy}A<%J8!J1t2BRO1pdq8tyHAP*ulB;HEb8YtH7d z{7%~;dyDO^w3%mJX;~1>HM3_<<=#<9OuucY}ZWH2EJpcCW`c zJaK>5?djS3FY!dnN39@f7H!+XGp|~R7^=j>pMjSE{Ic-ymOubG)_=8eZ6lMv_a7U* BshR)) literal 2338 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 diff --git a/public/scenario-previews/seaside-promenade@1x.png b/public/scenario-previews/seaside-promenade@1x.png index f714d043542e6cf3090378e94c2b3d9515f3b88d..6f16045e06de27fcd3df95004b146b369cc0c11c 100644 GIT binary patch delta 1068 zcmV+{1k?M32-OIXIDZ5ONklsND#AO{N9DI#K_b~a*VC8wQ@jjgrS%3F9tE}O6SCNIfkQ#?*xCwcSR%;Zzmv5n*N z8e;3pNpEn5~4P$wds3zc8C|5ZoKvyE%o03K>0_b{o z_#nA>(uk=5edVwLsW+aoEKbLg0GPu_U0a%v`e; zZYQd6K8O`_Zhy9x8I0tk8w9kqFiLA_0gyWSSODS*MJ%BHccgm0R6~s7fT4l`?fd)n zAxZ%L{BUlFVt~|lfC>2R<0WtW_NCFr$a16D;4oEDd1112(j-vxM1PJ+00?@ps zG$0kOD4=b;w`z|t{KU~qG@x(5yh?x=IDQTS#!S{z0)K|eij8c5`b;Etc}W5=6&$5* zQ9#Oa(U_Z%f{V#P43N6w%LUAZ=gMQ!fVuH(xrhLA_8T}IMhEPG=>cmQ-xYfYhR(O( z=QhBY8~gQjOFUeFS$bg|(6|540WE+C6FM?x`z-d+Dg_ujkfvOnwP9@KZB>+u~8xcTte{Oya&N0M{RLrVa< z^1y)H;T~eo93};Xim`Gt$uI9VhPb(XqX;0>tAFPKVdjbVL7j<20s5YMy;2A>QHZts zuNP4g5OaXAC+lz$ws>J5PKlXE@P+YBHzY=E3{ngHasSQ}t% zxpu$~*a59eM);rg03aTGAG%#lNguc8 zYC)_SP~T7*HkELDt``2!sfbIDZ4SNkl=aQr zJ#YPL4iV%);W|ZBEY!|Mt`ZATI~yBYYpaoG^<9!|l1V0SGMP+@hudS_$(x_^kx6EC za(UxK(>0qHk7XV1nswWoj14fPZY$vZ{d?Y-J-x%0L#u~bw||Fl*DiiOJHQz6?St(v zQT<#6^yrK3&o2P!_#Qi;Z3`k2HQzp5$}&j+UG~5V7%-hx0XqWH1)>7}f8l$T%MlQL7{neZ4pDLd z^o8pcP#xpdL)a0}G)S(1Er4xz8Qg$v+j317fG)RbT!36~K5a(@biL0F1&jsfQbROA zpV^NPz*KmqItC4x8c$bC6hPnkHx)4T#i9aMz-e~ly?@@$fnBE13DBiuKMppd#{`(< zDqH~r0J|>Y0MPZ&>I=|yAnns{T8yiJ7Cd_3Qv6A;B|!Db1fQUYoB>^KSKSdoUmxUc39KdHLjmRGjHPv=2a29Te1#KKOo< zisdSdh7sL-;K$dii(K8h(hDHk73)CMI#IhTAnPG4Hi{zDLXnl*&*$kAkZM45HKO*e z!#9?5;H|x#=JTu55}2A?0M(#o)Q&zR1w?~lY=1=(;Emb!q=0Cz4UnStCmNs++K>QE zm~4Pu;f4t41L*`90yktp719J~{Gv_hURMgBZErj^J*fxef-42kv^N3}kpQ{zN&-|7 zVI~2_z$*<+AkJruQkS0SOUib3nX6Vl~zUknnN^M96It z6MrxC5C-6%pW92x0gw>02Q;OxbKnwS>_$QXbGwMBsenTR^vUmQE8d?e4)EFIwdTd% z`T6vDs-QizTLj?Q?cL_w>|yet-C_XyN)dpirvg^M3OH=Q*tc>eC&|6=C;%&Bz;ssZ z3DpuKO{m76(k~HDn$pL@NX$j067i%(B~x0Si?ys-BA&FYiN#^O5Fc6NTv#s!PQ-)N zVqu-WsYIgUKfXWqD>U_AG$AML|K>n%ijcICF+qxbw&5Xv0UQ15IpsVO`~Uy|07*qo IM6N<$g0;BR3;+NC diff --git a/public/scenario-previews/seaside-promenade@2x.png b/public/scenario-previews/seaside-promenade@2x.png index 0559c2580d63394d19756f56bbc5a082ac73116b..de249e8238ccba56c42fc5073a1ce3bcfa2314ff 100644 GIT binary patch literal 1524 zcmX|B3p7-D82|1(3^N|HB;+y1IZ9c1BsxSFvm0i^k)*R^QY)F6lJP1-cT1_WJ#5%@ zTCW~R3cFED$!*)Bv#cqS?i|F1sIez`6si5+*|U4k`QPvSzwdv4-|zmu-@PZoLN*$3 zmvI5WASh52j$%2zbal}EyRO|%DCi{xZc_j-U(yR}%nX+Tuq%T^ei0dzrr$?u>bE5K zjnYzlYq~eFY75^LGc6=a?6{ALYEEq8`!TrV`gU>W(>&t7u}|E+bEi~px?{+E&A|S# ztg(*u_gjB`G4f~e;z&q*dRp30`_!YX1wu|9cO19P&rv%G29@oJO7<}RxH2bq` z0Sh#A%RK1pP(j^nyft1xz0${lQP0k(z$n|q8c)EYJn^Sz<|!_pSDm6<=d&gW5O~O-32lG^h4L!Re4KHB?cWLq8+?ti1PVZH03n@QH3l zO3O<7=~Io26!~tccu^dC9BkngIJkO8Pmswx+%n$~7-5L5(EX`O2k+Nz&2R-Tw+G~{ z8`btz)aqd-LM=9y$d0h7s;y#0H;=5V>*_E7OqV7Y7FGm?Dyw4hF4m031`jp}gd9G9s5qsIKOx-_R< z`u4FiQe!EpVpoF9q})RBUI5r-OUV_>8Y$acUE8DWWLz!}%AV-VY=El<(Y4t$Q+=#R zswk;8%<)L7o&W@^;z%Z);>ApvLFqmpK+R`$>r*poQ)z&gjQXCx*uf=||9Bw)mZSx? zxtY%8c6aPCN34vAJ4TTf>KwJH!eZwdOqEUih=$k`0V725JdW(p>B^^TIgd z)PvQ}o@UffiUtc+vbxo@JL>lml(*YjJVeyS)=o|9ZWj(2{rlK0Nm2kxrbfjQKPTUw{h zv|vUsdfJf;*Jwe=ses##cq09!@ClZ-u15o8x!$x;Q~g$UFw)qR>e|S(g|*O=z1bL= z91Z{Hbd1TegJ;$}lt58v`fs!s5E`btz=k7&%Bw$hc9(IUpx?$8U|ksG+d*~yVBSL4 zJuZ?V2s;;>$Nqs5#34z@px+B;zI}pBcnRc!?^^;`606&;p=gZA;2ZiJ17ZH#w~Mxj c$O`s5OaJt$=;0+kCjnhSUxbKi{UwM00m9)jx&QzG literal 1426 zcmX9;Yfuws6up}VfnXvvDv^c+OR=cXV5#y5#Rx$_YNl&2CvsX#%nyXlYb-rbq|oqO*&XZKu4kS~L7 zMF#+ezn^G7o)yF~HNj(k=MhIdnMwV=N(La069=iy+8+-<75R&Hg=O>^1~mCx9}f2V zoy*mSSxXDjQqEC2;TD%Mi&3ha~hJ=I!Rj6I{OsMm- zI)3NmRQpu8;mq0E80qo8wI6EW-vp zMtV26qVjQH8D8F!_59xVF}00N6>}##HJ&Jt#LifFQI_?Mm5=5$T>RZs@&yE_+8({< z3E>r~aLSWhmxLzMY|vD4bQ~JbXB%s{5>?LR)dTi;8w<<>t2c@6Cn2UbDBNBx<>%!A z#X<=E%Pd4l6cC~MFnavZ^IprBOZBSK5(?hQeZx@rEX1Gcb@u=y#Vf82;@vK;!fPGO zq*M6?-w14@Vk#;H$Fj_Xa0hYPl=<>Bt+=$wJ>nOAW41qwgv0jeC^QAHsXim5DSN(X zHwEv16~u9@Rrmv`P7~;aCwoYyDU3tBLR{y4{eijlDKVDr-X_=dH3-^FB>_e;%`+IvLzLk`YbzcirGpe^s zm7@eIhb&b`1y@m}@iVO*G-3*0G%C*}g+KkuXzmwyzgpsL6yON@_5Z-nyr!d zr)24PLyJnZxFXNC#+9QKW=Y=aT14Q=kW}Uuw5p?+VqO>^RpyeZQ(7P`eD^{myzn4!V)YBKgTC3pd|jr~WGkHA|oF=hFmmi!nui41X77mgLqi)n;R zOmrI-9s0><)P;`M{V`Eg_6xyUNu+)ea9-`OD@9JwM&g*Wa5|z{9JCFJ%|AvVkvteV z2+=eN?_mwRZ`@^v!VW}g2y{eKk>ZBf>>=H34DJyV+zp7>605mB3T(twB8T`q+MvI7 z#O91M&NoZ4bp||Q%btWzpE^oxF*uSRoL);xibeIFOJO~wO}d<_nw_P$Q_;=MQWN|; zgA06-ijlAx-RuG7S2D>Km^<8dSJb9?kp^>js#nvo#~TSlIFdR2&zSeYR5AcjyoY^Y zeb&w^9zP=x|#_Q`#_p$na(<3iQK!$*fPSb z>>h$Bjeot)?qCtqiOcSOnH%?HAvX@f*1^wDx#1P9yl_)RIF-Gcd5O;%xZAJ&i+oGl zO1^bpo5K||6gQ#JYj1i`_sP>^wzWCek_$5TXpo8q7_}J{-bkW6l%ayPT=XVs&{lcA Vl9`q1GlBnP!QUrHr1p}0`ycJ-J#zp6 diff --git a/public/scenario-previews/starter@1x.png b/public/scenario-previews/starter@1x.png index 8bc6c4bea8d955549b997ccc357bf315d2df809a..ae1f76f5357562e4ce9fb465ac272a8bd9ad9a2f 100644 GIT binary patch delta 751 zcmVkQbcJ5y{MPs2lOC< zQa=k)3xZG-LGXEe2d_RtWfoG>G|A57V|SD0@Ta9|vYFpbCX;M7TWBwitJFqwNh{m> zMQvqO1K8}HYGqTOFIUx%8UUt^=m1c!pP3L1S#twGWml~MxPQ9-+z)}$0oX)n*LS~E z0Ini^Rd;^^po|N-@(5kKCVk2vMJ&U3U&G8+GXPv9CsnC&^DUKA4+zO{42a+XV2xKn z2pRy@co_r|09hy6x659HY1=CR>`KeEQP?(2jTa%*)&qRq{RAKZa10{|x@@ct0Gus`#N-E)j@Ai))pD4+&(6vY`zw`+0TBC72B6xkDB9F` zAFYp%UREm+12B49BRvX3?+IcXs2YH^2gCrtDhAj#5FG%j3ndRo01|)%AOQ#j0P1`| z0uU(x^a+tr0W>ckv_gA8Xo=A0V0X&Mt^2bXi6Ei@aDQ@soCDao>QA)&bTK8qOa>un z0HCj7D>rWM`gx*OZ;*@sjfYU181Vb^VFjSm?c@MN!$t8BL@x*)0Q7-3e*bPbB_09* zU;(ob0CsDv4gkPF_+&;OJig}QApih~2`B)R9by{*f8B<4EMNdc<9P_o3jhF{6`TQ3 z3HA$%1b-fY`Jd_s23dPq(ZWIZT~&?|#RF6ly#SjCvHI{##K;3&$Q1w{0yY)a z0-zq0@(BRbKEKeBEri6y5MS2`0Lq(N6aZAfMQF=mS)D=vu3lY}{Z9p;%%k=w51>SR z>RVg@!1c*;>|t-CAc*NCSs}EK@f^n5PTlr!K;r@$wHPiW;dB6vzblz@E6_MZ047l$z*nGjrFJXg)6tTkcJ$&A?6dr)73IH_#MJLV51Aj09Kv&cE>YI#Lc>rYq zMdX9Z15^M)m#?aMn9iww^`#U^53mKT`d*gdIuKEWfT{5+2+jb8uS@7+E1vZ?)OZ;J z7=Y}4Y!a>Oc@(jG>HY^5fJux(0hkzNI)<(BA_OlXfaL*Lt6u@A0C)!ABd&{v;M^1B z1BCPd^j&~@2!Gf@@LmXo1^_9DWG{9qgm^_p0RY-zNLLI|15kKB;BB}(-s>#{lMVn| zz`RBD0$~4nF^Eh6=sY_*0MH(T5rDiw%jyCD0NAvjq5`1n!(~B<4#2b|!3uz{j!;wp z#G=785k{K?O+l0aK;C;onI51so_{t~IY0%ZEC5t<*MA;|%a#P!&+l@jvd0(z4-ZjP z0DSbfQX^MykChTZSbKmfKZFKwcyf>c*u3baT6;L1kocMG4OWGa2qH89rq4k$F>d?v zDOI!EPb6LwA!tLOs5;>1d*lS5-DxKPWW!~N5JWEk1CXy%0PsF)Oc=j&GnkMFfdSw- z0o)YD*nb9n0bmAhJf5XS@7}*85+N`EEGKXPBo0Hrow{=_-~eRfMF`vrya14sU`Vm} z=KweabO2PujNscI&jE#p00jVi3xp;?r=}>@t8|cY`F1AO0FZ4E{A5V=yKOTS%L}{} zLKI(|)Oi7<6!!LPkP-ywVaOT)v~3mwgi20bVM^UY#%N!chZ;@+lF1xE$6?chk?8~| zd6M(1vc8OgtQrb{7~|UnT98t>)FDvj)z9q;PqY32l4LNT23$Ui00000NkvXXu0mjf D)*Lzd diff --git a/public/scenario-previews/starter@2x.png b/public/scenario-previews/starter@2x.png index 025d9d61bc4e6affa6d8e853be7dd1bdcae40927..bf46d0ea713e69219e9f03fc9592f40a4affb302 100644 GIT binary patch literal 1089 zcmZ8gdrXs86h9wrp-`Y5Esv?#B06C5G9#1C3_ch*C{P)&rNfTt9}+-X7!pt(@sshG z5DU`=hlp(>$Ox#g@i|L*6gO<0V`YRPGCRmR9txBoSwVub`|-!J>?Ze~-~F9?Zhq&U zbI&J=K5%l_;Q#AZk9Mt;d_>n@XxC9JUXy~>id+?w6!YTvTy)pciCDZSz=TAy0e z5HHGmKBrv|c(bqR=fBMFU5ZanH{bhXXux}J!`jj;&Iu5)`5b;Y+phc&19;|- z<)>eBeq@6%s9NQ<707~0FITbm}&BS+sKV&rbjJX1)5 zDv*YJKDX6G{EB^jd0T}m1n;y(^bIF!I}&M68GL)C(EkQ5g|Rd~`(O47aI}OS+Tsat zM>!DZun(XI#GH%nx;1l?U%$Nfh4n#4IZg$9W3Rj3%5G&6zX!>G8NSIjj^AI?XgHKh z40W5KkDK;*7S7G+PkmQ>y4PiD`Go*^9BIbcwc9z#9k9q>Jn|Z-o!LWnUMW<4L2OfJ zo?ckj=7`4c+eN@#ZamVl1D2`|W7Auo*EuVcCVBtbt5snMhfX+hQGq-`v)k(=W7;@4 z%Ud|EW(met!k98Y4p>qSpaya$CJg48B=3Fr!t#)%%5h5qfvBNWQWO@V3CY9h#AXK> zu6}t*o?De^2~J$tOUXwK_@oA(atN;sCZ+! zOZiB6%Z1aJ=r@wa`BU~;8W+VY{4lclZ3tsd) rEe^UXO$dNLW(dyC>^YOkgKTV*X4)0#s=PCQj&j9Di=u8t9xM9?b(esfNKHAD?EnCHkeo*A(3rBfY_1&{jZu< z*4F*wim;Vg<_xhG6~sDWqx?r5NR0AGWmsD*n<1=#qf=-_9{ajw*(I0nzWeU(yZim_ zXT}8v9wT?8CW&)p_C@Dt`L;d5!ybz^UFvM&GwkLQx$otRh3*dDmr+UC?gwXW3VyJO z?~Ah>E8vL*;V#zgjM>?jYfe2rwAOyrd#xtIa3{6wjjzqx+cokgXJ>a1xGdMNc)Lt( z_x8?8xkg5z23ccyle*kWvIH;U1C2CR?%C;ojMrgCen$cV3kb8{ z@vn?M2gV|S-_}BL5bInP!yh4^`y&Z|ivc&G)y}>rR08oTW-GNG4Bc1HgV=crU`3J; z>?1zl0r-y()RpW2fM{+mmzeGOVgJadJOELMXsS*V0BW%C9JS2QzufxdueMUgJE?%i zF&-G|q{xA6%)44R`cKJVp{mR?v`cywI`Mp{-lO^_FeXzhcX%XET?RSt(nbt?zfSF4T` zbKZmOP~_DXwb%|m+D{uZ#`LK%>2yP3$`%FPrD_sj?(YF!ppT_T$d^VR_1$t< z2RWh(h~>c?gvlJ>vE0(P8-3f!3_oBcr@`c5aSIois?V)bvLCj!mb?gse}_Z9=!2Z>ce+HUoX`IzRFM&o`9e*~pTLj&tO9Yp zNS(~jyyQ*Xjh2iK?B;8+D%6ZN^*e$Fu#3_~>s!s~F3pA;Wgv;$go=p4hKs`!$57*t Mx<51NQi4SBH!aGPfdBvi diff --git a/public/scenario-previews/thunderhead-mesa@1x.png b/public/scenario-previews/thunderhead-mesa@1x.png index 829ba2bb2393555807f21dbf5f83d00b26e8c9fe..57fa4bacc36ae6cde42d8dc28c39b6976a0dcd49 100644 GIT binary patch delta 3297 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 delta 2253 zcmV;;2r~Ei8SN2}IDZJANklf)7R* zMrIfX6&zuR5Y*rcK|~T07j9gb7!qS#_#NE(5w59D>ZWeps&lH&Io+pw?kxU+d#Aha z>HqJ%pLDvoWDsg=i`O3=4Q41;AhS zsrjdapKGeks()h}wYDIDzL;7XLaO-?(Q+V2{+?b^07x(P^7^NvqZ`*J1m9US1OO#s zy%hk4)eJx~-zp9w^*K~I5Mlu4R<8z?3xI}m-@$!00QBYOKe%C53A0mScmbfnu`J31 zA{6@}>}CL%0?^on&F!eVf>8>9rQN|H#6T1QfY}EEK!1ZDeQ{z+KYqS6rH6NpH~QiB zv7r8be5k1YdUR0LpAQdANW1RAt;I(4yL&h18^L|wZ66&yd9c4xD*&kZ5`guqYeBvL z(Q2cW&5L7Q*f`&4dF|Zj$TG0^n(g(U{*? z0G@)l^J-|Q|HlhJ%7SVFpb#Jou~xaaAr|Y3&ISPeJRb9D((V%g5QKpmtjXFH5i@_P zJAWERd#u&a5&&pSs|kQ-MVJ~wLTDKKf4z5j0zjx|RRv&ah;ax2fadSkY=?J4^Z`If z^jZ|geEbYOqn2)M4nQ3d0{|eYGY&-oNRqM~UiZgXRTF?_Dt^|!hnOD%U>Rpu0U!ja zI~oOj{4wLTDjZGHH2K#80A@;h=F|I2?7cL@K~;8HB^%EeFX5! zH**uR0Psxji2|Syq_JTb#j-Y9xcM}Htqs6pz6F5CcrySA0;UK65Hnng@w{+@8raYQ zz))q%d@2(FjV6q{hU(1J_)v|aZz(`BpF`l`M*tSn=}ba50GcAc|7>BZK-FS9ZGW`P zI)J1UfF=ClOV`GNAC-*ev7J`sc;GpNAp=O6!55qx8k;)<1&>sZmZasKLjoYZ1BTlR zK%JcHnYJwf(CX76^XbbBp%9iL4wQ$qrf8iu*#Lk=0x63VIDj1U`v!nR2*v(R07!k^ z&;jK!cxV7(kthT}gCMRC&;Z0Ho`3EX03HZhxrG2?b5^4OJX5cC5&&-&%B#*608&M# zStAB(RZ|up>@)x&2%7mh0LF{-EC8f!1a=|-YdCqe834ql&AS1F_HeKQz<@&YTYDk= z+YkU~t#&VfiDjx3K+JTiKkmN}1R!-cYv$Jm0O3Gc%;#Z+j>%*Iuw#eE_dWkXw(Y;p+NT$fE4?A3b2ma?WTZ?EJ&*uXyNZ200``m zvmlG2%==W^{7R3Q+_0HgsKD*$N#1Se~C2|zMFwoV`<*gb{LnF2{5iey2a5wTFL$NOpl zkcCrueBoIa793L1e0Dr6TTmS$egaAyPAJBCQKtT9!9|3sHrw~E_!~-0>0O){BXfcCD z@Zz%qK=QFUL#As0wBLOe07MV*sR3Y?QUKq5oz^I;0H6?NF$H7;;DzvR8PIVS6srZr zOdmouw2MM`TnkEFBbHkYl>p=n7kXA&)~bez?SQTp=}920(|-YT0BCzy)M|)Lbw!i{ z;9Y5Aod(`DfUdeC%mB32^SDyJ#LAdblCm2QfHphh)bW520KAazDMtZV=Ki;ByvKYE zKo{N7E&#FJQaAwXz@rhpfkigjD+25~|Q~DKL!$W-{P$Brv9n zg5kv!S%)O2c7IFZ04yge<(y;}+SbK;T$SY++R<7#SWXAfV@Ft7B@N0;Q&XYIk1!k}GXm%GA!e&={})$T?W8glVNkCrwF{s!9kv)Xbj%VBK!FwD~nb z@ICNiDs}R!m;$_8?#{AG0T`D7v@_0I6WRq)7(h)3U4Q(J^*20cB)1Bn3kW$c(1+)z z*8Ii*U{E0CH0a#Gr{<;B*jX~KZtFcK=7zQb!P8bK3EZ*^q_>UIIsgfRB}>u*?_D!% z?Tz)maL%(!RJ&aOtPs3`w=CPIqec9;cyDZ~`Q9T&N;E!0o8hXHb1g@7r*>P!%uo5P z*t28L*G3N6Y2$cxadxyMs2xdyn^2I1P*9>%K`W06zo+-$b8>$x^lZ!XrDyZ-$7Bf; b4;Scv5M22%VZ^vY00000NkvXXu0mjf?=SNn diff --git a/public/scenario-previews/thunderhead-mesa@2x.png b/public/scenario-previews/thunderhead-mesa@2x.png index 27aa48bcfb2e8ee6fc0973b3a34e0307dfa46bac..25ee24e8c143115688d153318c26110a70e8d34f 100644 GIT binary patch literal 4215 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 literal 3058 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 delta 1829 zcmW+$dpwl+8vniTT#T6pA+w9gB#x-;B<3_K4MG|@qAWF-#Y)yCm!X7tqgGg&)so1X z%4HGKk~>3Nva;+%tXq~`)_uoq3}>Bp&hPi{^L#(g^SwMxN*zi9CV$KRwB?2Cg9{_w z$y6Kl_P-lb*-`H1in;-Qsy%mh+GY+I)vBDgUromzN!x!{(bh&U#ot>!UU@7*iVYsF zk2EtO+chRyxa^dcmb9ek=pBucMMlN?m6R_2HGA~t*70_I$u_&Y>rM237bgw;!q->q zd|TZXR0kI+ULy~?J_r2te}QIcpPl>4;GemMA2z(ClG#B2)t5fiIi0PYHK#_2pranZ z!MQZ(43P2>(?N3g<7IB#I)VyXW*xe&csg6b*Y1N1~hxS?fwbbpIv_p z@BGyk7`M5|WthrdZ2moZ)WwRu%=0`YizEVjFW|GXl0b3^*7nGIQCIh{>-fhL%pB$N zrk0GFki0zd8S#_upVPMY5pV`d*uCfiC~kbCtRth$jdp8Rfo+%P#as$Y`b2Vk#aFv# z4zObbK*wS@S28+MRHI51$8Qd3-3zhF6S@6Vr$%h$b?lZkf4ET@_xsw72dz&@kACzE z#UVgjP1tw~*MpOcEahdV^4h$8%p590sTFe+j@{ryO+(1J?~Tp&>;=$(25U2MtxXK{ ztH%l$4hx?wjOSF}CRaVJPyl@R+6Y)PbvV>01|Cb7&CA(oy%SME{Ts>&RX(%&p984Y z5ve4b8Z};Oxm&lse~%Ei8|9w+E-5o<+HczUF|`q25S?dSFG-5hMT!W8cPq9ZN-gJ%G=HDO%8*+4waH|GI|h98d0? z1%rrC-FmK=!fImagN~~p+!9N>s>Yoamjce0lt8ixCqWIQTYxuK*fBTYVPUlo7Odjv z>bl_J-QP?I5Dlcj!$TjL7WV#@k6HJrU@XfX z372%Ii#vaY1b~he{&2+|I!{H?Iiw3PA599q>Qi=3I`|BODjP`R&f_71C<~2P5ZKjp zgo@0;2ky-pt!LroIm^F+JboVz^kOmJ<;Fp%Z{;k3A^clOAUHwh8l9FGh1Z2foMijn z%*n|yWS^A86`D}pbWx>6_c=G7 z=jdzvashcv)*v|*HigOYp#c+-6W42)nVlN5v;5(Ti>atLMLO{9P_5J z2oG;ZhcYyu;19T$Ky1u2o;K`cyc-ZiJWSPI2bTbqaZ)#hTb3gI9WdVGFe=DJ@P;4R zRDN&V3L;9Kt`{c=JVEBSsNKp*T%$%O#Q1LIvbVvL@N-^Oc>21ugt8xH{` zowFR%S!tzUP`P{v5m(=XpI`XHbskeJcdJZ2zn+#EUj)^&I_54bWNCR97cfy}z;7Aj zMH)YzeP--x9dV0vr=KX|b5!IVAHZi?rJa4CY-cO7x{24yK2->z<{#5$&9Th#d!&vA zx0TGj8^&FssW`5goT&Gp&=HxEZHhgD7lusb7%z7@MV{EOvudVWH*iRvi^gu4)h4Q% zJgv%Lk{pJ4S6yX0gN;~Bni(zp8l|NYnyTj?cG-C}Uz?_W>{4Z%F(Z0QgPs(Z`wc%_ zCvn$k!0V_MIeqXd?xBpZF`U9}Zw@KXUyNF`{3@_vGOe+KBZE|sSg2Rah|Dbm-&j5) zE2D=A!#xbZJW0q?Q`{iZ=l4#_q74yt>p_d%WEN1`JkL3(m>Wm%cy}cTG#J_f8hGmX)>*|zXTRWP^y|J! zSz9L#JtXLoc_5s+e83|(&^j@)PkuOV!UM;D=~)r#466<4qjCd|s_>vm=!{nX`uh6N n*@cNOc%ysS3wFimSSeFp$zLql{z`4V2+(J5<9NE diff --git a/src/sim/scenario/scenario-preview-assets.test.ts b/src/sim/scenario/scenario-preview-assets.test.ts index 93b432d85..6882673bc 100644 --- a/src/sim/scenario/scenario-preview-assets.test.ts +++ b/src/sim/scenario/scenario-preview-assets.test.ts @@ -5,7 +5,7 @@ import sharp from 'sharp'; import { describe, expect, it } from 'vitest'; import { World } from '../core/world'; import { parseScenarioFile } from './scenario-file'; -import { prepareScenario } from './scenario-layout'; +import { prepareScenarioPark } from './scenario-layout'; import { renderScenarioPreview, SCENARIO_PREVIEW_RENDERER_VERSION } from './scenario-preview'; const scenarioDirectory = resolve(process.cwd(), 'src/sim/scenario/scenarios'); @@ -58,7 +58,7 @@ describe('scenario preview assets', () => { width: scenario.mapWidth, height: scenario.mapHeight, }); - prepareScenario(world, scenario); + prepareScenarioPark(world, scenario); const expectedPixels = renderScenarioPreview(world).pixels; expect(oneX.data, `${def.id} 1x preview should match its map data`).toEqual( diff --git a/src/sim/scenario/scenario-preview.ts b/src/sim/scenario/scenario-preview.ts index 6f9d8bdf2..5cd3546fa 100644 --- a/src/sim/scenario/scenario-preview.ts +++ b/src/sim/scenario/scenario-preview.ts @@ -5,7 +5,7 @@ import { rideFootprintTiles } from '../rides/ride-footprint'; import { RIDE_CATALOG } from '../rides/ride-types'; import type { RideType } from '../rides/ride-types'; -export const SCENARIO_PREVIEW_RENDERER_VERSION = 1; +export const SCENARIO_PREVIEW_RENDERER_VERSION = 2; export interface ScenarioPreviewPixels { width: number; diff --git a/src/ui/title-screen.test.ts b/src/ui/title-screen.test.ts index 695a6ea43..5aa2ea330 100644 --- a/src/ui/title-screen.test.ts +++ b/src/ui/title-screen.test.ts @@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest'; import { LedgerCategory } from '../sim/economy/ledger'; import { ObjectiveKind } from '../sim/scenario/scenario'; import type { ScenarioDef } from '../sim/scenario/scenario'; -import { objectiveText, scenarioRulesText } from './title-screen'; +import { objectiveText, scenarioRulesText, scenarioTerrainLines } from './title-screen'; function scenario( kind: ObjectiveKind, @@ -90,3 +90,21 @@ describe('title screen park rules', () => { ); }); }); + +describe('title screen terrain and challenge notes', () => { + it('names the terrain and the challenge when the scenario describes them', () => { + const def = { + ...scenario(ObjectiveKind.Guests, 100), + landscape: 'Narrow benches between red ridges.', + challenge: 'Landscaping is forbidden; follow the slopes.', + }; + expect(scenarioTerrainLines(def)).toEqual([ + 'Terrain: Narrow benches between red ridges.', + 'Challenge: Landscaping is forbidden; follow the slopes.', + ]); + }); + + it('adds nothing for scenarios without notes', () => { + expect(scenarioTerrainLines(scenario(ObjectiveKind.Guests, 100))).toEqual([]); + }); +}); diff --git a/src/ui/title-screen.ts b/src/ui/title-screen.ts index 8f8403078..a2c0cfde8 100644 --- a/src/ui/title-screen.ts +++ b/src/ui/title-screen.ts @@ -151,6 +151,9 @@ export class TitleScreen { element('p', 'scenario-rank', scenarioRankText(def)), element('p', 'scenario-map-size', `Map size: ${def.mapWidth} × ${def.mapHeight} tiles`), element('p', 'scenario-description', def.description ?? ''), + ...scenarioTerrainLines(def) + .slice(0, 1) + .map((line) => element('p', 'scenario-terrain', line)), ); card.append( scenarioPreview(def, 'scenario-card-preview'), @@ -168,6 +171,7 @@ export class TitleScreen { scenarioPreview(selected, 'scenario-map-preview'), element('h2', 'scenario-preview-name', selected.name), element('p', 'scenario-description', selected.description ?? ''), + ...scenarioTerrainLines(selected).map((line) => element('p', 'scenario-terrain', line)), element('p', 'scenario-objective', objectiveText(selected)), element('p', 'scenario-rules', scenarioRulesText(selected)), element('p', 'scenario-rank', scenarioRankText(selected)), @@ -260,6 +264,14 @@ function scenarioPreview(scenario: ScenarioDef, className: string): HTMLImageEle return image; } +/** The scenario's terrain and challenge notes, labelled for the scenario list. */ +export function scenarioTerrainLines(scenario: ScenarioDef): string[] { + return [ + ...(scenario.landscape ? [`Terrain: ${scenario.landscape}`] : []), + ...(scenario.challenge ? [`Challenge: ${scenario.challenge}`] : []), + ]; +} + function scenarioRankText(scenario: ScenarioDef): string { const category = scenario.category ?? 'beginner'; const label = `${category[0].toUpperCase()}${category.slice(1)}`; diff --git a/src/ui/ui.css b/src/ui/ui.css index a14f3f349..3101df899 100644 --- a/src/ui/ui.css +++ b/src/ui/ui.css @@ -1194,6 +1194,7 @@ } #app .title-tagline, #app .scenario-description, +#app .scenario-terrain, #app .scenario-meta, #app .scenario-objective, #app .scenario-rules, @@ -1206,6 +1207,10 @@ #app .title-tagline { margin: 2px 0 12px; } +#app .scenario-terrain { + color: #4a4130; + font-style: italic; +} #app .title-message { color: #8a321e; } diff --git a/tools/scenario-previews/generate.ts b/tools/scenario-previews/generate.ts index d3a135ddf..139c6cc7e 100644 --- a/tools/scenario-previews/generate.ts +++ b/tools/scenario-previews/generate.ts @@ -4,7 +4,7 @@ import { resolve } from 'node:path'; import sharp from 'sharp'; import { World } from '../../src/sim/core/world'; import { parseScenarioFile } from '../../src/sim/scenario/scenario-file'; -import { prepareScenario } from '../../src/sim/scenario/scenario-layout'; +import { prepareScenarioPark } from '../../src/sim/scenario/scenario-layout'; import { renderScenarioPreview, SCENARIO_PREVIEW_RENDERER_VERSION, @@ -38,7 +38,7 @@ for (const filename of readdirSync(scenarioDirectory) width: scenario.mapWidth, height: scenario.mapHeight, }); - prepareScenario(world, scenario); + prepareScenarioPark(world, scenario); const image = renderScenarioPreview(world); const raw = { raw: { width: image.width, height: image.height, channels: 4 as const } }; const oneX = `${scenario.id}@1x.png`; From 547aced6bd6357d02d95e1e84c88b62fdd3330cf Mon Sep 17 00:00:00 2001 From: "nori-sessions[bot]" <264258699+nori-sessions[bot]@users.noreply.github.com> Date: Sun, 1 Nov 2026 08:07:11 +0000 Subject: [PATCH 03/18] Play-proof tests for the hard parks; Mossgrove trails inside the flat island core Co-authored-by: Nori --- bench/hard-parks.test.ts | 234 +++++++++++++ bench/strategy/site.ts | 330 ++++++++++++++++++ src/sim/scenario/scenarios/copper-ridge.json | 2 +- .../scenario/scenarios/mossgrove-isle.json | 28 +- 4 files changed, 582 insertions(+), 12 deletions(-) create mode 100644 bench/hard-parks.test.ts create mode 100644 bench/strategy/site.ts diff --git a/bench/hard-parks.test.ts b/bench/hard-parks.test.ts new file mode 100644 index 000000000..3da549c1d --- /dev/null +++ b/bench/hard-parks.test.ts @@ -0,0 +1,234 @@ +import { describe, expect, it } from 'vitest'; +import { Simulation } from '../src/sim/core/simulation'; +import { ElementType } from '../src/sim/map/tile-map'; +import { RideState } from '../src/sim/rides/ride-store'; +import { SCENARIOS } from '../src/sim/scenario/catalog'; +import { ParkGrid } from '../src/sim/scenario/park-grid'; +import { prepareScenarioPark } from '../src/sim/scenario/scenario-layout'; +import type { ScenarioDef } from '../src/sim/scenario/scenario'; +import { ParkBuilder } from './strategy/builder'; +import { + clearScenery, + connectOnGround, + flatGroundPath, + layRoute, + openCoaster, + openFlatRide, + waypoints, +} from './strategy/site'; +import type { CoasterSite } from './strategy/site'; + +/** + * Plays the start of each hard park through ordinary player commands with the park's real cash: + * guests arrive through the gate, the first stalls and rides open, and the park's defining move + * (a gulch crossing, a pier bridge, a cliff descent, a mountainside coaster, a woodland clearing) + * is built and used. + */ + +interface Park { + def: ScenarioDef; + sim: Simulation; + builder: ParkBuilder; +} + +function open(id: string, items: readonly string[]): Park { + const def = SCENARIOS.find((s) => s.id === id)!; + const sim = new Simulation({ seed: def.seed, width: def.mapWidth, height: def.mapHeight }); + prepareScenarioPark(sim.world, def); + const builder = new ParkBuilder(sim, def); + for (const name of items) expect(builder.build(name), name).toBeGreaterThanOrEqual(0); + return { def, sim, builder }; +} + +/** The far end of the spine path the builder laid inward from the gate. */ +function spineEnd(park: Park): [number, number] { + const m = park.sim.world.map; + let row = 0; + for (;;) { + const [x, y] = park.builder.grid.tile(row + 1, 0); + if (m.pathElement(m.index(x, y), -1) < 0) break; + row++; + } + return park.builder.grid.tile(row, 0); +} + +function hasPath(park: Park, [x, y]: readonly [number, number]): boolean { + const m = park.sim.world.map; + return m.pathElement(m.index(x, y), -1) >= 0; +} + +/** Lays a route from the spine end through `points` and returns its tiles. */ +function route(park: Park, points: ReadonlyArray, clear: boolean) { + const m = park.sim.world.map; + const start = spineEnd(park); + const tiles = waypoints([start, ...points]).slice(1); + if (clear) clearScenery(park.sim, tiles); + const levels = layRoute(park.sim, tiles, m.heights[m.index(start[0], start[1])]); + expect(levels).not.toBeNull(); + for (const tile of tiles) expect(hasPath(park, tile), `path at ${tile}`).toBe(true); + return { tiles, levels: levels! }; +} + +function joinsRoute(park: Park, tiles: ReadonlyArray) { + const m = park.sim.world.map; + const set = new Set(tiles.map(([x, y]) => m.index(x, y))); + return (t: number) => set.has(t) && flatGroundPath(park.sim, t); +} + +function play(park: Park, ticks: number): void { + for (let t = 0; t < ticks; t++) { + park.builder.advance(); + park.sim.step(); + } +} + +/** Guests who rode in the ride's recent rider window. */ +function riders(park: Park, rideId: number): number { + const w = park.sim.world; + const slot = w.rides.idToSlot[rideId]; + const cols = w.rides.cols as unknown as Record>; + return Object.keys(cols) + .filter((k) => k.startsWith('ridersWindow')) + .reduce((sum, k) => sum + cols[k][slot], 0); +} + +function trees(park: Park): number { + const m = park.sim.world.map; + let n = 0; + for (let e = 0; e < m.elementCapacity; e++) if (m.elType[e] === ElementType.SmallScenery) n++; + return n; +} + +function expectSolvent(park: Park): void { + const l = park.sim.world.economy; + expect(l.cash).toBeGreaterThanOrEqual(0); + expect(l.loan).toBeLessThanOrEqual(l.maxLoan); +} + +const MONTH = 16_384; + +describe('hard parks are playable with legal construction', () => { + it('Copper Ridge: cross the gulch on the trail and open a coaster on the west bench', () => { + const park = open('copper-ridge', ['foodStall', 'drinkStall', 'toilets', 'merryGoRound']); + const [x0] = spineEnd(park); + const trail = route( + park, + [ + [x0, 75], + [34, 75], + [34, 42], + ], + true, + ); + expect(Math.min(...trail.levels)).toBeLessThanOrEqual(6); + expect(Math.max(...trail.levels)).toBeGreaterThanOrEqual(11); + const site: CoasterSite = { template: 'compact', x: 28, y: 40, dir: 0, mirror: true }; + const coaster = openCoaster(park.sim, site, joinsRoute(park, trail.tiles))!; + expect(coaster.state).toBe(RideState.Open); + expect(coaster.excitement).toBeGreaterThanOrEqual(park.def.objective.minimumExcitement!); + play(park, MONTH); + expect(riders(park, coaster.rideId)).toBeGreaterThan(0); + expectSolvent(park); + }); + + it('Glacier Point: open stalls and a mountainside coaster above the 4.70 target', () => { + const park = open('glacier-point', ['foodStall', 'drinkStall', 'toilets']); + const site: CoasterSite = { template: 'compact', x: 80, y: 56, dir: 2, mirror: false }; + const coaster = openCoaster(park.sim, site, (t) => flatGroundPath(park.sim, t))!; + expect(coaster).not.toBeNull(); + expect(coaster.state).toBe(RideState.Open); + expect(coaster.excitement).toBeGreaterThanOrEqual(park.def.objective.minimumExcitement!); + play(park, MONTH); + expect(riders(park, coaster.rideId)).toBeGreaterThan(0); + expectSolvent(park); + }); + + it('Tidewater Docks: buy rights over an inlet, bridge it and fit a ride on a narrow pier', () => { + const park = open('tidewater-docks', ['foodStall', 'drinkStall', 'toilets', 'merryGoRound']); + const sim = park.sim; + const m = sim.world.map; + const inlet = { x: 37, y: 43, width: 6, height: 3 }; + sim.enqueue({ type: 'buyLand', ...inlet, rights: true }); + sim.step(); + const quay = route( + park, + [ + [19, 47], + [19, 61], + [34, 61], + [34, 44], + [45, 44], + [45, 52], + ], + true, + ); + const bridge = quay.tiles.filter(([x, y]) => y === 44 && x >= 37 && x <= 42); + expect( + bridge.every( + ([x, y]) => + m.waterLevel[m.index(x, y)] > m.heights[m.index(x, y)] || m.slope[m.index(x, y)] !== 0, + ), + ).toBe(true); + expect(bridge.some(([x, y]) => m.waterLevel[m.index(x, y)] > m.heights[m.index(x, y)])).toBe( + true, + ); + const pier = new ParkGrid(45, 58, 'south'); + const wheel = openFlatRide(sim, pier, 10, 2, 'ferrisWheel')!; + expect(wheel).not.toBeNull(); + expect(wheel.state).toBe(RideState.Open); + play(park, MONTH); + expect(riders(park, wheel.rideId)).toBeGreaterThan(0); + expectSolvent(park); + }); + + it('Thunderhead Mesa: take the cliff trail down to the west shelf and open a ride there', () => { + const park = open('thunderhead-mesa', ['foodStall', 'drinkStall', 'toilets', 'merryGoRound']); + const [x0] = spineEnd(park); + const descent: Array<[number, number]> = [ + [x0, 24], + [34, 24], + ]; + for (let y = 27; y <= 51; y += 3) descent.push([Math.round(34 - ((y - 24) * 10) / 26), y]); + descent.push([24, 54]); + const trail = route(park, descent, true); + expect(trail.levels[0]).toBe(16); + expect(trail.levels[trail.levels.length - 1]).toBe(11); + const shelf = new ParkGrid(24, 51, 'north'); + const ride = openFlatRide(park.sim, shelf, 3, 2, 'drinkStall')!; + expect(ride).not.toBeNull(); + const pad: Array<[number, number]> = []; + for (let y = 52; y <= 58; y++) for (let x = 15; x <= 23; x++) pad.push([x, y]); + clearScenery(park.sim, pad); + const carousel = openFlatRide(park.sim, shelf, 3, -6, 'merryGoRound'); + expect(carousel?.state ?? -1).toBe(RideState.Open); + play(park, MONTH); + expect(riders(park, carousel!.rideId)).toBeGreaterThan(0); + expectSolvent(park); + }); + + it('Mossgrove Isle: thread a path through the protected woods to a clearing without felling a tree', () => { + const park = open('mossgrove-isle', ['foodStall', 'drinkStall', 'toilets']); + const sim = park.sim; + const m = sim.world.map; + const before = trees(park); + const clearing = new ParkGrid(44, 38, 'south'); + const spine = [clearing.tile(1, 0), clearing.tile(2, 0), clearing.tile(3, 0)]; + for (const [x, y] of spine) sim.enqueue({ type: 'placePath', x, y }); + sim.step(); + for (const tile of spine) expect(hasPath(park, tile)).toBe(true); + const own = new Set(spine.map(([x, y]) => m.index(x, y))); + const trail = connectOnGround( + sim, + clearing.tile(0, 0), + (t) => !own.has(t) && flatGroundPath(sim, t), + ); + expect(trail).not.toBeNull(); + expect(trail!.length).toBeGreaterThan(4); + const carousel = openFlatRide(sim, clearing, 3, 2, 'merryGoRound')!; + expect(carousel?.state).toBe(RideState.Open); + play(park, MONTH); + expect(riders(park, carousel.rideId)).toBeGreaterThan(0); + expect(trees(park)).toBe(before); + expectSolvent(park); + }); +}); diff --git a/bench/strategy/site.ts b/bench/strategy/site.ts new file mode 100644 index 000000000..bae0dc2be --- /dev/null +++ b/bench/strategy/site.ts @@ -0,0 +1,330 @@ +import { TRACK_STEPS_PER_LEVEL } from '../../src/sim/core/constants'; +import type { Simulation } from '../../src/sim/core/simulation'; +import { pieceByName } from '../../src/sim/track/catalog'; +import { getConstructionCursor, rotateTile } from '../../src/sim/track/construction'; +import { RIDE_CATALOG, RideType } from '../../src/sim/rides/ride-types'; +import { DIR_DX, DIR_DY, ElementType, PathFlag, SLOPE_DIR_SHIFT } from '../../src/sim/map/tile-map'; +import { PathResult, planPathPlacement } from '../../src/sim/map/paths'; +import { COASTER_TEMPLATES, mirrored } from './coasters'; +import { RideState } from '../../src/sim/rides/ride-store'; +import { validateRidePlacement } from '../../src/sim/rides/ride-footprint'; +import { RideResult } from '../../src/sim/rides/ride-results'; +import { PREBUILT_TYPES } from '../../src/sim/scenario/scenario-prebuilt'; +import { rideFrontage } from '../../src/sim/scenario/park-grid'; +import type { ParkGrid } from '../../src/sim/scenario/park-grid'; + +/** + * A coaster circuit pinned to the map: the station tile, the heading of its first piece, the + * station's height level, and whether the template is mirrored so it turns the other way. + */ +export interface CoasterSite { + template: string; + x: number; + y: number; + dir: 0 | 1 | 2 | 3; + mirror: boolean; + /** Station height level; defaults to the ground under the station. */ + level?: number; +} + +export interface SiteBuild { + rideId: number; + closed: boolean; + /** Tiles beside the station for the entrance and the exit. */ + entrance: [number, number]; + exit: [number, number]; + /** The tiles in front of the entrance and the exit, where their paths begin. */ + entranceFront: [number, number]; + exitFront: [number, number]; + level: number; +} + +/** + * Creates a wooden coaster at `site` and lays its template through player commands. The circuit + * may climb over slopes on supports or run into the ground as a tunnel; a piece the game refuses + * leaves the circuit open, which `closed` reports. + */ +export function buildCircuit(sim: Simulation, site: CoasterSite): SiteBuild { + const world = sim.world; + const map = world.map; + const template = COASTER_TEMPLATES[site.template]; + const pieces = site.mirror ? mirrored(template.pieces) : template.pieces; + const level = site.level ?? map.heights[map.index(site.x, site.y)]; + const sigma = site.mirror ? -1 : 1; + const at = (i: number, j: number): [number, number] => { + const [rx, ry] = rotateTile(i, j, site.dir); + return [site.x + rx, site.y + ry]; + }; + sim.enqueue({ type: 'createRide', rideType: RideType.WoodenCoaster, x: site.x, y: site.y }); + sim.step(); + const rideId = world.rides.slotToId[world.rides.count - 1]; + for (const [name, mode] of pieces) { + const cursor = getConstructionCursor(world, rideId); + const from = cursor.hasTrack + ? cursor + : { x: site.x, y: site.y, z: level * TRACK_STEPS_PER_LEVEL, dir: site.dir }; + sim.enqueue({ + type: 'placeTrack', + rideId, + pieceType: pieceByName(name)!.id, + x: from.x, + y: from.y, + z: from.z, + dir: from.dir, + mode, + }); + sim.step(); + } + return { + rideId, + closed: world.track.closed[rideId] === 1, + entrance: at(0, -sigma), + exit: at(0, sigma), + entranceFront: at(0, -2 * sigma), + exitFront: at(0, 2 * sigma), + level, + }; +} + +/** + * Lays a footpath along `tiles` (each edge-adjacent to the last), starting level with a path at + * `startLevel`. Each piece sits on or above its ground: the route keeps to the ground where it can + * and otherwise climbs, descends or bridges one level per tile, as a player's raised path would. + * Returns the levels of the pieces, or null when the route cannot start at `startLevel`. + */ +export function layRoute( + sim: Simulation, + tiles: ReadonlyArray, + startLevel: number, + queue = false, +): number[] | null { + const map = sim.world.map; + const top = tiles.map(([x, y]) => { + const i = map.index(x, y); + return Math.max(map.heights[i] + (map.slope[i] !== 0 ? 1 : 0), map.waterLevel[i]); + }); + const n = tiles.length; + const floor = Array.from({ length: n + 1 }, (_, k) => + Math.max(k > 0 ? top[k - 1] : 0, k < n ? top[k] : 0), + ); + floor[0] = Math.max(floor[0], startLevel); + const step = (k: number): number => { + const [x, y] = tiles[k]; + const [px, py] = k > 0 ? tiles[k - 1] : [x - (tiles[1][0] - x), y - (tiles[1][1] - y)]; + return [0, 1, 2, 3].find((d) => DIR_DX[d] === x - px && DIR_DY[d] === y - py)!; + }; + // A ramp only joins along its slope, so a tile where the route turns stays level. + const corner = tiles.map((_, k) => k + 1 < n && step(k + 1) !== step(k)); + let edge = floor; + for (let changed = true; changed;) { + edge = floor.map((_, k) => Math.max(...floor.map((f, j) => f - Math.abs(k - j)))); + changed = false; + for (let k = 0; k < n; k++) { + if (!corner[k] || edge[k] === edge[k + 1]) continue; + const level = Math.max(edge[k], edge[k + 1]); + floor[k] = Math.max(floor[k], level); + floor[k + 1] = Math.max(floor[k + 1], level); + changed = true; + } + } + if (edge[0] !== startLevel) return null; + const levels: number[] = []; + for (let k = 0; k < n; k++) { + const [x, y] = tiles[k]; + const forward = step(k); + const rise = edge[k + 1] - edge[k]; + const z = Math.min(edge[k], edge[k + 1]); + const slope = rise > 0 ? forward : rise < 0 ? (forward + 2) % 4 : -1; + sim.enqueue({ type: 'placePath', x, y, z, slope, queue }); + levels.push(z); + } + sim.step(); + return levels; +} + +/** + * Lays the shortest ground-level footpath from `start` (included) to beside any tile `goal` + * accepts, through tiles where the game would accept a path piece. Returns the tiles laid, + * `start` first, or null. + */ +export function connectOnGround( + sim: Simulation, + start: readonly [number, number], + goal: (tile: number) => boolean, + queue = false, +): Array<[number, number]> | null { + const map = sim.world.map; + const origin = map.index(start[0], start[1]); + /** Level of the piece's edge on `side`, or -1 where a ramp's flank cannot join. */ + const edge = (tile: number, side: number): number => { + let z: number; + let rise: number; + const existing = map.pathElement(tile, map.heights[tile]); + if (existing >= 0) { + z = map.elBase[existing]; + rise = + map.elFlags[existing] & PathFlag.Sloped + ? (map.elFlags[existing] & PathFlag.SlopeDir) >> SLOPE_DIR_SHIFT + : -1; + } else { + const plan = planPathPlacement(map, { x: tile % map.width, y: Math.floor(tile / map.width) }); + if (plan.result !== PathResult.Ok || plan.existing >= 0) return -1; + z = plan.z; + rise = plan.dir; + } + if (rise < 0) return z; + return side === rise ? z + 1 : side === ((rise + 2) & 3) ? z : -1; + }; + const from = new Map([[origin, -1]]); + const frontier = [origin]; + for (let head = 0; head < frontier.length; head++) { + const here = frontier[head]; + if (here !== origin && goal(here)) { + const route: Array<[number, number]> = []; + for (let t = from.get(here)!; t >= 0; t = from.get(t)!) + route.push([t % map.width, Math.floor(t / map.width)]); + route.reverse(); + for (const [x, y] of route) sim.enqueue({ type: 'placePath', x, y, queue }); + sim.step(); + return route; + } + if (here !== origin && map.pathElement(here, -1) >= 0) continue; + for (let d = 0; d < 4; d++) { + const n = map.neighbor(here, d); + if (n < 0 || from.has(n)) continue; + const out = edge(here, d); + if (out < 0 || out !== edge(n, (d + 2) & 3)) continue; + if (map.pathElement(n, -1) >= 0 && !goal(n)) continue; + from.set(n, here); + frontier.push(n); + } + } + return null; +} + +/** Edge-adjacent tiles through `points`, moving along x then y between each pair. */ +export function waypoints( + points: ReadonlyArray, +): Array<[number, number]> { + const out: Array<[number, number]> = [[points[0][0], points[0][1]]]; + for (let k = 1; k < points.length; k++) { + let [x, y] = out[out.length - 1]; + const [tx, ty] = points[k]; + while (x !== tx) out.push([(x += Math.sign(tx - x)), y]); + while (y !== ty) out.push([x, (y += Math.sign(ty - y))]); + } + return out; +} + +/** Removes the small scenery (trees, rocks) on `tiles` through the normal removal command. */ +export function clearScenery( + sim: Simulation, + tiles: ReadonlyArray, +): void { + const map = sim.world.map; + for (const [x, y] of tiles) { + const i = map.index(x, y); + for (let e = map.firstElement(i); e >= 0; e = map.nextElement(e)) + if (map.elType[e] === ElementType.SmallScenery) sim.enqueue({ type: 'removeScenery', x, y }); + } + sim.step(); +} + +/** True when tile `i` holds a flat footpath piece lying on its ground, which paths can join from any side. */ +export function flatGroundPath(sim: Simulation, i: number): boolean { + const map = sim.world.map; + const e = map.pathElement(i, map.heights[i]); + return e >= 0 && !(map.elFlags[e] & PathFlag.Sloped) && !map.isQueue(i); +} + +export interface OpenedRide { + rideId: number; + /** Ride state after the build: `RideState.Open` when it opened. */ + state: number; + excitement: number; +} + +/** + * Builds a coaster at `site`, lays its queue from the entrance and a path from the exit to tiles + * `joins` accepts, tests it and opens it. With `clear`, scenery on the entrance and exit tiles is + * removed first. Returns null when the circuit does not close or a path cannot be laid. + */ +export function openCoaster( + sim: Simulation, + site: CoasterSite, + joins: (tile: number) => boolean, + clear = true, +): OpenedRide | null { + const world = sim.world; + const c = buildCircuit(sim, site); + if (!c.closed) return null; + if (clear) clearScenery(sim, [c.entrance, c.exit, c.entranceFront, c.exitFront]); + sim.enqueue({ type: 'placePath', x: c.entrance[0], y: c.entrance[1], queue: true }); + sim.enqueue({ type: 'placePath', x: c.exit[0], y: c.exit[1] }); + sim.step(); + const exitTile = world.map.index(c.exit[0], c.exit[1]); + if (!connectOnGround(sim, c.entranceFront, (t) => t !== exitTile && joins(t), true)) return null; + if (!connectOnGround(sim, c.exitFront, joins)) return null; + sim.enqueue({ type: 'placeRideEntrance', rideId: c.rideId, x: c.entrance[0], y: c.entrance[1] }); + sim.enqueue({ type: 'placeRideExit', rideId: c.rideId, x: c.exit[0], y: c.exit[1] }); + sim.enqueue({ type: 'setRideStatus', rideId: c.rideId, status: 'test' }); + sim.step(); + const slot = () => world.rides.idToSlot[c.rideId]; + for (let t = 0; t < 12_000 && world.rides.cols.tested[slot()] !== 1; t++) sim.step(); + for (let t = 0; t < 4_000 && world.rides.cols.state[slot()] !== RideState.Open; t++) { + if (t % 50 === 0) sim.enqueue({ type: 'setRideStatus', rideId: c.rideId, status: 'open' }); + sim.step(); + } + return { + rideId: c.rideId, + state: world.rides.cols.state[slot()], + excitement: world.rides.cols.excitement[slot()], + }; +} + +/** + * Builds and opens a flat ride or stall beside a spine path the caller already laid, at + * (`row`, `lateral`) on `grid`, the way the scripted builder places rides along its spine. + */ +export function openFlatRide( + sim: Simulation, + grid: ParkGrid, + row: number, + lateral: number, + name: string, +): OpenedRide | null { + const world = sim.world; + const type = PREBUILT_TYPES[name]; + const frontage = rideFrontage(grid, row, lateral, RIDE_CATALOG[type].footprint); + if (validateRidePlacement(world, type, ...frontage.ride, frontage.dir) !== RideResult.Ok) + return null; + const service = + RIDE_CATALOG[type].category === 'stall' || RIDE_CATALOG[type].category === 'facility'; + for (const [x, y] of frontage.queue) sim.enqueue({ type: 'placePath', x, y, queue: !service }); + for (const [x, y] of frontage.exitPath) sim.enqueue({ type: 'placePath', x, y }); + sim.enqueue({ + type: 'createRide', + rideType: type, + x: frontage.ride[0], + y: frontage.ride[1], + dir: frontage.dir, + }); + sim.step(); + const rideId = world.rides.slotToId[world.rides.count - 1]; + sim.enqueue({ + type: 'placeRideEntrance', + rideId, + x: frontage.entrance[0], + y: frontage.entrance[1], + }); + if (!service) + sim.enqueue({ type: 'placeRideExit', rideId, x: frontage.exit[0], y: frontage.exit[1] }); + sim.enqueue({ type: 'setRideStatus', rideId, status: 'open' }); + sim.step(); + const slot = world.rides.idToSlot[rideId]; + return { + rideId, + state: world.rides.cols.state[slot], + excitement: world.rides.cols.excitement[slot], + }; +} diff --git a/src/sim/scenario/scenarios/copper-ridge.json b/src/sim/scenario/scenarios/copper-ridge.json index 6a59e07cc..fc00dacca 100644 --- a/src/sim/scenario/scenarios/copper-ridge.json +++ b/src/sim/scenario/scenarios/copper-ridge.json @@ -211,7 +211,7 @@ }, { "kind": "owned", - "band": [36, 76, 30, 46, 2] + "band": [34, 76, 34, 46, 2] }, { "kind": "owned", diff --git a/src/sim/scenario/scenarios/mossgrove-isle.json b/src/sim/scenario/scenarios/mossgrove-isle.json index d049bb61b..2360714c8 100644 --- a/src/sim/scenario/scenarios/mossgrove-isle.json +++ b/src/sim/scenario/scenarios/mossgrove-isle.json @@ -141,7 +141,7 @@ "mode": "raise", "level": 6, "run": 2, - "ellipse": [35, 30, 14, 10] + "ellipse": [35, 30, 16, 12] }, { "mode": "raise", @@ -189,7 +189,7 @@ }, { "kind": "owned", - "ellipse": [35, 30, 21, 16] + "ellipse": [35, 30, 22, 17] }, { "kind": "owned", @@ -209,7 +209,7 @@ { "density": 85, "rocks": 4, - "ellipse": [35, 30, 21, 16] + "ellipse": [35, 30, 22, 17] }, { "density": 60, @@ -218,28 +218,34 @@ ], "clearings": [ { - "ellipse": [25, 36, 6, 4] + "ellipse": [46, 34, 5, 4] }, { - "ellipse": [47, 37, 5, 4] + "ellipse": [25, 34, 5, 4] }, { - "ellipse": [28, 20, 5, 4] + "ellipse": [28, 21, 5, 3] }, { - "ellipse": [50, 26, 4, 3] + "ellipse": [49, 29, 3, 3] }, { - "band": [35, 44, 25, 36, 1] + "band": [35, 43, 35, 38, 1] }, { - "band": [35, 44, 47, 37, 1] + "band": [35, 38, 45, 38, 1] }, { - "band": [25, 36, 28, 20, 1] + "band": [35, 38, 26, 38, 1] }, { - "band": [47, 37, 50, 26, 1] + "band": [25, 34, 25, 24, 1] + }, + { + "band": [25, 24, 27, 22, 1] + }, + { + "band": [48, 34, 48, 29, 1] } ] }, From 6ddc981c66a80f1949132e07076fcddc4438b8ac Mon Sep 17 00:00:00 2001 From: "nori-sessions[bot]" <264258699+nori-sessions[bot]@users.noreply.github.com> Date: Sun, 1 Nov 2026 08:07:17 +0000 Subject: [PATCH 04/18] Regenerate previews; match apron error text Co-authored-by: Nori --- public/scenario-previews/copper-ridge@1x.png | Bin 2689 -> 2686 bytes public/scenario-previews/copper-ridge@2x.png | Bin 3489 -> 3482 bytes public/scenario-previews/manifest.json | 4 ++-- .../scenario-previews/mossgrove-isle@1x.png | Bin 991 -> 994 bytes .../scenario-previews/mossgrove-isle@2x.png | Bin 1342 -> 1350 bytes src/sim/scenario/scenario-shapes.test.ts | 2 +- 6 files changed, 3 insertions(+), 3 deletions(-) diff --git a/public/scenario-previews/copper-ridge@1x.png b/public/scenario-previews/copper-ridge@1x.png index f96a1f3227da5e91de1826c1fb80ae12930722d8..2f7a3a3270368edfd20851d269a74522fd9137e4 100644 GIT binary patch delta 2656 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 O0000V0Vw(LZH1;X z-{ZJB!&hc2+sXjJ%~J=U=Et_qnoW4jD&w)?TUy<>!oJUezz~|9V1`Gh?+qbmJQ$u6 z2ZBOqYO1OBM1Q%FR<7x5CxR`R52LcY@v8|jAQ%WuO&eKaxD~|MHLVo@Q1d0@*Y*#^ zfsi0HHJy`}`I_1=6@aMe8JN!-zrKI17Y{;)Pz=D^d@F#zzI<&o0J!v1^Cjcg-&kis z;p=MgdRgnF94bn-|La#SW;dhHw4v=g1Dw7gKEMJ%yExS}5OaORUacJtuy4|GQ(I;3UIydMr5p;m>Y&+XV9ifTo1x2Q153a`U=ez|kB7ygZJU%b$p3<3zjeArJ8z*s9VSOAuZm20AL6h1O^ZwVB@9d9<@L< z1g!-inZL2Ppf*u@Zh>+9;&~MW+0%zDkSAPoQs0-q*aC<0K@Jkjp}08pwHdk!L*Tl0h3Au4CO$GRo0`I_6&c&PEbq?F%w zVIa9(=MC2a(46r7?~g@FZhyZqzFYuE`2gv=*H6A2$$IQk(?Vz)D{GPvGWSw3fSPJ| z@srJ7n;&237&c(N$r;O|hw! z28F~+&=@6*p7gzM4@a^ax5upgAKhf$--ggc?WRL1)9UP%Gm*w9Wq;VTpT9X2DQ6lL zjL^F0S8w#{-b1f7!VqErg{GDobLR2~o!}(kv9^>Y_2|TZ`ub2Lt8rMft6vl;hQI(Q zH`Q+1`h$J&kvvKn zr{4J62YOM%vIa6ba)0)0C)hST=Y%0B0c@GBG%}Q0Ye_nF{#5rI9zpDOh2~&k!)HY`ATr-r>a-_z z<>-r%r0r@<00rYU`!Y8x+L~$W0}z0WsWm4=0Z0(IedL;t@P8bad`;VL(io#4_#kwu z0f0xFC@BS?wC%^+;r71+;MloiQ(fi(B{e`(HLLmoX&9IqB61@jH2ky}76ur};c;e! zsGA9A`hZZfRHe{Rg2D(0kA$e1k|{aS$yYQ1Ga05)VJs*&3QCnakE$un1qLRYOPMD8 zFiwEY6b<#52Y=+MW*bRgY{~~%X2N4t%@7v~@+f6A^qdMmyC+&K z88M$&P+ir88bTwZwWZ9QeDO{Ti94nN35kTgTcf6LROspT0$kC8V?%7bV(eDb@Us(R$x~FD7_gHwI3Fc1K^lXULTOT^;Wo##7-OqaixFWqoA1tpyb}5tpMTK zJRm=hssoULKttTAnQ(~jXpQ{m?;oD1nXq`Th}xUA;@eV27t3WJ@R>J#jnD#+Qlnn6 zpnuvpQR8v9Tnr%<4NYC#fg$(1*7l2U_fWk#nPaOcyJCY0l6zt=P0O0u}yza#V+rexW0KntedE2o8{0HcpR)QmD R%@F_q002ovPDHLkV1hd?#M)5_g4SkHE_^) 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 Wp)v*Os(yF?0000OIw~I+T0xuhoVu2H0ac z(T|gsb`YK5TCt{$U67hp=fWit5nw}3PV}Wr)H44Z9Na6hUY`FR(q4!u%so?pWdMvs zu8AYD<1GFt(<+O8=X$mHYW*CPmOonWI6-|V4})cF@zrj3 z%Wk6H(^OKt*vpm(A7RMigZZBvI2oD`x}_9*L5{K|Xy)w(qh9x{!N(Sle0?X%ILh^{ zWw3?A%_-hWsc;QlP4s)+)d=v2w{+*(@PFP|vn7=B6O06orX9plnvVwE#-IoBuEek; zQ>LeHjdbFssn>%93n{bQ%s;s2$%Fg)(c_}2ah^o;{jy^`PXA;aVL_JM1tK`?4CAs` z>Xo}cw3Ble578IV3%XxVKX=ust9|&PRJ5Q)x&CL<<}M@!KATDtBuu^AgVES+CY-X4 z2f*Va;%}w99_0yqC)c&aRBT1!(@nMC-~o&%-Yc(PtkNr6b+4N7e^163-`pnl@$aau z;4@TlDx%hV949hJ34G%e7g2W2g}Qp;I1{8SjfZOW>49wBQc=7G&7yY(L^s%1JG{wE zH^n%5_Ia;6F^|Lmx6FNAyWFR9H}>6oHGpe4<()QVJ~O=S?EQtqMB{fO5<9YZD`0bJ z2d47`WGCWJnk%aGF+Of-3 z5VNN|D`OD?9@1nPrmV;E2iBsMn|)!8kBfDohMSn^%7ZoS(9^V?d9yz4Q;m!3d8Q@S z1tNO=K!>p8XA<&|NE1ETC)|;vZ7_b76k>x4{3Fv+Vvp<2Q;lr1K6gNid_S;L4aQ8P z<9_hQfot$T(9z|D(f*#pvQ0?c%y28bYiKE;_Nb7MV}T+no1U2etI%=Ql7d9e7aet9 z+ql-9+h*46cN=n?1rJ8hBC%pzux%l3mO!7YEWMz`z?eT!%`Qi}DR-4N^6^&N{~UY_ zxMXnLbpc4N8pB6X{12keA=?(Bd*$fEgxoeCcwB?As6|olVLuzfZWfy3!+A0m7<-B8 bzUBc_5L9=dIb3@levE(}5XL&^zdi3?%C{LN literal 1342 zcmeAS@N?(olHy`uVBq!ia0vp^6F``Q4M;wBd$a>caTa()7Bes~zW`yzt<^!<3=AwE zJY5_^DsH{KdpavPP~_OheZ9`}RsW32dIIQMS7dzG3F7E7=2;?y^oonNM z`Xr@V@6)cSK^_c1^$o>#QWMy<#D#!56(0O3un8!d!^H_yc|nWGt5xXs4mOaP3epo; z4>V2UI?=?U05aB2Wqsh=y?&g`K*^AMz5cQuEI`(lo)fKAU%q;El)l-!F8KHFr%qkE zky28@k_=1%;sHsGPnKzW$Sruhc&)&+Vg?Qe(}hQ#ef+*!@zeKT7G~$~+j)CwtqJka z$z&C1_{HGnaAa91=j6}Rn;vbGV_;n2Z4g#;(B@}huHMpsZ};|d&OEnFu}CKRSCaJo zJGXcg7<83)Rj<{r&=b*LS&(;s?^c6P`x+))X*%*v4`})6NvWn*+083M4+S|!PKffK z+EdqU4K!41PWbyWaW!!-tp&GK&%JuKeV!B}$VW`>yN+7@p8x%MQmx+hlBI`s{(Ml> z!T$2tUvEV*jm~#ISF-*v0Yfv2`S@3=G0v<_R*{4!c4!4d(BwopZYT@!Fj)PM(W# z*xGQEPy2`yC>}#L**NKog@~0sK`4!+vA?ly?rLj7+Dr1 zGH=pbVzOxImkf`%$Cg{A?@PI@eyRjY4Mk=_n|6J?rn2hl-02YoQH)up8zicwg+YFq zbLZzLqa(9VeNYQ6{qkgGTX444;%`&fRe2m3UI|SQ&DUJbmaMC=`9Xwz#9H|)R{rlE z)nyxnu2To;ofJL&Yim~N?{k~jxuWa$PmSdVhC!%qs@#foj7R4!|5AO_Z&6w7E}+W7 zJJ%i`T)DN<>7DM`rFZ{cQe9KK|EQz`gOr)V`sn*yL90_`w?6o?^)??c46CcBM>uRX zn{rAwbgkG~{-@K@7#K6|MBmxUb~Wp#o92vtx{<)32;&aWT5@CUBQM3Jd@{%KoNYoZ zfQfqtV6Z8F;3&ncynD8m}LS^HEq55FwaBVq3GW}-5;P> zG;wiA-{0>9%t4@R1JVFxnle=W+`L^*=yxSp;uB*eFxR&Eq+b@$Of1rQU;P}E5Lp&{ zZrH=Yz&(NO5i3~pqsF7tHiR-Wp_{hcSFS;v+ry3@m{m}$f!MepF+U)cQR+2YAd(A^ znNd6)jV>UqKB>SU0Lp-E2iwA<0tyDEfZIZBV7|#BMogTe~DWM4fXJY}z diff --git a/src/sim/scenario/scenario-shapes.test.ts b/src/sim/scenario/scenario-shapes.test.ts index 2f01d826a..7bdb5c3e7 100644 --- a/src/sim/scenario/scenario-shapes.test.ts +++ b/src/sim/scenario/scenario-shapes.test.ts @@ -142,7 +142,7 @@ describe('land parcels', () => { it('rejects an apron that leaves the owned shape', () => { expect(() => recipe({ terrain: { ...TERRAIN, apronOffset: 20 } })).toThrow( - /apron must fit inside the owned land/, + /apron .* must fit inside the owned land/, ); expect(() => recipe({ terrain: { ...TERRAIN, apronOffset: 15 } })).not.toThrow(); }); From e2348283f8470faef27186d57267b877a9d34b7f Mon Sep 17 00:00:00 2001 From: "nori-sessions[bot]" <264258699+nori-sessions[bot]@users.noreply.github.com> Date: Sun, 1 Nov 2026 08:07:19 +0000 Subject: [PATCH 05/18] Catalog inventory tests respect forbidden ride types; timeouts for map-heavy tests Co-authored-by: Nori --- bench/hard-parks.test.ts | 2 +- src/sim/scenario/catalog.test.ts | 11 ++++++++--- src/sim/scenario/scenario-preview-assets.test.ts | 2 +- 3 files changed, 10 insertions(+), 5 deletions(-) diff --git a/bench/hard-parks.test.ts b/bench/hard-parks.test.ts index 3da549c1d..d96ef42eb 100644 --- a/bench/hard-parks.test.ts +++ b/bench/hard-parks.test.ts @@ -107,7 +107,7 @@ function expectSolvent(park: Park): void { const MONTH = 16_384; -describe('hard parks are playable with legal construction', () => { +describe('hard parks are playable with legal construction', { timeout: 60_000 }, () => { it('Copper Ridge: cross the gulch on the trail and open a coaster on the west bench', () => { const park = open('copper-ridge', ['foodStall', 'drinkStall', 'toilets', 'merryGoRound']); const [x0] = spineEnd(park); diff --git a/src/sim/scenario/catalog.test.ts b/src/sim/scenario/catalog.test.ts index 800d01541..60ee0e35a 100644 --- a/src/sim/scenario/catalog.test.ts +++ b/src/sim/scenario/catalog.test.ts @@ -116,18 +116,19 @@ describe('scenario catalog', () => { }); describe('ride unlocks per scenario', () => { - it('lets every scenario build every ride type, from its starting rides or by research', () => { + it('lets every scenario build every ride type it allows, from its starting rides or by research', () => { for (const def of SCENARIOS) { const reachable = new Set([ ...def.availableItemIds, ...def.inventions.map((invention) => invention.itemId), + ...(def.restrictions?.forbiddenRideTypeIds ?? []), ]); const missing = Object.keys(RIDE_CATALOG).filter((id) => !reachable.has(Number(id))); expect(missing, def.id).toEqual([]); } }); - it('starts every scenario with at least nine buildable types, including needs and an exciting ride', () => { + it('starts every scenario with at least nine buildable types, including needs, gentle rides where allowed and an exciting ride', () => { for (const def of SCENARIOS) { const world = new World({ seed: def.seed, width: 8, height: 8 }); applyScenario(world, def); @@ -137,10 +138,14 @@ describe('ride unlocks per scenario', () => { def.availableItemIds.length, ); expect(unlocked.size, def.id).toBeGreaterThanOrEqual(9); + const forbidden = new Set(def.restrictions?.forbiddenRideTypeIds ?? []); + const gentleAllowed = Object.entries(RIDE_CATALOG).some( + ([id, ride]) => ride.category === 'gentle' && !forbidden.has(Number(id)), + ); expect( starting.filter((ride) => ride?.category === 'gentle').length, def.id, - ).toBeGreaterThanOrEqual(3); + ).toBeGreaterThanOrEqual(gentleAllowed ? 3 : 0); expect( starting.some((ride) => ride?.category === 'coaster' || ride?.category === 'thrill'), def.id, diff --git a/src/sim/scenario/scenario-preview-assets.test.ts b/src/sim/scenario/scenario-preview-assets.test.ts index 6882673bc..b9ff40724 100644 --- a/src/sim/scenario/scenario-preview-assets.test.ts +++ b/src/sim/scenario/scenario-preview-assets.test.ts @@ -86,5 +86,5 @@ describe('scenario preview assets', () => { } expect(pixelated, `${def.id} 2x image should preserve crisp tile pixels`).toBe(true); } - }); + }, 30_000); }); From aa21d21a2d28decf556c5ba99be404ccd86603a8 Mon Sep 17 00:00:00 2001 From: "nori-sessions[bot]" <264258699+nori-sessions[bot]@users.noreply.github.com> Date: Sun, 1 Nov 2026 08:07:21 +0000 Subject: [PATCH 06/18] Check each hard park enforces its advertised rules Co-authored-by: Nori --- bench/hard-parks.test.ts | 77 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) diff --git a/bench/hard-parks.test.ts b/bench/hard-parks.test.ts index d96ef42eb..036940dd8 100644 --- a/bench/hard-parks.test.ts +++ b/bench/hard-parks.test.ts @@ -1,7 +1,9 @@ import { describe, expect, it } from 'vitest'; import { Simulation } from '../src/sim/core/simulation'; import { ElementType } from '../src/sim/map/tile-map'; +import { SceneryItem } from '../src/sim/map/scenery'; import { RideState } from '../src/sim/rides/ride-store'; +import { RideType } from '../src/sim/rides/ride-types'; import { SCENARIOS } from '../src/sim/scenario/catalog'; import { ParkGrid } from '../src/sim/scenario/park-grid'; import { prepareScenarioPark } from '../src/sim/scenario/scenario-layout'; @@ -107,6 +109,17 @@ function expectSolvent(park: Park): void { const MONTH = 16_384; +const TREES = new Set([ + SceneryItem.OakTree, + SceneryItem.Conifer, + SceneryItem.BlossomTree, + SceneryItem.BirchTree, + SceneryItem.AutumnTree, + SceneryItem.TopiaryTree, + SceneryItem.PalmTree, + SceneryItem.CactusTree, +]); + describe('hard parks are playable with legal construction', { timeout: 60_000 }, () => { it('Copper Ridge: cross the gulch on the trail and open a coaster on the west bench', () => { const park = open('copper-ridge', ['foodStall', 'drinkStall', 'toilets', 'merryGoRound']); @@ -232,3 +245,67 @@ describe('hard parks are playable with legal construction', { timeout: 60_000 }, expectSolvent(park); }); }); + +describe('each hard park enforces the rules it advertises', () => { + function fresh(id: string): Simulation { + const def = SCENARIOS.find((s) => s.id === id)!; + const sim = new Simulation({ seed: def.seed, width: def.mapWidth, height: def.mapHeight }); + prepareScenarioPark(sim.world, def); + return sim; + } + + it('Copper Ridge refuses to reshape its ridges', () => { + const sim = fresh('copper-ridge'); + const m = sim.world.map; + const before = Array.from(m.vertexHeights); + sim.enqueue({ + type: 'flattenLand', + x: 30, + y: 60, + width: 8, + height: 12, + anchorX: 32, + anchorY: 75, + }); + sim.step(); + expect(Array.from(m.vertexHeights)).toEqual(before); + }); + + it('Mossgrove Isle keeps every tree when the player tries to clear the woods', () => { + const sim = fresh('mossgrove-isle'); + const m = sim.world.map; + const count = () => { + let n = 0; + for (let e = 0; e < m.elementCapacity; e++) + if (m.elType[e] === ElementType.SmallScenery && TREES.has(m.elData[e])) n++; + return n; + }; + const before = count(); + sim.enqueue({ type: 'clearScenery', x: 20, y: 18, width: 30, height: 20 }); + sim.step(); + expect(before).toBeGreaterThan(400); + expect(count()).toBe(before); + }); + + it('Glacier Point builds no flat rides', () => { + const sim = fresh('glacier-point'); + sim.world.research.unlocked.add(RideType.MerryGoRound); + const rides = sim.world.rides.count; + sim.enqueue({ type: 'createRide', rideType: RideType.MerryGoRound, x: 80, y: 50 }); + sim.step(); + expect(sim.world.rides.count).toBe(rides); + }); + + it('Thunderhead Mesa refuses marketing and tall construction', () => { + const sim = fresh('thunderhead-mesa'); + const l = sim.world.economy; + const campaign = l.campaignId; + sim.enqueue({ type: 'economy', action: { type: 'startCampaign', campaignId: 1, weeks: 2 } }); + const m = sim.world.map; + const ground = m.heights[m.index(44, 14)]; + sim.enqueue({ type: 'placePath', x: 44, y: 14, z: ground + 8 }); + sim.step(); + expect(l.campaignId).toBe(campaign); + expect(m.pathElement(m.index(44, 14), -1)).toBeLessThan(0); + }); +}); From 4e4aacfc733e26bc5ca4b0fa70561cee5b94b50e Mon Sep 17 00:00:00 2001 From: "nori-sessions[bot]" <264258699+nori-sessions[bot]@users.noreply.github.com> Date: Sun, 1 Nov 2026 08:07:23 +0000 Subject: [PATCH 07/18] Site-plan strategies for the hard parks; browser proof spec; remix design doc draft Co-authored-by: Nori --- bench/hard-parks.test.ts | 19 ++ bench/strategy/builder.ts | 6 + bench/strategy/plans/mossgrove-isle.json | 12 + bench/strategy/plans/thunderhead-mesa.json | 81 +++++++ bench/strategy/plans/tidewater-docks.json | 36 +++ bench/strategy/site-plan.ts | 244 +++++++++++++++++++++ bench/strategy/site.ts | 69 +++++- bench/strategy/strategies.ts | 61 ++++-- docs/scenario-remixes.md | 57 +++++ e2e/hard-parks-proof.spec.ts | 143 ++++++++++++ 10 files changed, 701 insertions(+), 27 deletions(-) create mode 100644 bench/strategy/plans/mossgrove-isle.json create mode 100644 bench/strategy/plans/thunderhead-mesa.json create mode 100644 bench/strategy/plans/tidewater-docks.json create mode 100644 bench/strategy/site-plan.ts create mode 100644 docs/scenario-remixes.md create mode 100644 e2e/hard-parks-proof.spec.ts diff --git a/bench/hard-parks.test.ts b/bench/hard-parks.test.ts index 036940dd8..3c9f31afb 100644 --- a/bench/hard-parks.test.ts +++ b/bench/hard-parks.test.ts @@ -1,4 +1,7 @@ +import { mkdirSync, writeFileSync } from 'node:fs'; +import { join } from 'node:path'; import { describe, expect, it } from 'vitest'; +import { serialize } from '../src/save/save'; import { Simulation } from '../src/sim/core/simulation'; import { ElementType } from '../src/sim/map/tile-map'; import { SceneryItem } from '../src/sim/map/scenery'; @@ -109,6 +112,17 @@ function expectSolvent(park: Park): void { const MONTH = 16_384; +/** With HARD_PROOF_SAVES set, each proof park is saved there for the browser screenshots. */ +function keep(park: Park, focus: readonly [number, number]): void { + const dir = process.env.HARD_PROOF_SAVES; + if (!dir) return; + mkdirSync(dir, { recursive: true }); + writeFileSync(join(dir, `${park.def.id}.ocsave`), serialize(park.sim.world)); + const m = park.sim.world.map; + const z = m.heights[m.index(focus[0], focus[1])]; + writeFileSync(join(dir, `${park.def.id}.json`), JSON.stringify({ focus: [...focus, z] })); +} + const TREES = new Set([ SceneryItem.OakTree, SceneryItem.Conifer, @@ -142,6 +156,7 @@ describe('hard parks are playable with legal construction', { timeout: 60_000 }, play(park, MONTH); expect(riders(park, coaster.rideId)).toBeGreaterThan(0); expectSolvent(park); + keep(park, [34, 60]); }); it('Glacier Point: open stalls and a mountainside coaster above the 4.70 target', () => { @@ -154,6 +169,7 @@ describe('hard parks are playable with legal construction', { timeout: 60_000 }, play(park, MONTH); expect(riders(park, coaster.rideId)).toBeGreaterThan(0); expectSolvent(park); + keep(park, [80, 54]); }); it('Tidewater Docks: buy rights over an inlet, bridge it and fit a ride on a narrow pier', () => { @@ -192,6 +208,7 @@ describe('hard parks are playable with legal construction', { timeout: 60_000 }, play(park, MONTH); expect(riders(park, wheel.rideId)).toBeGreaterThan(0); expectSolvent(park); + keep(park, [40, 46]); }); it('Thunderhead Mesa: take the cliff trail down to the west shelf and open a ride there', () => { @@ -217,6 +234,7 @@ describe('hard parks are playable with legal construction', { timeout: 60_000 }, play(park, MONTH); expect(riders(park, carousel!.rideId)).toBeGreaterThan(0); expectSolvent(park); + keep(park, [28, 44]); }); it('Mossgrove Isle: thread a path through the protected woods to a clearing without felling a tree', () => { @@ -243,6 +261,7 @@ describe('hard parks are playable with legal construction', { timeout: 60_000 }, expect(riders(park, carousel.rideId)).toBeGreaterThan(0); expect(trees(park)).toBe(before); expectSolvent(park); + keep(park, [42, 39]); }); }); diff --git a/bench/strategy/builder.ts b/bench/strategy/builder.ts index c69c2d3be..26120c947 100644 --- a/bench/strategy/builder.ts +++ b/bench/strategy/builder.ts @@ -405,6 +405,12 @@ export class ParkBuilder { throw new Error('no walkway from the coaster exit to its connector'); } + /** Opens `rideId` once its test run, already started, finishes; see `advance`. */ + watch(rideId: number): void { + this.testing.set(rideId, this.sim.world.tick); + this.rideIds.push(rideId); + } + /** Opens each finished test run. Call regularly; it is cheap. */ advance(): void { const world = this.sim.world; diff --git a/bench/strategy/plans/mossgrove-isle.json b/bench/strategy/plans/mossgrove-isle.json new file mode 100644 index 000000000..b99217aba --- /dev/null +++ b/bench/strategy/plans/mossgrove-isle.json @@ -0,0 +1,12 @@ +[ + { "kind": "item", "name": "foodStall" }, + { "kind": "item", "name": "drinkStall" }, + { "kind": "item", "name": "toilets" }, + { "kind": "route", "points": [[35, 38]], "clear": false }, + { "kind": "flat", "grid": [35, 38, "west"], "row": 2, "lateral": 6, "name": "swingingShip" }, + { "kind": "flat", "grid": [35, 38, "west"], "row": 8, "lateral": -2, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [35, 38, "west"], "row": 8, "lateral": -6, "name": "swingingShip" }, + { "kind": "flat", "grid": [35, 38, "west"], "row": 10, "lateral": 2, "name": "toilets" }, + { "kind": "flat", "grid": [35, 38, "east"], "row": 2, "lateral": 6, "name": "merryGoRound" }, + { "kind": "flat", "grid": [35, 38, "east"], "row": 6, "lateral": -2, "name": "swingingShip" } +] diff --git a/bench/strategy/plans/thunderhead-mesa.json b/bench/strategy/plans/thunderhead-mesa.json new file mode 100644 index 000000000..93351160d --- /dev/null +++ b/bench/strategy/plans/thunderhead-mesa.json @@ -0,0 +1,81 @@ +[ + { "kind": "item", "name": "foodStall" }, + { "kind": "item", "name": "drinkStall" }, + { "kind": "item", "name": "toilets" }, + { "kind": "item", "name": "merryGoRound" }, + { "kind": "route", "points": [[46, 20]], "clear": true }, + { + "kind": "route", + "points": [ + [46, 24], + [34, 24], + [33, 27], + [32, 30], + [31, 33], + [29, 36], + [28, 39], + [27, 42], + [26, 45], + [25, 48], + [24, 51], + [24, 54] + ], + "clear": true, + "from": [46, 20] + }, + { "kind": "flat", "grid": [46, 20, "west"], "row": 2, "lateral": -6, "name": "swingingShip" }, + { "kind": "flat", "grid": [46, 20, "west"], "row": 4, "lateral": 2, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [46, 20, "west"], "row": 9, "lateral": 2, "name": "swingingShip" }, + { "kind": "flat", "grid": [46, 20, "west"], "row": 9, "lateral": -2, "name": "toilets" }, + { "kind": "flat", "grid": [46, 20, "east"], "row": 2, "lateral": 2, "name": "swingingShip" }, + { "kind": "flat", "grid": [46, 20, "east"], "row": 2, "lateral": -6, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [46, 20, "east"], "row": 3, "lateral": -2, "name": "merryGoRound" }, + { "kind": "flat", "grid": [46, 20, "east"], "row": 6, "lateral": -2, "name": "drinkStall" }, + { "kind": "flat", "grid": [46, 20, "east"], "row": 8, "lateral": 2, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [46, 20, "east"], "row": 8, "lateral": -2, "name": "merryGoRound" }, + { "kind": "flat", "grid": [24, 51, "north"], "row": 2, "lateral": -2, "name": "swingingShip" }, + { "kind": "flat", "grid": [24, 51, "north"], "row": 2, "lateral": 6, "name": "toilets" }, + { "kind": "flat", "grid": [24, 51, "north"], "row": 2, "lateral": -6, "name": "merryGoRound" }, + { "kind": "flat", "grid": [24, 51, "north"], "row": 4, "lateral": 6, "name": "swingingShip" }, + { "kind": "flat", "grid": [24, 51, "north"], "row": 6, "lateral": 2, "name": "ferrisWheel" }, + { + "kind": "flat", + "grid": [24, 51, "north"], + "row": 7, + "lateral": -2, + "name": "informationKiosk" + }, + { "kind": "flat", "grid": [24, 51, "north"], "row": 8, "lateral": -6, "name": "merryGoRound" }, + { "kind": "buy", "x": 56, "y": 28, "width": 18, "height": 26, "rights": false }, + { "kind": "buy", "x": 56, "y": 28, "width": 18, "height": 26, "rights": true }, + { "kind": "buy", "x": 60, "y": 51, "width": 20, "height": 12, "rights": false }, + { + "kind": "route", + "points": [ + [60, 30], + [63, 30], + [63, 36], + [66, 36], + [66, 42], + [68, 42], + [68, 48], + [70, 48], + [70, 57], + [62, 57] + ], + "clear": true, + "from": [60, 20] + }, + { "kind": "flat", "grid": [62, 57, "west"], "row": 2, "lateral": 2, "name": "swingingShip" }, + { "kind": "flat", "grid": [62, 57, "west"], "row": 2, "lateral": -2, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [62, 57, "west"], "row": 2, "lateral": 6, "name": "informationKiosk" }, + { "kind": "flat", "grid": [62, 57, "west"], "row": 4, "lateral": 6, "name": "swingingShip" }, + { "kind": "flat", "grid": [62, 57, "west"], "row": 5, "lateral": -6, "name": "merryGoRound" }, + { "kind": "flat", "grid": [62, 57, "west"], "row": 8, "lateral": 2, "name": "swingingShip" }, + { "kind": "flat", "grid": [62, 57, "west"], "row": 9, "lateral": -2, "name": "toilets" }, + { "kind": "flat", "grid": [62, 57, "west"], "row": 10, "lateral": 6, "name": "swingingShip" }, + { "kind": "flat", "grid": [62, 57, "west"], "row": 11, "lateral": -2, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [62, 57, "west"], "row": 14, "lateral": 2, "name": "merryGoRound" }, + { "kind": "flat", "grid": [62, 57, "west"], "row": 14, "lateral": -6, "name": "drinkStall" }, + { "kind": "flat", "grid": [62, 57, "west"], "row": 18, "lateral": 2, "name": "ferrisWheel" } +] diff --git a/bench/strategy/plans/tidewater-docks.json b/bench/strategy/plans/tidewater-docks.json new file mode 100644 index 000000000..061b7f6bf --- /dev/null +++ b/bench/strategy/plans/tidewater-docks.json @@ -0,0 +1,36 @@ +[ + { "kind": "item", "name": "foodStall" }, + { "kind": "item", "name": "drinkStall" }, + { "kind": "item", "name": "toilets" }, + { "kind": "item", "name": "merryGoRound" }, + { "kind": "buy", "x": 37, "y": 43, "width": 6, "height": 3, "rights": true }, + { + "kind": "route", + "points": [ + [19, 47], + [19, 61], + [34, 61], + [34, 44], + [45, 44], + [45, 52] + ], + "clear": true + }, + { "kind": "flat", "grid": [34, 61, "south"], "row": 3, "lateral": 2, "name": "swingingShip" }, + { "kind": "flat", "grid": [34, 61, "south"], "row": 9, "lateral": 2, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [34, 61, "south"], "row": 9, "lateral": -2, "name": "swingingShip" }, + { "kind": "flat", "grid": [34, 61, "south"], "row": 13, "lateral": 2, "name": "toilets" }, + { "kind": "flat", "grid": [34, 61, "south"], "row": 15, "lateral": -2, "name": "swingingShip" }, + { "kind": "flat", "grid": [45, 52, "north"], "row": 2, "lateral": 2, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [45, 52, "north"], "row": 2, "lateral": -2, "name": "swingingShip" }, + { "kind": "flat", "grid": [45, 52, "north"], "row": 6, "lateral": 2, "name": "toilets" }, + { "kind": "flat", "grid": [45, 52, "north"], "row": 8, "lateral": 2, "name": "merryGoRound" }, + { "kind": "flat", "grid": [45, 52, "north"], "row": 8, "lateral": -2, "name": "swingingShip" }, + { "kind": "flat", "grid": [19, 47, "north"], "row": 2, "lateral": -2, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [19, 47, "north"], "row": 4, "lateral": 2, "name": "informationKiosk" }, + { "kind": "flat", "grid": [19, 47, "north"], "row": 7, "lateral": 2, "name": "swingingShip" }, + { "kind": "flat", "grid": [19, 47, "north"], "row": 9, "lateral": -6, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [19, 61, "west"], "row": 4, "lateral": 2, "name": "swingingShip" }, + { "kind": "flat", "grid": [19, 61, "west"], "row": 4, "lateral": -2, "name": "toilets" }, + { "kind": "flat", "grid": [19, 61, "west"], "row": 10, "lateral": 2, "name": "swingingShip" } +] diff --git a/bench/strategy/site-plan.ts b/bench/strategy/site-plan.ts new file mode 100644 index 000000000..c4ee4a680 --- /dev/null +++ b/bench/strategy/site-plan.ts @@ -0,0 +1,244 @@ +import { + LAND_PRICE_CENTS, + PATH_COST_CENTS, + RIGHTS_PRICE_CENTS, + SALE_LAND, + SALE_RIGHTS, +} from '../../src/sim/map/tile-map'; +import { RIDE_CATALOG } from '../../src/sim/rides/ride-types'; +import { PathAddition } from '../../src/sim/map/paths'; +import { ParkGrid } from '../../src/sim/scenario/park-grid'; +import { PREBUILT_TYPES } from '../../src/sim/scenario/scenario-prebuilt'; +import type { EntranceSide } from '../../src/sim/scenario/scenario'; +import type { ParkBuilder } from './builder'; +import { StaffKind } from './builder'; +import type { Strategy, StrategyFactory } from './run'; +import { TICKS_PER_MONTH } from './run'; +import { + clearScenery, + flatGroundPath, + layRoute, + openFlatRide, + siteBounds, + startCoaster, + waypoints, +} from './site'; +import type { CoasterSite } from './site'; + +/** Loans move in $1,000 steps. */ +const LOAN_STEP_CENTS = 100_000; + +/** One build decision of a site plan; see `sitePlanStrategy`. */ +export type SiteStep = + /** A flat ride or stall on the builder's spine from the gate. */ + | { kind: 'item'; name: string } + /** + * A footpath through `points`, starting beside `from` (a tile already holding a flat path) or + * the end of the gate spine, clearing scenery on the way when the park allows it. + */ + | { kind: 'route'; points: Array<[number, number]>; clear: boolean; from?: [number, number] } + /** A coaster at a fixed site, buying the land and rights under it first. */ + | { kind: 'coaster'; site: CoasterSite } + /** + * A flat ride or stall beside a spine path laid along `grid` (gate x, gate y, side) for rows + * 0..`row`, the way the builder lays rides along its own spine. + */ + | { + kind: 'flat'; + grid: [number, number, EntranceSide]; + row: number; + lateral: number; + name: string; + } + /** Buys land or rights in a rectangle. */ + | { kind: 'buy'; x: number; y: number; width: number; height: number; rights: boolean } + /** Clears scenery from the owned part of a rectangle with the Clear tool. */ + | { kind: 'clear'; x: number; y: number; width: number; height: number }; + +export interface SitePlan { + steps: SiteStep[]; + /** Cash kept back for wages and running costs. */ + reserveCents: number; + prices: Record; + /** One handyman per this many rides and stalls (rounded up), at least one. */ + itemsPerHandyman: number; + /** One mechanic per this many attractions. */ + attractionsPerMechanic: number; + /** Repay the loan once cash exceeds it by this much. */ + repayAboveCents?: number; + /** Borrow up to the limit when a step is short of cash. */ + borrow?: boolean; + /** + * Patrol areas, inclusive tile rectangles [x0, y0, x1, y1], dealt to handymen in turn so a + * spread-out park is swept everywhere rather than only around the gate. + */ + patrols?: Array<[number, number, number, number]>; +} + +/** + * Plays a park through a fixed list of placements chosen for its terrain: each step is built, in + * order, as soon as the park can afford it on top of its reserve. Every placement goes through + * ordinary player commands, so the game's ownership, terrain and scenario rules apply. + */ +export function sitePlanStrategy(plan: SitePlan): StrategyFactory { + return () => { + let next = 0; + let nextDecision = 0; + let nextAdvance = 0; + const patrolled = new Set(); + const strategy: Strategy = { + step(b) { + const tick = b.tick; + if (tick === 0) b.prices = plan.prices; + if (tick >= nextAdvance) { + nextAdvance = tick + 64; + b.advance(); + } + if (tick < nextDecision) return; + nextDecision = tick + TICKS_PER_MONTH / 8; + while (next < plan.steps.length) { + const step = plan.steps[next]; + const cost = costOf(b, step); + const l = b.sim.world.economy; + if (plan.borrow && l.cash < cost + plan.reserveCents && l.loan < l.maxLoan) { + const short = cost + plan.reserveCents - l.cash; + b.borrow( + Math.min(l.maxLoan - l.loan, Math.ceil(short / LOAN_STEP_CENTS) * LOAN_STEP_CENTS), + ); + b.sim.step(); + } + if (l.cash < cost + plan.reserveCents) break; + perform(b, step); + next++; + } + const items = b.sim.world.rides.count; + b.staffTo(StaffKind.Handyman, Math.max(1, Math.ceil(items / plan.itemsPerHandyman))); + b.staffTo(StaffKind.Mechanic, Math.ceil(b.attractions() / plan.attractionsPerMechanic)); + if (plan.patrols) assignPatrols(b, plan.patrols, patrolled); + const l = b.sim.world.economy; + if ( + plan.repayAboveCents !== undefined && + l.loan > 0 && + l.cash > l.loan + plan.repayAboveCents + ) + b.repay(l.loan); + }, + }; + return strategy; + }; +} + +function assignPatrols( + b: ParkBuilder, + areas: Array<[number, number, number, number]>, + patrolled: Set, +): void { + const staff = b.sim.world.staff; + for (let slot = 0; slot < staff.count; slot++) { + const id = staff.slotToId[slot]; + if (staff.cols.kind[slot] !== StaffKind.Handyman || patrolled.has(id)) continue; + const [x0, y0, x1, y1] = areas[patrolled.size % areas.length]; + patrolled.add(id); + for (let y = y0; y <= y1; y += 4) + for (let x = x0; x <= x1; x += 4) + b.sim.enqueue({ type: 'setStaffPatrolTile', staffId: id, x, y, enabled: true }); + } +} + +function saleCost( + b: ParkBuilder, + r: { x: number; y: number; width: number; height: number }, +): number { + const m = b.sim.world.map; + let cents = 0; + for (let y = Math.max(0, r.y); y < Math.min(m.height, r.y + r.height); y++) + for (let x = Math.max(0, r.x); x < Math.min(m.width, r.x + r.width); x++) { + const o = m.ownership[m.index(x, y)]; + if (o & SALE_LAND) cents += LAND_PRICE_CENTS; + else if (o & SALE_RIGHTS) cents += RIGHTS_PRICE_CENTS; + } + return cents; +} + +function costOf(b: ParkBuilder, step: SiteStep): number { + switch (step.kind) { + case 'item': + return b.costOf(step.name); + case 'route': + return waypoints(step.points).length * PATH_COST_CENTS * 3; + case 'coaster': + return 350_000 + saleCost(b, siteBounds(step.site)); + case 'flat': + return RIDE_CATALOG[PREBUILT_TYPES[step.name]].cost + (step.row + 12) * PATH_COST_CENTS; + case 'buy': + return saleCost(b, step); + case 'clear': + return step.width * step.height * 2_000; + } +} + +function spineEnd(b: ParkBuilder): [number, number] { + const m = b.sim.world.map; + let row = 0; + while (m.pathElement(m.index(...b.grid.tile(row + 1, 0)), -1) >= 0) row++; + return b.grid.tile(row, 0); +} + +function perform(b: ParkBuilder, step: SiteStep): void { + const sim = b.sim; + const m = sim.world.map; + switch (step.kind) { + case 'item': + b.build(step.name); + return; + case 'route': { + const start = step.from ?? spineEnd(b); + const tiles = waypoints([start, ...step.points]).slice(1); + if (step.clear) clearScenery(sim, tiles); + layRoute(sim, tiles, m.heights[m.index(start[0], start[1])]); + return; + } + case 'coaster': { + const area = siteBounds(step.site); + sim.enqueue({ type: 'buyLand', ...area, rights: false }); + sim.enqueue({ type: 'buyLand', ...area, rights: true }); + sim.step(); + const rideId = startCoaster(sim, step.site, (t) => flatGroundPath(sim, t)); + if (rideId === null) return; + if (b.prices.coaster !== undefined) + sim.enqueue({ type: 'setRidePrice', rideId, priceCents: b.prices.coaster }); + b.watch(rideId); + return; + } + case 'flat': { + const grid = new ParkGrid(...step.grid); + for (let row = 0; row <= step.row; row++) { + const [x, y] = grid.tile(row, 0); + if (m.pathElement(m.index(x, y), -1) >= 0) continue; + sim.enqueue({ type: 'placePath', x, y }); + if (row % 2 === 0) + sim.enqueue({ type: 'setPathAddition', x, y, addition: PathAddition.Bin }); + } + sim.step(); + const ride = openFlatRide(sim, grid, step.row, step.lateral, step.name); + const price = ride ? b.prices[step.name] : undefined; + if (ride && price !== undefined) + sim.enqueue({ type: 'setRidePrice', rideId: ride.rideId, priceCents: price }); + return; + } + case 'buy': + sim.enqueue({ type: 'buyLand', ...step }); + sim.step(); + return; + case 'clear': + sim.enqueue({ + type: 'clearScenery', + x: step.x, + y: step.y, + width: step.width, + height: step.height, + }); + sim.step(); + return; + } +} diff --git a/bench/strategy/site.ts b/bench/strategy/site.ts index bae0dc2be..0a2c7a324 100644 --- a/bench/strategy/site.ts +++ b/bench/strategy/site.ts @@ -4,7 +4,7 @@ import { pieceByName } from '../../src/sim/track/catalog'; import { getConstructionCursor, rotateTile } from '../../src/sim/track/construction'; import { RIDE_CATALOG, RideType } from '../../src/sim/rides/ride-types'; import { DIR_DX, DIR_DY, ElementType, PathFlag, SLOPE_DIR_SHIFT } from '../../src/sim/map/tile-map'; -import { PathResult, planPathPlacement } from '../../src/sim/map/paths'; +import { PathAddition, PathResult, planPathPlacement } from '../../src/sim/map/paths'; import { COASTER_TEMPLATES, mirrored } from './coasters'; import { RideState } from '../../src/sim/rides/ride-store'; import { validateRidePlacement } from '../../src/sim/rides/ride-footprint'; @@ -136,6 +136,8 @@ export function layRoute( const z = Math.min(edge[k], edge[k + 1]); const slope = rise > 0 ? forward : rise < 0 ? (forward + 2) % 4 : -1; sim.enqueue({ type: 'placePath', x, y, z, slope, queue }); + if (!queue && slope < 0 && k % 3 === 2) + sim.enqueue({ type: 'setPathAddition', x, y, addition: PathAddition.Bin }); levels.push(z); } sim.step(); @@ -246,15 +248,16 @@ export interface OpenedRide { /** * Builds a coaster at `site`, lays its queue from the entrance and a path from the exit to tiles - * `joins` accepts, tests it and opens it. With `clear`, scenery on the entrance and exit tiles is - * removed first. Returns null when the circuit does not close or a path cannot be laid. + * `joins` accepts, and starts its test run. With `clear`, scenery on the entrance and exit tiles + * is removed first. Returns the ride id, or null when the circuit does not close or a path cannot + * be laid. */ -export function openCoaster( +export function startCoaster( sim: Simulation, site: CoasterSite, joins: (tile: number) => boolean, clear = true, -): OpenedRide | null { +): number | null { const world = sim.world; const c = buildCircuit(sim, site); if (!c.closed) return null; @@ -269,19 +272,62 @@ export function openCoaster( sim.enqueue({ type: 'placeRideExit', rideId: c.rideId, x: c.exit[0], y: c.exit[1] }); sim.enqueue({ type: 'setRideStatus', rideId: c.rideId, status: 'test' }); sim.step(); - const slot = () => world.rides.idToSlot[c.rideId]; + return c.rideId; +} + +/** `startCoaster`, then waits for the test run and opens the coaster. */ +export function openCoaster( + sim: Simulation, + site: CoasterSite, + joins: (tile: number) => boolean, + clear = true, +): OpenedRide | null { + const world = sim.world; + const rideId = startCoaster(sim, site, joins, clear); + if (rideId === null) return null; + const slot = () => world.rides.idToSlot[rideId]; for (let t = 0; t < 12_000 && world.rides.cols.tested[slot()] !== 1; t++) sim.step(); for (let t = 0; t < 4_000 && world.rides.cols.state[slot()] !== RideState.Open; t++) { - if (t % 50 === 0) sim.enqueue({ type: 'setRideStatus', rideId: c.rideId, status: 'open' }); + if (t % 50 === 0) sim.enqueue({ type: 'setRideStatus', rideId, status: 'open' }); sim.step(); } return { - rideId: c.rideId, + rideId, state: world.rides.cols.state[slot()], excitement: world.rides.cols.excitement[slot()], }; } +/** Tile rectangle a coaster at `site` and its station paths can cover, with a margin. */ +export function siteBounds( + site: CoasterSite, + margin = 2, +): { + x: number; + y: number; + width: number; + height: number; +} { + const t = COASTER_TEMPLATES[site.template]; + const [y0, y1] = site.mirror ? [-t.maxY, 0] : [0, t.maxY]; + const corners = [ + [t.minX, y0 - 2], + [t.maxX, y0 - 2], + [t.minX, y1 + 2], + [t.maxX, y1 + 2], + ].map(([i, j]) => rotateTile(i, j, site.dir)); + const xs = corners.map(([x]) => site.x + x); + const ys = corners.map(([, y]) => site.y + y); + const x = Math.min(...xs) - margin; + const y = Math.min(...ys) - margin; + return { + x, + y, + width: Math.max(...xs) + margin - x + 1, + height: Math.max(...ys) + margin - y + 1, + }; +} + /** * Builds and opens a flat ride or stall beside a spine path the caller already laid, at * (`row`, `lateral`) on `grid`, the way the scripted builder places rides along its spine. @@ -300,8 +346,11 @@ export function openFlatRide( return null; const service = RIDE_CATALOG[type].category === 'stall' || RIDE_CATALOG[type].category === 'facility'; - for (const [x, y] of frontage.queue) sim.enqueue({ type: 'placePath', x, y, queue: !service }); - for (const [x, y] of frontage.exitPath) sim.enqueue({ type: 'placePath', x, y }); + for (const [x, y] of [...frontage.queue, ...frontage.exitPath]) { + const queue = frontage.queue.some(([qx, qy]) => qx === x && qy === y) && !service; + sim.enqueue({ type: 'placePath', x, y, queue }); + sim.enqueue({ type: 'setPathAddition', x, y, addition: PathAddition.Bin }); + } sim.enqueue({ type: 'createRide', rideType: type, diff --git a/bench/strategy/strategies.ts b/bench/strategy/strategies.ts index 9107786b0..86bbf37b4 100644 --- a/bench/strategy/strategies.ts +++ b/bench/strategy/strategies.ts @@ -1,5 +1,10 @@ import type { StrategyFactory } from './run'; import { growthStrategy } from './growth'; +import { sitePlanStrategy } from './site-plan'; +import type { SiteStep } from './site-plan'; +import thunderheadPlan from './plans/thunderhead-mesa.json'; +import tidewaterPlan from './plans/tidewater-docks.json'; +import mossgrovePlan from './plans/mossgrove-isle.json'; /** Build orders are written as space-separated names. */ const list = (names: string): string[] => names.split(/\s+/).filter(Boolean); @@ -50,6 +55,19 @@ STRATEGIES['bramblewood-hollow'] = growthStrategy({ growth: LONG_GROWTH.slice(0, 14), }); +STRATEGIES['mossgrove-isle'] = sitePlanStrategy({ + steps: mossgrovePlan as SiteStep[], + reserveCents: 300_000, + patrols: [ + [28, 34, 44, 50], + [16, 18, 36, 40], + [36, 18, 54, 40], + ], + prices: RIDE_PRICES, + itemsPerHandyman: 1, + attractionsPerMechanic: 3, +}); + STRATEGIES['copper-ridge'] = growthStrategy({ ...BASE, reserveCents: 150_000, @@ -69,27 +87,36 @@ STRATEGIES['copper-ridge'] = growthStrategy({ ], }); -STRATEGIES['tidewater-docks'] = growthStrategy({ - ...BASE, - itemsPerHandyman: 1.5, - reserveCents: 600_000, +STRATEGIES['tidewater-docks'] = sitePlanStrategy({ + steps: tidewaterPlan as SiteStep[], + reserveCents: 400_000, + patrols: [ + [8, 38, 24, 56], + [8, 52, 24, 64], + [16, 56, 64, 64], + [30, 38, 50, 62], + ], prices: RIDE_PRICES, - jitter: { skipPercent: 15, startDelayMonths: 2 }, - opening: OPENING, - growth: LONG_GROWTH.slice(0, 18), - extra: (b) => { - const l = b.sim.world.economy; - if (l.loan > 0 && l.cash > l.loan + 150_000) b.repay(l.loan); - }, + itemsPerHandyman: 1.5, + attractionsPerMechanic: 3, + repayAboveCents: 150_000, }); -STRATEGIES['thunderhead-mesa'] = growthStrategy({ - ...BASE, - itemsPerHandyman: 1.5, +STRATEGIES['thunderhead-mesa'] = sitePlanStrategy({ + steps: thunderheadPlan as SiteStep[], + reserveCents: 200_000, + patrols: [ + [30, 8, 62, 28], + [30, 8, 62, 28], + [8, 46, 40, 64], + [30, 8, 62, 28], + [18, 22, 38, 52], + [58, 50, 84, 64], + [56, 26, 74, 52], + ], prices: RIDE_PRICES, - jitter: { skipPercent: 25, startDelayMonths: 3 }, - opening: OPENING, - growth: LONG_GROWTH.slice(0, 16), + itemsPerHandyman: 2, + attractionsPerMechanic: 3, }); STRATEGIES['glacier-point'] = growthStrategy({ diff --git a/docs/scenario-remixes.md b/docs/scenario-remixes.md new file mode 100644 index 000000000..d91fe07fa --- /dev/null +++ b/docs/scenario-remixes.md @@ -0,0 +1,57 @@ +# Hard scenario remixes + +The Challenging and Expert parks are original OpenCoaster designs. Each borrows one idea from a +RollerCoaster Tycoon 2 scenario and rebuilds it with OpenCoaster's map recipe: irregular owned land +(`land.parcels`), shaped terrain (`terrain.shapes`), dense woods and clearings (`trees.stands`, +`trees.clearings`), and the scenario rules in [scenario-restrictions.md](scenario-restrictions.md). +No original map, layout, park name, sprite or scenario file is used. Where a park copies a rule the +source scenario does not have, the matrix says so. + +## Sources + +- RCT2 manual, p. 23 ("Buy Land", "Buy Construction Rights") and pp. 57-62 (scenario editor: + "The land owned by the player is a single continuous piece of land", "A U-shaped park will + confuse your guests", forbidding tree removal, high construction and marketing): + . Page numbers are the + manual's printed pages. +- Scenario prohibitions (only Rainbow Summit uses them among the 15 original RCT2 scenarios; the + Wacky Worlds expansion forbids landscaping in Grand Canyon and others; Rainbow Valley and + Harmonic Hills are RCT1): +- Botany Breakers ("a small island overgrown with trees... the trees provide great scenery at the + expense of removal cost"; monthly ride income; no prohibitions): + +- Rainbow Summit ("Built on a hillside, this park is forbidden from building anything tall", + nothing above 10.5 m, marketing prohibited): +- Gravity Gardens ("No other rides, just roller coasters!", stalls and shops still allowed; repay + loan and park value): +- Alpine Adventures (small mountain ski resort with a lone chairlift; monthly ride income): + +- Fungus Woods ("lots and lots of trees") and Infernal Views (lava channels through the park): + , + +## Design matrix + +| Park | RCT2 idea (cited above) | OpenCoaster design | Owned land at start | Woods and clearance | Rules | Objective | A route to the goal | +| -------------------------------------- | ----------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Copper Ridge (Challenging, 96²) | Infernal Views' channels cutting a park apart; Grand Canyon's landscaping ban (Wacky Worlds, an expansion). | Red ridges with a dry gulch across the park. The gate bench (level 8) is reached from the south; a narrow owned trail crosses the gulch (level 5) to the west bench (level 11). East and summit benches are land for sale; the gulch and the ridge saddle are rights only. | 849 tiles: gate bench, trail and west bench (was a 2,916-tile rectangle). | Scattered boulders on the benches; no trees on the dirt ridges. Gate clearing 17×12. | No landscaping (our remix of the expansion rule). | Five coasters of 4.60+ excitement by the end of year 2 (was year 1). | Follow the trail across the gulch and fit coasters on the benches; terrain and nearby rocks lift ratings (the west-bench compact circuit rates 4.98 against 4.67 on flat ground). | +| Tidewater Docks (Challenging, 80²) | Lucky Lake's waterfront; the manual's warning that a U-shaped park confuses guests; construction rights. | An old harbour: a hook of quays round a basin with three finger piers. The basin and inlets are rights only, so they can be bridged but never filled; the third pier and the east breakwater are land for sale. | 966 tiles: west quay, south quay and two piers (was 3,136). | Woods on the banks and beyond the quays; gate clearing 13×10. | None: the shape is the challenge. | Repay the loan and reach $5,500 park value by the end of year 4 (unchanged). | Walk the south quay, buy rights over an inlet and bridge it, and stand narrow rides (a Ferris wheel fits a five-tile pier) along the piers. | +| Thunderhead Mesa (Expert, 96²) | Rainbow Summit's height limit and marketing ban; Extreme Heights' desert. | A scorched mesa top with buttes (level 16) above a dry canyon (level 4), with a narrow cliff trail down to the west shelf (11). East (13) and south (7) shelves are for sale behind steep corridors; the canyon is rights only. | 1,023 tiles: mesa top, cliff trail and west shelf (was 4,356). | Cacti and rock scatter; gate clearing 15×8. | Nothing more than 6 levels above local ground; no marketing (Rainbow Summit's rules, with OpenCoaster's own cap). | 460 guests and rating 700 by the end of year 4 (unchanged). | Build low on the mesa, take the cliff trail to the west shelf, and spread rides over the shelves; patrol handymen by area because the park is long. | +| Glacier Point (Expert, 96²) | Gravity Gardens' coaster-only roster; Alpine Adventures' mountain resort and chairlift. | Mountain shelves above a glacial lake. The gate shelf (12) sits on a saddle; a steep owned trail drops to a lake-shore shelf (6). A forested middle shelf (10) and a summit shelf (18) are for sale; the mountainside between them is rights only. | 589 tiles: gate shelf, trail and shore shelf (was 2,916). | Conifer and birch woods on the slopes and purchasable shelves; gate clearing 11×8. | Only coasters, stalls, toilets and the chairlift: gentle, thrill, water, transport rides other than the chairlift and the observation tower are forbidden (Gravity Gardens' roster is a research list, not a prohibition; here it is a rule). | Five coasters of 4.70+ excitement by the end of year 2 (was six of 4.90+ in about a month and a half). | Coasters on the gate shelf rate 5.2 to 5.9 on the mountainside; buy and clear the middle shelf or take the trail down to the shore for the rest. | +| Mossgrove Isle (Challenging, 72², new) | Botany Breakers' tree-covered island and monthly ride income; Fungus Woods' dense trees. | A wooded island reached by a causeway. A flat island core holds four small clearings joined by narrow trails; a protected grove on the knoll is not for sale; shallows to the south are rights only and a wooded islet is for sale. | 1,151 tiles, ellipse with a hole (bounding-box fill 65%). | About half the owned dry land is wooded; clearings of roughly 10×8. | No tree removal (our remix: Botany Breakers has no prohibitions; its trees only cost money to clear). | $900 a month in ride ticket income by the end of year 3. | Build in the clearings along the trails, lift track above the trees, and use the shallows for water rides. | + +## How the parks are validated + +- `src/sim/scenario/hard-scenarios.test.ts` checks each park's identity on the generated map: one + connected, non-rectangular owned piece; parcels that stay unbuyable after buying every sale; + a small gate clearing; height variation; and the park's own feature (Copper's benches, + Tidewater's rights-only water, Thunderhead's shelves, Glacier's lake and mountains, Mossgrove's + woods and open trails). +- `bench/hard-parks.test.ts` plays the start of every park with ordinary commands and the park's + real cash: the gate opens onto working stalls and a first ride, the park's defining move is + built and guests use it, and each park refuses the action its rules forbid. +- `pnpm balance -- --scenario ` plays each park with a scripted strategy. The hard parks use + site plans (`bench/strategy/site-plan.ts`, plans in `bench/strategy/plans/`) because the old + flat-apron scripts cannot fit rides on the new ground. Results are in + [BALANCE.md](BALANCE.md#hard-park-remixes). +- Saves keep their own map: a park saved before the remix loads with its old land, terrain and + scenery (`src/save/scenario-remix-saves.test.ts`). diff --git a/e2e/hard-parks-proof.spec.ts b/e2e/hard-parks-proof.spec.ts new file mode 100644 index 000000000..3df1b175e --- /dev/null +++ b/e2e/hard-parks-proof.spec.ts @@ -0,0 +1,143 @@ +import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'; +import { join } from 'node:path'; +import { devices, expect, test } from '@playwright/test'; +import type { Page, Request } from '@playwright/test'; +import { project } from '../src/render/projection'; + +/** + * Screenshots of the remixed hard parks for the PR proof: the scenario list entry, a whole-map + * overview and the gate on a fresh game, and the built proof park (see bench/hard-parks.test.ts, + * run with HARD_PROOF_SAVES) at its characteristic spot. Runs only when HARD_PROOF_DIR names the + * output directory; CANVAS2D=1 selects Canvas2D and MOBILE=1 the Pixel 8 viewport. + */ +const proofDir = process.env.HARD_PROOF_DIR; +const savesDir = process.env.HARD_PROOF_SAVES; +const useCanvas2d = process.env.CANVAS2D === '1'; +const mobile = process.env.MOBILE === '1'; +const tag = `${useCanvas2d ? 'canvas2d' : 'webgl2'}-${mobile ? 'mobile' : 'desktop'}`; + +const PARKS = [ + { id: 'copper-ridge', name: 'Copper Ridge', tab: 'Challenging Parks', gate: [46, 84, 8] }, + { id: 'tidewater-docks', name: 'Tidewater Docks', tab: 'Challenging Parks', gate: [12, 47, 6] }, + { id: 'mossgrove-isle', name: 'Mossgrove Isle', tab: 'Challenging Parks', gate: [35, 46, 6] }, + { id: 'thunderhead-mesa', name: 'Thunderhead Mesa', tab: 'Expert Parks', gate: [46, 13, 16] }, + { id: 'glacier-point', name: 'Glacier Point', tab: 'Expert Parks', gate: [87, 52, 12] }, +] as const satisfies ReadonlyArray<{ gate: readonly [number, number, number] }>; + +interface ProofWindow { + __sim: { map: { width: number; height: number }; setPaused(paused: boolean): void }; + __camera: { x: number; y: number; zoom: number; rotation: number }; +} + +if (mobile) test.use({ ...devices['Pixel 8'], defaultBrowserType: undefined } as never); + +/** Every sprite page the renderer asked for has been served and nothing new was asked for lately. */ +function spriteIdleTracker(page: Page) { + let pending = 0; + let last = Date.now(); + const atlas = (r: Request) => /\/sprites\//.test(r.url()); + page.on('request', (r) => { + if (atlas(r)) { + pending++; + last = Date.now(); + } + }); + const done = (r: Request) => { + if (atlas(r)) { + pending--; + last = Date.now(); + } + }; + page.on('requestfinished', done); + page.on('requestfailed', done); + return async () => { + const deadline = Date.now() + 60_000; + while (pending > 0 || Date.now() - last < 1500) { + if (Date.now() > deadline) throw new Error('sprite pages did not finish loading'); + await page.waitForTimeout(100); + } + }; +} + +async function look(page: Page, tile: readonly [number, number, number], zoom: number) { + const size = await page.evaluate(() => (window as unknown as ProofWindow).__sim.map); + const at = new Float64Array(2); + project(tile[0] * 256 + 128, tile[1] * 256 + 128, tile[2] * 64, size.width, size.height, 0, at); + await page.evaluate( + ([x, y, z]) => { + const camera = (window as unknown as ProofWindow).__camera; + camera.x = x!; + camera.y = y!; + camera.zoom = z!; + camera.rotation = 0; + }, + [at[0], at[1], zoom], + ); + await page.mouse.move(2, 2); +} + +async function shot(page: Page, name: string): Promise { + await page.waitForTimeout(1200); + writeFileSync(join(proofDir!, `${name}-${tag}.png`), await page.screenshot()); +} + +async function useRenderer(page: Page): Promise { + if (!useCanvas2d) return; + await page.addInitScript(() => { + const original = HTMLCanvasElement.prototype.getContext; + HTMLCanvasElement.prototype.getContext = function (type: string, ...args: unknown[]) { + if (type === 'webgl2' || type === 'webgl' || type === 'experimental-webgl') return null; + return original.call(this, type as '2d', ...(args as [])); + } as typeof HTMLCanvasElement.prototype.getContext; + }); +} + +for (const park of PARKS) { + test(`${park.name}: scenario list, overview, gate and built proof`, async ({ page }) => { + test.skip(!proofDir, 'set HARD_PROOF_DIR'); + test.setTimeout(600_000); + mkdirSync(proofDir!, { recursive: true }); + await useRenderer(page); + const idle = spriteIdleTracker(page); + + await page.goto('/'); + await page.getByRole('button', { name: 'New game' }).click(); + await page.getByRole('tab', { name: park.tab }).click(); + const card = page.locator('.scenario-card').filter({ hasText: park.name }); + await card.getByRole('button', { name: park.name, exact: true }).click(); + await expect(page.locator('.scenario-preview-panel')).toContainText('Terrain:'); + await expect(page.locator('.scenario-preview-panel')).toContainText('Park rules:'); + await shot(page, `${park.id}-select`); + + await card.getByRole('button', { name: 'Start', exact: true }).click(); + await expect(page.locator('.hud')).toContainText(useCanvas2d ? 'Canvas2D' : 'WebGL2'); + await page.evaluate(() => (window as unknown as ProofWindow).__sim.setPaused(true)); + const size = await page.evaluate(() => (window as unknown as ProofWindow).__sim.map); + const viewport = page.viewportSize()!; + const fit = Math.min(viewport.width / (size.width * 64), viewport.height / (size.height * 32)); + await look(page, [size.width / 2, size.height / 2, 6], fit * 0.95); + await idle(); + await shot(page, `${park.id}-overview`); + + await look(page, park.gate, mobile ? 0.5 : 1); + await idle(); + await shot(page, `${park.id}-gate`); + if (!savesDir) return; + const meta = JSON.parse(readFileSync(join(savesDir, `${park.id}.json`), 'utf8')) as { + focus: [number, number, number]; + }; + await page.goto('/'); + await page + .locator('input[type="file"]') + .first() + .setInputFiles(join(savesDir, `${park.id}.ocsave`)); + await expect(page.locator('.hud')).toContainText('tick'); + await page.evaluate(() => (window as unknown as ProofWindow).__sim.setPaused(true)); + await look(page, meta.focus, 1); + await idle(); + await shot(page, `${park.id}-built`); + await look(page, meta.focus, 0.5); + await idle(); + await shot(page, `${park.id}-built-wide`); + }); +} From f4188da7b9dba66e0044b39c2324bf3c0a8aa32f Mon Sep 17 00:00:00 2001 From: "nori-sessions[bot]" <264258699+nori-sessions[bot]@users.noreply.github.com> Date: Sun, 1 Nov 2026 08:07:27 +0000 Subject: [PATCH 08/18] Scenario-aware site plans for every hard park; harness plays the real park map Co-authored-by: Nori --- bench/strategy/plans/copper-ridge.json | 47 +++++++++ bench/strategy/plans/glacier-point.json | 47 +++++++++ bench/strategy/run.ts | 4 +- bench/strategy/site-plan.ts | 33 ++++-- bench/strategy/site.ts | 105 +++++++++++++++++-- bench/strategy/strategies.ts | 52 ++++----- public/scenario-previews/copper-ridge@1x.png | Bin 2686 -> 2701 bytes public/scenario-previews/copper-ridge@2x.png | Bin 3482 -> 3493 bytes public/scenario-previews/manifest.json | 2 +- src/sim/scenario/scenarios/copper-ridge.json | 4 +- 10 files changed, 244 insertions(+), 50 deletions(-) create mode 100644 bench/strategy/plans/copper-ridge.json create mode 100644 bench/strategy/plans/glacier-point.json diff --git a/bench/strategy/plans/copper-ridge.json b/bench/strategy/plans/copper-ridge.json new file mode 100644 index 000000000..739421886 --- /dev/null +++ b/bench/strategy/plans/copper-ridge.json @@ -0,0 +1,47 @@ +[ + { "kind": "item", "name": "foodStall" }, + { "kind": "item", "name": "drinkStall" }, + { "kind": "item", "name": "toilets" }, + { "kind": "item", "name": "merryGoRound" }, + { + "kind": "route", + "points": [ + [46, 75], + [34, 75], + [34, 42] + ], + "clear": true + }, + { + "kind": "coaster", + "site": { "template": "compact", "x": 24, "y": 42, "dir": 1, "mirror": false } + }, + { + "kind": "coaster", + "site": { "template": "compact", "x": 42, "y": 44, "dir": 2, "mirror": false } + }, + { + "kind": "coaster", + "site": { "template": "compact", "x": 54, "y": 78, "dir": 0, "mirror": false } + }, + { + "kind": "coaster", + "site": { "template": "compact", "x": 42, "y": 80, "dir": 0, "mirror": true } + }, + { "kind": "buy", "x": 58, "y": 36, "width": 1, "height": 42, "rights": false }, + { + "kind": "route", + "points": [ + [58, 77], + [58, 36] + ], + "clear": true, + "from": [46, 77] + }, + { "kind": "buy", "x": 59, "y": 37, "width": 13, "height": 1, "rights": false }, + { "kind": "route", "points": [[70, 37]], "clear": true, "from": [58, 37] }, + { + "kind": "coaster", + "site": { "template": "compact", "x": 72, "y": 34, "dir": 1, "mirror": true } + } +] diff --git a/bench/strategy/plans/glacier-point.json b/bench/strategy/plans/glacier-point.json new file mode 100644 index 000000000..79ab253b2 --- /dev/null +++ b/bench/strategy/plans/glacier-point.json @@ -0,0 +1,47 @@ +[ + { "kind": "item", "name": "foodStall" }, + { "kind": "item", "name": "drinkStall" }, + { "kind": "item", "name": "toilets" }, + { + "kind": "route", + "points": [ + [80, 52], + [80, 59], + [74, 59], + [74, 61], + [70, 61], + [70, 64], + [66, 64], + [66, 67], + [61, 67], + [61, 70] + ], + "clear": true + }, + { "kind": "buy", "x": 50, "y": 42, "width": 24, "height": 18, "rights": false }, + { "kind": "buy", "x": 50, "y": 42, "width": 24, "height": 18, "rights": true }, + { + "kind": "coaster", + "site": { "template": "compact", "x": 82, "y": 56, "dir": 3, "mirror": false } + }, + { + "kind": "coaster", + "site": { "template": "switchback", "x": 66, "y": 48, "dir": 1, "mirror": false } + }, + { + "kind": "coaster", + "site": { "template": "compact", "x": 58, "y": 50, "dir": 2, "mirror": true } + }, + { + "kind": "coaster", + "site": { "template": "switchback", "x": 82, "y": 46, "dir": 1, "mirror": false } + }, + { + "kind": "coaster", + "site": { "template": "compact", "x": 70, "y": 54, "dir": 3, "mirror": true } + }, + { + "kind": "coaster", + "site": { "template": "compact", "x": 59, "y": 71, "dir": 1, "mirror": false } + } +] diff --git a/bench/strategy/run.ts b/bench/strategy/run.ts index 94218f22d..26d4d36d3 100644 --- a/bench/strategy/run.ts +++ b/bench/strategy/run.ts @@ -1,6 +1,6 @@ import { Simulation } from '../../src/sim/core/simulation'; import { TICKS_PER_MONTH, TICKS_PER_YEAR } from '../../src/sim/economy/calendar'; -import { prepareScenario } from '../../src/sim/scenario/scenario-layout'; +import { prepareScenarioPark } from '../../src/sim/scenario/scenario-layout'; import { ScenarioStatus } from '../../src/sim/scenario/scenario'; import { objectiveMetric } from '../../src/sim/scenario/scenario-system'; import type { ScenarioDef } from '../../src/sim/scenario/scenario'; @@ -43,7 +43,7 @@ export function runScenario( opts: RunOptions, ): RunResult { const sim = new Simulation({ seed: opts.seed, width: def.mapWidth, height: def.mapHeight }); - prepareScenario(sim.world, def); + prepareScenarioPark(sim.world, def); // The strategy suite isolates park and economy balance from research pacing. sim.world.research.unlocked = new Set(Object.keys(RIDE_CATALOG).map(Number)); const builder = new ParkBuilder(sim, def); diff --git a/bench/strategy/site-plan.ts b/bench/strategy/site-plan.ts index c4ee4a680..fd12eeab2 100644 --- a/bench/strategy/site-plan.ts +++ b/bench/strategy/site-plan.ts @@ -7,6 +7,8 @@ import { } from '../../src/sim/map/tile-map'; import { RIDE_CATALOG } from '../../src/sim/rides/ride-types'; import { PathAddition } from '../../src/sim/map/paths'; +import { SCENERY_CATALOG } from '../../src/sim/map/scenery'; +import type { SceneryItem } from '../../src/sim/map/scenery'; import { ParkGrid } from '../../src/sim/scenario/park-grid'; import { PREBUILT_TYPES } from '../../src/sim/scenario/scenario-prebuilt'; import type { EntranceSide } from '../../src/sim/scenario/scenario'; @@ -15,6 +17,7 @@ import { StaffKind } from './builder'; import type { Strategy, StrategyFactory } from './run'; import { TICKS_PER_MONTH } from './run'; import { + circuitTiles, clearScenery, flatGroundPath, layRoute, @@ -37,7 +40,7 @@ export type SiteStep = * the end of the gate spine, clearing scenery on the way when the park allows it. */ | { kind: 'route'; points: Array<[number, number]>; clear: boolean; from?: [number, number] } - /** A coaster at a fixed site, buying the land and rights under it first. */ + /** A coaster at a fixed site, buying the land and rights under it and clearing its track tiles first. */ | { kind: 'coaster'; site: CoasterSite } /** * A flat ride or stall beside a spine path laid along `grid` (gate x, gate y, side) for rows @@ -64,6 +67,8 @@ export interface SitePlan { itemsPerHandyman: number; /** One mechanic per this many attractions. */ attractionsPerMechanic: number; + /** Scenery planted round each coaster station before its test run. */ + decorate?: { item: SceneryItem; count: number }; /** Repay the loan once cash exceeds it by this much. */ repayAboveCents?: number; /** Borrow up to the limit when a step is short of cash. */ @@ -98,7 +103,7 @@ export function sitePlanStrategy(plan: SitePlan): StrategyFactory { nextDecision = tick + TICKS_PER_MONTH / 8; while (next < plan.steps.length) { const step = plan.steps[next]; - const cost = costOf(b, step); + const cost = costOf(b, step, plan); const l = b.sim.world.economy; if (plan.borrow && l.cash < cost + plan.reserveCents && l.loan < l.maxLoan) { const short = cost + plan.reserveCents - l.cash; @@ -108,7 +113,7 @@ export function sitePlanStrategy(plan: SitePlan): StrategyFactory { b.sim.step(); } if (l.cash < cost + plan.reserveCents) break; - perform(b, step); + perform(b, step, plan); next++; } const items = b.sim.world.rides.count; @@ -160,14 +165,19 @@ function saleCost( return cents; } -function costOf(b: ParkBuilder, step: SiteStep): number { +function costOf(b: ParkBuilder, step: SiteStep, plan: SitePlan): number { switch (step.kind) { case 'item': return b.costOf(step.name); case 'route': return waypoints(step.points).length * PATH_COST_CENTS * 3; - case 'coaster': - return 350_000 + saleCost(b, siteBounds(step.site)); + case 'coaster': { + const area = siteBounds(step.site); + const decor = plan.decorate + ? plan.decorate.count * SCENERY_CATALOG[plan.decorate.item].priceCents + : 0; + return 350_000 + saleCost(b, area) + area.width * area.height * 1_000 + decor; + } case 'flat': return RIDE_CATALOG[PREBUILT_TYPES[step.name]].cost + (step.row + 12) * PATH_COST_CENTS; case 'buy': @@ -184,7 +194,7 @@ function spineEnd(b: ParkBuilder): [number, number] { return b.grid.tile(row, 0); } -function perform(b: ParkBuilder, step: SiteStep): void { +function perform(b: ParkBuilder, step: SiteStep, plan: SitePlan): void { const sim = b.sim; const m = sim.world.map; switch (step.kind) { @@ -203,7 +213,14 @@ function perform(b: ParkBuilder, step: SiteStep): void { sim.enqueue({ type: 'buyLand', ...area, rights: false }); sim.enqueue({ type: 'buyLand', ...area, rights: true }); sim.step(); - const rideId = startCoaster(sim, step.site, (t) => flatGroundPath(sim, t)); + clearScenery(sim, circuitTiles(sim, step.site)); + const rideId = startCoaster( + sim, + step.site, + (t) => flatGroundPath(sim, t), + true, + plan.decorate, + ); if (rideId === null) return; if (b.prices.coaster !== undefined) sim.enqueue({ type: 'setRidePrice', rideId, priceCents: b.prices.coaster }); diff --git a/bench/strategy/site.ts b/bench/strategy/site.ts index 0a2c7a324..1833ea13c 100644 --- a/bench/strategy/site.ts +++ b/bench/strategy/site.ts @@ -1,9 +1,19 @@ import { TRACK_STEPS_PER_LEVEL } from '../../src/sim/core/constants'; -import type { Simulation } from '../../src/sim/core/simulation'; -import { pieceByName } from '../../src/sim/track/catalog'; +import { Simulation } from '../../src/sim/core/simulation'; +import { PIECES, pieceByName } from '../../src/sim/track/catalog'; +import type { SceneryItem } from '../../src/sim/map/scenery'; +import { SCENERY_RADIUS_TILES } from '../../src/sim/vehicles/vehicle-ratings'; +import { deserialize, serialize } from '../../src/save/save'; import { getConstructionCursor, rotateTile } from '../../src/sim/track/construction'; import { RIDE_CATALOG, RideType } from '../../src/sim/rides/ride-types'; -import { DIR_DX, DIR_DY, ElementType, PathFlag, SLOPE_DIR_SHIFT } from '../../src/sim/map/tile-map'; +import { + DIR_DX, + DIR_DY, + ElementType, + PATH_BOARDING_MARKS, + PathFlag, + SLOPE_DIR_SHIFT, +} from '../../src/sim/map/tile-map'; import { PathAddition, PathResult, planPathPlacement } from '../../src/sim/map/paths'; import { COASTER_TEMPLATES, mirrored } from './coasters'; import { RideState } from '../../src/sim/rides/ride-store'; @@ -232,11 +242,19 @@ export function clearScenery( sim.step(); } -/** True when tile `i` holds a flat footpath piece lying on its ground, which paths can join from any side. */ +/** + * True when tile `i` holds a flat footpath piece lying on its ground that is not a ride's entrance + * or exit tile, so a new path or queue can join it from any side. + */ export function flatGroundPath(sim: Simulation, i: number): boolean { const map = sim.world.map; const e = map.pathElement(i, map.heights[i]); - return e >= 0 && !(map.elFlags[e] & PathFlag.Sloped) && !map.isQueue(i); + return ( + e >= 0 && + !(map.elFlags[e] & PathFlag.Sloped) && + !map.isQueue(i) && + !(map.elData[e] & PATH_BOARDING_MARKS) + ); } export interface OpenedRide { @@ -257,24 +275,60 @@ export function startCoaster( site: CoasterSite, joins: (tile: number) => boolean, clear = true, + decorate?: { item: SceneryItem; count: number }, ): number | null { const world = sim.world; const c = buildCircuit(sim, site); - if (!c.closed) return null; + const abandon = (): null => { + sim.enqueue({ type: 'demolishRide', rideId: c.rideId }); + sim.step(); + return null; + }; + if (!c.closed) return abandon(); + const taken = (t: readonly [number, number]) => + world.map.pathElement(world.map.index(t[0], t[1]), -1) >= 0; + if ([c.entrance, c.exit, c.entranceFront, c.exitFront].some(taken)) return abandon(); if (clear) clearScenery(sim, [c.entrance, c.exit, c.entranceFront, c.exitFront]); sim.enqueue({ type: 'placePath', x: c.entrance[0], y: c.entrance[1], queue: true }); sim.enqueue({ type: 'placePath', x: c.exit[0], y: c.exit[1] }); sim.step(); const exitTile = world.map.index(c.exit[0], c.exit[1]); - if (!connectOnGround(sim, c.entranceFront, (t) => t !== exitTile && joins(t), true)) return null; - if (!connectOnGround(sim, c.exitFront, joins)) return null; + if (!connectOnGround(sim, c.entranceFront, (t) => t !== exitTile && joins(t), true)) + return abandon(); + if (!connectOnGround(sim, c.exitFront, joins)) return abandon(); sim.enqueue({ type: 'placeRideEntrance', rideId: c.rideId, x: c.entrance[0], y: c.entrance[1] }); sim.enqueue({ type: 'placeRideExit', rideId: c.rideId, x: c.exit[0], y: c.exit[1] }); + sim.step(); + if (decorate) plantAround(sim, site, decorate.item, decorate.count); sim.enqueue({ type: 'setRideStatus', rideId: c.rideId, status: 'test' }); sim.step(); return c.rideId; } +/** + * Plants up to `count` scenery items on free tiles near the station, nearest first, the way a + * player decorates a coaster: scenery near the station lifts its excitement. + */ +export function plantAround( + sim: Simulation, + site: CoasterSite, + item: SceneryItem, + count: number, +): void { + const map = sim.world.map; + const spots: Array<[number, number, number]> = []; + for (let dy = -SCENERY_RADIUS_TILES; dy <= SCENERY_RADIUS_TILES; dy++) + for (let dx = -SCENERY_RADIUS_TILES; dx <= SCENERY_RADIUS_TILES; dx++) { + const x = site.x + dx; + const y = site.y + dy; + if (!map.inBounds(x, y) || map.firstElement(map.index(x, y)) >= 0) continue; + spots.push([dx * dx + dy * dy, x, y]); + } + spots.sort((a, b) => a[0] - b[0]); + for (const [, x, y] of spots.slice(0, count)) sim.enqueue({ type: 'placeScenery', x, y, item }); + sim.step(); +} + /** `startCoaster`, then waits for the test run and opens the coaster. */ export function openCoaster( sim: Simulation, @@ -377,3 +431,38 @@ export function openFlatRide( excitement: world.rides.cols.excitement[slot], }; } + +/** + * Tiles a coaster at `site` needs free of scenery: its track footprint and the tiles beside the + * station for the entrance and exit. Found by building it on a copy of the park with the + * surrounding scenery cleared, so the real park only loses the trees the track actually needs. + */ +export function circuitTiles(sim: Simulation, site: CoasterSite): Array<[number, number]> { + const copy = new Simulation(deserialize(serialize(sim.world))); + const map = copy.world.map; + const area = siteBounds(site); + for (let y = area.y; y < area.y + area.height; y++) + for (let x = area.x; x < area.x + area.width; x++) { + if (!map.inBounds(x, y)) continue; + const i = map.index(x, y); + for (let e = map.firstElement(i); e >= 0;) { + const next = map.nextElement(e); + if (map.elType[e] === ElementType.SmallScenery) map.removeElement(i, e); + e = next; + } + } + const c = buildCircuit(copy, site); + const tiles = new Map(); + const add = (x: number, y: number) => tiles.set(map.index(x, y), [x, y]); + const t = copy.world.track; + const cols = t.pieces.cols; + for (let slot = 0; slot < t.pieces.count; slot++) { + if (cols.rideId[slot] !== c.rideId) continue; + for (const cell of PIECES[cols.pieceType[slot]].footprint) { + const [rx, ry] = rotateTile(cell.i, cell.j, cols.dir[slot] as 0 | 1 | 2 | 3); + add(cols.x[slot] + rx, cols.y[slot] + ry); + } + } + for (const tile of [c.entrance, c.exit, c.entranceFront, c.exitFront]) add(...tile); + return [...tiles.values()]; +} diff --git a/bench/strategy/strategies.ts b/bench/strategy/strategies.ts index 86bbf37b4..a2015bea7 100644 --- a/bench/strategy/strategies.ts +++ b/bench/strategy/strategies.ts @@ -1,10 +1,13 @@ import type { StrategyFactory } from './run'; import { growthStrategy } from './growth'; +import { SceneryItem } from '../../src/sim/map/scenery'; import { sitePlanStrategy } from './site-plan'; import type { SiteStep } from './site-plan'; import thunderheadPlan from './plans/thunderhead-mesa.json'; import tidewaterPlan from './plans/tidewater-docks.json'; import mossgrovePlan from './plans/mossgrove-isle.json'; +import glacierPlan from './plans/glacier-point.json'; +import copperPlan from './plans/copper-ridge.json'; /** Build orders are written as space-separated names. */ const list = (names: string): string[] => names.split(/\s+/).filter(Boolean); @@ -68,22 +71,18 @@ STRATEGIES['mossgrove-isle'] = sitePlanStrategy({ attractionsPerMechanic: 3, }); -STRATEGIES['copper-ridge'] = growthStrategy({ - ...BASE, +STRATEGIES['copper-ridge'] = sitePlanStrategy({ + steps: copperPlan as SiteStep[], reserveCents: 150_000, prices: RIDE_PRICES, - jitter: { skipPercent: 15, startDelayMonths: 1 }, - opening: list('foodStall drinkStall toilets merryGoRound'), - growth: [ - 'coaster:compact:1', - ...list('ferrisWheel drinkStall'), - 'coaster:compact:-1', - ...list('foodStall swingingShip'), - 'coaster:riverRun:1', - ...list('twist toilets'), - 'coaster:riverRun:-1', - ...list('merryGoRound informationKiosk'), - 'coaster:compact:1', + itemsPerHandyman: 2, + attractionsPerMechanic: 2, + borrow: true, + decorate: { item: SceneryItem.Conifer, count: 30 }, + patrols: [ + [26, 72, 66, 88], + [14, 34, 46, 50], + [30, 44, 62, 76], ], }); @@ -119,23 +118,18 @@ STRATEGIES['thunderhead-mesa'] = sitePlanStrategy({ attractionsPerMechanic: 3, }); -STRATEGIES['glacier-point'] = growthStrategy({ - ...BASE, +STRATEGIES['glacier-point'] = sitePlanStrategy({ + steps: glacierPlan as SiteStep[], reserveCents: 150_000, prices: RIDE_PRICES, - jitter: { skipPercent: 20, startDelayMonths: 3 }, - opening: list('foodStall drinkStall toilets merryGoRound'), - growth: [ - 'coaster:riverRun:1', - ...list('ferrisWheel drinkStall'), - 'coaster:switchback:-1', - ...list('foodStall twist'), - 'coaster:riverRun:1', - ...list('toilets swingingShip'), - 'coaster:switchback:-1', - ...list('merryGoRound informationKiosk'), - 'coaster:riverRun:1', - 'coaster:switchback:-1', + itemsPerHandyman: 2, + attractionsPerMechanic: 2, + borrow: true, + decorate: { item: SceneryItem.Conifer, count: 30 }, + patrols: [ + [70, 42, 92, 60], + [50, 42, 74, 60], + [54, 56, 82, 78], ], }); diff --git a/public/scenario-previews/copper-ridge@1x.png b/public/scenario-previews/copper-ridge@1x.png index 2f7a3a3270368edfd20851d269a74522fd9137e4..1d6cbc0e918c6d8faaf804eb49f1b24eabf64452 100644 GIT binary patch delta 2671 zcmV-#3Xt{w6pa;-Ie$M%L_t(|+U=c7lN3b|$NSrO^ybZV#e<<;^y9uVZA2oe}5 zZwSP95C{_ZKsg#Hq8<$Oqxc=X`Vo}s-R#Y-&aBGJ%I+D&!#`N&(bMz)Rb^FWR`*oX z)#v_+RZsew5vnKh*EZU_ELZ9{iSw8ZAbkAb&)(@?R<-hcs(&E>WIx!!^wc>F37|E* z&P#GWmDT(lfT3FBJU+iMo-lZ=USow{CkCMXBDGNSFyHg@Q--e-qF#rORZ{>gCtnw6 zEb~1+H)r_zY<*W5AUHfV07_1_cGhgf&nz+?8@{8Bee2}o6bKBVS_CsZ27PY`Ipc%j zIZ+^D2vtcpm4ALwYNnM7ef3DNIrGD;EN}cqLIel`LRAtYErx4B4BgXe20&~+XZ+^= zz9XA@DR)Zyv^4F`2F*j2Lpgxe{4Qy{MM^m zB#0b@%4_f~H6H^A=6cB-embqcYktr8SPBT0*W#d}R3a zz^+sfQUEkFkwq|G10|QI+PAh$w*J_BY`hjiIDYt?sx*FDW4yH0rk=~`kBqn^VGN+t z`ZMOsARquGGmw(OHD~m1x4J4dI~+g$o6F870SF;r0LdO;or#ppZgOVE=I0>fjK}78 zAl!b1On-}a$AAsn7!b97b_}pg2|cEkUH~L5K8BGppBscNvmh$;^kzXC1HI<Pu1^l=;wOX4c}r1wytS&~Ncn%u>F01#unz5AT6v{CM|BuPy*42L%XVemG7Jz)(9dL}P#n z0D2>9eq?&eaIM1ef-wO^(3_VoG~ysoyILyiI?g3ow!M25cvRO3 zrvMCTzN8n#0O~|40~hRPV^q|H5L6{eYY*@m2dEy98^1)Ga>oQw0-y^a4S&F6CdAFE z;Ik!*$iV=VfXD$zfhZXVI4GLOWAk&fHwgf@3%d;cq`Cbbn23d>9YTTzS{E zrTy^LYdz&m3+EAx!)hP9cC$zrLKlG1)KY_j;aKlnK5c4coPy!sf7w;3iL+~;nbd_q z0I-|7Vm2)p9$HuU7gTBx7MOnji-WB+rZxMJxX0hS(Gm4nD+D14fHO7K%1XNC>5Fgo zRMN^~VdL-LInanRDSv4o@!G>@&x(X02m$Pvo-nS7iHfd?TN3{J)cI2#by}R!94s(B zC>-OL>o2y(fQcG2Q%W5N1K1vzGXTu-PHE7ob0>Sk&s)DZJQfU(RbpiB`S`g`!_oAB zj`>PcH79=c$g@2`(c7ctL8}L8%#(x_anIC^0SEwLs`Nx9uYaQeaK}isbnba_n3^K8v!EU2Oo9mp zHPIlInIXzn!VG|RPyRq%6VHC&Z>p7v&0y96y@i;{Fo}%0Aop32vTIW70McxAE8A8& z6){YLO_dF`u73k0qH-#+VR!`$@@i$0WZV!bW>q~vvl1SnYsR^tTry5;h$J2DUTD!& z#C&o=_O2Ov3C@U0($N|-#044ea-*~+T$&9n?V7j{6JUr7GD0I%CCMFAysCb=9TCmu z+>&~LN7p1vl8&Fr0?7REj@P!7+y#Zzm^%O{#pOuo0e@SMc1)Ct4MB-;QIGuNKvn#U zKe5~j@|`Osm)aH@!p^5B_H+aWhVf%_WvP{B+<{~Kdh?}LVF1QsKyw}hh_N8F0CJa{ zN;X8r@5cZsou38Kvn%OzwKD~cWHezKk(>Xzy!XUQLIa+pLy92P^42jwk z8i$peJn|FmnTtfe@#-sg*DWp;?su_2+l0l`v)em@8rSUJ<1?YsI&v>|89Dfk0Q@ zQpF-oHq;|QC;v57!3|sEJBxQN z9Zg)`G>LX(NR0ja$}=heY-!Y35Ae#2R<+}O5GV+}f)8`8S-d4Cr_cj5J2NJ!(r7&& z^JiQ-dZ_#CvsE(nZVU`SzB8j^K2ty+qi7U4DgY`h^+J>Sy0l#Y>YW)=de_33wcxn` zm~pojFzm*_08BeGjG^Yg3qYw30OO{qCk}w;9Z7ls499pZ0C=8+*S&bc>%wX_00{pM dUAG+?z`q3xXkG|kovZ)=002ovPDHLkV1h#s&v^g< delta 2656 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 O0000D2XtfkVCGiNC>46u(nH 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 Pq<}r;VDZ4*^V Date: Sun, 1 Nov 2026 08:07:29 +0000 Subject: [PATCH 09/18] Regenerate Copper Ridge preview Co-authored-by: Nori --- public/scenario-previews/manifest.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/public/scenario-previews/manifest.json b/public/scenario-previews/manifest.json index 8b18e88ae..cdeaab5b6 100644 --- a/public/scenario-previews/manifest.json +++ b/public/scenario-previews/manifest.json @@ -9,7 +9,7 @@ "height": 72 }, "copper-ridge": { - "sourceHash": "0b52809a325df2cf3db5e1b74ace25e4d8a9629c878fc829aad93f636f2aedca", + "sourceHash": "c225c2224d25772dc78f03c86c49235636caa500d05e8bb563d3cdb50daffa85", "oneX": "copper-ridge@1x.png", "twoX": "copper-ridge@2x.png", "width": 96, From 565a69e040a73866a4152a6dd82095cc82533fd5 Mon Sep 17 00:00:00 2001 From: "nori-sessions[bot]" <264258699+nori-sessions[bot]@users.noreply.github.com> Date: Sun, 1 Nov 2026 08:07:31 +0000 Subject: [PATCH 10/18] Mossgrove Isle: richer site plan; ride income target set from demonstrated play Co-authored-by: Nori --- bench/strategy/plans/mossgrove-isle.json | 8 +++++++- public/scenario-previews/manifest.json | 2 +- src/sim/scenario/scenarios/mossgrove-isle.json | 4 ++-- 3 files changed, 10 insertions(+), 4 deletions(-) diff --git a/bench/strategy/plans/mossgrove-isle.json b/bench/strategy/plans/mossgrove-isle.json index b99217aba..005553f32 100644 --- a/bench/strategy/plans/mossgrove-isle.json +++ b/bench/strategy/plans/mossgrove-isle.json @@ -8,5 +8,11 @@ { "kind": "flat", "grid": [35, 38, "west"], "row": 8, "lateral": -6, "name": "swingingShip" }, { "kind": "flat", "grid": [35, 38, "west"], "row": 10, "lateral": 2, "name": "toilets" }, { "kind": "flat", "grid": [35, 38, "east"], "row": 2, "lateral": 6, "name": "merryGoRound" }, - { "kind": "flat", "grid": [35, 38, "east"], "row": 6, "lateral": -2, "name": "swingingShip" } + { "kind": "flat", "grid": [35, 38, "east"], "row": 6, "lateral": -2, "name": "swingingShip" }, + { "kind": "flat", "grid": [25, 38, "south"], "row": 3, "lateral": -2, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [25, 38, "south"], "row": 4, "lateral": 2, "name": "informationKiosk" }, + { "kind": "flat", "grid": [25, 38, "south"], "row": 16, "lateral": 6, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [45, 38, "south"], "row": 3, "lateral": 2, "name": "merryGoRound" }, + { "kind": "flat", "grid": [45, 38, "south"], "row": 8, "lateral": 6, "name": "ferrisWheel" }, + { "kind": "flat", "grid": [45, 38, "south"], "row": 9, "lateral": 2, "name": "informationKiosk" } ] diff --git a/public/scenario-previews/manifest.json b/public/scenario-previews/manifest.json index cdeaab5b6..605fd5d43 100644 --- a/public/scenario-previews/manifest.json +++ b/public/scenario-previews/manifest.json @@ -37,7 +37,7 @@ "height": 72 }, "mossgrove-isle": { - "sourceHash": "a3a474f8ebe078675b169c3a0c48ba7ba8a83494451c58c6162b6aab656846f8", + "sourceHash": "69737960abc359897939e98d747c5c2904cfae2ed94c27aa68aaf39163dab41d", "oneX": "mossgrove-isle@1x.png", "twoX": "mossgrove-isle@2x.png", "width": 72, diff --git a/src/sim/scenario/scenarios/mossgrove-isle.json b/src/sim/scenario/scenarios/mossgrove-isle.json index 2360714c8..0fcfb736f 100644 --- a/src/sim/scenario/scenarios/mossgrove-isle.json +++ b/src/sim/scenario/scenarios/mossgrove-isle.json @@ -3,7 +3,7 @@ "name": "Mossgrove Isle", "category": "challenging", "climate": "coolAndWet", - "description": "A thickly wooded island where the old trees are protected. Reach $900 a month in ride ticket income by the end of year three.", + "description": "A thickly wooded island where the old trees are protected. Reach $350 a month in ride ticket income by the end of year three.", "landscape": "A thickly wooded island in a cold lake, with a few small clearings and a protected grove on the knoll.", "challenge": "Trees may not be removed. Build in the clearings, lift track above the treetops, and buy rights over the shallows for water rides.", "seed": 3307, @@ -251,7 +251,7 @@ }, "objective": { "kind": "monthlyRideIncome", - "target": 90000, + "target": 35000, "byYear": 3 }, "restrictions": { From 41e7437c2da15d3183c5a8b72c202992dc044a6d Mon Sep 17 00:00:00 2001 From: "nori-sessions[bot]" <264258699+nori-sessions[bot]@users.noreply.github.com> Date: Sun, 1 Nov 2026 08:07:34 +0000 Subject: [PATCH 11/18] Review fixes: rule tests with control runs, parser checks for parcels and bands, offset gate corridor, real pre-remix save fixture Co-authored-by: Nori --- bench/hard-parks.test.ts | 89 +++++++++------- bench/strategy/site.ts | 18 +++- e2e/hard-parks-proof.spec.ts | 22 +++- .../fixtures/copper-ridge-pre-remix.ocsave.gz | Bin 0 -> 139637 bytes src/save/scenario-remix-saves.test.ts | 95 +++++++++--------- src/sim/scenario/scenario-file.ts | 19 +++- src/sim/scenario/scenario-map.ts | 50 ++++++--- src/sim/scenario/scenario-shapes.test.ts | 38 +++++++ 8 files changed, 219 insertions(+), 112 deletions(-) create mode 100644 src/save/fixtures/copper-ridge-pre-remix.ocsave.gz diff --git a/bench/hard-parks.test.ts b/bench/hard-parks.test.ts index 3c9f31afb..0537e0ed1 100644 --- a/bench/hard-parks.test.ts +++ b/bench/hard-parks.test.ts @@ -266,65 +266,76 @@ describe('hard parks are playable with legal construction', { timeout: 60_000 }, }); describe('each hard park enforces the rules it advertises', () => { - function fresh(id: string): Simulation { - const def = SCENARIOS.find((s) => s.id === id)!; + /** The park as shipped, or with its rules removed for a control run. */ + function fresh(id: string, rules = true): Simulation { + const shipped = SCENARIOS.find((s) => s.id === id)!; + const def = rules ? shipped : { ...shipped, restrictions: undefined }; const sim = new Simulation({ seed: def.seed, width: def.mapWidth, height: def.mapHeight }); prepareScenarioPark(sim.world, def); return sim; } - it('Copper Ridge refuses to reshape its ridges', () => { - const sim = fresh('copper-ridge'); + function raisedBench(sim: Simulation): boolean { const m = sim.world.map; - const before = Array.from(m.vertexHeights); - sim.enqueue({ - type: 'flattenLand', - x: 30, - y: 60, - width: 8, - height: 12, - anchorX: 32, - anchorY: 75, - }); + const before = m.vertexHeights[m.vertexIndex(52, 80)]; + sim.enqueue({ type: 'raiseLand', x: 50, y: 78, width: 4, height: 4 }); sim.step(); - expect(Array.from(m.vertexHeights)).toEqual(before); + return m.vertexHeights[m.vertexIndex(52, 80)] !== before; + } + + it('Copper Ridge refuses to reshape its owned land', () => { + expect(raisedBench(fresh('copper-ridge', false))).toBe(true); + expect(raisedBench(fresh('copper-ridge'))).toBe(false); }); it('Mossgrove Isle keeps every tree when the player tries to clear the woods', () => { - const sim = fresh('mossgrove-isle'); - const m = sim.world.map; - const count = () => { + const count = (sim: Simulation) => { + const m = sim.world.map; let n = 0; for (let e = 0; e < m.elementCapacity; e++) if (m.elType[e] === ElementType.SmallScenery && TREES.has(m.elData[e])) n++; return n; }; - const before = count(); - sim.enqueue({ type: 'clearScenery', x: 20, y: 18, width: 30, height: 20 }); - sim.step(); - expect(before).toBeGreaterThan(400); - expect(count()).toBe(before); + const clear = (sim: Simulation) => { + const before = count(sim); + sim.enqueue({ type: 'clearScenery', x: 20, y: 18, width: 30, height: 20 }); + sim.step(); + return before - count(sim); + }; + expect(clear(fresh('mossgrove-isle', false))).toBeGreaterThan(100); + expect(clear(fresh('mossgrove-isle'))).toBe(0); }); it('Glacier Point builds no flat rides', () => { - const sim = fresh('glacier-point'); - sim.world.research.unlocked.add(RideType.MerryGoRound); - const rides = sim.world.rides.count; - sim.enqueue({ type: 'createRide', rideType: RideType.MerryGoRound, x: 80, y: 50 }); - sim.step(); - expect(sim.world.rides.count).toBe(rides); + const attempt = (sim: Simulation, x: number, y: number) => { + sim.world.research.unlocked.add(RideType.MerryGoRound); + const rides = sim.world.rides.count; + sim.enqueue({ type: 'createRide', rideType: RideType.MerryGoRound, x, y }); + sim.step(); + return sim.world.rides.count > rides; + }; + const spot = [ + [80, 50], + [78, 54], + [76, 48], + [84, 56], + ].find(([x, y]) => attempt(fresh('glacier-point', false), x, y)); + expect(spot).toBeDefined(); + expect(attempt(fresh('glacier-point'), spot![0], spot![1])).toBe(false); }); it('Thunderhead Mesa refuses marketing and tall construction', () => { - const sim = fresh('thunderhead-mesa'); - const l = sim.world.economy; - const campaign = l.campaignId; - sim.enqueue({ type: 'economy', action: { type: 'startCampaign', campaignId: 1, weeks: 2 } }); - const m = sim.world.map; - const ground = m.heights[m.index(44, 14)]; - sim.enqueue({ type: 'placePath', x: 44, y: 14, z: ground + 8 }); - sim.step(); - expect(l.campaignId).toBe(campaign); - expect(m.pathElement(m.index(44, 14), -1)).toBeLessThan(0); + const tryBoth = (sim: Simulation) => { + const l = sim.world.economy; + const campaign = l.campaignId; + sim.enqueue({ type: 'economy', action: { type: 'startCampaign', campaignId: 1, weeks: 2 } }); + const m = sim.world.map; + const ground = m.heights[m.index(44, 14)]; + sim.enqueue({ type: 'placePath', x: 44, y: 14, z: ground + 8 }); + sim.step(); + return { marketed: l.campaignId !== campaign, tall: m.pathElement(m.index(44, 14), -1) >= 0 }; + }; + expect(tryBoth(fresh('thunderhead-mesa', false))).toEqual({ marketed: true, tall: true }); + expect(tryBoth(fresh('thunderhead-mesa'))).toEqual({ marketed: false, tall: false }); }); }); diff --git a/bench/strategy/site.ts b/bench/strategy/site.ts index 1833ea13c..81f8ddf62 100644 --- a/bench/strategy/site.ts +++ b/bench/strategy/site.ts @@ -65,8 +65,19 @@ export function buildCircuit(sim: Simulation, site: CoasterSite): SiteBuild { const [rx, ry] = rotateTile(i, j, site.dir); return [site.x + rx, site.y + ry]; }; + const before = world.rides.count; sim.enqueue({ type: 'createRide', rideType: RideType.WoodenCoaster, x: site.x, y: site.y }); sim.step(); + if (world.rides.count === before) + return { + rideId: -1, + closed: false, + entrance: at(0, -sigma), + exit: at(0, sigma), + entranceFront: at(0, -2 * sigma), + exitFront: at(0, 2 * sigma), + level, + }; const rideId = world.rides.slotToId[world.rides.count - 1]; for (const [name, mode] of pieces) { const cursor = getConstructionCursor(world, rideId); @@ -120,6 +131,7 @@ export function layRoute( floor[0] = Math.max(floor[0], startLevel); const step = (k: number): number => { const [x, y] = tiles[k]; + if (k === 0 && n === 1) return -1; const [px, py] = k > 0 ? tiles[k - 1] : [x - (tiles[1][0] - x), y - (tiles[1][1] - y)]; return [0, 1, 2, 3].find((d) => DIR_DX[d] === x - px && DIR_DY[d] === y - py)!; }; @@ -280,8 +292,10 @@ export function startCoaster( const world = sim.world; const c = buildCircuit(sim, site); const abandon = (): null => { - sim.enqueue({ type: 'demolishRide', rideId: c.rideId }); - sim.step(); + if (c.rideId >= 0) { + sim.enqueue({ type: 'demolishRide', rideId: c.rideId }); + sim.step(); + } return null; }; if (!c.closed) return abandon(); diff --git a/e2e/hard-parks-proof.spec.ts b/e2e/hard-parks-proof.spec.ts index 3df1b175e..a8353d68c 100644 --- a/e2e/hard-parks-proof.spec.ts +++ b/e2e/hard-parks-proof.spec.ts @@ -118,19 +118,35 @@ for (const park of PARKS) { await look(page, [size.width / 2, size.height / 2, 6], fit * 0.95); await idle(); await shot(page, `${park.id}-overview`); + await page.getByRole('button', { name: 'Land rights', exact: true }).click(); + await page.getByRole('button', { name: 'Buy land', exact: true }).click(); + await page.mouse.move(2, 2); + await page.waitForTimeout(800); + await shot(page, `${park.id}-ownership`); + await page.keyboard.press('Escape'); await look(page, park.gate, mobile ? 0.5 : 1); await idle(); await shot(page, `${park.id}-gate`); - if (!savesDir) return; - const meta = JSON.parse(readFileSync(join(savesDir, `${park.id}.json`), 'utf8')) as { + }); +} + +for (const park of PARKS) { + test(`${park.name}: built proof park`, async ({ page }) => { + test.skip(!proofDir || !savesDir, 'set HARD_PROOF_DIR and HARD_PROOF_SAVES'); + test.setTimeout(600_000); + mkdirSync(proofDir!, { recursive: true }); + await useRenderer(page); + if (!mobile && !useCanvas2d) await page.setViewportSize({ width: 960, height: 640 }); + const idle = spriteIdleTracker(page); + const meta = JSON.parse(readFileSync(join(savesDir!, `${park.id}.json`), 'utf8')) as { focus: [number, number, number]; }; await page.goto('/'); await page .locator('input[type="file"]') .first() - .setInputFiles(join(savesDir, `${park.id}.ocsave`)); + .setInputFiles(join(savesDir!, `${park.id}.ocsave`)); await expect(page.locator('.hud')).toContainText('tick'); await page.evaluate(() => (window as unknown as ProofWindow).__sim.setPaused(true)); await look(page, meta.focus, 1); diff --git a/src/save/fixtures/copper-ridge-pre-remix.ocsave.gz b/src/save/fixtures/copper-ridge-pre-remix.ocsave.gz new file mode 100644 index 0000000000000000000000000000000000000000..d13f8e8765f571134ad1f6a23ff8a284c3be9220 GIT binary patch literal 139637 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 { - it('load with their own land, terrain and scenery rather than the remixed map', () => { - const legacy = newGame(LEGACY_COPPER_RIDGE); - const loaded = deserialize(serialize(legacy)); - expect(Array.from(loaded.map.ownership)).toEqual(Array.from(legacy.map.ownership)); - expect(Array.from(loaded.map.vertexHeights)).toEqual(Array.from(legacy.map.vertexHeights)); - expect(Array.from(loaded.map.waterLevel)).toEqual(Array.from(legacy.map.waterLevel)); - expect(Array.from(loaded.map.elData)).toEqual(Array.from(legacy.map.elData)); + it('load with their own rectangular land and rules, not the remixed map', () => { + const loaded = deserialize(legacySave()); + const box = ownedBox(loaded.map); + expect(box.count).toBe(box.area); + expect(loaded.scenario.restrictions).toEqual({}); + + const def = SCENARIOS.find((s) => s.id === 'copper-ridge')!; + const remix = new World({ seed: def.seed, width: def.mapWidth, height: def.mapHeight }); + prepareScenarioPark(remix, def); + expect(ownedBox(remix.map).count).toBeLessThan(box.count / 2); + }); - const remix = newGame(SCENARIOS.find((s) => s.id === 'copper-ridge')!); - const ownedCount = (w: World) => w.map.ownership.reduce((n, o) => n + (o & OWNED ? 1 : 0), 0); - expect(ownedCount(loaded)).not.toBe(ownedCount(remix)); + it('keep their land, terrain and scenery through another save', () => { + const loaded = deserialize(legacySave()); + const again = deserialize(serialize(loaded)); + expect(Array.from(again.map.ownership)).toEqual(Array.from(loaded.map.ownership)); + expect(Array.from(again.map.vertexHeights)).toEqual(Array.from(loaded.map.vertexHeights)); + expect(Array.from(again.map.elData)).toEqual(Array.from(loaded.map.elData)); }); }); diff --git a/src/sim/scenario/scenario-file.ts b/src/sim/scenario/scenario-file.ts index 59d8f459a..c5d748148 100644 --- a/src/sim/scenario/scenario-file.ts +++ b/src/sim/scenario/scenario-file.ts @@ -229,6 +229,7 @@ export function parseScenarioFile(raw: unknown): ScenarioDef { if (root.land !== undefined) def.land = check(() => land(root.land, def)); if (root.terrain !== undefined) def.terrain = check(() => terrain(root.terrain, def)); if (root.trees !== undefined) def.trees = check(() => trees(root.trees, def)); + if (def.land?.parcels && !def.terrain) fail('land.parcels needs a terrain recipe to paint them'); if (root.prebuilt !== undefined) def.prebuilt = check(() => prebuilt(root.prebuilt, def)); if (root.restrictions !== undefined) { def.restrictions = check(() => parseRestrictions(root.restrictions)); @@ -343,15 +344,15 @@ function land(v: unknown, def: ScenarioDef): ScenarioLand { }; }); const flags = landOwnership(def.mapWidth, def.mapHeight, out); + if (!flags.some((f) => (f & OWNED) !== 0)) throw new Error('land.parcels owns no land'); if (!connectedOwnership(flags, def.mapWidth)) throw new Error('owned land must be one connected piece'); return out; } -/** True when the owned tiles exist and join through edge-sharing neighbours. */ +/** True when the owned tiles join through edge-sharing neighbours. */ function connectedOwnership(flags: Uint8Array, width: number): boolean { const start = flags.findIndex((f) => (f & OWNED) !== 0); - if (start < 0) return false; const seen = new Uint8Array(flags.length); const queue = [start]; seen[start] = 1; @@ -390,7 +391,19 @@ function shape(o: Json, path: string, def: ScenarioDef): ScenarioShape { return { ellipse: [at(0, w), at(1, h), at(2, MAX_MAP_SIZE, 1), at(3, MAX_MAP_SIZE, 1)] }; } if (values.length !== 5) throw new Error(`${path}.band must list x0, y0, x1, y1, halfWidth`); - return { band: [at(0, w), at(1, h), at(2, w), at(3, h), at(4, MAX_BAND_HALF_WIDTH)] }; + const band: [number, number, number, number, number] = [ + at(0, w), + at(1, h), + at(2, w), + at(3, h), + at(4, MAX_BAND_HALF_WIDTH), + ]; + const [x0, y0, x1, y1, half] = band; + if (half === 0 && x0 !== x1 && y0 !== y1) + throw new Error( + `${path}.band needs a halfWidth of at least 1 unless it runs along a row or column`, + ); + return { band }; } function list(v: unknown, path: string): unknown[] { diff --git a/src/sim/scenario/scenario-map.ts b/src/sim/scenario/scenario-map.ts index 80086193a..449070026 100644 --- a/src/sim/scenario/scenario-map.ts +++ b/src/sim/scenario/scenario-map.ts @@ -183,7 +183,7 @@ export function generateScenarioMap(map: TileMap, def: ScenarioDef, seed: number relaxTerrain(map); paintTiles(map, terrain, land); } - if (def.trees) scatterTrees(map, def.trees, apron, rng, side, land); + if (def.trees) scatterTrees(map, def.trees, apron, rng, side, land, terrain?.apronOffset ?? 0); } function shapeHeights(map: TileMap, t: ScenarioTerrain, apron: TileRect, rng: Prng): void { @@ -320,12 +320,14 @@ function scatterTrees( rng: Prng, side: EntranceSide, land: ScenarioLand, + offset: number, ): void { const pool = trees.species ?? []; const clearings = trees.clearings ?? []; + const corridor = clearCorridor(map, side, land, trees, offset); const keepClear = (x: number, y: number): boolean => nearApron(x, y, apron) || - insideClearCorridor(x, y, map, side, land, trees.clearWidth ?? 0, trees.clearLength ?? 0) || + insideClearCorridor(x, y, corridor) || clearings.some((c) => shapeContains(c, x, y)); for (const stand of trees.stands ?? []) fillStand(map, stand, pool, rng, keepClear); @@ -425,28 +427,46 @@ export function treeClearAreas(def: ScenarioDef, width: number, height: number): return [apron, ...(def.trees?.clearings ?? []).map((c: ScenarioShape) => shapeBounds(c))]; } -function insideClearCorridor( - x: number, - y: number, +/** The straight strip kept clear inward from the gate: owned edge, gate midpoint and size. */ +interface ClearCorridor { + owned: TileRect; + midX: number; + midY: number; + side: EntranceSide; + width: number; + length: number; +} + +function clearCorridor( map: TileMap, side: EntranceSide, land: ScenarioLand, - width: number, - length: number, -): boolean { - if (width === 0 || length === 0) return false; + trees: ScenarioTrees, + offset: number, +): ClearCorridor { const owned = ownedBounds(map.width, map.height, land); - const midX = (owned.x0 + owned.x1) >> 1; - const midY = (owned.y0 + owned.y1) >> 1; + return { + owned, + midX: ((owned.x0 + owned.x1) >> 1) + offset, + midY: ((owned.y0 + owned.y1) >> 1) + offset, + side, + width: trees.clearWidth ?? 0, + length: trees.clearLength ?? 0, + }; +} + +function insideClearCorridor(x: number, y: number, c: ClearCorridor): boolean { + if (c.width === 0 || c.length === 0) return false; + const { owned, midX, midY } = c; const [row, across] = - side === 'south' + c.side === 'south' ? [owned.y1 - y, Math.abs(x - midX)] - : side === 'north' + : c.side === 'north' ? [y - owned.y0, Math.abs(x - midX)] - : side === 'east' + : c.side === 'east' ? [owned.x1 - x, Math.abs(y - midY)] : [x - owned.x0, Math.abs(y - midY)]; - return row >= 0 && row < length && across <= width; + return row >= 0 && row < c.length && across <= c.width; } function scatterGroundScenery( diff --git a/src/sim/scenario/scenario-shapes.test.ts b/src/sim/scenario/scenario-shapes.test.ts index 7bdb5c3e7..62cc5de7e 100644 --- a/src/sim/scenario/scenario-shapes.test.ts +++ b/src/sim/scenario/scenario-shapes.test.ts @@ -156,6 +156,27 @@ describe('land parcels', () => { ).toThrow(/land.parcels\[0\].kind/); }); + it('rejects land parcels with no terrain recipe to place them on', () => { + expect(() => parseScenarioFile({ ...BASE, land: { parcels: L_PARCELS } })).toThrow( + /land.parcels needs a terrain recipe/, + ); + }); + + it('rejects a parcel list that owns nothing', () => { + expect(() => recipe({ land: { parcels: [{ kind: 'land', rect: [10, 10, 50, 50] }] } })).toThrow( + /owns no land/, + ); + }); + + it('rejects zero-width diagonal bands, which leave gaps between tiles', () => { + expect(() => + recipe({ trees: { count: 0, groves: 1, clearings: [{ band: [10, 10, 30, 20, 0] }] } }), + ).toThrow(/trees.clearings\[0\].band/); + expect(() => + recipe({ trees: { count: 0, groves: 1, clearings: [{ band: [10, 10, 30, 10, 0] }] } }), + ).not.toThrow(); + }); + it('accepts ellipses and bands as parcel shapes', () => { const w = parkWorld( recipe({ @@ -245,6 +266,23 @@ describe('tree stands and clearings', () => { expect(beside).toBeGreaterThan(30); }); + it('keeps the gate corridor clear in front of an offset gate', () => { + const w = parkWorld( + recipe({ + terrain: { ...TERRAIN, apronOffset: -12 }, + trees: { + count: 0, + groves: 1, + clearWidth: 2, + clearLength: 40, + stands: [{ density: 100, rect: [10, 10, 53, 53] }], + }, + }), + ); + for (let y = 30; y <= 43; y++) + for (let x = 17; x <= 21; x++) expect(scenery(w, x, y), `${x},${y}`).toBeNull(); + }); + it('mixes boulders into a stand when asked', () => { const w = parkWorld( recipe({ From 942c4480ae2d16bf13efd93fa101c1184a9e9595 Mon Sep 17 00:00:00 2001 From: "nori-sessions[bot]" <264258699+nori-sessions[bot]@users.noreply.github.com> Date: Sun, 1 Nov 2026 08:07:36 +0000 Subject: [PATCH 12/18] Proof spec: optional small viewport Co-authored-by: Nori --- docs/DECISIONS.md | 3 ++- e2e/hard-parks-proof.spec.ts | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/DECISIONS.md b/docs/DECISIONS.md index f6612ec22..bb278e440 100644 --- a/docs/DECISIONS.md +++ b/docs/DECISIONS.md @@ -27,7 +27,8 @@ Resolutions of the cross-spec conflicts listed in `docs/mechanics/README.md`. Co | Scenario restrictions | Optional per-scenario rules modelled on the prohibitions RCT2's scenario editor offered (tree removal, landscaping, high construction, marketing), plus banned ride types. The height cap is an OpenCoaster remix: a tunable 4–96 land levels measured from each tile's local ground rather than a fixed limit. Rules gate new actions only and are saved with the park. See [scenario-restrictions.md](scenario-restrictions.md). | | Awards | Seventeen candidate award definitions are checked at month starts; at most one is granted, four may remain active, and each lasts five months. Positive/negative awards scale natural guest generation by 1.25/0.75. Food-award hunger counts use satiation 128 or lower, matching stall seeking; the award guide does not specify this cutoff. Criteria for unavailable park systems use proxies; exact catalog scope, duration and multiplier stacking are unverified. | | Starter rating target | 450. After correcting food-award hunger eligibility, the default-seed modest build ends at rating 554 and wins; at 550 only 7 / 12 established modest-build seeds win. The recalibrated 450 target wins 10 / 12 (ratings 386–688); seeds 22 and 26 miss on rating. See [BALANCE.md](BALANCE.md#results-deferred-economy-pass). | -| Shipped scenarios | Ten parks beyond the starter, each with an original generated map and OpenCoaster-tuned finances and objectives, not transcriptions of any RCT2 scenario. Thresholds are set against the scripted strategy ([BALANCE.md](BALANCE.md#scenario-win-rates)): Beginner at least 10 of 12 seeds, Expert 3 to 9. Coaster excitement targets use this game's scale (best searched circuit 4.94). Have Fun has no terminal state; its harness check (solvent, rating 600+, 200+ guests after four years) is not a game rule. Completion is a browser-local record. | +| Shipped scenarios | Eleven parks beyond the starter, each with an original generated map and OpenCoaster-tuned finances and objectives, not transcriptions of any RCT2 scenario. The Challenging and Expert parks are remixes of RCT2 ideas on irregular owned land and shaped terrain ([scenario-remixes.md](scenario-remixes.md)). Thresholds are set against scripted play ([BALANCE.md](BALANCE.md#scenario-win-rates)): Beginner at least 10 of 12 seeds with the flat-apron scripts, Expert 3 to 9. The hard parks are played by site plans fitted to their terrain; a hard park's goal must be reached by a legal script on at least one seed, except that Thunderhead Mesa and Tidewater Docks keep their earlier goals without a scripted win (reported, not hidden). Coaster excitement targets use this game's scale; scenery near a station adds up to 2.35, so wooded and decorated stations rate far above the bare-apron circuits. Have Fun has no terminal state; its harness check (solvent, rating 600+, 200+ guests after four years) is not a game rule. Completion is a browser-local record. | +| Scenario land shapes | A scenario may paint its starting ownership from shapes (`land.parcels`: owned, land for sale, rights for sale, or not for sale), raise or lower terrain inside shapes (`terrain.shapes`), and fill woods and clearings (`trees.stands`, `trees.clearings`). Owned land must be one connected piece and the gate apron must lie on it, following the RCT2 manual's advice that a park is one continuous piece of land; not-for-sale parcels stay unbuyable, so buying every sale cannot erase a park's outline. Margin-only recipes generate exactly as before. Saves store the map, so loading never regenerates land, terrain or scenery. | | Save format | Current version 31 (see [save/load documentation](../src/save/docs.md) for the format history). Version 10 added guest navigation fields and research work units; version 11 adds ride reliability, mode and mechanic-work columns; version 12 adds guest age, ride count and last-ride fields; version 13 adds recent guest ride history and per-worker task orders; version 14 adds the 60-slot rolling rider history; version 15 adds litter memory/anger, staff sweeps, litter order and climate; version 16 adds the per-worker stopped-vandal counter; version 30 adds ride downtime and mechanic-heading data; version 31 stores scenario average guest cash in the header, defaulting to $50 when absent in older saves. Older saves default new histories and counters to zero or worker-order defaults. Versions 9 and older store research costs and progress in cents, which convert at the old minimum rate (2,500 cents a week = 21 units), so each invention keeps its duration at minimum funding. `difficultRating`, `campaignTarget` and research `priority` are additive and default when absent. | | Guest cadence | Need decay every 128 world ticks; happiness motives every 512 ticks, matching the audited original cadence summary. | | Hunger and thirst | Values count satiation: high means full; low means hungry or thirsty. Loading saves through v11 inverts both bytes. | diff --git a/e2e/hard-parks-proof.spec.ts b/e2e/hard-parks-proof.spec.ts index a8353d68c..e9bcfe8cd 100644 --- a/e2e/hard-parks-proof.spec.ts +++ b/e2e/hard-parks-proof.spec.ts @@ -98,6 +98,7 @@ for (const park of PARKS) { test.setTimeout(600_000); mkdirSync(proofDir!, { recursive: true }); await useRenderer(page); + if (process.env.SMALL === '1') await page.setViewportSize({ width: 960, height: 640 }); const idle = spriteIdleTracker(page); await page.goto('/'); From 920aaa92718239e28ddd41607ebbec0540ea2f73 Mon Sep 17 00:00:00 2001 From: "nori-sessions[bot]" <264258699+nori-sessions[bot]@users.noreply.github.com> Date: Sun, 1 Nov 2026 08:07:38 +0000 Subject: [PATCH 13/18] Document land parcels, terrain shapes, tree stands, site plans and proof spec Co-authored-by: Nori --- bench/docs.md | 5 ++++- e2e/docs.md | 2 ++ src/save/docs.md | 1 + src/sim/scenario/docs.md | 24 ++++++++++++++---------- src/ui/docs.md | 4 ++-- tools/scenario-previews/docs.md | 4 ++-- 6 files changed, 25 insertions(+), 15 deletions(-) diff --git a/bench/docs.md b/bench/docs.md index 0e908e87f..69693e6ac 100644 --- a/bench/docs.md +++ b/bench/docs.md @@ -17,7 +17,10 @@ Path: @/bench - [audio.ts](audio.ts) feeds a warmed synthetic snapshot with a large guest count and many rides through [AudioEngine](../src/audio/audio.ts), using a recording Web Audio context so the benchmark measures JavaScript update and scheduling overhead without browser audio rendering. - [balance.ts](balance.ts) (`pnpm balance`) is the gameplay-balance harness: [balance-park.ts](balance-park.ts) scripts a starter park (rides take their real footprints: each side of the spine allocates rows for queue, exit and body, and late additions that no longer fit are skipped) (minimal, sensible, modest or ambitious profile) with player commands, and the runner steps one in-game year (flags `--admission DOLLARS`, `--repay-loan-month N` and `--stalls-at-value` stand in for a player who sets the gate price, prices stalls at their value and pays off the loan) and prints guest count, rating curve, cash, ride usage (including reliability, breakdown count and downtime ticks), the guest thought histogram, the ledger and the objective result. Stalls and facilities use adjacent public paths for direct access; ordinary rides use entrances, exits and queues. `balance.test.ts` pins determinism and basic health. Its year-end objective checks run default scenario seed 2026 and fixed seeds 1 to 3; the scripted park hires eight handymen and two mechanics by the time the coaster opens. The extra mechanic is assigned when the coaster is built so it can enter service with maintenance staff. Paired measurements are in [the PR proof](https://github.com/tilework-tech/opencoaster/tree/nori/pr-proofs/exterior-litter-graffiti). Results are recorded in [docs/BALANCE.md](../docs/BALANCE.md). - [finance-proof-save.ts](finance-proof-save.ts) writes a scripted starter park as a save file after a few months, for filming the Finances window ([e2e/finances.spec.ts](../e2e/finances.spec.ts)). -- [scenario-balance.ts](scenario-balance.ts) (`pnpm balance --scenario [--seeds 12] [--jobs N] [--trace]`) plays each shipped scenario with its scripted strategy over seeds 1..N, one child process per seed group, and prints the win count and per-seed outcome. [strategy/](strategy) holds the scripts: `builder.ts` places rides, stalls, and coasters on the gate-relative park grid; ordinary rides and coasters use entrance/exit and queue paths, while stalls and facilities use an adjacent public path for direct access. The builder adds bins along paths and a walkway around each coaster; `growth.ts` is the build-order strategy (cash-gated, optional per-seed imperfection); `coasters.ts` holds the searched circuits; `strategies.ts` assigns one per scenario. The balance harness unlocks the ride catalog before play to isolate park and economy tuning from research pacing; normal scenarios still enforce their own unlocks at the simulation command boundary. `scenario-balance.test.ts` checks every scenario has a strategy that builds an open park. A have-fun scenario counts as won when, after four years, the park is solvent, rated 600 or more and holds 200 guests. +- [scenario-balance.ts](scenario-balance.ts) (`pnpm balance --scenario [--seeds 12] [--jobs N] [--trace]`) plays each shipped scenario with its scripted strategy over seeds 1..N, one child process per seed group, and prints the win count and per-seed outcome. [strategy/](strategy) holds the scripts: `builder.ts` places rides, stalls, and coasters on the gate-relative park grid; ordinary rides and coasters use entrance/exit and queue paths, while stalls and facilities use an adjacent public path for direct access. The builder adds bins along paths and a walkway around each coaster; `growth.ts` is the build-order strategy (cash-gated, optional per-seed imperfection); `coasters.ts` holds the searched circuits; `strategies.ts` assigns one per scenario. Parks are prepared with `prepareScenarioPark`, the same path as a new game, so the strategy plays the real map including the approach path and ambient trees (scenery near a coaster station feeds its excitement rating, so leaving trees out would skew results). The balance harness unlocks the ride catalog before play to isolate park and economy tuning from research pacing; normal scenarios still enforce their own unlocks at the simulation command boundary. `scenario-balance.test.ts` checks every scenario has a strategy that builds an open park. A have-fun scenario counts as won when, after four years, the park is solvent, rated 600 or more and holds 200 guests. +- The hard parks (rough terrain, odd-shaped land, protected trees, build limits) cannot be played by the spine-based growth strategy, so they use `sitePlanStrategy` in [strategy/site-plan.ts](strategy/site-plan.ts) with a per-park plan in [strategy/plans/](strategy/plans). A plan is an ordered list of steps (`item` on the builder's spine, `route` footpath, `coaster` at a pinned site, `flat` ride beside its own spine, `buy` land or rights, `clear` scenery); each is built in order once cash covers its estimated cost plus a reserve, optionally borrowing in $1,000 steps. The strategy also keeps handymen and mechanics in proportion to the park, deals handymen patrol rectangles in turn, can plant decoration round each coaster station, and can repay the loan above a cash margin. +- [strategy/site.ts](strategy/site.ts) holds the legal-construction helpers those plans and the hard-park tests share: `buildCircuit` lays a wooden coaster template at a pinned site (supports over slopes, tunnels into ground); `layRoute` lays a footpath that keeps to the ground and otherwise climbs, descends or bridges one level per tile; `connectOnGround` finds the shortest ground-level connector to an existing path; `startCoaster`/`openCoaster` add queue and exit paths and run the test; `openFlatRide` places a flat ride beside a spine; `circuitTiles` finds the tiles a coaster actually needs by building it on a copy of the park, so only those trees are cleared. Everything goes through ordinary player commands, so ownership, terrain and scenario restrictions apply. +- [hard-parks.test.ts](hard-parks.test.ts) plays each hard park's opening and its defining move (e.g. a gulch crossing, a pier bridge, a cliff descent) with the park's real cash, and checks with control runs that each park enforces the restrictions it advertises. With `HARD_PROOF_SAVES` set it also writes each built park as a save plus a focus tile, consumed by [e2e/hard-parks-proof.spec.ts](../e2e/hard-parks-proof.spec.ts). - [stats.ts](stats.ts) supplies nearest-rank percentile and budget helpers used by the benchmark and its tests. ### Core Implementation diff --git a/e2e/docs.md b/e2e/docs.md index 7a6076f00..ae238f5e4 100644 --- a/e2e/docs.md +++ b/e2e/docs.md @@ -46,6 +46,7 @@ Path: @/e2e - [people-depth.spec.ts](people-depth.spec.ts) checks pixel ownership between a guest and flat, raised, queue and ramp paths, benches, trees and stalls, in WebGL2 and Canvas2D at all four rotations. It loads the dev-only [depth-fixture.html](../depth-fixture.html) ([src/dev/depth-fixture.ts](../src/dev/depth-fixture.ts)), which draws a hand-built map with one guest at a chosen position, and renders each case with and without the guest and on a bare map with the same camera. Pixels the guest owns are those of the bare-map render; pixels the scene owns are those of the scene-only render, so the check does not depend on the art. It asserts that a guest is not covered by the surface it stands on, is behind an object nearer the camera (only where the sprites overlap), and in front of one farther away. - [occlusion-oracle.spec.ts](occlusion-oracle.spec.ts) scores renderer occlusion against the oracle described in [src/render/docs.md](../src/render/docs.md) ("Occlusion model"). For every renderer × seed × rotation × zoom it loads the dev-only [occlusion-fixture.html](../occlusion-fixture.html) ([src/dev/occlusion-fixture.ts](../src/dev/occlusion-fixture.ts)), which renders a seeded fuzz park, captures the renderer's object-ID image and compares it with the oracle's z-buffer over the same placed sprites and terrain. It writes `.local/occlusion/