Content types

<!-- GENERATED by ContentTypeDocs from the registered type schemas; do not edit. Regenerate with ./gradlew generateContentDocs. -->

Every scripted content kind: the folder its files live in, the generic types a file picks with "type", the fields and hooks each type takes, and the old type ids kept as aliases.

• The file name is the id. data/<namespace>/<folder>/<any folders>/<id>.json (or .js) defines <namespace>:<id>; folders only organise. A family .js file may define several ids, naming each.
• A .js file calls its kind's global once: item("thematic:weapon", item => { item.set({...}); item.onHit(hit => ...); }). set takes the type's fields; each hook is a builder method (on_hit is onHit) whose callback is handed the same Actions an ability's callbacks are, so every verb in thematic.d.ts works there. use(id, options) applies a preset from content_prefabs. The script runs once, at load, and builds the JSON a file would hold.
• A hook in a file is an action list, "on_use": [ ... ], or "on_use": { "cooldown": 2, "if": {guard}, "every": 5, ...options, "do": [ ... ] }.
• Reload vs restart. /reload re-reads behaviour (hooks, stats, looks). A field marked identity changes what gets registered; changing it needs a restart, and a reload says so.

content_prefabs#

data/<namespace>/content_prefabs/, script global preset.

Preset libraries: data/<namespace>/content_prefabs/<any folders>/<file>.js. A file declares any number of presets, preset(id, { kind, doc, options }, (def, options) => { ... }), each a bundle of fields and hooks a definition of that kind applies by name with def.use(id, options). The function is handed the definition's own builder, so it calls the same set() and hook methods the file would. A bare id is thematic:.

content_samples#

data/<namespace>/content_samples/, script global contentSample, default type thematic:noop.

A sample kind that proves the scripted-content pipeline end to end; the engine ships no files of it. data/<namespace>/content_samples/<any folders>/<id>.json or .js.

thematic:noop#

Does nothing: its fields are read and kept, and its hook's actions run when the engine fires on_trigger, which nothing does.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

Traits: sample_marker: no effect; shows where a type documents the traits it reads.

• Alias thematic:noop_legacy: a definition naming it loads as thematic:noop with {"note":"legacy"} under its own fields.

status_effects#

data/<namespace>/status_effects/, script global statusEffect, default type thematic:status_effect (registers at startup).

Status effects: data/<namespace>/status_effects/<any folders>/<id>.json or .js. The file name is the effect's id (status_effects/stun.json is thematic:stun). Each id registers its own status effect at startup, so a new one, or a changed category, colour, attribute modifier or stun flag, needs a restart; everything else reloads with /reload. How the effect looks on a suit is an effect_visuals file of the same id.

thematic:status_effect#

A status effect. Every field but category is optional; a file with only a category is an effect that does nothing but show (a marker other code or moves ask about).

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

damage_elements#

data/<namespace>/damage_elements/, script global damageElement, default type thematic:element.

What a hit can be made of, for the weakness, resistance and immunity system: data/<namespace>/damage_elements/<any folders>/<id>.json or .js. The file name is the element's word (damage_elements/fire.json is "fire", the word suits, ability options and the element option use). The damage types themselves stay vanilla damage_type JSON; an element says which of them, and which damage-type tags, count as it. A hit also counts when its type is in the tag <namespace>:is_<id> (when the element has a damage_type) or <namespace>:compat/<mod>/<id> (while that compat module bridges damage types). Read on each side at startup and reloaded with /reload; a pack overrides an engine element by writing the same id.

thematic:element#

One damage element: what counts as it, and the colour it is shown in. An element with none of damage_type, tags and types is never matched, like "none".

vfx#

data/<namespace>/vfx/, script global vfxPreset, default type thematic:burst.

Named effects the vfx action plays: data/<namespace>/vfx/<any folders>/<id>.json or .js. The file name is the id (vfx/sonar_beam.json is thematic:sonar_beam); the old upper-case preset names still find them ("SONAR_BEAM" is thematic:sonar_beam). Read on the server, which sends the finished effect to every client near it, and reloaded with /reload.

thematic:ring#

Draws a ring of radius, height tall, on every client that can see it, for duration ticks.

thematic:dome#

Draws a dome of radius, height tall, on every client that can see it, for duration ticks.

thematic:sphere#

Draws a ball of radius, on every client that can see it, for duration ticks.

thematic:column#

Draws a column of radius, height long, along its direction (up when none), on every client that can see it, for duration ticks.

thematic:beam#

Draws a beam height long along its direction (up when none), radius thick; played at a point it runs there, on every client that can see it, for duration ticks.

thematic:tornado#

Draws a funnel of radius, height tall, about its direction, on every client that can see it, for duration ticks.

thematic:helix#

Draws two strands wound about its direction, radius out and height long, on every client that can see it, for duration ticks.

thematic:burst#

Draws a burst out to radius, on every client that can see it, for duration ticks.

thematic:atmospheric#

Draws particles drifting through radius, on every client that can see it, for duration ticks.

thematic:smoke_cloud#

Draws a cloud of smoke of radius, on every client that can see it, for duration ticks.

thematic:puddle#

Draws a flat pool of radius on the ground, on every client that can see it, for duration ticks.

thematic:wall#

Draws a standing sheet radius wide either side of the point, along its direction, height tall, on every client that can see it, for duration ticks.

thematic:trail#

Draws a ribbon from the point along its direction for height, arcing up to radius / 2, on every client that can see it, for duration ticks.

thematic:fog_layers#

Draws stacked translucent fog banks of radius, spread over height from the feet up, each turning and drifting at its own pace, with wisps rising out of them; they fade in, hang, then thin out, on every client that can see it, for duration ticks.

thematic:bolt#

Draws a bolt, on every client that can see it, for duration ticks.

thematic:flame_pillar#

Draws a pillar of dark-hearted fire bursting height up out of the ground along its direction (up when none), radius wide, with a flash at its foot, tongues and rising embers; it shoots up, roars, then sinks and fades. color is its burning rim, the heart a dim shade of it, on every client that can see it, for duration ticks.

thematic:bat_swarm#

Draws density vanilla bats (the bat model and skin, or texture's), drawn on the client with no entities: radius out from the point, flying through height from the point up, lit by the world and tinted color ("#FFFFFFFF" shows the skin as it is); motion says how they fly, on every client that can see it, for duration ticks.

thematic:bubble#

Draws a force-field bubble of radius about the point (lift raises it): a hex lattice of glowing lines, nearly clear where it faces the eye and bright towards its rim (color, its top byte the opacity, shading to rim_color), with a light band sweeping across the cells and ripples wherever a projectile crosses it or the body it follows is struck; motes may swirl into a glowing core or rise through it. It swells from grow of its radius over form seconds, holds for duration ticks (or, held under a session, until stopped) and then ends over release seconds as end says, on every client that can see it, for duration ticks.

thematic:pane#

Draws an upright, nearly clear plate of force radius wide either side of the point and height tall, facing its direction (the vfx action's direction: "look" faces it the wearer's way; up is ignored): faint fill, a sliding sheen and softly glowing edges. Wherever a projectile crosses it, from either side, it flashes and a ring runs out uncovering a hex pattern of cell blocks. It unfolds up from the floor over form seconds and fades over release seconds after duration ticks or once stopped, on every client that can see it, for duration ticks.

thematic:tiles#

Draws loose flat hex tiles, cell blocks across, at most density of them, laid out as layout says: ring (rings of tiles running out over the ground, each flipping up as the front passes), floor (a disc of tiles over the whole radius that peel up into the air height blocks, one by one, and come back down), swirl (streams of tiles spiralling in towards a bright core, with a tiled disc on the ground), spray (tiles flung out along the ground and up, tumbling, with a flash), wave (shells of tiles in a cone of arc degrees along the direction, each lighting as a front sweeps out to radius) or pull (a wave whose front sweeps in), on every client that can see it, for duration ticks.

thematic:shock_ring#

Draws a concussive air burst standing across its direction (up when none): a flat front with a soft near-white condensation rim over a dusty wake races out to radius while travelling height along the direction (0 for one lying on the ground), with a faint cone back to the point when height is above 0; density is how many segments round it, so how smooth; lit by the world, tinted color (its alpha is how thick the front is), on every client that can see it, for duration ticks.

thematic:ground_fracture#

Draws the ground split open: density jagged cracks run out from a crushed centre to radius, forking and joined by broken rings, each a dark seam (color) in a pale lip of dust, flat where it is played and lit by the world; they race out over the first ticks, sit, and fade at the end. With glow the seams burn in color instead, on every client that can see it, for duration ticks.

thematic:dust_burst#

Draws density soft, ragged dust billows thrown out low along the ground to radius, dragging to a stop as they swell and thin, with a heavier plume over the centre climbing to height; lit by the world, tinted color (its alpha is how thick the dust is), texture laid across each billow if named, on every client that can see it, for duration ticks.

thematic:impact_lines#

Draws comic-book speed lines bursting off the point in a flat star turned to the viewer: density streaks race out to radius from a hot flash, then thin away; color tints their tails, the heads are white, on every client that can see it, for duration ticks.

thematic:pressure_wave#

Draws a narrow cone of vapour thrown along its direction (up when none), radius across at the far end and height long: three soft bands race off the tip with streaks along the skin; lit by the world, tinted color (its alpha is how thick the vapour is); density is how many streaks, on every client that can see it, for duration ticks.

thematic:shards#

Draws density faceted crystal shards (at most 64) bursting out of a column height tall and radius / 5 wide at the point, flung about radius out, tumbling, falling with gravity and lying where they land until they fade at the end; color tints them and its alpha is how clear they are, glow draws them as light instead, on every client that can see it, for duration ticks.

thematic:flare#

Draws a starburst glint facing the camera: density spikes (4 to 16, long and short in turn) radius long round a white-hot core, a flat shock ring racing out and a level streak across it; it flares in its first quarter and fades out, a parry's or a struck guard's flash, on every client that can see it, for duration ticks.

thematic:implode#

Draws density streaks (4 to 24) rushing in to the point from radius out over the first half of its life, then a jagged crack-star and a flash popping out of it: a crush, a snap, something squeezed until it breaks, on every client that can see it, for duration ticks.

thematic:fissure#

Draws density jagged cracks (3 to 12) torn across the ground from the point, each up to radius long and height wide at its root and forking once, round a dark broken patch; they rip open in the first eighth of its life with rims glowing color, cool to dark gashes and fade at the end. Lies flat on the level of the point, on every client that can see it, for duration ticks.

thematic:lock_on#

Draws corner brackets snapping in round a body and locking onto it, with a turning diamond at its middle and a broken ring at its feet: sized to the body it follows (vfx follow), else radius wide either side and height tall from the point. color is the brackets, a lighter shade the diamond, on every client that can see it, for duration ticks.

thematic:flame_curtain#

Draws a closed ring wall of fire radius round the point and height tall, dense enough to read as solid: an alpha-blended body of churning flame under counter-turning sheets of additive fire, tongues licking off a jagged top, a glow on the ground and embers rising; it rises in its first rise share of life, turns, heats from color to hot_color, then shrinks in and sputters out over its last fall share, on every client that can see it, for duration ticks.

thematic:fire_bubble#

Draws a ball of boiling fire swelling from the point out to radius over all but its last fall share of life: a seething shell brightest at its rim, color, round a white-hot hot_color flash that fades as it grows, corona tongues flicking off it and a shock ring racing over the ground under it (give it lift to centre it above the point), on every client that can see it, for duration ticks.

thematic:flame_dome#

Draws a standing hemisphere of fire radius round the point: flames climb the shell from the ground and burn out toward its crown, hot_color at its foot fading through color, over a faint smoky body, tongues licking up round its rim and embers rising; it breathes slowly, flares in over its rise share and dies away over its fall share, on every client that can see it, for duration ticks.

thematic:strand_dome#

Draws a dome of web, radius out and height up (0.7 of radius when height is 0): density sets how many anchors ring its edge (6-20); a sheet splats over the floor with holes and heaped gobs, short strands glue its edge down, and every living body inside is draped in a shroud of web where it stands; it sags and collapses over its last 0.4 seconds. color is the web (its alpha the opacity), glow adds it as light, on every client that can see it, for duration ticks.

thematic:rope#

Draws a twisted line of thin white strands from the point along its direction, height long, that shoots out over its first ticks, sags a little and fades over its last 40%; color tints it (white leaves it as it is), on every client that can see it, for duration ticks.

thematic:strand_burst#

Draws density web strands thrown out of the point in every direction (more up than down), up to radius long, each shooting out over its first ticks, sagging a little and fading over its last 40%; color tints them (white leaves them as they are), on every client that can see it, for duration ticks.

thematic:fractal_bolt#

Draws a comic-book storm bolt from height above the point down to it: a zigzag of a few sharp straight stretches swinging about radius sideways with hard-angled forks that end in points, drawn in flat bands (a white core_color core, a glow_color band, a deeper rim) over a faint color bloom; it strikes for flash ticks, holding a pose for 3 ticks then snapping to a new shape, with a starburst and krackle dots where it lands, then hangs for afterglow ticks as its core dies and it thins; with scorch a dark cracked starburst stays on the ground under it for the rest of its life. Held (loop or hold) it crackles on as a standing column, re-snapping every 3 ticks, on every client that can see it, for duration ticks.

thematic:fork_wall#

Draws a rolling wall of zigzag bolts radius either side of the point across its direction and height tall: density bolts side by side, stood on the ground and leaning into the way it goes, linked by arcs, their forks sweeping forward, krackle dots at their feet; moving (a wave's vfx), it leaves fading bolts behind it. With ground it lies along the floor instead: zigzags crawling across its lane, forks stabbing down. Poses hold 3 ticks; it fades over its last afterglow ticks, on every client that can see it, for duration ticks.

thematic:fork_burst#

Draws zigzag bolts racing out along the ground from the point to radius over flash ticks, lengthening in steps (density / 4 of them, at most 8), krackle dots riding their heads and boiling at the middle where a starburst pops; then they hang for afterglow ticks and, with scorch, leave a cracked dark starburst with streaks along the bolts. No dome or ring, on every client that can see it, for duration ticks.

thematic:fork_cloud#

Draws a dark swirling cloud disc radius wide hung height above the point (density puffs, the middle turning faster than the rim) that fades in over half a second, with bolts stubbing down out of its underside and flashing it as they snap; use it held (hold or loop, with a session and follow), on every client that can see it, for duration ticks.

thematic:particle_system#

One of Thematic's particle systems, spawned once where it is played. Each system reads the numbers below its own way, and some ignore them (see system); a particle system has no session and no direction.

blocks#

data/<namespace>/blocks/, script global block, default type thematic:solid (registers at startup).

Blocks: data/<namespace>/blocks/<any folders>/<id>.json or .js registers the block <namespace>:<id> and its block item. Blocks are registry entries, read once at startup from mod jars, the dev tree and thematic/packs: a new block or a changed identity field needs a restart. The type is the block's shape and rules (a vanilla shape: solid, slab, stairs, wall, door...); a .json file names it (or a parent that does), a script's block(def => ...) is solid when it names none. Its model, blockstate, loot table and lang lines are ordinary resource files under the same id.

Fields every type takes:

thematic:solid#

A full cube with no state (vanilla's plain Block): stone, planks, an ore. The default type.

thematic:glass#

A full see-through cube of glass; neighbours draw no face between them. Pair with render_layer translucent.

thematic:slab#

A slab (vanilla's SlabBlock): top, bottom or double, waterloggable. Its loot table decides that a double slab drops two.

thematic:stairs#

Stairs (vanilla's StairsBlock): faces the way it is placed, joins its neighbours into corners, waterloggable.

thematic:wall#

A wall (vanilla's WallBlock): posts and low or tall sides joining its neighbours. List it in the minecraft:walls tag so others join it.

thematic:fence#

A fence (vanilla's FenceBlock): joins its neighbours, a leash ties to it. List it in minecraft:fences (and minecraft:wooden_fences for wood) so others join it.

thematic:fence_gate#

A fence gate (vanilla's FenceGateBlock): opens by hand or redstone, drops into a wall. Its sounds follow wood_type.

thematic:door#

A door (vanilla's DoorBlock): two blocks tall, opens by hand when its block_set allows (iron does not) and by redstone. Always non-opaque; breaks when a piston pushes it.

thematic:trapdoor#

A trapdoor (vanilla's TrapdoorBlock): top or bottom half, opens by hand when its block_set allows and by redstone, waterloggable. Always non-opaque.

thematic:pane#

A pane or bars (vanilla's PaneBlock): a thin cross joining its neighbours, waterloggable. Always non-opaque.

thematic:pillar#

A pillar (vanilla's PillarBlock): a log-like block along the axis it is placed on; strips_to needs one.

thematic:ladder#

A ladder (vanilla's LadderBlock): climbable, on a wall, waterloggable. Always non-opaque. List it in minecraft:climbable so it can be climbed.

thematic:chain#

A chain (vanilla's ChainBlock): a thin post along its axis, waterloggable. Always non-opaque.

thematic:button#

A button (vanilla's ButtonBlock): on a floor, wall or ceiling, gives a redstone pulse when pressed. No collision; breaks when pushed. Its sounds follow block_set.

thematic:pressure_plate#

A pressure plate (vanilla's PressurePlateBlock): powered while something stands on it. No collision; breaks when pushed. Its sounds follow block_set.

thematic:lightning_rod#

A lightning rod (vanilla's LightningRodBlock): draws lightning strikes near it and gives a redstone pulse when struck, waterloggable. Always non-opaque.

thematic:carpet#

A carpet (vanilla's CarpetBlock): one pixel high, needs a block under it.

thematic:furniture#

Furniture: a block with its own shape (written once, facing north, in pixels) that faces the way it is placed, stands on the floor or hangs on a wall or ceiling, and may be waterlogged or sat on. Always non-opaque. Its model is an ordinary blockstate and model the pack ships, turned per facing.

thematic:behavior#

A block with behaviour: a furniture block (every furniture field: its shape, facing, attach, seat...) that runs action lists at its moments (on_use, on_step, on_inside, on_collide, on_random_tick, on_scheduled_tick, on_break, on_neighbor, on_projectile_hit) with the verbs abilities and items use, may declare state properties of its own for its hooks to read and set, and takes the behaviour options (contact, ambient_particles, redstone, spread, layers, lift_column, jukebox, furnace). Hooks run on the server; the hooks, stats, contact, ambient_particles and spread reload with /reload, the rest needs a restart. Non-opaque unless opaque says otherwise; a furnace's block entity draws the block-entity visuals.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

thematic:lift_column#

A lift column: the air-like block a lift-column source (a block with lift_column naming this one) fills the carrier blocks stacked above it with. Whoever stands in it is lifted (above a source_up block) or lowered (above a source_down block), as in a bubble column; it puffs particles at its top, stands only on itself or a source, turns back into the carrier when the source goes, and has no collision. Adds the drag state property (true lowers).

thematic:brushable#

A suspicious block: a brush uncovers the loot its block entity holds (set the vanilla way: a structure, or a LootTable tag), it falls like sand, and once brushed clean it becomes base_block. Adds the dusted state property (0-3). Start it from vanilla's with "copy": "minecraft:suspicious_sand".

thematic:container#

A container: a furniture block (every furniture field but seat: its shape, facing, attach...) with a storage of its own that players open with a screen (the chest screen of its rows, or one the engine bound), as Thematic's cabinets, crates and trash cans. Its items drop when it is broken and a comparator reads how full it is. Its block entity is saved under block_entity, which containers may share. Its block entity may draw the block-entity visuals (item_display shows what is in it, as the display stands). Always non-opaque.

thematic:player_inventory#

A bench for one of the user's own inventories: a furniture block (every furniture field but seat) that, used, opens that inventory's screen, as Thematic's gadget and arrow benches do. It keeps nothing itself, so it has no block entity. Always non-opaque.

thematic:processor#

A processor: a furniture block (every furniture field but seat: its shape, facing, attach...) that makes a recipe type's recipes from its input slots, as Thematic's alloy smelter, centrifuge and plate press: through a screen the engine bound, or by hand in the world. With fuel it burns furnace fuel and adds the lit state property. Its items drop when it is broken. Its block entity is saved under block_entity, which processors may share. Its block entity may draw a geo model (geo, with working and resting clips) and the block-entity visuals (item_display...); what follows its items or its work (item_display, an item or count text_readout, the working and resting clips) needs interaction in_world, which sends them to the players. Non-opaque unless opaque says otherwise.

thematic:geo#

A block drawn by a geo model: a furniture block (every furniture field: its shape, facing, attach, seat...) whose block entity draws the model named after its id (geo.model to name another), turned with its facing, looping geo.animation.idle if it has one; its item is drawn with the same model unless geo.item_geo is false. It takes light_beam and text_readout too (its block entity holds no items, so no item_display). The block model the pack ships is only used for breaking particles. Always non-opaque.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

thematic:visual#

A block whose block entity draws on it: a furniture block (every furniture field) with its ordinary block model, plus at least one block-entity visual (light_beam, text_readout; its block entity holds no items, so no item_display). Always non-opaque.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

thematic:storage_link#

A storage link: a full cube that joins the inventories (chests, barrels, any modded container) touching its faces to the storage network it is part of. Adjacent network blocks (links, conduits, terminals) form one network. Items are inserted into higher priority links first, preferring inventories that already hold the item.

thematic:storage_conduit#

A storage conduit: a cable that extends the storage network, connecting to every adjacent network block. Adds the north, east, south, west, up and down boolean state properties (true when connected) for the blockstate to draw arms by. Always non-opaque.

thematic:storage_terminal#

A storage terminal: an interface type for a storage network. A furniture block (every furniture field but seat: its shape, facing, attach...) that, used, opens the items of the network it touches (only while the block is in the #thematic:storage_terminals tag; otherwise it is decoration) in a screen with a search box (name, @mod, #tag, $tooltip), a sort button and compact counts. theme sets the screen's look with no Java (title, frame texture, colours, boot sound, scanlines) and features turns on a 3x3 crafting grid that refills from the network. blueprints (it needs crafting) adds a blueprint slot with an Encode button and autocrafting: craftable items show with a marker even at zero, middle-click opens a request, and a job list shows the fabricator jobs. A pack may define as many terminals as it likes, each as small as { "parent": "thematic:batcomputer", "theme": { "accent": "#7CFF4F" } } (or "theme": "<preset>"); tools/new_storage_terminal.py writes the block's other files. Its crafting grid is saved in its block entity (block_entity, default its own id) and drops, with the blueprint, when it is broken. Always non-opaque.

thematic:storage_port#

A storage port: a cube that faces an inventory and moves items between it and the storage network it is part of. Placed against a block it faces it. Used, it opens a screen with nine ghost filter slots (whitelist or blacklist, match data, match by tag with a tag filter card, only what the destination already holds), upgrade card slots (speed, bulk, tag filter), a redstone mode and, for dispatch, an amount to keep in stock. Its filter and cards are saved in its block entity (block_entity, default its own id); the cards drop when it is broken.

thematic:storage_hopper#

A storage hopper: a storage port in a hopper's shape that connects to the network by touching it. Its spout faces down or sideways, set from the clicked face as a hopper's is. An intake hopper vacuums the item entities in the space above it and pulls from the inventory directly above, into the network; what the network cannot take stays where it was. An output hopper pushes items the filter names from the network through its spout into the inventory it points at; with an empty filter it does nothing. Powered, it is locked like a hopper unless the screen's redstone mode says otherwise. It has a port's filter, cards and screen, and moves 1 item every 8 ticks by default.

thematic:storage_uplink#

A storage uplink: a full cube on the storage network that relays it to players carrying a bound link chip. A player can open a terminal from afar when they are within the terminal's own uplink_range of it, within range of any uplink on its network, or anywhere when the network has a cross_dimension uplink.

thematic:fabricator#

A fabricator: a storage network member that holds blueprints (recipes encoded at a terminal with the blueprints feature) and crafts them for the whole network. Requesting an item at a terminal plans the crafts, takes the inputs out of the network and runs the job here, parallel crafts per cycle, then puts the results into the network. Used, it opens a screen with blueprint slots, upgrade card slots (speed, parallel) and nine keep-in-stock rules (an item and a target amount: when the network holds less, a job is queued). Placed it faces the player (adds the horizontal facing property). Its blueprints, cards, rules and running jobs are saved in its block entity (block_entity, default its own id); the blueprints, cards and reserved items drop when it is broken.

thematic:storage_core_array#

A core array: a storage network member that holds data cores (thematic:data_core items) in its slots and stores items in them for the whole network. Inserts go to higher priority members first, so with the default priority cores fill before chests behind a plain link; overflow goes on to the next member. Used, it opens a screen of the core slots with a fill bar each. The cores keep their contents in their own item data and drop, full, when the array is broken.

thematic:storage_drive#

A storage drive: a storage network member that is storage itself, with no chest or cores. It joins the network by touching a link, conduit, terminal or any network block, and stores items for the whole network up to its capacity. Inserts go to higher priority members first, so with the default priority drives fill before chests behind a plain link. Broken, it drops its block item carrying everything inside, and placing that item restores it; breaking an empty drive in creative drops nothing. Used with an empty hand it shows its fill. Has the blockstate properties facing (horizontal) and fill (0 empty to 4 full) for its model, and no loot table: the item drops from the block itself so the contents are never duplicated or lost.

items#

data/<namespace>/items/, script global item (registers at startup).

Items: data/<namespace>/items/<any folders>/<id>.json or .js registers the item <namespace>:<id>. Items are registry entries, read once at startup from mod jars, the dev tree and thematic/packs: a new item or a changed identity field needs a restart, while hooks, stats and looks retune on /reload.

Fields every type takes:

thematic:weapon#

A GeckoLib-rendered weapon. Its hooks run on use, on hit, while held and on release; use draws it back (a staff that blocks, a spear held ready).

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

Traits: any: a weapon's traits are what abilities and guards ask about ({held_trait: "billy_club"}); staff_block makes a blocking weapon answer as a staff.

thematic:weapon_equippable#

thematic:weapon, kept for the files that name it; the same type.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

Traits: any: a weapon's traits are what abilities and guards ask about ({held_trait: "billy_club"}); staff_block makes a blocking weapon answer as a staff.

thematic:shield#

A shield: blocks as vanilla's does, drawn with its GeckoLib model.

thematic:thrown_weapon#

A weapon drawn back and thrown, as a trident: held long enough and let go, it throws a throwable (or any entity) and, with riptide, launches the holder instead.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

thematic:tether_launcher#

Fires one tethered projectile at a time (a grapple, a gel charge) and remembers it on the stack (NBT key "entity") until it is cut.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

thematic:melee#

A held tool or weapon with durability, attributes and every use hook: the constructs, and anything else that mines, blocks, charges or casts.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

Traits: construct: a lantern construct (the roster, the construct HUD); any other trait is what abilities and guards ask about.

thematic:ingredient#

A plain crafting material.

thematic:modeled#

A plain item drawn with its GeckoLib model.

thematic:status_wearable#

A head item a move puts on someone (a lasso, a bola, a grab), or one worn for show: a helmet-slot armor item, a stack of one, fireproof. Its flags say what it does to its wearer; a while_worn hook does the rest. It draws a geo model over the whole body from the head slot. Set max_damage for how many swings or uses it lasts.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

Traits: stun, suit_head_allowed, cancel_swing, clear_on_owner_respawn: the flags of the same names answer them, so a definition may set either the flag or the trait.

thematic:spyglass#

A zoom scope held up to the eye: vanilla's spyglass (its zoom, its sounds, slowed while raised) with a geo model, which is hidden in first person while raised, and its own full-screen overlay.

thematic:fluid_container#

A bucket for one fluid, as two items that turn into each other: the empty one picks up a source block of its fluid, the filled one places its block. In creative it stays as it is. Edits are refused where the user may not change blocks (claims, spawn protection, the protected worlds).

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

thematic:currency#

Money: a note or coin worth amount in a wallet. Every currency counts toward a deposit, and the wallet pays withdrawals out in the largest amounts first, one currency per amount.

thematic:wallet#

A wallet, a stack of one: using it deposits every currency item in the main inventory, sneak-using it withdraws $100, and /withdrawal <amount> withdraws any sum. Its balance shows above the hotbar while it is held, and lives in the stack's "amount" NBT.

thematic:food#

A food item: the common "food" field ({ "hunger": 4, "saturation": 0.3 }) is required.

thematic:bound_link#

A link chip, a stack of one: shift-using it on a block that can be linked (a storage terminal) binds it there, remembering the dimension, position and name, which the tooltip shows. Using it in the air opens the bound terminal from afar when the range rule allows; the tablet's Terminal app does the same.

thematic:encoded_recipe#

A blueprint, a stack of one: a storage terminal with the blueprints feature encodes its crafting grid into it (the recipe is kept in the stack data), and a fabricator that holds it can craft that recipe for the network on request. Blank until encoded; encoding again overwrites.

thematic:spawn_egg#

Vanilla's spawn egg for an entity type (a mob): used on a block it spawns one, in the two colours given. Its item model is the usual {"parent": "item/template_spawn_egg"}.

thematic:bow#

A bow fed from its wearer's quiver move: drawing nocks the quiver's selected arrow (the next one off cooldown, else the plain arrow), releasing fires it, scaled by how far the string was drawn, then puts that arrow on cooldown and, with auto-swap on, turns the quiver to the next arrow. A stack of one, +4 attack damage and +0.2 attack speed in the main hand. Its model is geo/item/<id>.geo.json; its clips (idle, pull, hurricane) play on bow_controller.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

Traits: bow: every bow has it (the bow held-item kind; ItemTraits.has(stack, "bow")).

thematic:loot_box#

A box that is opened by using it: it takes one from the stack, gives one item picked at random from its pool and says which ("You got <item>!"), with a burst of gold dust for the opener.

thematic:upgrade_card#

An upgrade card: slotted into a device's card slots (a storage port, a fabricator, a builder gadget) it changes what the device does. The card id names the card; effects maps effect kinds to values, and the device combines the cards it holds (speed multiplies, stack and parallel add, tag_filter is on if any card has it). A device only reads the kinds it knows.

thematic:data_core#

A data core: slotted into a core array it adds its storage to the storage network. It holds up to capacity items in total, of any mix of kinds, and keeps them in its own item data, so a core carried or broken out of an array loses nothing. The tooltip shows how full it is. Never stacks.

thematic:builder_tool#

A construction gadget that only builds: right-click a block to build by its mode (extend the face, line, build to me, surface, grid; right-click the air for air-place), using the clicked block's own item from the inventory and then from the network of a link chip in the inventory. It never breaks or exchanges blocks. Sneak and right-click the air for its card slots; the thematic:upgrade_card cards with the effects capacity (more blocks), range (more reach and spread), network (pull from a link chip's network) and mode_surface / mode_grid / mode_build_to_me / mode_air_place (unlock a mode) upgrade it. Builds can be undone (the last ten), returning the items.

arrows#

data/<namespace>/arrows/, script global arrow, default type thematic:arrow (registers at startup).

Trick arrows: data/<namespace>/arrows/<any folders>/<id>.json or .js. Each id registers its own arrow item and entity type at startup (a restart is needed for a new one); the definition is what its hits do, how it looks and how it flies, and it reloads with /reload.

thematic:arrow#

A thematic arrow, fired from a bow or the quiver: a base hit (the tuned damage, scaled by the draw and the archer's utility stat), then its hooks. Numbers the actions read sit at the top level; a projectiles.csv row for the id wins per column.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

Traits: free words the engine and kits may ask about (read through ContentTraits)

throwables#

data/<namespace>/throwables/, script global throwable, default type thematic:thrown (registers at startup).

Things thrown and flying: gadgets, grenades, vials, thrown items. data/<namespace>/throwables/<any folders>/<id>.json or .js. Every one is the entity thematic:thrown; the definition is how it flies, looks and what its hits do. A definition with an item block also registers that item (a restart is needed for a new one).

thematic:thrown#

A thrown body: a GeckoLib model (or an item) in flight, with the throwable's flight rules and action lists. Numbers the actions read sit at the top level; a projectiles.csv row for the id wins per column.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

Traits: free words the engine and kits may ask about (read through ContentTraits)

criminals#

data/<namespace>/criminals/, script global criminal, default type thematic:criminal (registers at startup).

Criminals: data/<namespace>/criminals/<any folders>/<id>.json or .js. Each id registers its own entity type, attributes, spawn rules and spawn egg (<id>spawn_egg) at startup (a restart is needed for a new one, or for new stats); the look, the fight and the hooks reload with /reload. A crew file defines many ids, criminal("<id>", "thematic:criminal", c => c.use("thematic:criminal<role>", { ...crew })).

thematic:criminal#

A hostile human NPC on the criminal brain: it targets whoever the faction rules allow, calls its allies in, chases, punches (or stabs, with a held weapon), breaks and runs when badly hurt, and with a gunner block fights at range instead: aims, fires bursts, reloads in cover and keeps its distance.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

Traits: free words the engine and kits may ask about (read through ContentTraits)

entities#

data/<namespace>/entities/, script global entity (registers at startup).

Entity types: data/<namespace>/entities/<any folders>/<id>.json or .js. "type" names the body (a generic entity: zone, tether, owner_copy, mob, vehicle...) and the file sets its options. Each id registers its own entity type at startup (and a spawn egg <id>_spawn_egg with spawn_egg), so a new one, or a changed size, group, tracking, attributes, egg or boss flag, needs a restart; the render block and the body's options reload with /reload.

Fields every type takes:

thematic:thrown#

A thrown thing with an entity type of its own: every entity of the type flies as one throwable definition (data/<ns>/throwables/<id>), with that definition's flight, options (chain, stick, orbit, item_source, pierce, return, bounce, on_land, on_refused_hit...), hooks and look. Throws spawn thematic:thrown itself, so a pack needs its own type only to keep an old entity id loading (a save, a summon command) or to tell its throws apart. The hitbox is the throwable's size; render kind thrown (the default) draws its look.

thematic:bolt#

An energy bolt with an entity type of its own: every entity of the type is a thematic:bolt (the body a thematic:projectile fires by default), drawn by its look. Moves fire thematic:bolt itself, so a pack needs its own type only to keep an old entity id loading (a save, a summon command), or for a shot Java code fires by entity id (a gunner's round, a flier's gun): that shot flies as projectile says, with the damage and effects its shooter gives it. One made bare (read back from a save with no flight, a summon command) has nothing to run and goes on its first tick. The hitbox is the flight's size; render kind bolt (the default) draws its look.

thematic:tether#

A line from its owner to a head that takes hold of a block or a body: it hauls its owner in (pull_owner, a grapple), hauls what it holds in (pull_target, a fishing line) or stays on the body it holds (bind_target, a lasso). Fired by a tether_launcher, summoned (a summon's target is bound at once) or thrown like any entity (a move's projectile{body: "entity"} names the move and runs its on_hit / on_block, in the press, as the head takes hold); it lets go when its owner is gone, when it stretches too far, when a pull is done, at the end of its lifetime or when its launcher cuts it, running on_release. Its owner punching while it is out (with the launcher in hand) may start its reel and runs on_owner_swing. Every option is read live, so a /reload retunes lines already out; size, spawn_group, track_range and update_rate are the shared entity fields, and a render.model draws its head as a still GeckoLib model on top of the line.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

thematic:zone#

One entity for a lingering area, a pulse, a wall cell or a decal: it sits where it was put (or follows its owner, or keeps the velocity it was thrown with), lasts its lifetime, does something to the bodies inside it, and is drawn by its visual. Every option is read live, so a /reload retunes zones already out; size, spawn_group, track_range and update_rate are the shared entity fields.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

thematic:owner_copy#

A copy of whoever brought it in, wearing their suit: an after-image frozen in the pose it was cast in (copy frozen_pose), a projection that walks near its owner and copies what an onlooker sees of them (live), or a mob in its owner's clothes that picks targets and charges them (ai). Brought in by thematic:summon (its owner, lasts, health, damage, its place in the group, and a mimic's mirror, look and behaviour arrive from the summon) or by Java. It never drops anything and has no name tag. Every option is read live, so a /reload retunes copies already out; size and the attributes (health, speed, attack) are the shared entity fields.

thematic:mob#

A humanoid mob on the criminal brain: it picks a target (whoever hurt it, then anyone its faction may fight), chases and swings at it, opens doors, keeps room from its allies, may break and run at low health and steps around what blocks it. Its brain adds behaviour ids, it can wear a suit and fire its abilities, show a boss bar, fly, and trade. An encounter can lead with it as its boss. Give it attributes (minecraft:generic.max_health, ...), a size such as [0.6, 1.95] and spawn_group monster; its render block's model is drawn unless render.kind names another (worn_suit draws the suit it wears; humanoid draws its model with a turning head, its looks and the shared humanoid clips). With brain.base "none" it runs only the behaviours its brain lists: a brute, a boss or a shopkeeper of its own.

thematic:owned_summon#

A pet or minion that works for whoever brought it in: a drone, a jet, a school of fish, a swarm of bats, a mount, a tentacle. base picks what it is built as (a hovering or fixed-wing flier, a swimmer or a prop drawn from the render block's GeckoLib model, or a vanilla bat or horse reskinned), and each base reads its own group of options below; every group defaults to what that base's first user did, so a bare base is a working summon. Brought in by thematic:summon (its owner, its target, lasts, damage, its place in the group and the summon's options block arrive through the summon) or by Java. Every option is read live, so a /reload retunes summons already out, except base, which picks the class and needs a restart. Health, speed, attack and follow range are the shared attributes.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

thematic:vehicle#

A vehicle a player drives: a move of type generic_vehicle calls it to its wearer (it drives or flies up and takes them aboard), and only a rider whose suit has that move may climb in. It drives on the ground or flies, burns fuel, hits what it runs into, passes its rider's status effects and fire to them, and a bare-handed attacker next to a slow vehicle pulls its rider out. Its controls take the rider's ability keys in order (the first control the first key). Every option is read live, so a /reload retunes vehicles already out; size (with resizable: true), spawn_group, track_range and update_rate are the shared entity fields, and render names the geo model (render.scale sizes it). A rider's suit layers are hidden while they ride a vehicle in the #thematic:vehicles/hide_rider_layers entity tag.

thematic:seat#

An invisible seat a player rides while sitting on a block: when they get off it stands them on the block above and removes itself. A furniture block's seat option spawns Thematic's own (thematic:chair_entity), so a pack needs its own seat type only to tell its seats apart. Takes no options; give it a small size such as [0.5, 0.6] and spawn_group misc.

thematic:pin#

A wrap round one living body, brought in by thematic:summon with onto: "target": strands reach from the body's middle to every solid block within scan_radius (32 rays), and with hold it pins the body there -- hung off an overhang when a strand reaches above its chest, else feet locked to the ground; AI off, velocity zeroed, Immobile V and Stun each tick -- until its lifetime runs out or the body dies. Without hold it is only drawn (at most anchors strands, never hung). Strands whose block is gone drop every 10 ticks. Drawn by the pin render kind: a cocoon of rope round the body and guy-lines to the anchors, fading over its last second.

thematic:strike#

A lightning strike called down for someone: brought in by thematic:lightning (or thematic:summon, which hands it its owner, damage and hold), it flashes a number of times where it stands, a few ticks apart, with a thunderclap, and each flash hits every living body in a column round it (a block either way, from a block below to three above) that its owner may hit -- for damage, as the owner's attack (or, not credited, a lightning bolt's), holding a body stun seconds (Immobile) and playing victim_animation on a player the first time it holds them. It lights neither blocks nor mobs on fire and charges nothing. One nobody owns goes at once. Drawn by the strike render kind: vanilla's lightning bolt, scaled by render.scale, or with vfx that preset at each flash.

thematic:arc#

A crackling arc that runs out along the ground from where it is put, the way it was set moving (thematic:summon's velocity): speed blocks a tick, turned a little off its heading at random, jittering zigzag blocks side to side each tick and rising and falling over an arch up to arch_height blocks high (each arc picks its own height, 0.7 to 1.3 of it, and wavelength, 0.5 to 1.5 of arch_frequency cycles a block), through blocks, for lifetime ticks. It hurts nobody: it is a look. Drawn by the arc render kind: a jagged lightning line through the points it has passed, each stretch fading over 20 ticks, in its owner's colour (their suit's; white without one). Never saved.

thematic:mushroom_cloud#

The look of a great blast: from where it is put it rises rise blocks over its lifetime while, on each client, a mushroom cloud boils up round it -- a smoke cap spreading out to radius blocks and climbing, flame and puffs under it, a smoke stem, and at the start a ring of explosions and lava sparks -- over glowing fireball spheres that swell, pulse and fade (the mushroom_cloud render kind). It hurts nobody and burns nothing: pair it with the blast's own damage. thematic:summon's lasts sends it away sooner (the cloud is then cut short, not sped up).

thematic:perch#

A fixture that hangs over its owner's shoulder, brought in by thematic:summon (its owner must be a player): each tick it eases toward its perch, turns to face its owner's quarry (the nearest body a hunt mark of theirs names, within range) and, while its owner can see that quarry, looses its arrow at it every interval ticks -- the owner's arrow, a full critical draw for damage, led by where the quarry is going. With no quarry it faces the way its owner faces. It is placed, never pushed or hit, goes when its owner dies or its lifetime runs out, and a save never brings it back. A summon's lasts, damage and options range, shots (its lifetime split over that many shots, at least 10 ticks apart) and interval override the definition's. Drawn by the perch render kind: its look's item turned to its aim, full-bright over a halo, kicked back after each shot.

thematic:strand#

A straight line strung between two world points (the strand verb lays them) that stays after the move ends, until its lifetime runs out, its owner strings one too many, it snaps, or its chunk unloads (it is never saved). A gentle strand is a rail any living body can land and walk on (one-way: from above only); a steep one is climbed like a ladder, holding forward to move along it (looking down goes down). A body that crosses it fast, or with the catching trait, is caught: on_catch and effects run on it, and it may snap. Its owner and anyone its owner may not hit pass freely. Every option is read live; size, spawn_group, track_range and update_rate are the shared entity fields.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

professions#

data/<namespace>/professions/, script global profession, default type thematic:profession (registers at startup).

Villager professions: data/<namespace>/professions/<id>.json. The file name is the profession's id, and an unemployed villager near the workstation block takes the job, restocking there like any villager. Its name is the lang key entity.minecraft.villager.<file name>. A new id or a changed workstation needs a restart; the look and trades reload.

thematic:profession#

A villager profession. It offers pick of its trades at Novice, chosen once, and never levels up.

armors#

data/<namespace>/armors/, script global suit, default type thematic:suit (registers at startup).

Suits: data/<namespace>/armors/<collection>/<any folders>/<id>.json or .js. The first folder under armors/ is the suit's collection (data/<namespace>/collections/<collection>.json describes it). A suit's id is always thematic:<file name>, whatever namespace the file is in. A file with "parent", or one under a folder named alt/, is an alt (a skin variant) of its parent. Each id registers its own suit item at startup (a restart is needed for a new one); the kit reloads with /reload. When two packs define one suit id, the higher pack's file is the one /reload applies, whatever folder it sits in, unless the other sets a higher "priority".

thematic:suit#

A suit: one chestpiece item with a kit of abilities, stat bands and a look. Every field is optional. An alt ("parent") inherits every field it leaves out: abilities merge by identifier ("remove": true drops the parent's), stats replace per identifier, tags and attributes are added, and a field left at its default keeps the parent's value.

thematic:ladder#

A suit that grows: one item whose level picks a rung of its ladder, each rung with its own stats, the abilities it grants and the ones it lets the player choose between, and what the next upgrade costs. Takes every suit field as well; the rungs are laid over them.

ability_effects#

data/<namespace>/ability_effects/, script global abilityEffect, default type thematic:action_list.

Ability effects: data/<namespace>/ability_effects/<any folders>/<id>.json or .js. What a beam, a bolt or a spray carries (an ability's "effects": ["thematic:laser", {"id": "thematic:blindness", "duration": 3.5}]) and does to what it hits. Read before abilities are, and again on /reload.

thematic:action_list#

An effect made of actions: the ability's own hit (damage), then whatever its hooks do. A value written {"$option": "name"} anywhere in a hook is that option's value for the firing; {"$option": "flag", "then": x, "else": y} picks by a true/false option, and without "else" a false flag leaves the field (or list entry) out.

Every hook also takes if (a guard), every (ticks) and cooldown (seconds).

Traits: none read

effect_visuals#

data/<namespace>/effect_visuals/, script global effectVisual, default type thematic:effect_visual.

How a status effect shows on a suit: data/<namespace>/effect_visuals/<any folders>/<effect>.json or .js. The file name is the status effect's id (effect_visuals/frozen.json is thematic:frozen), or its effect field names one. Synced to clients and reloaded with /reload; an effect with no file shows nothing on the suit.

thematic:effect_visual#

What a body wearing a suit looks like while it has the effect. Every field is optional; a file with none draws nothing.

anim_controllers#

data/<namespace>/anim_controllers/, script global animController, default type thematic:suit_controllers.

The GeckoLib controllers every suit carries: data/<namespace>/anim_controllers/<any folders>/<id>.json or .js. The engine ships thematic:armor (anim_controllers/armor.js); a pack changes it by shipping the same path, or adds to it with a file of its own id. Every definition is read together, thematic:armor first and the rest in id order: a later one's idle wins, its states are tried before the earlier ones', its while_active controllers and trigger_clips_from are added, and its effect_clips replace the same effect's. What plays reloads with /reload; which controllers a suit has is fixed when the suit is first drawn. Synced to clients.

thematic:suit_controllers#

What a suit's clip controller (ArmorAnimations: the one ability clips are triggered on) plays when nothing is triggered, the extra controllers that hold a clip while something is true, and the player-animator clips status effects put on their target. A condition (when) holds when every key it names holds: riding: the wearer rides an entity of this type, or of this #tag; vehicle_moving: the ride is moving (a Thematic vehicle by its own measure, anything else by the ground vehicles' one: across faster than about 0.6 blocks a second); flag: the wearer's stored ability flag of this key is on; trait: the wearer has this trait; has_ability: the wearer's suit has this ability in its kit; active: the wearer has this ability running; holding: the main hand holds this item, or an item of this #tag; sneaking: the wearer is (or is not) sneaking; looking_at: the first living thing the wearer's look meets within range blocks (32), with no block in between, is there (of this entity type or #tag, if entity names one). Every key is answered on each client from what it sees of the wearer, so every viewer sees the same clip. Nothing but a player wearing the suit (or a mirage of one) matches anything.

encounters#

data/<namespace>/encounters/, script global encounter, default type thematic:encounter.

Ready-made missions: data/<namespace>/encounters/<any folders>/<id>.json or .js. The file name is the template's name (/thematic dev encounter template <name>, /thematic dev encounter import <name>, an NPC start). The fields are the wave spawner's own encounter NBT, key for key, so a mission authored in game and exported with /thematic dev encounter export is already a valid file. Read by the server and reloaded with /reload; a file in config/thematic/encounters/ with the same name wins.

thematic:encounter#

One mission: its phases, spawn geometry, boss, rewards and cooldown.

arena_themes#

data/<namespace>/arena_themes/, script global arenaTheme, default type thematic:arena_theme.

Remembered places shown round a mission: data/<namespace>/arena_themes/<any folders>/<id>.json or .js. An encounter names one in Arena.Memory (a bare name means thematic:). The place is vanilla structure templates, dissolved at their edges and set in a ring beyond the fight, shown only to the participants. Read by the server and reloaded with /reload.

thematic:arena_theme#

One arena theme: its light and the vanilla structure pieces around it.

pocket_dimensions#

data/<namespace>/pocket_dimensions/, script global pocketDimension, default type thematic:pocket_dimension.

Pocket dimensions a wearer is sent into for a while and then brought back from: data/<namespace>/pocket_dimensions/<any folders>/<id>.json or .js. The file name is the pocket's id, which the Java that sends someone in names. The dimension itself stays vanilla data (dimension/<id>.json and its dimension_type, whose coordinate_scale scales the walk back out). Read by the server and reloaded with /reload.

thematic:pocket_dimension#

One pocket: where the wearer lands, how long they stay, the corridor built around the landing spot on every entry and the resident waiting down it.

multiblocks#

data/<namespace>/multiblocks/, script global multiblock, default type thematic:multiblock.

Structures built from blocks the player places in a layout: data/<namespace>/multiblocks/<any folders>/<id>.json or .js. Using a placed part runs the thematic:assemble action, which swaps the layout for another set of blocks (a model block and its fillers); breaking any of them runs thematic:disassemble, which swaps the parts back. Read by the server and reloaded with /reload.

thematic:multiblock#

One structure: the layout the player places, the layout it becomes, and the block each character in them stands for.