@v12-engine/create 0.0.0-stage → 0.1.0

package/starters/melee/src/melee/bay.ts

@@ -0,0 +1,319 @@
+/**
+ * The Bay: melee's own map, made by a generator and always the same (master plan FG2). A sea in the middle with the
+ * shore all round it, four starts in the corners on high ground, each with its mine and woods behind, more mines along
+ * the shore guarded by camps of rising strength, an island in the middle with an alchemist on it reached by fords of
+ * shallow water, roads between the starts, the map mirrored both ways so that each corner is the others'. Made of the
+ * engine's passes (`basinShape` for the lie of the land) and melee's (`meleeGenerator`'s mines, camps and woods);
+ * `bayMap()` is the map itself, which `npm run map generate` writes to `maps/bay.vgmap.json` for the editor
+ */
+import {
+	basinShape,
+	clearGround,
+	createRegistry,
+	exactMath,
+	generateMap,
+	type GameMap,
+	type GeneratorContext,
+	MAP_NEUTRAL,
+	type MapGenerator,
+	resourcesPass,
+	roadsPass,
+	scatterPass,
+	startsPass,
+	terrainPass,
+	tilesPass,
+	type Vec2,
+	WATER_DEEP,
+	WATER_NONE,
+	WATER_SHALLOW
+} from '@v12-engine/engine'
+import { melee } from './index'
+import { meleeGenerator } from './generator'
+
+/** The island is this much of the way from the middle to a corner */
+const ISLAND = 0.16
+
+/** Who guards an expansion's mine, by how far from the starts it stands: the farther, the stronger */
+const GUARDS: string[][] = [['gnoll', 'gnoll'], ['gnoll', 'gnoll', 'gnoll'], ['ogre'], ['ogre', 'gnoll', 'gnoll']]
+
+/** Who holds the island */
+const ISLAND_GUARD = ['ogre', 'ogre', 'troll']
+
+/** A place rounded to the whole cell corner away from the map's middle: the same corner on every mirrored side */
+const awayFromMiddle = (v: number, size: number): number => (v < size / 2 ? Math.floor(v) : Math.ceil(v))
+
+/** How far a point is from the nearest start, in cells */
+function fromStarts(ctx: GeneratorContext, at: Vec2): number {
+	let near = Infinity
+	for (const player of ctx.map.players) if (player.start) near = Math.min(near, exactMath.hypot(player.start.x - at.x, player.start.z - at.z))
+	return near
+}
+
+/**
+ * The island's fords: shallow water from the island's rim towards each corner, as wide as three cells, so that what
+ * walks reaches the alchemist. One ford, mirrored to the other three
+ */
+const fordsPass = {
+	id: 'fords',
+	name: 'The fords',
+	run(ctx: GeneratorContext) {
+		const { map } = ctx
+		const { width, depth } = map
+		const middle = { x: width / 2, z: depth / 2 }
+		const reach = (Math.min(width, depth) / 2) * Math.SQRT2 * 0.55
+		for (let t = 0; t < reach; t += 0.5) {
+			const x = middle.x - t * Math.SQRT1_2
+			const z = middle.z - t * Math.SQRT1_2
+			for (const place of ctx.symmetric(x, z))
+				for (let dz = -1; dz <= 1; dz++)
+					for (let dx = -1; dx <= 1; dx++) {
+						const cx = Math.floor(place.x) + dx
+						const cz = Math.floor(place.z) + dz
+						if (cx < 0 || cz < 0 || cx >= width || cz >= depth) continue
+						const c = cz * width + cx
+						if (map.water[c] === WATER_DEEP) map.water[c] = WATER_SHALLOW
+					}
+		}
+	}
+}
+
+/**
+ * The woods behind each start: between the start and its corner, thick, for lumber from the first minute. One start's,
+ * mirrored to the others
+ */
+const woodsBehindPass = {
+	id: 'woods',
+	name: 'The woods behind the starts',
+	run(ctx: GeneratorContext) {
+		const { map, rng } = ctx
+		const start = map.players.find((player) => player.start)?.start
+		if (!start) return
+		// away from the middle: the way to the corner
+		const away = exactMath.atan2(start.z - map.depth / 2, start.x - map.width / 2)
+		const put = new Set<number>()
+		for (let i = 0; i < 400; i++) {
+			const far = 9 + rng.next() * 9
+			const turn = away + (rng.next() - 0.5) * Math.PI * 0.9
+			const x = Math.floor(start.x + exactMath.cos(turn) * far)
+			const z = Math.floor(start.z + exactMath.sin(turn) * far)
+			if (x < 1 || z < 1 || x >= map.width - 1 || z >= map.depth - 1) continue
+			const c = z * map.width + x
+			if (put.has(c) || map.water[c] !== 0 || !ctx.free(x + 0.5, z + 0.5, 4, ['resource', 'start'])) continue
+			put.add(c)
+			for (const place of ctx.symmetric(x + 0.5, z + 0.5)) {
+				ctx.mark('trees', place.x, place.z, 0.75)
+				ctx.addObject('tree', MAP_NEUTRAL, Math.floor(place.x) + 0.5, Math.floor(place.z) + 0.5)
+			}
+		}
+	}
+}
+
+/** The alchemist on the island, with its guards, and the island marked so that nothing else goes there */
+const islandPass = {
+	id: 'island',
+	name: 'The island',
+	run(ctx: GeneratorContext) {
+		const { map } = ctx
+		const at = { x: Math.round(map.width / 2), z: Math.round(map.depth / 2) }
+		ctx.mark('island', at.x, at.z, 10)
+		ctx.addObject('alchemist', MAP_NEUTRAL, at.x, at.z, { name: 'the island alchemist' })
+		ctx.addCamp(at.x + 4.5, at.z - 4.5, ISLAND_GUARD, { name: 'the island guard' })
+	}
+}
+
+/** A tavern on the island beside the alchemist, its heroes for whoever crosses: put down last, so that what was there keeps its ids */
+const tavernPass = {
+	id: 'tavern',
+	name: 'The tavern',
+	run(ctx: GeneratorContext) {
+		const { map } = ctx
+		ctx.addObject('tavern', MAP_NEUTRAL, Math.round(map.width / 2) - 4.5, Math.round(map.depth / 2) + 4.5, { name: 'the island tavern' })
+	}
+}
+
+/**
+ * A goblin shipyard on the shore of each side's part of the bay, its transport ships for whoever comes: on dry land
+ * free of everything, with deep water a few cells off, the nearest such to a place between the start and the island;
+ * mirrored to the other three. Put down last, as the tavern is
+ */
+const shipyardsPass = {
+	id: 'shipyards',
+	name: 'The goblin shipyards',
+	run(ctx: GeneratorContext) {
+		const { map } = ctx
+		const { width, depth } = map
+		const dry = (x: number, z: number) => x >= 0 && z >= 0 && x < width && z < depth && map.water[z * width + x] === WATER_NONE
+		const deepNear = (x: number, z: number) => {
+			for (let dz = -4; dz <= 4; dz++)
+				for (let dx = -4; dx <= 4; dx++) {
+					const cx = x + dx
+					const cz = z + dz
+					if (cx >= 0 && cz >= 0 && cx < width && cz < depth && map.water[cz * width + cx] === WATER_DEEP) return true
+				}
+			return false
+		}
+		const wanted = { x: width * 0.2, z: depth * 0.38 }
+		let best: { x: number; z: number } | undefined
+		let nearest = Infinity
+		for (let z = 2; z < depth / 2; z++)
+			for (let x = 2; x < width / 2; x++) {
+				let fits = true
+				for (let dz = -1; dz <= 1 && fits; dz++) for (let dx = -1; dx <= 1 && fits; dx++) fits = dry(x + dx, z + dz)
+				if (!fits || !deepNear(x, z) || !ctx.free(x + 0.5, z + 0.5, 3)) continue
+				const far = exactMath.hypot(x + 0.5 - wanted.x, z + 0.5 - wanted.z)
+				if (far < nearest) {
+					nearest = far
+					best = { x: x + 0.5, z: z + 0.5 }
+				}
+			}
+		if (!best) return
+		for (const place of ctx.symmetric(best.x, best.z)) ctx.addObject('goblinShipyard', MAP_NEUTRAL, place.x, place.z)
+	}
+}
+
+/**
+ * The mines of the bay: one by each start, the same way from each (mirrored from the first, so the walk to it is the
+ * same for everyone), and more along the shore, each guarded by a camp the stronger the farther from a start
+ */
+const minesPass = {
+	id: 'mines',
+	name: 'The gold mines',
+	run(ctx: GeneratorContext) {
+		const { map } = ctx
+		const first = map.players.find((player) => player.start)?.start
+		if (first) {
+			// towards the middle and to one side of the way down (the ramp of `rampsDownPass` goes straight), on the start's
+			// level: its workers walk to it, and nothing stands in the way to the shore
+			const toward = exactMath.atan2(map.depth / 2 - first.z, map.width / 2 - first.x)
+			const aside = toward - Math.PI / 2
+			const at = {
+				x: Math.round(first.x + exactMath.cos(toward) * 7 + exactMath.cos(aside) * 7),
+				z: Math.round(first.z + exactMath.sin(toward) * 7 + exactMath.sin(aside) * 7)
+			}
+			for (const place of ctx.symmetric(at.x, at.z)) {
+				const mine = { x: Math.round(place.x), z: Math.round(place.z) }
+				const start = map.players.find((player) => player.start && exactMath.hypot(player.start.x - mine.x, player.start.z - mine.z) < 14)?.start
+				clearGround(ctx, mine, 3, true, start ? ctx.levelAt(start.x, start.z) : undefined)
+				ctx.mark('resource', mine.x, mine.z, 3)
+				ctx.addObject('goldmine', MAP_NEUTRAL, mine.x, mine.z)
+			}
+		}
+		resourcesPass({
+			main: false,
+			extra: ctx.param('mines', 2),
+			spacing: 22,
+			from: (ctx, at) => {
+				// a mine stands on whole cells (4 by 4), its middle on a corner of them: the corner of the cell away from the map's
+				// middle, whose mirror is the mirrored cell's own (a half rounded up on both sides of the map is no mirror)
+				const mine = { x: awayFromMiddle(at.x, ctx.map.width), z: awayFromMiddle(at.z, ctx.map.depth) }
+				ctx.addObject('goldmine', MAP_NEUTRAL, mine.x, mine.z)
+				const far = fromStarts(ctx, at)
+				const guards = GUARDS[Math.min(GUARDS.length - 1, Math.floor((far / Math.max(ctx.map.width, ctx.map.depth)) * 8))]
+				// guarded from the side of the sea, four whole cells towards the middle each way: the same side of every
+				// mirrored one, and whole cells so that the mirrors are exact
+				const guard = { x: mine.x + Math.sign(ctx.map.width / 2 - mine.x) * 4, z: mine.z + Math.sign(ctx.map.depth / 2 - mine.z) * 4 }
+				ctx.mark('camps', guard.x, guard.z, 3)
+				ctx.addCamp(guard.x, guard.z, guards)
+			}
+		}).run(ctx)
+	}
+}
+
+/**
+ * The way down to the bay: from each start towards the middle, where the ground first drops a level, a ramp four
+ * cells wide, so that every base has its own way to the shore (the engine's ramps join what it can across straight
+ * stretches of cliff, and a shore this rough has few). One start's, mirrored to the others
+ */
+const rampsDownPass = {
+	id: 'rampsDown',
+	name: 'The ways down',
+	run(ctx: GeneratorContext) {
+		const { map } = ctx
+		const { width } = map
+		const first = map.players.find((player) => player.start)?.start
+		if (!first) return
+		const toward = exactMath.atan2(map.depth / 2 - first.z, map.width / 2 - first.x)
+		const dx = exactMath.cos(toward)
+		const dz = exactMath.sin(toward)
+		let level = ctx.levelAt(first.x, first.z)
+		for (let t = 0; t < 60; t += 1) {
+			const x = first.x + dx * t
+			const z = first.z + dz * t
+			const here = ctx.levelAt(x, z)
+			if (here === level) continue
+			if (here !== level - 1) break
+			// the edge is between t - 1 and t: a ramp of the cells two deep either side, four wide across the way
+			for (let along = -2; along < 2; along++)
+				for (let deep = -2; deep < 2; deep++) {
+					const cx = Math.floor(x - dz * along + dx * deep)
+					const cz = Math.floor(z + dx * along + dz * deep)
+					for (const place of ctx.symmetric(cx + 0.5, cz + 0.5)) {
+						const c = Math.floor(place.z) * width + Math.floor(place.x)
+						if (c >= 0 && c < map.ramps.length && map.water[c] === 0) map.ramps[c] = 1
+					}
+				}
+			level = here
+			if (here === 0) break
+		}
+	}
+}
+
+/** Roads along the shore: from each start to the next round the bay, not across it */
+const roadsAroundPass = {
+	id: 'roads',
+	name: 'The roads',
+	run(ctx: GeneratorContext) {
+		const { map } = ctx
+		const starts = map.players.flatMap((player) => (player.start ? [player.start] : []))
+		const around = [...starts].sort(
+			(a, b) => exactMath.atan2(a.z - map.depth / 2, a.x - map.width / 2) - exactMath.atan2(b.z - map.depth / 2, b.x - map.width / 2)
+		)
+		for (let i = 0; i < around.length; i++) roadsPass({ tile: 'road', width: 2, between: [around[i], around[(i + 1) % around.length]] }).run(ctx)
+	}
+}
+
+/** The generator of the bay: the parameters of melee's own but the ground's, which the bay's shape decides */
+export const bayGenerator: MapGenerator = {
+	params: meleeGenerator.params.filter((param) => !['levels', 'water', 'roughness', 'hills'].includes(param.id)),
+	passes: [
+		terrainPass({ shape: basinShape({ island: ISLAND, roughness: 0.4 }), levels: 3, water: 0.2, roughness: 0.3, hills: 40, rampWidth: 4 }),
+		tilesPass(),
+		fordsPass,
+		// room for a hall and its workers in each corner: the race puts them there as the game starts
+		startsPass({ clearing: 8, spread: 0.46 }),
+		islandPass,
+		minesPass,
+		rampsDownPass,
+		woodsBehindPass,
+		// camps about the map: on the land, away from the starts, off the mines and each other
+		scatterPass({
+			kind: 'camps',
+			spacing: 24,
+			avoid: 28,
+			patches: 0,
+			avoidKinds: { resource: 8, camps: 20, island: 12 },
+			where: (cell) => !cell.shore,
+			// who guards it by how far out it stands, not by a draw: a draw is made again for each mirrored one, and differs
+			what: (ctx, at) => ctx.addCamp(at.x, at.z, GUARDS[fromStarts(ctx, at) > 40 ? 1 : 0])
+		}),
+		// woods: trees to cut, thick behind the starts, off the mines and the camps and not on the island
+		scatterPass({
+			kind: 'trees',
+			spacing: 1.5,
+			avoid: 12,
+			avoidKinds: { resource: 5, camps: 4, island: 12, trees: 1 },
+			what: (ctx, at) => void ctx.addObject('tree', MAP_NEUTRAL, Math.floor(at.x) + 0.5, Math.floor(at.z) + 0.5)
+		}),
+		roadsAroundPass,
+		tavernPass,
+		shipyardsPass
+	]
+}
+
+/** How the bay is made: the same every time */
+export const BAY = { seed: 7, width: 192, depth: 192, players: 4, symmetry: 'both', name: 'The Bay', params: { mines: 2, trees: 0.2 } } as const
+
+/** The Bay, made anew: what `maps/bay.vgmap.json` holds, and what the editor opens */
+export function bayMap(): GameMap {
+	return generateMap(bayGenerator, { ...BAY }, createRegistry(melee)).map
+}

package/starters/melee/src/melee/blight.ts

@@ -0,0 +1,102 @@
+import { defineComponent, presetBlight, defineHook, type Entity, type RaceHookDef, raceOf, type SystemDef, type World, deposit } from '@v12-engine/engine'
+
+/*
+ * How the Restless plays differently (features-plan C5), in hooks of its race and a system of the game's: its acolytes
+ * gather gold only at a cursed mine of their own, standing round it (the engine's `builtOn`), and its buildings go
+ * up on blight, which spreads from its halls and cursed mines and heals its units that stand on it
+ */
+
+/**
+ * Ground the Restless has spoiled: the engine's blight layer (`presetBlight`), painted as the game goes (and on a map,
+ * by its maker), drawn with the client's `blightLook`. What it does is melee's: the undead build on it, and heal on it
+ */
+export const blightLayer = presetBlight
+
+/** What spreads blight round it, once it stands finished: the halls and the cursed mine */
+const SOURCES = new Set(['gravehold', 'hallOfBones', 'duskCitadel', 'cursedMine'])
+/** What goes up anywhere: what blight comes from */
+const ANYWHERE = SOURCES
+/** How far blight goes from what spreads it, in cells, and how much further it goes each time the system runs */
+export const BLIGHT_RADIUS = 9
+const SPREAD = 1
+/** Health a second the undead get on blight */
+const HEALING = 2
+/** Ticks between two runs of the system */
+const EVERY = 30
+
+/** How far blight has spread from each of what spreads it, by id: kept by a save, it goes on spreading where it was */
+export const blightSpread = defineComponent<Record<string, number>>('melee.blight', { default: () => ({}) })
+
+/** Whether the ground at a point is blighted */
+export const blighted = (world: World, x: number, z: number): boolean => world.terrain.cellAt('blight', x, z) > 0
+
+/** Whether the whole ground of a building's site is blighted: its corners and its middle */
+function siteBlighted(world: World, site: { x: number; z: number; hw: number; hd: number }): boolean {
+	const inset = 0.5
+	return [
+		[site.x, site.z],
+		[site.x - site.hw + inset, site.z - site.hd + inset],
+		[site.x + site.hw - inset, site.z - site.hd + inset],
+		[site.x - site.hw + inset, site.z + site.hd - inset],
+		[site.x + site.hw - inset, site.z + site.hd - inset]
+	].every(([x, z]) => blighted(world, x, z))
+}
+
+/** What the Restless does its own way: given to its race (`RaceDef.hooks`), run only for what is of its players */
+export const undeadHooks: RaceHookDef[] = [
+	// gold only at a cursed mine of their own, finished: there they gather round it, and hand in on the spot
+	defineHook({
+		hook: 'canHarvest',
+		id: 'undead.hauntedGold',
+		run(world, event) {
+			if (!event.allowed || event.source.def.resource?.kind !== 'gold') return
+			const haunted = world.get(event.source.get(deposit)?.under)
+			if (haunted?.alive && haunted.operational && haunted.owner === event.worker.owner) return
+			event.allowed = false
+			event.reason = { key: 'needsHauntedMine' }
+		}
+	}),
+	// its buildings on blight, but what blight comes from
+	defineHook({
+		hook: 'canPlace',
+		id: 'undead.onBlight',
+		run(world, event) {
+			if (!event.allowed || event.def.kind !== 'building' || ANYWHERE.has(event.def.id)) return
+			if (siteBlighted(world, event.site)) return
+			event.allowed = false
+			event.reason = { key: 'needsBlight' }
+		}
+	})
+]
+
+/**
+ * Blight spreading from what the undead have finished of what spreads it, a cell further each time up to
+ * `BLIGHT_RADIUS`, and the undead on it healed. Blight stays where it spread: only the map's maker takes it away
+ */
+export const blightSystem: SystemDef = {
+	name: 'melee.blight',
+	every: EVERY,
+	update(world, dt) {
+		// asked for only where something spreads blight: a game with no undead keeps nothing of it
+		let radii: Record<string, number> | undefined
+		let grew = false
+		for (const entity of world.actors.values()) {
+			if (!entity.alive || entity.hidden || raceOf(world, entity.owner) !== 'undead') continue
+			if (entity.isUnit) heal(world, entity, dt)
+			else if (SOURCES.has(entity.def.id) && entity.operational) {
+				radii ??= world.state(blightSpread)
+				const radius = Math.min((radii[entity.id] ?? 0) + SPREAD, BLIGHT_RADIUS)
+				if (radius === radii[entity.id]) continue
+				radii[entity.id] = radius
+				grew = true
+				world.setCells('blight', { kind: 'circle', x: entity.pos.x, z: entity.pos.z, radius: radius + entity.def.radius }, 1)
+			}
+		}
+		if (grew && radii) world.setState(blightSpread, radii)
+	}
+}
+
+function heal(world: World, unit: Entity, dt: number): void {
+	if (unit.hp >= unit.maxHp || !blighted(world, unit.pos.x, unit.pos.z)) return
+	world.heal(unit, HEALING * dt)
+}

package/starters/melee/src/melee/cellLayers.json

@@ -0,0 +1,11 @@
+{
+	"bush": {
+		"height": 2.9,
+		"density": 8,
+		"sway": 3,
+		"size": [
+			1.2,
+			1.6
+		]
+	}
+}

package/starters/melee/src/melee/data.json

@@ -0,0 +1,18 @@
+{
+	"rules": {
+		"combat": {
+			"damageTable": {
+				"attacks": ["normal", "pierce", "siege", "magic", "chaos", "hero"],
+				"armours": ["light", "medium", "heavy", "fortified", "hero", "unarmored"],
+				"table": [
+					[1, 1.5, 1, 0.7, 1, 1],
+					[2, 0.75, 1, 0.35, 0.5, 1.5],
+					[1, 0.5, 1, 1.5, 0.5, 1.5],
+					[1.25, 0.75, 2, 0.35, 0.5, 1],
+					[1, 1, 1, 1, 1, 1],
+					[1, 1, 1, 0.5, 1, 1]
+				]
+			}
+		}
+	}
+}

package/starters/melee/src/melee/floats.json

@@ -0,0 +1,199 @@
+{
+	"bounty": {
+		"text": "+{amount}",
+		"style": {
+			"color": "#ffd23c",
+			"size": 18,
+			"stroke": {
+				"color": "#1c1206",
+				"width": 3
+			}
+		},
+		"motion": [
+			{
+				"rise": 1.5,
+				"ease": "outQuad"
+			},
+			{
+				"pop": {
+					"from": 1.5,
+					"seconds": 0.2,
+					"ease": "outBack"
+				}
+			}
+		],
+		"seconds": 1.4
+	},
+	"crit": {
+		"text": "{amount}!",
+		"style": {
+			"color": "#ffb02e",
+			"size": 24,
+			"stroke": {
+				"color": "#1c1206",
+				"width": 3
+			}
+		},
+		"motion": [
+			{
+				"rise": 1.4,
+				"ease": "outQuad"
+			},
+			{
+				"pop": {
+					"from": 2.2,
+					"seconds": 0.25,
+					"ease": "outBack"
+				}
+			},
+			{
+				"shake": {
+					"amount": 3,
+					"seconds": 0.2
+				}
+			}
+		],
+		"seconds": 1.5,
+		"most": 30,
+		"within": 60
+	},
+	"damageTaken": {
+		"text": "-{amount}",
+		"style": {
+			"color": "#ff5040",
+			"stroke": {
+				"color": "#1c1206",
+				"width": 3
+			}
+		},
+		"merge": {
+			"window": 0.8,
+			"countUp": 0.25,
+			"pulse": {
+				"pop": {
+					"from": 1.3,
+					"seconds": 0.15
+				}
+			}
+		},
+		"motion": [
+			{
+				"drift": {
+					"x": -26,
+					"up": 1
+				},
+				"ease": "outQuad"
+			}
+		],
+		"seconds": 1.1,
+		"most": 60,
+		"within": 60
+	},
+	"heal": {
+		"text": "+{amount}",
+		"style": {
+			"color": "#7dff6a",
+			"stroke": {
+				"color": "#1c1206",
+				"width": 3
+			}
+		},
+		"merge": {
+			"key": "entity+kind",
+			"window": 1,
+			"countUp": 0.3
+		},
+		"motion": [
+			{
+				"rise": 1,
+				"ease": "outQuad"
+			}
+		],
+		"seconds": 1.2,
+		"within": 60
+	},
+	"levelUp": {
+		"text": "Level {amount}",
+		"style": {
+			"color": "#ffd23c",
+			"size": 22,
+			"stroke": {
+				"color": "#1c1206",
+				"width": 3
+			},
+			"background": {
+				"color": "rgba(28, 18, 6, 0.78)",
+				"padding": 5,
+				"radius": 4
+			}
+		},
+		"motion": [
+			{
+				"bounce": {
+					"height": 0.6,
+					"times": 3,
+					"seconds": 1.2
+				}
+			},
+			{
+				"pop": {
+					"from": 0.3,
+					"seconds": 0.3,
+					"ease": "outBack"
+				}
+			}
+		],
+		"offset": {
+			"y": -46
+		},
+		"seconds": 2.4
+	},
+	"mana": {
+		"text": "{+amount}",
+		"style": {
+			"color": "#6fb6ff",
+			"size": 15,
+			"stroke": {
+				"color": "#1c1206",
+				"width": 3
+			}
+		},
+		"at": "chest",
+		"motion": [
+			{
+				"drift": {
+					"x": 22,
+					"up": 0.8
+				},
+				"ease": "outQuad"
+			}
+		],
+		"seconds": 1.2
+	},
+	"xp": {
+		"text": "+{amount} xp",
+		"style": {
+			"color": "#c99cff",
+			"size": 15,
+			"stroke": {
+				"color": "#1c1206",
+				"width": 3
+			}
+		},
+		"merge": {
+			"key": "entity+kind",
+			"window": 1.5,
+			"countUp": 0.4
+		},
+		"motion": [
+			{
+				"rise": 0.9,
+				"ease": "outQuad"
+			}
+		],
+		"offset": {
+			"y": -40
+		},
+		"seconds": 1.6
+	}
+}

package/starters/melee/src/melee/formations.ts

@@ -0,0 +1,46 @@
+/**
+ * Melee's own formation, beside the engine's (`rows`, `circle`, `square`): the classic battle line, the fighters in front, those
+ * who shoot behind them and the casters (healers, those with no attack) at the back. Picked by the formation button
+ * beside the minimap, for every order to a point from then on
+ */
+import type { Entity, EntityId, FormationDef, Vec2, World } from '@v12-engine/engine'
+import { statsOf } from '@v12-engine/engine'
+
+/**
+ * Who stands in which row: 0 at the front for those who fight at arm's length, 1 for those who shoot, 2 for casters (those
+ * with mana: priests, sorceresses) and those with no attack
+ */
+function rowOf(world: World, unit: Entity): number {
+	if (!unit.def.attacks?.length || (unit.def.stats.mana ?? 0) > 0) return 2
+	const reach = statsOf(world, unit).attackRange ?? 0
+	return reach <= 1.5 ? 0 : 1
+}
+
+/**
+ * The battle line: a row of each kind across the way they go, as wide as needs be, the front row the fighters', each
+ * row's units in the order they stand side by side so that their ways do not cross
+ *
+ * @beta
+ */
+export const battleLine: FormationDef = {
+	id: 'battleLine',
+	name: 'Battle line',
+	points(context) {
+		const { world, units, centre, right, spacing, snap } = context
+		const rows: Entity[][] = [[], [], []]
+		for (const unit of units) rows[rowOf(world, unit)].push(unit)
+		const filled = rows.filter((row) => row.length)
+		const sideways = (unit: Entity) => (unit.pos.x - centre.x) * right.x + (unit.pos.z - centre.z) * right.z
+		const points = new Map<EntityId, Vec2>()
+		filled.forEach((row, index) => {
+			// the rows a step and a half apart: room to turn and to shoot past those in front
+			const back = (index - (filled.length - 1) / 2) * spacing * 1.5
+			const members = [...row].sort((a, b) => sideways(a) - sideways(b) || a.id - b.id)
+			members.forEach((unit, i) => points.set(unit.id, snap(context.place((i - (members.length - 1) / 2) * spacing, -back))))
+		})
+		return points
+	}
+}
+
+/** Melee's formations, beside the engine's */
+export const formations: FormationDef[] = [battleLine]