@jsprismarine/spawning 0.0.0 → 0.16.0-unstable-20261029140140

package/dist/spawner.cjs.cjs

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_constants = require("./constants.cjs.cjs");
+const require_conditions = require("./conditions.cjs.cjs");
+const require_engineRules = require("./engineRules.cjs.cjs");
+// src/spawner.ts
+/** Splits `minecraft:pillager<minecraft:spawn_as_patrol_follower>` into its two halves. */
+var splitSpawnType = (value) => {
+	const match = /^(?<identifier>[^<]+)<(?<event>[^>]+)>$/.exec(value);
+	if (match?.groups === void 0) return { identifier: value };
+	return {
+		identifier: match.groups.identifier,
+		event: match.groups.event
+	};
+};
+/** Draws an integer in the inclusive range, which is how every size and offset is picked. */
+var between = (random, min, max) => max <= min ? min : min + random.nextInt(max - min + 1);
+/**
+* Builds the permutation each herd member spawns as.
+*
+* `min_guaranteed` members take their permutation before the weighted draw
+* runs, which is what makes the pillager patrol's captain and the zombie
+* herd's one villager certain.
+*/
+var permutationsFor = (permutations, size, random) => {
+	const members = [];
+	for (const permutation of permutations) for (let index = 0; index < permutation.minGuaranteed && members.length < size; index += 1) members.push(permutation);
+	const total = permutations.reduce((sum, permutation) => sum + Math.max(0, permutation.weight), 0);
+	while (members.length < size) {
+		if (total <= 0) {
+			members.push(void 0);
+			continue;
+		}
+		let roll = random.nextFloat() * total;
+		let chosen;
+		for (const permutation of permutations) {
+			roll -= Math.max(0, permutation.weight);
+			if (roll < 0) {
+				chosen = permutation;
+				break;
+			}
+		}
+		members.push(chosen ?? permutations[permutations.length - 1]);
+	}
+	return members;
+};
+/**
+* The event one herd member runs.
+*
+* `initial_event` wins for the first `initial_event_count` members, `event`
+* takes every member past `event_skip_count`, and a permutation's `<event>`
+* suffix or the condition's `minecraft:spawn_event` fills in for the rest.
+*/
+var eventForMember = (index, herd, permutationEvent, condition) => {
+	if (herd?.initialEvent !== void 0 && index < herd.initialEventCount) return herd.initialEvent;
+	if (herd?.event !== void 0 && index >= herd.eventSkipCount) return herd.event;
+	return permutationEvent ?? condition.spawnEvent;
+};
+/** Runs the spawn loop for one world. */
+var Spawner = class {
+	rulesByPool = /* @__PURE__ */ new Map();
+	world;
+	random;
+	constants;
+	delays;
+	engineRules;
+	onUnanswered;
+	constructor(options) {
+		this.world = options.world;
+		this.random = options.random;
+		this.constants = options.constants ?? require_constants.SPAWN_CONSTANTS;
+		this.delays = options.delays ?? new require_conditions.SpawnDelays();
+		this.engineRules = options.engineRules ?? require_engineRules.VANILLA_ENGINE_SPAWN_RULES;
+		this.onUnanswered = options.onUnanswered;
+		for (const rule of options.rules) {
+			const pool = rule.populationControl;
+			if (pool === void 0) continue;
+			const existing = this.rulesByPool.get(pool);
+			if (existing === void 0) this.rulesByPool.set(pool, [rule]);
+			else existing.push(rule);
+		}
+	}
+	/** The pools the loaded rules name, which is what {@link tick} cycles. */
+	get pools() {
+		return [...this.rulesByPool.keys()];
+	}
+	/**
+	* Runs every pool whose cadence falls on this tick.
+	*
+	* @returns Every entity to create, in the order the cycles produced them.
+	*/
+	tick(tick) {
+		const requests = [];
+		for (const pool of this.rulesByPool.keys()) {
+			const cadence = this.constants.pools[pool]?.cycleTicks;
+			if (cadence === void 0 || cadence <= 0 || tick % cadence !== 0) continue;
+			requests.push(...this.cycle(pool, tick));
+		}
+		return requests;
+	}
+	/**
+	* Runs one cycle of one pool, whatever the cadence says.
+	*
+	* @returns Every entity to create, never more than the pool's remaining cap.
+	*/
+	cycle(pool, tick) {
+		const rules = this.rulesByPool.get(pool);
+		if (rules === void 0 || rules.length === 0) return [];
+		const players = this.world.players();
+		if (players.length === 0) return [];
+		const cap = require_constants.poolCapFor(pool, players.length, this.constants);
+		let remaining = cap === void 0 ? Number.POSITIVE_INFINITY : cap - this.world.poolCount(pool);
+		if (remaining <= 0) return [];
+		const requests = [];
+		const { spawnRadiusChunks, chunksPerCycle, positionsPerChunk } = this.constants;
+		for (const player of players) {
+			const playerChunkX = Math.floor(player.position.x / 16);
+			const playerChunkZ = Math.floor(player.position.z / 16);
+			for (let sample = 0; sample < chunksPerCycle && remaining > 0; sample += 1) {
+				const chunkX = playerChunkX + between(this.random, -spawnRadiusChunks, spawnRadiusChunks);
+				const chunkZ = playerChunkZ + between(this.random, -spawnRadiusChunks, spawnRadiusChunks);
+				for (let attempt = 0; attempt < positionsPerChunk && remaining > 0; attempt += 1) for (const pass of ["surface", "underground"]) {
+					if (remaining <= 0) break;
+					const position = this.positionIn(chunkX, chunkZ, pass);
+					if (position === void 0) continue;
+					const spawned = this.attemptAt(pool, rules, position, pass, tick, remaining);
+					remaining -= spawned.length;
+					requests.push(...spawned);
+				}
+			}
+		}
+		return requests;
+	}
+	/**
+	* Draws one position inside a chunk for one pass.
+	*
+	* @returns The position, or undefined when the column is unloaded or the draw landed
+	*   somewhere no entity fits.
+	*/
+	positionIn(chunkX, chunkZ, pass) {
+		const x = chunkX * 16 + this.random.nextInt(16);
+		const z = chunkZ * 16 + this.random.nextInt(16);
+		if (pass === "surface") return this.surfacePosition(x, z);
+		const top = this.world.surfaceY(x, z);
+		if (top === void 0) return void 0;
+		const floor = this.world.minY();
+		if (top - 1 < floor) return void 0;
+		const at = {
+			x,
+			y: between(this.random, floor, top - 1),
+			z
+		};
+		return this.fits(at) ? at : void 0;
+	}
+	/** The top spawn position in a column, using the water surface when one covers the terrain. */
+	surfacePosition(x, z) {
+		const top = this.world.surfaceY(x, z);
+		if (top === void 0) return void 0;
+		const surface = {
+			x,
+			y: top,
+			z
+		};
+		if (this.world.site("underwater", surface)) return surface;
+		const waterSurface = {
+			...surface,
+			y: top - 1
+		};
+		return this.world.site("underwater", waterSurface) ? waterSurface : surface;
+	}
+	/** Whether an entity fits at a position: its own block and the one over its head are free. */
+	fits(at) {
+		return !this.world.solid(at) && !this.world.solid({
+			...at,
+			y: at.y + 1
+		});
+	}
+	/**
+	* Runs one attempt: collect the rules that pass here, draw one, and build
+	* its herd.
+	*
+	* A rule with an engine condition is asked that first, because a condition
+	* Bedrock keeps in code is a condition the file was never able to state.
+	* `minecraft:slime` is the rule this matters to: its file names no
+	* brightness and no height, so without the engine condition it is the only
+	* monster that passes in daylight and it fills the pool on its own.
+	*/
+	attemptAt(pool, rules, position, pass, tick, remaining) {
+		const candidates = [];
+		let totalWeight = 0;
+		for (const rule of rules) {
+			if (this.world.structureSpawnOverrideAt?.(rule.identifier, position) === false) continue;
+			const engineRule = this.engineRules.get(rule.identifier);
+			if (engineRule !== void 0 && !engineRule(position, {
+				world: this.world,
+				random: this.random
+			})) continue;
+			for (const condition of rule.conditions) {
+				if (!require_conditions.evaluateSpawnCondition(condition, position, this.contextFor(rule, tick), pass).passed) continue;
+				candidates.push({
+					rule,
+					condition
+				});
+				totalWeight += Math.max(0, condition.weight.default);
+			}
+		}
+		if (candidates.length === 0 || totalWeight <= 0) return [];
+		let roll = this.random.nextFloat() * totalWeight;
+		let chosen = candidates[candidates.length - 1];
+		for (const candidate of candidates) {
+			roll -= Math.max(0, candidate.condition.weight.default);
+			if (roll < 0) {
+				chosen = candidate;
+				break;
+			}
+		}
+		const { rarity } = chosen.condition.weight;
+		if (rarity > 0 && this.random.nextFloat() * rarity >= 1) return [];
+		if (chosen.condition.delay !== void 0) this.delays.scheduleFrom(chosen.condition.delay, tick, this.random);
+		return this.herdAt(pool, chosen, position, pass, remaining);
+	}
+	/** Builds one herd around an anchor position. */
+	herdAt(pool, candidate, anchor, pass, remaining) {
+		const { condition, rule } = candidate;
+		const herd = condition.herd.length === 0 ? void 0 : condition.herd[this.random.nextInt(condition.herd.length)];
+		const drawn = herd === void 0 ? 1 : between(this.random, herd.minSize, herd.maxSize);
+		const size = Math.max(0, Math.min(drawn, remaining));
+		if (size === 0) return [];
+		const permutations = condition.permutations === void 0 ? void 0 : permutationsFor(condition.permutations, size, this.random);
+		const requests = [];
+		for (let index = 0; index < size; index += 1) {
+			const permutation = permutations?.[index];
+			const swapped = permutation?.entityType === void 0 ? void 0 : splitSpawnType(permutation.entityType);
+			const position = index === 0 ? anchor : this.herdMemberPosition(anchor, pass);
+			const identifier = swapped?.identifier ?? rule.identifier;
+			if (this.world.structureSpawnOverrideAt?.(identifier, position) === false) continue;
+			const event = eventForMember(index, herd, swapped?.event, condition);
+			const request = {
+				identifier,
+				position,
+				pool,
+				rule: rule.identifier,
+				pass
+			};
+			if (event !== void 0) request.spawnEvent = event;
+			requests.push(request);
+		}
+		return requests;
+	}
+	/** Places one herd member around the anchor, following the terrain on the surface pass. */
+	herdMemberPosition(anchor, pass) {
+		const radius = this.constants.herdRadius;
+		const x = anchor.x + between(this.random, -radius, radius);
+		const z = anchor.z + between(this.random, -radius, radius);
+		if (pass !== "surface") return {
+			x,
+			y: anchor.y,
+			z
+		};
+		const position = this.surfacePosition(x, z);
+		if (position === void 0) return anchor;
+		if (this.world.site("underwater", anchor) && !this.world.site("underwater", position)) return anchor;
+		return position;
+	}
+	contextFor(rule, tick) {
+		const context = {
+			world: this.world,
+			identifier: rule.identifier,
+			random: this.random,
+			tick,
+			constants: this.constants,
+			delays: this.delays
+		};
+		if (this.onUnanswered !== void 0) context.onUnanswered = this.onUnanswered;
+		return context;
+	}
+};
+exports.Spawner = Spawner;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"spawner.cjs.cjs","names":["SPAWN_CONSTANTS","SpawnDelays","VANILLA_ENGINE_SPAWN_RULES","poolCapFor","evaluateSpawnCondition"],"sources":["../src/spawner.ts"],"sourcesContent":["import type { EvaluateFilterOptions } from '@jsprismarine/entities';\nimport type { RandomSource } from '@jsprismarine/predicates';\n\nimport type { SpawnConditionContext } from './conditions';\nimport { SpawnDelays, evaluateSpawnCondition } from './conditions';\nimport type { SpawnConstants } from './constants';\nimport { SPAWN_CONSTANTS, poolCapFor } from './constants';\nimport type { EngineSpawnRule } from './engineRules';\nimport { VANILLA_ENGINE_SPAWN_RULES } from './engineRules';\nimport type { HerdRule, SpawnCondition, SpawnPermutation, SpawnRule } from './rules';\nimport type { SpawnPass, SpawnPosition, SpawnWorld } from './world';\n\n/**\n * The spawn loop.\n *\n * Mojang's spawn cycle diagram names six steps, \"check spawn conditions, find\n * valid spawn locations, check population caps, evaluate spawn weight, spawn\n * entity, and run spawn event\", and publishes no number behind any of them.\n * This loop implements those six steps over the constants in\n * `src/tables/spawnConstants.json`, and every draw goes through an injected\n * {@link RandomSource}, so one seed reproduces one set of spawns.\n *\n * One cycle of one pool samples `chunksPerCycle` chunks around each player,\n * tries `positionsPerChunk` positions in each chunk for the surface pass and\n * the same number for the underground pass, and at each position draws one of\n * the conditions that passed, weighted by `minecraft:weight`.\n */\n\n/** One entity the spawner asks the server to create. */\nexport interface SpawnRequest {\n    /** The entity type, with any `<event>` suffix already split off. */\n    readonly identifier: string;\n    /** The event to run instead of `minecraft:entity_spawned`, when the rule names one. */\n    readonly spawnEvent?: string;\n    readonly position: SpawnPosition;\n    /** The pool whose cap this spawn counts against. */\n    readonly pool: string;\n    /** The rule that produced the spawn, which is the identifier of its file. */\n    readonly rule: string;\n    readonly pass: SpawnPass;\n}\n\n/** How to build a {@link Spawner}. */\nexport interface SpawnerOptions {\n    readonly rules: Iterable<SpawnRule>;\n    readonly world: SpawnWorld;\n    readonly random: RandomSource;\n    readonly constants?: SpawnConstants;\n    /** The `minecraft:delay_filter` cooldowns, so a caller can persist them across a restart. */\n    readonly delays?: SpawnDelays;\n    /**\n     * The conditions Bedrock keeps in engine code, keyed by the entity each\n     * one gates. Defaults to {@link VANILLA_ENGINE_SPAWN_RULES}; pass an empty\n     * map to run the JSON conditions alone.\n     */\n    readonly engineRules?: ReadonlyMap<string, EngineSpawnRule>;\n    /** Receives every biome filter test the evaluator could not answer. */\n    readonly onUnanswered?: EvaluateFilterOptions['onUnanswered'];\n}\n\n/** One rule and the one of its conditions that passed at a position. */\ninterface Candidate {\n    readonly rule: SpawnRule;\n    readonly condition: SpawnCondition;\n}\n\n/** Splits `minecraft:pillager<minecraft:spawn_as_patrol_follower>` into its two halves. */\nconst splitSpawnType = (value: string): { readonly identifier: string; readonly event?: string } => {\n    const match = /^(?<identifier>[^<]+)<(?<event>[^>]+)>$/.exec(value);\n    if (match?.groups === undefined) return { identifier: value };\n    return { identifier: match.groups.identifier!, event: match.groups.event! };\n};\n\n/** Draws an integer in the inclusive range, which is how every size and offset is picked. */\nconst between = (random: RandomSource, min: number, max: number): number =>\n    max <= min ? min : min + random.nextInt(max - min + 1);\n\n/**\n * Builds the permutation each herd member spawns as.\n *\n * `min_guaranteed` members take their permutation before the weighted draw\n * runs, which is what makes the pillager patrol's captain and the zombie\n * herd's one villager certain.\n */\nconst permutationsFor = (\n    permutations: readonly SpawnPermutation[],\n    size: number,\n    random: RandomSource\n): readonly (SpawnPermutation | undefined)[] => {\n    const members: (SpawnPermutation | undefined)[] = [];\n    for (const permutation of permutations) {\n        for (let index = 0; index < permutation.minGuaranteed && members.length < size; index += 1)\n            members.push(permutation);\n    }\n\n    const total = permutations.reduce((sum, permutation) => sum + Math.max(0, permutation.weight), 0);\n    while (members.length < size) {\n        if (total <= 0) {\n            members.push(undefined);\n            continue;\n        }\n        let roll = random.nextFloat() * total;\n        let chosen: SpawnPermutation | undefined;\n        for (const permutation of permutations) {\n            roll -= Math.max(0, permutation.weight);\n            if (roll < 0) {\n                chosen = permutation;\n                break;\n            }\n        }\n        members.push(chosen ?? permutations[permutations.length - 1]);\n    }\n\n    return members;\n};\n\n/**\n * The event one herd member runs.\n *\n * `initial_event` wins for the first `initial_event_count` members, `event`\n * takes every member past `event_skip_count`, and a permutation's `<event>`\n * suffix or the condition's `minecraft:spawn_event` fills in for the rest.\n */\nconst eventForMember = (\n    index: number,\n    herd: HerdRule | undefined,\n    permutationEvent: string | undefined,\n    condition: SpawnCondition\n): string | undefined => {\n    if (herd?.initialEvent !== undefined && index < herd.initialEventCount) return herd.initialEvent;\n    if (herd?.event !== undefined && index >= herd.eventSkipCount) return herd.event;\n    return permutationEvent ?? condition.spawnEvent;\n};\n\n/** Runs the spawn loop for one world. */\nexport class Spawner {\n    private readonly rulesByPool = new Map<string, SpawnRule[]>();\n    private readonly world: SpawnWorld;\n    private readonly random: RandomSource;\n    private readonly constants: SpawnConstants;\n    private readonly delays: SpawnDelays;\n    private readonly engineRules: ReadonlyMap<string, EngineSpawnRule>;\n    private readonly onUnanswered: EvaluateFilterOptions['onUnanswered'] | undefined;\n\n    public constructor(options: SpawnerOptions) {\n        this.world = options.world;\n        this.random = options.random;\n        this.constants = options.constants ?? SPAWN_CONSTANTS;\n        this.delays = options.delays ?? new SpawnDelays();\n        this.engineRules = options.engineRules ?? VANILLA_ENGINE_SPAWN_RULES;\n        this.onUnanswered = options.onUnanswered;\n\n        for (const rule of options.rules) {\n            const pool = rule.populationControl;\n            if (pool === undefined) continue;\n            const existing = this.rulesByPool.get(pool);\n            if (existing === undefined) this.rulesByPool.set(pool, [rule]);\n            else existing.push(rule);\n        }\n    }\n\n    /** The pools the loaded rules name, which is what {@link tick} cycles. */\n    public get pools(): readonly string[] {\n        return [...this.rulesByPool.keys()];\n    }\n\n    /**\n     * Runs every pool whose cadence falls on this tick.\n     *\n     * @returns Every entity to create, in the order the cycles produced them.\n     */\n    public tick(tick: number): readonly SpawnRequest[] {\n        const requests: SpawnRequest[] = [];\n        for (const pool of this.rulesByPool.keys()) {\n            const cadence = this.constants.pools[pool]?.cycleTicks;\n            if (cadence === undefined || cadence <= 0 || tick % cadence !== 0) continue;\n            requests.push(...this.cycle(pool, tick));\n        }\n        return requests;\n    }\n\n    /**\n     * Runs one cycle of one pool, whatever the cadence says.\n     *\n     * @returns Every entity to create, never more than the pool's remaining cap.\n     */\n    public cycle(pool: string, tick: number): readonly SpawnRequest[] {\n        const rules = this.rulesByPool.get(pool);\n        if (rules === undefined || rules.length === 0) return [];\n\n        const players = this.world.players();\n        if (players.length === 0) return [];\n\n        const cap = poolCapFor(pool, players.length, this.constants);\n        let remaining = cap === undefined ? Number.POSITIVE_INFINITY : cap - this.world.poolCount(pool);\n        if (remaining <= 0) return [];\n\n        const requests: SpawnRequest[] = [];\n        const { spawnRadiusChunks, chunksPerCycle, positionsPerChunk } = this.constants;\n\n        for (const player of players) {\n            const playerChunkX = Math.floor(player.position.x / 16);\n            const playerChunkZ = Math.floor(player.position.z / 16);\n\n            for (let sample = 0; sample < chunksPerCycle && remaining > 0; sample += 1) {\n                const chunkX = playerChunkX + between(this.random, -spawnRadiusChunks, spawnRadiusChunks);\n                const chunkZ = playerChunkZ + between(this.random, -spawnRadiusChunks, spawnRadiusChunks);\n\n                for (let attempt = 0; attempt < positionsPerChunk && remaining > 0; attempt += 1) {\n                    for (const pass of ['surface', 'underground'] as const) {\n                        if (remaining <= 0) break;\n                        const position = this.positionIn(chunkX, chunkZ, pass);\n                        if (position === undefined) continue;\n                        const spawned = this.attemptAt(pool, rules, position, pass, tick, remaining);\n                        remaining -= spawned.length;\n                        requests.push(...spawned);\n                    }\n                }\n            }\n        }\n\n        return requests;\n    }\n\n    /**\n     * Draws one position inside a chunk for one pass.\n     *\n     * @returns The position, or undefined when the column is unloaded or the draw landed\n     *   somewhere no entity fits.\n     */\n    private positionIn(chunkX: number, chunkZ: number, pass: SpawnPass): SpawnPosition | undefined {\n        const x = chunkX * 16 + this.random.nextInt(16);\n        const z = chunkZ * 16 + this.random.nextInt(16);\n        if (pass === 'surface') return this.surfacePosition(x, z);\n\n        const top = this.world.surfaceY(x, z);\n        if (top === undefined) return undefined;\n\n        const floor = this.world.minY();\n        if (top - 1 < floor) return undefined;\n\n        // The draw is uniform over the column, so in a world with few caves most of it is\n        // inside rock. One attempt, one draw, the way Java's `NaturalSpawner` rejects a\n        // position rather than searching for a better one: a spawn inside a block is a mob\n        // that can path nowhere, never despawns and fills the pool so nothing else can spawn.\n        const at = { x, y: between(this.random, floor, top - 1), z };\n        return this.fits(at) ? at : undefined;\n    }\n\n    /** The top spawn position in a column, using the water surface when one covers the terrain. */\n    private surfacePosition(x: number, z: number): SpawnPosition | undefined {\n        const top = this.world.surfaceY(x, z);\n        if (top === undefined) return undefined;\n\n        const surface = { x, y: top, z };\n        if (this.world.site('underwater', surface)) return surface;\n\n        // A height map that counts water puts its surface one block above the fluid. Fish rules\n        // ask for both the surface pass and an underwater position, so sample the top water\n        // block instead of the air above it.\n        const waterSurface = { ...surface, y: top - 1 };\n        return this.world.site('underwater', waterSurface) ? waterSurface : surface;\n    }\n\n    /** Whether an entity fits at a position: its own block and the one over its head are free. */\n    private fits(at: SpawnPosition): boolean {\n        return !this.world.solid(at) && !this.world.solid({ ...at, y: at.y + 1 });\n    }\n\n    /**\n     * Runs one attempt: collect the rules that pass here, draw one, and build\n     * its herd.\n     *\n     * A rule with an engine condition is asked that first, because a condition\n     * Bedrock keeps in code is a condition the file was never able to state.\n     * `minecraft:slime` is the rule this matters to: its file names no\n     * brightness and no height, so without the engine condition it is the only\n     * monster that passes in daylight and it fills the pool on its own.\n     */\n    private attemptAt(\n        pool: string,\n        rules: readonly SpawnRule[],\n        position: SpawnPosition,\n        pass: SpawnPass,\n        tick: number,\n        remaining: number\n    ): readonly SpawnRequest[] {\n        const candidates: Candidate[] = [];\n        let totalWeight = 0;\n\n        for (const rule of rules) {\n            if (this.world.structureSpawnOverrideAt?.(rule.identifier, position) === false) continue;\n\n            const engineRule = this.engineRules.get(rule.identifier);\n            if (engineRule !== undefined && !engineRule(position, { world: this.world, random: this.random })) continue;\n\n            for (const condition of rule.conditions) {\n                if (!evaluateSpawnCondition(condition, position, this.contextFor(rule, tick), pass).passed) continue;\n                candidates.push({ rule, condition });\n                totalWeight += Math.max(0, condition.weight.default);\n            }\n        }\n\n        if (candidates.length === 0 || totalWeight <= 0) return [];\n\n        let roll = this.random.nextFloat() * totalWeight;\n        let chosen = candidates[candidates.length - 1]!;\n        for (const candidate of candidates) {\n            roll -= Math.max(0, candidate.condition.weight.default);\n            if (roll < 0) {\n                chosen = candidate;\n                break;\n            }\n        }\n\n        // `rarity` is documented by name only. This project reads it as a\n        // one-in-N roll on top of the weight, which is the only reading that\n        // makes a rarity of 2 or 3 rarer rather than more common.\n        const { rarity } = chosen.condition.weight;\n        if (rarity > 0 && this.random.nextFloat() * rarity >= 1) return [];\n\n        if (chosen.condition.delay !== undefined) this.delays.scheduleFrom(chosen.condition.delay, tick, this.random);\n\n        return this.herdAt(pool, chosen, position, pass, remaining);\n    }\n\n    /** Builds one herd around an anchor position. */\n    private herdAt(\n        pool: string,\n        candidate: Candidate,\n        anchor: SpawnPosition,\n        pass: SpawnPass,\n        remaining: number\n    ): readonly SpawnRequest[] {\n        const { condition, rule } = candidate;\n        const herd =\n            condition.herd.length === 0 ? undefined : condition.herd[this.random.nextInt(condition.herd.length)];\n        const drawn = herd === undefined ? 1 : between(this.random, herd.minSize, herd.maxSize);\n        const size = Math.max(0, Math.min(drawn, remaining));\n        if (size === 0) return [];\n\n        const permutations =\n            condition.permutations === undefined\n                ? undefined\n                : permutationsFor(condition.permutations, size, this.random);\n\n        const requests: SpawnRequest[] = [];\n        for (let index = 0; index < size; index += 1) {\n            const permutation = permutations?.[index];\n            const swapped = permutation?.entityType === undefined ? undefined : splitSpawnType(permutation.entityType);\n            const position = index === 0 ? anchor : this.herdMemberPosition(anchor, pass);\n            const identifier = swapped?.identifier ?? rule.identifier;\n            if (this.world.structureSpawnOverrideAt?.(identifier, position) === false) continue;\n            const event = eventForMember(index, herd, swapped?.event, condition);\n\n            const request: { -readonly [Key in keyof SpawnRequest]: SpawnRequest[Key] } = {\n                identifier,\n                position,\n                pool,\n                rule: rule.identifier,\n                pass\n            };\n            if (event !== undefined) request.spawnEvent = event;\n            requests.push(request);\n        }\n\n        return requests;\n    }\n\n    /** Places one herd member around the anchor, following the terrain on the surface pass. */\n    private herdMemberPosition(anchor: SpawnPosition, pass: SpawnPass): SpawnPosition {\n        const radius = this.constants.herdRadius;\n        const x = anchor.x + between(this.random, -radius, radius);\n        const z = anchor.z + between(this.random, -radius, radius);\n        if (pass !== 'surface') return { x, y: anchor.y, z };\n\n        const position = this.surfacePosition(x, z);\n        if (position === undefined) return anchor;\n        if (this.world.site('underwater', anchor) && !this.world.site('underwater', position)) return anchor;\n        return position;\n    }\n\n    private contextFor(rule: SpawnRule, tick: number): SpawnConditionContext {\n        const context: { -readonly [Key in keyof SpawnConditionContext]: SpawnConditionContext[Key] } = {\n            world: this.world,\n            identifier: rule.identifier,\n            random: this.random,\n            tick,\n            constants: this.constants,\n            delays: this.delays\n        };\n        if (this.onUnanswered !== undefined) context.onUnanswered = this.onUnanswered;\n        return context;\n    }\n}\n"],"mappings":"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"}

package/dist/spawner.d.ts

@@ -0,0 +1,105 @@
+import type { EvaluateFilterOptions } from '@jsprismarine/entities';
+import type { RandomSource } from '@jsprismarine/predicates';
+import { SpawnDelays } from './conditions';
+import type { SpawnConstants } from './constants';
+import type { EngineSpawnRule } from './engineRules';
+import type { SpawnRule } from './rules';
+import type { SpawnPass, SpawnPosition, SpawnWorld } from './world';
+/**
+ * The spawn loop.
+ *
+ * Mojang's spawn cycle diagram names six steps, "check spawn conditions, find
+ * valid spawn locations, check population caps, evaluate spawn weight, spawn
+ * entity, and run spawn event", and publishes no number behind any of them.
+ * This loop implements those six steps over the constants in
+ * `src/tables/spawnConstants.json`, and every draw goes through an injected
+ * {@link RandomSource}, so one seed reproduces one set of spawns.
+ *
+ * One cycle of one pool samples `chunksPerCycle` chunks around each player,
+ * tries `positionsPerChunk` positions in each chunk for the surface pass and
+ * the same number for the underground pass, and at each position draws one of
+ * the conditions that passed, weighted by `minecraft:weight`.
+ */
+/** One entity the spawner asks the server to create. */
+export interface SpawnRequest {
+    /** The entity type, with any `<event>` suffix already split off. */
+    readonly identifier: string;
+    /** The event to run instead of `minecraft:entity_spawned`, when the rule names one. */
+    readonly spawnEvent?: string;
+    readonly position: SpawnPosition;
+    /** The pool whose cap this spawn counts against. */
+    readonly pool: string;
+    /** The rule that produced the spawn, which is the identifier of its file. */
+    readonly rule: string;
+    readonly pass: SpawnPass;
+}
+/** How to build a {@link Spawner}. */
+export interface SpawnerOptions {
+    readonly rules: Iterable<SpawnRule>;
+    readonly world: SpawnWorld;
+    readonly random: RandomSource;
+    readonly constants?: SpawnConstants;
+    /** The `minecraft:delay_filter` cooldowns, so a caller can persist them across a restart. */
+    readonly delays?: SpawnDelays;
+    /**
+     * The conditions Bedrock keeps in engine code, keyed by the entity each
+     * one gates. Defaults to {@link VANILLA_ENGINE_SPAWN_RULES}; pass an empty
+     * map to run the JSON conditions alone.
+     */
+    readonly engineRules?: ReadonlyMap<string, EngineSpawnRule>;
+    /** Receives every biome filter test the evaluator could not answer. */
+    readonly onUnanswered?: EvaluateFilterOptions['onUnanswered'];
+}
+/** Runs the spawn loop for one world. */
+export declare class Spawner {
+    private readonly rulesByPool;
+    private readonly world;
+    private readonly random;
+    private readonly constants;
+    private readonly delays;
+    private readonly engineRules;
+    private readonly onUnanswered;
+    constructor(options: SpawnerOptions);
+    /** The pools the loaded rules name, which is what {@link tick} cycles. */
+    get pools(): readonly string[];
+    /**
+     * Runs every pool whose cadence falls on this tick.
+     *
+     * @returns Every entity to create, in the order the cycles produced them.
+     */
+    tick(tick: number): readonly SpawnRequest[];
+    /**
+     * Runs one cycle of one pool, whatever the cadence says.
+     *
+     * @returns Every entity to create, never more than the pool's remaining cap.
+     */
+    cycle(pool: string, tick: number): readonly SpawnRequest[];
+    /**
+     * Draws one position inside a chunk for one pass.
+     *
+     * @returns The position, or undefined when the column is unloaded or the draw landed
+     *   somewhere no entity fits.
+     */
+    private positionIn;
+    /** The top spawn position in a column, using the water surface when one covers the terrain. */
+    private surfacePosition;
+    /** Whether an entity fits at a position: its own block and the one over its head are free. */
+    private fits;
+    /**
+     * Runs one attempt: collect the rules that pass here, draw one, and build
+     * its herd.
+     *
+     * A rule with an engine condition is asked that first, because a condition
+     * Bedrock keeps in code is a condition the file was never able to state.
+     * `minecraft:slime` is the rule this matters to: its file names no
+     * brightness and no height, so without the engine condition it is the only
+     * monster that passes in daylight and it fills the pool on its own.
+     */
+    private attemptAt;
+    /** Builds one herd around an anchor position. */
+    private herdAt;
+    /** Places one herd member around the anchor, following the terrain on the surface pass. */
+    private herdMemberPosition;
+    private contextFor;
+}
+//# sourceMappingURL=spawner.d.ts.map

package/dist/spawner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawner.d.ts","sourceRoot":"","sources":["../src/spawner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,EAAE,WAAW,EAA0B,MAAM,cAAc,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,OAAO,KAAK,EAA8C,SAAS,EAAE,MAAM,SAAS,CAAC;AACrF,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEpE;;;;;;;;;;;;;;GAcG;AAEH,wDAAwD;AACxD,MAAM,WAAW,YAAY;IACzB,oEAAoE;IACpE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uFAAuF;IACvF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,oDAAoD;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;CAC5B;AAED,sCAAsC;AACtC,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,cAAc,CAAC;IACpC,6FAA6F;IAC7F,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC5D,uEAAuE;IACvE,QAAQ,CAAC,YAAY,CAAC,EAAE,qBAAqB,CAAC,cAAc,CAAC,CAAC;CACjE;AA4ED,yCAAyC;AACzC,qBAAa,OAAO;IAChB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAkC;IAC9D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAuC;IACnE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoD;IAEjF,YAAmB,OAAO,EAAE,cAAc,EAezC;IAED,0EAA0E;IAC1E,IAAW,KAAK,IAAI,SAAS,MAAM,EAAE,CAEpC;IAED;;;;OAIG;IACI,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,YAAY,EAAE,CAQjD;IAED;;;;OAIG;IACI,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,YAAY,EAAE,CAoChE;IAED;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAmBlB,+FAA+F;IAC/F,OAAO,CAAC,eAAe;IAcvB,8FAA8F;IAC9F,OAAO,CAAC,IAAI;IAIZ;;;;;;;;;OASG;IACH,OAAO,CAAC,SAAS;IA+CjB,iDAAiD;IACjD,OAAO,CAAC,MAAM;IA0Cd,2FAA2F;IAC3F,OAAO,CAAC,kBAAkB;IAY1B,OAAO,CAAC,UAAU;CAYrB"}