@v12-engine/create 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,91 @@
+import { entityDied } from '@v12-engine/engine'
+import { defineListener, defineObjective, defineSequence, setGate, talk, wait, type World } from '@v12-engine/engine'
+import { ALDRIC, BRANN, ENEMY, MSG, PLAYER, UNIT } from '../ids'
+import { siegeWaves, startWaves, waveBeaten, waveComing } from '../waves'
+
+/*
+ * Mission two, The Siege: the Red Hand comes for the fort at night, in waves out of the war camp (`waves.ts`, the
+ * editor's Waves panel says who). Hold for every wave, keep the hall; a tower lost costs the optional objective. The
+ * gate shuts as a wave sets out and opens between waves; the rules fire effects where things happen, and the map has
+ * its torches and its bonfire
+ */
+
+export const holdOut = defineObjective({ id: 'campaign.hold', text: MSG.objectiveHold })
+export const keepTheHall = defineObjective({ id: 'campaign.siegeHall', text: MSG.objectiveHall })
+export const keepTowers = defineObjective({ id: 'campaign.towers', text: MSG.objectiveTowers, required: false })
+
+/** The gate of the fort, a doodad of the map by that name (`gate: true` in the editor) */
+export const GATE = 'gate'
+
+/** The briefing: what is coming, and what the gate does */
+export const siegeBriefing = defineSequence('campaign.siegeBriefing', [
+	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({
+	event: waveComing,
+	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 } })
+		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 }]))
+
+/** A wave beaten: the gate opens, the objective moves along; after the last, the mission is won */
+export const waveHeld = defineListener({
+	event: waveBeaten,
+	id: 'campaign.waveHeld',
+	run(world, { wave }) {
+		const { objectives } = world
+		if (!objectives.has(PLAYER, holdOut.id)) return
+		objectives.progress(PLAYER, holdOut.id, wave, { params: { wave } })
+		if (wave >= siegeWaves(world).length) {
+			objectives.complete(PLAYER, holdOut.id)
+			objectives.complete(PLAYER, keepTheHall.id)
+			if (objectives.get(PLAYER, keepTowers.id).status === 'open') objectives.complete(PLAYER, keepTowers.id)
+			return
+		}
+		if (setGate(world, GATE, true)) world.message(PLAYER, MSG.gateOpen, 'info')
+		if (wave === Math.floor(siegeWaves(world).length / 2)) world.sequences.start(halfway)
+		else if (wave === siegeWaves(world).length - 1) world.sequences.start(beforeTheLast)
+	}
+})
+
+/** Something of the fort's fell: a burst where it stood; a tower, the optional objective; the hall, the mission */
+export const fortBuildingFell = defineListener({
+	event: entityDied,
+	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 } })
+		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)
+	}
+})
+
+export const siegeSequences = [siegeBriefing, halfway, beforeTheLast]
+export const siegeListeners = [waveSetsOut, waveHeld, fortBuildingFell]
+
+/** Gives the mission: once, as the world is made. The waves, their timers and the gate's state are kept in a save */
+export function siege(world: World, fresh: boolean): void {
+	if (!fresh) return
+	const { objectives } = world
+	objectives.add(PLAYER, holdOut, { params: { wave: 0, waves: siegeWaves(world).length }, progress: { value: 0, max: siegeWaves(world).length } })
+	objectives.add(PLAYER, keepTheHall)
+	objectives.add(PLAYER, keepTowers)
+	// the Red Hand of the war camp has nothing to pay with, and sees nothing it has not come to
+	const purse = world.player(ENEMY).resources
+	for (const key of Object.keys(purse)) purse[key] = 0
+	setGate(world, GATE, true)
+	startWaves(world)
+	world.sequences.start(siegeBriefing)
+}

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

@@ -0,0 +1,177 @@
+import { cinematicChoice as cinematicChoiceEvent, enteredArea, entityDied } from '@v12-engine/engine'
+import {
+	applyBuff,
+	areaShapeOf,
+	cinematic,
+	defineComponent,
+	defineListener,
+	defineObjective,
+	defineSequence,
+	MAP_NEUTRAL,
+	playCinematic,
+	talk,
+	wait,
+	waitFor,
+	type World
+} from '@v12-engine/engine'
+import { guard, holdPosition, missionBrain } from '@v12-engine/engine/ai'
+import { ALDRIC, BRANN, MSG, PLAYER, UNIT, ENEMY } from '../ids'
+
+/*
+ * Mission three, The Warlord: Aldric, as he left the siege (the campaign carries him: his level, his abilities, what
+ * he bought), up the pass to Varga's hold. A trader on the way sells what he can carry. At the hold's gate the two
+ * talk, and the player chooses: face Varga alone, his men standing down, or charge with everyone. Won when Varga
+ * falls; lost when Aldric does; the prisoners in the cells are the optional one
+ */
+
+export const slayWarlord = defineObjective({ id: 'campaign.warlord', text: MSG.objectiveWarlord })
+export const keepHero = defineObjective({ id: 'campaign.hero', text: MSG.objectiveHero })
+export const freePrisoners = defineObjective({ id: 'campaign.prisoners', text: MSG.objectivePrisoners, required: false })
+
+/** The areas of the map the rules watch: the hold's gate, where the talk is, and the cells */
+const GATE = 'campaign.holdGate'
+const CELLS = 'campaign.cells'
+const REGIONS: [string, string][] = [
+	[GATE, 'gate'],
+	[CELLS, 'cells']
+]
+
+/** The cinematic of the talk, by its id in the view, and what the choice in it is called */
+export const PARLEY = 'campaign.parley'
+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: () => ({}) })
+
+/** Varga's men: they hold the hold, and his guard stays by him */
+export const vargasMen = missionBrain({
+	id: 'campaign.vargasMen',
+	modules: [guard('warlord', { units: { named: ['guard1', 'guard2', 'guard3'] } }), holdPosition('hold')]
+})
+
+/** The briefing, and the trader pointed out */
+export const passBriefing = defineSequence('campaign.passBriefing', [
+	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', [
+	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) ?? [])
+
+/**
+ * The player's answer: a duel, and the guards stand down (neutral: they watch), Varga the stronger for it; a charge,
+ * and the guards come for the hero at once. A choice skipped is no choice: they fight as they would
+ */
+export const theChoice = defineListener({
+	event: cinematicChoiceEvent,
+	id: 'campaign.theChoice',
+	run(world, { cinematic: id, choice, player }) {
+		if (id !== PARLEY || player !== PLAYER || !world.objectives.has(PLAYER, slayWarlord.id)) return
+		const warlord = world.named('warlord')
+		const hero = world.named('hero')
+		world.state(parley).choice = choice === 'duel' ? 'duel' : 'charge'
+		if (choice === 'duel') {
+			for (const man of guards(world)) world.setOwner(man, MAP_NEUTRAL)
+			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 } })
+			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 }]))
+
+/** The prisoners' cells reached: they are the player's from then on */
+export const cellsOpened = defineListener({
+	event: enteredArea,
+	id: 'campaign.cellsOpened',
+	run(world, { area, entity }) {
+		if (area !== CELLS || entity.owner !== PLAYER || !world.objectives.has(PLAYER, freePrisoners.id)) return
+		if (world.objectives.get(PLAYER, freePrisoners.id).status !== 'open') return
+		for (const prisoner of [...world.index.ownedBy(MAP_NEUTRAL)])
+			if (prisoner.alive && prisoner.def.id === UNIT.prisoner) world.setOwner(prisoner, PLAYER)
+		world.objectives.complete(PLAYER, freePrisoners.id)
+		world.sequences.start(freed)
+	}
+})
+
+const freed = defineSequence('campaign.freed', 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', [
+	waitFor(entityDied, (_world, { entity }) => entity.def.id === UNIT.warlord),
+	wait(1.5),
+	cinematic('campaign.outro', { hold: true }),
+	wait(0.5),
+	(world) => {
+		const { objectives } = world
+		objectives.complete(PLAYER, slayWarlord.id)
+		objectives.complete(PLAYER, keepHero.id)
+		if (objectives.get(PLAYER, freePrisoners.id).status === 'open') objectives.fail(PLAYER, freePrisoners.id)
+	}
+])
+
+export const heroFell = defineListener({
+	event: entityDied,
+	id: 'campaign.heroFell',
+	run(world, { entity }) {
+		if (entity.def.id !== UNIT.knight || entity.owner !== PLAYER || !world.objectives.has(PLAYER, keepHero.id)) return
+		if (world.objectives.get(PLAYER, slayWarlord.id).status === 'open') world.objectives.fail(PLAYER, keepHero.id, MSG.heroFell)
+	}
+})
+
+export const warlordSequences = [passBriefing, atTheGate, duel, charge, freed, theEnd]
+export const warlordListeners = [theChoice, cellsOpened, heroFell]
+
+/**
+ * Gives the mission: once, as the world is made. On the campaign's difficulty (`MissionContext.difficulty`; normal from
+ * the editor's Play here): on easy Varga starts worn, three quarters of his health; on hard a brute stands by him
+ * besides his guard. The Red Hand's computer plays on it as well, which the campaign's scene sees to
+ */
+export function warlord(world: World, fresh: boolean, difficulty = 'normal'): void {
+	if (!fresh) return
+	const { objectives } = world
+	objectives.add(PLAYER, slayWarlord)
+	objectives.add(PLAYER, keepHero)
+	objectives.add(PLAYER, freePrisoners)
+	for (const [id, region] of REGIONS) {
+		const shape = areaShapeOf({ region }, world.map.regions)
+		if (shape) world.areas.add({ id, shape })
+	}
+	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' })
+	world.computers.seat(ENEMY, { brain: vargasMen })
+	world.sequences.start(passBriefing)
+	world.sequences.start(atTheGate)
+	world.sequences.start(theEnd)
+}

package/starters/campaign/src/campaign/prefabs/watchpost.prefab.json

@@ -0,0 +1,18 @@
+{
+	"name": "watchpost",
+	"version": 1,
+	"tags": ["defence"],
+	"contents": {
+		"kind": "v12-clip",
+		"objects": [
+			{ "id": 1, "type": "tower", "owner": 1, "x": 0, "z": 0, "facing": 0, "scale": 1 },
+			{ "id": 2, "type": "archer", "owner": 1, "x": -1.5, "z": 1.5, "facing": 3.14, "scale": 1 },
+			{ "id": 3, "type": "archer", "owner": 1, "x": 1.5, "z": 1.5, "facing": 3.14, "scale": 1 }
+		],
+		"camps": [],
+		"regions": [],
+		"points": [],
+		"paths": [],
+		"doodads": []
+	}
+}

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

@@ -0,0 +1,46 @@
+import { defineCampaign } from '@v12-engine/client/app'
+import campaignFile from './campaign.json'
+import { campaign, 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
+ * player is, the missions won with their times, the saves), the briefing before a mission and the debrief after one
+ * (where it says them) and the scene that plays any mission; a mission won is kept at once, its end offers the next
+ * and a retry. What is data is its file, `campaign.json` (the editor's Campaign panel): its chapters, and each mission's
+ * name, map, words, briefing and debrief. What is code is here, by mission id: each mission's `start` gives its rules
+ * once (`fresh`); a game loaded from a save has them already. What else goes on is the campaign's own data
+ * (`RoadData`): each mission's `carry` gives its part as it is won, the next reads it as it starts (`progress.data`)
+ */
+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),
+	// a mission's map by the name the file gives it: `homestead` is `src/maps/homestead.vgmap.json`
+	maps: campaignMap,
+	missions: [
+		{
+			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),
+			// the footmen who live through it, and whether the caravan was found
+			carry: (world) => homecomingCarry(world)
+		},
+		{
+			id: 'siege',
+			start: (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)
+			}
+		},
+		{
+			id: 'warlord',
+			// harder or easier with the campaign's difficulty, chosen in its menu
+			start: (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/tiles.ts

@@ -0,0 +1,8 @@
+import { presetTiles } from '@v12-engine/engine'
+
+/**
+ * What the ground is painted with: the engine's tiles of an RTS (grass, dark grass, dirt, road, sand, rock, snow),
+ * drawn with the client's `TILE_LOOKS`. A tile of the game's own goes beside them: `defineTile({ id, name })` here,
+ * its look in the view
+ */
+export const tiles = [...presetTiles]