@v12-engine/create 0.1.1 → 0.4.0

package/starters/examples/src/examples/moba/looks.ts

@@ -0,0 +1,349 @@
+/**
+ * The MOBA examples on the client's side: how their heroes, minions, towers and creeps look, their abilities' and hero
+ * spells' looks, and each example's card. Each example takes the HUD's half of the heroes (`heroesViewPack`: the hero's
+ * panel, its spells on D and F, the shop window) in its own look, so the other examples keep theirs
+ */
+import { type GameClientApi, type GameView, heroesViewPack, type UnitLook } from '@v12-engine/client'
+import { button, type CategoryLooks, type ExampleControl, type ExampleLook, readout, toggle } from '../../shell/look'
+import { character, hold, ONE_HANDED, person, sharedLooks, TWO_HANDED } from '../common/looks'
+import { castButton, look, readyOn, resetButton, withLooks } from '../abilities/lookKit'
+import { attack, buyback, buyItem, experience, fight, gold, learnIt, strafe, strike, trouble, wave } from './index'
+import { HERO_SPELLS } from './spells'
+import { abilities } from './units'
+
+const units: Record<string, UnitLook> = {
+	mobaStormcaller: {
+		height: 2,
+		model: character('mage', 0.8, { hold: [hold('staff')] }),
+		shot: { color: [0.55, 0.7, 1], size: 0.32 },
+		shapes: person(2)
+	},
+	mobaDuskblade: {
+		height: 2.2,
+		model: character('rogue', 0.85, { hold: [hold('dagger'), hold('dagger', 'l')] }),
+		attacks: [ONE_HANDED],
+		shapes: person(2.2)
+	},
+	mobaMinion: {
+		height: 1.4,
+		model: character('knight', 0.55, { hold: [hold('sword_1handed'), hold('shield_round', 'l')] }),
+		attacks: [ONE_HANDED],
+		shapes: person(1.4)
+	},
+	mobaCasterMinion: {
+		height: 1.4,
+		model: character('mage', 0.55, { hold: [hold('wand')] }),
+		shot: { color: [0.6, 0.5, 1], size: 0.22 },
+		shapes: person(1.4)
+	},
+	mobaStrafer: { ...sharedLooks.knight, attacks: [TWO_HANDED] },
+	mobaTower: {
+		height: 5.6,
+		model: { src: 'rts/watch_tower.glb', scale: 1.28, points: { launch: { offset: [0, 4.6, 0] } } },
+		shot: { color: [1, 0.85, 0.4], size: 0.45 },
+		shapes: [
+			{ shape: 'cylinder', size: [1.1, 4.4, 1.1], offset: [0, 2.2, 0], color: [0.62, 0.62, 0.68] },
+			{ shape: 'cylinder', size: [1.6, 0.5, 1.6], offset: [0, 4.6, 0], color: 'team' }
+		]
+	},
+	mobaShop: {
+		height: 2,
+		model: { src: 'rts/market_stalls.glb', scale: 0.66 },
+		shapes: [{ shape: 'box', size: [3, 1.6, 3], offset: [0, 0.8, 0], color: [0.55, 0.38, 0.22] }]
+	},
+	// the jungle's creeps: the dead of old battles
+	mobaRaider: {
+		height: 1.6,
+		model: character('skeleton_minion', 0.7, { hold: [{ src: 'skeleton-gear/blade.glb', at: 'handslot.r' }] }),
+		attacks: [ONE_HANDED],
+		shapes: person(1.6, [0.85, 0.82, 0.72])
+	},
+	mobaBrute: {
+		height: 3,
+		model: character('skeleton_warrior', 1.3, {
+			hold: [
+				{ src: 'skeleton-gear/axe.glb', at: 'handslot.r' },
+				{ src: 'skeleton-gear/shield_large_a.glb', at: 'handslot.l' }
+			]
+		}),
+		attacks: [ONE_HANDED],
+		shapes: person(3, [0.85, 0.82, 0.72])
+	},
+	// what the engine's items bring: the Sight Ward's ward, a standing torch of the dungeon kit's, its parts showing
+	// while it loads; and the Wolfhide Charm's wolf, of parts in a ghostly blue, the shared art having no animals
+	ward: {
+		height: 1.1,
+		blood: false,
+		model: { src: 'dungeon-kit/torch.glb', scale: 0.8, raise: 0.55 },
+		shapes: [
+			{ shape: 'cylinder', size: [0.12, 1, 0.12], offset: [0, 0.5, 0], color: [0.35, 0.25, 0.15] },
+			{ shape: 'sphere', size: [0.35, 0.35, 0.35], offset: [0, 1, 0], color: [1, 0.85, 0.3] }
+		]
+	},
+	spiritWolf: {
+		height: 1.1,
+		blood: false,
+		shapes: [
+			{ shape: 'sphere', size: [0.65, 0.6, 1.3], offset: [0, 0.65, 0], color: [0.6, 0.8, 1] },
+			{ shape: 'sphere', size: [0.42, 0.42, 0.5], offset: [0, 0.9, 0.7], color: [0.65, 0.85, 1] },
+			{ shape: 'cone', size: [0.2, 0.35, 0.2], offset: [0, 0.9, 1.05], color: [0.55, 0.75, 0.95], tilt: Math.PI / 2 },
+			{ shape: 'cone', size: [0.2, 0.6, 0.2], offset: [0, 0.75, -0.8], color: [0.55, 0.75, 0.95], tilt: -Math.PI / 2 }
+		]
+	}
+}
+
+/** The abilities' and hero spells' looks (and their buffs', where a buff has the id of its spell) */
+const abilityLooks = {
+	mobaArcaneBolt: look([0.55, 0.65, 1], 'missile', { options: { shape: 'ball' } }),
+	mobaChain: look([0.75, 0.8, 0.85], 'missile', { options: { shape: 'arrow' } }),
+	mobaShadowStep: look([0.55, 0.3, 0.9], 'slam'),
+	mobaStarLance: look([1, 0.9, 0.5], 'missile', { options: { shape: 'bird' } }),
+	mobaHeld: look([0.75, 0.8, 0.85], undefined, { aura: 'glow' }),
+	mobaFlash: look([1, 0.95, 0.6], 'burst'),
+	mobaSecondWind: look([0.45, 1, 0.5], 'sonar'),
+	mobaHealHaste: look([0.45, 1, 0.5], undefined, { aura: 'glow' }),
+	mobaBarrier: look([1, 0.85, 0.35], 'burst', { aura: 'glow', options: { bubble: true } }),
+	mobaBrand: look([1, 0.4, 0.1], 'burst', { aura: 'glow' }),
+	mobaWither: look([0.55, 0.45, 0.75], 'tether'),
+	mobaWithered: look([0.55, 0.45, 0.75], undefined, { aura: 'glow' }),
+	mobaPhantomStride: look([0.6, 0.9, 1], 'burst', { aura: 'glow' }),
+	mobaPurify: look([0.9, 1, 1], 'burst'),
+	mobaPurified: look([0.9, 1, 1], undefined, { aura: 'glow' }),
+	mobaWaystone: look([0.4, 0.75, 1], 'mark'),
+	mobaReap: look([1, 0.75, 0.25], 'smash')
+}
+
+/** The game's look with the heroes' HUD, the keys of a hero's abilities, spells and the shop, and the last hits shown */
+const heroHud = (view: GameView<any>): GameView<any> => ({
+	...view,
+	packs: [...(view.packs ?? []), heroesViewPack()],
+	input: { ...view.input, keys: { ...view.input?.keys, abilities: ['Q', 'W', 'E', 'R'], spells: ['D', 'F'], shop: 'P' } }
+})
+
+/** The player's hero, as the snapshot has it */
+const heroOn = (client: GameClientApi) => {
+	const named = ['mobaStormcaller', 'mobaDuskblade']
+	return client.session.snapshot().entities.find((each) => named.includes(each.type) && each.owner === client.session.playerId)
+}
+
+/** What the rules report of the player's hero (`moba.report`) */
+type HeroReport = {
+	level: number
+	xp: number
+	next: number
+	points: number
+	kills: number
+	deaths: number
+	assists: number
+	streak: number
+	back: number
+	items: string[]
+}
+const report = (client: GameClientApi) => (client.session.snapshot().report ?? {}) as { lastHits?: number; denies?: number; mobaHero?: HeroReport }
+
+/** The camera on the hero wherever it goes, as a MOBA's camera lock (Y in League), or free */
+const cameraLock = (on = false): ExampleControl =>
+	toggle(
+		'Camera locked on the hero',
+		on,
+		(client, locked) => {
+			const hero = heroOn(client)
+			client.follow(locked && hero ? hero.id : null, { smoothing: 0.15 })
+		},
+		'As a MOBA has it: the view follows the hero, the edges of the screen do not move it'
+	)
+
+/** Selects the player's hero and frames the box, as every example here starts */
+const readyHero =
+	(box: Parameters<typeof readyOn>[2], follow = false) =>
+	(client: GameClientApi) => {
+		readyOn(client, undefined, box)
+		const hero = heroOn(client)
+		if (hero) client.controller.select([hero.id])
+		if (follow && hero) client.follow(hero.id, { smoothing: 0.15 })
+	}
+
+const spells = HERO_SPELLS.abilities
+
+const looks: Record<string, ExampleLook> = {
+	'moba-skillshots': {
+		view: heroHud,
+		ready: readyHero({ minX: 12, minZ: 10, maxX: 34, maxZ: 30 }),
+		controls: [
+			...abilities.map((ability) => castButton(ability, { by: 'hero' })),
+			toggle(
+				'Duelists step aside',
+				true,
+				(client, on) => client.session.send(strafe.make({ on })),
+				'They walk side to side, or stand still to be hit'
+			),
+			cameraLock(),
+			toggle(
+				'Quick cast',
+				false,
+				(client, on) => client.controller.setQuickCast(on),
+				'A key casts at once where the pointer is, without a click to aim: as most MOBA players play'
+			),
+			resetButton('moba-skillshots')
+		]
+	},
+	'moba-spells': {
+		view: heroHud,
+		ready: readyHero({ minX: 12, minZ: 10, maxX: 38, maxZ: 32 }),
+		controls: [
+			button('Hurt the hero', (client) => client.session.send(trouble.make({ stun: false })), 'Takes most of its health, for Second Wind or Barrier'),
+			button('Stun the hero', (client) => client.session.send(trouble.make({ stun: true })), 'Holds it for 2.5 seconds, for Purify'),
+			...spells.map((spell) =>
+				castButton(spell, {
+					by: 'hero',
+					...(spell.id === 'mobaWaystone' && { at: 'waystone' }),
+					...(spell.id === 'mobaReap' && { at: 'creep' }),
+					...((spell.id === 'mobaBrand' || spell.id === 'mobaWither') && { at: 'rival' })
+				})
+			),
+			resetButton('moba-spells')
+		]
+	},
+	'moba-lane': {
+		view: (view) => {
+			const own = heroHud(view)
+			return {
+				...own,
+				hud: {
+					...own.hud,
+					status: (state) => [
+						...(own.hud?.status?.(state) ?? []),
+						{ text: `Last hits ${Number(state.lastHits ?? 0)} · Denies ${Number(state.denies ?? 0)}`, title: 'Minions you gave the killing blow to' }
+					]
+				}
+			}
+		},
+		ready: readyHero({ minX: 10, minZ: 2, maxX: 62, maxZ: 26 }),
+		controls: [
+			button(
+				'Last-hit the weakest',
+				(client) => client.session.send(strike.make({ deny: false })),
+				"The hero strikes the enemy minion nearest death: the gold is the killing blow's"
+			),
+			button(
+				'Deny the weakest',
+				(client) => client.session.send(strike.make({ deny: true })),
+				'The hero strikes one of its own below half health: the enemy gets less for it'
+			),
+			button('A wave now', (client) => client.session.send(wave.make({})), 'Both ends send a wave at once, besides the one every 20 seconds'),
+			cameraLock(),
+			readout(
+				'Last hits · denies',
+				(client) => `${report(client).lastHits ?? 0} · ${report(client).denies ?? 0}`,
+				'Minions your hero dealt the killing blow to: enemy ones (last hits, which pay gold) and its own (denies)'
+			),
+			readout('Gold', (client) =>
+				String(Math.floor(client.session.snapshot().players?.find((each) => each.id === client.session.playerId)?.own?.resources.gold ?? 0))
+			),
+			resetButton('moba-lane')
+		]
+	},
+	'moba-shop': {
+		view: heroHud,
+		ready: readyHero({ minX: 12, minZ: 12, maxX: 30, maxZ: 28 }),
+		controls: [
+			button(
+				'Iron Sword',
+				(client) => client.session.send(buyItem.make({ item: 'ironSword' })),
+				'A basic: one of the two a Hunter’s Knife is built from'
+			),
+			button(
+				'Hunter’s Knife',
+				(client) => client.session.send(buyItem.make({ item: 'huntersKnife' })),
+				'The recipe: costs what it does less the swords carried, which it uses up'
+			),
+			button(
+				'Boots',
+				(client) => client.session.send(buyItem.make({ item: 'boots' })),
+				'A basic item, +25 move speed: one of the two Greaves of Haste are built from'
+			),
+			button(
+				'Greaves of Haste',
+				(client) => client.session.send(buyItem.make({ item: 'greavesOfHaste' })),
+				'Boots built into more (+45 move speed, attacks faster): with Boots carried it costs that much less'
+			),
+			button('Healing Draught', (client) => client.session.send(buyItem.make({ item: 'healingDraught' })), 'A consumable: drink it, it is gone'),
+			button('1000 gold', (client) => client.session.send(gold.make({ amount: 1000 })), 'Gives you 1000 gold to buy with'),
+			readout('Carried', (client) => report(client).mobaHero?.items.join(', ') || 'nothing', 'The items your hero carries now'),
+			readout('Gold', (client) =>
+				String(Math.floor(client.session.snapshot().players?.find((each) => each.id === client.session.playerId)?.own?.resources.gold ?? 0))
+			),
+			resetButton('moba-shop')
+		]
+	},
+	'moba-levels': {
+		view: heroHud,
+		ready: readyHero({ minX: 12, minZ: 12, maxX: 28, maxZ: 28 }),
+		controls: [
+			button('Gain 150 experience', (client) => client.session.send(experience.make({ amount: 150 })), 'What killing a few minions near it brings'),
+			button('Up a level', (client) => client.session.send(experience.make({ levels: 1 })), 'Straight to the next level, with its point'),
+			...abilities.map((ability) =>
+				button(
+					`Learn ${ability.name} (${ability.hotkey})`,
+					(client) => client.session.send(learnIt.make({ ability: ability.id })),
+					ability.ultimate ? 'The ultimate: from level 6' : 'Spends a point'
+				)
+			),
+			readout('Level · experience', (client) => {
+				const hero = report(client).mobaHero
+				return hero ? `${hero.level} · ${hero.xp} / ${hero.next}` : '—'
+			}),
+			readout('Points to spend', (client) => String(report(client).mobaHero?.points ?? 0)),
+			resetButton('moba-levels')
+		]
+	},
+	'moba-teamfight': {
+		view: heroHud,
+		ready: readyHero({ minX: 6, minZ: 4, maxX: 42, maxZ: 28 }),
+		controls: [
+			button('Fight', (client) => client.session.send(fight.make({})), 'Every hero goes for the nearest of the other side'),
+			button('Buy back', (client) => client.session.send(buyback.make({})), 'Your fallen hero back at once, at home, for gold'),
+			readout('Kills · deaths · assists', (client) => {
+				const hero = report(client).mobaHero
+				return hero ? `${hero.kills} · ${hero.deaths} · ${hero.assists}` : '—'
+			}),
+			readout(
+				'Streak',
+				(client) => String(report(client).mobaHero?.streak ?? 0),
+				'Kills in a row without dying: a hero on a streak is worth more to whoever ends it'
+			),
+			readout(
+				'Back in',
+				(client) => {
+					const back = report(client).mobaHero?.back ?? 0
+					return back > 0 ? `${back} s` : 'alive'
+				},
+				'Seconds until your fallen hero comes back at home by itself'
+			),
+			resetButton('moba-teamfight')
+		]
+	},
+	'moba-jungle': {
+		view: heroHud,
+		ready: readyHero({ minX: 10, minZ: 10, maxX: 36, maxZ: 32 }),
+		controls: [
+			button(
+				'Attack the raiders',
+				(client) => client.session.send(attack.make({ unit: 'mobaRaider' })),
+				'They answer together, chase a while, and walk back to their camp'
+			),
+			button('Attack the brute', (client) => client.session.send(attack.make({ unit: 'mobaBrute' })), 'A strong creep alone: Reap finishes it'),
+			castButton(
+				spells.find((each) => each.id === 'mobaReap')!,
+				{ by: 'hero', label: 'Reap the nearest creep' }
+			),
+			cameraLock(),
+			resetButton('moba-jungle')
+		]
+	}
+}
+
+export const category: CategoryLooks = {
+	looks,
+	view: (view: GameView<any>) => withLooks(view, units, abilityLooks)
+}

package/starters/examples/src/examples/moba/maps.ts

@@ -0,0 +1,69 @@
+/**
+ * The MOBA examples' maps, made in code: a field of two sides (blue, the player, and red), and on it one lane with a
+ * spawner at each end, or camps of creeps in a jungle. The engine alone
+ */
+import { createMap, type GameMap, LANE_SPAWNERS, type Vec2 } from '@v12-engine/engine'
+import { tiles } from '../define'
+
+/** The two sides: the player's (blue) and the one it plays against (red), as the shared units say them */
+export const BLUE = 1
+export const RED = 2
+
+/**
+ * A field of two sides, painted grass, each side a team of its own with gold to spend and a home (`home.<team>`, where
+ * a hero comes back after it falls)
+ */
+export function mobaField(options: { name: string; width: number; depth: number; blue: Vec2; red: Vec2; gold?: number }): GameMap {
+	const { name, width, depth, blue, red, gold = 0 } = options
+	const map = createMap({ name, width, depth, players: 2, game: 'examples', tileset: tiles.map((each) => each.id) })
+	map.tiles.fill(map.tileset.indexOf('grass') + 1)
+	const sides = [
+		{ at: blue, name: 'Blue', color: [0.2, 0.45, 0.95] as [number, number, number] },
+		{ at: red, name: 'Red', color: [0.9, 0.2, 0.18] as [number, number, number] }
+	]
+	sides.forEach((side, i) => {
+		map.players[i] = { ...map.players[i], name: side.name, team: i + 1, color: side.color, start: side.at, resources: { gold } }
+		map.points.push({ id: 900 + i, name: `home.${i + 1}`, x: side.at.x, z: side.at.z, facing: 0 })
+	})
+	return map
+}
+
+/** The lane: west (blue) to east (red), along the middle of a long field */
+export const LANE = { width: 72, depth: 28, from: { x: 5, z: 14 }, to: { x: 67, z: 14 } }
+
+/** Where the lane's towers stand, a side's first: two a side, beside the lane, the outer one nearer the middle */
+export const TOWERS = {
+	blue: [
+		{ x: 16.5, z: 16.5 },
+		{ x: 27.5, z: 11.5 }
+	],
+	red: [
+		{ x: 55.5, z: 11.5 },
+		{ x: 44.5, z: 16.5 }
+	]
+}
+
+/**
+ * One lane between the two sides: a path painted as a road, a spawner at each end (`LANE_SPAWNERS`: whose waves, which
+ * lane), and the heroes' homes behind the spawners
+ */
+export function laneMap(): GameMap {
+	const map = mobaField({ name: 'One lane', width: LANE.width, depth: LANE.depth, blue: { x: 3, z: 14 }, red: { x: 69, z: 14 }, gold: 500 })
+	const lane = 100
+	map.paths.push({ id: lane, name: 'mid', points: [LANE.from, { x: 36, z: 14 }, LANE.to], width: 4, paint: 'road' })
+	map.data[LANE_SPAWNERS] = [
+		{ id: 200, x: LANE.from.x, z: LANE.from.z, data: { player: BLUE, lane } },
+		{ id: 201, x: LANE.to.x, z: LANE.to.z, data: { player: RED, lane } }
+	]
+	return map
+}
+
+/** A jungle between two lanes' worth of field: camps of creeps that come back a while after they are cleared */
+export function jungleMap(): GameMap {
+	const map = mobaField({ name: 'Jungle', width: 48, depth: 48, blue: { x: 6, z: 6 }, red: { x: 42, z: 42 }, gold: 500 })
+	map.camps.push(
+		{ id: 400, x: 18, z: 24, units: ['mobaRaider', 'mobaRaider', 'mobaRaider'], name: 'Raiders', respawn: 20 },
+		{ id: 401, x: 30, z: 20, units: ['mobaBrute'], name: 'Brute', respawn: 30 }
+	)
+	return map
+}

package/starters/examples/src/examples/moba/spells.ts

@@ -0,0 +1,34 @@
+/**
+ * The engine's nine hero spells (`defaultHeroSpells`: Flash, Second Wind, Barrier, Brand, Wither, Phantom Stride,
+ * Purify, Waystone, Reap) and their buffs, under ids of the MOBA examples' own (`flash` is `mobaFlash`): the game is one
+ * for every example, and their plain ids are words another example could use
+ */
+import { type AbilityDef, type BuffDef, defaultHeroSpellBuffs, defaultHeroSpells, type EffectDef } from '@v12-engine/engine'
+
+/** `flash` as `mobaFlash` */
+const own = (id: string) => `moba${id[0].toUpperCase()}${id.slice(1)}`
+
+/** An effect with the buffs it names (its own and its effects', at any depth) under their new ids */
+function renamed(effect: EffectDef): EffectDef {
+	const out: Record<string, unknown> = { ...effect }
+	if (typeof out.buff === 'string') out.buff = own(out.buff)
+	for (const key of ['effects', 'otherwise', 'onEnd', 'finished']) if (Array.isArray(out[key])) out[key] = (out[key] as EffectDef[]).map(renamed)
+	return out as unknown as EffectDef
+}
+
+/** The hero spells and their buffs, renamed: a new list each time, as the engine's are */
+function heroSpells(): { abilities: AbilityDef[]; buffs: BuffDef[] } {
+	const abilities = defaultHeroSpells().map((spell) => ({
+		...spell,
+		id: own(spell.id),
+		effects: spell.effects.map(renamed),
+		...(spell.channel && { channel: { ...spell.channel, ...(spell.channel.finished && { finished: spell.channel.finished.map(renamed) }) } })
+	}))
+	const buffs = defaultHeroSpellBuffs().map((buff) => ({ ...buff, id: own(buff.id) }))
+	return { abilities, buffs }
+}
+
+export const HERO_SPELLS = heroSpells()
+
+/** The spells' ids, in the engine's order */
+export const SPELL_IDS = HERO_SPELLS.abilities.map((each) => each.id)

package/starters/examples/src/examples/moba/units.ts

@@ -0,0 +1,196 @@
+/**
+ * The MOBA examples' units and abilities: two heroes (a caster of skillshots and a blade), lane minions, a tower, a
+ * shop, creeps of the jungle and a target that walks side to side. Data alone; how each looks is `./looks.ts`
+ */
+import { type AbilityDef, type BuffDef, defaultItems, itemTier, type UnitTypeDef } from '@v12-engine/engine'
+import { HERO_SPELLS } from './spells'
+
+/** The four abilities a hero learns, Q, W, E and R, the last its ultimate */
+export const abilities: AbilityDef[] = [
+	{
+		// a skillshot: flies where it was aimed, not at a unit, and stops at the first enemy it meets (`pierce: false`)
+		id: 'mobaArcaneBolt',
+		name: 'Arcane Bolt',
+		description: 'A bolt along the aim: {damage} to the first enemy it meets. It hits nothing that stepped aside',
+		hotkey: 'Q',
+		target: 'direction',
+		range: 11,
+		manaCost: 30,
+		cooldown: 1.2,
+		castTime: 0.15,
+		effects: [
+			{ type: 'missile', speed: 20, distance: 11, radius: 0.5, pierce: false, effects: [{ type: 'damage', amount: [90, 130, 170, 210, 250] }] }
+		],
+		maxLevel: 5
+	},
+	{
+		// a hook: the first enemy met is dragged back to the caster, held, and hurt as it arrives (a `when` chain)
+		id: 'mobaChain',
+		name: 'Grasping Chain',
+		description: 'A chain along the aim: the first enemy it meets is dragged back and held, and takes {damage} as it arrives',
+		hotkey: 'W',
+		target: 'direction',
+		range: 9,
+		manaCost: 60,
+		cooldown: 4,
+		castTime: 0.25,
+		effects: [
+			{ type: 'missile', speed: 26, distance: 9, radius: 0.6, pierce: false, returns: true },
+			{ type: 'pull', seconds: 0.5, when: 'hit' },
+			{ type: 'buff', buff: 'mobaHeld', when: 'hit' },
+			{ type: 'damage', amount: [80, 120, 160, 200, 240], when: 'arrived' }
+		],
+		maxLevel: 5
+	},
+	{
+		// a dash: rushes along the aim, no target needed, and keeps walking after
+		id: 'mobaShadowStep',
+		name: 'Shadow Step',
+		description: 'Rushes {distance} along the aim, through enemies, hurting each on the way',
+		hotkey: 'E',
+		target: 'direction',
+		range: 5,
+		manaCost: 40,
+		cooldown: 3,
+		effects: [{ type: 'dash', distance: 5, speed: 24, collide: [{ type: 'damage', amount: [60, 90, 120, 150, 180] }] }],
+		maxLevel: 5
+	},
+	{
+		// the ultimate: learned at level 6, a wide lance that goes through all
+		id: 'mobaStarLance',
+		name: 'Star Lance',
+		description: 'A wide lance of light through everything along the aim: {damage} to each',
+		hotkey: 'R',
+		target: 'direction',
+		range: 14,
+		manaCost: 100,
+		cooldown: 12,
+		castTime: 0.4,
+		ultimate: true,
+		effects: [{ type: 'missile', speed: 30, distance: 14, radius: 1.4, pierce: true, effects: [{ type: 'damage', amount: [300, 450, 600] }] }]
+	}
+]
+
+export const buffs: BuffDef[] = [{ id: 'mobaHeld', name: 'Held', harmful: true, duration: 0.8, stun: true }]
+
+/** What a hero learns: its four, Q W E R */
+const learns = abilities.map((each) => each.id)
+
+/** A hero's stats and what grows of them with each level */
+const hero = (callings: Record<string, 1 | 2 | 3>, spells = ['mobaFlash', 'mobaBarrier']): UnitTypeDef['hero'] => ({
+	learns,
+	spells,
+	callings,
+	growth: { stats: { health: 90, mana: 40, attackDamage: 4, armor: 3 } },
+	maxLevel: 18
+})
+
+export const units: UnitTypeDef[] = [
+	{
+		id: 'mobaStormcaller',
+		name: 'Stormcaller',
+		kind: 'unit',
+		radius: 0.45,
+		stats: { health: 620, healthRegen: 3, mana: 420, manaRegen: 8, attackDamage: 34, attackSpeed: 0.9, attackRange: 6, armor: 18, moveSpeed: 4.6 },
+		sight: 13,
+		attacks: [{ damagePoint: 0.4, acquisitionRange: 7, projectileSpeed: 22 }],
+		hero: hero({ arcanist: 3, binder: 2 }),
+		inventory: 6,
+		level: 1,
+		bounty: [250, 300]
+	},
+	{
+		id: 'mobaDuskblade',
+		name: 'Duskblade',
+		kind: 'unit',
+		radius: 0.5,
+		stats: { health: 760, healthRegen: 4, mana: 300, manaRegen: 6, attackDamage: 48, attackSpeed: 1, attackRange: 0.6, armor: 26, moveSpeed: 4.6 },
+		sight: 12,
+		attacks: [{ damagePoint: 0.35, acquisitionRange: 7 }],
+		hero: hero({ stalker: 3, reaver: 2 }, ['mobaFlash', 'mobaBrand']),
+		inventory: 6,
+		level: 1,
+		bounty: [250, 300]
+	},
+	{
+		id: 'mobaMinion',
+		name: 'Melee minion',
+		kind: 'unit',
+		radius: 0.4,
+		stats: { health: 420, attackDamage: 14, attackSpeed: 1.2, attackRange: 0.5, armor: 5, moveSpeed: 3.4 },
+		sight: 8,
+		attacks: [{ damagePoint: 0.4, acquisitionRange: 6 }],
+		cost: { gold: 80 },
+		bounty: [20, 22]
+	},
+	{
+		id: 'mobaCasterMinion',
+		name: 'Caster minion',
+		kind: 'unit',
+		radius: 0.4,
+		stats: { health: 280, attackDamage: 22, attackSpeed: 1.4, attackRange: 5.5, moveSpeed: 3.4 },
+		sight: 9,
+		attacks: [{ damagePoint: 0.5, acquisitionRange: 6, projectileSpeed: 18 }],
+		cost: { gold: 60 },
+		bounty: [14, 16]
+	},
+	{
+		// a lane's tower: strikes minions first, and the hero who hits one of its side's heroes (`lanesPack`)
+		id: 'mobaTower',
+		name: 'Tower',
+		kind: 'building',
+		radius: 1,
+		footprint: { w: 2, d: 2 },
+		stats: { health: 3000, attackDamage: 140, attackSpeed: 1.2, attackRange: 7.5, armor: 40 },
+		sight: 11,
+		attacks: [{ damagePoint: 0.2, acquisitionRange: 7.5, projectileSpeed: 24 }],
+		bounty: [250, 250]
+	},
+	{
+		// sells the engine's whole tree of items but its relics, to a hero within reach (`SHOP_RANGE`)
+		id: 'mobaShop',
+		name: 'Shop',
+		kind: 'building',
+		radius: 1.5,
+		footprint: { w: 3, d: 3 },
+		stats: { health: 2000, armor: 50 },
+		invulnerable: true,
+		sight: 8,
+		sells: defaultItems.filter((item) => itemTier(item) !== 'relic').map((item) => item.id)
+	},
+	{
+		id: 'mobaRaider',
+		name: 'Grave raider',
+		kind: 'unit',
+		radius: 0.45,
+		stats: { health: 480, attackDamage: 16, attackSpeed: 1.2, attackRange: 0.5, armor: 8, moveSpeed: 4.2 },
+		sight: 8,
+		attacks: [{ damagePoint: 0.35, acquisitionRange: 5 }],
+		level: 2,
+		bounty: [30, 36]
+	},
+	{
+		id: 'mobaBrute',
+		name: 'Ancient brute',
+		kind: 'unit',
+		radius: 0.8,
+		stats: { health: 1800, healthRegen: 4, attackDamage: 55, attackSpeed: 0.7, attackRange: 0.8, armor: 30, moveSpeed: 3 },
+		sight: 8,
+		attacks: [{ damagePoint: 0.5, acquisitionRange: 5 }],
+		level: 5,
+		bounty: [100, 120]
+	},
+	{
+		// what a skillshot is tried on: an enemy who walks side to side and never strikes back
+		id: 'mobaStrafer',
+		name: 'Dodging duelist',
+		kind: 'unit',
+		radius: 0.5,
+		stats: { health: 1400, healthRegen: 25, moveSpeed: 3.6, armor: 10 },
+		sight: 8
+	}
+]
+
+/** Every ability of the MOBA examples, the hero spells among them */
+export const allAbilities: AbilityDef[] = [...abilities, ...HERO_SPELLS.abilities]
+export const allBuffs: BuffDef[] = [...buffs, ...HERO_SPELLS.buffs]

package/starters/examples/src/examples/nature/camera.ts

@@ -0,0 +1,15 @@
+/** Where the camera stands in an example: the client's side of the nature and post-processing examples */
+import type { GameClientApi } from '@v12-engine/client'
+
+/**
+ * Puts the camera somewhere and keeps it there: the point looked at, how far back (cells), turned how far from
+ * looking north (degrees, clockwise) and looking down how steeply (degrees). The view rests at that turn, and keeps
+ * that steepness as the player zooms, steeper further out (`pitchCurve`, which the game's own would set again)
+ */
+export function stand(client: GameClientApi, at: { x: number; z: number }, distance: number, yaw: number, pitch: number): void {
+	const turn = (yaw * Math.PI) / 180
+	const { camera } = client
+	camera.restYaw = turn
+	camera.pitchCurve = (far) => Math.min(80, Math.max(15, pitch + (far - distance) * 0.7))
+	camera.setPose({ x: at.x, z: at.z, distance, yaw: turn, pitch: (pitch * Math.PI) / 180 })
+}