@v12-engine/engine 0.1.1 → 0.4.0

package/dist/map/types.js

@@ -0,0 +1,251 @@
+//#region src/map/types.ts
+/**
+* What a doodad keeps off a cell, in `Terrain.blocked`: building, walking too, or building on a bridge one walks on
+*
+* @beta
+*/
+var BLOCKS_BUILD = 1;
+/**
+* The `Terrain.blocked` value for a cell where walking and building are both kept off
+*
+* @beta
+*/
+var BLOCKS_WALK = 2;
+/**
+* The `Terrain.blocked` value for a bridge: walked on, nothing built on it
+*
+* @internal
+*/
+var BRIDGE = 3;
+/**
+* The format map files are written in. It goes up when a file of the format before would be read wrongly: a field
+* that changes what it means, or one a reader must not ignore. A step in `MIGRATIONS` then brings older files up to
+* it. A field that is merely new, and can be left out, needs no new format: a reader that does not know it carries
+* it along (`GameMap.extra`, and whatever an object, a player or a camp holds besides what is known)
+*
+* @internal
+*/
+var MAP_FORMAT = 3;
+/**
+* Owner of trees, mines and whatever belongs to nobody
+*
+* @beta
+*/
+var MAP_NEUTRAL = 0;
+/**
+* Owner of the creeps
+*
+* @beta
+*/
+var MAP_CREEPS = 90;
+/**
+* Players a map may have at most, whatever the game: each could be a team of its own, and the fog of war keeps 32
+* teams apart (`MAX_FOG_TEAMS`). How many a game allows is its own (`Rules.maxPlayers`, 8 when it says nothing)
+*
+* @beta
+*/
+var MAX_MAP_PLAYERS = 32;
+/**
+* Players a game allows on a map when it does not say (`Rules.maxPlayers`)
+*
+* @internal
+*/
+var DEFAULT_MAX_PLAYERS = 8;
+/**
+* Highest cliff level
+*
+* @beta
+*/
+var MAX_LEVEL = 4;
+/**
+* Cells a ramp reaches out on either side of where its slope is: long enough to walk up
+*
+* @internal
+*/
+var RAMP_REACH = 3;
+/**
+* The colours players are given by their number, in 0..1; past the end they start again
+*
+* @beta
+*/
+var PLAYER_COLORS = [
+	[
+		.16,
+		.38,
+		.95
+	],
+	[
+		.85,
+		.14,
+		.12
+	],
+	[
+		.1,
+		.72,
+		.62
+	],
+	[
+		.55,
+		.2,
+		.8
+	],
+	[
+		.95,
+		.85,
+		.15
+	],
+	[
+		.95,
+		.55,
+		.12
+	],
+	[
+		.25,
+		.75,
+		.2
+	],
+	[
+		.9,
+		.45,
+		.7
+	],
+	[
+		.58,
+		.58,
+		.6
+	],
+	[
+		.5,
+		.75,
+		.95
+	],
+	[
+		.06,
+		.38,
+		.27
+	],
+	[
+		.45,
+		.28,
+		.1
+	],
+	[
+		.55,
+		.05,
+		.12
+	],
+	[
+		.05,
+		.08,
+		.45
+	],
+	[
+		.25,
+		.85,
+		.85
+	],
+	[
+		.72,
+		.6,
+		.95
+	],
+	[
+		.92,
+		.82,
+		.62
+	],
+	[
+		.98,
+		.65,
+		.5
+	],
+	[
+		.6,
+		.95,
+		.65
+	],
+	[
+		.82,
+		.78,
+		.98
+	],
+	[
+		.18,
+		.18,
+		.2
+	],
+	[
+		.95,
+		.95,
+		.95
+	],
+	[
+		.05,
+		.6,
+		.3
+	],
+	[
+		.6,
+		.45,
+		.2
+	]
+];
+/**
+* Makes the `MapPlayer` for a player's id, with the default name `Player <id>`, its own team and the colour from `PLAYER_COLORS`
+*
+* @beta
+*/
+var playerSlot = (id) => ({
+	id,
+	name: `Player ${id}`,
+	team: id,
+	color: PLAYER_COLORS[(id - 1) % PLAYER_COLORS.length]
+});
+/**
+* Flat grass, two players and nothing on it
+*
+* @beta
+*/
+function createMap(options) {
+	const { width, depth, height = 1, players = 2 } = options;
+	const cells = width * depth;
+	return {
+		name: options.name ?? "New map",
+		description: "",
+		...options.game !== void 0 && { game: options.game },
+		width,
+		depth,
+		cliffHeight: 3,
+		ground: new Float32Array((width + 1) * (depth + 1)).fill(height),
+		levels: new Uint8Array(cells),
+		ramps: new Uint8Array(cells),
+		water: new Uint8Array(cells),
+		tiles: new Uint8Array(cells),
+		tileset: [...options.tileset ?? []],
+		players: Array.from({ length: players }, (_, i) => playerSlot(i + 1)),
+		objects: [],
+		camps: [],
+		regions: [],
+		points: [],
+		paths: [],
+		doodads: [],
+		cameras: [],
+		data: {}
+	};
+}
+/**
+* The smallest a map can be made, each way: the editor's, and the size a map file is read at
+*
+* @internal
+*/
+var MIN_MAP_SIZE = 8;
+/**
+* The largest, the same for the editor and a map file. 512 until a game needs more (S37 is what makes more cost little)
+*
+* @beta
+*/
+var MAX_MAP_SIZE = 512;
+//#endregion
+export { BLOCKS_BUILD, BLOCKS_WALK, BRIDGE, DEFAULT_MAX_PLAYERS, MAP_CREEPS, MAP_FORMAT, MAP_NEUTRAL, MAX_LEVEL, MAX_MAP_PLAYERS, MAX_MAP_SIZE, MIN_MAP_SIZE, PLAYER_COLORS, RAMP_REACH, createMap, playerSlot };
+
+//# sourceMappingURL=types.js.map

package/dist/map/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/map/types.ts"],"sourcesContent":["/*\n * A map's data as the engine reads it: the ground's layers, who plays, what stands on it, its names, and the constants they go by (design review E8a: `map.ts` in parts)\n */\nimport type { GameData } from '../gameData'\nimport type { AreaShape } from '../areas'\nimport type { PlayerId } from '../entity'\nimport type { GeneratedWith } from '../generate'\nimport type { Vec2 } from '../math'\nimport type { MapDoodadLight, MapEnvironment } from './look'\n\n/**\n * A map: the ground and what stands on it when the game begins, as data. The editor makes them, scenes play them.\n *\n * The ground is kept in layers that are edited apart and put together into a `Terrain`: the height of the land,\n * cliff levels, ramps between levels, water and paint. The layers are what a map file stores, the terrain is\n * derived from them whenever one changes.\n *\n * @public\n */\nexport interface GameMap {\n\t/** The map's name, as lists and the editor show it */\n\tname: string\n\t/** A line about the map, for lists of maps */\n\tdescription: string\n\t/**\n\t * The game the map was made for, by the id of its module (`Rules.id`): a world is not made from it for\n\t * another. For any game when left out, like the maps made before maps said\n\t */\n\tgame?: string\n\t/** The map's width in cells */\n\twidth: number\n\t/** The map's depth in cells */\n\tdepth: number\n\t/** How much higher a level stands than the one below */\n\tcliffHeight: number\n\t/** Height of the land per vertex, row by row, before cliffs and water */\n\tground: Float32Array\n\t/** Cliff level per cell */\n\tlevels: Uint8Array\n\t/** 1 where a cell is part of a ramp: the levels around it are joined by a slope instead of a cliff */\n\tramps: Uint8Array\n\t/** `WATER_*` per cell */\n\twater: Uint8Array\n\t/** Paint per cell: 0 for none, otherwise 1 and up into `tileset` */\n\ttiles: Uint8Array\n\t/**\n\t * The game's own layers of cells (`CellLayerDef`), by id: where the bushes are. A value per cell, row by row. Left\n\t * out, or a layer left out, for none\n\t */\n\tcells?: Record<string, Uint8Array>\n\t/**\n\t * What is kept off each cell by hand, as the editor's pathing brush paints it: `BLOCKS_BUILD` (no building there),\n\t * `BLOCKS_WALK` (nothing walks or builds there), 0 for nothing. With what doodads keep off, into `Terrain.blocked`:\n\t * no-build zones, invisible walls. Left out for none. While the game runs, a game blocks the way with obstacles\n\t * (`world.nav.addObstacle`) and keeps buildings off with the `canPlace` hook\n\t */\n\tpathing?: Uint8Array\n\t/**\n\t * The tiles the paint of `tiles` is, by name: index 1 is the first. The game's own list, as the map is opened with\n\t * a game (`adoptTileset`); names the game does not have come after it, kept for the file\n\t */\n\ttileset: string[]\n\t/** The players who can take part. Neutral and the creeps are always there on top of these */\n\tplayers: MapPlayer[]\n\t/** What stands on the map when the game begins: units, buildings, trees, mines */\n\tobjects: MapObject[]\n\t/** The creep camps of the map */\n\tcamps: MapCamp[]\n\t/** Parts of the map the rules watch by name: who walks in and out (see `MapRegion`) */\n\tregions: MapRegion[]\n\t/** Spots the rules know by name: where a wave comes in, where a hero waits (see `MapPoint`) */\n\tpoints: MapPoint[]\n\t/** Lines the rules know by name: a road, a patrol route (see `MapPath`) */\n\tpaths: MapPath[]\n\t/** Scenery, which the rules do not know of but where it blocks (see `MapDoodad`) */\n\tdoodads: MapDoodad[]\n\t/** Views of the map saved under names (see `MapCamera`) */\n\tcameras: MapCamera[]\n\t/** Groups what is placed can be drawn from when the game starts, and tables of what drops (see `MapRandomGroup`) */\n\trandomGroups?: MapRandomGroup[]\n\t/** The tables of what dropped things come from, by name (`MapObject.drops`) */\n\titemTables?: MapItemTable[]\n\t/**\n\t * The map's own definitions (campaign plan RC8), a `data.json` as the game's has it (`GameData`): laid over the\n\t * game's data as a world is made from the map, before its rules are checked. A footman of 200 health on this map\n\t * alone. Its rules hash has them, so a save of it is not one of another map with other definitions\n\t */\n\tdefinitions?: GameData\n\t/** Its teams, named, and what their players share (see `MapForce`). Teams by number only when left out */\n\tforces?: MapForce[]\n\t/** The races a lobby offers its players who have none fixed (`MapPlayer.race`), by id. All of the game's when left out */\n\traces?: string[]\n\t/** Who made it */\n\tauthor?: string\n\t/** The map's checks it does not want, by their rules' ids (`MapProblem.rule`): a desert map with no path to its mines */\n\tsilence?: string[]\n\t/** Who it is for, as lists show it: \"2 players\", \"2 v 2\" */\n\tmeantFor?: string\n\t/**\n\t * Whether the whole map starts explored for everyone, the fog over it all the same: its ground, and what stands on it\n\t * and belongs to no player (trees, mines, neutral buildings), seen from the first moment. Yes or no over the game's\n\t * (`FogSettings.startExplored`); the game's when left out\n\t */\n\texplored?: boolean\n\t/** What the loading screen says while it loads */\n\tloading?: string\n\t/** A picture of it, for lists of maps: a small PNG as a data URL, made from its ground in the editor */\n\tpreview?: string\n\t/** What the map looks like beyond its ground: its water, light, sky (see `MapEnvironment`) */\n\tenvironment?: MapEnvironment\n\t/** The hour the game starts at, and whether it moves (see `MapDay`) */\n\tday?: MapDay\n\t/** How it was made, where a generator made it (`generateMap`): the seed and the options, for the same again or another */\n\tgenerated?: GeneratedWith\n\t/**\n\t * The part of the map play happens in, in cells, when it is not all of it: nothing on foot goes outside it, nothing\n\t * is built there, the camera keeps to it, and the screen darkens what is beyond. Scenery around the edge\n\t */\n\tbounds?: CellRect\n\t/**\n\t * What the game keeps with the map, for its rules to read: a difficulty, the waves of this level. Plain data,\n\t * as in a save. The engine never looks inside\n\t */\n\tdata: Record<string, unknown>\n\t/**\n\t * What the map's editor keeps with it of its own (what is hidden or locked, its groups, its views, the instances of\n\t * prefabs): saved with the map as plain data, read by no game, world or rule, and taken away for play\n\t * (`withoutEditor`). The engine never looks inside: the editor says what it holds\n\t */\n\teditor?: Record<string, unknown>\n\t/**\n\t * What the file held that this reader does not know, as it was: written back when the map is saved, so that a map\n\t * from a newer editor loses nothing by passing through an older one\n\t */\n\textra?: Record<string, unknown>\n}\n\n/**\n * A seat for a player of the map: the player's id, name, team and colour with the options for what they start with\n *\n * @beta\n */\nexport interface MapPlayer {\n\t/** The player's id, the number units and entities are owned by */\n\tid: PlayerId\n\t/** The player's name as lobbies show it */\n\tname: string\n\t/** The player's team number; players of the same number are allies */\n\tteam: number\n\t/** The player's colour as red, green and blue in 0..1 */\n\tcolor: [number, number, number]\n\t/** Where their base goes, for a game that gives everyone a start */\n\tstart?: Vec2\n\t/** Where their view starts, by the name of a camera of the map (`MapCamera`). Over their start when it has one */\n\tcamera?: string\n\t/**\n\t * Who plays them: a person, the computer, or nobody (an open slot left empty). The game's to say when left out: the\n\t * game reads it (`world.map.player(id)`), the engine does nothing with it\n\t */\n\tcontroller?: 'person' | 'computer' | 'nobody'\n\t/** What they start with, by resource id, over what the game gives everyone */\n\tresources?: Record<string, number>\n\t/**\n\t * The race they play, fixed by the map (a campaign's), of the game's races (`Rules.races`), or `random`: not\n\t * chosen in a lobby. Left to the lobby, or the game's first, when left out\n\t */\n\trace?: string\n\t/** What the game's own fields for players were set to (`defineMapField` with `for: 'player'`) */\n\tdata?: Record<string, unknown>\n}\n\n/**\n * A team of a map, with a name, and what its players share: for the game to read (`world.map.forces`)\n *\n * @beta\n */\nexport interface MapForce {\n\t/** The team, as its players have it (`MapPlayer.team`) */\n\tteam: number\n\t/** The team's name, shown in lobbies and for the game to read */\n\tname: string\n\t/** Its players see what each other sees. Teams always do in this engine: kept for the game to read */\n\tsharedVision?: boolean\n\t/** Its players can give orders to each other's units: for the game to read */\n\tsharedControl?: boolean\n}\n\n/**\n * A view of the map saved under a name: what the camera looks at, from how far, which way and how steeply. For\n * cinematics (`cut.camera('gate')`), a player's first view, and code (`client.lookFrom('gate')`). The screen's\n *\n * @beta\n */\nexport interface MapCamera {\n\t/** The editor's, see `MapRegion.id` */\n\tid: number\n\t/** The camera's name, which cinematics and code find it by */\n\tname: string\n\t/** The camera's target on the map's x axis, in cells */\n\tx: number\n\t/** The camera's target on the map's z axis, in cells */\n\tz: number\n\t/** How far the camera is from what it looks at */\n\tdistance: number\n\t/** Radians around the vertical axis, 0 looking north, and between the view and the ground */\n\tyaw: number\n\t/** The angle between the view and the ground, in radians */\n\tpitch: number\n}\n\n/**\n * Something that stands on the map when the game begins: a unit, a building, a tree, a mine\n *\n * @beta\n */\nexport interface MapObject {\n\t/** The object's id on the map, used by the editor */\n\tid: number\n\t/** The id of the unit type placed */\n\ttype: string\n\t/** The player that owns it (`MAP_NEUTRAL` or `MAP_CREEPS` for the neutral and the creeps) */\n\towner: PlayerId\n\t/** Where it stands on the map's x axis, in cells */\n\tx: number\n\t/** Where it stands on the map's z axis, in cells */\n\tz: number\n\t/** The way it faces in radians, the way entities do (0 is along +z) */\n\tfacing: number\n\t/** How big it is drawn */\n\tscale: number\n\t/** Which of the models of its type it is drawn with, for things that come in kinds like trees. Left out: one picked for it */\n\tlook?: string\n\t/**\n\t * The random group it is drawn from when the game starts (`MapRandomGroup`, by name): `type` is what the editor\n\t * shows until then\n\t */\n\trandom?: string\n\t/** The item table it drops from when it dies (`MapItemTable`, by name) */\n\tdrops?: string\n\t/**\n\t * A name of its own, for the rules to find it by (`world.named('gate')`). No two things on a map have the same,\n\t * whatever they are\n\t */\n\tname?: string\n\t/** The health it starts with, as a part of what it can have: 0.5 is half. All of it when left out */\n\thealth?: number\n\t/** The mana it starts with, as a part of what it can have. What its type starts with when left out */\n\tmana?: number\n\t/** For a hero: the level it starts at */\n\tlevel?: number\n\t/** For a hero: what it has learned already, as the level of each ability by id. As far as its level lets it */\n\tabilities?: Record<string, number>\n\t/** The items it carries, by the id of each, as far as it has room */\n\titems?: string[]\n\t/** For a resource: how much there is of it. What its type holds when left out */\n\tamount?: number\n\t/** For a building: it starts as a site that is still to be built */\n\tunderConstruction?: boolean\n\t/** Seconds until it is gone, for what is not there to stay */\n\tlifetime?: number\n\t/**\n\t * What it is doing as the game begins, its own orders and no player's, one after the other (campaign plan MS2): a\n\t * guard walking a patrol route, a caravan on its road. Nothing but what a unit does by itself when left out\n\t */\n\torders?: MapObjectOrder[]\n\t/**\n\t * What the game's own fields were set to, by the id of each (see `defineMapField`). The engine does not look\n\t * inside: the `mapObject` hook hands it to the game\n\t */\n\tdata?: Record<string, unknown>\n}\n\n/**\n * An order a unit of the map is given as the game begins (`MapObject.orders`): to go somewhere (`move`), to walk to\n * and fro fighting what it meets (`patrol`), to stand somewhere and fight what comes near, coming back after\n * (`guard`), to stand its ground (`hold`); to a point, or along a path of the map by its name, bend after bend (a\n * patrol along one walks it back and forth)\n *\n * @beta\n */\nexport interface MapObjectOrder {\n\t/** What the order is: `move` to a point or along a path, `patrol`, `guard` or `hold` */\n\tkind: 'move' | 'patrol' | 'guard' | 'hold'\n\t/** The name of a path of the map it follows, bend after bend */\n\tpath?: string\n\t/** The point it goes to, or guards */\n\tpoint?: Vec2\n}\n\n/**\n * A named part of the map, which becomes an area of the world made from it (`AreaDef`): the rules hear who walks in\n * and out (`enteredArea`, `leftArea`) and ask who is in it (`world.areas`), by its name\n *\n * @beta\n */\nexport interface MapRegion {\n\t/** The editor's, to tell regions apart while one is renamed. The world knows it by its name */\n\tid: number\n\t/** What the rules know it by. No two things on a map have the same, whatever they are */\n\tname: string\n\t/** The shape of the region: a circle or a rectangle (`AreaShape`) */\n\tshape: AreaShape\n\t/** What it is drawn in, in the editor, to tell it from the others. The editor picks one when left out */\n\tcolor?: [number, number, number]\n\t/** What the game's own fields for regions were set to, see `MapObject.data`: the `mapRegion` hook hands it to the game */\n\tdata?: Record<string, unknown>\n\t/**\n\t * A cinematic the region plays (ED4): for everyone, once, the first time a unit of a player walks in, unless the game\n\t * plays it its own way (`play: 'code'`: the region says which, `world.map.regions`, and the game's rules play it)\n\t */\n\tcinematic?: MapRegionCinematic\n}\n\n/**\n * The cinematic a region of the map plays (`MapRegion.cinematic`): which, by its id (`GameView.cinematics.defs`), and who\n * plays it: the engine, as a unit of a player first walks in (`'enter'`, when left out), or the game's own code\n * (`'code'`)\n *\n * @beta\n */\nexport interface MapRegionCinematic {\n\t/** The cinematic, by its id: the game's (`GameView.cinematics.defs`) */\n\tid: string\n\t/** Who plays it: the engine as a unit of a player first walks in (`'enter'`, when left out), or the game's code */\n\tplay?: 'enter' | 'code'\n}\n\n/**\n * A named spot of the map, facing a way: `world.map.point('spawn')`\n *\n * @beta\n */\nexport interface MapPoint {\n\t/** The editor's, see `MapRegion.id` */\n\tid: number\n\t/** What the rules know it by. No two things on a map have the same, whatever they are */\n\tname: string\n\t/** Where it stands on the map's x axis, in cells */\n\tx: number\n\t/** Where it stands on the map's z axis, in cells */\n\tz: number\n\t/** Radians, the way entities face: 0 is along +z */\n\tfacing: number\n\t/** What it is drawn in, in the editor */\n\tcolor?: [number, number, number]\n}\n\n/**\n * Scenery: a model on the map that is no entity of the rules, with no health, owner or place in a snapshot. A rock, a\n * fence, a ruined arch, free to lean, float and stretch. What it keeps off the cells under it (`blocks`) the terrain\n * has, for the paths of units and for building\n *\n * @beta\n */\nexport interface MapDoodad {\n\t/** The editor's, see `MapRegion.id` */\n\tid: number\n\t/** The model, by its path in `models/`: the map's own, the game's, or a shared one */\n\tmodel: string\n\t/** Where it stands on the map's x axis, in cells */\n\tx: number\n\t/** Where it stands on the map's z axis, in cells */\n\tz: number\n\t/** How high above the ground under it */\n\ty?: number\n\t/** Radians: which way it faces, the way entities do (0 is along +z), then how far it leans forward and to the side */\n\tyaw: number\n\t/** How far it leans forward in radians; 0 when left out */\n\tpitch?: number\n\t/** How far it leans to the side in radians; 0 when left out */\n\troll?: number\n\t/** How much bigger or smaller it is drawn than it was made, across, up and deep */\n\tscale: [number, number, number]\n\t/** A colour it is drawn in, over its own */\n\ttint?: [number, number, number]\n\t/** What code knows it by (`client.doodads.named`). Doodads are the screen's: the rules never see them */\n\tname?: string\n\t/** What it keeps off the cells within `radius` of its middle: building there, or walking and building. Nothing when left out */\n\tblocks?: 'build' | 'walk'\n\t/**\n\t * A bridge: walked on, over deep water too, at its height (`y`) above the water. Nothing is built on it. Within\n\t * `radius` of its middle\n\t */\n\tbridge?: boolean\n\t/**\n\t * A gate: it keeps walking off the cells within `radius` while it is shut, and the rules open and shut it by its\n\t * name while the game runs (`setGate`). Shut when the game starts, unless `open`\n\t */\n\tgate?: boolean\n\t/** Whether the gate starts open; shut when left out */\n\topen?: boolean\n\t/** How far around its middle it blocks, in cells */\n\tradius?: number\n\t/**\n\t * A clip of its model it plays over and over (a windmill's sails, a flag, a chest held open), by its name: none when\n\t * left out, or as the game says of its model (`SceneryDef.animation`). It is drawn on its own while it plays\n\t */\n\tanimation?: string\n\t/**\n\t * Merged with the scenery near it, to be drawn in one go (`DoodadView`): yes when left out, as far as its model can be.\n\t * No keeps it a copy of its model's mesh: for a game's code that reaches for it\n\t */\n\tbatch?: boolean\n\t/**\n\t * This one's lights otherwise than its model's (`GameView.ground.scenery`): put out (`on: false`), another colour, brighter,\n\t * further. Laid over every light its model gives\n\t */\n\tlight?: MapDoodadLight\n\t/**\n\t * How this one is drawn by distance, over its model's (`MapDetail`): pinned to a level by its index (`level`: 0 always at\n\t * full), or levels of its own. As its model when left out\n\t */\n\tdetail?: MapDoodadDetail\n}\n\n/**\n * One way a thing is drawn, and when, as a map says it (`MapDetail.models`, `MapDoodad.detail`): the client's\n * `DetailLevel` without what only code can say. A level applies when any of its conditions holds; of a thing's levels the\n * last that applies is drawn, the first being its full self\n *\n * @beta\n */\nexport interface MapDetailLevel {\n\t/** What is drawn: a picture of the model (`impostor`), or nothing (`none`). The model, or `model`, when left out */\n\tdraw?: 'impostor' | 'none'\n\t/** Another model, by its path in `models/`, in place of the thing's own */\n\tmodel?: string\n\t/** Or a lighter version of the full model made from it: this part of its triangles (0.25) */\n\tratio?: number\n\t/** From this far from the camera, in cells */\n\tfrom?: number\n\t/** Or: once the thing is at most this tall on the screen, in pixels */\n\tunder?: number\n\t/** Or: while the camera is over a region of the map, by its name; or not over it (`!name`) */\n\tregion?: string\n\t/**\n\t * How its file is loaded: with the model (`eager`), once something comes near wanting it (`lazy`, when left out: within\n\t * half again its distance), by code alone (`never`), or as the camera comes over a region of the map, by its name\n\t */\n\tload?: 'eager' | 'lazy' | 'never' | { region: string }\n\t/**\n\t * The level its shadow is drawn at, by index: a lighter one is cheaper, and nobody sees a leaf's shadow. One of nothing\n\t * casts none. As the shadows' bias says when left out (`MapDetail.shadowBias`), else the level it is drawn at\n\t */\n\tshadow?: number\n}\n\n/**\n * How one doodad is drawn by distance (`MapDoodad.detail`)\n *\n * @beta\n */\nexport interface MapDoodadDetail {\n\t/** Always at this level, by its index: 0 at full */\n\tlevel?: number\n\t/** Its own levels, over its model's */\n\tlevels?: MapDetailLevel[]\n}\n\n/**\n * How much detail things are drawn with by their distance on a map (`MapEnvironment.detail`), over the game's\n * (`GameView.world.detail`): a forest map drawn lighter. The screen's: the rules never see it\n *\n * @beta\n */\nexport interface MapDetail {\n\t/** Every distance a level starts from, times this: under 1 lighter sooner, over 1 later. The game's when left out */\n\tscale?: number\n\t/** Past this far from the camera, in cells, no scenery, tree or mine is drawn at all, nor casts a shadow. None when left out */\n\tcull?: number\n\t/**\n\t * How many cells past the edges of the view what is there is drawn already, so that it is ready (its pictures, its\n\t * shaders, its scenery merged) before the camera brings it in: no trees coming in as the view moves, for a little more\n\t * drawn off the screen. The game's when left out\n\t */\n\tpreload?: number\n\t/**\n\t * How many levels coarser than it is drawn at a thing casts its shadow, where its level does not say (`shadow`): 1\n\t * draws a tree's shadow at its next lighter level. The game's when left out\n\t */\n\tshadowBias?: number\n\t/** The levels of every model that has none said of it, over the game's (`GameView.world.detail.levels`) */\n\tlevels?: MapDetailLevel[]\n\t/** A model's levels, by its path in `models/`, over its own and the game's */\n\tmodels?: Record<string, MapDetailLevel[]>\n}\n\n/**\n * A group a placed thing is drawn from when the game starts (random groups, as classic map editors have them): one of these types by\n * weight, or any creep of a level (\"a level 3 creep\")\n *\n * @beta\n */\nexport interface MapRandomGroup {\n\t/** The group's name, which `MapObject.random` names it by */\n\tname: string\n\t/** One of these, more likely by its weight */\n\tchoices?: { type: string; weight: number }[]\n\t/** Or any unit type with a bounty, of this level */\n\tlevel?: number\n}\n\n/**\n * What something drops when it dies (item tables, as classic map editors have them): one item by weight, or none\n *\n * @beta\n */\nexport interface MapItemTable {\n\t/** The table's name, which `MapObject.drops` names it by */\n\tname: string\n\t/** The lines of the table, one of which is picked by weight */\n\titems: MapItemTableEntry[]\n\t/** How likely it is to drop anything, 0..1. Always when left out */\n\tchance?: number\n}\n\n/**\n * A line of an item table (`MapItemTable.items`): an item by id, or any item of a level, a class, or both (campaign\n * plan GP3: `{ level: 3, weight: 2 }`), its weight shared among those of the game that match\n *\n * @beta\n */\nexport interface MapItemTableEntry {\n\t/** The item's id, for a line that names one */\n\titem?: string\n\t/** The level of item it stands for, for a line that does not name one */\n\tlevel?: number\n\t/** The class of item it stands for, for a line that does not name one */\n\tclass?: string\n\t/** How likely this line is among the table's, relative to the others' weights */\n\tweight: number\n}\n\n/**\n * What a doodad keeps off a cell, in `Terrain.blocked`: building, walking too, or building on a bridge one walks on\n *\n * @beta\n */\nexport const BLOCKS_BUILD = 1\n/**\n * The `Terrain.blocked` value for a cell where walking and building are both kept off\n *\n * @beta\n */\nexport const BLOCKS_WALK = 2\n/**\n * The `Terrain.blocked` value for a bridge: walked on, nothing built on it\n *\n * @internal\n */\nexport const BRIDGE = 3\n\n/**\n * A named line of the map, through points in order, with a width: `world.map.path('road')` (see `Path`)\n *\n * @beta\n */\nexport interface MapPath {\n\t/** The editor's, see `MapRegion.id` */\n\tid: number\n\t/** What the rules know it by. No two things on a map have the same, whatever they are */\n\tname: string\n\t/** The points of the path in order, in cells */\n\tpoints: Vec2[]\n\t/** How wide it is, in cells: what it paints and keeps clear, and what `Path.contains` says is on it */\n\twidth: number\n\t/** A tile of the game's, by id, that the ground under it is painted with, over the map's own paint */\n\tpaint?: string\n\t/** Nothing may be built on it: a road the invaders need to get through */\n\tkeepClear?: boolean\n\t/** What it is drawn in, in the editor */\n\tcolor?: [number, number, number]\n\t/**\n\t * A road's or a river's bed under it, carved in the ground and painted each time the terrain is worked out (the\n\t * map's own heights stay as they are, so the bed follows the path wherever its points go): `PathProfile`\n\t */\n\tprofile?: PathProfile\n}\n\n/**\n * The bed a path carves, as a road or a river: its middle as smooth along it as a road is (the land along it averaged\n * over four cells each way), lowered by `depth`, level across `width`, eased into the land over `banks` cells each\n * side; painted with `ground`, and with water in it for a river\n *\n * @beta\n */\nexport interface PathProfile {\n\t/** How wide the bed is, in cells: the path's own width when left out */\n\twidth?: number\n\t/** How far below the land along it the bed is (0, a road; a river's bed with its water), in the heights' units */\n\tdepth?: number\n\t/** A tile of the game's the bed is painted with, by id (over the path's `paint`) */\n\tground?: string\n\t/** Over how many cells each side the bed is eased into the land: 2 when left out */\n\tbanks?: number\n\t/** Water in the bed: deep where `depth` is 1 or more, else shallow (a river, a ford) */\n\twater?: boolean\n}\n\n/**\n * The time of day of a map, in a game with days (`Rules.day`). The rules': what is done at night is done by it\n *\n * @beta\n */\nexport interface MapDay {\n\t/** The hour the game starts at. The game's when left out */\n\tstart?: number\n\t/** The hour stays where it starts: always night, always noon */\n\tstill?: boolean\n}\n\n/**\n * Creeps that guard a spot\n *\n * @beta\n */\nexport interface MapCamp {\n\t/** The map's id for the camp, used by the editor */\n\tid: number\n\t/** Where the camp stands on the map's x axis, in cells */\n\tx: number\n\t/** Where the camp stands on the map's z axis, in cells */\n\tz: number\n\t/** Unit types, the first one stands in the middle */\n\tunits: string[]\n\t/** A name of its own, for the rules to find it by (`campNamed(world, 'ogres')`), see `MapObject.name` */\n\tname?: string\n\t/** What the game's own fields for camps were set to, see `MapObject.data`: the `mapCamp` hook hands it to the game */\n\tdata?: Record<string, unknown>\n\t/** Seconds after it is cleared that it comes back (see `Camp.respawn`). The game's rule when left out */\n\trespawn?: number\n}\n\n/**\n * The format map files are written in. It goes up when a file of the format before would be read wrongly: a field\n * that changes what it means, or one a reader must not ignore. A step in `MIGRATIONS` then brings older files up to\n * it. A field that is merely new, and can be left out, needs no new format: a reader that does not know it carries\n * it along (`GameMap.extra`, and whatever an object, a player or a camp holds besides what is known)\n *\n * @internal\n */\nexport const MAP_FORMAT = 3\n/**\n * Owner of trees, mines and whatever belongs to nobody\n *\n * @beta\n */\nexport const MAP_NEUTRAL: PlayerId = 0\n/**\n * Owner of the creeps\n *\n * @beta\n */\nexport const MAP_CREEPS: PlayerId = 90\n/**\n * Players a map may have at most, whatever the game: each could be a team of its own, and the fog of war keeps 32\n * teams apart (`MAX_FOG_TEAMS`). How many a game allows is its own (`Rules.maxPlayers`, 8 when it says nothing)\n *\n * @beta\n */\nexport const MAX_MAP_PLAYERS = 32\n/**\n * Players a game allows on a map when it does not say (`Rules.maxPlayers`)\n *\n * @internal\n */\nexport const DEFAULT_MAX_PLAYERS = 8\n/**\n * Highest cliff level\n *\n * @beta\n */\nexport const MAX_LEVEL = 4\n/**\n * Cells a ramp reaches out on either side of where its slope is: long enough to walk up\n *\n * @internal\n */\nexport const RAMP_REACH = 3\n\n/**\n * The colours players are given by their number, in 0..1; past the end they start again\n *\n * @beta\n */\nexport const PLAYER_COLORS: [number, number, number][] = [\n\t[0.16, 0.38, 0.95],\n\t[0.85, 0.14, 0.12],\n\t[0.1, 0.72, 0.62],\n\t[0.55, 0.2, 0.8],\n\t[0.95, 0.85, 0.15],\n\t[0.95, 0.55, 0.12],\n\t[0.25, 0.75, 0.2],\n\t[0.9, 0.45, 0.7],\n\t// past eight, as the classic twenty-four go on: each told apart from the eight and from each other\n\t[0.58, 0.58, 0.6],\n\t[0.5, 0.75, 0.95],\n\t[0.06, 0.38, 0.27],\n\t[0.45, 0.28, 0.1],\n\t[0.55, 0.05, 0.12],\n\t[0.05, 0.08, 0.45],\n\t[0.25, 0.85, 0.85],\n\t[0.72, 0.6, 0.95],\n\t[0.92, 0.82, 0.62],\n\t[0.98, 0.65, 0.5],\n\t[0.6, 0.95, 0.65],\n\t[0.82, 0.78, 0.98],\n\t[0.18, 0.18, 0.2],\n\t[0.95, 0.95, 0.95],\n\t[0.05, 0.6, 0.3],\n\t[0.6, 0.45, 0.2]\n]\n\n/**\n * Makes the `MapPlayer` for a player's id, with the default name `Player <id>`, its own team and the colour from `PLAYER_COLORS`\n *\n * @beta\n */\nexport const playerSlot = (id: number): MapPlayer => ({ id, name: `Player ${id}`, team: id, color: PLAYER_COLORS[(id - 1) % PLAYER_COLORS.length] })\n\n/**\n * The options `createMap` makes a map with\n *\n * @beta\n */\nexport interface NewMapOptions {\n\t/** The map's name: `New map` when left out */\n\tname?: string\n\t/** The map's width in cells */\n\twidth: number\n\t/** The map's depth in cells */\n\tdepth: number\n\t/** Height of the land everywhere */\n\theight?: number\n\t/** How many player slots the map has: 2 when left out */\n\tplayers?: number\n\t/** The game it is for, see `GameMap.game` */\n\tgame?: string\n\t/** The tiles it can be painted with, by name: the game's (`registry.tiles`). None when left out */\n\ttileset?: string[]\n}\n\n/**\n * Flat grass, two players and nothing on it\n *\n * @beta\n */\nexport function createMap(options: NewMapOptions): GameMap {\n\tconst { width, depth, height = 1, players = 2 } = options\n\tconst cells = width * depth\n\treturn {\n\t\tname: options.name ?? 'New map',\n\t\tdescription: '',\n\t\t...(options.game !== undefined && { game: options.game }),\n\t\twidth,\n\t\tdepth,\n\t\tcliffHeight: 3,\n\t\tground: new Float32Array((width + 1) * (depth + 1)).fill(height),\n\t\tlevels: new Uint8Array(cells),\n\t\tramps: new Uint8Array(cells),\n\t\twater: new Uint8Array(cells),\n\t\ttiles: new Uint8Array(cells),\n\t\ttileset: [...(options.tileset ?? [])],\n\t\tplayers: Array.from({ length: players }, (_, i) => playerSlot(i + 1)),\n\t\tobjects: [],\n\t\tcamps: [],\n\t\tregions: [],\n\t\tpoints: [],\n\t\tpaths: [],\n\t\tdoodads: [],\n\t\tcameras: [],\n\t\tdata: {}\n\t}\n}\n\n/**\n * A rectangle of a map, in cells\n *\n * @beta\n */\nexport interface CellRect {\n\t/** The rectangle's first cell on the x axis */\n\tx: number\n\t/** The rectangle's first cell on the z axis */\n\tz: number\n\t/** How many cells across it is */\n\twidth: number\n\t/** How many cells down it is */\n\tdepth: number\n}\n\n/**\n * The smallest a map can be made, each way: the editor's, and the size a map file is read at\n *\n * @internal\n */\nexport const MIN_MAP_SIZE = 8\n/**\n * The largest, the same for the editor and a map file. 512 until a game needs more (S37 is what makes more cost little)\n *\n * @beta\n */\nexport const MAX_MAP_SIZE = 512\n"],"mappings":";;;;;;AA0hBA,IAAa,eAAe;;;;;;AAM5B,IAAa,cAAc;;;;;;AAM3B,IAAa,SAAS;;;;;;;;;AA2FtB,IAAa,aAAa;;;;;;AAM1B,IAAa,cAAwB;;;;;;AAMrC,IAAa,aAAuB;;;;;;;AAOpC,IAAa,kBAAkB;;;;;;AAM/B,IAAa,sBAAsB;;;;;;AAMnC,IAAa,YAAY;;;;;;AAMzB,IAAa,aAAa;;;;;;AAO1B,IAAa,gBAA4C;CACxD;EAAC;EAAM;EAAM;CAAI;CACjB;EAAC;EAAM;EAAM;CAAI;CACjB;EAAC;EAAK;EAAM;CAAI;CAChB;EAAC;EAAM;EAAK;CAAG;CACf;EAAC;EAAM;EAAM;CAAI;CACjB;EAAC;EAAM;EAAM;CAAI;CACjB;EAAC;EAAM;EAAM;CAAG;CAChB;EAAC;EAAK;EAAM;CAAG;CAEf;EAAC;EAAM;EAAM;CAAG;CAChB;EAAC;EAAK;EAAM;CAAI;CAChB;EAAC;EAAM;EAAM;CAAI;CACjB;EAAC;EAAM;EAAM;CAAG;CAChB;EAAC;EAAM;EAAM;CAAI;CACjB;EAAC;EAAM;EAAM;CAAI;CACjB;EAAC;EAAM;EAAM;CAAI;CACjB;EAAC;EAAM;EAAK;CAAI;CAChB;EAAC;EAAM;EAAM;CAAI;CACjB;EAAC;EAAM;EAAM;CAAG;CAChB;EAAC;EAAK;EAAM;CAAI;CAChB;EAAC;EAAM;EAAM;CAAI;CACjB;EAAC;EAAM;EAAM;CAAG;CAChB;EAAC;EAAM;EAAM;CAAI;CACjB;EAAC;EAAM;EAAK;CAAG;CACf;EAAC;EAAK;EAAM;CAAG;AAChB;;;;;;AAOA,IAAa,cAAc,QAA2B;CAAE;CAAI,MAAM,UAAU;CAAM,MAAM;CAAI,OAAO,eAAe,KAAK,KAAK,cAAc;AAAQ;;;;;;AA6BlJ,SAAgB,UAAU,SAAiC;CAC1D,MAAM,EAAE,OAAO,OAAO,SAAS,GAAG,UAAU,MAAM;CAClD,MAAM,QAAQ,QAAQ;CACtB,OAAO;EACN,MAAM,QAAQ,QAAQ;EACtB,aAAa;EACb,GAAI,QAAQ,SAAS,KAAA,KAAa,EAAE,MAAM,QAAQ,KAAK;EACvD;EACA;EACA,aAAa;EACb,QAAQ,IAAI,cAAc,QAAQ,MAAM,QAAQ,EAAE,CAAC,CAAC,KAAK,MAAM;EAC/D,QAAQ,IAAI,WAAW,KAAK;EAC5B,OAAO,IAAI,WAAW,KAAK;EAC3B,OAAO,IAAI,WAAW,KAAK;EAC3B,OAAO,IAAI,WAAW,KAAK;EAC3B,SAAS,CAAC,GAAI,QAAQ,WAAW,CAAC,CAAE;EACpC,SAAS,MAAM,KAAK,EAAE,QAAQ,QAAQ,IAAI,GAAG,MAAM,WAAW,IAAI,CAAC,CAAC;EACpE,SAAS,CAAC;EACV,OAAO,CAAC;EACR,SAAS,CAAC;EACV,QAAQ,CAAC;EACT,OAAO,CAAC;EACR,SAAS,CAAC;EACV,SAAS,CAAC;EACV,MAAM,CAAC;CACR;AACD;;;;;;AAuBA,IAAa,eAAe;;;;;;AAM5B,IAAa,eAAe"}

package/dist/mapCheck/cells.js

@@ -0,0 +1,94 @@
+import { footprintOf } from "../defs.js";
+import "../map/types.js";
+import { footprintCell } from "../grid.js";
+import "../terrain.js";
+import { mapTerrain } from "../map/terrain.js";
+//#region src/mapCheck/cells.ts
+/** The steepest ground something on foot walks, in radians: as the navigation mesh has it */
+var WALKABLE_SLOPE = 38 * Math.PI / 180;
+/**
+* Which cells of a map something on foot can stand on (1) and which have a building or a mine on them (`built`): for
+* the checks, and for what the editor shows of where one can walk and build. `steep` counts slopes too steep to walk
+*
+* @beta
+*/
+function mapCells(map, registry, terrain = mapTerrain(map), steep = false) {
+	const { width, depth } = map;
+	const open = new Uint8Array(width * depth);
+	const built = new Uint8Array(width * depth);
+	for (let c = 0; c < open.length; c++) {
+		const x = c % width;
+		const z = (c - x) / width;
+		open[c] = (terrain.water[c] !== 2 || terrain.blocked[c] === 3) && terrain.blocked[c] !== 2 && terrain.inPlay(x, z) && (!steep || terrain.slopeAt(x + .5, z + .5) <= WALKABLE_SLOPE) ? 1 : 0;
+	}
+	for (const object of map.objects) {
+		if (!registry.units.has(object.type)) continue;
+		const def = registry.unit(object.type);
+		if (def.kind === "unit") continue;
+		const { w, d } = footprintOf(def);
+		const corner = footprintCell(object.x, object.z, w, d);
+		for (let z = corner.z; z < corner.z + d; z++) for (let x = corner.x; x < corner.x + w; x++) {
+			if (x < 0 || z < 0 || x >= width || z >= depth) continue;
+			open[z * width + x] = 0;
+			built[z * width + x] = 1;
+		}
+	}
+	return {
+		open,
+		built
+	};
+}
+/** Cells something on foot can stand on, and which of them it can get to from which: a number per cell, 0 for none */
+function walkingAreas(map, registry) {
+	const { width, depth, levels, ramps } = map;
+	const { open } = mapCells(map, registry);
+	const passable = (a, b) => levels[a] === levels[b] || ramps[a] > 0 || ramps[b] > 0;
+	const area = new Int32Array(width * depth);
+	let next = 0;
+	const queue = new Int32Array(width * depth);
+	for (let start = 0; start < area.length; start++) {
+		if (!open[start] || area[start]) continue;
+		next++;
+		let head = 0;
+		let tail = 0;
+		queue[tail++] = start;
+		area[start] = next;
+		while (head < tail) {
+			const c = queue[head++];
+			const x = c % width;
+			const z = (c - x) / width;
+			for (const [nx, nz] of [
+				[x - 1, z],
+				[x + 1, z],
+				[x, z - 1],
+				[x, z + 1]
+			]) {
+				if (nx < 0 || nz < 0 || nx >= width || nz >= depth) continue;
+				const n = nz * width + nx;
+				if (!open[n] || area[n] || !passable(c, n)) continue;
+				area[n] = next;
+				queue[tail++] = n;
+			}
+		}
+	}
+	/** The area a point is in, or the one next to it, for what stands on cells nothing walks on: a mine, a town hall */
+	const at = (point) => {
+		const cx = Math.floor(point.x);
+		const cz = Math.floor(point.z);
+		for (let r = 0; r <= 4; r++) for (let z = cz - r; z <= cz + r; z++) for (let x = cx - r; x <= cx + r; x++) {
+			if (x < 0 || z < 0 || x >= width || z >= depth) continue;
+			if (Math.max(Math.abs(x - cx), Math.abs(z - cz)) !== r) continue;
+			const found = area[z * width + x];
+			if (found) return found;
+		}
+		return 0;
+	};
+	return {
+		area,
+		at
+	};
+}
+//#endregion
+export { mapCells, walkingAreas };
+
+//# sourceMappingURL=cells.js.map

package/dist/mapCheck/cells.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cells.js","names":[],"sources":["../../src/mapCheck/cells.ts"],"sourcesContent":["/*\n * Where something on foot can stand on a map, and which of it can get to which: what the checks of walking go by, and\n * what the editor shows (design review E8b)\n */\nimport { footprintOf } from '../defs'\nimport { footprintCell } from '../grid'\nimport { BLOCKS_WALK, BRIDGE, type GameMap, mapTerrain } from '../map'\nimport type { Vec2 } from '../math'\nimport type { Registry } from '../registry'\nimport { type Terrain, WATER_DEEP } from '../terrain'\n\n/** The steepest ground something on foot walks, in radians: as the navigation mesh has it */\nconst WALKABLE_SLOPE = (38 * Math.PI) / 180\n\n/**\n * Which cells of a map something on foot can stand on (1) and which have a building or a mine on them (`built`): for\n * the checks, and for what the editor shows of where one can walk and build. `steep` counts slopes too steep to walk\n *\n * @beta\n */\nexport function mapCells(\n\tmap: GameMap,\n\tregistry: Registry,\n\tterrain: Terrain = mapTerrain(map),\n\tsteep = false\n): { open: Uint8Array; built: Uint8Array } {\n\tconst { width, depth } = map\n\tconst open = new Uint8Array(width * depth)\n\tconst built = new Uint8Array(width * depth)\n\tfor (let c = 0; c < open.length; c++) {\n\t\tconst x = c % width\n\t\tconst z = (c - x) / width\n\t\topen[c] =\n\t\t\t(terrain.water[c] !== WATER_DEEP || terrain.blocked[c] === BRIDGE) &&\n\t\t\tterrain.blocked[c] !== BLOCKS_WALK &&\n\t\t\tterrain.inPlay(x, z) &&\n\t\t\t(!steep || terrain.slopeAt(x + 0.5, z + 0.5) <= WALKABLE_SLOPE)\n\t\t\t\t? 1\n\t\t\t\t: 0\n\t}\n\t// what is built stands in the way\n\tfor (const object of map.objects) {\n\t\tif (!registry.units.has(object.type)) continue\n\t\tconst def = registry.unit(object.type)\n\t\tif (def.kind === 'unit') continue\n\t\tconst { w, d } = footprintOf(def)\n\t\tconst corner = footprintCell(object.x, object.z, w, d)\n\t\tfor (let z = corner.z; z < corner.z + d; z++) {\n\t\t\tfor (let x = corner.x; x < corner.x + w; x++) {\n\t\t\t\tif (x < 0 || z < 0 || x >= width || z >= depth) continue\n\t\t\t\topen[z * width + x] = 0\n\t\t\t\tbuilt[z * width + x] = 1\n\t\t\t}\n\t\t}\n\t}\n\treturn { open, built }\n}\n\n/** Cells something on foot can stand on, and which of them it can get to from which: a number per cell, 0 for none */\nexport function walkingAreas(map: GameMap, registry: Registry): { area: Int32Array; at: (point: Vec2) => number } {\n\tconst { width, depth, levels, ramps } = map\n\tconst { open } = mapCells(map, registry)\n\t// a step between two levels is a cliff, unless one side is a ramp\n\tconst passable = (a: number, b: number) => levels[a] === levels[b] || ramps[a] > 0 || ramps[b] > 0\n\tconst area = new Int32Array(width * depth)\n\tlet next = 0\n\tconst queue = new Int32Array(width * depth)\n\tfor (let start = 0; start < area.length; start++) {\n\t\tif (!open[start] || area[start]) continue\n\t\tnext++\n\t\tlet head = 0\n\t\tlet tail = 0\n\t\tqueue[tail++] = start\n\t\tarea[start] = next\n\t\twhile (head < tail) {\n\t\t\tconst c = queue[head++]\n\t\t\tconst x = c % width\n\t\t\tconst z = (c - x) / width\n\t\t\tfor (const [nx, nz] of [\n\t\t\t\t[x - 1, z],\n\t\t\t\t[x + 1, z],\n\t\t\t\t[x, z - 1],\n\t\t\t\t[x, z + 1]\n\t\t\t]) {\n\t\t\t\tif (nx < 0 || nz < 0 || nx >= width || nz >= depth) continue\n\t\t\t\tconst n = nz * width + nx\n\t\t\t\tif (!open[n] || area[n] || !passable(c, n)) continue\n\t\t\t\tarea[n] = next\n\t\t\t\tqueue[tail++] = n\n\t\t\t}\n\t\t}\n\t}\n\t/** The area a point is in, or the one next to it, for what stands on cells nothing walks on: a mine, a town hall */\n\tconst at = (point: Vec2) => {\n\t\tconst cx = Math.floor(point.x)\n\t\tconst cz = Math.floor(point.z)\n\t\tfor (let r = 0; r <= 4; r++) {\n\t\t\tfor (let z = cz - r; z <= cz + r; z++) {\n\t\t\t\tfor (let x = cx - r; x <= cx + r; x++) {\n\t\t\t\t\tif (x < 0 || z < 0 || x >= width || z >= depth) continue\n\t\t\t\t\tif (Math.max(Math.abs(x - cx), Math.abs(z - cz)) !== r) continue\n\t\t\t\t\tconst found = area[z * width + x]\n\t\t\t\t\tif (found) return found\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn 0\n\t}\n\treturn { area, at }\n}\n"],"mappings":";;;;;;;AAYA,IAAM,iBAAkB,KAAK,KAAK,KAAM;;;;;;;AAQxC,SAAgB,SACf,KACA,UACA,UAAmB,WAAW,GAAG,GACjC,QAAQ,OACkC;CAC1C,MAAM,EAAE,OAAO,UAAU;CACzB,MAAM,OAAO,IAAI,WAAW,QAAQ,KAAK;CACzC,MAAM,QAAQ,IAAI,WAAW,QAAQ,KAAK;CAC1C,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACrC,MAAM,IAAI,IAAI;EACd,MAAM,KAAK,IAAI,KAAK;EACpB,KAAK,MACH,QAAQ,MAAM,OAAA,KAAqB,QAAQ,QAAQ,OAAA,MACpD,QAAQ,QAAQ,OAAA,KAChB,QAAQ,OAAO,GAAG,CAAC,MAClB,CAAC,SAAS,QAAQ,QAAQ,IAAI,IAAK,IAAI,EAAG,KAAK,kBAC7C,IACA;CACL;CAEA,KAAK,MAAM,UAAU,IAAI,SAAS;EACjC,IAAI,CAAC,SAAS,MAAM,IAAI,OAAO,IAAI,GAAG;EACtC,MAAM,MAAM,SAAS,KAAK,OAAO,IAAI;EACrC,IAAI,IAAI,SAAS,QAAQ;EACzB,MAAM,EAAE,GAAG,MAAM,YAAY,GAAG;EAChC,MAAM,SAAS,cAAc,OAAO,GAAG,OAAO,GAAG,GAAG,CAAC;EACrD,KAAK,IAAI,IAAI,OAAO,GAAG,IAAI,OAAO,IAAI,GAAG,KACxC,KAAK,IAAI,IAAI,OAAO,GAAG,IAAI,OAAO,IAAI,GAAG,KAAK;GAC7C,IAAI,IAAI,KAAK,IAAI,KAAK,KAAK,SAAS,KAAK,OAAO;GAChD,KAAK,IAAI,QAAQ,KAAK;GACtB,MAAM,IAAI,QAAQ,KAAK;EACxB;CAEF;CACA,OAAO;EAAE;EAAM;CAAM;AACtB;;AAGA,SAAgB,aAAa,KAAc,UAAuE;CACjH,MAAM,EAAE,OAAO,OAAO,QAAQ,UAAU;CACxC,MAAM,EAAE,SAAS,SAAS,KAAK,QAAQ;CAEvC,MAAM,YAAY,GAAW,MAAc,OAAO,OAAO,OAAO,MAAM,MAAM,KAAK,KAAK,MAAM,KAAK;CACjG,MAAM,OAAO,IAAI,WAAW,QAAQ,KAAK;CACzC,IAAI,OAAO;CACX,MAAM,QAAQ,IAAI,WAAW,QAAQ,KAAK;CAC1C,KAAK,IAAI,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS;EACjD,IAAI,CAAC,KAAK,UAAU,KAAK,QAAQ;EACjC;EACA,IAAI,OAAO;EACX,IAAI,OAAO;EACX,MAAM,UAAU;EAChB,KAAK,SAAS;EACd,OAAO,OAAO,MAAM;GACnB,MAAM,IAAI,MAAM;GAChB,MAAM,IAAI,IAAI;GACd,MAAM,KAAK,IAAI,KAAK;GACpB,KAAK,MAAM,CAAC,IAAI,OAAO;IACtB,CAAC,IAAI,GAAG,CAAC;IACT,CAAC,IAAI,GAAG,CAAC;IACT,CAAC,GAAG,IAAI,CAAC;IACT,CAAC,GAAG,IAAI,CAAC;GACV,GAAG;IACF,IAAI,KAAK,KAAK,KAAK,KAAK,MAAM,SAAS,MAAM,OAAO;IACpD,MAAM,IAAI,KAAK,QAAQ;IACvB,IAAI,CAAC,KAAK,MAAM,KAAK,MAAM,CAAC,SAAS,GAAG,CAAC,GAAG;IAC5C,KAAK,KAAK;IACV,MAAM,UAAU;GACjB;EACD;CACD;;CAEA,MAAM,MAAM,UAAgB;EAC3B,MAAM,KAAK,KAAK,MAAM,MAAM,CAAC;EAC7B,MAAM,KAAK,KAAK,MAAM,MAAM,CAAC;EAC7B,KAAK,IAAI,IAAI,GAAG,KAAK,GAAG,KACvB,KAAK,IAAI,IAAI,KAAK,GAAG,KAAK,KAAK,GAAG,KACjC,KAAK,IAAI,IAAI,KAAK,GAAG,KAAK,KAAK,GAAG,KAAK;GACtC,IAAI,IAAI,KAAK,IAAI,KAAK,KAAK,SAAS,KAAK,OAAO;GAChD,IAAI,KAAK,IAAI,KAAK,IAAI,IAAI,EAAE,GAAG,KAAK,IAAI,IAAI,EAAE,CAAC,MAAM,GAAG;GACxD,MAAM,QAAQ,KAAK,IAAI,QAAQ;GAC/B,IAAI,OAAO,OAAO;EACnB;EAGF,OAAO;CACR;CACA,OAAO;EAAE;EAAM;CAAG;AACnB"}

package/dist/mapCheck/rules/foliage.d.ts

@@ -0,0 +1,9 @@
+import type { MapRule } from '../rule';
+/**
+ * The styles of grass and bushes a map paints (`CellLayerValue.foliage`): cells painted with a value their layer names
+ * nothing of (a style the game and the map do not have, drawn as the layer and nothing to the rules); a style that
+ * hides but stands shorter than every unit on the ground the game has, and so hides none of them
+ * (`concealsTaller: false`); a style that burns in a game whose grass has no fire (no foliage pack, or its `fire` off).
+ * Warnings, each once a style, about the first cell painted with it
+ */
+export declare const foliageRules: MapRule;

package/dist/mapCheck/rules/foliage.js

@@ -0,0 +1,83 @@
+import { FOLIAGE, foliageLayers, foliageStyle } from "../../foliage.js";
+import { cellLayerValues, layCellLayerData } from "../../cellLayers.js";
+//#region src/mapCheck/rules/foliage.ts
+/** The game's layers of cells as this map has them: the game's values with the map's definitions over them */
+function layersOf(map, registry) {
+	const own = map.definitions?.cellLayers;
+	return own ? layCellLayerData(registry.cellLayers, own) : [...registry.cellLayers];
+}
+/** How tall a unit type stands to the rules' grass, as the foliage pack measures it when a game says nothing: twice its radius */
+var heightOf = (radius) => radius * 2;
+/**
+* The styles of grass and bushes a map paints (`CellLayerValue.foliage`): cells painted with a value their layer names
+* nothing of (a style the game and the map do not have, drawn as the layer and nothing to the rules); a style that
+* hides but stands shorter than every unit on the ground the game has, and so hides none of them
+* (`concealsTaller: false`); a style that burns in a game whose grass has no fire (no foliage pack, or its `fire` off).
+* Warnings, each once a style, about the first cell painted with it
+*/
+var foliageRules = {
+	id: "foliage",
+	check(map, registry, say, _context) {
+		const cells = map.cells;
+		if (!cells || !registry.cellLayers.length) return;
+		const layers = layersOf(map, registry);
+		const packs = registry.assembly?.rules.packs;
+		const options = (packs?.find((each) => each.id === FOLIAGE))?.options;
+		const ofPack = new Set(options ? foliageLayers(options).map((each) => each.layer) : []);
+		const burns = !!options && options.fire !== false;
+		const game = {
+			cellLayers: layers,
+			packs
+		};
+		let shortest = Infinity;
+		for (const def of registry.units.all()) if (def.kind === "unit" && !def.flying && !def.footprint) shortest = Math.min(shortest, heightOf(def.radius));
+		const { width } = map;
+		for (const def of layers) {
+			const painted = cells[def.id];
+			if (!painted) continue;
+			const counts = /* @__PURE__ */ new Uint32Array(256);
+			const first = (/* @__PURE__ */ new Int32Array(256)).fill(-1);
+			for (let c = 0; c < painted.length; c++) {
+				const value = painted[c];
+				if (!value) continue;
+				if (!counts[value]) first[value] = c;
+				counts[value]++;
+			}
+			const named = new Map(cellLayerValues(def).map((each) => [each.value, each]));
+			const at = (value) => ({
+				x: first[value] % width + .5,
+				z: Math.floor(first[value] / width) + .5
+			});
+			for (let value = 1; value < 256; value++) {
+				if (!counts[value]) continue;
+				const cellsSaid = `${counts[value].toLocaleString("en")} ${counts[value] === 1 ? "cell" : "cells"}`;
+				const known = named.get(value);
+				if (!known) {
+					say({
+						message: `${cellsSaid} of ${def.name} are painted with ${value}, a style neither the game nor the map has: drawn as the layer, nothing to the rules`,
+						at: at(value),
+						rule: "unknown-foliage-style"
+					});
+					continue;
+				}
+				const style = foliageStyle(game, def.id, value);
+				if (!style) continue;
+				const height = style.height ?? 1;
+				if (ofPack.has(def.id) && style.conceals && style.concealsTaller === false && Number.isFinite(shortest) && shortest > height) say({
+					message: `${known.name} (${def.name}) hides units inside, but stands ${height} tall and the shortest unit on the ground of the game ${shortest} (twice its radius): it hides none of them`,
+					at: at(value),
+					rule: "foliage-hides-nobody"
+				});
+				if ((style.flammable ?? 0) > 0 && !burns) say({
+					message: `${known.name} (${def.name}) is flammable, but the game's grass has no fire (${options ? "foliagePack has fire: false" : "no foliagePack"}): it never burns`,
+					at: at(value),
+					rule: "foliage-no-fire"
+				});
+			}
+		}
+	}
+};
+//#endregion
+export { foliageRules };
+
+//# sourceMappingURL=foliage.js.map

package/dist/mapCheck/rules/foliage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"foliage.js","names":[],"sources":["../../../src/mapCheck/rules/foliage.ts"],"sourcesContent":["import { type CellLayerDef, cellLayerValues, layCellLayerData } from '../../cellLayers'\nimport { FOLIAGE, type FoliageOptions, foliageLayers, foliageStyle } from '../../foliage'\nimport type { GameMap } from '../../map'\nimport type { Registry } from '../../registry'\nimport type { MapRule } from '../rule'\n\n/** The game's layers of cells as this map has them: the game's values with the map's definitions over them */\nfunction layersOf(map: GameMap, registry: Registry): CellLayerDef[] {\n\tconst own = map.definitions?.cellLayers\n\treturn own ? layCellLayerData(registry.cellLayers, own) : [...registry.cellLayers]\n}\n\n/** How tall a unit type stands to the rules' grass, as the foliage pack measures it when a game says nothing: twice its radius */\nconst heightOf = (radius: number) => radius * 2\n\n/**\n * The styles of grass and bushes a map paints (`CellLayerValue.foliage`): cells painted with a value their layer names\n * nothing of (a style the game and the map do not have, drawn as the layer and nothing to the rules); a style that\n * hides but stands shorter than every unit on the ground the game has, and so hides none of them\n * (`concealsTaller: false`); a style that burns in a game whose grass has no fire (no foliage pack, or its `fire` off).\n * Warnings, each once a style, about the first cell painted with it\n */\nexport const foliageRules: MapRule = {\n\tid: 'foliage',\n\tcheck(map, registry, say, _context) {\n\t\tconst cells = map.cells\n\t\tif (!cells || !registry.cellLayers.length) return\n\t\tconst layers = layersOf(map, registry)\n\t\tconst packs = registry.assembly?.rules.packs\n\t\tconst pack = packs?.find((each) => each.id === FOLIAGE)\n\t\tconst options = pack?.options as FoliageOptions | undefined\n\t\tconst ofPack = new Set(options ? foliageLayers(options).map((each) => each.layer) : [])\n\t\tconst burns = !!options && options.fire !== false\n\t\tconst game = { cellLayers: layers, packs }\n\t\t// the units hiding is for: on the ground, not built; the shortest of them\n\t\tlet shortest = Infinity\n\t\tfor (const def of registry.units.all()) if (def.kind === 'unit' && !def.flying && !def.footprint) shortest = Math.min(shortest, heightOf(def.radius))\n\t\tconst { width } = map\n\t\tfor (const def of layers) {\n\t\t\tconst painted = cells[def.id]\n\t\t\tif (!painted) continue\n\t\t\t// how many cells each value has, and the first of each\n\t\t\tconst counts = new Uint32Array(256)\n\t\t\tconst first = new Int32Array(256).fill(-1)\n\t\t\tfor (let c = 0; c < painted.length; c++) {\n\t\t\t\tconst value = painted[c]\n\t\t\t\tif (!value) continue\n\t\t\t\tif (!counts[value]) first[value] = c\n\t\t\t\tcounts[value]++\n\t\t\t}\n\t\t\tconst named = new Map(cellLayerValues(def).map((each) => [each.value, each]))\n\t\t\tconst at = (value: number) => ({ x: (first[value] % width) + 0.5, z: Math.floor(first[value] / width) + 0.5 })\n\t\t\tfor (let value = 1; value < 256; value++) {\n\t\t\t\tif (!counts[value]) continue\n\t\t\t\tconst cellsSaid = `${counts[value].toLocaleString('en')} ${counts[value] === 1 ? 'cell' : 'cells'}`\n\t\t\t\tconst known = named.get(value)\n\t\t\t\tif (!known) {\n\t\t\t\t\tsay({\n\t\t\t\t\t\tmessage: `${cellsSaid} of ${def.name} are painted with ${value}, a style neither the game nor the map has: drawn as the layer, nothing to the rules`,\n\t\t\t\t\t\tat: at(value),\n\t\t\t\t\t\trule: 'unknown-foliage-style'\n\t\t\t\t\t})\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tconst style = foliageStyle(game, def.id, value)\n\t\t\t\tif (!style) continue\n\t\t\t\tconst height = style.height ?? 1\n\t\t\t\t// hiding is the foliage pack's, on its layers\n\t\t\t\tif (ofPack.has(def.id) &&\n\t\t\t\t\tstyle.conceals && style.concealsTaller === false && Number.isFinite(shortest) && shortest > height)\n\t\t\t\t\tsay({\n\t\t\t\t\t\tmessage: `${known.name} (${def.name}) hides units inside, but stands ${height} tall and the shortest unit on the ground of the game ${shortest} (twice its radius): it hides none of them`,\n\t\t\t\t\t\tat: at(value),\n\t\t\t\t\t\trule: 'foliage-hides-nobody'\n\t\t\t\t\t})\n\t\t\t\tif ((style.flammable ?? 0) > 0 && !burns)\n\t\t\t\t\tsay({\n\t\t\t\t\t\tmessage: `${known.name} (${def.name}) is flammable, but the game's grass has no fire (${options ? 'foliagePack has fire: false' : 'no foliagePack'}): it never burns`,\n\t\t\t\t\t\tat: at(value),\n\t\t\t\t\t\trule: 'foliage-no-fire'\n\t\t\t\t\t})\n\t\t\t}\n\t\t}\n\t}\n}\n"],"mappings":";;;;AAOA,SAAS,SAAS,KAAc,UAAoC;CACnE,MAAM,MAAM,IAAI,aAAa;CAC7B,OAAO,MAAM,iBAAiB,SAAS,YAAY,GAAG,IAAI,CAAC,GAAG,SAAS,UAAU;AAClF;;AAGA,IAAM,YAAY,WAAmB,SAAS;;;;;;;;AAS9C,IAAa,eAAwB;CACpC,IAAI;CACJ,MAAM,KAAK,UAAU,KAAK,UAAU;EACnC,MAAM,QAAQ,IAAI;EAClB,IAAI,CAAC,SAAS,CAAC,SAAS,WAAW,QAAQ;EAC3C,MAAM,SAAS,SAAS,KAAK,QAAQ;EACrC,MAAM,QAAQ,SAAS,UAAU,MAAM;EAEvC,MAAM,WADO,OAAO,MAAM,SAAS,KAAK,OAAO,OAAO,EAAA,EAChC;EACtB,MAAM,SAAS,IAAI,IAAI,UAAU,cAAc,OAAO,CAAC,CAAC,KAAK,SAAS,KAAK,KAAK,IAAI,CAAC,CAAC;EACtF,MAAM,QAAQ,CAAC,CAAC,WAAW,QAAQ,SAAS;EAC5C,MAAM,OAAO;GAAE,YAAY;GAAQ;EAAM;EAEzC,IAAI,WAAW;EACf,KAAK,MAAM,OAAO,SAAS,MAAM,IAAI,GAAG,IAAI,IAAI,SAAS,UAAU,CAAC,IAAI,UAAU,CAAC,IAAI,WAAW,WAAW,KAAK,IAAI,UAAU,SAAS,IAAI,MAAM,CAAC;EACpJ,MAAM,EAAE,UAAU;EAClB,KAAK,MAAM,OAAO,QAAQ;GACzB,MAAM,UAAU,MAAM,IAAI;GAC1B,IAAI,CAAC,SAAS;GAEd,MAAM,yBAAS,IAAI,YAAY,GAAG;GAClC,MAAM,yBAAQ,IAAI,WAAW,GAAG,EAAA,CAAE,KAAK,EAAE;GACzC,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;IACxC,MAAM,QAAQ,QAAQ;IACtB,IAAI,CAAC,OAAO;IACZ,IAAI,CAAC,OAAO,QAAQ,MAAM,SAAS;IACnC,OAAO,MAAM;GACd;GACA,MAAM,QAAQ,IAAI,IAAI,gBAAgB,GAAG,CAAC,CAAC,KAAK,SAAS,CAAC,KAAK,OAAO,IAAI,CAAC,CAAC;GAC5E,MAAM,MAAM,WAAmB;IAAE,GAAI,MAAM,SAAS,QAAS;IAAK,GAAG,KAAK,MAAM,MAAM,SAAS,KAAK,IAAI;GAAI;GAC5G,KAAK,IAAI,QAAQ,GAAG,QAAQ,KAAK,SAAS;IACzC,IAAI,CAAC,OAAO,QAAQ;IACpB,MAAM,YAAY,GAAG,OAAO,MAAM,CAAC,eAAe,IAAI,EAAE,GAAG,OAAO,WAAW,IAAI,SAAS;IAC1F,MAAM,QAAQ,MAAM,IAAI,KAAK;IAC7B,IAAI,CAAC,OAAO;KACX,IAAI;MACH,SAAS,GAAG,UAAU,MAAM,IAAI,KAAK,oBAAoB,MAAM;MAC/D,IAAI,GAAG,KAAK;MACZ,MAAM;KACP,CAAC;KACD;IACD;IACA,MAAM,QAAQ,aAAa,MAAM,IAAI,IAAI,KAAK;IAC9C,IAAI,CAAC,OAAO;IACZ,MAAM,SAAS,MAAM,UAAU;IAE/B,IAAI,OAAO,IAAI,IAAI,EAAE,KACpB,MAAM,YAAY,MAAM,mBAAmB,SAAS,OAAO,SAAS,QAAQ,KAAK,WAAW,QAC5F,IAAI;KACH,SAAS,GAAG,MAAM,KAAK,IAAI,IAAI,KAAK,mCAAmC,OAAO,wDAAwD,SAAS;KAC/I,IAAI,GAAG,KAAK;KACZ,MAAM;IACP,CAAC;IACF,KAAK,MAAM,aAAa,KAAK,KAAK,CAAC,OAClC,IAAI;KACH,SAAS,GAAG,MAAM,KAAK,IAAI,IAAI,KAAK,oDAAoD,UAAU,gCAAgC,iBAAiB;KACnJ,IAAI,GAAG,KAAK;KACZ,MAAM;IACP,CAAC;GACH;EACD;CACD;AACD"}

package/dist/mapCheck/rules/names.js

@@ -0,0 +1,39 @@
+//#region src/mapCheck/rules/names.ts
+/** One thing a name, and the cameras players start looking from */
+var nameRules = {
+	id: "names",
+	check(map, _registry, say, _context) {
+		const named = /* @__PURE__ */ new Map();
+		const name = (value, at, about) => {
+			if (value) named.set(value, [...named.get(value) ?? [], {
+				at,
+				about
+			}]);
+		};
+		for (const object of map.objects) name(object.name, object, { object: object.id });
+		for (const camp of map.camps) name(camp.name, camp, { camp: camp.id });
+		for (const region of map.regions) name(region.name, region.shape, { region: region.id });
+		for (const point of map.points) name(point.name, point, { point: point.id });
+		for (const path of map.paths) name(path.name, path.points[0] ?? {
+			x: 0,
+			z: 0
+		}, { path: path.id });
+		for (const [value, places] of named) if (places.length > 1) say({
+			message: `"${value}" is the name of ${places.length} things: the rules find only one`,
+			error: true,
+			at: places[1].at,
+			rule: "name-twice",
+			about: places[1].about
+		});
+		for (const player of map.players) if (player.camera && !map.cameras.some((camera) => camera.name === player.camera)) say({
+			message: `${player.name} starts looking from "${player.camera}", which is no camera of the map`,
+			at: player.start,
+			rule: "unknown-camera",
+			about: { player: player.id }
+		});
+	}
+};
+//#endregion
+export { nameRules };
+
+//# sourceMappingURL=names.js.map

package/dist/mapCheck/rules/names.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.js","names":[],"sources":["../../../src/mapCheck/rules/names.ts"],"sourcesContent":["import type { MapTarget } from '../../mapFields'\nimport type { Vec2 } from '../../math'\nimport type { MapRule } from '../rule'\n\n/** One thing a name, and the cameras players start looking from */\nexport const nameRules: MapRule = {\n\tid: 'names',\n\tcheck(map, _registry, say, _context) {\n\t\t// the rules find things by name: one thing a name\n\t\tconst named = new Map<string, { at: Vec2; about: MapTarget }[]>()\n\t\tconst name = (value: string | undefined, at: Vec2, about: MapTarget) => {\n\t\t\tif (value) named.set(value, [...(named.get(value) ?? []), { at, about }])\n\t\t}\n\t\tfor (const object of map.objects) name(object.name, object, { object: object.id })\n\t\tfor (const camp of map.camps) name(camp.name, camp, { camp: camp.id })\n\t\tfor (const region of map.regions) name(region.name, region.shape, { region: region.id })\n\t\tfor (const point of map.points) name(point.name, point, { point: point.id })\n\t\tfor (const path of map.paths) name(path.name, path.points[0] ?? { x: 0, z: 0 }, { path: path.id })\n\t\tfor (const [value, places] of named) {\n\t\t\tif (places.length > 1)\n\t\t\t\tsay({\n\t\t\t\t\tmessage: `\"${value}\" is the name of ${places.length} things: the rules find only one`,\n\t\t\t\t\terror: true,\n\t\t\t\t\tat: places[1].at,\n\t\t\t\t\trule: 'name-twice',\n\t\t\t\t\tabout: places[1].about\n\t\t\t\t})\n\t\t}\n\t\tfor (const player of map.players) {\n\t\t\tif (player.camera && !map.cameras.some((camera) => camera.name === player.camera)) {\n\t\t\t\tsay({\n\t\t\t\t\tmessage: `${player.name} starts looking from \"${player.camera}\", which is no camera of the map`,\n\t\t\t\t\tat: player.start,\n\t\t\t\t\trule: 'unknown-camera',\n\t\t\t\t\tabout: { player: player.id }\n\t\t\t\t})\n\t\t\t}\n\t\t}\n\t}\n}\n"],"mappings":";;AAKA,IAAa,YAAqB;CACjC,IAAI;CACJ,MAAM,KAAK,WAAW,KAAK,UAAU;EAEpC,MAAM,wBAAQ,IAAI,IAA8C;EAChE,MAAM,QAAQ,OAA2B,IAAU,UAAqB;GACvE,IAAI,OAAO,MAAM,IAAI,OAAO,CAAC,GAAI,MAAM,IAAI,KAAK,KAAK,CAAC,GAAI;IAAE;IAAI;GAAM,CAAC,CAAC;EACzE;EACA,KAAK,MAAM,UAAU,IAAI,SAAS,KAAK,OAAO,MAAM,QAAQ,EAAE,QAAQ,OAAO,GAAG,CAAC;EACjF,KAAK,MAAM,QAAQ,IAAI,OAAO,KAAK,KAAK,MAAM,MAAM,EAAE,MAAM,KAAK,GAAG,CAAC;EACrE,KAAK,MAAM,UAAU,IAAI,SAAS,KAAK,OAAO,MAAM,OAAO,OAAO,EAAE,QAAQ,OAAO,GAAG,CAAC;EACvF,KAAK,MAAM,SAAS,IAAI,QAAQ,KAAK,MAAM,MAAM,OAAO,EAAE,OAAO,MAAM,GAAG,CAAC;EAC3E,KAAK,MAAM,QAAQ,IAAI,OAAO,KAAK,KAAK,MAAM,KAAK,OAAO,MAAM;GAAE,GAAG;GAAG,GAAG;EAAE,GAAG,EAAE,MAAM,KAAK,GAAG,CAAC;EACjG,KAAK,MAAM,CAAC,OAAO,WAAW,OAC7B,IAAI,OAAO,SAAS,GACnB,IAAI;GACH,SAAS,IAAI,MAAM,mBAAmB,OAAO,OAAO;GACpD,OAAO;GACP,IAAI,OAAO,EAAE,CAAC;GACd,MAAM;GACN,OAAO,OAAO,EAAE,CAAC;EAClB,CAAC;EAEH,KAAK,MAAM,UAAU,IAAI,SACxB,IAAI,OAAO,UAAU,CAAC,IAAI,QAAQ,MAAM,WAAW,OAAO,SAAS,OAAO,MAAM,GAC/E,IAAI;GACH,SAAS,GAAG,OAAO,KAAK,wBAAwB,OAAO,OAAO;GAC9D,IAAI,OAAO;GACX,MAAM;GACN,OAAO,EAAE,QAAQ,OAAO,GAAG;EAC5B,CAAC;CAGJ;AACD"}

package/dist/mapCheck/rules/objects.d.ts

@@ -1,3 +1,3 @@
 import type { MapRule } from '../rule';
-/** What is placed and the camps: of types the game has, on the map, out of deep water */
+/** What is placed and the camps: of types the game has, on the map, out of deep water (but what sails, or flies) */
 export declare const objectRules: MapRule;

package/dist/mapCheck/rules/objects.js

@@ -0,0 +1,56 @@
+import "../../terrain.js";
+//#region src/mapCheck/rules/objects.ts
+/** What is placed and the camps: of types the game has, on the map, out of deep water (but what sails, or flies) */
+var objectRules = {
+	id: "objects",
+	check(map, registry, say, { terrain, onMap }) {
+		for (const object of map.objects) {
+			if (!registry.units.has(object.type)) {
+				say({
+					message: `"${object.type}" is no unit type of the game: it is left out`,
+					at: object,
+					rule: "unknown-type",
+					about: { object: object.id }
+				});
+				continue;
+			}
+			if (!onMap(object)) {
+				say({
+					message: `${registry.unit(object.type).name} stands off the map`,
+					error: true,
+					at: object,
+					rule: "off-map",
+					about: { object: object.id }
+				});
+				continue;
+			}
+			const def = registry.unit(object.type);
+			if (!def.flying && !def.naval && terrain.waterAt(object.x, object.z) === 2) say({
+				message: `${def.name} stands in deep water`,
+				at: object,
+				rule: "deep-water",
+				about: { object: object.id }
+			});
+		}
+		for (const camp of map.camps) {
+			const strangers = camp.units.filter((type) => !type.startsWith("@") && !registry.units.has(type));
+			if (strangers.length) say({
+				message: `A camp has creeps the game does not have: ${strangers.join(", ")}`,
+				at: camp,
+				rule: "unknown-creeps",
+				about: { camp: camp.id }
+			});
+			if (!onMap(camp)) say({
+				message: "A camp stands off the map",
+				error: true,
+				at: camp,
+				rule: "off-map",
+				about: { camp: camp.id }
+			});
+		}
+	}
+};
+//#endregion
+export { objectRules };
+
+//# sourceMappingURL=objects.js.map