@jsprismarine/spawning 0.0.0 → 0.16.0-unstable-20261029135432

package/dist/rules.es.js

@@ -0,0 +1,277 @@
+import { FilterParseError, parseFilter } from "@jsprismarine/packs";
+// src/rules.ts
+/**
+* The spawn rule grammar.
+*
+* A file is `{"format_version": "<semver>", "minecraft:spawn_rules": {...}}`,
+* and the body has `description` and `conditions`. Mojang's
+* `Spawn Rules.json` declares 24 condition components; vanilla writes 21 of
+* them. Parsing reports an unknown component rather than refusing the file, so
+* a pack written against a newer game still loads and the report names what
+* the runtime did not read.
+*/
+/** The pools `description.population_control` names, each with its own cap. */
+var POPULATION_POOLS = [
+	"animal",
+	"water_animal",
+	"water_ambient",
+	"ambient",
+	"monster",
+	"cat",
+	"pillager",
+	"villager"
+];
+/** The difficulty names `minecraft:difficulty_filter` compares, in ascending order. */
+var DIFFICULTIES = [
+	"peaceful",
+	"easy",
+	"normal",
+	"hard"
+];
+/**
+* Every condition component `Spawn Rules.json` declares, in the schema's
+* order. Vanilla writes 21 of the 24; `minecraft:spawns_above_block_filter`,
+* `minecraft:is_persistent` and `minecraft:is_experimental` appear in the
+* schema alone, so this package parses them and leaves their meaning to the
+* caller.
+*/
+var SPAWN_RULE_COMPONENTS = [
+	"minecraft:biome_filter",
+	"minecraft:brightness_filter",
+	"minecraft:delay_filter",
+	"minecraft:density_limit",
+	"minecraft:difficulty_filter",
+	"minecraft:disallow_spawns_in_bubble",
+	"minecraft:distance_filter",
+	"minecraft:height_filter",
+	"minecraft:herd",
+	"minecraft:is_experimental",
+	"minecraft:is_persistent",
+	"minecraft:mob_event_filter",
+	"minecraft:permute_type",
+	"minecraft:player_in_village_filter",
+	"minecraft:spawn_event",
+	"minecraft:spawns_above_block_filter",
+	"minecraft:spawns_lava",
+	"minecraft:spawns_on_block_filter",
+	"minecraft:spawns_on_block_prevented_filter",
+	"minecraft:spawns_on_surface",
+	"minecraft:spawns_underground",
+	"minecraft:spawns_underwater",
+	"minecraft:weight",
+	"minecraft:world_age_filter"
+];
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var KNOWN_COMPONENTS = new Set(SPAWN_RULE_COMPONENTS);
+var KNOWN_POOLS = new Set(POPULATION_POOLS);
+/** Reads a number, falling back when the key is absent or not a number. */
+var numberAt = (source, key, fallback) => {
+	const value = source[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+};
+var stringAt = (source, key) => {
+	const value = source[key];
+	return typeof value === "string" ? value : void 0;
+};
+var bodyOf = (value) => isRecord(value) ? value : {};
+/**
+* Reads a block list written as one name, as a list of names, or as a list of
+* `{name}` objects. All three appear in vanilla.
+*/
+var blockList = (value) => {
+	const members = Array.isArray(value) ? value : [value];
+	const names = [];
+	for (const member of members) if (typeof member === "string") names.push(member);
+	else if (isRecord(member) && typeof member.name === "string") names.push(member.name);
+	return names;
+};
+var difficultyAt = (source, key, fallback, fail) => {
+	const value = source[key];
+	if (value === void 0) return fallback;
+	const name = DIFFICULTIES.find((difficulty) => difficulty === value);
+	if (name !== void 0) return name;
+	fail(`minecraft:difficulty_filter ${key} is not a difficulty: ${JSON.stringify(value)}`);
+	return fallback;
+};
+var parseHerd = (value) => (Array.isArray(value) ? value : [value]).filter(isRecord).map((body) => {
+	const rule = {
+		minSize: numberAt(body, "min_size", 1),
+		maxSize: numberAt(body, "max_size", 1),
+		initialEventCount: numberAt(body, "initial_event_count", 0),
+		eventSkipCount: numberAt(body, "event_skip_count", 0)
+	};
+	const initialEvent = stringAt(body, "initial_event");
+	if (initialEvent !== void 0) rule.initialEvent = initialEvent;
+	const event = stringAt(body, "event");
+	if (event !== void 0) rule.event = event;
+	return rule;
+});
+var parsePermutations = (value) => (Array.isArray(value) ? value : []).filter(isRecord).map((body) => {
+	const permutation = {
+		weight: numberAt(body, "weight", 1),
+		minGuaranteed: numberAt(body, "min_guaranteed", numberAt(body, "guaranteed_count", 0))
+	};
+	const entityType = stringAt(body, "entity_type");
+	if (entityType !== void 0) permutation.entityType = entityType;
+	return permutation;
+});
+var parseCondition = (value, fail) => {
+	for (const key of Object.keys(value)) if (!KNOWN_COMPONENTS.has(key)) fail("spawnRule.unknownComponent", `unknown spawn rule component ${key}`);
+	const weightBody = bodyOf(value["minecraft:weight"]);
+	const condition = {
+		weight: {
+			default: numberAt(weightBody, "default", 1),
+			rarity: numberAt(weightBody, "rarity", 0)
+		},
+		herd: "minecraft:herd" in value ? parseHerd(value["minecraft:herd"]) : [],
+		spawnsOnSurface: "minecraft:spawns_on_surface" in value,
+		spawnsUnderground: "minecraft:spawns_underground" in value,
+		spawnsUnderwater: "minecraft:spawns_underwater" in value,
+		spawnsLava: "minecraft:spawns_lava" in value,
+		disallowSpawnsInBubble: "minecraft:disallow_spawns_in_bubble" in value,
+		isPersistent: "minecraft:is_persistent" in value,
+		isExperimental: "minecraft:is_experimental" in value
+	};
+	if ("minecraft:biome_filter" in value) try {
+		condition.biomeFilter = parseFilter(value["minecraft:biome_filter"]);
+	} catch (error) {
+		if (!(error instanceof FilterParseError)) throw error;
+		fail("spawnRule.badValue", `minecraft:biome_filter does not parse: ${error.message}`);
+	}
+	if ("minecraft:brightness_filter" in value) {
+		const body = bodyOf(value["minecraft:brightness_filter"]);
+		condition.brightness = {
+			min: numberAt(body, "min", 0),
+			max: numberAt(body, "max", 15),
+			adjustForWeather: body.adjust_for_weather === true
+		};
+	}
+	if ("minecraft:difficulty_filter" in value) {
+		const body = bodyOf(value["minecraft:difficulty_filter"]);
+		const report = (message) => fail("spawnRule.badValue", message);
+		condition.difficulty = {
+			min: difficultyAt(body, "min", "peaceful", report),
+			max: difficultyAt(body, "max", "hard", report)
+		};
+	}
+	if ("minecraft:height_filter" in value) {
+		const body = bodyOf(value["minecraft:height_filter"]);
+		condition.height = {
+			min: numberAt(body, "min", 24),
+			max: numberAt(body, "max", 128)
+		};
+	}
+	if ("minecraft:distance_filter" in value) {
+		const body = bodyOf(value["minecraft:distance_filter"]);
+		condition.distance = {
+			min: numberAt(body, "min", 24),
+			max: numberAt(body, "max", 128)
+		};
+	}
+	if ("minecraft:world_age_filter" in value) {
+		const body = bodyOf(value["minecraft:world_age_filter"]);
+		condition.worldAge = {
+			min: numberAt(body, "min", 0),
+			max: numberAt(body, "max", -1)
+		};
+	}
+	if ("minecraft:density_limit" in value) {
+		const body = bodyOf(value["minecraft:density_limit"]);
+		condition.density = {
+			surface: numberAt(body, "surface", -1),
+			underground: numberAt(body, "underground", -1)
+		};
+	}
+	if ("minecraft:spawns_on_block_filter" in value) condition.blocks = blockList(value["minecraft:spawns_on_block_filter"]);
+	if ("minecraft:spawns_on_block_prevented_filter" in value) condition.preventedBlocks = blockList(value["minecraft:spawns_on_block_prevented_filter"]);
+	if ("minecraft:spawns_above_block_filter" in value) {
+		const body = bodyOf(value["minecraft:spawns_above_block_filter"]);
+		condition.aboveBlocks = {
+			blocks: blockList(body.blocks),
+			distance: numberAt(body, "distance", 1)
+		};
+	}
+	if ("minecraft:permute_type" in value) condition.permutations = parsePermutations(value["minecraft:permute_type"]);
+	if ("minecraft:delay_filter" in value) {
+		const body = bodyOf(value["minecraft:delay_filter"]);
+		const delay = {
+			min: numberAt(body, "min", 0),
+			max: numberAt(body, "max", 0),
+			spawnChance: numberAt(body, "spawn_chance", 100)
+		};
+		const identifier = stringAt(body, "identifier");
+		if (identifier !== void 0) delay.identifier = identifier;
+		condition.delay = delay;
+	}
+	const mobEvent = stringAt(bodyOf(value["minecraft:mob_event_filter"]), "event");
+	if ("minecraft:mob_event_filter" in value && mobEvent !== void 0) condition.mobEvent = mobEvent;
+	const spawnEvent = stringAt(bodyOf(value["minecraft:spawn_event"]), "event");
+	if ("minecraft:spawn_event" in value && spawnEvent !== void 0) condition.spawnEvent = spawnEvent;
+	if ("minecraft:player_in_village_filter" in value) {
+		const body = bodyOf(value["minecraft:player_in_village_filter"]);
+		condition.playerInVillage = {
+			distance: numberAt(body, "distance", 0),
+			villageBorderTolerance: numberAt(body, "village_border_tolerance", 10)
+		};
+	}
+	return condition;
+};
+/**
+* Parses one `spawn_rules/*.json` file.
+*
+* @returns The rule, or undefined when the file is not a spawn rule or names
+* no identifier. Everything else loads and reports.
+*/
+var parseSpawnRule = (file, options) => {
+	const fail = (code, message) => {
+		const diagnostic = {
+			severity: "error",
+			code,
+			pack: options.pack,
+			message
+		};
+		if (options.path !== void 0) diagnostic.path = options.path;
+		options.report?.(diagnostic);
+	};
+	const warn = (code, message) => {
+		const diagnostic = {
+			severity: "warning",
+			code,
+			pack: options.pack,
+			message
+		};
+		if (options.path !== void 0) diagnostic.path = options.path;
+		options.report?.(diagnostic);
+	};
+	if (!isRecord(file) || !isRecord(file["minecraft:spawn_rules"])) {
+		fail("spawnRule.notASpawnRule", "the file has no `minecraft:spawn_rules` body");
+		return;
+	}
+	const body = file["minecraft:spawn_rules"];
+	const description = bodyOf(body.description);
+	const identifier = stringAt(description, "identifier");
+	if (identifier === void 0) {
+		fail("spawnRule.missingIdentifier", "`description.identifier` is missing");
+		return;
+	}
+	const rule = {
+		identifier,
+		conditions: []
+	};
+	const formatVersion = stringAt(file, "format_version");
+	if (formatVersion !== void 0) rule.formatVersion = formatVersion;
+	const pool = stringAt(description, "population_control");
+	if (pool !== void 0) {
+		rule.populationControl = pool;
+		if (!KNOWN_POOLS.has(pool)) warn("spawnRule.unknownPool", `unknown population_control ${pool}`);
+	}
+	const conditions = body.conditions;
+	if (conditions !== void 0) {
+		if (!Array.isArray(conditions)) fail("spawnRule.badValue", "`conditions` must be an array");
+		else rule.conditions = conditions.filter(isRecord).map((condition) => parseCondition(condition, fail));
+	}
+	return rule;
+};
+export { DIFFICULTIES, POPULATION_POOLS, SPAWN_RULE_COMPONENTS, parseSpawnRule };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"rules.es.js","names":[],"sources":["../src/rules.ts"],"sourcesContent":["import type { Diagnostic } from '@jsprismarine/entities';\nimport type { Filter } from '@jsprismarine/packs';\nimport { FilterParseError, parseFilter } from '@jsprismarine/packs';\n\n/**\n * The spawn rule grammar.\n *\n * A file is `{\"format_version\": \"<semver>\", \"minecraft:spawn_rules\": {...}}`,\n * and the body has `description` and `conditions`. Mojang's\n * `Spawn Rules.json` declares 24 condition components; vanilla writes 21 of\n * them. Parsing reports an unknown component rather than refusing the file, so\n * a pack written against a newer game still loads and the report names what\n * the runtime did not read.\n */\n\n/** The pools `description.population_control` names, each with its own cap. */\nexport const POPULATION_POOLS = [\n    'animal',\n    'water_animal',\n    'water_ambient',\n    'ambient',\n    'monster',\n    'cat',\n    'pillager',\n    'villager'\n] as const;\n\n/** One of {@link POPULATION_POOLS}. */\nexport type PopulationPool = (typeof POPULATION_POOLS)[number];\n\n/** The difficulty names `minecraft:difficulty_filter` compares, in ascending order. */\nexport const DIFFICULTIES = ['peaceful', 'easy', 'normal', 'hard'] as const;\n\n/** One of {@link DIFFICULTIES}. */\nexport type Difficulty = (typeof DIFFICULTIES)[number];\n\n/**\n * Every condition component `Spawn Rules.json` declares, in the schema's\n * order. Vanilla writes 21 of the 24; `minecraft:spawns_above_block_filter`,\n * `minecraft:is_persistent` and `minecraft:is_experimental` appear in the\n * schema alone, so this package parses them and leaves their meaning to the\n * caller.\n */\nexport const SPAWN_RULE_COMPONENTS = [\n    'minecraft:biome_filter',\n    'minecraft:brightness_filter',\n    'minecraft:delay_filter',\n    'minecraft:density_limit',\n    'minecraft:difficulty_filter',\n    'minecraft:disallow_spawns_in_bubble',\n    'minecraft:distance_filter',\n    'minecraft:height_filter',\n    'minecraft:herd',\n    'minecraft:is_experimental',\n    'minecraft:is_persistent',\n    'minecraft:mob_event_filter',\n    'minecraft:permute_type',\n    'minecraft:player_in_village_filter',\n    'minecraft:spawn_event',\n    'minecraft:spawns_above_block_filter',\n    'minecraft:spawns_lava',\n    'minecraft:spawns_on_block_filter',\n    'minecraft:spawns_on_block_prevented_filter',\n    'minecraft:spawns_on_surface',\n    'minecraft:spawns_underground',\n    'minecraft:spawns_underwater',\n    'minecraft:weight',\n    'minecraft:world_age_filter'\n] as const;\n\n/** One of {@link SPAWN_RULE_COMPONENTS}. */\nexport type SpawnRuleComponent = (typeof SPAWN_RULE_COMPONENTS)[number];\n\n/** An inclusive numeric range, as every `{min, max}` component writes one. */\nexport interface SpawnRange {\n    readonly min: number;\n    readonly max: number;\n}\n\n/** How often one condition is drawn against the others that pass at the same position. */\nexport interface SpawnWeight {\n    /** The relative weight; a weight of 100 among a total of 1000 is drawn a tenth of the time. */\n    readonly default: number;\n    /** An extra rarity roll Mojang documents by name only. Zero means no roll. */\n    readonly rarity: number;\n}\n\n/** One `minecraft:herd` alternative: how many spawn together and which events they run. */\nexport interface HerdRule {\n    readonly minSize: number;\n    readonly maxSize: number;\n    /** The event the first {@link initialEventCount} members run instead of their spawn event. */\n    readonly initialEvent?: string;\n    readonly initialEventCount: number;\n    /** The event every member past {@link eventSkipCount} runs. */\n    readonly event?: string;\n    readonly eventSkipCount: number;\n}\n\n/** One `minecraft:permute_type` entry: a weighted swap of the entity a herd member spawns as. */\nexport interface SpawnPermutation {\n    readonly weight: number;\n    /**\n     * The entity to spawn instead, optionally in the `type<event>` form. Absent\n     * means the rule's own entity, which is how vanilla writes the common branch.\n     */\n    readonly entityType?: string;\n    /** How many herd members this permutation takes before the weighted draw runs. */\n    readonly minGuaranteed: number;\n}\n\n/** The `minecraft:delay_filter` body: a cooldown shared by every rule naming the same identifier. */\nexport interface SpawnDelay {\n    readonly min: number;\n    readonly max: number;\n    /** The cooldown's name, which is how the three pillager patrol conditions keep separate timers. */\n    readonly identifier?: string;\n    /** The percent chance the attempt takes once the cooldown has elapsed. */\n    readonly spawnChance: number;\n}\n\n/** The `minecraft:player_in_village_filter` body. */\nexport interface PlayerInVillageFilter {\n    readonly distance: number;\n    readonly villageBorderTolerance: number;\n}\n\n/** The `minecraft:spawns_above_block_filter` body, which no vanilla rule writes. */\nexport interface AboveBlockFilter {\n    readonly blocks: readonly string[];\n    readonly distance: number;\n}\n\n/**\n * One member of `conditions`: a complete alternative set of requirements with\n * its own weight, herd and permutations. A rule passes at a position when any\n * one of its conditions does.\n */\nexport interface SpawnCondition {\n    readonly weight: SpawnWeight;\n    readonly biomeFilter?: Filter;\n    readonly brightness?: { readonly min: number; readonly max: number; readonly adjustForWeather: boolean };\n    readonly difficulty?: { readonly min: Difficulty; readonly max: Difficulty };\n    readonly height?: SpawnRange;\n    /** How far from the nearest player the position must be. */\n    readonly distance?: SpawnRange;\n    /** How many of this entity may already stand nearby, per pass; -1 is no limit. */\n    readonly density?: { readonly surface: number; readonly underground: number };\n    readonly worldAge?: SpawnRange;\n    readonly spawnsOnSurface: boolean;\n    readonly spawnsUnderground: boolean;\n    readonly spawnsUnderwater: boolean;\n    readonly spawnsLava: boolean;\n    readonly disallowSpawnsInBubble: boolean;\n    readonly isPersistent: boolean;\n    readonly isExperimental: boolean;\n    /** The blocks the position may stand on; an empty list means the component is absent. */\n    readonly blocks?: readonly string[];\n    /** The blocks the position may not stand on. */\n    readonly preventedBlocks?: readonly string[];\n    readonly aboveBlocks?: AboveBlockFilter;\n    readonly herd: readonly HerdRule[];\n    readonly permutations?: readonly SpawnPermutation[];\n    readonly delay?: SpawnDelay;\n    readonly mobEvent?: string;\n    /** The event a spawned entity runs instead of `minecraft:entity_spawned`. */\n    readonly spawnEvent?: string;\n    readonly playerInVillage?: PlayerInVillageFilter;\n}\n\n/** One parsed `spawn_rules/*.json`. */\nexport interface SpawnRule {\n    readonly identifier: string;\n    /** The pool whose cap gates this entity, absent when the file names none. */\n    readonly populationControl?: string;\n    readonly formatVersion?: string;\n    readonly conditions: readonly SpawnCondition[];\n}\n\n/** Where a parse reports its findings. */\nexport interface SpawnRuleParseOptions {\n    /** The pack the file came from, used in the diagnostics. */\n    readonly pack: string;\n    readonly path?: string;\n    readonly report?: (diagnostic: Diagnostic) => void;\n}\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n    typeof value === 'object' && value !== null && !Array.isArray(value);\n\nconst KNOWN_COMPONENTS: ReadonlySet<string> = new Set(SPAWN_RULE_COMPONENTS);\n\nconst KNOWN_POOLS: ReadonlySet<string> = new Set(POPULATION_POOLS);\n\n/** Reads a number, falling back when the key is absent or not a number. */\nconst numberAt = (source: Record<string, unknown>, key: string, fallback: number): number => {\n    const value = source[key];\n    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;\n};\n\nconst stringAt = (source: Record<string, unknown>, key: string): string | undefined => {\n    const value = source[key];\n    return typeof value === 'string' ? value : undefined;\n};\n\nconst bodyOf = (value: unknown): Record<string, unknown> => (isRecord(value) ? value : {});\n\n/**\n * Reads a block list written as one name, as a list of names, or as a list of\n * `{name}` objects. All three appear in vanilla.\n */\nconst blockList = (value: unknown): readonly string[] => {\n    const members = Array.isArray(value) ? value : [value];\n    const names: string[] = [];\n    for (const member of members) {\n        if (typeof member === 'string') names.push(member);\n        else if (isRecord(member) && typeof member.name === 'string') names.push(member.name);\n    }\n    return names;\n};\n\nconst difficultyAt = (\n    source: Record<string, unknown>,\n    key: string,\n    fallback: Difficulty,\n    fail: (message: string) => void\n): Difficulty => {\n    const value = source[key];\n    if (value === undefined) return fallback;\n    const name = DIFFICULTIES.find((difficulty) => difficulty === value);\n    if (name !== undefined) return name;\n    fail(`minecraft:difficulty_filter ${key} is not a difficulty: ${JSON.stringify(value)}`);\n    return fallback;\n};\n\nconst parseHerd = (value: unknown): readonly HerdRule[] =>\n    (Array.isArray(value) ? value : [value]).filter(isRecord).map((body) => {\n        const rule: {\n            minSize: number;\n            maxSize: number;\n            initialEvent?: string;\n            initialEventCount: number;\n            event?: string;\n            eventSkipCount: number;\n        } = {\n            minSize: numberAt(body, 'min_size', 1),\n            maxSize: numberAt(body, 'max_size', 1),\n            initialEventCount: numberAt(body, 'initial_event_count', 0),\n            eventSkipCount: numberAt(body, 'event_skip_count', 0)\n        };\n        const initialEvent = stringAt(body, 'initial_event');\n        if (initialEvent !== undefined) rule.initialEvent = initialEvent;\n        const event = stringAt(body, 'event');\n        if (event !== undefined) rule.event = event;\n        return rule;\n    });\n\nconst parsePermutations = (value: unknown): readonly SpawnPermutation[] =>\n    (Array.isArray(value) ? value : []).filter(isRecord).map((body) => {\n        const permutation: { weight: number; entityType?: string; minGuaranteed: number } = {\n            weight: numberAt(body, 'weight', 1),\n            // The schema calls it `min_guaranteed`; the docs page calls the same\n            // field `guaranteed_count`, so both spellings read.\n            minGuaranteed: numberAt(body, 'min_guaranteed', numberAt(body, 'guaranteed_count', 0))\n        };\n        const entityType = stringAt(body, 'entity_type');\n        if (entityType !== undefined) permutation.entityType = entityType;\n        return permutation;\n    });\n\nconst parseCondition = (\n    value: Record<string, unknown>,\n    fail: (code: string, message: string) => void\n): SpawnCondition => {\n    for (const key of Object.keys(value)) {\n        if (!KNOWN_COMPONENTS.has(key)) fail('spawnRule.unknownComponent', `unknown spawn rule component ${key}`);\n    }\n\n    const weightBody = bodyOf(value['minecraft:weight']);\n    const condition: {\n        -readonly [Key in keyof SpawnCondition]: SpawnCondition[Key];\n    } = {\n        // The schema marks `default` required and says nothing about a condition\n        // that writes no weight at all, so an absent weight counts once.\n        weight: { default: numberAt(weightBody, 'default', 1), rarity: numberAt(weightBody, 'rarity', 0) },\n        herd: 'minecraft:herd' in value ? parseHerd(value['minecraft:herd']) : [],\n        spawnsOnSurface: 'minecraft:spawns_on_surface' in value,\n        spawnsUnderground: 'minecraft:spawns_underground' in value,\n        spawnsUnderwater: 'minecraft:spawns_underwater' in value,\n        spawnsLava: 'minecraft:spawns_lava' in value,\n        disallowSpawnsInBubble: 'minecraft:disallow_spawns_in_bubble' in value,\n        isPersistent: 'minecraft:is_persistent' in value,\n        isExperimental: 'minecraft:is_experimental' in value\n    };\n\n    if ('minecraft:biome_filter' in value) {\n        try {\n            condition.biomeFilter = parseFilter(value['minecraft:biome_filter']);\n        } catch (error) {\n            if (!(error instanceof FilterParseError)) throw error;\n            fail('spawnRule.badValue', `minecraft:biome_filter does not parse: ${error.message}`);\n        }\n    }\n\n    if ('minecraft:brightness_filter' in value) {\n        const body = bodyOf(value['minecraft:brightness_filter']);\n        condition.brightness = {\n            min: numberAt(body, 'min', 0),\n            max: numberAt(body, 'max', 15),\n            adjustForWeather: body.adjust_for_weather === true\n        };\n    }\n\n    if ('minecraft:difficulty_filter' in value) {\n        const body = bodyOf(value['minecraft:difficulty_filter']);\n        const report = (message: string): void => fail('spawnRule.badValue', message);\n        condition.difficulty = {\n            min: difficultyAt(body, 'min', 'peaceful', report),\n            max: difficultyAt(body, 'max', 'hard', report)\n        };\n    }\n\n    if ('minecraft:height_filter' in value) {\n        const body = bodyOf(value['minecraft:height_filter']);\n        condition.height = { min: numberAt(body, 'min', 24), max: numberAt(body, 'max', 128) };\n    }\n\n    if ('minecraft:distance_filter' in value) {\n        const body = bodyOf(value['minecraft:distance_filter']);\n        condition.distance = { min: numberAt(body, 'min', 24), max: numberAt(body, 'max', 128) };\n    }\n\n    if ('minecraft:world_age_filter' in value) {\n        const body = bodyOf(value['minecraft:world_age_filter']);\n        condition.worldAge = { min: numberAt(body, 'min', 0), max: numberAt(body, 'max', -1) };\n    }\n\n    if ('minecraft:density_limit' in value) {\n        const body = bodyOf(value['minecraft:density_limit']);\n        condition.density = { surface: numberAt(body, 'surface', -1), underground: numberAt(body, 'underground', -1) };\n    }\n\n    if ('minecraft:spawns_on_block_filter' in value)\n        condition.blocks = blockList(value['minecraft:spawns_on_block_filter']);\n\n    if ('minecraft:spawns_on_block_prevented_filter' in value)\n        condition.preventedBlocks = blockList(value['minecraft:spawns_on_block_prevented_filter']);\n\n    if ('minecraft:spawns_above_block_filter' in value) {\n        const body = bodyOf(value['minecraft:spawns_above_block_filter']);\n        condition.aboveBlocks = { blocks: blockList(body.blocks), distance: numberAt(body, 'distance', 1) };\n    }\n\n    if ('minecraft:permute_type' in value) condition.permutations = parsePermutations(value['minecraft:permute_type']);\n\n    if ('minecraft:delay_filter' in value) {\n        const body = bodyOf(value['minecraft:delay_filter']);\n        const delay: { min: number; max: number; identifier?: string; spawnChance: number } = {\n            min: numberAt(body, 'min', 0),\n            max: numberAt(body, 'max', 0),\n            spawnChance: numberAt(body, 'spawn_chance', 100)\n        };\n        const identifier = stringAt(body, 'identifier');\n        if (identifier !== undefined) delay.identifier = identifier;\n        condition.delay = delay;\n    }\n\n    const mobEvent = stringAt(bodyOf(value['minecraft:mob_event_filter']), 'event');\n    if ('minecraft:mob_event_filter' in value && mobEvent !== undefined) condition.mobEvent = mobEvent;\n\n    const spawnEvent = stringAt(bodyOf(value['minecraft:spawn_event']), 'event');\n    if ('minecraft:spawn_event' in value && spawnEvent !== undefined) condition.spawnEvent = spawnEvent;\n\n    if ('minecraft:player_in_village_filter' in value) {\n        const body = bodyOf(value['minecraft:player_in_village_filter']);\n        condition.playerInVillage = {\n            distance: numberAt(body, 'distance', 0),\n            villageBorderTolerance: numberAt(body, 'village_border_tolerance', 10)\n        };\n    }\n\n    return condition;\n};\n\n/**\n * Parses one `spawn_rules/*.json` file.\n *\n * @returns The rule, or undefined when the file is not a spawn rule or names\n * no identifier. Everything else loads and reports.\n */\nexport const parseSpawnRule = (file: unknown, options: SpawnRuleParseOptions): SpawnRule | undefined => {\n    const fail = (code: string, message: string): void => {\n        const diagnostic: Diagnostic = { severity: 'error', code, pack: options.pack, message };\n        if (options.path !== undefined) diagnostic.path = options.path;\n        options.report?.(diagnostic);\n    };\n    const warn = (code: string, message: string): void => {\n        const diagnostic: Diagnostic = { severity: 'warning', code, pack: options.pack, message };\n        if (options.path !== undefined) diagnostic.path = options.path;\n        options.report?.(diagnostic);\n    };\n\n    if (!isRecord(file) || !isRecord(file['minecraft:spawn_rules'])) {\n        fail('spawnRule.notASpawnRule', 'the file has no `minecraft:spawn_rules` body');\n        return undefined;\n    }\n\n    const body = file['minecraft:spawn_rules'];\n    const description = bodyOf(body.description);\n    const identifier = stringAt(description, 'identifier');\n    if (identifier === undefined) {\n        fail('spawnRule.missingIdentifier', '`description.identifier` is missing');\n        return undefined;\n    }\n\n    const rule: { -readonly [Key in keyof SpawnRule]: SpawnRule[Key] } = { identifier, conditions: [] };\n\n    const formatVersion = stringAt(file, 'format_version');\n    if (formatVersion !== undefined) rule.formatVersion = formatVersion;\n\n    const pool = stringAt(description, 'population_control');\n    if (pool !== undefined) {\n        rule.populationControl = pool;\n        if (!KNOWN_POOLS.has(pool)) warn('spawnRule.unknownPool', `unknown population_control ${pool}`);\n    }\n\n    const conditions = body.conditions;\n    if (conditions !== undefined) {\n        if (!Array.isArray(conditions)) {\n            fail('spawnRule.badValue', '`conditions` must be an array');\n        } else {\n            rule.conditions = conditions.filter(isRecord).map((condition) => parseCondition(condition, fail));\n        }\n    }\n\n    return rule;\n};\n"],"mappings":"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"}