@v12-engine/create 0.0.0-stage → 0.1.1

package/starters/campaign/files.txt

@@ -0,0 +1,42 @@
+# The files the campaign plays with: what its page asks for. In the starter's public/, but for those @v12-engine/assets
+# has: the project takes those from it (its groups' CREDITS.md say whose they are). The package's tests check that a
+# project's build has every one of the shared ones
+# the client fetches a game's own folder's list as it starts
+games/campaign/assets.json
+# the player's: peasants, footmen, archers, the knight
+models/characters/barbarian.glb
+models/characters/knight.glb
+models/characters/ranger.glb
+models/gear/axe_1handed.glb
+models/gear/sword_1handed.glb
+models/gear/shield_round.glb
+models/gear/bow.glb
+models/gear/sword_2handed.glb
+# the Red Hand and the woods: raiders, warlocks, brutes, Varga, gnolls, prisoners
+models/characters/mage.glb
+models/characters/rogue_hooded.glb
+models/characters/rogue.glb
+models/gear/shield_round_barbarian.glb
+models/gear/staff.glb
+models/gear/axe_2handed.glb
+models/gear/dagger.glb
+# the buildings
+models/rts/castle.glb
+models/rts/small_farm.glb
+models/rts/barracks.glb
+models/rts/watch_tower.glb
+models/rts/stone_wall.glb
+models/rts/mine.glb
+models/rts/castle_gate.glb
+models/village/market_stand.glb
+models/village/cart.glb
+models/village/crate.glb
+# the trees
+models/forest/common_tree_1.glb
+models/forest/common_tree_2.glb
+models/forest/common_tree_3.glb
+models/forest/common_tree_5.glb
+models/forest/pine_1.glb
+models/forest/pine_2.glb
+models/forest/pine_3.glb
+models/forest/pine_5.glb

package/starters/campaign/layers/editor/src/editor.ts

@@ -0,0 +1,18 @@
+/**
+ * The map editor of the game, a scene of the app (Map editor on the start screen, or `/?editor`) that `appScenes` makes
+ * (`src/main.ts`) with the editor's `editorScene`: it opens on the first mission's map, as a file of the project that
+ * Save writes back, and Play here tries a map with its mission's rules in the page's own game. What is set here is the
+ * editor's own: what the campaign adds to it (`src/campaign-editor.ts`), as one extension
+ */
+import type { AppEditorScene } from '@v12-engine/client/app'
+import '@v12-engine/editor/styles.css'
+
+// fetched as it first opens, with what the campaign adds to it: the start screen carries none of it
+export const editor = async (scene: AppEditorScene) => {
+	const [{ editorScene }, { campaignEditor }] = await Promise.all([import('@v12-engine/editor'), import('./campaign-editor')])
+	return editorScene({
+		...scene,
+		// what the campaign adds to its editor (src/campaign-editor.ts): the Waves panel, its icon, the search's entries
+		extensions: [campaignEditor]
+	})
+}

package/starters/campaign/layers/rooms/server.ts

@@ -0,0 +1,39 @@
+/**
+ * A server of many games of the game (`npm run server`), in rooms that share its port. The page finds them at
+ * `/?find-game` (`npm run dev` beside it): the games to join or watch, a New game on any mission's map, and Play now.
+ * `PORT` is the port, 8787 when not said
+ */
+import { GameRooms, mapMode, type GameMode } from '@v12-engine/engine/server'
+// @if ratings
+import { createRatings } from '@v12-engine/engine/server'
+// @end
+import { mapNamed, maps } from './src/maps'
+import { PLAYER, rules, start } from './src/rules'
+
+/** A game on one of the missions' maps: the one seat is Aldric's, the Red Hand the mission's own computer, which `start` seats */
+const onMap = (name: string): GameMode => mapMode(rules, mapNamed(name), { start, seats: [{ player: PLAYER, name: 'Aldric' }], ai: null })
+
+// @if ratings
+// a rating for each player, moved by every game that ends with a winner, kept in a file (`ratings.json`)
+const ratings = createRatings({ file: 'ratings.json' })
+// a file that cannot be read stops the server here, rather than being written over
+await ratings.ready
+// @end
+const rooms = await GameRooms.start({
+	port: Number(process.env.PORT ?? 8787),
+	// a room for each map: ws://host:8787/<map>. Its game starts once Aldric's seat is taken
+	rooms: Object.fromEntries(Object.keys(maps).map((name) => [name, { mode: onMap(name) }])),
+	// what players make games of (New game), each closed once nobody has been in it for a minute; Play now is matched
+	// at once, a game being for one
+	kinds: Object.fromEntries(Object.entries(maps).map(([name, map]) => [name, { name: map.name, room: { mode: onMap(name) } }])),
+	// @if ratings
+	ratings,
+	// @end
+	log: (line) => console.log(line)
+})
+console.log(`The game's server is at ws://localhost:${rooms.port}: open the page at /?find-game to find a game on it`)
+
+// stopped (Ctrl+C, or SIGTERM where it is hosted): no new games, and those running have 30 seconds to end
+const stop = () => void rooms.close({ drain: 30 }).then(() => process.exit(0))
+process.once('SIGINT', stop)
+process.once('SIGTERM', stop)

package/starters/campaign/layers/server/server.ts

@@ -0,0 +1,33 @@
+/**
+ * A server of the game (`npm run server`): each game on the first mission's map, Aldric's seat for whoever joins. The
+ * page joins it at `/?server` (`npm run dev` beside it). `PORT` is the port, 8787 when not said
+ */
+import { startServer } from '@v12-engine/engine/server'
+// @if ratings
+import { createRatings } from '@v12-engine/engine/server'
+// @end
+import { mapNamed } from './src/maps'
+import { PLAYER, rules, start } from './src/rules'
+
+// @if ratings
+// a rating for each player, moved by every game that ends with a winner, kept in a file (`ratings.json`)
+const ratings = createRatings({ file: 'ratings.json' })
+// a file that cannot be read stops the server here, rather than being written over
+await ratings.ready
+// @end
+const server = await startServer({
+	game: rules,
+	map: mapNamed(),
+	start,
+	// the one seat is Aldric's: the Red Hand is the mission's own computer, which `start` seats
+	seats: [{ player: PLAYER, name: 'Aldric' }],
+	computer: null,
+	// @if ratings
+	ratings,
+	// @end
+	port: Number(process.env.PORT ?? 8787)
+})
+console.log(`The game's server is at ws://localhost:${server.port}: open the page at /?server to play on it`)
+
+// stopped (Ctrl+C), it closes its connections first
+process.once('SIGINT', () => void server.close().then(() => process.exit(0)))

package/starters/campaign/layers/tests/tests/rules.test.ts

@@ -0,0 +1,320 @@
+/** The rules, tested with no page: a world steps here as it does in a page (`@v12-engine/engine/testing`) */
+import {
+	carryIn,
+	carryOut,
+	checkMap,
+	checkRules,
+	createRegistry,
+	createWorldFromMap,
+	type HeroRecord,
+	isGateOpen,
+	learn,
+	MAP_NEUTRAL,
+	missionWon,
+	newCampaignProgress,
+	readCampaignProgress,
+	type World,
+	heroOf
+} from '@v12-engine/engine'
+import { checkDeterminism, order, run, simulate, testWorld } from '@v12-engine/engine/testing'
+import { describe, expect, it } from 'vitest'
+import { homecomingCarry, type RoadData, siegeCarriedIn, warlordCarry } from '../src/campaign/carry'
+import { kills } from '../src/campaign/kills'
+import { builtWaves, FIRST_WAIT, readWaves, siegeWaves, wavesOf } from '../src/campaign/waves'
+import { warlord } from '../src/campaign/missions/warlord'
+import { mapNamed, maps } from '../src/maps'
+import { ENEMY, PLAYER, rules, start, UNIT } from '../src/rules'
+import wavesFile from '../src/campaign/waves.json'
+
+const registry = createRegistry(rules)
+
+/** A mission's world, started as the page starts it */
+async function mission(name: string): Promise<World> {
+	const map = mapNamed(name)
+	const world = await createWorldFromMap({ map, game: rules, seed: 1 })
+	start(world, { map })
+	return world
+}
+
+/** Steps `seconds` of the game */
+function play(world: World, seconds: number): void {
+	for (let i = 0; i < seconds * world.tickRate; i++) world.step()
+}
+
+const standing = (world: World, owner: number, type: string) =>
+	[...world.index.ownedBy(owner)].filter((entity) => entity.alive && entity.def.id === type)
+
+describe('the maps', () => {
+	it.each(Object.keys(maps))('%s has nothing wrong with it', (name) => {
+		const problems = checkMap(mapNamed(name), registry).filter((problem) => problem.error)
+		expect(problems).toEqual([])
+	})
+})
+
+describe('mission one, Homecoming', () => {
+	it('gives the objectives, puts up the outpost from its prefab, and seats the Red Hand', async () => {
+		const world = await mission('homestead')
+		expect(world.objectives.get(PLAYER, 'campaign.raze').progress?.max).toBeGreaterThan(2)
+		expect(world.objectives.get(PLAYER, 'campaign.caravan').status).toBe('open')
+		// the outpost: a tower and two walls where the map's point is, besides what the map places
+		const outpost = world.map.point('outpost')
+		const towers = standing(world, PLAYER, UNIT.tower).filter((tower) => Math.hypot(tower.pos.x - outpost.x, tower.pos.z - outpost.z) < 2)
+		expect(towers).toHaveLength(1)
+		expect(world.computers.get(ENEMY)).toBeDefined()
+		world.dispose()
+	})
+
+	it('is won by burning every building of the camp, and lost when the hall falls', async () => {
+		const won = await mission('homestead')
+		play(won, 1)
+		for (const entity of [...won.index.ownedBy(ENEMY)]) if (entity.def.kind === 'building') won.kill(entity)
+		play(won, 1)
+		expect(won.objectives.get(PLAYER, 'campaign.raze').status).toBe('done')
+		expect(won.winner).toBe(won.player(PLAYER).team)
+		won.dispose()
+
+		const lost = await mission('homestead')
+		for (const hall of standing(lost, PLAYER, UNIT.hall)) lost.kill(hall)
+		play(lost, 1)
+		expect(lost.objectives.get(PLAYER, 'campaign.hall').status).toBe('failed')
+		expect(lost.winner).not.toBe(lost.player(PLAYER).team)
+		lost.dispose()
+	})
+
+	it('pays for the caravan when one of the player’s walks into its region', async () => {
+		const world = await mission('homestead')
+		const caravan = world.map.regions.find((region) => region.name === 'caravan')!.shape
+		const gold = world.player(PLAYER).resources.gold ?? 0
+		world.spawn(UNIT.footman, PLAYER, { x: caravan.x, z: caravan.z })
+		play(world, 1)
+		expect(world.objectives.get(PLAYER, 'campaign.caravan').status).toBe('done')
+		expect(world.player(PLAYER).resources.gold).toBe(gold + 200)
+		world.dispose()
+	})
+
+	it('plays, the Red Hand’s computer thinking, with no error for a minute (simulate)', async () => {
+		const map = mapNamed('homestead')
+		// the mission seats the Red Hand's computer itself (`start`): simulate is told of none
+		const [game] = await simulate({ game: rules, map, computers: [], seconds: 60, start: (world) => start(world, { map }) }, { seeds: [1] })
+		expect(game.failed).toBeUndefined()
+		expect(game.ticks).toBeGreaterThan(0)
+	})
+})
+
+describe('mission two, The Siege', () => {
+	it('plays the waves of waves.json, what the editor’s Waves panel writes', () => {
+		expect(builtWaves()).toEqual(readWaves(wavesFile))
+		expect(builtWaves().length).toBeGreaterThanOrEqual(3)
+		expect(readWaves([{ units: [{ type: 'raider', count: 0 }] }, { units: [{ type: 'brute', count: 2 }], interval: -1 }, 'nothing'])).toEqual([
+			{ units: [{ type: 'brute', count: 2 }], interval: 1, bonus: 0 }
+		])
+	})
+
+	it('names its waves’ unit types to the editor, where Used by and Find references list them (ED2)', () => {
+		const registry = createRegistry(rules)
+		const asked = builtWaves()[0].units[0].type
+		const uses = rules.editor!.references!({ type: asked }, Object.values(maps)[0], registry)
+		expect(uses.length).toBeGreaterThan(0)
+		expect(uses.every((use) => use.where === 'waves.json' && /^wave \d+$/.test(use.what))).toBe(true)
+		expect(rules.editor!.references!({ type: 'nobody sends this' }, Object.values(maps)[0], registry)).toEqual([])
+	})
+
+	it('sends the first wave out of the war camp after a while, and shuts the gate as it comes', async () => {
+		const world = await mission('fort')
+		expect(isGateOpen(world, 'gate')).toBe(true)
+		expect(wavesOf(world).phase).toBe('waiting')
+		play(world, FIRST_WAIT + 2)
+		expect(wavesOf(world).phase).not.toBe('waiting')
+		expect(standing(world, ENEMY, UNIT.raider).length).toBeGreaterThan(0)
+		expect(isGateOpen(world, 'gate')).toBe(false)
+		world.dispose()
+	})
+
+	it('counts what each tower kills, for the view to pin over it (kills, sent to everyone)', async () => {
+		const world = await mission('fort')
+		play(world, FIRST_WAIT + 4)
+		const [tower] = standing(world, PLAYER, UNIT.tower)
+		const [first, second] = standing(world, ENEMY, UNIT.raider)
+		world.kill(first, tower)
+		expect(tower.get(kills)).toBe(1)
+		// one that falls to something else is not the tower's
+		world.kill(second)
+		expect(tower.get(kills)).toBe(1)
+		world.dispose()
+	})
+
+	it('is won once every wave is beaten', async () => {
+		const world = await mission('fort')
+		play(world, FIRST_WAIT + 2)
+		for (let wave = 0; wave < siegeWaves(world).length; wave++) {
+			// every raider of the wave down
+			play(world, 20)
+			for (const raider of [...world.index.ownedBy(ENEMY)]) if (raider.def.kind === 'unit') world.kill(raider)
+			play(world, 1)
+			if (wave < siegeWaves(world).length - 1) {
+				expect(isGateOpen(world, 'gate')).toBe(true)
+				play(world, 30)
+			}
+		}
+		expect(world.objectives.get(PLAYER, 'campaign.hold').status).toBe('done')
+		expect(world.winner).toBe(world.player(PLAYER).team)
+		world.dispose()
+	})
+})
+
+describe('what goes on to the next mission', () => {
+	it('takes the footmen who came through Homecoming, three at most, and the caravan, into the Siege', async () => {
+		const home = await mission('homestead')
+		// four footmen at the end, one of them hurt: the three healthiest go on
+		const footmen = standing(home, PLAYER, UNIT.footman)
+		const more = [home.spawn(UNIT.footman, PLAYER, { x: 20, z: 20 }), home.spawn(UNIT.footman, PLAYER, { x: 22, z: 20 })]
+		const hurt = more[0]
+		hurt.hp = 10
+		home.objectives.complete(PLAYER, 'campaign.caravan')
+		const carried = homecomingCarry(home)
+		expect(footmen.length + more.length).toBe(4)
+		expect(carried.footmen).toHaveLength(3)
+		expect(carried.footmen.every((record) => record.type === UNIT.footman && record.health === 1)).toBe(true)
+		expect(carried.caravan).toBe(true)
+		// kept as the campaign keeps it, and read back
+		const won = missionWon(newCampaignProgress<RoadData>('campaign', 'homecoming'), 'homecoming', 600, carryOut(home, PLAYER), 'siege', carried)
+		const kept = readCampaignProgress(JSON.parse(JSON.stringify(won)))
+		home.dispose()
+
+		const map = mapNamed('fort')
+		const fort = await createWorldFromMap({ map, game: rules, seed: 1 })
+		start(fort, { map })
+		const before = { footmen: standing(fort, PLAYER, UNIT.footman).length, gold: fort.player(PLAYER).resources.gold ?? 0 }
+		siegeCarriedIn(fort, map, kept.data as Partial<RoadData>)
+		expect(standing(fort, PLAYER, UNIT.footman)).toHaveLength(before.footmen + 3)
+		expect(fort.player(PLAYER).resources.gold).toBe(before.gold + 100)
+		fort.dispose()
+	})
+})
+
+describe('mission three, The Warlord', () => {
+	/** Aldric as he might come out of the siege: level 3, Holy Light learned twice, a sword in his bag */
+	const seasoned: HeroRecord = {
+		type: UNIT.knight,
+		name: 'hero',
+		level: 3,
+		xp: 0,
+		points: 0,
+		abilities: { holyLight: 2 },
+		items: [{ item: 'steelSword', charges: 0 }, null, null, null, null, null]
+	}
+
+	it('brings the carried hero in where the map has one, with what he earned', async () => {
+		const map = mapNamed('pass')
+		const world = await createWorldFromMap({ map, game: rules, seed: 1 })
+		const [hero] = carryIn(world, [seasoned], PLAYER, map.players[0].start!)
+		start(world, { map })
+		expect(heroOf(hero)?.level).toBe(3)
+		expect(hero.abilities.find((ability) => ability.id === 'holyLight')?.level).toBe(2)
+		expect(standing(world, PLAYER, UNIT.knight)).toHaveLength(1)
+		world.dispose()
+	})
+
+	it('is harder on hard and easier on easy, its computer seated on the campaign’s difficulty', async () => {
+		const on = async (difficulty: string) => {
+			const map = mapNamed('pass')
+			const world = await createWorldFromMap({ map, game: rules, seed: 1 })
+			// what the campaign's scene does before a mission seats its computers
+			world.computers.defaults = { difficulty }
+			warlord(world, true, difficulty)
+			return world
+		}
+		const hard = await on('hard')
+		expect(standing(hard, ENEMY, UNIT.brute).some((brute) => hard.nameOf(brute) === 'guard4')).toBe(true)
+		expect((hard.computers.get(ENEMY)?.computer as { profile?: { difficulty?: string } }).profile?.difficulty).toBe('hard')
+		const easy = await on('easy')
+		const varga = easy.named('warlord')!
+		expect(varga.hp).toBe(Math.round(varga.maxHp * 0.75))
+		expect(easy.named('guard4')).toBeUndefined()
+		hard.dispose()
+		easy.dispose()
+	})
+
+	it('lets the player choose a duel: the guards stand down, Varga is rallied, and the campaign keeps the answer', async () => {
+		const world = await mission('pass')
+		play(world, 0.5)
+		expect(warlordCarry(world)).toEqual({})
+		world.issue({ type: 'cinematicChoice', player: PLAYER, cinematic: 'campaign.parley', question: 'How does this end?', choice: 'duel' })
+		play(world, 0.5)
+		for (const name of ['guard1', 'guard2', 'guard3']) expect(world.named(name)?.owner).toBe(MAP_NEUTRAL)
+		expect(world.named('warlord')?.buffs.some((buff) => buff.id === 'rallied')).toBe(true)
+		expect(warlordCarry(world)).toEqual({ parley: 'duel' })
+		world.dispose()
+	})
+
+	it('frees the prisoners when the hero reaches the cells, and is won when Varga falls, lost when Aldric does', async () => {
+		const freed = await mission('pass')
+		const cells = freed.map.regions.find((region) => region.name === 'cells')!.shape
+		freed.spawn(UNIT.footman, PLAYER, { x: cells.x, z: cells.z })
+		play(freed, 1)
+		expect(freed.objectives.get(PLAYER, 'campaign.prisoners').status).toBe('done')
+		expect(standing(freed, PLAYER, UNIT.prisoner).length).toBeGreaterThan(0)
+		freed.kill(freed.named('warlord')!)
+		// the outro plays for the player first; nobody watches here, so it ends at once
+		play(freed, 3)
+		expect(freed.objectives.get(PLAYER, 'campaign.warlord').status).toBe('done')
+		expect(freed.winner).toBe(freed.player(PLAYER).team)
+		freed.dispose()
+
+		const lost = await mission('pass')
+		lost.kill(lost.named('hero')!)
+		play(lost, 1)
+		expect(lost.objectives.get(PLAYER, 'campaign.hero').status).toBe('failed')
+		expect(lost.winner).not.toBe(lost.player(PLAYER).team)
+		lost.dispose()
+	})
+})
+
+describe('the hero', () => {
+	it('heals a friend with Holy Light once he has learned it', async () => {
+		const world = await testWorld(rules)
+		const hero = world.spawn(UNIT.knight, PLAYER, { x: 20, z: 20 })
+		const footman = world.spawn(UNIT.footman, PLAYER, { x: 22, z: 20 })
+		learn(world, hero, 'holyLight')
+		footman.hp = 100
+		order(world, [hero], { type: 'cast', ability: 'holyLight', target: footman.id })
+		run(world, 3, () => footman.hp > 200)
+		expect(footman.hp).toBeGreaterThan(200)
+		world.dispose()
+	})
+
+	it('strikes with Judgement, an effect of the game’s own, and heals for what it took', async () => {
+		const world = await testWorld(rules)
+		const hero = world.spawn(UNIT.knight, PLAYER, { x: 20, z: 20 })
+		// something of the enemy's that does not hit back: what the strike took is then the strike's alone
+		const captive = world.spawn(UNIT.prisoner, ENEMY, { x: 23, z: 20 })
+		learn(world, hero, 'judgement')
+		hero.hp = 300
+		// a tick first: an enemy is a target once it is seen, and the fog is worked out as the game steps
+		run(world, 0.1)
+		order(world, [hero], { type: 'cast', ability: 'judgement', target: captive.id })
+		run(world, 3, () => captive.hp <= captive.maxHp - 120)
+		expect(captive.maxHp - captive.hp).toBeGreaterThanOrEqual(120)
+		expect(hero.hp).toBeGreaterThanOrEqual(300 + 120 - 1)
+		world.dispose()
+	})
+})
+
+describe('the rules', () => {
+	it('fit together: every id they name is theirs, every effect has a handler (checkRules)', () => {
+		expect(checkRules(rules).filter((problem) => problem.level === 'error')).toEqual([])
+	})
+})
+
+describe('each mission', () => {
+	// the same game every time it is played from its start, and from a save of it: what a replay, a save that goes on
+	// and a game over the wire stand on. A rule that reads Math.random or the clock is found here, with its tick
+	it.each(Object.keys(maps))(
+		'%s comes out the same, played twice and on from a save',
+		async (name) => {
+			const report = await checkDeterminism(() => mission(name), { ticks: 600, from: 150, game: rules })
+			expect(report).toEqual({ twice: null, fromSave: null })
+		},
+		120_000
+	)
+})

package/starters/campaign/public/games/campaign/assets.json

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

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

@@ -0,0 +1,52 @@
+{
+	"id": "campaign",
+	"name": "The Long Road",
+	"menu": {
+		"title": "The Long Road",
+		"subtitle": "A campaign in three missions",
+		"background": "radial-gradient(ellipse at 50% 30%, #2b3346 0%, #14161c 70%)"
+	},
+	"chapters": [
+		{
+			"id": "road",
+			"name": "I. The Way Home",
+			"missions": ["homecoming"]
+		},
+		{
+			"id": "fort",
+			"name": "II. The Fort",
+			"missions": ["siege", "warlord"]
+		}
+	],
+	"missions": [
+		{
+			"id": "homecoming",
+			"name": "Homecoming",
+			"map": "homestead",
+			"description": "Through the woods, and burn the camp of the Red Hand beyond them",
+			"briefing": {
+				"text": "Aldric is home from the war, and the Red Hand burns the farms of the valley. Take what men are left at the homestead through the woods, find the caravan the raiders took, and put their camp to the torch.",
+				"objectives": ["Burn the camp of the Red Hand", "Find the caravan (if you can)", "Aldric must live"]
+			},
+			"debrief": {
+				"text": "The camp burns. The valley breathes again, for a night: the Red Hand has a fort in mind."
+			}
+		},
+		{
+			"id": "siege",
+			"name": "The Siege",
+			"map": "fort",
+			"description": "The Red Hand comes for the fort at night. Hold for every wave",
+			"briefing": {
+				"text": "Scouts saw torches on the ridge. The Red Hand comes for the fort at nightfall, wave on wave. Man the walls.",
+				"objectives": ["Hold the fort until the last wave breaks"]
+			}
+		},
+		{
+			"id": "warlord",
+			"name": "The Warlord",
+			"map": "pass",
+			"description": "Up the pass to Varga’s hold. Do not lose Aldric"
+		}
+	]
+}

package/starters/campaign/src/campaign/carry.ts

@@ -0,0 +1,47 @@
+import { carryUnits, giveResources, type GameMap, placeUnits, type UnitRecord, type World } from '@v12-engine/engine'
+import { PLAYER, UNIT } from './ids'
+import { findCaravan } from './missions/homecoming'
+import { parley } from './missions/warlord'
+
+/**
+ * What the campaign carries from one mission to the next besides Aldric (the heroes are carried as they are): its own
+ * data, of this type (`CampaignDef<RoadData>`), each mission won giving its part (`MissionDef.carry`) and the next
+ * reading it as it starts (`context.progress.data`)
+ */
+export interface RoadData {
+	/** The footmen who came through Homecoming, three at the most: they man the fort in the Siege */
+	footmen: UnitRecord[]
+	/** Whether the lost caravan was found in Homecoming: the fort's quartermaster remembers it */
+	caravan: boolean
+	/** What Aldric answered at Varga's gate: a duel, or a charge */
+	parley: 'duel' | 'charge'
+}
+
+/** How many of the footmen go on to the fort */
+const FOOTMEN_CARRIED = 3
+/** What the quartermaster gives at the fort for the caravan found */
+const CARAVAN_THANKS = 100
+
+/** What Homecoming carries on: the footmen who lived through it (the healthiest first, three), and the caravan found or not */
+export function homecomingCarry(world: World): Pick<RoadData, 'footmen' | 'caravan'> {
+	const footmen = carryUnits(world, PLAYER, (unit) => unit.def.id === UNIT.footman)
+		.sort((a, b) => b.health - a.health)
+		.slice(0, FOOTMEN_CARRIED)
+	return { footmen, caravan: world.objectives.has(PLAYER, findCaravan.id) && world.objectives.get(PLAYER, findCaravan.id).status === 'done' }
+}
+
+/**
+ * The Siege, given what came before: the footmen of Homecoming where the player starts, and the quartermaster's
+ * thanks for the caravan. For a fresh game of it: a game loaded from a save has them already
+ */
+export function siegeCarriedIn(world: World, map: GameMap, data: Partial<RoadData>): void {
+	const start = map.players.find((player) => player.id === PLAYER)?.start ?? { x: map.width / 2, z: map.depth / 2 }
+	if (data.footmen?.length) placeUnits(world, PLAYER, data.footmen, start)
+	if (data.caravan) giveResources(world, PLAYER, { gold: CARAVAN_THANKS })
+}
+
+/** What The Warlord carries on: the answer at the gate, where one was given (the last mission: the campaign keeps it) */
+export function warlordCarry(world: World): Partial<Pick<RoadData, 'parley'>> {
+	const { choice } = world.state(parley)
+	return choice ? { parley: choice } : {}
+}