@v12-engine/create 0.1.1 → 0.4.0

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

@@ -0,0 +1,61 @@
+/**
+ * Creep camps: neutral monsters that guard a spot. Hit one and the whole camp comes, for whoever hurt it most; lead it
+ * too far from home (its leash, 14 cells) and it gives up, walks back and heals. Cleared, a camp can come back
+ * (`respawnCamp`). Camps come with the heroes pack, placed by a map or in code (`spawnCamp`)
+ */
+import { defineCommand, oneOf, type World } from '@v12-engine/engine'
+import { PLAYER } from '../common/units'
+import { type ExampleDef, exampleField } from '../define'
+import { clear, ownedOf } from './base'
+import { camps, type CampSpot, withCamps } from './camps'
+import { RTS } from './data'
+
+/** Three camps across the north of the field */
+export const CREEP_CAMPS: readonly CampSpot[] = [
+	{ name: 'west', at: { x: 12, z: 34 }, types: [RTS.gnoll, RTS.gnoll, RTS.gnoll] },
+	{ name: 'middle', at: { x: 24, z: 38 }, types: [RTS.ogre, RTS.brute, RTS.brute] },
+	{ name: 'east', at: { x: 36, z: 34 }, types: [RTS.brute, RTS.gnoll, RTS.gnoll] }
+]
+
+/** Where the army waits, and pulls back to */
+const HOME = { x: 24, z: 10 }
+
+/** Eight footmen and four riflemen in the south by their hall and farms, the camps in the north */
+function layOut(world: World): void {
+	clear(world)
+	// the supply the army takes: the hall's and three farms'
+	world.spawn(RTS.townhall, { at: { x: 24, z: 4 }, owner: PLAYER })
+	for (let i = 0; i < 3; i++) world.spawn(RTS.farm, { at: { x: 30 + i * 2.5, z: 4 }, owner: PLAYER })
+	for (let i = 0; i < 12; i++) {
+		const type = i < 8 ? RTS.footman : RTS.rifleman
+		world.spawn(type, { at: { x: HOME.x - 3 + (i % 4) * 1.6, z: HOME.z + 2 - Math.floor(i / 4) * 1.6 }, owner: PLAYER, facing: 0 })
+	}
+	camps(world, CREEP_CAMPS)
+}
+
+/** The army goes for a camp */
+export const attackCamp = defineCommand('rts.attackCamp', { camp: oneOf('west', 'middle', 'east') }, (world, player, { camp }) => {
+	const spot = CREEP_CAMPS.find((each) => each.name === camp)!
+	const army = ownedOf(world, player).filter((each) => each.isUnit)
+	world.issue({ type: 'order', player, entities: army.map((each) => each.id), order: { type: 'attackMove', point: spot.at } })
+})
+
+/** The army runs home without fighting: the creeps chase as far as their leash, then go back to their camp */
+export const pullBack = defineCommand('rts.pullBack', {}, (world, player) => {
+	const army = ownedOf(world, player).filter((each) => each.isUnit)
+	world.issue({ type: 'order', player, entities: army.map((each) => each.id), order: { type: 'move', point: HOME } })
+})
+
+export const resetCreeps = defineCommand('rts.resetCreeps', {}, (world) => layOut(world))
+
+export const creeps: ExampleDef = {
+	id: 'rts-creeps',
+	category: 'rts',
+	title: 'Creep camps',
+	summary:
+		'Three camps of neutral creeps guard their ground. Attack one and the whole camp answers; pull back and they chase only so far, then walk home and heal. Clear them all, or bring them back.',
+	tags: ['creeps', 'neutral', 'camp', 'leash', 'aggro', 'jungle', 'monsters'],
+	map: () => withCamps(exampleField({ name: 'Creeps', size: 48 }), CREEP_CAMPS),
+	start: (world) => layOut(world),
+	source: ['examples/rts/creeps.ts', 'examples/rts/camps.ts', 'examples/rts/data.ts', 'examples/rts/looks.ts']
+}

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

@@ -0,0 +1,406 @@
+/**
+ * What the RTS examples play with, as data: workers, soldiers, a hero, the buildings of a base, gold mines and trees,
+ * creeps, two upgrades, the hero's spells and a shop's items. A small classic roster, its ids starting `rts` so that no
+ * other example's collide. How each looks is `./looks.ts`
+ */
+import type { AbilityDef, BuffDef, ItemDef, UnitTypeDef, UpgradeDef } from '@v12-engine/engine'
+
+/** The ids, in one place: `RTS.peasant` everywhere else */
+export const RTS = {
+	peasant: 'rtsPeasant',
+	footman: 'rtsFootman',
+	rifleman: 'rtsRifleman',
+	paladin: 'rtsPaladin',
+	townhall: 'rtsTownhall',
+	keep: 'rtsKeep',
+	farm: 'rtsFarm',
+	barracks: 'rtsBarracks',
+	blacksmith: 'rtsBlacksmith',
+	tower: 'rtsTower',
+	altar: 'rtsAltar',
+	shop: 'rtsShop',
+	goldmine: 'rtsGoldmine',
+	tree: 'rtsTree',
+	gnoll: 'rtsGnoll',
+	brute: 'rtsGnollBrute',
+	ogre: 'rtsOgre'
+} as const
+
+// ---- units
+
+export const peasant: UnitTypeDef = {
+	id: RTS.peasant,
+	name: 'Peasant',
+	kind: 'unit',
+	radius: 0.4,
+	stats: { health: 250, attackDamage: 8, attackSpeed: 0.6, attackRange: 0.4, moveSpeed: 4 },
+	sight: 8,
+	// it fights only when told to: it never goes after an enemy on its own (`acquisitionRange: 0`)
+	attacks: [{ damagePoint: 0.4, acquisitionRange: 0, targets: ['unit', 'building'] }],
+	cost: { gold: 75 },
+	supply: 1,
+	buildTime: 8,
+	// a worker: it carries 10 a trip, and a load of gold takes 1.5 seconds to dig
+	harvester: { capacity: 10, gatherTime: 1.5 },
+	builds: [RTS.townhall, RTS.farm, RTS.barracks, RTS.blacksmith, RTS.tower, RTS.altar],
+	hotkey: 'P'
+}
+
+export const footman: UnitTypeDef = {
+	id: RTS.footman,
+	name: 'Footman',
+	kind: 'unit',
+	radius: 0.45,
+	stats: { health: 420, attackDamage: 12, attackSpeed: 1.2, attackRange: 0.5, armor: 10, moveSpeed: 4 },
+	sight: 10,
+	attacks: [{ damagePoint: 0.45, acquisitionRange: 8 }],
+	cost: { gold: 135 },
+	supply: 2,
+	buildTime: 6,
+	hotkey: 'F'
+}
+
+export const rifleman: UnitTypeDef = {
+	id: RTS.rifleman,
+	name: 'Rifleman',
+	kind: 'unit',
+	radius: 0.45,
+	stats: { health: 300, attackDamage: 20, attackSpeed: 0.7, attackRange: 6.5, moveSpeed: 4 },
+	sight: 11,
+	attacks: [{ damagePoint: 0.35, acquisitionRange: 9, projectileSpeed: 24, targets: ['ground', 'air'] }],
+	cost: { gold: 205, lumber: 30 },
+	supply: 3,
+	buildTime: 8,
+	// a finished blacksmith first
+	requires: [RTS.blacksmith],
+	hotkey: 'R'
+}
+
+/** A hero: it levels up by what it kills, and learns a spell a level from the three it `learns` */
+export const paladin: UnitTypeDef = {
+	id: RTS.paladin,
+	name: 'Paladin',
+	kind: 'unit',
+	radius: 0.5,
+	stats: { health: 700, mana: 280, manaRegen: 1.2, attackDamage: 30, attackSpeed: 0.9, attackRange: 0.6, armor: 25, moveSpeed: 4.4 },
+	sight: 12,
+	attacks: [{ damagePoint: 0.4, acquisitionRange: 8 }],
+	hero: {
+		learns: ['rtsHolyLight', 'rtsThunderClap', 'rtsDevotionAura'],
+		growth: { stats: { health: 90, mana: 25, attackDamage: 3, armor: 3 } },
+		maxLevel: 10
+	},
+	inventory: 6,
+	level: 1,
+	cost: { gold: 425, lumber: 100 },
+	supply: 5,
+	buildTime: 10,
+	hotkey: 'P'
+}
+
+// ---- buildings
+
+export const townhall: UnitTypeDef = {
+	id: RTS.townhall,
+	name: 'Town Hall',
+	kind: 'building',
+	radius: 2,
+	footprint: { w: 4, d: 4 },
+	stats: { health: 2000, armor: 40 },
+	sight: 12,
+	cost: { gold: 385, lumber: 205 },
+	buildTime: 45,
+	supplyGiven: 12,
+	trains: [RTS.peasant],
+	// workers bring what they gather here
+	dropOff: true,
+	// it can become a keep, as it stands (`upgradeBuilding`)
+	upgradesTo: RTS.keep,
+	hotkey: 'H'
+}
+
+export const keep: UnitTypeDef = {
+	...townhall,
+	id: RTS.keep,
+	name: 'Keep',
+	stats: { health: 2800, armor: 50 },
+	cost: { gold: 200, lumber: 100 },
+	buildTime: 12,
+	// it counts as a town hall for what asks for one
+	provides: [RTS.townhall],
+	upgradesTo: undefined,
+	hotkey: 'U'
+}
+
+export const farm: UnitTypeDef = {
+	id: RTS.farm,
+	name: 'Farm',
+	kind: 'building',
+	radius: 1,
+	footprint: { w: 2, d: 2 },
+	stats: { health: 600, armor: 20 },
+	sight: 6,
+	cost: { gold: 80, lumber: 20 },
+	buildTime: 10,
+	// room for six more of supply
+	supplyGiven: 6,
+	hotkey: 'F'
+}
+
+export const barracks: UnitTypeDef = {
+	id: RTS.barracks,
+	name: 'Barracks',
+	kind: 'building',
+	radius: 1.5,
+	footprint: { w: 3, d: 3 },
+	stats: { health: 1500, armor: 30 },
+	sight: 9,
+	cost: { gold: 160, lumber: 60 },
+	buildTime: 15,
+	trains: [RTS.footman, RTS.rifleman],
+	hotkey: 'B'
+}
+
+export const blacksmith: UnitTypeDef = {
+	id: RTS.blacksmith,
+	name: 'Blacksmith',
+	kind: 'building',
+	radius: 1.5,
+	footprint: { w: 3, d: 3 },
+	stats: { health: 1200, armor: 30 },
+	sight: 9,
+	cost: { gold: 140, lumber: 60 },
+	buildTime: 15,
+	requires: [RTS.barracks],
+	researches: ['rtsSwords', 'rtsPlating'],
+	hotkey: 'S'
+}
+
+export const tower: UnitTypeDef = {
+	id: RTS.tower,
+	name: 'Guard Tower',
+	kind: 'building',
+	radius: 1,
+	footprint: { w: 2, d: 2 },
+	stats: { health: 1000, attackDamage: 25, attackSpeed: 0.9, attackRange: 8, armor: 30 },
+	sight: 12,
+	attacks: [{ damagePoint: 0.3, acquisitionRange: 8, projectileSpeed: 24, targets: ['ground', 'air'] }],
+	cost: { gold: 110, lumber: 50 },
+	buildTime: 12,
+	requires: [RTS.barracks],
+	hotkey: 'T'
+}
+
+export const altar: UnitTypeDef = {
+	id: RTS.altar,
+	name: 'Altar of Kings',
+	kind: 'building',
+	radius: 1.5,
+	footprint: { w: 3, d: 3 },
+	stats: { health: 1200, armor: 30 },
+	sight: 9,
+	cost: { gold: 180, lumber: 50 },
+	buildTime: 15,
+	// trains the hero, and brings it back when it falls
+	trains: [RTS.paladin],
+	revives: true,
+	hotkey: 'A'
+}
+
+/** A goblin merchant: neutral and unbreakable, selling to whoever has a unit near it */
+export const shop: UnitTypeDef = {
+	id: RTS.shop,
+	name: 'Goblin Merchant',
+	kind: 'building',
+	radius: 1.5,
+	footprint: { w: 3, d: 3 },
+	stats: { health: 1000, armor: 40 },
+	sight: 8,
+	invulnerable: true,
+	sells: ['rtsHealingSalve', 'rtsClaws', 'rtsRingOfProtection', 'rtsGlovesOfHaste']
+}
+
+// ---- what is gathered
+
+export const goldmine: UnitTypeDef = {
+	id: RTS.goldmine,
+	name: 'Gold Mine',
+	kind: 'resource',
+	radius: 2,
+	footprint: { w: 4, d: 4 },
+	stats: { health: 1 },
+	sight: 0,
+	invulnerable: true,
+	// workers go in one at a time (`entered`) and come out with a load
+	resource: { id: 'gold', amount: 12500, slots: 1, entered: true }
+}
+
+export const tree: UnitTypeDef = {
+	id: RTS.tree,
+	name: 'Tree',
+	kind: 'resource',
+	radius: 0.5,
+	footprint: { w: 1, d: 1 },
+	stats: { health: 1 },
+	sight: 0,
+	invulnerable: true,
+	fellable: true,
+	// a worker chops a load in 4 seconds; 50 in all and the tree is gone
+	resource: { id: 'lumber', amount: 50, slots: 1, gatherTime: 4 }
+}
+
+// ---- creeps
+
+export const gnoll: UnitTypeDef = {
+	id: RTS.gnoll,
+	name: 'Gnoll Poacher',
+	kind: 'unit',
+	radius: 0.42,
+	stats: { health: 300, attackDamage: 12, attackSpeed: 0.8, attackRange: 0.5, moveSpeed: 4 },
+	sight: 8,
+	attacks: [{ damagePoint: 0.4, acquisitionRange: 5 }],
+	level: 1,
+	bounty: [8, 12],
+	xp: 40
+}
+
+export const brute: UnitTypeDef = {
+	...gnoll,
+	id: RTS.brute,
+	name: 'Gnoll Brute',
+	radius: 0.5,
+	stats: { health: 600, attackDamage: 20, attackSpeed: 0.7, attackRange: 0.6, armor: 10, moveSpeed: 3.8 },
+	level: 3,
+	bounty: [18, 24],
+	xp: 80,
+	drops: [{ item: 'rtsHealingSalve', chance: 1 }]
+}
+
+export const ogre: UnitTypeDef = {
+	id: RTS.ogre,
+	name: 'Ogre Lord',
+	kind: 'unit',
+	radius: 0.75,
+	stats: { health: 1400, healthRegen: 1, attackDamage: 45, attackSpeed: 0.5, attackRange: 0.7, armor: 20, moveSpeed: 3.6 },
+	sight: 9,
+	attacks: [{ damagePoint: 0.55, acquisitionRange: 5 }],
+	level: 5,
+	bounty: [45, 60],
+	xp: 200,
+	drops: [{ item: 'rtsClaws', chance: 1 }]
+}
+
+export const rtsUnits: UnitTypeDef[] = [
+	peasant,
+	footman,
+	rifleman,
+	paladin,
+	townhall,
+	keep,
+	farm,
+	barracks,
+	blacksmith,
+	tower,
+	altar,
+	shop,
+	goldmine,
+	tree,
+	gnoll,
+	brute,
+	ogre
+]
+
+// ---- upgrades
+
+export const rtsUpgrades: UpgradeDef[] = [
+	{
+		id: 'rtsSwords',
+		name: 'Forged Swords',
+		description: '+4 damage for footmen, each level',
+		cost: { gold: 100, lumber: 50 },
+		researchTime: 8,
+		maxLevel: 3,
+		// the second and third levels ask for a keep
+		requires: [[], [RTS.keep], [RTS.keep]],
+		hotkey: 'W',
+		effects: [{ units: [RTS.footman], stats: { attackDamage: 4 } }]
+	},
+	{
+		id: 'rtsPlating',
+		name: 'Iron Plating',
+		description: '+10 armor for footmen and riflemen, each level',
+		cost: { gold: 125, lumber: 75 },
+		researchTime: 8,
+		maxLevel: 2,
+		hotkey: 'P',
+		effects: [{ units: [RTS.footman, RTS.rifleman], stats: { armor: 10 } }]
+	}
+]
+
+// ---- the hero's spells
+
+export const rtsBuffs: BuffDef[] = [
+	{ id: 'rtsStunned', name: 'Stunned', description: 'Cannot do anything', harmful: true, stun: true },
+	{ id: 'rtsDevotion', name: 'Devotion Aura', description: 'More armor, near the paladin', stats: { armor: [10, 20, 30] } }
+]
+
+export const rtsAbilities: AbilityDef[] = [
+	{
+		id: 'rtsHolyLight',
+		name: 'Holy Light',
+		description: 'Heals an ally for 200, 350 or 500',
+		hotkey: 'Q',
+		target: 'unit',
+		targets: { allies: true, self: false },
+		manaCost: 65,
+		cooldown: 5,
+		range: 8,
+		castTime: 0.4,
+		effects: [{ type: 'heal', amount: [200, 350, 500] }]
+	},
+	{
+		id: 'rtsThunderClap',
+		name: 'Thunder Clap',
+		description: 'Slams the ground: 60, 110 or 160 damage to enemies around, and they are stunned a second',
+		hotkey: 'W',
+		target: 'none',
+		manaCost: 75,
+		cooldown: 8,
+		castTime: 0.4,
+		effects: [
+			{ type: 'damage', amount: [60, 110, 160], radius: 3.5 },
+			{ type: 'buff', buff: 'rtsStunned', duration: 1, radius: 3.5 }
+		]
+	},
+	{
+		id: 'rtsDevotionAura',
+		name: 'Devotion Aura',
+		description: 'Allies near the paladin have 10, 20 or 30 more armor',
+		target: 'passive',
+		effects: [{ type: 'aura', buff: 'rtsDevotion', radius: 9 }]
+	},
+	// what the items use
+	{
+		id: 'rtsDrinkSalve',
+		name: 'Healing Salve',
+		description: 'Heals 400 at once',
+		target: 'none',
+		cooldown: 1,
+		effects: [{ type: 'heal', amount: 400, on: 'caster' }]
+	}
+]
+
+// ---- what the shop sells
+
+export const rtsItems: ItemDef[] = [
+	{ id: 'rtsHealingSalve', name: 'Healing Salve', description: 'Heals 400 at once', cost: { gold: 100 }, charges: 2, ability: 'rtsDrinkSalve' },
+	{ id: 'rtsClaws', name: 'Claws of Attack', description: '+12 damage', cost: { gold: 300 }, bonus: { stats: { attackDamage: 12 } } },
+	{ id: 'rtsRingOfProtection', name: 'Ring of Protection', description: '+15 armor', cost: { gold: 250 }, bonus: { stats: { armor: 15 } } },
+	{
+		id: 'rtsGlovesOfHaste',
+		name: 'Gloves of Haste',
+		description: 'Attacks 20% faster',
+		cost: { gold: 200 },
+		bonus: { percent: { attackSpeed: 0.2 } }
+	}
+]

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

@@ -0,0 +1,41 @@
+/**
+ * A transport ship across a river: footmen, archers and a mage board it from the west bank, it sails over and lets
+ * them out on the east bank, where nothing that walks could go. A ship is a unit type with `naval` (it goes on deep
+ * water and nowhere else) and `transport` (it carries others); what it carries goes down with it if it sinks
+ */
+import { defineCommand, type World } from '@v12-engine/engine'
+import { PLAYER, UNIT } from '../common/units'
+import type { ExampleDef } from '../define'
+import { clear } from './base'
+import { CARRY, route } from './carry'
+import { riverAt, riverMap } from './waterside'
+
+/** Where the ship waits by the west bank, where it crosses to, and where it lets them out on the east bank */
+const MOOR = { x: riverAt(20) - 3.4, z: 21.5 }
+const ACROSS = { x: riverAt(20) + 3.4, z: 21.5 }
+const LAND = { x: riverAt(20) + 9, z: 20 }
+
+/** The squad on the west bank, by the jetty, and the ship by the bank waiting for them */
+export function layOutFerry(world: World): void {
+	clear(world)
+	world.setState(route, { moor: MOOR, across: ACROSS, land: LAND })
+	world.spawn(CARRY.ship, { at: MOOR, owner: PLAYER, facing: 0 })
+	const squad = [UNIT.footman, UNIT.footman, UNIT.footman, UNIT.footman, UNIT.archer, UNIT.archer, UNIT.archer, UNIT.mage]
+	squad.forEach((type, i) =>
+		world.spawn(type, { at: { x: 9 + Math.floor(i / 4) * 1.8, z: 17.3 + (i % 4) * 1.8 }, owner: PLAYER, facing: Math.PI / 2 })
+	)
+}
+
+export const resetFerry = defineCommand('rts.resetFerry', {}, (world) => layOutFerry(world))
+
+export const ferry: ExampleDef = {
+	id: 'rts-ferry',
+	category: 'rts',
+	title: 'Ferrying across a river',
+	summary:
+		'Board the squad onto the ship, sail it across the river and unload on the far bank, or play it by hand: right-click the ship with your units, select the ship and right-click the far bank. Sink it loaded to see what it carries go down with it.',
+	tags: ['transport', 'ship', 'boat', 'naval', 'board', 'load', 'unload', 'cargo', 'river', 'water', 'ferry'],
+	map: riverMap,
+	start: (world) => layOutFerry(world),
+	source: ['examples/rts/ferry.ts', 'examples/rts/carry.ts', 'examples/rts/waterside.ts', 'examples/rts/looks.ts']
+}

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

@@ -0,0 +1,50 @@
+/**
+ * A garrison: soldiers go into a tower, out of reach inside, and it shoots for them. A building that carries others is
+ * one with `transport`; with `armed` it attacks only while someone is in it, and each one inside adds to its arrows.
+ * Brought down, it lets them out alive, where a ship or a zeppelin takes them down with it
+ */
+import { defineCommand, type World } from '@v12-engine/engine'
+import { ENEMY, PLAYER, UNIT } from '../common/units'
+import type { ExampleDef } from '../define'
+import { clear } from './base'
+import { CARRY, route } from './carry'
+import { RTS } from './data'
+import { outpostMap, roadAt } from './waterside'
+
+/** Where the tower stands, before the hall it guards, and where the gnolls come from */
+export const TOWER = { x: roadAt(22) + 2.5, z: 22 }
+const DEN = { x: roadAt(35), z: 35 }
+
+/** The hall and the tower before it on the road, four soldiers by the tower */
+export function layOutGarrison(world: World): void {
+	clear(world)
+	world.setState(route, { moor: TOWER, across: TOWER, land: TOWER })
+	world.spawn(RTS.townhall, { at: { x: 24, z: 13 }, owner: PLAYER })
+	world.spawn(RTS.farm, { at: { x: 18.5, z: 12 }, owner: PLAYER })
+	world.spawn(RTS.farm, { at: { x: 29.5, z: 12 }, owner: PLAYER })
+	world.spawn(CARRY.tower, { at: TOWER, owner: PLAYER })
+	;[UNIT.archer, UNIT.archer, UNIT.archer, UNIT.footman].forEach((type, i) =>
+		world.spawn(type, { at: { x: TOWER.x - 4 + i * 1.6, z: 18.5 }, owner: PLAYER, facing: Math.PI / 2 })
+	)
+}
+
+/** A pack of gnolls, four poachers and two brutes, comes down the way for the tower and the hall behind it */
+export const gnollsCome = defineCommand('rts.gnollsCome', {}, (world) => {
+	const pack = [RTS.gnoll, RTS.gnoll, RTS.brute, RTS.gnoll, RTS.gnoll, RTS.brute]
+	const ids = pack.map((type, i) => world.spawn(type, { at: { x: DEN.x - 3 + (i % 3) * 3, z: DEN.z + Math.floor(i / 3) * 2 }, owner: ENEMY }).id)
+	world.issue({ type: 'order', player: ENEMY, entities: ids, order: { type: 'attackMove', point: { x: TOWER.x, z: TOWER.z - 4 } } })
+})
+
+export const resetGarrison = defineCommand('rts.resetGarrison', {}, (world) => layOutGarrison(world))
+
+export const garrison: ExampleDef = {
+	id: 'rts-garrison',
+	category: 'rts',
+	title: 'Garrisoning a tower',
+	summary:
+		'Put the soldiers in the tower (or right-click it with them): it shoots only while someone is inside, harder for each. Send in the gnolls, then let them out with the Unload button, or bring the tower down and see them come out alive.',
+	tags: ['garrison', 'tower', 'bunker', 'burrow', 'transport', 'board', 'unload', 'cargo', 'defend', 'armed'],
+	map: outpostMap,
+	start: (world) => layOutGarrison(world),
+	source: ['examples/rts/garrison.ts', 'examples/rts/carry.ts', 'examples/rts/waterside.ts', 'examples/rts/looks.ts']
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Gathering: peasants dig gold at the mine and chop trees, carry a load at a time to the town hall and hand it in.
+ * A worker is a unit type with `harvester`; a mine and a tree are resources (`resource`); the hall takes loads in
+ * (`dropOff`). A mine takes one worker in at a time, so five or so keep it busy; each tree is felled once it is cut down
+ */
+import type { World } from '@v12-engine/engine'
+import { PLAYER } from '../common/units'
+import { type ExampleDef, exampleField } from '../define'
+import { base, clear, purse, startWork } from './base'
+
+/** The base, its five peasants put to work, three on the gold and two in the wood */
+export function harvestStart(world: World): void {
+	clear(world)
+	purse(world, PLAYER, 200, 50)
+	base(world, PLAYER, { x: 26, z: 22 })
+	startWork(world, PLAYER, 3)
+}
+
+export const harvest: ExampleDef = {
+	id: 'rts-harvest',
+	category: 'rts',
+	title: 'Gold and lumber',
+	summary:
+		'Peasants dig gold at the mine and chop wood, carrying each load home to the town hall. Train more from the hall (or press Train a peasant) and send them to work with a right-click on the mine or a tree.',
+	tags: ['economy', 'gather', 'harvest', 'workers', 'gold', 'lumber', 'resources', 'mine'],
+	map: () => exampleField({ name: 'Homestead', size: 44 }),
+	start: (world) => harvestStart(world),
+	source: ['examples/rts/harvest.ts', 'examples/rts/base.ts', 'examples/rts/data.ts', 'examples/rts/looks.ts']
+}

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

@@ -0,0 +1,67 @@
+/**
+ * A hero: a unit type with `hero`. It earns experience from what is killed near it, levels up (stronger each level by
+ * its `growth`), and gets a point a level to learn one of the spells it `learns` or raise one a level. Camps of creeps
+ * round the field are worth hunting; the altar trains another hero and brings a fallen one back
+ */
+import { defineCommand, grantXp, 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 } from './data'
+
+/** The camps round the field, from the easiest to the ogre */
+export const HERO_CAMPS: readonly CampSpot[] = [
+	{ name: 'gnolls', at: { x: 22, z: 32 }, types: [RTS.gnoll, RTS.gnoll] },
+	{ name: 'brutes', at: { x: 34, z: 28 }, types: [RTS.brute, RTS.gnoll, RTS.gnoll] },
+	{ name: 'ogre', at: { x: 30, z: 38 }, types: [RTS.ogre, RTS.gnoll] }
+]
+
+/** The paladin and two footmen by the altar, the camps round them */
+function layOut(world: World): void {
+	clear(world)
+	purse(world, PLAYER, 600, 200)
+	world.spawn(RTS.altar, { at: { x: 16.5, z: 16.5 }, owner: PLAYER })
+	// the supply the hero and the footmen take
+	world.spawn(RTS.farm, { at: { x: 13, z: 21 }, owner: PLAYER })
+	world.spawn(RTS.farm, { at: { x: 16, z: 21 }, owner: PLAYER })
+	world.spawn(RTS.paladin, { at: { x: 21, z: 18 }, owner: PLAYER, facing: 0.6 })
+	world.spawn(RTS.footman, { at: { x: 19.5, z: 19.5 }, owner: PLAYER })
+	world.spawn(RTS.footman, { at: { x: 22.5, z: 19.5 }, owner: PLAYER })
+	camps(world, HERO_CAMPS)
+}
+
+/** The hero and its footmen go for a camp, fighting what they meet on the way */
+export const hunt = defineCommand('rts.hunt', { camp: oneOf('gnolls', 'brutes', 'ogre') }, (world, player, { camp }) => {
+	const spot = HERO_CAMPS.find((each) => each.name === camp)!
+	const party = ownedOf(world, player).filter((each) => each.isUnit)
+	world.issue({ type: 'order', player, entities: party.map((each) => each.id), order: { type: 'attackMove', point: spot.at } })
+})
+
+/** Experience for the hero, as a kill would give it: enough for a level or two */
+export const giveXp = defineCommand('rts.heroXp', {}, (world, player) => {
+	for (const hero of heroesOf(world, player)) if (hero.alive) grantXp(world, hero, 300)
+})
+
+/** The hero learns a spell, or raises one a level, with a point it has: what its card's learn buttons send */
+export const learnSpell = defineCommand(
+	'rts.learn',
+	{ ability: oneOf('rtsHolyLight', 'rtsThunderClap', 'rtsDevotionAura') },
+	(world, player, { ability }) => {
+		for (const hero of heroesOf(world, player)) world.issue({ type: 'learn', player, entity: hero.id, ability })
+	}
+)
+
+export const resetHero = defineCommand('rts.resetHero', {}, (world) => layOut(world))
+
+export const hero: ExampleDef = {
+	id: 'rts-hero',
+	category: 'rts',
+	title: 'A hero levels up',
+	summary:
+		'A paladin hunts creep camps for experience, levels up, and spends a point a level on Holy Light, Thunder Clap or Devotion Aura. Hunt a camp, or give experience and learn from the card; Q and W cast.',
+	tags: ['hero', 'level', 'experience', 'xp', 'skills', 'learn', 'spells', 'aura', 'creeps', 'altar', 'revive'],
+	map: () => withCamps(exampleField({ name: 'Hunting grounds', size: 48 }), HERO_CAMPS),
+	start: (world) => layOut(world),
+	source: ['examples/rts/hero.ts', 'examples/rts/camps.ts', 'examples/rts/data.ts', 'examples/rts/looks.ts']
+}