@v12-engine/create 0.1.0 → 0.4.0

package/starters/examples/src/examples/rts/shop.ts

@@ -0,0 +1,46 @@
+/**
+ * Items and a shop: a building that `sells` items sells them to whoever has a hero near it, for the item's cost. An
+ * item gives what it gives while carried (`bonus`), or is used for its ability, a charge a use (`charges`). A creep
+ * can drop one when it dies (`drops`): the brute by the shop carries a salve
+ */
+import { defineCommand, heroesOf, oneOf, type World } from '@v12-engine/engine'
+import { PLAYER } from '../common/units'
+import { type ExampleDef, exampleField } from '../define'
+import { clear, ownedOf, purse } from './base'
+import { camps, type CampSpot, withCamps } from './camps'
+import { RTS, rtsItems } from './data'
+
+/** A camp of one: the brute, with its salve */
+const BRUTE: readonly CampSpot[] = [{ name: 'brute', at: { x: 35, z: 14 }, types: [RTS.brute] }]
+
+/** The merchant, the paladin by it with a purse to spend, and a brute that drops a salve */
+function layOut(world: World): void {
+	clear(world)
+	purse(world, PLAYER, 1500, 0)
+	world.spawn(RTS.shop, { at: { x: 24.5, z: 26.5 }, owner: 0 })
+	world.spawn(RTS.paladin, { at: { x: 24, z: 22 }, owner: PLAYER, facing: 0 })
+	// the supply the hero takes
+	world.spawn(RTS.farm, { at: { x: 19, z: 21 }, owner: PLAYER })
+	camps(world, BRUTE)
+}
+
+/** The player's hero buys an item at the merchant, as a click on its card's item does */
+export const buy = defineCommand('rts.buy', { item: oneOf(...rtsItems.map((each) => each.id)) }, (world, player, { item }) => {
+	const [shop] = ownedOf(world, 0, RTS.shop)
+	const [hero] = heroesOf(world, player)
+	if (shop && hero) world.issue({ type: 'buy', player, shop: shop.id, item, hero: hero.id })
+})
+
+export const resetShop = defineCommand('rts.resetShop', {}, (world) => layOut(world))
+
+export const shopExample: ExampleDef = {
+	id: 'rts-shop',
+	category: 'rts',
+	title: 'Items and a shop',
+	summary:
+		'A goblin merchant sells to a hero standing by it. Buy claws, a ring or gloves and watch the paladin’s numbers go up; a salve is drunk from the inventory. The gnoll brute drops a salve when it dies.',
+	tags: ['items', 'shop', 'inventory', 'buy', 'merchant', 'drops', 'loot', 'hero'],
+	map: () => withCamps(exampleField({ name: 'Market', size: 44 }), BRUTE),
+	start: (world) => layOut(world),
+	source: ['examples/rts/shop.ts', 'examples/rts/data.ts', 'examples/rts/looks.ts']
+}

package/starters/examples/src/examples/rts/tech.ts

@@ -0,0 +1,39 @@
+/**
+ * Tech: a blacksmith `researches` upgrades, each level of one paid and studied in its own time, and what it gives goes
+ * on every footman at once, and on every one trained after. Forged Swords' second level asks for a keep: the town hall
+ * becomes one in place (`upgradesTo`), still a hall to everything that asks for one (`provides`)
+ */
+import { defineCommand, type World } from '@v12-engine/engine'
+import { PLAYER } from '../common/units'
+import { type ExampleDef, exampleField } from '../define'
+import { base, clear, ownedOf, purse } from './base'
+import { RTS } from './data'
+
+/** A base with a barracks and a blacksmith up, six footmen drilling in front of them */
+function layOut(world: World): void {
+	clear(world)
+	purse(world, PLAYER, 3000, 1500)
+	base(world, PLAYER, { x: 22, z: 26 }, { workers: 0 })
+	world.spawn(RTS.barracks, { at: { x: 30.5, z: 26.5 }, owner: PLAYER })
+	world.spawn(RTS.blacksmith, { at: { x: 30.5, z: 21.5 }, owner: PLAYER })
+	world.spawn(RTS.farm, { at: { x: 34, z: 30 }, owner: PLAYER })
+	for (let i = 0; i < 6; i++) world.spawn(RTS.footman, { at: { x: 21 + (i % 3) * 1.5, z: 17 - Math.floor(i / 3) * 1.5 }, owner: PLAYER, facing: 0 })
+}
+
+/** The town hall becomes a keep, as its card's button does: paid, and built over its own time in place */
+export const toKeep = defineCommand('rts.toKeep', {}, (world, player) => {
+	const [hall] = ownedOf(world, player, RTS.townhall)
+	if (hall) world.issue({ type: 'upgradeBuilding', player, building: hall.id })
+})
+
+export const tech: ExampleDef = {
+	id: 'rts-tech',
+	category: 'rts',
+	title: 'Upgrades and tech',
+	summary:
+		'The blacksmith researches Forged Swords and Iron Plating; each level lands on every footman at once. The second level of swords needs a keep: upgrade the town hall in place, then research again.',
+	tags: ['research', 'upgrade', 'tech', 'tech tree', 'requires', 'blacksmith', 'keep', 'morph'],
+	map: () => exampleField({ name: 'Smithy', size: 44 }),
+	start: (world) => layOut(world),
+	source: ['examples/rts/tech.ts', 'examples/rts/base.ts', 'examples/rts/data.ts', 'examples/rts/looks.ts']
+}

package/starters/examples/src/examples/rts/train.ts

@@ -0,0 +1,48 @@
+/**
+ * Training: a building `trains` unit types, a queue of them at a time, each paid for as it is queued and made in its
+ * `buildTime`. Supply caps the army: each unit takes some (`supply`), halls and farms give it (`supplyGiven`). A
+ * rally point sends what comes out where the player says. The rifleman asks for a blacksmith first (`requires`)
+ */
+import { defineCommand, type World } from '@v12-engine/engine'
+import { PLAYER } from '../common/units'
+import { type ExampleDef, exampleField } from '../define'
+import { base, clear, ownedOf, purse } from './base'
+import { RTS } from './data'
+
+/** Where the rally button sends the new units: the field in front of the barracks */
+export const RALLY = { x: 31, z: 28 }
+
+/** A hall, a barracks, two farms and plenty of gold: all there is to train with */
+function layOut(world: World): void {
+	clear(world)
+	purse(world, PLAYER, 2000, 500)
+	base(world, PLAYER, { x: 26, z: 26 }, { workers: 0 })
+	world.spawn(RTS.barracks, { at: { x: 32.5, z: 20.5 }, owner: PLAYER })
+	world.spawn(RTS.farm, { at: { x: 20, z: 18 }, owner: PLAYER })
+	world.spawn(RTS.farm, { at: { x: 23, z: 18 }, owner: PLAYER })
+}
+
+/** The barracks' rally point, out on the field: what it trains walks there as it comes out */
+export const rally = defineCommand('rts.rally', {}, (world, player) => {
+	const barracks = ownedOf(world, player, RTS.barracks)
+	world.issue({ type: 'rally', player, buildings: barracks.map((each) => each.id), point: RALLY })
+})
+
+/** A blacksmith put down, built at once: the rifleman's requirement */
+export const smithy = defineCommand('rts.smithy', {}, (world, player) => {
+	if (!ownedOf(world, player, RTS.blacksmith).length) world.spawn(RTS.blacksmith, { at: { x: 36.5, z: 26.5 }, owner: player })
+})
+
+export const resetTrain = defineCommand('rts.resetTrain', {}, (world) => layOut(world))
+
+export const training: ExampleDef = {
+	id: 'rts-train',
+	category: 'rts',
+	title: 'Training and supply',
+	summary:
+		'A barracks trains footmen, a queue of five at a time, each paid as it is queued. Farms give the supply the army takes; riflemen need a blacksmith first. Set a rally point and new units walk there.',
+	tags: ['train', 'queue', 'production', 'supply', 'food', 'rally', 'barracks', 'requires', 'tech'],
+	map: () => exampleField({ name: 'Barracks', size: 44 }),
+	start: (world) => layOut(world),
+	source: ['examples/rts/train.ts', 'examples/rts/base.ts', 'examples/rts/data.ts', 'examples/rts/looks.ts']
+}

package/starters/examples/src/examples/rts/waterside.ts

@@ -0,0 +1,185 @@
+/**
+ * The land the transport examples are played on, made in code: a river across a field to ferry over, and a plateau
+ * behind a cliff wall to fly up onto. Each is a map (`GameMap`): its ground, its cliff levels, its water (deep where
+ * boats go and nothing walks, shallow where it is waded), its paint and its scenery
+ */
+import { createMap, exactMath, type GameMap, type MapDoodad, type Vec2, WATER_DEEP, WATER_SHALLOW } from '@v12-engine/engine'
+import { tiles } from '../define'
+
+/** A test of a cell, by its middle */
+type Where = (x: number, z: number) => boolean
+
+/** A small hash of a whole cell, 0 to 1: the wobble of a bank, where a tree goes. The same on every machine */
+export function hash(x: number, z: number, seed = 1): number {
+	const n = exactMath.sin(Math.floor(x) * 127.1 + Math.floor(z) * 311.7 + seed * 74.7) * 43758.5453
+	return n - Math.floor(n)
+}
+
+/** A smooth wobble along a line, -1 to 1: what makes a bank or a cliff's edge look grown, not drawn */
+export const wobble = (along: number, seed = 1): number => exactMath.sin(along * 0.31 + seed) * 0.6 + exactMath.sin(along * 0.73 + seed * 2.1) * 0.4
+
+/** A field of grass `width` by `depth`, a player for each start given, starting there */
+export function land(name: string, width: number, depth: number, ...starts: Vec2[]): GameMap {
+	const map = createMap({ name, width, depth, players: starts.length, game: 'examples', tileset: tiles.map((each) => each.id) })
+	map.tiles.fill(map.tileset.indexOf('grass') + 1)
+	starts.forEach((start, i) => (map.players[i].start = start))
+	return map
+}
+
+/** Every cell `where` says, given to `set` by its index */
+function eachCell(map: GameMap, where: Where, set: (cell: number) => void): void {
+	for (let z = 0; z < map.depth; z++) for (let x = 0; x < map.width; x++) if (where(x + 0.5, z + 0.5)) set(z * map.width + x)
+}
+
+/** Paints a tile of the game's (`grass`, `darkGrass`, `dirt`, `road`, `sand`, `rock`, `snow`) where it says */
+export function paint(map: GameMap, tile: string, where: Where): void {
+	const value = map.tileset.indexOf(tile) + 1
+	if (value > 0) eachCell(map, where, (cell) => (map.tiles[cell] = value))
+}
+
+/** Water where `where` says: deep where `deep` says too, shallow (waded through) elsewhere */
+export function pour(map: GameMap, where: Where, deep: Where): void {
+	eachCell(map, where, (cell) => (map.water[cell] = deep((cell % map.width) + 0.5, Math.floor(cell / map.width) + 0.5) ? WATER_DEEP : WATER_SHALLOW))
+}
+
+/** Raises the cells it says to a cliff level: the cliffs round them have no ramp, so nothing walks up */
+export function raise(map: GameMap, level: number, where: Where): void {
+	eachCell(map, where, (cell) => (map.levels[cell] = level))
+}
+
+/** The ground's height at every vertex, from a function of where it is */
+export function sculpt(map: GameMap, height: (x: number, z: number) => number): void {
+	const row = map.width + 1
+	for (let z = 0; z <= map.depth; z++) for (let x = 0; x <= map.width; x++) map.ground[z * row + x] = height(x, z)
+}
+
+/** Puts a model of the shared art down as scenery, turned `yaw` and scaled; `blocks` keeps walkers off it */
+export function place(map: GameMap, model: string, at: Vec2, options: { yaw?: number; scale?: number; blocks?: number } = {}): void {
+	const { yaw = 0, scale = 1, blocks } = options
+	const doodad: MapDoodad = { id: map.doodads.length + 1, model, x: at.x, z: at.z, yaw, scale: [scale, scale, scale] }
+	if (blocks) Object.assign(doodad, { blocks: 'walk', radius: blocks })
+	map.doodads.push(doodad)
+}
+
+/** The trees of the shared art the woods are made of: pines and columnar trees, an oak now and then */
+const TREES = ['trees/pine_1.glb', 'trees/pine_3.glb', 'trees/columnar_1.glb', 'trees/pine_4.glb', 'trees/columnar_2.glb', 'trees/oak_5.glb']
+
+/** Trees, as scenery, on the cells `where` says, about one in `every` of them, each kind and size and turn its own */
+export function wood(map: GameMap, where: Where, every: number, seed: number): void {
+	eachCell(map, where, (cell) => {
+		const x = (cell % map.width) + 0.5
+		const z = Math.floor(cell / map.width) + 0.5
+		if (hash(x, z, seed) * every >= 1) return
+		const kind = TREES[Math.floor(hash(z, x, seed + 1) * TREES.length)]
+		const scale = (kind.includes('oak') ? 0.6 : 1) * (0.8 + hash(x, z, seed + 2) * 0.45)
+		place(
+			map,
+			kind,
+			{ x: x + (hash(x, z, seed + 3) - 0.5) * 0.6, z: z + (hash(x, z, seed + 4) - 0.5) * 0.6 },
+			{ yaw: hash(x, z, seed + 5) * 6.28, scale }
+		)
+	})
+}
+
+/** Rocks of the shared art scattered on the cells `where` says, about one in `every` */
+export function rocks(map: GameMap, where: Where, every: number, seed: number): void {
+	eachCell(map, where, (cell) => {
+		const x = (cell % map.width) + 0.5
+		const z = Math.floor(cell / map.width) + 0.5
+		if (hash(x, z, seed) * every >= 1) return
+		const kind = `forest/rock_medium_${1 + Math.floor(hash(z, x, seed) * 3)}.glb`
+		place(map, kind, { x, z }, { yaw: hash(x, z, seed + 1) * 6.28, scale: 0.6 + hash(x, z, seed + 2) * 0.6 })
+	})
+}
+
+// ---- a river to ferry over
+
+/** The river's middle runs north to south along this x, its deep water `RIVER_DEEP` either side of it */
+export const RIVER_X = 24
+const RIVER_DEEP = 5.5
+const RIVER_BANK = 7
+
+/** The river's middle at a row: it bends a little as it goes */
+export const riverAt = (z: number): number => RIVER_X + wobble(z, 3) * 1.6
+
+/**
+ * A field of 48 by 40 cells cut north to south by a river eleven cells of deep water across, a fringe of shallows and
+ * sand on either bank, woods along the far edges. Nothing that walks crosses it
+ */
+export function riverMap(): GameMap {
+	const map = land('River crossing', 48, 40, { x: 12, z: 20 })
+	sculpt(map, (x, z) => 1 + wobble(x * 0.7 + z * 0.4, 5) * 0.25)
+	const from = (x: number, z: number) => Math.abs(x - riverAt(z))
+	pour(
+		map,
+		(x, z) => from(x, z) < RIVER_BANK + wobble(z, 7) * 0.5,
+		(x, z) => from(x, z) < RIVER_DEEP
+	)
+	paint(map, 'sand', (x, z) => from(x, z) < RIVER_BANK + 1.4 + wobble(z, 9) * 0.6)
+	paint(map, 'darkGrass', (x, z) => from(x, z) > RIVER_BANK + 6 && hash(x, z, 4) > 0.45)
+	paint(map, 'dirt', (x, z) => Math.abs(z - 20) < 1.2 + wobble(x, 2) * 0.3 && from(x, z) > RIVER_BANK + 1 && from(x, z) < RIVER_BANK + 12)
+	wood(map, (x, z) => (x < 4 || x > 44 || z < 4 || z > 36) && from(x, z) > RIVER_BANK + 2, 2.2, 11)
+	rocks(map, (x, z) => from(x, z) > RIVER_BANK + 1.5 && from(x, z) < RIVER_BANK + 2.5 && Math.abs(z - 20) > 4, 9, 12)
+	// a jetty on each bank, out over the shallows where the ship comes in
+	place(map, 'rts/dock_2.glb', { x: riverAt(20) - RIVER_BANK + 0.4, z: 20 }, { yaw: Math.PI / 2, scale: 1.2 })
+	place(map, 'rts/dock_2.glb', { x: riverAt(20) + RIVER_BANK - 0.4, z: 20 }, { yaw: -Math.PI / 2, scale: 1.2 })
+	// the harbour the west bank sails from, and crates and barrels by the far jetty
+	place(map, 'rts/port.glb', { x: riverAt(28) - RIVER_BANK - 4, z: 28 }, { yaw: Math.PI / 2, scale: 1, blocks: 2.6 })
+	place(map, 'props/barrel.glb', { x: riverAt(22) + RIVER_BANK + 2, z: 23 }, { scale: 1.2 })
+	place(map, 'props/crate_wooden.glb', { x: riverAt(22) + RIVER_BANK + 2.8, z: 23.6 }, { yaw: 0.4, scale: 1.2 })
+	place(map, 'props/crate_wooden.glb', { x: riverAt(22) + RIVER_BANK + 2.4, z: 24.6 }, { yaw: 1.1, scale: 1 })
+	return map
+}
+
+// ---- a plateau behind a cliff wall
+
+/** The plateau: from this x east, one level up behind a cliff with no ramp, to the map's east edge */
+export const PLATEAU_X = 26
+/** The plateau's cliff edge at a row: it wanders a little */
+export const edgeAt = (z: number): number => PLATEAU_X + wobble(z, 6) * 1.5
+
+/**
+ * A field of 48 by 40 cells, its east half a plateau two cliff levels up: a wall of rock all along it with no ramp, so
+ * nothing that walks gets up. A pond and woods below, rocks and pines up top
+ */
+export function plateauMap(): GameMap {
+	const map = land('Cliff wall', 48, 40, { x: 12, z: 20 })
+	sculpt(map, (x, z) => 1 + wobble(x * 0.6 + z * 0.5, 2) * 0.3)
+	const up = (x: number, z: number) => x > edgeAt(z)
+	raise(map, 2, up)
+	paint(map, 'rock', (x, z) => up(x, z) && x < edgeAt(z) + 1.5)
+	paint(map, 'darkGrass', (x, z) => up(x, z) && hash(x, z, 8) > 0.5)
+	paint(map, 'dirt', (x, z) => !up(x, z) && x > edgeAt(z) - 2.5)
+	paint(map, 'dirt', (x, z) => up(x, z) && exactMath.hypot(x - 36, z - 20) < 3.5 + wobble(x + z, 4) * 0.6)
+	// a pond below the wall, to the south
+	const pond = (x: number, z: number) => exactMath.hypot(x - 10, z - 7) < 4 + wobble(x - z, 3) * 0.8
+	pour(map, pond, () => false)
+	paint(map, 'sand', (x, z) => exactMath.hypot(x - 10, z - 7) < 5.2 + wobble(x - z, 3) * 0.8)
+	wood(map, (x, z) => !up(x, z) && (x < 3 || z > 35) && !pond(x, z), 2.2, 21)
+	wood(map, (x, z) => up(x, z) && x > edgeAt(z) + 3 && (z < 8 || z > 31 || x > 43), 2.4, 22)
+	rocks(map, (x, z) => up(x, z) && x > edgeAt(z) + 1.5 && x < edgeAt(z) + 3 && Math.abs(z - 20) > 5, 5, 23)
+	rocks(map, (x, z) => !up(x, z) && x > edgeAt(z) - 2 && hash(x, z, 30) > 0.5 && Math.abs(z - 20) > 6, 6, 24)
+	return map
+}
+
+// ---- a watch post on a road
+
+/** The road's middle at a row: it winds down from the north to the hall */
+export const roadAt = (z: number): number => 24 + wobble(z * 0.5, 1) * 2
+
+/**
+ * A field of 48 cells a side for two players, a dirt road winding down it from the north to the hall in the south,
+ * woods either side of the road and rocks along it: the way the gnolls come
+ */
+export function outpostMap(): GameMap {
+	const map = land('Watch post', 48, 48, { x: 24, z: 13 }, { x: 24, z: 42 })
+	sculpt(map, (x, z) => 1 + wobble(x * 0.5 + z * 0.3, 4) * 0.3)
+	const from = (x: number, z: number) => Math.abs(x - roadAt(z))
+	paint(map, 'darkGrass', (x, z) => from(x, z) > 6 && hash(x, z, 3) > 0.4)
+	paint(map, 'dirt', (x, z) => z > 9 && from(x, z) < 1.6 + wobble(z, 5) * 0.3)
+	paint(map, 'road', (x, z) => z > 9 && z < 17 && from(x, z) < 3.5 && hash(x, z, 6) > 0.5)
+	wood(map, (x, z) => z > 26 && from(x, z) > 7 + wobble(z, 8) * 1.5, 1.6, 31)
+	wood(map, (x, z) => z <= 26 && (x < 6 || x > 42), 2, 32)
+	rocks(map, (x, z) => z > 24 && from(x, z) > 3 && from(x, z) < 5, 8, 33)
+	return map
+}