@v12-engine/create 0.0.0-stage → 0.1.1

package/starters/empty/src/rules.ts

@@ -0,0 +1,67 @@
+/**
+ * The rules: what there is, and what happens once a game starts. They use the engine alone, so the page, the server
+ * and the tests all play the same game. Start here: a unit type is an entry of `units`
+ */
+import { defineIds, type GameMap, type GameModule, hotRules, type IdOf, presetGenerator, type World } from '@v12-engine/engine'
+import { maps } from './maps'
+import { tiles } from './tiles'
+
+/** The ids of the game's unit types, named once: `UNIT.scout` everywhere else */
+export const UNIT = defineIds('scout')
+export type Unit = IdOf<typeof UNIT>
+
+export const rules: GameModule = {
+	// the maps of this game say they are its own by this id: change it, and change theirs (`"game"`) with it
+	id: 'my-game',
+	name: 'My game',
+	units: [
+		{
+			id: UNIT.scout,
+			name: 'Scout',
+			kind: 'unit',
+			radius: 0.4,
+			// no attack yet: give it `attackDamage`, `attackSpeed`, `attackRange` here and an attack in its `attacks`, and it fights
+			stats: { health: 100, moveSpeed: 5 },
+			sight: 10
+		}
+	],
+	// what the ground is painted with (src/tiles.ts)
+	tiles,
+	// @if assets
+	/**
+	 * Its generator of maps: the map editor's File › New map from a generator. The engine's preset (hills, water, ramps,
+	 * the paint, the starts, trees and rocks) with the shared art's trees and rocks; a game's own passes go in its list
+	 * (`presetGenerator(...).passes`, or a `MapGenerator` of its own: `terrainPass`, `scatterPass`…)
+	 */
+	generator: presetGenerator({
+		trees: ['forest/common_tree_1.glb', 'forest/common_tree_2.glb', 'forest/common_tree_5.glb', 'forest/pine_1.glb', 'forest/pine_3.glb'],
+		rocks: ['forest/rock_medium_1.glb', 'forest/rock_medium_2.glb', 'forest/rock_medium_3.glb'],
+		// the forest's trees are near 4 high as they are
+		treeScale: { scale: 1, vary: 0.2 }
+	}),
+	// @end
+	// @if !assets
+	/**
+	 * Its generator of maps: the map editor's File › New map from a generator. The engine's preset (hills, water, ramps,
+	 * the paint, the starts); trees and rocks are models of the game's to name (`presetGenerator({ trees: [...] })`)
+	 */
+	generator: presetGenerator(),
+	// @end
+	// the maps the game ships: a save of a game on one of them keeps only what changed of its ground
+	maps: Object.values(maps),
+	// nobody wins or loses yet. `coreVictory` (the last side with something wins) or a system of your own decides it
+	victory: null
+}
+
+/**
+ * What the game does once a world is made from a map, before anyone plays: a scout for each player with a start, at
+ * it. The page, the server and the editor's Play here each call it with the map
+ */
+export function start(world: World, { map }: { map?: GameMap }): void {
+	for (const player of map?.players ?? []) {
+		if (player.start) world.spawn(UNIT.scout, player.id, player.start)
+	}
+}
+
+// saved while it runs (npm run dev): the game and the editor open take the new version, with no new page
+if (import.meta.hot) import.meta.hot.accept((module) => hotRules(import.meta.hot, rules, module?.rules))

package/starters/empty/src/tiles.ts

@@ -0,0 +1,12 @@
+/**
+ * What the ground can be painted with: the rules' names for it, which the map editor's Paint offers and the rules read
+ * (`world.registry.tile('road')`). How each looks is the game's look's (`tiles` in `src/game.ts`). A new one is a line
+ * here and one there; a map keeps its paint by these names, so their order can change
+ */
+import { presetTiles } from '@v12-engine/engine'
+
+/**
+ * The engine's tiles of an RTS (grass, dark grass, dirt, road, sand, rock, snow), drawn with the client's `TILE_LOOKS`.
+ * A game's own goes beside them: `defineTile({ id: 'lava', name: 'Lava' })` here, its look in `src/game.ts`
+ */
+export const tiles = [...presetTiles]

package/starters/melee/README.md

@@ -0,0 +1,61 @@
+# My game
+
+A real-time strategy game made with V12, whole: melee. Two races, the humans and the Restless, each with its workers, halls, army and heroes; gold from mines and lumber from the woods; bases built up, armies trained, the other side's buildings brought down. You play the first player of the Bay, and the computer the others; or a random map, made anew each time.
+
+| To      | Run                                                                                |
+| ------- | ---------------------------------------------------------------------------------- |
+| Play it | `npm run dev`, and open the page it says: its start screen, Play (or Random map) |
+<!-- @if editor -->
+| Make maps | `npm run dev`, and open `/?editor`: Save writes them into `src/maps` |
+| Check the maps | `npm run map check`: every map in `src/maps` against the game's rules |
+<!-- @end -->
+<!-- @if server -->
+<!-- @if !rooms -->
+| Play it on a server | `npm run server`, beside `npm run dev`, and open `/?server` |
+<!-- @end -->
+<!-- @if rooms -->
+| Play it online | `npm run server`, beside `npm run dev`, and open `/?find-game` |
+<!-- @end -->
+<!-- @end -->
+<!-- @if tests -->
+| Test the rules | `npm test` |
+<!-- @end -->
+| Check the types | `npm run typecheck` |
+| Build the page to host | `npm run build`, into `dist/` |
+
+## What is where
+
+- `src/melee/`: the game. `index.ts` puts the rules together (the engine's packs it turns on: stances, capture points, bushes that hide); `units.ts` the humans, `undead.ts` the Restless, `heroSpells.ts` the spells every hero brings along, `abilities.ts` and `items.ts` what they cast and carry; `blight.ts` the Restless' ground; `generator.ts` the random maps and `bay.ts` the Bay made in code; `maps.ts` what a melee map must have (a town hall for someone, and someone to play against); `view/` how it looks; `data.json`, `looks.json`, `hud.json`, `fx.json`, `floats.json`, `pings.json`, `quality.json`, `cellLayers.json` and `sounds.json` what the editor's panels write
+- `src/rules.ts`, `src/game.ts`, `src/maps.ts`: the game by the names the page, the server and the tests know it by. `start` in `src/rules.ts` seats the computer at every player but you
+- `src/maps/`: the maps, made in the editor. A new one is imported in `src/maps.ts`
+- `src/main.ts`: the page, its scenes made by `appScenes`
+
+<!-- @if editor -->
+
+- `src/editor.ts`: the map editor's own settings, for `appScenes`: the capture points placed as things of their kind. What it checks of a map is the rules' (`src/melee/maps.ts`)
+
+<!-- @end -->
+<!-- @if server -->
+<!-- @if !rooms -->
+
+- `server.ts`: a server of the game, one game at a time, `startServer`: the first player's seat for whoever joins, the computer the rest
+
+<!-- @end -->
+<!-- @if rooms -->
+
+- `server.ts`: a server of many games, `GameRooms`: a room for each map, a random map, and games players make (New game). The page's `/?find-game` is the client's Find a game
+
+<!-- @end -->
+<!-- @if ratings -->
+
+- `ratings.json` (made by the server): a rating for each player, moved by each game that ends with a winner
+
+<!-- @end -->
+<!-- @end -->
+<!-- @if tests -->
+
+- `tests/`: the rules tested with no page
+
+<!-- @end -->
+
+Every model it plays with is of the shared art, `@v12-engine/assets` (whose each is: its group's `CREDITS.md` in `node_modules/@v12-engine/assets/groups/`)

package/starters/melee/files.txt

@@ -0,0 +1,60 @@
+# The files melee plays with: what its page asks for in a game on the Bay (the models' levels, lod1 and lod2, as the
+# camera asks, besides). All of them @v12-engine/assets has: the project takes them from it (its groups' CREDITS.md say
+# whose they are). The package's tests check that a project's build has every one
+# the races' workers, soldiers and heroes, with what they hold
+models/characters/barbarian.glb
+models/characters/knight.glb
+models/characters/mage.glb
+models/characters/ranger.glb
+models/characters/rogue_hooded.glb
+models/characters/skeleton_mage.glb
+models/characters/skeleton_minion.glb
+models/characters/skeleton_rogue.glb
+models/characters/skeleton_warrior.glb
+models/gear/axe_1handed.glb
+models/gear/crossbow_2handed.glb
+models/gear/dagger.glb
+models/gear/shield_round.glb
+models/gear/spellbook_open.glb
+models/gear/staff.glb
+models/gear/sword_1handed.glb
+models/gear/sword_2handed.glb
+models/gear/wand.glb
+models/skeleton-gear/axe.glb
+models/skeleton-gear/blade.glb
+models/skeleton-gear/crossbow.glb
+models/skeleton-gear/shield_large_a.glb
+models/skeleton-gear/shield_small_a.glb
+models/skeleton-gear/staff.glb
+# the halls, farms, barracks, towers and the mine
+models/rts/archery_building.glb
+models/rts/archery_towers.glb
+models/rts/barracks.glb
+models/rts/castle.glb
+models/rts/castle_2.glb
+models/rts/castle_fortress.glb
+models/rts/fortress.glb
+models/rts/houses.glb
+models/rts/mine.glb
+models/rts/small_farm.glb
+models/rts/stone_tower.glb
+models/rts/stone_tower_2.glb
+models/rts/storage_house.glb
+models/rts/storage_shed.glb
+models/rts/temple.glb
+models/rts/temple_2.glb
+models/rts/temple_3.glb
+models/rts/tower_house.glb
+models/rts/watch_tower.glb
+models/rts/wooden_fortress.glb
+models/rts/wooden_monument.glb
+models/rts/wooden_temple.glb
+models/village/blacksmith.glb
+models/village/fantasy_sawmill.glb
+# the trees
+models/trees/columnar_1.glb
+models/trees/columnar_2.glb
+models/trees/columnar_5.glb
+models/trees/oak_5.glb
+models/trees/pine_4.glb
+models/trees/pine_5.glb

package/starters/melee/layers/editor/src/editor.ts

@@ -0,0 +1,13 @@
+/**
+ * The map editor of the game, a scene of the app (Map editor on the start screen, or `/?editor`) that `appScenes` makes
+ * (`src/main.ts`): it opens on the Bay, as a file of the project that Save writes back, and Play here tries it in the
+ * page's own game. What is set here is the editor's own: what melee checks of a map and says of its players are its
+ * rules' (`src/melee/maps.ts`, `meleeEditor`); the capture points of the engine's pack, which melee turns on, are placed
+ * as things of their kind
+ */
+import type { AppEditorScene } from '@v12-engine/client/app'
+import '@v12-engine/editor/styles.css'
+
+// fetched as it first opens: the start screen carries none of it
+export const editor = (scene: AppEditorScene) =>
+	import('@v12-engine/editor').then(({ captureKind, editorScene }) => editorScene({ ...scene, kinds: [captureKind] }))

package/starters/melee/layers/tests/tests/rules.test.ts

@@ -0,0 +1,58 @@
+/** The rules, tested with no page: a world steps here as it does in a page */
+import { checkRules, createRegistry, createWorldFromMap, generateMap, type World } from '@v12-engine/engine'
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_MAP, mapNamed, maps } from '../src/maps'
+import { rules, start } from '../src/rules'
+import { checkMeleeMap, HALLS } from '../src/melee/maps'
+
+/** A game on a map, started as the page starts it: you are the first player, the computer the others */
+async function game(name = DEFAULT_MAP): Promise<World> {
+	const map = mapNamed(name)
+	const world = await createWorldFromMap({ map, game: rules, seed: 1 })
+	start(world, { map, player: map.players[0].id })
+	return world
+}
+
+describe('the rules', () => {
+	it('fit together: every id they name is theirs, every effect has a handler (checkRules)', () => {
+		expect(checkRules(rules).filter((problem) => problem.level === 'error')).toEqual([])
+	})
+
+	it('give every player with a start a hall and workers, and seat the computer at all but you', async () => {
+		const world = await game()
+		const starts = mapNamed().players.filter((player) => player.start)
+		for (const player of starts) {
+			const own = [...world.index.ownedBy(player.id)]
+			expect(
+				own.some((entity) => HALLS.has(entity.def.id)),
+				`player ${player.id}`
+			).toBe(true)
+			expect(own.filter((entity) => entity.def.kind === 'unit').length).toBeGreaterThanOrEqual(5)
+		}
+		expect(world.computers.list()).toEqual(starts.slice(1).map((player) => player.id))
+		world.dispose()
+	}, 30_000)
+
+	it('have the computer gather and build as the game goes', async () => {
+		const world = await game()
+		const enemy = world.computers.list()[0]
+		const gold = world.player(enemy).resources.gold
+		for (let i = 0; i < 60 * world.tickRate; i++) world.step()
+		expect(world.player(enemy).resources.gold).not.toBe(gold)
+		world.dispose()
+	}, 30_000)
+
+	it('read every map, each one melee can be played on', () => {
+		for (const [name, map] of Object.entries(maps))
+			expect(
+				checkMeleeMap(map).filter((problem) => problem.error),
+				name
+			).toEqual([])
+	})
+
+	it('make random maps with their generator, each one melee can be played on', () => {
+		const { map, problems } = generateMap(rules.generator!, { seed: 3, width: 128, depth: 128, players: 2, symmetry: 'half' }, createRegistry(rules))
+		expect(problems.filter((problem) => problem.error)).toEqual([])
+		expect(checkMeleeMap(map).filter((problem) => problem.error)).toEqual([])
+	})
+})

package/starters/melee/src/game.ts

@@ -0,0 +1,2 @@
+/** The game, whole: melee's rules and how it looks (`src/melee/game.ts`, its view in `src/melee/view`) */
+export { meleeGame as game } from './melee/game'

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

@@ -0,0 +1,28 @@
+// Written by the map editor with bay.vgmap.json, anew with every save: not to be changed by hand
+
+/** What is named on the map, for `world.named<BayNames>(...)` */
+export type BayNames =
+	| 'the island alchemist'
+	| 'the island tavern'
+
+/** The camps that are named on the map, for `campNamed(world, ...)` */
+export type BayCamps =
+	| 'the island guard'
+
+/** The regions of the map, for `world.areas` and `enteredArea` */
+export type BayRegions = never
+
+/** The points of the map, for `world.map.point(...)` */
+export type BayPoints = never
+
+/** The paths of the map, for `world.map.path(...)` */
+export type BayPaths = never
+
+/** The lights of the map that are named, for `client.lights.named(...)` */
+export type BayLights = never
+
+/** The effects of the map that are named, for `client.mapEffects.named(...)` */
+export type BayEffects = never
+
+/** The ids of the regions, points and paths by name: what a field that names one keeps (it is handed the name) */
+export const BayIds = { regions: {  }, points: {  }, paths: {  } } as const