@v12-engine/create 0.1.0 → 0.4.0

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

@@ -0,0 +1,377 @@
+/**
+ * The MOBA examples on the rules' side: heroes with levels, skill points and callings (`heroesPack`), skillshots and
+ * the hero spells, a lane of minions and towers (`lanesPack`), last hits and denies (`lastHitsPack`), a shop of the
+ * engine's items (`defaultItemSet`), kill streaks and buyback, camps of the jungle, heroes that come back after they fall
+ * (`respawnPack`). Their units are `./units.ts`, their maps `./maps.ts`
+ */
+import {
+	applyBuff,
+	bool,
+	buy,
+	buyBack,
+	defaultItemAbilities,
+	defaultItemBuffs,
+	defaultItems,
+	defaultItemsPack,
+	defaultItemUnits,
+	defineCommand,
+	type Entity,
+	type Game,
+	type GamePack,
+	grantAbility,
+	grantXp,
+	heroesPack,
+	heroOf,
+	heroState,
+	heroTally,
+	laneMinion,
+	lanesOf,
+	lanesPack,
+	type LanesOptions,
+	lastHitsOf,
+	lastHitsPack,
+	learn,
+	mobaStatsPack,
+	number,
+	optional,
+	respawnIn,
+	respawnPack,
+	sendWave,
+	setHeroLevel,
+	slotsOf,
+	string,
+	type Vec2,
+	type World,
+	exactMath
+} from '@v12-engine/engine'
+import { nearestEnemy, packOnce, put, starts } from '../abilities/kit'
+import type { ExampleCategory, ExampleDef } from '../define'
+import { BLUE, jungleMap, laneMap, mobaField, RED, TOWERS } from './maps'
+import { SPELL_IDS } from './spells'
+import { abilities, allAbilities, allBuffs, units } from './units'
+
+// ---- heroes
+
+/**
+ * Puts down a hero of `type`, raised to `level` with its points spent: the ultimate first where it may, then its
+ * other abilities in turn, as a player levels a hero
+ */
+export function putHero(world: World, type: string, owner: number, at: Vec2, level: number, name?: string): Entity {
+	const hero = put(world, type, owner, at, name, owner === BLUE ? Math.PI / 2 : -Math.PI / 2)
+	if (level > 1) setHeroLevel(world, hero, level)
+	const order = [abilities[3], abilities[0], abilities[1], abilities[2]].map((each) => each.id)
+	for (let spent = true; spent && (heroOf(hero)?.points ?? 0) > 0;) {
+		spent = false
+		for (const id of order) if ((heroOf(hero)?.points ?? 0) > 0 && learn(world, hero, id)) spent = true
+	}
+	return hero
+}
+
+/** The player's hero: the one named `hero`, alive or fallen (a fallen one is out of the world, waiting to come back) */
+function heroOfPlayer(world: World, player: number): Entity | undefined {
+	const named = world.named('hero')
+	if (named && named.owner === player) return named
+	for (const entity of world.index.with(heroState, player)) if (entity.def.id.startsWith('moba')) return entity
+	return undefined
+}
+
+/** Gives a player gold */
+function giveGold(world: World, player: number, amount: number): void {
+	const purse = world.player(player).resources
+	purse.gold = (purse.gold ?? 0) + amount
+}
+
+// ---- the lane
+
+/** The lane's waves: three minions that close in and two casters, the first a few seconds in */
+const laneOptions: LanesOptions = {
+	firstWave: 4,
+	every: 20,
+	minions: { melee: 'mobaMinion', ranged: 'mobaCasterMinion' },
+	wave: () => ['mobaMinion', 'mobaMinion', 'mobaMinion', 'mobaCasterMinion', 'mobaCasterMinion'],
+	// the game's own way of winning (none: an example plays until it is left)
+	cores: false,
+	towers: (_world, entity) => entity.def.id === 'mobaTower'
+}
+
+/** A minion of a lane, of this game's lanes */
+const isMinion = (_world: World, entity: Entity) => entity.has(laneMinion)
+
+// ---- commands the cards send
+
+/** Strafers walk side to side, or stand still */
+export const strafe = defineCommand('moba.strafe', { on: bool }, (world, _player, { on }) => {
+	for (const unit of world.units.values()) {
+		if (!unit.alive || unit.def.id !== 'mobaStrafer') continue
+		if (on) unit.order('patrol', { x: unit.pos.x, z: unit.pos.z < 22 ? unit.pos.z + 6 : unit.pos.z - 6 })
+		else unit.order('hold')
+	}
+})
+
+/** Experience for the player's hero: as much as `amount`, or the rest of the way to its next level (`levels`) */
+export const experience = defineCommand('moba.xp', { amount: optional(number), levels: optional(number) }, (world, player, { amount, levels }) => {
+	const hero = heroOfPlayer(world, player)
+	const state = hero && heroOf(hero)
+	if (!hero || !state) return
+	if (levels) setHeroLevel(world, hero, Math.min(state.level + levels, 18))
+	else grantXp(world, hero, amount ?? 100)
+})
+
+/** The player's hero learns an ability, spending a point (`learn`): refused as a player's would be */
+export const learnIt = defineCommand('moba.learn', { ability: string }, (world, player, { ability }) => {
+	const hero = heroOfPlayer(world, player)
+	if (hero && !learn(world, hero, ability)) world.message(player, 'cannotDoThat')
+})
+
+/** Gold for the player */
+export const gold = defineCommand('moba.gold', { amount: number }, (world, player, { amount }) => giveGold(world, player, Math.min(amount, 10000)))
+
+/** The player's hero buys an item at the shop named `shop`, as the shop window would (`buy`) */
+export const buyItem = defineCommand('moba.buy', { item: string }, (world, player, { item }) => {
+	const shop = world.named('shop')
+	const hero = heroOfPlayer(world, player)
+	if (shop && hero) buy(world, shop, item, player, hero)
+})
+
+/** The player's fallen hero bought back, there and then (`buyBack`) */
+export const buyback = defineCommand('moba.buyback', {}, (world, player) => {
+	const hero = heroOfPlayer(world, player)
+	if (hero) buyBack(world, hero)
+})
+
+/** Every hero of both sides goes for the other side, fighting what it meets */
+export const fight = defineCommand('moba.fight', {}, (world) => {
+	for (const unit of world.index.with(heroState)) {
+		if (!unit.alive) continue
+		const enemy = nearestEnemy(world, unit)
+		if (enemy) unit.order('attackMove', { x: enemy.pos.x, z: enemy.pos.z })
+	}
+})
+
+/** A wave from both ends of the lane now, besides those that come by themselves */
+export const wave = defineCommand('moba.wave', {}, (world) => {
+	for (const lane of lanesOf(world)) for (const end of lane.ends) if (end) sendWave(world, end.spawner.id, laneOptions)
+})
+
+/**
+ * The player's hero strikes the weakest minion near it: an enemy's to last-hit it, or (`deny`) one of its own side's
+ * that is below half its health, to deny it
+ */
+export const strike = defineCommand('moba.strike', { deny: bool }, (world, player, { deny }) => {
+	const hero = heroOfPlayer(world, player)
+	if (!hero?.alive) return
+	let best: Entity | undefined
+	for (const unit of world.spatial.query(hero.pos.x, hero.pos.z, 9)) {
+		if (!unit.alive || !unit.has(laneMinion)) continue
+		const ours = !world.areEnemies(player, unit.owner)
+		if (ours !== deny || (deny && unit.health >= unit.maxHealth * 0.5)) continue
+		if (!best || unit.health < best.health) best = unit
+	}
+	if (best) hero.order('attack', best)
+})
+
+/** The player's hero attacks the nearest unit of a type */
+export const attack = defineCommand('moba.attack', { unit: string }, (world, player, { unit: type }) => {
+	const hero = heroOfPlayer(world, player)
+	if (!hero?.alive) return
+	let best: Entity | undefined
+	for (const unit of world.units.values())
+		if (
+			unit.alive &&
+			unit.def.id === type &&
+			(!best || exactMath.hypot(unit.pos.x - hero.pos.x, unit.pos.z - hero.pos.z) < exactMath.hypot(best.pos.x - hero.pos.x, best.pos.z - hero.pos.z))
+		)
+			best = unit
+	if (best) hero.order('attack', best)
+})
+
+/** Hurts or stuns the player's own hero, for a hero spell that answers it (Second Wind, Barrier, Purify) */
+export const trouble = defineCommand('moba.trouble', { stun: bool }, (world, player, { stun }) => {
+	const hero = heroOfPlayer(world, player)
+	if (!hero?.alive) return
+	if (stun) applyBuff(world, hero, 'mobaHeld', 2.5)
+	else world.damage(hero, hero.health * 0.6, undefined, { damageType: 'true' })
+})
+
+const commands = [attack, strafe, experience, learnIt, gold, buyItem, buyback, fight, wave, strike, trouble]
+
+/** What the HUD reads of the player: last hits and denies, and its hero's level, points, tally and wait to come back */
+const report: GamePack = {
+	id: 'moba.report',
+	report(world, player) {
+		const hero = heroOfPlayer(world, player)
+		const state = hero && heroOf(hero)
+		const tally = hero?.get(heroTally)
+		return {
+			...lastHitsOf(world, player),
+			mobaHero: state
+				? {
+						level: state.level,
+						xp: Math.floor(state.xp),
+						next: world.settings.heroes.xpForLevel(state.level + 1),
+						points: state.points,
+						kills: tally?.kills ?? 0,
+						deaths: tally?.deaths ?? 0,
+						assists: tally?.assists ?? 0,
+						streak: tally?.streak ?? 0,
+						back: hero.alive ? 0 : Math.ceil(respawnIn(world, hero) ?? 0),
+						items: (slotsOf(hero) ?? []).flatMap((slot) =>
+							slot ? [world.registry.items.has(slot.item) ? world.registry.item(slot.item).name : slot.item] : []
+						)
+					}
+				: undefined
+		}
+	}
+}
+
+// ---- the examples
+
+/** The examples' starts by id, kept for their Start again button (`starts`) */
+function example(def: ExampleDef): ExampleDef {
+	if (def.start) starts[def.id] = def.start as (world: World) => void
+	return def
+}
+
+const SOURCE = ['examples/moba/index.ts', 'examples/moba/units.ts', 'examples/moba/maps.ts']
+
+export const examples: ExampleDef[] = [
+	example({
+		id: 'moba-skillshots',
+		category: 'moba',
+		title: 'Skillshots and a locked camera',
+		summary:
+			'Aimed abilities that hit the first enemy in their way: a bolt, a chain that drags back, a dash, a lance. The duelists step side to side, so aim ahead of them; the camera can be locked on the hero.',
+		tags: ['skillshot', 'hook', 'dash', 'direction', 'camera', 'quick cast', 'league'],
+		source: SOURCE,
+		map: () => mobaField({ name: 'Skillshots', width: 48, depth: 40, blue: { x: 8, z: 20 }, red: { x: 40, z: 20 } }),
+		start: (world) => {
+			putHero(world, 'mobaStormcaller', BLUE, { x: 16, z: 20 }, 6, 'hero')
+			const duelists: Vec2[] = [
+				{ x: 27, z: 15 },
+				{ x: 30, z: 22 },
+				{ x: 26, z: 26 }
+			]
+			duelists.forEach((at, i) =>
+				put(world, 'mobaStrafer', RED, at, `enemy${i + 1}`, -Math.PI / 2).order('patrol', { x: at.x, z: at.z + (i % 2 ? -5 : 5) })
+			)
+		}
+	}),
+	example({
+		id: 'moba-spells',
+		category: 'moba',
+		title: 'Hero spells: Flash and the rest',
+		summary:
+			"The engine's nine hero spells, two of them on D and F: Flash, Barrier, Second Wind, Brand, Wither, Phantom Stride, Purify, Waystone and Reap. Each button casts one; hurt or stun the hero first to see what answers it.",
+		tags: ['flash', 'barrier', 'ignite', 'exhaust', 'ghost', 'cleanse', 'teleport', 'smite', 'summoner spells', 'D', 'F'],
+		source: [...SOURCE, 'examples/moba/spells.ts'],
+		map: () => mobaField({ name: 'Hero spells', width: 48, depth: 40, blue: { x: 8, z: 20 }, red: { x: 40, z: 20 } }),
+		start: (world) => {
+			const hero = putHero(world, 'mobaStormcaller', BLUE, { x: 18, z: 20 }, 6, 'hero')
+			// the other seven, besides its two: given for good (`grantAbility`)
+			for (const id of SPELL_IDS) grantAbility(world, hero, id, { level: 1 })
+			put(world, 'mobaDuskblade', RED, { x: 26, z: 21 }, 'rival', -Math.PI / 2)
+			// what Reap is for (no hero), and what Waystone goes to (an ally of the hero's far off)
+			put(world, 'mobaBrute', RED, { x: 25, z: 15 }, 'creep', -Math.PI / 2)
+			put(world, 'mobaMinion', BLUE, { x: 36, z: 31 }, 'waystone')
+		}
+	}),
+	example({
+		id: 'moba-lane',
+		category: 'moba',
+		title: 'A lane: waves, towers, last hits',
+		summary:
+			'Waves of minions walk the lane from both ends and fight; two towers a side guard it. Strike the blow that kills an enemy minion for its gold (a last hit), or kill one of your own below half health so the enemy gets less (a deny).',
+		tags: ['lane', 'minions', 'waves', 'towers', 'last hit', 'deny', 'creep score', 'farm'],
+		source: [...SOURCE, 'examples/moba/maps.ts'],
+		map: laneMap,
+		start: (world) => {
+			for (const at of TOWERS.blue) put(world, 'mobaTower', BLUE, at)
+			for (const at of TOWERS.red) put(world, 'mobaTower', RED, at)
+			putHero(world, 'mobaStormcaller', BLUE, { x: 30, z: 14 }, 3, 'hero')
+		}
+	}),
+	example({
+		id: 'moba-shop',
+		category: 'moba',
+		title: 'A shop and build paths',
+		summary:
+			"The engine's whole tree of items in a shop: starters, basics, what they build into, legendaries. Open the shop window (P, or click the shop), or buy a path from the card: the parts first, then the recipe that uses them up.",
+		tags: ['shop', 'items', 'recipe', 'build path', 'gold', 'inventory', 'default items'],
+		source: SOURCE,
+		map: () => mobaField({ name: 'Shop', width: 40, depth: 40, blue: { x: 20, z: 14 }, red: { x: 20, z: 36 }, gold: 4000 }),
+		start: (world) => {
+			put(world, 'mobaShop', BLUE, { x: 20.5, z: 22.5 }, 'shop')
+			putHero(world, 'mobaDuskblade', BLUE, { x: 20, z: 18 }, 1, 'hero')
+		}
+	}),
+	example({
+		id: 'moba-levels',
+		category: 'moba',
+		title: 'Levels, skill points and callings',
+		summary:
+			'A hero gains experience, levels up and gets a point a level to learn an ability with: Q, W and E from level 1, the ultimate R from level 6. Its callings (Arcanist, Binder) are on its panel; learn with the + on it, or the card.',
+		tags: ['hero', 'level', 'experience', 'skill points', 'ultimate', 'callings', 'roles'],
+		source: SOURCE,
+		map: () => mobaField({ name: 'Levels', width: 40, depth: 40, blue: { x: 14, z: 20 }, red: { x: 32, z: 20 } }),
+		start: (world) => {
+			put(world, 'mobaStormcaller', BLUE, { x: 18, z: 20 }, 'hero', Math.PI / 2)
+			for (let i = 0; i < 3; i++) put(world, 'mobaMinion', RED, { x: 24, z: 17 + i * 3 }, undefined, -Math.PI / 2).order('hold')
+		}
+	}),
+	example({
+		id: 'moba-teamfight',
+		category: 'moba',
+		title: 'Kill streaks, assists and buyback',
+		summary:
+			'Two heroes a side. A hero that kills is on a streak until it falls, a kill helped is an assist, a fallen hero comes back after a while, or at once for gold (buyback). Fight sends them at each other.',
+		tags: ['kills', 'deaths', 'assists', 'streak', 'shutdown', 'buyback', 'respawn', 'KDA'],
+		source: SOURCE,
+		map: () => mobaField({ name: 'Teamfight', width: 48, depth: 32, blue: { x: 6, z: 16 }, red: { x: 42, z: 16 }, gold: 1500 }),
+		start: (world) => {
+			putHero(world, 'mobaStormcaller', BLUE, { x: 18, z: 14 }, 8, 'hero')
+			putHero(world, 'mobaDuskblade', BLUE, { x: 19, z: 18 }, 8)
+			putHero(world, 'mobaDuskblade', RED, { x: 30, z: 14 }, 5)
+			putHero(world, 'mobaStormcaller', RED, { x: 31, z: 18 }, 5)
+		}
+	}),
+	example({
+		id: 'moba-jungle',
+		category: 'moba',
+		title: 'Camps of the jungle',
+		summary:
+			'Creeps of the jungle keep to their camp: they turn on whoever strikes one, chase a while and walk back. Cleared, a camp comes back 20 or 30 seconds later. Reap (F) finishes a creep off with true damage.',
+		tags: ['jungle', 'camps', 'creeps', 'neutral', 'respawn', 'smite', 'reap', 'leash'],
+		source: [...SOURCE, 'examples/moba/maps.ts'],
+		map: jungleMap,
+		start: (world) => {
+			const hero = putHero(world, 'mobaDuskblade', BLUE, { x: 18, z: 16 }, 6, 'hero')
+			grantAbility(world, hero, 'mobaReap', { level: 1 })
+		}
+	})
+]
+
+export const category: ExampleCategory = {
+	rules: (game: Game<any>) => {
+		// the gold a shop sells for and a kill pays: none to start with, so it shows nothing in the other examples
+		if (!(game.toRules().resources ?? []).some((each) => each.id === 'gold')) game.resource({ id: 'gold', name: 'Gold', start: 0 })
+		packOnce(game, heroesPack())
+		packOnce(game, mobaStatsPack())
+		packOnce(game, defaultItemsPack())
+		packOnce(game, lanesPack(laneOptions))
+		// last hits and denies of lane minions alone
+		packOnce(game, lastHitsPack({ deny: { below: 0.5, denies: (world, _attacker, target) => isMinion(world, target) }, counts: isMinion }))
+		// the MOBA's heroes come back by themselves, 6 seconds after they fall; another example's hero is left as it was
+		packOnce(game, respawnPack({ time: () => 6, heroes: (_world, hero) => hero.def.id.startsWith('moba') }))
+		packOnce(game, report)
+		// the engine's items, with what they use: their abilities, buffs and units (a ward, a wolf)
+		for (const item of defaultItems) game.item(item)
+		for (const ability of defaultItemAbilities) game.ability(ability)
+		for (const buff of defaultItemBuffs) game.buff(buff)
+		for (const unit of defaultItemUnits) game.unit(unit)
+		for (const unit of units) game.unit(unit)
+		for (const ability of allAbilities) game.ability(ability)
+		for (const buff of allBuffs) game.buff(buff)
+		for (const command of commands) game.command(command)
+	},
+	examples
+}