@v12-engine/create 0.1.0 → 0.4.0

package/starters/melee/src/melee/index.ts

@@ -1,37 +1,41 @@
 import {
 	defineCellLayer,
+	foliagePack,
+	presetFoliageStyles,
 	defineRace,
-	withCapture,
-	withConcealment,
-	withStances,
-	withData,
+	capturePack,
+	stancesPack,
+	layData,
 	type Entity,
-	type GameModule,
-	type StartData,
+	type Rules,
+	type StartingBaseData,
 	hotRules,
 	presetScore,
 	heroState,
-	withHeroes,
-	withMobaStats,
-	withVeterancy,
-	withWalls,
-	withRemains,
-	withFriendlyFire,
-	laneMinion
+	heroesPack,
+	mobaStatsPack,
+	veterancyPack,
+	wallsPack,
+	remainsPack,
+	friendlyFirePack,
+	laneMinion,
+	defaultCallingSet,
+	defaultHeroSpellSet,
+	useDefaults,
+	visionPack
 } from '@v12-engine/engine'
 import { meleeBrain } from '@v12-engine/engine/ai'
 import { abilities, buffs } from './abilities'
 import { formations } from './formations'
 import { blightLayer, blightSpread, blightSystem, undeadHooks } from './blight'
-import { heroSpellBuffs, heroSpells } from './heroSpells'
-import { itemAbilities, itemEffects, items } from './items'
+import { harvested, heroAbilities, heroBuffs, heroEffects, heroHooks } from './heroes'
+import { defaultItemSet } from './items'
 import { meleeEditor, tiles } from './maps'
 import { meleeGenerator } from './generator'
 import { units, upgrades } from './units'
 import { meleeSaves } from './saves'
 import { undeadAbilities, undeadBuffs } from './undead'
 import dataFile from './data.json'
-import { maps } from '../maps'
 import { PING_KINDS, pingsFile } from './pings'
 
 /** The ruins a fallen building leaves (`ruins`): of its size, 2 to 4 cells; none for a wall's piece, what stands on something, what cannot be felled, or ruins (taken away, they leave nothing) */
@@ -43,11 +47,14 @@ function ruinsOf(dead: Entity): string | null {
 }
 
 /** A town hall and five peasants on the side of the closest gold mine, as in a classic melee game: the humans' start, and the game's */
-const HUMAN_START: StartData = { hall: 'townhall', workers: { type: 'peasant', count: 5 } }
+const HUMAN_START: StartingBaseData = { hall: 'townhall', workers: { type: 'peasant', count: 5 } }
 
-/** Classic base building: gather gold, raise an army, destroy the other side */
-export const melee: GameModule = withData(
-	{
+/**
+ * Classic base building: gather gold, raise an army, destroy the other side. Its items are the engine's (`./items`):
+ * all of them, with what they use and the hero arena stats they give
+ */
+export const melee: Rules = layData(
+	useDefaults({
 		id: 'my-game',
 		name: 'My game',
 		version: '1.0.0',
@@ -63,24 +70,24 @@ export const melee: GameModule = withData(
 				id: 'human',
 				name: 'Human',
 				description: 'The Kingdom: peasants, footmen, riflemen and gryphons',
-				// a town hall and five peasants on the side of the closest gold mine (`StartData`, the engine's `startingBase`)
-				start: HUMAN_START
+				// a town hall and five peasants on the side of the closest gold mine (`StartingBaseData`, the engine's `startingBase`)
+				startingBase: HUMAN_START
 			}),
 			defineRace({
 				id: 'undead',
 				name: 'Undead',
 				description: 'The Restless: acolytes gather at a cursed mine, ghouls bring lumber, everything goes up on blight',
 				// a gravehold and a cursed mine on the closest gold mine, three acolytes and a ghoul
-				start: { hall: 'gravehold', workers: { type: 'acolyte', count: 3 }, units: [{ type: 'ghoul', count: 1 }], onMine: 'cursedMine' },
+				startingBase: { hall: 'gravehold', workers: { type: 'acolyte', count: 3 }, units: [{ type: 'ghoul', count: 1 }], onMine: 'cursedMine' },
 				// gold at a cursed mine, buildings on blight (`blight.ts`)
 				hooks: undeadHooks
 			})
 		],
-		abilities: [...abilities, ...heroSpells, ...itemAbilities, ...undeadAbilities],
+		// the heroes' own (`heroes.ts`); the spells every hero brings two of are the engine's set (`defaultHeroSpellSet`)
+		abilities: [...abilities, ...heroAbilities, ...undeadAbilities],
 		// the classic battle line beside the engine's formations, on the button by the minimap (`formations.ts`)
 		formations,
-		effects: itemEffects,
-		items,
+		effects: heroEffects,
 		resources: [
 			// gold pays for most things, and is what upkeep cuts into
 			{ id: 'gold', name: 'Gold', start: 500, upkeep: true },
@@ -88,13 +95,19 @@ export const melee: GameModule = withData(
 		],
 		currency: 'gold',
 		tiles,
-		// tall grass, painted on the map: what is in it is hidden from those outside (features-plan G)
+		// grass painted on the map, of the foliage pack (`foliagePack` below): tall grass, whose who stands in it is hidden
+		// from those outside it, and dry grass that burns fast. Each value is a style: what it is to the rules here, how it
+		// looks in the view (`ground.cellLayers.bush`), by the names of the engine's ready-made ones (`presetFoliageStyles`)
 		cellLayers: [
 			defineCellLayer({
 				id: 'bush',
 				name: 'Bushes',
 				description: 'Tall grass: who stands in it is hidden from those outside it',
-				color: [0.2, 0.75, 0.25]
+				color: [0.2, 0.75, 0.25],
+				values: [
+					{ value: 1, name: 'Tall grass', foliage: presetFoliageStyles.tallGrass },
+					{ value: 2, name: 'Dry grass', color: [0.8, 0.7, 0.4], foliage: presetFoliageStyles.dryGrass }
+				]
 			}),
 			// spoiled ground round the Restless' halls and cursed mines, that its buildings go up on (features-plan C5)
 			blightLayer
@@ -103,43 +116,44 @@ export const melee: GameModule = withData(
 		editor: meleeEditor,
 		// maps made by a generator: the ground, the starts, the mines and their camps, the woods (`generator.ts`)
 		generator: meleeGenerator,
-		// the maps it ships, the Bay: a save of a game on it keeps only what changed of its ground
-		maps: Object.values(maps),
 		// the file the editor's Pings fold writes, whose kinds the rules let go (`./pings`)
 		files: [pingsFile],
 		upkeep: [
 			{ above: 50, name: 'Low upkeep', income: 0.7 },
 			{ above: 80, name: 'High upkeep', income: 0.4 }
 		],
-		buffs: [...buffs, ...heroSpellBuffs, ...undeadBuffs],
+		buffs: [...buffs, ...heroBuffs, ...undeadBuffs],
 		// as in classic RTS games: eight minutes from one morning to the next, starting at eight
 		day: { length: 480, start: 8, dawn: 6, dusk: 18 },
 		// heroes, creeps' camps that guard their ground and sleep there at night, shops and taverns, as in classic RTS games
-		// who stands in the bushes is seen only from the same bush, or from close by; points to capture; units' stances
+		// who stands in the bushes is seen only from the same bush, or from close by, and they burn, as their styles say
+		// (`foliagePack`: set alight with `ignite`, by an ability's `foliage` effect, or the editor's Play here); points to
+		// capture; units' stances
 		// the heroes' stats: ability power, crits, penetration, life steal, tenacity, haste (a hero arena game's)
 		// pieces of wall laid in a line and joined (`stoneWall`); units that are not heroes ranking up by their kills, a
 		// lane's minions not: a wave is as strong as the one before it
 		packs: [
-			withHeroes(),
-			withConcealment({ layer: 'bush' }),
-			withCapture(),
-			withStances(),
-			withMobaStats(),
-			withWalls(),
-			withVeterancy({ earns: (_world, entity) => entity.alive && !entity.isStructure && !entity.has(heroState) && !entity.has(laneMinion) }),
+			heroesPack(),
+			foliagePack({ layer: 'bush', fire: { damage: 5 } }),
+			capturePack(),
+			stancesPack(),
+			mobaStatsPack(),
+			wallsPack(),
+			veterancyPack({ earns: (_world, entity) => entity.alive && !entity.isStructure && !entity.has(heroState) && !entity.has(laneMinion) }),
+			// a unit seen wherever it runs (a branded hero, a marked one), and one seen only from up close (a hero in the shadows)
+			visionPack(),
 			// a fallen building leaves ruins of its size where it stood, to clear for their lumber (`ruins`); not a wall's
 			// piece, nor what stands on something (a cursed mine on its gold mine), nor what nothing can fell
-			withRemains({ rubble: (_world, dead) => ruinsOf(dead) }),
+			remainsPack({ rubble: (_world, dead) => ruinsOf(dead) }),
 			// as in classic RTS games: a unit told to attack (A, then a click) one of its own or an ally's does; a right click never
-			withFriendlyFire()
+			friendlyFirePack()
 		],
 		// what a player of no race starts with: the humans' start
-		start: HUMAN_START,
+		startingBase: HUMAN_START,
 		// its computer players play by the engine's profiles: on a server, each seat the computer plays gets a difficulty
 		// and a personality to choose in the lobby (`seatSettingsOf`; `againstTheRest` reads them)
 		ai: {},
-		// the classic damage table: each attack type against each armour type (`units.ts`, `undead.ts` name them)
-		rules: {
+		settings: {
 			// the pings the view draws (`./pings`), and those the editor's Pings fold added (`pings.json`)
 			talk: { pings: { kinds: PING_KINDS } },
 			// the time left of a hero's buffs to everyone who sees it, for the plate's sweeps (indicators-plan U3): a hero's
@@ -153,28 +167,17 @@ export const melee: GameModule = withData(
 			// sight. A map says otherwise (Map › Starts explored)
 			fog: { startExplored: true },
 			// allies trade as in a classic allies menu: what one sends arrives whole (`give`, the Allies panel)
-			economy: { tradeTax: 0 },
-			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]
-					]
-				}
-			}
+			economy: { tradeTax: 0 }
 		},
-		components: [blightSpread],
+		// what Bone Reaver reaped, kept through his deaths (`heroes.ts`)
+		components: [blightSpread, harvested],
+		// what the heroes' innates do in code: Bulwark, Shatter, Shadow Step, Static Charge, Harvest (`heroes.ts`)
+		hooks: heroHooks,
 		// a save made before a patch is loaded after it (`saves.ts`)
 		saves: meleeSaves,
 		// every number and word of every definition can be changed from the editor's Data panel, and is kept in `data.json`
 		editable: 'all'
-	},
+	}, [defaultItemSet, defaultHeroSpellSet(), defaultCallingSet()]),
 	dataFile
 )
 

package/starters/melee/src/melee/items.ts

@@ -1,362 +1,15 @@
-import { type AbilityDef, defineEffect, type EffectKind, type ItemDef } from '@v12-engine/engine'
-
-// the game's own effects, each with the fields it reads (`EffectTypes`)
-declare module '@v12-engine/engine' {
-	interface EffectTypes {
-		/** Heals the carrier `perSecond` of its health a second, once it has gone `unhurtFor` seconds without being hurt */
-		mend: { perSecond: number; unhurtFor: number }
-	}
-}
-
-/** What using an item does. Abilities like any other, only that nobody has them without the item */
-export const itemAbilities: AbilityDef[] = [
-	{
-		id: 'revealArea',
-		name: 'Reveal',
-		description: 'Lifts the fog over an area anywhere for 5 seconds. Enemies can see it happen',
-		target: 'point',
-		range: 1000,
-		cooldown: 10,
-		effects: [{ type: 'reveal', radius: 9, duration: 5 }]
-	},
-	{
-		id: 'plantWard',
-		name: 'Plant',
-		description: 'Puts down a ward that sees around it for 60 seconds. Enemies see it for the first 2 seconds, then only with an oracle',
-		target: 'point',
-		range: 6,
-		cooldown: 1,
-		effects: [{ type: 'spawn', unit: 'ward' }]
-	},
-	{
-		id: 'sweep',
-		name: 'Sweep',
-		description: 'Sends out a pulse that finds enemy wards around the hero. They can be seen, and struck down, for 8 seconds',
-		target: 'none',
-		cooldown: 25,
-		effects: [{ type: 'detect', radius: 14, duration: 8 }]
-	},
-	{
-		id: 'drinkHealing',
-		name: 'Drink',
-		description: 'Restores 250 health',
-		target: 'none',
-		cooldown: 20,
-		effects: [{ type: 'heal', amount: 250, on: 'caster' }]
-	},
-	{
-		id: 'drinkMana',
-		name: 'Drink',
-		description: 'Restores 150 mana',
-		target: 'none',
-		cooldown: 20,
-		effects: [{ type: 'mana', amount: 150, on: 'caster' }]
-	},
-	{
-		id: 'readHealing',
-		name: 'Read',
-		description: 'Heals friendly units around the reader for 150',
-		target: 'none',
-		cooldown: 30,
-		effects: [{ type: 'heal', amount: 150, radius: 6 }]
-	},
-	{
-		id: 'intervention',
-		name: 'Intervention',
-		description: 'Calls down a beam on a spot far away: after 2.5 seconds friends there regain 150 to 350 health, more with every level',
-		target: 'point',
-		range: 68,
-		cooldown: 90,
-		aim: { shape: 'circle', radius: 6.9 },
-		effects: [{ type: 'after', delay: 2.5, effects: [{ type: 'heal', amount: 150, scaling: { level: 11.8 }, radius: 6.9 }] }]
-	},
-	{
-		id: 'mendingHeart',
-		name: 'Mending Heart',
-		description: 'Regains 3% of its health every second after 8 seconds without being hurt',
-		target: 'passive',
-		effects: [{ type: 'mend', perSecond: 0.03, unhurtFor: 8 }]
-	}
-]
-
-/** What the items do that the effects of the engine do not cover */
-export const itemEffects: EffectKind[] = [
-	/** Kept up all the time: a part of its health back every second, once `delay` seconds have passed without being hurt */
-	defineEffect('mend', ({ world, caster, interval = 0 }, effect) => {
-		if (world.time - caster.hurtAt >= effect.unhurtFor) world.heal(caster, caster.maxHp * effect.perSecond * interval)
-	})
-]
-
-/** Shops never run out of what is built to last. What is used up comes a few at a time */
-const few = (max: number, restock: number) => ({ max, restock })
-
-export const items: ItemDef[] = [
-	// ---- used up
-	{
-		id: 'healingPotion',
-		name: 'Health Potion',
-		description: 'Restores 250 health when drunk',
-		tier: 'consumable',
-		cost: { gold: 150 },
-		charges: 1,
-		ability: 'drinkHealing',
-		stock: few(3, 60)
-	},
-	{
-		id: 'manaPotion',
-		name: 'Mana Potion',
-		description: 'Restores 150 mana when drunk',
-		tier: 'consumable',
-		cost: { gold: 200 },
-		charges: 1,
-		ability: 'drinkMana',
-		stock: few(2, 60)
-	},
-	{
-		id: 'scrollOfHealing',
-		name: 'Scroll of Healing',
-		description: 'Heals friendly units around the reader for 150',
-		tier: 'consumable',
-		cost: { gold: 250 },
-		charges: 1,
-		ability: 'readHealing',
-		stock: few(1, 120)
-	},
-	{
-		id: 'revealingDust',
-		name: 'Revealing Dust',
-		description: 'Lifts the fog over an area anywhere on the map for 5 seconds. Enemies can see it happen',
-		tier: 'consumable',
-		cost: { gold: 50 },
-		charges: 2,
-		ability: 'revealArea',
-		stock: few(3, 45)
-	},
-	{
-		id: 'sentryWard',
-		name: 'Sentry Ward',
-		description: 'Puts down a ward that sees around it for 60 seconds. Enemies see it for 2 seconds, then only with an oracle. Goes down in 3 hits',
-		tier: 'consumable',
-		cost: { gold: 75 },
-		charges: 2,
-		ability: 'plantWard',
-		stock: few(2, 60)
-	},
-	{
-		id: 'oracle',
-		name: "Oracle's Eye",
-		description: 'Sends out a pulse that finds enemy wards around the hero, for 8 seconds. Every 25 seconds',
-		tier: 'consumable',
-		cost: { gold: 150 },
-		ability: 'sweep',
-		stock: few(1, 90)
-	},
-
-	// ---- to start with
-	{
-		id: 'squiresBlade',
-		name: "Squire's Blade",
-		description: '+10 attack damage, +80 health, and 2.5% of all damage dealt comes back as health',
-		tier: 'starter',
-		cost: { gold: 225 },
-		bonus: { stats: { attackDamage: 10, health: 80, omnivamp: 0.025 } }
-	},
-	{
-		id: 'squiresShield',
-		name: "Squire's Shield",
-		description: '+110 health, and 0.8 more health regained per second',
-		tier: 'starter',
-		cost: { gold: 225 },
-		bonus: { stats: { health: 110, healthRegen: 0.8 } }
-	},
-	{
-		id: 'squiresRing',
-		name: "Squire's Ring",
-		description: '+18 ability power, +90 health, and 1 more mana regained per second',
-		tier: 'starter',
-		cost: { gold: 200 },
-		bonus: { stats: { abilityPower: 18, health: 90, manaRegen: 1 } }
-	},
-
-	// ---- basic
-	{
-		id: 'longSword',
-		name: 'Long Sword',
-		description: '+10 attack damage',
-		tier: 'basic',
-		cost: { gold: 175 },
-		bonus: { stats: { attackDamage: 10 } }
-	},
-	{ id: 'dagger', name: 'Dagger', description: 'Attacks 10% faster', tier: 'basic', cost: { gold: 125 }, bonus: { percent: { attackSpeed: 0.1 } } },
-	{ id: 'clothArmor', name: 'Cloth Armor', description: '+15 armor', tier: 'basic', cost: { gold: 150 }, bonus: { stats: { armor: 15 } } },
-	{
-		id: 'wardingMantle',
-		name: 'Warding Mantle',
-		description: '+20 magic resist',
-		tier: 'basic',
-		cost: { gold: 200 },
-		bonus: { stats: { magicResist: 20 } }
-	},
-	{ id: 'bloodGem', name: 'Blood Gem', description: '+150 health', tier: 'basic', cost: { gold: 200 }, bonus: { stats: { health: 150 } } },
-	{
-		id: 'apprenticeTome',
-		name: "Apprentice's Tome",
-		description: '+20 ability power',
-		tier: 'basic',
-		cost: { gold: 200 },
-		bonus: { stats: { abilityPower: 20 } }
-	},
-	{
-		id: 'manaCharm',
-		name: 'Mana Charm',
-		description: 'Mana comes back 50% faster',
-		tier: 'basic',
-		cost: { gold: 100 },
-		bonus: { percent: { manaRegen: 0.5 } }
-	},
-	{ id: 'boots', name: 'Boots', description: '+25 move speed', tier: 'basic', cost: { gold: 150 }, bonus: { stats: { moveSpeed: 0.3125 } } },
-	{
-		id: 'duelistsCloak',
-		name: "Duelist's Cloak",
-		description: '15% chance to strike critically',
-		tier: 'basic',
-		cost: { gold: 300 },
-		bonus: { stats: { critChance: 0.15 } }
-	},
-	{ id: 'pickaxe', name: 'Pickaxe', description: '+25 attack damage', tier: 'basic', cost: { gold: 440 }, bonus: { stats: { attackDamage: 25 } } },
-	{
-		id: 'greatsword',
-		name: 'Greatsword',
-		description: '+40 attack damage',
-		tier: 'basic',
-		cost: { gold: 650 },
-		bonus: { stats: { attackDamage: 40 } }
-	},
-
-	// ---- built from the basic ones
-	{
-		id: 'leechingRod',
-		name: 'Leeching Rod',
-		description: '+15 attack damage, and 7% of the damage of attacks comes back as health',
-		tier: 'epic',
-		cost: { gold: 450 },
-		from: ['longSword'],
-		bonus: { stats: { attackDamage: 15, lifeSteal: 0.07 } }
-	},
-	{
-		id: 'jaggedKnife',
-		name: 'Jagged Knife',
-		description: '+20 attack damage, ignores 10 armor',
-		tier: 'epic',
-		cost: { gold: 500 },
-		from: ['longSword', 'longSword'],
-		bonus: { stats: { attackDamage: 20, lethality: 10 } }
-	},
-	{
-		id: 'hexCodex',
-		name: 'Hex Codex',
-		description: '+25 ability power, 10 ability haste',
-		tier: 'epic',
-		cost: { gold: 425 },
-		from: ['apprenticeTome'],
-		bonus: { stats: { abilityPower: 25, abilityHaste: 10 } }
-	},
-	{
-		id: 'piercingJewel',
-		name: 'Piercing Jewel',
-		description: '+25 ability power, ignores 13% of magic resist',
-		tier: 'epic',
-		cost: { gold: 550 },
-		from: ['apprenticeTome'],
-		bonus: { stats: { abilityPower: 25, magicPenetrationPercent: 0.13 } }
-	},
-	{
-		id: 'mendersIdol',
-		name: "Mender's Idol",
-		description: 'Heals and shields are 8% stronger, mana comes back 50% faster',
-		tier: 'epic',
-		cost: { gold: 300 },
-		from: ['manaCharm'],
-		bonus: { stats: { healShieldPower: 0.08 }, percent: { manaRegen: 0.5 } }
-	},
-	{
-		id: 'ogreBelt',
-		name: 'Ogre Belt',
-		description: '+350 health',
-		tier: 'epic',
-		cost: { gold: 450 },
-		from: ['bloodGem'],
-		bonus: { stats: { health: 350 } }
-	},
-	{
-		id: 'stoneBracer',
-		name: 'Stone Bracer',
-		description: '+200 health, and health comes back twice as fast',
-		tier: 'epic',
-		cost: { gold: 400 },
-		from: ['bloodGem'],
-		bonus: { stats: { health: 200 }, percent: { healthRegen: 1 } }
-	},
-	{
-		id: 'chainVest',
-		name: 'Chain Vest',
-		description: '+40 armor',
-		tier: 'epic',
-		cost: { gold: 400 },
-		from: ['clothArmor'],
-		bonus: { stats: { armor: 40 } }
-	},
-	{
-		id: 'swiftGreaves',
-		name: 'Swift Greaves',
-		description: '+45 move speed, attacks 30% faster',
-		tier: 'epic',
-		cost: { gold: 550 },
-		from: ['boots', 'dagger', 'dagger'],
-		bonus: { stats: { moveSpeed: 0.5625 }, percent: { attackSpeed: 0.3 } }
-	},
-	{
-		id: 'steadfastTreads',
-		name: 'Steadfast Treads',
-		description: '+45 move speed, +20 magic resist, stuns and slows last 30% shorter',
-		tier: 'epic',
-		cost: { gold: 625 },
-		from: ['boots', 'wardingMantle'],
-		bonus: { stats: { moveSpeed: 0.5625, magicResist: 20, tenacity: 0.3 } }
-	},
-
-	// ---- what it all leads to
-	{
-		id: 'keenEdge',
-		name: 'Keen Edge',
-		description: '+75 attack damage, 25% chance to strike critically, and critical strikes deal 30% more',
-		tier: 'legendary',
-		cost: { gold: 1750 },
-		from: ['greatsword', 'pickaxe', 'duelistsCloak'],
-		bonus: { stats: { attackDamage: 75, critChance: 0.25, critDamage: 0.3 } }
-	},
-	{
-		id: 'mendingPlate',
-		name: 'Mending Plate',
-		description: '+1000 health, health comes back twice as fast. After 8 seconds without being hurt, 3% of its health comes back every second',
-		tier: 'legendary',
-		cost: { gold: 1550 },
-		from: ['ogreBelt', 'ogreBelt', 'stoneBracer'],
-		bonus: { stats: { health: 1000 }, percent: { healthRegen: 1 } },
-		passive: 'mendingHeart'
-	},
-	{
-		id: 'reprieve',
-		name: 'Reprieve',
-		description:
-			'+30 ability power, 15 ability haste, heals and shields are 10% stronger, mana comes back twice as fast. Used: a beam on a spot far away heals friends there for 150 to 350 after 2.5 seconds. Every 90 seconds',
-		tier: 'legendary',
-		cost: { gold: 1150 },
-		from: ['hexCodex', 'mendersIdol'],
-		bonus: { stats: { abilityPower: 30, abilityHaste: 15, healShieldPower: 0.1 }, percent: { manaRegen: 1 } },
-		ability: 'intervention'
-	}
-]
-
-/** Everything there is to buy, the way a shop lays it out */
-export const catalogue = items.map((item) => item.id)
+import { defaultItems, defaultItemSet, itemTier } from '@v12-engine/engine'
+
+/*
+ * The game's items are the engine's default set (`defaultItemSet`): a whole tree, from the draughts to the twelve
+ * legendaries and the relics, with what they use. The game takes it in `index.ts` (`useDefaults`), all of it; to take
+ * all but some, only some, some changed, items of its own besides, or none, say so there:
+ *
+ *     useDefaults(rules, [defaultItemSet], { items: { except: ['sightWard'], with: [myItem], change: { boots: { cost: { gold: 250 } } } } })
+ *
+ * or in `data.json` (the editor's Data panel writes it): `"defaults": { "items": { "except": ["sightWard"] } }`
+ */
+export { defaultItemSet }
+
+/** Everything there is to buy, the way a shop lays it out: the set's items but the relics, which are found, never sold */
+export const catalogue = defaultItems.filter((item) => itemTier(item) !== 'relic').map((item) => item.id)

package/starters/melee/src/melee/languages/he.json

@@ -56,6 +56,12 @@
 		"ui.menu.saves": "שמירה וטעינה",
 		"ui.menu.score": "ניקוד",
 		"ui.menu.restart": "התחלה מחדש",
+		"ui.menu.photo": "מצב צילום",
+		"ui.photo.how": "W, A, S, D לתנועה, Q ו-E למטה ולמעלה, Shift מהר יותר; גרירה לסיבוב, הכפתור האמצעי להזזה, הגלגלת לקרבה ולמרחק; Esc ליציאה",
+		"ui.photo.hour": "שעה ביום",
+		"ui.photo.take": "צילום",
+		"ui.photo.leave": "יציאה",
+		"ui.photo.taken": "{name}, {width} × {height}",
 		"ui.menu.surrender": "כניעה",
 		"ui.menu.waits": "המשחק ממתין",
 		"ui.settings.reset": "החזרת הכול לברירת המחדל",
@@ -78,8 +84,14 @@
 		"unit.gryphon": "רוכב גריפון",
 		"unit.priest": "כוהן",
 		"unit.sorceress": "מכשפה",
-		"unit.paladin": "פלדין",
-		"unit.archmage": "ארכי־קוסם",
+		"unit.oathbreaker": "שובר השבועה",
+		"unit.dawnPriest": "כוהן השחר",
+		"unit.stormcaller": "קורא הסערה",
+		"unit.galeHunter": "צייד הרוח",
+		"unit.gravelord": "אדון הקברים",
+		"unit.rimeWitch": "מכשפת הכפור",
+		"unit.duskblade": "להב הדמדומים",
+		"unit.boneReaver": "קוצר העצמות",
 		"unit.townhall": "בית העירייה",
 		"unit.keep": "מבצר",
 		"unit.castle": "טירה",

package/starters/melee/src/melee/pings.ts

@@ -9,23 +9,22 @@ export const WHEEL_PINGS = ['look', 'danger', 'assist', 'onMyWay', 'missing', 'r
 
 /**
  * The pings melee has besides the wheel's: sent from code and heard by a computer ally (push attacks, hold defends:
- * `GameRules.talk.pings.meanings`), off the wheel (`wheel: { hidden: true }` in the view)
+ * `RuleSettings.talk.pings.meanings`), off the wheel (`wheel: { hidden: true }` in the view)
  */
 export const OFF_WHEEL_PINGS = ['hold', 'push', 'question'] as const
 
 /**
  * The kinds of ping melee has, kept in one place: what the view draws and puts on the wheel (`playerPings:
- * withPingsFile(presetPings(PINGS), pings.json)`)
+ * layPings(presetPings(PINGS), pings.json)`)
  */
 export const PINGS = [...WHEEL_PINGS, ...OFF_WHEEL_PINGS] as const
 
 /**
- * The kinds the editor's Pings fold added in `pings.json`, its keys: a file of the game's own (`GameModule.files`), read
+ * The kinds the editor's Pings fold added in `pings.json`, its keys: a file of the game's own (`Rules.files`), read
  * without the client (the module runs where the simulation runs), and read again as the fold writes it
  */
-export const pingsFile = defineGameFile('pings.json', pingsData, (data) =>
-	Object.keys((data as { kinds?: Record<string, unknown> } | null)?.kinds ?? {})
-)
+export const pingsFile = defineGameFile({ id: 'pings.json', data: pingsData, read: (data) =>
+	Object.keys((data as { kinds?: Record<string, unknown> } | null)?.kinds ?? {}) })
 
 /**
  * What the rules let go (`rules.talk.pings.kinds`): the kinds above and those of `pings.json` as the game plays it, so a

package/starters/melee/src/melee/saves.ts

@@ -1,7 +1,7 @@
 import type { SaveRules } from '@v12-engine/engine'
 
 /*
- * How melee's saves outlive its patches (`GameModule.saves`): the version of what it keeps in a save, and the step
+ * How melee's saves outlive its patches (`Rules.saves`): the version of what it keeps in a save, and the step
  * from each version to the next, for a save made before a patch that changed what a save holds. Declared, a save made
  * before a change of the rules loads all the same (without it, only a save of the very same rules does).
  */