@v12-engine/create 0.1.1 → 0.4.0

package/starters/examples/src/examples/abilities/recasts.ts

@@ -0,0 +1,181 @@
+/**
+ * Recasts, charges, holds and channels: abilities used several times in a row, cast again for a second part, charged
+ * by stacks, made ready again, held down to charge (the holds pack), and kept up while aimed, while walking, or while
+ * the target stays near
+ */
+import type { AbilityDef, BuffDef } from '@v12-engine/engine'
+import { exampleField } from '../define'
+import type { Family } from './family'
+import { caster, lineUp } from './kit'
+
+const buffs: BuffDef[] = [
+	{ id: 'abilitiesSonicMark', name: 'Sonic Wave', description: 'Marked: the wave’s recast rushes here', harmful: true, duration: 3 },
+	// four stacks charge Point Blank
+	{ id: 'abilitiesFocus', name: 'Focus', description: 'At four, Point Blank is charged', maxStacks: 4 },
+	{ id: 'abilitiesDrawing', name: 'Drawing', description: 'Slowed while the bow is drawn', percent: { moveSpeed: -0.2 } }
+]
+
+const abilities: AbilityDef[] = [
+	{
+		// three dashes: the cast and two recasts within 10 seconds; the cooldown after the last
+		id: 'abilitiesSpiritRush',
+		name: 'Spirit Rush',
+		description: 'A dash, and two more within {window}: press it three times',
+		hotkey: 'Q',
+		target: 'point',
+		range: 6,
+		cooldown: 6,
+		recast: { window: 10, count: 2 },
+		effects: [{ type: 'dash', distance: 3, speed: 30 }]
+	},
+	{
+		// a recast that does something else: rushes to whoever the first cast marked
+		id: 'abilitiesSonicWave',
+		name: 'Sonic Wave',
+		description: 'A wave that marks the first enemy it hits; cast again within 3 seconds to rush to it',
+		hotkey: 'W',
+		target: 'direction',
+		range: 12,
+		cooldown: 5,
+		recast: {
+			window: 3,
+			mark: 'abilitiesSonicMark',
+			target: 'none',
+			effects: [{ type: 'dash', to: 'target', speed: 30, effects: [{ type: 'damage', amount: 100 }] }]
+		},
+		effects: [
+			{
+				type: 'missile',
+				speed: 30,
+				distance: 12,
+				pierce: false,
+				effects: [
+					{ type: 'damage', amount: 50 },
+					{ type: 'buff', buff: 'abilitiesSonicMark' }
+				]
+			}
+		]
+	},
+	{
+		// three uses held, one back every 6 seconds; the button shows how many are left
+		id: 'abilitiesRoll',
+		name: 'Roll',
+		description: 'A short roll: three held, one back every 6 seconds',
+		hotkey: 'E',
+		target: 'point',
+		range: 3,
+		cooldown: 0.4,
+		charges: { count: 3, refill: 6 },
+		effects: [{ type: 'dash', distance: 2.5, speed: 25 }]
+	},
+	{
+		// charged by stacks of Focus, one a spell (its passive part); charged, it hits much harder and spends them
+		id: 'abilitiesPointBlank',
+		name: 'Point Blank',
+		description: 'A cone of shot: 300 when charged by four casts of anything, 100 otherwise',
+		hotkey: 'R',
+		target: 'direction',
+		range: 6,
+		cooldown: 0.5,
+		charge: 'abilitiesFocus',
+		effects: [
+			{
+				type: 'charged',
+				effects: [{ type: 'damage', amount: 300, shape: 'cone', length: 7, angle: 1 }],
+				otherwise: [{ type: 'damage', amount: 100, shape: 'cone', length: 7, angle: 1 }]
+			}
+		],
+		passive: [{ type: 'onCast', effects: [{ type: 'buff', buff: 'abilitiesFocus', stack: true, on: 'caster' }] }]
+	},
+	{
+		// makes abilities ready again, charges and all
+		id: 'abilitiesReady',
+		name: 'Ready again',
+		description: 'Spirit Rush, Sonic Wave and Roll ready at once',
+		hotkey: 'T',
+		target: 'none',
+		effects: [
+			{ type: 'refresh', ability: 'abilitiesSpiritRush', on: 'caster' },
+			{ type: 'refresh', ability: 'abilitiesSonicWave', on: 'caster' },
+			{ type: 'refresh', ability: 'abilitiesRoll', on: 'caster' }
+		]
+	},
+	{
+		// held: the cast starts the draw, letting go fires it, farther and harder the longer it was held
+		id: 'abilitiesPiercingArrow',
+		name: 'Piercing Arrow',
+		description: 'Hold to draw (then Release): farther and half again as hard at full, fired by itself after 4 seconds',
+		hotkey: 'D',
+		target: 'direction',
+		cooldown: 1,
+		hold: { max: 1.5, upTo: 4, range: { from: 5, to: 13 }, scale: 1.5, buff: 'abilitiesDrawing' },
+		effects: [{ type: 'missile', speed: 40, distance: 20, toPoint: true, radius: 0.7, effects: [{ type: 'damage', amount: 100 }] }]
+	},
+	{
+		// a channel that follows the player's aim (holds pack)
+		id: 'abilitiesDisintegrate',
+		name: 'Disintegrate',
+		description: 'A beam kept up for 3 seconds, following the aim',
+		hotkey: 'F',
+		target: 'direction',
+		range: 10,
+		cooldown: 1,
+		effects: [],
+		channel: { duration: 3, every: 0.25, aimed: true, effects: [{ type: 'damage', amount: 20, shape: 'line', length: 10, width: 0.5 }] }
+	},
+	{
+		// a channel kept up on the march (holds pack)
+		id: 'abilitiesWarSong',
+		name: 'War Song',
+		description: 'Heals allies round the caster every second for 6 seconds, while it walks',
+		hotkey: 'G',
+		target: 'none',
+		cooldown: 1,
+		effects: [],
+		channel: { duration: 6, every: 1, walks: true, effects: [{ type: 'heal', amount: 40, radius: 5 }] }
+	},
+	{
+		// a channel on a unit, broken as it gets 9 cells away
+		id: 'abilitiesLifeDrain',
+		name: 'Life Drain',
+		description: 'Drains an enemy for 4 seconds, while it stays within 9',
+		hotkey: 'Z',
+		target: 'unit',
+		targets: { enemies: true },
+		range: 7,
+		cooldown: 1,
+		effects: [],
+		channel: {
+			duration: 4,
+			every: 0.5,
+			leash: 9,
+			effects: [
+				{ type: 'damage', amount: 30 },
+				{ type: 'heal', amount: 30, on: 'caster' }
+			]
+		}
+	}
+]
+
+export const recasts: Family = {
+	abilities,
+	buffs,
+	units: [
+		caster(
+			'abilitiesRanger',
+			'Ranger',
+			abilities.map((each) => each.id)
+		)
+	],
+	example: {
+		id: 'abilities-recasts',
+		category: 'abilities',
+		title: 'Recasts, charges, holds, channels',
+		summary:
+			'Press Spirit Rush three times, Sonic Wave twice (the second rushes to who it marked), Roll till its charges run out; four casts charge Point Blank. Piercing Arrow draws while held: Release fires it. Three channels: aimed, walking, leashed.',
+		tags: ['recast', 'charges', 'cooldown', 'refresh', 'hold', 'charge up', 'channel', 'stacks', 'charged'],
+		source: ['examples/abilities/recasts.ts', 'examples/abilities/kit.ts'],
+		map: () => exampleField({ name: 'Recasts', players: 2 }),
+		start: (world) => lineUp(world, 'abilitiesRanger', 'abilitiesTarget', 3, 'abilitiesWounded')
+	}
+}

package/starters/examples/src/examples/abilities/recastsLooks.ts

@@ -0,0 +1,41 @@
+/** How the recasts example looks, and its card: a button for each, and one to let go of the drawn bow */
+import { character, hold, person } from '../common/looks'
+import type { FamilyLooks } from './looks'
+import { castButton, look, readyOn, releaseButton, resetButton } from './lookKit'
+import { recasts } from './recasts'
+
+export const recastsLooks: FamilyLooks = {
+	units: {
+		abilitiesRanger: {
+			height: 1.7,
+			model: character('ranger', 0.7, { hold: [hold('bow')], animations: { attack: 'Ranged_2H_Shoot' } }),
+			shot: { color: [0.85, 0.75, 0.55], size: 0.2 },
+			shapes: person(1.7)
+		}
+	},
+	abilities: {
+		abilitiesSpiritRush: look([0.9, 0.45, 1], 'burst'),
+		abilitiesSonicWave: look([1, 0.75, 0.3], 'missile', { options: { shape: 'hawk' } }),
+		abilitiesRoll: look([0.8, 0.8, 0.8]),
+		abilitiesPointBlank: look([1, 0.6, 0.2], 'burst'),
+		abilitiesReady: look([0.5, 1, 0.6], 'sonar'),
+		abilitiesPiercingArrow: look([0.4, 1, 0.5], 'missile', { options: { shape: 'arrow' } }),
+		abilitiesDisintegrate: look([1, 0.3, 0.9], 'ring'),
+		abilitiesWarSong: look([1, 0.9, 0.5], 'sonar'),
+		abilitiesLifeDrain: look([0.7, 0.1, 0.3], 'tether'),
+		abilitiesSonicMark: look([1, 0.75, 0.3], undefined, { aura: 'glow', options: { shape: 'ring', at: 'head' } }),
+		abilitiesFocus: look([1, 0.6, 0.2], undefined, { counter: { max: 4 } }),
+		abilitiesDrawing: look([0.4, 1, 0.5], undefined, { aura: 'glow', options: { shape: 'about' } })
+	},
+	examples: {
+		'abilities-recasts': {
+			ready: (client) => readyOn(client, 'abilitiesRanger'),
+			controls: [
+				...recasts.abilities.flatMap((ability) =>
+					ability.hold ? [castButton(ability, { label: `${ability.name}: hold` }), releaseButton()] : [castButton(ability)]
+				),
+				resetButton('abilities-recasts')
+			]
+		}
+	}
+}

package/starters/examples/src/examples/abilities/resources.ts

@@ -0,0 +1,166 @@
+/**
+ * Resources: what abilities cost beyond mana. With the resources pack (`resourcesPack`), pools of a unit's own: energy
+ * that comes back, fury built by blows, heat that overheats, ammo that reloads. And health as a cost, a cost that grows
+ * with each cast, a toggle that pays with health, and mana burned off an enemy (`manaBurnPack`)
+ */
+import { type AbilityDef, type BuffDef, poolOf } from '@v12-engine/engine'
+import { exampleField } from '../define'
+import { ENEMY, PLAYER, UNIT } from '../common/units'
+import type { Family } from './family'
+import { caster, put } from './kit'
+
+const buffs: BuffDef[] = [
+	// heat's thresholds: hot at 50 (stronger), and at 100 overheated: silenced, the pool held, then emptied
+	{ id: 'abilitiesDangerZone', name: 'Danger Zone', description: 'Hot: 30% more damage', stats: { outgoingDamage: 0.3 } },
+	{ id: 'abilitiesOverheat', name: 'Overheated', description: 'Can not cast until it cools', harmful: true, duration: 3, silence: true },
+	{
+		id: 'abilitiesRiftwalkStacks',
+		name: 'Riftwalk',
+		description: 'Each makes the next Riftwalk cost as much again',
+		duration: 8,
+		maxStacks: 4,
+		stacking: 'refresh'
+	},
+	// its carrier's abilities cost health, not mana
+	{ id: 'abilitiesBloodTithe', name: 'Blood Tithe', description: 'Spells cost health, not mana', paysWithHealth: true }
+]
+
+const abilities: AbilityDef[] = [
+	{
+		id: 'abilitiesFivePoint',
+		name: 'Five Point Strike',
+		description: 'Costs 60 energy (energy comes back 10 a second)',
+		hotkey: 'Q',
+		target: 'direction',
+		range: 5,
+		cost: { energy: 60 },
+		effects: [{ type: 'damage', amount: 80, shape: 'cone', length: 5, angle: 1 }]
+	},
+	{
+		// as much as the fury it has, then all of it spent
+		id: 'abilitiesBloodlust',
+		name: 'Bloodlust',
+		description: 'Heals 30, and 3 for each point of fury; spends all the fury (gathered by its blows)',
+		hotkey: 'W',
+		target: 'none',
+		cooldown: 0.5,
+		effects: [
+			{ type: 'heal', on: 'caster', amount: (context) => 30 + 3 * (context.effect ? poolOf(context.effect.caster, 'fury') : 0) },
+			{ type: 'gain', pool: 'fury', on: 'caster', amount: -100 }
+		]
+	},
+	{
+		// fills heat as it goes off: at 50 it is hot, at 100 it overheats
+		id: 'abilitiesFlameBurst',
+		name: 'Flame Burst',
+		description: 'Burns the nearest enemies and gives 25 heat; hot at 50, overheated (silenced) at 100',
+		hotkey: 'E',
+		target: 'point',
+		range: 8,
+		cooldown: 0.3,
+		gain: { heat: 25 },
+		effects: [{ type: 'damage', amount: 50, radius: 2 }]
+	},
+	{
+		id: 'abilitiesBloodRite',
+		name: 'Blood Rite',
+		description: 'Costs a tenth of the caster’s health: 150 to an enemy',
+		hotkey: 'R',
+		target: 'unit',
+		targets: { enemies: true },
+		range: 8,
+		cooldown: 0.5,
+		healthCost: 0.1,
+		effects: [{ type: 'damage', amount: 150 }]
+	},
+	{
+		// each cast leaves a stack that makes the next cost more
+		id: 'abilitiesRiftwalk',
+		name: 'Riftwalk',
+		description: 'A blink for 50 mana, and 50 more for each Riftwalk of the last 8 seconds',
+		hotkey: 'T',
+		target: 'point',
+		range: 5,
+		manaCost: 50,
+		costGrowth: { buff: 'abilitiesRiftwalkStacks', per: 1 },
+		effects: [
+			{ type: 'blink', distance: 3 },
+			{ type: 'buff', buff: 'abilitiesRiftwalkStacks', stack: true, on: 'caster' }
+		]
+	},
+	{
+		id: 'abilitiesManaBurn',
+		name: 'Mana Burn',
+		description: 'Burns 80 of an enemy’s mana, and deals as much',
+		hotkey: 'D',
+		target: 'unit',
+		targets: { enemies: true },
+		range: 8,
+		cooldown: 0.5,
+		manaCost: 20,
+		effects: [{ type: 'manaBurn', amount: 80 }]
+	},
+	{
+		id: 'abilitiesCastTithe',
+		name: 'Blood Tithe',
+		description: 'Turned on and off: while on, every spell costs health instead of mana',
+		hotkey: 'F',
+		target: 'none',
+		effects: [{ type: 'toggle', buff: 'abilitiesBloodTithe' }]
+	}
+]
+
+/** What gathers fury: each blow that lands */
+const battleFury: AbilityDef = {
+	id: 'abilitiesBattleFury',
+	name: 'Battle Fury',
+	description: 'Each blow that lands: 10 fury',
+	target: 'passive',
+	effects: [{ type: 'onHit', effects: [{ type: 'gain', pool: 'fury', amount: 10, on: 'caster' }] }]
+}
+
+export const resources: Family = {
+	abilities,
+	more: [battleFury],
+	buffs,
+	units: [
+		caster('abilitiesStriker', 'Striker', [...abilities.map((each) => each.id), battleFury.id], {
+			// it strikes the dummy beside it: every attack spends a shot of ammo, and gives fury
+			stats: { health: 1500, healthRegen: 15, mana: 400, manaRegen: 8, attackDamage: 25, attackSpeed: 1.6, attackRange: 5, moveSpeed: 4.2 },
+			attacks: [{ damagePoint: 0.3, acquisitionRange: 6, projectileSpeed: 30 }],
+			attackCost: { ammo: 1 },
+			pools: {
+				energy: { name: 'Energy', color: '#ffe14d', max: 200, regen: 10 },
+				fury: { name: 'Fury', color: '#e0402a', max: 100, start: 0, decay: 8, idle: 3 },
+				heat: {
+					name: 'Heat',
+					color: '#ff7a1a',
+					max: 100,
+					start: 0,
+					decay: 12,
+					idle: 2,
+					thresholds: [
+						{ at: 50, buff: 'abilitiesDangerZone', kept: true },
+						{ at: 100, buff: 'abilitiesOverheat', empties: true }
+					]
+				},
+				ammo: { name: 'Ammo', color: '#c8c8c8', max: 6, reload: 2.5 }
+			}
+		})
+	],
+	example: {
+		id: 'abilities-resources',
+		category: 'abilities',
+		title: 'Energy, fury, heat, ammo',
+		summary:
+			'A striker with four pools besides mana: energy that comes back, fury its blows build, heat that overheats, and six shots that reload. It shoots the dummy by itself. Press the buttons to spend them, and watch the bars below.',
+		tags: ['resource', 'energy', 'fury', 'rage', 'heat', 'ammo', 'reload', 'health cost', 'mana burn', 'cost'],
+		source: ['examples/abilities/resources.ts', 'examples/abilities/kit.ts'],
+		map: () => exampleField({ name: 'Resources', players: 2 }),
+		start: (world) => {
+			put(world, 'abilitiesStriker', PLAYER, { x: 24, z: 18 }, 'caster')
+			put(world, UNIT.dummy, ENEMY, { x: 24, z: 22.5 }, 'dummy', Math.PI)
+			for (const [i, x] of [21.5, 26.5].entries()) put(world, 'abilitiesTarget', ENEMY, { x, z: 24 }, `enemy${i + 1}`, Math.PI)
+		}
+	}
+}

package/starters/examples/src/examples/abilities/resourcesLooks.ts

@@ -0,0 +1,42 @@
+/** How the resources example looks, and its card: a button for each, and the pools read out */
+import { readout } from '../../shell/look'
+import { character, hold, person } from '../common/looks'
+import type { FamilyLooks } from './looks'
+import { castButton, look, readyOn, resetButton } from './lookKit'
+import { resources } from './resources'
+
+export const resourcesLooks: FamilyLooks = {
+	units: {
+		abilitiesStriker: {
+			height: 1.8,
+			model: character('rogue', 0.72, { hold: [hold('crossbow_1handed')], animations: { attack: 'Ranged_1H_Shoot' } }),
+			shot: { color: [0.9, 0.85, 0.7], size: 0.18 },
+			shapes: person(1.8)
+		}
+	},
+	abilities: {
+		abilitiesFivePoint: look([1, 0.9, 0.3], 'burst'),
+		abilitiesBloodlust: look([0.9, 0.15, 0.1], 'burst'),
+		abilitiesFlameBurst: look([1, 0.45, 0.1], 'smash'),
+		abilitiesBloodRite: look([0.7, 0.05, 0.1], 'burst'),
+		abilitiesRiftwalk: look([0.7, 0.4, 1], 'burst'),
+		abilitiesManaBurn: look([0.3, 0.4, 1], 'tether'),
+		abilitiesDangerZone: look([1, 0.5, 0.1], undefined, { aura: 'glow', options: { shape: 'rise' } }),
+		abilitiesOverheat: look([1, 0.2, 0.05], undefined, { aura: 'glow', options: { shape: 'column', streaks: true } }),
+		abilitiesRiftwalkStacks: look([0.7, 0.4, 1], undefined, { counter: { max: 4 } }),
+		abilitiesBloodTithe: look([0.8, 0.05, 0.1], undefined, { aura: 'glow', options: { shape: 'fall', solid: true } })
+	},
+	examples: {
+		'abilities-resources': {
+			ready: (client) => readyOn(client, 'abilitiesStriker', { minX: 18, minZ: 14, maxX: 30, maxZ: 27 }),
+			controls: [
+				...resources.abilities.map((ability) => castButton(ability, ability.id === 'abilitiesManaBurn' ? { at: 'enemy1' } : {})),
+				resetButton('abilities-resources'),
+				readout('Health · mana', (client) => {
+					const striker = client.session.snapshot().entities.find((each) => each.type === 'abilitiesStriker')
+					return striker ? `${Math.round(striker.health)} · ${Math.round(striker.mana ?? 0)}` : '—'
+				})
+			]
+		}
+	}
+}