@v12-engine/create 0.1.0 → 0.4.0

package/layers/desktop/tests/shell.test.ts

@@ -0,0 +1,152 @@
+// @if tests
+// @vitest-environment happy-dom
+/** The page's side of the shell (`src/shell.ts`), on a pretend bridge in the place of `electron/preload.cjs`'s */
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+	autosaveOnClose,
+	canQuit,
+	checkForUpdate,
+	createErrorLog,
+	fileStore,
+	gameFullscreen,
+	inShell,
+	quit,
+	setWindowed,
+	watchWindowed
+} from '../src/shell'
+
+function pretendBridge() {
+	const files = new Map<string, string>()
+	const calls: unknown[] = []
+	const listeners = { resized: [] as (() => void)[], close: [] as (() => void)[] }
+	let over = false
+	let update: { version: string; notes?: string } | undefined
+	const bridge = {
+		fullscreen: async (on?: boolean) => {
+			calls.push(['fullscreen', on])
+			if (on !== undefined) over = on
+			return over
+		},
+		close: async () => void calls.push(['close']),
+		destroy: async () => void calls.push(['destroy']),
+		onResized: (listener: () => void) => (listeners.resized.push(listener), () => (listeners.resized.length = 0)),
+		onCloseRequested: (listener: () => void) => (listeners.close.push(listener), () => (listeners.close.length = 0)),
+		openFolder: async (folder: string) => void calls.push(['openFolder', folder]),
+		records: {
+			list: async (folder: string) => [...files].filter(([key]) => key.startsWith(`${folder}/`)).map(([, text]) => text),
+			read: async (folder: string, id: string) => files.get(`${folder}/${id}`),
+			write: async (folder: string, id: string, text: string) => void files.set(`${folder}/${id}`, text),
+			remove: async (folder: string, id: string) => void files.delete(`${folder}/${id}`)
+		},
+		log: { append: async () => undefined, size: async () => 0, rename: async () => undefined },
+		updates: {
+			check: async () => (calls.push(['check']), update),
+			install: async () => void calls.push(['install'])
+		}
+	}
+	;(window as any).v12Shell = bridge
+	return { files, calls, listeners, found: (version: typeof update) => (update = version) }
+}
+
+afterEach(() => {
+	delete (window as any).v12Shell
+})
+
+describe('in a browser', () => {
+	it('is nothing of the shell', async () => {
+		expect(inShell()).toBe(false)
+		expect(canQuit()).toBe(false)
+		expect(await gameFullscreen(true)).toBe(false)
+		await quit()
+		expect(await checkForUpdate()).toBeUndefined()
+	})
+})
+
+describe('in the shell', () => {
+	it('asks it for the screen, and is told which it is', async () => {
+		const { calls } = pretendBridge()
+		expect(inShell()).toBe(true)
+		expect(await gameFullscreen(true)).toBe(true)
+		expect(await gameFullscreen()).toBe(true)
+		await setWindowed(true)
+		expect(calls).toEqual([
+			['fullscreen', true],
+			['fullscreen', undefined],
+			['fullscreen', false]
+		])
+	})
+
+	it('keeps records as JSON, and leaves out one that does not read', async () => {
+		const { files } = pretendBridge()
+		const store = fileStore<{ id: string; n: number }>('saves')
+		await store.write({ id: 'a', n: 1 })
+		files.set('saves/broken', '{ cut sho')
+		expect(await store.read('a')).toEqual({ id: 'a', n: 1 })
+		expect(await store.read('broken')).toBeUndefined()
+		expect(await store.list()).toEqual([{ id: 'a', n: 1 }])
+		await store.remove('a')
+		expect(await store.read('a')).toBeUndefined()
+	})
+
+	it('saves as the window closes and only then lets it close, and not for longer than the limit', async () => {
+		const { calls, listeners } = pretendBridge()
+		let saved = false
+		const client = {
+			saves: {
+				canSave: () => true,
+				refresh: async () => undefined,
+				list: () => [],
+				save: async () => ((saved = true), { id: 's', name: 'Autosave' }),
+				remove: async () => undefined
+			}
+		}
+		await autosaveOnClose(() => client as never)
+		await listeners.close[0]!()
+		expect(saved).toBe(true)
+		expect(calls).toEqual([['destroy']])
+
+		const hung = pretendBridge()
+		vi.useFakeTimers()
+		await autosaveOnClose(() => ({ saves: { ...client.saves, save: () => new Promise(() => undefined) } }) as never, { limit: 50 })
+		const closing = hung.listeners.close[0]!() as unknown as Promise<void>
+		await vi.advanceTimersByTimeAsync(60)
+		await closing
+		vi.useRealTimers()
+		expect(hung.calls).toEqual([['destroy']])
+	})
+
+	it('keeps the Windowed setting to the window', async () => {
+		pretendBridge()
+		const values = new Map<string, boolean>([['windowed', true]])
+		const client = { settings: { get: (id: string) => values.get(id), set: (id: string, on: boolean) => values.set(id, on) } }
+		let heard = () => undefined as unknown
+		await watchWindowed(client as never, { onResized: async (handler) => ((heard = handler), () => undefined) }, async () => true)
+		await new Promise((resolve) => setTimeout(resolve, 0))
+		vi.useFakeTimers({ now: Date.now() + 5000 })
+		await heard()
+		vi.useRealTimers()
+		expect(values.get('windowed')).toBe(false)
+	})
+
+	it('writes the error log in order, and a failing log does not throw', async () => {
+		const lines: string[] = []
+		const log = createErrorLog(
+			{ append: async (_file, text) => void lines.push(text), size: async () => 0, rename: async () => undefined },
+			{ now: () => new Date(0) }
+		)
+		await log.write('here', 'it broke')
+		expect(lines).toEqual(['1970-01-01T00:00:00.000Z [here] it broke\n'])
+		await createErrorLog({ append: () => Promise.reject(new Error('no')), size: async () => 0, rename: async () => undefined }).write('x', 'y')
+	})
+
+	it('offers a version the shell found, and installs it by the shell', async () => {
+		const { calls, found } = pretendBridge()
+		expect(await checkForUpdate()).toBeUndefined()
+		found({ version: '1.2.0', notes: 'What is new' })
+		const update = await checkForUpdate()
+		expect(update).toMatchObject({ version: '1.2.0', notes: 'What is new' })
+		await update!.install()
+		expect(calls).toEqual([['check'], ['check'], ['install']])
+	})
+})
+// @end

package/layers/rooms/server.ts

@@ -7,11 +7,17 @@ import { GameRooms, generatedMode, mapMode, type GameMode, type RoomKind } from
 // @if ratings
 import { createRatings } from '@v12-engine/engine/server'
 // @end
-import { DEFAULT_MAP, mapNamed, maps } from './src/maps'
-import { rules, start } from './src/rules'
+import { game } from './src/game'
 
-/** A game on one of the game's maps, each world started as the page starts it */
-const onMap = (name: string): GameMode => mapMode(rules, mapNamed(name), { start })
+/** The game's rules: a server reads the game's (`src/game.ts`), never its look */
+const rules = game.toRules()
+/** The game's maps by name, each read */
+const maps = Object.fromEntries(await Promise.all(Object.keys(game.toMaps()).map(async (name) => [name, await game.loadMap(name)] as const)))
+/** The first: the room to try the game alone in plays it */
+const DEFAULT_MAP = Object.keys(maps)[0]
+
+/** A game on one of the game's maps, each world started as the page starts it (`game.onStart`) */
+const onMap = (name: string): GameMode => mapMode(game, maps[name])
 
 /**
  * A game on a map the game's generator makes (`rules.generator`): another for each game made, of 128 cells a side for
@@ -22,13 +28,12 @@ const random: Record<string, RoomKind> = rules.generator
 			random: {
 				name: 'A random map',
 				room: (settings) => ({
-					mode: generatedMode(rules, rules.generator!, {
+					mode: generatedMode(game, rules.generator!, {
 						width: 128,
 						depth: 128,
 						players: 2,
 						symmetry: 'half',
-						...(Number(settings.seed) > 0 && { seed: Number(settings.seed) }),
-						start
+						...(Number(settings.seed) > 0 && { seed: Number(settings.seed) })
 					})
 				})
 			}
@@ -42,9 +47,7 @@ const ratings = createRatings({ file: 'ratings.json' })
 await ratings.ready
 // @end
 // the seats the computer plays in the room to try the game alone in: every player of the first map but the first
-const computer = mapNamed()
-	.players.slice(1)
-	.map((player) => player.id)
+const computer = maps[DEFAULT_MAP].players.slice(1).map((player) => player.id)
 const rooms = await GameRooms.start({
 	port: Number(process.env.PORT ?? 8787),
 	rooms: {

package/layers/server/server.ts

@@ -7,10 +7,9 @@ import { startServer } from '@v12-engine/engine/server'
 // @if ratings
 import { createRatings } from '@v12-engine/engine/server'
 // @end
-import { mapNamed } from './src/maps'
-import { rules, start } from './src/rules'
+import { game } from './src/game'
 
-const map = mapNamed()
+const map = await game.loadMap()
 // @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' })
@@ -18,9 +17,9 @@ const ratings = createRatings({ file: 'ratings.json' })
 await ratings.ready
 // @end
 const server = await startServer({
-	game: rules,
+	// the game: its rules and its start, never its look (`src/game.ts`), on its first map
+	game,
 	map,
-	start,
 	// the seats the computer plays: leave it out for a game of people alone, which starts once every seat is taken
 	ai: map.players.slice(1).map((player) => player.id),
 	// @if ratings

package/layers/source/vite.config.ts

@@ -34,11 +34,31 @@ export default defineConfig({
 		assetsPackage(),
 		// @end
 		// @if editor
-		editorFiles({ gameFolder: () => 'src' })
+		editorFiles({
+			gameFolder: () => 'src',
+			// where New with code in the editor may write a stub (never over a file)
+			scaffold: ['src'],
+			// the scripts the editor's Run panel may start and stop while developing, and no others
+			run: [
+				// @if server
+				'server',
+				// @end
+				// @if desktop
+				// (`app` starts the dev server itself, which the editor is open on: this one uses that one)
+				'app:editor',
+				// @end
+			]
+		})
 		// @end
 	],
 	// the packages' source on the page, on the dev server's own side and in the tests (the library's `config/vite.ts`)
 	...sourceLibrary(),
+	// @if desktop
+	// the app made to hand out is not the page's to watch
+	server: { watch: { ignored: ['**/out/**'] } },
+	// the shell's own Chromium (Electron's) is the one browser the built page runs in
+	build: { target: 'esnext' },
+	// @end
 	// @if tests
 	test: { environment: 'node' }
 	// @end

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@v12-engine/create",
-	"version": "0.1.0",
+	"version": "0.4.0",
 	"license": "MIT",
 	"publishConfig": {
 		"access": "public"
@@ -13,6 +13,7 @@
 	"type": "module",
 	"description": "A project to start a game from: npm create @v12-engine my-game",
 	"bin": {
+		"create": "./bin.mjs",
 		"create-v12": "./bin.mjs",
 		"v12": "./v12.mjs"
 	},

package/starters/campaign/README.md

@@ -22,12 +22,16 @@ A campaign made with V12: three missions on the long road home, a hero carried f
 <!-- @end -->
 | Check the types | `npm run typecheck` |
 | Build the page to host | `npm run build`, into `dist/` |
+<!-- @if desktop -->
+| Play it as an app | `npm run app`: the page in a window of its own (Electron, fetched the first time) |
+| Make the app to hand out | `npm run package`, into `out/` |
+<!-- @end -->
 
 ## What is where
 
 - `src/campaign/`: the game. `index.ts` puts the rules together and gives each map its mission; `ids.ts` names everything once; `units.ts` the units, buildings, the hero, his abilities and the items; `missions/` a file a mission: `homecoming.ts` (objectives, a prefab, areas, a brain that holds and raids), `siege.ts` (the waves, the gate, effects fired from the rules), `warlord.ts` (the hero carried in, a shop, the talk at the gate and its choice, the prisoners); `waves.ts` the waves, as `waves.json` says them; `view/` how it looks and sounds, with the cinematic of the talk in code; `cinematics/` the intro and the outro, made in the editor's Cinematic panel; `prefabs/` what the editor's Save as a prefab wrote; `campaign.json` the campaign's chapters and missions (their maps, words, briefings, debriefs), what the editor's Campaign panel writes, and `scenes.ts` what of them is code, for the page (`defineCampaign`); `data.json`, `looks.json`, `fx.json` and `waves.json` what the editor's Data, model, Effects and Waves panels write
-- `src/rules.ts`, `src/game.ts`, `src/maps.ts`: the game by the names the page, the server and the tests know it by
-- `src/maps/`: the missions' maps, made in the editor. Each has the names its mission's rules look for (`hall`, `hero`, `camp`, `warcamp`, `gate`, `cells`…): a names file beside each says which
+- `src/game.ts`: the game (`createGame`) the page, the server, the editor, the tests and the campaign's scenes take: the campaign's rules, its look fetched as the page first plays it, its maps (`src/maps.ts`), and the mission of a map given as a game of it starts
+- `src/maps/`: the missions' maps, made in the editor, each with a meadow (the rules' `grass` layer, `foliagePack`: a meadow that burns and grows back, and on the homestead tall grass that hides). Each has the names its mission's rules look for (`hall`, `hero`, `camp`, `warcamp`, `gate`, `cells`…): a names file beside each says which
 - `src/main.ts`: the page: the start screen, the campaign's menu and its missions, free play, the settings
 
 <!-- @if editor -->
@@ -48,6 +52,9 @@ A campaign made with V12: three missions on the long road home, a hero carried f
 
 - `tests/`: the missions tested with no page: the maps checked, each mission won and lost as it says, the waves, the carried hero, the choice at the gate, the computer playing a minute (`simulate`)
 <!-- @end -->
+<!-- @if desktop -->
+- `electron/`: the shell around the page, Electron's main process: `config.mjs` (the app's name, its identifier and the updater's address, yours to settle before it is handed out), `app.mjs` (the window, its full screen, what the page may ask), `preload.cjs` (the bridge the page asks through), `files.mjs` (saves, settings and the error log as files), `updates.mjs`, `presentation.m` (the addon that hides the Dock and the menu bar on macOS), `dev.mjs` (`npm run app`) and `package.mjs` (`npm run package`). `src/shell.ts` is all the page asks of it and `src/desktop.ts` what it does with that: over the whole screen with a Windowed setting, saves and settings as files, the game saved as the window closes, an error log, Exit on the start menu, Quit on the pause menu. The updater's address (`UPDATES`) is a placeholder until the docs' A desktop game, offline says what goes there, whose example is this campaign in such a shell
+<!-- @end -->
 - `public/games/campaign/`: the game's own folder of files: what the editor's Assets panel takes in (models, sounds, pictures), with an `assets.json` saying what is there
 - `@v12-engine/assets`: the shared art every unit and building is drawn with (adventurers with their clips and their gear, buildings, trees), served where `public/`'s files are by `assetsPackage()` in `vite.config.ts`, and copied into a build as the game uses it. Whose each file is: its group's `CREDITS.md` in `node_modules/@v12-engine/assets/groups/`
 

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

@@ -7,11 +7,11 @@ import { GameRooms, mapMode, type GameMode } from '@v12-engine/engine/server'
 // @if ratings
 import { createRatings } from '@v12-engine/engine/server'
 // @end
+import { game, PLAYER } from './src/game'
 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 })
+/** A game on one of the missions' maps: the one seat is Aldric's, the Red Hand the mission's own computer, which its start seats */
+const onMap = (name: string): GameMode => mapMode(game, mapNamed(name), { 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`)

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

@@ -6,8 +6,7 @@ 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'
+import { game, PLAYER } from './src/game'
 
 // @if ratings
 // a rating for each player, moved by every game that ends with a winner, kept in a file (`ratings.json`)
@@ -16,9 +15,8 @@ const ratings = createRatings({ file: 'ratings.json' })
 await ratings.ready
 // @end
 const server = await startServer({
-	game: rules,
-	map: mapNamed(),
-	start,
+	// the game: its rules and its start (the mission of its map), never its look (`src/game.ts`), on its first map
+	game,
 	// 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,

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

@@ -14,7 +14,8 @@ import {
 	newCampaignProgress,
 	readCampaignProgress,
 	type World,
-	heroOf
+	heroOf,
+	heroCallings
 } from '@v12-engine/engine'
 import { checkDeterminism, order, run, simulate, testWorld } from '@v12-engine/engine/testing'
 import { describe, expect, it } from 'vitest'
@@ -23,16 +24,19 @@ 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 { ENEMY, game, PLAYER, UNIT } from '../src/game'
 import wavesFile from '../src/campaign/waves.json'
 
+const rules = game.toRules()
 const registry = createRegistry(rules)
+/** What the game does as a world of it starts: the mission of its map (`game.onStart`), at once */
+const onStart = game.toStart()!
 
-/** A mission's world, started as the page starts it */
+/** A mission's world, started as the page starts it (`game.onStart`: the mission of its map) */
 async function mission(name: string): Promise<World> {
 	const map = mapNamed(name)
-	const world = await createWorldFromMap({ map, game: rules, seed: 1 })
-	start(world, { map })
+	const world = await createWorldFromMap({ map, rules, seed: 1 })
+	await onStart(world, { map })
 	return world
 }
 
@@ -95,7 +99,7 @@ describe('mission one, Homecoming', () => {
 	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] })
+		const [game] = await simulate({ rules: rules, map, computers: [], seconds: 60, onStart: (world) => void onStart(world, { map }) }, { seeds: [1] })
 		expect(game.failed).toBeUndefined()
 		expect(game.ticks).toBeGreaterThan(0)
 	})
@@ -169,7 +173,7 @@ describe('what goes on to the next mission', () => {
 		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
+		hurt.health = 10
 		home.objectives.complete(PLAYER, 'campaign.caravan')
 		const carried = homecomingCarry(home)
 		expect(footmen.length + more.length).toBe(4)
@@ -182,8 +186,8 @@ describe('what goes on to the next mission', () => {
 		home.dispose()
 
 		const map = mapNamed('fort')
-		const fort = await createWorldFromMap({ map, game: rules, seed: 1 })
-		start(fort, { map })
+		const fort = await createWorldFromMap({ map, rules, seed: 1 })
+		onStart(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)
@@ -206,9 +210,9 @@ describe('mission three, The Warlord', () => {
 
 	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 world = await createWorldFromMap({ map, rules, seed: 1 })
 		const [hero] = carryIn(world, [seasoned], PLAYER, map.players[0].start!)
-		start(world, { map })
+		onStart(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)
@@ -218,7 +222,7 @@ describe('mission three, The Warlord', () => {
 	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 })
+			const world = await createWorldFromMap({ map, rules, seed: 1 })
 			// what the campaign's scene does before a mission seats its computers
 			world.computers.defaults = { difficulty }
 			warlord(world, true, difficulty)
@@ -229,7 +233,7 @@ describe('mission three, The Warlord', () => {
 		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(varga.health).toBe(Math.round(varga.maxHealth * 0.75))
 		expect(easy.named('guard4')).toBeUndefined()
 		hard.dispose()
 		easy.dispose()
@@ -271,15 +275,30 @@ describe('mission three, The Warlord', () => {
 })
 
 describe('the hero', () => {
+	it('is a Vanguard and a Keeper, of the engine’s callings', () => {
+		expect(heroCallings(registry, registry.unit(UNIT.knight)).map(({ calling, strength }) => [calling.name, strength])).toEqual([
+			['Vanguard', 3],
+			['Keeper', 2]
+		])
+	})
+
+	it('brings two of the engine’s hero spells, Barrier and Purify, and the shop names his items’ tags', () => {
+		expect(registry.unit(UNIT.knight).hero!.spells).toEqual(['barrier', 'purify'])
+		expect(['barrier', 'purify'].map((id) => registry.ability(id).name)).toEqual(['Barrier', 'Purify'])
+		// of the set, only what he brings
+		expect(rules.abilities!.some((ability) => ability.id === 'flash')).toBe(false)
+		expect(rules.tags!.map((tag) => tag.id).sort()).toEqual(['attack', 'consumable', 'health', 'movement'])
+	})
+
 	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
+		footman.health = 100
 		order(world, [hero], { type: 'cast', ability: 'holyLight', target: footman.id })
-		run(world, 3, () => footman.hp > 200)
-		expect(footman.hp).toBeGreaterThan(200)
+		run(world, 3, () => footman.health > 200)
+		expect(footman.health).toBeGreaterThan(200)
 		world.dispose()
 	})
 
@@ -289,13 +308,13 @@ describe('the hero', () => {
 		// 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
+		hero.health = 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)
+		run(world, 3, () => captive.health <= captive.maxHealth - 120)
+		expect(captive.maxHealth - captive.health).toBeGreaterThanOrEqual(120)
+		expect(hero.health).toBeGreaterThanOrEqual(300 + 120 - 1)
 		world.dispose()
 	})
 })
@@ -312,7 +331,7 @@ describe('each mission', () => {
 	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 })
+			const report = await checkDeterminism(() => mission(name), { ticks: 600, from: 150, rules })
 			expect(report).toEqual({ twice: null, fromSave: null })
 		},
 		120_000

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

@@ -1,6 +1,27 @@
-import { defineGame } from '@v12-engine/client'
-import { campaign } from './index'
-import { campaignView } from './view'
+import { createGame } from '@v12-engine/engine'
+import { campaign, startMission } from './index'
+import { maps } from './maps'
 
-/** 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 })
+/**
+ * The campaign's game, whole (`createGame`): its rules, its missions' maps, the mission of a map given as a game of it
+ * starts, and its look, fetched as a page first plays it (`./view`, and the client that draws it: not part of a start
+ * screen's code, nor of what a server or a test reads). What a page launches, its editor makes maps for and its
+ * campaign's scenes play (`scenes.ts`)
+ */
+export const campaignGame = createGame(campaign).maps(maps)
+
+/**
+ * What the game does once a world is made from a map, before anyone plays: the map's mission is given (each map is
+ * a mission's; a map of none plays on with no objectives). The page's free play, the server, the tests and the
+ * editor's Play here each run it with the map; the campaign's own scene gives the mission itself, knowing whether
+ * the game is new or loaded from a save
+ */
+campaignGame.onStart((world, { map }) => startMission(world, map))
+
+// @if !desktop
+campaignGame.view(() => import('./view').then((module) => module.campaignView))
+// @end
+// @if desktop
+// its look with what the desktop app adds to it: a Windowed setting, Quit on the pause menu
+campaignGame.view(() => Promise.all([import('./view'), import('../desktop')]).then(([{ campaignView }, { desktopView }]) => desktopView(campaignView)))
+// @end