@v12-engine/create 0.1.0 → 0.4.0

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

@@ -1,4 +1,18 @@
-import { type GameMap, type GameModule, hotRules, objectiveVictory, prefabsFrom, withData, withHeroes, type World } from '@v12-engine/engine'
+import {
+	defaultHeroSpellSet,
+	defineCellLayer,
+	foliagePack,
+	type GameMap,
+	presetFoliageStyles,
+	type Rules,
+	hotRules,
+	objectiveVictory,
+	prefabsFrom,
+	layData,
+	heroesPack,
+	useDefaults,
+	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'
@@ -6,7 +20,7 @@ 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 { abilities, buffs, effects, items, itemTags, 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'
@@ -31,75 +45,97 @@ export { builtWaves, readWaves, siegeWaves, type Wave, WAVE_UNITS, wavesFile, wa
  *   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
+ * - two of the engine's hero spells for the knight (`useDefaults`: of the set, only those he brings; `all` would take
+ *   the nine, to give heroes in the Data panel), and the engine's item tags its items say
  */
-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' }
+export const campaign: Rules = layData(
+	useDefaults(
+		{
+			// 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,
+			// what its items' tags are called and look like (the shop's filters and search)
+			tags: itemTags,
+			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 (`heroesPack`); the grass of
+			// its maps, which hides who stands in the tall of it and burns (`foliagePack`)
+			packs: [heroesPack(), foliagePack({ layer: 'grass' })],
+			tiles,
+			// grass painted on the maps, each value a style of it: a meadow, and tall grass that hides who stands in it.
+			// How each looks is the view's (`ground.cellLayers.grass`), by the same names (`presetFoliage`)
+			cellLayers: [
+				defineCellLayer({
+					id: 'grass',
+					name: 'Grass',
+					color: [0.4, 0.72, 0.28],
+					values: [
+						{ value: 1, name: 'Meadow', foliage: presetFoliageStyles.meadow },
+						{ value: 2, name: 'Tall grass', color: [0.25, 0.5, 0.18], foliage: presetFoliageStyles.tallGrass }
+					]
+				})
 			],
-			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' }] : []
-						)
-					: []
+			// 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']
+			}
 		},
-		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']
-		}
-	},
+		[defaultHeroSpellSet()],
+		{ heroSpells: { only: ['barrier', 'purify'] } }
+	),
 	dataFile
 )
 

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

@@ -3,7 +3,7 @@ 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' })
+export const kills = defineComponent<number>({ id: '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({

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

@@ -65,18 +65,18 @@ export const redHand = missionBrain({
 })
 
 /** Every so often, two raiders more at the camp: the brain sends them */
-export const reinforcements = defineTimer('campaign.reinforcements', (world) => {
+export const reinforcements = defineTimer({ id: 'campaign.reinforcements', run: (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', [
+export const briefing = defineSequence({ id: 'campaign.briefing', steps: [
 	// 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' }),
@@ -85,17 +85,17 @@ export const briefing = defineSequence('campaign.briefing', [
 		{ 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', [
+export const atTheFord = defineSequence({ id: 'campaign.atTheFord', steps: [
 	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({
@@ -130,7 +130,7 @@ export const buildingFell = defineListener({
 	}
 })
 
-const wellDone = defineSequence('campaign.homeDone', talk(PLAYER, [{ speaker: ALDRIC, text: MSG.homeDone, seconds: 4 }]))
+const wellDone = defineSequence({ id: 'campaign.homeDone', steps: talk(PLAYER, [{ speaker: ALDRIC, text: MSG.homeDone, seconds: 4 }]) })
 
 export const homecomingSequences = [briefing, atTheFord, wellDone]
 export const homecomingListeners = [caravanFound, buildingFell]

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

@@ -18,13 +18,13 @@ export const keepTowers = defineObjective({ id: 'campaign.towers', text: MSG.obj
 export const GATE = 'gate'
 
 /** The briefing: what is coming, and what the gate does */
-export const siegeBriefing = defineSequence('campaign.siegeBriefing', [
+export const siegeBriefing = defineSequence({ id: 'campaign.siegeBriefing', steps: [
 	wait(0.5),
 	...talk(PLAYER, [
 		{ speaker: BRANN, text: MSG.siegeStart, seconds: 5 },
 		{ speaker: ALDRIC, text: MSG.siegeGate, seconds: 5 }
 	])
-])
+] })
 
 /** A wave sets out: the gate shuts, the camp flares (an effect fired by the rules, seen by every screen) */
 export const waveSetsOut = defineListener({
@@ -32,13 +32,13 @@ export const waveSetsOut = defineListener({
 	id: 'campaign.waveSetsOut',
 	run(world, { x, z }) {
 		if (!world.objectives.has(PLAYER, holdOut.id)) return
-		world.effect('spark-burst', { at: { x, z }, params: { size: 2 } })
+		world.fx('spark-burst', { at: { x, z }, params: { size: 2 } })
 		if (setGate(world, GATE, false)) world.message(PLAYER, MSG.gateShut, 'info')
 	}
 })
 
-const halfway = defineSequence('campaign.siegeHalfway', talk(PLAYER, [{ speaker: BRANN, text: MSG.siegeHalfway, seconds: 4 }]))
-const beforeTheLast = defineSequence('campaign.siegeLast', talk(PLAYER, [{ speaker: ALDRIC, text: MSG.siegeLast, seconds: 5 }]))
+const halfway = defineSequence({ id: 'campaign.siegeHalfway', steps: talk(PLAYER, [{ speaker: BRANN, text: MSG.siegeHalfway, seconds: 4 }]) })
+const beforeTheLast = defineSequence({ id: 'campaign.siegeLast', steps: talk(PLAYER, [{ speaker: ALDRIC, text: MSG.siegeLast, seconds: 5 }]) })
 
 /** A wave beaten: the gate opens, the objective moves along; after the last, the mission is won */
 export const waveHeld = defineListener({
@@ -66,7 +66,7 @@ export const fortBuildingFell = defineListener({
 	id: 'campaign.fortBuildingFell',
 	run(world, { entity }) {
 		if (entity.owner !== PLAYER || entity.def.kind !== 'building' || !world.objectives.has(PLAYER, holdOut.id)) return
-		world.effect('explosion', { at: { x: entity.pos.x, z: entity.pos.z }, params: { size: entity.def.id === UNIT.wall ? 0.8 : 1.5 } })
+		world.fx('explosion', { at: { x: entity.pos.x, z: entity.pos.z }, params: { size: entity.def.id === UNIT.wall ? 0.8 : 1.5 } })
 		if (entity.def.id === UNIT.tower) world.objectives.fail(PLAYER, keepTowers.id)
 		if (entity.def.id === UNIT.hall) world.objectives.fail(PLAYER, keepTheHall.id, MSG.hallFell)
 	}

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

@@ -44,7 +44,7 @@ export const PARLEY_CHOICE = 'parley'
  * What the player answered at the gate, kept in the world (so a save keeps it): what the campaign carries on as the
  * mission is won (`carry.ts`). Nothing for a talk skipped, or not had yet
  */
-export const parley = defineComponent<{ choice?: 'duel' | 'charge' }>('campaign.parley', { default: () => ({}) })
+export const parley = defineComponent<{ choice?: 'duel' | 'charge' }>({ id: 'campaign.parley', default: () => ({}) })
 
 /** Varga's men: they hold the hold, and his guard stays by him */
 export const vargasMen = missionBrain({
@@ -53,27 +53,27 @@ export const vargasMen = missionBrain({
 })
 
 /** The briefing, and the trader pointed out */
-export const passBriefing = defineSequence('campaign.passBriefing', [
+export const passBriefing = defineSequence({ id: 'campaign.passBriefing', steps: [
 	wait(0.5),
 	...talk(PLAYER, [
 		{ speaker: BRANN, text: MSG.passStart, seconds: 5 },
 		{ speaker: BRANN, text: MSG.passShop, seconds: 5 }
 	])
-])
+] })
 
 /**
  * At the gate: the talk, as a cinematic the rules play for the player (`playCinematic`, handed who talks), the game
  * held while it plays. The choice in it comes back as a command of the player's (`cinematicChoice`), which
  * `theChoice` hears; a cinematic with no data to hand over is the `cinematic` step, waited for or not
  */
-export const atTheGate = defineSequence('campaign.atTheGate', [
+export const atTheGate = defineSequence({ id: 'campaign.atTheGate', steps: [
 	waitFor(enteredArea, (_world, { area, entity }) => area === GATE && entity.owner === PLAYER),
 	(world) => {
 		const hero = world.named('hero')
 		const warlord = world.named('warlord')
 		playCinematic(world, PARLEY, { to: PLAYER, hold: true, params: { hero: hero?.id, warlord: warlord?.id } })
 	}
-])
+] })
 
 /** Varga's guards, by the names the map gives them */
 const guards = (world: World) => ['guard1', 'guard2', 'guard3'].flatMap((name) => world.named(name) ?? [])
@@ -95,15 +95,14 @@ export const theChoice = defineListener({
 			if (warlord?.alive) applyBuff(world, warlord, 'rallied', 60)
 			world.sequences.start(duel)
 		} else {
-			if (hero?.alive)
-				for (const man of guards(world)) world.issue({ type: 'order', player: ENEMY, entities: [man.id], order: { type: 'attack', target: hero.id } })
+			if (hero?.alive) for (const man of guards(world)) man.order('attack', hero)
 			world.sequences.start(charge)
 		}
 	}
 })
 
-const duel = defineSequence('campaign.duel', talk(PLAYER, [{ speaker: ALDRIC, text: MSG.passDuel, seconds: 4 }]))
-const charge = defineSequence('campaign.charge', talk(PLAYER, [{ speaker: BRANN, text: MSG.passCharge, seconds: 4 }]))
+const duel = defineSequence({ id: 'campaign.duel', steps: talk(PLAYER, [{ speaker: ALDRIC, text: MSG.passDuel, seconds: 4 }]) })
+const charge = defineSequence({ id: 'campaign.charge', steps: talk(PLAYER, [{ speaker: BRANN, text: MSG.passCharge, seconds: 4 }]) })
 
 /** The prisoners' cells reached: they are the player's from then on */
 export const cellsOpened = defineListener({
@@ -119,13 +118,13 @@ export const cellsOpened = defineListener({
 	}
 })
 
-const freed = defineSequence('campaign.freed', talk(PLAYER, [{ speaker: BRANN, text: MSG.passPrisoners, seconds: 4 }]))
+const freed = defineSequence({ id: 'campaign.freed', steps: talk(PLAYER, [{ speaker: BRANN, text: MSG.passPrisoners, seconds: 4 }]) })
 
 /**
  * Varga falls: the outro plays, the game held while it does, and then it is won (the end screen comes once the
  * outro is over, as the game stands still under it). Aldric falls: it is lost
  */
-export const theEnd = defineSequence('campaign.theEnd', [
+export const theEnd = defineSequence({ id: 'campaign.theEnd', steps: [
 	waitFor(entityDied, (_world, { entity }) => entity.def.id === UNIT.warlord),
 	wait(1.5),
 	cinematic('campaign.outro', { hold: true }),
@@ -136,7 +135,7 @@ export const theEnd = defineSequence('campaign.theEnd', [
 		objectives.complete(PLAYER, keepHero.id)
 		if (objectives.get(PLAYER, freePrisoners.id).status === 'open') objectives.fail(PLAYER, freePrisoners.id)
 	}
-])
+] })
 
 export const heroFell = defineListener({
 	event: entityDied,
@@ -168,8 +167,8 @@ export function warlord(world: World, fresh: boolean, difficulty = 'normal'): vo
 	const purse = world.player(ENEMY).resources
 	for (const key of Object.keys(purse)) purse[key] = 0
 	const varga = world.named('warlord')
-	if (varga && difficulty === 'easy') varga.hp = Math.round(varga.maxHp * 0.75)
-	if (varga && difficulty === 'hard') world.spawn(UNIT.brute, ENEMY, { x: varga.pos.x + 2, z: varga.pos.z + 1 }, { name: 'guard4' })
+	if (varga && difficulty === 'easy') varga.health = Math.round(varga.maxHealth * 0.75)
+	if (varga && difficulty === 'hard') world.spawn(UNIT.brute, { at: { x: varga.pos.x + 2, z: varga.pos.z + 1 }, owner: ENEMY, name: 'guard4' })
 	world.computers.seat(ENEMY, { brain: vargasMen })
 	world.sequences.start(passBriefing)
 	world.sequences.start(atTheGate)

package/starters/campaign/src/campaign/scenes.ts

@@ -1,6 +1,7 @@
 import { defineCampaign } from '@v12-engine/client/app'
+import { campaignGame } from './game'
 import campaignFile from './campaign.json'
-import { campaign, campaignMap, homecoming, homecomingCarry, type RoadData, siege, siegeCarriedIn, warlord, warlordCarry } from './index'
+import { campaignMap, homecoming, homecomingCarry, type RoadData, siege, siegeCarriedIn, warlord, warlordCarry } from './index'
 
 /**
  * The campaign of three missions, Aldric carried from one to the next: `defineCampaign` gives the menu (where the
@@ -13,9 +14,9 @@ import { campaign, campaignMap, homecoming, homecomingCarry, type RoadData, sieg
  */
 export const theLongRoad = defineCampaign<RoadData>({
 	file: campaignFile,
-	game: campaign,
-	// its look (and the client that draws it) fetched as its menu opens: not part of the start screen's code
-	view: () => import('./view').then((module) => module.campaignView),
+	// the game (`./game.ts`): its rules, and its look (and the client that draws it) fetched as the campaign's menu
+	// opens, not part of the start screen's code
+	game: campaignGame,
 	// a mission's map by the name the file gives it: `homestead` is `src/maps/homestead.vgmap.json`
 	maps: campaignMap,
 	missions: [
@@ -23,13 +24,13 @@ export const theLongRoad = defineCampaign<RoadData>({
 			id: 'homecoming',
 			// its debrief's words are the file's; its rating, by how quick it was, is code
 			debrief: { rating: ({ seconds }) => (seconds < 600 ? 3 : seconds < 1200 ? 2 : 1) },
-			start: (world, { fresh }) => homecoming(world, fresh),
+			onStart: (world, { fresh }) => homecoming(world, fresh),
 			// the footmen who live through it, and whether the caravan was found
 			carry: (world) => homecomingCarry(world)
 		},
 		{
 			id: 'siege',
-			start: (world, { fresh, map, progress }) => {
+			onStart: (world, { fresh, map, progress }) => {
 				siege(world, fresh)
 				// the footmen of Homecoming man the fort; a game loaded from a save has them already
 				if (fresh) siegeCarriedIn(world, map, progress.data)
@@ -38,7 +39,7 @@ export const theLongRoad = defineCampaign<RoadData>({
 		{
 			id: 'warlord',
 			// harder or easier with the campaign's difficulty, chosen in its menu
-			start: (world, { fresh, difficulty }) => warlord(world, fresh, difficulty),
+			onStart: (world, { fresh, difficulty }) => warlord(world, fresh, difficulty),
 			// the answer at the gate: the last mission, so the campaign keeps it for whatever comes after
 			carry: (world) => warlordCarry(world)
 		}

package/starters/campaign/src/campaign/units.ts

@@ -1,5 +1,15 @@
 import type { EffectFields } from '@v12-engine/engine'
-import { type AbilityDef, type BuffDef, defineEffect, type EffectKind, type ItemDef, type Scaled, scaled, type UnitTypeDef } from '@v12-engine/engine'
+import {
+	type AbilityDef,
+	type BuffDef,
+	defaultItemTags,
+	defineEffect,
+	effectAmount,
+	type EffectType,
+	type ItemDef,
+	type TagDef,
+	type UnitTypeDef
+} from '@v12-engine/engine'
 import { UNIT } from './ids'
 
 // the game's own effects, each with the fields it reads (`EffectTypes`)
@@ -62,9 +72,9 @@ export const archer: UnitTypeDef = {
 }
 
 /**
- * The hero: Aldric, the map names him `hero`. He grows with every level (`hero.growth`), learns three abilities with
- * his skill points, carries six items, and goes from one mission to the next with all of it (the campaign carries
- * him: `carryOut`, `carryIn`)
+ * The hero: Aldric, the map names him `hero`. He grows with every level (`hero.growth`), is a Vanguard and a Keeper
+ * (`hero.callings`), learns three abilities with his skill points, carries six items, and goes from one mission to
+ * the next with all of it (the campaign carries him: `carryOut`, `carryIn`)
  */
 export const knight: UnitTypeDef = {
 	id: UNIT.knight,
@@ -86,7 +96,12 @@ export const knight: UnitTypeDef = {
 	attacks: [{ damagePoint: 0.4, acquisitionRange: 8 }],
 	hero: {
 		growth: { stats: { health: 80, mana: 30, attackDamage: 3, armor: 3 } },
+		// what he is good at (the engine's callings, `defaultCallings`): in front, taking the blows; keeping his men up
+		callings: { vanguard: 3, keeper: 2 },
 		learns: ['holyLight', 'warCry', 'judgement'],
+		// two of the engine's hero spells, on D and F (the set taken in `index.ts`, `defaultHeroSpellSet`): a shield, and
+		// a way out of a stun
+		spells: ['barrier', 'purify'],
 		maxLevel: 10
 	},
 	inventory: 6,
@@ -274,7 +289,7 @@ export const goldmine: UnitTypeDef = {
 	stats: { health: 1 },
 	sight: 0,
 	invulnerable: true,
-	resource: { kind: 'gold', amount: 8000, slots: 1, entered: true }
+	resource: { id: 'gold', amount: 8000, slots: 1, entered: true }
 }
 
 export const units = [
@@ -304,23 +319,24 @@ export const buffs: BuffDef[] = [
 	{ id: 'rallied', name: 'Rallied', description: 'Hits 20% harder and 15% faster', percent: { attackDamage: 0.2, attackSpeed: 0.15 } }
 ]
 
-/** A number a level (`Scaled`): the level's, or the last for a level past the list */
-const atLevel = (amount: Scaled | undefined, level: number): number =>
-	Array.isArray(amount) ? amount[Math.min(level, amount.length) - 1] : (amount ?? 0)
-
 /**
  * Effects the engine does not have, by the type an ability's effect names (`effects` of the module): a function given
  * the caster, the target and the level, with the world's own damage and healing, so that armour, death, bounty and
  * experience happen as for any hit
  */
-export const effects: EffectKind[] = [
+export const effects: EffectType[] = [
 	/** Judgement: the enemy struck, and the caster healed for what it took */
-	defineEffect('campaign.judgement', ({ world, caster, target, level }, effect) => {
-		if (!target?.alive) return
-		const amount = scaled(world, caster, atLevel(effect.amount, level), effect.scaling, level)
-		const before = target.hp
-		world.damage(target, amount, caster, { damageType: 'magic' })
-		world.heal(caster, Math.max(0, before - Math.max(target.hp, 0)), caster)
+	defineEffect({
+		type: 'campaign.judgement',
+		run: (context, effect) => {
+			const { world, caster, target } = context
+			if (!target?.alive) return
+			// its amount at its level, with what the caster's stats add, as the engine's damage works it out
+			const amount = effectAmount(context, effect, target)
+			const before = target.health
+			world.damage(target, amount, caster, { damageType: 'magic' })
+			world.heal(caster, Math.max(0, before - Math.max(target.health, 0)), caster)
+		}
 	})
 ]
 
@@ -375,7 +391,10 @@ export const abilities: AbilityDef[] = [
 	}
 ]
 
-/** What the trader sells (`trader.sells`) */
+/**
+ * What the trader sells (`trader.sells`): each with its tags (what the shop's search and filters find it by) and the
+ * callings it suits (what the shop puts first for the knight)
+ */
 export const items: ItemDef[] = [
 	{
 		id: 'healingPotion',
@@ -383,8 +402,28 @@ export const items: ItemDef[] = [
 		description: 'Drunk, heals 200. Three in the bottle',
 		cost: { gold: 60 },
 		charges: 3,
-		ability: 'drinkPotion'
+		ability: 'drinkPotion',
+		tier: 'consumable',
+		tags: ['consumable', 'health']
+	},
+	{
+		id: 'steelSword',
+		name: 'Steel Sword',
+		description: '+12 attack damage',
+		cost: { gold: 180 },
+		bonus: { stats: { attackDamage: 12 } },
+		tags: ['attack'],
+		suits: ['vanguard']
 	},
-	{ id: 'steelSword', name: 'Steel Sword', description: '+12 attack damage', cost: { gold: 180 }, bonus: { stats: { attackDamage: 12 } } },
-	{ id: 'swiftBoots', name: 'Swift Boots', description: '+0.8 move speed', cost: { gold: 120 }, bonus: { stats: { moveSpeed: 0.8 } } }
+	{
+		id: 'swiftBoots',
+		name: 'Swift Boots',
+		description: '+0.8 move speed',
+		cost: { gold: 120 },
+		bonus: { stats: { moveSpeed: 0.8 } },
+		tags: ['movement']
+	}
 ]
+
+/** The tags its items say, named and coloured: the engine's own (`defaultItemTags`), those its items use */
+export const itemTags: TagDef[] = defaultItemTags.filter((tag) => items.some((item) => item.tags?.includes(tag.id)))

package/starters/campaign/src/campaign/view/attacks.ts

@@ -0,0 +1,19 @@
+import type { AttackLook } from '@v12-engine/client'
+
+// The swings of the shared characters' rig (`UnitLook.attacks`): several each, so a fight does not play the same blow
+// over and over. At random, never the same twice running; a critical strike ends in a big two-handed slice
+
+/** A one-handed weapon's swings: a chop, a slice, a stab */
+export const ONE_HANDED: AttackLook = {
+	clip: ['Melee_1H_Attack_Chop', 'Melee_1H_Attack_Slice_Diagonal', 'Melee_1H_Attack_Stab'],
+	order: 'random',
+	crit: 'Melee_2H_Attack_Slice'
+}
+/** A two-handed weapon's: a chop and a slice, in turn */
+export const TWO_HANDED: AttackLook = { clip: ['Melee_2H_Attack_Chop', 'Melee_2H_Attack_Slice'], crit: 'Melee_2H_Attack_Chop' }
+/** Two weapons': both together, and each alone */
+export const DUAL_WIELD: AttackLook = {
+	clip: ['Melee_Dualwield_Attack_Chop', 'Melee_1H_Attack_Slice_Diagonal', 'Melee_1H_Attack_Stab'],
+	order: 'random',
+	crit: 'Melee_Dualwield_Attack_Chop'
+}

package/starters/campaign/src/campaign/view/fire.ts

@@ -1,5 +1,5 @@
 import { Vector3 } from '@babylonjs/core/Maths/math.vector'
-import { type EffectHandle, type Rgb, Sparks, type SpellStyleFactory } from '@v12-engine/client'
+import { type FxHandle, type Rgb, Sparks, type SpellStyleFactory } from '@v12-engine/client'
 
 /*
  * A spell style of the campaign's own (`styles` in the view, `style: 'campaign.holyFire'` on Judgement's look), as an
@@ -24,7 +24,7 @@ export const holyFire: SpellStyleFactory = (context) => {
 	const sparks = new Sparks(context.fx)
 	/** What is still to happen, by the time it happens at (`context.time`) */
 	const later: { at: number; run: () => void }[] = []
-	const burning: { until: number; stream: EffectHandle }[] = []
+	const burning: { until: number; stream: FxHandle }[] = []
 
 	const groundAt = (x: number, z: number) => context.terrain.heightAt(x, z)