@jsprismarine/spawning 0.0.0 → 0.16.0-unstable-20261029140140

package/README.md

@@ -0,0 +1,207 @@
+# @jsprismarine/spawning
+
+[![Join the Discord Server](https://img.shields.io/discord/704967868885762108?color=%237289DA&label=Discord)](https://discord.gg/6w8JWhy)
+[![npm](https://img.shields.io/npm/dt/@jsprismarine/spawning)](https://www.npmjs.com/package/@jsprismarine/spawning)
+
+Bedrock natural spawning: the `spawn_rules/*.json` grammar, the condition evaluator, the population
+pools and the spawn loop. It builds on `@jsprismarine/packs` for the filter grammar, on
+`@jsprismarine/entities` for the filter evaluator that spawn rules, entity definitions and trade
+tables all share, and on `@jsprismarine/predicates` for the injected random source.
+
+```typescript
+import { Spawner, parseSpawnRule } from '@jsprismarine/spawning';
+import { seededRandom } from '@jsprismarine/predicates';
+
+const rules = files.map((file) => parseSpawnRule(file.data, { pack: file.pack, path: file.path }));
+const spawner = new Spawner({ rules: rules.filter((rule) => rule !== undefined), world, random: seededRandom(seed) });
+
+for (const request of spawner.tick(tick)) {
+    world.create(request.identifier, request.position, request.spawnEvent);
+}
+```
+
+## The grammar
+
+A file is `{"format_version": "<semver>", "minecraft:spawn_rules": {description, conditions}}`.
+`description` carries `identifier` and `population_control`; `conditions` is a list of alternatives,
+and a rule allows a position when any one of them does.
+
+`parseSpawnRule` reads all 24 components `Spawn Rules.json` declares and reports an unknown one
+rather than refusing the file, so a pack written against a newer game still loads. Vanilla writes 21
+of the 24. The three it never writes, `minecraft:spawns_above_block_filter`,
+`minecraft:is_persistent` and `minecraft:is_experimental`, parse into the condition and keep their
+meaning for the caller, because Mojang documents none of them.
+
+Three components are written in more than one shape, and all of them read:
+
+- `minecraft:spawns_on_block_filter` as one name, as a list of names, or as a list of `{name}`
+  objects.
+- `minecraft:herd` as one object or as a list of alternatives, which is how the tropical fish picks
+  a color event.
+- `minecraft:biome_filter` as one test, as a bare array (an implicit `all_of`), or as a group map.
+  `@jsprismarine/packs` parses it, including the integer `subject` and `operator` encoding and the
+  `AND`, `OR` and `NOT` aliases.
+
+`minecraft:permute_type` entries read both spellings of their third field: the schema's
+`min_guaranteed` and the documentation page's `guaranteed_count`.
+
+## What a condition decides
+
+`evaluateSpawnCondition` runs the components cheapest first and names the first one that rejected
+the position, so a server can explain an empty attempt and a test can name the component it covers.
+
+| Component | What it compares |
+| --- | --- |
+| `minecraft:spawns_on_surface`, `minecraft:spawns_underground` | The pass the position is in. Naming both takes either; naming neither takes any. |
+| `minecraft:spawns_underwater`, `minecraft:spawns_lava` | The medium. Naming neither refuses a position inside either liquid. |
+| `minecraft:disallow_spawns_in_bubble` | A bubble column at the position. |
+| `minecraft:height_filter` | The position's Y against the inclusive range. |
+| `minecraft:spawns_on_block_filter`, `minecraft:spawns_on_block_prevented_filter` | The block one below the position. |
+| `minecraft:spawns_above_block_filter` | The `distance` blocks below the position. |
+| `minecraft:brightness_filter` | The light the world reports, lowered by the weather when `adjust_for_weather` is set. |
+| `minecraft:difficulty_filter` | The world difficulty against the inclusive range. |
+| `minecraft:world_age_filter` | The world age in ticks; a maximum of -1 is no upper bound. |
+| `minecraft:mob_event_filter` | Whether the named mob event is running. |
+| `minecraft:distance_filter` | The distance to the nearest player. |
+| `minecraft:player_in_village_filter` | A player within `distance` who is within `village_border_tolerance` of a village border. |
+| `minecraft:biome_filter` | The shared filter grammar, through the `@jsprismarine/entities` evaluator. |
+| `minecraft:density_limit` | How many entities of this type stand within `densityRadius`, per pass. |
+| `minecraft:delay_filter` | A cooldown keyed by the filter's `identifier`, then a `spawn_chance` roll. |
+
+The remaining six components are not gates. `minecraft:weight` and its `rarity` pick between the
+conditions that passed, `minecraft:herd` and `minecraft:permute_type` build the group, and
+`minecraft:spawn_event`, `minecraft:is_persistent` and `minecraft:is_experimental` describe what
+spawns.
+
+Three readings in that table are this project's, because Mojang states the component and not the
+rule. A condition that names neither liquid refuses a position inside one, which is what keeps cows
+out of the ocean. `minecraft:spawns_above_block_filter` scans downward, because an entity "above a
+block" stands on it. `rarity` is read as a one-in-N roll on top of the weight, which is the only
+reading under which a rarity of 3 makes a spawn rarer.
+
+## 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".
+`Spawner.tick(tick)` runs them for every pool whose cadence falls on that tick, and
+`Spawner.cycle(pool, tick)` runs one pool on demand.
+
+One cycle of one pool:
+
+1. Read the pool's cap. A `per_player` cap multiplies by the players in the region; a `per_region`
+   cap does not. A pool with no cap, which is the pillager pool, skips the check.
+2. For each player, sample `chunksPerCycle` chunks inside `spawnRadiusChunks`.
+3. In each chunk, try `positionsPerChunk` positions for the surface pass, where Y is
+   `SpawnWorld.surfaceY`, and the same number for the underground pass, where Y is drawn between
+   `SpawnWorld.minY` and the surface.
+4. At each position, collect every condition of every rule in the pool that passes, draw one
+   weighted by `minecraft:weight.default`, then apply its `rarity` roll.
+5. Draw a herd size inside the chosen `minecraft:herd` alternative, place the first member at the
+   position and the rest within `herdRadius`, following the terrain on the surface pass.
+6. Give each member its entity type and spawn event. `minecraft:permute_type` swaps the type, taking
+   its `min_guaranteed` members first and drawing the rest by weight, and the
+   `minecraft:pillager<minecraft:spawn_as_patrol_follower>` form splits into a type and an event.
+   The event is `initial_event` for the first `initial_event_count` members, then `event` for every
+   member past `event_skip_count`, then the permutation's own event, then
+   `minecraft:spawn_event`.
+7. Stop as soon as the pool reaches its cap, mid-herd if that is where the cap falls.
+
+`despawnReason` carries the two rules that belong to the population rather than to an entity: the
+published Y floor of -128, and the edge of the simulated region. The per-entity policy is
+`minecraft:despawn` in `@jsprismarine/entities`, which this package does not duplicate.
+
+## The injected seams
+
+`SpawnWorld` is the one interface the loop reads the world through, so a test drives the whole
+algorithm with a typed double and a server implements it once.
+
+- `site(flag, at)` answers the six site facts, each named by the component or filter test that
+  reads it: `surface`, `underground`, `underwater`, `lava`, `bubble_column` and `snow_covered`.
+- `block(at)`, `light(at)`, `biomeTags(at)` and `biome(at)` answer one position.
+- `surfaceY(x, z)` and `minY()` give the two passes their Y.
+- `players()`, `poolCount(pool)` and `typeCount(identifier, at, radius)` answer the caps and the
+  density limit.
+- `difficulty()`, `weather()`, `age()`, `mobEventActive(event)` and `villageBorderDistance(at)`
+  answer the rest.
+
+`RandomSource` from `@jsprismarine/predicates` is the only source of randomness, so one seed
+reproduces one set of spawns. `SpawnDelays` holds the `minecraft:delay_filter` cooldowns and a
+caller can persist it across a restart. `SpawnConstants` replaces the numbers below.
+
+## Which numbers Mojang publishes
+
+**None of the ones the algorithm needs.** Mojang documents the pool names and every component's
+parameters. Mojang publishes no spawn attempt rate, no cap value, no spawn radius, no herd placement
+rule, no density radius, and no statement of which light value `minecraft:brightness_filter`
+compares or what `adjust_for_weather` does to it. The research note
+[`docs/research/bedrock-entities-spawning-loot-trading.md`](../../docs/research/bedrock-entities-spawning-loot-trading.md)
+section 4 lists the gaps one by one.
+
+The one place numbers appear is the "Typical Cap" column of `EntitySpawningDeepDive.md`, and every
+entry there is hedged with a tilde: `animal` "~10 per player", `monster` "~70 in loaded chunks",
+`water_animal` "~5 per water body", `water_ambient` "~20 per water body", `ambient` "~15 in caves",
+`pillager` "Limited by patrols".
+
+So every number this package uses is this project's choice. They live in
+[`src/tables/spawnConstants.json`](src/tables/spawnConstants.json) rather than in code, each with a
+`source` string, so a reader can judge them and a host can replace the whole table through
+`SpawnerOptions.constants`.
+
+| Constant | Value | Where it came from |
+| --- | --- | --- |
+| `pools.animal.cap` | 10 per player | The tilde-hedged "~10 per player". |
+| `pools.water_animal.cap` | 5 per player | "~5 per water body". A water body is not a quantity this server tracks, so the cap counts per player. |
+| `pools.water_ambient.cap` | 20 per player | "~20 per water body". No vanilla rule names this pool. |
+| `pools.ambient.cap` | 15 per player | "~15 in caves". Only the bat uses this pool. |
+| `pools.monster.cap` | 70 per region | "~70 in loaded chunks", so it covers the region rather than scaling with players. |
+| `pools.cat.cap` | 5 per region | Mojang says only that cat limits are "based upon the amount within a village" and gives no number. |
+| `pools.pillager.cap` | none | "Limited by patrols", so `minecraft:delay_filter` and `minecraft:mob_event_filter` gate it instead. |
+| `pools.*.cycleTicks` | 400 for the calm pools, 20 for monsters and pillagers, 1200 for cats | Mojang publishes no rate. Java's animal pass runs every 400 ticks and its monster pass every tick; 20 is this project's cheaper monster cadence. |
+| `spawnRadiusChunks` | 4 | Bedrock's documented default simulation distance, because the ticking area documentation says spawning happens "in a radius centered on a player". |
+| `chunksPerCycle`, `positionsPerChunk` | 8 and 3 | This project's budget, picked so one player in an empty plains biome reaches the animal cap within a few cycles. |
+| `herdRadius` | 5 blocks | Java's horizontal pack spread. |
+| `densityRadius` | 16 blocks | One chunk's width, as this project's reading of the "certain locations" the density limit talks about. |
+| `rainDarkening`, `thunderDarkening` | 5 and 10 | Java's `Level.getSkyDarken` subtracts these under rain and thunder. |
+| `despawnRadiusChunks` | 8 | The 128 blocks of `minecraft:despawn.despawn_from_distance.max_distance`, the one published spawning distance. |
+| `despawnFloorY` | -128 | Published, and the same in both editions. |
+
+The project chose Bedrock's model over Java's deliberately.
+[`docs/plans/data-driven-vanilla.md`](../../docs/plans/data-driven-vanilla.md) section 12 decision 3
+records why: Java's model is implementable and invisible to a Bedrock client, and it would break
+every farm a Bedrock player has built.
+
+## Measured coverage
+
+Against the composed vanilla behavior pack of Bedrock Dedicated Server 1.26.51.1, through the corpus
+test in `src/vanillaSpawnRules.test.ts`:
+
+| Measure | Result |
+| --- | --- |
+| Spawn rule files composed | 60 |
+| Files that parse with no diagnostic | 60 |
+| Condition components the schema declares | 24, all parsed |
+| Condition components vanilla writes | 21, all evaluated |
+| Population pools in vanilla | `animal` 27, `monster` 24, `water_animal` 5, `pillager` 2, `cat` 1, `ambient` 1 |
+| Rules with no conditions | 4: blaze, cat, pillager, wither skeleton |
+| Biome filter tests left unanswered by the spawn filter context | 0 |
+
+The corpus test needs the sources that `pnpm --filter @jsprismarine/bedrock-data run fetch:sources`
+caches and runs only with `JSP_VANILLA_SPAWN_RULES` set:
+
+```sh
+JSP_VANILLA_SPAWN_RULES=1 pnpm --filter @jsprismarine/spawning exec vitest run src/vanillaSpawnRules.test.ts
+```
+
+## What a later agent adds
+
+- **The four rules with no conditions.** Blaze, cat, pillager and wither skeleton register a pool
+  and leave placement to engine code: fortress spawns, village cats and patrol placement. This
+  package spawns them wherever the pool cycle looks, which is wrong for all four.
+- **Structure-based spawn selection.** When the world supplies Java structure data, the spawner
+  suppresses a rule candidate if Java reserves that entity type exclusively for structure
+  overrides and the candidate is outside every matching structure. This keeps guardians out of
+  ordinary ocean water while leaving entities also listed in Java biome spawn tables eligible
+  outside structures. Structure overrides do not yet create spawn attempts or replace the biome
+  category's weighted selection.
+- **Measuring the constants.** Every number in the table above is replaceable, and a capture against
+  a running BDS would turn the guesses into measurements.

package/dist/conditions.cjs.cjs

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_world = require("./world.cjs.cjs");
+const require_constants = require("./constants.cjs.cjs");
+const require_rules = require("./rules.cjs.cjs");
+let _jsprismarine_entities = require("@jsprismarine/entities");
+// src/conditions.ts
+/**
+* The cooldowns `minecraft:delay_filter` keeps.
+*
+* The three pillager patrol conditions each name their own identifier, which
+* is how one per-difficulty cooldown exists per world rather than one per
+* condition.
+*/
+var SpawnDelays = class {
+	ready = /* @__PURE__ */ new Map();
+	/** The tick the named cooldown next allows a spawn, or undefined when it has never run. */
+	readyAt(identifier) {
+		return this.ready.get(identifier);
+	}
+	/** Sets the tick at which the named cooldown allows the next spawn. */
+	schedule(identifier, tick) {
+		this.ready.set(identifier, tick);
+	}
+	/** Draws a delay inside the filter's range and schedules it from `tick`. */
+	scheduleFrom(delay, tick, random) {
+		if (delay.identifier === void 0) return;
+		const span = Math.max(0, delay.max - delay.min);
+		this.schedule(delay.identifier, tick + delay.min + Math.floor(random.nextFloat() * (span + 1)));
+	}
+};
+var rejected = (component) => ({
+	passed: false,
+	rejectedBy: component
+});
+var PASSED = { passed: true };
+/**
+* Builds the filter context a `minecraft:biome_filter` reads.
+*
+* A spawn rule has no entity yet, so the `self` subject is the position: its
+* biome tags answer `has_biome_tag`, its biome answers `is_biome`, and its
+* site flags answer `is_snow_covered`, `is_underground`, `is_underwater` and
+* `in_lava`. Every other test the shared grammar allows goes unanswered and is
+* reported, which is what the engine does for a fact it cannot establish.
+*/
+var spawnFilterContext = (world, at) => {
+	return {
+		self: {
+			flag: (name) => {
+				switch (name) {
+					case "is_snow_covered": return world.site("snow_covered", at);
+					case "is_underground": return world.site("underground", at);
+					case "is_underwater":
+					case "in_water": return world.site("underwater", at);
+					case "in_lava": return world.site("lava", at);
+					default: return;
+				}
+			},
+			names: (name) => {
+				if (name === "has_biome_tag") return world.biomeTags(at);
+				if (name === "is_biome") {
+					const biome = world.biome?.(at);
+					return biome === void 0 ? void 0 : [biome];
+				}
+			}
+		},
+		world: {
+			difficulty: () => world.difficulty(),
+			weather: () => world.weather()
+		}
+	};
+};
+/** The light a brightness filter compares, after the darkening weather applies to it. */
+var brightnessAt = (world, at, adjustForWeather, constants) => {
+	const light = world.light(at);
+	if (!adjustForWeather) return light;
+	const weather = world.weather();
+	if (weather === "rain") return Math.max(0, light - constants.rainDarkening);
+	if (weather === "thunder") return Math.max(0, light - constants.thunderDarkening);
+	return light;
+};
+var difficultyRank = (difficulty) => require_rules.DIFFICULTIES.indexOf(difficulty);
+/** The distance from a position to the nearest player, or undefined when no player is loaded. */
+var nearestPlayerDistance = (world, at) => {
+	let best;
+	for (const player of world.players()) {
+		const distance = require_world.distanceSquared(player.position, at);
+		if (best === void 0 || distance < best) best = distance;
+	}
+	return best === void 0 ? void 0 : Math.sqrt(best);
+};
+var matchesBlock = (identifier, names) => identifier !== void 0 && names.includes(identifier);
+/**
+* Decides whether one condition allows a spawn at a position.
+*
+* The components run cheapest first, and the first one that rejects names
+* itself in the result. A condition that declares neither
+* `minecraft:spawns_underwater` nor `minecraft:spawns_lava` refuses a position
+* inside either liquid, which is the reading that keeps land mobs out of the
+* ocean; Mojang states the components and not that rule.
+*
+* @param requestedPass - The pass the spawn loop is evaluating, or absent to
+*   derive it from the world's site facts.
+*/
+var evaluateSpawnCondition = (condition, at, context, requestedPass) => {
+	const { world } = context;
+	const constants = context.constants ?? require_constants.SPAWN_CONSTANTS;
+	const pass = requestedPass ?? require_world.passAt(world, at);
+	if (condition.spawnsOnSurface || condition.spawnsUnderground) {
+		if (pass === "surface" && !condition.spawnsOnSurface) return rejected("minecraft:spawns_underground");
+		if (pass === "underground" && !condition.spawnsUnderground) return rejected("minecraft:spawns_on_surface");
+	}
+	const inWater = world.site("underwater", at);
+	const inLava = world.site("lava", at);
+	if (condition.spawnsUnderwater && !inWater) return rejected("minecraft:spawns_underwater");
+	if (condition.spawnsLava && !inLava) return rejected("minecraft:spawns_lava");
+	if (!condition.spawnsUnderwater && inWater) return rejected("minecraft:spawns_underwater");
+	if (!condition.spawnsLava && inLava) return rejected("minecraft:spawns_lava");
+	if (condition.disallowSpawnsInBubble && world.site("bubble_column", at)) return rejected("minecraft:disallow_spawns_in_bubble");
+	if (condition.height !== void 0 && (at.y < condition.height.min || at.y > condition.height.max)) return rejected("minecraft:height_filter");
+	if (condition.blocks !== void 0) {
+		if (!matchesBlock(world.block({
+			x: at.x,
+			y: at.y - 1,
+			z: at.z
+		}), condition.blocks)) return rejected("minecraft:spawns_on_block_filter");
+	}
+	if (condition.preventedBlocks !== void 0) {
+		if (matchesBlock(world.block({
+			x: at.x,
+			y: at.y - 1,
+			z: at.z
+		}), condition.preventedBlocks)) return rejected("minecraft:spawns_on_block_prevented_filter");
+	}
+	if (condition.aboveBlocks !== void 0) {
+		let found = false;
+		for (let depth = 1; depth <= condition.aboveBlocks.distance && !found; depth += 1) found = matchesBlock(world.block({
+			x: at.x,
+			y: at.y - depth,
+			z: at.z
+		}), condition.aboveBlocks.blocks);
+		if (!found) return rejected("minecraft:spawns_above_block_filter");
+	}
+	if (condition.brightness !== void 0) {
+		const light = brightnessAt(world, at, condition.brightness.adjustForWeather, constants);
+		if (light < condition.brightness.min || light > condition.brightness.max) return rejected("minecraft:brightness_filter");
+	}
+	if (condition.difficulty !== void 0) {
+		const rank = difficultyRank(world.difficulty());
+		if (rank < difficultyRank(condition.difficulty.min) || rank > difficultyRank(condition.difficulty.max)) return rejected("minecraft:difficulty_filter");
+	}
+	if (condition.worldAge !== void 0) {
+		const age = world.age();
+		if (age < condition.worldAge.min) return rejected("minecraft:world_age_filter");
+		if (condition.worldAge.max >= 0 && age > condition.worldAge.max) return rejected("minecraft:world_age_filter");
+	}
+	if (condition.mobEvent !== void 0 && !world.mobEventActive(condition.mobEvent)) return rejected("minecraft:mob_event_filter");
+	if (condition.distance !== void 0) {
+		const distance = nearestPlayerDistance(world, at);
+		if (distance === void 0 || distance < condition.distance.min || distance > condition.distance.max) return rejected("minecraft:distance_filter");
+	}
+	if (condition.playerInVillage !== void 0) {
+		const { distance, villageBorderTolerance } = condition.playerInVillage;
+		if (!world.players().filter((player) => require_world.distanceSquared(player.position, at) <= distance * distance).some((player) => {
+			const border = world.villageBorderDistance?.(player.position);
+			return border !== void 0 && border <= villageBorderTolerance;
+		})) return rejected("minecraft:player_in_village_filter");
+	}
+	if (condition.biomeFilter !== void 0) {
+		const options = {};
+		if (context.onUnanswered !== void 0) options.onUnanswered = context.onUnanswered;
+		if (!(0, _jsprismarine_entities.evaluateFilter)(condition.biomeFilter, spawnFilterContext(world, at), options)) return rejected("minecraft:biome_filter");
+	}
+	if (condition.density !== void 0) {
+		const limit = pass === "surface" ? condition.density.surface : condition.density.underground;
+		if (limit >= 0 && world.typeCount(context.identifier, at, constants.densityRadius) >= limit) return rejected("minecraft:density_limit");
+	}
+	if (condition.delay !== void 0) {
+		const identifier = condition.delay.identifier;
+		const readyAt = identifier === void 0 ? void 0 : context.delays?.readyAt(identifier);
+		if (readyAt !== void 0 && context.tick < readyAt) return rejected("minecraft:delay_filter");
+		if (context.random.nextFloat() * 100 >= condition.delay.spawnChance) return rejected("minecraft:delay_filter");
+	}
+	return PASSED;
+};
+exports.SpawnDelays = SpawnDelays;
+exports.evaluateSpawnCondition = evaluateSpawnCondition;
+exports.spawnFilterContext = spawnFilterContext;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"conditions.cjs.cjs","names":["DIFFICULTIES","distanceSquared","SPAWN_CONSTANTS","passAt","evaluateFilter"],"sources":["../src/conditions.ts"],"sourcesContent":["import type { EvaluateFilterOptions, FilterContext, FilterEntityView } from '@jsprismarine/entities';\nimport { evaluateFilter } from '@jsprismarine/entities';\nimport type { RandomSource } from '@jsprismarine/predicates';\n\nimport type { SpawnConstants } from './constants';\nimport { SPAWN_CONSTANTS } from './constants';\nimport type { Difficulty, SpawnCondition, SpawnDelay, SpawnRuleComponent } from './rules';\nimport { DIFFICULTIES } from './rules';\nimport type { SpawnPass, SpawnPosition, SpawnWorld } from './world';\nimport { distanceSquared, passAt } from './world';\n\n/**\n * Deciding whether one condition of a spawn rule allows a position.\n *\n * A rule's `conditions` are alternatives: the rule allows a position when any\n * one condition does. Each condition is a conjunction of its components, and\n * this module reports which component rejected a position so a server can\n * explain an empty spawn attempt and a test can name the component it covers.\n *\n * `minecraft:biome_filter` goes through the filter evaluator of\n * `@jsprismarine/entities`, because spawn rules, entity definitions and trade\n * tables share one filter grammar and one evaluator.\n */\n\n/** What one condition evaluation produced. */\nexport interface SpawnConditionResult {\n    readonly passed: boolean;\n    /** The first component that rejected the position, absent when the condition passed. */\n    readonly rejectedBy?: SpawnRuleComponent;\n}\n\n/** Reads the cooldowns `minecraft:delay_filter` keeps, keyed by its `identifier`. */\nexport interface SpawnDelayView {\n    /** The tick the named cooldown next allows a spawn, or undefined when it has never run. */\n    readyAt(identifier: string): number | undefined;\n}\n\n/**\n * The cooldowns `minecraft:delay_filter` keeps.\n *\n * The three pillager patrol conditions each name their own identifier, which\n * is how one per-difficulty cooldown exists per world rather than one per\n * condition.\n */\nexport class SpawnDelays implements SpawnDelayView {\n    private readonly ready = new Map<string, number>();\n\n    /** The tick the named cooldown next allows a spawn, or undefined when it has never run. */\n    public readyAt(identifier: string): number | undefined {\n        return this.ready.get(identifier);\n    }\n\n    /** Sets the tick at which the named cooldown allows the next spawn. */\n    public schedule(identifier: string, tick: number): void {\n        this.ready.set(identifier, tick);\n    }\n\n    /** Draws a delay inside the filter's range and schedules it from `tick`. */\n    public scheduleFrom(delay: SpawnDelay, tick: number, random: RandomSource): void {\n        if (delay.identifier === undefined) return;\n        const span = Math.max(0, delay.max - delay.min);\n        this.schedule(delay.identifier, tick + delay.min + Math.floor(random.nextFloat() * (span + 1)));\n    }\n}\n\n/** Everything one condition evaluation needs beyond the condition and the position. */\nexport interface SpawnConditionContext {\n    readonly world: SpawnWorld;\n    /** The entity the rule spawns, which `minecraft:density_limit` counts. */\n    readonly identifier: string;\n    readonly random: RandomSource;\n    /** The current world tick, which `minecraft:delay_filter` compares. */\n    readonly tick: number;\n    readonly constants?: SpawnConstants;\n    readonly delays?: SpawnDelayView;\n    /** Receives every biome filter test the evaluator could not answer. */\n    readonly onUnanswered?: EvaluateFilterOptions['onUnanswered'];\n}\n\nconst rejected = (component: SpawnRuleComponent): SpawnConditionResult => ({ passed: false, rejectedBy: component });\n\nconst PASSED: SpawnConditionResult = { passed: true };\n\n/**\n * Builds the filter context a `minecraft:biome_filter` reads.\n *\n * A spawn rule has no entity yet, so the `self` subject is the position: its\n * biome tags answer `has_biome_tag`, its biome answers `is_biome`, and its\n * site flags answer `is_snow_covered`, `is_underground`, `is_underwater` and\n * `in_lava`. Every other test the shared grammar allows goes unanswered and is\n * reported, which is what the engine does for a fact it cannot establish.\n */\nexport const spawnFilterContext = (world: SpawnWorld, at: SpawnPosition): FilterContext => {\n    const self: FilterEntityView = {\n        flag: (name) => {\n            switch (name) {\n                case 'is_snow_covered':\n                    return world.site('snow_covered', at);\n                case 'is_underground':\n                    return world.site('underground', at);\n                case 'is_underwater':\n                case 'in_water':\n                    return world.site('underwater', at);\n                case 'in_lava':\n                    return world.site('lava', at);\n                default:\n                    return undefined;\n            }\n        },\n        names: (name) => {\n            if (name === 'has_biome_tag') return world.biomeTags(at);\n            if (name === 'is_biome') {\n                const biome = world.biome?.(at);\n                return biome === undefined ? undefined : [biome];\n            }\n            return undefined;\n        }\n    };\n\n    return {\n        self,\n        world: { difficulty: () => world.difficulty(), weather: () => world.weather() }\n    };\n};\n\n/** The light a brightness filter compares, after the darkening weather applies to it. */\nconst brightnessAt = (\n    world: SpawnWorld,\n    at: SpawnPosition,\n    adjustForWeather: boolean,\n    constants: SpawnConstants\n): number => {\n    const light = world.light(at);\n    if (!adjustForWeather) return light;\n    const weather = world.weather();\n    if (weather === 'rain') return Math.max(0, light - constants.rainDarkening);\n    if (weather === 'thunder') return Math.max(0, light - constants.thunderDarkening);\n    return light;\n};\n\nconst difficultyRank = (difficulty: Difficulty): number => DIFFICULTIES.indexOf(difficulty);\n\n/** The distance from a position to the nearest player, or undefined when no player is loaded. */\nconst nearestPlayerDistance = (world: SpawnWorld, at: SpawnPosition): number | undefined => {\n    let best: number | undefined;\n    for (const player of world.players()) {\n        const distance = distanceSquared(player.position, at);\n        if (best === undefined || distance < best) best = distance;\n    }\n    return best === undefined ? undefined : Math.sqrt(best);\n};\n\nconst matchesBlock = (identifier: string | undefined, names: readonly string[]): boolean =>\n    identifier !== undefined && names.includes(identifier);\n\n/**\n * Decides whether one condition allows a spawn at a position.\n *\n * The components run cheapest first, and the first one that rejects names\n * itself in the result. A condition that declares neither\n * `minecraft:spawns_underwater` nor `minecraft:spawns_lava` refuses a position\n * inside either liquid, which is the reading that keeps land mobs out of the\n * ocean; Mojang states the components and not that rule.\n *\n * @param requestedPass - The pass the spawn loop is evaluating, or absent to\n *   derive it from the world's site facts.\n */\nexport const evaluateSpawnCondition = (\n    condition: SpawnCondition,\n    at: SpawnPosition,\n    context: SpawnConditionContext,\n    requestedPass?: SpawnPass\n): SpawnConditionResult => {\n    const { world } = context;\n    const constants = context.constants ?? SPAWN_CONSTANTS;\n    const pass = requestedPass ?? passAt(world, at);\n\n    if (condition.spawnsOnSurface || condition.spawnsUnderground) {\n        if (pass === 'surface' && !condition.spawnsOnSurface) return rejected('minecraft:spawns_underground');\n        if (pass === 'underground' && !condition.spawnsUnderground) return rejected('minecraft:spawns_on_surface');\n    }\n\n    const inWater = world.site('underwater', at);\n    const inLava = world.site('lava', at);\n    if (condition.spawnsUnderwater && !inWater) return rejected('minecraft:spawns_underwater');\n    if (condition.spawnsLava && !inLava) return rejected('minecraft:spawns_lava');\n    if (!condition.spawnsUnderwater && inWater) return rejected('minecraft:spawns_underwater');\n    if (!condition.spawnsLava && inLava) return rejected('minecraft:spawns_lava');\n\n    if (condition.disallowSpawnsInBubble && world.site('bubble_column', at))\n        return rejected('minecraft:disallow_spawns_in_bubble');\n\n    if (condition.height !== undefined && (at.y < condition.height.min || at.y > condition.height.max))\n        return rejected('minecraft:height_filter');\n\n    if (condition.blocks !== undefined) {\n        const below = world.block({ x: at.x, y: at.y - 1, z: at.z });\n        if (!matchesBlock(below, condition.blocks)) return rejected('minecraft:spawns_on_block_filter');\n    }\n\n    if (condition.preventedBlocks !== undefined) {\n        const below = world.block({ x: at.x, y: at.y - 1, z: at.z });\n        if (matchesBlock(below, condition.preventedBlocks))\n            return rejected('minecraft:spawns_on_block_prevented_filter');\n    }\n\n    if (condition.aboveBlocks !== undefined) {\n        // The component names no direction. \"Spawns above block\" reads as the\n        // entity standing above one of the blocks, so the scan runs downward\n        // from the position for `distance` blocks.\n        let found = false;\n        for (let depth = 1; depth <= condition.aboveBlocks.distance && !found; depth += 1) {\n            found = matchesBlock(world.block({ x: at.x, y: at.y - depth, z: at.z }), condition.aboveBlocks.blocks);\n        }\n        if (!found) return rejected('minecraft:spawns_above_block_filter');\n    }\n\n    if (condition.brightness !== undefined) {\n        const light = brightnessAt(world, at, condition.brightness.adjustForWeather, constants);\n        if (light < condition.brightness.min || light > condition.brightness.max)\n            return rejected('minecraft:brightness_filter');\n    }\n\n    if (condition.difficulty !== undefined) {\n        const rank = difficultyRank(world.difficulty());\n        if (rank < difficultyRank(condition.difficulty.min) || rank > difficultyRank(condition.difficulty.max))\n            return rejected('minecraft:difficulty_filter');\n    }\n\n    if (condition.worldAge !== undefined) {\n        const age = world.age();\n        if (age < condition.worldAge.min) return rejected('minecraft:world_age_filter');\n        if (condition.worldAge.max >= 0 && age > condition.worldAge.max) return rejected('minecraft:world_age_filter');\n    }\n\n    if (condition.mobEvent !== undefined && !world.mobEventActive(condition.mobEvent))\n        return rejected('minecraft:mob_event_filter');\n\n    if (condition.distance !== undefined) {\n        const distance = nearestPlayerDistance(world, at);\n        if (distance === undefined || distance < condition.distance.min || distance > condition.distance.max)\n            return rejected('minecraft:distance_filter');\n    }\n\n    if (condition.playerInVillage !== undefined) {\n        const { distance, villageBorderTolerance } = condition.playerInVillage;\n        const inRange = world.players().filter((player) => distanceSquared(player.position, at) <= distance * distance);\n        const nearVillage = inRange.some((player) => {\n            const border = world.villageBorderDistance?.(player.position);\n            return border !== undefined && border <= villageBorderTolerance;\n        });\n        if (!nearVillage) return rejected('minecraft:player_in_village_filter');\n    }\n\n    if (condition.biomeFilter !== undefined) {\n        const options: EvaluateFilterOptions = {};\n        if (context.onUnanswered !== undefined) options.onUnanswered = context.onUnanswered;\n        if (!evaluateFilter(condition.biomeFilter, spawnFilterContext(world, at), options))\n            return rejected('minecraft:biome_filter');\n    }\n\n    if (condition.density !== undefined) {\n        const limit = pass === 'surface' ? condition.density.surface : condition.density.underground;\n        if (limit >= 0 && world.typeCount(context.identifier, at, constants.densityRadius) >= limit)\n            return rejected('minecraft:density_limit');\n    }\n\n    if (condition.delay !== undefined) {\n        const identifier = condition.delay.identifier;\n        const readyAt = identifier === undefined ? undefined : context.delays?.readyAt(identifier);\n        if (readyAt !== undefined && context.tick < readyAt) return rejected('minecraft:delay_filter');\n        if (context.random.nextFloat() * 100 >= condition.delay.spawnChance) return rejected('minecraft:delay_filter');\n    }\n\n    return PASSED;\n};\n"],"mappings":"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"}

package/dist/conditions.d.ts

@@ -0,0 +1,81 @@
+import type { EvaluateFilterOptions, FilterContext } from '@jsprismarine/entities';
+import type { RandomSource } from '@jsprismarine/predicates';
+import type { SpawnConstants } from './constants';
+import type { SpawnCondition, SpawnDelay, SpawnRuleComponent } from './rules';
+import type { SpawnPass, SpawnPosition, SpawnWorld } from './world';
+/**
+ * Deciding whether one condition of a spawn rule allows a position.
+ *
+ * A rule's `conditions` are alternatives: the rule allows a position when any
+ * one condition does. Each condition is a conjunction of its components, and
+ * this module reports which component rejected a position so a server can
+ * explain an empty spawn attempt and a test can name the component it covers.
+ *
+ * `minecraft:biome_filter` goes through the filter evaluator of
+ * `@jsprismarine/entities`, because spawn rules, entity definitions and trade
+ * tables share one filter grammar and one evaluator.
+ */
+/** What one condition evaluation produced. */
+export interface SpawnConditionResult {
+    readonly passed: boolean;
+    /** The first component that rejected the position, absent when the condition passed. */
+    readonly rejectedBy?: SpawnRuleComponent;
+}
+/** Reads the cooldowns `minecraft:delay_filter` keeps, keyed by its `identifier`. */
+export interface SpawnDelayView {
+    /** The tick the named cooldown next allows a spawn, or undefined when it has never run. */
+    readyAt(identifier: string): number | undefined;
+}
+/**
+ * The cooldowns `minecraft:delay_filter` keeps.
+ *
+ * The three pillager patrol conditions each name their own identifier, which
+ * is how one per-difficulty cooldown exists per world rather than one per
+ * condition.
+ */
+export declare class SpawnDelays implements SpawnDelayView {
+    private readonly ready;
+    /** The tick the named cooldown next allows a spawn, or undefined when it has never run. */
+    readyAt(identifier: string): number | undefined;
+    /** Sets the tick at which the named cooldown allows the next spawn. */
+    schedule(identifier: string, tick: number): void;
+    /** Draws a delay inside the filter's range and schedules it from `tick`. */
+    scheduleFrom(delay: SpawnDelay, tick: number, random: RandomSource): void;
+}
+/** Everything one condition evaluation needs beyond the condition and the position. */
+export interface SpawnConditionContext {
+    readonly world: SpawnWorld;
+    /** The entity the rule spawns, which `minecraft:density_limit` counts. */
+    readonly identifier: string;
+    readonly random: RandomSource;
+    /** The current world tick, which `minecraft:delay_filter` compares. */
+    readonly tick: number;
+    readonly constants?: SpawnConstants;
+    readonly delays?: SpawnDelayView;
+    /** Receives every biome filter test the evaluator could not answer. */
+    readonly onUnanswered?: EvaluateFilterOptions['onUnanswered'];
+}
+/**
+ * Builds the filter context a `minecraft:biome_filter` reads.
+ *
+ * A spawn rule has no entity yet, so the `self` subject is the position: its
+ * biome tags answer `has_biome_tag`, its biome answers `is_biome`, and its
+ * site flags answer `is_snow_covered`, `is_underground`, `is_underwater` and
+ * `in_lava`. Every other test the shared grammar allows goes unanswered and is
+ * reported, which is what the engine does for a fact it cannot establish.
+ */
+export declare const spawnFilterContext: (world: SpawnWorld, at: SpawnPosition) => FilterContext;
+/**
+ * Decides whether one condition allows a spawn at a position.
+ *
+ * The components run cheapest first, and the first one that rejects names
+ * itself in the result. A condition that declares neither
+ * `minecraft:spawns_underwater` nor `minecraft:spawns_lava` refuses a position
+ * inside either liquid, which is the reading that keeps land mobs out of the
+ * ocean; Mojang states the components and not that rule.
+ *
+ * @param requestedPass - The pass the spawn loop is evaluating, or absent to
+ *   derive it from the world's site facts.
+ */
+export declare const evaluateSpawnCondition: (condition: SpawnCondition, at: SpawnPosition, context: SpawnConditionContext, requestedPass?: SpawnPass) => SpawnConditionResult;
+//# sourceMappingURL=conditions.d.ts.map

package/dist/conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../src/conditions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,aAAa,EAAoB,MAAM,wBAAwB,CAAC;AAErG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,KAAK,EAAc,cAAc,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE1F,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGpE;;;;;;;;;;;GAWG;AAEH,8CAA8C;AAC9C,MAAM,WAAW,oBAAoB;IACjC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,wFAAwF;IACxF,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;CAC5C;AAED,qFAAqF;AACrF,MAAM,WAAW,cAAc;IAC3B,2FAA2F;IAC3F,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACnD;AAED;;;;;;GAMG;AACH,qBAAa,WAAY,YAAW,cAAc;IAC9C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6B;IAEnD,2FAA2F;IACpF,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAErD;IAED,uEAAuE;IAChE,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAEtD;IAED,4EAA4E;IACrE,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAI/E;CACJ;AAED,uFAAuF;AACvF,MAAM,WAAW,qBAAqB;IAClC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,0EAA0E;IAC1E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,cAAc,CAAC;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IACjC,uEAAuE;IACvE,QAAQ,CAAC,YAAY,CAAC,EAAE,qBAAqB,CAAC,cAAc,CAAC,CAAC;CACjE;AAMD;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,UAAW,UAAU,MAAM,aAAa,KAAG,aA+BzE,CAAC;AAgCF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,cACpB,cAAc,MACrB,aAAa,WACR,qBAAqB,kBACd,SAAS,KAC1B,oBAuGF,CAAC"}