@v12-engine/create 0.0.0-stage → 0.1.0

package/starters/melee/src/melee/fx.json

@@ -0,0 +1 @@
+{}

package/starters/melee/src/melee/game.ts

@@ -0,0 +1,6 @@
+import { defineGame } from '@v12-engine/client'
+import { melee } from './index'
+import { meleeView } from './view'
+
+/** Melee, whole: its rules and how it looks */
+export const meleeGame = defineGame({ rules: melee, view: meleeView })

package/starters/melee/src/melee/generator.ts

@@ -0,0 +1,116 @@
+/**
+ * Melee's maps made by a generator (world plan G4): the engine's passes for the ground, its paint and the starts
+ * (each race puts its own hall and workers there, `defineRace`'s `start`), and the game's own for what it is played
+ * with: a gold mine by each start and more about the map, each guarded by a camp, more camps scattered away from the
+ * starts, and woods of trees to cut (the `tree` unit, not scenery). Everything mirrored as the map is
+ */
+import {
+	exactMath,
+	type GeneratorContext,
+	MAP_NEUTRAL,
+	type MapGenerator,
+	presetGenerator,
+	resourcesPass,
+	scatterPass,
+	startsPass,
+	terrainPass,
+	tilesPass,
+	type Vec2
+} from '@v12-engine/engine'
+
+/** The engine's preset's parameters for the ground (cliff levels, water, roughness, hills): the game's own come after */
+const GROUND = presetGenerator().params.filter((param) => ['levels', 'water', 'roughness', 'hills'].includes(param.id))
+
+/** Who guards a camp, the weaker more often */
+const CAMPS = [['gnoll', 'gnoll'], ['gnoll', 'gnoll', 'gnoll'], ['ogre'], ['ogre', 'gnoll']]
+
+/** A camp of creeps at a place, of a kind drawn from the seed once for the place and its mirrors: the map is fair */
+const camp = (ctx: GeneratorContext, at: Vec2) =>
+	ctx.addCamp(
+		at.x,
+		at.z,
+		ctx.once(at.x, at.z, () => CAMPS[ctx.rng.int(0, CAMPS.length - 1)])
+	)
+
+export const meleeGenerator: MapGenerator = {
+	params: [
+		...GROUND,
+		{
+			id: 'mines',
+			name: 'Gold mines',
+			description: 'How many more gold mines there are besides one at each start, each guarded: each mirrored as the map is',
+			default: 2,
+			min: 0,
+			max: 8,
+			step: 1
+		},
+		{
+			id: 'camps',
+			name: 'Creep camps',
+			description: 'How often a camp of creeps stands about the map, away from the starts',
+			default: 0.002,
+			min: 0,
+			max: 0.01,
+			step: 0.001
+		},
+		{ id: 'trees', name: 'Woods', description: 'How much of the map is woods, to cut for lumber', default: 0.18, min: 0, max: 0.5, step: 0.02 }
+	],
+	passes: [
+		terrainPass(),
+		tilesPass(),
+		// room for a hall and its workers: the race puts them there as the game starts
+		startsPass({ clearing: 8 }),
+		{
+			id: 'mines',
+			name: 'The gold mines',
+			run(ctx) {
+				resourcesPass({
+					main: 9,
+					extra: ctx.param('mines', 2),
+					from: (ctx, at, start) => {
+						// a mine stands on whole cells (4 by 4), its middle on a corner of them
+						ctx.addObject('goldmine', MAP_NEUTRAL, Math.round(at.x), Math.round(at.z))
+						if (start) return
+						// one not at a start is guarded, by a camp between it and the map's middle: the same side of every mirrored one
+						const dx = ctx.map.width / 2 - at.x
+						const dz = ctx.map.depth / 2 - at.z
+						const far = exactMath.hypot(dx, dz) || 1
+						const guard = { x: at.x + (dx / far) * 5, z: at.z + (dz / far) * 5 }
+						ctx.mark('camps', guard.x, guard.z, 3)
+						camp(ctx, guard)
+					}
+				}).run(ctx)
+			}
+		},
+		// a tavern in the middle, for anyone who goes there (its heroes hired once each), where the middle is land
+		{
+			id: 'tavern',
+			name: 'The tavern',
+			run(ctx) {
+				const at = { x: Math.round(ctx.map.width / 2) + 0.5, z: Math.round(ctx.map.depth / 2) + 0.5 }
+				const { map } = ctx
+				if (!ctx.free(at.x, at.z, 3) || map.water[Math.floor(at.z) * map.width + Math.floor(at.x)] !== 0) return
+				ctx.mark('camps', at.x, at.z, 4)
+				ctx.addObject('tavern', MAP_NEUTRAL, at.x, at.z, { name: 'the tavern' })
+			}
+		},
+		// camps about the map: far from the starts, off the mines and each other
+		scatterPass({
+			kind: 'camps',
+			spacing: 24,
+			avoid: 24,
+			patches: 0,
+			avoidKinds: { resource: 8, camps: 20 },
+			where: (cell) => !cell.shore,
+			what: camp
+		}),
+		// woods: trees to cut, on whole cells, off the mines and the camps
+		scatterPass({
+			kind: 'trees',
+			spacing: 1.5,
+			avoid: 12,
+			avoidKinds: { resource: 5, camps: 4 },
+			what: (ctx, at) => void ctx.addObject('tree', MAP_NEUTRAL, Math.floor(at.x) + 0.5, Math.floor(at.z) + 0.5)
+		})
+	]
+}

package/starters/melee/src/melee/heroSpells.ts

@@ -0,0 +1,38 @@
+import type { AbilityDef, BuffDef } from '@v12-engine/engine'
+
+/** The spells every hero brings along (`HeroDef.spells`): learned from the start, one point each, on long cooldowns */
+
+export const heroSpellBuffs: BuffDef[] = [
+	{ id: 'healHaste', name: 'Second Wind', description: 'Moves 30% faster', duration: 1, percent: { moveSpeed: 0.3 } },
+	{ id: 'barrier', name: 'Barrier', description: 'A shield takes the damage', duration: 2.5, shield: 120, shieldScaling: { level: 21.2 } }
+]
+
+export const heroSpells: AbilityDef[] = [
+	{
+		id: 'flash',
+		name: 'Flash',
+		description: 'At once a short way towards the pointer, through whatever is in between',
+		target: 'direction',
+		cooldown: 300,
+		effects: [{ type: 'blink', distance: 5.3 }]
+	},
+	{
+		id: 'secondWind',
+		name: 'Second Wind',
+		description: 'The hero and allied heroes nearby regain 80 to 318 health, more with every level, and run 30% faster for a second',
+		target: 'none',
+		cooldown: 240,
+		effects: [
+			{ type: 'heal', amount: 80, scaling: { level: 14 }, radius: 10.9, only: 'heroes' },
+			{ type: 'buff', buff: 'healHaste', radius: 10.9, only: 'heroes' }
+		]
+	},
+	{
+		id: 'barrier',
+		name: 'Barrier',
+		description: 'A shield for 2.5 seconds that takes 120 to 480 damage, more with every level',
+		target: 'none',
+		cooldown: 180,
+		effects: [{ type: 'buff', buff: 'barrier', on: 'caster' }]
+	}
+]

package/starters/melee/src/melee/hud.json

@@ -0,0 +1,269 @@
+{
+	"default": {
+		"plates": [
+			{
+				"when": {
+					"relation": [
+						"self",
+						"ally"
+					]
+				},
+				"show": "hurt",
+				"gap": 2,
+				"items": [
+					{
+						"bar": "health",
+						"ghost": {
+							"seconds": 0.5
+						}
+					},
+					{
+						"buffs": "all",
+						"size": 10,
+						"gap": 1,
+						"most": 6,
+						"dots": true
+					}
+				]
+			},
+			{
+				"show": "hurt",
+				"items": [
+					{
+						"bar": "health",
+						"ghost": {
+							"seconds": 0.5
+						}
+					}
+				]
+			}
+		]
+	},
+	"types": {
+		"necromancer": {
+			"plates": [
+				{
+					"when": {
+						"relation": [
+							"self",
+							"ally"
+						]
+					},
+					"show": "hurt",
+					"gap": 2,
+					"items": [
+						{
+							"column": [
+								{
+									"bar": "health",
+									"ghost": {
+										"seconds": 0.5
+									}
+								},
+								{
+									"bar": "mana",
+									"height": 3
+								}
+							],
+							"gap": 1
+						},
+						{
+							"buffs": "all",
+							"size": 10,
+							"gap": 1,
+							"most": 6,
+							"dots": true
+						}
+					]
+				},
+				{
+					"show": "hurt",
+					"items": [
+						{
+							"bar": "health",
+							"ghost": {
+								"seconds": 0.5
+							}
+						}
+					]
+				}
+			]
+		},
+		"priest": {
+			"plates": [
+				{
+					"when": {
+						"relation": [
+							"self",
+							"ally"
+						]
+					},
+					"show": "hurt",
+					"gap": 2,
+					"items": [
+						{
+							"column": [
+								{
+									"bar": "health",
+									"ghost": {
+										"seconds": 0.5
+									}
+								},
+								{
+									"bar": "mana",
+									"height": 3
+								}
+							],
+							"gap": 1
+						},
+						{
+							"buffs": "all",
+							"size": 10,
+							"gap": 1,
+							"most": 6,
+							"dots": true
+						}
+					]
+				},
+				{
+					"show": "hurt",
+					"items": [
+						{
+							"bar": "health",
+							"ghost": {
+								"seconds": 0.5
+							}
+						}
+					]
+				}
+			]
+		},
+		"sorceress": {
+			"plates": [
+				{
+					"when": {
+						"relation": [
+							"self",
+							"ally"
+						]
+					},
+					"show": "hurt",
+					"gap": 2,
+					"items": [
+						{
+							"column": [
+								{
+									"bar": "health",
+									"ghost": {
+										"seconds": 0.5
+									}
+								},
+								{
+									"bar": "mana",
+									"height": 3
+								}
+							],
+							"gap": 1
+						},
+						{
+							"buffs": "all",
+							"size": 10,
+							"gap": 1,
+							"most": 6,
+							"dots": true
+						}
+					]
+				},
+				{
+					"show": "hurt",
+					"items": [
+						{
+							"bar": "health",
+							"ghost": {
+								"seconds": 0.5
+							}
+						}
+					]
+				}
+			]
+		},
+		"gnoll": {
+			"plates": [
+				{
+					"show": "hurt",
+					"items": [
+						{
+							"bar": "health",
+							"ghost": {
+								"seconds": 0.5
+							}
+						}
+					]
+				}
+			],
+			"within": 45,
+			"far": {
+				"items": [
+					{
+						"badge": "",
+						"size": 7,
+						"background": "#e8913a",
+						"border": "#2a1a08"
+					}
+				]
+			}
+		},
+		"ogre": {
+			"plates": [
+				{
+					"show": "hurt",
+					"items": [
+						{
+							"bar": "health",
+							"ghost": {
+								"seconds": 0.5
+							}
+						}
+					]
+				}
+			],
+			"within": 45,
+			"far": {
+				"items": [
+					{
+						"badge": "",
+						"size": 7,
+						"background": "#e8913a",
+						"border": "#2a1a08"
+					}
+				]
+			}
+		},
+		"troll": {
+			"plates": [
+				{
+					"show": "hurt",
+					"items": [
+						{
+							"bar": "health",
+							"ghost": {
+								"seconds": 0.5
+							}
+						}
+					]
+				}
+			],
+			"within": 45,
+			"far": {
+				"items": [
+					{
+						"badge": "",
+						"size": 7,
+						"background": "#e8913a",
+						"border": "#2a1a08"
+					}
+				]
+			}
+		}
+	}
+}

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

@@ -0,0 +1,182 @@
+import {
+	defineCellLayer,
+	defineRace,
+	withCapture,
+	withConcealment,
+	withStances,
+	withData,
+	type Entity,
+	type GameModule,
+	type StartData,
+	hotRules,
+	presetScore,
+	heroState,
+	withHeroes,
+	withMobaStats,
+	withVeterancy,
+	withWalls,
+	withRemains,
+	withFriendlyFire,
+	laneMinion
+} 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 { 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) */
+function ruinsOf(dead: Entity): string | null {
+	const footprint = dead.def.footprint
+	if (!footprint || dead.isResource || dead.def.wall || dead.def.invulnerable || dead.on !== undefined) return null
+	const size = Math.min(Math.max(footprint.w, footprint.d), 4)
+	return size >= 2 ? `ruins${size}` : 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 } }
+
+/** Classic base building: gather gold, raise an army, destroy the other side */
+export const melee: GameModule = withData(
+	{
+		id: 'my-game',
+		name: 'My game',
+		version: '1.0.0',
+		// a route in the dark says nothing of what is there: each side plans with the buildings it has seen
+		paths: 'seen',
+		// its computer player: the engine's melee brain, what a seat that names no brain gets
+		brains: [meleeBrain],
+		units,
+		upgrades,
+		// two sides, each its own roster, hall and workers (features-plan C4): chosen in the lobby, or fixed by a map
+		races: [
+			defineRace({
+				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
+			}),
+			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' },
+				// gold at a cursed mine, buildings on blight (`blight.ts`)
+				hooks: undeadHooks
+			})
+		],
+		abilities: [...abilities, ...heroSpells, ...itemAbilities, ...undeadAbilities],
+		// the classic battle line beside the engine's formations, on the button by the minimap (`formations.ts`)
+		formations,
+		effects: itemEffects,
+		items,
+		resources: [
+			// gold pays for most things, and is what upkeep cuts into
+			{ id: 'gold', name: 'Gold', start: 500, upkeep: true },
+			{ id: 'lumber', name: 'Lumber', start: 300 }
+		],
+		currency: 'gold',
+		tiles,
+		// tall grass, painted on the map: what is in it is hidden from those outside (features-plan G)
+		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]
+			}),
+			// spoiled ground round the Restless' halls and cursed mines, that its buildings go up on (features-plan C5)
+			blightLayer
+		],
+		systems: [blightSystem],
+		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],
+		// 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
+		// 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) }),
+			// 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) }),
+			// 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()
+		],
+		// what a player of no race starts with: the humans' start
+		start: 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: {
+			// 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
+			// alone, not every footman's under an aura
+			hud: { shareBuffTimes: (_world, entity) => entity.has(heroState) },
+			// the classic score screen: everything the engine counts, a point of the graph every 10 seconds; the side's numbers
+			// while it goes on, everyone's at the end
+			score: presetScore(),
+			// classic melee maps: the whole map explored from the start, the fog over it all the same: the ground dim,
+			// trees, mines and neutral buildings seen as they stand; units, and the other players' buildings, only once in
+			// 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]
+					]
+				}
+			}
+		},
+		components: [blightSpread],
+		// 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'
+	},
+	dataFile
+)
+
+// saved while it runs in the dev server: the games and editors of the page take the new version (hot reload)
+if (import.meta.hot) import.meta.hot.accept((module) => hotRules(import.meta.hot, melee, module?.melee))