@v12-engine/create 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,390 @@
+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 { UNIT } from './ids'
+
+// the game's own effects, each with the fields it reads (`EffectTypes`)
+declare module '@v12-engine/engine' {
+	interface EffectTypes {
+		'campaign.judgement': Pick<EffectFields, 'amount' | 'scaling'>
+	}
+}
+
+/*
+ * What there is: the player's workers, soldiers and buildings, the hero, the Red Hand, the creeps of the woods, and
+ * what the maps are dressed with. Each is data (`UnitTypeDef`): what the editor's Data panel changes of it is kept in
+ * `data.json` (`editable`, in index.ts), and the look of each is the view's (`view/index.ts`)
+ */
+
+// ---- the player's
+
+/** Digs gold at a mine and carries it home, and puts up the buildings */
+export const peasant: UnitTypeDef = {
+	id: UNIT.peasant,
+	name: 'Peasant',
+	kind: 'unit',
+	radius: 0.4,
+	stats: { health: 220, attackDamage: 6, attackSpeed: 0.6, attackRange: 0.4, moveSpeed: 4 },
+	sight: 8,
+	attacks: [{ damagePoint: 0.4, acquisitionRange: 0 }],
+	cost: { gold: 60 },
+	buildTime: 8,
+	harvester: { capacity: 10, gatherTime: 1.5 },
+	builds: [UNIT.farm, UNIT.barracks, UNIT.tower, UNIT.wall],
+	hotkey: 'P'
+}
+
+/** Sword and shield: the line that holds */
+export const footman: UnitTypeDef = {
+	id: UNIT.footman,
+	name: 'Footman',
+	kind: 'unit',
+	radius: 0.45,
+	stats: { health: 420, attackDamage: 14, attackSpeed: 1.1, attackRange: 0.5, armor: 12, moveSpeed: 4 },
+	sight: 10,
+	attacks: [{ damagePoint: 0.45, acquisitionRange: 8 }],
+	cost: { gold: 90 },
+	buildTime: 12,
+	hotkey: 'F'
+}
+
+/** Shoots over the line, and falls fast when reached */
+export const archer: UnitTypeDef = {
+	id: UNIT.archer,
+	name: 'Archer',
+	kind: 'unit',
+	radius: 0.42,
+	stats: { health: 260, attackDamage: 18, attackSpeed: 1, attackRange: 7, moveSpeed: 4.2 },
+	sight: 11,
+	attacks: [{ damagePoint: 0.5, acquisitionRange: 8, projectileSpeed: 26 }],
+	cost: { gold: 110 },
+	buildTime: 14,
+	hotkey: 'A'
+}
+
+/**
+ * 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`)
+ */
+export const knight: UnitTypeDef = {
+	id: UNIT.knight,
+	name: 'Knight',
+	kind: 'unit',
+	radius: 0.5,
+	stats: {
+		health: 650,
+		healthRegen: 1,
+		mana: 200,
+		manaRegen: 1.5,
+		attackDamage: 42,
+		attackSpeed: 0.8,
+		attackRange: 0.6,
+		armor: 30,
+		moveSpeed: 4.4
+	},
+	sight: 12,
+	attacks: [{ damagePoint: 0.4, acquisitionRange: 8 }],
+	hero: {
+		growth: { stats: { health: 80, mana: 30, attackDamage: 3, armor: 3 } },
+		learns: ['holyLight', 'warCry', 'judgement'],
+		maxLevel: 10
+	},
+	inventory: 6,
+	level: 1,
+	hotkey: 'K'
+}
+
+const building = (def: Omit<UnitTypeDef, 'kind'>): UnitTypeDef => ({ kind: 'building', ...def })
+
+/** The hall: it trains peasants, and takes the gold they bring. The mission is lost when it falls */
+export const hall = building({
+	id: UNIT.hall,
+	name: 'Town Hall',
+	radius: 2,
+	footprint: { w: 4, d: 4 },
+	stats: { health: 2200, armor: 40 },
+	sight: 12,
+	trains: [UNIT.peasant],
+	dropOff: true,
+	hotkey: 'H'
+})
+
+/** A farm: it feeds the men, and is the first thing a raid burns */
+export const farm = building({
+	id: UNIT.farm,
+	name: 'Farm',
+	radius: 1,
+	footprint: { w: 2, d: 2 },
+	stats: { health: 600, armor: 20 },
+	sight: 6,
+	cost: { gold: 80 },
+	buildTime: 12,
+	hotkey: 'F'
+})
+
+/** The barracks: footmen and archers */
+export const barracks = building({
+	id: UNIT.barracks,
+	name: 'Barracks',
+	radius: 1.5,
+	footprint: { w: 3, d: 3 },
+	stats: { health: 1600, armor: 30 },
+	sight: 9,
+	cost: { gold: 180 },
+	buildTime: 25,
+	trains: [UNIT.footman, UNIT.archer],
+	hotkey: 'B'
+})
+
+/** A guard tower: it shoots what comes near */
+export const tower = building({
+	id: UNIT.tower,
+	name: 'Guard Tower',
+	radius: 1,
+	footprint: { w: 2, d: 2 },
+	stats: { health: 1100, attackDamage: 40, attackSpeed: 0.9, attackRange: 9, armor: 40 },
+	sight: 12,
+	attacks: [{ damagePoint: 0.3, acquisitionRange: 9, projectileSpeed: 24 }],
+	cost: { gold: 140 },
+	buildTime: 20,
+	hotkey: 'T'
+})
+
+/** A stretch of wall: nothing walks through it until it is down */
+export const wall = building({
+	id: UNIT.wall,
+	name: 'Wall',
+	radius: 1,
+	footprint: { w: 2, d: 1 },
+	stats: { health: 700, armor: 60 },
+	sight: 2,
+	cost: { gold: 25 },
+	buildTime: 5,
+	hotkey: 'W'
+})
+
+/** A trader on the road: sells to whoever comes by, and cannot be hurt */
+export const trader = building({
+	id: UNIT.trader,
+	name: 'Trader',
+	radius: 1.2,
+	footprint: { w: 2, d: 2 },
+	stats: { health: 1000 },
+	invulnerable: true,
+	sight: 8,
+	sells: ['healingPotion', 'steelSword', 'swiftBoots']
+})
+
+// ---- the Red Hand's
+
+const enemy = (def: Omit<UnitTypeDef, 'kind' | 'sight'> & Partial<Pick<UnitTypeDef, 'sight'>>): UnitTypeDef => ({ kind: 'unit', sight: 8, ...def })
+
+/** The common raider: an axe and a shield */
+export const raider = enemy({
+	id: UNIT.raider,
+	name: 'Raider',
+	radius: 0.45,
+	stats: { health: 380, attackDamage: 15, attackSpeed: 1, attackRange: 0.5, armor: 8, moveSpeed: 4 },
+	attacks: [{ damagePoint: 0.45, acquisitionRange: 8 }],
+	level: 1,
+	bounty: [6, 10],
+	xp: 24
+})
+
+/** Throws fire from behind the raiders */
+export const warlock = enemy({
+	id: UNIT.warlock,
+	name: 'Warlock',
+	radius: 0.42,
+	stats: { health: 240, attackDamage: 24, attackSpeed: 0.8, attackRange: 7, moveSpeed: 3.8 },
+	attacks: [{ damagePoint: 0.5, acquisitionRange: 8, projectileSpeed: 18 }],
+	level: 2,
+	bounty: [10, 14],
+	xp: 36
+})
+
+/** Twice a raider, slow, with a two-handed axe that hits all round where it comes down (`splash`: an `impact` event) */
+export const brute = enemy({
+	id: UNIT.brute,
+	name: 'Brute',
+	radius: 0.6,
+	stats: { health: 900, attackDamage: 34, attackSpeed: 0.7, attackRange: 0.7, armor: 20, moveSpeed: 3.4 },
+	attacks: [{ damagePoint: 0.5, acquisitionRange: 8, splash: 1.2 }],
+	level: 4,
+	bounty: [24, 30],
+	xp: 90
+})
+
+/** Varga, who leads them: the last mission is won when he falls */
+export const warlord = enemy({
+	id: UNIT.warlord,
+	name: 'Warlord',
+	radius: 0.7,
+	stats: { health: 2400, healthRegen: 2, attackDamage: 60, attackSpeed: 0.8, attackRange: 0.8, armor: 35, moveSpeed: 4 },
+	sight: 12,
+	attacks: [{ damagePoint: 0.4, acquisitionRange: 9 }],
+	level: 8,
+	bounty: [200, 250],
+	xp: 600
+})
+
+// ---- the woods'
+
+/** The creeps of the forest: in camps by the road, with a bounty for clearing them */
+export const gnoll = enemy({
+	id: UNIT.gnoll,
+	name: 'Gnoll',
+	radius: 0.42,
+	stats: { health: 300, attackDamage: 12, attackSpeed: 0.8, attackRange: 0.5, moveSpeed: 4 },
+	attacks: [{ damagePoint: 0.4, acquisitionRange: 5 }],
+	level: 1,
+	bounty: [5, 9],
+	xp: 20
+})
+
+/** Villagers the Red Hand took: they fight for nobody until they are freed, and then they are the player's */
+export const prisoner: UnitTypeDef = {
+	id: UNIT.prisoner,
+	name: 'Prisoner',
+	kind: 'unit',
+	radius: 0.4,
+	stats: { health: 160, moveSpeed: 3.8 },
+	sight: 6
+}
+
+/** For the look of the maps */
+export const tree: UnitTypeDef = {
+	id: UNIT.tree,
+	name: 'Tree',
+	kind: 'resource',
+	radius: 0.5,
+	footprint: { w: 1, d: 1 },
+	stats: { health: 1 },
+	sight: 0,
+	invulnerable: true
+}
+
+/** Where the gold comes from: a peasant goes in with nothing and out with ten */
+export const goldmine: UnitTypeDef = {
+	id: UNIT.goldmine,
+	name: 'Gold Mine',
+	kind: 'resource',
+	radius: 2,
+	footprint: { w: 4, d: 4 },
+	stats: { health: 1 },
+	sight: 0,
+	invulnerable: true,
+	resource: { kind: 'gold', amount: 8000, slots: 1, entered: true }
+}
+
+export const units = [
+	peasant,
+	footman,
+	archer,
+	knight,
+	hall,
+	farm,
+	barracks,
+	tower,
+	wall,
+	trader,
+	raider,
+	warlock,
+	brute,
+	warlord,
+	gnoll,
+	prisoner,
+	tree,
+	goldmine
+]
+
+// ---- what the hero can do, and what he can carry
+
+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[] = [
+	/** 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)
+	})
+]
+
+/**
+ * The hero's three abilities, learned a level at a time (`hero.learns`), and the one a potion gives. Two are made of
+ * the engine's effects (`heal`, `buff`); Judgement is an effect of the game's own (`effects` above)
+ */
+export const abilities: AbilityDef[] = [
+	{
+		id: 'holyLight',
+		name: 'Holy Light',
+		description: 'Heals a friendly unit for 150, 250 or 350',
+		hotkey: 'Q',
+		target: 'unit',
+		targets: { allies: true, self: true },
+		manaCost: 50,
+		cooldown: 6,
+		range: 8,
+		castTime: 0.3,
+		effects: [{ type: 'heal', amount: [150, 250, 350] }]
+	},
+	{
+		id: 'warCry',
+		name: 'War Cry',
+		description: 'Friends within 7 hit harder and faster for 10 seconds',
+		hotkey: 'W',
+		target: 'none',
+		manaCost: 60,
+		cooldown: 20,
+		effects: [{ type: 'buff', buff: 'rallied', radius: 7, affects: 'allies', duration: 10 }]
+	},
+	{
+		id: 'judgement',
+		name: 'Judgement',
+		description: 'Strikes an enemy for 120, 200 or 280 and heals the knight for as much',
+		hotkey: 'E',
+		target: 'unit',
+		targets: { enemies: true },
+		manaCost: 70,
+		cooldown: 10,
+		range: 6,
+		castTime: 0.4,
+		effects: [{ type: 'campaign.judgement', amount: [120, 200, 280] }]
+	},
+	{
+		id: 'drinkPotion',
+		name: 'Drink',
+		description: 'Heals 200 at once',
+		target: 'none',
+		cooldown: 1,
+		effects: [{ type: 'heal', amount: 200, on: 'caster' }]
+	}
+]
+
+/** What the trader sells (`trader.sells`) */
+export const items: ItemDef[] = [
+	{
+		id: 'healingPotion',
+		name: 'Healing Potion',
+		description: 'Drunk, heals 200. Three in the bottle',
+		cost: { gold: 60 },
+		charges: 3,
+		ability: 'drinkPotion'
+	},
+	{ 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 } } }
+]

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

@@ -0,0 +1,59 @@
+import type { Cinematic, Cut } from '@v12-engine/client'
+import { ALDRIC, BRANN, VARGA } from '../ids'
+import { PARLEY_CHOICE } from '../missions/warlord'
+
+/*
+ * The campaign's cinematics in code: a script given a cut (`Cinematic`). The intro and the outro are files made in
+ * the editor's Cinematic panel (`../cinematics/*.json`) instead; both kinds are played by id, by the rules
+ * (`playCinematic`) or the screen (`client.play`)
+ */
+
+/**
+ * The talk at the hold's gate (mission three): the camera on Varga, then on Aldric, a line each, and the player's
+ * choice. The answer goes to the rules as a command of the player's (`cinematicChoice`), which branch the fight on
+ * it; here it only picks the last line
+ */
+export const parley: Cinematic = async (cut, params) => {
+	const { hero, warlord } = (params ?? {}) as { hero?: number; warlord?: number }
+	if (hero === undefined || warlord === undefined) return
+	await cut.camera({ at: { entity: warlord }, distance: 14, pitch: 0.4, yaw: 0.6 }, 1.2)
+	await cut.say(VARGA, 'So the knight walks up to my door, with what is left of his village behind him.', 5)
+	await cut.camera({ at: { entity: hero }, distance: 10, pitch: 0.3, yaw: -0.8 }, 1)
+	await cut.say(ALDRIC, 'Your camp is ash, Varga. Your siege broke on our walls. This ends here.', 5)
+	await cut.camera({ at: { entity: warlord }, distance: 12, pitch: 0.35, yaw: 0.4 }, 1)
+	await cut.say(VARGA, 'Then come and end it. Alone, if you have the stomach. Or hide behind your men.', 5)
+	const answer = await cut.choose(
+		[
+			{ id: 'duel', label: 'Face him alone' },
+			{ id: 'charge', label: 'Charge, all of us' }
+		],
+		{ name: PARLEY_CHOICE, question: 'How does this end?', seconds: 15, default: 'charge' }
+	)
+	if (answer === 'duel') await cut.say(ALDRIC, 'Stand back, all of you. He is mine.', 3)
+	else await cut.say(BRANN, 'With me! For the village!', 3)
+	await roar(cut, warlord)
+}
+
+/** The clip Varga roars with, and the moment of it his arms come up */
+const ROAR = 'Ranged_Magic_Spellcasting_Long'
+const ROAR_PEAK = 0.55
+
+/**
+ * Varga roars as the fight starts: a clip of his model played on the cut (`cut.clip`) with a moment in it (`marks`):
+ * at the height of it, sparks burst from him (an effect of the game's, `cut.fx`) and the view shakes
+ */
+async function roar(cut: Cut, warlord: number): Promise<void> {
+	await cut.camera({ at: { entity: warlord }, distance: 12, pitch: 0.5 }, 0.6)
+	await cut.clip(warlord, ROAR, {
+		seconds: 2.2,
+		marks: [
+			{
+				at: ROAR_PEAK,
+				run: () => {
+					cut.fx('spark-burst', { on: warlord })
+					cut.shake(0.8)
+				}
+			}
+		]
+	})
+}

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

@@ -0,0 +1,115 @@
+import { Vector3 } from '@babylonjs/core/Maths/math.vector'
+import { type EffectHandle, 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
+ * example of what a game draws with the client's toolkit: particles (`Sparks`, effects of the view's effect system),
+ * timed by the style itself
+ */
+
+const HALO: Rgb = [1, 0.78, 0.3]
+const LIGHT: Rgb = [1, 0.96, 0.7]
+
+/** Seconds the light takes to come down, and how long the ground burns after */
+const FALL = 0.45
+const BURN = 1.5
+/** How wide it comes down on a unit, when the ability says nothing */
+const RADIUS = 1.2
+
+/**
+ * Holy fire: while the knight winds up, a glow gathers over him and a ring marks the one he strikes; then light rains
+ * down there, bursts on the ground, and the ground burns for a moment. All of it particles
+ */
+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 groundAt = (x: number, z: number) => context.terrain.heightAt(x, z)
+
+	return {
+		windup(event) {
+			const caster = context.anchors.position(event.caster)
+			if (caster)
+				sparks.burst(caster.x, caster.y + 2.4, caster.z, {
+					color: HALO,
+					tint: LIGHT,
+					count: 40,
+					way: 'about',
+					radius: 0.5,
+					speed: [0.5, 1.5],
+					life: [0.4, event.duration],
+					over: event.duration
+				})
+			context.ring(event.aim.x, event.aim.z, HALO, Math.max(event.size, RADIUS) * 2, 0.5)
+		},
+
+		cast(event) {
+			const { x, z } = event
+			const radius = event.radius ?? RADIUS
+			const ground = groundAt(x, z)
+			// light coming down on the one struck, long streaks of it
+			sparks.burst(x, ground + 9, z, {
+				color: HALO,
+				tint: LIGHT,
+				count: 60,
+				way: 'down',
+				radius,
+				height: 2,
+				speed: [14, 20],
+				life: [0.45, 0.6],
+				size: [0.4, 0.9],
+				streaks: true,
+				over: 0.3
+			})
+			later.push({
+				at: context.time + FALL,
+				run: () => {
+					// the burst where it lands, and the ground left burning
+					sparks.burst(x, ground + 0.3, z, {
+						color: HALO,
+						tint: LIGHT,
+						count: 50,
+						way: 'out',
+						radius: radius * 0.5,
+						speed: [3, 9],
+						life: [0.3, 0.7],
+						gravity: 6
+					})
+					context.ring(x, z, LIGHT, 0.5, radius * 2)
+					context.shake?.(x, z, 0.2)
+					const stream = sparks.stream(new Vector3(x, ground + 0.15, z), {
+						color: HALO,
+						tint: LIGHT,
+						count: 35,
+						way: 'up',
+						radius: radius * 0.85,
+						speed: [0.6, 2.2],
+						life: [0.5, 1.1],
+						size: [0.3, 0.8]
+					})
+					burning.push({ until: context.time + BURN, stream })
+				}
+			})
+		},
+
+		update() {
+			const now = context.time
+			for (let i = later.length - 1; i >= 0; i--) {
+				if (later[i].at > now) continue
+				const [due] = later.splice(i, 1)
+				due.run()
+			}
+			for (let i = burning.length - 1; i >= 0; i--) {
+				if (burning[i].until > now) continue
+				sparks.release(burning[i].stream)
+				burning.splice(i, 1)
+			}
+		},
+
+		dispose() {
+			sparks.dispose()
+		}
+	}
+}