game-village-politics-frontend/app/diorama/mapVillage.ts

485 lines
24 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// Villages on the world map, seen from above like the village pictures on the Die Stämme
// map: a predefined picture per points tier (six, like its v1 to v6), hand-placed, not
// generated from counts. A round plot of trodden earth fills the field, its edge in the
// relation colour; on it the roofs seen from above (two halves either side of the ridge, or
// four facets of a hipped roof, lit from the upper left like the village, a flat shadow to
// the lower right), the yard, paths to the gate and gardens; a stake palisade from the third
// tier, a stone wall with towers from the fifth, the headquarters the biggest roof in the
// middle with the flag. Barbarian villages have the same layouts worn: darker, roofs gone
// grey and broken, a house burnt down, weeds in the yard, gaps in the palisade, no flag.
// Crown forts are a stone keep in a walled ring. Each look is drawn once as an SVG <symbol>
// (`MapVillageDefs`) and placed with <use>; the relation colour (the plot's edge and the flag)
// is `currentColor`, set per village. Two variants per tier, mirrored, picked by the village
// id. Units: a field is 100 × 100, the plot's centre at 0|0.
import { mix, scale } from './iso'
import { C } from './models'
export type MapTier = 1 | 2 | 3 | 4 | 5 | 6
/** One path of a look: the shapes of one colour and layer, merged into one element. */
export interface MapVillageShape {
d: string
fill?: string
stroke?: string
width?: number
dash?: string
}
export interface MapVillageLook {
id: string
shapes: MapVillageShape[]
}
/** Lowest points of tiers 2 to 6; below the first, tier 1. */
export const MAP_TIER_POINTS = [300, 1000, 3000, 6000, 10000] as const
/** Six sizes by points, like the village pictures on the Die Stämme map. */
export const mapTier = (points: number): MapTier => (MAP_TIER_POINTS.findIndex((p) => points < p) + 1 || 6) as MapTier
/** The relation colour, set on each <use>. */
const OWNER = 'currentColor'
/** Stands for the shadow colour of the plot's earth until the look is built. */
const SHADOW = 'shadow'
/** The plot's dark rim, so every relation colour stands off the grass. */
const RIM = '#2b2118'
const EARTH = '#6c5940'
const EARTH_WORN = '#574a3a'
/** Paths, the plaza and the yard: trodden lighter. */
const PATH = '#806a4c'
const PATH_WORN = '#655542'
const WEEDS = '#575c3c'
/** Weathered grey that a barbarian village's roofs fade to. */
const WEATHER = '#77726a'
// Light from the upper left, as in the village: what faces it keeps its colour, what faces
// away drops to two thirds and cools a little, the rest in between.
const LIGHT: [number, number] = [-0.6, -0.8]
function tone(base: string, nx: number, ny: number): string {
const d = nx * LIGHT[0] + ny * LIGHT[1]
return d > 0.35 ? scale(base, 1.05) : d < -0.35 ? mix(scale(base, 0.64), '#2a3038', 0.12) : scale(base, 0.84)
}
type Pt = [number, number]
const f = (n: number) => (Math.round(n * 10) / 10).toString()
const poly = (pts: Pt[]) => `M${pts.map(([x, y]) => `${f(x)} ${f(y)}`).join('L')}Z`
const line = (pts: Pt[]) => `M${pts.map(([x, y]) => `${f(x)} ${f(y)}`).join('L')}`
const circle = (cx: number, cy: number, r: number) => `M${f(cx - r)} ${f(cy)}a${f(r)} ${f(r)} 0 1 0 ${f(2 * r)} 0a${f(r)} ${f(r)} 0 1 0 ${f(-2 * r)} 0Z`
const box = (cx: number, cy: number, hw: number, hh: number) => poly([[cx - hw, cy - hh], [cx + hw, cy - hh], [cx + hw, cy + hh], [cx - hw, cy + hh]])
/** An arc round the plot's centre (or moved by dx|dy, for its shadow) from angle a0 to a1 (radians, clockwise on screen). */
function arc(r: number, a0: number, a1: number, dx = 0, dy = 0) {
const p = (a: number) => `${f(dx + Math.cos(a) * r)} ${f(dy + Math.sin(a) * r)}`
return `M${p(a0)}A${f(r)} ${f(r)} 0 ${a1 - a0 > Math.PI ? 1 : 0} 1 ${p(a1)}`
}
const rotate = ([x, y]: Pt, a: number): Pt => [x * Math.cos(a) - y * Math.sin(a), x * Math.sin(a) + y * Math.cos(a)]
// Painter's layers, bottom to top. Shapes within a layer never overlap, so each colour of a
// layer can be one path.
const enum L {
Base,
Ground,
Furrows,
Shadow,
Edge,
Wall,
Roof,
Ridge,
Tower,
Top,
}
/** Collects a look's shapes, merged by layer and style. */
class Picture {
private parts = new Map<string, { layer: number; order: number; style: Omit<MapVillageShape, 'd'>; d: string }>()
constructor(
/** Variant 1 is the mirror image of variant 0, lit the same way. */
readonly mirror: boolean,
readonly worn: boolean,
) {}
x = (x: number) => (this.mirror ? -x : x)
add(layer: L, style: Omit<MapVillageShape, 'd'>, d: string) {
if (!d) return
const key = `${layer}|${style.fill}|${style.stroke}|${style.width}|${style.dash}`
const part = this.parts.get(key)
if (part) part.d += d
else this.parts.set(key, { layer, order: this.parts.size, style, d })
}
shapes(shadow: string): MapVillageShape[] {
return [...this.parts.values()]
.sort((a, b) => a.layer - b.layer || a.order - b.order)
.map((p) => ({ d: p.d, ...p.style, ...(p.style.fill === SHADOW ? { fill: shadow } : {}), ...(p.style.stroke === SHADOW ? { stroke: shadow } : {}) }))
}
}
type Material = 'thatch' | 'tile' | 'shingle' | 'slate'
const MATERIAL: Record<Material, string> = { thatch: C.thatch, tile: C.roofRed, shingle: C.shingle, slate: C.slate }
interface RoofSpec {
/** Centre on the plot (mirrored in variant 1). */
at: Pt
/** Size along the ridge and across it. */
w: number
d: number
/** Turn in degrees, clockwise. */
turn?: number
material: Material
/** Gable: two halves; hip: four facets. */
hip?: boolean
/** How high it stands, for its shadow. */
height?: number
/** In a barbarian village: burnt down to its walls. */
burnt?: boolean
/** In a barbarian village: a hole in the roof. */
hole?: boolean
}
/** A roof seen from above, its shadow on the ground and its ridge. */
function roof(p: Picture, s: RoofSpec) {
const a = ((p.mirror ? -(s.turn ?? 0) : (s.turn ?? 0)) * Math.PI) / 180
const cx = p.x(s.at[0])
const cy = s.at[1]
const at = (x: number, y: number): Pt => {
const [rx, ry] = rotate([x, y], a)
return [cx + rx, cy + ry]
}
const hw = s.w / 2
const hd = s.d / 2
const h = s.height ?? Math.min(s.w, s.d) * 0.6
const corners = [at(-hw, -hd), at(hw, -hd), at(hw, hd), at(-hw, hd)]
p.add(L.Shadow, { fill: SHADOW }, poly(corners.map(([x, y]) => [x + h * 0.42, y + h * 0.3])))
if (p.worn && s.burnt) {
// Charred walls round the ash, a fallen beam or two across.
p.add(L.Roof, { fill: C.char }, poly(corners))
p.add(L.Ridge, { fill: C.ash }, poly([at(-hw + 1.6, -hd + 1.6), at(hw - 1.6, -hd + 1.6), at(hw - 1.6, hd - 1.6), at(-hw + 1.6, hd - 1.6)]))
p.add(L.Tower, { stroke: C.char, width: 1.2 }, line([at(-hw + 1, -hd * 0.3), at(hw - 2, hd * 0.5)]) + line([at(-hw * 0.3, -hd + 1), at(hw * 0.1, hd - 1)]))
return
}
const base = p.worn ? scale(mix(MATERIAL[s.material], WEATHER, 0.5), 0.88) : MATERIAL[s.material]
const facet = (pts: Pt[], nx: number, ny: number) => {
const [ex, ey] = rotate([nx, ny], a)
p.add(L.Roof, { fill: tone(base, ex, ey) }, poly(pts))
}
const ridge = scale(base, 0.56)
if (s.hip) {
const r = Math.max(0, hw - hd)
facet([at(-hw, -hd), at(hw, -hd), at(r, 0), at(-r, 0)], 0, -1)
facet([at(-hw, hd), at(hw, hd), at(r, 0), at(-r, 0)], 0, 1)
facet([at(-hw, -hd), at(-r, 0), at(-hw, hd)], -1, 0)
facet([at(hw, -hd), at(r, 0), at(hw, hd)], 1, 0)
if (r > 0) p.add(L.Ridge, { stroke: ridge, width: 0.9 }, line([at(-r, 0), at(r, 0)]))
} else {
facet([at(-hw, -hd), at(hw, -hd), at(hw, 0), at(-hw, 0)], 0, -1)
facet([at(-hw, 0), at(hw, 0), at(hw, hd), at(-hw, hd)], 0, 1)
p.add(L.Ridge, { stroke: ridge, width: 0.9 }, line([at(-hw, 0), at(hw, 0)]))
}
if (p.worn && s.hole) {
// Fallen in: the rafters show over the dark inside.
p.add(L.Ridge, { fill: C.char }, poly([at(-hw * 0.1, hd * 0.15), at(hw * 0.55, hd * 0.15), at(hw * 0.45, hd * 0.8), at(-hw * 0.05, hd * 0.75)]))
p.add(L.Tower, { stroke: scale(C.wood, 0.8), width: 0.7 }, line([at(hw * 0.12, hd * 0.15), at(hw * 0.12, hd * 0.78)]) + line([at(hw * 0.32, hd * 0.15), at(hw * 0.3, hd * 0.8)]))
}
}
/** A round tower or a tree seen from above: a cone or a crown, lit half and shadowed half. */
function round(p: Picture, layer: L, at: Pt, r: number, base: string, height: number) {
const cx = p.x(at[0])
const cy = at[1]
p.add(L.Shadow, { fill: SHADOW }, circle(cx + height * 0.42, cy + height * 0.3, r))
// The line between the halves runs across the light.
const dx = 0.8 * r
const dy = -0.6 * r
const half = (sweep: 0 | 1) => `M${f(cx + dx)} ${f(cy + dy)}A${f(r)} ${f(r)} 0 0 ${sweep} ${f(cx - dx)} ${f(cy - dy)}Z`
p.add(layer, { fill: tone(base, -0.6, -0.8) }, half(0))
p.add(layer, { fill: tone(base, 0.6, 0.8) }, half(1))
}
const SLATE = (p: Picture) => (p.worn ? mix(C.slate, WEATHER, 0.4) : C.slate)
const tree = (p: Picture, at: Pt, r: number) => round(p, L.Roof, at, r, p.worn ? C.broadleafDark : C.broadleaf, r * 1.6)
const hay = (p: Picture, at: Pt, r: number) => round(p, L.Roof, at, r, p.worn ? mix(C.hay, WEATHER, 0.5) : C.hay, r)
/** Paths trodden into the yard, each a run of points. */
function paths(p: Picture, width: number, ...runs: Pt[][]) {
p.add(L.Ground, { stroke: p.worn ? PATH_WORN : PATH, width }, runs.map((r) => line(r.map(([x, y]) => [p.x(x), y]))).join(''))
}
/** The plaza: a trodden patch in front of the headquarters. */
const plaza = (p: Picture, at: Pt, r: number) => p.add(L.Ground, { fill: p.worn ? PATH_WORN : PATH }, circle(p.x(at[0]), at[1], r))
/** A garden or a little field: furrows across a patch of greens or wheat; weeds in a barbarian village. */
function garden(p: Picture, at: Pt, w: number, d: number, turn: number, wheat = false) {
const a = ((p.mirror ? -turn : turn) * Math.PI) / 180
const cx = p.x(at[0])
const cy = at[1]
const pt = (x: number, y: number): Pt => {
const [rx, ry] = rotate([x, y], a)
return [cx + rx, cy + ry]
}
p.add(L.Ground, { fill: p.worn ? WEEDS : wheat ? C.wheat : C.field }, poly([pt(-w / 2, -d / 2), pt(w / 2, -d / 2), pt(w / 2, d / 2), pt(-w / 2, d / 2)]))
let rows = ''
for (let y = -d / 2 + 2; y < d / 2 - 1; y += 2.6) rows += line([pt(-w / 2 + 1, y), pt(w / 2 - 1, y)])
p.add(L.Furrows, { stroke: C.furrow, width: 0.8 }, rows)
}
/** A well on the plaza: a stone ring round the dark shaft. */
function well(p: Picture, at: Pt) {
p.add(L.Roof, { fill: C.stone }, circle(p.x(at[0]), at[1], 2.6))
p.add(L.Ridge, { fill: C.dark }, circle(p.x(at[0]), at[1], 1.3))
}
/** Weeds grown over the yard of a barbarian village. */
function weeds(p: Picture, ...spots: [number, number, number][]) {
if (p.worn) p.add(L.Furrows, { fill: WEEDS }, spots.map(([x, y, r]) => circle(p.x(x), y, r)).join(''))
}
/** A few graves behind the chapel, the newest still open. */
function graves(p: Picture, ...at: Pt[]) {
p.add(L.Ridge, { fill: C.stoneDark }, at.slice(1).map(([x, y]) => box(p.x(x), y, 0.8, 1.3)).join(''))
p.add(L.Ridge, { fill: C.dark }, box(p.x(at[0]![0]), at[0]![1], 0.9, 1.6))
}
/** Half the gate's width at the bottom of a ring, in radians. */
const GATE = 0.2
const TURN = Math.PI * 2
/** Runs of a ring from the gate round to the gate, without the gaps (angles, mirrored in variant 1). */
function ringRuns(p: Picture, gaps: [number, number][]): [number, number][] {
const from = Math.PI / 2 + GATE
const to = from + TURN - GATE * 2
const runs: [number, number][] = []
let a = from
const norm = (g: number) => (g < from ? g + TURN : g)
for (const [g0, g1] of gaps.map(([g0, g1]) => (p.mirror ? [Math.PI - g1, Math.PI - g0] : [g0, g1])).map(([g0, g1]) => [norm(g0!), norm(g1!)]).sort((x, y) => x[0]! - y[0]!)) {
runs.push([a, g0!])
a = g1!
}
runs.push([a, to])
return runs
}
/** A stake palisade round the plot, the gate at the bottom: posts, or wooden gate towers. A barbarian's has gaps. */
function palisade(p: Picture, r: number, towers: boolean) {
const runs = ringRuns(p, p.worn ? [[0.5, 0.75], [2.7, 2.85], [4.3, 4.55]] : [])
const d = runs.map(([a0, a1]) => arc(r, a0, a1)).join('')
p.add(L.Shadow, { stroke: SHADOW, width: 3.2 }, runs.map(([a0, a1]) => arc(r, a0, a1, 1.8, 1.3)).join(''))
p.add(L.Wall, { stroke: p.worn ? mix(C.woodDark, WEATHER, 0.3) : scale(C.woodDark, 0.85), width: 3.4 }, d)
// The stakes' tops, lit.
p.add(L.Ridge, { stroke: p.worn ? mix(C.plank, WEATHER, 0.4) : C.plank, width: 2.2, dash: '1.5 0.9' }, d)
for (const s of [-1, 1]) {
const g = Math.PI / 2 + s * (GATE + 0.05)
// Either side of the gate, the same in both variants.
const at: Pt = [Math.cos(g) * r, Math.sin(g) * r]
if (towers) roof(p, { at, w: 6.5, d: 6.5, material: 'shingle', hip: true, height: 9 })
else p.add(L.Wall, { fill: C.woodDark }, box(at[0], at[1], 1.7, 1.7))
}
}
/** A stone wall round the plot with battlements, round towers and a gate at the bottom. */
function stoneWall(p: Picture, r: number, towers: number, gatehouse: boolean) {
const stone = p.worn ? scale(mix(C.stone, WEATHER, 0.3), 0.9) : C.stone
const from = Math.PI / 2 + GATE
const to = from + TURN - GATE * 2
const d = arc(r, from, to)
p.add(L.Shadow, { stroke: SHADOW, width: 4.4 }, arc(r, from + 0.05, to - 0.05, 2, 1.5))
p.add(L.Wall, { stroke: scale(stone, 0.72), width: 4.6 }, d)
p.add(L.Wall, { stroke: stone, width: 2.8 }, arc(r - 0.5, from, to))
// Merlons along the outer edge.
p.add(L.Ridge, { stroke: scale(stone, 0.58), width: 1.2, dash: '1.6 1.4' }, arc(r + 1.4, from, to))
for (let k = 0; k < towers; k++) {
const a = Math.PI / 2 + ((k + 0.5) / towers) * TURN
// Spread evenly from the gate, so the same in both variants.
round(p, L.Tower, [Math.cos(a) * r, Math.sin(a) * r], 4.4, SLATE(p), 12)
}
for (const s of [-1, 1]) {
const g = Math.PI / 2 + s * (GATE + 0.03)
round(p, L.Tower, [Math.cos(g) * r, Math.sin(g) * r], gatehouse ? 4.8 : 3.8, SLATE(p), 13)
}
if (gatehouse) roof(p, { at: [0, r - 0.5], w: 8, d: 6, material: 'slate', hip: true, height: 10 })
}
/** The village's flag on a pole at the headquarters, in the relation colour, and its shadow. */
function flag(p: Picture, at: Pt) {
if (p.worn) return
const x = p.x(at[0])
const y = at[1]
p.add(L.Top, { fill: SHADOW }, poly([[x + 4, y + 3], [x + 15, y + 5], [x + 5, y + 9.5]]))
p.add(L.Top, { fill: C.woodDark }, circle(x, y, 1.3))
p.add(L.Top, { fill: OWNER }, poly([[x, y - 1.2], [x + 12, y + 2], [x + 0.6, y + 6.6]]))
}
// The six pictures. Roofs never overlap, nor trees and roofs, so the layers can merge by colour.
function tier1(p: Picture) {
plaza(p, [0, 7], 8)
paths(p, 4, [[0, 41], [0, 8]], [[0, 9], [-19, 10]], [[0, 9], [16, 16]])
garden(p, [-14, 27], 15, 10, -12)
weeds(p, [10, 27, 5], [-25, -6, 4])
roof(p, { at: [0, -8], w: 27, d: 14, material: 'thatch', height: 10, hole: true })
roof(p, { at: [-21, 7], w: 15, d: 11, turn: 82, material: 'thatch', height: 7, burnt: true })
roof(p, { at: [18, 18], w: 14, d: 10, turn: -8, material: 'thatch', height: 7 })
tree(p, [-19, -22], 6.5)
tree(p, [21, -20], 5.5)
hay(p, [26, 3], 3.4)
flag(p, [12, -15])
}
function tier2(p: Picture) {
plaza(p, [0, 7], 10)
paths(p, 4, [[0, 43], [0, 8]], [[0, 8], [-21, 6]], [[0, 8], [21, 9]], [[-6, 14], [-15, 23]], [[6, 14], [16, 25]])
garden(p, [-24, -21], 14, 10, 32, true)
garden(p, [25, -20], 13, 9, -30)
weeds(p, [-8, 31, 5], [28, 0, 4])
well(p, [5, 9])
roof(p, { at: [0, -9], w: 29, d: 15, material: 'thatch', height: 11 })
roof(p, { at: [-23, 6], w: 15, d: 11, turn: 84, material: 'thatch', height: 7, hole: true })
roof(p, { at: [23, 8], w: 14, d: 11, turn: -84, material: 'shingle', height: 7 })
roof(p, { at: [-16, 25], w: 14, d: 9, turn: -12, material: 'thatch', height: 6, burnt: true })
roof(p, { at: [17, 26], w: 13, d: 9, turn: 14, material: 'thatch', height: 6 })
tree(p, [-6, -30], 5.5)
tree(p, [9, -31], 5)
hay(p, [33, -5], 3)
flag(p, [13, -16])
}
function tier3(p: Picture) {
plaza(p, [0, 7], 10)
paths(p, 4, [[0, 45], [0, 8]], [[-26, 8], [26, 8]])
garden(p, [-24, -20], 12, 10, 38, true)
weeds(p, [24, 27, 4], [-4, -29, 4])
well(p, [6, 10])
roof(p, { at: [0, -9], w: 28, d: 16, material: 'tile', hip: true, height: 12 })
roof(p, { at: [-22, -3], w: 15, d: 11, turn: 86, material: 'thatch', height: 7, hole: true })
roof(p, { at: [23, -2], w: 15, d: 11, turn: -86, material: 'tile', height: 7 })
roof(p, { at: [-17, 21], w: 15, d: 10, turn: -14, material: 'thatch', height: 7, burnt: true })
roof(p, { at: [17, 21], w: 14, d: 10, turn: 14, material: 'shingle', height: 7 })
roof(p, { at: [13, -27], w: 17, d: 9, turn: -20, material: 'shingle', height: 7 })
tree(p, [-8, -29], 5)
hay(p, [-31, 9], 3)
palisade(p, 39.5, false)
flag(p, [12, -17])
}
function tier4(p: Picture) {
plaza(p, [0, 8], 11)
paths(p, 4.4, [[0, 46], [0, 9]], [[-28, 9], [28, 9]], [[-14, 9], [-22, 28]], [[14, 9], [22, 28]])
garden(p, [-26, -16], 11, 9, 50, true)
weeds(p, [-2, 31, 4], [28, -14, 3.5])
well(p, [6, 11])
roof(p, { at: [0, -8], w: 30, d: 17, material: 'tile', hip: true, height: 13, hole: true })
// The chapel: a long slate nave behind the headquarters, its tower at the end.
roof(p, { at: [15, -27], w: 20, d: 9, turn: -22, material: 'slate', height: 10 })
roof(p, { at: [4, -33], w: 7, d: 7, turn: -22, material: 'slate', hip: true, height: 16 })
roof(p, { at: [-23, -1], w: 15, d: 11, turn: 86, material: 'thatch', height: 7 })
roof(p, { at: [24, -2], w: 15, d: 11, turn: -86, material: 'tile', height: 7, hole: true })
roof(p, { at: [-8, 24], w: 13, d: 9, turn: -64, material: 'tile', height: 7 })
roof(p, { at: [8, 24], w: 13, d: 9, turn: 64, material: 'thatch', height: 7, burnt: true })
roof(p, { at: [-29, 18], w: 12, d: 9, turn: 30, material: 'shingle', height: 6 })
roof(p, { at: [29, 18], w: 12, d: 9, turn: -30, material: 'thatch', height: 6 })
roof(p, { at: [-12, -28], w: 13, d: 9, turn: 24, material: 'thatch', height: 6 })
palisade(p, 40.5, true)
flag(p, [13, -17])
}
function tier5(p: Picture) {
plaza(p, [0, 8], 11)
paths(p, 4.4, [[0, 47], [0, 9]], [[-28, 9], [28, 9]], [[-14, 9], [-21, 28]], [[14, 9], [21, 28]])
weeds(p, [0, 31, 4], [-28, -12, 3.5])
well(p, [6, 11])
// The headquarters a stone hall with a slate roof; the chapel and its graves behind it.
roof(p, { at: [0, -8], w: 31, d: 17, material: 'slate', hip: true, height: 14 })
roof(p, { at: [16, -26], w: 20, d: 9, turn: -24, material: 'slate', height: 10, hole: true })
roof(p, { at: [5, -33], w: 7, d: 7, turn: -24, material: 'slate', hip: true, height: 17 })
graves(p, [24, -13], [27, -15], [21, -16], [28, -11])
roof(p, { at: [-23, -2], w: 15, d: 11, turn: 86, material: 'tile', height: 8 })
roof(p, { at: [-14, -25], w: 14, d: 9, turn: 26, material: 'tile', height: 7 })
roof(p, { at: [-8, 24], w: 13, d: 9, turn: -64, material: 'tile', height: 7, burnt: true })
roof(p, { at: [8, 24], w: 13, d: 9, turn: 64, material: 'shingle', height: 7 })
roof(p, { at: [-28, 18], w: 12, d: 9, turn: 34, material: 'thatch', height: 6, hole: true })
roof(p, { at: [28, 18], w: 12, d: 9, turn: -34, material: 'tile', height: 6 })
roof(p, { at: [29, -1], w: 11, d: 9, turn: -88, material: 'thatch', height: 6 })
stoneWall(p, 41, 4, false)
flag(p, [14, -17])
}
function tier6(p: Picture) {
plaza(p, [0, 9], 10)
paths(p, 4.4, [[0, 47], [0, 10]], [[-30, 10], [30, 10]], [[-15, 10], [-23, 29]], [[15, 10], [23, 29]], [[-19, 10], [-30, -10]], [[19, 10], [30, -10]])
weeds(p, [0, 32, 4], [-31, 0, 3])
well(p, [6, 12])
// The headquarters a stone hall round a small court with two towers: the biggest roofs of the town.
roof(p, { at: [0, -14], w: 32, d: 9, material: 'slate', height: 15 })
roof(p, { at: [-12, -2], w: 13, d: 8, turn: 90, material: 'slate', height: 14 })
roof(p, { at: [12, -2], w: 13, d: 8, turn: 90, material: 'slate', height: 14, hole: true })
p.add(L.Ground, { fill: p.worn ? PATH_WORN : PATH }, box(0, -3, 7.5, 6.5))
round(p, L.Tower, [-16, -18], 3.8, SLATE(p), 18)
round(p, L.Tower, [16, -18], 3.8, SLATE(p), 18)
roof(p, { at: [10, -31], w: 18, d: 8, turn: -16, material: 'slate', height: 10 })
roof(p, { at: [-12, -31], w: 13, d: 8, turn: 18, material: 'tile', height: 7, burnt: true })
roof(p, { at: [-26, -16], w: 12, d: 8, turn: 52, material: 'tile', height: 7 })
roof(p, { at: [26, -16], w: 12, d: 8, turn: -52, material: 'tile', height: 7 })
roof(p, { at: [-28, 2], w: 11, d: 8, turn: 86, material: 'shingle', height: 7, hole: true })
roof(p, { at: [28, 2], w: 11, d: 8, turn: -86, material: 'tile', height: 7 })
roof(p, { at: [-8, 24], w: 13, d: 8, turn: -64, material: 'tile', height: 7 })
roof(p, { at: [8, 24], w: 13, d: 8, turn: 64, material: 'tile', height: 7 })
roof(p, { at: [-28, 20], w: 11, d: 8, turn: 36, material: 'thatch', height: 6 })
roof(p, { at: [28, 20], w: 11, d: 8, turn: -36, material: 'shingle', height: 6 })
stoneWall(p, 42, 6, true)
flag(p, [16, -24])
}
/** The crown fort: a square stone keep with battlements and corner turrets in a walled ring, the gold crown over it. */
function crownFort(p: Picture, banner: boolean) {
plaza(p, [0, 8], 17)
paths(p, 5, [[0, 47], [0, 18]])
weeds(p, [-24, 14, 4], [22, -22, 3.5])
const stone = p.worn ? scale(mix(C.stone, WEATHER, 0.3), 0.9) : C.stone
const s = 30
const [kx, ky] = [0, -5]
p.add(L.Shadow, { fill: SHADOW }, box(kx + 9, ky + 7, s / 2, s / 2))
// The keep's flat roof: the wall walk round it lit, the roof inside a step down, merlons on the edge.
p.add(L.Roof, { fill: stone }, box(kx, ky, s / 2, s / 2))
p.add(L.Ridge, { fill: scale(stone, 0.72) }, box(kx, ky, s / 2 - 4, s / 2 - 4))
p.add(L.Ridge, { stroke: scale(stone, 0.58), width: 1.3, dash: '2 2' }, box(kx, ky, s / 2 - 0.7, s / 2 - 0.7))
p.add(L.Tower, { fill: C.dark }, box(p.x(kx + 6), ky + 6, 1.6, 1.6))
for (const [cx, cy] of [[-1, -1], [1, -1], [1, 1], [-1, 1]] as const) round(p, L.Tower, [kx + (cx * s) / 2, ky + (cy * s) / 2], 4.4, SLATE(p), 20)
roof(p, { at: [-27, 7], w: 13, d: 8, turn: 80, material: 'tile', height: 6, hole: true })
roof(p, { at: [27, 7], w: 13, d: 8, turn: -80, material: 'shingle', height: 6 })
roof(p, { at: [-18, 26], w: 12, d: 8, turn: -40, material: 'tile', height: 6, burnt: true })
stoneWall(p, 42, 6, true)
// A player's flag on the keep's wall walk, clear of the crown.
if (banner) flag(p, [kx + 6, ky - 13])
const y = ky + 3
p.add(L.Top, { fill: '#d9b44a' }, poly([[-8, y], [-8, y - 9], [-4, y - 4.5], [0, y - 11], [4, y - 4.5], [8, y - 9], [8, y]]))
p.add(L.Top, { fill: '#a8842e' }, box(0, y - 1.3, 8, 1.3))
}
const PICTURES: Record<MapTier, (p: Picture) => void> = { 1: tier1, 2: tier2, 3: tier3, 4: tier4, 5: tier5, 6: tier6 }
/** The plot's radius per tier: it fills most of the field, more of it as the village grows. */
const RADIUS: Record<MapTier, number> = { 1: 42, 2: 44, 3: 45.5, 4: 46.5, 5: 47, 6: 47 }
function build(id: string, r: number, worn: boolean, mirror: boolean, draw: (p: Picture) => void): MapVillageLook {
const p = new Picture(mirror, worn)
const earth = worn ? EARTH_WORN : EARTH
p.add(L.Base, { fill: RIM }, circle(0, 0, r + 2.5))
p.add(L.Base, { fill: earth }, circle(0, 0, r))
// The edge in the relation colour lies over the ground and the shadows, under what stands.
p.add(L.Edge, { stroke: OWNER, width: 5 }, circle(0, 0, r - 0.5))
draw(p)
return { id, shapes: p.shapes(scale(earth, 0.74)) }
}
const TIER_LIST: MapTier[] = [1, 2, 3, 4, 5, 6]
/** Every look, built once: each tier for players and barbarians in two variants, and the crown forts. */
export const MAP_VILLAGE_LOOKS: MapVillageLook[] = [
...(['player', 'barbarian'] as const).flatMap((kind) =>
TIER_LIST.flatMap((tier) => [0, 1].map((v) => build(`mv-${kind}-${tier}-${v}`, RADIUS[tier], kind === 'barbarian', v === 1, PICTURES[tier]))),
),
build('mv-crown', 47, true, false, (p) => crownFort(p, false)),
build('mv-crown-player', 47, false, false, (p) => crownFort(p, true)),
]
/** The symbol a village wears: its kind and tier, the variant from its id. */
export function mapVillageSymbol(v: { id: number; points: number; crown: boolean; player: unknown }): string {
if (v.crown) return v.player ? '#mv-crown-player' : '#mv-crown'
return `#mv-${v.player ? 'player' : 'barbarian'}-${mapTier(v.points)}-${Math.abs(v.id) % 2}`
}