@v12-engine/create 0.1.0 → 0.4.0

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

@@ -0,0 +1,137 @@
+/**
+ * Vision and stealth, played in the fog of war: see a far spot, find what hides, go unseen; and with the vision pack
+ * (`visionPack`), mark an enemy so it is seen wherever it runs, be seen only up close, and see the hidden with true
+ * sight. A sentry far to the north is in the fog, an assassin near is invisible, a ranger camouflaged
+ */
+import { type AbilityDef, applyBuff, type BuffDef } from '@v12-engine/engine'
+import { exampleField } from '../define'
+import { ENEMY, PLAYER } from '../common/units'
+import type { Family } from './family'
+import { caster, put, sparring } from './kit'
+
+const buffs: BuffDef[] = [
+	// unseen by enemies unless found, until it attacks or casts
+	{
+		id: 'abilitiesWindWalk',
+		name: 'Wind Walk',
+		description: 'Unseen, 30% faster, until it attacks or casts',
+		duration: 10,
+		invisible: true,
+		breaksOn: ['attack', 'cast'],
+		percent: { moveSpeed: 0.3 }
+	},
+	// seen by the team of who put it on, wherever it stands: through fog and invisibility
+	{ id: 'abilitiesHunted', name: 'Hunted', description: 'Seen wherever it runs', harmful: true, duration: 12, revealed: true },
+	// seen only by an enemy within 4 cells
+	{ id: 'abilitiesCamouflage', name: 'Camouflage', description: 'Seen only from within 4 cells', camouflage: 4 },
+	{ id: 'abilitiesGhostwater', name: 'Ghostwater', description: 'Seen only from within 3 cells', duration: 8, camouflage: 3 },
+	// finds the invisible and camouflaged within 10, for as long as they stay near
+	{ id: 'abilitiesOracle', name: 'Oracle Lens', description: 'Finds what hides within 10', duration: 10, trueSight: 10 }
+]
+
+const abilities: AbilityDef[] = [
+	{
+		id: 'abilitiesFarSight',
+		name: 'Far Sight',
+		description: 'Lights an 8-cell circle in the north for 8 seconds: the sentry there',
+		hotkey: 'Q',
+		target: 'point',
+		range: 99,
+		cooldown: 1,
+		effects: [{ type: 'reveal', radius: 8, duration: 8 }]
+	},
+	{
+		// finds the invisible around it for a while: the assassin
+		id: 'abilitiesDust',
+		name: 'Dust of Appearance',
+		description: 'Finds invisible enemies within 9 of the caster for 8 seconds',
+		hotkey: 'W',
+		target: 'none',
+		cooldown: 1,
+		effects: [{ type: 'detect', radius: 9, duration: 8 }]
+	},
+	{
+		id: 'abilitiesCastWindWalk',
+		name: 'Wind Walk',
+		description: 'The caster is unseen by enemies for 10 seconds, until it attacks or casts',
+		hotkey: 'E',
+		target: 'none',
+		cooldown: 1,
+		effects: [{ type: 'buff', buff: 'abilitiesWindWalk', on: 'caster' }]
+	},
+	{
+		// every enemy within 30 seen for 6 seconds, wherever it goes
+		id: 'abilitiesThrill',
+		name: 'Thrill of the Hunt',
+		description: 'Every enemy within 30 is seen for 6 seconds, wherever it goes, hidden or not',
+		hotkey: 'R',
+		target: 'none',
+		cooldown: 1,
+		effects: [{ type: 'revealUnit', radius: 30, duration: 6 }]
+	},
+	{
+		id: 'abilitiesMark',
+		name: 'Hunter’s Mark',
+		description: 'Marks the sentry (once seen): seen wherever it runs for 12 seconds',
+		hotkey: 'T',
+		target: 'unit',
+		targets: { enemies: true },
+		range: 99,
+		cooldown: 1,
+		effects: [{ type: 'buff', buff: 'abilitiesHunted' }]
+	},
+	{
+		id: 'abilitiesGhostwaterDive',
+		name: 'Ghostwater Dive',
+		description: 'The caster is seen only from within 3 cells, for 8 seconds',
+		hotkey: 'D',
+		target: 'none',
+		cooldown: 1,
+		effects: [{ type: 'buff', buff: 'abilitiesGhostwater', on: 'caster' }]
+	},
+	{
+		id: 'abilitiesOracleLens',
+		name: 'Oracle Lens',
+		description: 'True sight within 10 for 10 seconds: the assassin and the ranger',
+		hotkey: 'F',
+		target: 'none',
+		cooldown: 1,
+		effects: [{ type: 'buff', buff: 'abilitiesOracle', on: 'caster' }]
+	}
+]
+
+export const vision: Family = {
+	abilities,
+	buffs,
+	units: [
+		caster(
+			'abilitiesSeer',
+			'Seer',
+			abilities.map((each) => each.id),
+			{ sight: 9 }
+		),
+		// invisible as it is: found only by detection or true sight
+		sparring('abilitiesAssassin', 'Assassin', { invisible: { after: 0 } }),
+		sparring('abilitiesSentry', 'Sentry', { sight: 6 })
+	],
+	example: {
+		id: 'abilities-vision',
+		category: 'abilities',
+		title: 'Vision and stealth',
+		summary:
+			'In the fog of war: an invisible assassin stands near you, a camouflaged ranger to the right, a sentry far north. Light the north, find the hidden, mark the sentry so it is seen as it walks, go unseen yourself.',
+		tags: ['vision', 'fog', 'reveal', 'invisible', 'stealth', 'detect', 'true sight', 'camouflage', 'far sight', 'mark'],
+		source: ['examples/abilities/vision.ts', 'examples/abilities/kit.ts'],
+		map: () => exampleField({ name: 'Vision', players: 2 }),
+		// the fog of war, for once
+		reveal: false,
+		start: (world) => {
+			put(world, 'abilitiesSeer', PLAYER, { x: 24, z: 14 }, 'caster')
+			put(world, 'abilitiesAssassin', ENEMY, { x: 22, z: 18.5 }, 'assassin', Math.PI)
+			const ranger = put(world, 'abilitiesTarget', ENEMY, { x: 28.5, z: 18 }, 'ranger', Math.PI)
+			applyBuff(world, ranger, 'abilitiesCamouflage')
+			// the sentry, in the north out of sight: set walking as the page starts (`walkAgain`)
+			put(world, 'abilitiesSentry', ENEMY, { x: 22, z: 36 }, 'sentry', Math.PI)
+		}
+	}
+}

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

@@ -0,0 +1,50 @@
+/** How the vision example looks, and its card: a button for each, and what the player sees of the enemies */
+import { readout } from '../../shell/look'
+import { character, hold, person, sharedLooks } from '../common/looks'
+import { ENEMY } from '../common/units'
+import type { FamilyLooks } from './looks'
+import { castButton, look, readyOn, resetButton } from './lookKit'
+import { walkAgain } from './control'
+import { vision } from './vision'
+
+/** Where each is aimed, where the nearest enemy is not it */
+const aims: Record<string, { at?: string; point?: { x: number; z: number } }> = {
+	abilitiesFarSight: { point: { x: 26, z: 37 } },
+	abilitiesMark: { at: 'sentry' }
+}
+
+export const visionLooks: FamilyLooks = {
+	units: {
+		abilitiesSeer: { ...sharedLooks.mage, model: character('mage', 0.72, { hold: [hold('wand'), hold('spellbook_open', 'l')] }) },
+		abilitiesAssassin: { height: 1.8, model: character('rogue_hooded', 0.72, { hold: [hold('dagger'), hold('dagger', 'l')] }), shapes: person(1.8) },
+		abilitiesSentry: sharedLooks.archer
+	},
+	abilities: {
+		abilitiesFarSight: look([0.5, 0.8, 1], 'mark', { options: { column: true, fill: true } }),
+		abilitiesDust: look([1, 0.9, 0.6], 'sonar'),
+		abilitiesThrill: look([1, 0.4, 0.3], 'sonar'),
+		abilitiesMark: look([1, 0.3, 0.2], 'burst'),
+		abilitiesWindWalk: look([0.8, 0.9, 1], undefined, { aura: 'glow', options: { shape: 'dust' } }),
+		abilitiesHunted: look([1, 0.3, 0.2], undefined, { aura: 'glow', options: { shape: 'ring', at: 'head' } }),
+		abilitiesGhostwater: look([0.4, 0.6, 1], undefined, { aura: 'glow', options: { shape: 'fall' } }),
+		abilitiesOracle: look([1, 0.85, 0.3], undefined, { aura: 'glow', options: { shape: 'ring' } })
+	},
+	examples: {
+		'abilities-vision': {
+			ready: (client) => {
+				readyOn(client, 'abilitiesSeer', { minX: 15, minZ: 5, maxX: 33, maxZ: 40 })
+				client.session.send(walkAgain.make({}))
+			},
+			controls: [
+				...vision.abilities.map((ability) => castButton(ability, aims[ability.id])),
+				resetButton('abilities-vision'),
+				readout('Enemies you see', (client) => {
+					const seen = client.session.snapshot().entities.filter((each) => each.owner === ENEMY && each.visible && each.health > 0)
+					return seen.length
+						? seen.map((each) => (each.type === 'abilitiesTarget' ? 'ranger' : each.type.replace('abilities', '').toLowerCase())).join(', ')
+						: 'none'
+				})
+			]
+		}
+	}
+}

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

@@ -0,0 +1,235 @@
+/**
+ * The animation examples on the rules' side (`ExampleCategory`): the shared art's characters as unit types of their
+ * own, each to be drawn with its model and its clips (`./looks.ts`), and what the examples set them doing. The rules
+ * know nothing of clips: a unit stands, walks, swings and dies, and the client plays the clip for it
+ */
+import { defineCommand, defineIds, type Game, type UnitTypeDef, type Vec2, type World, exactMath } from '@v12-engine/engine'
+import { ENEMY, PLAYER, UNIT } from '../common/units'
+import { type ExampleCategory, exampleField } from '../define'
+
+/** The characters of the shared art (`characters/<name>.glb`), one unit type each */
+export const CHARACTERS = [
+	'knight',
+	'barbarian',
+	'mage',
+	'ranger',
+	'rogue',
+	'rogue_hooded',
+	'skeleton_warrior',
+	'skeleton_mage',
+	'skeleton_rogue',
+	'skeleton_minion'
+] as const
+export type Character = (typeof CHARACTERS)[number]
+
+/** A unit type's id for each character: `animationKnight` */
+export const characterType = (name: Character): string => `animation${name.replace(/(^|_)(\w)/g, (_, _sep: string, c: string) => c.toUpperCase())}`
+
+/** The category's own units besides: swordsmen that swing in different ways, walkers at three paces, and the fallen */
+export const ANIM = defineIds(
+	'animationTurns',
+	'animationRandom',
+	'animationTwoHanded',
+	'animationSlow',
+	'animationJog',
+	'animationRun',
+	'animationWielder',
+	'animationVictim',
+	'animationWaver'
+)
+
+/** A character that stands where it is put: it does nothing of its own, the card plays its clips */
+const standing = (id: string, name: string): UnitTypeDef => ({ id, name, kind: 'unit', radius: 0.45, stats: { health: 500, moveSpeed: 0 }, sight: 6 })
+
+/** A swordsman that hits the dummy in front of it for ever */
+const swordsman = (id: string, name: string, attackSpeed: number): UnitTypeDef => ({
+	id,
+	name,
+	kind: 'unit',
+	radius: 0.45,
+	stats: { health: 500, attackDamage: 10, attackSpeed, attackRange: 0.6, moveSpeed: 4 },
+	sight: 6,
+	attacks: [{ damagePoint: 0.4, acquisitionRange: 4 }]
+})
+
+/** A walker of a pace: its clips are matched to how fast it goes (`./looks.ts`) */
+const walker = (id: string, name: string, moveSpeed: number): UnitTypeDef => ({
+	id,
+	name,
+	kind: 'unit',
+	radius: 0.45,
+	stats: { health: 500, moveSpeed },
+	sight: 6
+})
+
+const units: UnitTypeDef[] = [
+	...CHARACTERS.map((name) => standing(characterType(name), name.replace('_', ' '))),
+	swordsman(ANIM.animationTurns, 'Swings in turn', 1),
+	swordsman(ANIM.animationRandom, 'Swings at random', 1),
+	swordsman(ANIM.animationTwoHanded, 'Two-handed', 0.8),
+	walker(ANIM.animationSlow, 'Stroller', 2),
+	walker(ANIM.animationJog, 'Walker', 3.2),
+	walker(ANIM.animationRun, 'Runner', 6.5),
+	swordsman(ANIM.animationWielder, 'Wielder', 1),
+	{ ...standing(ANIM.animationVictim, 'Fallen'), stats: { health: 300, moveSpeed: 0 } },
+	walker(ANIM.animationWaver, 'Waver', 3)
+]
+
+/** `count` of a type in a row across x, `gap` apart, round `at`, facing the camera (south) */
+function row(world: World, types: readonly string[], at: Vec2, gap: number, owner = PLAYER): void {
+	types.forEach((type, i) => world.spawn(type, { at: { x: at.x + (i - (types.length - 1) / 2) * gap, z: at.z }, owner, facing: Math.PI }))
+}
+
+/** The fallen of the deaths example stood up again: those dead taken away, a row of five laid out anew */
+export const raise = defineCommand('animation.raise', {}, (world) => {
+	for (const unit of [...world.units.values()]) if (unit.alive && unit.def.id === ANIM.animationVictim) world.kill(unit, undefined, false, 'removed')
+	row(world, Array(5).fill(ANIM.animationVictim), { x: 24, z: 24 }, 2.2)
+})
+
+/** One of the fallen struck down, the one at `index` along the row (or the first left standing) */
+export const strike = defineCommand('animation.strike', {}, (world) => {
+	const left = [...world.units.values()].filter((unit) => unit.alive && unit.def.id === ANIM.animationVictim).sort((a, b) => a.pos.x - b.pos.x)
+	const unit = left[0]
+	if (unit) world.kill(unit)
+})
+
+/** Walkers that go to the far side of a track and back for ever: a system on the paces example's field */
+const pacing = {
+	name: 'animation.pacing',
+	every: 10,
+	update: (world: World) => {
+		if (world.map?.name !== 'Paces') return
+		for (const unit of world.units.values()) {
+			if (!unit.alive || unit.orders.length || !unit.def.stats.moveSpeed) continue
+			unit.order('move', { x: unit.pos.x < 24 ? 36 : 12, z: unit.pos.z })
+		}
+	}
+}
+
+/** The waver of the layered example walking round a square for ever */
+const circling = {
+	name: 'animation.circling',
+	every: 5,
+	update: (world: World) => {
+		if (world.map?.name !== 'Layers') return
+		const corners = [
+			{ x: 18, z: 18 },
+			{ x: 30, z: 18 },
+			{ x: 30, z: 30 },
+			{ x: 18, z: 30 }
+		]
+		for (const unit of world.units.values()) {
+			if (!unit.alive || unit.def.id !== ANIM.animationWaver || unit.orders.length) continue
+			// the corner after the one it stands nearest
+			const near = corners.reduce(
+				(best, each, i) =>
+					exactMath.hypot(each.x - unit.pos.x, each.z - unit.pos.z) < exactMath.hypot(corners[best]!.x - unit.pos.x, corners[best]!.z - unit.pos.z)
+						? i
+						: best,
+				0
+			)
+			unit.order('move', corners[(near + 1) % corners.length]!)
+		}
+	}
+}
+
+export const category: ExampleCategory = {
+	rules: (game: Game<any>) => {
+		for (const unit of units) game.unit(unit)
+		game.command(raise)
+		game.command(strike)
+		game.system(pacing)
+		game.system(circling)
+	},
+	examples: [
+		{
+			id: 'animation-clips',
+			category: 'animation',
+			title: 'Every clip of every character',
+			summary:
+				"The shared art's ten characters in a row. Pick a clip and they all play it at once (the skeletons have six of their own); slow it down, speed it up, or loop it.",
+			tags: ['clips', 'playClip', 'characters', 'models', 'KayKit', 'skeletons', 'browser'],
+			start: (world) => row(world, CHARACTERS.map(characterType), { x: 24, z: 24 }, 2.1),
+			source: ['examples/animation/index.ts', 'examples/animation/looks.ts']
+		},
+		{
+			id: 'animation-attacks',
+			category: 'animation',
+			title: 'Swings in turn, at random, two-handed',
+			summary:
+				"Three swordsmen at dummies, each with an attack look of its own: three swings in turn, the same three at random, and a two-handed chop and slice. The blow lands on the clip's hit, at any attack speed.",
+			tags: ['attack', 'clips', 'AttackLook', 'order', 'random', 'damagePoint', 'hit mark', 'swing'],
+			map: () => exampleField({ name: 'Swings', players: 2 }),
+			start: (world) => {
+				const types = [ANIM.animationTurns, ANIM.animationRandom, ANIM.animationTwoHanded]
+				types.forEach((type, i) => {
+					const x = 18 + i * 6
+					// side on to the camera: the swordsman to the west, its dummy to the east
+					world.spawn(type, { at: { x: x - 0.7, z: 24 }, owner: PLAYER, facing: Math.PI / 2 })
+					world.spawn(UNIT.dummy, { at: { x: x + 0.7, z: 24 }, owner: ENEMY, facing: -Math.PI / 2 })
+				})
+			},
+			source: ['examples/animation/index.ts', 'examples/animation/looks.ts']
+		},
+		{
+			id: 'animation-blending',
+			category: 'animation',
+			title: 'Blending one clip into the next',
+			summary:
+				'A knight and a barbarian switch between the same clips, the knight blending each into the next, the barbarian snapping. Slide the blend time and pick the clips.',
+			tags: ['blend', 'blends', 'BlendDef', 'transition', 'crossfade', 'clips'],
+			start: (world) => row(world, [characterType('knight'), characterType('barbarian')], { x: 24, z: 24 }, 3),
+			source: ['examples/animation/index.ts', 'examples/animation/looks.ts']
+		},
+		{
+			id: 'animation-paces',
+			category: 'animation',
+			title: 'Feet on the ground at any pace',
+			summary:
+				'Three walkers at three speeds: a stroll, a walk and a run, each clip played as fast as the unit goes, so the feet keep to the ground. Turn the matching off to see them slide.',
+			tags: ['walk', 'run', 'stride', 'speed', 'loop', 'foot sliding', 'moveSpeed'],
+			map: () => exampleField({ name: 'Paces' }),
+			start: (world) => {
+				world.spawn(ANIM.animationSlow, { at: { x: 12, z: 21.5 }, owner: PLAYER })
+				world.spawn(ANIM.animationJog, { at: { x: 12, z: 24 }, owner: PLAYER })
+				world.spawn(ANIM.animationRun, { at: { x: 12, z: 26.5 }, owner: PLAYER })
+			},
+			source: ['examples/animation/index.ts', 'examples/animation/looks.ts']
+		},
+		{
+			id: 'animation-weapons',
+			category: 'animation',
+			title: 'Gear in hand',
+			summary:
+				'A knight at a dummy, with what it holds in each hand chosen on the card: the weapon is hung from the hand bone and moves with every clip, and the swing changes with it.',
+			tags: ['hold', 'weapons', 'gear', 'handslot', 'swap', 'equipment', 'looks.set'],
+			map: () => exampleField({ name: 'Gear', players: 2 }),
+			start: (world) => {
+				world.spawn(ANIM.animationWielder, { at: { x: 23.3, z: 24 }, owner: PLAYER, facing: Math.PI / 2 })
+				world.spawn(UNIT.dummy, { at: { x: 24.7, z: 24 }, owner: ENEMY, facing: -Math.PI / 2 })
+			},
+			source: ['examples/animation/index.ts', 'examples/animation/looks.ts']
+		},
+		{
+			id: 'animation-deaths',
+			category: 'animation',
+			title: 'Deaths and what is left',
+			summary:
+				'Five skeletons in a row, each with a death of its own: a fall, another fall, one that keeps its body, one that shatters to pieces, one that sinks away. Strike them down one by one, and raise them again.',
+			tags: ['death', 'die', 'DeathLook', 'corpse', 'shatter', 'clip', 'remains'],
+			start: (world) => row(world, Array(5).fill(ANIM.animationVictim), { x: 24, z: 24 }, 2.2),
+			source: ['examples/animation/index.ts', 'examples/animation/looks.ts']
+		},
+		{
+			id: 'animation-layers',
+			category: 'animation',
+			title: 'Upper body, lower body',
+			summary:
+				'A mage walks round a square while the card plays a clip on its upper body alone: the legs keep walking under a cast, a throw or a wave. Or play it on the whole body to see the difference.',
+			tags: ['mask', 'layer', 'upper body', 'ClipMask', 'playClip', 'additive', 'walk'],
+			map: () => exampleField({ name: 'Layers' }),
+			start: (world) => world.spawn(ANIM.animationWaver, { at: { x: 18, z: 18 }, owner: PLAYER }),
+			source: ['examples/animation/index.ts', 'examples/animation/looks.ts']
+		}
+	]
+}