@v12-engine/create 0.1.0 → 0.4.0

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

@@ -0,0 +1,71 @@
+/**
+ * What the abilities examples share on the client's side (the MOBA ones too): a look laid into the game's (units and
+ * abilities by id), a button that casts an ability, and the camera and selection an example starts with
+ */
+import type { AbilityDef } from '@v12-engine/engine'
+import type { AbilityLook, GameClientApi, GameView, UnitLook } from '@v12-engine/client'
+import { button, type ExampleControl } from '../../shell/look'
+import { cast, release, reset } from './kit'
+
+type Color = [number, number, number]
+
+/** An ability's or a buff's look: a colour, a style of the client's (`ring` when not said) and anything else */
+export const look = (color: Color, style?: string, more: Partial<AbilityLook> = {}): AbilityLook => ({ color, ...(style && { style }), ...more })
+
+/** The game's look with these units' and abilities' (and buffs') looks laid over its own */
+export function withLooks(view: GameView<any>, units: Record<string, UnitLook>, abilities: Record<string, AbilityLook>): GameView<any> {
+	const fx = view.fx ?? {}
+	return {
+		...view,
+		units: { ...view.units, looks: { ...view.units?.looks, ...units } },
+		fx: { ...fx, abilities: { ...fx.abilities, looks: { ...fx.abilities?.looks, ...abilities } } }
+	}
+}
+
+/**
+ * A button casting an ability, named as it is, its description the hint (or what it is, where it has none): aimed for
+ * the player (`castFor`)
+ */
+export const castButton = (
+	ability: AbilityDef,
+	options: { by?: string; at?: string; point?: { x: number; z: number }; label?: string } = {}
+): ExampleControl =>
+	button(
+		options.label ?? ability.name,
+		(client) =>
+			client.session.send(
+				cast.make({
+					ability: ability.id,
+					...(options.by && { by: options.by }),
+					...(options.at && { at: options.at }),
+					...(options.point && { point: options.point })
+				})
+			),
+		ability.description ?? `Casts ${ability.name}`
+	)
+
+/** A button letting go of what the caster holds (hold to charge, release to fire) */
+export const releaseButton = (label = 'Release', by?: string): ExampleControl =>
+	button(
+		label,
+		(client) => client.session.send(release.make({ ...(by && { by }) })),
+		'Lets go of what is held: it fires as far and as hard as it charged'
+	)
+
+/** A button laying the example out again as it started */
+export const resetButton = (example: string): ExampleControl =>
+	button('Start again', (client) => client.session.send(reset.make({ example })), 'Takes everything away and lays the example out again')
+
+/** A box of the ground, in cells */
+export type Box = { minX: number; minZ: number; maxX: number; maxZ: number }
+
+/**
+ * Makes the example ready: the camera framing `box` (the caster and its targets as `lineUp` lays them, when not said),
+ * and the player's unit of `type` selected, so its card shows its abilities
+ */
+export function readyOn(client: GameClientApi, type: string | undefined, box: Box = { minX: 18, minZ: 15, maxX: 30, maxZ: 29 }): void {
+	client.camera.frame(box)
+	if (!type) return
+	const unit = client.session.snapshot().entities.find((each) => each.type === type && each.owner === client.session.playerId)
+	if (unit) client.controller.select([unit.id])
+}

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

@@ -0,0 +1,47 @@
+/**
+ * The abilities examples on the client's side: how their casters, targets and abilities look, and each example's card
+ * (a button casting each of its family's abilities). Each family's looks are its own file (`./damageLooks.ts`…)
+ */
+import type { CategoryLooks, ExampleLook } from '../../shell/look'
+import type { AbilityLook, GameView, UnitLook } from '@v12-engine/client'
+import { areasLooks } from './areasLooks'
+import { buffsLooks } from './buffsLooks'
+import { changingLooks } from './changingLooks'
+import { controlLooks } from './controlLooks'
+import { damageLooks } from './damageLooks'
+import { withLooks } from './lookKit'
+import { missilesLooks } from './missilesLooks'
+import { movesLooks } from './movesLooks'
+import { recastsLooks } from './recastsLooks'
+import { resourcesLooks } from './resourcesLooks'
+import { summonsLooks } from './summonsLooks'
+import { triggersLooks } from './triggersLooks'
+import { visionLooks } from './visionLooks'
+
+/** A family's looks: its units' and abilities', and its example's card */
+export interface FamilyLooks {
+	units: Record<string, UnitLook>
+	abilities: Record<string, AbilityLook>
+	examples: Record<string, ExampleLook>
+}
+
+const all: FamilyLooks[] = [
+	damageLooks,
+	missilesLooks,
+	areasLooks,
+	controlLooks,
+	buffsLooks,
+	movesLooks,
+	summonsLooks,
+	triggersLooks,
+	recastsLooks,
+	resourcesLooks,
+	visionLooks,
+	changingLooks
+]
+
+export const category: CategoryLooks = {
+	looks: Object.assign({}, ...all.map((each) => each.examples)),
+	view: (view: GameView<any>) =>
+		withLooks(view, Object.assign({}, ...all.map((each) => each.units)), Object.assign({}, ...all.map((each) => each.abilities)))
+}

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

@@ -0,0 +1,203 @@
+/**
+ * Missiles: the `missile` effect in every shape it takes. A bolt that chases, a wave through a line, one that stops at
+ * the first, a rocket to a spot, a grenade over everything, lightning that bounces, a fan, an orb that comes back,
+ * wisps that seek, a bolt that splits and a hook that drags its catch in
+ */
+import type { AbilityDef, BuffDef } from '@v12-engine/engine'
+import { exampleField } from '../define'
+import type { Family } from './family'
+import { caster, put, sparring } from './kit'
+import { ENEMY, PLAYER } from '../common/units'
+
+const buffs: BuffDef[] = [
+	{ id: 'abilitiesBoltStun', name: 'Stunned', harmful: true, duration: 1.5, stun: true },
+	{ id: 'abilitiesBound', name: 'Bound', harmful: true, duration: 2, root: true },
+	{ id: 'abilitiesHooked', name: 'Hooked', harmful: true, duration: 0.6, stun: true }
+]
+
+const abilities: AbilityDef[] = [
+	{
+		// follows the unit it was cast on, wherever it goes: Storm Bolt
+		id: 'abilitiesStormBolt',
+		name: 'Storm Bolt',
+		description: 'A hammer that chases an enemy: {damage} and a stun',
+		hotkey: 'Q',
+		target: 'unit',
+		targets: { enemies: true },
+		range: 10,
+		cooldown: 1,
+		effects: [
+			{
+				type: 'missile',
+				homing: true,
+				speed: 14,
+				effects: [
+					{ type: 'damage', amount: 100 },
+					{ type: 'buff', buff: 'abilitiesBoltStun' }
+				]
+			}
+		]
+	},
+	{
+		// toward a spot, through everything on its way (`pierce` is true unless said)
+		id: 'abilitiesShockwave',
+		name: 'Shockwave',
+		description: 'A wave along a line, through every enemy on it',
+		hotkey: 'W',
+		target: 'direction',
+		range: 12,
+		cooldown: 1,
+		effects: [{ type: 'missile', speed: 16, distance: 12, radius: 1, effects: [{ type: 'damage', amount: 80 }] }]
+	},
+	{
+		// stops at the first enemy it meets: a skillshot
+		id: 'abilitiesLightBinding',
+		name: 'Light Binding',
+		description: 'A bolt that stops at the first enemy it meets and roots it',
+		hotkey: 'E',
+		target: 'direction',
+		range: 12,
+		cooldown: 1,
+		effects: [{ type: 'missile', speed: 14, distance: 12, radius: 0.6, pierce: false, effects: [{ type: 'buff', buff: 'abilitiesBound' }] }]
+	},
+	{
+		// to the spot clicked, blowing up there
+		id: 'abilitiesRocket',
+		name: 'Rocket',
+		description: 'Flies to the spot and blows up there',
+		hotkey: 'R',
+		target: 'point',
+		range: 12,
+		cooldown: 1,
+		effects: [{ type: 'missile', speed: 20, distance: 12, toPoint: true, onEnd: [{ type: 'damage', amount: 120, radius: 2.5 }] }]
+	},
+	{
+		// thrown in an arc, over whatever is between: hits around where it lands
+		id: 'abilitiesGrenade',
+		name: 'Grenade',
+		description: 'Thrown high over everything, it hits around where it lands',
+		hotkey: 'T',
+		target: 'point',
+		range: 12,
+		cooldown: 1,
+		effects: [{ type: 'missile', toPoint: true, distance: 12, radius: 2, arc: { height: 4, time: 1 }, effects: [{ type: 'damage', amount: 110 }] }]
+	},
+	{
+		// springs on to the nearest it has not hit, a third weaker each time
+		id: 'abilitiesChainLightning',
+		name: 'Chain Lightning',
+		description: 'Lightning that springs from enemy to enemy, weaker each time',
+		hotkey: 'D',
+		target: 'unit',
+		targets: { enemies: true },
+		range: 10,
+		cooldown: 1,
+		effects: [{ type: 'missile', homing: true, speed: 30, bounce: { count: 4, range: 6, falloff: 0.25 }, effects: [{ type: 'damage', amount: 120 }] }]
+	},
+	{
+		// several in a fan: none hits what another already hit
+		id: 'abilitiesVolley',
+		name: 'Volley',
+		description: 'Seven arrows in a fan, each stopping at the first it meets',
+		hotkey: 'F',
+		target: 'direction',
+		range: 10,
+		cooldown: 1,
+		effects: [{ type: 'missile', count: 7, spread: Math.PI / 2.5, speed: 18, distance: 10, pierce: false, effects: [{ type: 'damage', amount: 45 }] }]
+	},
+	{
+		// out and back, hitting on the way back too
+		id: 'abilitiesOrb',
+		name: 'Orb of Deception',
+		description: 'An orb out and back again, hurting on both ways',
+		hotkey: 'G',
+		target: 'direction',
+		range: 10,
+		cooldown: 1,
+		effects: [{ type: 'missile', speed: 15, distance: 10, radius: 0.9, returns: true, hitsOnReturn: true, effects: [{ type: 'damage', amount: 50 }] }]
+	},
+	{
+		// each finds its own: they fly round and after the nearest enemy within 7
+		id: 'abilitiesFoxFire',
+		name: 'Fox-Fire',
+		description: 'Three wisps that find the nearest enemies by themselves',
+		hotkey: 'Z',
+		target: 'none',
+		cooldown: 1,
+		effects: [{ type: 'missile', count: 3, spread: 2 * Math.PI, speed: 14, distance: 9, seek: 7, effects: [{ type: 'damage', amount: 50 }] }]
+	},
+	{
+		// where it ends it splits in two, each going on aside
+		id: 'abilitiesFission',
+		name: 'Plasma Fission',
+		description: 'A bolt that splits in two where it stops, each half flying on aside',
+		hotkey: 'X',
+		target: 'direction',
+		range: 8,
+		cooldown: 1,
+		effects: [
+			{
+				type: 'missile',
+				speed: 14,
+				distance: 7,
+				pierce: false,
+				effects: [{ type: 'damage', amount: 60 }],
+				split: [
+					{ type: 'missile', count: 2, spread: Math.PI / 1.2, speed: 14, distance: 7, look: 'halves', effects: [{ type: 'damage', amount: 60 }] }
+				]
+			}
+		]
+	},
+	{
+		// a chain written flat: the missile, then a pull on what it hits, then damage as it arrives
+		id: 'abilitiesHook',
+		name: 'Rocket Grab',
+		description: 'A hook to the first enemy it meets, dragged back and hurt as it arrives',
+		hotkey: 'C',
+		target: 'direction',
+		range: 12,
+		cooldown: 1,
+		effects: [
+			{ type: 'missile', speed: 28, distance: 12, radius: 0.7, pierce: false, returns: true },
+			{ type: 'pull', seconds: 0.6, when: 'hit' },
+			{ type: 'damage', amount: 90, when: 'arrived' },
+			{ type: 'buff', buff: 'abilitiesHooked', when: 'hit' }
+		]
+	}
+]
+
+export const missiles: Family = {
+	abilities,
+	buffs,
+	units: [
+		caster(
+			'abilitiesArcher',
+			'Missile mage',
+			abilities.map((each) => each.id)
+		),
+		sparring('abilitiesStrafer', 'Sparring footman')
+	],
+	example: {
+		id: 'abilities-missiles',
+		category: 'abilities',
+		title: 'Missiles',
+		summary:
+			'Every kind of missile: homing, through a line, stopped by the first, to a spot, thrown, bouncing, in a fan, out and back, seeking, splitting and a hook. Press a button to fire it at the footmen across the field.',
+		tags: ['missile', 'projectile', 'skillshot', 'homing', 'bounce', 'chain', 'hook', 'arc', 'boomerang', 'split', 'seek'],
+		source: ['examples/abilities/missiles.ts', 'examples/abilities/kit.ts'],
+		map: () => exampleField({ name: 'Missiles', players: 2 }),
+		start: (world) => {
+			put(world, 'abilitiesArcher', PLAYER, { x: 24, z: 15 }, 'caster')
+			// a loose crowd across the field: one in front, others behind and aside, for lines, fans and bounces to find
+			const spots = [
+				[24, 23],
+				[22, 25.5],
+				[26.5, 25],
+				[24, 27.5],
+				[20, 28],
+				[28.5, 28.5]
+			]
+			spots.forEach(([x, z], i) => put(world, 'abilitiesStrafer', ENEMY, { x, z }, `enemy${i + 1}`, Math.PI))
+		}
+	}
+}

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

@@ -0,0 +1,38 @@
+/** How the missiles example looks, and its card: a button for each missile (`./missiles.ts`) */
+import { sharedLooks } from '../common/looks'
+import type { FamilyLooks } from './looks'
+import { castButton, look, readyOn, resetButton } from './lookKit'
+import { missiles } from './missiles'
+
+/** A missile's look: the missile style, flying as `shape` (an arrow, a rock, a bird of light or a ball of fire) */
+const flying = (color: [number, number, number], shape: 'arrow' | 'rock' | 'hawk' | 'ball', more = {}) =>
+	look(color, 'missile', { options: { shape }, ...more })
+
+export const missilesLooks: FamilyLooks = {
+	units: {
+		abilitiesArcher: sharedLooks.mage,
+		abilitiesStrafer: sharedLooks.footman
+	},
+	abilities: {
+		abilitiesStormBolt: flying([0.6, 0.8, 1], 'rock'),
+		abilitiesShockwave: flying([1, 0.75, 0.35], 'hawk'),
+		abilitiesLightBinding: flying([1, 0.95, 0.6], 'hawk'),
+		abilitiesRocket: flying([1, 0.45, 0.15], 'ball'),
+		abilitiesGrenade: flying([0.7, 0.6, 0.5], 'rock'),
+		abilitiesChainLightning: flying([0.55, 0.75, 1], 'hawk', { link: 'chain' }),
+		abilitiesVolley: flying([0.85, 0.75, 0.55], 'arrow'),
+		abilitiesOrb: flying([0.9, 0.45, 1], 'ball'),
+		abilitiesFoxFire: flying([0.4, 0.7, 1], 'hawk'),
+		// the halves a colour of their own (`look: 'halves'` on the split's missile)
+		abilitiesFission: flying([0.6, 0.35, 1], 'ball', { effects: { halves: { color: [1, 0.6, 0.15] } } }),
+		abilitiesHook: flying([0.75, 0.75, 0.8], 'rock'),
+		abilitiesBoltStun: look([1, 1, 0.6], undefined, { aura: 'glow', options: { shape: 'ring', at: 'head' } }),
+		abilitiesBound: look([1, 0.95, 0.6], undefined, { aura: 'glow', options: { shape: 'column' } })
+	},
+	examples: {
+		'abilities-missiles': {
+			ready: (client) => readyOn(client, 'abilitiesArcher', { minX: 16, minZ: 13, maxX: 32, maxZ: 30 }),
+			controls: [...missiles.abilities.map((ability) => castButton(ability)), resetButton('abilities-missiles')]
+		}
+	}
+}

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

@@ -0,0 +1,206 @@
+/**
+ * Moves: abilities that move units. The caster leaping, blinking, rushing to an enemy and through it, teleporting;
+ * enemies thrown back (into a wall, to be stunned), thrown into each other, thrown over, dragged in; two units trading
+ * places; the caster riding an ally. Most need the moves pack (`movesPack`, added in `./kit.ts`)
+ */
+import type { AbilityDef, BuffDef } from '@v12-engine/engine'
+import { exampleField } from '../define'
+import { ENEMY, PLAYER } from '../common/units'
+import type { Family } from './family'
+import { caster, put } from './kit'
+
+const buffs: BuffDef[] = [{ id: 'abilitiesWallStun', name: 'Slammed', harmful: true, duration: 1.5, stun: true }]
+
+const abilities: AbilityDef[] = [
+	{
+		// a dash with a leap flies over what is between, and hurts round where it lands
+		id: 'abilitiesLeap',
+		name: 'Leap',
+		description: 'Jumps toward the spot and strikes where it lands',
+		hotkey: 'Q',
+		target: 'point',
+		range: 7,
+		cooldown: 0.5,
+		effects: [{ type: 'dash', distance: 7, speed: 16, leap: 2, effects: [{ type: 'damage', amount: 80, radius: 2 }] }]
+	},
+	{
+		// at once, up to its distance
+		id: 'abilitiesBlink',
+		name: 'Blink',
+		description: 'At once to the spot, up to 8 cells',
+		hotkey: 'W',
+		target: 'point',
+		range: 8,
+		cooldown: 0.5,
+		effects: [{ type: 'blink', distance: 8 }]
+	},
+	{
+		// home: where the side's home is (here its start)
+		id: 'abilitiesRecall',
+		name: 'Teleport home',
+		description: 'Back to where it started, however far',
+		hotkey: 'E',
+		target: 'none',
+		cooldown: 0.5,
+		castTime: 0.6,
+		effects: [{ type: 'teleport', to: 'home' }]
+	},
+	{
+		// rushes to the unit, to its edge, following it
+		id: 'abilitiesCharge',
+		name: 'Heroic Charge',
+		description: 'Rushes to an enemy and strikes it',
+		hotkey: 'R',
+		target: 'unit',
+		targets: { enemies: true },
+		range: 10,
+		cooldown: 0.5,
+		effects: [{ type: 'dash', to: 'target', speed: 22, effects: [{ type: 'damage', amount: 60 }] }]
+	},
+	{
+		// through the unit, 3 cells past its middle
+		id: 'abilitiesSweep',
+		name: 'Sweeping Blade',
+		description: 'Dashes through an enemy, cutting it',
+		hotkey: 'T',
+		target: 'unit',
+		targets: { enemies: true },
+		range: 8,
+		cooldown: 0.5,
+		effects: [{ type: 'dash', to: 'target', through: 3, speed: 20, effects: [{ type: 'damage', amount: 50 }] }]
+	},
+	{
+		// thrown back from the caster; a wall on the way stuns it
+		id: 'abilitiesCondemn',
+		name: 'Condemn',
+		description: 'Throws an enemy back: into the pillar behind it, it is stunned',
+		hotkey: 'D',
+		target: 'unit',
+		targets: { enemies: true },
+		range: 10,
+		cooldown: 0.5,
+		effects: [{ type: 'knockback', distance: 5, speed: 20, onWall: [{ type: 'buff', buff: 'abilitiesWallStun' }] }]
+	},
+	{
+		// what it is thrown into is hit and thrown aside too
+		id: 'abilitiesDragonsRage',
+		name: 'Dragon’s Rage',
+		description: 'Kicks an enemy into the others: each it meets is hurt and knocked up',
+		hotkey: 'F',
+		target: 'unit',
+		targets: { enemies: true },
+		range: 10,
+		cooldown: 0.5,
+		effects: [
+			{
+				type: 'knockback',
+				distance: 8,
+				speed: 16,
+				collide: [
+					{ type: 'damage', amount: 70 },
+					{ type: 'knockback', distance: 1.5, leap: 2, speed: 4 }
+				]
+			}
+		]
+	},
+	{
+		// every enemy round the caster, back 4 cells
+		id: 'abilitiesShove',
+		name: 'Shove',
+		description: 'Throws every enemy within 4 back, through the air',
+		hotkey: 'G',
+		target: 'none',
+		cooldown: 0.5,
+		effects: [{ type: 'knockback', distance: 4, speed: 12, radius: 4, leap: 1 }]
+	},
+	{
+		// over the caster, to land on its far side
+		id: 'abilitiesFlay',
+		name: 'Flay',
+		description: 'Throws the enemies near over the caster, to land behind it',
+		hotkey: 'Z',
+		target: 'none',
+		cooldown: 0.5,
+		effects: [{ type: 'knockback', direction: 'over', distance: 2.5, leap: 2, speed: 10, radius: 4 }]
+	},
+	{
+		// dragged in to where it landed: a vacuum
+		id: 'abilitiesVacuum',
+		name: 'Vacuum',
+		description: 'Drags every enemy within 4 of the spot into its middle',
+		hotkey: 'X',
+		target: 'point',
+		range: 10,
+		cooldown: 0.5,
+		effects: [{ type: 'pull', seconds: 0.5, radius: 4, toPoint: true, effects: [{ type: 'damage', amount: 40 }] }]
+	},
+	{
+		// the caster and the target trade places
+		id: 'abilitiesSwap',
+		name: 'Nether Swap',
+		description: 'The caster and an enemy trade places',
+		hotkey: 'C',
+		target: 'unit',
+		targets: { allies: true, enemies: true },
+		range: 12,
+		cooldown: 0.5,
+		effects: [{ type: 'swap' }]
+	},
+	{
+		// out of the world, riding the ally until it ends; healing round as it lets go
+		id: 'abilitiesAttach',
+		name: 'Ride an ally',
+		description: 'Rides the ally for 6 seconds, then heals round it as it lets go',
+		hotkey: 'V',
+		target: 'unit',
+		targets: { allies: true },
+		range: 10,
+		cooldown: 0.5,
+		effects: [{ type: 'attach', duration: 6, onEnd: [{ type: 'heal', amount: 100, radius: 3 }] }]
+	}
+]
+
+export const moves: Family = {
+	abilities,
+	buffs,
+	units: [
+		caster(
+			'abilitiesMover',
+			'Duelist',
+			abilities.map((each) => each.id)
+		),
+		// a wall to throw things into: a pillar that blocks the ground
+		{
+			id: 'abilitiesPillar',
+			name: 'Pillar',
+			kind: 'building',
+			radius: 1,
+			footprint: { w: 2, d: 2 },
+			stats: { health: 5000, armor: 50 },
+			invulnerable: true,
+			sight: 2
+		}
+	],
+	example: {
+		id: 'abilities-moves',
+		category: 'abilities',
+		title: 'Dash, blink, knockback, pull',
+		summary:
+			'Leap, blink, teleport home, rush to an enemy and through it; throw enemies back into a pillar, into each other, over you; drag them in; trade places; ride an ally. Press a button to see each.',
+		tags: ['dash', 'blink', 'leap', 'teleport', 'knockback', 'pull', 'swap', 'attach', 'collide', 'wall stun', 'movement'],
+		source: ['examples/abilities/moves.ts', 'examples/abilities/kit.ts'],
+		map: () => exampleField({ name: 'Moves', players: 2 }),
+		start: (world) => {
+			put(world, 'abilitiesMover', PLAYER, { x: 24, z: 16 }, 'caster')
+			put(world, 'abilitiesWounded', PLAYER, { x: 20, z: 16 }, 'ally')
+			put(world, 'abilitiesTarget', ENEMY, { x: 24, z: 22 }, 'enemy1', Math.PI)
+			put(world, 'abilitiesTarget', ENEMY, { x: 22.5, z: 25 }, 'enemy2', Math.PI)
+			put(world, 'abilitiesTarget', ENEMY, { x: 25.5, z: 25.5 }, 'enemy3', Math.PI)
+			put(world, 'abilitiesTarget', ENEMY, { x: 24, z: 28 }, 'enemy4', Math.PI)
+			// pillars behind them, to be thrown into
+			put(world, 'abilitiesPillar', world.neutral, { x: 24, z: 31 })
+			put(world, 'abilitiesPillar', world.neutral, { x: 20, z: 30 })
+			put(world, 'abilitiesPillar', world.neutral, { x: 28, z: 30 })
+		}
+	}
+}

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

@@ -0,0 +1,52 @@
+/** How the moves example looks, and its card: a button for each move (`./moves.ts`) */
+import { character, hold, person } from '../common/looks'
+import type { FamilyLooks } from './looks'
+import { castButton, look, readyOn, resetButton } from './lookKit'
+import { moves } from './moves'
+
+/** Where each is aimed, where the nearest enemy is not it */
+const aims: Record<string, { at?: string; point?: { x: number; z: number } }> = {
+	abilitiesLeap: { point: { x: 21, z: 22 } },
+	abilitiesBlink: { point: { x: 28, z: 20 } },
+	abilitiesSweep: { at: 'enemy2' },
+	abilitiesCondemn: { at: 'enemy4' },
+	abilitiesVacuum: { point: { x: 24, z: 25 } },
+	abilitiesSwap: { at: 'enemy4' },
+	abilitiesAttach: { at: 'ally' }
+}
+
+export const movesLooks: FamilyLooks = {
+	units: {
+		abilitiesMover: { height: 1.8, model: character('rogue', 0.72, { hold: [hold('dagger'), hold('dagger', 'l')] }), shapes: person(1.8) },
+		// the dungeon kit's pillar; its parts show while it loads
+		abilitiesPillar: {
+			height: 3.6,
+			model: { src: 'dungeon-kit/pillar.glb', scale: 0.9 },
+			shapes: [
+				{ shape: 'cylinder', size: [1.6, 3, 1.6], offset: [0, 1.5, 0], color: [0.55, 0.52, 0.48] },
+				{ shape: 'box', size: [2, 0.4, 2], offset: [0, 3.1, 0], color: [0.45, 0.42, 0.4] }
+			]
+		}
+	},
+	abilities: {
+		abilitiesLeap: look([1, 0.7, 0.3], 'slam'),
+		abilitiesBlink: look([0.6, 0.4, 1], 'burst'),
+		abilitiesRecall: look([0.5, 0.8, 1], 'tornado'),
+		abilitiesCharge: look([1, 0.6, 0.2], 'slam'),
+		abilitiesSweep: look([0.8, 0.9, 1], 'burst'),
+		abilitiesCondemn: look([0.85, 0.75, 1], 'burst'),
+		abilitiesDragonsRage: look([1, 0.5, 0.1], 'smash'),
+		abilitiesShove: look([0.9, 0.85, 0.6], 'slam'),
+		abilitiesFlay: look([0.4, 1, 0.6], 'slam'),
+		abilitiesVacuum: look([0.6, 0.4, 1], 'tornado'),
+		abilitiesSwap: look([0.7, 0.3, 1], 'tether'),
+		abilitiesAttach: look([0.5, 1, 0.8], 'tether'),
+		abilitiesWallStun: look([1, 1, 0.6], undefined, { aura: 'glow', options: { shape: 'ring', at: 'head' } })
+	},
+	examples: {
+		'abilities-moves': {
+			ready: (client) => readyOn(client, 'abilitiesMover', { minX: 16, minZ: 13, maxX: 32, maxZ: 32 }),
+			controls: [...moves.abilities.map((ability) => castButton(ability, aims[ability.id])), resetButton('abilities-moves')]
+		}
+	}
+}