Data registry reference

Every directory a mod can ship under data/, one page per registry. A mod’s data/<dir>/ files declare and patch entries of the registry that owns <dir>. The data stage loads every mod’s files in load order, checks each reference with its file and line, and freezes the registries before the world ticks.

These pages are generated from the code: each registry’s RegistryEntry::DOC and the /// docs of its file schema. A test checks every schema against the types the registry decodes and against every bundled data file, so a page cannot drift from what the engine reads.

Files

File	Stage	Holds
`data/<dir>/*.ron`	declare	one entry, or a list of entries, each with `id: "<mod-id>:<name>"` in the mod’s own namespace
`data/<dir>/*.update.ron`	update	a list of `Patch(target: "<key>", ops: [..])` and `Declare(<entry>)` items; add `optional: true` to a patch whose target’s mod may be absent
`data/<dir>/*.final.ron`	final-fixes	`FinalFixes(reason: "…", patches: [..])`, after every mod’s updates; the reason is required

A patch’s ops are Set(path: [..], value: ..), Merge(path: [..], value: ..), Append(path: [..], value: [..]) and Remove(path: [..]). A path names fields from the entry’s root, with name[i] for a list element; see stages and order.

Registries

Entities

Directory	Registry	Sides	What
`archetypes/`	`manifold:archetype`	both	An archetype: a kind of entity, such as the player, a boar or a pet, with the components every instance carries and their default values.
`relationships/`	`manifold:relationship`	both	A relationship kind: a typed link from one entity to others, such as a pet’s `tamed-by` link to its owner.
`spatial-layers/`	`manifold:spatial-layer`	both	A layer of the spatial index, which answers “what is near here” queries for sensors, area hits and pickups.

World

Directory	Registry	Sides	What
`game-rules/`	`manifold:game-rule`	both	A game rule: a typed world setting, such as whether the sun moves or how many creatures may wander.

Gameplay

Directory	Registry	Sides	What
`abilities/`	`manifold:ability`	both	An ability: something an entity does, such as a sword swing, a rifle shot or a boar’s charge.
`cues/`	`manifold:cue`	both	A cue: a sound or particle effect gameplay plays for clients, such as a hit, a footstep or an ability’s telegraph.
`damage_formulas/`	`manifold:damage-formula`	both	A damage formula: how a hit’s base amount becomes the damage dealt, from the attacker’s and victim’s stats.
`damage_hooks/`	`manifold:damage-hooks`	server	A damage hook set: named data hooks an archetype carries, listed in its `manifold-gameplay:damage-hooks` component (armour by body region, a creature’s thick hide).
`damage_types/`	`manifold:damage-type`	both	A damage type: what kind of hit this is (a sword swing, a fall, a boar’s charge).
`effects/`	`manifold:effect`	both	An effect: a bag of parts applied to an entity.
`elements/`	`manifold:element`	both	An element: a kind of damage amount, such as fire or physical.
`equipment_slots/`	`manifold:equipment-slot`	both	An equipment slot, such as the main hand or the head.
`explosion_damage/`	`manifold:explosion-damage`	server	Explosion damage: what an explosion does to entities.
`factions/`	`manifold:faction`	both	A faction: a side entities take, and how it regards other factions (`Friendly`, `Neutral` or `Hostile`).
`gameplay/`	`manifold:gameplay-config`	both	The world’s gameplay settings: the default damage formula, faction and relation, which stat is loot luck, PvP, the tick rate durations convert with, and the effect and damage caps.
`impact_damage/`	`manifold:impact-damage`	server	Impact damage rules: how a character’s physics impacts (landing, hitting a wall, being struck or crushed) become damage, such as fall damage.
`items/`	`manifold:item-kind`	both	An item kind: what an item is.
`loot_tables/`	`manifold:loot-table`	server	A loot table: what a creature drops or a container holds, in Minecraft’s shape.
`predicates/`	`manifold:predicate`	both	A named predicate: a condition or number written once and reused by name.
`presentation/`	`manifold:presentation-field`	both	A presentation field: one value of the public `manifold-gameplay:presentation` component, which animation binding tables read (`Field(..)` and `Counter(..)` sources).
`stats/`	`manifold:stat`	both	A stat: a number an entity carries, such as health, strength or armour.
`tags/`	`manifold:tag`	both	A tag: a name in a dotted hierarchy (`mymod:state.charging`) that entities, effects, abilities and hits carry.

Directory	Registry	Sides	What
`awareness/`	`manifold-ai:awareness-profile`	server	An awareness profile: how an agent’s awareness of each thing it perceives rises and falls, from `Unaware` to `Engaged`.
`brains/`	`manifold-ai:brain`	server	A brain: how an AI agent decides what to do.
`curves/`	`manifold-ai:curve`	server	A response curve: a named shape that maps an input in 0..1 to a score in 0..1, which utility considerations and sensor falloff use.
`ai_lod/`	`manifold-ai:lod-profile`	server	An AI level-of-detail profile: how far from players an agent thinks at full rate, at reduced rate, or goes dormant, so distant creatures cost little.
`memories/`	`manifold-ai:memory-kind`	server	A memory kind: a typed slot an AI agent remembers, such as who last hurt it or the nearest dropped item.
`spawn_categories/`	`manifold-ai:spawn-category`	server	A spawn category: a population class, such as ambient creatures, with caps on how many may live near each player and in each 64-block region.
`spawn_rules/`	`manifold-ai:spawn-rule`	server	A spawn rule: what spawns, how often relative to other rules, where, and under which conditions (grass under open sky, at least 24 blocks from every player).
`spawners/`	`manifold-ai:spawner`	server	A spawner placed by content: a region of the world that keeps a number of creatures alive from its spawn rules, checking every few seconds and respawning after deaths.
`state_trees/`	`manifold-ai:state-tree`	server	A state tree: the steps of one AI activity, such as a pet’s fetch.
`styles/`	`manifold-ai:style`	server	A style: per-encounter rules over activity tags that change what agents choose, which activities they may pick (`allow`, `deny`) and how much each is worth (`scale`).
`locomotion/`	`manifold-nav:locomotion`	server	A locomotion profile: how a creature moves and how pathfinding plans for it.

Physics

Directory	Registry	Sides	What
`physical-materials/`	`manifold:physical-material`	both	A physical material: the bulk properties rigid-body physics needs, in SI units.

Registries without data files

These registries are in the data stage, but their entries come from code or assets, never from data/.

Registry	What
`manifold:binding-table`	The animation binding tables a mod ships as model assets (`*.bind.ron` under `assets/`), keyed by table id; `manifold-anim:anim-setup` names one. They are assets, never `data/` entries.
`manifold:component`	Every component, from its metadata: its fields, codec, replication and persistence. Components are declared in code (the engine’s, and a mod’s through its component declarations), never in `data/`; archetypes name them by key.

Reading a page

Sides. both: the server and every client load the registry, and the connection handshake’s data hash covers it, so both must have the same data. server: only the server loads it.
Fields. A required field must be written. An optional one may be left out and takes its default.
Types. string, bool, integers (u8 to i64) and f32 are written as RON literals. A type T or None may be written None, Some(x) or x. list of T is [a, b], map of K to V is {k: v}, and (A, B) is a tuple. Keys of other entries are strings ("flagship-game:boar"). Linked names are records and enums described on the same page.
Records are written Name(field: value, ..) or (field: value, ..); the name is optional.
Enums. A unit variant is written by name (Replace), a tuple variant Name(value, ..), and a record variant Name(field: value, ..). A record variant whose fields are all optional may be written by name alone.
Value forms are values the engine reads by hand, such as expressions and durations, described once below.

Value forms

`component-value`

A component’s value in that component’s own schema: a record of its fields ((asset: "mymod:creatures/boar")), or () for its defaults. Registry references are written as keys. In an archetype that has a parent, a value merges into the parent’s field by field; Replace(value) replaces it whole. See archetypes.

`condition`

A gameplay condition: Always, Never, Molang shorthand in a string ("q.stat('this', 'manifold:health') < 5"), or a typed record such as Present(KillerPlayer), Chance(0.1), Tags(..), Not(..) or All([..]). Where it is evaluated decides which context values it may read; reading one the context lacks is a load error. See the gameplay framework.

`duration`

A length of time: ticks as an integer (40), or seconds as a string ending in s ("1.5s"), rounded to the nearest tick when the data loads. See the gameplay framework.

`effect-duration`

How long an effect lasts: Instant, Infinite, For(<ticks>), For("1.5s"), For(ticks: <number>) or For(secs: <number>). Numbers are gameplay numbers, evaluated once when the effect applies. See the gameplay framework.

`effect-ref`

An effect to apply with this one: its key ("x:poison"), or (effect: "x:poison", level: <number>) to give the chained effect a level (the parent’s when left out). See the gameplay framework.

`float-or-param`

A number, or "$name": the brain parameter name from params, substituted when the brain compiles. See perception and brains.

`malus`

An extra path cost: an integer (8, negative to prefer the path type), or Impassable. See movement and navigation.

`number`

A gameplay number: a literal (4), Molang shorthand in a string ("2 * q.stat('attacker', 'x:strength')"), or a typed record such as Const(1) or Uniform(min: .., max: ..). Where it is evaluated decides which context values it may read. See the gameplay framework.

`part-args`

A registered effect part’s arguments, a record whose fields the part declares ((ticks: 60)); each is checked against the part’s argument types. See the gameplay framework.

`relation-mask`

One relation (Friendly, Neutral, Hostile) or a list of them ([Hostile, Neutral]). See the gameplay framework.

`reserved`

Reserved for a later phase: leave it out. Writing a value is an error that names the phase that brings it. See the gameplay framework.

`rule-value`

A game rule’s value, of the type its kind gives: true or false, an integer, a number, a string, a key of the named registry, or one of the enum’s names. See game rules.

`seconds`

Seconds: one number (2.0), or (min, max) for a value drawn between them each time ((2.0, 3.0)). See perception and brains.

`subject`

Whose values an expression or action uses: This, Attacker, DirectSource, Owner, Target, Killer or KillerPlayer, or the id of a subject another crate registered, as a string. Each is available only where its context provides it. See the gameplay framework.

`sweep-ticks`

How long a sweep runs: a duration (ticks, or "0.5s"), or Window("<name>"): while the caster’s animation window of that name is open, waiting at most the sweep’s timeout for it to open. See the gameplay framework.

`tag-match`

A tag key ("manifold:status.debuff"), which matches the tag and its descendants, or Exact("<tag>"), which matches that tag only. See the gameplay framework.

Keyboard shortcuts