@v12-engine/engine 0.1.1 → 0.4.0

package/dist/session/local.js

@@ -0,0 +1,670 @@
+import { checkpoint } from "../engineEvents.js";
+import { SessionView } from "../replication.js";
+import { deposit } from "../entity.js";
+import { heroSummaries } from "../hero.js";
+import { names } from "../names.js";
+import { assertPlainData } from "../debug2.js";
+import { formationPreview } from "../formation.js";
+import { decidedAvailability, decidedUnlocks, techOf } from "../tech.js";
+import { canPlaceStructure, placementCells } from "../orders/build.js";
+import { shownFx } from "../effects.js";
+import { minesFor } from "../systems/economy.js";
+import { campsFor } from "../camps.js";
+import { saveWorld } from "../save.js";
+import { lanesOf } from "../lanes.js";
+import { paceOf, savesOf } from "./can.js";
+import { sameEntity } from "./delta.js";
+import { LocalDebug } from "./debug.js";
+import { checkTold, commonEntityState, commonStillTold, hasOnePlayersPart, playerEntityState, sharedStillTold } from "./entityState.js";
+//#region src/session/local.ts
+/**
+* A seat at a world running in the same page. It does the job a server will do later:
+* run the simulation, and hand the player only what their team is allowed to know.
+*/
+/** The effects of the rules a player was shown that are kept, for a stop to be told to them: the latest so many */
+var MOST_EFFECTS = 1024;
+/**
+* The events a computer player's seat hears (`forComputer`): the facts a brain reads and a save keeps for it (deaths,
+* damage, healing, pings, chat, the game's own events) and the answers to its commands. The rest is for a screen (an
+* attack's swing, a shot, a buff, a hammer blow, a line said), and a computer's seat is spared hearing it
+*
+* @beta
+*/
+var COMPUTER_EVENTS = /* @__PURE__ */ new Set([
+	"death",
+	"damage",
+	"heal",
+	"ping",
+	"chat",
+	"game",
+	"command"
+]);
+var SHARED = /* @__PURE__ */ new WeakMap();
+/**
+* From here until `endSharedCaptures`, the sessions of the world describe each entity once between them (what
+* everyone is told; what is one player's goes on a copy): for a host's round of sending, where every seat is captured
+* from the same world. Not while the world changes: what was described is said again
+*
+* @internal
+*/
+function shareCaptures(world) {
+	SHARED.set(world, {
+		common: /* @__PURE__ */ new Map(),
+		sides: /* @__PURE__ */ new Map()
+	});
+}
+/** @internal */
+function endSharedCaptures(world) {
+	SHARED.delete(world);
+}
+/**
+* A `GameSession` over a world in the same process: steps it from real time, takes a player's snapshots of it and sends their commands into it
+*
+* @beta
+*/
+var LocalSession = class {
+	world;
+	playerId;
+	/** The ground of the world, for the client to draw and ask about */
+	terrain;
+	/** The map's look (sky, mist, light), when the world was made from a map that has one */
+	environment;
+	/** The map's scenery objects, which have no life at runtime */
+	doodads;
+	/** The map's named regions */
+	regions;
+	/** The map's named camera positions */
+	cameras;
+	/** The map's named paths */
+	paths;
+	/** The definitions of the game the world runs: unit types, abilities, orders and the rest */
+	registry;
+	/** Simulation ticks per second of the world */
+	tickRate;
+	/** How far, 0..1, the time is between the last tick and the next, for the client to blend its drawing by; 1 when paused */
+	alpha = 1;
+	/** What the world says (`World.log`): a session in the page has it, and the client shows it with its own */
+	get log() {
+		return this.world.log;
+	}
+	/** Why the game ended on an error, once it has (`World.failure`) */
+	get failure() {
+		return this.world.failure;
+	}
+	/** Simulation speed multiplier, 0 pauses. A debug control, a real server sets the pace itself */
+	speed = 1;
+	accumulator = 0;
+	/** Whether the team saw the whole map at the last snapshot (the debug switch): what it saw then only is forgotten after */
+	wasRevealed = false;
+	/** What the player's team remembers, or an observer's own (`SessionView.memory`) */
+	get memory() {
+		return this.view.memory;
+	}
+	/** Ids of what made it into the snapshot being put together as in sight. Kept to be cleared, not made anew */
+	inSight = /* @__PURE__ */ new Set();
+	/** The names the map or the rules gave entities, by id, as of the snapshot being put together (`world.named`) */
+	namesNow = /* @__PURE__ */ new Map();
+	disposers = [];
+	pendingCheckpoint;
+	/** The label and save taken at the last tick that a checkpoint was asked for, for the game to be taken back to */
+	checkpoint;
+	/** The debug tools over this session's world */
+	debug;
+	/** Its pace, saves of its world, the debug tools' view, and what a computer player's brain reads (`SessionCan`) */
+	can = {
+		pace: paceOf(this),
+		saves: savesOf(this),
+		inspect: void 0,
+		computer: {
+			mines: () => this.mines(),
+			lanes: () => this.lanes(),
+			pendingEvents: () => this.pendingEvents(),
+			restoreEvents: (events) => this.restoreEvents(events)
+		}
+	};
+	/**
+	* Who only watches, and sees everything: every entity, the whole map, every player's resources and heroes. From
+	* `playerId`'s side all the same (who is an ally, an enemy). For a server's watchers, whose commands go nowhere
+	*/
+	observer;
+	/**
+	* Whose seat is a computer player's (`forComputer`): its snapshots leave out projectiles, missiles, corpses, reveals
+	* and the events a brain never reads, and it listens for none of those, so twelve computers cost the world less
+	*/
+	forComputer;
+	/** The seat's side of the world: whose it is, what they may know, what was told to them since the last snapshot */
+	view;
+	constructor(world, playerId, options = {}) {
+		this.world = world;
+		this.playerId = playerId;
+		this.observer = options.observer ?? false;
+		this.ownsWorld = options.ownsWorld ?? false;
+		this.forComputer = options.forComputer ?? false;
+		this.view = new SessionView(world, playerId, {
+			observer: this.observer,
+			forComputer: this.forComputer,
+			mostEffects: options.mostEffects ?? MOST_EFFECTS
+		});
+		if (options.debug) world.debugPlayers.add(playerId);
+		this.terrain = world.terrain;
+		this.environment = world.map.environment;
+		this.doodads = world.map.doodads;
+		this.regions = world.map.regions;
+		this.cameras = world.map.cameras;
+		this.paths = world.map.paths;
+		this.registry = world.registry;
+		this.tickRate = world.tickRate;
+		this.debug = new LocalDebug(world);
+		this.can.inspect = this.debug;
+		const { events } = world;
+		const { view } = this;
+		for (const replication of world.registry.replications) {
+			if (!this.hears(replication.as)) continue;
+			this.disposers.push(events.on(replication.event, (payload) => {
+				const said = replication.tell(payload, view);
+				if (said) view.events.push(said);
+			}));
+		}
+		this.disposers.push(events.on(checkpoint, ({ label }) => this.pendingCheckpoint = label));
+		if (this.hears("game")) this.disposers.push(events.watch((type, payload) => {
+			if (typeof type !== "string") return;
+			const audience = world.registry.event(type)?.replicate;
+			if (!audience) return;
+			if (audience !== "everyone" && !audience(payload, view)) return;
+			if (this.world.checks.events) assertPlainData(payload, `Event "${type}"`);
+			view.events.push({
+				type: "game",
+				event: type,
+				payload
+			});
+		}));
+	}
+	/** Whether the seat is told of events of a kind: a player's seat of all of them, a computer's of what a brain reads */
+	hears(kind) {
+		return !this.forComputer || COMPUTER_EVENTS.has(kind);
+	}
+	/** The player's team: theirs now, as the rules may move them to another (`setTeam`) */
+	get team() {
+		return this.view.team;
+	}
+	isAlly(owner) {
+		return this.view.isAlly(owner);
+	}
+	/** Whether the player's team sees a spot of the map right now: an observer sees all of it */
+	sees(x, z) {
+		return this.view.sees(x, z);
+	}
+	/**
+	* How many effects of the rules are kept for their stop to be told (`mostEffects`), for a test of the bound
+	*
+	* @internal
+	*/
+	get keptEffects() {
+		return shownFx(this.view).size;
+	}
+	/** Whether the player's team can see the entity right now */
+	knows(entity) {
+		return this.view.knows(entity);
+	}
+	/**
+	* What everyone in sight of an entity is told of it this tick, the same for every seat: worked out once for all
+	* the sessions of a world while a host's round of sending is on (`shareCaptures`), else for this session alone
+	*/
+	common(entity) {
+		const shared = SHARED.get(this.world)?.common;
+		const known = shared?.get(entity.id);
+		if (known) return known;
+		const name = this.namesNow.get(entity.id);
+		const { told } = entity;
+		const state = told && commonStillTold(this.world, entity, told, name) ? told : entity.told = commonEntityState(this.world, entity, name);
+		shared?.set(entity.id, state);
+		return state;
+	}
+	/**
+	* What this player was told of each entity last (`Told`), to be told again while it holds (`tell`): with the entity,
+	* gone with it
+	*/
+	told = /* @__PURE__ */ new WeakMap();
+	/**
+	* What this player is told of an entity: what everyone is (`common`, shared between the seats of a host), and on a
+	* copy of it what is this player's to know: an illusion's lifetime on its own side, the components replicated to it
+	* and what they make of themselves for it, and its own part (`own`) for an ally's. Last time's objects wherever
+	* nothing changed (`playerEntityState`)
+	*/
+	tell(entity) {
+		const shared = this.common(entity);
+		const before = this.told.get(entity);
+		const state = playerEntityState(this.view, entity, shared, before);
+		if (this.world.checks.snapshots) checkTold(this.view, entity, state, this.namesNow.get(entity.id));
+		this.keep(entity, shared, state);
+		return state;
+	}
+	/** Remembers what the player was told of an entity (`told`) */
+	keep(entity, shared, state) {
+		const told = this.told.get(entity);
+		if (!told) this.told.set(entity, {
+			shared,
+			state
+		});
+		else {
+			told.shared = shared;
+			told.state = state;
+		}
+	}
+	/**
+	* What this player is told of an entity (`tell`), once for the seats of a side told the same while a host's round
+	* of sending is on (`Round.sides`): the side's object, which this seat remembers as its own, is this seat's too
+	*/
+	describe(entity) {
+		const side = this.sideNow;
+		if (!side) return this.tell(entity);
+		if (this.isOnePlayers(entity)) {
+			const state = this.tell(entity);
+			const first = side.alike.get(entity.id);
+			if (!first) side.alike.set(entity.id, state);
+			else if (first !== state && sameEntity(first, state)) {
+				this.keep(entity, this.common(entity), first);
+				return first;
+			}
+			return state;
+		}
+		const known = side.all.get(entity.id);
+		if (known) {
+			this.keep(entity, this.common(entity), known);
+			return known;
+		}
+		const state = this.tell(entity);
+		side.all.set(entity.id, state);
+		return state;
+	}
+	/**
+	* What the seats of this one's side are told alike this round (`Round.sides`), by entity: none outside a host's round.
+	* Set as the capture starts (`capture`)
+	*/
+	sideNow;
+	/**
+	* Which seats are told the same of an entity where nothing of it is one player's: an observer's, or a team's with the
+	* same allies among the players (relations are a pair of players', not a team's)
+	*/
+	sideKey() {
+		if (this.observer) return "observer";
+		let key = `team ${this.team}:`;
+		for (const player of this.world.players.keys()) key += this.isAlly(player) ? "1" : "0";
+		return key;
+	}
+	/**
+	* Whether what this player is told of an entity is theirs alone, not their side's: a component replicated to its owner
+	* or shaping itself for each player (`Component.snapshot`), or control of another's unit shared with this player
+	*/
+	isOnePlayers(entity) {
+		if (hasOnePlayersPart(this.world, entity)) return true;
+		return entity.owner !== this.playerId && !this.observer && this.isAlly(entity.owner) && this.world.mayCommand(this.playerId, entity);
+	}
+	/** Where in the list being captured are those that may be one player's (`SideSeen.mine`): while the first seat of a side captures */
+	mineNow;
+	/**
+	* What the team remembers of a structure is every teammate's to be told, not this seat's: without the parts of the
+	* description shaped for one player (components replicated to the owner, or made by their `snapshot` for whoever is
+	* told), which the seat that happened to see it first would otherwise give to the whole team
+	*/
+	forTeam(entity, state) {
+		if (!state.components || !hasOnePlayersPart(this.world, entity)) return state;
+		const components = {};
+		for (const [id, part] of Object.entries(state.components)) {
+			const component = this.world.registry.component(id);
+			if (component?.replicate === "owner" || component?.replicate && component.snapshot) continue;
+			components[id] = part;
+		}
+		return {
+			...state,
+			components
+		};
+	}
+	/** Adds what the player sees of an entity in sight to the snapshot, and remembers structures for when they are out of sight */
+	see(entity, out, remembered) {
+		const before = remembered[entity.id];
+		const kept = entity.isResource && before?.visible && before.resource === entity.get(deposit)?.amount && sharedStillTold(entity, before);
+		const state = kept ? before : this.describe(entity);
+		if (!kept && this.mineNow && (this.isAlly(entity.owner) || hasOnePlayersPart(this.world, entity))) this.mineNow.push(out.length);
+		out.push(state);
+		this.inSight.add(entity.id);
+		if (entity.isStructure && !this.isAlly(entity.owner)) {
+			if (state !== before) remembered[entity.id] = this.forTeam(entity, state);
+		} else if (before) delete remembered[entity.id];
+	}
+	/** Throws when what was taken to be in sight is not what testing every entity gives. See `debugChecks` */
+	checkSight() {
+		for (const entity of this.world.entities.values()) {
+			if (!entity.alive || this.knows(entity) === this.inSight.has(entity.id)) continue;
+			const said = this.inSight.has(entity.id) ? "in sight" : "out of sight";
+			throw new Error(`Snapshot for player ${this.playerId} has ${entity.def.id}#${entity.id} ${said}, it is not`);
+		}
+	}
+	/** The scenery the player's team sees right now */
+	*sceneryInSight() {
+		const { world } = this;
+		if (this.observer || world.fog.isRevealed(this.team)) {
+			for (const entity of world.entities.values()) if (entity.scenery) yield entity;
+		} else yield* world.sceneryInSight.get(this.team) ?? [];
+	}
+	/**
+	* On a map explored from the start, what stands on it and belongs to no player (trees, mines, rocks, neutral
+	* buildings, the creeps' own) known to the team from the first snapshot, as it stands, out of sight: the genre's melee
+	* maps. Once for a team (`TeamMemory.startKnown`); units, and players' buildings, only once seen
+	*/
+	knowStart(remembered) {
+		const { world } = this;
+		if (this.observer || !world.fog.exploredFromStart) return;
+		const memory = this.memory;
+		if (memory.startKnown) return;
+		memory.startKnown = true;
+		for (const entity of world.entities.values()) {
+			if (!entity.alive || !entity.isStructure || this.inSight.has(entity.id) || remembered[entity.id]) continue;
+			const owner = world.players.get(entity.owner);
+			if (!owner?.neutral && !owner?.creeps) continue;
+			remembered[entity.id] = {
+				...this.forTeam(entity, this.describe(entity)),
+				visible: false
+			};
+		}
+	}
+	capture() {
+		const { world } = this;
+		const round = SHARED.get(world);
+		if (round) {
+			const key = this.sideKey();
+			let side = round.sides.get(key);
+			if (!side) round.sides.set(key, side = {
+				all: /* @__PURE__ */ new Map(),
+				alike: /* @__PURE__ */ new Map()
+			});
+			this.sideNow = side;
+		} else this.sideNow = void 0;
+		const remembered = this.memory.structures;
+		this.namesNow.clear();
+		if (world.states.has(names)) for (const [name, id] of Object.entries(world.state(names))) this.namesNow.set(id, name);
+		const seen = this.sideNow?.seen;
+		const entities = seen ? this.seeAsSide(seen) : this.seeAll(remembered);
+		if (this.world.checks.sight) this.checkSight();
+		if (seen) return this.finish(entities);
+		this.knowStart(remembered);
+		const revealed = this.observer || world.fog.isRevealed(this.team);
+		if (this.wasRevealed && !revealed) {
+			for (const [key, state] of Object.entries(remembered)) if (!this.inSight.has(Number(key)) && !world.fog.isExplored(this.team, state.x, state.z)) delete remembered[Number(key)];
+		}
+		this.wasRevealed = revealed;
+		const forget = world.settings.fog?.explored === "nothing" && !revealed;
+		for (const [key, state] of Object.entries(remembered)) {
+			const id = Number(key);
+			if (this.inSight.has(id)) continue;
+			if (forget) {
+				delete remembered[id];
+				continue;
+			}
+			if (!world.get(id) && this.sees(state.x, state.z)) {
+				delete remembered[id];
+				continue;
+			}
+			const memory = state.visible ? {
+				...state,
+				visible: false
+			} : state;
+			if (memory !== state) remembered[id] = memory;
+			entities.push(memory);
+		}
+		if (this.sideNow) this.sideNow.seen = {
+			entities: [...entities],
+			inSight: new Set(this.inSight),
+			mine: this.mineNow ?? []
+		};
+		this.mineNow = void 0;
+		return this.finish(entities);
+	}
+	/** The entities in sight, and what the side remembers out of it, as the first seat of a side (or a seat on its own) sees them */
+	seeAll(remembered) {
+		const { world } = this;
+		const entities = [];
+		this.inSight.clear();
+		this.mineNow = this.sideNow ? [] : void 0;
+		for (const entity of world.units.values()) if (entity.alive && this.knows(entity)) this.see(entity, entities, remembered);
+		for (const entity of this.sceneryInSight()) if (entity.alive && entity.scenery) this.see(entity, entities, remembered);
+		return entities;
+	}
+	/**
+	* What another seat of the side saw this round, as this one sees it: the same, but what may be this player's alone
+	* described again for them. The side's memory is the first seat's to keep
+	*/
+	seeAsSide(seen) {
+		const entities = [...seen.entities];
+		this.inSight.clear();
+		for (const id of seen.inSight) this.inSight.add(id);
+		for (const at of seen.mine) entities[at] = this.describe(this.world.get(entities[at].id));
+		this.wasRevealed = this.observer || this.world.fog.isRevealed(this.team);
+		return entities;
+	}
+	/** The rest of a snapshot, round its entities: the players, and every feature's part (`SnapshotField`) */
+	finish(entities) {
+		const { world } = this;
+		const players = [];
+		for (const player of world.players.values()) {
+			const state = {
+				id: player.id,
+				name: player.name,
+				team: player.team,
+				color: player.color,
+				neutral: player.neutral,
+				creeps: player.creeps || void 0,
+				...player.race !== void 0 && { race: player.race },
+				defeated: player.defeated,
+				relation: player.id === this.playerId ? "self" : world.areAllies(this.playerId, player.id) ? "ally" : world.areEnemies(this.playerId, player.id) ? "enemy" : "neutral"
+			};
+			if (state.relation === "ally" && !player.neutral && !this.observer) {
+				const me = world.player(this.playerId);
+				state.shared = {
+					control: world.sides.controlOf(this.playerId).includes(player.id),
+					vision: me.team === player.team || world.sides.visionOf(me.team).includes(player.team)
+				};
+			}
+			if (player.id === this.playerId || this.observer && !player.neutral) {
+				state.own = {
+					resources: { ...player.resources },
+					supplyUsed: player.supplyUsed,
+					supplyCap: player.supplyCap,
+					...Object.keys(player.supplies).length > 0 && { supplies: structuredClone(player.supplies) },
+					upkeep: world.settings.economy.upkeep(world, player.id),
+					upgrades: Object.fromEntries(player.upgrades),
+					researching: [...player.researching],
+					tech: [...techOf(world, player.id)],
+					heroes: heroSummaries(world, player.id),
+					objectives: world.objectives.of(player.id).map((objective) => structuredClone(objective)),
+					...world.timers.shownTo(player.id).length && { timers: world.timers.shownTo(player.id) }
+				};
+				if (world.hooks.has("requirement") && player.id === this.playerId) state.own.unlocks = decidedUnlocks(world, player.id);
+				if (world.hooks.has("available") && player.id === this.playerId) {
+					const availability = decidedAvailability(world, player.id);
+					if (availability) state.own.availability = availability;
+				}
+			}
+			players.push(state);
+		}
+		const { view } = this;
+		const snapshot = { tick: world.tick };
+		const parts = world.registry.snapshotFields;
+		const take = (part) => {
+			const value = part.capture(view);
+			if (value !== void 0) snapshot[part.key] = value;
+		};
+		for (const part of parts) if (part.head) take(part);
+		snapshot.entities = entities;
+		snapshot.players = players;
+		for (const part of parts) if (!part.head) take(part);
+		return snapshot;
+	}
+	/** Takes a snapshot of the world as the seat sees it now, without stepping */
+	snapshot() {
+		return this.capture();
+	}
+	/**
+	* Moves the game on by `ticks` at the next update, however fast it goes: a step of a paused game (`speed` 0), as
+	* an editor's Step does. Ticks asked for while it runs are taken on top of its pace
+	*/
+	advance(ticks = 1) {
+		this.accumulator += this.world.dt * Math.max(0, Math.floor(ticks));
+	}
+	/** A save of the world as it stands (`saveWorld`): at once, as a promise for what a session elsewhere answers later */
+	save() {
+		try {
+			return Promise.resolve(saveWorld(this.world));
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+	/**
+	* Runs the game on by itself, a tick at a time, as fast as the page can, until `until` holds of the world, `most`
+	* ticks have run, the game is over, or `deadline` (`performance.now()`'s) is past: what an editor's "Play to" does a
+	* slice a frame, its pace and `advance` aside. The ticks are the same ticks the game runs at its own pace, so the
+	* same game comes to the same moment. What happened in them is in the next snapshot (`update`), as after a slow frame.
+	* `until` is asked before the first tick too: what holds already runs none
+	*/
+	runUntil(until, options = {}) {
+		const { world } = this;
+		const most = options.most ?? Infinity;
+		const deadline = options.deadline ?? Infinity;
+		let ticks = 0;
+		const over = () => world.failure !== null || world.winner !== null;
+		while (!until(world)) {
+			if (ticks >= most || over()) return this.ran(ticks, false, over());
+			if (ticks % 8 === 7 && performance.now() > deadline) return this.ran(ticks, false, false);
+			this.tickOnce();
+			ticks++;
+		}
+		return this.ran(ticks, true, over());
+	}
+	/** What `runUntil` gives back, the debug tools' view brought up to date where it ran */
+	ran(ticks, reached, over) {
+		if (ticks) {
+			this.debug.refresh();
+			this.ranOn = true;
+		}
+		return {
+			ticks,
+			reached,
+			over
+		};
+	}
+	/** Whether `runUntil` ran ticks since the last update: its next snapshot describes them, paused or not */
+	ranOn = false;
+	/** A tick of the world, and the checkpoint it marked saved as the world stood at its end, not at the end of the frame */
+	tickOnce() {
+		this.world.step();
+		if (this.pendingCheckpoint) {
+			this.checkpoint = {
+				label: this.pendingCheckpoint,
+				save: saveWorld(this.world)
+			};
+			this.pendingCheckpoint = void 0;
+		}
+	}
+	/** Adds `dt` real seconds (scaled by `speed`) and steps the world one tick for each tick's worth; returns a snapshot of how it stands after, or none when nothing happened */
+	update(dt) {
+		const { world } = this;
+		let stepped = this.ranOn;
+		this.ranOn = false;
+		this.accumulator += dt * this.speed * world.cheats.speed;
+		if (world.cheats.speed === 0 && this.speed > 0 && world.debugWaiting) this.accumulator += world.dt;
+		while (this.accumulator >= world.dt) {
+			this.tickOnce();
+			this.accumulator -= world.dt;
+			stepped = true;
+		}
+		this.alpha = this.speed * world.cheats.speed > 0 ? this.accumulator / world.dt : 1;
+		if (!stepped) return this.view.events.length ? [this.capture()] : [];
+		this.debug.refresh();
+		return [this.capture()];
+	}
+	/** Sends a command. `seq` is the sender's own number for it, for a host passing on what a remote player numbered */
+	send(command, seq = ++this.lastSeq) {
+		this.world.issue({
+			...command,
+			player: this.playerId,
+			seq
+		});
+		return seq;
+	}
+	/**
+	* The number of the last command sent: a computer's seat keeps it through a save, so the commands it sends after a
+	* load are numbered as they would have been
+	*
+	* @beta
+	*/
+	lastSeq = 0;
+	/** The seat's team's fog as cells, visible and explored */
+	fog() {
+		const { fog } = this.world;
+		const cells = fog.cells(this.team);
+		return {
+			width: fog.width,
+			depth: fog.depth,
+			version: fog.version,
+			revealed: this.observer || fog.isRevealed(this.team) || !cells,
+			visible: cells?.visible ?? /* @__PURE__ */ new Uint8Array(0),
+			explored: cells?.explored ?? /* @__PURE__ */ new Uint8Array(0)
+		};
+	}
+	/** Where the game's money is mined, as the map shows it, seen or not (`GameSession.mines`, `minesFor`) */
+	mines() {
+		return minesFor(this.view);
+	}
+	/** The lanes of the map, as the map shows them (`GameSession.lanes`) */
+	lanes() {
+		return lanesOf(this.world);
+	}
+	/** The camps as the player knows them (`GameSession.camps`, `campsFor`): worked out once a tick */
+	camps() {
+		return campsFor(this.view);
+	}
+	/** Whether the player could place a building of this type at the point now, seen as their team sees the ground */
+	canPlace(unitType, point) {
+		return this.registry.units.has(unitType) && canPlaceStructure(this.world, this.registry.unit(unitType), point, this.playerId, true);
+	}
+	/** Which cells of a building's ground are in the way for the player: taken, or not explored by their team (`placementCells`) */
+	placeCells(unitType, point) {
+		if (!this.registry.units.has(unitType)) return void 0;
+		const { world } = this;
+		const { team } = world.player(this.playerId);
+		return placementCells(this.registry.unit(unitType), point, (x, z) => world.grid.canPlace(x, z, 1, 1), (x, z) => world.fog.isExplored(team, x + .5, z + .5));
+	}
+	/** Where a group would stand sent to a point in a formation, the rules' own pick when none is named (`GameSession.formationPlaces`) */
+	formationPlaces(units, point, facing, formation) {
+		const { world } = this;
+		const id = formation ?? world.settings.movement.formation(world, units.flatMap((unit) => world.get(unit.id) ?? []), {
+			type: "move",
+			point
+		});
+		return formationPreview(this.registry, units, point, world, id, facing);
+	}
+	/** A path between two points on the ground, or in the air when `flying`; null when there is none */
+	findPath(from, to, flying = false) {
+		return (flying ? this.world.air : this.world.nav).findPath(from, to);
+	}
+	/** What happened since the last snapshot, not yet given in one: a copy, for a computer's save */
+	pendingEvents() {
+		return structuredClone(this.view.events);
+	}
+	/** Takes back what `pendingEvents` gave, ahead of what has happened since: in a game loaded from a save */
+	restoreEvents(events) {
+		this.view.events = [...structuredClone(events), ...this.view.events];
+	}
+	/** Whether the world goes with the session */
+	ownsWorld;
+	/** Stops the session's listeners and debug tools, and the world too when the session owns it */
+	dispose() {
+		for (const dispose of this.disposers.splice(0)) dispose();
+		this.debug.dispose();
+		if (this.ownsWorld) this.world.dispose();
+	}
+};
+//#endregion
+export { COMPUTER_EVENTS, LocalSession, endSharedCaptures, shareCaptures };
+
+//# sourceMappingURL=local.js.map