@v12-engine/create 0.0.0-stage → 0.1.0

package/starters/campaign/src/campaign/cinematics/intro.json

@@ -0,0 +1,148 @@
+{
+	"id": "campaign.intro",
+	"name": "Intro",
+	"length": 22,
+	"lanes": [
+		{
+			"id": "camera",
+			"kind": "camera",
+			"items": [
+				{
+					"at": 0,
+					"value": {
+						"x": 20,
+						"z": 60,
+						"distance": 44,
+						"yaw": 0.4,
+						"pitch": 0.95
+					}
+				},
+				{
+					"at": 6,
+					"value": {
+						"x": 22,
+						"z": 58,
+						"distance": 22,
+						"yaw": 0.9,
+						"pitch": 0.7
+					},
+					"path": "smooth",
+					"ease": "inOutCubic"
+				},
+				{
+					"at": 11,
+					"value": {
+						"x": 24,
+						"z": 56,
+						"distance": 26,
+						"yaw": 1.3,
+						"pitch": 0.8
+					},
+					"ease": "inOutSine"
+				},
+				{
+					"at": 12,
+					"value": {
+						"x": 58,
+						"z": 22,
+						"distance": 30,
+						"yaw": 2.4,
+						"pitch": 0.85
+					},
+					"transition": "dissolve"
+				},
+				{
+					"at": 17,
+					"value": {
+						"x": 62,
+						"z": 18,
+						"distance": 20,
+						"yaw": 2.9,
+						"pitch": 0.65
+					},
+					"path": "smooth",
+					"ease": "inOutCubic"
+				},
+				{
+					"at": 18,
+					"value": {
+						"x": 22,
+						"z": 58,
+						"distance": 32,
+						"yaw": 0,
+						"pitch": 0.95
+					},
+					"transition": "dissolve"
+				}
+			]
+		},
+		{
+			"id": "screen",
+			"kind": "screen",
+			"items": [
+				{
+					"at": 0,
+					"for": 22,
+					"letterbox": 2.39,
+					"vignette": 0.3,
+					"in": 0.6,
+					"out": 0.8
+				},
+				{
+					"at": 0,
+					"for": 2,
+					"fade": 1,
+					"in": 0,
+					"out": 2
+				}
+			]
+		},
+		{
+			"id": "dialog",
+			"kind": "dialog",
+			"items": [
+				{
+					"at": 2,
+					"for": 4,
+					"speaker": "campaign.aldric",
+					"text": "Home. Three years on the road, and the woods have gone dark while we were away."
+				},
+				{
+					"at": 6.5,
+					"for": 4.5,
+					"speaker": "campaign.brann",
+					"text": "The hall still stands, my lord. The farms, not all of them."
+				},
+				{
+					"at": 12.5,
+					"for": 4.5,
+					"speaker": "campaign.brann",
+					"text": "The Red Hand. Dug in beyond the trees, raiding by night."
+				},
+				{
+					"at": 17.5,
+					"for": 4,
+					"speaker": "campaign.aldric",
+					"text": "Then we burn them out."
+				}
+			]
+		}
+	],
+	"markers": [
+		{
+			"at": 0,
+			"name": "home",
+			"kind": "section"
+		},
+		{
+			"at": 12,
+			"name": "camp",
+			"kind": "section"
+		},
+		{
+			"at": 18,
+			"name": "back",
+			"kind": "section"
+		}
+	]
+}

package/starters/campaign/src/campaign/cinematics/outro.json

@@ -0,0 +1,92 @@
+{
+	"id": "campaign.outro",
+	"name": "Outro",
+	"length": 16,
+	"lanes": [
+		{
+			"id": "camera",
+			"kind": "camera",
+			"items": [
+				{
+					"at": 0,
+					"value": {
+						"x": 46,
+						"z": 20,
+						"distance": 18,
+						"yaw": 2.4,
+						"pitch": 0.6
+					}
+				},
+				{
+					"at": 8,
+					"value": {
+						"x": 44,
+						"z": 22,
+						"distance": 36,
+						"yaw": 3.0,
+						"pitch": 0.8
+					},
+					"path": "smooth",
+					"ease": "inOutSine"
+				},
+				{
+					"at": 16,
+					"value": {
+						"x": 36,
+						"z": 30,
+						"distance": 64,
+						"yaw": 3.6,
+						"pitch": 0.9
+					},
+					"ease": "inOutSine"
+				}
+			]
+		},
+		{
+			"id": "screen",
+			"kind": "screen",
+			"items": [
+				{
+					"at": 0,
+					"for": 16,
+					"letterbox": 2.39,
+					"vignette": 0.35,
+					"in": 0.6,
+					"out": 0
+				},
+				{
+					"at": 13,
+					"for": 3,
+					"fade": 1,
+					"in": 3,
+					"out": 0
+				}
+			]
+		},
+		{
+			"id": "dialog",
+			"kind": "dialog",
+			"items": [
+				{
+					"at": 1,
+					"for": 4,
+					"speaker": "campaign.brann",
+					"text": "It is done, my lord. The Red Hand is finished."
+				},
+				{
+					"at": 6,
+					"for": 5,
+					"speaker": "campaign.aldric",
+					"text": "Take the prisoners home. Then we rebuild the farms. The long road ends where it began."
+				}
+			]
+		}
+	],
+	"markers": [
+		{
+			"at": 13,
+			"name": "fade",
+			"kind": "section"
+		}
+	]
+}

package/starters/campaign/src/campaign/data.json

@@ -0,0 +1 @@
+{}

package/starters/campaign/src/campaign/fx.json

@@ -0,0 +1 @@
+{}

package/starters/campaign/src/campaign/game.ts

@@ -0,0 +1,6 @@
+import { defineGame } from '@v12-engine/client'
+import { campaign } from './index'
+import { campaignView } from './view'
+
+/** The campaign's game, whole: its rules and how it looks. What a page launches, and its editor makes maps for */
+export const campaignGame = defineGame({ rules: campaign, view: campaignView })

package/starters/campaign/src/campaign/ids.ts

@@ -0,0 +1,77 @@
+import { defineIds, type IdOf, type PlayerId } from '@v12-engine/engine'
+
+/*
+ * The ids of the campaign, named once (`defineIds`): the compiler checks them wherever they are written, in the rules
+ * and in the view (`GameView<CampaignUnit, CampaignResource, CampaignMessage>`), where plain text would be found wrong
+ * only when the game runs
+ */
+
+/** Its unit types: the player's, the Red Hand's, the creeps', and what the maps are dressed with */
+export const UNIT = defineIds(
+	'peasant',
+	'footman',
+	'archer',
+	'knight',
+	'hall',
+	'farm',
+	'barracks',
+	'tower',
+	'wall',
+	'trader',
+	'raider',
+	'warlock',
+	'brute',
+	'warlord',
+	'gnoll',
+	'prisoner',
+	'tree',
+	'goldmine'
+)
+export type CampaignUnit = IdOf<typeof UNIT>
+
+/** What its players have amounts of */
+export const RESOURCE = defineIds('gold')
+export type CampaignResource = IdOf<typeof RESOURCE>
+
+/** The keys of what it says: the rules say the key, the view has the words (`GameView.hud.messages`) */
+export const MSG = defineIds(
+	'objectiveRaze',
+	'objectiveHall',
+	'objectiveCaravan',
+	'objectiveHold',
+	'objectiveTowers',
+	'objectiveWarlord',
+	'objectiveHero',
+	'objectivePrisoners',
+	'caravanFound',
+	'waveComing',
+	'waveBeaten',
+	'gateShut',
+	'gateOpen',
+	'checkpointWave',
+	'heroFell',
+	'hallFell',
+	'homeStart',
+	'homeCamp',
+	'homeFord',
+	'homeDone',
+	'siegeStart',
+	'siegeGate',
+	'siegeHalfway',
+	'siegeLast',
+	'passStart',
+	'passShop',
+	'passPrisoners',
+	'passDuel',
+	'passCharge'
+)
+export type CampaignMessage = IdOf<typeof MSG>
+
+/** Who is who: the player at the screen, and the Red Hand */
+export const PLAYER: PlayerId = 1
+export const ENEMY: PlayerId = 2
+
+/** Who speaks: their names and looks are the view's (`GameView.cinematics.speakers`) */
+export const ALDRIC = 'campaign.aldric'
+export const BRANN = 'campaign.brann'
+export const VARGA = 'campaign.varga'

package/starters/campaign/src/campaign/index.ts

@@ -0,0 +1,121 @@
+import { type GameMap, type GameModule, hotRules, objectiveVictory, prefabsFrom, withData, withHeroes, type World } from '@v12-engine/engine'
+import { ENEMY, PLAYER } from './ids'
+import { mapKeyOf, maps } from './maps'
+import { homecoming, homecomingListeners, homecomingSequences, outpost, redHand, reinforcements } from './missions/homecoming'
+import { siege, siegeListeners, siegeSequences } from './missions/siege'
+import { parley, vargasMen, warlord, warlordListeners, warlordSequences } from './missions/warlord'
+import { countKills, kills } from './kills'
+import { tiles } from './tiles'
+import { abilities, buffs, effects, items, units } from './units'
+import { nextWave, reportWaves, siegeWaves, waveBeaten, waveComing, waveListeners, waves, wavesFile, waveTimers } from './waves'
+import dataFile from './data.json'
+import watchpost from './prefabs/watchpost.prefab.json'
+
+export { campaignMap, DEFAULT_MAP, maps } from './maps'
+export { ENEMY, MSG, PLAYER, UNIT, type CampaignMessage, type CampaignResource, type CampaignUnit } from './ids'
+export { homecoming, siege, warlord }
+export { kills } from './kills'
+export { homecomingCarry, type RoadData, siegeCarriedIn, warlordCarry } from './carry'
+export { builtWaves, readWaves, siegeWaves, type Wave, WAVE_UNITS, wavesFile, wavesOf } from './waves'
+
+/**
+ * The campaign's game: a game module of its own on the engine's public API, and nothing else. Its missions are won
+ * and lost by their objectives (`objectiveVictory`), not by who has buildings left; each mission's rules are in
+ * `missions/`, and the maps say which mission they are (`startMission`)
+ *
+ * What it brings, and what of the engine it uses for that:
+ * - its units, buildings, hero, abilities, items (data: `units.ts`), and what the editor's Data panel may change of them
+ * - a resource, gold, dug at mines and paid as bounty
+ * - the waves of the siege (`waves.ts`): timers, a component in the world, an event, a command to call one in early
+ * - how many each tower has killed (`kills.ts`): a component of an entity every player is sent, which its view pins
+ *   over the tower
+ * - missions: objectives, sequences of dialog and cinematics, areas of the map the rules watch, timers, prefabs, and
+ *   computer players that are mission brains (`@v12-engine/engine/ai`), each listed so that a save finds it by its id
+ */
+export const campaign: GameModule = withData(
+	{
+		// the maps of this game say they are its own by this id: change it, and change theirs (`"game"`) with it
+		id: 'my-game',
+		name: 'My game',
+		units,
+		abilities,
+		buffs,
+		items,
+		effects,
+		resources: [{ id: 'gold', name: 'Gold', start: 300 }],
+		currency: 'gold',
+		// its hero, who earns levels and is brought back at an altar, and the creeps' camps (`withHeroes`)
+		packs: [withHeroes()],
+		tiles,
+		// the maps it ships: a save of a game on one keeps only what changed of its ground
+		maps: Object.values(maps),
+		// the outpost in code, and the designers' prefabs (`prefabs/*.prefab.json`), as the rules may spawn them too
+		prefabs: [outpost, ...prefabsFrom({ 'watchpost.prefab.json': watchpost }, { prefix: 'campaign.' })],
+		brains: [redHand, vargasMen],
+		commands: [nextWave],
+		listeners: [...waveListeners, countKills, ...homecomingListeners, ...siegeListeners, ...warlordListeners],
+		timers: [...waveTimers, reinforcements],
+		files: [wavesFile],
+		sequences: [...homecomingSequences, ...siegeSequences, ...warlordSequences],
+		// what it keeps of its own: the waves' state, each tower's kills (sent to everyone, pinned over it by the view), and
+		// the answer at Varga's gate
+		components: [waves, kills, parley],
+		events: [waveBeaten, waveComing],
+		editor: {
+			// the player and the Red Hand, always: the editor sets where they start, not who they are
+			players: [
+				{ id: PLAYER, name: 'Aldric', team: 1, color: [0.2, 0.45, 0.95] },
+				{ id: ENEMY, name: 'The Red Hand', team: 2, color: [0.9, 0.2, 0.18], controller: 'computer' }
+			],
+			playersNote: 'Aldric is you. The Red Hand is the computer, as each mission says.',
+			// where the game names a unit type beyond the map: the waves that send it (Used by, Find references)
+			references: (ref, _map, registry) =>
+				'type' in ref
+					? siegeWaves({ registry }).flatMap((wave, i) =>
+							wave.units.some((unit) => unit.type === ref.type) ? [{ what: `wave ${i + 1}`, where: 'waves.json' }] : []
+						)
+					: []
+		},
+		victory: objectiveVictory,
+		report: (world) => reportWaves(world),
+		// a save made before a patch is loaded after it (`saves.migrate` takes the step)
+		saves: { version: 1 },
+		// what the editor's Data panel may change, kept in `data.json`: numbers and prices, never what a unit is
+		editable: {
+			units: (def) =>
+				def.kind === 'building'
+					? ['name', { path: 'stats.health', min: 1 }, 'stats.armor', { path: 'cost.gold', kind: 'integer', min: 0 }, 'buildTime']
+					: def.kind === 'unit'
+						? [
+								'name',
+								{ path: 'stats.health', min: 1 },
+								'stats.attackDamage',
+								'stats.attackSpeed',
+								'stats.armor',
+								'stats.moveSpeed',
+								{ path: 'cost.gold', kind: 'integer', min: 0 }
+							]
+						: null,
+			abilities: [{ path: 'cooldown', min: 0 }, { path: 'manaCost', min: 0 }, 'description'],
+			items: [{ path: 'cost.gold', kind: 'integer', min: 0 }, 'description']
+		}
+	},
+	dataFile
+)
+
+/** Each map's mission, by the map's file: what `startMission` gives a world made from it */
+const MISSIONS: Record<string, (world: World, fresh: boolean) => void> = { homestead: homecoming, fort: siege, pass: warlord }
+
+/**
+ * Gives a world the mission of the map it was made from: the campaign's scene does it with `fresh` as it knows it;
+ * the editor's Play here, a server and the tests do it through `start` with a fresh world. A map of none (one made in
+ * the editor for trying things) gets no mission: the game plays on, won by nobody
+ */
+export function startMission(world: World, map: Pick<GameMap, 'name'> | undefined, fresh = true): void {
+	const key = map && mapKeyOf(map)
+	const mission = key && MISSIONS[key]
+	if (mission) mission(world, fresh)
+}
+
+// saved while it runs in the dev server: the games and editors of the page take the new version (hot reload)
+if (import.meta.hot) import.meta.hot.accept((module) => hotRules(import.meta.hot, campaign, module?.campaign))

package/starters/campaign/src/campaign/kills.ts

@@ -0,0 +1,16 @@
+import { entityDied } from '@v12-engine/engine'
+import { defineComponent, defineListener } from '@v12-engine/engine'
+import { ENEMY, PLAYER } from './ids'
+
+/** How many of the Red Hand a tower of the fort has finished off. Everyone sees it: the view puts it over the tower */
+export const kills = defineComponent<number>('campaign.kills', { replicate: 'everyone' })
+
+/** One of the Red Hand that dies counts for the building of the player's that killed it */
+export const countKills = defineListener({
+	event: entityDied,
+	id: 'campaign.countKills',
+	run(_world, { entity, killer }) {
+		if (entity.owner !== ENEMY || !killer || killer.owner !== PLAYER || killer.def.kind !== 'building') return
+		killer.set(kills, (killer.get(kills) ?? 0) + 1)
+	}
+})

package/starters/campaign/src/campaign/looks.json

@@ -0,0 +1 @@
+{}

package/starters/campaign/src/campaign/maps.ts

@@ -0,0 +1,34 @@
+import { type GameMap, mapsFrom } from '@v12-engine/engine'
+
+import homestead from '../maps/homestead.vgmap.json'
+import fort from '../maps/fort.vgmap.json'
+import pass from '../maps/pass.vgmap.json'
+
+/**
+ * The maps of the campaign, one a mission: the files in `src/maps`, made in the editor (`/?editor`, whose Save writes
+ * them there, with a names file each). A new map is a new file there, imported here as these are. (Not with Vite's
+ * `import.meta.glob`: a server run by Node has no such thing.)
+ */
+const files = {
+	'./maps/homestead.vgmap.json': homestead,
+	'./maps/fort.vgmap.json': fort,
+	'./maps/pass.vgmap.json': pass
+}
+
+/** The maps by the name of their file, without `.vgmap.json`: `homestead` */
+export const maps: Readonly<Record<string, GameMap>> = mapsFrom(files)
+
+/** The map a game is on when nothing says which, and the one the editor opens first */
+export const DEFAULT_MAP = 'homestead'
+
+/** A map by name, as a copy: a game changes nothing of what the next one starts from */
+export function campaignMap(name = DEFAULT_MAP): GameMap {
+	const map = maps[name]
+	if (!map) throw new Error(`The campaign has no map "${name}": its maps are ${Object.keys(maps).join(', ')}`)
+	return structuredClone(map)
+}
+
+/** The file a map came from, by its name as the map says it: how the rules know which mission a map is */
+export function mapKeyOf(map: Pick<GameMap, 'name'>): string | undefined {
+	return Object.entries(maps).find(([, each]) => each.name === map.name)?.[0]
+}

package/starters/campaign/src/campaign/missions/homecoming.ts

@@ -0,0 +1,160 @@
+import { enteredArea, entityDied } from '@v12-engine/engine'
+import {
+	areaShapeOf,
+	cinematic,
+	defineListener,
+	defineObjective,
+	definePrefab,
+	defineSequence,
+	defineTimer,
+	earn,
+	talk,
+	wait,
+	waitFor,
+	type World
+} from '@v12-engine/engine'
+import { holdPosition, missionBrain, waveFrom } from '@v12-engine/engine/ai'
+import { ALDRIC, BRANN, ENEMY, MSG, PLAYER, UNIT } from '../ids'
+
+/*
+ * Mission one, Homecoming: Aldric comes home to a base with the Red Hand dug in beyond the woods. Burn their camp,
+ * keep the hall. On the way: a ford where Brann has a word, a lost caravan worth finding, an outpost the rules put
+ * up from a prefab, and a computer that holds its camp and sends what reaches it at the hall
+ */
+
+export const razeCamp = defineObjective({ id: 'campaign.raze', text: MSG.objectiveRaze })
+export const keepHall = defineObjective({ id: 'campaign.hall', text: MSG.objectiveHall })
+export const findCaravan = defineObjective({ id: 'campaign.caravan', text: MSG.objectiveCaravan, required: false })
+
+/** The areas of the map the rules watch, by the names of its regions: added as the mission starts (a save keeps them) */
+const FORD = 'campaign.ford'
+const CARAVAN = 'campaign.caravan'
+const REGIONS: [string, string][] = [
+	[FORD, 'ford'],
+	[CARAVAN, 'caravan']
+]
+
+/** Gold in the caravan's wreck */
+const CARAVAN_GOLD = 200
+
+/**
+ * An outpost: a tower between two walls and an archer behind them. A prefab in code, spawned where the map says
+ * (`outpost`); the designers' prefabs are files beside it (`prefabs/`), placed in the editor
+ */
+export const outpost = definePrefab({
+	id: 'campaign.outpost',
+	name: 'Outpost',
+	contents: {
+		objects: [
+			{ type: UNIT.tower, x: 0, z: 0 },
+			{ type: UNIT.wall, x: -2.5, z: 0.5 },
+			{ type: UNIT.wall, x: 2.5, z: 0.5 },
+			{ type: UNIT.archer, x: 0, z: -1.8, facing: Math.PI }
+		]
+	}
+})
+
+/**
+ * The Red Hand of the camp: it holds the camp with what it has, and every so often sends what the reinforcements
+ * bring (`waveFrom`: what the mission spawns at the camp goes for the hall in threes). A mission brain: parts and
+ * nothing else, no building, no training (`@v12-engine/engine/ai`)
+ */
+export const redHand = missionBrain({
+	id: 'campaign.redHand',
+	modules: [holdPosition('camp'), waveFrom('camp', { group: 3, every: 90 })]
+})
+
+/** Every so often, two raiders more at the camp: the brain sends them */
+export const reinforcements = defineTimer('campaign.reinforcements', (world) => {
+	if (world.winner !== null) return
+	const camp = world.map.point('camp')
+	if (!enemyBuildings(world).length) return
+	for (const dx of [-1.5, 1.5]) world.spawn(UNIT.raider, ENEMY, { x: camp.x + dx, z: camp.z + 1 })
+})
+
+/** The Red Hand's buildings, standing */
+export const enemyBuildings = (world: World) => [...world.index.ownedBy(ENEMY)].filter((entity) => entity.alive && entity.def.kind === 'building')
+
+/** The intro, then Brann's briefing: a sequence, skippable a line at a time, saved halfway like everything else */
+export const briefing = defineSequence('campaign.briefing', [
+	// the screen lets the first tick pass before it draws: the intro is the first thing seen, the game waiting
+	wait(0),
+	cinematic('campaign.intro', { hold: true, wait: 'ended' }),
+	wait(0.5),
+	...talk(PLAYER, [
+		{ speaker: BRANN, text: MSG.homeStart, seconds: 5 },
+		{ speaker: ALDRIC, text: MSG.homeCamp, seconds: 5 }
+	])
+])
+
+/** At the ford, a word, and the camp shown for a moment: whoever of the player's walks in first */
+export const atTheFord = defineSequence('campaign.atTheFord', [
+	waitFor(enteredArea, (_world, { area, entity }) => area === FORD && entity.owner === PLAYER),
+	(world) => {
+		const camp = world.map.point('camp')
+		world.reveal(world.player(PLAYER).team, camp, 12, 10)
+	},
+	...talk(PLAYER, [{ speaker: BRANN, text: MSG.homeFord, seconds: 5 }])
+])
+
+/** The caravan found: its gold, and the optional objective done */
+export const caravanFound = defineListener({
+	event: enteredArea,
+	id: 'campaign.caravanFound',
+	run(world, { area, entity }) {
+		if (area !== CARAVAN || entity.owner !== PLAYER || !world.objectives.has(PLAYER, findCaravan.id)) return
+		if (world.objectives.get(PLAYER, findCaravan.id).status !== 'open') return
+		earn(world.player(PLAYER).resources, 'gold', CARAVAN_GOLD)
+		world.objectives.complete(PLAYER, findCaravan.id)
+		world.message(PLAYER, { key: MSG.caravanFound, params: { gold: CARAVAN_GOLD } }, 'info')
+	}
+})
+
+/** A building fell: the camp's, one less to raze, the last of them the mission won; the hall, the mission lost */
+export const buildingFell = defineListener({
+	event: entityDied,
+	id: 'campaign.homeBuildingFell',
+	run(world, { entity }) {
+		if (entity.def.kind !== 'building' || !world.objectives.has(PLAYER, razeCamp.id)) return
+		const { objectives } = world
+		if (entity.owner === ENEMY) {
+			const left = enemyBuildings(world).length
+			const total = objectives.get(PLAYER, razeCamp.id).progress?.max ?? left
+			objectives.progress(PLAYER, razeCamp.id, total - left)
+			if (left) return
+			objectives.complete(PLAYER, razeCamp.id)
+			objectives.complete(PLAYER, keepHall.id)
+			if (objectives.get(PLAYER, findCaravan.id).status === 'open') objectives.fail(PLAYER, findCaravan.id)
+			world.sequences.start(wellDone)
+		} else if (entity.owner === PLAYER && entity.def.id === UNIT.hall) objectives.fail(PLAYER, keepHall.id, MSG.hallFell)
+	}
+})
+
+const wellDone = defineSequence('campaign.homeDone', talk(PLAYER, [{ speaker: ALDRIC, text: MSG.homeDone, seconds: 4 }]))
+
+export const homecomingSequences = [briefing, atTheFord, wellDone]
+export const homecomingListeners = [caravanFound, buildingFell]
+
+/**
+ * Gives the mission: once, as the world is made (`fresh`). A game loaded from a save has all of it already: the
+ * objectives, the areas, the sequences halfway, the computer's seat and its memory, the timers
+ */
+export function homecoming(world: World, fresh: boolean): void {
+	if (!fresh) return
+	const { objectives } = world
+	objectives.add(PLAYER, razeCamp, { progress: { value: 0, max: enemyBuildings(world).length } })
+	objectives.add(PLAYER, keepHall)
+	objectives.add(PLAYER, findCaravan)
+	for (const [id, region] of REGIONS) {
+		const shape = areaShapeOf({ region }, world.map.regions)
+		if (shape) world.areas.add({ id, shape })
+	}
+	// the outpost, where the map says: a prefab spawned by the rules
+	world.spawnPrefab(outpost, { at: world.map.point('outpost'), owner: PLAYER })
+	// the Red Hand's computer, remembered with the world: a save seats it again as it loads
+	const hall = world.named('hall')
+	world.computers.seat(ENEMY, { enemyBases: [hall ? { x: hall.pos.x, z: hall.pos.z } : world.map.point('outpost')], brain: redHand })
+	world.timers.every(90, reinforcements, {})
+	world.sequences.start(briefing)
+	world.sequences.start(atTheFord)
+}