2026-10-28 19:33:14 +00:00
|
|
|
|
// The village diorama: a stretch of land seen from a raised camera, in the layout of a
|
|
|
|
|
|
// classic village overview. The village core sits in the middle: the headquarters on a
|
|
|
|
|
|
// dirt plaza, with storage, hiding places and the rally point around it, inside the wall
|
|
|
|
|
|
// when there is one. Resource sites stand outside in their own zones of the surrounding
|
|
|
|
|
|
// land: iron mines below a rocky hill (top left), clay pits on clay ground (bottom left),
|
|
|
|
|
|
// timber camps at the forest edge (bottom right) and farms with their fields (right).
|
|
|
|
|
|
// Dirt paths run from the plaza through the gates to every zone; forest fills the rest.
|
|
|
|
|
|
//
|
|
|
|
|
|
// The server only says which buildings exist; where they stand is decided here,
|
|
|
|
|
|
// deterministically and in id order, so buildings stay put when new ones are added.
|
2026-10-28 18:54:20 +00:00
|
|
|
|
|
|
|
|
|
|
import type { BuildingType, VillageState } from '~/types/game'
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
import { box, DOOR, type Face, hash, mix, ngon, plane, type Poly, prism, project, pyramid, scale, toPolys, type V2, type V3 } from './iso'
|
2026-10-29 14:50:07 +00:00
|
|
|
|
import type { Tool } from './life'
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
import { blot, broadleaf, buildingModel, bush, C, conifer, crane, deadTree, gallows, grave, rock, ruin, scaffold, stump, well } from './models'
|
2026-10-28 18:54:20 +00:00
|
|
|
|
|
|
|
|
|
|
/** World units per unit of building space, roughly. */
|
2026-10-29 13:38:34 +00:00
|
|
|
|
export const U = 24
|
2026-10-28 18:54:20 +00:00
|
|
|
|
const GOLDEN = Math.PI * (3 - Math.sqrt(5))
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const deg = (d: number) => (d * Math.PI) / 180
|
|
|
|
|
|
const dir = (a: number): V2 => [Math.cos(a), Math.sin(a)]
|
|
|
|
|
|
|
|
|
|
|
|
// World angles seen on screen: 0° lower right, 90° lower left, 180° upper left,
|
|
|
|
|
|
// 270° upper right. 45° points at the viewer: the main gate and road.
|
|
|
|
|
|
const FRONT = deg(45)
|
|
|
|
|
|
const PATH_HALF = U * 0.5
|
|
|
|
|
|
const ZONE_PATH_HALF = U * 0.38
|
|
|
|
|
|
|
|
|
|
|
|
type Zone = 'iron' | 'clay' | 'timber' | 'farm'
|
|
|
|
|
|
const ZONE_OF: Partial<Record<BuildingType, Zone>> = { iron_mine: 'iron', clay_pit: 'clay', timber_camp: 'timber', farm: 'farm' }
|
|
|
|
|
|
/** Centre angle, half the angle it spans, model scale, and slot spacing in model sizes. */
|
|
|
|
|
|
const ZONES: Record<Zone, { angle: number; half: number; scale: number; gap: number; ground: string | null }> = {
|
2026-10-30 09:35:47 +00:00
|
|
|
|
iron: { angle: deg(196), half: deg(26), scale: 1.15, gap: 2.5, ground: '#716d66' },
|
|
|
|
|
|
clay: { angle: deg(102), half: deg(24), scale: 1.1, gap: 2.4, ground: '#7d543b' },
|
|
|
|
|
|
timber: { angle: deg(8), half: deg(22), scale: 1.1, gap: 2.4, ground: '#716345' },
|
2026-10-28 19:33:14 +00:00
|
|
|
|
farm: { angle: deg(-62), half: deg(27), scale: 1.3, gap: 2.6, ground: null },
|
|
|
|
|
|
}
|
|
|
|
|
|
const ZONE_NAMES = Object.keys(ZONES) as Zone[]
|
|
|
|
|
|
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
/** Tired grass, trodden and yellowed in places; roads and the plaza are mud. */
|
2026-10-30 09:35:47 +00:00
|
|
|
|
const GRASS = ['#6a7049', '#666c46', '#6e714c', '#73704b']
|
|
|
|
|
|
const DIRT = '#6b563f'
|
|
|
|
|
|
const PLAZA = '#735e45'
|
|
|
|
|
|
const VILLAGE_GROUND = '#6a6646'
|
|
|
|
|
|
const WALL_EARTH = '#5e4c38'
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
/** Ruts cut by cart wheels, and the rain standing in them. */
|
2026-10-30 09:35:47 +00:00
|
|
|
|
const RUT = '#4e3f2f'
|
|
|
|
|
|
const PUDDLE = '#59646a'
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
/** The land darkens towards the edges, into the forest. */
|
|
|
|
|
|
const DUSK = '#14170f'
|
|
|
|
|
|
|
|
|
|
|
|
/** A ground colour darkened from `r0` out to `r1`, at most by `max`. */
|
2026-10-30 09:35:47 +00:00
|
|
|
|
export function fade(color: string, r: number, r0: number, r1: number, max = 0.25): string {
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
const k = Math.min(1, Math.max(0, (r - r0) / (r1 - r0)))
|
|
|
|
|
|
return k ? mix(color, DUSK, k * max) : color
|
|
|
|
|
|
}
|
2026-10-28 18:54:20 +00:00
|
|
|
|
|
|
|
|
|
|
export interface SceneBuilding {
|
|
|
|
|
|
id: number
|
|
|
|
|
|
type: BuildingType
|
|
|
|
|
|
level: number
|
|
|
|
|
|
upgrading: boolean
|
|
|
|
|
|
/** Screen point above the roof, for the level badge. */
|
|
|
|
|
|
label: V2
|
|
|
|
|
|
/** Screen ellipse of its ground footprint. */
|
|
|
|
|
|
ring: { cx: number; cy: number; rx: number; ry: number }
|
|
|
|
|
|
/** Only one part of the wall takes keyboard focus. */
|
|
|
|
|
|
focusable: boolean
|
2026-10-29 13:09:03 +00:00
|
|
|
|
/** Click target: the outline round everything drawn for it and its ground, a little wider. */
|
|
|
|
|
|
hit?: string
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
export interface SceneObject {
|
|
|
|
|
|
key: string
|
|
|
|
|
|
polys: Poly[]
|
|
|
|
|
|
building?: SceneBuilding
|
|
|
|
|
|
planned?: boolean
|
2026-10-29 15:08:57 +00:00
|
|
|
|
/** A villager who stays put, sorted in among the buildings: chatting, building, drilling. */
|
2026-10-29 14:50:07 +00:00
|
|
|
|
life?: SceneLife
|
2026-10-29 15:08:57 +00:00
|
|
|
|
/** A villager going somewhere and back, sorted in among the buildings: out of a door, a porter. */
|
|
|
|
|
|
walker?: SceneWalker
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
export interface SceneWalker {
|
|
|
|
|
|
/** Screen path from where they start (a door, a store) to where they go. */
|
|
|
|
|
|
d: string
|
|
|
|
|
|
walk: number
|
|
|
|
|
|
work: number
|
|
|
|
|
|
rest: number
|
|
|
|
|
|
/** Out of sight while resting: they live in the building they come out of. */
|
|
|
|
|
|
indoors: boolean
|
2026-10-29 15:43:23 +00:00
|
|
|
|
/** A soldier: helmet and shield. */
|
|
|
|
|
|
soldier?: boolean
|
2026-10-29 15:08:57 +00:00
|
|
|
|
tool: Tool | null
|
|
|
|
|
|
carry: string | null
|
|
|
|
|
|
shirt: number
|
|
|
|
|
|
begin: number
|
2026-10-29 14:50:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
export interface SceneLife {
|
|
|
|
|
|
/** Screen point at their feet. */
|
|
|
|
|
|
at: V2
|
|
|
|
|
|
facing: 1 | -1
|
|
|
|
|
|
tool: Tool | null
|
|
|
|
|
|
shirt: number
|
2026-10-29 15:08:57 +00:00
|
|
|
|
/** A recruit thrusting the spear in drill, instead of a tool at work. */
|
|
|
|
|
|
drill?: boolean
|
2026-10-29 15:43:23 +00:00
|
|
|
|
/** A soldier standing guard: helmet, shield and spear, standing still. */
|
|
|
|
|
|
guard?: boolean
|
2026-10-29 14:50:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** What each zone's workers work with and bring home. */
|
|
|
|
|
|
const WORK: Record<Zone, { tool: Tool; carry: string }> = {
|
|
|
|
|
|
timber: { tool: 'axe', carry: C.wood },
|
|
|
|
|
|
clay: { tool: 'shovel', carry: C.clay },
|
|
|
|
|
|
iron: { tool: 'pick', carry: C.ore },
|
|
|
|
|
|
farm: { tool: 'sickle', carry: C.wheat },
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-28 21:14:56 +00:00
|
|
|
|
/**
|
|
|
|
|
|
* Ground kept free for a building type that doesn't stand yet: nothing is drawn there,
|
|
|
|
|
|
* but the spot opens that type's build card, like the empty plots in Die Stämme.
|
|
|
|
|
|
*/
|
|
|
|
|
|
export interface ScenePlot {
|
|
|
|
|
|
key: string
|
|
|
|
|
|
type: BuildingType
|
|
|
|
|
|
/** Room for one more of a type that already stands (zone plots). */
|
|
|
|
|
|
another: boolean
|
|
|
|
|
|
/** Screen ellipse of the plot, the click target. */
|
|
|
|
|
|
ring: { cx: number; cy: number; rx: number; ry: number }
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-28 20:03:51 +00:00
|
|
|
|
/** A running build order's countdown, anchored above what it works on. */
|
|
|
|
|
|
export interface SceneTimer {
|
|
|
|
|
|
orderId: number
|
|
|
|
|
|
finishesAt: string
|
|
|
|
|
|
/** Screen point above the roof or scaffold. */
|
|
|
|
|
|
at: V2
|
|
|
|
|
|
/** The building whose level badge sits at this spot; the timer goes above that badge. */
|
|
|
|
|
|
buildingId: number | null
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-28 18:54:20 +00:00
|
|
|
|
export interface Scene {
|
|
|
|
|
|
viewBox: string
|
2026-10-28 19:33:14 +00:00
|
|
|
|
/** viewBox size, for keeping badges a fixed size on screen. */
|
|
|
|
|
|
width: number
|
|
|
|
|
|
height: number
|
2026-10-28 18:54:20 +00:00
|
|
|
|
terrain: Poly[]
|
|
|
|
|
|
decals: Poly[]
|
|
|
|
|
|
objects: SceneObject[]
|
2026-10-28 21:14:56 +00:00
|
|
|
|
plots: ScenePlot[]
|
2026-10-28 20:03:51 +00:00
|
|
|
|
timers: SceneTimer[]
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
/** Chimneys, forges and kilns that smoke, as screen points. */
|
|
|
|
|
|
smoke: V2[]
|
|
|
|
|
|
/** Roads villagers walk to work and back: a screen path, how many walk it, seconds per round trip. */
|
2026-10-29 14:50:07 +00:00
|
|
|
|
walks: { d: string; count: number; walk: number; work: number; tool: Tool | null; carry: string | null }[]
|
|
|
|
|
|
/** Sheep by the farms and chickens on the plaza, wandering small loops. */
|
|
|
|
|
|
herds: { kind: 'sheep' | 'chicken'; d: string; dur: number; begin: number }[]
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
/** Crows crossing the land now and then, and circling over the graves and the gallows. */
|
2026-10-29 14:50:07 +00:00
|
|
|
|
birds: { d: string; dur: number; begin: number }[]
|
2026-10-29 13:09:03 +00:00
|
|
|
|
/** A wide click band along the wall ring, so the thin wall is easy to hit. */
|
|
|
|
|
|
wallBand: { id: number; ring: { cx: number; cy: number; rx: number; ry: number }; width: number } | null
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-29 15:43:23 +00:00
|
|
|
|
/** Units in the village (own and support) from which every other door gets a guard, and two. */
|
|
|
|
|
|
const DOOR_GUARDS_FROM = 100
|
|
|
|
|
|
const DOUBLE_GUARDS_FROM = 400
|
|
|
|
|
|
|
|
|
|
|
|
/** Units standing in the village: its own and support from elsewhere. */
|
|
|
|
|
|
export function garrisonOf(village: Pick<VillageState, 'troops' | 'support'>): number {
|
|
|
|
|
|
const count = (units: Partial<Record<string, number>>) => Object.values(units).reduce((n: number, c) => n + (c ?? 0), 0)
|
|
|
|
|
|
return count(village.troops ?? {}) + village.support.here.reduce((n, g) => n + count(g.units), 0)
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
* Soldiers standing guard at a building's door: two at the headquarters as soon as there
|
|
|
|
|
|
* are troops, one at every other door from a big army on, two from a bigger one.
|
|
|
|
|
|
*/
|
|
|
|
|
|
export function guardsAt(type: BuildingType, garrison: number): number {
|
|
|
|
|
|
if (garrison <= 0 || ZONE_OF[type]) return 0
|
|
|
|
|
|
if (type === 'headquarters') return 2
|
|
|
|
|
|
return garrison >= DOUBLE_GUARDS_FROM ? 2 : garrison >= DOOR_GUARDS_FROM ? 1 : 0
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** Where guards stand from the point outside a door (facing +x): a step out, to either side. */
|
|
|
|
|
|
export function guardSpots(type: BuildingType, [x, y]: V2, n: number, unit: number): V2[] {
|
|
|
|
|
|
const out = type === 'headquarters' ? 0.55 : 0.3
|
|
|
|
|
|
const side = type === 'headquarters' ? 0.75 : 0.6
|
|
|
|
|
|
return [
|
|
|
|
|
|
[x + unit * out, y + unit * side],
|
|
|
|
|
|
[x + unit * out, y - unit * side],
|
|
|
|
|
|
].slice(0, n) as V2[]
|
|
|
|
|
|
}
|
|
|
|
|
|
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
/** Buildings that smoke, from this level on. */
|
|
|
|
|
|
const SMOKY: Partial<Record<BuildingType, number>> = { headquarters: 1, barracks: 1, workshop: 1, academy: 1, clay_pit: 1, iron_mine: 5 }
|
2026-10-30 09:35:47 +00:00
|
|
|
|
const WATER = '#4a5b5d'
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
|
2026-10-28 18:54:20 +00:00
|
|
|
|
/** A scene object with its painter order (x + y of its ground point). */
|
|
|
|
|
|
type Ordered = SceneObject & { depth: number }
|
|
|
|
|
|
|
|
|
|
|
|
interface Slot {
|
|
|
|
|
|
key: string
|
|
|
|
|
|
x: number
|
|
|
|
|
|
y: number
|
2026-10-28 19:33:14 +00:00
|
|
|
|
/** Clearance radius on the ground. */
|
2026-10-28 18:54:20 +00:00
|
|
|
|
r: number
|
2026-10-28 19:33:14 +00:00
|
|
|
|
/** Model half-size. */
|
|
|
|
|
|
s: number
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const footRadius = (space: number) => Math.sqrt(Math.max(space, 1)) * U * 0.7
|
|
|
|
|
|
const halfSize = (space: number) => Math.sqrt(Math.max(space, 1)) * U * 0.52
|
|
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
/** Distance from a ray that starts at the centre and runs along angle `a`. */
|
|
|
|
|
|
function rayDistance(x: number, y: number, a: number) {
|
|
|
|
|
|
const [dx, dy] = dir(a)
|
|
|
|
|
|
const along = x * dx + y * dy
|
|
|
|
|
|
return along < 0 ? Math.hypot(x, y) : Math.abs(x * dy - y * dx)
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-29 13:09:03 +00:00
|
|
|
|
/** Convex outline round a building's polygons and ground ring, grown by `grow` around its middle. */
|
|
|
|
|
|
function hitOutline(polys: Poly[], ring: { cx: number; cy: number; rx: number; ry: number }, grow = 1.12): string {
|
|
|
|
|
|
const pts: V2[] = polys.flatMap((p) => p.points.split(' ').map((xy) => xy.split(',').map(Number) as V2))
|
|
|
|
|
|
if (ring.rx) pts.push([ring.cx - ring.rx, ring.cy], [ring.cx + ring.rx, ring.cy], [ring.cx, ring.cy - ring.ry], [ring.cx, ring.cy + ring.ry])
|
|
|
|
|
|
if (pts.length < 3) return ''
|
|
|
|
|
|
pts.sort((a, b) => a[0] - b[0] || a[1] - b[1])
|
|
|
|
|
|
const cross = (o: V2, a: V2, b: V2) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])
|
|
|
|
|
|
const half = (list: V2[]) => {
|
|
|
|
|
|
const out: V2[] = []
|
|
|
|
|
|
for (const p of list) {
|
|
|
|
|
|
while (out.length >= 2 && cross(out[out.length - 2]!, out[out.length - 1]!, p) <= 0) out.pop()
|
|
|
|
|
|
out.push(p)
|
|
|
|
|
|
}
|
|
|
|
|
|
return out.slice(0, -1)
|
|
|
|
|
|
}
|
|
|
|
|
|
const hull = [...half(pts), ...half([...pts].reverse())]
|
|
|
|
|
|
const cx = hull.reduce((n, p) => n + p[0], 0) / hull.length
|
|
|
|
|
|
const cy = hull.reduce((n, p) => n + p[1], 0) / hull.length
|
|
|
|
|
|
return hull.map(([x, y]) => `${(cx + (x - cx) * grow).toFixed(1)},${(cy + (y - cy) * grow).toFixed(1)}`).join(' ')
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-29 15:43:04 +00:00
|
|
|
|
/** Distance from point p to the segment a–b. */
|
|
|
|
|
|
function segmentDistance([px, py]: V2, [ax, ay]: V2, [bx, by]: V2): number {
|
|
|
|
|
|
const dx = bx - ax
|
|
|
|
|
|
const dy = by - ay
|
|
|
|
|
|
const t = Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy || 1)))
|
|
|
|
|
|
return Math.hypot(px - ax - dx * t, py - ay - dy * t)
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** A footpath along the points: a strip per stretch and a round patch at every bend. */
|
|
|
|
|
|
function trail(pts: V2[], half: number, seed: number): Face[] {
|
|
|
|
|
|
const faces: Face[] = []
|
|
|
|
|
|
for (let i = 0; i < pts.length - 1; i++) {
|
|
|
|
|
|
const [ax, ay] = pts[i]!
|
|
|
|
|
|
const [bx, by] = pts[i + 1]!
|
|
|
|
|
|
const l = Math.hypot(bx - ax, by - ay) || 1
|
|
|
|
|
|
const nx = (-(by - ay) / l) * half
|
|
|
|
|
|
const ny = ((bx - ax) / l) * half
|
|
|
|
|
|
faces.push(plane([[ax + nx, ay + ny, 1.1], [bx + nx, by + ny, 1.1], [bx - nx, by - ny, 1.1], [ax - nx, ay - ny, 1.1]], DIRT))
|
|
|
|
|
|
}
|
|
|
|
|
|
for (const [i, [x, y]] of pts.slice(1, -1).entries()) faces.push(plane(disc(x, y, half * 1.05, 8, seed + i, 1.1), DIRT))
|
|
|
|
|
|
return faces
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
function screenRing(x: number, y: number, r: number) {
|
|
|
|
|
|
const [cx, cy] = project([x, y, 0])
|
|
|
|
|
|
return { cx, cy, rx: r * Math.SQRT2, ry: r * Math.SQRT1_2 }
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Layout
|
|
|
|
|
|
|
|
|
|
|
|
/** Inside the village: a golden-angle spiral around the headquarters, keeping the roads free. */
|
|
|
|
|
|
function layoutCore(items: { key: string; space: number }[], hqRadius: number, roads: number[]): Slot[] {
|
|
|
|
|
|
const slots: Slot[] = [{ key: 'hq', x: 0, y: 0, r: hqRadius, s: 0 }]
|
2026-10-28 18:54:20 +00:00
|
|
|
|
for (const item of items) {
|
|
|
|
|
|
const r = footRadius(item.space)
|
|
|
|
|
|
for (let i = 1; i < 8000; i++) {
|
|
|
|
|
|
const d = U * 0.3 * Math.sqrt(i)
|
|
|
|
|
|
const x = Math.cos(i * GOLDEN) * d
|
|
|
|
|
|
const y = Math.sin(i * GOLDEN) * d
|
2026-10-28 19:33:14 +00:00
|
|
|
|
if (roads.some((a) => rayDistance(x, y, a) < r + PATH_HALF)) continue
|
|
|
|
|
|
if (slots.some((s) => Math.hypot(x - s.x, y - s.y) < r + s.r + U * 0.3)) continue
|
|
|
|
|
|
slots.push({ key: item.key, x, y, r, s: halfSize(item.space) })
|
2026-10-28 18:54:20 +00:00
|
|
|
|
break
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return slots
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
/**
|
|
|
|
|
|
* A zone outside the wall: rows of slots along an arc, nearest row first, filled from
|
|
|
|
|
|
* the zone's road outwards on both sides. `count` slots, however many buildings exist,
|
|
|
|
|
|
* so an empty zone still shows its ground.
|
|
|
|
|
|
*/
|
|
|
|
|
|
function layoutZone(zone: Zone, space: number, count: number, Rv: number): Slot[] {
|
|
|
|
|
|
const z = ZONES[zone]
|
|
|
|
|
|
const s = halfSize(space) * z.scale
|
|
|
|
|
|
const slots: Slot[] = []
|
|
|
|
|
|
for (let row = 0; slots.length < count && row < 20; row++) {
|
|
|
|
|
|
const r = Rv + U * 1.7 + s * 1.3 + row * s * z.gap
|
|
|
|
|
|
const step = (s * z.gap) / r
|
|
|
|
|
|
for (let k = 0; slots.length < count; k++) {
|
|
|
|
|
|
const offset = (k % 2 ? -1 : 1) * (Math.floor(k / 2) + 0.5)
|
|
|
|
|
|
if (Math.abs(offset) * step > z.half) break
|
|
|
|
|
|
const [x, y] = dir(z.angle + offset * step)
|
|
|
|
|
|
slots.push({ key: `${zone}-${slots.length}`, x: x * r, y: y * r, r: s * 1.15, s })
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return slots
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
// Ground
|
2026-10-28 18:54:20 +00:00
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
function inverse([X, Y]: V2): V2 {
|
|
|
|
|
|
return [Y + X / 2, Y - X / 2]
|
|
|
|
|
|
}
|
2026-10-28 18:54:20 +00:00
|
|
|
|
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
/**
|
|
|
|
|
|
* A low-poly ground mesh that covers the view; vertices hash from their grid index, so it
|
|
|
|
|
|
* never shifts. With `dark`, the land darkens from radius r0 out to r1.
|
|
|
|
|
|
*/
|
|
|
|
|
|
export function ground(view: { x: number; y: number; w: number; h: number }, dark?: { r0: number; r1: number }): Poly[] {
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const g = U * 2.6
|
|
|
|
|
|
const corners = [
|
|
|
|
|
|
inverse([view.x, view.y]),
|
|
|
|
|
|
inverse([view.x + view.w, view.y]),
|
|
|
|
|
|
inverse([view.x, view.y + view.h]),
|
|
|
|
|
|
inverse([view.x + view.w, view.y + view.h]),
|
|
|
|
|
|
]
|
|
|
|
|
|
const i0 = Math.floor(Math.min(...corners.map((c) => c[0])) / g) - 1
|
|
|
|
|
|
const i1 = Math.ceil(Math.max(...corners.map((c) => c[0])) / g) + 1
|
|
|
|
|
|
const j0 = Math.floor(Math.min(...corners.map((c) => c[1])) / g) - 1
|
|
|
|
|
|
const j1 = Math.ceil(Math.max(...corners.map((c) => c[1])) / g) + 1
|
|
|
|
|
|
const vertex = (i: number, j: number): V3 => [
|
|
|
|
|
|
(i + (hash(i, j, 1) - 0.5) * 0.6) * g,
|
|
|
|
|
|
(j + (hash(i, j, 2) - 0.5) * 0.6) * g,
|
|
|
|
|
|
(hash(i, j, 3) - 0.5) * 4,
|
|
|
|
|
|
]
|
|
|
|
|
|
const faces: Face[] = []
|
|
|
|
|
|
for (let i = i0; i < i1; i++) {
|
|
|
|
|
|
for (let j = j0; j < j1; j++) {
|
|
|
|
|
|
const a = vertex(i, j)
|
|
|
|
|
|
const b = vertex(i + 1, j)
|
|
|
|
|
|
const c = vertex(i + 1, j + 1)
|
|
|
|
|
|
const d = vertex(i, j + 1)
|
|
|
|
|
|
const xs = [a, b, c, d].map((p) => project(p))
|
|
|
|
|
|
const minX = Math.min(...xs.map((p) => p[0]))
|
|
|
|
|
|
const maxX = Math.max(...xs.map((p) => p[0]))
|
|
|
|
|
|
const minY = Math.min(...xs.map((p) => p[1]))
|
|
|
|
|
|
const maxY = Math.max(...xs.map((p) => p[1]))
|
|
|
|
|
|
if (maxX < view.x || minX > view.x + view.w || maxY < view.y || minY > view.y + view.h) continue
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
const tone = (k: number, p: V3, q: V3) => {
|
|
|
|
|
|
const color = GRASS[Math.floor(hash(i, j, k) * GRASS.length)]!
|
|
|
|
|
|
return dark ? fade(color, Math.hypot((a[0] + p[0] + q[0]) / 3, (a[1] + p[1] + q[1]) / 3), dark.r0, dark.r1) : color
|
|
|
|
|
|
}
|
|
|
|
|
|
faces.push({ pts: [a, b, c], color: tone(4, b, c), twoSided: true }, { pts: [a, c, d], color: tone(5, c, d), twoSided: true })
|
2026-10-28 19:33:14 +00:00
|
|
|
|
}
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
2026-10-28 19:33:14 +00:00
|
|
|
|
return toPolys(faces).map((p) => ({ ...p, stroke: p.fill }))
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-29 13:38:34 +00:00
|
|
|
|
export function disc(cx: number, cy: number, r: number, n: number, seed: number, z = 0.6): V3[] {
|
2026-10-28 19:33:14 +00:00
|
|
|
|
return ngon(cx, cy, r, n, hash(seed, 1) * 6).map(([x, y], i): V3 => {
|
|
|
|
|
|
const k = 0.82 + 0.3 * hash(seed, i)
|
|
|
|
|
|
return [cx + (x - cx) * k, cy + (y - cy) * k, z]
|
|
|
|
|
|
})
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
/** The winding centre line of a road from radius r0 to r1 along angle `a`, with each point's distance out. */
|
|
|
|
|
|
function roadLine(a: number, r0: number, r1: number, seed: number): { x: number; y: number; t: number; k: number }[] {
|
|
|
|
|
|
const [dx, dy] = dir(a)
|
|
|
|
|
|
const px = -dy
|
|
|
|
|
|
const py = dx
|
|
|
|
|
|
const steps = Math.max(2, Math.ceil((r1 - r0) / (U * 1.4)))
|
|
|
|
|
|
return Array.from({ length: steps + 1 }, (_, k) => {
|
|
|
|
|
|
const t = r0 + ((r1 - r0) * k) / steps
|
|
|
|
|
|
const wobble = k === 0 ? 0 : (hash(seed, k, 5) - 0.5) * U * 0.4
|
|
|
|
|
|
return { x: dx * t + px * wobble, y: dy * t + py * wobble, t, k }
|
|
|
|
|
|
})
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
/** A dirt road from radius r0 to r1 along angle `a`, gently winding. */
|
|
|
|
|
|
function road(a: number, r0: number, r1: number, half: number, seed: number): Face {
|
|
|
|
|
|
const [dx, dy] = dir(a)
|
|
|
|
|
|
const px = -dy
|
|
|
|
|
|
const py = dx
|
2026-10-28 18:54:20 +00:00
|
|
|
|
const left: V3[] = []
|
|
|
|
|
|
const right: V3[] = []
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
for (const { x, y, k } of roadLine(a, r0, r1, seed)) {
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const w = half * (0.85 + 0.3 * hash(seed, k, 6))
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
left.push([x + px * w, y + py * w, 1.2])
|
|
|
|
|
|
right.push([x - px * w, y - py * w, 1.2])
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
2026-10-28 19:33:14 +00:00
|
|
|
|
return plane([...left, ...right.reverse()], DIRT)
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
/** Two wheel ruts along a road, and rain standing in them here and there. */
|
|
|
|
|
|
function ruts(a: number, r0: number, r1: number, half: number, seed: number): Face[] {
|
|
|
|
|
|
const [dx, dy] = dir(a)
|
|
|
|
|
|
const line = roadLine(a, r0, r1, seed)
|
|
|
|
|
|
const faces: Face[] = []
|
|
|
|
|
|
const color = mix(DIRT, RUT, 0.6)
|
|
|
|
|
|
for (const side of [-1, 1]) {
|
|
|
|
|
|
const off = side * half * 0.36
|
|
|
|
|
|
const w = U * 0.03
|
|
|
|
|
|
const left: V3[] = line.map((p): V3 => [p.x - dy * (off - w), p.y + dx * (off - w), 1.3])
|
|
|
|
|
|
const right: V3[] = line.map((p): V3 => [p.x - dy * (off + w), p.y + dx * (off + w), 1.3])
|
|
|
|
|
|
faces.push(plane([...left, ...right.reverse()], color))
|
|
|
|
|
|
}
|
|
|
|
|
|
// Now and then the rain stands in a rut.
|
|
|
|
|
|
for (let i = 1; i < line.length - 1; i++) {
|
|
|
|
|
|
if (hash(seed, i, 7) > 0.22) continue
|
|
|
|
|
|
const side = hash(seed, i, 8) > 0.5 ? 1 : -1
|
|
|
|
|
|
const p = line[i]!
|
|
|
|
|
|
const off = side * half * 0.3
|
|
|
|
|
|
faces.push(blot(p.x - dy * off, p.y + dx * off, U * (0.2 + 0.12 * hash(seed, i, 9)), 7, seed * 31 + i, 1.4, PUDDLE))
|
|
|
|
|
|
}
|
|
|
|
|
|
return faces
|
|
|
|
|
|
}
|
|
|
|
|
|
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
/** The screen path along a road between two radii, for villagers to walk. */
|
|
|
|
|
|
function walkPath(a: number, r0: number, r1: number, seed: number, from: number, to: number): string {
|
|
|
|
|
|
const pts = roadLine(a, r0, r1, seed).filter((p) => p.t >= from && p.t <= to)
|
|
|
|
|
|
return pts.map((p, i) => `${i ? 'L' : 'M'}${project([p.x, p.y, 1.2]).map((v) => v.toFixed(1)).join(' ')}`).join(' ')
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** A flat shadow on the ground, cast away from the light (to the right on screen). */
|
2026-10-29 13:38:34 +00:00
|
|
|
|
export function shadow(x: number, y: number, r: number, color: string, seed: number): Face {
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
return plane(disc(x + r * 0.42, y - r * 0.32, r, 10, seed, 1.4), color)
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
/** A band around the village: worn earth under the wall, or the village's edge without one. */
|
|
|
|
|
|
function ringBand(r: number, width: number, color: string): Face[] {
|
|
|
|
|
|
const n = 56
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
// Trodden unevenly: each edge wanders in and out.
|
|
|
|
|
|
const edge = (i: number, side: number) => {
|
|
|
|
|
|
const a = ((i % n) / n) * Math.PI * 2
|
|
|
|
|
|
const k = r + side * (width / 2) * (0.55 + 0.9 * hash(i % n, side + 3, 17))
|
|
|
|
|
|
return [Math.cos(a) * k, Math.sin(a) * k, 1] as V3
|
2026-10-28 19:33:14 +00:00
|
|
|
|
}
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
const faces: Face[] = []
|
|
|
|
|
|
for (let i = 0; i < n; i++) faces.push(plane([edge(i, -1), edge(i + 1, -1), edge(i + 1, 1), edge(i, 1)], color))
|
2026-10-28 19:33:14 +00:00
|
|
|
|
return faces
|
|
|
|
|
|
}
|
2026-10-28 18:54:20 +00:00
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
// The wall rings the village; its look follows the level like the buildings, and each
|
|
|
|
|
|
// segment is its own object so it sorts correctly against buildings inside and out.
|
|
|
|
|
|
|
2026-10-29 13:38:34 +00:00
|
|
|
|
export function wallSegments(Rv: number, level: number, gates: number[]): { faces: Face[]; depth: number }[] {
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const steps = Math.max(28, Math.round((Math.PI * 2 * Rv) / (U * 0.55)))
|
|
|
|
|
|
const gateHalf = (PATH_HALF + U * 0.3) / Rv
|
|
|
|
|
|
const h = U * (0.5 + Math.min(level, 20) * 0.035)
|
|
|
|
|
|
const at = (a: number): V2 => [Math.cos(a) * Rv, Math.sin(a) * Rv]
|
|
|
|
|
|
const inGate = (a: number) => gates.some((g) => Math.abs(Math.atan2(Math.sin(a - g), Math.cos(a - g))) < gateHalf)
|
|
|
|
|
|
const out: { faces: Face[]; depth: number }[] = []
|
2026-10-28 18:54:20 +00:00
|
|
|
|
for (let i = 0; i < steps; i++) {
|
|
|
|
|
|
const a0 = (i / steps) * Math.PI * 2
|
|
|
|
|
|
const a1 = ((i + 1) / steps) * Math.PI * 2
|
|
|
|
|
|
const mid = (a0 + a1) / 2
|
2026-10-28 19:33:14 +00:00
|
|
|
|
if (inGate(mid)) continue
|
|
|
|
|
|
const nextToGate = inGate(mid + (Math.PI * 2) / steps) || inGate(mid - (Math.PI * 2) / steps)
|
2026-10-28 18:54:20 +00:00
|
|
|
|
const [x, y] = at(mid)
|
2026-10-28 19:33:14 +00:00
|
|
|
|
let faces: Face[]
|
|
|
|
|
|
if (level < 5) {
|
|
|
|
|
|
// Palisade of sharpened stakes.
|
|
|
|
|
|
const p = ngon(x, y, U * 0.09, 5, i)
|
|
|
|
|
|
faces = [...prism(p, 0, h, C.wood), ...pyramid(p, h, U * 0.12, C.woodDark)]
|
|
|
|
|
|
} else {
|
|
|
|
|
|
const [x0, y0] = at(a0)
|
|
|
|
|
|
const [x1, y1] = at(a1)
|
|
|
|
|
|
const nx = Math.cos(mid) * U * 0.1
|
|
|
|
|
|
const ny = Math.sin(mid) * U * 0.1
|
|
|
|
|
|
const base: V2[] = [
|
|
|
|
|
|
[x0 - nx, y0 - ny],
|
|
|
|
|
|
[x1 - nx, y1 - ny],
|
|
|
|
|
|
[x1 + nx, y1 + ny],
|
|
|
|
|
|
[x0 + nx, y0 + ny],
|
|
|
|
|
|
]
|
|
|
|
|
|
// Counter-clockwise from above, as prism() expects.
|
|
|
|
|
|
const ccw = (base[1]![0] - base[0]![0]) * (base[2]![1] - base[0]![1]) - (base[1]![1] - base[0]![1]) * (base[2]![0] - base[0]![0]) > 0
|
|
|
|
|
|
const stone = level >= 15
|
|
|
|
|
|
faces = prism(ccw ? base : [...base].reverse(), 0, h, stone ? C.stone : C.wood, stone ? C.stoneDark : C.plank)
|
|
|
|
|
|
if (stone && (i % 7 === 0 || nextToGate)) {
|
|
|
|
|
|
faces.push(...prism(ngon(x, y, U * 0.24, 6), 0, h * 1.55, C.stone, C.stoneDark), ...pyramid(ngon(x, y, U * 0.28, 6), h * 1.55, U * 0.38, C.slate))
|
|
|
|
|
|
} else if (!stone && nextToGate) {
|
|
|
|
|
|
faces.push(...prism(ngon(x, y, U * 0.16, 4, Math.PI / 4), 0, h * 1.4, C.woodDark), ...pyramid(ngon(x, y, U * 0.22, 4, Math.PI / 4), h * 1.4, U * 0.25, C.roofRed))
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
out.push({ faces, depth: x + y })
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
return out
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-29 10:15:26 +00:00
|
|
|
|
/** Pixels at the stage's edges that windows cover; the village fits into the rest. */
|
|
|
|
|
|
export interface SceneInset {
|
|
|
|
|
|
top: number
|
|
|
|
|
|
right: number
|
|
|
|
|
|
bottom: number
|
|
|
|
|
|
left: number
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
* The scene for a stage: either just its shape (`aspect`, the village filling the frame),
|
|
|
|
|
|
* or its size in pixels with the covered edges, so the whole village lands in the free
|
|
|
|
|
|
* part and land and forest run on under the windows to every edge.
|
|
|
|
|
|
*/
|
|
|
|
|
|
export function buildScene(village: VillageState, frame: number | { width: number; height: number; inset?: SceneInset } = 2.2): Scene {
|
|
|
|
|
|
const aspect = typeof frame === 'number' ? frame : frame.width / Math.max(1, frame.height)
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const isZone = (type: BuildingType) => ZONE_OF[type] !== undefined
|
2026-10-28 18:54:20 +00:00
|
|
|
|
const hq = village.buildings.find((b) => b.type === 'headquarters')
|
|
|
|
|
|
const hqRadius = footRadius(hq?.space ?? 9)
|
|
|
|
|
|
const planned = village.queue.filter((o) => o.action === 'build' && o.space > 0)
|
2026-10-28 19:33:14 +00:00
|
|
|
|
|
|
|
|
|
|
// Zone members in id order: existing buildings first, then queued new ones.
|
|
|
|
|
|
const members: Record<Zone, { key: string; space: number }[]> = { iron: [], clay: [], timber: [], farm: [] }
|
|
|
|
|
|
for (const b of [...village.buildings].sort((p, q) => p.id - q.id)) {
|
|
|
|
|
|
const zone = ZONE_OF[b.type]
|
|
|
|
|
|
if (zone) members[zone].push({ key: `b${b.id}`, space: b.space })
|
|
|
|
|
|
}
|
|
|
|
|
|
for (const o of [...planned].sort((p, q) => p.id - q.id)) {
|
|
|
|
|
|
const zone = ZONE_OF[o.type]
|
|
|
|
|
|
if (zone) members[zone].push({ key: `o${o.id}`, space: o.space })
|
|
|
|
|
|
}
|
|
|
|
|
|
const activeZones = ZONE_NAMES.filter((z) => members[z].length)
|
|
|
|
|
|
const roads = [FRONT, ...activeZones.map((z) => ZONES[z].angle)]
|
|
|
|
|
|
|
2026-10-28 21:14:56 +00:00
|
|
|
|
// Types with no building and no queued one keep an empty plot: inside the village
|
|
|
|
|
|
// after everything that stands, so building there moves nothing that already exists.
|
|
|
|
|
|
const present = new Set([...village.buildings.map((b) => b.type), ...village.queue.filter((o) => o.action === 'build').map((o) => o.type)])
|
|
|
|
|
|
const unbuilt = village.buildable.filter((o) => !present.has(o.type))
|
|
|
|
|
|
const corePlots = unbuilt.filter((o) => o.type !== 'headquarters' && o.type !== 'wall' && !isZone(o.type))
|
|
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const coreItems = [
|
|
|
|
|
|
{ key: 'well', space: 1.4 },
|
|
|
|
|
|
...village.buildings.filter((b) => b.type !== 'headquarters' && b.type !== 'wall' && b.space > 0 && !isZone(b.type)).map((b) => ({ key: `b${b.id}`, space: b.space })),
|
|
|
|
|
|
...planned.filter((o) => !isZone(o.type)).map((o) => ({ key: `o${o.id}`, space: o.space })),
|
2026-10-28 21:14:56 +00:00
|
|
|
|
...corePlots.map((o) => ({ key: `p:${o.type}`, space: Math.max(o.space, 1) })),
|
2026-10-28 19:33:14 +00:00
|
|
|
|
]
|
|
|
|
|
|
const core = layoutCore(coreItems, hqRadius, roads)
|
|
|
|
|
|
const Rv = Math.max(U * 5.2, ...core.map((s) => Math.hypot(s.x, s.y) + s.r + U * 0.9))
|
|
|
|
|
|
|
|
|
|
|
|
const zoneSlots: Record<Zone, Slot[]> = { iron: [], clay: [], timber: [], farm: [] }
|
|
|
|
|
|
for (const zone of ZONE_NAMES) {
|
|
|
|
|
|
const space = members[zone][0]?.space ?? 4
|
2026-10-28 21:14:56 +00:00
|
|
|
|
// Each zone shows one free plot of its ground past its buildings, two when empty.
|
|
|
|
|
|
const slots = layoutZone(zone, space, Math.max(members[zone].length + 1, 2), Rv)
|
2026-10-28 19:33:14 +00:00
|
|
|
|
members[zone].forEach((m, i) => (slots[i]!.key = m.key))
|
|
|
|
|
|
zoneSlots[zone] = slots
|
|
|
|
|
|
}
|
2026-10-28 21:14:56 +00:00
|
|
|
|
const allSlots = [...core, ...ZONE_NAMES.flatMap((z) => zoneSlots[z])]
|
|
|
|
|
|
|
|
|
|
|
|
const plots: ScenePlot[] = corePlots.map((o) => {
|
|
|
|
|
|
const s = core.find((c) => c.key === `p:${o.type}`)!
|
|
|
|
|
|
return { key: `p:${o.type}`, type: o.type, another: false, ring: screenRing(s.x, s.y, s.r) }
|
|
|
|
|
|
})
|
|
|
|
|
|
for (const zone of ZONE_NAMES) {
|
|
|
|
|
|
const type = (Object.keys(ZONE_OF) as BuildingType[]).find((t) => ZONE_OF[t] === zone)!
|
|
|
|
|
|
const free = zoneSlots[zone][members[zone].length]
|
|
|
|
|
|
if (free && village.buildable.some((o) => o.type === type)) plots.push({ key: `p:${type}`, type, another: present.has(type), ring: screenRing(free.x, free.y, free.r) })
|
|
|
|
|
|
}
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const slotOf = (key: string) => allSlots.find((s) => s.key === key)!
|
|
|
|
|
|
const zoneEnd = (zone: Zone) => Math.max(Rv + U * 3, ...zoneSlots[zone].map((s) => Math.hypot(s.x, s.y) + s.r))
|
|
|
|
|
|
|
2026-10-28 18:54:20 +00:00
|
|
|
|
const running = new Set(village.queue.filter((o) => o.builder !== null && o.building_id !== null).map((o) => o.building_id))
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
const shadows: Face[] = []
|
|
|
|
|
|
const smoke: V2[] = []
|
2026-10-28 18:54:20 +00:00
|
|
|
|
const objects: Ordered[] = []
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const labelTops: number[] = []
|
2026-10-28 20:03:51 +00:00
|
|
|
|
/** Badge point per building id, and per queued new building (order id), for the timers. */
|
|
|
|
|
|
const anchorOfBuilding = new Map<number, V2>()
|
|
|
|
|
|
const anchorOfOrder = new Map<number, V2>()
|
2026-10-28 18:54:20 +00:00
|
|
|
|
|
2026-10-29 15:08:57 +00:00
|
|
|
|
// Buildings and queued new ones. Each door is remembered as the ground point just outside it.
|
|
|
|
|
|
const doorOf = new Map<number, V2>()
|
2026-10-28 18:54:20 +00:00
|
|
|
|
for (const b of village.buildings) {
|
|
|
|
|
|
if (b.type === 'wall') continue
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const slot = b.type === 'headquarters' ? core[0]! : slotOf(`b${b.id}`)
|
|
|
|
|
|
const zone = ZONE_OF[b.type]
|
|
|
|
|
|
const s = zone ? slot.s : halfSize(b.space)
|
2026-10-28 18:54:20 +00:00
|
|
|
|
const model = buildingModel(b.type, b.level, s)
|
2026-10-29 15:08:57 +00:00
|
|
|
|
const doorFace = model.faces.find((f) => f.color === DOOR)
|
|
|
|
|
|
if (doorFace) {
|
|
|
|
|
|
const dx = doorFace.pts.reduce((n, p) => n + p[0], 0) / doorFace.pts.length
|
|
|
|
|
|
const dy = doorFace.pts.reduce((n, p) => n + p[1], 0) / doorFace.pts.length
|
|
|
|
|
|
doorOf.set(b.id, [slot.x + dx + U * 0.3, slot.y + dy])
|
|
|
|
|
|
}
|
2026-10-28 18:54:20 +00:00
|
|
|
|
const upgrading = running.has(b.id)
|
|
|
|
|
|
const faces = upgrading ? [...model.faces, ...crane(s, model.height)] : model.faces
|
|
|
|
|
|
const label = project([slot.x, slot.y, model.height + 10])
|
2026-10-28 19:33:14 +00:00
|
|
|
|
labelTops.push(label[1])
|
2026-10-28 20:03:51 +00:00
|
|
|
|
anchorOfBuilding.set(b.id, label)
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
const ground = b.type === 'headquarters' ? PLAZA : zone ? (ZONES[zone].ground ?? GRASS[0]!) : VILLAGE_GROUND
|
2026-10-30 09:35:47 +00:00
|
|
|
|
shadows.push(shadow(slot.x, slot.y, s * (zone ? 1.0 : 0.95), scale(ground, 0.8), b.id))
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
const smokyFrom = SMOKY[b.type]
|
|
|
|
|
|
if (smokyFrom !== undefined && b.level >= smokyFrom && !upgrading) smoke.push(project([slot.x - s * 0.35, slot.y + s * 0.3, model.height * 0.72]))
|
2026-10-28 18:54:20 +00:00
|
|
|
|
objects.push({
|
|
|
|
|
|
key: `b${b.id}`,
|
|
|
|
|
|
depth: slot.x + slot.y,
|
|
|
|
|
|
polys: toPolys(faces, [slot.x, slot.y, 0]),
|
|
|
|
|
|
building: { id: b.id, type: b.type, level: b.level, upgrading, label, ring: screenRing(slot.x, slot.y, slot.r), focusable: true },
|
|
|
|
|
|
})
|
|
|
|
|
|
}
|
|
|
|
|
|
for (const o of planned) {
|
|
|
|
|
|
const slot = slotOf(`o${o.id}`)
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const model = scaffold(ZONE_OF[o.type] ? slot.s : halfSize(o.space))
|
2026-10-28 20:03:51 +00:00
|
|
|
|
anchorOfOrder.set(o.id, project([slot.x, slot.y, model.height + 10]))
|
2026-10-28 18:54:20 +00:00
|
|
|
|
objects.push({ key: `o${o.id}`, depth: slot.x + slot.y, polys: toPolys(model.faces, [slot.x, slot.y, 0]), planned: true })
|
|
|
|
|
|
}
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const wellSlot = slotOf('well')
|
|
|
|
|
|
objects.push({ key: 'well', depth: wellSlot.x + wellSlot.y, polys: toPolys(well(U * 0.55).faces, [wellSlot.x, wellSlot.y, 0]) })
|
2026-10-28 18:54:20 +00:00
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
// The wall: every segment sorts on its own.
|
2026-10-28 18:54:20 +00:00
|
|
|
|
const wall = village.buildings.find((b) => b.type === 'wall')
|
|
|
|
|
|
const wallPlanned = !wall && village.queue.some((o) => o.action === 'build' && o.type === 'wall')
|
2026-10-28 19:33:14 +00:00
|
|
|
|
let wallTop = 0
|
2026-10-28 18:54:20 +00:00
|
|
|
|
if (wall || wallPlanned) {
|
|
|
|
|
|
const level = wall?.level ?? 0
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const segments = wallSegments(Rv, level, roads)
|
|
|
|
|
|
wallTop = U * (0.5 + Math.min(level, 20) * 0.035) * 1.55 + U * 0.4
|
|
|
|
|
|
const gateSide = FRONT + deg(24)
|
|
|
|
|
|
const label = project([Math.cos(gateSide) * Rv, Math.sin(gateSide) * Rv, wallTop + 10])
|
|
|
|
|
|
labelTops.push(label[1])
|
2026-10-28 20:03:51 +00:00
|
|
|
|
if (wall) anchorOfBuilding.set(wall.id, label)
|
|
|
|
|
|
else for (const o of village.queue) if (o.action === 'build' && o.type === 'wall') anchorOfOrder.set(o.id, label)
|
2026-10-28 18:54:20 +00:00
|
|
|
|
const ring = { cx: 0, cy: 0, rx: 0, ry: 0 }
|
2026-10-28 19:33:14 +00:00
|
|
|
|
// The segment nearest the badge takes keyboard focus for the whole wall.
|
|
|
|
|
|
const focusIndex = segments.reduce((best, seg, i) => (seg.depth > segments[best]!.depth ? i : best), 0)
|
|
|
|
|
|
segments.forEach((seg, i) => {
|
|
|
|
|
|
objects.push({
|
|
|
|
|
|
key: `wall-${i}`,
|
|
|
|
|
|
depth: seg.depth,
|
|
|
|
|
|
polys: toPolys(seg.faces),
|
|
|
|
|
|
...(wall
|
|
|
|
|
|
? { building: { id: wall.id, type: 'wall' as const, level, upgrading: running.has(wall.id), label, ring, focusable: i === focusIndex } }
|
|
|
|
|
|
: { planned: true }),
|
|
|
|
|
|
})
|
|
|
|
|
|
})
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-28 21:14:56 +00:00
|
|
|
|
// Without a wall, its plot is the stretch of village edge where its badge would sit.
|
|
|
|
|
|
if (!wall && !wallPlanned && unbuilt.some((o) => o.type === 'wall')) {
|
|
|
|
|
|
const gateSide = FRONT + deg(24)
|
|
|
|
|
|
plots.push({ key: 'p:wall', type: 'wall', another: false, ring: screenRing(Math.cos(gateSide) * Rv, Math.sin(gateSide) * Rv, U * 0.9) })
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
// The frame: the village and every zone, with room for labels; then widened or
|
|
|
|
|
|
// heightened to the container's shape, where more land and forest show.
|
|
|
|
|
|
const Rz = Math.max(Rv + U * 4.5, ...ZONE_NAMES.map(zoneEnd))
|
|
|
|
|
|
const pts: V2[] = []
|
|
|
|
|
|
for (let i = 0; i < 24; i++) {
|
|
|
|
|
|
const [x, y] = dir((i / 24) * Math.PI * 2)
|
|
|
|
|
|
pts.push(project([x * (Rv + U * 2.5), y * (Rv + U * 2.5), 0]))
|
|
|
|
|
|
}
|
|
|
|
|
|
for (const s of allSlots) pts.push(project([s.x - s.r, s.y + s.r, 0]), project([s.x + s.r, s.y - s.r, 0]), project([s.x + s.r, s.y + s.r, 0]))
|
|
|
|
|
|
let minX = Math.min(...pts.map((p) => p[0]))
|
|
|
|
|
|
let maxX = Math.max(...pts.map((p) => p[0]))
|
|
|
|
|
|
let minY = Math.min(...pts.map((p) => p[1]), ...labelTops) - U * 1.2
|
|
|
|
|
|
let maxY = Math.max(...pts.map((p) => p[1])) + U * 0.8
|
|
|
|
|
|
const padX = (maxX - minX) * 0.04
|
|
|
|
|
|
minX -= padX
|
|
|
|
|
|
maxX += padX
|
|
|
|
|
|
let w = maxX - minX
|
|
|
|
|
|
let h = maxY - minY
|
2026-10-29 10:15:26 +00:00
|
|
|
|
if (typeof frame !== 'number') {
|
|
|
|
|
|
// Fit the village into the free part of the stage; the view spans the whole stage.
|
|
|
|
|
|
const inset = frame.inset ?? { top: 0, right: 0, bottom: 0, left: 0 }
|
|
|
|
|
|
const freeW = Math.max(120, frame.width - inset.left - inset.right)
|
|
|
|
|
|
const freeH = Math.max(120, frame.height - inset.top - inset.bottom)
|
|
|
|
|
|
const perUnit = Math.min(freeW / w, freeH / h)
|
|
|
|
|
|
const cx = (minX + maxX) / 2
|
|
|
|
|
|
const cy = (minY + maxY) / 2
|
|
|
|
|
|
w = frame.width / perUnit
|
|
|
|
|
|
h = frame.height / perUnit
|
|
|
|
|
|
minX = cx - (inset.left + freeW / 2) / perUnit
|
|
|
|
|
|
minY = cy - (inset.top + freeH / 2) / perUnit
|
|
|
|
|
|
} else if (w / h < aspect) {
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const extra = h * aspect - w
|
|
|
|
|
|
minX -= extra / 2
|
|
|
|
|
|
w += extra
|
|
|
|
|
|
} else {
|
|
|
|
|
|
const extra = w / aspect - h
|
|
|
|
|
|
minY -= extra * 0.45
|
|
|
|
|
|
h += extra
|
|
|
|
|
|
}
|
|
|
|
|
|
maxX = minX + w
|
|
|
|
|
|
maxY = minY + h
|
|
|
|
|
|
const view = { x: minX, y: minY, w, h }
|
|
|
|
|
|
|
|
|
|
|
|
// Decals on the ground, back to front by layer.
|
|
|
|
|
|
const decalFaces: Face[] = [plane(disc(0, 0, Rv + U * 0.25, 40, 7, 0.5), VILLAGE_GROUND)]
|
|
|
|
|
|
for (const zone of ZONE_NAMES) {
|
|
|
|
|
|
const color = ZONES[zone].ground
|
|
|
|
|
|
if (!color) continue
|
|
|
|
|
|
zoneSlots[zone].forEach((s, i) => decalFaces.push(plane(disc(s.x, s.y, s.r * 1.3, 9, 30 + i * 7 + zone.length, 0.8), color)))
|
|
|
|
|
|
}
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
// Trodden mud between the houses.
|
|
|
|
|
|
for (let k = 0; k < 9; k++) {
|
|
|
|
|
|
const a = hash(k, 81) * Math.PI * 2
|
|
|
|
|
|
const r = (Rv - U) * Math.sqrt(hash(k, 82))
|
|
|
|
|
|
decalFaces.push(blot(Math.cos(a) * r, Math.sin(a) * r, U * (0.6 + 0.7 * hash(k, 83)), 9, 800 + k, 0.55, mix(VILLAGE_GROUND, DIRT, 0.6)))
|
|
|
|
|
|
}
|
|
|
|
|
|
decalFaces.push(road(FRONT, hqRadius * 0.9, Rz * 3, PATH_HALF, 1), ...ruts(FRONT, hqRadius * 0.9, Rz * 3, PATH_HALF, 1))
|
|
|
|
|
|
for (const zone of activeZones) {
|
|
|
|
|
|
const seed = ZONE_NAMES.indexOf(zone) + 2
|
|
|
|
|
|
decalFaces.push(road(ZONES[zone].angle, hqRadius * 0.9, zoneEnd(zone) + U * 0.5, ZONE_PATH_HALF, seed), ...ruts(ZONES[zone].angle, hqRadius * 0.9, zoneEnd(zone), ZONE_PATH_HALF, seed))
|
|
|
|
|
|
}
|
2026-10-29 15:43:04 +00:00
|
|
|
|
// Footpaths: from every door to the nearest road or the plaza, around other buildings,
|
|
|
|
|
|
// with a trodden patch in front of the door; from every site outside to its zone road.
|
|
|
|
|
|
const blockers = [{ key: 'hq', x: 0, y: 0, r: hqRadius * 0.8 }, ...allSlots.filter((sl) => sl.key !== 'hq').map((sl) => ({ key: sl.key, x: sl.x, y: sl.y, r: sl.r * 0.85 }))]
|
|
|
|
|
|
const length = (pts: V2[]) => pts.slice(1).reduce((n, p, i) => n + Math.hypot(p[0] - pts[i]![0], p[1] - pts[i]![1]), 0)
|
|
|
|
|
|
for (const b of village.buildings) {
|
|
|
|
|
|
if (b.type === 'headquarters' || b.type === 'wall') continue
|
|
|
|
|
|
const slot = slotOf(`b${b.id}`)
|
|
|
|
|
|
const zone = ZONE_OF[b.type]
|
|
|
|
|
|
if (zone) {
|
|
|
|
|
|
const [dx, dy] = dir(ZONES[zone].angle)
|
|
|
|
|
|
const t = slot.x * dx + slot.y * dy
|
|
|
|
|
|
if (Math.abs(slot.x * dy - slot.y * dx) > U * 0.6) decalFaces.push(...trail([[slot.x, slot.y], [dx * t, dy * t]], U * 0.17, b.id))
|
|
|
|
|
|
continue
|
|
|
|
|
|
}
|
|
|
|
|
|
const door = doorOf.get(b.id)
|
|
|
|
|
|
const from: V2 = door ?? [slot.x, slot.y]
|
|
|
|
|
|
const step: V2 = door ? [door[0] + U * 0.35, door[1]] : from
|
|
|
|
|
|
const targets: V2[] = []
|
|
|
|
|
|
const r = Math.hypot(step[0], step[1]) || 1
|
|
|
|
|
|
targets.push([(step[0] / r) * hqRadius * 1.15, (step[1] / r) * hqRadius * 1.15])
|
|
|
|
|
|
for (const a of roads) {
|
|
|
|
|
|
const [dx, dy] = dir(a)
|
|
|
|
|
|
const t = step[0] * dx + step[1] * dy
|
|
|
|
|
|
if (t > hqRadius && t < Rv + U) targets.push([dx * t, dy * t])
|
|
|
|
|
|
}
|
|
|
|
|
|
const clear = (pts: V2[]) =>
|
|
|
|
|
|
blockers.every((o) => {
|
|
|
|
|
|
const radius = o.key === slot.key ? slot.s * 0.85 : o.r
|
|
|
|
|
|
return pts.slice(1).every((p, i) => segmentDistance([o.x, o.y], pts[i]!, p) >= radius)
|
|
|
|
|
|
})
|
|
|
|
|
|
const shapes = targets.flatMap((t): V2[][] => [
|
|
|
|
|
|
[step, t],
|
|
|
|
|
|
[step, [step[0], t[1]], t],
|
|
|
|
|
|
[step, [t[0], step[1]], t],
|
|
|
|
|
|
])
|
|
|
|
|
|
shapes.sort((p, q) => length(p) - length(q))
|
|
|
|
|
|
const best = shapes.find(clear) ?? shapes[0]!
|
|
|
|
|
|
if (door) decalFaces.push(plane(disc(step[0], step[1], U * 0.42, 9, b.id + 50, 1.1), DIRT))
|
|
|
|
|
|
decalFaces.push(...trail(door ? [from, ...best] : best, U * 0.2, b.id))
|
|
|
|
|
|
}
|
2026-10-28 19:33:14 +00:00
|
|
|
|
decalFaces.push(...ringBand(Rv, U * (wall || wallPlanned ? 0.55 : 0.4), wall || wallPlanned ? WALL_EARTH : DIRT))
|
|
|
|
|
|
decalFaces.push(plane(disc(0, 0, hqRadius * 1.3, 11, 3, 1.6), PLAZA))
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
// Rain standing on the plaza, where the carts turn.
|
|
|
|
|
|
for (let k = 0; k < 3; k++) {
|
|
|
|
|
|
const [px, py] = dir(FRONT + deg(-50 + k * 50 + hash(k, 85) * 20))
|
|
|
|
|
|
decalFaces.push(blot(px * hqRadius * 1.12, py * hqRadius * 1.12, U * (0.22 + 0.15 * hash(k, 86)), 7, 860 + k, 1.7, PUDDLE))
|
|
|
|
|
|
}
|
2026-10-28 19:33:14 +00:00
|
|
|
|
|
|
|
|
|
|
// Landscape: a rocky hill behind the iron zone, then forest everywhere else.
|
|
|
|
|
|
const taken: { x: number; y: number; r: number }[] = allSlots.map((s) => ({ x: s.x, y: s.y, r: s.r + U * 0.45 }))
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
|
2026-10-29 14:50:07 +00:00
|
|
|
|
// Sheep graze past the farms, chickens peck round the plaza: small loops kept free of trees.
|
|
|
|
|
|
const herds: Scene['herds'] = []
|
|
|
|
|
|
const loop = (cx: number, cy: number, r: number, seed: number) => {
|
|
|
|
|
|
const pts = [0, 1, 2, 3, 0].map((i): V2 => {
|
|
|
|
|
|
const a = (i / 4) * Math.PI * 2 + hash(seed, 1) * 6
|
|
|
|
|
|
return project([cx + Math.cos(a) * r * (0.7 + 0.5 * hash(seed, i + 2)), cy + Math.sin(a) * r, 1.2])
|
|
|
|
|
|
})
|
|
|
|
|
|
return pts.map((p, i) => `${i ? 'L' : 'M'}${p[0].toFixed(1)} ${p[1].toFixed(1)}`).join(' ')
|
|
|
|
|
|
}
|
|
|
|
|
|
if (activeZones.includes('farm')) {
|
|
|
|
|
|
const [fx, fy] = dir(ZONES.farm.angle + deg(14))
|
|
|
|
|
|
const r = zoneEnd('farm') + U * 1.6
|
|
|
|
|
|
taken.push({ x: fx * r, y: fy * r, r: U * 1.8 })
|
|
|
|
|
|
for (let k = 0; k < 3; k++) herds.push({ kind: 'sheep', d: loop(fx * r + (k - 1) * U * 0.9, fy * r + (k % 2) * U * 0.7, U * 0.9, 300 + k), dur: 26 + k * 5, begin: -k * 7 })
|
|
|
|
|
|
}
|
|
|
|
|
|
{
|
|
|
|
|
|
const [cx, cy] = dir(FRONT + deg(75))
|
|
|
|
|
|
const r = hqRadius * 1.5
|
|
|
|
|
|
for (let k = 0; k < 2; k++) herds.push({ kind: 'chicken', d: loop(cx * r + k * U * 0.5, cy * r - k * U * 0.4, U * 0.5, 320 + k), dur: 14 + k * 4, begin: -k * 5 })
|
|
|
|
|
|
}
|
|
|
|
|
|
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
// A pond in the meadow between the clay pits and the hill, with reeds on its bank.
|
|
|
|
|
|
const pondR = U * 1.5
|
|
|
|
|
|
const pondOut = Math.max(Rv + U * 2.6, zoneEnd('clay') * 0.85)
|
|
|
|
|
|
const [pondX, pondY] = [Math.cos(deg(150)) * pondOut, Math.sin(deg(150)) * pondOut]
|
|
|
|
|
|
if (!taken.some((t) => Math.hypot(pondX - t.x, pondY - t.y) < t.r + pondR)) {
|
2026-10-30 09:35:47 +00:00
|
|
|
|
decalFaces.push(plane(disc(pondX, pondY, pondR * 1.18, 14, 91, 0.9), '#58513b'))
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
decalFaces.push(plane(disc(pondX, pondY, pondR, 14, 92, 1.0), WATER))
|
|
|
|
|
|
decalFaces.push(plane(disc(pondX - pondR * 0.25, pondY + pondR * 0.1, pondR * 0.45, 8, 93, 1.1), scale(WATER, 1.12)))
|
|
|
|
|
|
taken.push({ x: pondX, y: pondY, r: pondR * 1.3 })
|
|
|
|
|
|
for (let k = 0; k < 7; k++) {
|
|
|
|
|
|
const a = (k / 7) * Math.PI * 2 + hash(k, 94)
|
|
|
|
|
|
const [x, y] = [pondX + Math.cos(a) * pondR * 1.12, pondY + Math.sin(a) * pondR * 1.12]
|
|
|
|
|
|
const h = U * (0.3 + 0.25 * hash(k, 95))
|
2026-10-30 09:35:47 +00:00
|
|
|
|
objects.push({ key: `reed-${k}`, depth: x + y, polys: toPolys(prism(ngon(x, y, U * 0.05, 4), 0, h, '#5c6040', '#77744c')) })
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
}
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const iron = ZONES.iron
|
|
|
|
|
|
const hillFrom = zoneEnd('iron')
|
|
|
|
|
|
for (let k = 0; k < 11; k++) {
|
|
|
|
|
|
const a = iron.angle + (hash(k, 41) - 0.5) * 2 * (iron.half + deg(8))
|
|
|
|
|
|
const r = hillFrom + U * (0.6 + 3 * hash(k, 42))
|
|
|
|
|
|
const [x, y] = [Math.cos(a) * r, Math.sin(a) * r]
|
|
|
|
|
|
const size = U * (1.5 + 1.4 * hash(k, 43))
|
|
|
|
|
|
taken.push({ x, y, r: size * 0.45 })
|
|
|
|
|
|
objects.push({ key: `hill-${k}`, depth: x + y, polys: toPolys(rock(x, y, size, 100 + k, hash(k, 44) > 0.5 ? C.stoneDark : C.rock)) })
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const roadClear = (x: number, y: number) =>
|
|
|
|
|
|
rayDistance(x, y, FRONT) < PATH_HALF + U * 0.5 ||
|
|
|
|
|
|
activeZones.some((z) => {
|
|
|
|
|
|
const [dx, dy] = dir(ZONES[z].angle)
|
|
|
|
|
|
return x * dx + y * dy < zoneEnd(z) + U && rayDistance(x, y, ZONES[z].angle) < ZONE_PATH_HALF + U * 0.45
|
|
|
|
|
|
})
|
|
|
|
|
|
const inSector = (x: number, y: number, zone: Zone, pad: number) => {
|
|
|
|
|
|
const a = Math.atan2(y, x)
|
|
|
|
|
|
return Math.abs(Math.atan2(Math.sin(a - ZONES[zone].angle), Math.cos(a - ZONES[zone].angle))) < ZONES[zone].half + pad
|
|
|
|
|
|
}
|
|
|
|
|
|
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
// Hard times outside the wall: the graveyard behind the village, a grave more as it
|
|
|
|
|
|
// grows and the newest still open; the gallows by the main road; a farmstead burnt down
|
|
|
|
|
|
// and still smouldering. Each takes the first free spot of a few it may stand at.
|
|
|
|
|
|
const free = (x: number, y: number, r: number) =>
|
|
|
|
|
|
!taken.some((t) => Math.hypot(x - t.x, y - t.y) < t.r + r) &&
|
|
|
|
|
|
!ZONE_NAMES.some((z) => inSector(x, y, z, deg(4))) &&
|
|
|
|
|
|
[0, 1, 2, 3, 4, 5, 6, 7, 8].every((k) => !roadClear(x + (k ? Math.cos((k / 8) * Math.PI * 2) * r : 0), y + (k ? Math.sin((k / 8) * Math.PI * 2) * r : 0)))
|
|
|
|
|
|
const site = (angles: number[], from: number, r: number): V2 | null => {
|
|
|
|
|
|
for (let step = 0; step < 8; step++) {
|
|
|
|
|
|
for (const a of angles) {
|
|
|
|
|
|
const [x, y] = dir(a)
|
|
|
|
|
|
if (free(x * (from + step * U * 0.7), y * (from + step * U * 0.7), r)) return [x * (from + step * U * 0.7), y * (from + step * U * 0.7)]
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return null
|
|
|
|
|
|
}
|
|
|
|
|
|
const hard: { key: string; x: number; y: number; faces: Face[] }[] = []
|
|
|
|
|
|
const yard = site([deg(250), deg(240), deg(260), deg(232)], Rv + U * 2.6, U * 1.8)
|
|
|
|
|
|
if (yard) {
|
|
|
|
|
|
const [gx, gy] = yard
|
|
|
|
|
|
const count = Math.min(14, 4 + Math.floor(village.points / 150))
|
|
|
|
|
|
for (let k = 0; k < count; k++) {
|
|
|
|
|
|
const x = gx + (Math.floor(k / 4) - 1) * U * 0.95 + (hash(k, 91) - 0.5) * U * 0.12
|
|
|
|
|
|
const y = gy + ((k % 4) - 1.5) * U * 0.52 + (hash(k, 92) - 0.5) * U * 0.1
|
|
|
|
|
|
hard.push({ key: `grave-${k}`, x, y, faces: grave(x, y, U, 900 + k, k === count - 1) })
|
|
|
|
|
|
}
|
|
|
|
|
|
hard.push({ key: 'grave-tree', x: gx - U * 1.6, y: gy - U * 1.2, faces: deadTree(gx - U * 1.6, gy - U * 1.2, U * 1.5, 77) })
|
|
|
|
|
|
taken.push({ x: gx, y: gy, r: U * 2.1 })
|
|
|
|
|
|
}
|
|
|
|
|
|
{
|
|
|
|
|
|
const [fx, fy] = dir(FRONT)
|
|
|
|
|
|
const t = Rv + U * 2.6
|
|
|
|
|
|
for (const side of [1, -1]) {
|
|
|
|
|
|
const off = (PATH_HALF + U * 2) * side
|
|
|
|
|
|
const [x, y] = [fx * t - fy * off, fy * t + fx * off]
|
|
|
|
|
|
if (!free(x, y, U * 0.8)) continue
|
|
|
|
|
|
hard.push({ key: 'gallows', x, y, faces: gallows(x, y, U * 1.1, side) })
|
|
|
|
|
|
taken.push({ x, y, r: U * 1.1 })
|
|
|
|
|
|
break
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
const burnt = site([deg(64), deg(-24), deg(134), deg(150)], Rv + U * 4.2, U * 1.6)
|
|
|
|
|
|
if (burnt) {
|
|
|
|
|
|
const [x, y] = burnt
|
|
|
|
|
|
hard.push({ key: 'ruin', x, y, faces: ruin(x, y, U * 1.15, 5) })
|
|
|
|
|
|
hard.push({ key: 'ruin-tree', x: x + U * 1.3, y: y - U * 0.9, faces: deadTree(x + U * 1.3, y - U * 0.9, U * 1.3, 78) })
|
|
|
|
|
|
smoke.push(project([x + U * 0.1, y, U * 0.35]))
|
|
|
|
|
|
taken.push({ x, y, r: U * 1.8 })
|
|
|
|
|
|
}
|
|
|
|
|
|
for (const o of hard) objects.push({ key: o.key, depth: o.x + o.y, polys: toPolys(o.faces) })
|
|
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
const f = U * 1.25
|
|
|
|
|
|
const cornersW = [inverse([view.x, view.y]), inverse([view.x + w, view.y]), inverse([view.x, view.y + h]), inverse([view.x + w, view.y + h])]
|
|
|
|
|
|
const fi0 = Math.floor(Math.min(...cornersW.map((c) => c[0])) / f)
|
|
|
|
|
|
const fi1 = Math.ceil(Math.max(...cornersW.map((c) => c[0])) / f)
|
|
|
|
|
|
const fj0 = Math.floor(Math.min(...cornersW.map((c) => c[1])) / f)
|
|
|
|
|
|
const fj1 = Math.ceil(Math.max(...cornersW.map((c) => c[1])) / f)
|
|
|
|
|
|
const cx = view.x + w / 2
|
|
|
|
|
|
for (let i = fi0; i <= fi1; i++) {
|
|
|
|
|
|
for (let j = fj0; j <= fj1; j++) {
|
|
|
|
|
|
const x = (i + hash(i, j, 61) * 0.8) * f
|
|
|
|
|
|
const y = (j + hash(i, j, 62) * 0.8) * f
|
|
|
|
|
|
const [X, Y] = project([x, y, 0])
|
|
|
|
|
|
if (X < view.x - U || X > view.x + w + U || Y < view.y || Y > view.y + h + U * 2) continue
|
|
|
|
|
|
const r = Math.hypot(x, y)
|
|
|
|
|
|
if (r < Rv + U * 1.5) continue
|
|
|
|
|
|
if (roadClear(x, y)) continue
|
|
|
|
|
|
if (taken.some((t) => Math.hypot(x - t.x, y - t.y) < t.r + U * 0.35)) continue
|
|
|
|
|
|
// Open meadow round the village, forest thickening towards the sides and the back.
|
|
|
|
|
|
const edge = Math.abs(X - cx) / (w / 2)
|
|
|
|
|
|
const far = Math.min(1, Math.max(0, (r - Rz * 0.75) / (Rz * 0.5)))
|
|
|
|
|
|
let density = 0.05 + 0.25 * far + 0.75 * Math.max(0, edge - 0.55) / 0.45 + (Y < view.y + h * 0.15 ? 0.15 : 0)
|
|
|
|
|
|
if (inSector(x, y, 'timber', deg(22)) && r > zoneEnd('timber') - U && r < zoneEnd('timber') + U * 4) density += 0.4
|
|
|
|
|
|
if (inSector(x, y, 'farm', deg(6)) && r < zoneEnd('farm') + U * 1.5) density *= 0.15
|
|
|
|
|
|
if (inSector(x, y, 'iron', deg(10))) density *= 0.45
|
|
|
|
|
|
if (inSector(x, y, 'clay', deg(4)) && r < zoneEnd('clay') + U) density *= 0.4
|
|
|
|
|
|
const size = U * (1.0 + 0.55 * hash(i, j, 65))
|
|
|
|
|
|
const seed = i * 131 + j
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
if (hash(i, j, 63) > Math.min(density, 0.88)) {
|
|
|
|
|
|
// The forest round the village has been cut for timber and firewood: stumps remain.
|
|
|
|
|
|
const cleared = r < Rz * 1.1 && !inSector(x, y, 'farm', deg(6)) ? 0.16 : 0.03
|
|
|
|
|
|
if (hash(i, j, 66) < cleared) objects.push({ key: `s${i}:${j}`, depth: x + y, polys: toPolys(stump(x, y, size, seed)) })
|
|
|
|
|
|
continue
|
|
|
|
|
|
}
|
|
|
|
|
|
const kind = hash(i, j, 64)
|
|
|
|
|
|
const faces = kind < 0.1 ? bush(x, y, size * 0.8, seed) : kind < 0.6 ? conifer(x, y, size, seed) : kind < 0.68 ? deadTree(x, y, size, seed) : broadleaf(x, y, size, seed)
|
2026-10-28 19:33:14 +00:00
|
|
|
|
taken.push({ x, y, r: size * 0.3 })
|
2026-10-30 09:35:47 +00:00
|
|
|
|
shadows.push(shadow(x, y, size * 0.34, scale(GRASS[3]!, 0.8), seed))
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
// Further out the forest goes dark.
|
2026-10-30 09:35:47 +00:00
|
|
|
|
objects.push({ key: `t${i}:${j}`, depth: x + y, polys: toPolys(faces.map((face) => ({ ...face, color: fade(face.color, r, Rz * 0.9, Rz * 1.8, 0.2) }))) })
|
2026-10-28 19:33:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
// A few stones in the meadows.
|
|
|
|
|
|
for (let k = 0; k < 14; k++) {
|
|
|
|
|
|
const a = hash(k, 71) * Math.PI * 2
|
|
|
|
|
|
const r = Rv + U * (1.4 + 6 * hash(k, 72))
|
|
|
|
|
|
const [x, y] = [Math.cos(a) * r, Math.sin(a) * r]
|
|
|
|
|
|
if (roadClear(x, y) || taken.some((t) => Math.hypot(x - t.x, y - t.y) < t.r + U * 0.3)) continue
|
|
|
|
|
|
objects.push({ key: `stone-${k}`, depth: x + y, polys: toPolys(rock(x, y, U * (0.45 + 0.4 * hash(k, 73)), 200 + k)) })
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-28 20:03:51 +00:00
|
|
|
|
// Countdowns for the orders builders are working on, above what they change.
|
|
|
|
|
|
const timers: SceneTimer[] = []
|
|
|
|
|
|
for (const o of village.queue) {
|
|
|
|
|
|
if (!o.finishes_at) continue
|
|
|
|
|
|
const onBuilding = o.building_id !== null ? anchorOfBuilding.get(o.building_id) : undefined
|
|
|
|
|
|
const at = onBuilding ?? anchorOfOrder.get(o.id)
|
|
|
|
|
|
if (at) timers.push({ orderId: o.id, finishesAt: o.finishes_at, at, buildingId: onBuilding ? o.building_id : null })
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-29 14:50:07 +00:00
|
|
|
|
// Villagers go out to the zones they work in, work there with their tool and bring the
|
|
|
|
|
|
// load home, more where more work. One walks out of the gate and back.
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
const walks: Scene['walks'] = []
|
|
|
|
|
|
for (const zone of activeZones) {
|
|
|
|
|
|
const workers = village.buildings.filter((b) => ZONE_OF[b.type] === zone).reduce((n, b) => n + b.workers.assigned, 0)
|
|
|
|
|
|
if (!workers) continue
|
|
|
|
|
|
const end = zoneEnd(zone)
|
|
|
|
|
|
const d = walkPath(ZONES[zone].angle, hqRadius * 0.9, end + U * 0.5, ZONE_NAMES.indexOf(zone) + 2, hqRadius * 1.4, end - U * 1.2)
|
2026-10-29 14:50:07 +00:00
|
|
|
|
walks.push({ d, count: Math.min(3, Math.max(1, Math.round(workers / 6))), walk: Math.max(8, ((end - hqRadius) / U) * 2.2), work: 4.5, ...WORK[zone] })
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
}
|
2026-10-29 14:50:07 +00:00
|
|
|
|
walks.push({ d: walkPath(FRONT, hqRadius * 0.9, Rz * 3, 1, hqRadius * 1.4, Rv + U * 5), count: 1, walk: 20, work: 0, tool: null, carry: null })
|
|
|
|
|
|
// A guard paces inside the gate.
|
|
|
|
|
|
if (wall) {
|
|
|
|
|
|
const arc = [10, 22, 34, 46].map((a) => project([Math.cos(FRONT + deg(a)) * (Rv - U * 0.9), Math.sin(FRONT + deg(a)) * (Rv - U * 0.9), 1.2]))
|
|
|
|
|
|
walks.push({ d: arc.map((p, i) => `${i ? 'L' : 'M'}${p[0].toFixed(1)} ${p[1].toFixed(1)}`).join(' '), count: 1, walk: 6, work: 2.5, tool: 'spear', carry: null })
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// People who stay put: two talking on the plaza in front of the headquarters, a builder
|
|
|
|
|
|
// at every order in the works.
|
|
|
|
|
|
const people = (key: string, x: number, y: number, facing: 1 | -1, tool: Tool | null, shirt: number) =>
|
|
|
|
|
|
objects.push({ key, depth: x + y, polys: [], life: { at: project([x, y, 1.2]), facing, tool, shirt } })
|
|
|
|
|
|
const [chatX, chatY] = dir(FRONT + deg(32)).map((v) => v * hqRadius * 1.3)
|
|
|
|
|
|
people('chat-a', chatX! - U * 0.45, chatY! + U * 0.45, 1, null, 1)
|
|
|
|
|
|
people('chat-b', chatX! + U * 0.45, chatY! - U * 0.45, -1, null, 3)
|
2026-10-29 15:08:57 +00:00
|
|
|
|
const path = (pts: V2[]) => pts.map(([x, y], i) => `${i ? 'L' : 'M'}${project([x, y, 1.2]).map((v) => v.toFixed(1)).join(' ')}`).join(' ')
|
|
|
|
|
|
const walker = (key: string, from: V2, to: V2, w: Omit<SceneWalker, 'd' | 'walk'>) =>
|
|
|
|
|
|
objects.push({ key, depth: Math.max(from[0] + from[1], to[0] + to[1]), polys: [], walker: { d: path([from, to]), walk: Math.max(2, Math.hypot(to[0] - from[0], to[1] - from[1]) / U * 0.9), ...w } })
|
|
|
|
|
|
|
|
|
|
|
|
// Every order in the queue shows where it goes: building materials piled at the site, a
|
|
|
|
|
|
// porter bringing more from the storage, and while it runs, a builder at work.
|
|
|
|
|
|
const store = village.buildings.find((b) => b.type === 'storage') ?? village.buildings.find((b) => b.type === 'headquarters')
|
|
|
|
|
|
const storeDoor = store ? doorOf.get(store.id) : undefined
|
|
|
|
|
|
const sites = new Set<string>()
|
|
|
|
|
|
for (const o of village.queue) {
|
2026-10-29 14:50:07 +00:00
|
|
|
|
const b = o.building_id !== null ? village.buildings.find((x) => x.id === o.building_id) : null
|
2026-10-29 15:08:57 +00:00
|
|
|
|
if (b?.type === 'wall' || (!b && o.type === 'wall')) continue
|
2026-10-29 14:50:07 +00:00
|
|
|
|
const slot = b ? (b.type === 'headquarters' ? core[0]! : slotOf(`b${b.id}`)) : slotOf(`o${o.id}`)
|
2026-10-29 15:08:57 +00:00
|
|
|
|
if (o.builder !== null) {
|
|
|
|
|
|
people(`builder-${o.id}`, slot.x + slot.r * 0.95, slot.y + slot.r * 0.35, -1, o.action === 'demolish' ? 'pick' : 'hammer', o.id)
|
|
|
|
|
|
}
|
|
|
|
|
|
if (sites.has(slot.key) || o.action === 'demolish') continue
|
|
|
|
|
|
sites.add(slot.key)
|
|
|
|
|
|
const pile: V2 = [slot.x + slot.r * 0.3, slot.y + slot.r * 1.05]
|
|
|
|
|
|
const pileFaces = [
|
|
|
|
|
|
...box(pile[0], pile[1], U * 0.75, U * 0.32, 0, U * 0.11, C.plank, C.wood),
|
|
|
|
|
|
...box(pile[0] + U * 0.05, pile[1] - U * 0.04, U * 0.7, U * 0.3, U * 0.11, U * 0.11, C.wood, C.plank),
|
|
|
|
|
|
...pyramid(ngon(pile[0] + U * 0.55, pile[1] + U * 0.15, U * 0.22, 5), 0, U * 0.22, C.stone),
|
|
|
|
|
|
]
|
|
|
|
|
|
objects.push({ key: `pile-${o.id}`, depth: pile[0] + pile[1], polys: toPolys(pileFaces) })
|
|
|
|
|
|
if (storeDoor && Math.hypot(storeDoor[0] - pile[0], storeDoor[1] - pile[1]) > U * 1.5) {
|
|
|
|
|
|
walker(`porter-${o.id}`, storeDoor, [pile[0] + U * 0.6, pile[1] - U * 0.3], { work: 1.4, rest: 3, indoors: true, tool: null, carry: C.plank, shirt: o.id + 2, begin: -o.id * 1.7 })
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Units in training drill in front of their building, an instructor facing them.
|
|
|
|
|
|
for (const m of village.military) {
|
|
|
|
|
|
if (!m.queue.length) continue
|
|
|
|
|
|
const b = village.buildings.find((x) => x.id === m.building_id)
|
|
|
|
|
|
if (!b) continue
|
|
|
|
|
|
const slot = slotOf(`b${b.id}`)
|
|
|
|
|
|
for (let k = 0; k < 3; k++) {
|
|
|
|
|
|
const x = slot.x + slot.r * 1.15
|
|
|
|
|
|
const y = slot.y - slot.r * 0.35 + k * U * 0.55
|
|
|
|
|
|
objects.push({ key: `drill-${b.id}-${k}`, depth: x + y, polys: [], life: { at: project([x, y, 1.2]), facing: 1, tool: 'spear', shirt: 1, drill: true } })
|
|
|
|
|
|
}
|
|
|
|
|
|
people(`instructor-${b.id}`, slot.x + slot.r * 1.15 + U * 1.1, slot.y + slot.r * 0.2, -1, null, 4)
|
2026-10-29 14:50:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-29 15:43:23 +00:00
|
|
|
|
// Troops at home stand guard at the doors, more doors the bigger the army.
|
|
|
|
|
|
const garrison = garrisonOf(village)
|
|
|
|
|
|
for (const b of village.buildings) {
|
|
|
|
|
|
const door = doorOf.get(b.id)
|
|
|
|
|
|
if (!door) continue
|
|
|
|
|
|
guardSpots(b.type, door, guardsAt(b.type, garrison), U).forEach(([x, y], k) =>
|
|
|
|
|
|
objects.push({ key: `guard-${b.id}-${k}`, depth: x + y, polys: [], life: { at: project([x, y, 1.2]), facing: 1, tool: 'spear', shirt: 1, guard: true } }),
|
|
|
|
|
|
)
|
|
|
|
|
|
}
|
|
|
|
|
|
|
2026-10-29 15:08:57 +00:00
|
|
|
|
// Villagers step out of their buildings now and then, stand a moment, and go back in.
|
|
|
|
|
|
const homes = village.buildings.filter((b) => doorOf.has(b.id) && !ZONE_OF[b.type]).slice(0, 6)
|
|
|
|
|
|
homes.forEach((b, k) => {
|
|
|
|
|
|
const door = doorOf.get(b.id)!
|
|
|
|
|
|
const a = FRONT + deg(-40 + hash(b.id, 7) * 60)
|
|
|
|
|
|
const out: V2 = [door[0] + Math.cos(a) * U * (1.3 + hash(b.id, 8)), door[1] + Math.sin(a) * U * (1.3 + hash(b.id, 8))]
|
|
|
|
|
|
const soldier = village.military.some((m) => m.building_id === b.id)
|
|
|
|
|
|
walker(`visitor-${b.id}`, door, out, {
|
|
|
|
|
|
work: 2 + hash(b.id, 9) * 3,
|
|
|
|
|
|
rest: 6 + hash(b.id, 10) * 10,
|
|
|
|
|
|
indoors: true,
|
|
|
|
|
|
tool: soldier ? 'spear' : null,
|
2026-10-29 15:43:23 +00:00
|
|
|
|
soldier,
|
2026-10-29 15:08:57 +00:00
|
|
|
|
carry: b.type === 'storage' ? C.plank : null,
|
|
|
|
|
|
shirt: b.id,
|
|
|
|
|
|
begin: -k * 4.3,
|
|
|
|
|
|
})
|
|
|
|
|
|
})
|
|
|
|
|
|
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
// Crows cross the upper part of the view now and then, and circle over the graves and
|
|
|
|
|
|
// the gallows.
|
2026-10-29 14:50:07 +00:00
|
|
|
|
const birds: Scene['birds'] = [0, 1].map((k) => {
|
|
|
|
|
|
const y0 = view.y + h * (0.12 + 0.1 * k)
|
|
|
|
|
|
return { d: `M${(view.x - U * 2).toFixed(1)} ${y0.toFixed(1)} L${(view.x + w + U * 2).toFixed(1)} ${(y0 - h * 0.08).toFixed(1)}`, dur: 30 + k * 11, begin: -k * 17 }
|
|
|
|
|
|
})
|
feat: grim, war-worn village: cold overcast light, a dark desaturated palette, mud, ruts and puddles, rotten roofs, stumps and dead trees, a graveyard, the gallows, a burnt farmstead, blood on the training yard and rally ground, drab clothes, sooty smoke and crows
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-30 09:26:43 +00:00
|
|
|
|
const circle = ([x, y]: V2, rx: number, k: number) => {
|
|
|
|
|
|
const [cx, cy] = project([x, y, U * (3.2 + k)])
|
|
|
|
|
|
const ry = rx * 0.4
|
|
|
|
|
|
return `M${(cx - rx).toFixed(1)} ${cy.toFixed(1)} A${rx.toFixed(1)} ${ry.toFixed(1)} 0 1 1 ${(cx + rx).toFixed(1)} ${cy.toFixed(1)} A${rx.toFixed(1)} ${ry.toFixed(1)} 0 1 1 ${(cx - rx).toFixed(1)} ${cy.toFixed(1)}`
|
|
|
|
|
|
}
|
|
|
|
|
|
const gallowsAt = hard.find((o) => o.key === 'gallows')
|
|
|
|
|
|
for (const [k, at] of [yard, yard, gallowsAt ? ([gallowsAt.x, gallowsAt.y] as V2) : null].entries()) {
|
|
|
|
|
|
if (at) birds.push({ d: circle(at, U * (1.6 + k * 0.5), k * 0.6), dur: 9 + k * 3, begin: -k * 4 })
|
|
|
|
|
|
}
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
|
2026-10-28 19:33:14 +00:00
|
|
|
|
objects.sort((a, b) => a.depth - b.depth)
|
2026-10-28 18:54:20 +00:00
|
|
|
|
return {
|
2026-10-28 19:33:14 +00:00
|
|
|
|
viewBox: `${view.x.toFixed(1)} ${view.y.toFixed(1)} ${w.toFixed(1)} ${h.toFixed(1)}`,
|
|
|
|
|
|
width: w,
|
|
|
|
|
|
height: h,
|
2026-10-30 09:35:47 +00:00
|
|
|
|
terrain: ground(view, { r0: Rz * 0.9, r1: Rz * 1.8 }),
|
2026-10-28 19:33:14 +00:00
|
|
|
|
// One at a time, so the layers keep the order they were added in.
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
decals: [...decalFaces, ...shadows].flatMap((face) => toPolys([face])),
|
2026-10-29 13:09:03 +00:00
|
|
|
|
// Wall segments keep their own outlines; the band below covers the stretches between.
|
2026-10-29 15:42:50 +00:00
|
|
|
|
objects: objects.map(({ key, polys, building, planned, life, walker }) => ({
|
2026-10-29 13:09:03 +00:00
|
|
|
|
key,
|
|
|
|
|
|
polys,
|
|
|
|
|
|
building: building ? { ...building, hit: hitOutline(polys, building.ring) } : undefined,
|
|
|
|
|
|
planned,
|
2026-10-29 14:50:07 +00:00
|
|
|
|
life,
|
2026-10-29 15:42:50 +00:00
|
|
|
|
walker,
|
2026-10-29 13:09:03 +00:00
|
|
|
|
})),
|
|
|
|
|
|
// Centred halfway up the palisade, so the band covers the wall itself, not only its foot.
|
|
|
|
|
|
wallBand: wall ? { id: wall.id, ring: { ...screenRing(0, 0, Rv), cy: -wallTop / 2 }, width: U * 1.6 + wallTop } : null,
|
2026-10-28 21:14:56 +00:00
|
|
|
|
plots,
|
2026-10-28 20:03:51 +00:00
|
|
|
|
timers,
|
feat: building portraits, screen headers and a livelier village: shadows, smoke, walkers, a pond
Each building screen opens with the building drawn as it stands, its level and what it
does; the HQ list and the building cards show the same portraits. In the village,
buildings and trees cast flat shadows, chimneys, forges and kilns smoke, villagers walk
the roads to the zones they work in (more where more work), and a pond lies in the
meadow. Motion stops for players who prefer reduced motion.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 23:46:15 +00:00
|
|
|
|
smoke,
|
|
|
|
|
|
walks,
|
2026-10-29 14:50:07 +00:00
|
|
|
|
herds,
|
|
|
|
|
|
birds,
|
2026-10-28 18:54:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
}
|