{ "format": 1, "about": "Thematic script API. Scripts are ES5 JavaScript plus arrow functions, with no Java access. Ids without a namespace mean thematic:. Generated from the engine's declarations.", "globals": [ { "name": "program:main", "signature": "function main(drone: drone, owner: owner, args: {[input: string]: any})", "returns": "any", "doc": "Define this in every program, as a generator: function* main(drone, owner, args) { ... }. The program runs from it; it yields drone actions to wait on them, and ends when it returns. `args` holds what the player picked for the inputs the program declares in its header comments, one line each: `// @input \"\" [optional] [default=owner|look|here]`. Before the program runs the console walks the player through them (a click, or a zone or route drawn) and shows the prompt; an optional one can be skipped with Esc or Enter. The kinds and what args. is: `point` and `chest` (a container block) are {x, y, z}; `area` is {center: {x, y, z}, radius} (radius 1 to 16); `entity` is what a scan gives of a body ({id, type, name, x, y, z, ...}); `path` is a list of {x, y, z} (at most 32). An optional input left out with no default is not a property, so args. is undefined: test it before use. default=owner uses the owner's own spot (or the owner, for an entity), default=look the block (or body) they are looking at, default=here the spot the drone stands on. A program with no inputs gets an empty args. A program runs in a locked-down scope: Promise, Map, Set, WeakMap, WeakSet, Symbol, BigInt, ArrayBuffer and the typed arrays, XML and RegExp are not defined (nothing queues work behind the program's back, and a regular expression cannot run away), so a regular expression literal or any regex-taking String method (match, search, split or replace with a pattern) is an error; split(\",\"), replace(\"a\", \"b\" or a function), replaceAll, indexOf and includes work on plain strings. Arrays and strings are capped at 100000 elements or characters (fill, join, repeat, padStart, padEnd and the other array methods throw past it; join and JSON.stringify refuse results over a million characters or 200000 values). A program that holds more than about 16 MB of values stops with \"out of memory\"; a step that runs over 200000 instructions, nests structures too deeply for the stack or fails any other way crashes that program alone." }, { "name": "formation:plan", "signature": "function plan(ctx: {tick: number, dt: number, params: {kind: string, radius: number, height: number, speed: number, passes: boolean, tighten: number, defendOnly: boolean, retreatBelow: number, engageRange: number, spreadRadius: number}, owner: {id: string, pos: {x: number, y: number, z: number}, look: {x: number, y: number, z: number}, velocity: {x: number, y: number, z: number}, pool: number, health: number, maxHealth: number, yaw: number, anchorYaw: number, age: number, onGround: boolean}, target: {id: string, type: string, pos: {x: number, y: number, z: number}, velocity: {x: number, y: number, z: number}, pool: number, distance: number, airborne: boolean, hostile: boolean, player: boolean, effects: object} | null, enemies: {id: string, type: string, pos: {x: number, y: number, z: number}, velocity: {x: number, y: number, z: number}, pool: number, distance: number, airborne: boolean, hostile: boolean, player: boolean, effects: object}[], units: {index: number, slot: number, id: string, pos: {x: number, y: number, z: number}, velocity: {x: number, y: number, z: number}, pool: number, target: string | null, ready: object, order: string | null, busy: boolean, fallingBack: boolean}[], state: object})", "returns": "{units?: ({point?: {x: number, y: number, z: number}, face?: {x: number, y: number, z: number} | \"target\" | \"heading\", target?: string, prefer?: string[], hold?: boolean, speed?: number, pass?: boolean, direct?: boolean} | null)[], defendOnly?: boolean, scout?: boolean}", "doc": "A formation script defines this, and the game calls it every few ticks (the file's @cadence, 5 to 10, slower when the server is under load) once for the whole squad. ctx is a snapshot, capped (at most 16 enemies and 16 units) and rebuilt each plan: ctx.tick (the world's time), ctx.dt (ticks since the last plan), ctx.params (numbers from the squad's definition), ctx.owner (the body the squad guards: its position, look, velocity and yaw are the owner's, or the stand-in body's while the owner has left one behind; id and health stay the owner's), ctx.target (the squad's main target, or null), ctx.enemies, ctx.units (each with ready: which of its moves are off cooldown) and ctx.state, an object that is yours and keeps what you store on it from one plan to the next. Return {units: [...]} with one entry per ctx.units entry, in order (null leaves a unit to the default). An entry is {point, face?, target?, prefer?, hold?, speed?, pass?, direct?}: point is where the unit should be (the game steers it there round walls and moves it to open air with a line to its target, unless direct); face a point to look at; target an enemy id from ctx.enemies; prefer a list of move ids to favour when the unit picks a move (it still cannot use one on cooldown, out of range or without a line of sight); hold stands still; speed is blocks a tick; pass marks a fly-through. The result may also say defendOnly: true (fight only what attacks the owner or the squad) and scout: true. A plan may run 50,000 instructions. If it throws, overruns or returns nonsense (a point more than 80 blocks from the owner, NaN), the last good plan is kept, then a ring round the owner; a built-in only logs, but a formation of a player's takes their suit offline like a crashed program. The file's first lines are its header: // @formation \"Name\" makes it a formation (in a program-store file it also keeps the editor from running it as a drone program); // @description is a line for the picker; // @cadence N plans every N ticks (5 to 10, default 5); // @pattern surround|escort|ring takes ctx.params from the squad's pattern of that kind; // @order N sorts the built-ins." }, { "name": "formation:vec", "signature": "vec(x: number, y: number, z: number)", "returns": "{x: number, y: number, z: number}", "doc": "A point." }, { "name": "formation:add", "signature": "add(a: {x: number, y: number, z: number}, b: {x: number, y: number, z: number})", "returns": "{x: number, y: number, z: number}", "doc": "a + b." }, { "name": "formation:sub", "signature": "sub(a: {x: number, y: number, z: number}, b: {x: number, y: number, z: number})", "returns": "{x: number, y: number, z: number}", "doc": "a - b." }, { "name": "formation:scale", "signature": "scale(a: {x: number, y: number, z: number}, k: number)", "returns": "{x: number, y: number, z: number}", "doc": "a times k." }, { "name": "formation:len", "signature": "len(a: {x: number, y: number, z: number})", "returns": "number", "doc": "The length of a." }, { "name": "formation:dist", "signature": "dist(a: {x: number, y: number, z: number}, b: {x: number, y: number, z: number})", "returns": "number", "doc": "The distance between two points." }, { "name": "formation:flat", "signature": "flat(a: {x: number, y: number, z: number})", "returns": "{x: number, y: number, z: number}", "doc": "a with y set to 0." }, { "name": "formation:norm", "signature": "norm(a: {x: number, y: number, z: number})", "returns": "{x: number, y: number, z: number}", "doc": "a scaled to length 1 ({0, 0, 0} for a point at the origin)." }, { "name": "formation:rotY", "signature": "rotY(a: {x: number, y: number, z: number}, radians: number)", "returns": "{x: number, y: number, z: number}", "doc": "a turned round the vertical axis." }, { "name": "formation:yawVec", "signature": "yawVec(degrees: number)", "returns": "{x: number, y: number, z: number}", "doc": "The horizontal unit vector a Minecraft yaw faces: 0 is +z, 90 is -x. owner.yaw and owner.anchorYaw are in these degrees." }, { "name": "formation:toward", "signature": "toward(from: {x: number, y: number, z: number}, to: {x: number, y: number, z: number}, step: number)", "returns": "{x: number, y: number, z: number}", "doc": "from moved toward to by at most step (to itself when it is that close)." }, { "name": "formation:clamp", "signature": "clamp(v: number, lo: number, hi: number)", "returns": "number", "doc": "v kept between lo and hi." }, { "name": "component", "signature": "component(body: (component: Component) => void) | component(id, body)", "returns": "void", "doc": "Ability scripts (data//abilities//.js): declares an ability as a component -- the parts it is built from, and the phases it can be in. A file that declares one may leave it unnamed and the file name is its id; a file may declare any number in loops, naming each (component(id, ...)), over the read-only lists registry(), tag(), tags() and data(). The body runs once at load and builds the same definition the JSON format holds, through the builder it is handed; it never runs on the key press. Every builder method: section ability_script, or docs/thematic.d.ts." }, { "name": "ability", "signature": "ability(id, type, options?)", "returns": "void", "doc": "Ability scripts: defines an ability of a built-in Java type (docs/ability-types.md), configured as its JSON file would be." }, { "name": "preset", "signature": "preset(id: string, spec: PresetSpec, apply: (def: ContentBuilder, options: any) => void): void", "returns": "void", "doc": "Preset libraries: data//content_prefabs//.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:." }, { "name": "contentSample", "signature": "contentSample(body: (def: ContentBuilder) => void): void | contentSample(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | contentSample(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "A sample kind that proves the scripted-content pipeline end to end; the engine ships no files of it. data//content_samples//.json or .js. Files in data//content_samples/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "statusEffect", "signature": "statusEffect(body: (def: ContentBuilder) => void): void | statusEffect(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | statusEffect(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Status effects: data//status_effects//.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. Files in data//status_effects/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "damageElement", "signature": "damageElement(body: (def: ContentBuilder) => void): void | damageElement(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | damageElement(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "What a hit can be made of, for the weakness, resistance and immunity system: data//damage_elements//.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 :is_ (when the element has a damage_type) or :compat// (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. Files in data//damage_elements/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "vfxPreset", "signature": "vfxPreset(body: (def: ContentBuilder) => void): void | vfxPreset(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | vfxPreset(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Named effects the vfx action plays: data//vfx//.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. Files in data//vfx/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "block", "signature": "block(body: (def: ContentBuilder) => void): void | block(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | block(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Blocks: data//blocks//.json or .js registers the block : 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. Files in data//blocks/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "item", "signature": "item(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | item(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Items: data//items//.json or .js registers the item :. 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. Files in data//items/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "arrow", "signature": "arrow(body: (def: ContentBuilder) => void): void | arrow(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | arrow(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Trick arrows: data//arrows//.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. Files in data//arrows/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "throwable", "signature": "throwable(body: (def: ContentBuilder) => void): void | throwable(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | throwable(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Things thrown and flying: gadgets, grenades, vials, thrown items. data//throwables//.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). Files in data//throwables/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "criminal", "signature": "criminal(body: (def: ContentBuilder) => void): void | criminal(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | criminal(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Criminals: data//criminals//.json or .js. Each id registers its own entity type, attributes, spawn rules and spawn egg (_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(\"\", \"thematic:criminal\", c => c.use(\"thematic:criminal_\", { ...crew })). Files in data//criminals/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "entity", "signature": "entity(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | entity(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Entity types: data//entities//.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 _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. Files in data//entities/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "profession", "signature": "profession(body: (def: ContentBuilder) => void): void | profession(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | profession(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Villager professions: data//professions/.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.. A new id or a changed workstation needs a restart; the look and trades reload. Files in data//professions/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "suit", "signature": "suit(body: (def: ContentBuilder) => void): void | suit(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | suit(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Suits: data//armors///.json or .js. The first folder under armors/ is the suit's collection (data//collections/.json describes it). A suit's id is always thematic:, 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\". Files in data//armors/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "abilityEffect", "signature": "abilityEffect(body: (def: ContentBuilder) => void): void | abilityEffect(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | abilityEffect(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Ability effects: data//ability_effects//.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. Files in data//ability_effects/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "effectVisual", "signature": "effectVisual(body: (def: ContentBuilder) => void): void | effectVisual(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | effectVisual(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "How a status effect shows on a suit: data//effect_visuals//.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. Files in data//effect_visuals/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "animController", "signature": "animController(body: (def: ContentBuilder) => void): void | animController(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | animController(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "The GeckoLib controllers every suit carries: data//anim_controllers//.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. Files in data//anim_controllers/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "encounter", "signature": "encounter(body: (def: ContentBuilder) => void): void | encounter(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | encounter(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Ready-made missions: data//encounters//.json or .js. The file name is the template's name (/thematic dev encounter template , /thematic dev encounter import , 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. Files in data//encounters/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "arenaTheme", "signature": "arenaTheme(body: (def: ContentBuilder) => void): void | arenaTheme(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | arenaTheme(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Remembered places shown round a mission: data//arena_themes//.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. Files in data//arena_themes/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "pocketDimension", "signature": "pocketDimension(body: (def: ContentBuilder) => void): void | pocketDimension(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | pocketDimension(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Pocket dimensions a wearer is sent into for a while and then brought back from: data//pocket_dimensions//.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/.json and its dimension_type, whose coordinate_scale scales the walk back out). Read by the server and reloaded with /reload. Files in data//pocket_dimensions/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "multiblock", "signature": "multiblock(body: (def: ContentBuilder) => void): void | multiblock(type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void | multiblock(id: string, type: string, body?: ((def: ContentBuilder) => void) | { [field: string]: unknown }): void", "returns": "void", "doc": "Structures built from blocks the player places in a layout: data//multiblocks//.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. Files in data//multiblocks/ call it: once, when the file name is the id, or once per id, naming each (a family file)." }, { "name": "gun", "signature": "gun(body: (gun: Gun) => void) | gun(type, body)", "returns": "void", "doc": "Gun scripts (data//guns//.js; gun_effects/ calls gunEffect(type, fields), huds/ calls hud(body)): declares the file's gun, effect or HUD, built once at load into the same JSON the .json format holds. Every builder method: section gun_script, or docs/thematic.d.ts." } ], "types": [ { "type": "drone", "doc": "The unit the program runs on: a body it can read, move and make work. Calls that read answer at once; calls that return an action do their work over time when the program yields them (yield drone.moveTo(p)), evaluating to {ok: true, ...} or {ok: false, reason}. The drone acts as its owner and only where its owner may: within 32 blocks of them, in loaded chunks, never in a claim or spawn protection, never on bedrock or anything harder than a drone may break. Block actions reach 5 blocks from the drone.", "methods": [ { "name": "pos", "signature": "drone.pos(): {x: number, y: number, z: number}", "params": "", "returns": "{x: number, y: number, z: number}", "doc": "Where the drone is." }, { "name": "facing", "signature": "drone.facing(): {x: number, y: number, z: number}", "params": "", "returns": "{x: number, y: number, z: number}", "doc": "The way the drone faces, as a horizontal unit vector (y is 0)." }, { "name": "health", "signature": "drone.health(): number", "params": "", "returns": "number", "doc": "The drone's health, in the units the action bar shows." }, { "name": "inventory", "signature": "drone.inventory(): ({id: string, count: number} | null)[]", "params": "", "returns": "({id: string, count: number} | null)[]", "doc": "What the drone carries: nine slots, each {id, count} or null when empty. What it digs and harvests goes here." }, { "name": "count", "signature": "drone.count(itemId: string): number", "params": "itemId: string", "returns": "number", "doc": "How many of an item (\"minecraft:torch\") the drone carries." }, { "name": "free", "signature": "drone.free(): number", "params": "", "returns": "number", "doc": "How many of its nine slots are empty." }, { "name": "isFull", "signature": "drone.isFull(): boolean", "params": "", "returns": "boolean", "doc": "Whether nothing more fits: no empty slot and no stack with room." }, { "name": "blockAt", "signature": "drone.blockAt(p: {x: number, y: number, z: number} | [number, number, number]): {id: string, hardness: number, loaded: boolean, mature?: boolean}", "params": "p: {x: number, y: number, z: number} | [number, number, number]", "returns": "{id: string, hardness: number, loaded: boolean, mature?: boolean}", "doc": "The block at p: its id, its hardness (negative: unbreakable) and, for a crop, whether it is fully grown. Anything outside 32 blocks of the owner or in an unloaded chunk reads {id: \"unloaded\", hardness: -1, loaded: false}." }, { "name": "scanBlocks", "signature": "drone.scanBlocks(options?: {center?: {x: number, y: number, z: number} | [number, number, number], radius?: number, match?: string, limit?: number}): {x: number, y: number, z: number, id: string}[]", "params": "options?: {center?: {x: number, y: number, z: number} | [number, number, number], radius?: number, match?: string, limit?: number}", "returns": "{x: number, y: number, z: number, id: string}[]", "doc": "Blocks near a point (center: the drone), nearest first. radius is at most 16 and the answer at most 64 blocks. match is a block id (\"minecraft:diamond_ore\"), a block tag (\"#minecraft:logs\"), \"mature_crop\" or \"young_crop\"; none matches every non-air block. Scans, blocks and entities together, run at most four a second; past that the answer is an empty list." }, { "name": "scanEntities", "signature": "drone.scanEntities(options?: {center?: {x: number, y: number, z: number} | [number, number, number], radius?: number, type?: string, where?: {healthBelow?: number, inCombatWithin?: number, hostile?: boolean, player?: boolean, mob?: boolean, owned?: boolean, teammate?: boolean, entity?: string | string[], airborne?: boolean, onGround?: boolean, hasEffect?: string | string[], effectLevel?: {id: string, at_least: number}, flag?: string | string[], not?: any, any?: any[], all?: any[]}, limit?: number}): {id: string, type: string, name: string, x: number, y: number, z: number, health?: number, maxHealth?: number, player: boolean, hostile: boolean, teammate: boolean, ally: boolean, owned: boolean, airborne: boolean, entity: string, distance?: number, item?: string, count?: number}[]", "params": "options?: {center?: {x: number, y: number, z: number} | [number, number, number], radius?: number, type?: string, where?: {healthBelow?: number, inCombatWithin?: number, hostile?: boolean, player?: boolean, mob?: boolean, owned?: boolean, teammate?: boolean, entity?: string | string[], airborne?: boolean, onGround?: boolean, hasEffect?: string | string[], effectLevel?: {id: string, at_least: number}, flag?: string | string[], not?: any, any?: any[], all?: any[]}, limit?: number}", "returns": "{id: string, type: string, name: string, x: number, y: number, z: number, health?: number, maxHealth?: number, player: boolean, hostile: boolean, teammate: boolean, ally: boolean, owned: boolean, airborne: boolean, entity: string, distance?: number, item?: string, count?: number}[]", "doc": "Entities near a point (center: the drone), nearest first, never the drone itself. radius is at most 16 and the answer at most 64. type is \"hostile\", \"player\", \"living\" (the default), \"item\" or an entity type id. `where` keeps only the bodies that pass a guard, e.g. {where: {hostile: true, airborne: true}}: the same guard objects an ability's `when:` takes, limited to the keys that ask about a body (see check). Same scan rate as scanBlocks." }, { "name": "moveTo", "signature": "drone.moveTo(p: {x: number, y: number, z: number} | [number, number, number], options?: {within?: number}): action", "params": "p: {x: number, y: number, z: number} | [number, number, number], options?: {within?: number}", "returns": "action", "doc": "Flies to the block at p, until within `within` blocks (0.4, at least 0.3). Refused when p is out of the owner's range or unloaded." }, { "name": "follow", "signature": "drone.follow(who?: \"owner\" | {id: string} | string, options?: {distance?: number}): action", "params": "who?: \"owner\" | {id: string} | string, options?: {distance?: number}", "returns": "action", "doc": "Goes to someone and finishes once within `distance` blocks (6): the owner by default, which also sends the drone back to its place beside them." }, { "name": "patrol", "signature": "drone.patrol(points: {x: number, y: number, z: number} | [number, number, number][], options?: {loops?: number}): action", "params": "points: {x: number, y: number, z: number} | [number, number, number][], options?: {loops?: number}", "returns": "action", "doc": "Flies the points in order, `loops` times (1; 0 for until interrupted). At most 32 points." }, { "name": "breakBlock", "signature": "drone.breakBlock(p: {x: number, y: number, z: number} | [number, number, number]): action", "params": "p: {x: number, y: number, z: number} | [number, number, number]", "returns": "action", "doc": "Breaks the block at p as the owner, taking what drops into the drone's inventory (the overflow is dropped at the drone). Takes longer for harder blocks; at most one block every four ticks. Refused for bedrock, anything harder than 3, a container with items in it, anything unbreakable, or beyond 5 blocks of the drone. Evaluates to {ok, id, items}." }, { "name": "placeBlock", "signature": "drone.placeBlock(p: {x: number, y: number, z: number} | [number, number, number], itemId: string): action", "params": "p: {x: number, y: number, z: number} | [number, number, number], itemId: string", "returns": "action", "doc": "Places a block item from the drone's inventory at p, which must be air or something replaceable." }, { "name": "deposit", "signature": "drone.deposit(chest: {x: number, y: number, z: number} | [number, number, number], options?: {keep?: object}): action", "params": "chest: {x: number, y: number, z: number} | [number, number, number], options?: {keep?: object}", "returns": "action", "doc": "Walks to the container at `chest` (a chest input: `// @input chest \"...\"`, then args.chest) and puts the drone's items in it, except those `keep` names, e.g. {\"minecraft:torch\": 16} keeps 16 torches. Evaluates to {ok, moved}; {ok: false} when no chest was given, so check `args.chest` first and use setDelivery(\"owner\") when it is undefined." }, { "name": "giveToOwner", "signature": "drone.giveToOwner(): action", "params": "", "returns": "action", "doc": "Goes to the owner and hands over everything it carries." }, { "name": "setDelivery", "signature": "drone.setDelivery(mode: \"owner\" | \"inventory\"): string", "params": "mode: \"owner\" | \"inventory\"", "returns": "string", "doc": "Where what the drone collects (pickUp, collectNearby, what a break or harvest drops) goes: \"inventory\" (the default) keeps it in the drone's nine slots; \"owner\" puts it straight into the owner's inventory while they are online, in the drone's dimension and within 32 blocks of it, and drops what does not fit at their feet where only they can pick it up. Out of range or offline, it falls back to the drone's inventory. A trail of sparks marks each delivery. Returns the mode." }, { "name": "pickUp", "signature": "drone.pickUp(item: {id: string} | string | string): action", "params": "item: {id: string} | string | string", "returns": "action", "doc": "Flies to a dropped item (an entity from scanEntities({type: \"item\"}), or an item id such as \"minecraft:cobblestone\" for the nearest one) and picks it up, into the inventory or the owner's per setDelivery. Waits out the item's pickup delay. Refused for an item another player threw in the last 30 seconds, one that belongs to another player, one within a block of a player who is not the owner, or one out of the owner's range. Evaluates to {ok, count}." }, { "name": "collectNearby", "signature": "drone.collectNearby(options?: {radius?: number, filter?: string | string[], limit?: number}): action", "params": "options?: {radius?: number, filter?: string | string[], limit?: number}", "returns": "action", "doc": "Picks up the items round the drone, nearest first, under pickUp's rules, until none is left or `limit` items are in (2304 by default). radius is at most 16 (8 by default); filter is an item id, an item tag (\"#minecraft:logs\") or a list of them. Evaluates to {ok, count}, ok even when there was nothing to take." }, { "name": "take", "signature": "drone.take(p: {x: number, y: number, z: number} | [number, number, number], itemId: string, n: number): action", "params": "p: {x: number, y: number, z: number} | [number, number, number], itemId: string, n: number", "returns": "action", "doc": "Walks to the container at p and takes up to n of an item into the drone's inventory." }, { "name": "harvest", "signature": "drone.harvest(p: {x: number, y: number, z: number} | [number, number, number]): action", "params": "p: {x: number, y: number, z: number} | [number, number, number]", "returns": "action", "doc": "Breaks a fully grown crop at p and keeps what it drops; remembers its seed for replant. Refused when it is not grown." }, { "name": "replant", "signature": "drone.replant(p: {x: number, y: number, z: number} | [number, number, number]): action", "params": "p: {x: number, y: number, z: number} | [number, number, number]", "returns": "action", "doc": "Plants again the crop last harvested at p, from the drone's own seeds." }, { "name": "bonemeal", "signature": "drone.bonemeal(p: {x: number, y: number, z: number} | [number, number, number]): action", "params": "p: {x: number, y: number, z: number} | [number, number, number]", "returns": "action", "doc": "Uses one bone meal from the drone's inventory on the crop at p." }, { "name": "attack", "signature": "drone.attack(who: {id: string} | string): action", "params": "who: {id: string} | string", "returns": "action", "doc": "Fights one body with its own moves until it is dead or a minute has passed. Never the owner, their team, their units, or (unless the server allows it) players. Evaluates to {ok, killed}." }, { "name": "focus", "signature": "drone.focus(options?: {type?: string}): action", "params": "options?: {type?: string}", "returns": "action", "doc": "Fights up to eight bodies near it, nearest first, in place of its own choice; type is as scanEntities'. Finishes when they are dead or a minute has passed." }, { "name": "guard", "signature": "drone.guard(center: {x: number, y: number, z: number} | [number, number, number], radius: number, options?: {ticks?: number}): action", "params": "center: {x: number, y: number, z: number} | [number, number, number], radius: number, options?: {ticks?: number}", "returns": "action", "doc": "Holds the circle of that radius (2 to 48) round center, fighting hostiles that enter it, for `ticks` (until interrupted by default)." }, { "name": "useMove", "signature": "drone.useMove(abilityId: string, target?: {id: string} | string): action", "params": "abilityId: string, target?: {id: string} | string", "returns": "action", "doc": "Fires one of the drone's own moves, e.g. \"thematic:tractor_beam\" (or just \"tractor_beam\": a bare id means thematic:), at a target, on the move's usual cooldown. Refused when the drone does not have the move or it is not ready. A player may be the target only when the server allows combat against players, or they set off an enemyAbility event in the last ten seconds." }, { "name": "sleep", "signature": "drone.sleep(seconds: number): action", "params": "seconds: number", "returns": "action", "doc": "Does nothing for a while: the way to wait, in seconds as the pack's wait(seconds) is, e.g. yield drone.sleep(1.5). At least one tick; at most an hour." }, { "name": "wait", "signature": "drone.wait(ticks: number): action", "params": "ticks: number", "returns": "action", "doc": "DEPRECATED: use sleep(seconds). Does nothing for a while, counted in TICKS (20 is a second), where a pack's wait counts seconds. Still works; yield 20 (a bare number yields ticks) does the same." }, { "name": "notify", "signature": "drone.notify(text: string, options?: {color?: string, chat?: boolean}): boolean", "params": "text: string, options?: {color?: string, chat?: boolean}", "returns": "boolean", "doc": "Shows the owner (only them) a line of text, on their action bar or, with chat: true, in their chat: the pack's notify (color is a Minecraft formatting such as \"red\", \"gold\", \"aqua\"). At most four a second; answers false when one was dropped. log is for you in the editor; notify is for the player in the world." }, { "name": "check", "signature": "drone.check(guard: {healthBelow?: number, inCombatWithin?: number, hostile?: boolean, player?: boolean, mob?: boolean, owned?: boolean, teammate?: boolean, entity?: string | string[], airborne?: boolean, onGround?: boolean, hasEffect?: string | string[], effectLevel?: {id: string, at_least: number}, flag?: string | string[], not?: any, any?: any[], all?: any[]}, who?: {id: string} | string): boolean", "params": "guard: {healthBelow?: number, inCombatWithin?: number, hostile?: boolean, player?: boolean, mob?: boolean, owned?: boolean, teammate?: boolean, entity?: string | string[], airborne?: boolean, onGround?: boolean, hasEffect?: string | string[], effectLevel?: {id: string, at_least: number}, flag?: string | string[], not?: any, any?: any[], all?: any[]}, who?: {id: string} | string", "returns": "boolean", "doc": "Asks a guard about the drone, or about `who` (an entity from a scan or event, or \"owner\"), measured against the owner: owned and teammate say how the body stands to them. A guard is the same object an ability's `when:` takes and is read by the same evaluator, limited to the keys that ask about a body: healthBelow (health-bar units, 1000 is full), inCombatWithin (seconds), hostile, player, mob, owned, teammate, entity (type id or #tag), airborne, onGround, hasEffect, effectLevel, flag (read only), and not, any (or) and all (and) to combine. Any other key is an error that lists these. e.g. drone.check({hostile: true, not: {airborne: true}}, target)." }, { "name": "log", "signature": "drone.log(...text: any): void", "params": "...text: any", "returns": "void", "doc": "Adds a line to the program's log, the one the editor shows." }, { "name": "on", "signature": "drone.on(event: string, fn: (event: {ability: string, tags: string[], caster: {id: string, type: string, name: string, x: number, y: number, z: number, health?: number, maxHealth?: number, player: boolean, hostile: boolean, teammate: boolean, ally: boolean, owned: boolean, airborne: boolean, entity: string, distance?: number, item?: string, count?: number}, target?: {id: string, type: string, name: string, x: number, y: number, z: number, health?: number, maxHealth?: number, player: boolean, hostile: boolean, teammate: boolean, ally: boolean, owned: boolean, airborne: boolean, entity: string, distance?: number, item?: string, count?: number}, direction: {x: number, y: number, z: number}, tick: number}) => void, options?: {ability?: string | string[]}): boolean", "params": "event: string, fn: (event: {ability: string, tags: string[], caster: {id: string, type: string, name: string, x: number, y: number, z: number, health?: number, maxHealth?: number, player: boolean, hostile: boolean, teammate: boolean, ally: boolean, owned: boolean, airborne: boolean, entity: string, distance?: number, item?: string, count?: number}, target?: {id: string, type: string, name: string, x: number, y: number, z: number, health?: number, maxHealth?: number, player: boolean, hostile: boolean, teammate: boolean, ally: boolean, owned: boolean, airborne: boolean, entity: string, distance?: number, item?: string, count?: number}, direction: {x: number, y: number, z: number}, tick: number}) => void, options?: {ability?: string | string[]}", "returns": "boolean", "doc": "Runs fn each time an event fires, under the program's own budget. The one event is \"enemyAbility\": another player's ability, heard when they carry the console's gate effect at its level (a status effect at its cap, for a summoner's units) within 32 blocks of the owner and are not on the owner's side; the server decides whether it is on at all. The event is {ability, tags, caster, target, direction, tick}. Each subscription costs capacity. Returns false when this console gives no such event. options.ability keeps only those moves, e.g. {ability: \"feral_leap\"}: a bare id means thematic:, as everywhere in a pack. Inside fn, drone.interrupt(...) swaps the program's current action." }, { "name": "interrupt", "signature": "drone.interrupt(action: action): void", "params": "action: action", "returns": "void", "doc": "Replaces the action the program is waiting on with this one; the program carries on when the new action finishes. For an event handler: drone.interrupt(drone.useMove(id, event.caster))." } ] }, { "type": "owner", "doc": "The player the drone works for. Read only; every call answers at once.", "methods": [ { "name": "pos", "signature": "owner.pos(): {x: number, y: number, z: number}", "params": "", "returns": "{x: number, y: number, z: number}", "doc": "Where the owner is." }, { "name": "health", "signature": "owner.health(): number", "params": "", "returns": "number", "doc": "Their health, in the units the action bar shows (a full bar is 1000 in a suit)." }, { "name": "maxHealth", "signature": "owner.maxHealth(): number", "params": "", "returns": "number", "doc": "Their full health, in those units." }, { "name": "pool", "signature": "owner.pool(): number", "params": "", "returns": "number", "doc": "Their health as a fraction of full, 0 to 1." }, { "name": "overshield", "signature": "owner.overshield(): number", "params": "", "returns": "number", "doc": "Their overshield (absorption), in the same units." }, { "name": "inCombat", "signature": "owner.inCombat(): boolean", "params": "", "returns": "boolean", "doc": "Whether they took or dealt damage in the last ten seconds." }, { "name": "facing", "signature": "owner.facing(): {x: number, y: number, z: number}", "params": "", "returns": "{x: number, y: number, z: number}", "doc": "The way the owner faces, as a horizontal unit vector (y is 0): where a tunnel dug \"the way I am looking\" runs." }, { "name": "distance", "signature": "owner.distance(): number", "params": "", "returns": "number", "doc": "How far they are from the drone." }, { "name": "check", "signature": "owner.check(guard: {healthBelow?: number, inCombatWithin?: number, hostile?: boolean, player?: boolean, mob?: boolean, owned?: boolean, teammate?: boolean, entity?: string | string[], airborne?: boolean, onGround?: boolean, hasEffect?: string | string[], effectLevel?: {id: string, at_least: number}, flag?: string | string[], not?: any, any?: any[], all?: any[]}): boolean", "params": "guard: {healthBelow?: number, inCombatWithin?: number, hostile?: boolean, player?: boolean, mob?: boolean, owned?: boolean, teammate?: boolean, entity?: string | string[], airborne?: boolean, onGround?: boolean, hasEffect?: string | string[], effectLevel?: {id: string, at_least: number}, flag?: string | string[], not?: any, any?: any[], all?: any[]}", "returns": "boolean", "doc": "Asks a guard about the owner: owner.check({healthBelow: 300}) is true when they are below 300 on the health bar (1000 is full; owner.pool() is the fraction). The same guard objects an ability's `when:` takes; see drone.check for the keys." } ] }, { "type": "action", "doc": "Something a program waits on: what a drone call returns. yield it; it evaluates to {ok: true, ...} or {ok: false, reason}.", "methods": [] } ], "ability_format": { "about": "An ability component (thematic:composed): data//abilities//.js, a script that builds it (section ability_script), or the JSON it builds as .json. The file name is the id. A component is \"parts\" -- a key (press, hold or toggle; none for a passive), a cooldown, a gauge, requirements, visuals, reactions ... -- and \"phases\", named sets of parts the wearer is in for a while: a key's use leads, via its \"then\", to cooldown, ready, or a phase that lasts, ticks and answers events. Numbers left out come from defaults.csv. Worked examples: data/thematic/abilities/daredevil/devil_out.js (a window), docs/examples/abilities/brimstone_parry.js (a hold with a reaction).", "parts": { "press": "what pressing the key does: {\"steps\": [...], \"then\": exit}. \"then\" is where the steps lead: \"cooldown\" (default), \"ready\", or a phase", "hold": "what holding the key does: {\"steps\": [...], \"then\": phase}. The phase is held open while the key is down; letting go is a \"release\" it answers", "toggle": "what switching the key on does: {\"steps\": [...], \"then\": phase held while on, \"off_steps\": [...], \"on_equip\": true, \"bones\": {\"show\": [...], \"hide\": [...]}}", "cooldown": "the ability's cooldown, tuned in defaults.csv: {} or {\"from\": \"press\" | \"use\", \"steady\": true, \"persistent\": true, \"while\": guard (it counts only while the guard holds)}. Without one, nothing may lead to \"cooldown\"", "gauge": "a hold's heat meter, in the cooldown slot: fills while held, a full one lets go, cools after", "requires": "a guard that must hold for the ability to be usable; or a list [{\"if\": guard, \"message\": key, \"color\": formatting}]. The HUD padlocks it while it fails", "let": "{\"name\": value} -- values drawn once per use; a field written \"$name\" reads it", "mob": "how a mob wearing the suit uses the move: {\"max_range\", \"cooldown\", \"weight\", \"lasts\", \"steps\", \"every\", \"on\", \"end\" ...}", "switches": "[{\"id\", \"name\", \"icon\", \"on\"}] -- switches the ability wheel shows for it", "visual": "a client visual, or a list: a name, or {\"id\": name, ...options}", "on": "{\"event\": {\"if\": guard, \"do\": [...], \"steps\": [...], \"then\": exit}} -- how the component (in no phase) or the phase answers the world. \"tick\" is a keyless component's watch", "ultimate": "true, or {\"blocks_keys\": false}: the suit's ultimate. Its cooldown scales as one, and pressing it parks the rest of the kit unless blocks_keys is false", "ultimate_immune": "true: an ultimate's press leaves this ability's cooldown alone", "equips": "true: a toggle that puts the wearer's item out; a kit move refused only for the item in hand switches it on first", "equip_delay": "seconds (0 to 5, default 0.1): on an equipping toggle, how long a kit move pressed without the item waits for it to come out", "immune_to": "[damage type ids] the wearer takes no damage from while the ability is on the suit, e.g. [\"minecraft:fall\"]", "exclusive": "true, or {\"message\": translation key, \"color\": formatting}: while active, the rest of the suit can not be pressed", "while_active": "{\"still_limbs\", \"silent_steps\", \"cape_angle\"} -- the wearer's body while the ability is active", "stun_immune": "true: stuns, an ultimate's lockout and move locks pass this ability by (Berserker Rage)", "two_handed": "true: while active or held, first person draws the off arm too, as for a two-handed move", "locked_suffix": "a translation key, or {\"key\", \"args\": [...], \"color\": formatting (red)}: shown after the name, beside the padlock, while \"requires\" fails", "wheel_icon": "an item id: the ability's icon on the ability wheel when the suit's options give none (minecraft:feather)", "cosmetic_key": "true: the ability wheel puts it on the cosmetic key, beside the hood and other looks", "requires_target": "true: the move needs a locked target -- pressing it without one is refused, and the suit marks whoever is locked on to. Select that target with targets(\"locked\")", "body": "{\"still_limbs\", \"silent_steps\", \"no_sprint_particles\", \"cape\", \"cape_wrap\", \"cape_flare\", \"launch_lock\", \"pose_grace\", \"while\"} -- the wearer's body while the ability is active (\"while\": \"animating\": while its pose claim holds)", "camera": "{\"no_view_bob\", \"no_flight_sprint\", \"owns_flight_pose\", \"no_flight_tilt\"} -- what the camera and flight leave to the move while the ability is active (or held)", "lock_input": "{\"move\", \"pin_position\", \"jump\", \"look\", \"attack\"} -- the wearer's own inputs taken away while the ability is active", "hide_bones": "[bone names], or {\"bones\": [...], \"flag\": wearer flag, \"while\": \"active\" | \"cooldown\"} -- suit bones hidden while the ability is active (or cooling down)", "damage_bonus": "{\"times\": share, \"plus\": amount, \"melee\": bool, \"when\": guard, \"by\": \"self\" | \"owned\", \"within\": blocks, \"worn\": bool}: for as long as the suit has the ability (a toggle: while it is on, unless worn), each hit the wearer lands carries amount * times + plus more, inside the hit. when: a guard each hit must pass, asked with the body struck as the target ({\"marked_by\": \"quarry_mark\"}) and the hit's element and source as the event's ({\"source\": \"thematic:ballistic\"}: a gun's shot; the ballistic element also counts arrows). melee: true is only the wearer's own melee swings. by: \"owned\" rides the hits the wearer's own mobs land instead (a golem, a tamed wolf -- one landed in its own name, not credited to the wearer), while the mob is within within blocks of them (16). times and plus may read the wearer's body and held gun (health, gun_damage, gun_rpm...) and what the struck body carries ({effect_level: id, of: \"target\"}); a negative times cuts the hit. worn: true holds a toggle's bonus while it is off too (a standing stalk outlives the visor that made it)", "stats": "{\"attack\", \"defense\", \"speed\", \"utility\": points, \"when\": guard}: added to the wearer's suit stats while the ability is active (a passive: always), and with when only while that guard holds of the wearer -- e.g. {\"attack\": 15, \"when\": {\"sunlit\": true}}", "attributes": "attribute modifiers held on the wearer, [{\"attribute\": \"minecraft:generic.movement_speed\", \"amount\": -0.2, \"operation\": \"add\" | \"multiply_base\" | \"multiply_total\", \"uuid\": \"...\"}]: put on under their uuid while the ability is active (a passive: for as long as the suit has it), and taken off when it is not", "damage_taken": "{\"times\": share, \"when\": {...}}: while the ability is active (a passive: for as long as the suit has it), every hit on the wearer lands at times its size -- under 1 soaks part of it, over 1 adds to it -- as a phase's damage_taken does while the wearer is in it, with the same when (e.g. {\"not_element\": [\"psychic\", \"magic\"]}: plating that turns everything but the mind and magic)", "wheel": "a radial menu on the ability's key: hold to open, let go on an entry to pick it. {\"source\": \"construct_favourites\"} is the ring's starred constructs (a pick is the construct grid's summon); otherwise {\"entries\": [{\"id\", \"icon\", \"label\", \"cost\": {\"item\", \"count\"}, \"cooldown\": seconds, \"do\": [actions]}]} run on the server, which refuses a pick the wheel does not list. \"color\" and \"accent\" (\"#RRGGBB\") paint the wedges and the ready band; a suit's wheel_color and wheel_accent options override them. \"cooldown\": true makes a pick start the tuned cooldown. \"tap\": \"last\" makes a quick tap re-fire the entry picked last without opening the dial. A press only", "console": "a command console: a live overlay with a free cursor that expands into a desktop of windows and a tactical map. {\"widgets\": [{\"id\", \"kind\": button|toggle|choice|units|readout|map|draw|mode|programs, \"do\": actions...}], \"pages\", \"windows\", \"theme\", \"group\"}. The layout is synced to the client, which draws it; every press is checked again on the server against the widget's visible_when / enabled_when guards and runs its actions there. Written in a script with component.console(con => ...)", "hud_label": "[{\"if\": guard, \"text\": translation key, \"args\": [{\"seconds_until\": key, \"round\": \"up\" | \"down\"} | {\"combat_left\": seconds}], \"color\": formatting}]: text shown after the ability's name on the HUD, whatever it is doing -- the first rule whose guard holds, none for none. seconds_until counts down to a deadline mark_deadline stored (never below 1); combat_left is what is left of a fight window that long (dealt or took damage), rounded up", "environment": "{\"breathe_underwater\", \"underwater_vision\", \"walk_on_fluid\", \"walk_on_powder_snow\": true, \"terrain_speed\": [{\"blocks\": [ids or #tags], \"bonus\": speed, \"per_level\": share, \"level\": level}]}: breathing and seeing clearly under water, standing on fluids and on powder snow, and moving bonus * (1 + level * per_level) faster on the named blocks (level defaults to the ability's authored level; a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down); \"when\": a guard asked of the wearer each time, so they hold only while it does (a speedster's water running above a speed). While the ability is active (a passive: always)", "neutral_mobs": "true, or {\"mobs\": [entity type ids or #tags]}: mobs leave the wearer alone -- true is every mob, hostile NPCs included; mobs names only those. While the ability is active (a passive: always)", "silent_steps": "true: no footstep sounds. While the ability is active (a passive: always)", "force_run": "true: the wearer keeps running forward whatever the keys say. While the ability is active (a passive: always)", "vibrating": "true: the wearer's body vibrates through attacks, as a speedster's mirage copies. While the ability is active (a passive: always)", "invisible": "true: unseen -- others draw no name tag for the wearer. While the ability is active (a passive: always)", "fully_invisible": "true: not drawn at all -- the suit, the body and what it holds (invisible only hides the name tag). While the ability is active (a passive: always)", "slow_motion_immune": "true: slowed time never catches the wearer (the slow_motion move and the slow_time verb skip them). While the ability is active (a passive: always)", "heavy": "true: moves barely shift the wearer -- a push, launch or blast knockback keeps only what their knockback resistance lets through, and never lifts them off the ground. While the ability is active (a passive: always)", "loot": "{\"chest_luck\": level, \"looting\": level, \"when\": guard}: extra Luck while opening a loot chest, and extra Looting levels on a kill -- with when, only on a kill whose body passes it, asked as the target ({\"marked_by\": \"quarry_mark\"}); every such move the wearer has adds. a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down. While the ability is active (a passive: always)", "enchant_bonus": "{\"\": level, ..., \"item\": \"main_hand\" | \"off_hand\", \"when\": guard}: the held item counts as having that many more levels of each enchantment while a block is broken (Fortune on a pickaxe), put back after, and when the wearer attacks with it (Sharpness on a mace: its damage, knockback, fire aspect and sweep count them); with when, only while that guard holds of the wearer. a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down. While the ability is active (a passive: always)", "draw_speed": "{\"times\": multiplier, \"when\": guard}: the bow draws times as fast (2 reaches a full draw in half the time); every draw speed the wearer has multiplies; with when, only while that guard holds of the wearer (e.g. {\"riding\": true}). While the ability is active (a passive: always)", "movement": "{\"double_jump\": true or jumps or \"level\" or {\"per_level\": jumps, \"level\": level, \"min_level\": level}, \"wall_cling\": true, \"dodge_roll\": true or {\"cooldown\": seconds, \"clip_prefix\": \"dodge_\"}, \"climb\": true or {\"speed\": pull, \"while\": guard}, \"wall_run\": true, \"charge\": {\"speed\": blocks a tick, \"ramp\": per tick, \"max\": blocks a tick, \"toward\": \"locked\" | \"marked\", \"key\": data key, \"face\": true}, \"lunge\": {\"ticks\": n, \"distance\": blocks or \"speed\": blocks a tick, \"along\": \"yaw\" | \"look\", \"keep_vertical\": true}, \"swim_boost\": true or {\"per_speed\": 0.15, \"vertical\": 3}, \"tunnel\": true or {\"floor\": blocks, \"blocked_by\": [block ids]}, \"no_sprint\": true, \"step_height\": blocks, \"drift\": true or {\"friction\": 0.5, \"accel\": 1}, \"gravity\": scale, \"wall_crawl\": true or {\"sounds\": {\"left\": [sound ids], \"right\": [sound ids]}, \"backflip\": true}}: double_jump gives one jump in the air before landing (a number gives that many; 2 is a triple jump; {per_level, level} gives per_level jumps a level, rounded down, none below min_level (default 0), and \"level\" one a level of the ability's own authored level -- a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down); wall_cling holds the wearer on a wall while they sneak in the air, and kicks them off it when they let go moving; dodge_roll rolls them forward or back on the dodge key (default 1.5 s apart, clips forward / back, _air in the air); climb grips the wall ahead (jump climbs, sneak slides down; speed defaults to 0.49; while must hold to grip); wall_run sprints them along walls; charge drives them along where they look every tick, speed blocks a tick growing by ramp a tick up to max -- with toward, straight at a body instead, on all three axes: \"locked\" their lock-on, \"marked\" the one markTarget() stored under key (charge_target), turned to face it unless face is false, and with no such body nothing happens that tick; lunge drives them for ticks ticks from when it starts, at speed (or distance spread over the ticks) along their yaw (level, the default) or look as it started, their own rise and fall kept unless keep_vertical is false; swim_boost, sprinting under water, adds the suit's speed times per_speed (0.15) of their look to their velocity each tick, the vertical vertical (3) times that; tunnel lets them walk through blocks held on top of a floor found up to floor (2) blocks under their feet, with no jumping, and touching a blocked_by block (bedrock, barriers, structure voids, command blocks) ends the move and starts its cooldown. charge, lunge and swim_boost are steered by the wearer's own client, so they read as their own running; no_sprint stops them sprinting at all (the sprint key and double-tap are ignored, no sprint pose, field-of-view kick or sprint particles; pair it with a movement_speed attribute to keep their pace); step_height is how many blocks they walk straight up without jumping (vanilla 0.6, 1 a full block; the higher of theirs and vanilla's); drift eases their speed on the ground in and out on their own client, so they drift on a little when they stop -- friction (0.5) is how much of vanilla's ground friction still applies, accel (1) their top speed times vanilla's; gravity scales how hard they fall while moving down (0.75 a quarter lighter; jumps rise as usual); wall_crawl grips a wall the wearer walks into (forward climbs, back descends, no keys cling, strafe moves along the face and round corners, jump leaps off, sneak lets go, or with backflip leaps back off the face in the swing's back flip) with no web line out, at the ability's amplifier times its base speed, the sounds played on alternate footfalls; put one on a phase to have it for that phase. While the ability is active (a passive: always)", "adjust_value": "a meter key: the raise and lower speed keys turn this meter up and down (2 a press, 8 sneaking) instead of the speedster dial. \"speed\" is the speedster dial itself. While the ability is active (a passive: always)", "flight": "true, or {\"hover\": true, \"fast\": true, \"sprint_to_enter\": bool, \"windup\": {\"ticks\": n, \"requires\": guard, \"animation\": clip, \"stages\": [{\"at\": tick | \"launch\", \"every\": ticks, \"do\": [actions]}]}}: the wearer flies -- hovering as in creative (hover), and tearing along while sprinting in the air (fast; with sprint_to_enter, sprinting in the air starts it by itself, otherwise the suit's flight profile decides). A windup makes fast flight wait until the wearer has sprinted for ticks with requires holding, playing animation as it starts; each of its stages runs its actions (written as action objects) when the wind-up has counted at ticks (0: as it starts), or at \"launch\" -- the first tick fast flight takes over -- and then every every ticks while it lasts. Falls and flying into walls do the flyer no harm, and a hit from a mob or player grounds them for 2 seconds. Speeds come from the suit's flight profile. While the ability is active (a passive: always)", "glide": "true, or {\"needs_air_below\": true, \"immune\": true, \"when\": guard}: the wearer glides as on an elytra once airborne (with needs_air_below, only over two blocks of air; with when, only while it holds); immune: flying into a wall does no harm. While the ability is active (a passive: always)", "deflect": "true, or {\"projectiles\": true, \"beams\": false, \"reverse\": true, \"take_ownership\": true, \"chance\": share or {\"per_level\": share, \"level\": level}, \"when\": guard}: projectiles that would hit the wearer are turned back the way they came (reverse; otherwise they just miss) and become the wearer's (take_ownership); with beams, beams are bounced back at the shooter. chance is the odds of each (default always; per_level x the level, which defaults to the ability's; a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down); with when, only while that guard holds of the wearer. While the ability is active (a passive: always)", "affinity": "{\"kind\": \"weakness\" | \"resistance\", \"element\": damage element, \"level\": 1-3}: how an element treats the suit that has this ability. A weakness makes the element's hits land 16/33/50% harder and brings its debuffs; a resistance soaks as much. level also takes the names: vulnerable/damaging/deadly, mild/normal/strong (1)", "charges": "uses the key holds before it waits: {\"count\": 3, \"recharge\": seconds}. Each use spends one; each comes back in turn over the recharge (the tuned cooldown when left out). The HUD reads what is left under Charges", "meter": "a named resource kept on the wearer: an amount between 0 and max that may come back by itself, or -- with decay -- a window that opens, banks or bleeds and closes by itself. {\"key\", \"max\", \"regen\", \"decay\", \"persistent\", \"hud\"...}; the meter verbs fill and spend it, the meter guards ask about it", "costs": "a key's use paid from a meter: {\"meter\": key, \"per_use\": n, \"per_tick\": n}. While the meter can't pay, the key is held back; a tick it can't pay for ends the use", "tether": "the key throws a line and the wearer moves on it: {\"line\": \"swing\" | \"slingshot\" | \"hang\", ...}. A swing (a hold) zips on a tap and swings on a hold; a slingshot (a hold) draws two lines and launches; a hang (a press) hangs from a line overhead and drops onto a target on the next press. Range, damage and cooldown are the ability's tuning", "loadout": "keeps one of the wearer's named inventories as a loadout: {\"inventory\": \"gadgets\", \"size\": 36, \"display\": true, \"roster\": name}. The select key cycles it (loadout_cycle), the use key uses it (loadout_use), the HUD draws it and a loadout bench fills it; the suit's level option is how many slots it reaches, its default_item option the free item" }, "phase_parts": { "on": "{\"event\": {\"if\": guard, \"do\": [...], \"steps\": [...], \"then\": exit}} -- how the component (in no phase) or the phase answers the world. \"tick\" is a keyless component's watch", "lasts": "how long the phase lasts: \"duration\" (tuned) or seconds, or {\"time\": either, \"steady\": false, \"then\": exit} -- \"then\" is where running out leads (\"cooldown\" by default)", "steps": "a running order that starts on arrival: [{\"at\": seconds, \"do\": [...]}]", "every": "[{\"seconds\", \"chance\", \"clock\", \"start\", \"do\"}] -- what happens while here. seconds may be worked out (an Amount), read each time: a beat that quickens with a count the press keeps", "until": "[{\"if\": guard, \"then\": exit, \"do\": [...], \"check\": \"before\" | \"after\"}] -- ways out checked every tick", "hold_open": "{\"while\": guard, \"end_when\": guard, \"max\": seconds, \"grace\": seconds, \"then\": exit} -- a timed phase can't run out while \"while\" holds", "on_exit": "[actions] run as the phase is left, whichever way -- also when the wearer dies, logs out or takes the suit off", "animation_speed": "how fast the clip this phase plays runs (1): an Amount", "blocks_movement": "true to plant the wearer's feet while here", "hud_suffix": "{\"text\": \" - BRACING\", \"formatting\": [\"dark_red\", \"bold\"]} after the ability's name on the HUD while here", "slows_cooldowns": "a fraction 1/n, e.g. 0.2: the wearer's other abilities' cooldowns tick one tick in every n while here", "stun_immune": "true: while here, stuns, an ultimate's lockout and move locks pass this ability by (Run Wild's charge)", "unstoppable": "true, or {\"clear\": [effect ids or groups]}: every tick here, those effects come off the wearer. true clears [stun, thematic:immobile]; groups are [flash, stun]", "immune": "true, or {\"damage\": \"all\" | [damage type ids or #tags], \"grace\": seconds, \"tally\": name | {\"name\", \"mode\": \"sum\"|\"last\"}}: the wearer takes none of that damage while here, nor for grace seconds after. tally writes what was absorbed to _, zeroed on the press. Also \"if\": a guard about the wearer the immunity waits on; \"unless\": a guard about the hit (as a hurt reaction's, e.g. {element: \"emp\"}) whose hits are taken after all; \"soak\": true scales the hit to nothing where armour applies instead of calling it off, so it still lands -- knockback, the flash, the attacker's on-hit effects", "hides_swing": "true: while here, the wearer's own main-hand swing at a living thing under the crosshair is not drawn (pair with cancelEvent() on attack, so the move's own animation shows instead of a punch)", "body": "{\"still_limbs\", \"silent_steps\", \"no_sprint_particles\", \"cape\", \"cape_wrap\", \"cape_flare\", \"launch_lock\", \"pose_grace\", \"pose_claim\"} -- the wearer's body while in this phase", "camera": "{\"no_view_bob\", \"no_flight_sprint\", \"owns_flight_pose\", \"no_flight_tilt\"} -- what the camera and flight leave to the move while in this phase", "lock_input": "{\"move\", \"pin_position\", \"jump\", \"look\", \"attack\"} -- the wearer's own inputs taken away while in this phase", "hide_bones": "[bone names], or {\"bones\": [...], \"flag\": wearer flag} -- suit bones hidden while in this phase", "damage_bonus": "{\"vs\": \"tracked\" | \"any\", \"times\": share, \"plus\": amount, \"for\": seconds, \"track\": name}: while here, each hit the wearer lands on that target carries amount * times + plus more, inside the hit. vs tracked (default) is the entity thematic:track holds (the track named track, default the ability's id), for seconds counted from when the track started; vs any is everyone, for seconds counted from entering the phase. for left out: the whole phase. melee: true is only the wearer's own melee swings. when: a guard each hit must pass, asked with the body struck as the target and the hit's element and source as the event's", "holds_cooldown": "true: with \"cooldown\": \"on_press\", the cooldown the press started does not count down while here (a dash that has not landed yet); it runs on from the first tick after", "attributes": "attribute modifiers held on the wearer, [{\"attribute\": \"minecraft:generic.movement_speed\", \"amount\": -0.2, \"operation\": \"add\" | \"multiply_base\" | \"multiply_total\", \"uuid\": \"...\"}]: put on under their uuid as the wearer enters the phase, and taken off as they leave it", "damage_taken": "{\"times\": share, \"when\": {\"attacker_within\": blocks, \"melee\": true, \"element\": words, \"not_element\": words}}: while here, every hit on the wearer lands at times its size -- under 1 soaks part of it (where armour counts, so the hit still lands and can be answered), over 1 adds to it (inside the hit); with when, only the hits whose attacker stands within that many blocks (any worked-out number), with melee, that a living body delivers itself rather than anything thrown or shot, with element, made of one of those elements, with not_element, made of none of those, and with attacker, a guard whoever struck it must pass (asked with the attacker as the target: {\"attacker\": {\"marked_by\": \"example_mark\"}} is a hit from someone the wearer marked)", "phase": "true, or {\"if\": guard, \"solid\": false, \"density\": true}: while here the wearer is phased -- they pass through blocks (noclip, falling through the floor) and their body is drawn density-shifted. solid: true keeps them colliding with the world, the shift only; density: false leaves the body drawn as it is; if: a guard about the wearer the phase waits on (e.g. a suit's option)", "environment": "{\"breathe_underwater\", \"underwater_vision\", \"walk_on_fluid\", \"walk_on_powder_snow\": true, \"terrain_speed\": [{\"blocks\": [ids or #tags], \"bonus\": speed, \"per_level\": share, \"level\": level}]}: breathing and seeing clearly under water, standing on fluids and on powder snow, and moving bonus * (1 + level * per_level) faster on the named blocks (level defaults to the ability's authored level; a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down); \"when\": a guard asked of the wearer each time, so they hold only while it does (a speedster's water running above a speed). While the wearer is in this phase", "neutral_mobs": "true, or {\"mobs\": [entity type ids or #tags]}: mobs leave the wearer alone -- true is every mob, hostile NPCs included; mobs names only those. While the wearer is in this phase", "silent_steps": "true: no footstep sounds. While the wearer is in this phase", "force_run": "true: the wearer keeps running forward whatever the keys say. While the wearer is in this phase", "vibrating": "true: the wearer's body vibrates through attacks, as a speedster's mirage copies. While the wearer is in this phase", "invisible": "true: unseen -- others draw no name tag for the wearer. While the wearer is in this phase", "fully_invisible": "true: not drawn at all -- the suit, the body and what it holds (invisible only hides the name tag). While the wearer is in this phase", "slow_motion_immune": "true: slowed time never catches the wearer (the slow_motion move and the slow_time verb skip them). While the wearer is in this phase", "heavy": "true: moves barely shift the wearer -- a push, launch or blast knockback keeps only what their knockback resistance lets through, and never lifts them off the ground. While the wearer is in this phase", "loot": "{\"chest_luck\": level, \"looting\": level, \"when\": guard}: extra Luck while opening a loot chest, and extra Looting levels on a kill -- with when, only on a kill whose body passes it, asked as the target ({\"marked_by\": \"quarry_mark\"}); every such move the wearer has adds. a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down. While the wearer is in this phase", "enchant_bonus": "{\"\": level, ..., \"item\": \"main_hand\" | \"off_hand\", \"when\": guard}: the held item counts as having that many more levels of each enchantment while a block is broken (Fortune on a pickaxe), put back after, and when the wearer attacks with it (Sharpness on a mace: its damage, knockback, fire aspect and sweep count them); with when, only while that guard holds of the wearer. a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down. While the wearer is in this phase", "draw_speed": "{\"times\": multiplier, \"when\": guard}: the bow draws times as fast (2 reaches a full draw in half the time); every draw speed the wearer has multiplies; with when, only while that guard holds of the wearer (e.g. {\"riding\": true}). While the wearer is in this phase", "movement": "{\"double_jump\": true or jumps or \"level\" or {\"per_level\": jumps, \"level\": level, \"min_level\": level}, \"wall_cling\": true, \"dodge_roll\": true or {\"cooldown\": seconds, \"clip_prefix\": \"dodge_\"}, \"climb\": true or {\"speed\": pull, \"while\": guard}, \"wall_run\": true, \"charge\": {\"speed\": blocks a tick, \"ramp\": per tick, \"max\": blocks a tick, \"toward\": \"locked\" | \"marked\", \"key\": data key, \"face\": true}, \"lunge\": {\"ticks\": n, \"distance\": blocks or \"speed\": blocks a tick, \"along\": \"yaw\" | \"look\", \"keep_vertical\": true}, \"swim_boost\": true or {\"per_speed\": 0.15, \"vertical\": 3}, \"tunnel\": true or {\"floor\": blocks, \"blocked_by\": [block ids]}, \"no_sprint\": true, \"step_height\": blocks, \"drift\": true or {\"friction\": 0.5, \"accel\": 1}, \"gravity\": scale, \"wall_crawl\": true or {\"sounds\": {\"left\": [sound ids], \"right\": [sound ids]}, \"backflip\": true}}: double_jump gives one jump in the air before landing (a number gives that many; 2 is a triple jump; {per_level, level} gives per_level jumps a level, rounded down, none below min_level (default 0), and \"level\" one a level of the ability's own authored level -- a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down); wall_cling holds the wearer on a wall while they sneak in the air, and kicks them off it when they let go moving; dodge_roll rolls them forward or back on the dodge key (default 1.5 s apart, clips forward / back, _air in the air); climb grips the wall ahead (jump climbs, sneak slides down; speed defaults to 0.49; while must hold to grip); wall_run sprints them along walls; charge drives them along where they look every tick, speed blocks a tick growing by ramp a tick up to max -- with toward, straight at a body instead, on all three axes: \"locked\" their lock-on, \"marked\" the one markTarget() stored under key (charge_target), turned to face it unless face is false, and with no such body nothing happens that tick; lunge drives them for ticks ticks from when it starts, at speed (or distance spread over the ticks) along their yaw (level, the default) or look as it started, their own rise and fall kept unless keep_vertical is false; swim_boost, sprinting under water, adds the suit's speed times per_speed (0.15) of their look to their velocity each tick, the vertical vertical (3) times that; tunnel lets them walk through blocks held on top of a floor found up to floor (2) blocks under their feet, with no jumping, and touching a blocked_by block (bedrock, barriers, structure voids, command blocks) ends the move and starts its cooldown. charge, lunge and swim_boost are steered by the wearer's own client, so they read as their own running; no_sprint stops them sprinting at all (the sprint key and double-tap are ignored, no sprint pose, field-of-view kick or sprint particles; pair it with a movement_speed attribute to keep their pace); step_height is how many blocks they walk straight up without jumping (vanilla 0.6, 1 a full block; the higher of theirs and vanilla's); drift eases their speed on the ground in and out on their own client, so they drift on a little when they stop -- friction (0.5) is how much of vanilla's ground friction still applies, accel (1) their top speed times vanilla's; gravity scales how hard they fall while moving down (0.75 a quarter lighter; jumps rise as usual); wall_crawl grips a wall the wearer walks into (forward climbs, back descends, no keys cling, strafe moves along the face and round corners, jump leaps off, sneak lets go, or with backflip leaps back off the face in the swing's back flip) with no web line out, at the ability's amplifier times its base speed, the sounds played on alternate footfalls; put one on a phase to have it for that phase. While the wearer is in this phase", "flight": "true, or {\"hover\": true, \"fast\": true, \"sprint_to_enter\": bool, \"windup\": {\"ticks\": n, \"requires\": guard, \"animation\": clip, \"stages\": [{\"at\": tick | \"launch\", \"every\": ticks, \"do\": [actions]}]}}: the wearer flies -- hovering as in creative (hover), and tearing along while sprinting in the air (fast; with sprint_to_enter, sprinting in the air starts it by itself, otherwise the suit's flight profile decides). A windup makes fast flight wait until the wearer has sprinted for ticks with requires holding, playing animation as it starts; each of its stages runs its actions (written as action objects) when the wind-up has counted at ticks (0: as it starts), or at \"launch\" -- the first tick fast flight takes over -- and then every every ticks while it lasts. Falls and flying into walls do the flyer no harm, and a hit from a mob or player grounds them for 2 seconds. Speeds come from the suit's flight profile. While the wearer is in this phase", "glide": "true, or {\"needs_air_below\": true, \"immune\": true, \"when\": guard}: the wearer glides as on an elytra once airborne (with needs_air_below, only over two blocks of air; with when, only while it holds); immune: flying into a wall does no harm. While the wearer is in this phase", "deflect": "true, or {\"projectiles\": true, \"beams\": false, \"reverse\": true, \"take_ownership\": true, \"chance\": share or {\"per_level\": share, \"level\": level}, \"when\": guard}: projectiles that would hit the wearer are turned back the way they came (reverse; otherwise they just miss) and become the wearer's (take_ownership); with beams, beams are bounced back at the shooter. chance is the odds of each (default always; per_level x the level, which defaults to the ability's; a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down); with when, only while that guard holds of the wearer. While the wearer is in this phase" }, "every_fields": { "seconds": "how often, on the rule's clock (default 0.05: every tick). Keep to 0.05 steps, except on the animation clock. Any worked-out number, e.g. {\"expr\": \"max(0.25, 1 - $hits * 0.1)\"}: read each time, rounded to whole ticks, on the age, state or world clock (the age unless clock says)", "ticks": "how often in whole ticks, instead of seconds", "chance": "fraction of due ticks it fires on (default 1)", "clock": "what it counts on: \"age\" (the wearer's age; the default for a player's phase), \"state\" (ticks since the phase was entered, 1 on its first tick; the default for a mob's channel), \"world\" (the world's time) or \"animation\" (seconds of the phase's clip at its animation_speed, 0 as it starts; fires once for every frame a tick's stretch of clip crosses)", "start": "seconds on the clock of the first firing, and the phase after it: every 0.6 from 0.2 fires at 0.2, 0.8, 1.4 (0)", "frames": "instead of seconds and start: the moments within each cycle it fires at, e.g. [0, 0.2, 0.4, 0.6, 0.8]", "cycle": "seconds each cycle of frames lasts (1)", "from": "live from this far into the phase, in seconds (on the clip for an animation rule, the phase clock otherwise)", "until": "and up to this far", "do": "[actions]", "_comment": "free text; ignored" }, "reaction_fields": { "if": "a guard; the reaction is skipped when it fails", "do": "[actions], run at once with the event in hand (select \"attacker\" or \"victim\", \"event\": \"amount\", remove_effect)", "steps": "a running order from the moment of answering, same shape as the ability's \"steps\"; later moments still run after \"then\" has left the phase", "then": "where to go afterwards: a phase, \"cooldown\" or \"ready\", or {\"to\": \"cooldown\", \"seconds\": 30} for a fixed cooldown. Leave out to stay", "_comment": "free text; ignored" }, "until_fields": { "if": "a guard about the wearer (required)", "then": "where to go when it holds (required)", "do": "[actions] run as it is taken, before the phase's end", "check": "\"after\" the phase's work this tick (default) or \"before\" it", "_comment": "free text; ignored" }, "hold_open_fields": { "while": "a guard: while it holds the phase can't run out (required)", "end_when": "a guard: while held open, holding ends the phase at once", "max": "the oldest the phase may be held open, in seconds on the phase clock; left out, no limit", "grace": "seconds the phase has left while held, so it ends that long after \"while\" stops holding (0.1)", "then": "where \"end_when\" leads; left out, the phase's own then", "_comment": "free text; ignored" }, "let_kinds": { "random_hue": "{\"saturation\": [min, max], \"value\": [min, max], \"hue\": [min, max], \"as\": \"rgb\" | \"int\"} -- a colour of random hue (saturation and value 1 and hue 0..1 when left out), as [r, g, b] each 0 to 1 (\"rgb\", the default; what a dust particle's colour takes) or 0xRRGGBB (\"int\")", "random": "[min, max] -- a number drawn between them", "pick": "[a, b, ...] -- one of these, any JSON value, picked at random" }, "mob_fields": { "min_range": "the mob only uses it on a target at least this far off, in blocks (0)", "max_range": "and no further than this (16)", "cooldown": "seconds before the mob may use it again; its own pacing, not the CSV cooldown (0)", "weight": "how often the controller picks it, against the mob's other moves of the same priority in range (10)", "priority": "how much the controller wants it: a number, {value, when}, or a list of those; the highest value whose when holds counts (0 with none). The highest-priority move that may be used now wins; weight breaks ties (0)", "lasts": "seconds a channel runs; left out, a one-shot use", "active": "true: the ability counts as active while the channel runs, so its visuals draw for the mob (false)", "steps": "what using it does, same shape as the ability's \"steps\"; left out, the press's own steps", "every": "a channel's work: [{\"seconds\", \"do\"}] counted on the channel's own ticks from 1", "on": "{\"collide\": reaction} -- a then ends the channel", "end": "[actions] run as the channel ends, however", "until_blocked": "a channel ends when the ability becomes blocked (true)", "until": "a guard asked before each of a channel's ticks; once it holds, the channel ends", "needs_target": "true: the mob only uses it with a target to aim at, and declines it otherwise (false)", "when": "a guard the controller asks before it picks the move, of the mob with its target as the target (e.g. { target: { airborne: true } }); the move is left alone while it fails", "_comment": "free text; ignored" }, "switch_fields": { "id": "what the switch is asked by (required)", "name": "its label on the wheel (the id)", "icon": "an item id drawn on the wheel (minecraft:feather)", "on": "whether it starts switched on (false)", "on_setting": "a game setting it starts as instead, read live (auto_swap_utility: the Auto Swap Utility config option; toggleable_grapple_arrow: the Toggleable Grapple Arrow one; on when the setting is unknown)", "_comment": "free text; ignored" }, "exits": { "cooldown": "leave every phase and start the ability's cooldown from defaults.csv (needs a cooldown part); {\"to\": \"cooldown\", \"fraction\": 0.25} charges that share of it. Any way out may be {\"to\": ..., \"do\": [actions]}: those run as it is taken, before the phase's on_exit", "ready": "leave every phase with no cooldown", "": "go into that phase; its steps start and its \"lasts\" is armed" }, "events": [ { "event": "hurt", "doc": "The wearer is about to be hurt, before armour counts. Carries the attacker (select: \"attacker\") and the damage (\"event\": \"amount\").", "guards": [ "amount_at_least", "attacker", "element", "from_player", "melee", "source", "source_tag" ] }, { "event": "damaged", "doc": "The wearer is about to take damage that got past their own invulnerability (creative, a difficulty that scaled it to nothing): later than hurt, which also sees those. Carries the attacker and the damage, as hurt does.", "guards": [ "amount_at_least", "attacker", "element", "from_player", "melee", "source", "source_tag" ] }, { "event": "effect_added", "doc": "A status effect was just put on the wearer. thematic:remove_effect with no \"effect\" takes that one off again.", "guards": [ "effect", "effect_group" ] }, { "event": "attack", "doc": "The wearer lands a melee attack on a living thing, before the hit does its damage. Carries the entity hit (select: \"victim\").", "guards": [] }, { "event": "collide", "doc": "Every tick the wearer is against something solid -- a wall, a ceiling, or the floor -- while the phase runs, after its every rules. wall_or_ceiling and touching_for say which contact and for how long.", "guards": [ "surface", "touching_for", "wall_or_ceiling" ] }, { "event": "release", "doc": "The key of a \"hold\" ability was let go. Every phase a hold ability opens should say what this does.", "guards": [] }, { "event": "hit_landed", "doc": "The wearer's hit on a living thing has been dealt: after its damage, whatever did it (a punch, an ability, a projectile). Carries the entity hit (select: \"victim\"), the damage (\"event\": \"amount\") and its damage type (source). It fires for a hit the victim's invulnerability swallowed too; dealt: true keeps only the ones that hurt.", "guards": [ "amount_at_least", "attacker_kind", "dealt", "element", "source", "source_tag" ] }, { "event": "swing", "doc": "The wearer swung an arm -- at anything or at nothing, the climb's grip included. hand says which.", "guards": [ "hand" ] }, { "event": "tick", "doc": "Passive only: every tick the wearer is alive and has the ability, on the server. every: 0.2 checks five times a second. An answer with later steps (wait()) is not given again until they have all run; they find the wearer again by their UUID, so a respawned wearer is the same one, and a step that comes due while the wearer is dead or gone calls the rest off.", "guards": [ "every" ] }, { "event": "press", "doc": "The key of a \"press\" ability was pressed again while one of its phases runs. The phase takes the press instead of the move starting over; a phase that does not answer it leaves the press to do what it always did. Only a phase answers it.", "guards": [] }, { "event": "block_broken", "doc": "The wearer broke a block; it is already gone. block_type says which, dropped_itself whether it came back as itself (Silk Touch). Can't be called off.", "guards": [ "block_type", "dropped_itself", "placed_by_player" ] }, { "event": "use_block", "doc": "The wearer right-clicks a block, before the block or the held item reacts. block_type, item_type and hand say what with; cancel_event stops the use.", "guards": [ "block_type", "hand", "item_type", "placed_by_player" ] }, { "event": "use_entity", "doc": "The wearer right-clicks an entity. Carries it (select: \"victim\", when it is alive) and entity_type, item_type and hand; cancel_event stops the use.", "guards": [ "entity_type", "hand", "item_type" ] }, { "event": "use_item", "doc": "The wearer uses the item in a hand (a right-click in the air, or on a block that didn't take it). item_type and hand say which; cancel_event stops the item's own use.", "guards": [ "hand", "item_type" ] }, { "event": "jump", "doc": "The wearer jumped, as the server hears of it. The client has already jumped, so it can't be called off.", "guards": [] }, { "event": "land", "doc": "The wearer landed after a fall. How far they fell is fell_at_least's, and the event's amount (\"event\": \"amount\").", "guards": [ "fell_at_least" ] }, { "event": "kill", "doc": "Something the wearer hit died of it: by their own hand, their projectile, or a pet or summon they own. Carries the dead (select: \"victim\"), entity_type, and the killing blow's source.", "guards": [ "attacker_kind", "element", "entity_type", "source", "source_tag" ] }, { "event": "xp_gained", "doc": "The wearer is about to gain experience points (the event's amount). cancel_event takes the gain away.", "guards": [] }, { "event": "inventory_change", "doc": "A stack went into the wearer's inventory. item_type says what. An answer that gives an item does not set itself off again.", "guards": [ "item_type" ] }, { "event": "projectile_incoming", "doc": "A projectile is about to hit the wearer. Carries its shooter (select: \"attacker\"), projectile_type and from_player. cancel_event lets it pass through them. Asked again each tick it is still in reach, so a dodge wants a cooldown.", "guards": [ "from_player", "projectile_type" ] }, { "event": "projectile_approaching", "doc": "A projectile that is not the wearer's own is on a path that reaches them within a second, asked once for each one. Carries its shooter (select: \"attacker\"), projectile_type and from_player. Can't be called off.", "guards": [ "from_player", "projectile_type" ] }, { "event": "projectile_launched", "doc": "The wearer launched a projectile (a bow, a crossbow, a trident, a thrown item, a gadget), just before it appears. projectile_type says which; cancel_event stops it ever appearing.", "guards": [ "projectile_type" ] }, { "event": "arrow_loosed", "doc": "The wearer loosed an arrow from a bow, just after it left the string. The drawn guard asks how far the string was drawn and how long it was held; shot() changes the arrow (a harder hit, a critical, piercing, a tag). projectile_type says which arrow.", "guards": [ "drawn", "projectile_type" ] }, { "event": "chat_word", "doc": "The wearer said something in chat. word says what to listen for. Can't be called off.", "guards": [ "word" ] }, { "event": "enemy_ultimate_ready", "doc": "Another player nearby, not on the wearer's team, has their ultimate ready. Carries them (select: \"attacker\"); radius and enemy_ultimate narrow it.", "guards": [ "enemy_ultimate", "radius" ] }, { "event": "enemy_ultimate_pressed", "doc": "Another player nearby, not on the wearer's team, used their ultimate. Carries them (select: \"attacker\"); radius and enemy_ultimate narrow it.", "guards": [ "enemy_ultimate", "radius" ] }, { "event": "threat_nearby", "doc": "A mob has the wearer as its attack target: asked twice a second while one does, for the nearest. Carries it (select: \"attacker\"); radius and entity_type narrow it. Pair it with ready: true and a cooldown.", "guards": [ "entity_type", "radius" ] }, { "event": "suit_removed", "doc": "The suit came off the wearer -- taken off, or swapped for a different suit -- on the server: the place to undo what the move kept on them (an effect, a flag). A change within one suit (its data) is not a removal.", "guards": [] }, { "event": "crouch_toggled", "doc": "The wearer crouched down or stood back up, on the server: a sneak toggled, as a pattern of taps (Villager Whisperer's five) counts them.", "guards": [] }, { "event": "tether_arrive", "doc": "A line the wearer's tether move threw has hauled them to a creature (a zip onto a traced target), on the server, just after the arrival kick. Carries the creature (select: \"victim\").", "guards": [] } ], "guards": { "active": "another ability of the wearer's is active: an ability id, or a list of them (one is enough)", "airborne": "true: in the air -- off the ground, out of water, not climbing, riding or flying; false: any of those", "alive": "true: alive; false: dead or gone", "amount_at_least": "the hit is worth at least this much damage, in the game's points before armour; {share_of_max_health: 0.12} is that share of the wearer's max health, so it scales with a bigger health bar (hurt, damaged and hit_landed only)", "animal": "true: the game counts it an animal, one of the kinds that breed (cows, pigs, sheep, wolves, horses, hoglins...); false: anything else. Mostly asked inside target", "any": "a list of guards; passes if at least one does", "any_other_player": "some other player on the server (anyone but the one asking) passes this guard, asked about them: whether anyone else is already in the Speed Force, say", "aoe_lane_clear": "true: a blast of radius blocks where a throw at the target lands (at speed blocks a tick, 1.0) would catch no one the wearer may not hurt; false with no target", "attacker": "whoever threw the hit answers this guard about itself -- within is how far it stands from the wearer, held_trait what its main hand holds (e.g. {held_trait: \"kryptonite\"}); fails when nothing living threw it, or the wearer hit themselves (hurt and damaged only)", "attacker_kind": "who landed it: \"self\", the wearer (by hand or by their own projectile), or \"owned\", a pet or summon of theirs (kill and hit_landed only; and a damage_bonus's when)", "baby": "true: a young one (a baby villager, a calf, a baby zombie); false: grown. Mostly asked inside target", "block_state": "the block the actions run at (a block hook's own block, the block a move hit) has these state values, as block-state strings; a list: any of them. Fails where the actions run at no block", "block_type": "the block broken or used is this id, or one of this list; \"#ns:tag\" asks for a tag. A bare id is minecraft's (block_broken and use_block only)", "blocked": "true: this ability can't be used now -- someone holds the wearer, the server disabled it, a dampener covers it, or its requires fails; false: nothing blocks it", "burning_for": "burning with at least this many seconds of fire left, e.g. what a spreading flame carries", "carries": "the body carries this item in any slot -- the hands, the armour, a player's whole inventory: an item id, \"#ns:tag\" for an item tag, a list (any of them), or {item, tag}. A bare id is minecraft's", "chance": "passes this fraction of the time, 0 to 1", "climbing": "true: on a wall with a climbing ability; false: not", "critical_swing": "true: a swing now would be a critical hit by the game's own rule -- falling, off the ground, not climbing, not in water, not blind, not riding and not sprinting (the attack's charge is not asked); false: it would not", "daytime": "true: the sun is up in their world, wherever they stand (a cave at noon counts); false: night", "dealt": "true: the hit did damage -- the victim flinched; false: their invulnerability or a soak swallowed it (hit_landed only)", "drawn": "the bow was drawn at least pull of the way (0 to 1; 1 is a full draw) and held at least ticks, counted after any draw-speed modifier (arrow_loosed only): { pull: 1, ticks: 40 } is a full draw held a beat", "dropped_itself": "true: the block broken dropped itself to the wearer's main-hand tool (Silk Touch, or a block that always drops itself); false: it dropped something else, or nothing -- how an ore bonus refuses an ore that would come back to be placed and broken again (block_broken only)", "effect": "the effect that just arrived is this id, or one of this list (effect_added only)", "effect_group": "the effect that just arrived is in this named group: [flash, harmful] (effect_added only)", "effect_level": "the body has this status effect at this level or more (the amplifier plus one)", "element": "the hit counts as this Thematic damage element, or one of this list, as the weakness system matches them (its own type, its vanilla and thematic:is_ tags, compat) (hurt, damaged, hit_landed and kill only)", "empty_hand": "that hand holds nothing: \"main\", \"off\" or \"both\"", "enemies_within": "someone the wearer may hit is within this many blocks: the search a targets() block runs (\"around\", its hittable default, and any filter's fields: entity, line_of_sight, except_allies, box...), with no actions -- so an until can end a phase the moment a targets() would find someone. {radius, filter}'s radius may be worked out, e.g. {tuned: \"radius\"} for the move's tuned range. It holds when the number found is within [at_least (1), at_most (no limit)] (radius is capped at 128 blocks): at_most 1 is \"exactly one other\", at_least 0 with at_most 0 is \"alone\"", "enemy_ultimate": "the other player's ultimate is this ability, or one of this list (enemy_ultimate_ready and enemy_ultimate_pressed only)", "entity": "is of this entity type, or one of this list; \"#ns:tag\" asks for an entity type tag, and a bare id is minecraft's (\"zombie\" is minecraft:zombie). Mostly asked inside target", "entity_type": "the entity used, killed, or seen as a threat is this id, or one of this list; \"#ns:tag\" asks for a tag. A bare id is minecraft's (use_entity, kill and threat_nearby only)", "escaping": "the target is getting out of the fight: up in the air (airborne, true by default), or moving away from the fight's middle (from: owner, squad or self; owner by default) faster than speed (0.06 blocks a tick) while more than beyond blocks (8) from it. It must have been so for `for` seconds (0.5) on end, asked again and again, so the flinch of a hit is not an escape. Asked of the target the guard has. true is all defaults", "every": "seconds between looks: passes on the ticks where the wearer's age is a multiple of this, as the Java watchers counted (tick only)", "facing": "looking toward someone, within this many degrees of them, eyes to eyes: inside target, {toward: \"wearer\"} asks whether the target looks at the wearer; asked of the wearer, {toward: \"target\"} whether the wearer looks at the target, and {toward: \"attacker\"} at whoever threw the hit (hurt and damaged). assist (blocks) measures to the other's hitbox grown by that much instead of its eyes, and range (blocks, or worked out: {tuned: \"radius\"}) is how far that point may be", "fall_flying": "true: gliding on an elytra (or anything that flies the same way); false: not", "fell_at_least": "the wearer fell at least this many blocks before landing (land only)", "flag": "the flag stored under this key is set (set_flag, or a Java ability's stored flag); a list: any of them", "from_player": "true: the hit's attacker -- whoever swung, or shot the projectile -- is a player; false: anything else, or nobody (hurt, damaged, projectile_incoming and projectile_approaching only; there, the projectile's shooter)", "from_spot": "how far the wearer stands from the spot a mark_spot stored under key, from their feet: beyond (more than) and/or within (at most) so many blocks -- written, or worked out ({tuned: \"radius\"}: the move's tuned range); horizontal: true measures level only. Fails when no spot is stored under the key", "gauge_at_least": "this ability's gauge holds at least this many seconds of heat (see \"gauge\")", "hand": "which arm swung, or which hand's item was used (swing, use_block, use_entity and use_item only)", "hand_stack": "a hand holds a stack that passes: it is one of item (ids, or \"#ns:tag\"s; a bare id is minecraft's), its item's definition declares trait (one of a list), and its NBT carries every key in nbt -- a tether launcher whose line is out and caught on someone is { trait: \"grapple_gun\", nbt: [\"entity\", \"target\"] }, wool in the off hand { hand: \"off\", item: \"#minecraft:wool\" }. hand says which hand: main, off, or either (either)", "has": "the suit has this ability, or one of this list, whether or not it is in use -- e.g. a set of claws", "has_effect": "has this status effect, or one of this list", "health_below": "health is below this on the scaled health bar (a vanilla 20 reads as 1000, so 150 is three raw points)", "health_below_mark": "the wearer's health plus absorption is below the mark markHealth() stored under this key: a hit landed since, absorbed or not", "held_item": "the wearer's main hand holds this item id, or one of this list", "held_item_kind": "the wearer's main hand holds an item of this kind, or of one of this list: [gun, bow, weapon, trident] -- \"gun\" is any gun, whoever registered it -- or \"#ns:tag\", an item tag (a bare tag is thematic's)", "held_item_path_contains": "the wearer's main-hand item id's path contains this text, e.g. \"staff\"", "held_tag": "the wearer's main-hand item is in this item tag, e.g. \"#thematic:billy_clubs\" (or one of this list)", "held_trait": "the wearer's main-hand item's definition declares this trait, or one of this list (\"traits\": [...] in an item file)", "hittable": "inside target: true when the wearer may hit it (not an ally, not in creative)", "holding": "the wearer holds the key of this ability (an id, or a list of them); true: of any ability; false: of none", "hostile": "true: the game counts it a monster (zombies, spiders, slimes, the Warden...); false: anything else. Mostly asked inside target: a howl names {any: [{target: {hostile: true}}, {target: {player: true}}]}", "hunted_by": "they are a mob whose attack target is the wearer -- a monster closing in, a golem that turned on them: \"target\", inside targets() the one aimed at, or \"attacker\", whoever threw the hit (hurt and damaged)", "in_combat_within": "the wearer dealt or took damage within this many seconds -- the fight clock regeneration runs on, not the heal tag", "in_pocket_dimension": "true: the subject is inside a pocket dimension (the Speed Force); false: it is not", "in_state_for": "the phase has been running at least this many seconds, this tick included", "in_water": "true: touching water at all -- wading, swimming, under; false: dry (rain does not count)", "inside_block": "the block they stand in is this id, or one of this list; \"#ns:tag\" asks for a block tag, and a bare id is minecraft's. {blocks, at} looks at the block at the feet (default), at the eyes, or the one below (stood on)", "item_cooling_down": "the subject (a player) has this item on cooldown, or one of this list, as an ender pearl just thrown is; a bare id is Thematic's", "item_type": "the item used (inventory_change: the stack that went in) is this id, or one of this list; \"#ns:tag\" asks for a tag. A bare id is minecraft's (use_block, use_entity, use_item and inventory_change only)", "keeps": "the wearer keeps a live entity under this store key -- the last projectile a projectile's keep_as kept (a grapple's hook, \"grapple_entity\"), a bow's tracked arrow -- that is still out; drop_kept takes it down", "kin_used": "another body working for the same owner started this move within this many seconds -- so a group does not all fire the one move at the one target in the same breath. {not: {kin_used: ...}} staggers them", "kit_idle": "nothing in the wearer's kit is running or cooling down, the passives aside -- what a suit swap asks first. {active, cooling, passives} says what counts: a running move (true), one cooling down (true), the passives too (false). A body with no suit is idle", "lacks_effect": "has none of these status effects", "light_at_least": "the block they stand in is lit to at least this level (0-15); {level, light: \"block\" | \"sky\"} counts one kind of light only, where the default \"any\" is the game's own reading (sky and block light, less the night's darkness)", "light_below": "the block they stand in is lit below this level (0-15), e.g. 5 for proper dark; {level, light: \"block\" | \"sky\"} counts one kind of light only, where the default \"any\" is the game's own reading", "linked": "the wearer keeps a mob's id under this data key (a summon's link, e.g. \"companion_wolf_uuid\"), whether or not the mob is still there: with owned_mobs finding none, the one they had is gone", "locked_target": "true: the wearer has a locked target that is still alive (with within: no further than that); false: none", "looking_at_block": "the block the wearer looks at, within range (5 blocks, a player's reach, left out), is this id or one of this list; \"#ns:tag\" asks for a block tag, and a bare id is minecraft's. Fluids are looked through. Asked anywhere, not only in a block event", "marked_by": "the target carries a running mark (thematic:mark): true is the wearer's under \"mark\", a string names the key (\"quarry_mark\"), and {key, owner_key, owner: \"wearer\" | \"anyone\"} says whose (the wearer's). Asked of the target; inside target only owner \"anyone\" can pass", "melee": "true: the hit came straight from a living attacker, not a projectile (hurt and damaged only)", "meter_at_least": "the meter holds at least amount; for a window, it has at least amount openings banked (0 while closed)", "meter_open": "the window kept under this meter key is open; an amount meter: it holds anything at all", "meter_opened_by": "the window kept under meter is open, and was opened by one of by; or with not_self, by an ability other than the one asking", "mob": "true: a mob, anything with a brain (animals, monsters, villagers, golems); false: a player, an armour stand. Mostly asked inside target", "morphed_as": "the body is wearing this shape: a morph id, e.g. \"thematic:wolf\" -- the gate a form's own move asks so it refuses outside its shape", "moves_ready": "any of these moves is ready for the wearer to use: off its own cooldown, and for a mob off the controller's pacing", "moving": "which way the wearer has been moving over the last three ticks against the way they face: forward, back, left or right (the nearest), or none when they have barely moved; a list passes on any of them. A player's is where they went, so it reads the key they hold", "not": "a guard; passes when that guard does not", "number": "a worked-out number compared: of is any number an action takes -- {input: \"fall_distance\"}, {expr: \"motion_y * 20\"}, {tuned: \"damage\"}, or \"$name\" for one the press stored or let -- and every bound given must hold. who says whose body the body inputs read (the wearer, or the target); a number with nothing to read (no target, no stored value) fails every bound", "offhand_item": "the wearer's off hand holds this item id, or one of this list", "on_fire": "true: burning; false: not", "on_ground": "true: the wearer stands on the ground; false: the wearer is in the air", "option": "the suit's options for this ability say this: {variant_split: true} holds when the suit's entry for it has options.fields.variant_split true (true, \"true\" or 1). Every field written must match; a flag the suit leaves out reads as false, any other field left out matches nothing", "owned": "true: the target is one of the wearer's own mobs -- tamed to them, or naming them its owner; false: it is not. Asked of the target the guard has (the entity the actions are aimed at), as marked_by is", "owned_fighting": "one of the wearer's own mobs (a pet, a summon) within this many blocks of them has the target as its target: a pack already on it. Asked of the target the guard has (the entity the actions are aimed at, the hit's)", "owner": "the wearer's owner answers this guard about itself: the player a summon or pet works for, so a move a summon runs can ask about the one it works for (e.g. { owner: { ultimateActive: true } }); a wearer that works for nobody answers it itself", "placed_by_player": "true: the block the event is about was placed by a player a moment ago (it counts until the tick it is broken in is over); false: it was not -- how a bonus for breaking a block refuses one its breaker put down", "player": "true: the wearer is a player; false: a mob using the move (see the ability's \"mob\")", "players_within": "counts the OTHER players (never the wearer, never spectators) within radius blocks, and asks the count: min (at least), max (at most), equals (exactly); with none of them, at least one. radius may be worked out, e.g. {tuned: \"radius\"}; capped at 128 blocks", "projectile_type": "the projectile is this id, or one of this list; \"#ns:tag\" asks for a tag. A bare id is minecraft's (projectile_incoming, projectile_approaching and projectile_launched only)", "pushing_inward": "a push away from the wearer would send the target toward the fight's middle: the target is on the wearer's side of it, at least min blocks (0.5) off the middle, and between the middle and the wearer. For herding a target in rather than out", "radius": "the other player, or the threat, is at most this many blocks from the wearer. Without it every wearer in reach answers: 64 blocks for an enemy's ultimate, 32 for a threat (enemy_ultimate_ready, enemy_ultimate_pressed and threat_nearby only)", "ready": "true: this ability's cooldown has run out; false: it is still cooling down. What a passive asks before it goes off again", "remembered": "inside target: true when it is the one the press remembers", "remembers": "true: the press remembers someone (a targets() with remember found them, and nothing has let go of them since); false: nobody", "riding": "true: riding something -- a horse, a boat, another body; false: not", "run_speed_at_least": "the speedster's speed dial (the running speed the raise and lower keys set, as the speed bar shows it) is at least this; 0 for anyone who is no speedster", "rung_at_least": "their suit is on at least this rung of its ladder (a starter's level, 1 to 10); a suit on no ladder is on none", "running_kind": "a move of this kind on the body's suit is running: equip_item, the moves that hand out items while on (Pick Pocket asks it of its victim, inside target). A kind no move answers is never running", "same_world": "inside target: true when it is in the wearer's world", "sees": "the wearer has a clear line of sight to them, eyes to eyes, as the game measures it (blocks in between hide them, glass does not): \"target\", inside targets() the one aimed at, or \"attacker\", whoever threw the hit (hurt and damaged). {not: {sees: \"target\"}} is someone out of sight", "sky_above": "true: the block the actions run at has open sky straight above it (nothing but see-through blocks between it and the sky); false: it has not. Fails where the actions run at no block", "sneaking": "true: crouching; false: not", "source": "the hit's damage type is this id, or one of this list; \"#ns:tag\" asks for a damage type tag. A bare id is minecraft's, as damage types mostly are: \"player_attack\" is minecraft:player_attack. For \"unless\", write {not: {source: ...}} (hurt, damaged, hit_landed and kill only; on kill, the killing blow's)", "source_tag": "what dealt the hit -- the arrow or thrown thing, else the attacker -- carries this command tag, e.g. the \"thematic_bullseye\" a patient shot is tagged with (hurt, damaged, hit_landed and kill only; on kill, the killing blow's)", "speed_at_least": "they move at least this many blocks a tick, measured from where they were when last asked about (sprinting is about 0.28); sideways only, unless {speed: n, horizontal: false} counts falling and rising too", "sprinting": "true: sprinting; false: not", "stack_counter": "the counter stored on the stack under key (stackState): at least, below or equal to a number", "stack_flag": "the flag stored on the stack under this key is set (stackState)", "stack_gauge": "the gauge stored on the stack under key (stackState): at least, below or equal to a number", "stack_timer": "the timer stored on the stack under this key is still running (stackState)", "standing_order": "the wearer is carrying out a standing order of this kind (a squad flier's console order: \"waypoints\", \"patrol\", \"move_to\", \"hold_zone\", \"focus_set\"), or one of this list", "still": "true, or {moved_less_than: blocks}: they have moved less than that far sideways per tick since they were last asked about (0.05 when not given); false: they moved more", "submerged": "true: eyes under water; false: not", "suit_tag": "the suit carries this tag, or one of this list, e.g. \"kryptonian\"", "sunlit": "true: in sunlight -- daytime, and the block they stand in lit to 8 or more; false: not (night, a cave, under a roof)", "surface": "what the wearer is up against: any (every contact), wall_or_ceiling (a wall or a ceiling, not only the floor) or ground (standing on the floor, whatever else they touch) (collide only)", "switch_on": "a switch the ability wheel shows is on: the asking ability's switch by this id (its \"switches\"), or {id, ability} for another ability's. A switch the suit's ability does not have is off", "tamed": "true: tamed to someone (a wolf, cat or parrot, a horse); false: wild, or nothing that can be tamed. Mostly asked inside target", "target": "the target answers this guard about itself (the one a targets() block is aimed at, else the wearer's locked target); fails when there is no target", "teammate": "true: the target is on the wearer's side of the scoreboard -- their team, or a mob the game counts as theirs; false: it is not. Asked of the target the guard has, as marked_by is", "touching_for": "the contact (of the kind wall_or_ceiling, or surface: \"wall_or_ceiling\", asks about) has lasted at least this many seconds in a row (collide only)", "ultimate_active": "an ultimate of theirs is running: the wearer's, or the target's inside {\"target\": ...}. While one is, the rest of that kit is parked on a cooldown as long as it, so a refund asks this before it undoes that lock", "until": "the world time is still before the deadline stored under this key -- a lock that runs out by itself, e.g. {not: {until: \"claw_stab_lock_until\"}}", "using_item": "true: using the item in hand -- drawing a bow, eating, raising a shield; false: not", "wall_or_ceiling": "true: the contact is a wall or a ceiling, not only the floor under the wearer (collide only)", "weak_to": "weak to this damage element (\"fire\", \"kryptonite\"): a weakness move or an ability's affinity trait on the body's suit says so, or whatever answers the weak_to wearer trait. {element, who} asks it of the target", "within": "the target is at most this many blocks from the wearer: inside targets() the one aimed at, elsewhere the locked target", "word": "the line said has this word or phrase in it as whole words, or one of this list, ignoring case: \"shazam\" matches \"SHAZAM!\" but not \"shazams\" (chat_word only)" }, "worked_out_numbers": { "2.5": "that number, always", "{\"tuned\": \"radius\", \"times\": 1.5}": "one of the ability's tuned stats from defaults.csv (damage, radius, duration, amplifier), or any other key of its tuning rows (ability,key,value), scaled; duration is seconds; else: the number when the ability's table and the suit have no value for the key (a key beyond the four stats); times scales it", "{\"event\": \"amount\"}": "a number the event being answered carries (amount): the damage of the hit a parry turns away; times scales it", "{\"ramp\": [12.5, 50], \"across\": \"cooldown\"}": "moves from the first value to the second as the running phase's time is used up, measured against across; across: what the ramp runs across: \"cooldown\" (the tuned cooldown), \"duration\" (the tuned duration) or seconds (required); times scales it", "{\"wave\": 0.05, \"rate\": 0.5}": "wave * sin(the wearer's age in ticks * rate), times times: a bob; rate: radians per tick of the wearer's age (1); times scales it", "{\"level\": {\"min\": 1, \"max\": 5}}": "the move's level on the starter ladder, scaled between min and max (a starter's rung 1 is min, 10 is max); anyone off the ladder gets the level the suit gives the move, unclamped; times scales it", "{\"fire_ticks\": \"target\", \"times\": 0.05}": "ticks a body has left to burn (0 when not alight): the wearer's, or the target's (the entity the action is aimed at); times scales it", "{\"effect_level\": \"thematic:example_effect\", \"of\": \"target\", \"times\": 0.0005}": "the levels of a status effect a body carries (amplifier + 1; 0 without it): the target's (the entity the action is aimed at, or the body a hit struck), or the wearer's; of: \"wearer\" | \"target\": whose (target); times scales it", "{\"speed_value\": \"current\"}": "one of the wearer's speed readings, scaled: current or previous (the speed meter now or a tick ago, blocks a second) or modifier (the speed dial the wearer set, 1 to 100); times scales it", "{\"random\": [100, 200], \"whole\": true}": "a number picked at random between the first and the second each time it is worked out; store it to use one pick twice; whole: true: a whole number from the first to the second, both included (false: any number between them); times scales it", "{\"stored\": \"absorbed\", \"times\": 0.5}": "a number the press stored with thematic:store, or a let it drew, by name; 0 before anything is stored; times scales it", "{\"sum\": [{\"tuned\": \"damage\"}, {\"stored\": \"absorbed\", \"times\": 0.5}]}": "the numbers in the list added up, each any number a file can write; times scales it", "{\"bands\": [[3, 100], [6, 70]], \"else\": 30, \"by\": \"distance\"}": "the number of the first band whose bound the input is at or under -- [[bound, number], ...] in rising order -- else \"else\"; else: the number past the last band (required); by: what is measured against the bounds: one of the inputs (distance); times scales it", "{\"input\": \"gauge\", \"times\": 0.005}": "one thing the move knows as it runs (damage, radius, duration, amplifier, cooldown, event, age, state_ticks, ticks_left, gauge, distance, spot_distance, anim, motion_y, fall_distance, health, max_health, missing_health, attack, defense, level, look_pitch, fire_ticks, target_fire_ticks, speed_value, moving_angle, target_height, gun_damage, gun_rpm, gun_range, gun_pellets, pi, e), scaled; times scales it", "{\"expr\": \"min(gauge * 0.005, 0.75) * exp(-gauge * 0.015)\"}": "arithmetic over the inputs (damage, radius, duration, amplifier, cooldown, event, age, state_ticks, ticks_left, gauge, distance, spot_distance, anim, motion_y, fall_distance, health, max_health, missing_health, attack, defense, level, look_pitch, fire_ticks, target_fire_ticks, speed_value, moving_angle, target_height, gun_damage, gun_rpm, gun_range, gun_pellets, pi, e) and $name for a stored or let number: + - * / % ^, brackets, and [abs, ceil, clamp, cos, exp, floor, level, log, max, min, pow, round, sign, sin, sqrt, tan]; times scales it", "{\"pulse\": 0.45, \"period\": 0.4, \"phase\": 0.625, \"fit\": 6, \"around\": 1.25}": "around * (1 + pulse * cos(2 pi (t - phase) / period)), times times: a beat through a phase lasting the tuned duration, t its seconds so far (stretched by fit); period: seconds from one peak to the next (required); phase: seconds into the phase of the first peak (0); around: the middle it pulses about, and averages to (1); fit: seconds the tuned duration is stretched to cover: an animation's time when it is fitted to the duration (the phase's own seconds); times scales it", "{\"held_gun\": \"rpm\", \"times\": 0.5}": "one of the wearer's held gun's numbers, scaled: damage (per hit), rpm, range (blocks) or pellets (per trigger pull); 0 when the main hand holds no gun; times scales it", "{\"option\": \"newSize\", \"else\": 1}": "the number the suit's entry for the move writes under this name in its options (options.fields), times times; else when it writes none; else: the number when the suit's entry leaves the option out, or it is not a number (required); times scales it" }, "visuals": { "thematic:hud_overlay": { "doc": "The helmet heads-up display overlay, drawn while the ability is active.", "options": {} }, "thematic:reticle": { "doc": "A lock-on reticle over the living thing the wearer is aiming at, drawn on their own screen while the ability is active. With no options it is Sonic Pursuit's: purple corner crescents that throb, 32 blocks along the look.", "options": { "texture": "a texture id drawn centred on the target, tinted with color, instead of the crescents", "color": "its colour (0xA60D66)", "highlight": "the brighter colour at the middle of each crescent (0xDD33AA, or a lighter shade of color)", "size": "how much bigger than Sonic Pursuit's it is drawn (1)", "pulse": "how strongly it throbs (1); 0 holds it steady", "range": "how far it looks for a target, in blocks (32)", "target": "which way it looks for one: look (default), along the wearer's look; move, along the way they are moving" } }, "thematic:gauge_bar": { "doc": "The bar over the hotbar showing a hold's gauge while its key is held, the heat against the gauge's max; the speed bar comes back once the key is let go of. The wearer's own screen only. With no options it is Heat Vision's.", "options": { "style": "the bar's look, a row of the bar texture (heat_vision): frost_breath and super_breath are the breaths', the rest are plain colours", "label": "text over the bar, a translation key or plain text (none)", "color": "the label's colour (the style's)", "bound": "what the heat is drawn against: max (default), the gauge's max now, boosts included; base_max, its max with no boost, so a boosted gauge runs past the end as the breaths' did" } }, "thematic:screen_overlay": { "doc": "A texture, or a flat colour, stretched over the wearer's whole screen while the ability is active, drawn behind the rest of the HUD.", "options": { "texture": "the texture id, e.g. \"thematic:textures/gui/scent_tracker.png\" (this or color is required)", "color": "a flat fill in this colour, drawn when there is no texture, e.g. \"#32CD32\"", "alpha": "how opaque it is drawn, 0 to 1 (1)", "first_person_only": "true: drawn only while the wearer looks through their own eyes (false)", "pulse": "its opacity throbs between min and max (0.35, 1) times alpha every period seconds (1.2, at least 0.6); shape \"heartbeat\" is a lub-dub instead of a smooth swell (\"sine\")", "fade_in": "seconds it takes to ease in once the ability is active; 0 for at once (0)", "fade_out": "seconds it takes to ease out once the ability ends; 0 for at once (0)", "also_on": "also drawn for a wearer who has this status effect while a teammate within `within` blocks (24) has the ability active: {effect: \"minecraft:resistance\", within: 24}, the Lantern shield's tint on the teammates it shields" } }, "thematic:screen_vignette": { "doc": "While the ability is active, the edges of the wearer's screen close in: clear in the middle, shading through color to edge_color at the rim, with smoke-like streaks creeping in from the edges, drifting and flickering. Drawn over the screen in every view. E.g. {color: 0x4A0000, strength: 0.9, radius: 0.4, streaks: {amount: 0.6, speed: 1, scale: 1}}.", "options": { "color": "the colour the clear middle shades into (0x4A0000, a deep red)", "edge_color": "the colour at the very rim (0x000000, black)", "strength": "0 to 1: how opaque the rim is (0.9)", "radius": "0 to 1: how far the clear middle reaches before the shading starts, 1 being the corners (0.45)", "softness": "how wide the shading is, as a share of the middle-to-corner distance (0.55)", "streaks": "the smoke-like streaks creeping in from the edges: an amount, or {amount: 0 to 1, how much of the edge they cover and how far in they reach (0.5); speed, how fast they drift and flicker (1); scale, how fine they are (1); color (0x000000); texture, grain noise laid along them (thematic:textures/misc/shroud_noise.png)}. None when left out", "fade_in": "seconds it takes to close in as the ability starts (0.4)", "fade_out": "seconds it takes to clear as the ability ends (0.6)", "first_person_only": "true: drawn only while the wearer looks through their own eyes (false)" } }, "thematic:direction_ping": { "doc": "A warning on the wearer's own screen pointing the way something is: chevrons on a ring around the crosshair that pulse in and fade out, a brief label, and for strong levels a colour breathed into the screen edges. Shown when the server pings (the ping verb) with a level. With no options it is the spider-sense's: one pale chevron for a threat near, two amber for an enemy ultimate ready, three red for one fired.", "options": { "levels": "how each level looks, level 1 first: { color, chevrons, life (ticks), alpha, pulse (how fast it throbs), label (a translation key), vignette (true breathes its colour into the screen edges) }; a key left out is the spider-sense level's in that place", "ring": "how far out from the crosshair the ring is, [across, up] as shares of the screen ([0.17, 0.21]), or one number for both", "merge_angle": "degrees inside which a stronger ping replaces a weaker one rather than stacking (20)", "vignette_alpha": "the screen-edge colour's opacity at its strongest, 0 to 1 (0.27)" } }, "thematic:world_marker": { "doc": "A camera-facing reticle in the world on the point a move will reach, for the local wearer: a soft ring, four ticks and a centre dot that fade in, glide between candidates, and tighten and warm once locked on. With no options it is the web sling's anchor marker: where the next line would stick (green good, amber fair), and the anchor while swinging.", "options": { "probe": "what it marks: tether_anchor (default), where the next tether line would stick, out to the ability's range, and the line's anchor while swinging", "ring": "the ring: { radius (0.34), thickness (0.045), segments (24) }, in blocks close up", "dot": "the centre dot's radius in blocks (0.07); 0 draws none", "colors": "the ring while aiming: { good, fair } by how well the point will serve, each [r, g, b] (0 to 1), 0xRRGGBB or \"#RRGGBB\" (good [0.62, 1, 0.72], fair [1, 0.85, 0.45])", "locked_color": "the ring once locked on ([1, 0.55, 0.35])", "fade": "how much of the way to shown, hidden or locked it moves a tick (0.25)", "glide": "how much of the way to a new point it moves a tick (0.45); one farther than 6 blocks snaps", "rescan": "ticks between searches for the point while aiming (3)", "show_while": "when it shows before it locks on: aiming (default; in the air, looking up past 12 degrees, or in a swing's flow) or always" } }, "thematic:speed_lines": { "doc": "Short, faint, camera-facing streaks left in the air along a fast body's path, so it streaks past them. With no options they are the web sling's: up to 240, from 1 block a tick, alpha blended between a pale haze and a soft slate, behind any body swinging on a tether.", "options": { "min_speed": "blocks a tick below which a body leaves none (1)", "max_streaks": "the most alive at once, across every body (240)", "per_tick": "the most one body adds a tick (3): one at min_speed, one more each half block a tick faster", "width": "half a streak's width, in blocks (0.02)", "tints": "the two ends of the palette each streak is mixed from, [light, dark], each [r, g, b] (0 to 1), 0xRRGGBB or \"#RRGGBB\"; one colour is all streaks that colour ([[0.78, 0.84, 0.92], [0.42, 0.48, 0.58]])", "alpha": "a streak's opacity at its strongest (0.2); it starts at 0.4 of this at min_speed and rises by as much again a block a tick faster", "blend": "how a streak is laid over the world: translucent (default; it desaturates what it crosses) or additive (it lifts it toward its colour)", "show_while": "whose path gets streaks: tether (default; any body swinging on a tether, as the web sling's), active (a body with the ability, while it is active) or always (any body with the ability)" } }, "thematic:mark_sigil": { "doc": "A glyph floating over the head of every body carrying a mark this ability's wearer put on (mark(key)), through walls, bobbing and fading over the mark's last half second; by default only the marker and the marked see it, and the marked player in first person gets it pinned to the top of their screen. With no options: a white cobweb over the default mark.", "options": { "key": "the mark's key, as mark() wrote it (\"mark\")", "owner_key": "the key the mark's owner is kept under (mark()'s own default for the key)", "shape": "web (default), a cobweb of spokes and sagging rings; burst, jagged rays crackling from a point; ring, a ring with four ticks", "texture": "a texture id drawn instead of the shape, tinted with color", "color": "its colour (0xF4F4F4); a dark outline keeps it legible on any sky", "alpha": "its opacity, 0 to 1 (0.9)", "size": "blocks across (0.55); it never shrinks below a readable size far off", "lift": "blocks above the head (0.45)", "seen_by": "both (default): the marker and the marked; owner: the marker only; marked: the marked only; all: everyone near", "through_walls": "drawn through walls (true)", "hud": "the marked player sees it pinned to the top of their screen in first person (true)" } }, "thematic:sign": { "doc": "A glowing sign that flashes up in front of the wearer for the first moments of the ability's cooldown, spinning, shrinking and fading as it goes. With no options it is Righteous Cross's magenta X for 0.8 seconds.", "options": { "shape": "cross (default), an X; plus, a +", "color": "its colour (Righteous Cross's magenta, glowing white at the heart)", "duration": "how long it shows, in seconds from the start of the cooldown (0.8)", "distance": "how far in front of the wearer, in blocks (1.8)", "size": "how much bigger than Righteous Cross's it is drawn (1)" } }, "thematic:blast": { "doc": "An expanding shape counted from the world time thematic:mark_time stored under key, or drawn while the ability is active: a shockwave ring, an upright wall, rippling waves, an energy sphere, a pulsing dome or a sonic boom. With no options but its shape it draws what the move it came from drew.", "options": { "shape": "ring (default): a flat shockwave ring at the body's middle, thinning as it spreads; wall: an upright ring at the marked spot, facing the way the wearer faced; waves: three rippling orange spheres; sphere: a blue energy shell with a glow and a lightning cage; dome: a pulsing purple hemisphere and ring; boom: a sonic boom on the ground, a flash of shocked air then rings pressure fronts racing out ring_gap apart, each a white edge with a pale color fringe and an upright shock band height blocks tall", "key": "the mark_time key it counts from (_boom_tick)", "at": "wearer (default; spot for a wall): where it is centred -- spot is the point markSpot stored under spot", "spot": "the markSpot key it sits on with at: spot (the ability id)", "frame": "world: drawn in the world for everyone; suit: drawn with the suit, in its model's frame -- scaled and turned with it, and only where the suit is drawn -- as the old per-suit layers were (suit for waves and sphere, world otherwise)", "y_offset": "how far above the wearer's feet or the spot it is centred (the middle of the body for a ring or a dome; 0 at a spot and for a boom; 1 for waves and 0.2 for a sphere, in the suit's frame)", "radius": "its size, in blocks: one number, or [from, to] as it grows -- a dome's [smallest, largest] pulse (ring and wall [0, 12], waves [0.5, 8] for the outer sphere, sphere [1.5, 10], dome [3, 8], each boom front [0.5, 7])", "height": "a ring or wall's thickness, as a multiple: one number, or [from, to] ([4, 0.5] for a ring, 1 for a wall); a boom's shock band, in blocks tall as each front starts (0.6)", "seconds": "how long it grows (ring and wall 0.75, waves 1, sphere 3, each boom front 0.6); a dome's first swell, and how long it lingers once the ability ends (1)", "rings": "a boom's pressure fronts, one after another (3, at most 6)", "ring_gap": "a boom: seconds between one front and the next (0.15)", "debris": "a boom: rubble chips thrown up and out along the ground with the first front (0, at most 40)", "color": "its colour (the shape's own: a white ring, orange waves, a #3373CC sphere, a purple dome, a boom's #7FD0FF fringe)", "glow_layers": "a sphere's glow shells: one number, or [while small, at full size] ([5, 1])", "lightning": "a sphere's lightning cage (true)", "while_active": "true: drawn for as long as the ability is active, not only once it is counted from key", "first_person": "with frame suit: also drawn round the local wearer in first person, where the suit is not (true for a sphere)", "texture": "a sphere's texture, drawn as a beacon beam, e.g. \"minecraft:textures/block/water_still.png\" (plain white)", "waves": "a sphere drawn as one rippling shell in color at half opacity, instead of a core and glow shells: {intensity, frequency} of the ripples ({intensity: 0.12, frequency: 8}, the water shield's)", "spin": "a sphere's turn about the vertical, in degrees per tick (0)", "shells": "a sphere's core and glow shells: false for none (the lightning cage alone, the lightning shield's), or {core_scale, core_alpha, glow_scale, glow_alpha}, each a multiple of the radius and an opacity 0 to 1 ({core_scale: 0.5, core_alpha: 0.125, glow_scale: 0.75, glow_alpha: 0.063}; the Lantern shield's is 1, 0.5, 1, 0.25); hard_light: true draws the core as a bubble, one surface clear where it faces you and bright round its rim, in the texture's hard-light look (its .mcmeta's thematic_hard_light: tile, scroll), rippling where the wearer is struck; its rim is its glow, so the glow shells are left out (false)", "cage": "a sphere's lightning cage: {intensity, flicker}, its bolts' thickness plus up to flicker more each frame ({intensity: 0.3, flicker: 0.05}; the lightning shield's is 1 and 0.2)", "color_option": "a suit option of this ability that names its colour as \"#RRGGBB\", asked first: the suit's own colour for the move, e.g. \"color\" (an option that is there but no colour gives color)", "color_from": "where its colour comes from when color_option gives none: \"suit\" (the worn suit's speed-trail tint) or a name another system registers; color when that has none either", "also_on": "also drawn on a wearer who has this status effect while a teammate within `within` blocks (24) has the ability active: {effect: \"minecraft:resistance\", within: 24}, the Lantern shield on the teammates it shields. Their own suit must carry the ability too" } }, "thematic:flight_path": { "doc": "A model flown along a path in the world, with no entity behind it: for seconds after the mark_time key, round the spot mark_spot keeps (or the wearer), facing the way it travels. A path is keyframes, an orbit, or an orbit ending in a dive; a formation flies several copies of it. The move's own verbs do the damage, from the same places: a projectile from {flight: true} leaves from the model, a burst at the spot.", "options": { "model": "a GeckoLib geo model: \"thematic:jet\" is assets/thematic/geo/entity/jet.geo.json, or a full path (\"thematic:geo/entity/construct_missile.geo.json\")", "texture": "its texture (thematic:textures/item/construct.png)", "layer": "hard_light (default): the construct look, see-through light in the texture's own scroll, drawn in from nothing as it appears; solid: the texture as it is", "color": "the tint (white)", "color_from": "the tint from something about the wearer instead: \"suit\" (its trail colour), \"corps\" (their Lantern corps' colour)", "scale": "its size (1)", "key": "the mark_time key its time counts from (_flight)", "seconds": "how long after the mark it is drawn (6)", "at": "spot (default): round the point mark_spot keeps under spot, turned the way the wearer faced when it was marked -- marked again each tick, it follows (a target); wearer: round the wearer as they face", "spot": "the mark_spot key it flies round (the ability id)", "y_offset": "how far above the spot a dive ends (1)", "path": "keyframes, [seconds, right, up, forward] from the anchor in its frame, flown straight from each to the next; before the first and after the last it is not drawn -- a flight passing overhead: [[0, 0, 16, -12], [1.6, 0, 16, 36]]", "orbit": "a circle round the anchor instead: {radius (8), height (12), speed (60, degrees a second), phase (0, degrees it starts at), count (1, copies spaced evenly round it)}", "dive": "{start, seconds}: from where the path has it at start, straight into the anchor over seconds -- a kamikaze", "formation": "copies, each flying the path offset by [right, up, forward] in its frame ([[0, 0, 0]]): a V is [[0, 0, 0], [-10, 0, -8], [10, 0, -8]]", "smooth": "true (default): the path is one curve through every keyframe, sweeping round its turns; false: straight from each keyframe to the next", "bank": "the most it rolls into a turn, in degrees (55; 0: level through every turn)", "facing_key": "the mark_spot key whose facing turns the path's frame, when it is not the spot's own: mark the wearer once at the press and a target every tick, and the path keeps his facing while it follows them", "glow": "how far its colour is lifted toward white, 0 to 1, so it reads as light even tinted dark (0.45)", "shade": "how much darker its faces are as they turn away, 0 to 1 (0.1)", "turn": "degrees added to the model's heading, for a model built facing another way than GeckoLib's nose-to--z (0)" } }, "thematic:beam": { "doc": "A beam drawn out of the wearer: on the suit in third person, through the camera in first person, and on a mob using the move. With no options it is Heat Vision's: the suit's beam assets as a layered beam from the eyes, 80 blocks long (to the first block along the look in first person), drawn while the ability is active. Colours, width, glow, count, spacing and opacity are the suit's assets.beam unless an option says otherwise.", "layer": true, "options": { "from": "where it comes out (eyes); a list draws one from each: [\"right_hand\", \"left_hand\"]", "when": "when it is drawn (active): \"active\", \"held\" (the key is down), or { active, held, gaugeAtLeast: seconds, flag: a set_flag key, state: a phase's name }, all of which must hold; a list is any of them", "from_gauge": "seconds of heat: also drawn while the key is held with at least this much on the gauge (Heat Vision's 0.5)", "style": "how it is drawn: layered (Heat Vision's; the default from the head and body), fan (Visor Off's widening sheet), cylinder (the radiation beam's; the default from the hands), model (the suit's beam model's \"beam\" bone), filament (Vision's: a thin crackling line that stops on the first block along the look; lance is its old name) or cone (Incinerating Ice's: a square cone from size to end_width, in turning glow shells), or waves (the water jet's: rippling or crystal tubes out of the right arm, one per layers entry, in texture), or flame (a thruster flame as a beam: a core cone in the start colour inside an outer cone in the end colour, glow_size wide, flickering and fading to a point, without the white-hot layering), or hellfire (Hellfire's roiling stream: crossed ribbons rolling about the axis, a dim core_color heart in a bright color rim, glow_size its half width, surging outward and climbing, with tongues licking up and embers rising), or torch (a blowtorch jet: a white-hot core threaded with shock diamonds in a tight sheath of roaring flame that flares open at its far end, a muzzle flare, a heat shimmer and sparks, turned to the camera; core_color its core, color its flame, glow_size its half width; rings adds pressure rings), or fractal (comic-book lightning: a zigzag of a few sharp stretches snapping to a new shape every 3 ticks, hard-angled forks, a core_color core in a color band in a deeper rim, with a starburst and krackle dots where it stops on the first body or block along the look), or crystal (a beam of ice to the first block along the look: a still core_color core in a faceted translucent sheath of color whose facets glint, splinters shed off it, cold mist sinking off it, crystal spikes on a frost ring where it lands), or plume (a roaring cone of flame: a white-hot core_color jet at the mouth, size its half width there, soft flame puffs pouring out to end_width, cooling through color to deep red, smoke and sparks off it), or magma (a heavy molten stream, glow_size its half width, drooping droop blocks by its far end and stopping on the first block: white-hot core_color where it faces you, color across it, crusted edges, globs tearing off and falling, a splat where it lands), or vortex (a funnel of air drawn into the mouth, size its radius there and end_width at the far end: color streak arms spiralling in, rings closing in, chips of the blocks round its far end tumbling in; reverse blows out)", "length": "how long in third person, in blocks (80 layered or fanned, 15 as a cylinder, 30 as a cone, 12 as a flame or a plume, 10 as hellfire, 14 as a torch, magma or a vortex; a filament, crystal or fractal: the farthest it looks for a block to stop on, 64, 80 and 24)", "scale": "the whole third-person beam, length and all (1; Solar Fury's is 2.5); a filament or crystal it only thickens", "first_person_scale": "how much wider the first-person beam is drawn (scale)", "first_person": "a beam from the head in first person: layered (default), through the camera to the first block along the look; none. Hands are drawn on the first-person arm either way, except camera: a fractal beam from a hand is drawn through the camera from that hand's side, not on the arm", "first_person_range": "how far the first-person beam looks for a block to stop at (90)", "count": "how many beams side by side (the suit's)", "spacing": "how far apart they are (the suit's)", "size": "the core's width (the suit's)", "glow_size": "how far the glow reaches past the core (the suit's)", "color": "the outer, glow colour (the suit's endColor)", "core_color": "the core colour (the suit's startColor)", "texture": "a texture id a layered beam is drawn with (the suit's)", "opacity": "third-person opacity (the suit's)", "first_person_opacity": "first-person opacity (the suit's)", "end_width": "fan: how wide its far end is (30); cone and plume: half its width at the far end (5, 3.2); vortex: its radius at the far end (4)", "end_height": "fan: how tall its far end is (6)", "helix": "cylinder: winds the radiation beam's twin strand round it", "wobble": "filament, fractal: how far its line wanders off true, times the default (1); 0 draws it dead straight", "forks": "filament: sparks fork off the line; fractal: hard-angled forks branch off its corners (true)", "flicker": "hellfire, torch, plume and magma: how much it surges, churns and licks; fractal: how hard each snap flashes; crystal: how far its facets turn as they glint; times the default (1); 0 holds it steady", "embers": "hellfire, torch and plume: how many embers or sparks fly off it, times the default (1); 0 for none", "diamonds": "torch: how many shock diamonds thread its core (5, at most 10; 0 for none)", "rings": "torch: how many pressure rings race down it at once, for a heavier blast (0, at most 8)", "shards": "crystal: splinters shed off it per block (3)", "mist": "crystal: how much cold mist drifts off it and sinks, 0 to 1 (0.6)", "impact": "crystal: crystal spikes and a frost ring where it lands (true)", "copies": "crystal: how many beams, spread evenly round the wearer's vertical axis, 1 to 4 (1)", "ground_ring": "crystal: the radius, in blocks, of a frost ring on the ground round the wearer with a bright arc trailing each beam as it turns (0 for none)", "smoke": "plume: how much dark smoke rolls off its far end, 0 to 1 (0.6)", "droop": "magma: how far its far end sags under its weight, in blocks (2.5)", "blobs": "magma: how many glowing globs tear off it and fall, times the default (1)", "arms": "vortex: streak arms spiralling round it, 1 to 8 (4)", "debris": "vortex: chips of the blocks round its far end riding it in, 0 to 48 (24); none in open air", "swirl": "vortex: how fast it turns at its far end, radians a tick, twice that at the mouth (0.35); negative turns it the other way", "reverse": "vortex: blows out of the mouth instead of drawing in (false)", "bloom": "cylinder: soft glow shells round the beam past its glow, each wider and fainter, out to about twice its width (0, at most 8); fractal: widens its faint bloom a quarter more a step", "crackle": "Kirby crackle: dark dots that swell and pop round the beam (not a filament, model or waves beam); true, or the look options of thematic:crackle", "model": "the geo model a layered beam is placed by (geo/item/beam.geo.json) or a model beam drawn from (geo/armor/willpower_beam.geo.json); the suit's assets model when left out", "delay": "seconds after since before it shows", "ramp": "[from, to] seconds after since over which it thickens from 15% to full, as Starbolt Swerve's bolts built with the arms; it shows from `from`", "since": "the synced world time delay and ramp count from: a key the ability stored (StateStart, when its phase began)", "mobs": "drawn on a mob using the move too (true)", "layers": "waves: the tubes, each {shape: waves | crystal, radius (0.05), length (15), sides (8), segments (10), color (the beam's color), alpha (1), speed (1), intensity (0), frequency (0), jitter (crystal, 1), fullbright (false)}; the water jet's is [{radius: 0.08, sides: 16, segments: 20, alpha: 0.5, intensity: 0.05, frequency: 2}, {radius: 0.03, intensity: 0.01, frequency: 4.2}]", "lift": "model: how far up its bone it sits, in blocks (0.5, the Lantern hand beams'; 0 for the unleash beam on the body)", "flash": "model: the chance each frame, 0 to 1, that it is drawn as an energy swirl instead (0; the Lantern unleash's 0.05)", "until": "seconds after since from which it is no longer shown (always shown): with delay, a window" } }, "thematic:light_projection": { "doc": "A projector in the wearer's hand: a soft cone of light along their aim to the first block it meets, where an image (white where it lights) is cast flat onto the struck surface in a pool of light, growing with distance like a real projector's, following the aim live for everyone near. With no options: a warm round spot from the right hand, 48 blocks, while the ability is active. Place light blocks yourself if the world should brighten too.", "options": { "texture": "the image cast, a texture id, white where it lights and transparent elsewhere (a plain round spot)", "color": "the light's colour (0xFFF4D6)", "range": "blocks the light reaches, 1 to 128 (48)", "spread": "the cone's full angle in degrees, how fast the image grows with distance (9)", "size": "the largest the image grows, in blocks across (6)", "from": "where the cone starts: right_hand (default), left_hand or eyes", "intensity": "the image's brightness, 0 to 2 (1)", "cone_alpha": "the cone's opacity at the hand, 0 to 1 (0.22)", "flicker": "how much the light flickers, 0 to 1 (0.08)", "when": "when it shines: \"active\" (default), while the ability is active; \"always\", for as long as the suit has it; { state: \"\" }, while the ability is in that phase; { flag: \"\" }, while a flag it set is on; { effect: \"\" }, while the wearer carries that effect" } }, "thematic:trail_to_target": { "doc": "A curling ribbon from the wearer to the target thematic:track holds, its waves rolling toward it, drawn while the ability is active -- from the live entity, or the track's synced position once it is out of render distance. With no options it is Scent Tracker's two blood-red strands.", "options": { "track": "the track it follows (the ability's id)", "from": "where on the wearer it starts (eight tenths of the way up to the eyes, moved forward toward the target)", "forward": "how far toward the target it starts, in blocks (0.6)", "end_height": "how far up the target's body it ends, as a share of its height (0.5)", "strands": "how many ribbons, spread evenly out of step (2)", "waves": "how many waves along it (2.5)", "amplitude": "how far it swings either side at its middle, in blocks (0.55)", "scroll": "how fast the waves roll toward the target (0.35)", "width": "the half-width of its bright core, in blocks (0.09)", "max_length": "the longest it is drawn, in blocks (24)", "min_length": "the shortest; nearer than this it is not drawn (1)", "color": "its colour, glowing out to a faint halo (Scent Tracker's blood red)", "helix": "each ribbon corkscrews round the line in three dimensions, rising and falling with it, instead of waving flat to the camera (false)", "reverse": "it flows toward the wearer, brightest at their end, instead of away from them (false)", "to_effect": "an effect id: a ribbon to every living body that has it within within blocks, instead of the track's one target", "within": "how far to_effect bodies are drawn to, in blocks (16)" } }, "thematic:blade_trail": { "doc": "A glowing streak left by every blade of the wearer's claws (or the blade bones named in bones), hung off the bones the game drew each frame. With no options it is the Wolverine moves' white trail, while the ability is active.", "options": { "while": "active (default): while the ability is active; animating: while it claims the pose (claimPose)", "bones": "\"auto\" (default): the claws, every blade under clawsLeft and clawsRight; or a list of blade-root bones, each blade under them trailing -- a root whose name says \"left\" is the left hand's", "lifetime": "seconds a stretch of trail lasts before it has faded out (0.3)", "colors": "the trail's colours, core first: one colours every layer, more run core to halo (white to steel)", "width": "the bright core's width in blocks; the halo widens with it (0.06)" } }, "thematic:claw_marks": { "doc": "Claw marks a strike leaves: one bolted in front of the wearer as the blow lands (press), a run of them planted behind (trailing), or rips torn open in front (barrage). With no options, X-Slash's cross.", "options": { "mode": "press (default): one mark in front of the wearer at a moment of the pose claim; trailing: marks planted behind them as they go; barrage: rips torn open in front of them, on a metronome (every) or on an animation's frames", "shape": "cross (press's default), horizontal_cross (trailing's) or rip (barrage's)", "while": "trailing and barrage: when they run -- active (default), while the ability is active; animating, while it claims the pose", "at": "press: seconds into the pose claim the mark appears (0)", "claim": "press, needed: how long the move claims the pose, in seconds, as its claimPose({ for }) says", "lifetime": "seconds each mark lasts (press 0.6, trailing 0.75, barrage 0.35)", "every": "trailing, and a barrage without frames: seconds between marks (trailing 0.2, barrage 0.15)", "frames": "barrage: the moments within each cycle a rip opens, in seconds, e.g. [0, 0.2, 0.4, 0.6, 0.8]", "cycle": "barrage with frames: the animation's length in seconds, which the frames repeat on (1)", "for": "trailing and barrage: stop planting this many seconds after they begin (never)", "only_with_blades": "true: only for a suit whose model has claws (false)", "marks": "several sets at once, each with the options above -- Berserker Tunnel's trailing marks and its rips" } }, "thematic:motion_trail": { "doc": "A glowing ribbon trailing behind the wearer while they move a certain way: the lantern aura behind a flying corps member, the spiral behind a riptide. An item may name it in its visuals, and it then draws while the item is held. With no options, the lantern aura's white ribbon while the ability is active.", "options": { "when": "when it grows, each condition true or false: active (the ability; an item's visual ignores it), flying (gliding or flight), sprinting, airborne (off the ground), riptiding, holding (an item id held in either hand). With no when: an ability's while it is active, an item's while it is held", "color": "its colour (white), unless color_from gives one", "color_from": "take the colour from the wearer each frame, and draw nothing while they have none: \"suit\" (the worn suit's speed-trail tint), or a name another system registers (\"corps\")", "length": "how many ticks of movement it keeps, one point a tick (24)", "anchor_height": "where on the wearer's height it is anchored, 0 feet to 1 head (0.1)", "start_width": "half its width at the wearer, in blocks (0.1)", "width": "half its width at its widest, in blocks (0.55)", "peak": "how far along it is widest, 0 at the wearer to 1 at the tail (0.3)", "alpha": "the core's alpha at the wearer; it fades toward the tail (0.4)", "glow_width": "how many times wider the soft glow around the core is (2.8)", "glow_alpha": "the glow's alpha next to the core's (0.18)", "spiral_turns": "how many times it twists about its own path from wearer to tail; 0 lies it flat to the eye (0)", "spiral_speed": "how fast the twist rolls, in radians a tick (0)", "live_head": "true: while it grows, its head is the wearer where they are drawn this frame, so it never lags a tick behind (true)" } }, "thematic:slipstream": { "doc": "The air a fast body tears through, drawn on the body: a vapour cone opening back from just ahead of it, banded and with a bright collar, and flow lines wrapping round it and streaming off behind with dashes of light running along them. It swells with speed and follows the way the body moves, for every player who can see it. Dashes, lunges and flight bursts.", "options": { "when": "when it is lit, each condition written must hold: active (the ability running), flag (a setFlag flag set on the wearer), flying, sprinting, airborne (off the ground). Left out: while the ability is active", "color": "the vapour's colour (#E8F4FF)", "min_speed": "blocks a tick below which nothing shows (0.45; sprinting is about 0.28)", "full_speed": "blocks a tick at which it is strongest (1.4)", "size": "a multiplier on the cone's width round the body (1)", "cone_alpha": "the cone's opacity at its collar, 0 to 1 (0.32); 0 draws only the flow lines", "lines": "how many flow lines at full speed, up to 24 (16); 0 draws only the cone", "line_alpha": "the flow lines' brightest, 0 to 1 (0.55)", "length": "blocks the flow lines stream off behind the body (3)", "first_person": "how strongly the wearer sees their own from inside, 0 to 1 (0.35); the cone's nose is left out so the middle of the screen stays clear" } }, "thematic:fire_trail": { "doc": "Fire left along the path the wearer moves through, a point a tick, burning out from the tail: a band of flame with tongues rising off it (sheet, a flier's fire trail), or a rotating pillar of fire wrapped round the path (pillar: arms of flame spiralling round it in a smoky sleeve about a white-hot core). Drawn for everyone in sight while its when holds and the wearer moves; with hot_color and heat it heats the longer the phase runs.", "options": { "when": "when it grows (active): \"active\", \"held\", or { active, held, gaugeAtLeast: seconds, flag: a set_flag key, state: a phase's name }, all of which must hold; a list is any of them", "shape": "sheet (default): a band of flame along the path with tongues rising off it; pillar: a rotating pillar of fire wrapped round the path", "length": "how many ticks of path it keeps, one point a tick (16; a pillar 10; at most 40)", "width": "sheet: half its width at the wearer (0.45); pillar: its radius (1.3), in blocks", "height": "sheet: how tall its tongues rise, in blocks (1.1)", "anchor_height": "where on the wearer's height it is fed from, 0 feet to 1 head (0.3; a pillar 0.55)", "color": "its flame (#FF7A1A)", "core_color": "its white-hot heart (#FFF2B0)", "tip_color": "what its tongues burn out to (#A01800)", "hot_color": "the colour its flame heats to over heat seconds of the ability's phase (none: it stays color)", "heat": "seconds into the ability's phase it takes to heat from color to hot_color (0: hot_color at once)", "arms": "pillar: how many arms of flame spiral round it (3, at most 6)", "spin": "pillar: turns a second its arms make round the path (1.5)", "twist": "pillar: radians its arms lag per point back along the path (half a tick's spin); equal to a tick's spin, the spiral stays where it was laid", "alpha": "its opacity, 0 to 1 (1)", "embers": "how many sparks fly off it, times the default (1; 0 for none)" } }, "thematic:afterimage": { "doc": "Glowing echoes of the wearer left behind as they move: every few ticks a copy of their body in the pose it was drawn in that frame (clips and spins included), tinted one colour, hanging where it was taken and fading as it swells a little, with a brighter rim. Each client keeps its own; no entities. With no options: red echoes every 3 ticks, 14 ticks each, at most 6, while the ability is active.", "options": { "color": "the echoes' colour (0xE23636) when color_option and color_from give none", "color_option": "a suit option of this ability naming the colour as \"#RRGGBB\", asked first, so each suit (an alt's entry for the same ability) tints its own echoes", "color_from": "a colour source asked after color_option: \"suit\" (the worn suit's speed-trail tint) or a registered name", "every": "ticks between echoes (3)", "lifetime": "ticks each echo lasts (14)", "count": "the most echoes shown at once, 1 to 12 (6)", "delay": "seconds after the ability turns on before the first echo, e.g. past a charge-up (0)", "alpha": "a new echo's opacity, 0 to 1 (0.55)", "swell": "how much bigger an echo has grown by the time it is gone, as a share (0.05)", "rim": "the bright rim's strength, 0 to 2; 0 for none (1)", "textured": "show the suit's art through the tint (true); false is a flat silhouette", "when": "when echoes are left: \"active\" (default), while the ability is active; \"always\", for as long as the suit has it; { state: \"\" }, while the ability is in that phase; { flag: \"\" }, while a flag it set is on; { effect: \"\" }, while the wearer carries that effect" } }, "thematic:target_readout": { "doc": "Lines about the target thematic:track holds, on a torn scrap pinned beside its body on the wearer's screen (through walls), while the ability is active; while nothing is tracked, the empty line instead. With no options it is Scent Tracker's readout: scent, health and bleed. Style panel is a scanning visor's readout instead: a framed panel over the entity under the visor's crosshair with its name, health, distance and speed (a thematic:vision visor that scans draws it with no options).", "options": { "style": "scrap (default): lines about the tracked target on a torn scrap; panel: a scanning visor's framed readout of the entity under its crosshair", "track": "the track it reads (the ability's id)", "lines": "the lines, top to bottom: each a translation key given the value as its argument -- the target's name, display health or seconds of bleed; zero is a translation passed instead while the value is 0, wrap one the value is passed through first (Scent Tracker's scent, health and bleed lines)", "empty": "the translation key drawn while nothing is tracked; \"\" for nothing (thematic.scent_tracker.none)", "empty_at": "[x, y]: where the empty line is drawn, in scaled screen pixels ([5, 120])", "anchor": "where the scrap sits: body (default) pins it beside the target's body; speed_bar draws it fixed beside the speed bar, with no tie to the body (a target_portrait on the same anchor takes the same spot, so use one of the two)", "height": "how far up the target's body the readout is pinned, as a share of its height (0.55 for the scrap, 0.85 for the panel)" } }, "thematic:target_portrait": { "doc": "A scanning visor's portrait of its subject: a framed panel down one side of the screen with the subject's own model, ghosted and washed in its outline colour, its held item called out and its name on top. The subject is the entity under the crosshair, or the one a standing pin holds; while the pinned subject is drawn, rows about it fill the foot of the frame. A thematic:vision visor that scans draws it with no options; naming it on the same ability tunes it.", "options": { "anchor": "where the frame stands: screen_edge (default) down the side the side option names; speed_bar beside the speed bar, its bottom edge level with the bar", "side": "which edge of the screen the frame sits against (left)", "width": "the frame's width, in scaled pixels (78)", "height": "the frame's height, in scaled pixels (128)", "body_alpha": "how solid the subject's own body is drawn, 0 to 1 (0.85)", "wash_alpha": "the wash of outline colour over the frame, 0 to 1 (0.25)", "held_tint": "[r, g, b, alpha] the subject's held item is drawn in, each 0 to 1 ([1, 0.15, 0.15, 0.3], a red call-out)", "rows": "the rows at the foot of the frame while the pinned subject is drawn, top to bottom: health (display health over its maximum), gauge (the pin's time left) and cooldown (the subject's ultimate) and effect (a status effect's levels on the subject: {kind: \"effect\", effect: \"thematic:example_effect\", label?: \"Level\", per_level?: 0.05, decimals?: 1 (0 to 4), suffix?: \"%\"} reads \"Level 3.4%\"); health, gauge and cooldown by default", "pin": "{uuid, id, until, duration}: keeps a subject on the portrait while nothing is under the crosshair -- the entity whose uuid (store key uuid) and network id (store key id, optional) the wearer's data holds, until the world tick stored under until; duration (600) is the pin's full length in ticks. None by default" } }, "thematic:vision": { "doc": "A visor: a view shader while the ability is active (or for as long as it is worn), outlines on the entities it shows, and, when it scans, a readout on the one under the crosshair and nearby counts, with a switch for each on the wheel of a toggle. With no options it is an X-ray wash at full view width that scans and pings through walls.", "options": { "shader": "the view shader: xray (default; see-through wash that fills outlined bodies), radar (Daredevil's sense) or none", "when": "active (default): while the ability is active; worn: for as long as the wearer has it", "tint": "[r, g, b] the xray shader's highlight colour, each 0 to 1 ([0, 1, 0.85], aquamarine)", "fov": "the view's width, as a share of normal (1); X-Ray's is 0.6", "accent": "the readout and counts' colour (0xCC0000)", "label": "the name of the ability's own switch on the wheel (\"Vision\")", "icon": "that switch's item icon (minecraft:ender_eye)", "filters": "which switches the wheel offers besides it (all of them); one left out reads as its default (on)", "shows": "which kinds of entity it outlines at all (all of them)", "colors": "{kind: colour} outline colours, from [red, cyan, magenta, yellow, white] only -- the xray shader fills a body by matching one of those exact hues", "outline_color": "one colour, any colour, for every outline the wearer sees while it is on, in place of colors (Daredevil's is 0xFF5555); not with the xray shader, which only fills the pure hues", "ping_through_walls": "true (default): the ping key marks players through walls while it is on", "scan": "true (default): while it is on, the client scans for the entity under the crosshair and the nearby counts, which the scan mode draws from: the readout (thematic:target_readout, style panel), the portrait (thematic:target_portrait) and the counts; name either visual on the same ability to tune it", "counts": "true (default): the scan draws the nearby players, hostiles and passives down the left of the screen, in the accent (the wheel's counts switch still turns them off)", "overlay": "a texture drawn over the whole screen while the scan is on, e.g. a visor's lens frame (none)", "overlay_alpha": "how opaque the overlay is drawn, 0 to 1 (1)", "gauge": "a meter the scan's readout shows under the subject's health: meter (the key its 0-100 value is kept under), filling (a flag the move sets while it fills on the subject), until (the key of the world tick it stands until once full) and duration (seconds it stands, 30), and its label: full (\"Stalked\"), charging (with %s the value) and idle", "radar_tint": "the radar shader's colour for the edges it draws (Daredevil's pink-red); radar shader only", "radar_wash": "how far the radar's grey takes on radar_tint, 0 (grey, default) to 1; radar shader only", "clear_radius": "blocks around the wearer the radar leaves the world as it really looks, the sense drawn only beyond (0, default: the sense over the whole view); radar shader only", "clear_edge": "the width in blocks of the soft band where the clear zone gives way to the sense (3)", "edge_noise": "how many blocks that band ripples in and out, moving over time (0: a still circle)", "obscure": "how far the radar's sense is swallowed by fog_color, 0 (default: not at all) to 1 (only entity outlines and faint edges show); with a clear_radius it deepens across a band's width past the edge", "fog_color": "the colour obscure fades the sense into (0x000000)" } }, "thematic:silhouette": { "doc": "A sense for bodies that carry a status effect: to the wearer alone, every other body with the effect is drawn as a silhouette over everything -- walls and bodies in front of it -- as far off as the client has it, and its own body is hidden: only the whole shape shows, every limb and worn layer of it. Everyone else sees it as usual. Flat colour by default; with a texture the shape is filled with it as one surface over the whole body, tinted by color, and can scroll and pulse. E.g. Blood Sense: {effect: \"thematic:bleed\", color: 0xFF3030, alpha: 0.78, texture: \"textures/misc/blood_sense.png\", scroll: 0.02, shade: 0.45, pulse: {rate: 1.1, depth: 0.35}}.", "options": { "effect": "the status effect a body must carry to be seen this way, e.g. \"thematic:bleed\", or a list of them (any one does); a bare id is minecraft's. Required", "color": "the silhouette's colour (0xFF0000, red)", "alpha": "how solid it is drawn, 0 to 1 (1); below 1 the world shows through it, blended once over the whole shape (a pulse dims it a little between beats)", "texture": "a texture the shape is filled with instead of flat colour, tinted by color, e.g. \"textures/misc/blood_sense.png\" (a bare path is thematic's). It is laid over the whole body as one surface, the way hard light is, so it runs across every limb rather than following the model's own UVs; use one that tiles", "tile": "with a texture: how many times a block it repeats over the body (1.5)", "scroll": "with a texture: how far it slides down the body a tick, in texture heights, e.g. 0.012 for a slow drip (0, still); negative runs up", "shade": "0 to 1: how much darker a face turned edge-on to the viewer is than one facing them, so the limbs read as solid shapes rather than one flat cut-out (0, flat)", "pulse": "a heartbeat: the silhouette brightens on each beat (a double thump) and dims between. {rate: beats a second (1.1), depth: how far it dims between beats, 0 to 1 (0.35)}; a number is the depth at the default rate; true, both defaults (none, steady)", "when": "worn (default): for as long as the wearer has the ability; active: while it is active", "ramp_levels": "levels of the effect (amplifier + 1) at which the silhouette is drawn at its full alpha: a body with fewer is drawn fainter, a fifth of it at one level, so a stacking debuff shows how far it has built (0: always full)", "everyone": "with keep_body: every viewer sees the mark, not only the wearer -- the body carrying the effect is marked in everyone's eyes (false)", "keep_body": "true: the body is still drawn as usual and the silhouette laid over it, over walls too -- a mark on the body (a texture of lines over it) rather than a shape in its place (false)" } }, "thematic:self_outline": { "doc": "Outlines the wearer's own body in a colour, for the wearer alone: the game's entity outline, asked for on the wearer's client only, so it shows in third person and no other player ever sees it (first person draws no body to outline). E.g. {color: 0xFF8A1F}.", "options": { "color": "the outline's colour (0xFF8A1F, orange)", "when": "active (default): while the ability is active; worn: for as long as the wearer has it" } }, "thematic:glow": { "doc": "Suit bones drawn again, glowing, from an effect model in a beacon-beam texture: eyes, fists or a shell over the whole suit. With no options, the armorHead bone of geo/armor/.geo.json in textures/armor/beam.png, while the ability is active. A suit's own model/texture assets for the ability win over model and texture.", "layer": true, "options": { "bones": "the suit bones that glow ([\"armorHead\"]), each redrawn from the effect model's bone of the same name; \"all\" for every bone of the suit", "model": "the effect model, e.g. \"geo/armor/hand_glow.geo.json\" (geo/armor/.geo.json)", "texture": "the beacon-beam texture it is drawn in (\"textures/armor/beam.png\"); with blend translucent, the texture of the translucent layer (none: the suit's own texture)", "when": "what lights it at alpha: \"active\" (default), while the ability is active; \"toggle\", while its wheel switch is on; {flag: key}, while that set_flag flag is set", "toggle": "with when \"toggle\": the switch that lights it (the one named after the ability)", "alpha": "how opaque it is while lit, 0 to 1 (1)", "tint": "[r, g, b] it is tinted with, each 0 to 1 ([1, 1, 1], untinted)", "scroll": "how much of the texture it scrolls through per tick, e.g. 0.03 (0, still)", "scale": "how much larger than the bone it is drawn (1)", "shell": "true: lay the cubes over the worn bones as they stand rather than posing the effect bone again -- for an effect model that is the suit's own model", "bright_while_active": "ability ids whose running lights it fully, whatever when says, e.g. [\"solar_fury\"]", "fade_with_gauge": "{of: ability id, over: seconds}: lit by that ability's gauge, fully at over seconds and fading out as it empties (when's alpha wins while when holds)", "ramp": "for a glow an effect visual draws (effect_visuals' suit_visual): {ticks: [from, to], alpha: [a, b], scale: [a, b]} over the effect's remaining ticks -- nothing below from, easing from a to b up to to, b from there on (alpha and scale default to [1, 1])", "blend": "how it is laid over the suit: beacon (default), a full-bright beacon-beam glow; translucent, drawn like the suit itself at its light -- in a translucent layer of the texture when the suit's assets or texture name one, else in the suit's own texture -- for a prop the move puts on the suit (Wrecking Ball's ball); emissive, the suit's own texture (or texture) at full brightness with ordinary blending, so its painted glow lights up in its own colour (darkened by tint) and never washes out to white -- with shell and the suit's own model", "parent_bones": "true: each named bone is also drawn on the worn bone its parent in the effect model is named for, so a bone the suit lacks (a tiara under armorHead) still shows (false)", "bones_by_flag": "{flag: [bones]}: which bones glow follows the wearer's flags (set_flag) -- each set flag's list, instead of bones; none set, none glow. E.g. {\"gift_legs\": [\"armorLeftLeg\", \"armorRightLeg\"]}" } }, "thematic:model": { "doc": "A glTF model, or a glowing sphere, drawn on the suit at an anchor while the ability is active: growing along a ramp, looping the model's own animation clip, trailing ribbons behind its parts, or copied round a ring that circles the wearer. Name a model or a shape.", "layer": true, "options": { "model": "a glTF model id: \"thematic:atom\" is assets/thematic/gltf/atom.glb (or .gltf)", "shape": "a built-in shape instead of a model: glow_sphere, a sphere in glowing shells; flame_orb, a ball of fire (a white-hot heart in turning shells of flame, tongues licking up off it, sparks) tinted by color, core_color and tip_color", "at": "where on the body it is drawn (\"chest\"): [eyes, head, mouth, chest, main_hand, off_hand, left_hand, right_hand, feet], {bone, offset} or {point, offset}", "space": "bone (default): rides the anchor's bone as it swings; model: at the anchor's resting place, not following the bone's pose", "scale": "a model's size (1), or a ramp: {ramp: [0.15, 2.5], across: \"duration\"}. across is duration or cooldown (the tuned one, counted from since), countdown (the cooldown slot running down from the duration) or seconds", "radius": "the glow sphere's radius in blocks (0.3), or a ramp as for scale", "since": "the stored world time a ramp counts from (StateStart, which every phase writes; or a thematic:mark_time key)", "clip": "a model's animation to loop, by name, on the wearer's age", "smooth": "false: the clip, the ring's turn and a ramp step once a tick instead of every frame (true)", "color": "the tint (0xFFFFFF)", "alpha": "the tint's opacity, 0 to 1 (1)", "trails": "a model's ribbon trails: true behind every part with a mesh, or a list of node names", "orbit": "copies on a ring round the anchor: {count (4), radius (1.8), height (0), speed (radians a tick, 0), scale (each copy's size, 1)}", "glow_layers": "the glow sphere's shells (2), each 0.12 wider", "glow_fade": "how much less opaque each shell is than the one inside it (0.15)", "detail": "the glow sphere's rings and segments (24)", "when": "when it is drawn (active): \"active\", \"held\", or { active, held, gaugeAtLeast: seconds, flag: a set_flag key, state: a phase's name }, all of which must hold; a list is any of them", "core_color": "a flame_orb's white-hot heart (#FFF6D0)", "tip_color": "what a flame_orb's flames burn out to (#B01E00)", "embers": "a flame_orb's sparks, times the default (1)", "spin": "how fast a flame_orb's shells turn, times the default (1)" } }, "thematic:density_shift": { "doc": "The suit drawn as a phased shell -- its bones tinted grey and see-through over a faint pass of its own texture -- whenever the wearer's body is shifted: a phase of theirs that phases (the phase trait), a move holding the shift up, or a projection mirroring its owner's phase. Name it on anything that phases the wearer: the shift takes the suit's own textured pass away, and this layer draws the body instead. With no options, the Intangibility ghost.", "layer": true, "options": { "tint": "multiplied through the suit's texture: one grey level 0 to 1, or [r, g, b] (0.8)", "alpha": "how much of the world the body hides, 0 to 1 (0.5)", "fullbright": "drawn at full light, so a phased body keeps one weight walking from sun into shade (true)", "bones": "the top-level suit bones drawn; children come along (all eight, boots included)", "part": "body (default): the whole body while it is shifted, the main arm alone while only the hand is; main_hand: only the main arm, while either is", "depth_prime": "stamp each bone's depth first so only the body's nearest surface is shaded, one even skin rather than stacked cubes (true)" } }, "thematic:bone_sprites": { "doc": "Small spinning discs scattered about some of the suit's bones: Polka Dot Man's coloured dots on his forearms. Each bone's scatter is fixed, so the dots sit still and spin. With no options, his dots on both forearms while the ability is active.", "layer": true, "options": { "bones": "the suit bones they gather on ([\"leftArmBottom\", \"rightArmBottom\"])", "when": "active (default): while the ability is active; held: while its key is held down; always", "texture": "the disc's texture, a full id (\"thematic:textures/particle/sonic_beam.png\")", "colors": "each disc takes one of these at random (yellow, blue, red)", "count": "discs per bone (5)", "spread": "how far they scatter about the bone, in model units: [x, y, z] or one number ([0.4, 0.6, 0.4])", "size": "each disc's scale, between [min, max] ([0.06, 0.1])", "spin": "each disc's spin speed, between [min, max], either way round ([15, 30])", "alpha": "how opaque, 0 to 1 (200/255)", "emissive": "drawn glowing, unlit by the world (true)", "segments": "how round each disc is (12)" } }, "thematic:crackle": { "doc": "Kirby crackle: dark dots that swell, hold and pop on the faces of some of the suit's bones, each reborn somewhere new, so the energy there seethes. A beam takes the same look as its crackle option.", "layer": true, "options": { "bones": "the suit bones whose cube faces the dots sit on (required)", "when": "active (default): while the ability is active; held: while its key is held down; always", "faces": "which cube faces take dots (all)", "within": "dots only where the suit's texture is this colour (or one of these), each wholly inside it; anywhere when left out", "focus": "where the dots swell bigger, so the crackle pours out of one spot: {at: [x, y, z] in Blockbench pixels, grow: how many times bigger there (1.6), reach: pixels until they are back to their size (3)}", "float": "how far off the faces the dots hang in the air, in Blockbench pixels, as little balls; 0 prints them on the faces (0)", "tolerance": "how far a texel may be from a within colour and still count, 0 to 1 (0.18)", "colors": "each dot takes one of these at random (near-black, #0A0204)", "count": "on a suit: dots per bone (4); on a beam: dots per block of beam", "size": "each dot's width in blocks, between [min, max] ([0.03, 0.08]); a face too small for the biggest shrinks them all in step", "life": "seconds from a dot swelling to its popping, between [min, max] ([0.25, 0.6])", "satellites": "up to this many smaller dots cluster round each one (2)", "spread": "on a beam: how far from its line the dots reach, in blocks (0.12)", "drift": "on a beam: how fast each dot travels out along it while it lives, in blocks a second (0)", "alpha": "how opaque, 0 to 1 (1)", "emissive": "drawn unlit, at full brightness (true)" } }, "thematic:body_shroud": { "doc": "While the ability is active the suit is drawn as a shroud, for everyone (or only the wearer, with visible_to): below a height split it fades to see-through, above it it is taken down to near-black, and a noisy, flickering, fire-like outline burns around the silhouette. When the ability ends the body re-forms: the outline flares, the shroud fades back into the suit (with a brief flicker) and smoke and embers pour off it. E.g. {split: 0.45, lower_alpha: 0.2, upper_color: 0x0A0A0A, outline_color: 0xFF8A1F, outline_color_2: 0xFF3B00, outline_width: 0.06, outline_noise: {scale: 2, speed: 0.8}}.", "layer": true, "options": { "split": "the height, 0 (feet) to 1 (top of the head), where the see-through lower body meets the dark upper body (0.45)", "softness": "how tall the blend between the halves is, as a share of the body (0.25)", "lower_alpha": "how solid the lower body is at the feet, 0 to 1 (0.25)", "lower_color": "the lower body's tint, multiplied through the suit's texture (0xFFFFFF: its own colours)", "upper_color": "the upper body's tint, multiplied through the suit's texture (0x0A0A0A: near-black)", "body_noise": "0 to 1: how much the see-through part's alpha flickers, point by point (0)", "outline_color": "the outline's inner, brighter flame (0xFF8A1F, orange)", "outline_color_2": "the outline's outer flame, and the colour the flames flicker toward (0xFF3B00, ember)", "outline_width": "how far the inner flame stands off the body, in blocks; the outer about twice that (0.06)", "outline_alpha": "how strong the outline is, 0 to 1 (1)", "outline_noise": "the flames' noise: scale, repeats per block (2); speed, how fast it rises in blocks a second (0.8)", "flicker": "0 to 1: how much the flames' brightness and reach flicker, point by point (0.6)", "flicker_rate": "how many times a second the flicker re-rolls (14)", "noise_texture": "the outline's tiled texture; its brightness is the flame (thematic:textures/misc/shroud_noise.png)", "fade_in": "seconds the shroud takes to come over the body as the ability starts (0.2)", "reform": "seconds the body takes to re-form as the ability ends (0.65)", "reform_flare": "0 to 1: how much brighter and wider the outline burns as the body re-forms (1)", "reform_flicker": "the body blinks between shroud and solid as it re-forms (true)", "particles": "particle ids poured off the body, each a plain particle with no options ([\"minecraft:large_smoke\", \"minecraft:small_flame\"])", "reform_particles": "how many of each particle a tick while the body re-forms (4)", "active_particles": "how many of each particle a tick while the shroud is up; a fraction is a chance (0)", "visible_to": "who sees the shroud: \"everyone\" who can see the body, or only the \"wearer\" (everyone else sees the suit as it is) (everyone)", "bones": "the top-level suit bones drawn; children come along (all eight)" } }, "thematic:rising_aura": { "doc": "Tongues of energy licking up round the wearer's body from a glow at their feet, sparks rising off them, building with a level: more tongues, taller, hotter, faster and brighter as it climbs. The level is a meter on the wearer or a count of set flags, so stacks read at a glance; for every player who can see it. A rage, a power-up, a charge building.", "options": { "when": "when it is lit, each condition written must hold: active (the ability running), flag (a setFlag flag set on the wearer), flying, sprinting, airborne (off the ground). Left out: while the ability is active", "color": "the tongues' outer colour (#8A0A0A)", "core_color": "their hot inner colour, the glow at the feet and the sparks (#FF5A3A)", "level": "what its strength follows: { meter: key, max } a meter's value against max (5), or { flags: [...] } how many of those flags are set (max: their count). Left out: always full while lit", "base": "its strength while lit with the level at nothing, 0 to 1 (0.25)", "tongues": "how many tongues at full strength, up to 48 (28); about a third show at none", "height": "a multiplier on how tall they lick (1: up to the wearer's height, half again at full)", "size": "a multiplier on how wide they are and how far out they stand (1)", "alpha": "how bright they burn at full strength, 0 to 1 (0.55)", "embers": "sparks rising at full strength, up to 16 (10)", "halo": "a glow on the ground at the feet (true)", "flicker": "a multiplier on how fast the tongues live and sway (1)", "first_person": "how strongly the wearer sees their own, 0 to 1 (0.5); the tongues straight ahead are left out so they never cover the view" } }, "thematic:corona": { "doc": "A radiant sunburst behind the wearer while they are charged: a white-hot core, slowly turning shimmering rays and a ring beating out like a pulse, so the body stands backlit and reads from far off. With a countdown it shrinks as the time runs out and blinks near the end. In first person, small coronas round the fists. For every player who can see it. An empowered window, an overcharge, a blessing.", "options": { "when": "when it is lit, each condition written must hold: active (the ability running), flag (a setFlag flag set on the wearer), flying, sprinting, airborne (off the ground). Left out: while the ability is active", "color": "the rays' colour (#F4EDE4)", "core_color": "the core's white-hot colour (#FFFAF2)", "rays": "how many rays, 4 to 32 (14)", "size": "a multiplier on its size, 1 being about the wearer's height across (1)", "alpha": "how bright it burns, 0 to 1 (0.7)", "spin": "degrees the rays turn a tick (0.6); negative turns the other way", "pulse": "seconds between the beats ringing out of it (0.75); 0 for none", "countdown": "seconds it runs down over once lit: it shrinks as they pass and blinks in the last fifth (0: steady while lit)", "behind": "blocks it sits behind the body, away from whoever is looking (0.45)", "first_person": "what the wearer sees of their own: hands (default), small coronas round the fists; none" } }, "thematic:energy_plates": { "doc": "Translucent plates of hex cells of light wrapped round some of the suit's bones: a guard raised on the forearms. The cells shimmer in waves along the bone; each time the wearer is hurt the plates flash, a ripple runs out across them and a ring of light bursts off the bone. With no options, pale gold plates on both forearms while the ability is active.", "layer": true, "options": { "bones": "the suit bones they wrap ([\"rightArmBottom\", \"leftArmBottom\"])", "when": "active (default): while the ability is active; held: while its key is held down; always", "color": "the cells' colour (0xFFE2A0)", "edge": "the shimmer's and the rims' colour (0xFFFFFF)", "flash": "the colour a hit flashes them (0xFFFFFF)", "alpha": "how opaque a cell is at rest, 0 to 1 (0.45)", "cell": "a hex cell's radius in blocks (0.055)", "gap": "how far the plates stand off the bone's cubes, in blocks (0.045)", "shimmer": "how fast the shimmer runs along them (1); 0 holds them still", "burst": "how far a hit's ring of light flies off each bone, in blocks (0.35); 0 draws none" } }, "thematic:body_fire": { "doc": "The wearer burning head to foot: tongues of flame streaming off each named suit bone, white-hot at the root and burning out at the tip, with a glow hugging every bone, on the suit in third person and on the arm in first person. The flames rise in the world's up whatever the pose and lean back against the wearer's motion, so a flier trails fire. With no options, the whole suit while the ability is active.", "layer": true, "options": { "bones": "the suit bones that burn (the six of a standard suit: armorHead, armorBody, the arms and legs)", "when": "when it burns (active): \"active\", \"held\", or { active, held, gaugeAtLeast: seconds, flag: a set_flag key, state: a phase's name }, all of which must hold; a list is any of them", "color": "its flame (#FF8A1E)", "core_color": "the white-hot root of each tongue (#FFF4C8)", "tip_color": "what its tongues burn out to (#C82800)", "height": "how far its tongues reach off the body, in blocks (0.7)", "size": "a tongue's half width at its widest, in blocks (0.2)", "count": "tongues per bone, times the default (1, at most 3)", "glow": "the glow hugging each bone, 0 to 1 (0.22; 0 for none)", "flicker": "how much the tongues waver and leap, times the default (1)", "embers": "how many sparks fly off it, times the default (1; 0 for none)", "wind": "how far motion bends the flames back, times the default (1; 0 keeps them straight up)", "ramp": "[from, to] seconds after since over which the fire builds from 15% to full: its tongues, reach, glow and sparks swell with it; it shows from the start", "since": "the synced world time ramp counts from: a thematic:mark_time key (StateStart, when its phase began, if left out)" } }, "thematic:fork_sparks": { "doc": "Short forked bolts crackling about the wearer: a crown of them round the head of the item in the main hand (at: \"held_item\"), or arcs crawling over the suit's bones and leaping off them, some hopping from the feet to the ground (at: \"body\", the default). Each is a small zigzag bolt, a white core in a color band with a deeper rim, living a tick or two; drawn while the ability is active unless when says otherwise.", "layer": true, "options": { "at": "body (default): over the suit's bones; held_item: a crown round the head of the item in the main hand", "bones": "body: the suit bones they crawl over ([\"armorBody\", \"armorRightArm\", \"armorLeftArm\", \"armorRightLeg\", \"armorLeftLeg\"])", "when": "when they crackle (active): \"active\", \"held\", or { active, held, gaugeAtLeast: seconds, flag: a set_flag key, state: a phase's name }, all of which must hold; a list is any of them", "color": "the flat band round each spark's core (#39E0EC); its rim and the faint bloom are shades of it", "core_color": "the core (white)", "rate": "sparks born a second: per bone on the body (6), in all round a held item (40)", "length": "a spark's reach in blocks (0.4 body, 0.45 held item)", "spin": "held item: turns a second the crown goes round the hand while spin_when holds, to follow a twirled hammer (0, still)", "spin_when": "held item: when the crown turns (as when, by default); the same forms as when", "radius": "held item: how far the crown reaches out from the head (0.5); body: how far a leaping spark jumps off the suit (0.35)", "count": "the most alive at once on one bone (3 body, 8 held item; at most 24)", "offset": "held item: where the item's head is from the hand, [x, y, z] blocks with -z forward along the item ([0, 0.05, -0.55], a held tool's head)", "flicker": "how hard they strobe, 0 (steady) to 1 (0.6)", "ground": "body: sparks also hop from the feet down to the ground (false)", "width": "a spark's band width in blocks (0.05 body, 0.06 held item)" } }, "thematic:aim_arm": { "doc": "Raises the suit's arm (or both) to point down the wearer's aim: while the ability's key is held, or in a quick arc just after it is pressed. With no options it is the hand beams' pose: the right arm, lifted with the gauge until it is fully up at one second of heat.", "options": { "arm": "which arm: right (default), left or both", "while": "held (default): while the key is held; after_press: while the cooldown runs after a press", "raise": "gauge (the default while held): lifted with the heat on the gauge; arc (the default after a press): up and back down once over arc seconds; straight: along the look the whole time", "full_at": "seconds of gauge heat at which a gauge raise is fully up (1)", "arc": "seconds an arc takes, capped at the ability's cooldown (0.6)", "jitter": "radians of shake either side of the pose, drawn fresh each frame (0)", "empty_hand": "true: only while the main hand is empty", "first_person": "a fixed {pitch, yaw} in radians for the wearer's own arm in first person, where following the head reads wrong" } }, "thematic:spin": { "doc": "Spins the whole suit model while the ability is active, counted from a synced world time so every viewer sees the same angle. With no options it is Starbolt Spiral's: upright, about the vertical axis, -48 degrees a tick from the moment the ability's phase began.", "options": { "axis": "the axis it turns about: y (default, upright), x or z", "degrees_per_tick": "how fast it turns, in degrees a tick; the sign picks the direction (-48)", "key": "the synced world-time key it counts from (StateStart, which each phase writes as it begins)" } }, "thematic:stretch": { "doc": "A rubbery limb while the ability is active: an arm reaches out to a goal, as long as it needs, thinning as it goes, along a curve that can bow to the side and coil round a body -- out along the look through every swing (a stretch punch), or to a tracked body (a wrap). The body can sway taller and back. Third person and other players; the wearer's own first-person arm is left alone.", "options": { "arm": "which arm: swing (default: the one swinging), right or left", "reach": "where the hand goes: swing (default: out along the look through each swing and back) or tracked (to the body the track holds)", "track": "the track it reaches for (the ability's id): reach tracked follows it; a swing lands on it when it holds a body in front, within 10 blocks", "stretch": "reach swing: the arm's longest, times its own length (2.5)", "segments": "pieces the limb is drawn in: 1 (default) turns and lengthens the arm itself, more lay copies of it end to end along the curve", "bend": "how far the limb bows out to its side, as a share of the distance (0: straight)", "coil": "reach tracked: turns it winds round the body (0)", "coil_radius": "the coil's radius, blocks (0: the body's half width and a little)", "height": "reach tracked: how far up the body the hand goes, 0 feet to 1 head (0.6)", "grow": "reach tracked: seconds it takes to get there from when the track began (0: at once)", "thin": "how much the arm narrows as it lengthens: 0 keeps its width, 0.5 keeps its volume (0.5)", "taper": "how far along the limb its thinning comes in, a share of it: 0 (default) thins it evenly; more keeps it full width at the shoulder", "duration": "reach swing: ticks one punch takes, drawn back, out, held and snapped back (10)", "body": "how much taller the body sways at its tallest, as a share of its height, once every two seconds (0: no sway)" } }, "thematic:pursuit_reticle": { "alias_of": "thematic:reticle", "defaults": {} }, "thematic:righteous_cross": { "alias_of": "thematic:sign", "defaults": { "shape": "cross", "duration": 0.8 } }, "thematic:devil_out_dome": { "alias_of": "thematic:blast", "defaults": { "shape": "dome", "while_active": true } }, "thematic:xray_vision": { "alias_of": "thematic:vision", "defaults": { "shader": "xray", "when": "active", "fov": 0.6, "accent": 13369344, "label": "X-Ray Vision", "icon": "minecraft:ender_eye", "ping_through_walls": true, "scan": true } }, "thematic:daredevil_vision": { "alias_of": "thematic:vision", "defaults": { "shader": "radar", "when": "worn", "filters": [], "shows": [ "teammate", "player", "hostile" ], "outline_color": 16733525, "ping_through_walls": false, "scan": false } }, "thematic:eye_glow": { "alias_of": "thematic:glow", "defaults": { "when": "toggle", "alpha": 0.8, "bright_while_active": [ "solar_fury", "solar_absorption" ], "fade_with_gauge": { "of": "heat_vision", "over": 15 } } }, "thematic:phase_shell": { "alias_of": "thematic:density_shift", "defaults": {} } }, "ability_actions": { "thematic:explode": "A vanilla explosion where it happens. Blocks survive unless break_blocks. Fields: power: explosion power (2); fire: sets fires (false); break_blocks: breaks blocks (false)", "thematic:area_effect": "A status effect on everyone in radius but the wearer and their allies. Fields: effect (required): the status effect id, e.g. \"minecraft:slowness\"; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier; ambient: the faint beacon-style swirl (false); show_particles: false hides the effect's particles (true); show_icon: false hides the HUD icon (true); radius: left out, the tuned radius", "thematic:area_damage": "Hurts everyone in radius but the wearer and their allies. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; element: what the hit is made of, e.g. \"fire\"; left out, the wearer's own attack", "thematic:ignite": "Sets the entity hit on fire, or caps how long it still burns. Fields: seconds: how long it burns (3); exact: burns for exactly that long, Fire Protection and the difficulty left out of it, and never cuts a longer fire already burning short (false: vanilla's setOnFireFor, which they shorten); max_seconds: then cuts its burn down to at most this long (a shorter one is left alone): spending a body's fire down to a stub. Without seconds it only caps, and sets nothing alight", "thematic:discard": "Removes the thrown thing that did this. Throwables only.", "thematic:basic_damage": "A throwable payload; the stat fields override the definition's own. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier", "thematic:emp": "A throwable payload; the stat fields override the definition's own. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier", "thematic:flash": "A throwable payload; the stat fields override the definition's own. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier", "thematic:smoke": "A throwable payload; the stat fields override the definition's own. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier; tear_gas: tear gas rather than plain smoke (false)", "thematic:freeze": "A throwable payload; the stat fields override the definition's own. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier", "thematic:electric": "A throwable payload; the stat fields override the definition's own. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier", "thematic:bind": "A throwable payload; the stat fields override the definition's own. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier; bind_equipment: also binds held items (true)", "thematic:explosive": "A throwable payload; the stat fields override the definition's own. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier; power: explosion power; power_per_damage: power added per point of damage (1); break_blocks: breaks blocks", "thematic:incendiary": "A throwable payload; the stat fields override the definition's own. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier", "thematic:status": "A throwable payload; the stat fields override the definition's own. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier; effects (required): the effects to apply", "thematic:sonic": "A throwable payload; the stat fields override the definition's own. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier", "thematic:antidote": "A throwable payload; the stat fields override the definition's own. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier", "thematic:projectile_damage": "Damage from a thrown thing, scaled by the thrower's utility attack. Fields: damage: left out, the definition's damage; damage_type: the damage type (the throwable's own); element: what the hit is made of, the generic spelling of damageType", "thematic:impact_damage": "Arrow-style damage scaled by speed. Fields: damage: left out, the definition's damage", "thematic:lightning_strike": "Strikes the entity hit with lightning.", "thematic:thematic_explosion": "Thematic's own explosion: flat damage to everyone the thrower may hit, a dome of particles and a bang. Fields: damage: left out, the tuned damage; radius: left out, the tuned radius; fire: sets fires (false); fire_seconds: sets those hit alight this long (0); break_blocks: breaks blocks (false); shockwave: adds a shockwave ring (false); shockwave_damage: what the shockwave itself deals; needs shockwave (0); at: where it goes off: here (where the action happens), spot (the spot the move fixed; nothing without one) or summoned (where the body the action is aimed at stands now -- inside a summon's do; nothing once it is gone, and a display summon is taken away as it goes off)", "thematic:status_area": "Status effects on everyone in an area. Fields: effects (required): the effects; shape: the area's shape (sphere); radius: left out, the tuned radius; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier; respect_teams: skips the thrower's allies (true); include_owner: includes the thrower (false); particle_on_each: a particle circle on each one affected", "thematic:feed": "Feeds the wearer. Fields: food: hunger points (1); saturation: (1)", "thematic:run_ability_hook": "Runs a hook registered in Java by id. Fields: hook (required): the hook id; damage: stat override; radius: stat override; duration: stat override; amplifier: stat override", "thematic:self_effect": "A status effect on the wearer. Fields: effect (required): the status effect id, e.g. \"minecraft:slowness\"; duration: seconds; left out, the ability's tuned duration; amplifier: 0 is level I; left out, the tuned amplifier; ambient: the faint beacon-style swirl (false); show_particles: false hides the effect's particles (true); show_icon: false hides the HUD icon (true)", "thematic:ignite_jets": "Lights the wearer's thrusters (the flight profile's jets that say \"when\": \"dash\") for a moment, for everyone who can see them; a suit-wearing mob lights its own the same way. Call it every tick of a longer burn, or once with a duration that covers it: the flames fade out over the last few ticks. Fields: duration: seconds the jets stay lit (0.5), at most 10", "thematic:area_launch": "Throws everyone in radius the way the wearer is facing. Fields: strength: (1); lift: added upward (0); radius: left out, the tuned radius", "thematic:lunge": "Throws the wearer the way they are facing. Fields: strength: (1); lift: added upward (0)", "thematic:speedster_run": "One server tick of a speedster's run for this move: run it every tick. The run's jump, step and motion scales and its speed modifier go on (the motion and the modifier stand aside while the wearer wall-runs or slowed time owns their motion), and the run-in and running sounds play as they set off and keep going -- the move's own cues (options run_in_sound / running_sound, or sound_prefix), else Thematic's. stop takes the run off. Fields: stop: takes the run's scales and modifier off instead (false); sounds: plays the running sounds (true; false with stop)", "thematic:if": "Runs one list of actions when a guard holds and another when it does not. Fields: if (required): the question; do (required): when it holds; else: when it does not", "thematic:push": "Sets or adds velocity to the wearer or the target, in a named direction. Fields: who: self (default) or target; direction: which way (none: lift only); strength: along the direction (1); worked out when it runs, e.g. a recoil growing with the gauge; lift: added upward (0); wave(...) for a bob; flat: drop the direction's vertical part (false); mode: add (default) or set; keep: with set (a launch too): the fraction of current sideways speed kept (0); falloff: weaker further out: strength times (1 - distance / falloff), measured from the spot markSpot fixed, or the wearer; min_strength: with falloff: the least it pushes, however far out (0); vertical_strength: the direction's vertical part is scaled by this rather than strength; reset_fall: forget the fall so far, so the push does not end in fall damage (false); launch: a launch rather than a plain push: the launch rules every slam used -- the launch callback, a lock, a packet to a player (false); vertical: the whole vertical, apart from the direction: keep (a set keeps the one it had, an add adds none) or a number. Takes no lift or vertical_strength beside it. mode \"set\" with direction \"none\" and vertical \"keep\" stops the sideways motion alone; on_collide: a thrown body: watched every tick while it flies, the first living thing it passes within collide_radius of (not itself, not the wearer, not one the wearer may not hit) gets these actions as the target, the thrown body as remembered -- a hurled victim knocking down whoever it lands in. The watch ends then, or when it lands, dies, all but stops, or after 10 seconds; collide_radius: with on_collide: how near the body must pass, in blocks (1.2); on_wall: a pushed body (not the wearer): watched every tick for wall_for seconds, and the first tick it runs into a wall it gets these actions as the target, once -- a blast that hurts more when it slams its victim into a wall; wall_for: with on_wall: how many seconds the body is watched for a wall (0.75); within: with direction toward_nearest: how far it looks for a wall or body to throw the pushed one at, in blocks (8)", "thematic:mark_time": "Stores the world time on the wearer, synced, for a client visual to count from. Fields: key (required): the key the visual reads", "thematic:mark_spot": "Fixes a point for the rest of the press or reaction -- the body centre of the target inside targets(), of the wearer otherwise -- for at: \"spot\" and away_from_spot to use later. Also stored on the wearer, synced, under the key, with the wearer's facing under _yaw and _pitch, for a client visual drawn there. Fields: key (required): the key the visual reads; anchor: body (default): the centre; feet: where it stands; eyes: its eyes (with along \"look\": the point the look ray meets a block at); impact: where the action happens -- in a projectile's onHit or onBlock, the point it broke, mid-air at the end of a fuse too; behind: instead, the point this many blocks behind the subject's back (the way its body faces), at its feet; ahead: instead, the point this many blocks ahead the way the subject looks, level whatever its pitch, at its feet; safe: with behind: searched for room -- level, then 1 up, 1 down, 2 up, 2 down, for two free blocks with a solid floor if the subject stands on the ground -- centred on the block; no room: the wearer's own feet (false); along: instead, look: the wearer's own point (anchor) carried along their look, a ray from the eyes against block colliders, not fluids, out to reach; block_top: the top centre of the block their look ray meets (outline shapes, not fluids; a ray that meets nothing, the block at its end), above blocks over its top face; reach: with along: how far the ray goes; left out, the tuned radius (block_top: 75); reach_min: with along: the reach is never less than this, whatever the Amount works out to (0); reach_max: with along: the reach is never more than this (no cap); fail_message: with required: said on the wearer's action bar when the press is called off for want of room: a translation key or text; above: with along \"block_top\": how far over the block's top face the spot sits (0); offset: moves the spot, once found, this many blocks on the world's axes: [8, 0, 0] is 8 blocks east of it (none); with offset_frame \"line\", [right, up, forward] instead; offset_frame: how offset is measured: world (default), on the world's axes; line, [right, up, forward] along the line from the wearer's eyes to the spot -- [0, 5, -4] is 4 back toward the wearer and 5 up, [8, 5, 0] 8 to the right of that line; rise_out_of_blocks: once placed, moved up half a block at a time (ten at most) while it sits in a block that is not air (false); standoff: with along: how far short of a block the ray met the spot stops, never behind the wearer (0); fit: with along: walked back toward the wearer half a block at a time until their hitbox fits there empty; fits nowhere and nothing is marked (false); required: with fit: fitting nowhere calls the whole press off: no later steps, no cooldown -- or, with missCooldown (miss_cooldown in a file), that share of it; along \"look\" without fit: the same when the look ray meets no block", "thematic:extinguish": "Puts out fire, lit candles and lit campfires in the box around the wearer -- or, with at and shape, around the block hit, the spot, or wherever the block verbs can start from. With who, a burning body instead. Fields: at: which block it starts from (self): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; shape: which blocks (box); radius: a box or circle: sideways, rounded up, at most 16; left out, the tuned radius; height: a box: up and down, at most the radius (3); a circle: layers going up (1); blocks: what it puts out (all three); grief_check: only where the wearer may build -- claims, spawn protection (false); who: instead of blocks, put out a burning body: the wearer (self) or the target inside targets(). Takes none of the block fields", "thematic:swap_held_item": "Swaps the held item for the next one in a cycle, keeping its tag. Fields: cycle (required): item ids, in the order they swap; hand: main (default) or off; do: run only if it swapped", "thematic:teleport": "Puts the wearer by the target, or the target by the wearer. Inside targets() -- except to: \"spot\", which puts the wearer on a point markSpot fixed, anywhere, and along_look_clear and away_from_attacker_clear, which move the wearer by their own look or the hit that answered. Fields: to (required): where; gap: above_target: space left above its head; block_top: how far over the block's top face (0); distance: behind_target: how far behind; in_front_of_owner: how far along the wearer's look, at the target's own height; facing_target: how far from the target; short_of_target: how far short of it (1); around_target: how far from the target (2); spread: behind_target (not safe), around_target: random extra distance (0); rise: around_target: up to this many blocks higher than the target, at random; behind_target: this many blocks higher; facing_target: this many blocks above the target's feet, unless keep_height (0); reach: along_look_clear, away_from_attacker_clear: the furthest the hop goes; ring_around_owner: how far out the ring is; clear_spot: how far the target is moved (the tuned radius); block_top: how far the look ray goes (75); min: the clear placements, swap, target_to_spot, ring_around_owner, impact, clear_spot: the shortest move worth making; with no room that far, nobody moves (1); a safe behind_target: the nearest it searches (1); step: those same: how far back each try walks when the body does not fit (0.5); else: those same, and nudge: run when they found nowhere to put anyone and nobody moved -- a refund, a fizzle; sideways: nudge: blocks to the wearer's right, negative to their left (0.25); if_fits: nudge: only move the target where its hitbox fits (true); bearing: clear_spot: which way (random); standoff: clear_spot toward_owner: stop this far short of the wearer (1); stop: zero the velocity of whoever was moved, so the placement sticks (false); keep_height: facing_target, short_of_target: stay at the wearer's height rather than drop to the target's (false); max_snap: short_of_target: the furthest the wearer may be moved, in blocks; further and they stay put; along: short_of_target: which way is short (heading); safe: under_owner: stop at the first floor on the way down, and only move the target if it fits there; behind_target: search from distance behind the target's back (along its look, pitch and all) in by step to min, rise higher, for air at the feet and head -- none, and the furthest regardless (false); fall_speed: under_owner: then set the target's velocity to straight down at this speed -- or to nothing, when a safe placement found the floor; spot: spot, target_to_spot: the markSpot key of the point; left out, the spot this press or reaction marked last. The one moved is stopped dead and their fall forgotten; nothing marked, they stay put; below: spot: how many blocks under it, never under the bottom of the world (0); face: spot: turn the wearer to face them; left out, the wearer keeps their look", "thematic:look_at": "Turns the wearer to face the target's eyes, or (who: target) the target -- player or mob -- to face the wearer's. With spot, to face a point instead: the nearest ore findBlock() found, a markSpot(); with away, to turn their back on the other. Fields: who: self (default) or target; drop: aim this many blocks under the other's eyes: the throat, not the face (0); spot: look at a point instead of the other's eyes: true, the spot this press fixed last (findBlock, markSpot); a markSpot key, the one stored under it. Needs no target for the wearer; away: turn the back on the other instead, level: lookAt(\"target\", { away: true }) holds a victim facing away from the wearer (false)", "thematic:remove_effect": "Takes a status effect off the wearer, or (who: target) off the target inside targets(). Fields: effect: the effect id; left out, the one an effect_added event brought; who: self (default) or target", "thematic:knockback": "Vanilla knockback (a sword's): flat, weakened by knockback resistance. On the entity hit -- the target inside targets() -- unless who says otherwise. Fields: strength: vanilla's knockback strength (0.5); direction: which way (away_from_source); who: target (default) or self", "thematic:targets": "Picks who a move lands on and runs its actions once aimed at each. Inside, damage, effect, sound and particles are about the target. Fields: select (required): who to pick; radius: around, ahead, allies, marked: how far; trail: how far either side of each node; left out, the tuned radius; box: around: the distances either side of the wearer's hitbox per axis, instead of radius -- each may be worked out, e.g. [tuned(\"radius\"), tuned(\"radius\", 0.5), tuned(\"radius\")]; { look: n } grows each axis by the look's part times n, signed (so it can shrink), and with y the height by y either way instead; { across, below, above } grows the hitbox (or, with at, the spot or the source's hitbox) across sideways, below under its feet and above over its head -- across left out is the radius, below and above left out are across. On locked, remembered, attacker or victim: only if its hitbox touches that box; ahead: moves the box (or the radius box) this many blocks the way along says; along: ahead: which way is in front (look); length: cone: how long; left out, the tuned radius; width: cone: width at the far end; look: how far either side of the line (1); height: cone: height at the far end (1); start_width: cone: width at the near end (0); start_height: cone: height at the near end (0); from: cone: where on the body it starts (eyes); range: look, aimed, locked_or_look: how far (locked_or_look: the locked target must be within it, else the look is searched); left out, the tuned radius; max_angle: aimed (and locked_or_look with aim_assist), for a player: the widest angle from the crosshair that still counts, degrees (18); aim_assist: locked_or_look: with no lock, pick as aimed does -- the hitbox nearest the crosshair, seen -- not along a thin look line (false); assist: aimed, for a player: how far each hitbox is grown before measuring (0.35); prefer_players: aimed, for a player: a player aimed at outranks anything else (false); pick: all (default), nearest, first, or random (one of those found, by the wearer's random); sort: the order before the pick (none); sort_effect: with sort \"effect_level\": the status effect whose levels order them, most first (the infected before the clean, closest first among equals); at: around: here (default: around the wearer), spot (around the point markSpot fixed) or source (the hitbox of the thrown thing or bolt whose hit runs this, grown by radius; the wearer's when there is none); within: only those at most this many blocks from the wearer, e.g. tuned(\"radius\", 2); round: around: only those whose feet are within the radius of the centre (the wearer, the spot, the source or the target): a sphere rather than the box (false); hollow: with round: leave out those whose feet are within this many blocks of the centre, so a band between hollow and radius is searched; beyond: only those more than this many blocks from the wearer: with within, a ring; entity: only those of this entity type, or one of this list; \"#ns:tag\" is an entity type tag, and a bare id is minecraft's (\"zombie\", \"#minecraft:undead\"); hittable: false: searches find allies and the protected too; true: named selects only those the wearer may hit (true for searches, false for allies, remembered, attacker, victim); line_of_sight: only those the wearer can see (false; true for a player's aimed); except_allies: skip the wearer's teammates within the tuned radius (true) or this many blocks; unless_active: skip anyone with one of these abilities active, e.g. the same move of their own; arc: only those within this many degrees of the wearer's look, eyes to eyes: a swipe's half-angle, e.g. 60; worked out, it is read each time and held between 0 and 180 (a cone that widens with a count the press keeps); arc_widen: with arc: it opens up with the distance, from arc at the wearer's eyes to `to` degrees `over` blocks out, and no wider beyond (the cosine moving evenly between the two): a beam that fans out, e.g. arc 8.11 widening to 31.79 over 30; except: leave this one out: struck, the body the actions are aimed at (a bolt's struck body, the target of a targets() around this one), else the one the answered event struck; or players, every player; spawn_groups: only those whose entity type is in one of these spawn groups: [\"monster\"] leaves the peaceful out; once: each one is hit once in the press (cast), or not again until rehitAfter seconds have passed (rehit_after in a file); remember: keep the pick for a later select: \"remembered\" in the same press and the phases it opens; \"all\" keeps every one picked, and remembered lands on each still alive; required: nobody found calls the whole press off: no later steps, no cooldown -- or, with missCooldown (miss_cooldown in a file), that share of it; the wearer is told on the action bar (message.thematic.no_target, or message: a lang key; \"\" for nothing); key: trail: the name markNode laid the trail under; marked: the mark's key, e.g. \"quarry_mark\"; tracked: the track's name, whose held entity it takes (thematic:track); by: marked: whose marks count -- the wearer's own (wearer, default) or anyone's; below: trail: how far under each node the box reaches (the radius); above: trail: how far over each node the box reaches (the radius); do: the actions run on each target; else: the actions run once when nobody was found", "thematic:once": "Runs its actions only the first time it is reached in each pass of the targets() around it, or in the whole press: a slash sound for the first body a sweep meets, a shield for the first body of the run. With per: \"beat\", only on the ticks a beat of seconds falls on -- seconds worked out each time, so the beat can quicken with a count the press keeps; a phase's every with a worked-out seconds is read as one of these. Fields: per (required): pass, run or beat; seconds: beat: how often it runs; any worked-out number, rounded to whole ticks (at least one); clock: beat: what it counts on (age); start: beat: seconds on the clock of the first beat (0); do: what the first one does", "thematic:drive": "Sets the wearer's velocity for this tick: a direction times a speed, with a vertical of its own. Put it in a phase's every() to hold a charge, pounce or leap every tick -- a velocity thrown once is gone to friction in two blocks. The speed is sideways along the direction; a negative speed drives backwards. A server set, told to the client: while it runs, where a player goes is the move's call, not their keys'. With path: \"circle\" it runs round a centre instead, angularSpeed radians a tick, on a radius that grows by radiusGrowth over the tuned duration, pulling those around it in with suction: Whirlwind's widening run. Fields: path: line (default): along a direction; circle: round a centre; along: which way (yaw); speed: blocks a tick along it (1); pulse(...) for a gallop that surges with each bound; vertical: along (default): the direction's own vertical times the speed; keep: as it is; gravity: vanilla's fall, worked out on the server, zero on the ground; a number; {arc: {peak, across}}: up peak blocks and back down across the tuned duration or seconds; {phases: [[from, to, vertical], ...]}: seconds into the phase (to null: the rest), the direction's own outside them. Arcs and phases count the step entering the phase and its first tick both as 0; on_wall: while against a wall: skip or halt; left out, it drives on regardless; reset_fall: forget the fall so far, so the drive never ends in fall damage (false); sprint: sets the wearer sprinting, or not; left out, left alone; radius: circle: the radius it starts on, in blocks (1); radius_growth: circle: blocks the radius grows by over the tuned duration, counted from the phase's start (0); angular_speed: circle: radians it goes round a tick (2); height: circle: blocks above the centre the circle is flown at (0); an amount that grows with the phase flies a climbing spiral; pull: circle: how hard it steers at the next point, times the gap (2.5); max_speed: circle: the fastest it steers, blocks a tick (1.5); around: circle: the centre (start); face: circle: turn the wearer the way they run (false); suction: circle: pull everyone the wearer may hit inside the current radius, and height (5) up and down, in to the centre at strength (1.25) and up at lift (1.15), both times how near they are (1 - distance / radius, never under 0.1)", "thematic:ride": "Puts the wearer on the target's back (inside targets()), or with rider: \"target\" the target on the wearer's; off gets the rider down. Guard a phase on riding to end the move with the ride. Fields: rider: self (default) or target; off: get the rider down instead (false); force: mount what would not take a rider of its own accord (true); free: only when neither already carries someone (true); max_distance: only when the target is no further than this, in blocks", "thematic:jump": "A vanilla jump: what a flying kick does from a standing start, so the charge has height to fly at. Fields: only_on_ground: only when standing on something (true)", "thematic:rise": "Climbs the wearer straight up to height blocks over where the climb began, at speed a tick, easing into the top and holding there. Sideways speed is dropped while it climbs. Every tick, in a phase's every(). Fields: height: blocks above the start (5); speed: blocks a tick while more than ease is left (0.6); ease: within this many blocks of the top, it closes exactly the gap (1); from: start (default) or spot; sprint: sets the wearer sprinting, or not; left out, left alone", "thematic:orbit": "Hands the wearer's own client a spiral to fly round a centre: it steers itself along the path (movement input is ignored, so pair it with lockInput), the sprint flag held, turned to run along the circle. The server sends one packet and no velocity, so there is no lag or teleporting. Put it in a phase's body (it runs as the phase starts); radius and height ease from their first value to their \"To\" over the seconds. A player only. Fields: around: spot (default) or start; radius: blocks from the centre at the start (1); radius_to: blocks at the end (the same); height: blocks above the centre at the start (0); height_to: blocks at the end (the same); angular_speed: radians a tick round the centre; negative the other way (0.2); seconds: how long it flies (1); sprint: holds sprinting (true); face: turns the wearer to run along the circle (true); stop: cancels a flight under way instead; the other fields are ignored (false)", "thematic:gravity": "Turns gravity off, or back on. It stays as set: turn it back on in the phase's end(), which runs however the phase is left, death and logging out included. Fields: who: self (default), target or both; off: true (default) turns it off, false back on", "thematic:swing_hand": "Swings a hand where everyone can see it, the wearer included: a slash that reads as one. Fields: hand: main (default), off, or alternate; chance: 0 to 1: how likely it swings at all (1)", "thematic:turn": "Turns the wearer by so much a tick, and eases their pitch toward a target or level: a spin that tracks. Fields: yaw: degrees added to the yaw (0); ramp(...) for a spin that speeds up; pitch_toward: ease the pitch toward the nearest target, or level; left out, the pitch is left alone; pitch: sets the pitch to this many degrees, down positive (45 looks at the ground ahead, -90 straight up); not with pitch_toward; within: with nearest: how far either side it looks (20); ease: how much of the way the pitch moves each time, 0 to 1 (1)", "thematic:carry": "Holds the target in front of the wearer, tick by tick: in a phase's every(), inside targets() -- usually select \"remembered\". Lets go by itself (and forgets the pick) once they are dead, gone, further than release, or won't fit (fit). Aerial Charge's is the defaults with along: \"heading\"; Feral Leap's {from: \"feet\", distance: 0.9, at: \"feet\", along: \"yaw\", move: \"fit\", blocked: \"slam\", fall: \"book\", hold: {for: 0.75, every: 0.25, owedFall: 10}, victimAnimation: {name: \"feral_leap_victim\", every: 1.5}}; Stronger, Smarter, Better's {from: \"feet\", distance: 1.5, at: \"feet\", along: \"yaw\", move: \"teleport\", fall: \"keep\"}. Fields: from: the point on the wearer it is held out from (eyes); distance: how far out from it (2); at: which part of the target is put there: middle (default) or feet; along: look (default), heading or yaw; move: swept (default), fit or teleport; max_step: swept: the furthest they are moved in one tick, in blocks (3); blocked: fit: what happens when they won't fit there: release (default) or slam; slam: blocked slam: how fast both are sent down, blocks a tick (1.2); release: let go -- and forget the pick and the heading -- once the target is further than this; 0: never (4); fall: reset (default), book or keep; hold: take them out of their own hands: no walking, attacking or abilities, for `for` seconds (0.75) renewed every `every` (0.25), and a landing owed for owedFall seconds (0) that a suit's fall immunity can't cancel. Lifted by letGo(), and when the press ends however it ends; victim_animation: the clip a carried player is put in, and again every `every` seconds (left out: once); stopped when they are let go; in_hand: with hold: draw the held body hanging from a point on one of the wearer's suit bones (armorHead, armorBody, armorRightArm, armorLeftArm, armorRightLeg, armorLeftLeg) instead of where it stands, so it follows that limb's clip. point: [x, y, z] on the bone in model blocks, its rest pose (the right hand is about [0.375, 0.74, -0.15]); hang: the share of the held body's height that hangs there (0.85, the throat); yaw: degrees it is turned from facing the wearer (0); first_person: { ahead, side, drop } where the wearer sees it from their own eyes, in blocks (1, 0.45, 0.35: ahead of the eyes, out to the gripping side, below them). Its hitbox stays where the carry puts it", "thematic:let_go": "Hands the carried target back: the one inside targets(), else the remembered one. Forgets them, lifts the hold a carry put on them (this press's, or one run from a passive's tick) and stops its victim clip; with slam, puts them under the wearer's feet (stopping at the floor, only if they fit) and sends both down. The owed landing keeps running. Fields: slam: slam them: the speed both are sent down at, blocks a tick (Feral Leap's 1.2); left out, no slam; forget: forget the remembered pick, so a targets() of remembered finds no one (true)", "thematic:mark_heading": "Fixes where the wearer aims now as the move's heading, for later pushes, drives and carries along \"heading\": their look, or for a mob straight at its target. Fields: yaw_only: laid level: straight along the yaw, so the heading neither climbs nor dives (false); max_turn: degrees: with a heading already marked this press, the new one only turns it that far toward the aim, about the vertical axis (limited steering for a drive along the heading); with none yet, set outright; from: where the heading comes from: aim (their look, a mob's at its target; the default), moving (level, the way they have been moving these last few ticks -- the key they hold; their look laid level when still) or away_from_target (level, from the target -- the one inside targets(), else the one aimed at -- out to the wearer; back along their look with none)", "thematic:mark_target": "Inside targets(): stores the target on the wearer, synced, under key, so a phase's movement { charge: { toward: \"marked\" } } steers the wearer's own client straight at it -- a dash at one victim, without the server pinning their momentum. It is also remembered for the press, so a later targets(\"remembered\") finds the same one; the mark is cleared when the press's phases are over. Fields: key: the data key (charge_target); the charge's key must match; clear: forget the mark now instead (false); remember: also remember the target for the press (true); uuid: a second key the target's uuid is kept under too, e.g. for a portrait pin that finds the subject again after its network id goes stale (none); keep: keep the mark when the press's phases are over, until it is replaced or cleared (false)", "thematic:spin": "Turns a body round on the spot: every tick for ticks ticks its look moves degrees further round, at eye height -- a victim spun dizzy by a dash. A body already spinning is left to finish; one that dies stops. Fields: who: target (default) or self; degrees: how far it turns each tick; negative the other way (20); ticks: how long it spins, in ticks (30)", "thematic:damage": "Hurts the entity hit -- inside targets(), the target -- or, with who: \"self\", the wearer. Fields: damage: left out, the tuned damage; tuned(\"damage\", 0.5) for half of it; damage_type: a damage type id, e.g. \"thematic:psychic\"; the wearer is behind it; element: what the hit is made of, e.g. \"bleed\" or \"radiation\": the same damage type by the word the suits use, which is what lets a weakness, a resistance or an immunity answer it; not with damageType or source; source: auto (default), player_attack or mob_attack; not with damageType; through_absorption: spends health and leaves the absorption pool alone (false); store: keeps the health the hit actually took (after armour, resistance, a body nearly dead) under this name for the rest of the press, as store() does: $name in an expr reads it; who: target (default: the entity hit) or self: the wearer pays in health, as magic credited to the wearer unless source, element or damageType says otherwise; ignore_iframes: lands through the body's hurt window: it is cleared for this hit and put back after, with the last damage taken, so hits a few ticks apart all land and later blows are not priced against this one (false)", "thematic:effect": "A status effect on the entity hit -- inside targets(), the target. Fields: effect (required): the status effect id, e.g. \"minecraft:slowness\"; duration: seconds; left out, the ability's tuned duration; amplifier: left out, the ability's tuned amplifier; ambient: the faint beacon-style swirl (false); show_particles: false hides the effect's particles (true); show_icon: false hides the HUD icon (true); chance: the share of the time it lands, 0 to 1 (1); tint: the colour an effect worn in one takes (thematic:doused): 0x8CE01A, \"#8CE01A\", [r, g, b] or \"$name\" for one the press chose; resolve_against: whose tuned duration and amplifier fill in the left-out ones (wearer); suppress: leaves a body that already has the effect alone (false); mark_grounded: marks the body freshly grounded once it lands, so the same hit's damage is not the first after it (false); stack: builds up: on a body that has it, the amplifier is the running one plus add (1), never past max; amplifier is then the first landing's", "thematic:heal": "Heals the wearer, or the entity hit: by an amount, up to a level, or both (by the amount, no further than the level). Fields: amount: how much, in the action bar's units (1000 is a full vanilla bar, 50 is one hit point), or fromEvent(\"amount\") for what the answered hit was worth; left out, the tuned \"heal\" key, else 50 (1, or up to the level with to); to: heal up to this level (action bar units) and never past it; a body already above it is left alone; target: self (default) or hit", "thematic:overshield": "An absorption pool on the wearer, or the entity hit, that hits spend before health: raised to the amount (a second grant tops it up, never stacks), or added to it with stack. Fields: amount: how much, in the action bar's units (1000 is a full vanilla bar); left out, the tuned \"overshield\" key, else 50; target: self (default) or hit; stack: adds the amount to the pool already there instead of topping it up to it (false); for: seconds the points it added last: then what is left of them goes (hits spend them first); left out, they stay until spent", "thematic:clear_effects": "Takes status effects off the wearer, or the target: every one, the harmful or the beneficial ones, or none (only the absorption pool, with absorption: true). Fields: who: self (default) or target; category: which ones (all); absorption: also empties the absorption pool, after the effects (false)", "thematic:cooldowns": "Changes cooldowns across a kit, the wearer's or the target's: takes seconds off, sets them, or starts each one's whole cooldown. Fields: who: self (default) or target; ability: only this ability id, \"self\" (this ability) or \"ultimate_key\" (whatever sits on the ultimate key); left out, all; except: all but this one: an ability id, \"self\" (this ability) or \"ultimate_key\" -- a refund that must never hand itself back; cooling: only abilities still cooling down (false); ready: only abilities not cooling down: a move that can still be wasted (false); except_ultimate: leaves ultimates out (false); skip_active: leaves running abilities out (false); a cooldown change ends a running one; keyed: only moves on a key (ability_0-5, utility, equip_item, ultimate): passives left out (false); pick: all (default), the first in kit order, or one at random; reduce: seconds taken off, floored at 0; set: seconds it is set to; add: seconds put on top of what is left (a move not cooling starts cooling for that long); times: the share of what is left that stays, e.g. 0.35 takes 65% off a cooldown that has just started (a number, not seconds); full: each one's own whole tuned cooldown is started, as if it had just been used: with pick: \"random\" and ready, a move wasted (Hypnosis). One of reduce, set, add, times or full; inventories: the items' cooldowns instead of the kit's: every stack in these of a player's inventories (gadgets, quiver, main) has its item's cooldown set to set seconds; tag: with inventories: only items in this item tag", "thematic:scale": "A temporary scale on the wearer: slower while charging, a longer reach. Stays until unscale(), unless for or while hold it: then it comes off by itself, death and logout included. With who: \"target\", on the target inside targets(): a player keeps it as the wearer would; a mob's is set outright and stays (a summon's size) unless for puts it back. Fields: scale (required): which scale; value: the scale (1); key: what it is kept under on the wearer (_); unscale() names the same; for: seconds it lasts; while: active: while the ability runs; state: while the wearer stays in this phase; not with who: \"target\"; snap: jump straight to it (true); false eases in over Pehkui's tick delay; who: self (default) or target; exclusive: first take off every other scale of this kind the body wears, so two size moves never stack (false); relative: value is added to the body's scale of this kind as it stands now: 0.3 is three tenths bigger than it is (false)", "thematic:unscale": "Takes a scale() off the wearer, or the target: a mob's goes back to the default. Fields: scale (required): which scale; key: the key scale() used (_); who: self (default) or target", "thematic:attack": "A real attack on the target inside targets(), as the wearer's own swing would land it: the held item's damage, enchantments, knockback, crits, sweeping and durability, weakened by the attack cooldown as any swing is (a blow every tick is a weak one). A mob wearer attacks as a mob does. Turn to the target first with lookAt(), and swingHand() for the swing to show. Fields: weapon: only when the main hand holds this kind, e.g. \"weapon\"; left out, whatever is held; sweep: draw a sword's sweep after the blow (false)", "thematic:slow_time": "Catches the target in slowed time (the reflex slow), held at the speed it was caught at. Inside targets(); run it every tick of a phase and it is topped up, never shortened. Fields: for: seconds it lasts; left out, what is left of the running phase, so it lapses when the phase does", "thematic:release_time": "Lets the target out of slowed time. Inside targets().", "thematic:hold_projectiles": "Freezes the projectiles around the wearer in the air. Fields: radius: left out, the tuned radius; for: seconds it lasts; left out, what is left of the running phase, so it lapses when the phase does", "thematic:lock_moves": "Locks a kit's moves -- the target's inside targets(), the wearer's otherwise. Never the move doing the locking. Which moves a mode takes by default follows the Java it replaced: dampen takes ultimates but spares stun-immune moves; interrupt and disable_effect spare ultimates but take stun-immune moves; cooldown_floor takes both and skips passives. Fields: mode: how the kit is held (dampen); who: who it lands on; left out, the target inside targets() and the wearer otherwise; for: seconds it lasts; left out, what is left of the running phase, so it lapses when the phase does; except: ability ids left alone; only: lock only these ability ids; include_ultimates: also take ultimates (true for dampen and cooldown_floor, false otherwise); stun_immune_too: also take moves immune to stuns (false for dampen, true otherwise); skip_passives: leave passives alone (true for cooldown_floor, false otherwise); stop: switch off locked moves already running (true). dampen with false only holds the kit: presses are refused, a running move finishes; disable_effect with false only puts the effect on. Not for cooldown_floor; cooldown: seconds a stopped move is left on, or \"full\" for its own full cooldown; left out, none for dampen and the lock's length otherwise. Not for cooldown_floor; amplifier: disable_effect only: the Disable effect's amplifier, holding that many idle moves plus one (15: any kit); message: dampen only: translation key a refused press shows while the lock lasts; color: the message's colour", "thematic:unlock_moves": "Lifts a dampen lock early (stamps, holds and its message) -- the target's inside targets(), the wearer's otherwise. Fields: who: who it lands on; left out, the target inside targets() and the wearer otherwise; only: unlock only these ability ids", "thematic:slow_motion": "The wearer keeps moving while everything around them crawls (Enhanced Reflexes). start: the wearer sheds anyone else's slow and takes their own motion scale; tick: sparks, then everyone hittable in the radius not running one of victims.unlessActive is caught -- the reflex slow for the time left, their kit locked, the speed they are held at worked out once -- and held, and projectiles freeze; end: the wearer's scales come off and everyone in the radius is let go. A script writes it with phase.slowMotion(). Fields: phase: which part this is (tick); phase.slowMotion() writes all three; radius: how far it reaches, a box that far out each way (the tuned radius); for: seconds the slow, the lock and the held projectiles last; left out, what is left of the running phase, so they lapse on the tick it does; self: the wearer's own time: false leaves it alone ({ motion: 0.8 }); victims: what happens to those caught; hold_projectiles: holds the projectiles in the radius in the air (true); sparks: particles around the wearer each tick, over three bursts of five electric sparks scattered across the radius and up to two blocks up; false for none; release_on_end: lets everyone in the radius go as it ends -- slow, held figure and kit lock (true)", "thematic:spray": "Particle projectiles thrown from a point on the wearer along their look -- a mob's, straight at its target; an arm anchor's, along the arm -- each carrying ability effects to what it hits: a breath, a spray. Flat, it is one projectile; with cones, one per cone, in order, e.g. a breath's { spread: 0.8, lifetimeTicks: 90 }, { spread: 5, lifetimeTicks: 20 }, { spread: 10, lifetimeTicks: 20 }. Fields: from: where on the body it is thrown from (eyes: exactly where the breaths always came from); cones: one projectile per cone, each firing; left out, the spray is one cone; particle: the particle it is drawn with (minecraft:spit); spread: how far it strays from the look, as vanilla's divergence; it also tips the throw up by as many degrees, as the breaths always did (1); lifetime: seconds before it goes, to the nearest tick (3); lifetime_ticks: ticks before it goes, exactly; instead of lifetime; speed: how fast it flies, blocks a tick (2); the wearer's own velocity is added; damage: what the effects it carries are handed as the hit's damage (0); effects: ability effects it carries: ids, e.g. [\"thematic:laser\", \"thematic:ignite\"], or an effect that takes options with them, e.g. { id: \"thematic:blindness\", duration: 3.5, amplifier: tuned(\"amplifier\") }; option_effects: a suit option whose comma list of effect ids is added after these, e.g. \"laser_effects\"; dedupe: an effect already in the list is not added again, e.g. when the suit option names it too (false: it fires twice)", "thematic:set_flag": "Stores true or false on the wearer, synced, under a key an animation or a client visual reads. Fields: key (required): the key; value: (true); for: seconds after which it flips back, whatever happens in between -- the wearer dying, a later step called off; left out, it stays", "thematic:beam": "A hitscan ray that hurts and carries ability effects: from the eyes along the look unless told otherwise (a mob's, straight at its target). Reflect abilities bounce it back, and a wall stops it. Fields: effects: ability effects it carries: ids, e.g. [\"thematic:laser\", \"thematic:ignite\"], or an effect that takes options with them, e.g. { id: \"thematic:blindness\", duration: 3.5, amplifier: tuned(\"amplifier\") }; option_effects: a suit option whose comma list of effect ids is added after these, e.g. \"laser_effects\"; dedupe: an effect already in the list is not added again, e.g. when the suit option names it too (false: it fires twice); from: where it leaves (\"eyes\", exactly the eye position). A list fires one beam from each; inside targets() it fires one per target, taking the anchors in turn: [\"right_hand\", \"left_hand\"]. A swept arm ({ point: \"arm\", side, sweep }) turns from the heading markHeading() fixed, or the wearer's yaw, by the phase's ticks; direction: which way it goes (look); aim: a mob's look beam: at its target (default) or along its own look; range: how far, in blocks (128); reach: range (default), or target: to the target plus overshoot, however far; needs direction \"target\"; overshoot: with reach \"target\": how far past the target's centre it runs (0.5); margin: how far either side of the line still counts as a hit, in blocks (0.3, an arrow's); damage: what a hit deals; left out, the tuned damage; splash: the blast round the first hit: a radius, or its options; chain: jumps on from the first hit: true for the suit's beam assets, or its options; on_hit: run aimed at the living thing it hit, after any splash and chain: push(\"target\", ...) knocks it; on_block: run when it hit no one -- at the block it stopped on, or the end of its range: push(\"self\", ...) for a recoil off the wall; unstoppable: true: its hit goes through guards -- no parry, counter, soak or reflect hears of it (pair with an effect whose damage bypasses shields, e.g. thematic:solar_lance). on_hit runs after, as usual (false)", "thematic:store": "Keeps a number under a name for as long as this press's phases last, for {stored: name}, $name in an expr, or a field written \"$name\" to read back. A fresh press starts with none. Fields: key (required): the name it is kept under; value: the number (1), e.g. fromEvent(\"amount\") for the damage of the hit being answered; mode: set (the default: the last one wins), add, max or min", "thematic:cancel_event": "Calls off the event being answered. attack: the swing's own damage never lands (what the answer itself deals still does) -- an armed punch consumed by the move it arms. damaged: the hit on the wearer is cancelled. use_block, use_entity, use_item: the use never happens. xp_gained: the experience is not added. projectile_incoming: the projectile passes through the wearer. projectile_launched: the projectile never appears. The first answer to cancel decides; the rest are not asked. Every other event has already happened, and this does nothing there. Pair it on attack with the phase trait hidesSwing, so the client doesn't draw a punch over the move.", "thematic:start_cooldown": "Starts this ability's cooldown now: the tuned cooldown times fraction. For a passive -- which has no then() -- and for an answer whose cooldown is owed part-way through its steps, as a vent that is only paid for once it goes off. Inside a phase of a pressed ability the cooldown slot counts the phase's time; leave with then(\"cooldown\") there. Fields: fraction: of the tuned cooldown (1)", "thematic:set_bones": "Puts this ability's suit bones (its bones trait) in their on or off pose. Time it to the frame of an animation so the swap lands mid-gesture; until an ability first calls it, its bones follow whether it is on. Fields: on: true (default): the on pose -- show drawn, hide hidden; false: the off pose", "thematic:say": "A chat line from the wearer to the players within earshot, through vanilla's chat.type.text so a server's chat formatting applies to it as to anything else the wearer says. Fields: lines (required): translation keys: one, a list, or { prefix, count } for prefix1 .. prefixN (first: where the numbers start, 1); pick: random (default) or cycle; sender: the name it is signed with, as written; left out, the wearer's name; color: a chat colour for the whole line, e.g. \"blue\"; radius: how far it carries, in blocks (32); radius_option: a suit option that overrides the radius when set above 0, e.g. \"chat_radius\"; format: the translation key the sender and line are put into (chat.type.text)", "thematic:equip": "Puts an item in one of the wearer's slots, tied to the ability: tagged, so it is stripped once the ability is not running and discarded if dropped. Already there, nothing happens; copies moved elsewhere are taken first, so it is safe every tick. In a phase, phase.equip() also takes it back when the phase ends. Fields: item (required): the item id, e.g. \"thematic:cyclops_visor\"; an item not registered (its pack missing) hands out nothing; slot: mainhand (default), offhand, head, chest, legs or feet; count: (1); enchant: enchantments and levels, e.g. { \"minecraft:binding_curse\": 9 }; tag: what ties the item to a move; left out, this ability's id; displaced: what happens to what held the slot: stash (default) or drop; named: named for the wearer, \"'s \", in grey (false)", "thematic:unequip": "Takes back the items an equip() handed out: every stack with the tag, from hands, armour and inventory. Fields: item: only stacks of this item; tag: left out, this ability's id", "thematic:particles": "A burst of particles where it happens -- inside targets(), where the target stands -- or from a point on the wearer's body. Fields: particle (required): a particle id, dust(color, scale), or \"block_below\": debris of the block underneath; count: how many (12); in a sphere, how many points; spread: how far they scatter, one number or per axis (0.5; 0 in a sphere); any worked-out number, e.g. tuned(\"radius\", 0.5); speed: how fast they move (0.05; 0 in a sphere and for relative; 0.15 inward); y_offset: raise or lower the burst (0); anchor: feet (default), body (half the subject's height), or a fraction of its height; at: here (default) or spot: the point markSpot fixed; from: a point on the wearer's body to start from, rather than where it happens (see Anchor); forward: blocks along the wearer's look, from wherever it starts (0); color: recolours dust: on its own, dust of this colour; with dust(...), its colour. [r, g, b], \"#RRGGBB\" or \"$name\"; system: how they leave (burst); aim: with a system other than burst: which way (look); shape: point (default); sphere: count points in a sphere of radius; line: count points from the wearer's eyes to the target's, one particle each (inside targets(); spread and speed 0 unless given); inward: count particles, each born 60 to 100% of radius out and flying in toward the point at speed (a drawn-in glow); radius: the sphere's (or the inward shell's) radius; left out, the tuned radius; scatter: several bursts, each at its own random point: across either way, up to up above the feet; bursts: with scatter: how many bursts of count (1)", "thematic:particle_circle": "One of the particle circle systems, centred where it happens, on the spot markSpot fixed, or on a point of the wearer's body. Fields: system: which system (circle); particle: the particle (campfire smoke); height: (1); radius: left out, the tuned radius; count: (32); y_offset: raise or lower it (0); block_center: snap to the block's centre (false); at: here (default) or spot: the point markSpot fixed; from: a point on the wearer's body to start from, rather than where it happens (see Anchor); forward: blocks along the wearer's look, from wherever it starts (0); color: recolours dust: on its own, dust of this colour; with dust(...), its colour. [r, g, b], \"#RRGGBB\" or \"$name\"", "thematic:particle_dome": "A hemisphere of particles, or part of one, centred where it happens, on the spot markSpot fixed, or on a point of the wearer's body. Fields: shape: which part (full_dome); particle: the particle (smoke); radius: left out, the tuned radius; height: (0); count: (60); y_offset: raise or lower it (0); at: here (default) or spot: the point markSpot fixed; anchor: feet (default), body (half the subject's height), or a fraction of its height; from: a point on the wearer's body to start from, rather than where it happens (see Anchor); forward: blocks along the wearer's look, from wherever it starts (0); color: recolours dust: on its own, dust of this colour; with dust(...), its colour. [r, g, b], \"#RRGGBB\" or \"$name\"", "thematic:sound": "Plays a sound. For one sound, a suit's options sound, volume, pitch and soundOffset still win (unless world). Fields: sound (required): a sound id (\"minecraft:...\" or a Thematic sound name), or { cycle, key } for the next of a set; volume: (1); [low, high] is drawn at random each time it plays; pitch: (1); [low, high] is drawn at random each time it plays, e.g. [0.9, 1.1] for a pack's howls; delay: seconds before it plays (0); a suit's soundOffset replaces it; at: where it plays (here); world: a plain sound in the world: no suit re-voices it (false); once: at most once per pass through a list, or per press; loop: replayed while a phase lasts, when run from its every(); stop_on_exit: cut it off on every client when the move's phases end (false); follow: played at a body (the wearer, a target), it moves with that body rather than staying where it started (true); voice: a voice clip: one at a time per listener, 2 s of silence after it, and one asked for sooner is dropped (false); duration: seconds a voice clip runs, how long its listener's channel stays busy (3); gap: seconds a listener who already heard this sound is not sent it again, so a cue used often never stacks (0); heard_by: who hears it (all): wearer plays it at the wearer for them alone, a warning nobody near them gets; target plays it for the aimed player alone; both take no at", "thematic:stop_sound": "Stops a sound on the wearer's client and every client near them, at once. A suit's options sound is the one stopped, unless world. Fields: sound (required): the sound, or a set: every member stops; world: the sound as written, never the suit's own (false)", "thematic:animation": "Plays a suit animation clip. A suit's options.animation still wins for the wearer. A suit-wearing mob (a squad flier running a mob() block) plays it once on its own body, for everyone who can see it; hold, hold_for and first_person do nothing for it. Fields: animation (required): the clip name; speed: playback speed (1); on: self (default), or target: a targeted player; fit: play it at the speed that fills a window, instead of speed; fade_in: seconds spent blending in from the current pose (0); stop_after: stop it this many seconds after it starts; stop_on_leave: stop it when the move's phases end (false); hold: hold it on the suit, on its last frame, for as long as the move lasts, rather than play it once; play: with hold or holdFor: hold (default) on its last frame, loop, or once; then: with hold: once the clip has played through and parked, loop this one; blend: with hold or holdFor: seconds to ease in and out (0); hold_for: hold it on the suit for this many seconds from now, over any held clip (a hit pose); priority: a clip played once: its priority over the other clips on the wearer's animation layer, e.g. 1 for a throw over the swing's own clips (the layer's default); alternate: a clip played once: clips that take turns with this one, a run each -- animation(\"web_shoot_right\", { alternate: \"web_shoot_left\" }) throws right, then left, then right; counted per wearer and ability; first_person: a clip played once: the clip the wearer sees in first person instead, while everyone else (and their own third person) sees this one -- animation(\"shoot_missile\", { firstPerson: \"shoot_missile_fp\" })", "thematic:stop_animation": "Stops a clip, played or held. Fields: animation (required): the clip name; a suit's options.animation still wins for the wearer; on: self (default), or target: a targeted player", "thematic:gun_clip": "Plays a clip on the gun in the wearer's main hand: one of the cues that gun declares, by name. The gun owns its own clips, so a move asks for the name and gets whatever the gun in hand calls it -- or nothing, when it has no cue by that name. First person only: the weapon model animates nowhere else, and the third person of the same beat is the wearer's own body (swingHand, or a suit clip). Fields: clip (required): the cue's name, as the gun's cue() declares it, e.g. \"bash\"", "thematic:assets": "Fires the suit's clips and sounds for this move from its options anims_ and sounds_, as the key press does. The press already fires anims_press and sounds_press once; assets(\"press\") fires them again, as moves that restarted the clip and doubled the sound at their own start did. Fields: key: which options: \"press\" (default) for anims_press and sounds_press, \"release\" for anims_release ...", "thematic:claim_pose": "The move's clip drives the wearer's pose for a while, and any other move's claim is dropped. An ability with body({ while: \"animating\" }) holds its limbs for as long as the claim. Fields: for: seconds; left out, what is left of the running phase", "thematic:release_pose": "Gives the wearer's pose back before the claim runs out.", "thematic:shot": "Changes the arrow the answered arrow_loosed loosed, as it leaves the string: a harder hit, a critical, piercing, a command tag, who may pick it up. A patient shot: shot({ damageTimes: tuned(\"damage\"), critical: true, pierce: 1, tag: \"thematic_bullseye\" }). Nothing outside arrow_loosed. Fields: damage: its damage, set outright (a Thematic arrow's is scaled by the draw when it lands); damage_times: its own base damage (before the draw scales it) times this; not with damage; critical: a critical arrow (the trail of sparks, and vanilla's extra); pierce: how many bodies it passes through, 0 to 127; tag: a command tag it carries, which a kill guard can ask of the killing arrow; pickup: who may pick it up once it lands", "thematic:projectile": "Fires or throws a projectile. A bolt body is an energy bolt (optic blasts, starbolts, crescents); a thrown body is a throwable definition's model and flight (vials, a cup of tea). on_hit runs aimed at the entity it strikes, on_block where it meets a block (or a thrown body's fuse runs out), each with the owner's tuned numbers as they are when it lands. Fields: body: bolt (default), thrown, arrow or entity; entity: entity: the entity type it is, e.g. \"thematic:cap_shield\"; owned by the shooter when it is a projectile, its damage set when damage is written and it is an arrow; how it looks and hits is its own (1.5 a tick unless speed says); a tether body (thematic:tether) names the move and runs its on_hit / on_block, in the press, when its head takes hold of a body / a block (a lasso's catch); any other entity body takes neither; consume_held: an item (or #tag) each one takes out of the wearer's hands as it leaves, main hand first; none held, none fired; a thrown body whose throwable carries its item carries the one taken; carries: thrown, a throwable that carries its item (thrown_item): the stack each one flies with, made for it -- one of items at random, in a corps' colour and prefix with tint (e.g. \"yellow\"), as a construct is drawn; not with consume_held; throwable: thrown: the throwable definition it is, e.g. \"thematic:science_vial\" (model, size, flight); \"self\" for the throwable whose own hook fires it, or whose item is in hand (a gadget's throw); arrow: arrow: the arrow definition it is, e.g. \"thematic:arrow_explosive\" (minecraft:arrow for a plain one); its definition decides its look and hits, so on_hit, on_block, effects and look are not taken; from: where on the body it leaves (eyes); several anchors fire one from each; \"spot\" over the spot the press fixed (nothing fired with none); toward: aimed at the spot the press fixed instead of along the aim (no aim: target); aim: look (default), heading, target, ballistic, or crosshair; aim_reach: aim crosshair: blocks along the look to look for what the crosshair is on (64); it stops short of unloaded chunks; pitch: degrees added to the look's or heading's pitch; negative tilts it up (-3 lobs a throw); at: aim target: who to throw at, written as a targets() search; nobody found, it goes along the look; count: how many from each anchor (1); per_target: at least one at each target at found, dealt round in turn (Stars and Garters: count 5, one each if more); speed: blocks a tick (bolt 2.5; thrown, the throwable's velocity); spread: vanilla's inaccuracy along a look or heading, and at a target with lead (0); jitter: up to this much added to its velocity on each axis, either way (0); lift: added to its velocity's rise after aiming (0); inherit_motion: adds the shooter's motion, as vanilla shots do (true along a look or heading, false at a target); delay: seconds before it leaves (0); gone with a wearer who dies meanwhile; latch: with a delay: read the origin and/or the aim as the action runs (press) rather than as it leaves (fire, the default); gravity: blocks a tick it falls by (bolt: vanilla's first tick then none, the Java bolts' way; thrown: the throwable's); max_age: seconds before it is gone without breaking (bolt 2; thrown 10); 0 for a bolt's no limit of its own; a Thematic arrow body: how long it stays, landed or not (its own 120); pickup: arrow: who may pick it up once it lands (the arrow's own); shot: arrow: a fully drawn shot, critical (false), passing through pierce bodies (the arrow's own) and carrying a command tag a kill guard can ask of the killing arrow; max_distance: bolt: blocks from its shooter before it is gone (32); 0 for no limit; fuse: thrown: seconds before it breaks where it is, running on_block (the throwable's fuse); size: bolt: its hitbox, blocks (0.3); direct_hit: what a head-on hit deals besides on_hit (bolt: flat; thrown: none); damage: the direct hit's damage and the effects' damage (the tuned damage), fixed when it is fired; effects: ability effects a direct hit carries, as a beam's: ids, e.g. [\"thematic:push\", \"thematic:laser\"], or { id, ...options }; option_effects: a suit option whose comma list of effect ids is added after these, e.g. \"laser_effects\"; dedupe: an effect already in the list is not added again; pierce: bolt: true flies on through bodies, striking each once with on_hit and the effects but no direct hit; { unless, max } flies through the bodies the guard does not hold for and strikes those it does, spent after max of them; return: bolt: turns back to its shooter and is caught there (true: straight home after 17 ticks); on_return: bolt with a return: run at the shooter when it is caught; pierce_option: a suit option that switches pierce on when true, e.g. \"pierce\"; hit_once: a body it has hit is passed through after (true); hittable_only: it passes through the shooter and anyone they may not hit (bolt false, thrown true); ricochet: bolt: bounces off blocks instead of spending itself on them; recoil: bolt: the shooter pushed back when it meets a block; steer: thrown at a target: how much of the way it turns onto them each tick, 0 to 1 (the vials: 0.3); contact: thrown at a target: it breaks on them once within this many blocks of their middle (the vials: 0.7); trail: particles it sheds in flight; hit_sound: bolt: played when a direct hit lands (minecraft:entity.firework_rocket.blast); \"none\" for silence; look: how it is drawn (a bolt as a bolt from the ability's assets.beam; a thrown body as its model); on_hit: run aimed at the entity it strikes, before the direct hit; on_block: run where it meets a block, or where a thrown body's fuse runs out; cycle: with at: each firing takes the next of the targets at found, in turn, counted over the press -- a volley spread round a crowd; a number goes round only the first that many (sort: \"distance\" for the nearest); lead: at a target: aimed where they will be after the flight (their motion times its ticks, at most 40) and raised by what the shot falls on the way, then strayed by spread; spiral: at a target, when at finds nobody: the nth firing of the press leaves at the wearer's yaw plus n times step degrees (137.5), at the nth of pitches in turn ([0]), strayed by spread (0) -- a blind corkscrew instead of the look; pattern: how the count shots of a firing are laid out: ring, fan, converge or rain; formation: the shots in a grid across the look, in place of count; volleys: the whole firing count times in all, every seconds apart (0.25), each read afresh as it leaves; none from a wearer who died meanwhile; homing: turns onto its target each tick (strength 0.2); hover: seconds held still where it was made before it goes; a bolt's max_age grows by the hold unless written; orbit: circles the wearer, then is gone (or let go); a bolt's max_age grows by it unless written; wobble: its heading wanders on the way, its speed kept; explode_on_impact: bolt or thrown: Thematic's explosion wherever it hits, after on_hit and on_block (by_definition: the throw detonates on any hit, at radius when given); by_definition: thrown: it flies and breaks as its throwable definition says (flight, fuse, hooks) with the fired damage, instead of breaking on the first thing it meets and running on_hit / on_block; takes no on_hit, on_block, effects, steer, contact, trail or max_age; color: picked for each one as it leaves and put in its look's color (a thrown body: its tint): a colour, one of a list at random, a random hue, the wearer's suit colour, the colour tag of the item stack firing it (a lantern construct's corps colour), or a press value; keep_as: the wearer's store key the last one fired is kept under (e.g. \"grapple_entity\"): the one kept there before is taken down as this one leaves, the keeps guard asks whether it is still out, and drop_kept takes it down", "thematic:drop_kept": "Takes down the entity the wearer keeps under a store key -- the projectile a projectile's keep_as kept (a grapple's hook), a bow's tracked arrow -- if one is still out, and forgets it. dropKept(\"grapple_entity\"). Fields: key (required): the store key, as keep_as wrote it", "thematic:recall_thrown": "Turns every throwable the wearer has out for home now, by its own return (those of one definition when throwable names it). recallThrown({ throwable: \"thematic:my_throwable\" }). Fields: throwable: only throwables of this definition id", "thematic:burst": "A blast going off at a point -- where a shot landed (the default), on the wearer, at a marked spot, or at random around one -- that hurts, doses and throws back everyone the wearer may hit within radius, with a flash and a bang. Fields: at: where it goes off (impact); from: a point on the wearer's body it goes off at, instead of at; radius: how far it reaches, in blocks; left out, the tuned radius; targets_around: whose surroundings are searched (self when at is self, burst otherwise); shape: box (default) or sphere; hittable: false: allies and protected entities are caught too (the wearer never is) (true); exclude: who it leaves out besides the wearer (none); damage: what each body takes; left out, the tuned damage; 0 hurts no one; source: what the hit counts as (attack); damage_type: a damage type id instead of source, e.g. \"thematic:psychic\"; element: what the blast is made of instead of source, e.g. \"radiation\": the hit carries that element's damage type, so a suit weak or resistant to it answers; hit_objects: true: the non-living thing a shot struck (an armour stand, a boat) takes the damage too (false); effect: a status effect on everyone it catches (none); knockback: a shove away from the point: a strength, or its options (none); particles: particles where it goes off: the fields of particles(...), e.g. { particle: \"minecraft:flash\", count: 80, spread: 3, speed: 0, yOffset: 1 }; sound: a bang where it goes off, re-voiced by the suit's sound option; do: more for each body it catches, as inside targets()", "thematic:zone": "A patch of ground that keeps biting: fixed where it is laid, every so often for a while it runs its actions on everyone standing in it -- first ones only the first time each body is caught. The first pulse comes one every after it is laid, the last at for: floor(for / every) pulses, at least one. Its numbers are read as each pulse lands. Fields: at: where it lies (here); floor: drop it onto the first solid surface up to 4 blocks below, as a pool lies (false); radius: how far it reaches sideways; left out, the tuned radius; height: how far above the ground it still reaches (1); footing: how far below the ground it reaches (0.5); shape: round (default) or box; every: seconds between pulses (0.25); for: how long it lies there, seconds; left out, the tuned duration; hittable: only those the wearer may hit (true); false catches allies too. Never the wearer; caught: a catch markCaught() filled earlier in the press (or the same throwable's hit): those already in it skip the first actions, as a pool leaves alone whoever the break already burned; do: run on everyone standing in it, every pulse; first: run before do, once per body: the first pulse that catches it", "thematic:mark_node": "Adds where the wearer stands to a trail kept for the rest of the press under a name: targets(\"trail\") searches around its nodes and decal({ along }) stains the last stretch of it. Fields: key (required): the trail's name; max: how many nodes it keeps before the oldest give way (256)", "thematic:mark_caught": "Counts the entity the action is about -- the target inside targets() -- as caught under a name, so a zone given the same caught skips its first actions for it. Fields: key (required): the catch's name", "thematic:decal": "Stains the floor with a block that is only shown, never placed: laid in lanes across the way the wearer faces, sampled every step along the last stretch of a trail (or at the spot), each on the first floor with a full top face within depth below. Every player sees each one for as long as it lasts, on the server's clock. With touch, whoever stands in one has those actions run on them, as the wearer, every touchEvery seconds of their own age. Fields: block (required): the block phase, as a command writes it: \"thematic:blood_splatter[down=true]\"; along: a trail markNode laid: stains the stretch from its last node but one to its last; left out, at the spot; facing: which way the lanes run across (heading); lanes: side by side (1); spacing: blocks between lanes (1); step: blocks between samples along the stretch (0.7); depth: how many blocks below a sample it looks for the floor (2); max: stains this action lays in the press at most, each spot once (64); lasts: seconds each stays on the ground (15); tag: an id gameplay can ask the ground about, e.g. \"thematic:blood\"; touch: run on whoever stands in a stain, aimed at them, while it lasts; touch_every: seconds between touches, counted on the stander's age (0.2); touch_hittable: never the wearer, and only while the wearer is in that world and may hit the stander (true); false: anyone but the wearer, online or not", "thematic:splash": "Liquid of a colour. Breaking at the spot: drops thrown out, a burst, a pool on the floor under it for a while and pool.splatter smaller ones up to pool.spread away. With drench: landing on the entity the action is about instead, over the chest and across the eyes. Fields: color (required): 0x8CE01A, \"#8CE01A\", [r, g, b] or \"$name\" for one the press drew; at: here (default) or spot (where markSpot fixed); pool: the pool it leaves: for (seconds; left out, the tuned duration), radius (1.4), splatter (further pools, 0) and spread (how far they land, 0); drench: splash the target rather than break at the spot (false)", "thematic:track": "Remembers a target across the move, with a synced copy of it the client can draw from (thematic:trail_to_target, thematic:target_readout) even once it is out of render distance. Inside targets(): starts tracking the one picked. Anywhere else: refreshes the copy of the one tracked -- run it in a phase's every(). stop: true lets go. Kept on the wearer under _target (and _name, _health, _bleed, _x, _y, _z, _since): scent_tracker's keys, which Keen Nose writes too. Fields: name: which track: lower_snake_case; left out, the ability's id; sync: what to keep a copy of (all of them); resync: how much change rewrites the copy: blocks moved (0.5) and display health (1); stop: true: lets go of the target and blanks the copy; glow: outlines the target for the wearer alone, through walls, while the track is refreshed; stop takes it off (false)", "thematic:strike_spray": "Blood off a blade strike, inside targets(): each client that can see the wearer throws it off the blade nearest the wound, along the way that blade was travelling; one that can't sprays from the wound along aim. What every Wolverine move's hit threw. Fields: count: how many drops (12); aim: which way it sprays when no blade is seen: look (default), up, down, motion (where the wearer moves, or their look while they stand still) or heading; particle: what is thrown (thematic:blood_particle); color: recolours dust, as particles() does", "thematic:mark_deadline": "Stores a deadline on the wearer, synced: the world time plus for seconds. The until guard holds until it passes -- a lock that runs out by itself, with nothing to clear on death, logout or a move cut short: markDeadline(\"claw_stab_lock_until\", { for: 1.5 }) with requires({ not: { until: \"claw_stab_lock_until\" } }). Fields: key (required): the key it is stored under, the one an until guard names; for (required): seconds from now", "thematic:outgoing_damage": "For a while, every hit the wearer deals carries amount * times + plus more -- negative for less -- folded into the hit as a phase's damageBonus is, but kept on the wearer with its own deadline, so it outlasts the phase and the press: outgoingDamage({ times: -0.1, for: 5 }) is a tenth off for five seconds. A later one under the same key replaces it; it runs out by itself, death and logout included. A hit's bonuses are summed and never total less than none, so a negative share only takes off what its other bonuses added. Fields: times: the share of each hit added, e.g. -0.1 for a tenth less (0); plus: a flat amount added to each hit (0); for (required): seconds it lasts; melee: true: only the wearer's own melee swings carry it, not projectiles, beams or other moves' damage; key: what it is kept under on the wearer, lower_snake_case (the ability's id; an item's hook has none, so it names one); one per key; uses: spent after this many hits, 1 for an empowered next hit; a hit in the tick it was granted never spends it, so the hit that earns it does not (0: no limit); held_trait: only hits dealt while the wearer's main hand holds an item with this trait count, e.g. \"construct\" (any)", "thematic:phase": "The shared phase every intangible suit uses (intangibility's own phase: noclip movement, the shimmer, active: \"intangibility\"). phase() begins it until ended, phase({ for: 0.55 }) for that long, phase({ end: true }) ends it; beginning turns the body shimmer on and ending turns it off. phase({ density: \"hand\" }) only turns that part's shimmer on (value: false, off). Players only. Fields: for: seconds the phase lasts; 0 or left out: until ended; end: true: ends the phase instead (false); density: only turns this part's density shimmer on or off; takes no for or end; value: with density: on (true) or off", "thematic:mark_health": "Keeps the wearer's health plus absorption under a key, for the healthBelowMark guard: markHealth(\"my_charge_health\") on the press, until({ healthBelowMark: \"my_charge_health\" }, \"ready\", { check: \"before\" }) in the phase, and markHealth again in its every() so a heal raises the mark. Only a hit that really took health or absorption counts; one an immunity or resistance swallowed does not. Fields: key (required): the key it is kept under, the one healthBelowMark names", "thematic:summon": "Brings in entities that belong to the wearer, placed around them and facing the way they face: summon(\"thematic:hologram\", { count: 3, arrangement: \"rear_arc\", radius: 3.6, health: 50, lasts: 20, mirror: { melee: 0.2 } }). An entity built to be summoned (thematic:hologram) also takes its owner, its lifespan, the echo and goes away when the wearer loses this ability; any other is only placed and given its health. The body runs at each one, aimed at it as at a target. Fields: entity (required): the entity type id, e.g. \"thematic:hologram\"; count: how many (1, or one per offset); a worked-out number is truncated, never below 1; arrangement: where they stand around their centre (ring); radius: how far from their centre, in blocks (0), or [min, max] picked for each one; for formation_v, how far apart the ranks stand sideways; stagger: with formation_v, how far back each rank stands, in blocks (half the radius); offsets: fixed places added on top of the arrangement, each [right, up, forward] in blocks from the way the wearer's body faces, used in turn: [[0, 5.62, -5], [-6.5, 5.62, -7.25], [6.5, 5.62, -7.25]]; scatter: moves each one up to this many blocks at random on each level axis (0); target: whom each one goes for: a mob takes it as its target, an effect entity (a construct jet) flies at it; named and not there, nothing is summoned; velocity: sends each one off as it arrives: {along, speed}; every: seconds between one and the next (0: all at once); later ones are dropped if the wearer is gone; damage: what an effect entity that works for the wearer (a stun bolt, a construct jet) or an arrow hits for; left out, the entity's own; health: each one's maximum and starting health, in raw hit points; left out, the entity's own; lasts: seconds before each fades on its own (a summon built for it, a shockwave, a construct jet), e.g. expr(\"cooldown / 20\") for a full cooldown; any other entity (a mob, a TNT) is sent away after it; left out, the entity's own; attributes: attribute modifiers put on each living one for good (saved with it): [{ attribute: \"minecraft:generic.armor\", amount: tuned(\"damage\"), operation: \"add\" }]; scales: Pehkui sizes each one grows to besides its whole body's (scale): { defense: 8, attack: 2, reach: 2.25, falling: 0 }; display: for show only (a lit charge that never goes off, a prop): it cannot be hurt, a mob's AI is off, a primed TNT's fuse never runs down, it drops nothing and is never saved -- one a save brings back is discarded. Send it away with lasts, or action(\"thematic:thematic_explosion\", { at: \"summoned\" }) inside do (false); floor: each one is set down on the collision surface below its spot (a slab's top, a step), so a prop sits flush instead of hanging where the wearer's feet were (false); options: anything else an effect entity that works for the wearer takes (a jet's missile count, a thrown construct's item), handed to it as written; a worked-out number (tuned(\"damage\"), expr(...)) is worked out at the cast. Keys arrive snake_case; an entity reads only those it knows; echo_melee: the share of each of the wearer's melee hits each one repeats on whatever the wearer hit, and what it hits for on its own (0); the same number as mirror.melee, which a new file should use; replace: first clears the wearer's own earlier summons of this entity within this many blocks of them; like: each one takes on the look of the body the action is aimed at: a villager's type, trade and level; do: more at each one as it arrives, as inside targets(); at: what they stand round: the wearer (default), the target the action is aimed at -- the body a projectile struck, the one inside targets(); no living target, nothing is summoned -- the spot the move fixed (none, nothing is summoned), the block face a shot struck, turned out of it (face: a splat on a wall; aimed at a body, as in a push's onWall, the wall beside it; no face, nothing is summoned), or a random spot near the wearer (random, random_water); spread: with at: \"random\", how far off the wearer each one stands (1.5); with \"random_water\", how far off on each level axis the spot may be (5); onto: stand each on the target and hand it the target as its subject (thematic:web_snare_entity: a cocoon wrapped round it); no living target, nothing is summoned; anchors: with onto: how many lines it may keep to the world round its subject (-1: as many as it finds); hold: with onto: it holds its subject where it stands, rather than only wrapping it (false); mirror: makes them mimics: which of the wearer's moves each one runs again from its own body, and the share of the wearer's punches it repeats; look: how a mimic is drawn: the wearer's suit (as ever), a tint, how solid; solid: it can be bumped, pushed and struck by blows and projectiles (true); false lets them pass through; hittable: anything can hurt it (true); false leaves it untouchable; hurts_owner: a blow that hurts it hurts the wearer for the same (false); tame: tames each one to the wearer when it can be tamed -- a wolf, a cat, a horse (false); owner: writes the wearer into each one's own data as its owner (ownerUUID), as the mod's summons do; any option below that needs an owner writes it anyway, unless taming already said (false); credit_owner: the damage it deals counts as the wearer's: their bonuses, hit_landed, kill credit, loot (false); tag: a command tag each one carries, telling a group apart (\"thematic_pack\"); caps count only those with it; name: a translation key each one is named with, the wearer's name as its argument; link: the wearer's data key each one's id is kept under (\"companion_wolf_uuid\"), for targets and caps to find it; cleared when it is sent home; persistent: never despawns (false); follow: keeps up with the wearer: true, or the speed it walks at (1); brought along past 24 blocks; defend_owner: goes for whoever hurt the wearer (false); assist_owner: goes for whatever the wearer is fighting (false); never_target_owner: drops a target on the wearer's side: the wearer, their mobs, their teammates (false); hostile_to: what it goes for on sight: \"anyone\", entity type ids or \"#tag\"s; never the wearer's side; max_alive: no more of the wearer's own of this entity (and tag) standing than this: the oldest go first; keep_one: exactly one: while one stands (the linked one, else the first) the rest go and none is brought; top_up: those already standing within 48 blocks count toward count; any more, or further off, go home; dismiss_on_unequip: each one goes home when the wearer's suit no longer grants this ability (false); mount: owner: the wearer rides it; target: it rides the target the action is aimed at (inside another summon's do, the one summoned); gear: what each one wears by the wearer's level: for a slot, the last piece whose minLevel it reaches; levels: [min, max], the range the wearer's ladder is read onto for gear ([1, 5]); off a ladder, the ability's level; launch: throws each one along the wearer's look at this speed; scale: each one's size, 1 its own; baby: each one is a baby, where the entity has one (false); share_damage_to_owner: each one takes nothing from a hit and bills the wearer a share of it instead, through the attacker's own damage source; tint: a corps by its colour name, e.g. \"green\": each living one is drawn in that corps' light, as a construct is (its prefix kept in the body's own data)", "thematic:give": "Hands the wearer an item to keep: into the inventory (the ground when it is full), or onto a slot. Unlike equip() nothing takes it back -- unless tie names a move, when it carries that move's tag as an equipped item does: stripped while the move is not running, and discarded if dropped; or permanent, lasts or rounds say when it goes. Fields: item: the item id, e.g. \"minecraft:iron_sword\" (a bare id means thematic:); an item not registered (its pack missing) hands out nothing. Needed unless from says otherwise; from: instead of item: each construct the body starred (the Construct Wheel's), one apiece, skipping any it carries already; count: (1); slot: inventory (default), mainhand, offhand, head, chest, legs, feet, hand (the main hand when empty, else the inventory) or hotbar (into the hand: the selected hotbar slot when empty, else the first empty one, switched to for the first item given; no empty hotbar slot, nothing handed); only_if_empty: with an equipment slot: handed over only when that slot holds nothing, so it never displaces what is worn there (false); enchant: enchantments and levels, e.g. { \"minecraft:sharpness\": 2 }; named: named for the wearer, \"'s \", in grey (false); tie: the id of a move the item lasts only while running, e.g. \"equip_green_ring\"; {corps} in it is the wearer's corps prefix (\"equip_{corps}_ring\"; no corps, no tie); left out, the item is the wearer's to keep; displaced: with a slot: what happens to what held it, stash (default) or drop; permanent: the wearer's for as long as their suit has this move, taken back once it does not; and had once: carrying one already (anywhere, tagged or not), they are handed nothing (false); lasts: seconds the item lasts, then it is taken back wherever it is -- a mob's equipment too (0: it stays); tuned(\"duration\") for the move's tuned duration; rounds: a gun's budget: it goes once that many rounds have been fired, however often it reloads (left out: no budget); gun: for a gun: picks its fire mode -- the first of fireMode it has (automatic, then burst, when none is named; else its first) -- and marks it set up; oneClip: one magazine, no reserve. Anything else is left alone; tint: a corps, e.g. \"white\": its colour and prefix on the item, the way a construct is drawn in its light; \"wearer\" for the wearer's own corps (the green one when they have none); nbt: flags written on the item for it to read, e.g. { prefix: \"gold\", dontRemove: true }; keys are written in camelCase; who: self (default) or target: the one inside targets(), when the wearer may hit them; required: nothing handed (a permanent item already carried, an item not registered, nobody to hand it to): the rest of the list is called off, and the press costs missCooldown of the cooldown (0 with true)", "thematic:disarm": "Takes whatever is in both of a body's hands away -- inside targets(), the target's. What is taken lands on the floor, where a vanilla sword can be picked back up and a granted construct is discarded as any dropped one is. Fields: who: target (default: the one inside targets()) or self; drop: drops it on the floor (true); false stows a player's in their own inventory off the hotbar, the floor when that is full; lock: seconds what a player lost stays on their item cooldown, the sweep they see over it, e.g. tuned(\"disarm_lock\") (none)", "thematic:take_item": "Takes up to count of an item out of the wearer's inventory, from the first stack of it found: an offering the move asks for. Nothing carried: nothing happens. Fields: item (required): an item id, or \"#ns:tag\" (a bare id is minecraft's); count: how many (1)", "thematic:console_open": "Opens the wearer's command console for an ability, in a mode (a pick mode of its own, e.g. \"strike\"). Run from a press, it is how one ability's key opens another's console. Fields: ability: the ability whose console opens; left out, the one running this; mode: \"overlay\", \"desktop\" or a mode widget's id; left out, the console's default mode", "thematic:console_close": "Closes the wearer's open command console. Fields: ability: left out, whichever is open", "thematic:delay_pickups": "Holds the dropped items around the wearer out of reach: each one's pickup delay is set to seconds, so the wearer walks through them. Run it from every() to keep them off while a phase lasts; it runs out by itself after: every(e => e.delayPickups({ radius: 2, seconds: 0.5 })). Fields: radius: how far out from the wearer's box, in blocks (2); seconds: the pickup delay the items are held at (0.5)", "thematic:eject_from_blocks": "Lifts the wearer out of any block they are standing inside, straight up a block at a time, at most up blocks -- and leaves them where they are if none of those is clear. For a body going solid again where it may be inside a wall. Fields: up: the most whole blocks it lifts them (4)", "thematic:calm": "Takes a mob's grudge away, inside targets(): it forgets who it was after and stops attacking; with stop, it also stops walking and stands where it is. A player is not a mob and is left alone -- hold one with effects. Fields: stop: also stops its path and its motion, once (false); hostile_only: only hostile mobs; the neutral and the tame keep their target (false)", "thematic:provoke": "Sets a mob on something, inside targets(): one of the wearer's own bodies of the entity type within range (a decoy: an illusion, a summon), or the wearer when entity is left out (a classic taunt). A player is untouched -- turn them with lookAt. Fields: entity: the type id of the wearer's own body to set it on; left out, the wearer; within: blocks around the wearer to look for one (16); pick: which of them: the nearest to the mob, or any (nearest)", "thematic:notify": "A message on a player's action bar, for them alone: how the move went, to the wearer, or what it did, to the one aimed at. A mob is told nothing. Fields: message (required): a translation key, e.g. \"message.thematic.dracula.eyes_averted\"; text no translation has is shown as written; color: the colour of the whole line, e.g. \"red\" (none); who: whose action bar: the wearer's (default), or the one aimed at's -- inside targets(), or an item's on_hit victim; chat: in their chat instead of on the action bar, still for them alone (false); decimals: places the numbers in args are rounded to, trailing zeros dropped (2); args: what fills the line's %s in order: \"owner_name\" and \"target_name\" are those bodies' names, \"target_distance\" how many whole blocks off the one aimed at is and \"target_compass\" the compass point it lies toward (north, northeast...), a number or a worked-out one ({ tuned: \"damage\" }) is shown whole when it is, and any other text is shown as written", "thematic:pocket": "Sends the owner into a pocket dimension, or back out of the one they are in, to where they left it. Fields: mode: which way (exit); pocket: the pocket to enter, e.g. \"thematic:quantum_realm\"; needed for enter", "thematic:assemble": "Swaps the parts of a multiblock the block belongs to for its assembled blocks, with a spray of particles; nothing when the parts are not all there. Fields: multiblock: the multiblock's id, e.g. \"thematic:quantum_tunnel\"; incomplete: a translation key shown over the hotbar when the parts are not all there", "thematic:disassemble": "Swaps an assembled multiblock the block belongs to back for the parts the player placed. Fields: multiblock: the multiblock's id", "thematic:open_guide": "Opens the guide book for the owner, at the front page or on one entry or category. Fields: entry: an entry or category id, e.g. \"thematic:suits/superman\" (the front page)", "thematic:offline": "Takes a player offline, a suit or system crash: they cannot fly (they fall normally) or use any move but a passive, sparks and smoke come off them, and their screen fills with static, until it runs out. A stronger crash replaces a weaker one. Never creative or spectator players; a mob is not affected. Fields: ticks: how long, in ticks, capped by the server's configured maximum (60); intensity: how hard it hits, 0 to 1 (0.7); who: whose body: the one the move runs for (default), the one aimed at or hit, or the owner of the body the move runs for -- a summon's summoner; cause: a short word kept with the status (\"action\"); direct: in a hurt or damaged reaction: ignore a hit a summon passed on to its owner, so only a hit that struck the body itself counts (false)", "thematic:loadout_cycle": "Steps the wearer's selection along a loadout's row -- backward while they sneak -- through the slots their suit reaches and the free default, skipping empty ones, and names what it landed on. The row is the one the suit's loadout part for that inventory keeps; with none worn, nothing happens. Fields: inventory (required): the loadout's inventory, e.g. \"gadgets\"", "thematic:loadout_use": "Uses the item selected in a loadout, as the item's own use would (a thrown gadget), and starts the ability's tuned cooldown when it did. With the free default or an item that is cooling down, the switch named by auto_swap (when on) moves on to the next item that is not; after a use it steps the selection on the same way. Fields: inventory (required): the loadout's inventory, e.g. \"gadgets\"; auto_swap: the id of the ability's wheel switch that turns automatic swapping on; left out, it never swaps", "thematic:break_pattern": "Breaks blocks: one, a plane, a cube, a vein, a tree and its leaves, or a line -- each one only where the wearer may break it (claims, spawn protection, protected worlds; mobGriefing for a mob). Unbreakable blocks are left. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; pattern: what it breaks (single); radius: a plane's or a cube's reach from its centre: 1 is 3 across (1); orient: which way a plane lies (face) or a line runs (look); max: the most blocks a vein or tree breaks (64; a tree 256); leaves: a tree: leaves this far from each log are broken too (0); leaf_chance: a tree: the chance each of those leaves goes, 0 to 1 (1); drops: what the blocks drop (normal); fortune: with drops: \"fortune\", the Fortune level (3); harvestable_only: only blocks the wearer could harvest -- the right tool for ore (false); wear_chance: the chance, 0 to 1, each broken block wears the stack the action runs for by 1; the stack breaking stops the rest (0); tool: what it mines with, for the drops and harvestable_only: \"held\" -- the wearer's main-hand stack; an item id -- a fresh one of it; { nbt, fallback } -- the stack in either hand (main first) whose NBT holds each key (case and underscores aside) at one of its values, else a fresh fallback, else a bare hand. Left out, the stack the action runs for; tool_wear: with tool: each block broken wears the tool as mining it by hand would (never for a creative player); the tool breaking stops the rest (false); length: a line: how many blocks past the start block it runs, rounded down, 1 to 64; left out, the tuned radius; offset: a plane or a line: moved this many blocks along its direction (0); depth: a plane: how many planes deep it breaks, one behind the other along its direction (1); advance: a plane or a line: the start block and direction are found on its first run in the press and kept, and each later run goes one block further along -- a face mined deeper every beat (false); vein: a vein: what it is made of (corners); fall_through: where a block of the shape is air, the first block under it within this many is broken instead -- a floor under a slab gap (0); skip_block_entities: never breaks a block holding a block entity: a chest, a furnace, a spawner (false; a line ends there); drop_at: where the drops land (block); then: actions run once after, when it broke at least one block; the number broken is stored under count_key for them (and later steps) to read; count_key: the name the number of blocks broken is stored under, read by stored(name) or $name (broken); filter: only these blocks: ids and #tags (any, left out); except: never these blocks: ids and #tags; with_property: only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like", "thematic:place_blocks": "Places a block in a shape, where the wearer may build and only over what it may replace. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; block (required): the block id; properties: state properties to place it with, e.g. { layers: \"2\" }; replace: what it may take the place of (replaceable); chance: the chance each block is placed, 0 to 1 (1); lifespan: seconds after which each block placed turns back to air, if it is still there (0: stays); lasts: instead of lifespan: any worked-out number of seconds, e.g. the tuned duration; schedule_tick: seconds after which each block placed is ticked -- a melt or decay clock (0: none); max: with a lifespan: at most this many of this ability's blocks stay for their wearer, the oldest taken back first (0: no cap); shape: which blocks around it (single); radius: a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius; height: a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius); below: a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0); thickness: a ring: how many blocks thick its wall is, inward from the radius (1); top_radius: a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)", "thematic:transform_block": "Turns blocks into others by a map -- water to ice, lava to obsidian, fire to air -- or into the block the answered event broke or used, keeping the properties both share (a log's axis), where the wearer may build. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; map: what each block becomes: a block id or #tag to a block id; the first match wins. Needed unless to is given; to: instead of a map: each block the filter takes becomes the block the answered event broke or used; variant: with to: which form of the event's block goes in, by name -- the one with prefix in front of its path where the block replaced is when (an id or #tag), the one without it elsewhere; a form that is not registered is the block as it is. E.g. { prefix: \"deepslate_\", when: \"minecraft:deepslate\" }; pick: which of the blocks found it changes (all); only: what else a block must be to change (any); revert_after: seconds after which each block changed goes back to what it was, if what was put there is still there -- a crust that melts back (0: stays); keep_properties: copy the properties both blocks share (true); shape: which blocks around it (single); radius: a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius; height: a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius); below: a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0); thickness: a ring: how many blocks thick its wall is, inward from the radius (1); top_radius: a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall); filter: which blocks may change (any, left out; needed with to); except: never these blocks: ids and #tags; with_property: only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like", "thematic:place_layered_block": "Adds a layer to a layered block (snow, ice sheets), or starts one on top of the block when that is something else -- only where the wearer may build, both on the block and above it. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; block (required): the layered block's id; property: its layer count property (layers); max: the most layers it stacks to (the property's highest); schedule_tick: seconds after which the block is ticked -- a melt clock (0: none)", "thematic:ignite_block": "What fire does to a block it hits, where the wearer may build: a player's fire smelts what smelts, lights candles and campfires, melts ice and snow, and sets flame beside what burns; anyone else's only sets the flame beside the face. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor", "thematic:place_fire": "Places fire (soul fire on soul soil) in the air where fire can burn, where the wearer may build: in a shape around the block found, or in a line across the way the wearer faces. Fields: at: which block it starts from (hit, with face): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; chance: the chance each block catches, 0 to 1 (1); lifespan: seconds after which the fire goes out, if it is still there (0: burns on); lasts: instead of lifespan: any worked-out number of seconds, e.g. the tuned duration; block: this fire block (e.g. \"minecraft:soul_fire\") instead of the fire that suits the spot; footing: where the fire may stand (any); line: instead of a shape: a row across the way the wearer faces (across, facing), halfWidth (half_width in a file) blocks out to each side of the block found (rounded down; the tuned radius, left out) -- a wall of fire; shape: which blocks around it (single); radius: a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius; height: a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius); below: a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0); thickness: a ring: how many blocks thick its wall is, inward from the radius (1); top_radius: a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)", "thematic:light_area": "Lights the air around a point for a while -- sent only to the players who can see it, so nothing in the world changes and nothing is left behind. Fields: at: which block it starts from (pos): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; level: the light level, 0 to 15 (15); seconds: how long it stays lit; left out, the tuned duration; shape: which blocks around it (circle); radius: a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius; height: a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius); below: a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0); thickness: a ring: how many blocks thick its wall is, inward from the radius (1); top_radius: a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)", "thematic:power_block": "Presses a block as the wearer would (a button, a lever, a door) when it answers a press; otherwise powers it, or lights it, for a moment. Only where the wearer may build. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; interact: a player presses it first, as with an empty hand (true); seconds: how long it stays powered or lit (1)", "thematic:sit": "Seats the owner (a player) on the block as a seat block does: they ride the seat already there, or one spawned offset_y above the block's floor. Getting off, or any change to the block, stands them up. do runs once they sit. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; offset_y: how far above the block's floor a new seat is, in blocks (0; -0.2 sinks into the block); do: run once they sit", "thematic:drop_blocks": "Drops one vanilla falling block from above a random point within radius of the block found, when that spot is open air. Without place it vanishes where it comes down and drops nothing; with place it lands as a block where the wearer may build, and vanishes elsewhere. on_land runs where it came down either way: the air it came down in, on top of the ground, is the hit block, its centre the point. Fields: at: which block it starts from (self): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; blocks (required): the block, or blocks to pick one from at random (name one twice to drop it twice as often); radius: how far from the point, sideways, it may fall: a random spot in that disc (0); above: how many blocks over the point it starts, at most 64 (0); place: it lands as a block, the vanilla way, where the wearer may build (false: it vanishes); on_land: actions where it came down: the lowest air at or under where it was last seen, within 6 blocks. There the spot is that point (targets with at: \"spot\" finds who it fell on); the press's stored numbers are not carried", "thematic:till": "Tills the block: grass, dirt paths and dirt to farmland; coarse and rooted dirt to dirt. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; wear: durability the stack the action runs for loses when a block changed (0); sound: the tool's sound on each block changed (true); shape: which blocks around it (single); radius: a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius; height: a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius); below: a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0); thickness: a ring: how many blocks thick its wall is, inward from the radius (1); top_radius: a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)", "thematic:flatten": "Flattens the block into a path: grass, dirt, mycelium, podzol, rooted and coarse dirt. A block used from underneath is left alone. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; wear: durability the stack the action runs for loses when a block changed (0); sound: the tool's sound on each block changed (true); shape: which blocks around it (single); radius: a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius; height: a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius); below: a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0); thickness: a ring: how many blocks thick its wall is, inward from the radius (1); top_radius: a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)", "thematic:strip": "Strips a log or wood to its stripped form, keeping its axis: vanilla's, other mods' and Thematic's own. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; wear: durability the stack the action runs for loses when a block changed (0); sound: the tool's sound on each block changed (true); shape: which blocks around it (single); radius: a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius; height: a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius); below: a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0); thickness: a ring: how many blocks thick its wall is, inward from the radius (1); top_radius: a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)", "thematic:trim_plant": "Stops a growing stem (kelp, vines, weeping and twisting vines) from growing further, as shears do. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; wear: durability the stack the action runs for loses when a block changed (0); sound: the tool's sound on each block changed (true); shape: which blocks around it (single); radius: a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius; height: a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius); below: a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0); thickness: a ring: how many blocks thick its wall is, inward from the radius (1); top_radius: a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)", "thematic:shear": "Shears the entity inside targets() -- a sheep, a mooshroom, a snow golem -- if it can be sheared. Fields: wear: durability the stack the action runs for loses when it sheared (0); bonus: a sheep drops its wool again a random number of times, least to most, e.g. [1, 2]", "thematic:cycle_block_property": "Steps one of the block's state properties to its next value (a door's facing, a rail's shape), or picks which one the next step turns. The pick is remembered per block in the stack the action runs for; with none picked, a facing, axis or side property goes first. Tells a player what changed, above the hotbar. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; mode: (auto); property: with mode: \"value\", always this property; reverse: with value or select: step backward (false); exclude: properties it never touches ([\"age\", \"moisture\", \"stage\"]: stepping those force-ages crops and dries farmland); selection_key: the stack's compound the picks are kept in (selected_property); feedback: tell a player what changed (true); wear: durability the stack loses when it worked (0); sound: a click when it worked (true); filter: only these blocks: ids and #tags (any, left out); except: never these blocks: ids and #tags; with_property: only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like", "thematic:pull": "Draws the entity hit -- or, with radius, every living body within it but the owner -- toward a point: each pull adds strength along the line to it. Once, now; or with for, every tick from the next for that long, stopping when either end is gone or the body is within stop_within. Loose items too, with items. Fields: toward: owner (default), source, here or spot; strength: velocity added per pull along the line (0.05); a harpoon's reel is 5; radius: pulls every living body within this many blocks of the action but the owner -- friend and foe, as a magnet does; left out, only the entity hit; for: seconds it keeps pulling, every tick from the next; left out, one pull now; stop_within: with for: stops once the body is this close to what it is pulled to (0: never early); brake: with stop_within: on arriving, also drops the sideways speed the pull built up (false); jitter: up to this much more at random on each axis, every pull (0); a magnet's is 0.5; anchor_height: the owner or source is pulled to at this share of its eye height (0: its feet); max_rise: the most upward speed (blocks a tick) the pull gives the body: its lift is trimmed so the reel never carries it up past this, however long it runs (left out: no cap); point: the point of the body pulled from, feet (default) or center; beam: a beam drawn from the point to the body on each pull; items: also drags loose items within radius (a magnet's is { tuned: \"radius\", times: 12 }) by strength (0.2), and gives a player owner any that come within pickup_within of the point (0: none)", "thematic:stack_effect": "A status effect that builds up: put on fresh when the body has none, otherwise the running one grows longer -- and stronger, by steps or by levels of length -- and every client is told. Fields: effect (required): the status effect id, e.g. \"thematic:frozen\"; who: target (default: the entity hit, or the one inside targets()) or self; duration: fresh: seconds; left out, the ability's tuned duration; amplifier: fresh: 0 is level I; left out, the tuned amplifier; add: running: seconds added (0); add_random: running: up to this many seconds more at random, drawn in whole ticks (0); max_duration: running: the longest it grows to, in seconds; amplifier_add: running: added to its amplifier (0); max_amplifier: running: the highest amplifier amplifier_add reaches; levels: running: the amplifier from the new length instead -- the highest step whose at_least (seconds) it reaches; none reached keeps the running one; by: levels this gain adds, whole, 1 or more; the effect's own \"stack\" ({ max_level, hold }) supplies the cap and the clock, so it replaces duration, amplifier, add, amplifier_add, max_amplifier, max_duration and levels; hold: with by: seconds this gain holds the effect, instead of the effect's stack.hold; gain_every: running: seconds between the level rising on one body; hits in between still put the length back but add no level (0: every hit adds); gain_clock: the name of that clock; stacks sharing a name share it (the effect's id); gain_shared: who shares the clock on one body: owner_group (default: the owner and everything it owns, so a hive's five beams gain once), source or anyone; ambient: the faint beacon-style swirl (false); show_particles: false hides the effect's particles (true); show_icon: false hides the HUD icon (true; off for a stacking effect the HUD's readout shows)", "thematic:air": "Adds breath to a body, or takes it: a drowning hit. Fields: amount: ticks of breath added; negative takes (-1); who: target (default) or self", "thematic:press_random_ability": "Presses one of a player's own moves for them, at random: any that could be pressed now, never an ultimate unless ultimates says so. A toggle picked is switched on. Fields: who: target (default: the player hit) or self; ultimates: ultimates may be picked too (false); skip_running: leaves out a move already running (false)", "thematic:command_pets": "Every animal tamed to the owner within range stands up and obeys: attacks the entity hit, rallies where the action happens, or comes back to the owner. Fields: command (required): attack, rally or recall; range: how far from the owner an animal still hears it, in blocks (48); entity_type: only animals of this type, e.g. \"minecraft:wolf\"; tag: only animals carrying this command tag; speed: how fast they go (1.3 to rally, 1.2 to recall); do: more at each animal, as inside targets()", "thematic:glow_mark": "Marks the entity hit -- or everyone within radius but the owner and the owner's animals -- in the owner's name, for a time, with a glow: an expiry and the owner's UUID in the body's persistent data. The mark verb (thematic:mark) under its first name; only its owner key's default differs. Fields: key: the persistent data key the mark's expiry is kept under (\"mark\"); owner_key: the key the owner's UUID is kept under (_owner); for: seconds; left out, the ability's tuned duration; keep_longer: never shortens a mark already there (false); glow: a hidden Glowing effect as long as the mark (true); seen_by: who sees the glow: everyone (\"all\"), or the owner alone, through walls (\"owner\"); vfx: a VFX preset played at the body's feet, sized to it, when the mark is new; radius: marks everyone in this box around the action; left out, only the entity hit", "thematic:deflect_projectile": "Turns a projectile back -- the entity hit, or the one a projectile_incoming reaction answers -- and makes it the wearer's. Fields: direction: reverse (default), look or shooter; own: the wearer becomes its owner, so what it hits on the way back is theirs (true)", "thematic:catch_projectile": "Takes a projectile -- the entity hit, or the one a projectile_incoming reaction answers -- out of the world; an arrow or spectral arrow that could be picked up goes into the wearer's inventory. Fields: give: hand over the arrow item when it could be picked up (true)", "thematic:absorb_projectiles": "Takes every projectile within reach of the wearer's middle out of the world -- and one that would cross into it before the next tick, so a fast bullet doesn't slip through -- unless the wearer or a teammate shot it; clients see where each was absorbed, so a shield there ripples. Run every tick for a wall projectiles don't get through. Fields: within: how far from the wearer's middle, in blocks (2); pane: a flat plate instead of the sphere: it takes projectiles that cross it from either face", "thematic:reset_fall_distance": "A body forgets how far it has fallen, so its landing does not hurt. Fields: who: self (default) or target", "thematic:capture_entity": "Stores the entity hit in the owner's holder item and removes it from the world. Never a player or the owner; where the owner may not grief it is refused with a message. Resets the item's cooldown. Fields: item: the holder item's id; left out, the item that fired (a net arrow's own); inventories: the owner's inventories searched after the hands, in order, before the main inventory ([\"quiver\", \"gadgets\"]); key: the NBT key the entity is kept under in the holder (\"StoredEntity\"); when_full: nothing (default) or release; discard_source: also removes what did it -- the arrow -- when something was caught or let out (false); deny_message: the translation key shown on the owner's action bar when they may not capture there (\"message.thematic.cant_capture\")", "thematic:release_entity": "Lets the entity the owner's holder item stores out where the action happens, and empties it. Fields: item: the holder item's id; left out, the item that fired (a net arrow's own); inventories: the owner's inventories searched after the hands, in order, before the main inventory ([\"quiver\", \"gadgets\"]); key: the NBT key the entity is kept under in the holder (\"StoredEntity\"); up: blocks above where the action happens (0); 1 on a block hit stands it on the block; discard_source: also removes what did it -- the arrow -- when something was caught or let out (false)", "thematic:throw_held": "Throws the stack the actions run for (an item hook's), else the owner's main-hand item from the owner's eyes along their look, as a throwables definition or an entity, and takes what it threw from the stack outside creative: one, or with count a fan of several at once. Its do runs aimed at each thing thrown. Fields: throwable: a throwables id it flies as; or entity; entity: an entity type id it flies as; or throwable; velocity: launch speed (2); divergence: vanilla's spread (0.5); consume: takes what it threw from the stack outside creative (true); sound: a sound played as it leaves, once however many are thrown; count: how many at once (1): a number, or as many as the stack holds up to max (the thrown cards: { from_stack: true, max: 3 }); spread: with more than one: the degrees the outermost throws turn off the look, the rest even between (10: three at -10, 0 and 10); clip: the thrower's clip as it throws (players): one for either arm, or by the arm the stack is in -- right for a stack in the right hand, left for the left; do: run aimed at each thrown entity", "thematic:stop_using": "The body lets go of the item it is using, as a released key does (the item's release runs): a drill out of charge stops. Nothing when it is using none. Fields: who: the owner (default), or the one aimed at", "thematic:riptide": "Launches the owner (a player) as a Riptide trident does, and puts the stack's item on cooldown. Fields: level: the Riptide level: 1 to 3 as vanilla's, stronger above; left out, the stack's own Riptide, else 3; keep_horizontal: pushes along the heading without the pitch shortening it, as Aquaman's trident did (false); cooldown: seconds the item cools down after (2)", "thematic:enchant_held": "Keeps enchantments on the stack the actions run for (an item hook's), else the owner's main-hand item: when it lacks one (or has it at another level) they are put on, after taking every other enchantment off unless replace is false. Fields: enchantments (required): enchantment ids and levels, e.g. { \"minecraft:sharpness\": 8 }; when: picks enchantments when it holds, otherwise when it does not; otherwise: with when: the enchantments while the guard fails; replace: takes the stack's other enchantments off first (true)", "thematic:item_cooldown": "Puts an item on the owner's cooldown, as an ender pearl is: the stack's, or item. Fields: seconds (required): how long; item: another item id to cool down instead", "thematic:trigger_item_anim": "Plays a triggerable GeckoLib clip on the stack the actions run for (an item hook's), else the owner's main-hand item, for every client. Fields: controller (required): the controller's name, e.g. \"Hammer\"; clip (required): the clip's trigger name, e.g. \"twirl\"; hand: with no stack of the hook's own: main (default) or off", "thematic:use_ability": "Presses one of the owner's kit abilities by id, as its key would: a press presses, a toggle flips, a hold starts. A disabled or dampened ability is refused as the key is. Fields: ability (required): the ability id, e.g. \"hammer_throw\"", "thematic:wear": "Takes durability off the stack the actions run for (an item hook's), else the owner's main-hand item, breaking it with the usual sound when it runs out. Fields: amount: (1)", "thematic:stack_strike": "A stack strikes the target inside targets(), or what a thrown body hit: the item's own hit (a data construct's on_hit), then the main-hand attack damage its modifiers add, as the owner's mob attack. The stack is the one a thrown body carries (thrown_item, or a projectile that carries one), else the stack the actions run for (an item hook's), else the owner's main-hand item.", "thematic:consume_gauge": "Spends an ability's charge (a lantern's power): do runs when there was enough, else when there was not (and nothing is spent). Fields: amount (required): how much; ability: the charge ability's id; left out, the first charge ability of the owner's kit; do: run when it was spent; else: run when there was not enough", "thematic:refill_gauge": "Fills an ability's charge (a lantern's power) back up to its most, as a power battery does; the charge tells the player how it went. do runs when it filled, else when it was already full or there was no charge. Fields: ability: the charge ability's id; left out, the first charge ability of the owner's kit; do: run when it filled; else: run when it was full, or there was no charge", "thematic:take_held": "Takes some of what the owner holds, outside creative: the ingredient a block is repaired with. Nothing when the hand is empty. Fields: count: how many (1); a smaller stack gives what it has; hand: the hand it takes from (main)", "thematic:stack_state": "Changes one key of the stack the actions run for (an item hook's), else the owner's main-hand item's own state: its counters, flags, gauges and timers, which the guards stackCounter, stackFlag, stackGauge and stackTimer read. Fields: key (required): the name the value is kept under; op (required): what to do to it; value: add_counter / add_gauge: how much (1); set_counter / set_gauge: the value (0); wrap: add_counter: wraps back to 0 on reaching this (0: never); min: gauges: the lowest it goes (0); max: gauges: the highest it goes (no limit); seconds: start_timer: how long it runs", "thematic:wave": "A ring spreading out from a centre over the ground, on the server's clock once it goes off: every `every` seconds, starting at once at radius 0, it runs do on everyone whose feet are within band of its front, measured straight from the centre, and no more than height above or below it -- while its radius is under maxRadius. Lightning Boom's ring: {from: \"self\", speed: 2.4, maxRadius: 96, band: 3, height: 2.125, once: false}. With along it is a front running out along a line instead, from the wearer's eyes (or the spot), out to maxRadius or the first block in the way, running do on everyone it passes within width of the line: Caped Colony's line of bats, {along: \"look\", speed: 0.8, maxRadius: 20, width: 1.2, vfx: \"thematic:bat_stream\"}. Fields: from: the centre (start); a line can't run from self; along: makes it a line running this way instead of a ring; width: a line's reach either side of it, in blocks, from the edge of each body (1); vfx: a VFX preset carried with a line's front, or played at a ring's centre, for as long as the wave runs; speed: blocks the front runs a tick (1); max_radius: it stops once its radius reaches this (the tuned radius); band: a ring's: how far inside or outside the front still counts, in blocks (1); height: a ring's: how far above or below the centre it reaches, in blocks (1); once: each body only the first time the front passes it (true); every: seconds between pulses (0.05: every tick); hittable: only those the wearer may hit (true); do: run on each one the front passes, aimed at them", "thematic:after": "Runs do a little later, on the same context -- inside targets(), on the same target, which must still be alive then (unless survive), as must the wearer. Keeps running on the server's clock whatever the press does meanwhile. Fields: seconds (required): how long to wait; survive: run even when the target has died by then (false); do: what to run once the time is up", "thematic:command": "An order to the wearer's own mobs. Which of the wearer's mobs: select (owned: every mob tamed to them or naming them as its owner; companions: only the companion, tagged thematic_companion), types, tag and link narrow it, radius is how far from the wearer (48); with link, radius 0 finds the linked one wherever it is loaded in the wearer's world. else runs when attack finds nothing to go for, or when the wearer has none of those mobs: command(\"attack\", { at: [\"nearest_marked\", \"aimed\"], types: \"wolf\" }). Fields: order (required): what they do; at: attack, expend and use: what they go for, a list tried in order (target; expend and use left without it go for the target the action is aimed at, else their own); range: attack, expend and use: how far aimed and nearest_marked look (the tuned radius); seconds: gather and offline: how long it lasts (3); share: expend: the share of its own damage it goes off for (1); move: use: the id of the move it fires, one of its kit; spread: use: how far off its target it aims, in degrees either way (0); idle_only: attack: only those not already fighting something alive (false: every one turns); mob: aimed: the one mob the action is aimed at takes the order -- each of the wearer's mobs inside ownedMobs(), a villager inside targets() -- instead of the ones the filter finds; speed: follow, tempt and rally: how fast they go (1.2; tempt 1.25, rally 1.3); stop_at: follow and tempt: they stop this close to the wearer, in blocks (2; tempt 2.5); reach: fetch_items: how far from each mob a drop is noticed (the tuned radius); handover: fetch_items: a mob this close to the wearer hands over what it carries (6); carry: fetch_items: a drop this close to a mob counts as carried (2); pull: fetch_items: blocks a tick a drop is pulled toward its mob (0.35); beyond: fetch: how far off one has to be to be brought (40); select: which of the wearer's mobs (owned); types: only these entity types; \"#tag\" for a tag, a bare id is minecraft's; tag: only those carrying this command tag (\"thematic_pack\"); link: only the one whose id the wearer keeps under this data key; radius: how far from the wearer they may be (48); else: what happens when there is nothing to go for or nobody to tell", "thematic:tame": "Tames the target the action is aimed at to the wearer -- a wild wolf, cat or parrot, a horse -- healing it first. Anything already tamed, dead or that can't be tamed runs else instead. Fields: heal: health it gets back first (0); else: what happens when it can't be tamed", "thematic:breed": "Puts the target the action is aimed at into love mode for the wearer, as if fed its food: a grown animal that is ready to breed, then runs do. A young one, one already in love or cooling off, or anything else runs else instead. Fields: do: what happens once it is in love; else: what happens when it can't breed", "thematic:attract": "Draws what lies within radius toward the wearer: items and experience through the air, to be picked up; animals walk over, unless already walking somewhere. Fields: kind (required): what it draws; filter: items: item ids or \"#tag\"s; animals: entity type ids or \"#tag\"s (everything); radius: how far (the tuned radius); speed: items and xp: blocks a tick they're pulled (0.35); animals: how fast they walk (1.25); settle: left alone this close to the wearer, in blocks (1.5; animals 2.5); babies: animals: young ones come too (false)", "thematic:owned_mobs": "Runs do at each of the wearer's own mobs, aimed at it as targets() aims at each one it picks -- buffs for the pack, a heal for the companion -- or else once when there are none: ownedMobs(\"owned\", { types: \"wolf\" }, wolf => wolf.effect(\"minecraft:strength\", { duration: 1.5, amplifier: 1 })). Which of the wearer's mobs: select (owned: every mob tamed to them or naming them as its owner; companions: only the companion, tagged thematic_companion), types, tag and link narrow it, radius is how far from the wearer (48); with link, radius 0 finds the linked one wherever it is loaded in the wearer's world. Fields: select: which of the wearer's mobs: owned or companions; types: only these entity types; \"#tag\" for a tag, a bare id is minecraft's; tag: only those carrying this command tag (\"thematic_pack\"); link: only the one whose id the wearer keeps under this data key; radius: how far from the wearer they may be (48); pick: which of them: all, nearest, first or random (all); do: what happens at each one, aimed at it; else: what happens once when the wearer has none", "thematic:unlink": "The wearer forgets the id kept under a link key -- a summon's link -- whether or not the mob is still there: what a companion's death leaves to tidy. Fields: key (required): the data key, e.g. \"companion_wolf_uuid\"", "thematic:quarry": "Breaks the matching blocks around a point, working outwards -- each only if the wearer's own tool could harvest it (a mob: only blocks that need no tool) and they may break it there -- and drops what they held at the wearer's feet. Extra Fortune goes on a copy of the held tool; the real one is not touched. Fields: at: which block it starts from (self): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; radius: how far out it reaches, rounded, at most 32; left out, the tuned radius; max: the most blocks it takes (64); fortune: Fortune levels added to the tool for the drops (0); filter: the blocks it takes (#thematic:quarry_ores, left out); except: never these blocks: ids and #tags; with_property: only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like", "thematic:find_block": "Finds the matching block nearest the point, in the cube radius around it: fixes it as the spot (at: \"spot\" later in the same press), stores it under key for a visual, and tells the wearer with notify. do runs at each matching block, working outwards. Nothing found: nothing happens, and required calls the list off. Fields: at: which block it starts from (self): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; radius: how far out it looks, rounded, at most 32; left out, the tuned radius; max: the most blocks do runs at (64); do: actions at each matching block: the block is the hit, its centre the point; key: store the block's centre on the wearer, synced, under this key (as markSpot does); required: nothing found calls the rest of the list off; miss_cooldown is the share of the cooldown that still costs; notify: a line on the wearer's action bar: a translation key or plain text, with %1$s the block's name and %2$s the compass word (north, northeast, ...) toward it; all: a sweep, not a search: do runs at every matching block in the cube, however many, and nothing is fixed as the spot, stored or told -- a glow on every ore in reach (false; takes no max, key, required or notify); filter (required): what it looks for: block ids and #tags; except: never these blocks: ids and #tags; with_property: only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like", "thematic:replant": "A grown crop that was just broken goes back as a seedling, paid for with one of its own seeds from the drops lying around it, where the wearer may build. Answers block_broken; outside it, the block hit. Fields: radius: how far around the block the drops are looked for (1.5); filter: the blocks it replants (every crop, nether wart and cocoa, left out); with a filter, any matching block with an age, grown at its highest; except: never these blocks: ids and #tags; with_property: only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like", "thematic:collect_drops": "Brings the items lying around the block -- the event's, or the block hit -- to the wearer's feet (or the spot), still, ready to be picked up at once. Fields: radius: how far around the block the items are looked for (1.5); to: where they go (wearer)", "thematic:extra_drops": "Rolls the block's drops again -- the block the event broke, or the block hit -- with the wearer's main-hand tool, for more of them where it stood. Fields: rolls: how many more times it drops (1); above_same: only a block that stood on the same block pays: the part of a stalk (sugar cane, bamboo) that grew, not the planted base (false); filter: only these blocks (any, left out); except: never these blocks: ids and #tags; with_property: only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like", "thematic:use_item_on": "Uses an item on a block as if the wearer held one -- bone meal grows what it grows, flint and steel lights what it lights -- where they may build. The held stack is not touched. Fields: at: which block it starts from (look): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; item (required): the item id; consume: a use that took calls off the use_block it answers, so the block and the held item don't react too (true)", "thematic:light_trail": "One tick of a trail of light following the wearer: a light in the air where they stand (or the nearest air), a new one each time they move on, the newest few kept, each gone lasts seconds after it was put down. Sent only to the players who can see it; nothing in the world changes. Run it every tick while it should glow, and with stop once it should not. Fields: level: the light level, 0 to 15 (15); max: the most lights kept at once; the oldest goes first (6); lasts: seconds each light stays after it was put down (4.5); stop: take every light down now, and forget the trail (false)", "thematic:meter": "One change to a meter kept on the wearer (declared by a meter part; a key nothing declared is a plain amount with no cap): add, consume (a spend, only when what is left keeps the reserve), cost (the same, but not being able to pay calls off the rest of the list), set, refill (to its max) -- or, for a window, open and close. A failed consume, cost or refill says fail_message. meter(\"green_ringCharge\", { cost: 40, failMessage: \"Not enough green!\", failChance: 0.05 }); meter(\"pact_momentum\", { open: { for: 1.5, onRefresh: \"bank\" } }). Fields: key (required): the meter's key; add: added, up to its max; negative takes it away, to nothing; consume: spent when it can be paid, keeping the reserve; a window is spent whole; cost: as consume, and not being able to pay calls off the rest of the list; set: set, between 0 and its max; a window: opened for that many seconds, or closed at 0; refill: true: filled to its max; full already counts as failing; open: a window: opened, or -- already open -- banked, bled or refreshed as its on_refresh says; close: true: a window dropped without spending it; an amount emptied; who: whose meter: the wearer's (self), or the target the action is aimed at; fail_message: said on the wearer's action bar when a consume, cost or refill fails: a translation key or text; fail_chance: the share of failures that say it (1); a lantern ring said it one time in twenty; color: the message's colour, a formatting name", "thematic:meter_spend": "Spends a window whole -- the only way to, and it always closes -- and lets the openings banked into it as $charges (0 when nothing was open), for the rest of the list: meterSpend(\"pact_momentum\", { keepOwn: true }) then if({ ... }) on \"$charges\". Spend only after the move has committed, or a press that did nothing eats the window. An amount is spent down to its reserve, and $charges is what was taken. Fields: key (required): the meter's key; store: the name what was spent is let as (charges); keep_own: true: a window this ability opened itself is left alone, and 0 is let (false); required: true: nothing to spend calls off the rest of the list (false)", "thematic:drive_meter": "Run every tick: an amount meter fills over fill seconds while a watched move is active and drains at drain times that speed otherwise -- a cooldown that builds while a move runs. driveMeter(\"cooldown_fill\", { watchOption: \"watches\", fill: 5, endAtFull: true }). Fields: key (required): the meter's key (an amount); fill (required): seconds a full run takes; watch: the move whose active state drives it (this move); watch_option: instead, the suit option that names that move's id; drain: how fast it drains while the move is off, as a multiple of the fill speed (1); 0 holds it; end_at_full: true: a full meter switches the watched move off (false)", "thematic:vfx": "Plays a VFX preset (a vfx/.json file) where the action happens: at the target inside targets(), the wearer otherwise. vfx(\"thematic:circle_ring\") plays it as the file says; to points it at somewhere and makes it as long as the gap (a ray, a blink's trail), direction points it a way keeping its own length, radius and height resize it. With a session it is held (a hold or loop preset) until vfx(id, { session, stop: true }). The old upper-case names work as ids (\"SONAR_BEAM\" is thematic:sonar_beam). Fields: id (required): the preset's id, e.g. \"thematic:dome\"; at: here (default): where the action happens; spot: the point markSpot fixed; from: a point on the wearer's body to start from instead; forward: blocks along the wearer's look to move the start (0); anchor: how high up the body it starts, as a fraction of its height (feet); not with from; to: points it from the start at the wearer's feet, the body the action is aimed at, or the marked spot, as long as the gap; nothing plays when there is no such place; direction: points it along the wearer's look, straight up, or a fixed way, keeping the preset's length; not with to; radius: replaces the preset's radius (blocks), a number or a worked-out one; left out, the preset's; height: replaces the preset's height (blocks): an axial shape's length; duration: replaces how long it hangs, in seconds (the preset's own, which its file gives in ticks); at least a tick: vfx(\"thematic:pyre_ring\", { radius: 8, duration: 1.2 }) for a bigger, slower ring; session: holds the effect under this name, one per wearer, until a vfx with stop; a new start under the same name replaces it. A particle-system preset has no session and plays once; stop: ends the effect held under session instead of playing anything; layers: a fog_layers preset's bank count (replaces the preset's); wisps: a fog_layers preset's rising wisps (replaces the preset's); fade_in: a fog_layers preset's fade-in, in seconds (replaces the preset's); fade_out: a fog_layers preset's thinning-out, in seconds (replaces the preset's); hand: a rope preset only: the line starts at that fingertip of the wearer as the arm is posed this frame, running on to where it was thrown, instead of starting at the point; follow: carries it along with the wearer or the body the action is aimed at, keeping its place beside them, while they are in sight; a bat_swarm flock heads the way they go; color: replaces the preset's colour: \"#AARRGGBB\" (alpha first) or \"#RRGGBB\" (opaque), e.g. vfx(\"thematic:circle_ring\", { color: \"#999DB7FF\" }) for a pale blue-violet ring; density: replaces the preset's density: its particles, a fractal_bolt's stretches, a fork_wall's bolts, a fork_burst's spokes (a quarter of it), a fork_cloud's puffs", "thematic:shake": "Shakes the camera of every player within radius of where it happens -- the target inside targets(), the spot with at: \"spot\" -- easing out over duration, harder the nearer they stand (a quarter as hard at the edge): shake({ at: \"spot\", radius: 16, strength: 2, duration: 0.6 }) for a slam landing. Fields: radius: blocks it reaches; left out, the tuned radius; strength: degrees the view jolts at the centre (1.5); duration: seconds it takes to settle (0.5); at: here (default): where the action happens; spot: the point markSpot fixed; from: a point on the wearer's body to centre it on instead; forward: blocks along the wearer's look to move the centre (0); style: classic (default): the older jitter; trauma: smooth noise that swells with trauma squared and fades exponentially, yaw, pitch and roll plus a trace of drift; rumble: a long low swell in and out. Scaled by the player's Distortion Effects setting. With any of style, direction, kick or to, trauma is the default; direction: none (default); away: also kicks the view away from where it happens, springing back; hit: for duration seconds (10) every hit the player takes kicks the view away from where it came from (nothing shakes now); kick: degrees of the direction kick (1.2 times strength); to: shake only this player's screen, at full strength, instead of everyone within radius: the wearer, or the body the action is aimed at", "thematic:hitstop": "A visual freeze of 30 to 120 ms, for a landed hit or a grab: the picture holds and then melts back, while the game itself keeps running (nothing is paused or delayed). At most one every quarter second. Fields: duration: seconds, 0.03 to 0.12 (0.07); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:fov_punch": "The field of view kicks by delta degrees and springs back, with no overshoot: negative narrows it (a grab, a pull in), positive widens it (a shockwave). Scaled by the player's FOV Effects setting. Fields: delta: degrees, -25 to 25 (4); duration: seconds it takes to settle (0.45); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:screen_flash": "A flash of colour over the screen that peaks at once and falls off exponentially in a few frames, never held and never fully opaque. Skipped for players who hide lightning flashes, and softened by the reduced-flash setting; at most three a second. Fields: color: \"#RRGGBB\" or 0xRRGGBB (white); black makes a cut; alpha: peak opacity, 0 to 0.85 (0.55); duration: seconds until it is gone, 0.05 to 0.4 (0.12); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:overlay": "A texture, or a flat colour, laid over the screen for a while to one player, easing in and out and optionally throbbing. (The ability visual thematic:screen_overlay is the always-on-while-active form.) Fields: texture: a texture id, e.g. \"thematic:textures/overlay/vignette.png\" (this or color is needed); color: a flat fill in this colour when there is no texture; alpha: opacity at its fullest, 0 to 1 (0.5); duration: seconds in all, the fades included; 0 keeps it until screenClear() (2); fade_in: seconds easing in (0.25); fade_out: seconds easing out (0.6); pulse: throbs between min and max (0.35, 1) times its opacity every period seconds (1.2, at least 0.6); heartbeat is a lub-dub; blend: normal (default), or add to brighten what is behind it; to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:grade": "Grades the colour of the world -- not the HUD -- eased in and out: desaturate it, optionally keeping one hue in colour (grade({ keepHue: \"red\" }) for a grey world with red left in it), with contrast, a tint and lifted shadows. A new grade while one runs glides into it. Fields: desaturate: 0 to 1, how much colour is drained (0.6); keep_hue: a hue left in colour: red, orange, yellow, green, cyan, blue, purple, magenta, pink, a number of degrees or \"#RRGGBB\" (none); hue_width: degrees either side of keep_hue that stay in colour, edges softened (30); contrast: -0.5 flatter to 1 harder around mid grey (0); tint: a colour the picture is washed toward (none); tint_amount: 0 to 1, how far toward tint (0.15); lift: 0 to 0.3, how far the darkest parts are raised toward grey (in the tint's colour, when there is one) so shapes stay readable in the dark (0); duration: seconds in all, the fades included; 0 keeps it until screenClear() (3); fade_in: seconds easing in (0.8); fade_out: seconds easing out (1.2); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:letterbox": "Black cinema bars at the top and bottom of the screen that ease in to a height and back out. Fields: height: each bar's height as a share of the screen, 0 to 0.3 (0.11); duration: seconds in all, the fades included; 0 keeps them until screenClear() (3); fade_in: seconds easing in (0.7); fade_out: seconds easing out (0.7); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:fog": "Closes the view in with fog to a distance, optionally toward a colour, eased in and out; never further out than the world's own fog, and left alone underwater and in lava. A new fog while one runs glides into it. Fields: end: blocks where the fog is solid (20); start: blocks where it begins (a quarter of end); color: the fog's colour; left out, the world's own; color_amount: 0 to 1, how far the fog colour replaces the world's (0.8); duration: seconds in all, the fades included; 0 keeps it until screenClear() (3); fade_in: seconds easing in (1.5); fade_out: seconds easing out (2); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:muffle": "Ducks the game's audio -- everything but interface sounds -- smoothly, as if heard through a wall. (A volume duck, not a filter.) Fields: amount: 0 to 0.88, the share of the volume taken away (0.6); duration: seconds in all, the fades included; 0 keeps it until screenClear() (3); fade_in: seconds easing in (0.25); fade_out: seconds easing out (0.8); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:film_grain": "Animated film grain over the world, with optional scanlines and static. Slowed and softened for players with the reduced-flash setting. Fields: amount: grain strength, 0 to 1 (0.25); scanlines: 0 to 1 (0); static: 0 to 1 (0); duration: seconds in all, the fades included; 0 keeps it until screenClear() (3); fade_in: seconds easing in (0.8); fade_out: seconds easing out (1); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:screen_look_at": "Draws the player's look round to a point, smoothly, on their own client (no rotation packet from the server): it eases onto the point, holds there, and is let go. At strength 1 the player cannot turn away from it while it holds; below 1 the pull only takes the view that share of the way and lets their own turning through. Their look stays where it was drawn when it is let go. A new screen_look_at while one runs glides to the new point. Fields: at: the point (anchor); up: blocks added above the point (0): the top of a block rather than its middle; strength: 0 to 1, how far the pull takes the view and how hard it holds (1); duration: seconds in all, the eases included; 0 keeps it until screenClear() (3); ease_in: seconds turning onto the point (0.8); hold: instead of duration: seconds held on the point, the eases added to make the total; ease_out: seconds letting the player's own turning back in (0.8); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:cinematic_hud": "Hides the whole HUD (hotbar, health, crosshair, boss bars, chat, effect icons, ability HUDs) like F1 for a cinematic beat, then restores it. The screen effects (bars, flashes, overlays, grade, grain) keep drawing. Ended by screenClear(), death or a disconnect. Fields: duration: seconds in all, the fade included; 0 keeps it until screenClear() (3); fade: seconds the HUD stays hidden through at either end (0.4); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:disorient": "A drunken sway of the view: the head rolls and nods slowly, the field of view breathes, and the sound goes dull (ringing), easing in and out. Softened for players with the reduced-flash setting. Fields: amount: 0 to 1, how far the view sways (0.7); muffle: 0 to 0.88, how dull the sound goes; 0 leaves it to muffle() (0.8 times amount); duration: seconds in all, the fades included (3); fade_in: seconds easing in (0.3); fade_out: seconds easing out (1.2); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:screen_splat": "Gobs of sticky mass flung onto one player's screen from its edges -- irregular blobs, thick in the middle, joined by stringy tendrils, heaviest across the lower half -- held, then sliding down in drips as they fade: a face full of webbing, goo or mud. Drawn, not a texture, and different every time. Fields: color: \"#RRGGBB\" or 0xRRGGBB (0xF2F2EE, wet white); alpha: the gobs' opacity, 0 to 1 (0.95); coverage: how much of the screen they cover, 0.05 to 1 (0.7); count: how many gobs, 1 to 9 (6); duration: seconds held before they start to go (1); fade_out: seconds sliding and fading away (1.5); drip: how far they slide down as they go, 0 to 1 (0.6); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:screen_jolt": "Jagged lines jolting in from one player's screen edges, flickering and re-jagging, pulsing a few times over its length and thickest on the side a threat lies: a sense of danger, a static shock. With from, it says where: screenJolt({ from: \"target\" }) inside a targets() body gathers them toward that body. Fields: color: \"#RRGGBB\" or 0xRRGGBB (white); alpha: their opacity at the peak of a pulse, 0 to 1 (0.85); count: how many lines, 4 to 40 (18); reach: how far in from the edge they reach, as a share of the screen, 0.05 to 0.6 (0.22); duration: seconds in all (1); pulses: how many times they flare over the duration, 1 to 8 (2); from: where they gather: the body the action is aimed at, or where it happens (every edge alike); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:screen_clear": "Eases out a sustained screen effect early, or all of them (and any freeze) at once. Fields: effect: which one (all); fade: seconds to ease out (0.8); to: whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen", "thematic:drain": "Wears a body's health down in steps, from what it is when this runs toward a floor, and never past it: direct health, no damage (no flinch, no armour), and never below half a heart, so it cannot kill. A body already at or under the floor is left alone. On a player each step throbs a red vignette. A second drain on the same body replaces the first. Fields: to: whose health: the wearer's (default), or the body the action is aimed at; floor: display units, what the action bar shows (1000 is a full bar): the level it will not go under (100); duration: seconds from the start to the floor (6); every: seconds between steps (0.5); pulse: throb a red vignette with each step (true); stop: instead of draining, ends a drain already running on the body (false)", "thematic:book_pose": "Eases the floating book of the mission's anchor block (the book visual) to a pose for the player it is aimed at, holds it, and eases it back to normal when the duration ends; a private run's book moves only for its participant. A new pose eases from whatever the book is showing. Fields: to: whose book: the body the action is aimed at (default), or the wearer's; at: the book's block: \"anchor\" (default) or a point; height: blocks above its resting height (0); spin: degrees per second it turns (0); it ends on a whole turn; tilt: degrees it leans (0); open: 0 closed to 1 wide open; left out, the book opens as it normally would; flip_speed: page turns per second added to its flipping (0); shake: blocks of jitter (0); duration: seconds the pose lasts in all, the eases inside it (4); ease_in: seconds easing into the pose (1); ease_out: seconds easing back out (1)", "thematic:page_burst": "Parchment pages fly out of the floating book (the anchor's, or the point's) for one player: they spray, flutter down on paper physics, tint from one colour to another and fade. Starts at the book's current posed height. Fields: to: whose screen: the body the action is aimed at (default), or the wearer's; at: the book's block: \"anchor\" (default) or a point; count: pages (40, at most 120; thinned by the viewer's particle setting); speed: blocks per second they leave at (7); spread: 0 straight up to 1 nearly flat out (0.7); duration: seconds a page lives (4); color_from: colour a page starts as (#E8DCC0); color_to: colour it ends as (#7A0A0A); color_delay: fraction of its life before it starts to change (0.2); texture: a texture drawn whole; left out, the book's own page", "thematic:leash_pause": "For a while a player in a mission with a pull-back leash is not pulled back, so a blast that throws them clear of the fight is allowed to carry them; the pull takes over again afterwards. Fields: seconds: how long (3); to: whose leash: the wearer's (default), or the body the action is aimed at", "thematic:fake_crater": "A crater made of nothing but looks: cracks spread out from the impact over a few ticks, some blocks turn into broken versions of themselves, debris flies and dust rises. Seen by one player only; the world is not changed and the ground feels exactly as solid. It heals outward by itself after lasts. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; radius: blocks across the surface, at most 12 (4); depth_visual: 0 to 1: how much of it is swapped for broken block variants; 0 is cracks only (0.6); debris: chunks thrown (14); the viewer's client thins them for its particle setting and distance; crack_stage: 0 to 9, the deepest crack, at the middle (6); lasts: seconds until it starts to heal; 0 keeps it until fakeRevert() (20); heal: blocks per second the healing spreads out from the impact at; 0 heals it all at once (10); spread: ticks the cracks take to reach the rim (5); audience: who sees it when the wearer is not a private entity (a private wearer's viewer always, and only them): self -- the wearer (default); target -- the player the action is aimed at; nearby -- players within 48 blocks", "thematic:fake_crack_line": "A crack racing along the ground from one point to another, widest at the start and tapering, with the odd broken block and chunks kicked up along it. One player's screen only. Fields: from: where it starts (self); to: where it ends; left out, length blocks along the wearer's look, level; reach: with look: how far the look reaches (32); length: blocks, when there is no to (8); at most 48; width: blocks across, 1 to 5 (1); crack_stage: 0 to 9, the deepest crack, at the start (5); debris: chunks kicked up along it (8); lasts: seconds until it starts to heal; 0 keeps it until fakeRevert() (20); heal: blocks per second the healing spreads out from the impact at; 0 heals it all at once (10); audience: who sees it when the wearer is not a private entity (a private wearer's viewer always, and only them): self -- the wearer (default); target -- the player the action is aimed at; nearby -- players within 48 blocks", "thematic:fake_splinter": "Breaks leaves, fences, walls and glass within a radius as fakes: they vanish from one player's screen and fly apart. Only what the palettes allow (data//fake_palettes): leaves anywhere (they come back the moment the viewer gets near), fences, walls and glass only where the top is two or more above the ground the viewer can stand on; a fence the viewer could walk into is cracked instead. Call it again as something passes to splinter a path. Fields: at: which block it starts from (self): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; radius: blocks, at most 8 (4); chance: 0 to 1, the chance each block goes (0.6); max: the most blocks one run touches (24); debris: chunks flung from each block (4); lasts: seconds until they heal (15); heal: blocks per second the healing spreads out from the impact at; 0 heals it all at once (10); audience: who sees it when the wearer is not a private entity (a private wearer's viewer always, and only them): self -- the wearer (default); target -- the player the action is aimed at; nearby -- players within 48 blocks", "thematic:debris_burst": "Flying block chunks for one player: cut from the block's texture, thrown with weight (the heavier ones fly lower, tumble slowly and land with a thud), bounce once or twice, lie still, then fade. Made on the client; no entities. Fields: at: which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down); reach: with at: \"look\": how far the look reaches, in blocks (5); face: step one block out through the face that was hit -- the air beside a wall, the block on top of a floor; count: chunks, at most 48 (12); speed: blocks per second for the lightest chunk (6); spread: 0 a tight cone, 1 a full dome (0.5); size: 1 is a handful of pixels across, 0.3 to 3 (1); rest: seconds a chunk lies still before it fades (4); block: the block whose texture they are cut from; left out, the block at the spot; direction: which way they are thrown (face); audience: who sees it when the wearer is not a private entity (a private wearer's viewer always, and only them): self -- the wearer (default); target -- the player the action is aimed at; nearby -- players within 48 blocks", "thematic:fake_revert": "Puts a player's fake world back: every fake block and crack at once, or healing outward in a ring from a point, a puff of dust at each block as the real one returns. Fields: mode: ring (default) or all; from: where the ring starts (self); reach: with look: how far the look reaches (32); speed: ring: blocks per second (12); 0 or less is all at once; audience: who sees it when the wearer is not a private entity (a private wearer's viewer always, and only them): self -- the wearer (default); target -- the player the action is aimed at; nearby -- players within 48 blocks", "thematic:mark": "Marks the target the action is aimed at in the wearer's name, for a while: kept on the body, so anything can ask whose it is (the markedBy guard). Renewing a mark keeps it the wearer's; marking one another wearer holds takes it over. With radius, marks everything in that box around the action but the wearer and their own animals. The hunter's quarry: mark({ key: \"quarry_mark\", vfx: \"HUNT_MARK\" }). Fields: key: what the mark is kept under, lower_snake_case (\"mark\"); the one markedBy names; owner_key: what the owner's id is kept under (_owner for a key ending in _mark, so quarry_mark's is quarry_owner; else _owner); for: seconds it lasts (the tuned duration); keep_longer: never shortens a mark already there (false); glow: a hidden Glowing effect as long as the mark, visible to everyone (true); seen_by: who sees the glow: everyone (\"all\"), or the wearer alone, through walls (\"owner\"); vfx: a VFX preset played at the body's feet, sized to it, only when the mark is new; radius: marks everyone in this box around the action instead of the target; max: at most this many bodies carry the wearer's mark under the key at once (no cap); fifo: with max reached, the oldest mark goes to make room; false refuses the new one (false); clear: takes the wearer's own mark under the key off the target (or everyone in radius) instead; with none of the fields that put one on (false)", "thematic:gun_window": "For a while, the wearer's held gun fires for free and hits harder. shots: the gun fires that many free shots now, itself (flash, recoil, animation), and the window closes on the last; unlimited: every shot is free until it runs out, the gun cycling fire_rate times faster (holding the trigger keeps firing). Neither: only the damage, knockback and bleed. One window per wearer: a new one replaces the old, except that an unlimited one outlasting it is kept. gunWindow({ shots: 1, for: 0.5 }) is a pressed blast; gunWindow({ unlimited: true, fireRate: 3.5, damageBonus: 0.35, closeOnEnd: true }) an ultimate's burst. Fields: for: seconds it stays open (the tuned duration); shots: free shots the gun fires at once, 1 or more; unlimited: every shot is free while it is open (false); fire_rate: how many times faster the gun cycles while it is open: fire rate, pump and their animations (1); damage_bonus: each landed shot hits this share harder: 0.35 is 35% more (0); knockback: knockback each landed shot adds, once per target, in blocks of impulse (0); bleed_chance: 0 to 1: the chance a landed shot bleeds its target, once per target (0); close_on_end: ends the window, both halves, when the press's states are over (false)", "thematic:gun_action": "Has the wearer's held gun do something now: gunAction(\"reload\") on a press is the reload move (while a gun is held, ability_0 is reload). Fields: action (required): what the held gun does", "thematic:one_of": "Runs one of its branches, picked at random: each branch an action or a list of them, as likely as its weight. In a script, oneOf([b => ..., b => ...], { weights: [3, 1] }). Fields: of (required): the branches; weights: one per branch, 0 or more; left out, all alike", "thematic:weather": "Changes the weather for a while, and can put it back afterwards. Fields: set: cycle (default), clear, rain or thunder; for: seconds the new weather lasts (300); restore: the weather it found comes back when that time is up (false)", "thematic:open_screen": "Opens a screen for the wearer, with no block behind it: their ender chest, a 3x3 crafting grid that hands back what is left in it when it closes, or an inventory stored on them by name, shown as a chest of as many rows. Fields: screen (required): which screen; name: stored_inventory: the inventory's key, e.g. \"backpack\"; size: stored_inventory: its slots the first time it is made, 1 to 54 (27); title: the screen's title, a translation key (container.enderchest, container.crafting, container.backpack)", "thematic:spectate": "Hands the wearer's camera to something else: it rides with the entity hit (target; hidden from them while they look out through it), or is latched onto their own head (head), for a while or until a stop. Synced to their client. A still view without bob is camera({ noViewBob: true }) on the phase. Fields: view: target or head; needed unless stop; for: seconds; left out, until a spectate({ stop: true }); stop: gives the camera back (false)", "thematic:repair_item": "Takes durability damage off the damageable stacks in the wearer's hands: a fixed amount, or so much per experience point of the xp_gained being answered. Fields: hands: main, off or both (default); amount: points of durability (1); per_xp: points per experience point of the event, in place of amount", "thematic:smelt": "Smelts from the wearer's inventory as a furnace would, the results into the inventory (or at their feet when it is full): one item, or every smeltable stack whole. Fields: one: only one item (true); false smelts every smeltable stack; skip: items and #tags left alone, e.g. [\"#minecraft:logs_that_burn\", \"minecraft:cobblestone\"]; skip_named: leave renamed items alone (true); xp: pay the recipe's experience, rounded up per item (true); required: nothing smelted calls the rest of the list off; miss_cooldown is the share of the cooldown that still costs", "thematic:merge_stacks": "Tops up every partial stack in the wearer's inventory from the matching stacks after it.", "thematic:compress": "For each item the wearer carries enough of, crafts full grids of it into what the crafting recipe makes -- nine ingots into a block -- as many times as it can. Only plain stacks (no NBT) go in. Fields: recipe: the grid it fills (3x3); filter: only these items and #tags; left out, any item with such a recipe", "thematic:press_ability": "Presses whatever sits on a key of the kit, as the key would: a press presses, a toggle flips, a hold starts. Fields: slot (required): \"ultimate\", \"ability_1\", or a key number such as 1; who: self (default), or target: the player hit; reset_cooldown: clear its cooldown first, so it goes off even while cooling down (false)", "thematic:use_move": "Presses a registered move by id, whether or not it is in the wearer's kit, as the wearer's own. A move that is not pressable, or not registered, does nothing. Fields: id (required): the move's ability id, e.g. \"sneezing_powder\"; delay: seconds before it is pressed (0); ready: only when its key would take it now: off its cooldown, not held or blocked (false: pressed regardless); do: run only once it was pressed", "thematic:wear_shape": "Lends the wearer the shape one of their kit's morph moves wears, for a while, as part of another move (Bat Colony leaves Dracula a bat once the colony scatters). Borrowed: it costs the morph no cooldown however it ends, and leaves them on Slow Falling if they are in the air. Nothing happens while they are already in a shape. Fields: id (required): the morph move's ability id, e.g. \"bat_form\"; seconds: how long the shape is lent (5)", "thematic:entity_clip": "Triggers a GeckoLib clip on each nearby entity of this type summoned by the wearer. Fields: entity (required): the summoned entity type id; controller (required): the entity's animation controller; clip (required): the trigger name registered by that controller; radius: how far from the action's target to search (4); at: \"spot\" to search around the point markSpot fixed (the trap's own place), or \"target\" (default)", "thematic:despawn_entity": "Removes each nearby entity of this type summoned by the wearer. Fields: entity (required): the summoned entity type id; radius: how far from the action's target to search (4); at: \"spot\" to search around the point markSpot fixed (the trap's own place), or \"target\" (default)", "thematic:drop_item": "Drops an item in the world, with the usual pickup delay. Fields: item (required): the item id; one not registered (its pack missing) drops nothing; count: (1); at: self (default), hit, pos or spot", "thematic:transform_drops": "Rewrites the items the entity hit -- a kill's victim -- has just dropped: some multiplied, food cooked. A multiplied stack is not cooked too. Fields: multiply: those items' stacks times over (2), up to a full stack; items left out, every item; smelt_food: food with a smelting recipe becomes what it cooks into (false); radius: how far around the body the drops are looked for (1.5)", "thematic:item_clip": "The item in a hand plays one of its own clips: a gun in the main hand the cue it declares under that name (sent to the wearer), any other geo item the clip on its controller. Fields: clip (required): the gun's cue, or the item's clip; controller: the geo item's animation controller; without it only a gun answers; hand: main (default) or off; stop: stops the geo item's clip on its controller instead (a twirl that loops until the move ends); needs controller (false)", "thematic:throw_potion": "Throws a splash (or lingering) potion of the effects given, from the wearer's eyes along their look. Fields: effects (required): the effects it carries (5 seconds, amplifier 0); color: the potion's tint, an RGB number or \"#rrggbb\"; lingering: a lingering cloud rather than a splash (false); velocity: (0.5); divergence: (1); pitch_offset: degrees added to the look's pitch (-20, vanilla's throw)", "thematic:launch_lock": "Movement systems leave the body's velocity alone for a while, so a launch just given is not steered away at once. Fields: for: seconds (0.5); who: self (default) or target", "thematic:disable_shield": "A player's shield is knocked down for a while, as an axe does. Fields: who: target (default) or self; only_blocking: only while they are holding it up (true)", "thematic:ping": "A direction ping on the wearer's own screen, pointing the way something is: chevrons on a ring around the crosshair, drawn with this ability's thematic:direction_ping options (the spider-sense's with none). Sent to the wearer only. Fields: level: which of the visual's levels it shows as, from 1 (1); past the last, the last; at: what it points at: hit (default), pos or spot", "thematic:reset_constructs": "Lifts any limits a move put on which constructs the wearer may make: what a lantern ring's charge did as the suit came off.", "thematic:lightning": "Calls down bolts that strike for the wearer: each flashes one to three times where it lands and, each time, hits everyone in a small column round it the wearer may hit -- for damage, as the wearer's attack, holding them where they stand -- and never the wearer's side. lightning({ count: 3 }) inside targets() is three bolts on each target; lightning({ at: \"wearer\", count: 2, scatter: 4 }) two anywhere near the wearer. Fields: at: what they land round (here); count: how many (1, or one per offset); a worked-out number is truncated, never below 1; arrangement: where they land around their centre (ring), as a summon's stand; radius: how far from their centre, in blocks (0: all on it), or [min, max] picked for each one; stagger: with formation_v, how far back each rank lands, in blocks (half the radius); offsets: fixed places added on top of the arrangement, each [right, up, forward] in blocks from the way the wearer's body faces, used in turn; scatter: moves each one up to this many blocks at random on each level axis (0); every: seconds between one bolt and the next (0: all at once); damage: what each flash deals to each body it hits, in raw points (2); owner_credited: its hits are the wearer's attack -- their bonuses, hit_landed, kill credit (true); false makes them a lightning bolt's own, still never on the wearer's side; stun: how long a struck body is held where it stands: true (1.5 seconds), false (not at all) or seconds; scale: how big each bolt is (normal); cosmetic: for show: vanilla's cosmetic bolt, a flash and a crack that strikes, burns and charges nothing -- no damage, stun, owner_credited or scale beside it (false); entity: a thematic:strike entity id to call down instead of the stun lightning, for its own look, flashes, damage and stun (the verb's damage and stun still override); no scale beside it. With cosmetic it is drawn and strikes nobody", "thematic:strand": "Strings a lasting strand (a thematic:strand entity) from a point to the block the wearer looks at. It stays after the move ends: bodies walk along a gentle one and climb a steep one, and it catches whoever crosses it fast, as its definition says. Repeated presses of strand({ from: \"chain\" }) lay a tightrope point to point: the first anchors, each later one strings on from the last point. Past the definition's max_per_owner the wearer's oldest goes. do runs at the new end, the strand as its source. Fields: to: where it ends (look_hit); from: where it starts (self); range: blocks the look reaches, and the longest a chained strand may be (the tuned range, else 24); lasts: seconds it stays (the definition's lifetime); window: seconds a press's point stays open for the next chained press (the tuned chain_window, else 3); entity: the strand entity id (thematic:web_strand); required: a press that strings nothing (missed, or only anchored) calls the rest off and costs no cooldown, or missCooldown's share of it; do: run once it is strung, where it ends", "thematic:swap_suit": "Puts the wearer in another suit: the one named (to), or the other of a pair of suits (pair; wearing neither, nothing happens). A swap to a base suit puts on the variant of it last worn, remembered on the stack (ThematicTransformVariant_), and the new stack remembers the variant taken off. With for, the suit is only borrowed: bound on for that long, then the wearer's own suit and health come back. Banner's turn: swapSuit({ pair: [\"jason_blood\", \"etrigan\"] }). Fields: to: the suit to put on, a base suit or an alt (\"batson\"); give this or pair; pair: two base suits, [\"jason_blood\", \"etrigan\"]: swaps to whichever is not worn; give this or to; keep_nbt: the new stack keeps the old one's data -- colour, level, stored items (true); remember_variant: remember and restore which variant of each suit was worn (true); for: seconds the suit is borrowed for; left out, the swap is for good; scale: with for: the wearer's health while it is borrowed, in health points (unchanged); required: a swap that does not happen calls the rest of the list off; miss_cooldown is the share of the cooldown that still costs", "thematic:copy_suit": "Lends the wearer a fresh copy of a suit -- the target's, or one by id -- bound on for a while; then their own suit and health come back. The copy carries none of the original's data. Fails for a wearer already borrowing one, or nearly dead. Fields: from: \"target\" (default: the suit the entity hit wears) or a suit id, \"superman\"; lasts: seconds it is worn (the tuned duration); scale: the wearer's health while it is worn, in health points (unchanged); end_on_return: this move ends when the suit comes back, and its tuned cooldown starts then (false); required: a swap that does not happen calls the rest of the list off; miss_cooldown is the share of the cooldown that still costs", "thematic:set_active": "Switches a move on or off: this one, one by id, or every move of the wearer's suit (\"kit\"), with a time written to its clock -- the cooldown it is left on when off, how long it runs when a timed move is on. Fields: ability: a move's id, or \"kit\" for every move of the suit (default: this move); on: on (true) or off; for: seconds on its clock; left out, the clock is left alone; up_to: with for: the time is drawn at random between for and this many seconds; clear_capture: first end the wearer's shape-shift capture (the form they copied), if they hold one, so the move starts from their own shape (false); who: whose moves: the wearer's (self, the default) or, inside targets(), the target's; kind: instead of ability: every move of that body's suit of this kind, switched off from outside -- its clean-up runs, and a toggle's switching-off (equip_item: the moves that hand out items, which take them back); needs on: false; take_back: with kind: also take off the body every stack still tied to those moves (false)", "thematic:end_ability": "Ends a running move as running out would: it switches off, its clean-up runs, and its tuned cooldown starts. Fields: ability: a move's id (default: this move)", "thematic:capture_menu": "Opens a menu of forms for the wearer (a player), on behalf of this move: suits rolled at random, none of which can be taken. Picking one takes on its look for this move's tuned duration (the shape-shift capture) and runs this move again for as long; the menu stays open while this move runs. Mystique's Shapeshift: captureMenu() in the press, into a phase that lasts \"duration\". Fields: slots: how many forms it offers, 1 to 5 (5); source: where the forms come from: suits rolled at random (random_suits); inventory: the stored inventory the forms are kept in (\"shapeshift\"); title: the menu's title, a translation key (container.shapeshift)", "thematic:end_capture": "Lets go of the look a capture_menu pick took on, if the wearer holds one: they look like their own suit again." } }, "ability_script": { "about": "Ability scripts: data//abilities//.js. The file name is the id. A script builds the same definition as the JSON format (section ability_format) through callbacks; docs/thematic.d.ts is this section as TypeScript declarations, for editor autocompletion.", "globals": [ { "name": "ability", "signatures": [ "ability(id: string, type: string, options?: { [field: string]: unknown }): void" ], "doc": "Defines an ability of a built-in Java type (see docs/ability-types.md), configured as its JSON file would be: ability(`${corp.prefix}_beam`, \"thematic:power_i_beam\"). A file may define any number, in plain loops, each named with an id in the file's namespace that no other ability anywhere may use. An ability whose behaviour is written out is a component: component(component => { ... })." }, { "name": "component", "signatures": [ "component(body: (component: Component) => void): void", "component(id: string, body: (component: Component) => void): void" ], "doc": "Declares an ability as a component: the parts it is built from, and the phases it can be in. A file that declares one may leave it unnamed, and the file name is its id (data//abilities//.js); a file may also declare any number, in plain loops, each named. The body runs once, when the pack loads, and builds the component; it never runs on the key press and never sees a player. component(component => { component.cooldown(); component.press(press => { ... }); })." }, { "name": "prefab", "signatures": [ "prefab(id: string, spec: PrefabSpec, apply: (target: any, options: any, body?: any) => void): void" ], "doc": "Declares a prefab, in a library file under data//ability_prefabs/ (nowhere else): parts bundled under a name, applied with component.use(id, options, body) or phase.use(...). apply is handed the component (or phase) it is applied to, the options the use passed (under the names the spec declares), and the use's body. A bare id is in the library's namespace." }, { "name": "tuned", "signatures": [ "tuned(key: TunedStat | string, times?: number, otherwise?: number): Tuned" ], "doc": "A number that follows this ability's tuning, scaled: tuned(\"radius\", 1.5) stays one and a half times the radius when the radius is retuned. A key beyond the four stats (damage, radius, duration, amplifier) is a row of the ability_defaults CSV, ability,key,value -- tuned(\"push_strength\") -- changed by /thematic ability set or the sheet; otherwise is the number used when no row (or suit option of that name) has the key. Gameplay numbers (damage, heal, knockback, ranges, durations, chances) are tuned keys, never literals." }, { "name": "fromEvent", "signatures": [ "fromEvent(value: EventNumber, times?: number): FromEvent" ], "doc": "A number the event being answered carries, scaled: fromEvent(\"amount\") is the damage of the hit a reaction answers." }, { "name": "ramp", "signatures": [ "ramp(from: number, to: number, across: \"cooldown\" | \"duration\" | number): Ramp" ], "doc": "A number that moves from one value to another as the running phase's time is used up: ramp(12.5, 50, \"cooldown\") measured against the tuned cooldown, \"duration\" the tuned duration, or a number of seconds. Solar Fury's spin." }, { "name": "random", "signatures": [ "random(low: number, high: number, whole?: boolean): RandomNumber" ], "doc": "A number picked at random between low and high each time it is worked out: random(100, 200, true) is a whole 100 to 200. store() it to use the one pick twice -- a drain and the message that names it." }, { "name": "wave", "signatures": [ "wave(amplitude: number, rate?: number): Wave" ], "doc": "amplitude * sin(the wearer's age in ticks * rate): a bob, e.g. a lift of wave(0.05, 0.5)." }, { "name": "ladderLevel", "signatures": [ "ladderLevel(min: number, max: number, times?: number): LadderLevel" ], "doc": "The move's level on the starter ladder, scaled between min and max (rung 1 is min, rung 10 is max), as the Java moves asked effectiveLevel(1, 5); a suit off the ladder gives the level it gives the move, unclamped. Inside an expr the same reads as level(min, max): Luck's amplifier is expr(\"amplifier * level(1, 5)\")." }, { "name": "fireTicks", "signatures": [ "fireTicks(who?: \"wearer\" | \"target\", times?: number): FireTicks" ], "doc": "Ticks a body has left to burn, scaled, 0 when it is not alight: the wearer's (default) or the target's -- the entity the action is aimed at. fireTicks(\"target\", 0.05) is its burn in seconds." }, { "name": "speedValue", "signatures": [ "speedValue(key?: \"current\" | \"previous\" | \"modifier\", times?: number): SpeedValue" ], "doc": "One of the wearer's speed readings, scaled: current (default) or previous -- the speed meter now or a tick ago, in blocks a second -- or modifier, the speed dial the wearer set (1 to 100)." }, { "name": "stored", "signatures": [ "stored(name: string, times?: number): Stored" ], "doc": "A number this press stored with store() (or drew with let()), scaled: stored(\"absorbed\", 0.5). 0 before anything is stored." }, { "name": "sum", "signatures": [ "sum(...parts: Amount[]): Sum" ], "doc": "Numbers added up, each any number a file can write: sum(tuned(\"damage\"), stored(\"absorbed\", 0.5))." }, { "name": "bands", "signatures": [ "bands(bands: [number, Amount][], otherwise: Amount, by?: NumberInput): Bands" ], "doc": "The number of the first band whose bound the input is at or under, else otherwise: bands([[3, tuned(\"damage\")], [6, tuned(\"damage\", 0.7)]], tuned(\"damage\", 0.3)) falls off with distance from the wearer (by defaults to \"distance\")." }, { "name": "input", "signatures": [ "input(name: NumberInput, times?: number): Input" ], "doc": "One thing the move knows as it runs, scaled: input(\"gauge\", 0.005), input(\"distance\")." }, { "name": "gauge", "signatures": [ "gauge(times?: number): Input" ], "doc": "What the ability's cooldown slot holds, in ticks -- a hold's gauge -- scaled. For a curve over it, expr(\"min(gauge * 0.005, 0.75)\")." }, { "name": "expr", "signatures": [ "expr(text: string, times?: number): Expression" ], "doc": "Arithmetic over what the move knows as it runs, read once at load: expr(\"min(gauge * 0.005, 0.75) * exp(-gauge * 0.015)\"), expr(\"damage + $absorbed * 0.5\"). The inputs are NumberInput's names; $name reads a stored or let number." }, { "name": "pulse", "signatures": [ "pulse(pulse: number, period: number, options?: { phase?: number; around?: number; fit?: number; times?: number }): Pulse" ], "doc": "around * (1 + pulse * cos(2 pi (t - phase) / period)): a beat through a phase that lasts the tuned duration, peaking phase seconds in and every period after. fit stretches the clock so the duration covers that many seconds, the time of an animation fitted to it. Run Wild's gallop: drive({ speed: pulse(0.45, 0.4, { phase: 0.625, fit: 6, around: 1.25 }) })." }, { "name": "registry", "signatures": [ "registry(name: RegistryName): string[]" ], "doc": "Every id in a registry, sorted: registry(\"damage_type\") is [\"minecraft:arrow\", ..., \"thematic:kryptonite\", ...]. Vanilla's entries plus what the installed packs define as files; entries other mods or Thematic register in code are not listed, so a loop defines the same abilities on every install." }, { "name": "tag", "signatures": [ "tag(registry: \"damage_type\", id: DamageTypeTag): string[]", "tag(registry: \"entity_type\", id: EntityTypeTag): string[]", "tag(registry: \"item\", id: ItemTag): string[]", "tag(registry: RegistryName, id: string): string[]" ], "doc": "A tag's members, sorted, with the tags it includes expanded: tag(\"damage_type\", \"minecraft:is_fire\"). Vanilla's tag merged with every pack's file at that path, as the game merges them. Empty when nothing defines it." }, { "name": "tags", "signatures": [ "tags(registry: RegistryName): string[]" ], "doc": "Every tag id a registry has, vanilla's and the packs', sorted." }, { "name": "data", "signatures": [ "data(kind: \"corps\"): Corps[]" ], "doc": "Every file of a pack data kind, sorted by id: data(\"corps\") is one entry per data//corps/.json, its fields plus its id. A pack adds an entry by adding a file, and every script that loops over the kind picks it up." }, { "name": "corps", "signatures": [ "corps(): Corps[]" ], "doc": "The Lantern corps: data(\"corps\"). corps().forEach(corp => ability(`${corp.prefix}_beam`, \"thematic:power_i_beam\"))." }, { "name": "streak", "signatures": [ "streak(color: Color, scale?: number, length?: number): StreakParticle" ], "doc": "A spark of coloured light that streaks along its flight, for bursts that throw off lines of light rather than dots: streak(\"$stack_color\", 1, 2). scale is its width (1); length how long it is drawn per block a tick it travels (2). Give it speed: a still streak is a short dash." }, { "name": "dust", "signatures": [ "dust(color: Color, scale?: number): DustParticle" ], "doc": "Coloured dust, the one particle that takes settings: dust([0.7, 0.05, 0.35], 1.5). A colour is [r, g, b] (each 0 to 1), \"#RRGGBB\", or \"$name\" for a value the press holds." }, { "name": "print", "signatures": [ "print(message: unknown): void" ], "doc": "Writes a line to the game log." } ], "interfaces": [ { "name": "Actions", "doc": "Somewhere actions are written: a moment of a running order, an every() rule, a reaction, an end(), a block's body. Every method writes one action, in the order called.", "methods": [ { "name": "areaDamage", "signatures": [ "areaDamage(options?: AreaDamageOptions): void" ], "doc": "Hurts everyone in radius but the wearer and their allies. (In a JSON file: thematic:area_damage.)\n@param options damage, radius, element; a field left out is the default, or the tuned value" }, { "name": "areaEffect", "signatures": [ "areaEffect(effect: string, options?: AreaEffectOptions): void" ], "doc": "A status effect on everyone in radius but the wearer and their allies. (In a JSON file: thematic:area_effect.)\n@param effect the status effect id, e.g. \"minecraft:slowness\"\n@param options duration, amplifier, ambient, showParticles, showIcon, radius; a field left out is the default, or the tuned value" }, { "name": "explode", "signatures": [ "explode(options?: ExplodeOptions): void" ], "doc": "A vanilla explosion where it happens. Blocks survive unless break_blocks. (In a JSON file: thematic:explode.)\n@param options power, fire, breakBlocks; a field left out is the default, or the tuned value" }, { "name": "ignite", "signatures": [ "ignite(options?: IgniteOptions): void" ], "doc": "Sets the entity hit on fire, or caps how long it still burns. (In a JSON file: thematic:ignite.)\n@param options seconds, exact, maxSeconds; a field left out is the default, or the tuned value" }, { "name": "igniteJets", "signatures": [ "igniteJets(options?: IgniteJetsOptions): void" ], "doc": "Lights the wearer's thrusters (the flight profile's jets that say \"when\": \"dash\") for a moment, for everyone who can see them; a suit-wearing mob lights its own the same way. Call it every tick of a longer burn, or once with a duration that covers it: the flames fade out over the last few ticks. (In a JSON file: thematic:ignite_jets.)\n@param options duration; a field left out is the default, or the tuned value" }, { "name": "selfEffect", "signatures": [ "selfEffect(effect: string, options?: SelfEffectOptions): void" ], "doc": "A status effect on the wearer. (In a JSON file: thematic:self_effect.)\n@param effect the status effect id, e.g. \"minecraft:slowness\"\n@param options duration, amplifier, ambient, showParticles, showIcon; a field left out is the default, or the tuned value" }, { "name": "when", "signatures": [ "when(guard: Guard, body: (branch: Actions) => void, otherwise?: (branch: Actions) => void): void" ], "doc": "Runs one list of actions when a guard holds and another when it does not. (In a JSON file: thematic:if.)\n@param guard the question\n@param body when it holds\n@param otherwise when it does not" }, { "name": "push", "signatures": [ "push(who: Who, body?: (collided: Actions) => void, onWall?: (collided: Actions) => void): void", "push(who: Who, options: PushOptions, body?: (collided: Actions) => void, onWall?: (collided: Actions) => void): void" ], "doc": "Sets or adds velocity to the wearer or the target, in a named direction. (In a JSON file: thematic:push.)\n@param who self (default) or target\n@param options direction, strength, lift, flat, mode, keep, falloff, minStrength, verticalStrength, resetFall, launch, vertical, collideRadius, wallFor, within; a field left out is the default, or the tuned value\n@param body a thrown body: watched every tick while it flies, the first living thing it passes within collide_radius of (not itself, not the wearer, not one the wearer may not hit) gets these actions as the target, the thrown body as remembered -- a hurled victim knocking down whoever it lands in. The watch ends then, or when it lands, dies, all but stops, or after 10 seconds\n@param onWall a pushed body (not the wearer): watched every tick for wall_for seconds, and the first tick it runs into a wall it gets these actions as the target, once -- a blast that hurts more when it slams its victim into a wall" }, { "name": "markTime", "signatures": [ "markTime(key: string): void" ], "doc": "Stores the world time on the wearer, synced, for a client visual to count from. (In a JSON file: thematic:mark_time.)\n@param key the key the visual reads" }, { "name": "markSpot", "signatures": [ "markSpot(key: string, options?: MarkSpotOptions): void" ], "doc": "Fixes a point for the rest of the press or reaction -- the body centre of the target inside targets(), of the wearer otherwise -- for at: \"spot\" and away_from_spot to use later. Also stored on the wearer, synced, under the key, with the wearer's facing under _yaw and _pitch, for a client visual drawn there. (In a JSON file: thematic:mark_spot.)\n@param key the key the visual reads\n@param options anchor, behind, ahead, safe, along, reach, reachMin, reachMax, failMessage, above, offset, offsetFrame, riseOutOfBlocks, standoff, fit, required; a field left out is the default, or the tuned value" }, { "name": "extinguish", "signatures": [ "extinguish(options?: ExtinguishOptions): void" ], "doc": "Puts out fire, lit candles and lit campfires in the box around the wearer -- or, with at and shape, around the block hit, the spot, or wherever the block verbs can start from. With who, a burning body instead. (In a JSON file: thematic:extinguish.)\n@param options at, reach, face, shape, radius, height, blocks, griefCheck, who; a field left out is the default, or the tuned value" }, { "name": "swapHeldItem", "signatures": [ "swapHeldItem(cycle: string[], body?: (swapped: Actions) => void): void", "swapHeldItem(cycle: string[], options: SwapHeldItemOptions, body?: (swapped: Actions) => void): void" ], "doc": "Swaps the held item for the next one in a cycle, keeping its tag. (In a JSON file: thematic:swap_held_item.)\n@param cycle item ids, in the order they swap\n@param options hand; a field left out is the default, or the tuned value\n@param body run only if it swapped" }, { "name": "areaLaunch", "signatures": [ "areaLaunch(options?: AreaLaunchOptions): void" ], "doc": "Throws everyone in radius the way the wearer is facing. (In a JSON file: thematic:area_launch.)\n@param options strength, lift, radius; a field left out is the default, or the tuned value" }, { "name": "lunge", "signatures": [ "lunge(options?: LungeOptions): void" ], "doc": "Throws the wearer the way they are facing. (In a JSON file: thematic:lunge.)\n@param options strength, lift; a field left out is the default, or the tuned value" }, { "name": "speedsterRun", "signatures": [ "speedsterRun(options?: SpeedsterRunOptions): void" ], "doc": "One server tick of a speedster's run for this move: run it every tick. The run's jump, step and motion scales and its speed modifier go on (the motion and the modifier stand aside while the wearer wall-runs or slowed time owns their motion), and the run-in and running sounds play as they set off and keep going -- the move's own cues (options run_in_sound / running_sound, or sound_prefix), else Thematic's. stop takes the run off. (In a JSON file: thematic:speedster_run.)\n@param options stop, sounds; a field left out is the default, or the tuned value" }, { "name": "teleport", "signatures": [ "teleport(to: TeleportTo, body?: (missed: Actions) => void): void", "teleport(to: TeleportTo, options: TeleportOptions, body?: (missed: Actions) => void): void" ], "doc": "Puts the wearer by the target, or the target by the wearer. Inside targets() -- except to: \"spot\", which puts the wearer on a point markSpot fixed, anywhere, and along_look_clear and away_from_attacker_clear, which move the wearer by their own look or the hit that answered. (In a JSON file: thematic:teleport.)\n@param to where\n@param options gap, distance, spread, rise, reach, min, step, sideways, ifFits, bearing, standoff, stop, keepHeight, maxSnap, along, safe, fallSpeed, spot, below, face; a field left out is the default, or the tuned value\n@param body those same, and nudge: run when they found nowhere to put anyone and nobody moved -- a refund, a fizzle" }, { "name": "lookAt", "signatures": [ "lookAt(who?: Who, options?: LookAtOptions): void", "lookAt(options: LookAtOptions): void" ], "doc": "Turns the wearer to face the target's eyes, or (who: target) the target -- player or mob -- to face the wearer's. With spot, to face a point instead: the nearest ore findBlock() found, a markSpot(); with away, to turn their back on the other. (In a JSON file: thematic:look_at.)\n@param who self (default) or target\n@param options drop, spot, away; a field left out is the default, or the tuned value" }, { "name": "removeEffect", "signatures": [ "removeEffect(effect?: string, options?: RemoveEffectOptions): void", "removeEffect(options: RemoveEffectOptions): void" ], "doc": "Takes a status effect off the wearer, or (who: target) off the target inside targets(). (In a JSON file: thematic:remove_effect.)\n@param effect the effect id; left out, the one an effect_added event brought\n@param options who; a field left out is the default, or the tuned value" }, { "name": "knockback", "signatures": [ "knockback(options?: KnockbackOptions): void" ], "doc": "Vanilla knockback (a sword's): flat, weakened by knockback resistance. On the entity hit -- the target inside targets() -- unless who says otherwise. (In a JSON file: thematic:knockback.)\n@param options strength, direction, who; a field left out is the default, or the tuned value" }, { "name": "targets", "signatures": [ "targets(select: TargetSelect, body?: (target: Actions) => void, otherwise?: (target: Actions) => void): void", "targets(select: TargetSelect, options: TargetsOptions, body?: (target: Actions) => void, otherwise?: (target: Actions) => void): void" ], "doc": "Picks who a move lands on and runs its actions once aimed at each. Inside, damage, effect, sound and particles are about the target. (In a JSON file: thematic:targets.)\n@param select who to pick\n@param options radius, box, ahead, along, length, width, height, startWidth, startHeight, from, range, maxAngle, aimAssist, assist, preferPlayers, pick, sort, sortEffect, at, within, round, hollow, beyond, entity, hittable, lineOfSight, exceptAllies, unlessActive, arc, arcWiden, except, spawnGroups, once, remember, required, key, by, below, above; a field left out is the default, or the tuned value\n@param body the actions run on each target\n@param otherwise the actions run once when nobody was found" }, { "name": "once", "signatures": [ "once(per: OncePer, body: (first: Actions) => void): void", "once(per: OncePer, options: OnceOptions, body: (first: Actions) => void): void" ], "doc": "Runs its actions only the first time it is reached in each pass of the targets() around it, or in the whole press: a slash sound for the first body a sweep meets, a shield for the first body of the run. With per: \"beat\", only on the ticks a beat of seconds falls on -- seconds worked out each time, so the beat can quicken with a count the press keeps; a phase's every with a worked-out seconds is read as one of these. (In a JSON file: thematic:once.)\n@param per pass, run or beat\n@param options seconds, clock, start; a field left out is the default, or the tuned value\n@param body what the first one does" }, { "name": "drive", "signatures": [ "drive(options?: DriveOptions): void" ], "doc": "Sets the wearer's velocity for this tick: a direction times a speed, with a vertical of its own. Put it in a phase's every() to hold a charge, pounce or leap every tick -- a velocity thrown once is gone to friction in two blocks. The speed is sideways along the direction; a negative speed drives backwards. A server set, told to the client: while it runs, where a player goes is the move's call, not their keys'. With path: \"circle\" it runs round a centre instead, angularSpeed radians a tick, on a radius that grows by radiusGrowth over the tuned duration, pulling those around it in with suction: Whirlwind's widening run. (In a JSON file: thematic:drive.)\n@param options path, along, speed, vertical, onWall, resetFall, sprint, radius, radiusGrowth, angularSpeed, height, pull, maxSpeed, around, face, suction; a field left out is the default, or the tuned value" }, { "name": "orbit", "signatures": [ "orbit(options?: OrbitOptions): void" ], "doc": "Hands the wearer's own client a spiral to fly round a centre: it steers itself along the path (movement input is ignored, so pair it with lockInput), the sprint flag held, turned to run along the circle. The server sends one packet and no velocity, so there is no lag or teleporting. Put it in a phase's body (it runs as the phase starts); radius and height ease from their first value to their \"To\" over the seconds. A player only. (In a JSON file: thematic:orbit.)\n@param options around, radius, radiusTo, height, heightTo, angularSpeed, seconds, sprint, face, stop; a field left out is the default, or the tuned value" }, { "name": "jump", "signatures": [ "jump(options?: JumpOptions): void" ], "doc": "A vanilla jump: what a flying kick does from a standing start, so the charge has height to fly at. (In a JSON file: thematic:jump.)\n@param options onlyOnGround; a field left out is the default, or the tuned value" }, { "name": "rise", "signatures": [ "rise(options?: RiseOptions): void" ], "doc": "Climbs the wearer straight up to height blocks over where the climb began, at speed a tick, easing into the top and holding there. Sideways speed is dropped while it climbs. Every tick, in a phase's every(). (In a JSON file: thematic:rise.)\n@param options height, speed, ease, from, sprint; a field left out is the default, or the tuned value" }, { "name": "gravity", "signatures": [ "gravity(options?: GravityOptions): void" ], "doc": "Turns gravity off, or back on. It stays as set: turn it back on in the phase's end(), which runs however the phase is left, death and logging out included. (In a JSON file: thematic:gravity.)\n@param options who, off; a field left out is the default, or the tuned value" }, { "name": "swingHand", "signatures": [ "swingHand(hand?: SwingHandWhich, options?: SwingHandOptions): void", "swingHand(options: SwingHandOptions): void" ], "doc": "Swings a hand where everyone can see it, the wearer included: a slash that reads as one. (In a JSON file: thematic:swing_hand.)\n@param hand main (default), off, or alternate\n@param options chance; a field left out is the default, or the tuned value" }, { "name": "turn", "signatures": [ "turn(options?: TurnOptions): void" ], "doc": "Turns the wearer by so much a tick, and eases their pitch toward a target or level: a spin that tracks. (In a JSON file: thematic:turn.)\n@param options yaw, pitchToward, pitch, within, ease; a field left out is the default, or the tuned value" }, { "name": "carry", "signatures": [ "carry(options?: CarryOptions): void" ], "doc": "Holds the target in front of the wearer, tick by tick: in a phase's every(), inside targets() -- usually select \"remembered\". Lets go by itself (and forgets the pick) once they are dead, gone, further than release, or won't fit (fit). Aerial Charge's is the defaults with along: \"heading\"; Feral Leap's {from: \"feet\", distance: 0.9, at: \"feet\", along: \"yaw\", move: \"fit\", blocked: \"slam\", fall: \"book\", hold: {for: 0.75, every: 0.25, owedFall: 10}, victimAnimation: {name: \"feral_leap_victim\", every: 1.5}}; Stronger, Smarter, Better's {from: \"feet\", distance: 1.5, at: \"feet\", along: \"yaw\", move: \"teleport\", fall: \"keep\"}. (In a JSON file: thematic:carry.)\n@param options from, distance, at, along, move, maxStep, blocked, slam, release, fall, hold, victimAnimation, inHand; a field left out is the default, or the tuned value" }, { "name": "letGo", "signatures": [ "letGo(options?: LetGoOptions): void" ], "doc": "Hands the carried target back: the one inside targets(), else the remembered one. Forgets them, lifts the hold a carry put on them (this press's, or one run from a passive's tick) and stops its victim clip; with slam, puts them under the wearer's feet (stopping at the floor, only if they fit) and sends both down. The owed landing keeps running. (In a JSON file: thematic:let_go.)\n@param options slam, forget; a field left out is the default, or the tuned value" }, { "name": "markHeading", "signatures": [ "markHeading(options?: MarkHeadingOptions): void" ], "doc": "Fixes where the wearer aims now as the move's heading, for later pushes, drives and carries along \"heading\": their look, or for a mob straight at its target. (In a JSON file: thematic:mark_heading.)\n@param options yawOnly, maxTurn, from; a field left out is the default, or the tuned value" }, { "name": "ride", "signatures": [ "ride(options?: RideOptions): void" ], "doc": "Puts the wearer on the target's back (inside targets()), or with rider: \"target\" the target on the wearer's; off gets the rider down. Guard a phase on riding to end the move with the ride. (In a JSON file: thematic:ride.)\n@param options rider, off, force, free, maxDistance; a field left out is the default, or the tuned value" }, { "name": "markTarget", "signatures": [ "markTarget(key?: string, options?: MarkTargetOptions): void", "markTarget(options: MarkTargetOptions): void" ], "doc": "Inside targets(): stores the target on the wearer, synced, under key, so a phase's movement { charge: { toward: \"marked\" } } steers the wearer's own client straight at it -- a dash at one victim, without the server pinning their momentum. It is also remembered for the press, so a later targets(\"remembered\") finds the same one; the mark is cleared when the press's phases are over. (In a JSON file: thematic:mark_target.)\n@param key the data key (charge_target); the charge's key must match\n@param options clear, remember, uuid, keep; a field left out is the default, or the tuned value" }, { "name": "spin", "signatures": [ "spin(who?: SpinWho, options?: SpinOptions): void", "spin(options: SpinOptions): void" ], "doc": "Turns a body round on the spot: every tick for ticks ticks its look moves degrees further round, at eye height -- a victim spun dizzy by a dash. A body already spinning is left to finish; one that dies stops. (In a JSON file: thematic:spin.)\n@param who target (default) or self\n@param options degrees, ticks; a field left out is the default, or the tuned value" }, { "name": "damage", "signatures": [ "damage(options?: DamageOptions): void" ], "doc": "Hurts the entity hit -- inside targets(), the target -- or, with who: \"self\", the wearer. (In a JSON file: thematic:damage.)\n@param options damage, damageType, element, source, throughAbsorption, store, who, ignoreIframes; a field left out is the default, or the tuned value" }, { "name": "effect", "signatures": [ "effect(effect: string, options?: EffectOptions): void" ], "doc": "A status effect on the entity hit -- inside targets(), the target. (In a JSON file: thematic:effect.)\n@param effect the status effect id, e.g. \"minecraft:slowness\"\n@param options duration, amplifier, ambient, showParticles, showIcon, chance, tint, resolveAgainst, suppress, markGrounded, stack; a field left out is the default, or the tuned value" }, { "name": "heal", "signatures": [ "heal(amount?: Amount, options?: HealOptions): void", "heal(options: HealOptions): void" ], "doc": "Heals the wearer, or the entity hit: by an amount, up to a level, or both (by the amount, no further than the level). (In a JSON file: thematic:heal.)\n@param amount how much, in the action bar's units (1000 is a full vanilla bar, 50 is one hit point), or fromEvent(\"amount\") for what the answered hit was worth; left out, the tuned \"heal\" key, else 50 (1, or up to the level with to)\n@param options to, target; a field left out is the default, or the tuned value" }, { "name": "overshield", "signatures": [ "overshield(amount?: Amount, options?: OvershieldOptions): void", "overshield(options: OvershieldOptions): void" ], "doc": "An absorption pool on the wearer, or the entity hit, that hits spend before health: raised to the amount (a second grant tops it up, never stacks), or added to it with stack. (In a JSON file: thematic:overshield.)\n@param amount how much, in the action bar's units (1000 is a full vanilla bar); left out, the tuned \"overshield\" key, else 50\n@param options target, stack, for; a field left out is the default, or the tuned value" }, { "name": "clearEffects", "signatures": [ "clearEffects(options?: ClearEffectsOptions): void" ], "doc": "Takes status effects off the wearer, or the target: every one, the harmful or the beneficial ones, or none (only the absorption pool, with absorption: true). (In a JSON file: thematic:clear_effects.)\n@param options who, category, absorption; a field left out is the default, or the tuned value" }, { "name": "cooldowns", "signatures": [ "cooldowns(options?: CooldownsOptions): void" ], "doc": "Changes cooldowns across a kit, the wearer's or the target's: takes seconds off, sets them, or starts each one's whole cooldown. (In a JSON file: thematic:cooldowns.)\n@param options who, ability, except, cooling, ready, exceptUltimate, skipActive, keyed, pick, reduce, set, add, times, full, inventories, tag; a field left out is the default, or the tuned value" }, { "name": "scale", "signatures": [ "scale(scale: ScaleType, options?: ScaleOptions): void" ], "doc": "A temporary scale on the wearer: slower while charging, a longer reach. Stays until unscale(), unless for or while hold it: then it comes off by itself, death and logout included. With who: \"target\", on the target inside targets(): a player keeps it as the wearer would; a mob's is set outright and stays (a summon's size) unless for puts it back. (In a JSON file: thematic:scale.)\n@param scale which scale\n@param options value, key, for, while, snap, who, exclusive, relative; a field left out is the default, or the tuned value" }, { "name": "unscale", "signatures": [ "unscale(scale: ScaleType, options?: UnscaleOptions): void" ], "doc": "Takes a scale() off the wearer, or the target: a mob's goes back to the default. (In a JSON file: thematic:unscale.)\n@param scale which scale\n@param options key, who; a field left out is the default, or the tuned value" }, { "name": "attack", "signatures": [ "attack(options?: AttackOptions): void" ], "doc": "A real attack on the target inside targets(), as the wearer's own swing would land it: the held item's damage, enchantments, knockback, crits, sweeping and durability, weakened by the attack cooldown as any swing is (a blow every tick is a weak one). A mob wearer attacks as a mob does. Turn to the target first with lookAt(), and swingHand() for the swing to show. (In a JSON file: thematic:attack.)\n@param options weapon, sweep; a field left out is the default, or the tuned value" }, { "name": "slowTime", "signatures": [ "slowTime(options?: SlowTimeOptions): void" ], "doc": "Catches the target in slowed time (the reflex slow), held at the speed it was caught at. Inside targets(); run it every tick of a phase and it is topped up, never shortened. (In a JSON file: thematic:slow_time.)\n@param options for; a field left out is the default, or the tuned value" }, { "name": "releaseTime", "signatures": [ "releaseTime(): void" ], "doc": "Lets the target out of slowed time. Inside targets(). (In a JSON file: thematic:release_time.)" }, { "name": "holdProjectiles", "signatures": [ "holdProjectiles(options?: HoldProjectilesOptions): void" ], "doc": "Freezes the projectiles around the wearer in the air. (In a JSON file: thematic:hold_projectiles.)\n@param options radius, for; a field left out is the default, or the tuned value" }, { "name": "lockMoves", "signatures": [ "lockMoves(options?: LockMovesOptions): void" ], "doc": "Locks a kit's moves -- the target's inside targets(), the wearer's otherwise. Never the move doing the locking. Which moves a mode takes by default follows the Java it replaced: dampen takes ultimates but spares stun-immune moves; interrupt and disable_effect spare ultimates but take stun-immune moves; cooldown_floor takes both and skips passives. (In a JSON file: thematic:lock_moves.)\n@param options mode, who, for, except, only, includeUltimates, stunImmuneToo, skipPassives, stop, cooldown, amplifier, message, color; a field left out is the default, or the tuned value" }, { "name": "unlockMoves", "signatures": [ "unlockMoves(options?: UnlockMovesOptions): void" ], "doc": "Lifts a dampen lock early (stamps, holds and its message) -- the target's inside targets(), the wearer's otherwise. (In a JSON file: thematic:unlock_moves.)\n@param options who, only; a field left out is the default, or the tuned value" }, { "name": "spray", "signatures": [ "spray(particle?: ParticleSpec, options?: SprayOptions): void", "spray(options: SprayOptions): void" ], "doc": "Particle projectiles thrown from a point on the wearer along their look -- a mob's, straight at its target; an arm anchor's, along the arm -- each carrying ability effects to what it hits: a breath, a spray. Flat, it is one projectile; with cones, one per cone, in order, e.g. a breath's { spread: 0.8, lifetimeTicks: 90 }, { spread: 5, lifetimeTicks: 20 }, { spread: 10, lifetimeTicks: 20 }. (In a JSON file: thematic:spray.)\n@param particle the particle it is drawn with (minecraft:spit)\n@param options from, cones, spread, lifetime, lifetimeTicks, speed, damage, effects, optionEffects, dedupe; a field left out is the default, or the tuned value" }, { "name": "setFlag", "signatures": [ "setFlag(key: string, options?: SetFlagOptions): void" ], "doc": "Stores true or false on the wearer, synced, under a key an animation or a client visual reads. (In a JSON file: thematic:set_flag.)\n@param key the key\n@param options value, for; a field left out is the default, or the tuned value" }, { "name": "beam", "signatures": [ "beam(body?: (hit: Actions) => void, onBlock?: (hit: Actions) => void): void", "beam(options: BeamOptions, body?: (hit: Actions) => void, onBlock?: (hit: Actions) => void): void" ], "doc": "A hitscan ray that hurts and carries ability effects: from the eyes along the look unless told otherwise (a mob's, straight at its target). Reflect abilities bounce it back, and a wall stops it. (In a JSON file: thematic:beam.)\n@param options effects, optionEffects, dedupe, from, direction, aim, range, reach, overshoot, margin, damage, splash, chain, unstoppable; a field left out is the default, or the tuned value\n@param body run aimed at the living thing it hit, after any splash and chain: push(\"target\", ...) knocks it\n@param onBlock run when it hit no one -- at the block it stopped on, or the end of its range: push(\"self\", ...) for a recoil off the wall" }, { "name": "store", "signatures": [ "store(key: string, options?: StoreOptions): void" ], "doc": "Keeps a number under a name for as long as this press's phases last, for {stored: name}, $name in an expr, or a field written \"$name\" to read back. A fresh press starts with none. (In a JSON file: thematic:store.)\n@param key the name it is kept under\n@param options value, mode; a field left out is the default, or the tuned value" }, { "name": "cancelEvent", "signatures": [ "cancelEvent(): void" ], "doc": "Calls off the event being answered. attack: the swing's own damage never lands (what the answer itself deals still does) -- an armed punch consumed by the move it arms. damaged: the hit on the wearer is cancelled. use_block, use_entity, use_item: the use never happens. xp_gained: the experience is not added. projectile_incoming: the projectile passes through the wearer. projectile_launched: the projectile never appears. The first answer to cancel decides; the rest are not asked. Every other event has already happened, and this does nothing there. Pair it on attack with the phase trait hidesSwing, so the client doesn't draw a punch over the move. (In a JSON file: thematic:cancel_event.)" }, { "name": "startCooldown", "signatures": [ "startCooldown(fraction?: number): void" ], "doc": "Starts this ability's cooldown now: the tuned cooldown times fraction. For a passive -- which has no then() -- and for an answer whose cooldown is owed part-way through its steps, as a vent that is only paid for once it goes off. Inside a phase of a pressed ability the cooldown slot counts the phase's time; leave with then(\"cooldown\") there. (In a JSON file: thematic:start_cooldown.)\n@param fraction of the tuned cooldown (1)" }, { "name": "setBones", "signatures": [ "setBones(on?: boolean): void" ], "doc": "Puts this ability's suit bones (its bones trait) in their on or off pose. Time it to the frame of an animation so the swap lands mid-gesture; until an ability first calls it, its bones follow whether it is on. (In a JSON file: thematic:set_bones.)\n@param on true (default): the on pose -- show drawn, hide hidden; false: the off pose" }, { "name": "say", "signatures": [ "say(options?: SayOptions): void" ], "doc": "A chat line from the wearer to the players within earshot, through vanilla's chat.type.text so a server's chat formatting applies to it as to anything else the wearer says. (In a JSON file: thematic:say.)\n@param options lines, pick, sender, color, radius, radiusOption, format; a field left out is the default, or the tuned value" }, { "name": "equip", "signatures": [ "equip(options?: EquipOptions): void" ], "doc": "Puts an item in one of the wearer's slots, tied to the ability: tagged, so it is stripped once the ability is not running and discarded if dropped. Already there, nothing happens; copies moved elsewhere are taken first, so it is safe every tick. In a phase, phase.equip() also takes it back when the phase ends. (In a JSON file: thematic:equip.)\n@param options item, slot, count, enchant, tag, displaced, named; a field left out is the default, or the tuned value" }, { "name": "unequip", "signatures": [ "unequip(options?: UnequipOptions): void" ], "doc": "Takes back the items an equip() handed out: every stack with the tag, from hands, armour and inventory. (In a JSON file: thematic:unequip.)\n@param options item, tag; a field left out is the default, or the tuned value" }, { "name": "particles", "signatures": [ "particles(particle: ParticleSpec, options?: ParticlesOptions): void" ], "doc": "A burst of particles where it happens -- inside targets(), where the target stands -- or from a point on the wearer's body. (In a JSON file: thematic:particles.)\n@param particle a particle id, dust(color, scale), or \"block_below\": debris of the block underneath\n@param options count, spread, speed, yOffset, anchor, at, from, forward, color, system, aim, shape, radius, scatter, bursts; a field left out is the default, or the tuned value" }, { "name": "particleCircle", "signatures": [ "particleCircle(system: CircleSystem, options?: ParticleCircleOptions): void" ], "doc": "One of the particle circle systems, centred where it happens, on the spot markSpot fixed, or on a point of the wearer's body. (In a JSON file: thematic:particle_circle.)\n@param system which system (circle)\n@param options particle, height, radius, count, yOffset, blockCenter, at, from, forward, color; a field left out is the default, or the tuned value" }, { "name": "particleDome", "signatures": [ "particleDome(shape: DomeShape, options?: ParticleDomeOptions): void" ], "doc": "A hemisphere of particles, or part of one, centred where it happens, on the spot markSpot fixed, or on a point of the wearer's body. (In a JSON file: thematic:particle_dome.)\n@param shape which part (full_dome)\n@param options particle, radius, height, count, yOffset, at, anchor, from, forward, color; a field left out is the default, or the tuned value" }, { "name": "sound", "signatures": [ "sound(sound: string | SoundCycle, options?: SoundOptions): void" ], "doc": "Plays a sound. For one sound, a suit's options sound, volume, pitch and soundOffset still win (unless world). (In a JSON file: thematic:sound.)\n@param sound a sound id (\"minecraft:...\" or a Thematic sound name), or { cycle, key } for the next of a set\n@param options volume, pitch, delay, at, world, once, loop, stopOnExit, follow, voice, duration, gap, heardBy; a field left out is the default, or the tuned value" }, { "name": "stopSound", "signatures": [ "stopSound(sound: string | SoundCycle, options?: StopSoundOptions): void" ], "doc": "Stops a sound on the wearer's client and every client near them, at once. A suit's options sound is the one stopped, unless world. (In a JSON file: thematic:stop_sound.)\n@param sound the sound, or a set: every member stops\n@param options world; a field left out is the default, or the tuned value" }, { "name": "animation", "signatures": [ "animation(animation: string, options?: AnimationOptions): void" ], "doc": "Plays a suit animation clip. A suit's options.animation still wins for the wearer. A suit-wearing mob (a squad flier running a mob() block) plays it once on its own body, for everyone who can see it; hold, hold_for and first_person do nothing for it. (In a JSON file: thematic:animation.)\n@param animation the clip name\n@param options speed, on, fit, fadeIn, stopAfter, stopOnLeave, hold, play, then, blend, holdFor, priority, alternate, firstPerson; a field left out is the default, or the tuned value" }, { "name": "stopAnimation", "signatures": [ "stopAnimation(animation: string, options?: StopAnimationOptions): void" ], "doc": "Stops a clip, played or held. (In a JSON file: thematic:stop_animation.)\n@param animation the clip name; a suit's options.animation still wins for the wearer\n@param options on; a field left out is the default, or the tuned value" }, { "name": "gunClip", "signatures": [ "gunClip(clip: string): void" ], "doc": "Plays a clip on the gun in the wearer's main hand: one of the cues that gun declares, by name. The gun owns its own clips, so a move asks for the name and gets whatever the gun in hand calls it -- or nothing, when it has no cue by that name. First person only: the weapon model animates nowhere else, and the third person of the same beat is the wearer's own body (swingHand, or a suit clip). (In a JSON file: thematic:gun_clip.)\n@param clip the cue's name, as the gun's cue() declares it, e.g. \"bash\"" }, { "name": "assets", "signatures": [ "assets(key?: string): void" ], "doc": "Fires the suit's clips and sounds for this move from its options anims_ and sounds_, as the key press does. The press already fires anims_press and sounds_press once; assets(\"press\") fires them again, as moves that restarted the clip and doubled the sound at their own start did. (In a JSON file: thematic:assets.)\n@param key which options: \"press\" (default) for anims_press and sounds_press, \"release\" for anims_release ..." }, { "name": "claimPose", "signatures": [ "claimPose(options?: ClaimPoseOptions): void" ], "doc": "The move's clip drives the wearer's pose for a while, and any other move's claim is dropped. An ability with body({ while: \"animating\" }) holds its limbs for as long as the claim. (In a JSON file: thematic:claim_pose.)\n@param options for; a field left out is the default, or the tuned value" }, { "name": "releasePose", "signatures": [ "releasePose(): void" ], "doc": "Gives the wearer's pose back before the claim runs out. (In a JSON file: thematic:release_pose.)" }, { "name": "shot", "signatures": [ "shot(options?: ShotOptions): void" ], "doc": "Changes the arrow the answered arrow_loosed loosed, as it leaves the string: a harder hit, a critical, piercing, a command tag, who may pick it up. A patient shot: shot({ damageTimes: tuned(\"damage\"), critical: true, pierce: 1, tag: \"thematic_bullseye\" }). Nothing outside arrow_loosed. (In a JSON file: thematic:shot.)\n@param options damage, damageTimes, critical, pierce, tag, pickup; a field left out is the default, or the tuned value" }, { "name": "dropKept", "signatures": [ "dropKept(key: string): void" ], "doc": "Takes down the entity the wearer keeps under a store key -- the projectile a projectile's keep_as kept (a grapple's hook), a bow's tracked arrow -- if one is still out, and forgets it. dropKept(\"grapple_entity\"). (In a JSON file: thematic:drop_kept.)\n@param key the store key, as keep_as wrote it" }, { "name": "recallThrown", "signatures": [ "recallThrown(options?: RecallThrownOptions): void" ], "doc": "Turns every throwable the wearer has out for home now, by its own return (those of one definition when throwable names it). recallThrown({ throwable: \"thematic:my_throwable\" }). (In a JSON file: thematic:recall_thrown.)\n@param options throwable; a field left out is the default, or the tuned value" }, { "name": "projectile", "signatures": [ "projectile(body?: (hit: Actions) => void, onBlock?: (hit: Actions) => void): void", "projectile(options: ProjectileOptions, body?: (hit: Actions) => void, onBlock?: (hit: Actions) => void): void" ], "doc": "Fires or throws a projectile. A bolt body is an energy bolt (optic blasts, starbolts, crescents); a thrown body is a throwable definition's model and flight (vials, a cup of tea). on_hit runs aimed at the entity it strikes, on_block where it meets a block (or a thrown body's fuse runs out), each with the owner's tuned numbers as they are when it lands. (In a JSON file: thematic:projectile.)\n@param options body, entity, consumeHeld, carries, throwable, arrow, from, toward, aim, aimReach, pitch, at, count, perTarget, speed, spread, jitter, lift, inheritMotion, delay, latch, gravity, maxAge, pickup, shot, maxDistance, fuse, size, directHit, damage, effects, optionEffects, dedupe, pierce, return, onReturn, pierceOption, hitOnce, hittableOnly, ricochet, recoil, steer, contact, trail, hitSound, look, cycle, lead, spiral, pattern, formation, volleys, homing, hover, orbit, wobble, explodeOnImpact, byDefinition, color, keepAs; a field left out is the default, or the tuned value\n@param body run aimed at the entity it strikes, before the direct hit\n@param onBlock run where it meets a block, or where a thrown body's fuse runs out" }, { "name": "burst", "signatures": [ "burst(body?: (target: Actions) => void): void", "burst(options: BurstOptions, body?: (target: Actions) => void): void" ], "doc": "A blast going off at a point -- where a shot landed (the default), on the wearer, at a marked spot, or at random around one -- that hurts, doses and throws back everyone the wearer may hit within radius, with a flash and a bang. (In a JSON file: thematic:burst.)\n@param options at, from, radius, targetsAround, shape, hittable, exclude, damage, source, damageType, element, hitObjects, effect, knockback, particles, sound; a field left out is the default, or the tuned value\n@param body more for each body it catches, as inside targets()" }, { "name": "zone", "signatures": [ "zone(body: (standing: Actions) => void, first?: (standing: Actions) => void): void", "zone(options: ZoneOptions, body: (standing: Actions) => void, first?: (standing: Actions) => void): void" ], "doc": "A patch of ground that keeps biting: fixed where it is laid, every so often for a while it runs its actions on everyone standing in it -- first ones only the first time each body is caught. The first pulse comes one every after it is laid, the last at for: floor(for / every) pulses, at least one. Its numbers are read as each pulse lands. (In a JSON file: thematic:zone.)\n@param options at, floor, radius, height, footing, shape, every, for, hittable, caught; a field left out is the default, or the tuned value\n@param body run on everyone standing in it, every pulse\n@param first run before do, once per body: the first pulse that catches it" }, { "name": "markNode", "signatures": [ "markNode(key: string, options?: MarkNodeOptions): void" ], "doc": "Adds where the wearer stands to a trail kept for the rest of the press under a name: targets(\"trail\") searches around its nodes and decal({ along }) stains the last stretch of it. (In a JSON file: thematic:mark_node.)\n@param key the trail's name\n@param options max; a field left out is the default, or the tuned value" }, { "name": "markCaught", "signatures": [ "markCaught(key: string): void" ], "doc": "Counts the entity the action is about -- the target inside targets() -- as caught under a name, so a zone given the same caught skips its first actions for it. (In a JSON file: thematic:mark_caught.)\n@param key the catch's name" }, { "name": "decal", "signatures": [ "decal(block: string, body?: (standing: Actions) => void): void", "decal(block: string, options: DecalOptions, body?: (standing: Actions) => void): void" ], "doc": "Stains the floor with a block that is only shown, never placed: laid in lanes across the way the wearer faces, sampled every step along the last stretch of a trail (or at the spot), each on the first floor with a full top face within depth below. Every player sees each one for as long as it lasts, on the server's clock. With touch, whoever stands in one has those actions run on them, as the wearer, every touchEvery seconds of their own age. (In a JSON file: thematic:decal.)\n@param block the block phase, as a command writes it: \"thematic:blood_splatter[down=true]\"\n@param options along, facing, lanes, spacing, step, depth, max, lasts, tag, touchEvery, touchHittable; a field left out is the default, or the tuned value\n@param body run on whoever stands in a stain, aimed at them, while it lasts" }, { "name": "splash", "signatures": [ "splash(color: number | string | [number, number, number], options?: SplashOptions): void" ], "doc": "Liquid of a colour. Breaking at the spot: drops thrown out, a burst, a pool on the floor under it for a while and pool.splatter smaller ones up to pool.spread away. With drench: landing on the entity the action is about instead, over the chest and across the eyes. (In a JSON file: thematic:splash.)\n@param color 0x8CE01A, \"#8CE01A\", [r, g, b] or \"$name\" for one the press drew\n@param options at, pool, drench; a field left out is the default, or the tuned value" }, { "name": "track", "signatures": [ "track(name?: string, options?: TrackOptions): void", "track(options: TrackOptions): void" ], "doc": "Remembers a target across the move, with a synced copy of it the client can draw from (thematic:trail_to_target, thematic:target_readout) even once it is out of render distance. Inside targets(): starts tracking the one picked. Anywhere else: refreshes the copy of the one tracked -- run it in a phase's every(). stop: true lets go. Kept on the wearer under _target (and _name, _health, _bleed, _x, _y, _z, _since): scent_tracker's keys, which Keen Nose writes too. (In a JSON file: thematic:track.)\n@param name which track: lower_snake_case; left out, the ability's id\n@param options sync, resync, stop, glow; a field left out is the default, or the tuned value" }, { "name": "strikeSpray", "signatures": [ "strikeSpray(options?: StrikeSprayOptions): void" ], "doc": "Blood off a blade strike, inside targets(): each client that can see the wearer throws it off the blade nearest the wound, along the way that blade was travelling; one that can't sprays from the wound along aim. What every Wolverine move's hit threw. (In a JSON file: thematic:strike_spray.)\n@param options count, aim, particle, color; a field left out is the default, or the tuned value" }, { "name": "markDeadline", "signatures": [ "markDeadline(key: string, options?: MarkDeadlineOptions): void" ], "doc": "Stores a deadline on the wearer, synced: the world time plus for seconds. The until guard holds until it passes -- a lock that runs out by itself, with nothing to clear on death, logout or a move cut short: markDeadline(\"claw_stab_lock_until\", { for: 1.5 }) with requires({ not: { until: \"claw_stab_lock_until\" } }). (In a JSON file: thematic:mark_deadline.)\n@param key the key it is stored under, the one an until guard names\n@param options for; a field left out is the default, or the tuned value" }, { "name": "outgoingDamage", "signatures": [ "outgoingDamage(options?: OutgoingDamageOptions): void" ], "doc": "For a while, every hit the wearer deals carries amount * times + plus more -- negative for less -- folded into the hit as a phase's damageBonus is, but kept on the wearer with its own deadline, so it outlasts the phase and the press: outgoingDamage({ times: -0.1, for: 5 }) is a tenth off for five seconds. A later one under the same key replaces it; it runs out by itself, death and logout included. A hit's bonuses are summed and never total less than none, so a negative share only takes off what its other bonuses added. (In a JSON file: thematic:outgoing_damage.)\n@param options times, plus, for, melee, key, uses, heldTrait; a field left out is the default, or the tuned value" }, { "name": "phase", "signatures": [ "phase(options?: PhaseOptions): void" ], "doc": "The shared phase every intangible suit uses (intangibility's own phase: noclip movement, the shimmer, active: \"intangibility\"). phase() begins it until ended, phase({ for: 0.55 }) for that long, phase({ end: true }) ends it; beginning turns the body shimmer on and ending turns it off. phase({ density: \"hand\" }) only turns that part's shimmer on (value: false, off). Players only. (In a JSON file: thematic:phase.)\n@param options for, end, density, value; a field left out is the default, or the tuned value" }, { "name": "markHealth", "signatures": [ "markHealth(key: string): void" ], "doc": "Keeps the wearer's health plus absorption under a key, for the healthBelowMark guard: markHealth(\"my_charge_health\") on the press, until({ healthBelowMark: \"my_charge_health\" }, \"ready\", { check: \"before\" }) in the phase, and markHealth again in its every() so a heal raises the mark. Only a hit that really took health or absorption counts; one an immunity or resistance swallowed does not. (In a JSON file: thematic:mark_health.)\n@param key the key it is kept under, the one healthBelowMark names" }, { "name": "summon", "signatures": [ "summon(entity: string, body?: (summoned: Actions) => void): void", "summon(entity: string, options: SummonOptions, body?: (summoned: Actions) => void): void" ], "doc": "Brings in entities that belong to the wearer, placed around them and facing the way they face: summon(\"thematic:hologram\", { count: 3, arrangement: \"rear_arc\", radius: 3.6, health: 50, lasts: 20, mirror: { melee: 0.2 } }). An entity built to be summoned (thematic:hologram) also takes its owner, its lifespan, the echo and goes away when the wearer loses this ability; any other is only placed and given its health. The body runs at each one, aimed at it as at a target. (In a JSON file: thematic:summon.)\n@param entity the entity type id, e.g. \"thematic:hologram\"\n@param options count, arrangement, radius, stagger, offsets, scatter, target, velocity, every, damage, health, lasts, attributes, scales, display, floor, options, echoMelee, replace, like, at, spread, onto, anchors, hold, mirror, look, solid, hittable, hurtsOwner, tame, owner, creditOwner, tag, name, link, persistent, follow, defendOwner, assistOwner, neverTargetOwner, hostileTo, maxAlive, keepOne, topUp, dismissOnUnequip, mount, gear, levels, launch, scale, baby, shareDamageToOwner, tint; a field left out is the default, or the tuned value\n@param body more at each one as it arrives, as inside targets()" }, { "name": "takeItem", "signatures": [ "takeItem(item: string, options?: TakeItemOptions): void" ], "doc": "Takes up to count of an item out of the wearer's inventory, from the first stack of it found: an offering the move asks for. Nothing carried: nothing happens. (In a JSON file: thematic:take_item.)\n@param item an item id, or \"#ns:tag\" (a bare id is minecraft's)\n@param options count; a field left out is the default, or the tuned value" }, { "name": "give", "signatures": [ "give(item?: string, options?: GiveOptions): void", "give(options: GiveOptions): void" ], "doc": "Hands the wearer an item to keep: into the inventory (the ground when it is full), or onto a slot. Unlike equip() nothing takes it back -- unless tie names a move, when it carries that move's tag as an equipped item does: stripped while the move is not running, and discarded if dropped; or permanent, lasts or rounds say when it goes. (In a JSON file: thematic:give.)\n@param item the item id, e.g. \"minecraft:iron_sword\" (a bare id means thematic:); an item not registered (its pack missing) hands out nothing. Needed unless from says otherwise\n@param options from, count, slot, onlyIfEmpty, enchant, named, tie, displaced, permanent, lasts, rounds, gun, tint, nbt, who, required; a field left out is the default, or the tuned value" }, { "name": "disarm", "signatures": [ "disarm(options?: DisarmOptions): void" ], "doc": "Takes whatever is in both of a body's hands away -- inside targets(), the target's. What is taken lands on the floor, where a vanilla sword can be picked back up and a granted construct is discarded as any dropped one is. (In a JSON file: thematic:disarm.)\n@param options who, drop, lock; a field left out is the default, or the tuned value" }, { "name": "openConsole", "signatures": [ "openConsole(ability?: string, options?: OpenConsoleOptions): void", "openConsole(options: OpenConsoleOptions): void" ], "doc": "Opens the wearer's command console for an ability, in a mode (a pick mode of its own, e.g. \"strike\"). Run from a press, it is how one ability's key opens another's console. (In a JSON file: thematic:console_open.)\n@param ability the ability whose console opens; left out, the one running this\n@param options mode; a field left out is the default, or the tuned value" }, { "name": "closeConsole", "signatures": [ "closeConsole(ability?: string): void" ], "doc": "Closes the wearer's open command console. (In a JSON file: thematic:console_close.)\n@param ability left out, whichever is open" }, { "name": "delayPickups", "signatures": [ "delayPickups(options?: DelayPickupsOptions): void" ], "doc": "Holds the dropped items around the wearer out of reach: each one's pickup delay is set to seconds, so the wearer walks through them. Run it from every() to keep them off while a phase lasts; it runs out by itself after: every(e => e.delayPickups({ radius: 2, seconds: 0.5 })). (In a JSON file: thematic:delay_pickups.)\n@param options radius, seconds; a field left out is the default, or the tuned value" }, { "name": "ejectFromBlocks", "signatures": [ "ejectFromBlocks(options?: EjectFromBlocksOptions): void" ], "doc": "Lifts the wearer out of any block they are standing inside, straight up a block at a time, at most up blocks -- and leaves them where they are if none of those is clear. For a body going solid again where it may be inside a wall. (In a JSON file: thematic:eject_from_blocks.)\n@param options up; a field left out is the default, or the tuned value" }, { "name": "calm", "signatures": [ "calm(options?: CalmOptions): void" ], "doc": "Takes a mob's grudge away, inside targets(): it forgets who it was after and stops attacking; with stop, it also stops walking and stands where it is. A player is not a mob and is left alone -- hold one with effects. (In a JSON file: thematic:calm.)\n@param options stop, hostileOnly; a field left out is the default, or the tuned value" }, { "name": "provoke", "signatures": [ "provoke(options?: ProvokeOptions): void" ], "doc": "Sets a mob on something, inside targets(): one of the wearer's own bodies of the entity type within range (a decoy: an illusion, a summon), or the wearer when entity is left out (a classic taunt). A player is untouched -- turn them with lookAt. (In a JSON file: thematic:provoke.)\n@param options entity, within, pick; a field left out is the default, or the tuned value" }, { "name": "notify", "signatures": [ "notify(message: string, options?: NotifyOptions): void" ], "doc": "A message on a player's action bar, for them alone: how the move went, to the wearer, or what it did, to the one aimed at. A mob is told nothing. (In a JSON file: thematic:notify.)\n@param message a translation key, e.g. \"message.thematic.dracula.eyes_averted\"; text no translation has is shown as written\n@param options color, who, chat, decimals, args; a field left out is the default, or the tuned value" }, { "name": "offline", "signatures": [ "offline(options?: OfflineOptions): void" ], "doc": "Takes a player offline, a suit or system crash: they cannot fly (they fall normally) or use any move but a passive, sparks and smoke come off them, and their screen fills with static, until it runs out. A stronger crash replaces a weaker one. Never creative or spectator players; a mob is not affected. (In a JSON file: thematic:offline.)\n@param options ticks, intensity, who, cause, direct; a field left out is the default, or the tuned value" }, { "name": "loadoutCycle", "signatures": [ "loadoutCycle(inventory: string): void" ], "doc": "Steps the wearer's selection along a loadout's row -- backward while they sneak -- through the slots their suit reaches and the free default, skipping empty ones, and names what it landed on. The row is the one the suit's loadout part for that inventory keeps; with none worn, nothing happens. (In a JSON file: thematic:loadout_cycle.)\n@param inventory the loadout's inventory, e.g. \"gadgets\"" }, { "name": "loadoutUse", "signatures": [ "loadoutUse(inventory: string, options?: LoadoutUseOptions): void" ], "doc": "Uses the item selected in a loadout, as the item's own use would (a thrown gadget), and starts the ability's tuned cooldown when it did. With the free default or an item that is cooling down, the switch named by auto_swap (when on) moves on to the next item that is not; after a use it steps the selection on the same way. (In a JSON file: thematic:loadout_use.)\n@param inventory the loadout's inventory, e.g. \"gadgets\"\n@param options autoSwap; a field left out is the default, or the tuned value" }, { "name": "breakPattern", "signatures": [ "breakPattern(pattern?: BreakPattern, body?: (broke: Actions) => void): void", "breakPattern(pattern?: BreakPattern, options: BreakPatternOptions, body?: (broke: Actions) => void): void" ], "doc": "Breaks blocks: one, a plane, a cube, a vein, a tree and its leaves, or a line -- each one only where the wearer may break it (claims, spawn protection, protected worlds; mobGriefing for a mob). Unbreakable blocks are left. (In a JSON file: thematic:break_pattern.)\n@param pattern what it breaks (single)\n@param options at, reach, face, radius, orient, max, leaves, leafChance, drops, fortune, harvestableOnly, wearChance, tool, toolWear, length, offset, depth, advance, vein, fallThrough, skipBlockEntities, dropAt, countKey, filter, except, withProperty; a field left out is the default, or the tuned value\n@param body actions run once after, when it broke at least one block; the number broken is stored under count_key for them (and later steps) to read" }, { "name": "placeBlocks", "signatures": [ "placeBlocks(block: string, options?: PlaceBlocksOptions): void" ], "doc": "Places a block in a shape, where the wearer may build and only over what it may replace. (In a JSON file: thematic:place_blocks.)\n@param block the block id\n@param options at, reach, face, properties, replace, chance, lifespan, lasts, scheduleTick, max, shape, radius, height, below, thickness, topRadius; a field left out is the default, or the tuned value" }, { "name": "transformBlock", "signatures": [ "transformBlock(map?: { [from: string]: string }, options?: TransformBlockOptions): void", "transformBlock(options: TransformBlockOptions): void" ], "doc": "Turns blocks into others by a map -- water to ice, lava to obsidian, fire to air -- or into the block the answered event broke or used, keeping the properties both share (a log's axis), where the wearer may build. (In a JSON file: thematic:transform_block.)\n@param map what each block becomes: a block id or #tag to a block id; the first match wins. Needed unless to is given\n@param options at, reach, face, to, variant, pick, only, revertAfter, keepProperties, shape, radius, height, below, thickness, topRadius, filter, except, withProperty; a field left out is the default, or the tuned value" }, { "name": "placeLayeredBlock", "signatures": [ "placeLayeredBlock(block: string, options?: PlaceLayeredBlockOptions): void" ], "doc": "Adds a layer to a layered block (snow, ice sheets), or starts one on top of the block when that is something else -- only where the wearer may build, both on the block and above it. (In a JSON file: thematic:place_layered_block.)\n@param block the layered block's id\n@param options at, reach, face, property, max, scheduleTick; a field left out is the default, or the tuned value" }, { "name": "igniteBlock", "signatures": [ "igniteBlock(options?: IgniteBlockOptions): void" ], "doc": "What fire does to a block it hits, where the wearer may build: a player's fire smelts what smelts, lights candles and campfires, melts ice and snow, and sets flame beside what burns; anyone else's only sets the flame beside the face. (In a JSON file: thematic:ignite_block.)\n@param options at, reach, face; a field left out is the default, or the tuned value" }, { "name": "placeFire", "signatures": [ "placeFire(options?: PlaceFireOptions): void" ], "doc": "Places fire (soul fire on soul soil) in the air where fire can burn, where the wearer may build: in a shape around the block found, or in a line across the way the wearer faces. (In a JSON file: thematic:place_fire.)\n@param options at, reach, face, chance, lifespan, lasts, block, footing, line, shape, radius, height, below, thickness, topRadius; a field left out is the default, or the tuned value" }, { "name": "lightArea", "signatures": [ "lightArea(options?: LightAreaOptions): void" ], "doc": "Lights the air around a point for a while -- sent only to the players who can see it, so nothing in the world changes and nothing is left behind. (In a JSON file: thematic:light_area.)\n@param options at, reach, face, level, seconds, shape, radius, height, below, thickness, topRadius; a field left out is the default, or the tuned value" }, { "name": "powerBlock", "signatures": [ "powerBlock(options?: PowerBlockOptions): void" ], "doc": "Presses a block as the wearer would (a button, a lever, a door) when it answers a press; otherwise powers it, or lights it, for a moment. Only where the wearer may build. (In a JSON file: thematic:power_block.)\n@param options at, reach, face, interact, seconds; a field left out is the default, or the tuned value" }, { "name": "sit", "signatures": [ "sit(body?: (seated: Actions) => void): void", "sit(options: SitOptions, body?: (seated: Actions) => void): void" ], "doc": "Seats the owner (a player) on the block as a seat block does: they ride the seat already there, or one spawned offset_y above the block's floor. Getting off, or any change to the block, stands them up. do runs once they sit. (In a JSON file: thematic:sit.)\n@param options at, reach, face, offsetY; a field left out is the default, or the tuned value\n@param body run once they sit" }, { "name": "dropBlocks", "signatures": [ "dropBlocks(blocks: string | string[], body?: (landed: Actions) => void): void", "dropBlocks(blocks: string | string[], options: DropBlocksOptions, body?: (landed: Actions) => void): void" ], "doc": "Drops one vanilla falling block from above a random point within radius of the block found, when that spot is open air. Without place it vanishes where it comes down and drops nothing; with place it lands as a block where the wearer may build, and vanishes elsewhere. on_land runs where it came down either way: the air it came down in, on top of the ground, is the hit block, its centre the point. (In a JSON file: thematic:drop_blocks.)\n@param blocks the block, or blocks to pick one from at random (name one twice to drop it twice as often)\n@param options at, reach, face, radius, above, place; a field left out is the default, or the tuned value\n@param body actions where it came down: the lowest air at or under where it was last seen, within 6 blocks. There the spot is that point (targets with at: \"spot\" finds who it fell on); the press's stored numbers are not carried" }, { "name": "till", "signatures": [ "till(options?: TillOptions): void" ], "doc": "Tills the block: grass, dirt paths and dirt to farmland; coarse and rooted dirt to dirt. (In a JSON file: thematic:till.)\n@param options at, reach, face, wear, sound, shape, radius, height, below, thickness, topRadius; a field left out is the default, or the tuned value" }, { "name": "flatten", "signatures": [ "flatten(options?: FlattenOptions): void" ], "doc": "Flattens the block into a path: grass, dirt, mycelium, podzol, rooted and coarse dirt. A block used from underneath is left alone. (In a JSON file: thematic:flatten.)\n@param options at, reach, face, wear, sound, shape, radius, height, below, thickness, topRadius; a field left out is the default, or the tuned value" }, { "name": "strip", "signatures": [ "strip(options?: StripOptions): void" ], "doc": "Strips a log or wood to its stripped form, keeping its axis: vanilla's, other mods' and Thematic's own. (In a JSON file: thematic:strip.)\n@param options at, reach, face, wear, sound, shape, radius, height, below, thickness, topRadius; a field left out is the default, or the tuned value" }, { "name": "trimPlant", "signatures": [ "trimPlant(options?: TrimPlantOptions): void" ], "doc": "Stops a growing stem (kelp, vines, weeping and twisting vines) from growing further, as shears do. (In a JSON file: thematic:trim_plant.)\n@param options at, reach, face, wear, sound, shape, radius, height, below, thickness, topRadius; a field left out is the default, or the tuned value" }, { "name": "shear", "signatures": [ "shear(options?: ShearOptions): void" ], "doc": "Shears the entity inside targets() -- a sheep, a mooshroom, a snow golem -- if it can be sheared. (In a JSON file: thematic:shear.)\n@param options wear, bonus; a field left out is the default, or the tuned value" }, { "name": "cycleBlockProperty", "signatures": [ "cycleBlockProperty(mode?: PropertyCycleMode, options?: CycleBlockPropertyOptions): void", "cycleBlockProperty(options: CycleBlockPropertyOptions): void" ], "doc": "Steps one of the block's state properties to its next value (a door's facing, a rail's shape), or picks which one the next step turns. The pick is remembered per block in the stack the action runs for; with none picked, a facing, axis or side property goes first. Tells a player what changed, above the hotbar. (In a JSON file: thematic:cycle_block_property.)\n@param mode (auto)\n@param options at, reach, face, property, reverse, exclude, selectionKey, feedback, wear, sound, filter, except, withProperty; a field left out is the default, or the tuned value" }, { "name": "pull", "signatures": [ "pull(options?: PullOptions): void" ], "doc": "Draws the entity hit -- or, with radius, every living body within it but the owner -- toward a point: each pull adds strength along the line to it. Once, now; or with for, every tick from the next for that long, stopping when either end is gone or the body is within stop_within. Loose items too, with items. (In a JSON file: thematic:pull.)\n@param options toward, strength, radius, for, stopWithin, brake, jitter, anchorHeight, maxRise, point, beam, items; a field left out is the default, or the tuned value" }, { "name": "stackEffect", "signatures": [ "stackEffect(effect: string, options?: StackEffectOptions): void" ], "doc": "A status effect that builds up: put on fresh when the body has none, otherwise the running one grows longer -- and stronger, by steps or by levels of length -- and every client is told. (In a JSON file: thematic:stack_effect.)\n@param effect the status effect id, e.g. \"thematic:frozen\"\n@param options who, duration, amplifier, add, addRandom, maxDuration, amplifierAdd, maxAmplifier, levels, by, hold, gainEvery, gainClock, gainShared, ambient, showParticles, showIcon; a field left out is the default, or the tuned value" }, { "name": "air", "signatures": [ "air(amount?: Amount, options?: AirOptions): void", "air(options: AirOptions): void" ], "doc": "Adds breath to a body, or takes it: a drowning hit. (In a JSON file: thematic:air.)\n@param amount ticks of breath added; negative takes (-1)\n@param options who; a field left out is the default, or the tuned value" }, { "name": "pressRandomAbility", "signatures": [ "pressRandomAbility(options?: PressRandomAbilityOptions): void" ], "doc": "Presses one of a player's own moves for them, at random: any that could be pressed now, never an ultimate unless ultimates says so. A toggle picked is switched on. (In a JSON file: thematic:press_random_ability.)\n@param options who, ultimates, skipRunning; a field left out is the default, or the tuned value" }, { "name": "commandPets", "signatures": [ "commandPets(command: PetCommand, body?: (pet: Actions) => void): void", "commandPets(command: PetCommand, options: CommandPetsOptions, body?: (pet: Actions) => void): void" ], "doc": "Every animal tamed to the owner within range stands up and obeys: attacks the entity hit, rallies where the action happens, or comes back to the owner. (In a JSON file: thematic:command_pets.)\n@param command attack, rally or recall\n@param options range, entityType, tag, speed; a field left out is the default, or the tuned value\n@param body more at each animal, as inside targets()" }, { "name": "glowMark", "signatures": [ "glowMark(options?: GlowMarkOptions): void" ], "doc": "Marks the entity hit -- or everyone within radius but the owner and the owner's animals -- in the owner's name, for a time, with a glow: an expiry and the owner's UUID in the body's persistent data. The mark verb (thematic:mark) under its first name; only its owner key's default differs. (In a JSON file: thematic:glow_mark.)\n@param options key, ownerKey, for, keepLonger, glow, seenBy, vfx, radius; a field left out is the default, or the tuned value" }, { "name": "deflectProjectile", "signatures": [ "deflectProjectile(options?: DeflectProjectileOptions): void" ], "doc": "Turns a projectile back -- the entity hit, or the one a projectile_incoming reaction answers -- and makes it the wearer's. (In a JSON file: thematic:deflect_projectile.)\n@param options direction, own; a field left out is the default, or the tuned value" }, { "name": "catchProjectile", "signatures": [ "catchProjectile(options?: CatchProjectileOptions): void" ], "doc": "Takes a projectile -- the entity hit, or the one a projectile_incoming reaction answers -- out of the world; an arrow or spectral arrow that could be picked up goes into the wearer's inventory. (In a JSON file: thematic:catch_projectile.)\n@param options give; a field left out is the default, or the tuned value" }, { "name": "absorbProjectiles", "signatures": [ "absorbProjectiles(options?: AbsorbProjectilesOptions): void" ], "doc": "Takes every projectile within reach of the wearer's middle out of the world -- and one that would cross into it before the next tick, so a fast bullet doesn't slip through -- unless the wearer or a teammate shot it; clients see where each was absorbed, so a shield there ripples. Run every tick for a wall projectiles don't get through. (In a JSON file: thematic:absorb_projectiles.)\n@param options within, pane; a field left out is the default, or the tuned value" }, { "name": "resetFallDistance", "signatures": [ "resetFallDistance(options?: ResetFallDistanceOptions): void" ], "doc": "A body forgets how far it has fallen, so its landing does not hurt. (In a JSON file: thematic:reset_fall_distance.)\n@param options who; a field left out is the default, or the tuned value" }, { "name": "captureEntity", "signatures": [ "captureEntity(options?: CaptureEntityOptions): void" ], "doc": "Stores the entity hit in the owner's holder item and removes it from the world. Never a player or the owner; where the owner may not grief it is refused with a message. Resets the item's cooldown. (In a JSON file: thematic:capture_entity.)\n@param options item, inventories, key, whenFull, discardSource, denyMessage; a field left out is the default, or the tuned value" }, { "name": "releaseEntity", "signatures": [ "releaseEntity(options?: ReleaseEntityOptions): void" ], "doc": "Lets the entity the owner's holder item stores out where the action happens, and empties it. (In a JSON file: thematic:release_entity.)\n@param options item, inventories, key, up, discardSource; a field left out is the default, or the tuned value" }, { "name": "throwHeld", "signatures": [ "throwHeld(body?: (thrown: Actions) => void): void", "throwHeld(options: ThrowHeldOptions, body?: (thrown: Actions) => void): void" ], "doc": "Throws the stack the actions run for (an item hook's), else the owner's main-hand item from the owner's eyes along their look, as a throwables definition or an entity, and takes what it threw from the stack outside creative: one, or with count a fan of several at once. Its do runs aimed at each thing thrown. (In a JSON file: thematic:throw_held.)\n@param options throwable, entity, velocity, divergence, consume, sound, count, spread, clip; a field left out is the default, or the tuned value\n@param body run aimed at each thrown entity" }, { "name": "stopUsing", "signatures": [ "stopUsing(options?: StopUsingOptions): void" ], "doc": "The body lets go of the item it is using, as a released key does (the item's release runs): a drill out of charge stops. Nothing when it is using none. (In a JSON file: thematic:stop_using.)\n@param options who; a field left out is the default, or the tuned value" }, { "name": "riptide", "signatures": [ "riptide(level?: number, options?: RiptideOptions): void", "riptide(options: RiptideOptions): void" ], "doc": "Launches the owner (a player) as a Riptide trident does, and puts the stack's item on cooldown. (In a JSON file: thematic:riptide.)\n@param level the Riptide level: 1 to 3 as vanilla's, stronger above; left out, the stack's own Riptide, else 3\n@param options keepHorizontal, cooldown; a field left out is the default, or the tuned value" }, { "name": "enchantHeld", "signatures": [ "enchantHeld(options?: EnchantHeldOptions): void" ], "doc": "Keeps enchantments on the stack the actions run for (an item hook's), else the owner's main-hand item: when it lacks one (or has it at another level) they are put on, after taking every other enchantment off unless replace is false. (In a JSON file: thematic:enchant_held.)\n@param options enchantments, when, otherwise, replace; a field left out is the default, or the tuned value" }, { "name": "itemCooldown", "signatures": [ "itemCooldown(seconds: number, options?: ItemCooldownOptions): void" ], "doc": "Puts an item on the owner's cooldown, as an ender pearl is: the stack's, or item. (In a JSON file: thematic:item_cooldown.)\n@param seconds how long\n@param options item; a field left out is the default, or the tuned value" }, { "name": "triggerItemAnim", "signatures": [ "triggerItemAnim(controller: string, options?: TriggerItemAnimOptions): void" ], "doc": "Plays a triggerable GeckoLib clip on the stack the actions run for (an item hook's), else the owner's main-hand item, for every client. (In a JSON file: thematic:trigger_item_anim.)\n@param controller the controller's name, e.g. \"Hammer\"\n@param options clip, hand; a field left out is the default, or the tuned value" }, { "name": "useAbility", "signatures": [ "useAbility(ability: string): void" ], "doc": "Presses one of the owner's kit abilities by id, as its key would: a press presses, a toggle flips, a hold starts. A disabled or dampened ability is refused as the key is. (In a JSON file: thematic:use_ability.)\n@param ability the ability id, e.g. \"hammer_throw\"" }, { "name": "wear", "signatures": [ "wear(amount?: number): void" ], "doc": "Takes durability off the stack the actions run for (an item hook's), else the owner's main-hand item, breaking it with the usual sound when it runs out. (In a JSON file: thematic:wear.)\n@param amount (1)" }, { "name": "stackStrike", "signatures": [ "stackStrike(): void" ], "doc": "A stack strikes the target inside targets(), or what a thrown body hit: the item's own hit (a data construct's on_hit), then the main-hand attack damage its modifiers add, as the owner's mob attack. The stack is the one a thrown body carries (thrown_item, or a projectile that carries one), else the stack the actions run for (an item hook's), else the owner's main-hand item. (In a JSON file: thematic:stack_strike.)" }, { "name": "consumeGauge", "signatures": [ "consumeGauge(amount: number, body?: (spent: Actions) => void, otherwise?: (spent: Actions) => void): void", "consumeGauge(amount: number, options: ConsumeGaugeOptions, body?: (spent: Actions) => void, otherwise?: (spent: Actions) => void): void" ], "doc": "Spends an ability's charge (a lantern's power): do runs when there was enough, else when there was not (and nothing is spent). (In a JSON file: thematic:consume_gauge.)\n@param amount how much\n@param options ability; a field left out is the default, or the tuned value\n@param body run when it was spent\n@param otherwise run when there was not enough" }, { "name": "refillGauge", "signatures": [ "refillGauge(ability?: string, body?: (filled: Actions) => void, otherwise?: (filled: Actions) => void): void" ], "doc": "Fills an ability's charge (a lantern's power) back up to its most, as a power battery does; the charge tells the player how it went. do runs when it filled, else when it was already full or there was no charge. (In a JSON file: thematic:refill_gauge.)\n@param ability the charge ability's id; left out, the first charge ability of the owner's kit\n@param body run when it filled\n@param otherwise run when it was full, or there was no charge" }, { "name": "takeHeld", "signatures": [ "takeHeld(count?: number, options?: TakeHeldOptions): void", "takeHeld(options: TakeHeldOptions): void" ], "doc": "Takes some of what the owner holds, outside creative: the ingredient a block is repaired with. Nothing when the hand is empty. (In a JSON file: thematic:take_held.)\n@param count how many (1); a smaller stack gives what it has\n@param options hand; a field left out is the default, or the tuned value" }, { "name": "stackState", "signatures": [ "stackState(key: string, options?: StackStateOptions): void" ], "doc": "Changes one key of the stack the actions run for (an item hook's), else the owner's main-hand item's own state: its counters, flags, gauges and timers, which the guards stackCounter, stackFlag, stackGauge and stackTimer read. (In a JSON file: thematic:stack_state.)\n@param key the name the value is kept under\n@param options op, value, wrap, min, max, seconds; a field left out is the default, or the tuned value" }, { "name": "wave", "signatures": [ "wave(body: (caught: Actions) => void): void", "wave(options: WaveOptions, body: (caught: Actions) => void): void" ], "doc": "A ring spreading out from a centre over the ground, on the server's clock once it goes off: every `every` seconds, starting at once at radius 0, it runs do on everyone whose feet are within band of its front, measured straight from the centre, and no more than height above or below it -- while its radius is under maxRadius. Lightning Boom's ring: {from: \"self\", speed: 2.4, maxRadius: 96, band: 3, height: 2.125, once: false}. With along it is a front running out along a line instead, from the wearer's eyes (or the spot), out to maxRadius or the first block in the way, running do on everyone it passes within width of the line: Caped Colony's line of bats, {along: \"look\", speed: 0.8, maxRadius: 20, width: 1.2, vfx: \"thematic:bat_stream\"}. (In a JSON file: thematic:wave.)\n@param options from, along, width, vfx, speed, maxRadius, band, height, once, every, hittable; a field left out is the default, or the tuned value\n@param body run on each one the front passes, aimed at them" }, { "name": "after", "signatures": [ "after(seconds: Amount, body: (later: Actions) => void): void", "after(seconds: Amount, options: AfterOptions, body: (later: Actions) => void): void" ], "doc": "Runs do a little later, on the same context -- inside targets(), on the same target, which must still be alive then (unless survive), as must the wearer. Keeps running on the server's clock whatever the press does meanwhile. (In a JSON file: thematic:after.)\n@param seconds how long to wait\n@param options survive; a field left out is the default, or the tuned value\n@param body what to run once the time is up" }, { "name": "unlink", "signatures": [ "unlink(key?: string): void" ], "doc": "The wearer forgets the id kept under a link key -- a summon's link -- whether or not the mob is still there: what a companion's death leaves to tidy. (In a JSON file: thematic:unlink.)\n@param key the data key, e.g. \"companion_wolf_uuid\"" }, { "name": "command", "signatures": [ "command(order: CommandOrder, body?: (none: Actions) => void): void", "command(order: CommandOrder, options: CommandOptions, body?: (none: Actions) => void): void" ], "doc": "An order to the wearer's own mobs. Which of the wearer's mobs: select (owned: every mob tamed to them or naming them as its owner; companions: only the companion, tagged thematic_companion), types, tag and link narrow it, radius is how far from the wearer (48); with link, radius 0 finds the linked one wherever it is loaded in the wearer's world. else runs when attack finds nothing to go for, or when the wearer has none of those mobs: command(\"attack\", { at: [\"nearest_marked\", \"aimed\"], types: \"wolf\" }). (In a JSON file: thematic:command.)\n@param order what they do\n@param options at, range, seconds, share, move, spread, idleOnly, mob, speed, stopAt, reach, handover, carry, pull, beyond, select, types, tag, link, radius; a field left out is the default, or the tuned value\n@param body what happens when there is nothing to go for or nobody to tell" }, { "name": "tame", "signatures": [ "tame(body?: (untamed: Actions) => void): void", "tame(options: TameOptions, body?: (untamed: Actions) => void): void" ], "doc": "Tames the target the action is aimed at to the wearer -- a wild wolf, cat or parrot, a horse -- healing it first. Anything already tamed, dead or that can't be tamed runs else instead. (In a JSON file: thematic:tame.)\n@param options heal; a field left out is the default, or the tuned value\n@param body what happens when it can't be tamed" }, { "name": "breed", "signatures": [ "breed(body?: (animal: Actions) => void, otherwise?: (animal: Actions) => void): void" ], "doc": "Puts the target the action is aimed at into love mode for the wearer, as if fed its food: a grown animal that is ready to breed, then runs do. A young one, one already in love or cooling off, or anything else runs else instead. (In a JSON file: thematic:breed.)\n@param body what happens once it is in love\n@param otherwise what happens when it can't breed" }, { "name": "attract", "signatures": [ "attract(kind: AttractKind, options?: AttractOptions): void" ], "doc": "Draws what lies within radius toward the wearer: items and experience through the air, to be picked up; animals walk over, unless already walking somewhere. (In a JSON file: thematic:attract.)\n@param kind what it draws\n@param options filter, radius, speed, settle, babies; a field left out is the default, or the tuned value" }, { "name": "ownedMobs", "signatures": [ "ownedMobs(select: OwnedSelect, body: (mob: Actions) => void, otherwise?: (mob: Actions) => void): void", "ownedMobs(select: OwnedSelect, options: OwnedMobsOptions, body: (mob: Actions) => void, otherwise?: (mob: Actions) => void): void" ], "doc": "Runs do at each of the wearer's own mobs, aimed at it as targets() aims at each one it picks -- buffs for the pack, a heal for the companion -- or else once when there are none: ownedMobs(\"owned\", { types: \"wolf\" }, wolf => wolf.effect(\"minecraft:strength\", { duration: 1.5, amplifier: 1 })). Which of the wearer's mobs: select (owned: every mob tamed to them or naming them as its owner; companions: only the companion, tagged thematic_companion), types, tag and link narrow it, radius is how far from the wearer (48); with link, radius 0 finds the linked one wherever it is loaded in the wearer's world. (In a JSON file: thematic:owned_mobs.)\n@param select which of the wearer's mobs: owned or companions\n@param options types, tag, link, radius, pick; a field left out is the default, or the tuned value\n@param body what happens at each one, aimed at it\n@param otherwise what happens once when the wearer has none" }, { "name": "quarry", "signatures": [ "quarry(options?: QuarryOptions): void" ], "doc": "Breaks the matching blocks around a point, working outwards -- each only if the wearer's own tool could harvest it (a mob: only blocks that need no tool) and they may break it there -- and drops what they held at the wearer's feet. Extra Fortune goes on a copy of the held tool; the real one is not touched. (In a JSON file: thematic:quarry.)\n@param options at, reach, face, radius, max, fortune, filter, except, withProperty; a field left out is the default, or the tuned value" }, { "name": "findBlock", "signatures": [ "findBlock(filter: string | string[], body?: (found: Actions) => void): void", "findBlock(filter: string | string[], options: FindBlockOptions, body?: (found: Actions) => void): void" ], "doc": "Finds the matching block nearest the point, in the cube radius around it: fixes it as the spot (at: \"spot\" later in the same press), stores it under key for a visual, and tells the wearer with notify. do runs at each matching block, working outwards. Nothing found: nothing happens, and required calls the list off. (In a JSON file: thematic:find_block.)\n@param filter what it looks for: block ids and #tags\n@param options at, reach, face, radius, max, key, required, notify, all, except, withProperty; a field left out is the default, or the tuned value\n@param body actions at each matching block: the block is the hit, its centre the point" }, { "name": "replant", "signatures": [ "replant(options?: ReplantOptions): void" ], "doc": "A grown crop that was just broken goes back as a seedling, paid for with one of its own seeds from the drops lying around it, where the wearer may build. Answers block_broken; outside it, the block hit. (In a JSON file: thematic:replant.)\n@param options radius, filter, except, withProperty; a field left out is the default, or the tuned value" }, { "name": "collectDrops", "signatures": [ "collectDrops(options?: CollectDropsOptions): void" ], "doc": "Brings the items lying around the block -- the event's, or the block hit -- to the wearer's feet (or the spot), still, ready to be picked up at once. (In a JSON file: thematic:collect_drops.)\n@param options radius, to; a field left out is the default, or the tuned value" }, { "name": "extraDrops", "signatures": [ "extraDrops(options?: ExtraDropsOptions): void" ], "doc": "Rolls the block's drops again -- the block the event broke, or the block hit -- with the wearer's main-hand tool, for more of them where it stood. (In a JSON file: thematic:extra_drops.)\n@param options rolls, aboveSame, filter, except, withProperty; a field left out is the default, or the tuned value" }, { "name": "useItemOn", "signatures": [ "useItemOn(item: string, options?: UseItemOnOptions): void" ], "doc": "Uses an item on a block as if the wearer held one -- bone meal grows what it grows, flint and steel lights what it lights -- where they may build. The held stack is not touched. (In a JSON file: thematic:use_item_on.)\n@param item the item id\n@param options at, reach, face, consume; a field left out is the default, or the tuned value" }, { "name": "lightTrail", "signatures": [ "lightTrail(options?: LightTrailOptions): void" ], "doc": "One tick of a trail of light following the wearer: a light in the air where they stand (or the nearest air), a new one each time they move on, the newest few kept, each gone lasts seconds after it was put down. Sent only to the players who can see it; nothing in the world changes. Run it every tick while it should glow, and with stop once it should not. (In a JSON file: thematic:light_trail.)\n@param options level, max, lasts, stop; a field left out is the default, or the tuned value" }, { "name": "meter", "signatures": [ "meter(key: string, options?: MeterOptions): void" ], "doc": "One change to a meter kept on the wearer (declared by a meter part; a key nothing declared is a plain amount with no cap): add, consume (a spend, only when what is left keeps the reserve), cost (the same, but not being able to pay calls off the rest of the list), set, refill (to its max) -- or, for a window, open and close. A failed consume, cost or refill says fail_message. meter(\"green_ringCharge\", { cost: 40, failMessage: \"Not enough green!\", failChance: 0.05 }); meter(\"pact_momentum\", { open: { for: 1.5, onRefresh: \"bank\" } }). (In a JSON file: thematic:meter.)\n@param key the meter's key\n@param options add, consume, cost, set, refill, open, close, who, failMessage, failChance, color; a field left out is the default, or the tuned value" }, { "name": "driveMeter", "signatures": [ "driveMeter(key: string, options?: DriveMeterOptions): void" ], "doc": "Run every tick: an amount meter fills over fill seconds while a watched move is active and drains at drain times that speed otherwise -- a cooldown that builds while a move runs. driveMeter(\"cooldown_fill\", { watchOption: \"watches\", fill: 5, endAtFull: true }). (In a JSON file: thematic:drive_meter.)\n@param key the meter's key (an amount)\n@param options fill, watch, watchOption, drain, endAtFull; a field left out is the default, or the tuned value" }, { "name": "meterSpend", "signatures": [ "meterSpend(key: string, options?: MeterSpendOptions): void" ], "doc": "Spends a window whole -- the only way to, and it always closes -- and lets the openings banked into it as $charges (0 when nothing was open), for the rest of the list: meterSpend(\"pact_momentum\", { keepOwn: true }) then if({ ... }) on \"$charges\". Spend only after the move has committed, or a press that did nothing eats the window. An amount is spent down to its reserve, and $charges is what was taken. (In a JSON file: thematic:meter_spend.)\n@param key the meter's key\n@param options store, keepOwn, required; a field left out is the default, or the tuned value" }, { "name": "vfx", "signatures": [ "vfx(id: string, options?: VfxOptions): void" ], "doc": "Plays a VFX preset (a vfx/.json file) where the action happens: at the target inside targets(), the wearer otherwise. vfx(\"thematic:circle_ring\") plays it as the file says; to points it at somewhere and makes it as long as the gap (a ray, a blink's trail), direction points it a way keeping its own length, radius and height resize it. With a session it is held (a hold or loop preset) until vfx(id, { session, stop: true }). The old upper-case names work as ids (\"SONAR_BEAM\" is thematic:sonar_beam). (In a JSON file: thematic:vfx.)\n@param id the preset's id, e.g. \"thematic:dome\"\n@param options at, from, forward, anchor, to, direction, radius, height, duration, session, stop, layers, wisps, fadeIn, fadeOut, hand, follow, color, density; a field left out is the default, or the tuned value" }, { "name": "shake", "signatures": [ "shake(options?: ShakeOptions): void" ], "doc": "Shakes the camera of every player within radius of where it happens -- the target inside targets(), the spot with at: \"spot\" -- easing out over duration, harder the nearer they stand (a quarter as hard at the edge): shake({ at: \"spot\", radius: 16, strength: 2, duration: 0.6 }) for a slam landing. (In a JSON file: thematic:shake.)\n@param options radius, strength, duration, at, from, forward, style, direction, kick, to; a field left out is the default, or the tuned value" }, { "name": "hitstop", "signatures": [ "hitstop(options?: HitstopOptions): void" ], "doc": "A visual freeze of 30 to 120 ms, for a landed hit or a grab: the picture holds and then melts back, while the game itself keeps running (nothing is paused or delayed). At most one every quarter second. (In a JSON file: thematic:hitstop.)\n@param options duration, to; a field left out is the default, or the tuned value" }, { "name": "fovPunch", "signatures": [ "fovPunch(options?: FovPunchOptions): void" ], "doc": "The field of view kicks by delta degrees and springs back, with no overshoot: negative narrows it (a grab, a pull in), positive widens it (a shockwave). Scaled by the player's FOV Effects setting. (In a JSON file: thematic:fov_punch.)\n@param options delta, duration, to; a field left out is the default, or the tuned value" }, { "name": "screenFlash", "signatures": [ "screenFlash(options?: ScreenFlashOptions): void" ], "doc": "A flash of colour over the screen that peaks at once and falls off exponentially in a few frames, never held and never fully opaque. Skipped for players who hide lightning flashes, and softened by the reduced-flash setting; at most three a second. (In a JSON file: thematic:screen_flash.)\n@param options color, alpha, duration, to; a field left out is the default, or the tuned value" }, { "name": "overlay", "signatures": [ "overlay(options?: OverlayOptions): void" ], "doc": "A texture, or a flat colour, laid over the screen for a while to one player, easing in and out and optionally throbbing. (The ability visual thematic:screen_overlay is the always-on-while-active form.) (In a JSON file: thematic:overlay.)\n@param options texture, color, alpha, duration, fadeIn, fadeOut, pulse, blend, to; a field left out is the default, or the tuned value" }, { "name": "grade", "signatures": [ "grade(options?: GradeOptions): void" ], "doc": "Grades the colour of the world -- not the HUD -- eased in and out: desaturate it, optionally keeping one hue in colour (grade({ keepHue: \"red\" }) for a grey world with red left in it), with contrast, a tint and lifted shadows. A new grade while one runs glides into it. (In a JSON file: thematic:grade.)\n@param options desaturate, keepHue, hueWidth, contrast, tint, tintAmount, lift, duration, fadeIn, fadeOut, to; a field left out is the default, or the tuned value" }, { "name": "letterbox", "signatures": [ "letterbox(options?: LetterboxOptions): void" ], "doc": "Black cinema bars at the top and bottom of the screen that ease in to a height and back out. (In a JSON file: thematic:letterbox.)\n@param options height, duration, fadeIn, fadeOut, to; a field left out is the default, or the tuned value" }, { "name": "fog", "signatures": [ "fog(options?: FogOptions): void" ], "doc": "Closes the view in with fog to a distance, optionally toward a colour, eased in and out; never further out than the world's own fog, and left alone underwater and in lava. A new fog while one runs glides into it. (In a JSON file: thematic:fog.)\n@param options end, start, color, colorAmount, duration, fadeIn, fadeOut, to; a field left out is the default, or the tuned value" }, { "name": "muffle", "signatures": [ "muffle(options?: MuffleOptions): void" ], "doc": "Ducks the game's audio -- everything but interface sounds -- smoothly, as if heard through a wall. (A volume duck, not a filter.) (In a JSON file: thematic:muffle.)\n@param options amount, duration, fadeIn, fadeOut, to; a field left out is the default, or the tuned value" }, { "name": "filmGrain", "signatures": [ "filmGrain(options?: FilmGrainOptions): void" ], "doc": "Animated film grain over the world, with optional scanlines and static. Slowed and softened for players with the reduced-flash setting. (In a JSON file: thematic:film_grain.)\n@param options amount, scanlines, static, duration, fadeIn, fadeOut, to; a field left out is the default, or the tuned value" }, { "name": "screenLookAt", "signatures": [ "screenLookAt(options?: ScreenLookAtOptions): void" ], "doc": "Draws the player's look round to a point, smoothly, on their own client (no rotation packet from the server): it eases onto the point, holds there, and is let go. At strength 1 the player cannot turn away from it while it holds; below 1 the pull only takes the view that share of the way and lets their own turning through. Their look stays where it was drawn when it is let go. A new screen_look_at while one runs glides to the new point. (In a JSON file: thematic:screen_look_at.)\n@param options at, up, strength, duration, easeIn, hold, easeOut, to; a field left out is the default, or the tuned value" }, { "name": "cinematicHud", "signatures": [ "cinematicHud(options?: CinematicHudOptions): void" ], "doc": "Hides the whole HUD (hotbar, health, crosshair, boss bars, chat, effect icons, ability HUDs) like F1 for a cinematic beat, then restores it. The screen effects (bars, flashes, overlays, grade, grain) keep drawing. Ended by screenClear(), death or a disconnect. (In a JSON file: thematic:cinematic_hud.)\n@param options duration, fade, to; a field left out is the default, or the tuned value" }, { "name": "disorient", "signatures": [ "disorient(options?: DisorientOptions): void" ], "doc": "A drunken sway of the view: the head rolls and nods slowly, the field of view breathes, and the sound goes dull (ringing), easing in and out. Softened for players with the reduced-flash setting. (In a JSON file: thematic:disorient.)\n@param options amount, muffle, duration, fadeIn, fadeOut, to; a field left out is the default, or the tuned value" }, { "name": "screenSplat", "signatures": [ "screenSplat(options?: ScreenSplatOptions): void" ], "doc": "Gobs of sticky mass flung onto one player's screen from its edges -- irregular blobs, thick in the middle, joined by stringy tendrils, heaviest across the lower half -- held, then sliding down in drips as they fade: a face full of webbing, goo or mud. Drawn, not a texture, and different every time. (In a JSON file: thematic:screen_splat.)\n@param options color, alpha, coverage, count, duration, fadeOut, drip, to; a field left out is the default, or the tuned value" }, { "name": "screenJolt", "signatures": [ "screenJolt(options?: ScreenJoltOptions): void" ], "doc": "Jagged lines jolting in from one player's screen edges, flickering and re-jagging, pulsing a few times over its length and thickest on the side a threat lies: a sense of danger, a static shock. With from, it says where: screenJolt({ from: \"target\" }) inside a targets() body gathers them toward that body. (In a JSON file: thematic:screen_jolt.)\n@param options color, alpha, count, reach, duration, pulses, from, to; a field left out is the default, or the tuned value" }, { "name": "screenClear", "signatures": [ "screenClear(options?: ScreenClearOptions): void" ], "doc": "Eases out a sustained screen effect early, or all of them (and any freeze) at once. (In a JSON file: thematic:screen_clear.)\n@param options effect, fade, to; a field left out is the default, or the tuned value" }, { "name": "drain", "signatures": [ "drain(options?: DrainOptions): void" ], "doc": "Wears a body's health down in steps, from what it is when this runs toward a floor, and never past it: direct health, no damage (no flinch, no armour), and never below half a heart, so it cannot kill. A body already at or under the floor is left alone. On a player each step throbs a red vignette. A second drain on the same body replaces the first. (In a JSON file: thematic:drain.)\n@param options to, floor, duration, every, pulse, stop; a field left out is the default, or the tuned value" }, { "name": "bookPose", "signatures": [ "bookPose(options?: BookPoseOptions): void" ], "doc": "Eases the floating book of the mission's anchor block (the book visual) to a pose for the player it is aimed at, holds it, and eases it back to normal when the duration ends; a private run's book moves only for its participant. A new pose eases from whatever the book is showing. (In a JSON file: thematic:book_pose.)\n@param options to, at, height, spin, tilt, open, flipSpeed, shake, duration, easeIn, easeOut; a field left out is the default, or the tuned value" }, { "name": "pageBurst", "signatures": [ "pageBurst(options?: PageBurstOptions): void" ], "doc": "Parchment pages fly out of the floating book (the anchor's, or the point's) for one player: they spray, flutter down on paper physics, tint from one colour to another and fade. Starts at the book's current posed height. (In a JSON file: thematic:page_burst.)\n@param options to, at, count, speed, spread, duration, colorFrom, colorTo, colorDelay, texture; a field left out is the default, or the tuned value" }, { "name": "leashPause", "signatures": [ "leashPause(options?: LeashPauseOptions): void" ], "doc": "For a while a player in a mission with a pull-back leash is not pulled back, so a blast that throws them clear of the fight is allowed to carry them; the pull takes over again afterwards. (In a JSON file: thematic:leash_pause.)\n@param options seconds, to; a field left out is the default, or the tuned value" }, { "name": "fakeCrater", "signatures": [ "fakeCrater(options?: FakeCraterOptions): void" ], "doc": "A crater made of nothing but looks: cracks spread out from the impact over a few ticks, some blocks turn into broken versions of themselves, debris flies and dust rises. Seen by one player only; the world is not changed and the ground feels exactly as solid. It heals outward by itself after lasts. (In a JSON file: thematic:fake_crater.)\n@param options at, reach, face, radius, depthVisual, debris, crackStage, lasts, heal, spread, audience; a field left out is the default, or the tuned value" }, { "name": "fakeCrackLine", "signatures": [ "fakeCrackLine(options?: FakeCrackLineOptions): void" ], "doc": "A crack racing along the ground from one point to another, widest at the start and tapering, with the odd broken block and chunks kicked up along it. One player's screen only. (In a JSON file: thematic:fake_crack_line.)\n@param options from, to, reach, length, width, crackStage, debris, lasts, heal, audience; a field left out is the default, or the tuned value" }, { "name": "fakeSplinter", "signatures": [ "fakeSplinter(options?: FakeSplinterOptions): void" ], "doc": "Breaks leaves, fences, walls and glass within a radius as fakes: they vanish from one player's screen and fly apart. Only what the palettes allow (data//fake_palettes): leaves anywhere (they come back the moment the viewer gets near), fences, walls and glass only where the top is two or more above the ground the viewer can stand on; a fence the viewer could walk into is cracked instead. Call it again as something passes to splinter a path. (In a JSON file: thematic:fake_splinter.)\n@param options at, reach, face, radius, chance, max, debris, lasts, heal, audience; a field left out is the default, or the tuned value" }, { "name": "debrisBurst", "signatures": [ "debrisBurst(options?: DebrisBurstOptions): void" ], "doc": "Flying block chunks for one player: cut from the block's texture, thrown with weight (the heavier ones fly lower, tumble slowly and land with a thud), bounce once or twice, lie still, then fade. Made on the client; no entities. (In a JSON file: thematic:debris_burst.)\n@param options at, reach, face, count, speed, spread, size, rest, block, direction, audience; a field left out is the default, or the tuned value" }, { "name": "fakeRevert", "signatures": [ "fakeRevert(options?: FakeRevertOptions): void" ], "doc": "Puts a player's fake world back: every fake block and crack at once, or healing outward in a ring from a point, a puff of dust at each block as the real one returns. (In a JSON file: thematic:fake_revert.)\n@param options mode, from, reach, speed, audience; a field left out is the default, or the tuned value" }, { "name": "mark", "signatures": [ "mark(key?: string, options?: MarkOptions): void", "mark(options: MarkOptions): void" ], "doc": "Marks the target the action is aimed at in the wearer's name, for a while: kept on the body, so anything can ask whose it is (the markedBy guard). Renewing a mark keeps it the wearer's; marking one another wearer holds takes it over. With radius, marks everything in that box around the action but the wearer and their own animals. The hunter's quarry: mark({ key: \"quarry_mark\", vfx: \"HUNT_MARK\" }). (In a JSON file: thematic:mark.)\n@param key what the mark is kept under, lower_snake_case (\"mark\"); the one markedBy names\n@param options ownerKey, for, keepLonger, glow, seenBy, vfx, radius, max, fifo, clear; a field left out is the default, or the tuned value" }, { "name": "gunWindow", "signatures": [ "gunWindow(options?: GunWindowOptions): void" ], "doc": "For a while, the wearer's held gun fires for free and hits harder. shots: the gun fires that many free shots now, itself (flash, recoil, animation), and the window closes on the last; unlimited: every shot is free until it runs out, the gun cycling fire_rate times faster (holding the trigger keeps firing). Neither: only the damage, knockback and bleed. One window per wearer: a new one replaces the old, except that an unlimited one outlasting it is kept. gunWindow({ shots: 1, for: 0.5 }) is a pressed blast; gunWindow({ unlimited: true, fireRate: 3.5, damageBonus: 0.35, closeOnEnd: true }) an ultimate's burst. (In a JSON file: thematic:gun_window.)\n@param options for, shots, unlimited, fireRate, damageBonus, knockback, bleedChance, closeOnEnd; a field left out is the default, or the tuned value" }, { "name": "gunAction", "signatures": [ "gunAction(action: GunAction): void" ], "doc": "Has the wearer's held gun do something now: gunAction(\"reload\") on a press is the reload move (while a gun is held, ability_0 is reload). (In a JSON file: thematic:gun_action.)\n@param action what the held gun does" }, { "name": "weather", "signatures": [ "weather(set?: WeatherSet, options?: WeatherOptions): void", "weather(options: WeatherOptions): void" ], "doc": "Changes the weather for a while, and can put it back afterwards. (In a JSON file: thematic:weather.)\n@param set cycle (default), clear, rain or thunder\n@param options for, restore; a field left out is the default, or the tuned value" }, { "name": "openScreen", "signatures": [ "openScreen(screen: ScreenKind, options?: OpenScreenOptions): void" ], "doc": "Opens a screen for the wearer, with no block behind it: their ender chest, a 3x3 crafting grid that hands back what is left in it when it closes, or an inventory stored on them by name, shown as a chest of as many rows. (In a JSON file: thematic:open_screen.)\n@param screen which screen\n@param options name, size, title; a field left out is the default, or the tuned value" }, { "name": "spectate", "signatures": [ "spectate(view?: SpectateView, options?: SpectateOptions): void", "spectate(options: SpectateOptions): void" ], "doc": "Hands the wearer's camera to something else: it rides with the entity hit (target; hidden from them while they look out through it), or is latched onto their own head (head), for a while or until a stop. Synced to their client. A still view without bob is camera({ noViewBob: true }) on the phase. (In a JSON file: thematic:spectate.)\n@param view target or head; needed unless stop\n@param options for, stop; a field left out is the default, or the tuned value" }, { "name": "repairItem", "signatures": [ "repairItem(options?: RepairItemOptions): void" ], "doc": "Takes durability damage off the damageable stacks in the wearer's hands: a fixed amount, or so much per experience point of the xp_gained being answered. (In a JSON file: thematic:repair_item.)\n@param options hands, amount, perXp; a field left out is the default, or the tuned value" }, { "name": "smelt", "signatures": [ "smelt(options?: SmeltOptions): void" ], "doc": "Smelts from the wearer's inventory as a furnace would, the results into the inventory (or at their feet when it is full): one item, or every smeltable stack whole. (In a JSON file: thematic:smelt.)\n@param options one, skip, skipNamed, xp, required; a field left out is the default, or the tuned value" }, { "name": "mergeStacks", "signatures": [ "mergeStacks(): void" ], "doc": "Tops up every partial stack in the wearer's inventory from the matching stacks after it. (In a JSON file: thematic:merge_stacks.)" }, { "name": "compress", "signatures": [ "compress(options?: CompressOptions): void" ], "doc": "For each item the wearer carries enough of, crafts full grids of it into what the crafting recipe makes -- nine ingots into a block -- as many times as it can. Only plain stacks (no NBT) go in. (In a JSON file: thematic:compress.)\n@param options recipe, filter; a field left out is the default, or the tuned value" }, { "name": "pressAbility", "signatures": [ "pressAbility(slot: string | number, options?: PressAbilityOptions): void" ], "doc": "Presses whatever sits on a key of the kit, as the key would: a press presses, a toggle flips, a hold starts. (In a JSON file: thematic:press_ability.)\n@param slot \"ultimate\", \"ability_1\", or a key number such as 1\n@param options who, resetCooldown; a field left out is the default, or the tuned value" }, { "name": "useMove", "signatures": [ "useMove(id: string, options?: UseMoveOptions): void" ], "doc": "Presses a registered move by id, whether or not it is in the wearer's kit, as the wearer's own. A move that is not pressable, or not registered, does nothing. (In a JSON file: thematic:use_move.)\n@param id the move's ability id, e.g. \"sneezing_powder\"\n@param options delay, ready, do; a field left out is the default, or the tuned value" }, { "name": "wearShape", "signatures": [ "wearShape(id: string, options?: WearShapeOptions): void" ], "doc": "Lends the wearer the shape one of their kit's morph moves wears, for a while, as part of another move (Bat Colony leaves Dracula a bat once the colony scatters). Borrowed: it costs the morph no cooldown however it ends, and leaves them on Slow Falling if they are in the air. Nothing happens while they are already in a shape. (In a JSON file: thematic:wear_shape.)\n@param id the morph move's ability id, e.g. \"bat_form\"\n@param options seconds; a field left out is the default, or the tuned value" }, { "name": "entityClip", "signatures": [ "entityClip(entity: string, options?: EntityClipOptions): void" ], "doc": "Triggers a GeckoLib clip on each nearby entity of this type summoned by the wearer. (In a JSON file: thematic:entity_clip.)\n@param entity the summoned entity type id\n@param options controller, clip, radius, at; a field left out is the default, or the tuned value" }, { "name": "despawnEntity", "signatures": [ "despawnEntity(entity: string, options?: DespawnEntityOptions): void" ], "doc": "Removes each nearby entity of this type summoned by the wearer. (In a JSON file: thematic:despawn_entity.)\n@param entity the summoned entity type id\n@param options radius, at; a field left out is the default, or the tuned value" }, { "name": "dropItem", "signatures": [ "dropItem(item: string, options?: DropItemOptions): void" ], "doc": "Drops an item in the world, with the usual pickup delay. (In a JSON file: thematic:drop_item.)\n@param item the item id; one not registered (its pack missing) drops nothing\n@param options count, at; a field left out is the default, or the tuned value" }, { "name": "transformDrops", "signatures": [ "transformDrops(options?: TransformDropsOptions): void" ], "doc": "Rewrites the items the entity hit -- a kill's victim -- has just dropped: some multiplied, food cooked. A multiplied stack is not cooked too. (In a JSON file: thematic:transform_drops.)\n@param options multiply, smeltFood, radius; a field left out is the default, or the tuned value" }, { "name": "itemClip", "signatures": [ "itemClip(clip: string, options?: ItemClipOptions): void" ], "doc": "The item in a hand plays one of its own clips: a gun in the main hand the cue it declares under that name (sent to the wearer), any other geo item the clip on its controller. (In a JSON file: thematic:item_clip.)\n@param clip the gun's cue, or the item's clip\n@param options controller, hand, stop; a field left out is the default, or the tuned value" }, { "name": "throwPotion", "signatures": [ "throwPotion(options?: ThrowPotionOptions): void" ], "doc": "Throws a splash (or lingering) potion of the effects given, from the wearer's eyes along their look. (In a JSON file: thematic:throw_potion.)\n@param options effects, color, lingering, velocity, divergence, pitchOffset; a field left out is the default, or the tuned value" }, { "name": "launchLock", "signatures": [ "launchLock(options?: LaunchLockOptions): void" ], "doc": "Movement systems leave the body's velocity alone for a while, so a launch just given is not steered away at once. (In a JSON file: thematic:launch_lock.)\n@param options for, who; a field left out is the default, or the tuned value" }, { "name": "disableShield", "signatures": [ "disableShield(options?: DisableShieldOptions): void" ], "doc": "A player's shield is knocked down for a while, as an axe does. (In a JSON file: thematic:disable_shield.)\n@param options who, onlyBlocking; a field left out is the default, or the tuned value" }, { "name": "ping", "signatures": [ "ping(level?: number, options?: PingOptions): void", "ping(options: PingOptions): void" ], "doc": "A direction ping on the wearer's own screen, pointing the way something is: chevrons on a ring around the crosshair, drawn with this ability's thematic:direction_ping options (the spider-sense's with none). Sent to the wearer only. (In a JSON file: thematic:ping.)\n@param level which of the visual's levels it shows as, from 1 (1); past the last, the last\n@param options at; a field left out is the default, or the tuned value" }, { "name": "resetConstructs", "signatures": [ "resetConstructs(): void" ], "doc": "Lifts any limits a move put on which constructs the wearer may make: what a lantern ring's charge did as the suit came off. (In a JSON file: thematic:reset_constructs.)" }, { "name": "lightning", "signatures": [ "lightning(options?: LightningOptions): void" ], "doc": "Calls down bolts that strike for the wearer: each flashes one to three times where it lands and, each time, hits everyone in a small column round it the wearer may hit -- for damage, as the wearer's attack, holding them where they stand -- and never the wearer's side. lightning({ count: 3 }) inside targets() is three bolts on each target; lightning({ at: \"wearer\", count: 2, scatter: 4 }) two anywhere near the wearer. (In a JSON file: thematic:lightning.)\n@param options at, count, arrangement, radius, stagger, offsets, scatter, every, damage, ownerCredited, stun, scale, cosmetic, entity; a field left out is the default, or the tuned value" }, { "name": "strand", "signatures": [ "strand(body?: (placed: Actions) => void): void", "strand(options: StrandOptions, body?: (placed: Actions) => void): void" ], "doc": "Strings a lasting strand (a thematic:strand entity) from a point to the block the wearer looks at. It stays after the move ends: bodies walk along a gentle one and climb a steep one, and it catches whoever crosses it fast, as its definition says. Repeated presses of strand({ from: \"chain\" }) lay a tightrope point to point: the first anchors, each later one strings on from the last point. Past the definition's max_per_owner the wearer's oldest goes. do runs at the new end, the strand as its source. (In a JSON file: thematic:strand.)\n@param options to, from, range, lasts, window, entity, required; a field left out is the default, or the tuned value\n@param body run once it is strung, where it ends" }, { "name": "swapSuit", "signatures": [ "swapSuit(to?: string, options?: SwapSuitOptions): void", "swapSuit(options: SwapSuitOptions): void" ], "doc": "Puts the wearer in another suit: the one named (to), or the other of a pair of suits (pair; wearing neither, nothing happens). A swap to a base suit puts on the variant of it last worn, remembered on the stack (ThematicTransformVariant_), and the new stack remembers the variant taken off. With for, the suit is only borrowed: bound on for that long, then the wearer's own suit and health come back. Banner's turn: swapSuit({ pair: [\"jason_blood\", \"etrigan\"] }). (In a JSON file: thematic:swap_suit.)\n@param to the suit to put on, a base suit or an alt (\"batson\"); give this or pair\n@param options pair, keepNbt, rememberVariant, for, scale, required; a field left out is the default, or the tuned value" }, { "name": "copySuit", "signatures": [ "copySuit(from?: string, options?: CopySuitOptions): void", "copySuit(options: CopySuitOptions): void" ], "doc": "Lends the wearer a fresh copy of a suit -- the target's, or one by id -- bound on for a while; then their own suit and health come back. The copy carries none of the original's data. Fails for a wearer already borrowing one, or nearly dead. (In a JSON file: thematic:copy_suit.)\n@param from \"target\" (default: the suit the entity hit wears) or a suit id, \"superman\"\n@param options lasts, scale, endOnReturn, required; a field left out is the default, or the tuned value" }, { "name": "setActive", "signatures": [ "setActive(ability?: string, options?: SetActiveOptions): void", "setActive(options: SetActiveOptions): void" ], "doc": "Switches a move on or off: this one, one by id, or every move of the wearer's suit (\"kit\"), with a time written to its clock -- the cooldown it is left on when off, how long it runs when a timed move is on. (In a JSON file: thematic:set_active.)\n@param ability a move's id, or \"kit\" for every move of the suit (default: this move)\n@param options on, for, upTo, clearCapture, who, kind, takeBack; a field left out is the default, or the tuned value" }, { "name": "endAbility", "signatures": [ "endAbility(ability?: string): void" ], "doc": "Ends a running move as running out would: it switches off, its clean-up runs, and its tuned cooldown starts. (In a JSON file: thematic:end_ability.)\n@param ability a move's id (default: this move)" }, { "name": "captureMenu", "signatures": [ "captureMenu(options?: CaptureMenuOptions): void" ], "doc": "Opens a menu of forms for the wearer (a player), on behalf of this move: suits rolled at random, none of which can be taken. Picking one takes on its look for this move's tuned duration (the shape-shift capture) and runs this move again for as long; the menu stays open while this move runs. Mystique's Shapeshift: captureMenu() in the press, into a phase that lasts \"duration\". (In a JSON file: thematic:capture_menu.)\n@param options slots, source, inventory, title; a field left out is the default, or the tuned value" }, { "name": "endCapture", "signatures": [ "endCapture(): void" ], "doc": "Lets go of the look a capture_menu pick took on, if the wearer holds one: they look like their own suit again. (In a JSON file: thematic:end_capture.)" }, { "name": "action", "signatures": [ "action(type: T, fields?: ActionFields[T]): void" ], "doc": "Writes any action by type, for the ones with no method of their own (throwable payloads, addon actions). Fields are camelCase or snake_case; a bare type means thematic:." }, { "name": "use", "signatures": [ "use(id: string, options?: { [option: string]: unknown }, body?: (...args: any[]) => void): void" ], "doc": "Applies a prefab: parts bundled under a name in data//ability_prefabs/, e.g. use(\"thematic:armed\", { window: 5 }, hit => ...). A bare name is thematic:'s. What it writes is plain parts, as if written here." }, { "name": "oneOf", "signatures": [ "oneOf(branches: (((branch: Actions) => void) | ActionObject)[], options?: { weights?: number[] }): void" ], "doc": "Runs one of the branches, picked at random each time: oneOf([b => b.heal(2), b => b.damage(2)], { weights: [3, 1] }). Each branch is a function writing its actions (or an action object); weights, one per branch, are all alike when left out." } ] }, { "name": "Timeline", "extends": "Actions", "doc": "A running order. Actions land at a cursor that starts at the press (or at entering the phase); wait() moves it.", "methods": [ { "name": "wait", "signatures": [ "wait(seconds: number): void" ], "doc": "Moves the cursor on. Everything after it happens that much later; the script itself never blocks, because it runs once at load, not on the key press. Keep to 0.05s steps: a tick is 0.05s." }, { "name": "repeat", "signatures": [ "repeat(options: RepeatOptions, body: (repetition: Timeline, index: number, alternate: any) => void): void" ], "doc": "Says a running order over and over on a fixed rhythm, from the cursor, which it leaves where it was: repeat({ times: 5, every: 0.625, alternate: [\"right_hand\", \"left_hand\"] }, (shot, i, hand) => ...). Each repetition lands on tick floor(i * every * 20) and may wait() within itself. The body runs once per repetition, at load, with its index and its alternate value." } ] }, { "name": "Reaction", "extends": "Timeline", "doc": "What a phase does when an event reaches it. Actions written here run with the event in hand: select \"attacker\" or \"victim\", fromEvent(\"amount\"), removeEffect(). A running order like a phase's: wait() schedules the rest, which still runs after then() has left the phase.", "methods": [ { "name": "then", "signatures": [ "then(exit: Exit, options?: ThenOptions): void" ], "doc": "Where the phase goes after answering. Left out, it stays." }, { "name": "defaultThen", "signatures": [ "defaultThen(exit: Exit, options?: ThenOptions): void" ], "doc": "Where the reaction leads unless something says then(): for a prefab that hands a reaction to its author's body, which may still say where it leads." } ] }, { "name": "Mob", "extends": "Timeline", "doc": "How a mob uses the move, handed to mob()'s callback. What is written on it directly is the mob's running order, in place of the move's own steps; the rest is its channel, which needs lasts in mob()'s options.", "methods": [ { "name": "every", "signatures": [ "every(body: (every: Actions) => void): void", "every(seconds: number, body: (every: Actions) => void): void", "every(options: EveryOptions, body: (every: Actions) => void): void" ], "doc": "Something the channel does while it lasts, counted on the channel's own ticks from 1 -- every(0.6, ...) fires on its 12th, 24th, ... tick. Rules run in the order written, so a sound rule written first plays before a beam rule due the same tick. every({ clock: \"animation\", ... }) takes the rules a phase's every() does. With no interval, every tick." }, { "name": "on", "signatures": [ "on(event: \"collide\", body: (reaction: Reaction) => void): void", "on(event: \"collide\", when: CollideGuard, body: (reaction: Reaction) => void): void" ], "doc": "How the channel answers bumping into something, checked after each tick's every() rules. A then() in the reaction ends the channel." }, { "name": "end", "signatures": [ "end(body: (end: Actions) => void): void" ], "doc": "Actions run as the channel ends, however it ends: run out, a collide reaction's then(), until, blocked, the target lost, or the controller cutting it short." } ] }, { "name": "Wheel", "doc": "A wheel's wedges, in the order they sit clockwise from the top. Nothing else is written here.", "methods": [ { "name": "entry", "signatures": [ "entry(id: string, options: WheelEntryOptions, pick: (pick: Actions) => void): void" ], "doc": "One wedge. The pick callback is what the server runs when the wearer lets go on it -- give() above all -- after checking the wheel lists it, the ability is not blocked, the wearer can pay its cost and (with cooldown) the ability is ready." } ] }, { "name": "ConsoleBuilder", "doc": "A console's layout. Pages and windows group widgets (their callback is handed a builder that puts every widget it writes on that page or in that window); everything has a stable id, which is what a client keys the player's own arrangement on.", "methods": [ { "name": "theme", "signatures": [ "theme(options: ConsoleTheme): void" ], "doc": "How the console is painted." }, { "name": "programs", "signatures": [ "programs(options?: ConsoleProgramsOptions): void" ], "doc": "Gives the console a unit-programs editor: the player writes scripts for their units in it and runs them from the console. A player's programs are their own (stored on the server); the templates seed them the first time." }, { "name": "page", "signatures": [ "page(id: string, options: ConsolePageOptions, body?: (page: ConsoleBuilder) => void): void", "page(id: string, body?: (page: ConsoleBuilder) => void): void" ], "doc": "A tab. The callback's widgets are on it." }, { "name": "window", "signatures": [ "window(id: string, options: ConsoleWindowOptions, body?: (window: ConsoleBuilder) => void): void", "window(id: string, body?: (window: ConsoleBuilder) => void): void" ], "doc": "A desktop window. The callback's widgets are in it; on the overlay they show as they would without it." }, { "name": "button", "signatures": [ "button(id: string, options: ConsoleButtonOptions, press: (actions: Actions) => void): void", "button(id: string, press: (actions: Actions) => void): void" ], "doc": "A button. A press runs the actions." }, { "name": "toggle", "signatures": [ "toggle(id: string, options: ConsoleToggleOptions, on?: (actions: Actions) => void, off?: (actions: Actions) => void): void" ], "doc": "A switch on a flag. A press flips the flag, then runs the on actions (it was off) or the off actions (it was on); either may be left out." }, { "name": "choice", "signatures": [ "choice(id: string, options: ConsoleChoiceOptions, choose: (actions: Actions, option: string) => void): void" ], "doc": "One of several options. The callback is called once per option with its id, and writes what choosing it does: choice(\"formation\", { options: [...] }, (a, option) => ...)." }, { "name": "units", "signatures": [ "units(id: string, options: ConsoleUnitsOptions, press?: (actions: Actions, slot: number, button: string) => void): void" ], "doc": "A card per unit of the group. The callback is called once per slot and button with that slot (a number from 1) and button id in hand: units(\"cards\", { buttons: [...] }, (a, slot, button) => ...)." }, { "name": "readout", "signatures": [ "readout(id: string, options: ConsoleReadoutOptions): void" ], "doc": "A value shown: a flag or a meter." }, { "name": "map", "signatures": [ "map(id: string, options?: ConsoleMapOptions): void" ], "doc": "The tactical map." }, { "name": "programRunner", "signatures": [ "programRunner(id: string, options?: ConsoleProgramRunnerOptions): void" ], "doc": "The programs section: pick one of the player's programs and run it on the selected units, stop the selected units' programs or all of them, or run the last one again with the inputs it was given." }, { "name": "draw", "signatures": [ "draw(id: string, options: ConsoleDrawOptions, drawn?: (actions: Actions) => void): void" ], "doc": "A drawing tool. The gesture becomes the verb's squad order for the group's units; the optional callback is what else happens once the order was taken." }, { "name": "mode", "signatures": [ "mode(id: string, options: ConsoleModeOptions, picked?: (actions: Actions, slot: number) => void): void" ], "doc": "A pick mode. For a unit pick (or a [\"target\"] or two-stage [\"unit\", \"target\"] one) the callback is called once per slot (a number from 1) and writes what picking that unit does; for an entity or a point pick the order is the verb's, and the callback (no slot) is what else happens." } ] }, { "name": "Component", "doc": "The component this file declares: the parts it is built from -- a key, a cooldown, requirements, visuals, a mob's use, properties -- and the phases it can be in. Nothing is written on it directly: the key's running order is component.press(...), component.hold(...) or component.toggle(...), a phase's is component.phase(name, ...).", "methods": [ { "name": "visual", "signatures": [ "visual(visual: V, options?: VisualOptions[V]): void", "visual(...visuals: Visual[]): void" ], "doc": "Names client presentation from the shelf -- a shader, an overlay, a world effect -- installed for this ability, with options that say how it looks: visual(\"thematic:beam\", { scale: 2.5 }). An option the visual does not declare is an error. Several visuals by name: visual(\"a\", \"b\")." }, { "name": "then", "signatures": [ "then(exit: Exit, options?: ThenOptions): void" ], "doc": "Where the key leads once its running order is under way: \"cooldown\" when left out, \"ready\", or a phase. The same as then() on the key's own body; say it once." }, { "name": "wheelSwitch", "signatures": [ "wheelSwitch(id: string, options?: ToggleOptions): void" ], "doc": "Adds a switch for this ability to the ability wheel, e.g. wheelSwitch(\"solar_glare\", { icon: \"minecraft:magma_cream\" }). Whatever reads it -- a layer visual, say -- asks whether switch is on for the wearer." }, { "name": "phase", "signatures": [ "phase(name: string, body: (phase: Phase) => void): void" ], "doc": "Declares a phase: parts that hold while the component is in it. Nothing enters it until a then() names it." }, { "name": "on", "signatures": [ "on(event: \"hurt\", body: (reaction: Reaction) => void): void", "on(event: \"hurt\", when: HurtGuard, body: (reaction: Reaction) => void): void", "on(event: \"damaged\", body: (reaction: Reaction) => void): void", "on(event: \"damaged\", when: DamagedGuard, body: (reaction: Reaction) => void): void", "on(event: \"effect_added\", body: (reaction: Reaction) => void): void", "on(event: \"effect_added\", when: EffectAddedGuard, body: (reaction: Reaction) => void): void", "on(event: \"attack\", body: (reaction: Reaction) => void): void", "on(event: \"attack\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"collide\", body: (reaction: Reaction) => void): void", "on(event: \"collide\", when: CollideGuard, body: (reaction: Reaction) => void): void", "on(event: \"release\", body: (reaction: Reaction) => void): void", "on(event: \"release\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"hit_landed\", body: (reaction: Reaction) => void): void", "on(event: \"hit_landed\", when: HitLandedGuard, body: (reaction: Reaction) => void): void", "on(event: \"swing\", body: (reaction: Reaction) => void): void", "on(event: \"swing\", when: SwingGuard, body: (reaction: Reaction) => void): void", "on(event: \"tick\", body: (reaction: Reaction) => void): void", "on(event: \"tick\", when: TickGuard, body: (reaction: Reaction) => void): void", "on(event: \"press\", body: (reaction: Reaction) => void): void", "on(event: \"press\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"block_broken\", body: (reaction: Reaction) => void): void", "on(event: \"block_broken\", when: BlockBrokenGuard, body: (reaction: Reaction) => void): void", "on(event: \"use_block\", body: (reaction: Reaction) => void): void", "on(event: \"use_block\", when: UseBlockGuard, body: (reaction: Reaction) => void): void", "on(event: \"use_entity\", body: (reaction: Reaction) => void): void", "on(event: \"use_entity\", when: UseEntityGuard, body: (reaction: Reaction) => void): void", "on(event: \"use_item\", body: (reaction: Reaction) => void): void", "on(event: \"use_item\", when: UseItemGuard, body: (reaction: Reaction) => void): void", "on(event: \"jump\", body: (reaction: Reaction) => void): void", "on(event: \"jump\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"land\", body: (reaction: Reaction) => void): void", "on(event: \"land\", when: LandGuard, body: (reaction: Reaction) => void): void", "on(event: \"kill\", body: (reaction: Reaction) => void): void", "on(event: \"kill\", when: KillGuard, body: (reaction: Reaction) => void): void", "on(event: \"xp_gained\", body: (reaction: Reaction) => void): void", "on(event: \"xp_gained\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"inventory_change\", body: (reaction: Reaction) => void): void", "on(event: \"inventory_change\", when: InventoryChangeGuard, body: (reaction: Reaction) => void): void", "on(event: \"projectile_incoming\", body: (reaction: Reaction) => void): void", "on(event: \"projectile_incoming\", when: ProjectileIncomingGuard, body: (reaction: Reaction) => void): void", "on(event: \"projectile_approaching\", body: (reaction: Reaction) => void): void", "on(event: \"projectile_approaching\", when: ProjectileApproachingGuard, body: (reaction: Reaction) => void): void", "on(event: \"projectile_launched\", body: (reaction: Reaction) => void): void", "on(event: \"projectile_launched\", when: ProjectileLaunchedGuard, body: (reaction: Reaction) => void): void", "on(event: \"arrow_loosed\", body: (reaction: Reaction) => void): void", "on(event: \"arrow_loosed\", when: ArrowLoosedGuard, body: (reaction: Reaction) => void): void", "on(event: \"chat_word\", body: (reaction: Reaction) => void): void", "on(event: \"chat_word\", when: ChatWordGuard, body: (reaction: Reaction) => void): void", "on(event: \"enemy_ultimate_ready\", body: (reaction: Reaction) => void): void", "on(event: \"enemy_ultimate_ready\", when: EnemyUltimateReadyGuard, body: (reaction: Reaction) => void): void", "on(event: \"enemy_ultimate_pressed\", body: (reaction: Reaction) => void): void", "on(event: \"enemy_ultimate_pressed\", when: EnemyUltimatePressedGuard, body: (reaction: Reaction) => void): void", "on(event: \"threat_nearby\", body: (reaction: Reaction) => void): void", "on(event: \"threat_nearby\", when: ThreatNearbyGuard, body: (reaction: Reaction) => void): void", "on(event: \"suit_removed\", body: (reaction: Reaction) => void): void", "on(event: \"suit_removed\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"crouch_toggled\", body: (reaction: Reaction) => void): void", "on(event: \"crouch_toggled\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"tether_arrive\", body: (reaction: Reaction) => void): void", "on(event: \"tether_arrive\", when: Guard, body: (reaction: Reaction) => void): void" ], "doc": "How the component answers an event while in no phase -- a passive's watch, a press's standing reaction. A phase answers events in its own on()." }, { "name": "traits", "signatures": [ "traits(traits: ComponentTraitOptions): void" ], "doc": "What the ability is beyond what it does, e.g. traits({ ultimate: true, immuneTo: [\"minecraft:fall\"] }) or traits({ environment: { walkOnFluid: true }, loot: { looting: { min: 1, max: 3 } } }). Written as fields of the file, and checked as the file is." }, { "name": "let", "signatures": [ "let(name: string, value: LetValue): void" ], "doc": "A value drawn once per press and kept while its phases last: let(\"mixture\", { randomHue: { saturation: [0.85, 1], value: [0.9, 1] } }). Any action field written \"$mixture\" reads it, and { stored: \"mixture\" } or $mixture in an expr when it is a number." }, { "name": "requires", "signatures": [ "requires(guard: Guard, refusal?: Refusal): void" ], "doc": "Something that must hold for the ability to be usable at all: while it fails, the HUD shows a padlock and a press is refused (for a hold, the key is not taken and a running gauge stands still). Call it once per requirement; every one must hold. With a refusal, a refused press shows its message while this requirement fails -- the first failing one with a message, in the order written." }, { "name": "blockedBy", "signatures": [ "blockedBy(blockers: Guard, refusal?: Refusal): void" ], "doc": "The ability can't be used while any one of these holds: requires({ not: { any: [ ...each key on its own ] } }). blockedBy({ active: \"seeing_red\", holding: [\"super_breath\", \"frost_breath\"] }) is blocked while seeing red is on or either breath is held. Takes a refusal as requires() does." }, { "name": "body", "signatures": [ "body(options: BodyOptions): void" ], "doc": "The wearer's body while the ability is active, e.g. body({ stillLimbs: \"whole_body\", silentSteps: true, cape: -60 })." }, { "name": "camera", "signatures": [ "camera(options: CameraOptions): void" ], "doc": "What the camera and flight leave to the move while the ability is active, e.g. camera({ noViewBob: true, ownsFlightPose: true })." }, { "name": "lockInput", "signatures": [ "lockInput(options: InputLockOptions): void" ], "doc": "The wearer's own inputs taken away while the ability is active, e.g. lockInput({ move: true, pinPosition: true, jump: true })." }, { "name": "hideBones", "signatures": [ "hideBones(bones: string[], options?: HideBonesOptions): void" ], "doc": "Suit bones hidden while the ability is active, e.g. hideBones([\"helmet\"], { flag: \"visor_off\" })." }, { "name": "mob", "signatures": [ "mob(options?: MobOptions): void", "mob(options: MobOptions, body: (mob: Mob) => void): void", "mob(body: (mob: Mob) => void): void" ], "doc": "Lets a mob wearing the suit use the move. Its controller fires it with the mob as the wearer, aimed at its target (\"heading\" and \"aim\" point at it), and paces it from these numbers; no cooldown is written. A press or a hold. Left at that, the mob runs the move's own steps once. The callback says what a mob does instead: what it writes directly is the mob's running order, and with lasts it is a channel -- every(), on(\"collide\"), end() and until run on the channel's own ticks. A mob never runs the move's phases or gauge." }, { "name": "gauge", "signatures": [ "gauge(options: GaugeOptions): void" ], "doc": "A hold's heat meter, kept in the ability's cooldown slot: it fills while the key is held, a full gauge lets go of the key, and it drains once released, one tick of heat at a time. The held phase's ticks start once it holds startsAt seconds of heat; the move starts again only from empty unless restart is \"any\". It runs on the server and, to predict the heat and cut the loop off at once, on every client. A hold only. Show it with visual(\"thematic:gauge_bar\"). Heat Vision: gauge({ max: 8, fill: 2, drain: 2, startsAt: 0.5, loop: { sound: \"heat_vision\", every: 1.5 }, boosts: [{ if: { active: [\"solar_absorption\", \"lunar_absorption\"] }, maxTimes: 1.25 }, { if: { active: \"solar_absorption\" }, fill: 1, drain: 4 }] })." }, { "name": "wheel", "signatures": [ "wheel(options: WheelOptions): void", "wheel(options: WheelOptions, body: (wheel: Wheel) => void): void", "wheel(body: (wheel: Wheel) => void): void" ], "doc": "Makes the ability a radial menu on its key: holding the key opens a dial, letting go on a wedge picks it; with tap: \"last\" a quick tap fires the wedge picked last instead. wheel({ source: \"construct_favourites\" }) is the Construct Wheel -- the ring's starred constructs, a pick summoning one exactly as the construct grid does. Otherwise the callback lists the wedges and what picking each runs on the server, which refuses a pick the wheel does not list. color and accent paint it; a suit overrides them per suit with the wheel_color and wheel_accent options of its entry for this ability. A press only." }, { "name": "console", "signatures": [ "console(options: ConsoleOptions, body: (console: ConsoleBuilder) => void): void", "console(body: (console: ConsoleBuilder) => void): void" ], "doc": "Makes the ability a command console: a live overlay with a free cursor that expands into a desktop of windows and a tactical map. The callback lays out pages, windows, a theme and widgets (buttons, toggles, choices, unit cards, readouts, a map, drawing tools, pick modes); a press on a widget runs its actions on the server, which refuses a widget the layout does not list, one hidden by its visibleWhen, or a disabled one. The ability's key opens the console on the client (as it opens a wheel); openConsole(ability, { mode }) opens it from the server, e.g. from another ability's press." }, { "name": "press", "signatures": [ "press(body?: (press: Key) => void): void", "press(options: PressKeyOptions, body?: (press: Key) => void): void" ], "doc": "Gives the component a press key: each press runs this running order once, then goes where then() says -- \"cooldown\" when left out. press({ bones: { show, hide } }, press => ...) swaps suit bones while the press's phases run, as a toggle's do while on. A component has at most one key; with none it is passive." }, { "name": "hold", "signatures": [ "hold(body?: (hold: Key) => void): void" ], "doc": "Gives the component a hold key: the key going down runs this running order and opens the phase then() names, held while the key is down; letting go is a \"release\" the phase answers. A component has at most one key; with none it is passive." }, { "name": "toggle", "signatures": [ "toggle(on?: (on: Key) => void, off?: (off: Timeline) => void): void", "toggle(options: ToggleKeyOptions, on?: (on: Key) => void, off?: (off: Timeline) => void): void" ], "doc": "Gives the component a toggle key: each press switches it on or off. The first body is switching on (then(phase) holds a phase while on -- or use(\"thematic:while_on\", ...)), the second switching off." }, { "name": "cooldown", "signatures": [ "cooldown(options?: CooldownOptions): void" ], "doc": "Gives the component a cooldown: the tuned one from its defaults.csv row. Without one nothing may lead to \"cooldown\" -- a hold whose gauge is its limit leaves with \"ready\"." }, { "name": "use", "signatures": [ "use(id: string, options?: { [option: string]: unknown }, body?: (...args: any[]) => void): void" ], "doc": "Applies a prefab: parts bundled under a name in data//ability_prefabs/, e.g. use(\"thematic:armed\", { window: 5 }, hit => ...). A bare name is thematic:'s. What it writes is plain parts, as if written here." }, { "name": "charges", "signatures": [ "charges(count: number, options?: { recharge?: number }): void" ], "doc": "Lets the key be used count times before it waits; each charge comes back in turn over the recharge (the tuned cooldown, or recharge seconds)." }, { "name": "meter", "signatures": [ "meter(options: MeterSpec): void" ], "doc": "Declares a meter kept on the wearer: an amount between 0 and max (regen brings it back on the server), or with decay a window that opens, banks or bleeds and closes by itself. With hud it also names visual(\"thematic:gauge_bar\"), which draws it: name no gauge_bar beside it. A lantern ring: meter({ key: \"green_ringCharge\", maxKey: \"green_ringMaxCharge\", max: 2000, reserve: 1, persistent: true, regen: { amount: 4, every: 1, boosts: [{ effect: \"thematic:recharge\", times: 8 }] }, hud: { bar: \"willpower_green\", text: \"%s Green\" } })." }, { "name": "costs", "signatures": [ "costs(meter: string, options: { perUse?: number, perTick?: number }): void" ], "doc": "Pays the key's use from a meter: perUse as a use begins, perTick for every tick it runs. While the meter can't pay (keeping its reserve), the key is held back; a tick it can't pay for ends the use. A construct on a lantern ring: costs(\"green_ringCharge\", { perUse: 40, perTick: 2 })." }, { "name": "tether", "signatures": [ "tether(options: { line: \"swing\" | \"slingshot\" | \"hang\", entity: string, poses?: string, clips?: { swingRight?: string, swingLeft?: string, zip?: string, air?: string, kickoff?: string, shootRight?: string, shootLeft?: string, climb?: string, cling?: string, draw?: string, strike?: string }, tricks?: { front?: string, back?: string, left?: string, right?: string, ticks?: number, gap?: number, priority?: number, flair?: { enabled?: boolean, after?: number, minSpeed?: number, ground?: number, wall?: number, cooldown?: number, max?: number, moves?: (string | { clip: string, weight?: number })[] }, moves?: { clip: string, input?: string | string[], entry?: boolean, fallback?: boolean, clearance?: number, rise?: number, ticks?: number }[], entryWindow?: number, shortest?: number }, sounds?: { shot?: string | string[], attach?: string | string[], stretch?: string | string[], snap?: string | string[], whoosh?: string | string[], bump?: string | string[], effort?: string | string[] }, gate?: \"sneaking\" | \"standing\", traced?: string, reel?: false | { speed?: number, blend?: number, releaseAt?: number }, windows?: { reweb?: number, climb?: number, kickoff?: number, debris?: number, air?: number, zip?: number }, slingshot?: { window?: number, minDraw?: number, maxWander?: number, hitReach?: number, autoGrace?: number }, hang?: { drop?: number, reach?: number, knockback?: number, window?: number, stagger?: number, landed?: number }, plant?: boolean | { max?: number, lasts?: number, releaseOnSneak?: boolean, slingshotTimes?: number, slingshotCooldown?: number } }): void" ], "doc": "Makes the key a line the wearer moves on: line \"swing\" (a hold: tap to zip, hold to swing, tricks in the air), \"slingshot\" (a hold: two lines out, walk back to draw, let go to launch) or \"hang\" (a press: hang from a line overhead, press again to drop onto a target). The key's own part (hold or press) is still written; the tether does the rest. The moves of one suit find each other by their line." }, { "name": "loadout", "signatures": [ "loadout(options: { inventory: string, size?: number, display?: boolean, roster?: string }): void" ], "doc": "Keeps one of the wearer's named inventories as a loadout: the select key cycles it (loadoutCycle), the use key uses it (loadoutUse), the HUD draws it beside the hotbar and a loadout bench fills it. The suit's level option is how many slots it reaches; its default_item option the free item. With a roster, the suit fills it from the arrow data's named roster and no bench may edit it." } ] }, { "name": "Key", "extends": "Timeline", "doc": "What the component's key does first -- pressing it, holding it down, or switching it on -- as a running order, and where that leads.", "methods": [ { "name": "then", "signatures": [ "then(exit: Exit, options?: ThenOptions): void" ], "doc": "Where the key leads once its running order is under way: \"cooldown\" when left out, \"ready\", or a phase -- which a hold holds open and a toggle holds while on. then(\"cooldown\", { fraction: 0.25 }) charges a share." } ] }, { "name": "Phase", "extends": "Timeline", "doc": "One phase: parts that hold while the component is in it. What is written on it directly runs on arrival, as a running order of its own.", "methods": [ { "name": "lasts", "signatures": [ "lasts(time: \"duration\" | Amount, options?: LastsOptions): void" ], "doc": "How long the phase lasts: \"duration\" (the tuned duration from defaults.csv) or seconds. Left out, it lasts until a reaction, an until() or a release moves on. The deadline is steady -- it runs on every tick, whatever throttles the cooldowns; lasts(5, { steady: false }) waits out the throttled ticks." }, { "name": "every", "signatures": [ "every(body: (every: Actions) => void): void", "every(seconds: number, body: (every: Actions) => void): void", "every(options: EveryOptions, body: (every: Actions) => void): void" ], "doc": "Something the phase does while it lasts. Counted on the wearer's age by default, so every(1, ...) fires on the ticks where age is a multiple of 20; every({ seconds: 0.6, start: 0.2, clock: \"phase\" }, ...) counts from entering the phase, and every({ clock: \"animation\", frames: [0, 0.2, 0.4], cycle: 1 }, ...) strikes on the clip's frames at any speed. With no interval, every tick." }, { "name": "on", "signatures": [ "on(event: \"hurt\", body: (reaction: Reaction) => void): void", "on(event: \"hurt\", when: HurtGuard, body: (reaction: Reaction) => void): void", "on(event: \"damaged\", body: (reaction: Reaction) => void): void", "on(event: \"damaged\", when: DamagedGuard, body: (reaction: Reaction) => void): void", "on(event: \"effect_added\", body: (reaction: Reaction) => void): void", "on(event: \"effect_added\", when: EffectAddedGuard, body: (reaction: Reaction) => void): void", "on(event: \"attack\", body: (reaction: Reaction) => void): void", "on(event: \"attack\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"collide\", body: (reaction: Reaction) => void): void", "on(event: \"collide\", when: CollideGuard, body: (reaction: Reaction) => void): void", "on(event: \"release\", body: (reaction: Reaction) => void): void", "on(event: \"release\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"hit_landed\", body: (reaction: Reaction) => void): void", "on(event: \"hit_landed\", when: HitLandedGuard, body: (reaction: Reaction) => void): void", "on(event: \"swing\", body: (reaction: Reaction) => void): void", "on(event: \"swing\", when: SwingGuard, body: (reaction: Reaction) => void): void", "on(event: \"tick\", body: (reaction: Reaction) => void): void", "on(event: \"tick\", when: TickGuard, body: (reaction: Reaction) => void): void", "on(event: \"press\", body: (reaction: Reaction) => void): void", "on(event: \"press\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"block_broken\", body: (reaction: Reaction) => void): void", "on(event: \"block_broken\", when: BlockBrokenGuard, body: (reaction: Reaction) => void): void", "on(event: \"use_block\", body: (reaction: Reaction) => void): void", "on(event: \"use_block\", when: UseBlockGuard, body: (reaction: Reaction) => void): void", "on(event: \"use_entity\", body: (reaction: Reaction) => void): void", "on(event: \"use_entity\", when: UseEntityGuard, body: (reaction: Reaction) => void): void", "on(event: \"use_item\", body: (reaction: Reaction) => void): void", "on(event: \"use_item\", when: UseItemGuard, body: (reaction: Reaction) => void): void", "on(event: \"jump\", body: (reaction: Reaction) => void): void", "on(event: \"jump\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"land\", body: (reaction: Reaction) => void): void", "on(event: \"land\", when: LandGuard, body: (reaction: Reaction) => void): void", "on(event: \"kill\", body: (reaction: Reaction) => void): void", "on(event: \"kill\", when: KillGuard, body: (reaction: Reaction) => void): void", "on(event: \"xp_gained\", body: (reaction: Reaction) => void): void", "on(event: \"xp_gained\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"inventory_change\", body: (reaction: Reaction) => void): void", "on(event: \"inventory_change\", when: InventoryChangeGuard, body: (reaction: Reaction) => void): void", "on(event: \"projectile_incoming\", body: (reaction: Reaction) => void): void", "on(event: \"projectile_incoming\", when: ProjectileIncomingGuard, body: (reaction: Reaction) => void): void", "on(event: \"projectile_approaching\", body: (reaction: Reaction) => void): void", "on(event: \"projectile_approaching\", when: ProjectileApproachingGuard, body: (reaction: Reaction) => void): void", "on(event: \"projectile_launched\", body: (reaction: Reaction) => void): void", "on(event: \"projectile_launched\", when: ProjectileLaunchedGuard, body: (reaction: Reaction) => void): void", "on(event: \"arrow_loosed\", body: (reaction: Reaction) => void): void", "on(event: \"arrow_loosed\", when: ArrowLoosedGuard, body: (reaction: Reaction) => void): void", "on(event: \"chat_word\", body: (reaction: Reaction) => void): void", "on(event: \"chat_word\", when: ChatWordGuard, body: (reaction: Reaction) => void): void", "on(event: \"enemy_ultimate_ready\", body: (reaction: Reaction) => void): void", "on(event: \"enemy_ultimate_ready\", when: EnemyUltimateReadyGuard, body: (reaction: Reaction) => void): void", "on(event: \"enemy_ultimate_pressed\", body: (reaction: Reaction) => void): void", "on(event: \"enemy_ultimate_pressed\", when: EnemyUltimatePressedGuard, body: (reaction: Reaction) => void): void", "on(event: \"threat_nearby\", body: (reaction: Reaction) => void): void", "on(event: \"threat_nearby\", when: ThreatNearbyGuard, body: (reaction: Reaction) => void): void", "on(event: \"suit_removed\", body: (reaction: Reaction) => void): void", "on(event: \"suit_removed\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"crouch_toggled\", body: (reaction: Reaction) => void): void", "on(event: \"crouch_toggled\", when: Guard, body: (reaction: Reaction) => void): void", "on(event: \"tether_arrive\", body: (reaction: Reaction) => void): void", "on(event: \"tether_arrive\", when: Guard, body: (reaction: Reaction) => void): void" ], "doc": "How the phase answers an event while it lasts. A guard, if given, must hold for the reaction to fire." }, { "name": "onExit", "signatures": [ "onExit(body: (exit: Actions) => void): void" ], "doc": "Actions run as the phase is left, whichever way out was taken -- including an ultimate switching it off, and the wearer dying, logging out or taking the suit off." }, { "name": "then", "signatures": [ "then(exit: Exit, options?: ThenOptions): void", "then(exit: Exit, body: (lapse: Actions) => void): void", "then(exit: Exit, options: ThenOptions, body: (lapse: Actions) => void): void" ], "doc": "Where running out of lasts() leads. Left out: \"cooldown\". then(\"cooldown\", { fraction: 0.25 }) charges a share of it: an armed window that lapsed. A body runs as the time runs out, before end(), and on no other way out: then(\"cooldown\", lapse => { ... }) is what only letting the window run out costs." }, { "name": "blocksMovement", "signatures": [ "blocksMovement(blocks?: boolean): void" ], "doc": "Plants the wearer's feet while in this phase." }, { "name": "hudSuffix", "signatures": [ "hudSuffix(text: string, ...formatting: Formatting[]): void" ], "doc": "Text shown after the ability's name on the HUD while in this phase, e.g. hudSuffix(\" - BRACING\", \"dark_red\", \"bold\")." }, { "name": "traits", "signatures": [ "traits(traits: StateTraitOptions): void" ], "doc": "What the phase is while the wearer is in it, e.g. traits({ slowsCooldowns: 0.2 }) or traits({ silentSteps: true, forceRun: true })." }, { "name": "until", "signatures": [ "until(guard: Guard, exit: Exit, body?: (until: Actions) => void): void", "until(guard: Guard, exit: Exit, options: UntilOptions, body?: (until: Actions) => void): void" ], "doc": "A way out checked every tick: until({ onGround: true }, \"cooldown\"). After the phase's work unless { check: \"before\" }; the first whose guard holds is taken, in the order written. The body's actions run as it is taken." }, { "name": "holdOpen", "signatures": [ "holdOpen(options: HoldOpenOptions): void" ], "doc": "Keeps this timed phase from running out while a guard holds: holdOpen({ while: { active: \"x\" }, endWhen: { onGround: true }, max: 10 }). Its time left is kept at grace (0.1s), so it ends that long after while stops holding; endWhen ends it at once." }, { "name": "animationSpeed", "signatures": [ "animationSpeed(speed: Amount): void" ], "doc": "How fast the clip this phase plays runs, for every({ clock: \"animation\" }) and the anim input: animationSpeed(expr(\"6 / duration\")) for a 6s clip fitted to the tuned duration. Left out, 1 -- or what a fitted clip set." }, { "name": "body", "signatures": [ "body(options: BodyOptions): void" ], "doc": "The wearer's body while in this phase, e.g. body({ stillLimbs: \"whole_body\", silentSteps: true, cape: -60 })." }, { "name": "camera", "signatures": [ "camera(options: CameraOptions): void" ], "doc": "What the camera and flight leave to the move while in this phase, e.g. camera({ noViewBob: true, ownsFlightPose: true })." }, { "name": "lockInput", "signatures": [ "lockInput(options: InputLockOptions): void" ], "doc": "The wearer's own inputs taken away while in this phase, e.g. lockInput({ move: true, pinPosition: true, jump: true })." }, { "name": "hideBones", "signatures": [ "hideBones(bones: string[], options?: HideBonesOptions): void" ], "doc": "Suit bones hidden while in this phase, e.g. hideBones([\"helmet\"], { flag: \"visor_off\" })." }, { "name": "damageBonus", "signatures": [ "damageBonus(options: DamageBonusOptions): void" ], "doc": "While in this phase, each hit the wearer lands on the target carries amount * times + plus more, folded into the hit so the target's invulnerability window can not swallow it: damageBonus({ vs: \"tracked\", times: 0.05, for: 3 })." }, { "name": "damageTaken", "signatures": [ "damageTaken(options: DamageTakenOptions): void" ], "doc": "While in this phase, every hit on the wearer lands at times its size: under 1 soaks part of it where armour counts (the hit still lands, and can be answered), over 1 adds to it inside the hit. With when, only the hits that pass it: a ring that soaks melee from anyone standing inside it. damageTaken({ times: 0.6 })." }, { "name": "use", "signatures": [ "use(id: string, options?: { [option: string]: unknown }, body?: (...args: any[]) => void): void" ], "doc": "Applies a prefab: parts bundled under a name in data//ability_prefabs/, e.g. use(\"thematic:armed\", { window: 5 }, hit => ...). A bare name is thematic:'s. What it writes is plain parts, as if written here." }, { "name": "afterExit", "signatures": [ "afterExit(body: (exit: Actions) => void): void" ], "doc": "Actions run as the phase is left, after onExit()'s: what a prefab sets up on arrival and takes down again, whichever way out was taken." } ] } ], "unions": { "Trigger": { "doc": "How the ability fires. A \"hold\" must name the phase it holds open with then().", "values": [ "press", "hold", "toggle", "passive" ] }, "AbilityEvent": { "doc": "What a phase (or a passive ability) can answer with on().", "values": [ "hurt", "damaged", "effect_added", "attack", "collide", "release", "hit_landed", "swing", "tick", "press", "block_broken", "use_block", "use_entity", "use_item", "jump", "land", "kill", "xp_gained", "inventory_change", "projectile_incoming", "projectile_approaching", "projectile_launched", "arrow_loosed", "chat_word", "enemy_ultimate_ready", "enemy_ultimate_pressed", "threat_nearby", "suit_removed", "crouch_toggled", "tether_arrive" ] }, "Visual": { "doc": "Client presentation an ability can name. Shaders and overlays are code; a pack picks one of these and sets its options.", "values": [ "thematic:hud_overlay", "thematic:reticle", "thematic:gauge_bar", "thematic:screen_overlay", "thematic:screen_vignette", "thematic:direction_ping", "thematic:world_marker", "thematic:speed_lines", "thematic:mark_sigil", "thematic:sign", "thematic:blast", "thematic:flight_path", "thematic:beam", "thematic:light_projection", "thematic:trail_to_target", "thematic:blade_trail", "thematic:claw_marks", "thematic:motion_trail", "thematic:slipstream", "thematic:fire_trail", "thematic:afterimage", "thematic:target_readout", "thematic:target_portrait", "thematic:vision", "thematic:silhouette", "thematic:self_outline", "thematic:glow", "thematic:model", "thematic:density_shift", "thematic:bone_sprites", "thematic:crackle", "thematic:body_shroud", "thematic:rising_aura", "thematic:corona", "thematic:energy_plates", "thematic:body_fire", "thematic:fork_sparks", "thematic:aim_arm", "thematic:spin", "thematic:stretch", "thematic:pursuit_reticle", "thematic:righteous_cross", "thematic:devil_out_dome", "thematic:xray_vision", "thematic:daredevil_vision", "thematic:eye_glow", "thematic:phase_shell" ] }, "TunedStat": { "doc": "A stat from this ability's row in its ability_defaults CSV. radius is the CSV's range column; duration is in seconds.", "values": [ "damage", "radius", "duration", "amplifier" ] }, "EventNumber": { "doc": "A number the event being answered carries.", "values": [ "amount" ] }, "Exit": { "doc": "Where to go next: \"cooldown\" (start the CSV cooldown), \"ready\" (no cooldown), or the name of one of this ability's phases.", "values": [ "cooldown", "ready" ], "open": true }, "Formatting": { "doc": "A Minecraft text formatting, for hudSuffix().", "values": [ "aqua", "black", "blue", "bold", "dark_aqua", "dark_blue", "dark_gray", "dark_green", "dark_purple", "dark_red", "gold", "gray", "green", "italic", "light_purple", "obfuscated", "red", "strikethrough", "underline", "white", "yellow" ] }, "EffectGroup": { "doc": "A named group of status effects a guard can ask about.", "values": [ "flash", "harmful" ] }, "HeldItemKind": { "doc": "A kind of held item a guard can ask about, rather than one item's id.", "values": [ "bow", "gun", "trident", "weapon" ] }, "NumberInput": { "doc": "Something a move knows as it runs, for input(), bands() and expr().", "values": [ "damage", "radius", "duration", "amplifier", "cooldown", "event", "age", "state_ticks", "ticks_left", "gauge", "distance", "spot_distance", "anim", "motion_y", "fall_distance", "health", "max_health", "missing_health", "attack", "defense", "level", "look_pitch", "fire_ticks", "target_fire_ticks", "speed_value", "moving_angle", "target_height", "gun_damage", "gun_rpm", "gun_range", "gun_pellets", "pi", "e" ] }, "RegistryName": { "doc": "A registry registry() and tag() can list: vanilla's entries (pinned for this Minecraft version), plus what the installed packs define as files -- damage_type/ files, and the events of assets/thematic/sounds.json.", "values": [ "damage_type", "entity_type", "item", "mob_effect", "particle_type", "sound_event" ] }, "DamageTypeTag": { "doc": "A tag of the damage_type registry: vanilla's, or any a pack defines.", "values": [ "minecraft:always_hurts_ender_dragons", "minecraft:always_most_significant_fall", "minecraft:always_triggers_silverfish", "minecraft:avoids_guardian_thorns", "minecraft:burns_armor_stands", "minecraft:bypasses_armor", "minecraft:bypasses_effects", "minecraft:bypasses_enchantments", "minecraft:bypasses_invulnerability", "minecraft:bypasses_resistance", "minecraft:bypasses_shield", "minecraft:damages_helmet", "minecraft:ignites_armor_stands", "minecraft:is_drowning", "minecraft:is_explosion", "minecraft:is_fall", "minecraft:is_fire", "minecraft:is_freezing", "minecraft:is_lightning", "minecraft:is_projectile", "minecraft:no_anger", "minecraft:no_impact", "minecraft:witch_resistant_to", "minecraft:wither_immune_to" ], "open": true }, "EntityTypeTag": { "doc": "A tag of the entity_type registry: vanilla's, or any a pack defines.", "values": [ "minecraft:arrows", "minecraft:axolotl_always_hostiles", "minecraft:axolotl_hunt_targets", "minecraft:beehive_inhabitors", "minecraft:dismounts_underwater", "minecraft:fall_damage_immune", "minecraft:freeze_hurts_extra_types", "minecraft:freeze_immune_entity_types", "minecraft:frog_food", "minecraft:impact_projectiles", "minecraft:powder_snow_walkable_mobs", "minecraft:raiders", "minecraft:skeletons" ], "open": true }, "ItemTag": { "doc": "A tag of the item registry: vanilla's, or any a pack defines.", "values": [ "minecraft:acacia_logs", "minecraft:anvil", "minecraft:arrows", "minecraft:axes", "minecraft:axolotl_tempt_items", "minecraft:bamboo_blocks", "minecraft:banners", "minecraft:beacon_payment_items", "minecraft:beds", "minecraft:birch_logs", "minecraft:boats", "minecraft:bookshelf_books", "minecraft:breaks_decorated_pots", "minecraft:buttons", "minecraft:candles", "minecraft:cherry_logs", "minecraft:chest_boats", "minecraft:cluster_max_harvestables", "minecraft:coal_ores", "minecraft:coals", "minecraft:compasses", "minecraft:completes_find_tree_tutorial", "minecraft:copper_ores", "minecraft:creeper_drop_music_discs", "minecraft:creeper_igniters", "minecraft:crimson_stems", "minecraft:dampens_vibrations", "minecraft:dark_oak_logs", "minecraft:decorated_pot_ingredients", "minecraft:decorated_pot_sherds", "minecraft:diamond_ores", "minecraft:dirt", "minecraft:doors", "minecraft:emerald_ores", "minecraft:fence_gates", "minecraft:fences", "minecraft:fishes", "minecraft:flowers", "minecraft:fox_food", "minecraft:freeze_immune_wearables", "minecraft:gold_ores", "minecraft:hanging_signs", "minecraft:hoes", "minecraft:ignored_by_piglin_babies", "minecraft:iron_ores", "minecraft:jungle_logs", "minecraft:lapis_ores", "minecraft:leaves", "minecraft:lectern_books", "minecraft:logs", "minecraft:logs_that_burn", "minecraft:mangrove_logs", "minecraft:music_discs", "minecraft:non_flammable_wood", "minecraft:noteblock_top_instruments", "minecraft:oak_logs", "minecraft:pickaxes", "minecraft:piglin_food", "minecraft:piglin_loved", "minecraft:piglin_repellents", "minecraft:planks", "minecraft:rails", "minecraft:redstone_ores", "minecraft:sand", "minecraft:saplings", "minecraft:shovels", "minecraft:signs", "minecraft:slabs", "minecraft:small_flowers", "minecraft:smelts_to_glass", "minecraft:sniffer_food", "minecraft:soul_fire_base_blocks", "minecraft:spruce_logs", "minecraft:stairs", "minecraft:stone_bricks", "minecraft:stone_buttons", "minecraft:stone_crafting_materials", "minecraft:stone_tool_materials", "minecraft:swords", "minecraft:tall_flowers", "minecraft:terracotta", "minecraft:tools", "minecraft:trapdoors", "minecraft:trim_materials", "minecraft:trim_templates", "minecraft:trimmable_armor", "minecraft:villager_plantable_seeds", "minecraft:walls", "minecraft:warped_stems", "minecraft:wart_blocks", "minecraft:wooden_buttons", "minecraft:wooden_doors", "minecraft:wooden_fences", "minecraft:wooden_pressure_plates", "minecraft:wooden_slabs", "minecraft:wooden_stairs", "minecraft:wooden_trapdoors", "minecraft:wool", "minecraft:wool_carpets" ], "open": true }, "DataKind": { "doc": "A pack data kind data() lists: data///.json files a pack adds to.", "values": [ "corps" ] }, "CorpsColor": { "doc": "A Lantern corps colour.", "values": [ "green", "yellow", "red", "blue", "indigo", "violet", "orange", "black", "white" ] }, "At": { "doc": "Where an action happens: here (where it would anyway -- the target inside targets(), the wearer otherwise), or spot (the point markSpot fixed earlier in the same press or reaction).", "values": [ "here", "spot" ] }, "AreaShape": { "doc": "The shape status_area covers.", "values": [ "sphere", "box", "block_box" ] }, "DamageType": { "doc": "Thematic's damage types.", "values": [ "none", "bleed", "kryptonite", "magic", "psychic", "sonic", "ice", "electric", "fire", "radiation", "explosive", "poison", "emp", "solar", "wither", "asphyxiation", "ballistic", "fall" ] }, "Element": { "doc": "What a hit is made of: the word a suit's weaknesses, resistances and immunities are written in. A move that names its element is one an affinity can answer.", "values": [ "bleed", "kryptonite", "magic", "psychic", "sonic", "ice", "electric", "fire", "radiation", "explosive", "poison", "emp", "solar", "wither", "asphyxiation", "ballistic", "fall" ] }, "Who": { "doc": "Who a push moves, who lookAt() turns, or who removeEffect() clears: the wearer, or the target inside targets().", "values": [ "self", "target" ] }, "PushDirection": { "doc": "Which way a push goes. away_from_spot: out from the point markSpot fixed; heading: where the wearer faced as the move began (markHeading() can fix it later); aim: where the wearer aims now -- a mob, straight at its target; yaw: level along the wearer's yaw, whatever their pitch; toward_target_horizontal: level toward the target, full strength whatever the height between them; away_from_owner: from the wearer out to the one pushed; away_from_owner_horizontal: the same laid level, full strength whatever the height (the look laid level when straight overhead); toward_spot: from the one pushed in to the point markSpot fixed (none standing on it); moving: level, the way the wearer has been moving these last few ticks (the key they hold), their look laid level when still; away_from_target_horizontal: level, from the target out to the wearer (a retreat); toward_nearest: at the nearest wall or other living body (not the wearer) within reach, about the pushed one's height, so on_wall and on_collide fire on impact -- away_from_owner when nothing is in reach; away_from_anchor: level, from the anchor of the mission whose beat this runs in out to the one pushed (the one pushed's look laid level, reversed, standing on it); nothing outside a mission.", "values": [ "look", "look_horizontal", "yaw", "toward_target", "toward_target_horizontal", "toward_owner", "away_from_owner", "away_from_owner_horizontal", "away_from_spot", "away_from_anchor", "toward_spot", "heading", "aim", "moving", "away_from_target_horizontal", "toward_nearest", "none" ] }, "PushMode": { "doc": "add to the current velocity, or set it.", "values": [ "add", "set" ] }, "Hand": { "doc": "Which hand swapHeldItem() looks at.", "values": [ "main", "off" ] }, "SpotAnchor": { "doc": "Which point of the subject markSpot fixes: the body's centre, the feet, or the eyes; or impact, the point the action happens at (where a shot broke).", "values": [ "body", "feet", "eyes", "impact" ] }, "TeleportTo": { "doc": "Where teleport() puts someone. Moving the wearer: above_target (on its head), behind_target (at its back), facing_target (a step from it on the side the wearer came from: a face-off), short_of_target (a step short of it along a heading: a charge coming to rest). Moving the target: in_front_of_owner (along the wearer's look), under_owner (under the wearer's feet: a slam), to_owner (onto the wearer's feet, unchecked). spot moves the wearer onto a point markSpot fixed, and needs no target. The clear placements never put anyone inside a wall: along_look_clear (the wearer as far along their look as they fit: a blink) and away_from_attacker_clear (the wearer level away from the hit's attacker: a ward) need no target; around_target (the wearer at a random bearing from the target: a haunting), swap (the wearer and the target trade places, or neither moves), target_to_spot (the target onto the marked spot, or as near on the way as it fits: a yank) and ring_around_owner (the target on a random bearing around the wearer: a gather) do. impact moves the wearer onto the point the actions run at -- where a projectile stopped, in its on_block_hit or on_entity_hit -- walked back toward them until they fit: a landing; block_top puts the wearer on top of the block their look ray meets. nudge moves the target a little to the wearer's side, only where it fits: a stumble; clear_spot moves the target a little along a bearing (random, or toward the wearer), as far as it fits: a snap; level_with_owner drops (or lifts) the target straight along its own column to the wearer's feet height, half a block higher at a time until its box fits, or moves nobody and runs else: a drop to the wearer's level.", "values": [ "above_target", "behind_target", "in_front_of_owner", "facing_target", "short_of_target", "under_owner", "to_owner", "spot", "along_look_clear", "away_from_attacker_clear", "around_target", "swap", "target_to_spot", "ring_around_owner", "impact", "block_top", "nudge", "clear_spot", "level_with_owner" ] }, "TeleportBearing": { "doc": "Which way teleport() to: \"clear_spot\" moves the target: random (a level bearing at random) or toward_owner (level toward the wearer, never past them).", "values": [ "random", "toward_owner" ] }, "TeleportFace": { "doc": "Who teleport() to: \"spot\" turns the wearer to face: the hit's attacker (in a hurt or damaged reaction), or the one the press remembers, alive or not.", "values": [ "attacker", "remembered" ] }, "TeleportAlong": { "doc": "Which way short_of_target measures \"short\": the heading the move fixed (markHeading, or where the wearer faced as the move began), the wearer's look now, or straight at the target.", "values": [ "heading", "look", "toward_target" ] }, "KnockbackDirection": { "doc": "Which way knockback() shoves: away from what hit (a thrown thing; for an ability, the wearer), along the wearer's look, straight away from the wearer, or out from the spot markSpot fixed.", "values": [ "away_from_source", "look", "away", "away_from_spot" ] }, "KnockbackWho": { "doc": "Who knockback() shoves: the target inside targets() (the default), or the wearer.", "values": [ "target", "self" ] }, "TargetSelect": { "doc": "Who thematic:targets picks. Searches (around, ahead, cone, look, aimed, locked, locked_or_look, trail) only find those the wearer may hit unless hittable: false; allies, remembered, attacker, victim, marked and tracked take who they name.", "values": [ "around", "ahead", "cone", "look", "allies", "locked", "locked_or_look", "remembered", "attacker", "victim", "aimed", "trail", "marked", "tracked" ] }, "TargetPick": { "doc": "How many of those it keeps: all, the nearest, the first the search lists (what the old selectTarget picked), or one at random.", "values": [ "all", "nearest", "first", "random" ] }, "TargetSort": { "doc": "The order the found are taken in before the pick: as found, most directly aimed at first, closest first, or most levels of a status effect (sortEffect) first.", "values": [ "none", "aim", "distance", "effect_level" ] }, "TargetAlong": { "doc": "Which way ahead is: look (now, pitch and all), yaw (now, level) or heading (as the move began).", "values": [ "look", "yaw", "heading" ] }, "TargetsAt": { "doc": "Where an around search is centred: here (the wearer's hitbox), spot (the point markSpot fixed), source (the hitbox of the thrown thing or bolt whose hit runs the block) or target (the hitbox of the body the actions are aimed at -- each of the wearer's mobs inside ownedMobs() -- with nearest and a distance sort measured from it).", "values": [ "here", "spot", "source", "target" ] }, "OncePer": { "doc": "How often once() lets its actions run: the first time in each pass of the targets() around it, in the whole press, or on each beat of seconds.", "values": [ "pass", "run", "beat" ] }, "BeatClock": { "doc": "What once({ per: \"beat\" }) counts its beat on: the wearer's age, ticks since the phase began, or the world's time.", "values": [ "age", "state", "world" ] }, "TargetsExcept": { "doc": "Who targets() leaves out: struck, the body the actions are aimed at (what a bolt struck, the target of a targets() around this one), else the one the answered event struck; or players, every player.", "values": [ "struck", "players" ] }, "SpawnGroup": { "doc": "A spawn group, as vanilla sorts entity types: monster is the one not peaceful (misc, arrows and the like, counts as peaceful).", "values": [ "monster", "creature", "ambient", "axolotls", "underground_water_creature", "water_creature", "water_ambient", "misc" ] }, "PitchToward": { "doc": "Where turn() eases the wearer's pitch: toward the nearest one they may hit and can see, or level.", "values": [ "nearest", "level" ] }, "CarryAlong": { "doc": "Which way carry() holds the target out: the wearer's look now, the heading the move fixed, or level along their yaw.", "values": [ "look", "heading", "yaw" ] }, "CarryAt": { "doc": "Which part of the target carry() puts at the point: its middle (half its height below it) or its feet.", "values": [ "middle", "feet" ] }, "CarryMove": { "doc": "How carry() gets the target there. swept: a player teleported as far as fits, never through a wall, anything else moved with collision, at most max_step a tick; fit: teleported there only if they fit, else blocked says what happens; teleport: teleported there, no questions asked.", "values": [ "swept", "fit", "teleport" ] }, "CarryBlocked": { "doc": "What a fit carry does when the target won't fit at the point: let go where they are, or let go and slam them down under the wearer.", "values": [ "release", "slam" ] }, "CarryFall": { "doc": "The target's fall distance while carried: reset (forgotten every tick, no fall damage), book (every block the carry takes them down is added, so the landing costs what the drop would have), keep (left alone).", "values": [ "reset", "book", "keep" ] }, "DriveAlong": { "doc": "Which way drive() goes. yaw: level along the wearer's yaw; look: their look, pitch and all; heading: the heading the press fixed (or markHeading() since); aim: where they aim now -- a mob, straight at its target; toward_target: at the target, inside targets().", "values": [ "yaw", "look", "heading", "aim", "toward_target" ] }, "DriveOnWall": { "doc": "What drive() does while the wearer is against a wall: skip (leave the velocity alone this tick) or halt (stop dead).", "values": [ "skip", "halt" ] }, "SwingHandWhich": { "doc": "Which hand swingHand() swings: main, off, or alternate (main first, then off, through one press).", "values": [ "main", "off", "alternate" ] }, "GravityWho": { "doc": "Whose gravity gravity() turns off or on: the wearer, the target inside targets(), or both.", "values": [ "self", "target", "both" ] }, "RiseFrom": { "doc": "Where rise() measures its height from: start (where the wearer was the first time it ran in this press) or spot (the point markSpot fixed).", "values": [ "start", "spot" ] }, "DrivePath": { "doc": "The way drive() goes: line (along a direction, the default) or circle (round a centre).", "values": [ "line", "circle" ] }, "DriveAround": { "doc": "Where a circle drive's centre is: start (where the wearer stood the first time it ran in this press) or spot (the point markSpot fixed).", "values": [ "start", "spot" ] }, "RideRider": { "doc": "Who rides in ride(): self (the wearer, on the target) or target (the target, on the wearer).", "values": [ "self", "target" ] }, "HeadingFrom": { "doc": "Where markHeading() takes the heading from.", "values": [ "aim", "moving", "away_from_target" ] }, "SpinWho": { "doc": "Who spin() turns round: the target inside targets() (the default) or the wearer.", "values": [ "target", "self" ] }, "ScaleType": { "doc": "A Pehkui scale scale() can set: base is the whole body's size, falling how much a fall hurts (0: none), hitbox_width and hitbox_height the hitbox alone.", "values": [ "motion", "jump_height", "step_height", "reach", "block_reach", "attack", "defense", "base", "falling", "hitbox_width", "hitbox_height" ] }, "ScaleWhile": { "doc": "What holds a scale() on besides its time: the ability running, or the phase it was put on in.", "values": [ "active", "state" ] }, "DamageSourceKind": { "doc": "Who a damage() hit is credited as when no damageType says: auto (a thrown thing's, else the wearer's own attack), player_attack or mob_attack.", "values": [ "auto", "player_attack", "mob_attack" ] }, "ResolveAgainst": { "doc": "Whose tuned duration and amplifier an effect() left without them reads: the wearer's or the victim's.", "values": [ "wearer", "target" ] }, "HealTarget": { "doc": "Who heal() heals: the wearer, or the entity hit.", "values": [ "self", "hit" ] }, "EffectCategory": { "doc": "Which effects clearEffects() takes off.", "values": [ "all", "harmful", "beneficial", "none" ] }, "CooldownPick": { "doc": "Which of the matching abilities cooldowns() changes.", "values": [ "all", "first", "random" ] }, "LockMode": { "doc": "How lockMoves() holds a kit. dampen: each move is stamped shut until the lock lapses (presses refused, greyed on the HUD) and running ones are switched off; with stop: false they are only held, and a running move finishes. interrupt: running moves are switched off onto a cooldown, idle ones left alone. cooldown_floor: every move's cooldown is pushed out to at least the lock, running or not. disable_effect: interrupt, then the Disable effect for the lock's length.", "values": [ "dampen", "interrupt", "cooldown_floor", "disable_effect" ] }, "SlowMotionPhase": { "doc": "Which part of a slow motion a thematic:slow_motion action is: start (the wearer's own scales, shedding anyone else's slow), tick (sparks, catching and holding victims, holding projectiles) or end (letting go).", "values": [ "start", "tick", "end" ] }, "BeamDirection": { "doc": "Which way a beam goes: look (the wearer's; a mob's, eye to eye at what it was aimed at), target (at the centre of the one the targets() around it picked), outward (down a swept arm anchor; the look from any other) or facing (level, the way the body faces: the heading markHeading() fixed, else the wearer's yaw).", "values": [ "look", "target", "outward", "facing" ] }, "BeamReach": { "doc": "How far a beam runs: range, or target -- just past the one it is aimed at (overshoot), whatever the range.", "values": [ "range", "target" ] }, "BeamAim": { "doc": "What a mob's look-direction beam is aimed along: target (straight at what its controller aimed the move at, eye to eye; the default) or look (its own look, like a player).", "values": [ "target", "look" ] }, "Clock": { "doc": "What an every() rule counts on: \"age\" (the wearer's age; the default for a player's phase), \"state\" (ticks since the phase was entered, 1 on its first tick; a mob channel's default), \"world\" (the world's time), \"animation\" (the phase's clip, at its animationSpeed, 0 as it starts). In a component, \"phase\" is the phase clock: ticks since the phase was entered.", "values": [ "state", "age", "world", "animation", "phase" ] }, "StoreMode": { "doc": "How store() combines with what is kept: set it, add to it, or keep the larger or smaller.", "values": [ "set", "add", "max", "min" ] }, "SayPick": { "doc": "Which of its lines say() uses: a random one each time, or each in turn.", "values": [ "random", "cycle" ] }, "EquipSlot": { "doc": "The slot equip() fills.", "values": [ "mainhand", "offhand", "head", "chest", "legs", "feet" ] }, "Displaced": { "doc": "What equip() does with whatever already held the slot: into the inventory (or on the ground when that is full), or straight on the ground.", "values": [ "stash", "drop" ] }, "ParticleAnchor": { "doc": "How high on the subject a burst sits: its feet, or the middle of its body.", "values": [ "feet", "body" ] }, "ParticleEmit": { "doc": "How a burst's particles leave. burst: scattered where it happens; relative: sent to the clients to appear exactly there; spray: thrown along aim with a little lift; rake: three short strokes across aim; streak: four puffs in a line along aim.", "values": [ "burst", "relative", "spray", "rake", "streak" ] }, "ParticleAim": { "doc": "Which way a directional system throws: the look, straight up or down, where the wearer is moving (the look while they stand still), or the heading the move began with.", "values": [ "look", "up", "down", "motion", "heading" ] }, "ParticleShape": { "doc": "What a burst fills: one point, count points at random in a sphere, count points evenly from the wearer's eyes to the target's (inside targets()), or count particles born on a shell round the point and flying in to it.", "values": [ "point", "sphere", "line", "inward" ] }, "CircleSystem": { "doc": "The particle circle systems.", "values": [ "circle", "unfilled_circle", "tornado", "whirlpool", "helix", "ground_slam", "sonic_scream", "solar_explosion", "thick_smoke", "green_haze", "spiral_tornado", "spinning_ring", "surge", "green_wave", "fire_vortex", "cloud_puff" ] }, "DomeShape": { "doc": "The particle dome shapes.", "values": [ "full_dome", "dome_only", "burst_only", "atmospheric", "column", "expanding_ring" ] }, "SoundAt": { "doc": "Where a sound plays: here (where the action happens -- the target inside targets(), the wearer otherwise), spot (the point markSpot fixed), self (the wearer, even inside targets()), target (the entity hit, or the one the press remembered) or impact (the exact point something was hit).", "values": [ "here", "spot", "self", "target", "impact" ] }, "SoundOnce": { "doc": "How often a sound may play: once per pass through a list (the first target of a sweep sounds, the rest are silent), or once per press.", "values": [ "per_pass", "per_press" ] }, "SoundHeardBy": { "doc": "Who hears a sound: all (everyone near where it plays), wearer (the wearer alone, at their own position), or target (the aimed player alone; a body that is not a player hears nothing).", "values": [ "all", "wearer", "target" ] }, "AnimationOn": { "doc": "Who a clip plays on.", "values": [ "self", "target" ] }, "HoldPlay": { "doc": "How a held clip plays: through once and stays on its last frame, round and round, or through once and lets the pose go.", "values": [ "hold", "loop", "once" ] }, "HoldMode": { "doc": "How long a held clip stays: while the move's active flag is up, or while its phases run (let go of the moment they end).", "values": [ "active", "state" ] }, "LimbSet": { "doc": "A named set of limbs: all (head too), whole_body (all but the head), arms, upper_body (arms and body).", "values": [ "all", "whole_body", "arms", "upper_body" ] }, "Limb": { "doc": "One limb.", "values": [ "left_arm", "right_arm", "left_leg", "right_leg", "body", "head" ] }, "ProjectileBody": { "doc": "What carries a projectile: bolt (an energy bolt drawn from its look), thrown (a throwable definition's model and flight), arrow (an arrow definition, which decides its look and hits) or entity (any registered entity type, which decides how it looks, flies and hits).", "values": [ "bolt", "thrown", "arrow", "entity" ] }, "PatternShape": { "doc": "How the shots of one firing are laid out: ring (level, evenly round the wearer), fan (across lanes, centred on the aim), converge (from a ring round the anchor, meeting on one point), rain (falling from above) or spiral (laid round turns of a circle over the wearer, falling to the ground).", "values": [ "ring", "fan", "converge", "rain", "spiral" ] }, "RainAround": { "doc": "What a rain pattern falls around: self (the wearer's feet), target (the shot's target), spot (the spot the press fixed) or look (what the wearer looks at).", "values": [ "self", "target", "spot", "look" ] }, "FlightRelease": { "doc": "How a held or orbiting projectile is let go: keep (the way it was fired), look (along the wearer's look now), target (at its target's eyes, else along the look) or discard (gone; an orbit only). Always at the speed it was fired at.", "values": [ "keep", "look", "target", "discard" ] }, "HomingSeek": { "doc": "Who a homing projectile turns onto: target (the one it was fired at; a mob's, the one its move was aimed at) or nearest (the nearest its shooter may hit, picked again when that one is gone).", "values": [ "target", "nearest" ] }, "ProjectileAim": { "doc": "Which way a projectile leaves: look (the wearer's; a mob's, at its target), heading (as the press began) target (at the middle of one at found, or of the target a targets() block is aimed at) or ballistic (lobbed at that target: where they will be after the flight, raised by what it falls on the way) or crosshair (from where it leaves, toward what the wearer's crosshair is on, so a bolt leaving a palm still meets it).", "values": [ "look", "heading", "target", "ballistic", "crosshair" ] }, "DirectHit": { "doc": "What a projectile's head-on hit deals besides its actions: flat (exactly damage), arrow (vanilla's: damage times the speed it lands at, rounded up) or none.", "values": [ "flat", "arrow", "none" ] }, "LatchWhen": { "doc": "When a delayed projectile's origin or aim is read: press (as the action runs) or fire (as it leaves).", "values": [ "press", "fire" ] }, "LookStyle": { "doc": "How a projectile is drawn: bolt, streak, rod, crescent, model, none, lightning, orb, feather, polka_dot, bullet, particles, disc.", "values": [ "bolt", "streak", "rod", "crescent", "model", "none", "lightning", "orb", "feather", "polka_dot", "bullet", "particles", "disc" ] }, "BurstAt": { "doc": "Where a burst goes off. impact: where a shot landed -- the body it struck (its feet), else the point it hit, else where the action runs; here: where the action runs (the target inside targets(), the wearer otherwise); self: the wearer's feet; spot: the point markSpot fixed.", "values": [ "impact", "here", "self", "spot" ] }, "BurstAround": { "doc": "Whose surroundings a burst searches: burst, a box radius either way of its point; self, the wearer's hitbox grown by radius, while the push still comes from the burst's point.", "values": [ "burst", "self" ] }, "BurstShape": { "doc": "What a burst keeps of its search box: box, everything it touches; sphere, only bodies whose feet are within radius of the point.", "values": [ "box", "sphere" ] }, "BurstExclude": { "doc": "Who a burst leaves out besides the wearer. direct_hit: the body a shot struck head-on, which its own hit already paid; already_hit: anything the shot caught before (a piercing shot catches each body once); none.", "values": [ "direct_hit", "already_hit", "none" ] }, "BurstSource": { "doc": "What a burst's hit counts as. attack: the wearer's attack (a player's, else a mob's, else magic once nobody is left to credit); thrown: the thrown thing's hit, its owner behind it.", "values": [ "attack", "thrown" ] }, "ZoneAt": { "doc": "Where a zone lies: here (the impact, the target inside targets(), the wearer otherwise), spot (where markSpot fixed) or feet (where the wearer stands).", "values": [ "here", "spot", "feet" ] }, "ZoneShape": { "doc": "A zone's footprint: round (a disc, measured level) or box (the square).", "values": [ "round", "box" ] }, "TrackSync": { "doc": "What a track keeps a synced copy of, for the trail and readout visuals: the target's name, display health, whole seconds of bleed left, and position.", "values": [ "name", "health", "bleed", "position" ] }, "DensityPart": { "doc": "Which part of the wearer a density shimmer covers: body (the whole of them, the phase's own) or hand (a hand reaching into someone while the rest stays solid).", "values": [ "body", "hand" ] }, "SummonArrangement": { "doc": "Where summons stand around their centre, measured from the way the wearer's body faces: ring (evenly all the way round, the first straight ahead), front_arc (a half turn from hard left to hard right through the front), rear_arc (the same through the back; a lone one straight behind), random (each at a bearing of its own) or formation_v (a lead with the rest paired off behind it, left then right: radius further out and stagger further back each rank).", "values": [ "ring", "front_arc", "rear_arc", "random", "formation_v" ] }, "SummonTarget": { "doc": "Whom summons go for: target (the target the action is aimed at), attacker (whoever hurt the wearer, in a hurt reaction), victim (whoever the wearer hit) or locked (the one the wearer has locked on). Named and not there, nothing is summoned.", "values": [ "target", "attacker", "victim", "locked" ] }, "SummonAlong": { "doc": "Which way a summon is sent off: look (along the wearer's look), facing (level, the way they face), outward (along the bearing it was laid out on: a ring running out), to_target (toward the one target named; the look when there is none) or up.", "values": [ "look", "facing", "outward", "to_target", "up" ] }, "SummonAt": { "doc": "What summons stand round: wearer (the default), target (the target the action is aimed at), spot (the spot the move fixed with markSpot), face (on the block face a shot struck, or the wall beside the body aimed at, turned out of it), random (a random bearing, spread blocks off the wearer) or random_water (a random spot of water within spread of them; one try, none when it is not water).", "values": [ "wearer", "target", "spot", "face", "random", "random_water" ] }, "AttributeOperation": { "doc": "How an attribute modifier counts: add (to the base), multiply_base (adds that share of the base) or multiply_total (scales the total by one plus it).", "values": [ "add", "multiply_base", "multiply_total" ] }, "GiveSlot": { "doc": "Where give() puts the item: the inventory, an equipment slot (what held it moves to the inventory), hand: the main hand when it holds nothing, else the inventory; or hotbar: the first of a player's nine hotbar slots that takes it, and nothing handed when none does.", "values": [ "inventory", "mainhand", "offhand", "head", "chest", "legs", "feet", "hand", "hotbar" ] }, "GunFireMode": { "doc": "A gun's fire mode, as give()'s gun option picks it.", "values": [ "single", "automatic", "burst" ] }, "WheelSource": { "doc": "Where a wheel's entries come from: the ring's starred constructs (a pick is the construct grid's summon), or the entries the script lists.", "values": [ "construct_favourites", "list" ] }, "WheelTap": { "doc": "What a quick tap of a wheel's key does: open the dial as a hold does, or fire the entry picked last (sneak: and a sneaking press opens the dial at once).", "values": [ "open", "last", "sneak" ] }, "ConsoleGesture": { "doc": "How a draw tool is drawn: a path of points, a zone (a centre and an edge) or a lasso round bodies.", "values": [ "path", "zone", "lasso" ] }, "ConsoleVerb": { "doc": "The squad order a gesture gives: patrol and waypoints fly the points in order, move_to goes to the last, hold_zone guards a circle, focus_set takes the bodies inside a lasso (or one picked entity).", "values": [ "waypoints", "patrol", "move_to", "hold_zone", "focus_set" ] }, "ConsolePick": { "doc": "What a pick mode lets the cursor pick: a unit (its slot), an entity, or a point in the world; \"target\" is an entity if one is under the cursor, else the point: on its own (\"target\") the nearest ready unit goes there, after \"unit\" the unit that was picked.", "values": [ "unit", "entity", "point", "target" ] }, "BlockAt": { "doc": "Which block a block verb starts from.", "values": [ "hit", "pos", "self", "below", "look", "spot" ] }, "BlockShape": { "doc": "Which blocks around it: single -- that one; plus -- it and its four level neighbours (with face, the block it stepped out of too); circle -- a level disc; box -- a box; ring -- a hollow wall round the point, radius out and thickness thick.", "values": [ "single", "plus", "circle", "box", "ring" ] }, "BreakPattern": { "doc": "What breakPattern breaks: single -- one block; plane -- a square across the face; cube -- a cube; vein -- the same block touching it, corners included; tree -- the trunk touching it, and its leaves; line -- the start block and length more along a direction, ending at the first block in the way it may not take (a tunnel).", "values": [ "single", "plane", "cube", "vein", "tree", "line" ] }, "PlaneOrient": { "doc": "Which way a plane lies (and a line runs): face -- across the face that was hit (a line: into it); horizontal -- level, whatever was hit (a line: straight down); look -- across the wearer's look now (a line: along it); heading -- across the way the wearer faced as the press began, the look now outside a press (a line: along it).", "values": [ "face", "horizontal", "look", "heading" ] }, "VeinKind": { "doc": "What a vein is made of: corners -- the start block's own kind (or the filter, once it is broken), touching through faces, edges and corners; event_block -- the kind of block the answered event broke or used, touching through faces only.", "values": [ "corners", "event_block" ] }, "DropsAt": { "doc": "Where a broken block's drops land: block -- where it was; wearer -- at the wearer's feet; start -- at the block the pattern started from.", "values": [ "block", "wearer", "start" ] }, "TransformPick": { "doc": "Which of the blocks it finds transformBlock changes: all -- every one; random_neighbour -- one of the six blocks touching the start one that it would change, at random.", "values": [ "all", "random_neighbour" ] }, "TransformOnly": { "doc": "What else a block must be for transformBlock to take it: any; still_source -- a fluid's source lying still (not a flowing one, not a dry block).", "values": [ "any", "still_source" ] }, "FireFooting": { "doc": "Where placeFire's fire may stand: any -- wherever fire can burn (on a block with a top, or beside something that burns); solid -- only air over a solid block; search -- each spot dropped up to 2 blocks onto the first air over a solid block, none where there is none.", "values": [ "any", "solid", "search" ] }, "FireAcross": { "doc": "Which way placeFire's line is measured from: facing -- the way the wearer faces now; heading -- the way they faced as the press began (now, outside a press).", "values": [ "facing", "heading" ] }, "BlockDrops": { "doc": "What a broken block drops: none; normal -- what it drops to the stack the action runs for (its enchantments count) or to a bare hand; fortune -- what it drops to a diamond pickaxe with Fortune.", "values": [ "none", "normal", "fortune" ] }, "BlockReplace": { "doc": "What a placed block may take the place of: replaceable -- air, water, grass and the like; air -- air only; any -- any block that can be broken.", "values": [ "replaceable", "air", "any" ] }, "PropertyCycleMode": { "doc": "What cycleBlockProperty does: auto -- picks the next property when the wearer sneaks (going back through the list), steps its value otherwise; value -- steps the value; select -- picks the next property.", "values": [ "auto", "value", "select" ] }, "PullToward": { "doc": "What pull() draws toward: the owner, the source (the projectile, or the wearer), here (where the action happens, fixed when it starts) or the spot markSpot() fixed.", "values": [ "owner", "source", "here", "spot" ] }, "PullPoint": { "doc": "Which point of a pulled body pull() aims from: its feet or its middle.", "values": [ "feet", "center" ] }, "PullBeam": { "doc": "The beam pull() draws from what pulls to what is pulled.", "values": [ "harpoon", "web", "sonar", "arc" ] }, "PetCommand": { "doc": "What commandPets() tells the owner's animals: attack the entity hit, rally where the action happens, or recall to the owner.", "values": [ "attack", "rally", "recall" ] }, "DeflectDirection": { "doc": "Where deflectProjectile() sends a projectile: reverse (straight back, keeping its rise or fall), look (the way the wearer looks, at the speed it came) or shooter (straight at whoever shot it, at the speed it came; reverse when nothing living shot it).", "values": [ "reverse", "look", "shooter" ] }, "CaptureWhenFull": { "doc": "What captureEntity() does when the holder already has something: nothing, or release it where the action happens.", "values": [ "nothing", "release" ] }, "StackStateOp": { "doc": "What stackState() does to its key: a counter added to (wrapping at wrap) or set, a flag set, cleared or toggled, a gauge set or added to within min..max, a timer started for seconds, or the key cleared.", "values": [ "add_counter", "set_counter", "set_flag", "clear_flag", "toggle_flag", "set_gauge", "add_gauge", "start_timer", "clear" ] }, "WaveFrom": { "doc": "Where a wave() spreads from: start (where the wearer stood when it went off), self (the wearer, wherever they are at each pulse), spot (the point markSpot fixed) or here (where the actions are happening: a thrown thing's hit).", "values": [ "start", "self", "spot", "here" ] }, "WaveAlong": { "doc": "Which way a line wave() runs: look (along the wearer's look) or facing (level, the way they face).", "values": [ "look", "facing" ] }, "OwnedSelect": { "doc": "Which of the wearer's mobs: owned (every one tamed to them or naming them as its owner) or companions (only the companion, tagged thematic_companion).", "values": [ "owned", "companions" ] }, "CommandOrder": { "doc": "What command() tells the wearer's mobs: attack (go for one thing, never one the wearer couldn't hit), recall (break off and come back; one past 8 blocks is brought), rally (run to a step from where the action happens), sit, stand, follow (stand up and walk to the wearer), tempt (walk over looking at them), dismiss (gone from the world), fetch_items (bring back the drops lying near them) or fetch (one left further off than beyond is brought to the wearer's side, still doing what it was). A summon that takes orders (a squad flier) also answers expend (a homing charge at the target, going off for share of its damage), gather (close in round the wearer for seconds), offline (drop out of the air for seconds), use (fire move now) and refresh (every move ready again).", "values": [ "attack", "recall", "rally", "sit", "stand", "follow", "tempt", "dismiss", "fetch_items", "fetch", "expend", "gather", "offline", "use", "refresh" ] }, "CommandAttackAt": { "doc": "What command(\"attack\") goes for: target (the target the action is aimed at), aimed (what the wearer aims at, in sight, within range), nearest_marked (the nearest thing only they marked, within range) or nearest_threat (the nearest monster or player they may hit within range of the one ordered -- mob: \"aimed\" -- else of the wearer).", "values": [ "target", "aimed", "nearest_marked", "nearest_threat" ] }, "AttractKind": { "doc": "What attract() draws: items (drops, pulled through the air), xp (experience orbs) or animals (passive mobs, which walk over).", "values": [ "items", "xp", "animals" ] }, "CollectTo": { "doc": "Where collectDrops brings the items: wearer -- to their feet; spot -- the point markSpot or findBlock fixed.", "values": [ "wearer", "spot" ] }, "MeterRefresh": { "doc": "What opening a window that is already open does: bank (a charge more and the clock again, up to charges.max; at the max, nothing -- Ember), bleed (the time left cut by bleed; cut past nothing, it closes -- Void), refresh (the clock again) or keep (nothing).", "values": [ "bank", "bleed", "refresh", "keep" ] }, "ShakeStyle": { "doc": "How a shake moves the view.", "values": [ "classic", "trauma", "rumble" ] }, "ShakeDirection": { "doc": "Whether a shake also kicks the view.", "values": [ "none", "away", "hit" ] }, "ScreenTo": { "doc": "Whose screen a screen effect plays on.", "values": [ "self", "target", "targets" ] }, "OverlayBlend": { "doc": "How an overlay is mixed into the picture: laid over it, or added to its light.", "values": [ "normal", "add" ] }, "ScreenEffectName": { "doc": "A sustained screen effect screenClear() can end.", "values": [ "all", "overlay", "grade", "letterbox", "fog", "muffle", "film_grain", "look_at", "disorient", "cinematic_hud", "splat", "jolt" ] }, "LookAtPoint": { "doc": "What screenLookAt() turns the view toward: anchor (the mission's anchor when run from a mission's beat, else where the action happens), wearer (the wearer's eyes: the boss, in a mission's beat), target (the eyes of the body the action is aimed at), pos (where the action happens), or a world point.", "values": [ "anchor", "wearer", "target", "pos" ] }, "FakeAudience": { "doc": "Who sees a fake-world effect.", "values": [ "self", "target", "nearby" ] }, "DebrisHeading": { "doc": "Which way debris is thrown: face -- out of the face that was hit (up, off a floor); up; look -- along the wearer's look; away -- away from the wearer.", "values": [ "face", "up", "look", "away" ] }, "FakeRevertMode": { "doc": "How fakeRevert() undoes the fake world: ring -- healing outward from a point; all -- at once.", "values": [ "ring", "all" ] }, "GunAction": { "doc": "What gunAction() has the held gun do: reload (the client reloads the gun in hand, as the reload key does), fire (the client pulls the trigger once, with ammo) or close (ends an open gunWindow, both halves).", "values": [ "reload", "fire", "close" ] }, "WeatherSet": { "doc": "What weather() does: cycle (clear to rain, rain to thunder, thunder to clear), or the weather to set.", "values": [ "cycle", "clear", "rain", "thunder" ] }, "ScreenKind": { "doc": "The screen openScreen() opens: the wearer's ender chest, a crafting grid, or an inventory stored on them.", "values": [ "ender_chest", "crafting", "stored_inventory" ] }, "SpectateView": { "doc": "What spectate() hands the camera to: the entity hit (the wearer looks out through it), or the wearer's own head.", "values": [ "target", "head" ] }, "RepairHands": { "doc": "Which hands repairItem() mends.", "values": [ "main", "off", "both" ] }, "DropAt": { "doc": "Where dropItem() drops: the wearer, the entity or block hit, where the actions happen, or the spot.", "values": [ "self", "hit", "pos", "spot" ] }, "PingAt": { "doc": "What ping() points at: the entity or block hit, where the actions happen, or the spot.", "values": [ "hit", "pos", "spot" ] }, "LightningAt": { "doc": "What bolts land round: here (where the action is -- the target inside targets(), the wearer on a press), wearer, target (the target the action is aimed at; none, no bolt) or spot (the spot the move fixed with markSpot; none, no bolt).", "values": [ "here", "wearer", "target", "spot" ] }, "LightningScale": { "doc": "How big a bolt is: normal (the stun lightning) or huge (five times the size, flashing for longer).", "values": [ "normal", "huge" ] }, "StrandTo": { "doc": "Where a strand() ends: look_hit (the block the wearer's look meets within range; none, no strand).", "values": [ "look_hit" ] }, "StrandFrom": { "doc": "Where a strand() starts: self (the wearer's feet) or chain (the end of the wearer's newest strand of that entity while it lasts and is within range, else the point of their last strand() press within window; with neither, the press only anchors its point).", "values": [ "self", "chain" ] } }, "actions": { "thematic:explode": { "doc": "A vanilla explosion where it happens. Blocks survive unless break_blocks.", "fields": { "power": { "type": "number", "doc": "explosion power (2)" }, "fire": { "type": "boolean", "doc": "sets fires (false)" }, "break_blocks": { "type": "boolean", "doc": "breaks blocks (false)" } } }, "thematic:area_effect": { "doc": "A status effect on everyone in radius but the wearer and their allies.", "fields": { "effect": { "type": "string", "required": true, "doc": "the status effect id, e.g. \"minecraft:slowness\"" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" }, "ambient": { "type": "boolean", "doc": "the faint beacon-style swirl (false)" }, "show_particles": { "type": "boolean", "doc": "false hides the effect's particles (true)" }, "show_icon": { "type": "boolean", "doc": "false hides the HUD icon (true)" }, "radius": { "type": "number", "doc": "left out, the tuned radius" } } }, "thematic:area_damage": { "doc": "Hurts everyone in radius but the wearer and their allies.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "element": { "type": "Element", "doc": "what the hit is made of, e.g. \"fire\"; left out, the wearer's own attack" } } }, "thematic:ignite": { "doc": "Sets the entity hit on fire, or caps how long it still burns.", "fields": { "seconds": { "type": "Amount", "doc": "how long it burns (3)" }, "exact": { "type": "boolean", "doc": "burns for exactly that long, Fire Protection and the difficulty left out of it, and never cuts a longer fire already burning short (false: vanilla's setOnFireFor, which they shorten)" }, "max_seconds": { "type": "Amount", "doc": "then cuts its burn down to at most this long (a shorter one is left alone): spending a body's fire down to a stub. Without seconds it only caps, and sets nothing alight" } } }, "thematic:discard": { "doc": "Removes the thrown thing that did this. Throwables only.", "fields": {} }, "thematic:basic_damage": { "doc": "A throwable payload; the stat fields override the definition's own.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" } } }, "thematic:emp": { "doc": "A throwable payload; the stat fields override the definition's own.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" } } }, "thematic:flash": { "doc": "A throwable payload; the stat fields override the definition's own.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" } } }, "thematic:smoke": { "doc": "A throwable payload; the stat fields override the definition's own.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" }, "tear_gas": { "type": "boolean", "doc": "tear gas rather than plain smoke (false)" } } }, "thematic:freeze": { "doc": "A throwable payload; the stat fields override the definition's own.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" } } }, "thematic:electric": { "doc": "A throwable payload; the stat fields override the definition's own.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" } } }, "thematic:bind": { "doc": "A throwable payload; the stat fields override the definition's own.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" }, "bind_equipment": { "type": "boolean", "doc": "also binds held items (true)" } } }, "thematic:explosive": { "doc": "A throwable payload; the stat fields override the definition's own.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" }, "power": { "type": "number", "doc": "explosion power" }, "power_per_damage": { "type": "number", "doc": "power added per point of damage (1)" }, "break_blocks": { "type": "boolean", "doc": "breaks blocks" } } }, "thematic:incendiary": { "doc": "A throwable payload; the stat fields override the definition's own.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" } } }, "thematic:status": { "doc": "A throwable payload; the stat fields override the definition's own.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" }, "effects": { "type": "Array<{ effect: string; duration?: number; amplifier?: number }>", "required": true, "doc": "the effects to apply" } } }, "thematic:sonic": { "doc": "A throwable payload; the stat fields override the definition's own.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" } } }, "thematic:antidote": { "doc": "A throwable payload; the stat fields override the definition's own.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" } } }, "thematic:projectile_damage": { "doc": "Damage from a thrown thing, scaled by the thrower's utility attack.", "fields": { "damage": { "type": "number", "doc": "left out, the definition's damage" }, "damage_type": { "type": "DamageType", "doc": "the damage type (the throwable's own)" }, "element": { "type": "Element", "doc": "what the hit is made of, the generic spelling of damageType" } } }, "thematic:impact_damage": { "doc": "Arrow-style damage scaled by speed.", "fields": { "damage": { "type": "number", "doc": "left out, the definition's damage" } } }, "thematic:lightning_strike": { "doc": "Strikes the entity hit with lightning.", "fields": {} }, "thematic:thematic_explosion": { "doc": "Thematic's own explosion: flat damage to everyone the thrower may hit, a dome of particles and a bang.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "fire": { "type": "boolean", "doc": "sets fires (false)" }, "fire_seconds": { "type": "number", "doc": "sets those hit alight this long (0)" }, "break_blocks": { "type": "boolean", "doc": "breaks blocks (false)" }, "shockwave": { "type": "boolean", "doc": "adds a shockwave ring (false)" }, "shockwave_damage": { "type": "number", "doc": "what the shockwave itself deals; needs shockwave (0)" }, "at": { "type": "\"here\" | \"spot\" | \"summoned\"", "doc": "where it goes off: here (where the action happens), spot (the spot the move fixed; nothing without one) or summoned (where the body the action is aimed at stands now -- inside a summon's do; nothing once it is gone, and a display summon is taken away as it goes off)" } } }, "thematic:status_area": { "doc": "Status effects on everyone in an area.", "fields": { "effects": { "type": "Array<{ effect: string; duration?: number; amplifier?: number; ambient?: boolean; show_particles?: boolean; show_icon?: boolean }>", "required": true, "doc": "the effects" }, "shape": { "type": "AreaShape", "doc": "the area's shape (sphere)" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" }, "respect_teams": { "type": "boolean", "doc": "skips the thrower's allies (true)" }, "include_owner": { "type": "boolean", "doc": "includes the thrower (false)" }, "particle_on_each": { "type": "{ system?: CircleSystem; height?: number; radius?: number; count?: number; particle?: ParticleSpec }", "doc": "a particle circle on each one affected" } } }, "thematic:feed": { "doc": "Feeds the wearer.", "fields": { "food": { "type": "number", "doc": "hunger points (1)" }, "saturation": { "type": "number", "doc": "(1)" } } }, "thematic:run_ability_hook": { "doc": "Runs a hook registered in Java by id.", "fields": { "hook": { "type": "string", "required": true, "doc": "the hook id" }, "damage": { "type": "number", "doc": "stat override" }, "radius": { "type": "number", "doc": "stat override" }, "duration": { "type": "number", "doc": "stat override" }, "amplifier": { "type": "number", "doc": "stat override" } } }, "thematic:self_effect": { "doc": "A status effect on the wearer.", "fields": { "effect": { "type": "string", "required": true, "doc": "the status effect id, e.g. \"minecraft:slowness\"" }, "duration": { "type": "number", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "number", "doc": "0 is level I; left out, the tuned amplifier" }, "ambient": { "type": "boolean", "doc": "the faint beacon-style swirl (false)" }, "show_particles": { "type": "boolean", "doc": "false hides the effect's particles (true)" }, "show_icon": { "type": "boolean", "doc": "false hides the HUD icon (true)" } } }, "thematic:ignite_jets": { "doc": "Lights the wearer's thrusters (the flight profile's jets that say \"when\": \"dash\") for a moment, for everyone who can see them; a suit-wearing mob lights its own the same way. Call it every tick of a longer burn, or once with a duration that covers it: the flames fade out over the last few ticks.", "fields": { "duration": { "type": "number", "doc": "seconds the jets stay lit (0.5), at most 10" } } }, "thematic:area_launch": { "doc": "Throws everyone in radius the way the wearer is facing.", "fields": { "strength": { "type": "number", "doc": "(1)" }, "lift": { "type": "number", "doc": "added upward (0)" }, "radius": { "type": "number", "doc": "left out, the tuned radius" } } }, "thematic:lunge": { "doc": "Throws the wearer the way they are facing.", "fields": { "strength": { "type": "number", "doc": "(1)" }, "lift": { "type": "number", "doc": "added upward (0)" } } }, "thematic:speedster_run": { "doc": "One server tick of a speedster's run for this move: run it every tick. The run's jump, step and motion scales and its speed modifier go on (the motion and the modifier stand aside while the wearer wall-runs or slowed time owns their motion), and the run-in and running sounds play as they set off and keep going -- the move's own cues (options run_in_sound / running_sound, or sound_prefix), else Thematic's. stop takes the run off.", "fields": { "stop": { "type": "boolean", "doc": "takes the run's scales and modifier off instead (false)" }, "sounds": { "type": "boolean", "doc": "plays the running sounds (true; false with stop)" } } }, "thematic:if": { "doc": "Runs one list of actions when a guard holds and another when it does not.", "fields": { "if": { "type": "Guard", "required": true, "doc": "the question" }, "do": { "type": "ActionObject[]", "required": true, "doc": "when it holds" }, "else": { "type": "ActionObject[]", "doc": "when it does not" } } }, "thematic:push": { "doc": "Sets or adds velocity to the wearer or the target, in a named direction.", "fields": { "who": { "type": "Who", "doc": "self (default) or target" }, "direction": { "type": "PushDirection", "doc": "which way (none: lift only)" }, "strength": { "type": "Amount", "doc": "along the direction (1); worked out when it runs, e.g. a recoil growing with the gauge" }, "lift": { "type": "Amount", "doc": "added upward (0); wave(...) for a bob" }, "flat": { "type": "boolean", "doc": "drop the direction's vertical part (false)" }, "mode": { "type": "PushMode", "doc": "add (default) or set" }, "keep": { "type": "number", "doc": "with set (a launch too): the fraction of current sideways speed kept (0)" }, "falloff": { "type": "Amount", "doc": "weaker further out: strength times (1 - distance / falloff), measured from the spot markSpot fixed, or the wearer" }, "min_strength": { "type": "number", "doc": "with falloff: the least it pushes, however far out (0)" }, "vertical_strength": { "type": "number", "doc": "the direction's vertical part is scaled by this rather than strength" }, "reset_fall": { "type": "boolean", "doc": "forget the fall so far, so the push does not end in fall damage (false)" }, "launch": { "type": "boolean", "doc": "a launch rather than a plain push: the launch rules every slam used -- the launch callback, a lock, a packet to a player (false)" }, "vertical": { "type": "\"keep\" | Amount", "doc": "the whole vertical, apart from the direction: keep (a set keeps the one it had, an add adds none) or a number. Takes no lift or vertical_strength beside it. mode \"set\" with direction \"none\" and vertical \"keep\" stops the sideways motion alone" }, "on_collide": { "type": "ActionObject[]", "doc": "a thrown body: watched every tick while it flies, the first living thing it passes within collide_radius of (not itself, not the wearer, not one the wearer may not hit) gets these actions as the target, the thrown body as remembered -- a hurled victim knocking down whoever it lands in. The watch ends then, or when it lands, dies, all but stops, or after 10 seconds" }, "collide_radius": { "type": "number", "doc": "with on_collide: how near the body must pass, in blocks (1.2)" }, "on_wall": { "type": "ActionObject[]", "doc": "a pushed body (not the wearer): watched every tick for wall_for seconds, and the first tick it runs into a wall it gets these actions as the target, once -- a blast that hurts more when it slams its victim into a wall" }, "wall_for": { "type": "Amount", "doc": "with on_wall: how many seconds the body is watched for a wall (0.75)" }, "within": { "type": "Amount", "doc": "with direction toward_nearest: how far it looks for a wall or body to throw the pushed one at, in blocks (8)" } } }, "thematic:mark_time": { "doc": "Stores the world time on the wearer, synced, for a client visual to count from.", "fields": { "key": { "type": "string", "required": true, "doc": "the key the visual reads" } } }, "thematic:mark_spot": { "doc": "Fixes a point for the rest of the press or reaction -- the body centre of the target inside targets(), of the wearer otherwise -- for at: \"spot\" and away_from_spot to use later. Also stored on the wearer, synced, under the key, with the wearer's facing under _yaw and _pitch, for a client visual drawn there.", "fields": { "key": { "type": "string", "required": true, "doc": "the key the visual reads" }, "anchor": { "type": "SpotAnchor", "doc": "body (default): the centre; feet: where it stands; eyes: its eyes (with along \"look\": the point the look ray meets a block at); impact: where the action happens -- in a projectile's onHit or onBlock, the point it broke, mid-air at the end of a fuse too" }, "behind": { "type": "number", "doc": "instead, the point this many blocks behind the subject's back (the way its body faces), at its feet" }, "ahead": { "type": "number", "doc": "instead, the point this many blocks ahead the way the subject looks, level whatever its pitch, at its feet" }, "safe": { "type": "boolean", "doc": "with behind: searched for room -- level, then 1 up, 1 down, 2 up, 2 down, for two free blocks with a solid floor if the subject stands on the ground -- centred on the block; no room: the wearer's own feet (false)" }, "along": { "type": "\"look\" | \"block_top\"", "doc": "instead, look: the wearer's own point (anchor) carried along their look, a ray from the eyes against block colliders, not fluids, out to reach; block_top: the top centre of the block their look ray meets (outline shapes, not fluids; a ray that meets nothing, the block at its end), above blocks over its top face" }, "reach": { "type": "Amount", "doc": "with along: how far the ray goes; left out, the tuned radius (block_top: 75)" }, "reach_min": { "type": "number", "doc": "with along: the reach is never less than this, whatever the Amount works out to (0)" }, "reach_max": { "type": "number", "doc": "with along: the reach is never more than this (no cap)" }, "fail_message": { "type": "string", "doc": "with required: said on the wearer's action bar when the press is called off for want of room: a translation key or text" }, "above": { "type": "number", "doc": "with along \"block_top\": how far over the block's top face the spot sits (0)" }, "offset": { "type": "[number, number, number]", "doc": "moves the spot, once found, this many blocks on the world's axes: [8, 0, 0] is 8 blocks east of it (none); with offset_frame \"line\", [right, up, forward] instead" }, "offset_frame": { "type": "\"world\" | \"line\"", "doc": "how offset is measured: world (default), on the world's axes; line, [right, up, forward] along the line from the wearer's eyes to the spot -- [0, 5, -4] is 4 back toward the wearer and 5 up, [8, 5, 0] 8 to the right of that line" }, "rise_out_of_blocks": { "type": "boolean", "doc": "once placed, moved up half a block at a time (ten at most) while it sits in a block that is not air (false)" }, "standoff": { "type": "number", "doc": "with along: how far short of a block the ray met the spot stops, never behind the wearer (0)" }, "fit": { "type": "boolean", "doc": "with along: walked back toward the wearer half a block at a time until their hitbox fits there empty; fits nowhere and nothing is marked (false)" }, "required": { "type": "boolean | { missCooldown: number }", "doc": "with fit: fitting nowhere calls the whole press off: no later steps, no cooldown -- or, with missCooldown (miss_cooldown in a file), that share of it; along \"look\" without fit: the same when the look ray meets no block" } } }, "thematic:extinguish": { "doc": "Puts out fire, lit candles and lit campfires in the box around the wearer -- or, with at and shape, around the block hit, the spot, or wherever the block verbs can start from. With who, a burning body instead.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (self): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "shape": { "type": "BlockShape", "doc": "which blocks (box)" }, "radius": { "type": "Amount", "doc": "a box or circle: sideways, rounded up, at most 16; left out, the tuned radius" }, "height": { "type": "number", "doc": "a box: up and down, at most the radius (3); a circle: layers going up (1)" }, "blocks": { "type": "(\"fire\" | \"candles\" | \"campfires\")[]", "doc": "what it puts out (all three)" }, "grief_check": { "type": "boolean", "doc": "only where the wearer may build -- claims, spawn protection (false)" }, "who": { "type": "Who", "doc": "instead of blocks, put out a burning body: the wearer (self) or the target inside targets(). Takes none of the block fields" } } }, "thematic:swap_held_item": { "doc": "Swaps the held item for the next one in a cycle, keeping its tag.", "fields": { "cycle": { "type": "string[]", "required": true, "doc": "item ids, in the order they swap" }, "hand": { "type": "Hand", "doc": "main (default) or off" }, "do": { "type": "ActionObject[]", "doc": "run only if it swapped" } } }, "thematic:teleport": { "doc": "Puts the wearer by the target, or the target by the wearer. Inside targets() -- except to: \"spot\", which puts the wearer on a point markSpot fixed, anywhere, and along_look_clear and away_from_attacker_clear, which move the wearer by their own look or the hit that answered.", "fields": { "to": { "type": "TeleportTo", "required": true, "doc": "where" }, "gap": { "type": "number", "doc": "above_target: space left above its head; block_top: how far over the block's top face (0)" }, "distance": { "type": "number", "doc": "behind_target: how far behind; in_front_of_owner: how far along the wearer's look, at the target's own height; facing_target: how far from the target; short_of_target: how far short of it (1); around_target: how far from the target (2)" }, "spread": { "type": "number", "doc": "behind_target (not safe), around_target: random extra distance (0)" }, "rise": { "type": "number", "doc": "around_target: up to this many blocks higher than the target, at random; behind_target: this many blocks higher; facing_target: this many blocks above the target's feet, unless keep_height (0)" }, "reach": { "type": "Amount", "doc": "along_look_clear, away_from_attacker_clear: the furthest the hop goes; ring_around_owner: how far out the ring is; clear_spot: how far the target is moved (the tuned radius); block_top: how far the look ray goes (75)" }, "min": { "type": "number", "doc": "the clear placements, swap, target_to_spot, ring_around_owner, impact, clear_spot: the shortest move worth making; with no room that far, nobody moves (1); a safe behind_target: the nearest it searches (1)" }, "step": { "type": "number", "doc": "those same: how far back each try walks when the body does not fit (0.5)" }, "else": { "type": "ActionObject[]", "doc": "those same, and nudge: run when they found nowhere to put anyone and nobody moved -- a refund, a fizzle" }, "sideways": { "type": "number", "doc": "nudge: blocks to the wearer's right, negative to their left (0.25)" }, "if_fits": { "type": "boolean", "doc": "nudge: only move the target where its hitbox fits (true)" }, "bearing": { "type": "TeleportBearing", "doc": "clear_spot: which way (random)" }, "standoff": { "type": "number", "doc": "clear_spot toward_owner: stop this far short of the wearer (1)" }, "stop": { "type": "boolean", "doc": "zero the velocity of whoever was moved, so the placement sticks (false)" }, "keep_height": { "type": "boolean", "doc": "facing_target, short_of_target: stay at the wearer's height rather than drop to the target's (false)" }, "max_snap": { "type": "number", "doc": "short_of_target: the furthest the wearer may be moved, in blocks; further and they stay put" }, "along": { "type": "TeleportAlong", "doc": "short_of_target: which way is short (heading)" }, "safe": { "type": "boolean", "doc": "under_owner: stop at the first floor on the way down, and only move the target if it fits there; behind_target: search from distance behind the target's back (along its look, pitch and all) in by step to min, rise higher, for air at the feet and head -- none, and the furthest regardless (false)" }, "fall_speed": { "type": "number", "doc": "under_owner: then set the target's velocity to straight down at this speed -- or to nothing, when a safe placement found the floor" }, "spot": { "type": "string", "doc": "spot, target_to_spot: the markSpot key of the point; left out, the spot this press or reaction marked last. The one moved is stopped dead and their fall forgotten; nothing marked, they stay put" }, "below": { "type": "number", "doc": "spot: how many blocks under it, never under the bottom of the world (0)" }, "face": { "type": "TeleportFace", "doc": "spot: turn the wearer to face them; left out, the wearer keeps their look" } } }, "thematic:look_at": { "doc": "Turns the wearer to face the target's eyes, or (who: target) the target -- player or mob -- to face the wearer's. With spot, to face a point instead: the nearest ore findBlock() found, a markSpot(); with away, to turn their back on the other.", "fields": { "who": { "type": "Who", "doc": "self (default) or target" }, "drop": { "type": "number", "doc": "aim this many blocks under the other's eyes: the throat, not the face (0)" }, "spot": { "type": "boolean | string", "doc": "look at a point instead of the other's eyes: true, the spot this press fixed last (findBlock, markSpot); a markSpot key, the one stored under it. Needs no target for the wearer" }, "away": { "type": "boolean", "doc": "turn the back on the other instead, level: lookAt(\"target\", { away: true }) holds a victim facing away from the wearer (false)" } } }, "thematic:remove_effect": { "doc": "Takes a status effect off the wearer, or (who: target) off the target inside targets().", "fields": { "effect": { "type": "string", "doc": "the effect id; left out, the one an effect_added event brought" }, "who": { "type": "Who", "doc": "self (default) or target" } } }, "thematic:knockback": { "doc": "Vanilla knockback (a sword's): flat, weakened by knockback resistance. On the entity hit -- the target inside targets() -- unless who says otherwise.", "fields": { "strength": { "type": "Amount", "doc": "vanilla's knockback strength (0.5)" }, "direction": { "type": "KnockbackDirection", "doc": "which way (away_from_source)" }, "who": { "type": "KnockbackWho", "doc": "target (default) or self" } } }, "thematic:targets": { "doc": "Picks who a move lands on and runs its actions once aimed at each. Inside, damage, effect, sound and particles are about the target.", "fields": { "select": { "type": "TargetSelect", "required": true, "doc": "who to pick" }, "radius": { "type": "Amount", "doc": "around, ahead, allies, marked: how far; trail: how far either side of each node; left out, the tuned radius" }, "box": { "type": "[Amount, Amount, Amount] | { look: Amount; y?: Amount } | { across?: Amount; below?: Amount; above?: Amount }", "doc": "around: the distances either side of the wearer's hitbox per axis, instead of radius -- each may be worked out, e.g. [tuned(\"radius\"), tuned(\"radius\", 0.5), tuned(\"radius\")]; { look: n } grows each axis by the look's part times n, signed (so it can shrink), and with y the height by y either way instead; { across, below, above } grows the hitbox (or, with at, the spot or the source's hitbox) across sideways, below under its feet and above over its head -- across left out is the radius, below and above left out are across. On locked, remembered, attacker or victim: only if its hitbox touches that box" }, "ahead": { "type": "Amount", "doc": "moves the box (or the radius box) this many blocks the way along says" }, "along": { "type": "TargetAlong", "doc": "ahead: which way is in front (look)" }, "length": { "type": "Amount", "doc": "cone: how long; left out, the tuned radius" }, "width": { "type": "number", "doc": "cone: width at the far end; look: how far either side of the line (1)" }, "height": { "type": "number", "doc": "cone: height at the far end (1)" }, "start_width": { "type": "number", "doc": "cone: width at the near end (0)" }, "start_height": { "type": "number", "doc": "cone: height at the near end (0)" }, "from": { "type": "Anchor", "doc": "cone: where on the body it starts (eyes)" }, "range": { "type": "Amount", "doc": "look, aimed, locked_or_look: how far (locked_or_look: the locked target must be within it, else the look is searched); left out, the tuned radius" }, "max_angle": { "type": "number", "doc": "aimed (and locked_or_look with aim_assist), for a player: the widest angle from the crosshair that still counts, degrees (18)" }, "aim_assist": { "type": "boolean", "doc": "locked_or_look: with no lock, pick as aimed does -- the hitbox nearest the crosshair, seen -- not along a thin look line (false)" }, "assist": { "type": "number", "doc": "aimed, for a player: how far each hitbox is grown before measuring (0.35)" }, "prefer_players": { "type": "boolean", "doc": "aimed, for a player: a player aimed at outranks anything else (false)" }, "pick": { "type": "TargetPick", "doc": "all (default), nearest, first, or random (one of those found, by the wearer's random)" }, "sort": { "type": "TargetSort", "doc": "the order before the pick (none)" }, "sort_effect": { "type": "string", "doc": "with sort \"effect_level\": the status effect whose levels order them, most first (the infected before the clean, closest first among equals)" }, "at": { "type": "TargetsAt", "doc": "around: here (default: around the wearer), spot (around the point markSpot fixed) or source (the hitbox of the thrown thing or bolt whose hit runs this, grown by radius; the wearer's when there is none)" }, "within": { "type": "Amount", "doc": "only those at most this many blocks from the wearer, e.g. tuned(\"radius\", 2)" }, "round": { "type": "boolean", "doc": "around: only those whose feet are within the radius of the centre (the wearer, the spot, the source or the target): a sphere rather than the box (false)" }, "hollow": { "type": "Amount", "doc": "with round: leave out those whose feet are within this many blocks of the centre, so a band between hollow and radius is searched" }, "beyond": { "type": "Amount", "doc": "only those more than this many blocks from the wearer: with within, a ring" }, "entity": { "type": "string | string[]", "doc": "only those of this entity type, or one of this list; \"#ns:tag\" is an entity type tag, and a bare id is minecraft's (\"zombie\", \"#minecraft:undead\")" }, "hittable": { "type": "boolean", "doc": "false: searches find allies and the protected too; true: named selects only those the wearer may hit (true for searches, false for allies, remembered, attacker, victim)" }, "line_of_sight": { "type": "boolean", "doc": "only those the wearer can see (false; true for a player's aimed)" }, "except_allies": { "type": "boolean | Amount", "doc": "skip the wearer's teammates within the tuned radius (true) or this many blocks" }, "unless_active": { "type": "string[]", "doc": "skip anyone with one of these abilities active, e.g. the same move of their own" }, "arc": { "type": "Amount", "doc": "only those within this many degrees of the wearer's look, eyes to eyes: a swipe's half-angle, e.g. 60; worked out, it is read each time and held between 0 and 180 (a cone that widens with a count the press keeps)" }, "arc_widen": { "type": "{ to: number; over: number }", "doc": "with arc: it opens up with the distance, from arc at the wearer's eyes to `to` degrees `over` blocks out, and no wider beyond (the cosine moving evenly between the two): a beam that fans out, e.g. arc 8.11 widening to 31.79 over 30" }, "except": { "type": "TargetsExcept", "doc": "leave this one out: struck, the body the actions are aimed at (a bolt's struck body, the target of a targets() around this one), else the one the answered event struck; or players, every player" }, "spawn_groups": { "type": "SpawnGroup | SpawnGroup[]", "doc": "only those whose entity type is in one of these spawn groups: [\"monster\"] leaves the peaceful out" }, "once": { "type": "\"cast\" | { rehitAfter: number }", "doc": "each one is hit once in the press (cast), or not again until rehitAfter seconds have passed (rehit_after in a file)" }, "remember": { "type": "boolean | \"all\"", "doc": "keep the pick for a later select: \"remembered\" in the same press and the phases it opens; \"all\" keeps every one picked, and remembered lands on each still alive" }, "required": { "type": "boolean | { missCooldown?: number; message?: string }", "doc": "nobody found calls the whole press off: no later steps, no cooldown -- or, with missCooldown (miss_cooldown in a file), that share of it; the wearer is told on the action bar (message.thematic.no_target, or message: a lang key; \"\" for nothing)" }, "key": { "type": "string", "doc": "trail: the name markNode laid the trail under; marked: the mark's key, e.g. \"quarry_mark\"; tracked: the track's name, whose held entity it takes (thematic:track)" }, "by": { "type": "\"wearer\" | \"anyone\"", "doc": "marked: whose marks count -- the wearer's own (wearer, default) or anyone's" }, "below": { "type": "number", "doc": "trail: how far under each node the box reaches (the radius)" }, "above": { "type": "number", "doc": "trail: how far over each node the box reaches (the radius)" }, "do": { "type": "ActionObject[]", "doc": "the actions run on each target" }, "else": { "type": "ActionObject[]", "doc": "the actions run once when nobody was found" } } }, "thematic:once": { "doc": "Runs its actions only the first time it is reached in each pass of the targets() around it, or in the whole press: a slash sound for the first body a sweep meets, a shield for the first body of the run. With per: \"beat\", only on the ticks a beat of seconds falls on -- seconds worked out each time, so the beat can quicken with a count the press keeps; a phase's every with a worked-out seconds is read as one of these.", "fields": { "per": { "type": "OncePer", "required": true, "doc": "pass, run or beat" }, "seconds": { "type": "Amount", "doc": "beat: how often it runs; any worked-out number, rounded to whole ticks (at least one)" }, "clock": { "type": "BeatClock", "doc": "beat: what it counts on (age)" }, "start": { "type": "number", "doc": "beat: seconds on the clock of the first beat (0)" }, "do": { "type": "ActionObject[]", "doc": "what the first one does" } } }, "thematic:drive": { "doc": "Sets the wearer's velocity for this tick: a direction times a speed, with a vertical of its own. Put it in a phase's every() to hold a charge, pounce or leap every tick -- a velocity thrown once is gone to friction in two blocks. The speed is sideways along the direction; a negative speed drives backwards. A server set, told to the client: while it runs, where a player goes is the move's call, not their keys'. With path: \"circle\" it runs round a centre instead, angularSpeed radians a tick, on a radius that grows by radiusGrowth over the tuned duration, pulling those around it in with suction: Whirlwind's widening run.", "fields": { "path": { "type": "DrivePath", "doc": "line (default): along a direction; circle: round a centre" }, "along": { "type": "DriveAlong", "doc": "which way (yaw)" }, "speed": { "type": "Amount", "doc": "blocks a tick along it (1); pulse(...) for a gallop that surges with each bound" }, "vertical": { "type": "\"along\" | \"keep\" | \"gravity\" | Amount | { arc: { peak: number; across?: \"duration\" | number } } | { phases: Array<[number, number | null, number]> }", "doc": "along (default): the direction's own vertical times the speed; keep: as it is; gravity: vanilla's fall, worked out on the server, zero on the ground; a number; {arc: {peak, across}}: up peak blocks and back down across the tuned duration or seconds; {phases: [[from, to, vertical], ...]}: seconds into the phase (to null: the rest), the direction's own outside them. Arcs and phases count the step entering the phase and its first tick both as 0" }, "on_wall": { "type": "DriveOnWall", "doc": "while against a wall: skip or halt; left out, it drives on regardless" }, "reset_fall": { "type": "boolean", "doc": "forget the fall so far, so the drive never ends in fall damage (false)" }, "sprint": { "type": "boolean", "doc": "sets the wearer sprinting, or not; left out, left alone" }, "radius": { "type": "Amount", "doc": "circle: the radius it starts on, in blocks (1)" }, "radius_growth": { "type": "number", "doc": "circle: blocks the radius grows by over the tuned duration, counted from the phase's start (0)" }, "angular_speed": { "type": "number", "doc": "circle: radians it goes round a tick (2)" }, "height": { "type": "Amount", "doc": "circle: blocks above the centre the circle is flown at (0); an amount that grows with the phase flies a climbing spiral" }, "pull": { "type": "number", "doc": "circle: how hard it steers at the next point, times the gap (2.5)" }, "max_speed": { "type": "number", "doc": "circle: the fastest it steers, blocks a tick (1.5)" }, "around": { "type": "DriveAround", "doc": "circle: the centre (start)" }, "face": { "type": "boolean", "doc": "circle: turn the wearer the way they run (false)" }, "suction": { "type": "{ strength?: number; lift?: number; height?: number }", "doc": "circle: pull everyone the wearer may hit inside the current radius, and height (5) up and down, in to the centre at strength (1.25) and up at lift (1.15), both times how near they are (1 - distance / radius, never under 0.1)" } } }, "thematic:ride": { "doc": "Puts the wearer on the target's back (inside targets()), or with rider: \"target\" the target on the wearer's; off gets the rider down. Guard a phase on riding to end the move with the ride.", "fields": { "rider": { "type": "RideRider", "doc": "self (default) or target" }, "off": { "type": "boolean", "doc": "get the rider down instead (false)" }, "force": { "type": "boolean", "doc": "mount what would not take a rider of its own accord (true)" }, "free": { "type": "boolean", "doc": "only when neither already carries someone (true)" }, "max_distance": { "type": "Amount", "doc": "only when the target is no further than this, in blocks" } } }, "thematic:jump": { "doc": "A vanilla jump: what a flying kick does from a standing start, so the charge has height to fly at.", "fields": { "only_on_ground": { "type": "boolean", "doc": "only when standing on something (true)" } } }, "thematic:rise": { "doc": "Climbs the wearer straight up to height blocks over where the climb began, at speed a tick, easing into the top and holding there. Sideways speed is dropped while it climbs. Every tick, in a phase's every().", "fields": { "height": { "type": "Amount", "doc": "blocks above the start (5)" }, "speed": { "type": "number", "doc": "blocks a tick while more than ease is left (0.6)" }, "ease": { "type": "number", "doc": "within this many blocks of the top, it closes exactly the gap (1)" }, "from": { "type": "RiseFrom", "doc": "start (default) or spot" }, "sprint": { "type": "boolean", "doc": "sets the wearer sprinting, or not; left out, left alone" } } }, "thematic:orbit": { "doc": "Hands the wearer's own client a spiral to fly round a centre: it steers itself along the path (movement input is ignored, so pair it with lockInput), the sprint flag held, turned to run along the circle. The server sends one packet and no velocity, so there is no lag or teleporting. Put it in a phase's body (it runs as the phase starts); radius and height ease from their first value to their \"To\" over the seconds. A player only.", "fields": { "around": { "type": "DriveAround", "doc": "spot (default) or start" }, "radius": { "type": "Amount", "doc": "blocks from the centre at the start (1)" }, "radius_to": { "type": "Amount", "doc": "blocks at the end (the same)" }, "height": { "type": "Amount", "doc": "blocks above the centre at the start (0)" }, "height_to": { "type": "Amount", "doc": "blocks at the end (the same)" }, "angular_speed": { "type": "Amount", "doc": "radians a tick round the centre; negative the other way (0.2)" }, "seconds": { "type": "Amount", "doc": "how long it flies (1)" }, "sprint": { "type": "boolean", "doc": "holds sprinting (true)" }, "face": { "type": "boolean", "doc": "turns the wearer to run along the circle (true)" }, "stop": { "type": "boolean", "doc": "cancels a flight under way instead; the other fields are ignored (false)" } } }, "thematic:gravity": { "doc": "Turns gravity off, or back on. It stays as set: turn it back on in the phase's end(), which runs however the phase is left, death and logging out included.", "fields": { "who": { "type": "GravityWho", "doc": "self (default), target or both" }, "off": { "type": "boolean", "doc": "true (default) turns it off, false back on" } } }, "thematic:swing_hand": { "doc": "Swings a hand where everyone can see it, the wearer included: a slash that reads as one.", "fields": { "hand": { "type": "SwingHandWhich", "doc": "main (default), off, or alternate" }, "chance": { "type": "number", "doc": "0 to 1: how likely it swings at all (1)" } } }, "thematic:turn": { "doc": "Turns the wearer by so much a tick, and eases their pitch toward a target or level: a spin that tracks.", "fields": { "yaw": { "type": "Amount", "doc": "degrees added to the yaw (0); ramp(...) for a spin that speeds up" }, "pitch_toward": { "type": "PitchToward", "doc": "ease the pitch toward the nearest target, or level; left out, the pitch is left alone" }, "pitch": { "type": "Amount", "doc": "sets the pitch to this many degrees, down positive (45 looks at the ground ahead, -90 straight up); not with pitch_toward" }, "within": { "type": "number", "doc": "with nearest: how far either side it looks (20)" }, "ease": { "type": "number", "doc": "how much of the way the pitch moves each time, 0 to 1 (1)" } } }, "thematic:carry": { "doc": "Holds the target in front of the wearer, tick by tick: in a phase's every(), inside targets() -- usually select \"remembered\". Lets go by itself (and forgets the pick) once they are dead, gone, further than release, or won't fit (fit). Aerial Charge's is the defaults with along: \"heading\"; Feral Leap's {from: \"feet\", distance: 0.9, at: \"feet\", along: \"yaw\", move: \"fit\", blocked: \"slam\", fall: \"book\", hold: {for: 0.75, every: 0.25, owedFall: 10}, victimAnimation: {name: \"feral_leap_victim\", every: 1.5}}; Stronger, Smarter, Better's {from: \"feet\", distance: 1.5, at: \"feet\", along: \"yaw\", move: \"teleport\", fall: \"keep\"}.", "fields": { "from": { "type": "Anchor", "doc": "the point on the wearer it is held out from (eyes)" }, "distance": { "type": "number", "doc": "how far out from it (2)" }, "at": { "type": "CarryAt", "doc": "which part of the target is put there: middle (default) or feet" }, "along": { "type": "CarryAlong", "doc": "look (default), heading or yaw" }, "move": { "type": "CarryMove", "doc": "swept (default), fit or teleport" }, "max_step": { "type": "number", "doc": "swept: the furthest they are moved in one tick, in blocks (3)" }, "blocked": { "type": "CarryBlocked", "doc": "fit: what happens when they won't fit there: release (default) or slam" }, "slam": { "type": "number", "doc": "blocked slam: how fast both are sent down, blocks a tick (1.2)" }, "release": { "type": "number", "doc": "let go -- and forget the pick and the heading -- once the target is further than this; 0: never (4)" }, "fall": { "type": "CarryFall", "doc": "reset (default), book or keep" }, "hold": { "type": "true | { for?: number; every?: number; owedFall?: number }", "doc": "take them out of their own hands: no walking, attacking or abilities, for `for` seconds (0.75) renewed every `every` (0.25), and a landing owed for owedFall seconds (0) that a suit's fall immunity can't cancel. Lifted by letGo(), and when the press ends however it ends" }, "victim_animation": { "type": "string | { name: string; every?: number }", "doc": "the clip a carried player is put in, and again every `every` seconds (left out: once); stopped when they are let go" }, "in_hand": { "type": "{ bone: string; point?: [number, number, number]; hang?: number; yaw?: number }", "doc": "with hold: draw the held body hanging from a point on one of the wearer's suit bones (armorHead, armorBody, armorRightArm, armorLeftArm, armorRightLeg, armorLeftLeg) instead of where it stands, so it follows that limb's clip. point: [x, y, z] on the bone in model blocks, its rest pose (the right hand is about [0.375, 0.74, -0.15]); hang: the share of the held body's height that hangs there (0.85, the throat); yaw: degrees it is turned from facing the wearer (0); first_person: { ahead, side, drop } where the wearer sees it from their own eyes, in blocks (1, 0.45, 0.35: ahead of the eyes, out to the gripping side, below them). Its hitbox stays where the carry puts it" } } }, "thematic:let_go": { "doc": "Hands the carried target back: the one inside targets(), else the remembered one. Forgets them, lifts the hold a carry put on them (this press's, or one run from a passive's tick) and stops its victim clip; with slam, puts them under the wearer's feet (stopping at the floor, only if they fit) and sends both down. The owed landing keeps running.", "fields": { "slam": { "type": "number", "doc": "slam them: the speed both are sent down at, blocks a tick (Feral Leap's 1.2); left out, no slam" }, "forget": { "type": "boolean", "doc": "forget the remembered pick, so a targets() of remembered finds no one (true)" } } }, "thematic:mark_heading": { "doc": "Fixes where the wearer aims now as the move's heading, for later pushes, drives and carries along \"heading\": their look, or for a mob straight at its target.", "fields": { "yaw_only": { "type": "boolean", "doc": "laid level: straight along the yaw, so the heading neither climbs nor dives (false)" }, "max_turn": { "type": "number", "doc": "degrees: with a heading already marked this press, the new one only turns it that far toward the aim, about the vertical axis (limited steering for a drive along the heading); with none yet, set outright" }, "from": { "type": "HeadingFrom", "doc": "where the heading comes from: aim (their look, a mob's at its target; the default), moving (level, the way they have been moving these last few ticks -- the key they hold; their look laid level when still) or away_from_target (level, from the target -- the one inside targets(), else the one aimed at -- out to the wearer; back along their look with none)" } } }, "thematic:mark_target": { "doc": "Inside targets(): stores the target on the wearer, synced, under key, so a phase's movement { charge: { toward: \"marked\" } } steers the wearer's own client straight at it -- a dash at one victim, without the server pinning their momentum. It is also remembered for the press, so a later targets(\"remembered\") finds the same one; the mark is cleared when the press's phases are over.", "fields": { "key": { "type": "string", "doc": "the data key (charge_target); the charge's key must match" }, "clear": { "type": "boolean", "doc": "forget the mark now instead (false)" }, "remember": { "type": "boolean", "doc": "also remember the target for the press (true)" }, "uuid": { "type": "string", "doc": "a second key the target's uuid is kept under too, e.g. for a portrait pin that finds the subject again after its network id goes stale (none)" }, "keep": { "type": "boolean", "doc": "keep the mark when the press's phases are over, until it is replaced or cleared (false)" } } }, "thematic:spin": { "doc": "Turns a body round on the spot: every tick for ticks ticks its look moves degrees further round, at eye height -- a victim spun dizzy by a dash. A body already spinning is left to finish; one that dies stops.", "fields": { "who": { "type": "SpinWho", "doc": "target (default) or self" }, "degrees": { "type": "number", "doc": "how far it turns each tick; negative the other way (20)" }, "ticks": { "type": "number", "doc": "how long it spins, in ticks (30)" } } }, "thematic:damage": { "doc": "Hurts the entity hit -- inside targets(), the target -- or, with who: \"self\", the wearer.", "fields": { "damage": { "type": "Amount", "doc": "left out, the tuned damage; tuned(\"damage\", 0.5) for half of it" }, "damage_type": { "type": "string", "doc": "a damage type id, e.g. \"thematic:psychic\"; the wearer is behind it" }, "element": { "type": "Element", "doc": "what the hit is made of, e.g. \"bleed\" or \"radiation\": the same damage type by the word the suits use, which is what lets a weakness, a resistance or an immunity answer it; not with damageType or source" }, "source": { "type": "DamageSourceKind", "doc": "auto (default), player_attack or mob_attack; not with damageType" }, "through_absorption": { "type": "boolean", "doc": "spends health and leaves the absorption pool alone (false)" }, "store": { "type": "string", "doc": "keeps the health the hit actually took (after armour, resistance, a body nearly dead) under this name for the rest of the press, as store() does: $name in an expr reads it" }, "who": { "type": "Who", "doc": "target (default: the entity hit) or self: the wearer pays in health, as magic credited to the wearer unless source, element or damageType says otherwise" }, "ignore_iframes": { "type": "boolean", "doc": "lands through the body's hurt window: it is cleared for this hit and put back after, with the last damage taken, so hits a few ticks apart all land and later blows are not priced against this one (false)" } } }, "thematic:effect": { "doc": "A status effect on the entity hit -- inside targets(), the target.", "fields": { "effect": { "type": "string", "required": true, "doc": "the status effect id, e.g. \"minecraft:slowness\"" }, "duration": { "type": "Amount", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "Amount", "doc": "left out, the ability's tuned amplifier" }, "ambient": { "type": "boolean", "doc": "the faint beacon-style swirl (false)" }, "show_particles": { "type": "boolean", "doc": "false hides the effect's particles (true)" }, "show_icon": { "type": "boolean", "doc": "false hides the HUD icon (true)" }, "chance": { "type": "number", "doc": "the share of the time it lands, 0 to 1 (1)" }, "tint": { "type": "number | string | [number, number, number]", "doc": "the colour an effect worn in one takes (thematic:doused): 0x8CE01A, \"#8CE01A\", [r, g, b] or \"$name\" for one the press chose" }, "resolve_against": { "type": "ResolveAgainst", "doc": "whose tuned duration and amplifier fill in the left-out ones (wearer)" }, "suppress": { "type": "boolean", "doc": "leaves a body that already has the effect alone (false)" }, "mark_grounded": { "type": "boolean", "doc": "marks the body freshly grounded once it lands, so the same hit's damage is not the first after it (false)" }, "stack": { "type": "{ add?: number; max: Amount }", "doc": "builds up: on a body that has it, the amplifier is the running one plus add (1), never past max; amplifier is then the first landing's" } } }, "thematic:heal": { "doc": "Heals the wearer, or the entity hit: by an amount, up to a level, or both (by the amount, no further than the level).", "fields": { "amount": { "type": "Amount", "doc": "how much, in the action bar's units (1000 is a full vanilla bar, 50 is one hit point), or fromEvent(\"amount\") for what the answered hit was worth; left out, the tuned \"heal\" key, else 50 (1, or up to the level with to)" }, "to": { "type": "Amount", "doc": "heal up to this level (action bar units) and never past it; a body already above it is left alone" }, "target": { "type": "HealTarget", "doc": "self (default) or hit" } } }, "thematic:overshield": { "doc": "An absorption pool on the wearer, or the entity hit, that hits spend before health: raised to the amount (a second grant tops it up, never stacks), or added to it with stack.", "fields": { "amount": { "type": "Amount", "doc": "how much, in the action bar's units (1000 is a full vanilla bar); left out, the tuned \"overshield\" key, else 50" }, "target": { "type": "HealTarget", "doc": "self (default) or hit" }, "stack": { "type": "boolean", "doc": "adds the amount to the pool already there instead of topping it up to it (false)" }, "for": { "type": "Amount", "doc": "seconds the points it added last: then what is left of them goes (hits spend them first); left out, they stay until spent" } } }, "thematic:clear_effects": { "doc": "Takes status effects off the wearer, or the target: every one, the harmful or the beneficial ones, or none (only the absorption pool, with absorption: true).", "fields": { "who": { "type": "Who", "doc": "self (default) or target" }, "category": { "type": "EffectCategory", "doc": "which ones (all)" }, "absorption": { "type": "boolean", "doc": "also empties the absorption pool, after the effects (false)" } } }, "thematic:cooldowns": { "doc": "Changes cooldowns across a kit, the wearer's or the target's: takes seconds off, sets them, or starts each one's whole cooldown.", "fields": { "who": { "type": "Who", "doc": "self (default) or target" }, "ability": { "type": "string", "doc": "only this ability id, \"self\" (this ability) or \"ultimate_key\" (whatever sits on the ultimate key); left out, all" }, "except": { "type": "string", "doc": "all but this one: an ability id, \"self\" (this ability) or \"ultimate_key\" -- a refund that must never hand itself back" }, "cooling": { "type": "boolean", "doc": "only abilities still cooling down (false)" }, "ready": { "type": "boolean", "doc": "only abilities not cooling down: a move that can still be wasted (false)" }, "except_ultimate": { "type": "boolean", "doc": "leaves ultimates out (false)" }, "skip_active": { "type": "boolean", "doc": "leaves running abilities out (false); a cooldown change ends a running one" }, "keyed": { "type": "boolean", "doc": "only moves on a key (ability_0-5, utility, equip_item, ultimate): passives left out (false)" }, "pick": { "type": "CooldownPick", "doc": "all (default), the first in kit order, or one at random" }, "reduce": { "type": "Amount", "doc": "seconds taken off, floored at 0" }, "set": { "type": "Amount", "doc": "seconds it is set to" }, "add": { "type": "Amount", "doc": "seconds put on top of what is left (a move not cooling starts cooling for that long)" }, "times": { "type": "Amount", "doc": "the share of what is left that stays, e.g. 0.35 takes 65% off a cooldown that has just started (a number, not seconds)" }, "full": { "type": "boolean", "doc": "each one's own whole tuned cooldown is started, as if it had just been used: with pick: \"random\" and ready, a move wasted (Hypnosis). One of reduce, set, add, times or full" }, "inventories": { "type": "string[]", "doc": "the items' cooldowns instead of the kit's: every stack in these of a player's inventories (gadgets, quiver, main) has its item's cooldown set to set seconds" }, "tag": { "type": "string", "doc": "with inventories: only items in this item tag" } } }, "thematic:scale": { "doc": "A temporary scale on the wearer: slower while charging, a longer reach. Stays until unscale(), unless for or while hold it: then it comes off by itself, death and logout included. With who: \"target\", on the target inside targets(): a player keeps it as the wearer would; a mob's is set outright and stays (a summon's size) unless for puts it back.", "fields": { "scale": { "type": "ScaleType", "required": true, "doc": "which scale" }, "value": { "type": "Amount", "doc": "the scale (1)" }, "key": { "type": "string", "doc": "what it is kept under on the wearer (_); unscale() names the same" }, "for": { "type": "Amount", "doc": "seconds it lasts" }, "while": { "type": "ScaleWhile", "doc": "active: while the ability runs; state: while the wearer stays in this phase; not with who: \"target\"" }, "snap": { "type": "boolean", "doc": "jump straight to it (true); false eases in over Pehkui's tick delay" }, "who": { "type": "Who", "doc": "self (default) or target" }, "exclusive": { "type": "boolean", "doc": "first take off every other scale of this kind the body wears, so two size moves never stack (false)" }, "relative": { "type": "boolean", "doc": "value is added to the body's scale of this kind as it stands now: 0.3 is three tenths bigger than it is (false)" } } }, "thematic:unscale": { "doc": "Takes a scale() off the wearer, or the target: a mob's goes back to the default.", "fields": { "scale": { "type": "ScaleType", "required": true, "doc": "which scale" }, "key": { "type": "string", "doc": "the key scale() used (_)" }, "who": { "type": "Who", "doc": "self (default) or target" } } }, "thematic:attack": { "doc": "A real attack on the target inside targets(), as the wearer's own swing would land it: the held item's damage, enchantments, knockback, crits, sweeping and durability, weakened by the attack cooldown as any swing is (a blow every tick is a weak one). A mob wearer attacks as a mob does. Turn to the target first with lookAt(), and swingHand() for the swing to show.", "fields": { "weapon": { "type": "HeldItemKind", "doc": "only when the main hand holds this kind, e.g. \"weapon\"; left out, whatever is held" }, "sweep": { "type": "boolean", "doc": "draw a sword's sweep after the blow (false)" } } }, "thematic:slow_time": { "doc": "Catches the target in slowed time (the reflex slow), held at the speed it was caught at. Inside targets(); run it every tick of a phase and it is topped up, never shortened.", "fields": { "for": { "type": "Amount", "doc": "seconds it lasts; left out, what is left of the running phase, so it lapses when the phase does" } } }, "thematic:release_time": { "doc": "Lets the target out of slowed time. Inside targets().", "fields": {} }, "thematic:hold_projectiles": { "doc": "Freezes the projectiles around the wearer in the air.", "fields": { "radius": { "type": "Amount", "doc": "left out, the tuned radius" }, "for": { "type": "Amount", "doc": "seconds it lasts; left out, what is left of the running phase, so it lapses when the phase does" } } }, "thematic:lock_moves": { "doc": "Locks a kit's moves -- the target's inside targets(), the wearer's otherwise. Never the move doing the locking. Which moves a mode takes by default follows the Java it replaced: dampen takes ultimates but spares stun-immune moves; interrupt and disable_effect spare ultimates but take stun-immune moves; cooldown_floor takes both and skips passives.", "fields": { "mode": { "type": "LockMode", "doc": "how the kit is held (dampen)" }, "who": { "type": "Who", "doc": "who it lands on; left out, the target inside targets() and the wearer otherwise" }, "for": { "type": "Amount", "doc": "seconds it lasts; left out, what is left of the running phase, so it lapses when the phase does" }, "except": { "type": "string[]", "doc": "ability ids left alone" }, "only": { "type": "string[]", "doc": "lock only these ability ids" }, "include_ultimates": { "type": "boolean", "doc": "also take ultimates (true for dampen and cooldown_floor, false otherwise)" }, "stun_immune_too": { "type": "boolean", "doc": "also take moves immune to stuns (false for dampen, true otherwise)" }, "skip_passives": { "type": "boolean", "doc": "leave passives alone (true for cooldown_floor, false otherwise)" }, "stop": { "type": "boolean", "doc": "switch off locked moves already running (true). dampen with false only holds the kit: presses are refused, a running move finishes; disable_effect with false only puts the effect on. Not for cooldown_floor" }, "cooldown": { "type": "Amount | \"full\"", "doc": "seconds a stopped move is left on, or \"full\" for its own full cooldown; left out, none for dampen and the lock's length otherwise. Not for cooldown_floor" }, "amplifier": { "type": "Amount", "doc": "disable_effect only: the Disable effect's amplifier, holding that many idle moves plus one (15: any kit)" }, "message": { "type": "string", "doc": "dampen only: translation key a refused press shows while the lock lasts" }, "color": { "type": "Formatting", "doc": "the message's colour" } } }, "thematic:unlock_moves": { "doc": "Lifts a dampen lock early (stamps, holds and its message) -- the target's inside targets(), the wearer's otherwise.", "fields": { "who": { "type": "Who", "doc": "who it lands on; left out, the target inside targets() and the wearer otherwise" }, "only": { "type": "string[]", "doc": "unlock only these ability ids" } } }, "thematic:slow_motion": { "doc": "The wearer keeps moving while everything around them crawls (Enhanced Reflexes). start: the wearer sheds anyone else's slow and takes their own motion scale; tick: sparks, then everyone hittable in the radius not running one of victims.unlessActive is caught -- the reflex slow for the time left, their kit locked, the speed they are held at worked out once -- and held, and projectiles freeze; end: the wearer's scales come off and everyone in the radius is let go. A script writes it with phase.slowMotion().", "fields": { "phase": { "type": "SlowMotionPhase", "doc": "which part this is (tick); phase.slowMotion() writes all three" }, "radius": { "type": "Amount", "doc": "how far it reaches, a box that far out each way (the tuned radius)" }, "for": { "type": "Amount", "doc": "seconds the slow, the lock and the held projectiles last; left out, what is left of the running phase, so they lapse on the tick it does" }, "self": { "type": "SlowMotionSelf | boolean", "doc": "the wearer's own time: false leaves it alone ({ motion: 0.8 })" }, "victims": { "type": "SlowMotionVictims", "doc": "what happens to those caught" }, "hold_projectiles": { "type": "boolean", "doc": "holds the projectiles in the radius in the air (true)" }, "sparks": { "type": "(ParticlesOptions & { particle?: ParticleSpec }) | boolean", "doc": "particles around the wearer each tick, over three bursts of five electric sparks scattered across the radius and up to two blocks up; false for none" }, "release_on_end": { "type": "boolean", "doc": "lets everyone in the radius go as it ends -- slow, held figure and kit lock (true)" } } }, "thematic:spray": { "doc": "Particle projectiles thrown from a point on the wearer along their look -- a mob's, straight at its target; an arm anchor's, along the arm -- each carrying ability effects to what it hits: a breath, a spray. Flat, it is one projectile; with cones, one per cone, in order, e.g. a breath's { spread: 0.8, lifetimeTicks: 90 }, { spread: 5, lifetimeTicks: 20 }, { spread: 10, lifetimeTicks: 20 }.", "fields": { "from": { "type": "Anchor", "doc": "where on the body it is thrown from (eyes: exactly where the breaths always came from)" }, "cones": { "type": "SprayCone[]", "doc": "one projectile per cone, each firing; left out, the spray is one cone" }, "particle": { "type": "ParticleSpec", "doc": "the particle it is drawn with (minecraft:spit)" }, "spread": { "type": "Amount", "doc": "how far it strays from the look, as vanilla's divergence; it also tips the throw up by as many degrees, as the breaths always did (1)" }, "lifetime": { "type": "number", "doc": "seconds before it goes, to the nearest tick (3)" }, "lifetime_ticks": { "type": "number", "doc": "ticks before it goes, exactly; instead of lifetime" }, "speed": { "type": "Amount", "doc": "how fast it flies, blocks a tick (2); the wearer's own velocity is added" }, "damage": { "type": "Amount", "doc": "what the effects it carries are handed as the hit's damage (0)" }, "effects": { "type": "(string | AbilityEffectEntry)[]", "doc": "ability effects it carries: ids, e.g. [\"thematic:laser\", \"thematic:ignite\"], or an effect that takes options with them, e.g. { id: \"thematic:blindness\", duration: 3.5, amplifier: tuned(\"amplifier\") }" }, "option_effects": { "type": "string", "doc": "a suit option whose comma list of effect ids is added after these, e.g. \"laser_effects\"" }, "dedupe": { "type": "boolean", "doc": "an effect already in the list is not added again, e.g. when the suit option names it too (false: it fires twice)" } } }, "thematic:set_flag": { "doc": "Stores true or false on the wearer, synced, under a key an animation or a client visual reads.", "fields": { "key": { "type": "string", "required": true, "doc": "the key" }, "value": { "type": "boolean", "doc": "(true)" }, "for": { "type": "number", "doc": "seconds after which it flips back, whatever happens in between -- the wearer dying, a later step called off; left out, it stays" } } }, "thematic:beam": { "doc": "A hitscan ray that hurts and carries ability effects: from the eyes along the look unless told otherwise (a mob's, straight at its target). Reflect abilities bounce it back, and a wall stops it.", "fields": { "effects": { "type": "(string | AbilityEffectEntry)[]", "doc": "ability effects it carries: ids, e.g. [\"thematic:laser\", \"thematic:ignite\"], or an effect that takes options with them, e.g. { id: \"thematic:blindness\", duration: 3.5, amplifier: tuned(\"amplifier\") }" }, "option_effects": { "type": "string", "doc": "a suit option whose comma list of effect ids is added after these, e.g. \"laser_effects\"" }, "dedupe": { "type": "boolean", "doc": "an effect already in the list is not added again, e.g. when the suit option names it too (false: it fires twice)" }, "from": { "type": "Anchor | Anchor[]", "doc": "where it leaves (\"eyes\", exactly the eye position). A list fires one beam from each; inside targets() it fires one per target, taking the anchors in turn: [\"right_hand\", \"left_hand\"]. A swept arm ({ point: \"arm\", side, sweep }) turns from the heading markHeading() fixed, or the wearer's yaw, by the phase's ticks" }, "direction": { "type": "BeamDirection", "doc": "which way it goes (look)" }, "aim": { "type": "BeamAim", "doc": "a mob's look beam: at its target (default) or along its own look" }, "range": { "type": "Amount", "doc": "how far, in blocks (128)" }, "reach": { "type": "BeamReach", "doc": "range (default), or target: to the target plus overshoot, however far; needs direction \"target\"" }, "overshoot": { "type": "number", "doc": "with reach \"target\": how far past the target's centre it runs (0.5)" }, "margin": { "type": "number", "doc": "how far either side of the line still counts as a hit, in blocks (0.3, an arrow's)" }, "damage": { "type": "Amount", "doc": "what a hit deals; left out, the tuned damage" }, "splash": { "type": "Amount | BeamSplash", "doc": "the blast round the first hit: a radius, or its options" }, "chain": { "type": "boolean | BeamChain", "doc": "jumps on from the first hit: true for the suit's beam assets, or its options" }, "on_hit": { "type": "ActionObject[]", "doc": "run aimed at the living thing it hit, after any splash and chain: push(\"target\", ...) knocks it" }, "on_block": { "type": "ActionObject[]", "doc": "run when it hit no one -- at the block it stopped on, or the end of its range: push(\"self\", ...) for a recoil off the wall" }, "unstoppable": { "type": "boolean", "doc": "true: its hit goes through guards -- no parry, counter, soak or reflect hears of it (pair with an effect whose damage bypasses shields, e.g. thematic:solar_lance). on_hit runs after, as usual (false)" } } }, "thematic:store": { "doc": "Keeps a number under a name for as long as this press's phases last, for {stored: name}, $name in an expr, or a field written \"$name\" to read back. A fresh press starts with none.", "fields": { "key": { "type": "string", "required": true, "doc": "the name it is kept under" }, "value": { "type": "Amount", "doc": "the number (1), e.g. fromEvent(\"amount\") for the damage of the hit being answered" }, "mode": { "type": "StoreMode", "doc": "set (the default: the last one wins), add, max or min" } } }, "thematic:cancel_event": { "doc": "Calls off the event being answered. attack: the swing's own damage never lands (what the answer itself deals still does) -- an armed punch consumed by the move it arms. damaged: the hit on the wearer is cancelled. use_block, use_entity, use_item: the use never happens. xp_gained: the experience is not added. projectile_incoming: the projectile passes through the wearer. projectile_launched: the projectile never appears. The first answer to cancel decides; the rest are not asked. Every other event has already happened, and this does nothing there. Pair it on attack with the phase trait hidesSwing, so the client doesn't draw a punch over the move.", "fields": {} }, "thematic:start_cooldown": { "doc": "Starts this ability's cooldown now: the tuned cooldown times fraction. For a passive -- which has no then() -- and for an answer whose cooldown is owed part-way through its steps, as a vent that is only paid for once it goes off. Inside a phase of a pressed ability the cooldown slot counts the phase's time; leave with then(\"cooldown\") there.", "fields": { "fraction": { "type": "number", "doc": "of the tuned cooldown (1)" } } }, "thematic:set_bones": { "doc": "Puts this ability's suit bones (its bones trait) in their on or off pose. Time it to the frame of an animation so the swap lands mid-gesture; until an ability first calls it, its bones follow whether it is on.", "fields": { "on": { "type": "boolean", "doc": "true (default): the on pose -- show drawn, hide hidden; false: the off pose" } } }, "thematic:say": { "doc": "A chat line from the wearer to the players within earshot, through vanilla's chat.type.text so a server's chat formatting applies to it as to anything else the wearer says.", "fields": { "lines": { "type": "string | string[] | { prefix: string; count: number; first?: number }", "required": true, "doc": "translation keys: one, a list, or { prefix, count } for prefix1 .. prefixN (first: where the numbers start, 1)" }, "pick": { "type": "SayPick", "doc": "random (default) or cycle" }, "sender": { "type": "string", "doc": "the name it is signed with, as written; left out, the wearer's name" }, "color": { "type": "string", "doc": "a chat colour for the whole line, e.g. \"blue\"" }, "radius": { "type": "number", "doc": "how far it carries, in blocks (32)" }, "radius_option": { "type": "string", "doc": "a suit option that overrides the radius when set above 0, e.g. \"chat_radius\"" }, "format": { "type": "string", "doc": "the translation key the sender and line are put into (chat.type.text)" } } }, "thematic:equip": { "doc": "Puts an item in one of the wearer's slots, tied to the ability: tagged, so it is stripped once the ability is not running and discarded if dropped. Already there, nothing happens; copies moved elsewhere are taken first, so it is safe every tick. In a phase, phase.equip() also takes it back when the phase ends.", "fields": { "item": { "type": "string", "required": true, "doc": "the item id, e.g. \"thematic:cyclops_visor\"; an item not registered (its pack missing) hands out nothing" }, "slot": { "type": "EquipSlot", "doc": "mainhand (default), offhand, head, chest, legs or feet" }, "count": { "type": "number", "doc": "(1)" }, "enchant": { "type": "Record", "doc": "enchantments and levels, e.g. { \"minecraft:binding_curse\": 9 }" }, "tag": { "type": "string", "doc": "what ties the item to a move; left out, this ability's id" }, "displaced": { "type": "Displaced", "doc": "what happens to what held the slot: stash (default) or drop" }, "named": { "type": "boolean", "doc": "named for the wearer, \"'s \", in grey (false)" } } }, "thematic:unequip": { "doc": "Takes back the items an equip() handed out: every stack with the tag, from hands, armour and inventory.", "fields": { "item": { "type": "string", "doc": "only stacks of this item" }, "tag": { "type": "string", "doc": "left out, this ability's id" } } }, "thematic:particles": { "doc": "A burst of particles where it happens -- inside targets(), where the target stands -- or from a point on the wearer's body.", "fields": { "particle": { "type": "ParticleSpec", "required": true, "doc": "a particle id, dust(color, scale), or \"block_below\": debris of the block underneath" }, "count": { "type": "number", "doc": "how many (12); in a sphere, how many points" }, "spread": { "type": "Amount | [Amount, Amount, Amount]", "doc": "how far they scatter, one number or per axis (0.5; 0 in a sphere); any worked-out number, e.g. tuned(\"radius\", 0.5)" }, "speed": { "type": "number", "doc": "how fast they move (0.05; 0 in a sphere and for relative; 0.15 inward)" }, "y_offset": { "type": "number", "doc": "raise or lower the burst (0)" }, "anchor": { "type": "ParticleAnchor | number", "doc": "feet (default), body (half the subject's height), or a fraction of its height" }, "at": { "type": "At", "doc": "here (default) or spot: the point markSpot fixed" }, "from": { "type": "Anchor", "doc": "a point on the wearer's body to start from, rather than where it happens (see Anchor)" }, "forward": { "type": "number", "doc": "blocks along the wearer's look, from wherever it starts (0)" }, "color": { "type": "Color", "doc": "recolours dust: on its own, dust of this colour; with dust(...), its colour. [r, g, b], \"#RRGGBB\" or \"$name\"" }, "system": { "type": "ParticleEmit", "doc": "how they leave (burst)" }, "aim": { "type": "ParticleAim", "doc": "with a system other than burst: which way (look)" }, "shape": { "type": "ParticleShape", "doc": "point (default); sphere: count points in a sphere of radius; line: count points from the wearer's eyes to the target's, one particle each (inside targets(); spread and speed 0 unless given); inward: count particles, each born 60 to 100% of radius out and flying in toward the point at speed (a drawn-in glow)" }, "radius": { "type": "Amount", "doc": "the sphere's (or the inward shell's) radius; left out, the tuned radius" }, "scatter": { "type": "{ across: Amount; up?: number }", "doc": "several bursts, each at its own random point: across either way, up to up above the feet" }, "bursts": { "type": "number", "doc": "with scatter: how many bursts of count (1)" } } }, "thematic:particle_circle": { "doc": "One of the particle circle systems, centred where it happens, on the spot markSpot fixed, or on a point of the wearer's body.", "fields": { "system": { "type": "CircleSystem", "doc": "which system (circle)" }, "particle": { "type": "ParticleSpec", "doc": "the particle (campfire smoke)" }, "height": { "type": "Amount", "doc": "(1)" }, "radius": { "type": "Amount", "doc": "left out, the tuned radius" }, "count": { "type": "number", "doc": "(32)" }, "y_offset": { "type": "number", "doc": "raise or lower it (0)" }, "block_center": { "type": "boolean", "doc": "snap to the block's centre (false)" }, "at": { "type": "At", "doc": "here (default) or spot: the point markSpot fixed" }, "from": { "type": "Anchor", "doc": "a point on the wearer's body to start from, rather than where it happens (see Anchor)" }, "forward": { "type": "number", "doc": "blocks along the wearer's look, from wherever it starts (0)" }, "color": { "type": "Color", "doc": "recolours dust: on its own, dust of this colour; with dust(...), its colour. [r, g, b], \"#RRGGBB\" or \"$name\"" } } }, "thematic:particle_dome": { "doc": "A hemisphere of particles, or part of one, centred where it happens, on the spot markSpot fixed, or on a point of the wearer's body.", "fields": { "shape": { "type": "DomeShape", "doc": "which part (full_dome)" }, "particle": { "type": "ParticleSpec", "doc": "the particle (smoke)" }, "radius": { "type": "Amount", "doc": "left out, the tuned radius" }, "height": { "type": "Amount", "doc": "(0)" }, "count": { "type": "number", "doc": "(60)" }, "y_offset": { "type": "number", "doc": "raise or lower it (0)" }, "at": { "type": "At", "doc": "here (default) or spot: the point markSpot fixed" }, "anchor": { "type": "ParticleAnchor | number", "doc": "feet (default), body (half the subject's height), or a fraction of its height" }, "from": { "type": "Anchor", "doc": "a point on the wearer's body to start from, rather than where it happens (see Anchor)" }, "forward": { "type": "number", "doc": "blocks along the wearer's look, from wherever it starts (0)" }, "color": { "type": "Color", "doc": "recolours dust: on its own, dust of this colour; with dust(...), its colour. [r, g, b], \"#RRGGBB\" or \"$name\"" } } }, "thematic:sound": { "doc": "Plays a sound. For one sound, a suit's options sound, volume, pitch and soundOffset still win (unless world).", "fields": { "sound": { "type": "string | SoundCycle", "required": true, "doc": "a sound id (\"minecraft:...\" or a Thematic sound name), or { cycle, key } for the next of a set" }, "volume": { "type": "number | [number, number]", "doc": "(1); [low, high] is drawn at random each time it plays" }, "pitch": { "type": "number | [number, number]", "doc": "(1); [low, high] is drawn at random each time it plays, e.g. [0.9, 1.1] for a pack's howls" }, "delay": { "type": "number", "doc": "seconds before it plays (0); a suit's soundOffset replaces it" }, "at": { "type": "SoundAt", "doc": "where it plays (here)" }, "world": { "type": "boolean", "doc": "a plain sound in the world: no suit re-voices it (false)" }, "once": { "type": "SoundOnce", "doc": "at most once per pass through a list, or per press" }, "loop": { "type": "SoundLoop", "doc": "replayed while a phase lasts, when run from its every()" }, "stop_on_exit": { "type": "boolean", "doc": "cut it off on every client when the move's phases end (false)" }, "follow": { "type": "boolean", "doc": "played at a body (the wearer, a target), it moves with that body rather than staying where it started (true)" }, "voice": { "type": "boolean", "doc": "a voice clip: one at a time per listener, 2 s of silence after it, and one asked for sooner is dropped (false)" }, "duration": { "type": "number", "doc": "seconds a voice clip runs, how long its listener's channel stays busy (3)" }, "gap": { "type": "number", "doc": "seconds a listener who already heard this sound is not sent it again, so a cue used often never stacks (0)" }, "heard_by": { "type": "SoundHeardBy", "doc": "who hears it (all): wearer plays it at the wearer for them alone, a warning nobody near them gets; target plays it for the aimed player alone; both take no at" } } }, "thematic:stop_sound": { "doc": "Stops a sound on the wearer's client and every client near them, at once. A suit's options sound is the one stopped, unless world.", "fields": { "sound": { "type": "string | SoundCycle", "required": true, "doc": "the sound, or a set: every member stops" }, "world": { "type": "boolean", "doc": "the sound as written, never the suit's own (false)" } } }, "thematic:animation": { "doc": "Plays a suit animation clip. A suit's options.animation still wins for the wearer. A suit-wearing mob (a squad flier running a mob() block) plays it once on its own body, for everyone who can see it; hold, hold_for and first_person do nothing for it.", "fields": { "animation": { "type": "string", "required": true, "doc": "the clip name" }, "speed": { "type": "number", "doc": "playback speed (1)" }, "on": { "type": "AnimationOn", "doc": "self (default), or target: a targeted player" }, "fit": { "type": "AnimationFit", "doc": "play it at the speed that fills a window, instead of speed" }, "fade_in": { "type": "number", "doc": "seconds spent blending in from the current pose (0)" }, "stop_after": { "type": "number", "doc": "stop it this many seconds after it starts" }, "stop_on_leave": { "type": "boolean", "doc": "stop it when the move's phases end (false)" }, "hold": { "type": "HoldMode", "doc": "hold it on the suit, on its last frame, for as long as the move lasts, rather than play it once" }, "play": { "type": "HoldPlay", "doc": "with hold or holdFor: hold (default) on its last frame, loop, or once" }, "then": { "type": "string", "doc": "with hold: once the clip has played through and parked, loop this one" }, "blend": { "type": "number", "doc": "with hold or holdFor: seconds to ease in and out (0)" }, "hold_for": { "type": "number", "doc": "hold it on the suit for this many seconds from now, over any held clip (a hit pose)" }, "priority": { "type": "number", "doc": "a clip played once: its priority over the other clips on the wearer's animation layer, e.g. 1 for a throw over the swing's own clips (the layer's default)" }, "alternate": { "type": "string | string[]", "doc": "a clip played once: clips that take turns with this one, a run each -- animation(\"web_shoot_right\", { alternate: \"web_shoot_left\" }) throws right, then left, then right; counted per wearer and ability" }, "first_person": { "type": "string", "doc": "a clip played once: the clip the wearer sees in first person instead, while everyone else (and their own third person) sees this one -- animation(\"shoot_missile\", { firstPerson: \"shoot_missile_fp\" })" } } }, "thematic:stop_animation": { "doc": "Stops a clip, played or held.", "fields": { "animation": { "type": "string", "required": true, "doc": "the clip name; a suit's options.animation still wins for the wearer" }, "on": { "type": "AnimationOn", "doc": "self (default), or target: a targeted player" } } }, "thematic:gun_clip": { "doc": "Plays a clip on the gun in the wearer's main hand: one of the cues that gun declares, by name. The gun owns its own clips, so a move asks for the name and gets whatever the gun in hand calls it -- or nothing, when it has no cue by that name. First person only: the weapon model animates nowhere else, and the third person of the same beat is the wearer's own body (swingHand, or a suit clip).", "fields": { "clip": { "type": "string", "required": true, "doc": "the cue's name, as the gun's cue() declares it, e.g. \"bash\"" } } }, "thematic:assets": { "doc": "Fires the suit's clips and sounds for this move from its options anims_ and sounds_, as the key press does. The press already fires anims_press and sounds_press once; assets(\"press\") fires them again, as moves that restarted the clip and doubled the sound at their own start did.", "fields": { "key": { "type": "string", "doc": "which options: \"press\" (default) for anims_press and sounds_press, \"release\" for anims_release ..." } } }, "thematic:claim_pose": { "doc": "The move's clip drives the wearer's pose for a while, and any other move's claim is dropped. An ability with body({ while: \"animating\" }) holds its limbs for as long as the claim.", "fields": { "for": { "type": "Amount", "doc": "seconds; left out, what is left of the running phase" } } }, "thematic:release_pose": { "doc": "Gives the wearer's pose back before the claim runs out.", "fields": {} }, "thematic:shot": { "doc": "Changes the arrow the answered arrow_loosed loosed, as it leaves the string: a harder hit, a critical, piercing, a command tag, who may pick it up. A patient shot: shot({ damageTimes: tuned(\"damage\"), critical: true, pierce: 1, tag: \"thematic_bullseye\" }). Nothing outside arrow_loosed.", "fields": { "damage": { "type": "Amount", "doc": "its damage, set outright (a Thematic arrow's is scaled by the draw when it lands)" }, "damage_times": { "type": "Amount", "doc": "its own base damage (before the draw scales it) times this; not with damage" }, "critical": { "type": "boolean", "doc": "a critical arrow (the trail of sparks, and vanilla's extra)" }, "pierce": { "type": "number", "doc": "how many bodies it passes through, 0 to 127" }, "tag": { "type": "string", "doc": "a command tag it carries, which a kill guard can ask of the killing arrow" }, "pickup": { "type": "\"allowed\" | \"creative_only\" | \"disallowed\"", "doc": "who may pick it up once it lands" } } }, "thematic:projectile": { "doc": "Fires or throws a projectile. A bolt body is an energy bolt (optic blasts, starbolts, crescents); a thrown body is a throwable definition's model and flight (vials, a cup of tea). on_hit runs aimed at the entity it strikes, on_block where it meets a block (or a thrown body's fuse runs out), each with the owner's tuned numbers as they are when it lands.", "fields": { "body": { "type": "ProjectileBody", "doc": "bolt (default), thrown, arrow or entity" }, "entity": { "type": "string", "doc": "entity: the entity type it is, e.g. \"thematic:cap_shield\"; owned by the shooter when it is a projectile, its damage set when damage is written and it is an arrow; how it looks and hits is its own (1.5 a tick unless speed says); a tether body (thematic:tether) names the move and runs its on_hit / on_block, in the press, when its head takes hold of a body / a block (a lasso's catch); any other entity body takes neither" }, "consume_held": { "type": "string | ConsumeHeld", "doc": "an item (or #tag) each one takes out of the wearer's hands as it leaves, main hand first; none held, none fired; a thrown body whose throwable carries its item carries the one taken" }, "carries": { "type": "string | string[] | { items: string | string[]; tint?: string }", "doc": "thrown, a throwable that carries its item (thrown_item): the stack each one flies with, made for it -- one of items at random, in a corps' colour and prefix with tint (e.g. \"yellow\"), as a construct is drawn; not with consume_held" }, "throwable": { "type": "string", "doc": "thrown: the throwable definition it is, e.g. \"thematic:science_vial\" (model, size, flight); \"self\" for the throwable whose own hook fires it, or whose item is in hand (a gadget's throw)" }, "arrow": { "type": "string", "doc": "arrow: the arrow definition it is, e.g. \"thematic:arrow_explosive\" (minecraft:arrow for a plain one); its definition decides its look and hits, so on_hit, on_block, effects and look are not taken" }, "from": { "type": "Anchor | Anchor[] | \"spot\" | SpotOrigin", "doc": "where on the body it leaves (eyes); several anchors fire one from each; \"spot\" over the spot the press fixed (nothing fired with none)" }, "toward": { "type": "\"spot\" | SpotToward", "doc": "aimed at the spot the press fixed instead of along the aim (no aim: target)" }, "aim": { "type": "ProjectileAim", "doc": "look (default), heading, target, ballistic, or crosshair" }, "aim_reach": { "type": "number", "doc": "aim crosshair: blocks along the look to look for what the crosshair is on (64); it stops short of unloaded chunks" }, "pitch": { "type": "number", "doc": "degrees added to the look's or heading's pitch; negative tilts it up (-3 lobs a throw)" }, "at": { "type": "TargetsOptions & { select: TargetSelect }", "doc": "aim target: who to throw at, written as a targets() search; nobody found, it goes along the look" }, "count": { "type": "number", "doc": "how many from each anchor (1)" }, "per_target": { "type": "boolean", "doc": "at least one at each target at found, dealt round in turn (Stars and Garters: count 5, one each if more)" }, "speed": { "type": "Amount", "doc": "blocks a tick (bolt 2.5; thrown, the throwable's velocity)" }, "spread": { "type": "number", "doc": "vanilla's inaccuracy along a look or heading, and at a target with lead (0)" }, "jitter": { "type": "number", "doc": "up to this much added to its velocity on each axis, either way (0)" }, "lift": { "type": "number", "doc": "added to its velocity's rise after aiming (0)" }, "inherit_motion": { "type": "boolean", "doc": "adds the shooter's motion, as vanilla shots do (true along a look or heading, false at a target)" }, "delay": { "type": "number", "doc": "seconds before it leaves (0); gone with a wearer who dies meanwhile" }, "latch": { "type": "LatchWhen | { from?: LatchWhen, aim?: LatchWhen }", "doc": "with a delay: read the origin and/or the aim as the action runs (press) rather than as it leaves (fire, the default)" }, "gravity": { "type": "number", "doc": "blocks a tick it falls by (bolt: vanilla's first tick then none, the Java bolts' way; thrown: the throwable's)" }, "max_age": { "type": "number", "doc": "seconds before it is gone without breaking (bolt 2; thrown 10); 0 for a bolt's no limit of its own; a Thematic arrow body: how long it stays, landed or not (its own 120)" }, "pickup": { "type": "\"allowed\" | \"creative_only\" | \"disallowed\"", "doc": "arrow: who may pick it up once it lands (the arrow's own)" }, "shot": { "type": "{ critical?: boolean; pierce?: number; tag?: string }", "doc": "arrow: a fully drawn shot, critical (false), passing through pierce bodies (the arrow's own) and carrying a command tag a kill guard can ask of the killing arrow" }, "max_distance": { "type": "number", "doc": "bolt: blocks from its shooter before it is gone (32); 0 for no limit" }, "fuse": { "type": "number", "doc": "thrown: seconds before it breaks where it is, running on_block (the throwable's fuse)" }, "size": { "type": "number", "doc": "bolt: its hitbox, blocks (0.3)" }, "direct_hit": { "type": "DirectHit", "doc": "what a head-on hit deals besides on_hit (bolt: flat; thrown: none)" }, "damage": { "type": "Amount", "doc": "the direct hit's damage and the effects' damage (the tuned damage), fixed when it is fired" }, "effects": { "type": "(string | AbilityEffectEntry)[]", "doc": "ability effects a direct hit carries, as a beam's: ids, e.g. [\"thematic:push\", \"thematic:laser\"], or { id, ...options }" }, "option_effects": { "type": "string", "doc": "a suit option whose comma list of effect ids is added after these, e.g. \"laser_effects\"" }, "dedupe": { "type": "boolean", "doc": "an effect already in the list is not added again" }, "pierce": { "type": "boolean | BoltPierce", "doc": "bolt: true flies on through bodies, striking each once with on_hit and the effects but no direct hit; { unless, max } flies through the bodies the guard does not hold for and strikes those it does, spent after max of them" }, "return": { "type": "true | BoltReturn", "doc": "bolt: turns back to its shooter and is caught there (true: straight home after 17 ticks)" }, "on_return": { "type": "ActionObject[]", "doc": "bolt with a return: run at the shooter when it is caught" }, "pierce_option": { "type": "string", "doc": "a suit option that switches pierce on when true, e.g. \"pierce\"" }, "hit_once": { "type": "boolean", "doc": "a body it has hit is passed through after (true)" }, "hittable_only": { "type": "boolean", "doc": "it passes through the shooter and anyone they may not hit (bolt false, thrown true)" }, "ricochet": { "type": "Ricochet", "doc": "bolt: bounces off blocks instead of spending itself on them" }, "recoil": { "type": "number | Recoil", "doc": "bolt: the shooter pushed back when it meets a block" }, "steer": { "type": "number", "doc": "thrown at a target: how much of the way it turns onto them each tick, 0 to 1 (the vials: 0.3)" }, "contact": { "type": "number", "doc": "thrown at a target: it breaks on them once within this many blocks of their middle (the vials: 0.7)" }, "trail": { "type": "Trail | Trail[]", "doc": "particles it sheds in flight" }, "hit_sound": { "type": "string", "doc": "bolt: played when a direct hit lands (minecraft:entity.firework_rocket.blast); \"none\" for silence" }, "look": { "type": "ProjectileLook | LookStyle", "doc": "how it is drawn (a bolt as a bolt from the ability's assets.beam; a thrown body as its model)" }, "on_hit": { "type": "ActionObject[]", "doc": "run aimed at the entity it strikes, before the direct hit" }, "on_block": { "type": "ActionObject[]", "doc": "run where it meets a block, or where a thrown body's fuse runs out" }, "cycle": { "type": "boolean | number", "doc": "with at: each firing takes the next of the targets at found, in turn, counted over the press -- a volley spread round a crowd; a number goes round only the first that many (sort: \"distance\" for the nearest)" }, "lead": { "type": "boolean", "doc": "at a target: aimed where they will be after the flight (their motion times its ticks, at most 40) and raised by what the shot falls on the way, then strayed by spread" }, "spiral": { "type": "true | { step?: number, pitches?: number[], spread?: number }", "doc": "at a target, when at finds nobody: the nth firing of the press leaves at the wearer's yaw plus n times step degrees (137.5), at the nth of pitches in turn ([0]), strayed by spread (0) -- a blind corkscrew instead of the look" }, "pattern": { "type": "PatternShape | ProjectilePattern", "doc": "how the count shots of a firing are laid out: ring, fan, converge or rain" }, "formation": { "type": "Formation", "doc": "the shots in a grid across the look, in place of count" }, "volleys": { "type": "number | { count: number, every?: number }", "doc": "the whole firing count times in all, every seconds apart (0.25), each read afresh as it leaves; none from a wearer who died meanwhile" }, "homing": { "type": "true | Homing", "doc": "turns onto its target each tick (strength 0.2)" }, "hover": { "type": "number | Hover", "doc": "seconds held still where it was made before it goes; a bolt's max_age grows by the hold unless written" }, "orbit": { "type": "true | Orbit", "doc": "circles the wearer, then is gone (or let go); a bolt's max_age grows by it unless written" }, "wobble": { "type": "true | Wobble", "doc": "its heading wanders on the way, its speed kept" }, "explode_on_impact": { "type": "boolean | ExplodeOnImpact", "doc": "bolt or thrown: Thematic's explosion wherever it hits, after on_hit and on_block (by_definition: the throw detonates on any hit, at radius when given)" }, "by_definition": { "type": "boolean", "doc": "thrown: it flies and breaks as its throwable definition says (flight, fuse, hooks) with the fired damage, instead of breaking on the first thing it meets and running on_hit / on_block; takes no on_hit, on_block, effects, steer, contact, trail or max_age" }, "color": { "type": "Color | Color[] | \"$random_hue\" | \"$suit_color\" | \"$stack_color\" | string", "doc": "picked for each one as it leaves and put in its look's color (a thrown body: its tint): a colour, one of a list at random, a random hue, the wearer's suit colour, the colour tag of the item stack firing it (a lantern construct's corps colour), or a press value" }, "keep_as": { "type": "string", "doc": "the wearer's store key the last one fired is kept under (e.g. \"grapple_entity\"): the one kept there before is taken down as this one leaves, the keeps guard asks whether it is still out, and drop_kept takes it down" } } }, "thematic:drop_kept": { "doc": "Takes down the entity the wearer keeps under a store key -- the projectile a projectile's keep_as kept (a grapple's hook), a bow's tracked arrow -- if one is still out, and forgets it. dropKept(\"grapple_entity\").", "fields": { "key": { "type": "string", "required": true, "doc": "the store key, as keep_as wrote it" } } }, "thematic:recall_thrown": { "doc": "Turns every throwable the wearer has out for home now, by its own return (those of one definition when throwable names it). recallThrown({ throwable: \"thematic:my_throwable\" }).", "fields": { "throwable": { "type": "string", "doc": "only throwables of this definition id" } } }, "thematic:burst": { "doc": "A blast going off at a point -- where a shot landed (the default), on the wearer, at a marked spot, or at random around one -- that hurts, doses and throws back everyone the wearer may hit within radius, with a flash and a bang.", "fields": { "at": { "type": "BurstAt | BurstScatter", "doc": "where it goes off (impact)" }, "from": { "type": "Anchor", "doc": "a point on the wearer's body it goes off at, instead of at" }, "radius": { "type": "Amount", "doc": "how far it reaches, in blocks; left out, the tuned radius" }, "targets_around": { "type": "BurstAround", "doc": "whose surroundings are searched (self when at is self, burst otherwise)" }, "shape": { "type": "BurstShape", "doc": "box (default) or sphere" }, "hittable": { "type": "boolean", "doc": "false: allies and protected entities are caught too (the wearer never is) (true)" }, "exclude": { "type": "BurstExclude | BurstExclude[]", "doc": "who it leaves out besides the wearer (none)" }, "damage": { "type": "Amount", "doc": "what each body takes; left out, the tuned damage; 0 hurts no one" }, "source": { "type": "BurstSource", "doc": "what the hit counts as (attack)" }, "damage_type": { "type": "string", "doc": "a damage type id instead of source, e.g. \"thematic:psychic\"" }, "element": { "type": "Element", "doc": "what the blast is made of instead of source, e.g. \"radiation\": the hit carries that element's damage type, so a suit weak or resistant to it answers" }, "hit_objects": { "type": "boolean", "doc": "true: the non-living thing a shot struck (an armour stand, a boat) takes the damage too (false)" }, "effect": { "type": "string | BurstEffect | (string | BurstEffect)[]", "doc": "a status effect on everyone it catches (none)" }, "knockback": { "type": "number | BurstKnockback", "doc": "a shove away from the point: a strength, or its options (none)" }, "particles": { "type": "ParticlesOptions & { particle: ParticleSpec } | (ParticlesOptions & { particle: ParticleSpec })[]", "doc": "particles where it goes off: the fields of particles(...), e.g. { particle: \"minecraft:flash\", count: 80, spread: 3, speed: 0, yOffset: 1 }" }, "sound": { "type": "string | BurstSound", "doc": "a bang where it goes off, re-voiced by the suit's sound option" }, "do": { "type": "ActionObject[]", "doc": "more for each body it catches, as inside targets()" } } }, "thematic:zone": { "doc": "A patch of ground that keeps biting: fixed where it is laid, every so often for a while it runs its actions on everyone standing in it -- first ones only the first time each body is caught. The first pulse comes one every after it is laid, the last at for: floor(for / every) pulses, at least one. Its numbers are read as each pulse lands.", "fields": { "at": { "type": "ZoneAt", "doc": "where it lies (here)" }, "floor": { "type": "boolean", "doc": "drop it onto the first solid surface up to 4 blocks below, as a pool lies (false)" }, "radius": { "type": "Amount", "doc": "how far it reaches sideways; left out, the tuned radius" }, "height": { "type": "number", "doc": "how far above the ground it still reaches (1)" }, "footing": { "type": "number", "doc": "how far below the ground it reaches (0.5)" }, "shape": { "type": "ZoneShape", "doc": "round (default) or box" }, "every": { "type": "number", "doc": "seconds between pulses (0.25)" }, "for": { "type": "Amount", "doc": "how long it lies there, seconds; left out, the tuned duration" }, "hittable": { "type": "boolean", "doc": "only those the wearer may hit (true); false catches allies too. Never the wearer" }, "caught": { "type": "string", "doc": "a catch markCaught() filled earlier in the press (or the same throwable's hit): those already in it skip the first actions, as a pool leaves alone whoever the break already burned" }, "do": { "type": "ActionObject[]", "doc": "run on everyone standing in it, every pulse" }, "first": { "type": "ActionObject[]", "doc": "run before do, once per body: the first pulse that catches it" } } }, "thematic:mark_node": { "doc": "Adds where the wearer stands to a trail kept for the rest of the press under a name: targets(\"trail\") searches around its nodes and decal({ along }) stains the last stretch of it.", "fields": { "key": { "type": "string", "required": true, "doc": "the trail's name" }, "max": { "type": "number", "doc": "how many nodes it keeps before the oldest give way (256)" } } }, "thematic:mark_caught": { "doc": "Counts the entity the action is about -- the target inside targets() -- as caught under a name, so a zone given the same caught skips its first actions for it.", "fields": { "key": { "type": "string", "required": true, "doc": "the catch's name" } } }, "thematic:decal": { "doc": "Stains the floor with a block that is only shown, never placed: laid in lanes across the way the wearer faces, sampled every step along the last stretch of a trail (or at the spot), each on the first floor with a full top face within depth below. Every player sees each one for as long as it lasts, on the server's clock. With touch, whoever stands in one has those actions run on them, as the wearer, every touchEvery seconds of their own age.", "fields": { "block": { "type": "string", "required": true, "doc": "the block phase, as a command writes it: \"thematic:blood_splatter[down=true]\"" }, "along": { "type": "string", "doc": "a trail markNode laid: stains the stretch from its last node but one to its last; left out, at the spot" }, "facing": { "type": "TargetAlong", "doc": "which way the lanes run across (heading)" }, "lanes": { "type": "number", "doc": "side by side (1)" }, "spacing": { "type": "number", "doc": "blocks between lanes (1)" }, "step": { "type": "number", "doc": "blocks between samples along the stretch (0.7)" }, "depth": { "type": "number", "doc": "how many blocks below a sample it looks for the floor (2)" }, "max": { "type": "number", "doc": "stains this action lays in the press at most, each spot once (64)" }, "lasts": { "type": "number", "doc": "seconds each stays on the ground (15)" }, "tag": { "type": "string", "doc": "an id gameplay can ask the ground about, e.g. \"thematic:blood\"" }, "touch": { "type": "ActionObject[]", "doc": "run on whoever stands in a stain, aimed at them, while it lasts" }, "touch_every": { "type": "number", "doc": "seconds between touches, counted on the stander's age (0.2)" }, "touch_hittable": { "type": "boolean", "doc": "never the wearer, and only while the wearer is in that world and may hit the stander (true); false: anyone but the wearer, online or not" } } }, "thematic:splash": { "doc": "Liquid of a colour. Breaking at the spot: drops thrown out, a burst, a pool on the floor under it for a while and pool.splatter smaller ones up to pool.spread away. With drench: landing on the entity the action is about instead, over the chest and across the eyes.", "fields": { "color": { "type": "number | string | [number, number, number]", "required": true, "doc": "0x8CE01A, \"#8CE01A\", [r, g, b] or \"$name\" for one the press drew" }, "at": { "type": "At", "doc": "here (default) or spot (where markSpot fixed)" }, "pool": { "type": "{ for?: Amount; radius?: number; splatter?: number; spread?: number }", "doc": "the pool it leaves: for (seconds; left out, the tuned duration), radius (1.4), splatter (further pools, 0) and spread (how far they land, 0)" }, "drench": { "type": "boolean", "doc": "splash the target rather than break at the spot (false)" } } }, "thematic:track": { "doc": "Remembers a target across the move, with a synced copy of it the client can draw from (thematic:trail_to_target, thematic:target_readout) even once it is out of render distance. Inside targets(): starts tracking the one picked. Anywhere else: refreshes the copy of the one tracked -- run it in a phase's every(). stop: true lets go. Kept on the wearer under _target (and _name, _health, _bleed, _x, _y, _z, _since): scent_tracker's keys, which Keen Nose writes too.", "fields": { "name": { "type": "string", "doc": "which track: lower_snake_case; left out, the ability's id" }, "sync": { "type": "TrackSync[]", "doc": "what to keep a copy of (all of them)" }, "resync": { "type": "{ move?: number; health?: number }", "doc": "how much change rewrites the copy: blocks moved (0.5) and display health (1)" }, "stop": { "type": "boolean", "doc": "true: lets go of the target and blanks the copy" }, "glow": { "type": "boolean", "doc": "outlines the target for the wearer alone, through walls, while the track is refreshed; stop takes it off (false)" } } }, "thematic:strike_spray": { "doc": "Blood off a blade strike, inside targets(): each client that can see the wearer throws it off the blade nearest the wound, along the way that blade was travelling; one that can't sprays from the wound along aim. What every Wolverine move's hit threw.", "fields": { "count": { "type": "number", "doc": "how many drops (12)" }, "aim": { "type": "ParticleAim", "doc": "which way it sprays when no blade is seen: look (default), up, down, motion (where the wearer moves, or their look while they stand still) or heading" }, "particle": { "type": "ParticleSpec", "doc": "what is thrown (thematic:blood_particle)" }, "color": { "type": "Color", "doc": "recolours dust, as particles() does" } } }, "thematic:mark_deadline": { "doc": "Stores a deadline on the wearer, synced: the world time plus for seconds. The until guard holds until it passes -- a lock that runs out by itself, with nothing to clear on death, logout or a move cut short: markDeadline(\"claw_stab_lock_until\", { for: 1.5 }) with requires({ not: { until: \"claw_stab_lock_until\" } }).", "fields": { "key": { "type": "string", "required": true, "doc": "the key it is stored under, the one an until guard names" }, "for": { "type": "Amount", "required": true, "doc": "seconds from now" } } }, "thematic:outgoing_damage": { "doc": "For a while, every hit the wearer deals carries amount * times + plus more -- negative for less -- folded into the hit as a phase's damageBonus is, but kept on the wearer with its own deadline, so it outlasts the phase and the press: outgoingDamage({ times: -0.1, for: 5 }) is a tenth off for five seconds. A later one under the same key replaces it; it runs out by itself, death and logout included. A hit's bonuses are summed and never total less than none, so a negative share only takes off what its other bonuses added.", "fields": { "times": { "type": "Amount", "doc": "the share of each hit added, e.g. -0.1 for a tenth less (0)" }, "plus": { "type": "Amount", "doc": "a flat amount added to each hit (0)" }, "for": { "type": "Amount", "required": true, "doc": "seconds it lasts" }, "melee": { "type": "boolean", "doc": "true: only the wearer's own melee swings carry it, not projectiles, beams or other moves' damage" }, "key": { "type": "string", "doc": "what it is kept under on the wearer, lower_snake_case (the ability's id; an item's hook has none, so it names one); one per key" }, "uses": { "type": "number", "doc": "spent after this many hits, 1 for an empowered next hit; a hit in the tick it was granted never spends it, so the hit that earns it does not (0: no limit)" }, "held_trait": { "type": "string", "doc": "only hits dealt while the wearer's main hand holds an item with this trait count, e.g. \"construct\" (any)" } } }, "thematic:phase": { "doc": "The shared phase every intangible suit uses (intangibility's own phase: noclip movement, the shimmer, active: \"intangibility\"). phase() begins it until ended, phase({ for: 0.55 }) for that long, phase({ end: true }) ends it; beginning turns the body shimmer on and ending turns it off. phase({ density: \"hand\" }) only turns that part's shimmer on (value: false, off). Players only.", "fields": { "for": { "type": "number", "doc": "seconds the phase lasts; 0 or left out: until ended" }, "end": { "type": "boolean", "doc": "true: ends the phase instead (false)" }, "density": { "type": "DensityPart", "doc": "only turns this part's density shimmer on or off; takes no for or end" }, "value": { "type": "boolean", "doc": "with density: on (true) or off" } } }, "thematic:mark_health": { "doc": "Keeps the wearer's health plus absorption under a key, for the healthBelowMark guard: markHealth(\"my_charge_health\") on the press, until({ healthBelowMark: \"my_charge_health\" }, \"ready\", { check: \"before\" }) in the phase, and markHealth again in its every() so a heal raises the mark. Only a hit that really took health or absorption counts; one an immunity or resistance swallowed does not.", "fields": { "key": { "type": "string", "required": true, "doc": "the key it is kept under, the one healthBelowMark names" } } }, "thematic:summon": { "doc": "Brings in entities that belong to the wearer, placed around them and facing the way they face: summon(\"thematic:hologram\", { count: 3, arrangement: \"rear_arc\", radius: 3.6, health: 50, lasts: 20, mirror: { melee: 0.2 } }). An entity built to be summoned (thematic:hologram) also takes its owner, its lifespan, the echo and goes away when the wearer loses this ability; any other is only placed and given its health. The body runs at each one, aimed at it as at a target.", "fields": { "entity": { "type": "string", "required": true, "doc": "the entity type id, e.g. \"thematic:hologram\"" }, "count": { "type": "Amount", "doc": "how many (1, or one per offset); a worked-out number is truncated, never below 1" }, "arrangement": { "type": "SummonArrangement", "doc": "where they stand around their centre (ring)" }, "radius": { "type": "Amount | number[]", "doc": "how far from their centre, in blocks (0), or [min, max] picked for each one; for formation_v, how far apart the ranks stand sideways" }, "stagger": { "type": "number", "doc": "with formation_v, how far back each rank stands, in blocks (half the radius)" }, "offsets": { "type": "number[][]", "doc": "fixed places added on top of the arrangement, each [right, up, forward] in blocks from the way the wearer's body faces, used in turn: [[0, 5.62, -5], [-6.5, 5.62, -7.25], [6.5, 5.62, -7.25]]" }, "scatter": { "type": "number", "doc": "moves each one up to this many blocks at random on each level axis (0)" }, "target": { "type": "SummonTarget", "doc": "whom each one goes for: a mob takes it as its target, an effect entity (a construct jet) flies at it; named and not there, nothing is summoned" }, "velocity": { "type": "SummonVelocity", "doc": "sends each one off as it arrives: {along, speed}" }, "every": { "type": "number", "doc": "seconds between one and the next (0: all at once); later ones are dropped if the wearer is gone" }, "damage": { "type": "Amount", "doc": "what an effect entity that works for the wearer (a stun bolt, a construct jet) or an arrow hits for; left out, the entity's own" }, "health": { "type": "Amount", "doc": "each one's maximum and starting health, in raw hit points; left out, the entity's own" }, "lasts": { "type": "Amount", "doc": "seconds before each fades on its own (a summon built for it, a shockwave, a construct jet), e.g. expr(\"cooldown / 20\") for a full cooldown; any other entity (a mob, a TNT) is sent away after it; left out, the entity's own" }, "attributes": { "type": "SummonAttribute[]", "doc": "attribute modifiers put on each living one for good (saved with it): [{ attribute: \"minecraft:generic.armor\", amount: tuned(\"damage\"), operation: \"add\" }]" }, "scales": { "type": "SummonScales", "doc": "Pehkui sizes each one grows to besides its whole body's (scale): { defense: 8, attack: 2, reach: 2.25, falling: 0 }" }, "display": { "type": "boolean", "doc": "for show only (a lit charge that never goes off, a prop): it cannot be hurt, a mob's AI is off, a primed TNT's fuse never runs down, it drops nothing and is never saved -- one a save brings back is discarded. Send it away with lasts, or action(\"thematic:thematic_explosion\", { at: \"summoned\" }) inside do (false)" }, "floor": { "type": "boolean", "doc": "each one is set down on the collision surface below its spot (a slab's top, a step), so a prop sits flush instead of hanging where the wearer's feet were (false)" }, "options": { "type": "{ [key: string]: unknown }", "doc": "anything else an effect entity that works for the wearer takes (a jet's missile count, a thrown construct's item), handed to it as written; a worked-out number (tuned(\"damage\"), expr(...)) is worked out at the cast. Keys arrive snake_case; an entity reads only those it knows" }, "echo_melee": { "type": "Amount", "doc": "the share of each of the wearer's melee hits each one repeats on whatever the wearer hit, and what it hits for on its own (0); the same number as mirror.melee, which a new file should use" }, "replace": { "type": "number", "doc": "first clears the wearer's own earlier summons of this entity within this many blocks of them" }, "like": { "type": "\"target\"", "doc": "each one takes on the look of the body the action is aimed at: a villager's type, trade and level" }, "do": { "type": "ActionObject[]", "doc": "more at each one as it arrives, as inside targets()" }, "at": { "type": "SummonAt", "doc": "what they stand round: the wearer (default), the target the action is aimed at -- the body a projectile struck, the one inside targets(); no living target, nothing is summoned -- the spot the move fixed (none, nothing is summoned), the block face a shot struck, turned out of it (face: a splat on a wall; aimed at a body, as in a push's onWall, the wall beside it; no face, nothing is summoned), or a random spot near the wearer (random, random_water)" }, "spread": { "type": "number", "doc": "with at: \"random\", how far off the wearer each one stands (1.5); with \"random_water\", how far off on each level axis the spot may be (5)" }, "onto": { "type": "\"target\"", "doc": "stand each on the target and hand it the target as its subject (thematic:web_snare_entity: a cocoon wrapped round it); no living target, nothing is summoned" }, "anchors": { "type": "number", "doc": "with onto: how many lines it may keep to the world round its subject (-1: as many as it finds)" }, "hold": { "type": "boolean", "doc": "with onto: it holds its subject where it stands, rather than only wrapping it (false)" }, "mirror": { "type": "SummonMirror", "doc": "makes them mimics: which of the wearer's moves each one runs again from its own body, and the share of the wearer's punches it repeats" }, "look": { "type": "SummonLook", "doc": "how a mimic is drawn: the wearer's suit (as ever), a tint, how solid" }, "solid": { "type": "boolean", "doc": "it can be bumped, pushed and struck by blows and projectiles (true); false lets them pass through" }, "hittable": { "type": "boolean", "doc": "anything can hurt it (true); false leaves it untouchable" }, "hurts_owner": { "type": "boolean", "doc": "a blow that hurts it hurts the wearer for the same (false)" }, "tame": { "type": "boolean", "doc": "tames each one to the wearer when it can be tamed -- a wolf, a cat, a horse (false)" }, "owner": { "type": "boolean", "doc": "writes the wearer into each one's own data as its owner (ownerUUID), as the mod's summons do; any option below that needs an owner writes it anyway, unless taming already said (false)" }, "credit_owner": { "type": "boolean", "doc": "the damage it deals counts as the wearer's: their bonuses, hit_landed, kill credit, loot (false)" }, "tag": { "type": "string", "doc": "a command tag each one carries, telling a group apart (\"thematic_pack\"); caps count only those with it" }, "name": { "type": "string", "doc": "a translation key each one is named with, the wearer's name as its argument" }, "link": { "type": "string", "doc": "the wearer's data key each one's id is kept under (\"companion_wolf_uuid\"), for targets and caps to find it; cleared when it is sent home" }, "persistent": { "type": "boolean", "doc": "never despawns (false)" }, "follow": { "type": "boolean | number", "doc": "keeps up with the wearer: true, or the speed it walks at (1); brought along past 24 blocks" }, "defend_owner": { "type": "boolean", "doc": "goes for whoever hurt the wearer (false)" }, "assist_owner": { "type": "boolean", "doc": "goes for whatever the wearer is fighting (false)" }, "never_target_owner": { "type": "boolean", "doc": "drops a target on the wearer's side: the wearer, their mobs, their teammates (false)" }, "hostile_to": { "type": "string | string[]", "doc": "what it goes for on sight: \"anyone\", entity type ids or \"#tag\"s; never the wearer's side" }, "max_alive": { "type": "Amount", "doc": "no more of the wearer's own of this entity (and tag) standing than this: the oldest go first" }, "keep_one": { "type": "boolean", "doc": "exactly one: while one stands (the linked one, else the first) the rest go and none is brought" }, "top_up": { "type": "boolean", "doc": "those already standing within 48 blocks count toward count; any more, or further off, go home" }, "dismiss_on_unequip": { "type": "boolean", "doc": "each one goes home when the wearer's suit no longer grants this ability (false)" }, "mount": { "type": "\"owner\" | \"target\"", "doc": "owner: the wearer rides it; target: it rides the target the action is aimed at (inside another summon's do, the one summoned)" }, "gear": { "type": "SummonGear[]", "doc": "what each one wears by the wearer's level: for a slot, the last piece whose minLevel it reaches" }, "levels": { "type": "number[]", "doc": "[min, max], the range the wearer's ladder is read onto for gear ([1, 5]); off a ladder, the ability's level" }, "launch": { "type": "Amount", "doc": "throws each one along the wearer's look at this speed" }, "scale": { "type": "number", "doc": "each one's size, 1 its own" }, "baby": { "type": "boolean", "doc": "each one is a baby, where the entity has one (false)" }, "share_damage_to_owner": { "type": "SummonShare", "doc": "each one takes nothing from a hit and bills the wearer a share of it instead, through the attacker's own damage source" }, "tint": { "type": "string", "doc": "a corps by its colour name, e.g. \"green\": each living one is drawn in that corps' light, as a construct is (its prefix kept in the body's own data)" } } }, "thematic:give": { "doc": "Hands the wearer an item to keep: into the inventory (the ground when it is full), or onto a slot. Unlike equip() nothing takes it back -- unless tie names a move, when it carries that move's tag as an equipped item does: stripped while the move is not running, and discarded if dropped; or permanent, lasts or rounds say when it goes.", "fields": { "item": { "type": "string", "doc": "the item id, e.g. \"minecraft:iron_sword\" (a bare id means thematic:); an item not registered (its pack missing) hands out nothing. Needed unless from says otherwise" }, "from": { "type": "\"construct_favourites\"", "doc": "instead of item: each construct the body starred (the Construct Wheel's), one apiece, skipping any it carries already" }, "count": { "type": "number", "doc": "(1)" }, "slot": { "type": "GiveSlot", "doc": "inventory (default), mainhand, offhand, head, chest, legs, feet, hand (the main hand when empty, else the inventory) or hotbar (into the hand: the selected hotbar slot when empty, else the first empty one, switched to for the first item given; no empty hotbar slot, nothing handed)" }, "only_if_empty": { "type": "boolean", "doc": "with an equipment slot: handed over only when that slot holds nothing, so it never displaces what is worn there (false)" }, "enchant": { "type": "Record", "doc": "enchantments and levels, e.g. { \"minecraft:sharpness\": 2 }" }, "named": { "type": "boolean", "doc": "named for the wearer, \"'s \", in grey (false)" }, "tie": { "type": "string", "doc": "the id of a move the item lasts only while running, e.g. \"equip_green_ring\"; {corps} in it is the wearer's corps prefix (\"equip_{corps}_ring\"; no corps, no tie); left out, the item is the wearer's to keep" }, "displaced": { "type": "Displaced", "doc": "with a slot: what happens to what held it, stash (default) or drop" }, "permanent": { "type": "boolean", "doc": "the wearer's for as long as their suit has this move, taken back once it does not; and had once: carrying one already (anywhere, tagged or not), they are handed nothing (false)" }, "lasts": { "type": "Amount", "doc": "seconds the item lasts, then it is taken back wherever it is -- a mob's equipment too (0: it stays); tuned(\"duration\") for the move's tuned duration" }, "rounds": { "type": "number", "doc": "a gun's budget: it goes once that many rounds have been fired, however often it reloads (left out: no budget)" }, "gun": { "type": "boolean | { fireMode?: GunFireMode | GunFireMode[], oneClip?: boolean }", "doc": "for a gun: picks its fire mode -- the first of fireMode it has (automatic, then burst, when none is named; else its first) -- and marks it set up; oneClip: one magazine, no reserve. Anything else is left alone" }, "tint": { "type": "string", "doc": "a corps, e.g. \"white\": its colour and prefix on the item, the way a construct is drawn in its light; \"wearer\" for the wearer's own corps (the green one when they have none)" }, "nbt": { "type": "Record", "doc": "flags written on the item for it to read, e.g. { prefix: \"gold\", dontRemove: true }; keys are written in camelCase" }, "who": { "type": "Who", "doc": "self (default) or target: the one inside targets(), when the wearer may hit them" }, "required": { "type": "boolean | { missCooldown?: number }", "doc": "nothing handed (a permanent item already carried, an item not registered, nobody to hand it to): the rest of the list is called off, and the press costs missCooldown of the cooldown (0 with true)" } } }, "thematic:disarm": { "doc": "Takes whatever is in both of a body's hands away -- inside targets(), the target's. What is taken lands on the floor, where a vanilla sword can be picked back up and a granted construct is discarded as any dropped one is.", "fields": { "who": { "type": "Who", "doc": "target (default: the one inside targets()) or self" }, "drop": { "type": "boolean", "doc": "drops it on the floor (true); false stows a player's in their own inventory off the hotbar, the floor when that is full" }, "lock": { "type": "Amount", "doc": "seconds what a player lost stays on their item cooldown, the sweep they see over it, e.g. tuned(\"disarm_lock\") (none)" } } }, "thematic:take_item": { "doc": "Takes up to count of an item out of the wearer's inventory, from the first stack of it found: an offering the move asks for. Nothing carried: nothing happens.", "fields": { "item": { "type": "string", "required": true, "doc": "an item id, or \"#ns:tag\" (a bare id is minecraft's)" }, "count": { "type": "number", "doc": "how many (1)" } } }, "thematic:console_open": { "doc": "Opens the wearer's command console for an ability, in a mode (a pick mode of its own, e.g. \"strike\"). Run from a press, it is how one ability's key opens another's console.", "fields": { "ability": { "type": "string", "doc": "the ability whose console opens; left out, the one running this" }, "mode": { "type": "string", "doc": "\"overlay\", \"desktop\" or a mode widget's id; left out, the console's default mode" } } }, "thematic:console_close": { "doc": "Closes the wearer's open command console.", "fields": { "ability": { "type": "string", "doc": "left out, whichever is open" } } }, "thematic:delay_pickups": { "doc": "Holds the dropped items around the wearer out of reach: each one's pickup delay is set to seconds, so the wearer walks through them. Run it from every() to keep them off while a phase lasts; it runs out by itself after: every(e => e.delayPickups({ radius: 2, seconds: 0.5 })).", "fields": { "radius": { "type": "number", "doc": "how far out from the wearer's box, in blocks (2)" }, "seconds": { "type": "number", "doc": "the pickup delay the items are held at (0.5)" } } }, "thematic:eject_from_blocks": { "doc": "Lifts the wearer out of any block they are standing inside, straight up a block at a time, at most up blocks -- and leaves them where they are if none of those is clear. For a body going solid again where it may be inside a wall.", "fields": { "up": { "type": "number", "doc": "the most whole blocks it lifts them (4)" } } }, "thematic:calm": { "doc": "Takes a mob's grudge away, inside targets(): it forgets who it was after and stops attacking; with stop, it also stops walking and stands where it is. A player is not a mob and is left alone -- hold one with effects.", "fields": { "stop": { "type": "boolean", "doc": "also stops its path and its motion, once (false)" }, "hostile_only": { "type": "boolean", "doc": "only hostile mobs; the neutral and the tame keep their target (false)" } } }, "thematic:provoke": { "doc": "Sets a mob on something, inside targets(): one of the wearer's own bodies of the entity type within range (a decoy: an illusion, a summon), or the wearer when entity is left out (a classic taunt). A player is untouched -- turn them with lookAt.", "fields": { "entity": { "type": "string", "doc": "the type id of the wearer's own body to set it on; left out, the wearer" }, "within": { "type": "number", "doc": "blocks around the wearer to look for one (16)" }, "pick": { "type": "\"nearest\" | \"random\"", "doc": "which of them: the nearest to the mob, or any (nearest)" } } }, "thematic:notify": { "doc": "A message on a player's action bar, for them alone: how the move went, to the wearer, or what it did, to the one aimed at. A mob is told nothing.", "fields": { "message": { "type": "string", "required": true, "doc": "a translation key, e.g. \"message.thematic.dracula.eyes_averted\"; text no translation has is shown as written" }, "color": { "type": "Formatting", "doc": "the colour of the whole line, e.g. \"red\" (none)" }, "who": { "type": "\"self\" | \"target\"", "doc": "whose action bar: the wearer's (default), or the one aimed at's -- inside targets(), or an item's on_hit victim" }, "chat": { "type": "boolean", "doc": "in their chat instead of on the action bar, still for them alone (false)" }, "decimals": { "type": "number", "doc": "places the numbers in args are rounded to, trailing zeros dropped (2)" }, "args": { "type": "(string | number | Amount)[]", "doc": "what fills the line's %s in order: \"owner_name\" and \"target_name\" are those bodies' names, \"target_distance\" how many whole blocks off the one aimed at is and \"target_compass\" the compass point it lies toward (north, northeast...), a number or a worked-out one ({ tuned: \"damage\" }) is shown whole when it is, and any other text is shown as written" } } }, "thematic:pocket": { "doc": "Sends the owner into a pocket dimension, or back out of the one they are in, to where they left it.", "fields": { "mode": { "type": "\"enter\" | \"exit\"", "doc": "which way (exit)" }, "pocket": { "type": "string", "doc": "the pocket to enter, e.g. \"thematic:quantum_realm\"; needed for enter" } } }, "thematic:assemble": { "doc": "Swaps the parts of a multiblock the block belongs to for its assembled blocks, with a spray of particles; nothing when the parts are not all there.", "fields": { "multiblock": { "type": "string", "doc": "the multiblock's id, e.g. \"thematic:quantum_tunnel\"" }, "incomplete": { "type": "string", "doc": "a translation key shown over the hotbar when the parts are not all there" } } }, "thematic:disassemble": { "doc": "Swaps an assembled multiblock the block belongs to back for the parts the player placed.", "fields": { "multiblock": { "type": "string", "doc": "the multiblock's id" } } }, "thematic:open_guide": { "doc": "Opens the guide book for the owner, at the front page or on one entry or category.", "fields": { "entry": { "type": "string", "doc": "an entry or category id, e.g. \"thematic:suits/superman\" (the front page)" } } }, "thematic:offline": { "doc": "Takes a player offline, a suit or system crash: they cannot fly (they fall normally) or use any move but a passive, sparks and smoke come off them, and their screen fills with static, until it runs out. A stronger crash replaces a weaker one. Never creative or spectator players; a mob is not affected.", "fields": { "ticks": { "type": "number", "doc": "how long, in ticks, capped by the server's configured maximum (60)" }, "intensity": { "type": "number", "doc": "how hard it hits, 0 to 1 (0.7)" }, "who": { "type": "\"self\" | \"target\" | \"owner\"", "doc": "whose body: the one the move runs for (default), the one aimed at or hit, or the owner of the body the move runs for -- a summon's summoner" }, "cause": { "type": "string", "doc": "a short word kept with the status (\"action\")" }, "direct": { "type": "boolean", "doc": "in a hurt or damaged reaction: ignore a hit a summon passed on to its owner, so only a hit that struck the body itself counts (false)" } } }, "thematic:loadout_cycle": { "doc": "Steps the wearer's selection along a loadout's row -- backward while they sneak -- through the slots their suit reaches and the free default, skipping empty ones, and names what it landed on. The row is the one the suit's loadout part for that inventory keeps; with none worn, nothing happens.", "fields": { "inventory": { "type": "string", "required": true, "doc": "the loadout's inventory, e.g. \"gadgets\"" } } }, "thematic:loadout_use": { "doc": "Uses the item selected in a loadout, as the item's own use would (a thrown gadget), and starts the ability's tuned cooldown when it did. With the free default or an item that is cooling down, the switch named by auto_swap (when on) moves on to the next item that is not; after a use it steps the selection on the same way.", "fields": { "inventory": { "type": "string", "required": true, "doc": "the loadout's inventory, e.g. \"gadgets\"" }, "auto_swap": { "type": "string", "doc": "the id of the ability's wheel switch that turns automatic swapping on; left out, it never swaps" } } }, "thematic:break_pattern": { "doc": "Breaks blocks: one, a plane, a cube, a vein, a tree and its leaves, or a line -- each one only where the wearer may break it (claims, spawn protection, protected worlds; mobGriefing for a mob). Unbreakable blocks are left.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "pattern": { "type": "BreakPattern", "doc": "what it breaks (single)" }, "radius": { "type": "number", "doc": "a plane's or a cube's reach from its centre: 1 is 3 across (1)" }, "orient": { "type": "PlaneOrient", "doc": "which way a plane lies (face) or a line runs (look)" }, "max": { "type": "number", "doc": "the most blocks a vein or tree breaks (64; a tree 256)" }, "leaves": { "type": "number", "doc": "a tree: leaves this far from each log are broken too (0)" }, "leaf_chance": { "type": "number", "doc": "a tree: the chance each of those leaves goes, 0 to 1 (1)" }, "drops": { "type": "BlockDrops", "doc": "what the blocks drop (normal)" }, "fortune": { "type": "number", "doc": "with drops: \"fortune\", the Fortune level (3)" }, "harvestable_only": { "type": "boolean", "doc": "only blocks the wearer could harvest -- the right tool for ore (false)" }, "wear_chance": { "type": "number", "doc": "the chance, 0 to 1, each broken block wears the stack the action runs for by 1; the stack breaking stops the rest (0)" }, "tool": { "type": "\"held\" | string | { nbt: { [key: string]: string | string[] }; fallback?: string }", "doc": "what it mines with, for the drops and harvestable_only: \"held\" -- the wearer's main-hand stack; an item id -- a fresh one of it; { nbt, fallback } -- the stack in either hand (main first) whose NBT holds each key (case and underscores aside) at one of its values, else a fresh fallback, else a bare hand. Left out, the stack the action runs for" }, "tool_wear": { "type": "boolean", "doc": "with tool: each block broken wears the tool as mining it by hand would (never for a creative player); the tool breaking stops the rest (false)" }, "length": { "type": "Amount", "doc": "a line: how many blocks past the start block it runs, rounded down, 1 to 64; left out, the tuned radius" }, "offset": { "type": "Amount", "doc": "a plane or a line: moved this many blocks along its direction (0)" }, "depth": { "type": "number", "doc": "a plane: how many planes deep it breaks, one behind the other along its direction (1)" }, "advance": { "type": "boolean", "doc": "a plane or a line: the start block and direction are found on its first run in the press and kept, and each later run goes one block further along -- a face mined deeper every beat (false)" }, "vein": { "type": "VeinKind", "doc": "a vein: what it is made of (corners)" }, "fall_through": { "type": "number", "doc": "where a block of the shape is air, the first block under it within this many is broken instead -- a floor under a slab gap (0)" }, "skip_block_entities": { "type": "boolean", "doc": "never breaks a block holding a block entity: a chest, a furnace, a spawner (false; a line ends there)" }, "drop_at": { "type": "DropsAt", "doc": "where the drops land (block)" }, "then": { "type": "ActionObject[]", "doc": "actions run once after, when it broke at least one block; the number broken is stored under count_key for them (and later steps) to read" }, "count_key": { "type": "string", "doc": "the name the number of blocks broken is stored under, read by stored(name) or $name (broken)" }, "filter": { "type": "string | string[]", "doc": "only these blocks: ids and #tags (any, left out)" }, "except": { "type": "string | string[]", "doc": "never these blocks: ids and #tags" }, "with_property": { "type": "string", "doc": "only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like" } } }, "thematic:place_blocks": { "doc": "Places a block in a shape, where the wearer may build and only over what it may replace.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "block": { "type": "string", "required": true, "doc": "the block id" }, "properties": { "type": "{ [property: string]: string }", "doc": "state properties to place it with, e.g. { layers: \"2\" }" }, "replace": { "type": "BlockReplace", "doc": "what it may take the place of (replaceable)" }, "chance": { "type": "number", "doc": "the chance each block is placed, 0 to 1 (1)" }, "lifespan": { "type": "number", "doc": "seconds after which each block placed turns back to air, if it is still there (0: stays)" }, "lasts": { "type": "Amount", "doc": "instead of lifespan: any worked-out number of seconds, e.g. the tuned duration" }, "schedule_tick": { "type": "number", "doc": "seconds after which each block placed is ticked -- a melt or decay clock (0: none)" }, "max": { "type": "number", "doc": "with a lifespan: at most this many of this ability's blocks stay for their wearer, the oldest taken back first (0: no cap)" }, "shape": { "type": "BlockShape", "doc": "which blocks around it (single)" }, "radius": { "type": "Amount", "doc": "a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius" }, "height": { "type": "number", "doc": "a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius)" }, "below": { "type": "number", "doc": "a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0)" }, "thickness": { "type": "number", "doc": "a ring: how many blocks thick its wall is, inward from the radius (1)" }, "top_radius": { "type": "Amount", "doc": "a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)" } } }, "thematic:transform_block": { "doc": "Turns blocks into others by a map -- water to ice, lava to obsidian, fire to air -- or into the block the answered event broke or used, keeping the properties both share (a log's axis), where the wearer may build.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "map": { "type": "{ [from: string]: string }", "doc": "what each block becomes: a block id or #tag to a block id; the first match wins. Needed unless to is given" }, "to": { "type": "\"event_block\"", "doc": "instead of a map: each block the filter takes becomes the block the answered event broke or used" }, "variant": { "type": "{ prefix: string; when: string }", "doc": "with to: which form of the event's block goes in, by name -- the one with prefix in front of its path where the block replaced is when (an id or #tag), the one without it elsewhere; a form that is not registered is the block as it is. E.g. { prefix: \"deepslate_\", when: \"minecraft:deepslate\" }" }, "pick": { "type": "TransformPick", "doc": "which of the blocks found it changes (all)" }, "only": { "type": "TransformOnly", "doc": "what else a block must be to change (any)" }, "revert_after": { "type": "number", "doc": "seconds after which each block changed goes back to what it was, if what was put there is still there -- a crust that melts back (0: stays)" }, "keep_properties": { "type": "boolean", "doc": "copy the properties both blocks share (true)" }, "shape": { "type": "BlockShape", "doc": "which blocks around it (single)" }, "radius": { "type": "Amount", "doc": "a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius" }, "height": { "type": "number", "doc": "a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius)" }, "below": { "type": "number", "doc": "a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0)" }, "thickness": { "type": "number", "doc": "a ring: how many blocks thick its wall is, inward from the radius (1)" }, "top_radius": { "type": "Amount", "doc": "a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)" }, "filter": { "type": "string | string[]", "doc": "which blocks may change (any, left out; needed with to)" }, "except": { "type": "string | string[]", "doc": "never these blocks: ids and #tags" }, "with_property": { "type": "string", "doc": "only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like" } } }, "thematic:place_layered_block": { "doc": "Adds a layer to a layered block (snow, ice sheets), or starts one on top of the block when that is something else -- only where the wearer may build, both on the block and above it.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "block": { "type": "string", "required": true, "doc": "the layered block's id" }, "property": { "type": "string", "doc": "its layer count property (layers)" }, "max": { "type": "number", "doc": "the most layers it stacks to (the property's highest)" }, "schedule_tick": { "type": "number", "doc": "seconds after which the block is ticked -- a melt clock (0: none)" } } }, "thematic:ignite_block": { "doc": "What fire does to a block it hits, where the wearer may build: a player's fire smelts what smelts, lights candles and campfires, melts ice and snow, and sets flame beside what burns; anyone else's only sets the flame beside the face.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" } } }, "thematic:place_fire": { "doc": "Places fire (soul fire on soul soil) in the air where fire can burn, where the wearer may build: in a shape around the block found, or in a line across the way the wearer faces.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit, with face): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "chance": { "type": "number", "doc": "the chance each block catches, 0 to 1 (1)" }, "lifespan": { "type": "number", "doc": "seconds after which the fire goes out, if it is still there (0: burns on)" }, "lasts": { "type": "Amount", "doc": "instead of lifespan: any worked-out number of seconds, e.g. the tuned duration" }, "block": { "type": "string", "doc": "this fire block (e.g. \"minecraft:soul_fire\") instead of the fire that suits the spot" }, "footing": { "type": "FireFooting", "doc": "where the fire may stand (any)" }, "line": { "type": "{ across?: FireAcross; halfWidth?: Amount }", "doc": "instead of a shape: a row across the way the wearer faces (across, facing), halfWidth (half_width in a file) blocks out to each side of the block found (rounded down; the tuned radius, left out) -- a wall of fire" }, "shape": { "type": "BlockShape", "doc": "which blocks around it (single)" }, "radius": { "type": "Amount", "doc": "a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius" }, "height": { "type": "number", "doc": "a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius)" }, "below": { "type": "number", "doc": "a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0)" }, "thickness": { "type": "number", "doc": "a ring: how many blocks thick its wall is, inward from the radius (1)" }, "top_radius": { "type": "Amount", "doc": "a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)" } } }, "thematic:light_area": { "doc": "Lights the air around a point for a while -- sent only to the players who can see it, so nothing in the world changes and nothing is left behind.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (pos): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "level": { "type": "number", "doc": "the light level, 0 to 15 (15)" }, "seconds": { "type": "Amount", "doc": "how long it stays lit; left out, the tuned duration" }, "shape": { "type": "BlockShape", "doc": "which blocks around it (circle)" }, "radius": { "type": "Amount", "doc": "a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius" }, "height": { "type": "number", "doc": "a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius)" }, "below": { "type": "number", "doc": "a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0)" }, "thickness": { "type": "number", "doc": "a ring: how many blocks thick its wall is, inward from the radius (1)" }, "top_radius": { "type": "Amount", "doc": "a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)" } } }, "thematic:power_block": { "doc": "Presses a block as the wearer would (a button, a lever, a door) when it answers a press; otherwise powers it, or lights it, for a moment. Only where the wearer may build.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "interact": { "type": "boolean", "doc": "a player presses it first, as with an empty hand (true)" }, "seconds": { "type": "number", "doc": "how long it stays powered or lit (1)" } } }, "thematic:sit": { "doc": "Seats the owner (a player) on the block as a seat block does: they ride the seat already there, or one spawned offset_y above the block's floor. Getting off, or any change to the block, stands them up. do runs once they sit.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "offset_y": { "type": "number", "doc": "how far above the block's floor a new seat is, in blocks (0; -0.2 sinks into the block)" }, "do": { "type": "ActionObject[]", "doc": "run once they sit" } } }, "thematic:drop_blocks": { "doc": "Drops one vanilla falling block from above a random point within radius of the block found, when that spot is open air. Without place it vanishes where it comes down and drops nothing; with place it lands as a block where the wearer may build, and vanishes elsewhere. on_land runs where it came down either way: the air it came down in, on top of the ground, is the hit block, its centre the point.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (self): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "blocks": { "type": "string | string[]", "required": true, "doc": "the block, or blocks to pick one from at random (name one twice to drop it twice as often)" }, "radius": { "type": "Amount", "doc": "how far from the point, sideways, it may fall: a random spot in that disc (0)" }, "above": { "type": "number", "doc": "how many blocks over the point it starts, at most 64 (0)" }, "place": { "type": "boolean", "doc": "it lands as a block, the vanilla way, where the wearer may build (false: it vanishes)" }, "on_land": { "type": "ActionObject[]", "doc": "actions where it came down: the lowest air at or under where it was last seen, within 6 blocks. There the spot is that point (targets with at: \"spot\" finds who it fell on); the press's stored numbers are not carried" } } }, "thematic:till": { "doc": "Tills the block: grass, dirt paths and dirt to farmland; coarse and rooted dirt to dirt.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "wear": { "type": "number", "doc": "durability the stack the action runs for loses when a block changed (0)" }, "sound": { "type": "boolean", "doc": "the tool's sound on each block changed (true)" }, "shape": { "type": "BlockShape", "doc": "which blocks around it (single)" }, "radius": { "type": "Amount", "doc": "a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius" }, "height": { "type": "number", "doc": "a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius)" }, "below": { "type": "number", "doc": "a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0)" }, "thickness": { "type": "number", "doc": "a ring: how many blocks thick its wall is, inward from the radius (1)" }, "top_radius": { "type": "Amount", "doc": "a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)" } } }, "thematic:flatten": { "doc": "Flattens the block into a path: grass, dirt, mycelium, podzol, rooted and coarse dirt. A block used from underneath is left alone.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "wear": { "type": "number", "doc": "durability the stack the action runs for loses when a block changed (0)" }, "sound": { "type": "boolean", "doc": "the tool's sound on each block changed (true)" }, "shape": { "type": "BlockShape", "doc": "which blocks around it (single)" }, "radius": { "type": "Amount", "doc": "a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius" }, "height": { "type": "number", "doc": "a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius)" }, "below": { "type": "number", "doc": "a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0)" }, "thickness": { "type": "number", "doc": "a ring: how many blocks thick its wall is, inward from the radius (1)" }, "top_radius": { "type": "Amount", "doc": "a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)" } } }, "thematic:strip": { "doc": "Strips a log or wood to its stripped form, keeping its axis: vanilla's, other mods' and Thematic's own.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "wear": { "type": "number", "doc": "durability the stack the action runs for loses when a block changed (0)" }, "sound": { "type": "boolean", "doc": "the tool's sound on each block changed (true)" }, "shape": { "type": "BlockShape", "doc": "which blocks around it (single)" }, "radius": { "type": "Amount", "doc": "a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius" }, "height": { "type": "number", "doc": "a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius)" }, "below": { "type": "number", "doc": "a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0)" }, "thickness": { "type": "number", "doc": "a ring: how many blocks thick its wall is, inward from the radius (1)" }, "top_radius": { "type": "Amount", "doc": "a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)" } } }, "thematic:trim_plant": { "doc": "Stops a growing stem (kelp, vines, weeping and twisting vines) from growing further, as shears do.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "wear": { "type": "number", "doc": "durability the stack the action runs for loses when a block changed (0)" }, "sound": { "type": "boolean", "doc": "the tool's sound on each block changed (true)" }, "shape": { "type": "BlockShape", "doc": "which blocks around it (single)" }, "radius": { "type": "Amount", "doc": "a circle's, ring's or box's reach sideways, rounded up, at most 16; left out, the tuned radius" }, "height": { "type": "number", "doc": "a circle or ring: how many layers it stacks going up (1); a box: how far it reaches up and down (the radius)" }, "below": { "type": "number", "doc": "a circle or ring: how many of its height layers go under the block found rather than above it -- height 7, below 3 is three layers down to three up (0)" }, "thickness": { "type": "number", "doc": "a ring: how many blocks thick its wall is, inward from the radius (1)" }, "top_radius": { "type": "Amount", "doc": "a ring: its radius at its highest layer; the wall widens (or narrows) evenly from radius at its lowest layer to this at its highest, a funnel (left out, a straight wall)" } } }, "thematic:shear": { "doc": "Shears the entity inside targets() -- a sheep, a mooshroom, a snow golem -- if it can be sheared.", "fields": { "wear": { "type": "number", "doc": "durability the stack the action runs for loses when it sheared (0)" }, "bonus": { "type": "[number, number]", "doc": "a sheep drops its wool again a random number of times, least to most, e.g. [1, 2]" } } }, "thematic:cycle_block_property": { "doc": "Steps one of the block's state properties to its next value (a door's facing, a rail's shape), or picks which one the next step turns. The pick is remembered per block in the stack the action runs for; with none picked, a facing, axis or side property goes first. Tells a player what changed, above the hotbar.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "mode": { "type": "PropertyCycleMode", "doc": "(auto)" }, "property": { "type": "string", "doc": "with mode: \"value\", always this property" }, "reverse": { "type": "boolean", "doc": "with value or select: step backward (false)" }, "exclude": { "type": "string[]", "doc": "properties it never touches ([\"age\", \"moisture\", \"stage\"]: stepping those force-ages crops and dries farmland)" }, "selection_key": { "type": "string", "doc": "the stack's compound the picks are kept in (selected_property)" }, "feedback": { "type": "boolean", "doc": "tell a player what changed (true)" }, "wear": { "type": "number", "doc": "durability the stack loses when it worked (0)" }, "sound": { "type": "boolean", "doc": "a click when it worked (true)" }, "filter": { "type": "string | string[]", "doc": "only these blocks: ids and #tags (any, left out)" }, "except": { "type": "string | string[]", "doc": "never these blocks: ids and #tags" }, "with_property": { "type": "string", "doc": "only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like" } } }, "thematic:pull": { "doc": "Draws the entity hit -- or, with radius, every living body within it but the owner -- toward a point: each pull adds strength along the line to it. Once, now; or with for, every tick from the next for that long, stopping when either end is gone or the body is within stop_within. Loose items too, with items.", "fields": { "toward": { "type": "PullToward", "doc": "owner (default), source, here or spot" }, "strength": { "type": "Amount", "doc": "velocity added per pull along the line (0.05); a harpoon's reel is 5" }, "radius": { "type": "Amount", "doc": "pulls every living body within this many blocks of the action but the owner -- friend and foe, as a magnet does; left out, only the entity hit" }, "for": { "type": "Amount", "doc": "seconds it keeps pulling, every tick from the next; left out, one pull now" }, "stop_within": { "type": "number", "doc": "with for: stops once the body is this close to what it is pulled to (0: never early)" }, "brake": { "type": "boolean", "doc": "with stop_within: on arriving, also drops the sideways speed the pull built up (false)" }, "jitter": { "type": "number", "doc": "up to this much more at random on each axis, every pull (0); a magnet's is 0.5" }, "anchor_height": { "type": "number", "doc": "the owner or source is pulled to at this share of its eye height (0: its feet)" }, "max_rise": { "type": "number", "doc": "the most upward speed (blocks a tick) the pull gives the body: its lift is trimmed so the reel never carries it up past this, however long it runs (left out: no cap)" }, "point": { "type": "PullPoint", "doc": "the point of the body pulled from, feet (default) or center" }, "beam": { "type": "PullBeam", "doc": "a beam drawn from the point to the body on each pull" }, "items": { "type": "{ radius: Amount; strength?: number; pickup_within?: number }", "doc": "also drags loose items within radius (a magnet's is { tuned: \"radius\", times: 12 }) by strength (0.2), and gives a player owner any that come within pickup_within of the point (0: none)" } } }, "thematic:stack_effect": { "doc": "A status effect that builds up: put on fresh when the body has none, otherwise the running one grows longer -- and stronger, by steps or by levels of length -- and every client is told.", "fields": { "effect": { "type": "string", "required": true, "doc": "the status effect id, e.g. \"thematic:frozen\"" }, "who": { "type": "Who", "doc": "target (default: the entity hit, or the one inside targets()) or self" }, "duration": { "type": "Amount", "doc": "fresh: seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "Amount", "doc": "fresh: 0 is level I; left out, the tuned amplifier" }, "add": { "type": "Amount", "doc": "running: seconds added (0)" }, "add_random": { "type": "number", "doc": "running: up to this many seconds more at random, drawn in whole ticks (0)" }, "max_duration": { "type": "number", "doc": "running: the longest it grows to, in seconds" }, "amplifier_add": { "type": "number", "doc": "running: added to its amplifier (0)" }, "max_amplifier": { "type": "number", "doc": "running: the highest amplifier amplifier_add reaches" }, "levels": { "type": "{ at_least: number; amplifier: number }[]", "doc": "running: the amplifier from the new length instead -- the highest step whose at_least (seconds) it reaches; none reached keeps the running one" }, "by": { "type": "number", "doc": "levels this gain adds, whole, 1 or more; the effect's own \"stack\" ({ max_level, hold }) supplies the cap and the clock, so it replaces duration, amplifier, add, amplifier_add, max_amplifier, max_duration and levels" }, "hold": { "type": "number", "doc": "with by: seconds this gain holds the effect, instead of the effect's stack.hold" }, "gain_every": { "type": "number", "doc": "running: seconds between the level rising on one body; hits in between still put the length back but add no level (0: every hit adds)" }, "gain_clock": { "type": "string", "doc": "the name of that clock; stacks sharing a name share it (the effect's id)" }, "gain_shared": { "type": "string", "doc": "who shares the clock on one body: owner_group (default: the owner and everything it owns, so a hive's five beams gain once), source or anyone" }, "ambient": { "type": "boolean", "doc": "the faint beacon-style swirl (false)" }, "show_particles": { "type": "boolean", "doc": "false hides the effect's particles (true)" }, "show_icon": { "type": "boolean", "doc": "false hides the HUD icon (true; off for a stacking effect the HUD's readout shows)" } } }, "thematic:air": { "doc": "Adds breath to a body, or takes it: a drowning hit.", "fields": { "amount": { "type": "Amount", "doc": "ticks of breath added; negative takes (-1)" }, "who": { "type": "Who", "doc": "target (default) or self" } } }, "thematic:press_random_ability": { "doc": "Presses one of a player's own moves for them, at random: any that could be pressed now, never an ultimate unless ultimates says so. A toggle picked is switched on.", "fields": { "who": { "type": "Who", "doc": "target (default: the player hit) or self" }, "ultimates": { "type": "boolean", "doc": "ultimates may be picked too (false)" }, "skip_running": { "type": "boolean", "doc": "leaves out a move already running (false)" } } }, "thematic:command_pets": { "doc": "Every animal tamed to the owner within range stands up and obeys: attacks the entity hit, rallies where the action happens, or comes back to the owner.", "fields": { "command": { "type": "PetCommand", "required": true, "doc": "attack, rally or recall" }, "range": { "type": "number", "doc": "how far from the owner an animal still hears it, in blocks (48)" }, "entity_type": { "type": "string", "doc": "only animals of this type, e.g. \"minecraft:wolf\"" }, "tag": { "type": "string", "doc": "only animals carrying this command tag" }, "speed": { "type": "number", "doc": "how fast they go (1.3 to rally, 1.2 to recall)" }, "do": { "type": "ActionObject[]", "doc": "more at each animal, as inside targets()" } } }, "thematic:glow_mark": { "doc": "Marks the entity hit -- or everyone within radius but the owner and the owner's animals -- in the owner's name, for a time, with a glow: an expiry and the owner's UUID in the body's persistent data. The mark verb (thematic:mark) under its first name; only its owner key's default differs.", "fields": { "key": { "type": "string", "doc": "the persistent data key the mark's expiry is kept under (\"mark\")" }, "owner_key": { "type": "string", "doc": "the key the owner's UUID is kept under (_owner)" }, "for": { "type": "Amount", "doc": "seconds; left out, the ability's tuned duration" }, "keep_longer": { "type": "boolean", "doc": "never shortens a mark already there (false)" }, "glow": { "type": "boolean", "doc": "a hidden Glowing effect as long as the mark (true)" }, "seen_by": { "type": "\"all\" | \"owner\"", "doc": "who sees the glow: everyone (\"all\"), or the owner alone, through walls (\"owner\")" }, "vfx": { "type": "string", "doc": "a VFX preset played at the body's feet, sized to it, when the mark is new" }, "radius": { "type": "Amount", "doc": "marks everyone in this box around the action; left out, only the entity hit" } } }, "thematic:deflect_projectile": { "doc": "Turns a projectile back -- the entity hit, or the one a projectile_incoming reaction answers -- and makes it the wearer's.", "fields": { "direction": { "type": "DeflectDirection", "doc": "reverse (default), look or shooter" }, "own": { "type": "boolean", "doc": "the wearer becomes its owner, so what it hits on the way back is theirs (true)" } } }, "thematic:catch_projectile": { "doc": "Takes a projectile -- the entity hit, or the one a projectile_incoming reaction answers -- out of the world; an arrow or spectral arrow that could be picked up goes into the wearer's inventory.", "fields": { "give": { "type": "boolean", "doc": "hand over the arrow item when it could be picked up (true)" } } }, "thematic:absorb_projectiles": { "doc": "Takes every projectile within reach of the wearer's middle out of the world -- and one that would cross into it before the next tick, so a fast bullet doesn't slip through -- unless the wearer or a teammate shot it; clients see where each was absorbed, so a shield there ripples. Run every tick for a wall projectiles don't get through.", "fields": { "within": { "type": "number", "doc": "how far from the wearer's middle, in blocks (2)" }, "pane": { "type": "AbsorbPane", "doc": "a flat plate instead of the sphere: it takes projectiles that cross it from either face" } } }, "thematic:reset_fall_distance": { "doc": "A body forgets how far it has fallen, so its landing does not hurt.", "fields": { "who": { "type": "Who", "doc": "self (default) or target" } } }, "thematic:capture_entity": { "doc": "Stores the entity hit in the owner's holder item and removes it from the world. Never a player or the owner; where the owner may not grief it is refused with a message. Resets the item's cooldown.", "fields": { "item": { "type": "string", "doc": "the holder item's id; left out, the item that fired (a net arrow's own)" }, "inventories": { "type": "string[]", "doc": "the owner's inventories searched after the hands, in order, before the main inventory ([\"quiver\", \"gadgets\"])" }, "key": { "type": "string", "doc": "the NBT key the entity is kept under in the holder (\"StoredEntity\")" }, "when_full": { "type": "CaptureWhenFull", "doc": "nothing (default) or release" }, "discard_source": { "type": "boolean", "doc": "also removes what did it -- the arrow -- when something was caught or let out (false)" }, "deny_message": { "type": "string", "doc": "the translation key shown on the owner's action bar when they may not capture there (\"message.thematic.cant_capture\")" } } }, "thematic:release_entity": { "doc": "Lets the entity the owner's holder item stores out where the action happens, and empties it.", "fields": { "item": { "type": "string", "doc": "the holder item's id; left out, the item that fired (a net arrow's own)" }, "inventories": { "type": "string[]", "doc": "the owner's inventories searched after the hands, in order, before the main inventory ([\"quiver\", \"gadgets\"])" }, "key": { "type": "string", "doc": "the NBT key the entity is kept under in the holder (\"StoredEntity\")" }, "up": { "type": "number", "doc": "blocks above where the action happens (0); 1 on a block hit stands it on the block" }, "discard_source": { "type": "boolean", "doc": "also removes what did it -- the arrow -- when something was caught or let out (false)" } } }, "thematic:throw_held": { "doc": "Throws the stack the actions run for (an item hook's), else the owner's main-hand item from the owner's eyes along their look, as a throwables definition or an entity, and takes what it threw from the stack outside creative: one, or with count a fan of several at once. Its do runs aimed at each thing thrown.", "fields": { "throwable": { "type": "string", "doc": "a throwables id it flies as; or entity" }, "entity": { "type": "string", "doc": "an entity type id it flies as; or throwable" }, "velocity": { "type": "number", "doc": "launch speed (2)" }, "divergence": { "type": "number", "doc": "vanilla's spread (0.5)" }, "consume": { "type": "boolean", "doc": "takes what it threw from the stack outside creative (true)" }, "sound": { "type": "string", "doc": "a sound played as it leaves, once however many are thrown" }, "count": { "type": "number | { from_stack: true, max?: number }", "doc": "how many at once (1): a number, or as many as the stack holds up to max (the thrown cards: { from_stack: true, max: 3 })" }, "spread": { "type": "number", "doc": "with more than one: the degrees the outermost throws turn off the look, the rest even between (10: three at -10, 0 and 10)" }, "clip": { "type": "string | { right?: string, left?: string }", "doc": "the thrower's clip as it throws (players): one for either arm, or by the arm the stack is in -- right for a stack in the right hand, left for the left" }, "do": { "type": "ActionObject[]", "doc": "run aimed at each thrown entity" } } }, "thematic:stop_using": { "doc": "The body lets go of the item it is using, as a released key does (the item's release runs): a drill out of charge stops. Nothing when it is using none.", "fields": { "who": { "type": "\"self\" | \"target\"", "doc": "the owner (default), or the one aimed at" } } }, "thematic:riptide": { "doc": "Launches the owner (a player) as a Riptide trident does, and puts the stack's item on cooldown.", "fields": { "level": { "type": "number", "doc": "the Riptide level: 1 to 3 as vanilla's, stronger above; left out, the stack's own Riptide, else 3" }, "keep_horizontal": { "type": "boolean", "doc": "pushes along the heading without the pitch shortening it, as Aquaman's trident did (false)" }, "cooldown": { "type": "number", "doc": "seconds the item cools down after (2)" } } }, "thematic:enchant_held": { "doc": "Keeps enchantments on the stack the actions run for (an item hook's), else the owner's main-hand item: when it lacks one (or has it at another level) they are put on, after taking every other enchantment off unless replace is false.", "fields": { "enchantments": { "type": "Record", "required": true, "doc": "enchantment ids and levels, e.g. { \"minecraft:sharpness\": 8 }" }, "when": { "type": "Guard", "doc": "picks enchantments when it holds, otherwise when it does not" }, "otherwise": { "type": "Record", "doc": "with when: the enchantments while the guard fails" }, "replace": { "type": "boolean", "doc": "takes the stack's other enchantments off first (true)" } } }, "thematic:item_cooldown": { "doc": "Puts an item on the owner's cooldown, as an ender pearl is: the stack's, or item.", "fields": { "seconds": { "type": "number", "required": true, "doc": "how long" }, "item": { "type": "string", "doc": "another item id to cool down instead" } } }, "thematic:trigger_item_anim": { "doc": "Plays a triggerable GeckoLib clip on the stack the actions run for (an item hook's), else the owner's main-hand item, for every client.", "fields": { "controller": { "type": "string", "required": true, "doc": "the controller's name, e.g. \"Hammer\"" }, "clip": { "type": "string", "required": true, "doc": "the clip's trigger name, e.g. \"twirl\"" }, "hand": { "type": "Hand", "doc": "with no stack of the hook's own: main (default) or off" } } }, "thematic:use_ability": { "doc": "Presses one of the owner's kit abilities by id, as its key would: a press presses, a toggle flips, a hold starts. A disabled or dampened ability is refused as the key is.", "fields": { "ability": { "type": "string", "required": true, "doc": "the ability id, e.g. \"hammer_throw\"" } } }, "thematic:wear": { "doc": "Takes durability off the stack the actions run for (an item hook's), else the owner's main-hand item, breaking it with the usual sound when it runs out.", "fields": { "amount": { "type": "number", "doc": "(1)" } } }, "thematic:stack_strike": { "doc": "A stack strikes the target inside targets(), or what a thrown body hit: the item's own hit (a data construct's on_hit), then the main-hand attack damage its modifiers add, as the owner's mob attack. The stack is the one a thrown body carries (thrown_item, or a projectile that carries one), else the stack the actions run for (an item hook's), else the owner's main-hand item.", "fields": {} }, "thematic:consume_gauge": { "doc": "Spends an ability's charge (a lantern's power): do runs when there was enough, else when there was not (and nothing is spent).", "fields": { "amount": { "type": "number", "required": true, "doc": "how much" }, "ability": { "type": "string", "doc": "the charge ability's id; left out, the first charge ability of the owner's kit" }, "do": { "type": "ActionObject[]", "doc": "run when it was spent" }, "else": { "type": "ActionObject[]", "doc": "run when there was not enough" } } }, "thematic:refill_gauge": { "doc": "Fills an ability's charge (a lantern's power) back up to its most, as a power battery does; the charge tells the player how it went. do runs when it filled, else when it was already full or there was no charge.", "fields": { "ability": { "type": "string", "doc": "the charge ability's id; left out, the first charge ability of the owner's kit" }, "do": { "type": "ActionObject[]", "doc": "run when it filled" }, "else": { "type": "ActionObject[]", "doc": "run when it was full, or there was no charge" } } }, "thematic:take_held": { "doc": "Takes some of what the owner holds, outside creative: the ingredient a block is repaired with. Nothing when the hand is empty.", "fields": { "count": { "type": "number", "doc": "how many (1); a smaller stack gives what it has" }, "hand": { "type": "\"main\" | \"off\"", "doc": "the hand it takes from (main)" } } }, "thematic:stack_state": { "doc": "Changes one key of the stack the actions run for (an item hook's), else the owner's main-hand item's own state: its counters, flags, gauges and timers, which the guards stackCounter, stackFlag, stackGauge and stackTimer read.", "fields": { "key": { "type": "string", "required": true, "doc": "the name the value is kept under" }, "op": { "type": "StackStateOp", "required": true, "doc": "what to do to it" }, "value": { "type": "number", "doc": "add_counter / add_gauge: how much (1); set_counter / set_gauge: the value (0)" }, "wrap": { "type": "number", "doc": "add_counter: wraps back to 0 on reaching this (0: never)" }, "min": { "type": "number", "doc": "gauges: the lowest it goes (0)" }, "max": { "type": "number", "doc": "gauges: the highest it goes (no limit)" }, "seconds": { "type": "number", "doc": "start_timer: how long it runs" } } }, "thematic:wave": { "doc": "A ring spreading out from a centre over the ground, on the server's clock once it goes off: every `every` seconds, starting at once at radius 0, it runs do on everyone whose feet are within band of its front, measured straight from the centre, and no more than height above or below it -- while its radius is under maxRadius. Lightning Boom's ring: {from: \"self\", speed: 2.4, maxRadius: 96, band: 3, height: 2.125, once: false}. With along it is a front running out along a line instead, from the wearer's eyes (or the spot), out to maxRadius or the first block in the way, running do on everyone it passes within width of the line: Caped Colony's line of bats, {along: \"look\", speed: 0.8, maxRadius: 20, width: 1.2, vfx: \"thematic:bat_stream\"}.", "fields": { "from": { "type": "WaveFrom", "doc": "the centre (start); a line can't run from self" }, "along": { "type": "WaveAlong", "doc": "makes it a line running this way instead of a ring" }, "width": { "type": "Amount", "doc": "a line's reach either side of it, in blocks, from the edge of each body (1)" }, "vfx": { "type": "string", "doc": "a VFX preset carried with a line's front, or played at a ring's centre, for as long as the wave runs" }, "speed": { "type": "Amount", "doc": "blocks the front runs a tick (1)" }, "max_radius": { "type": "Amount", "doc": "it stops once its radius reaches this (the tuned radius)" }, "band": { "type": "number", "doc": "a ring's: how far inside or outside the front still counts, in blocks (1)" }, "height": { "type": "number", "doc": "a ring's: how far above or below the centre it reaches, in blocks (1)" }, "once": { "type": "boolean", "doc": "each body only the first time the front passes it (true)" }, "every": { "type": "number", "doc": "seconds between pulses (0.05: every tick)" }, "hittable": { "type": "boolean", "doc": "only those the wearer may hit (true)" }, "do": { "type": "ActionObject[]", "doc": "run on each one the front passes, aimed at them" } } }, "thematic:after": { "doc": "Runs do a little later, on the same context -- inside targets(), on the same target, which must still be alive then (unless survive), as must the wearer. Keeps running on the server's clock whatever the press does meanwhile.", "fields": { "seconds": { "type": "Amount", "required": true, "doc": "how long to wait" }, "survive": { "type": "boolean", "doc": "run even when the target has died by then (false)" }, "do": { "type": "ActionObject[]", "doc": "what to run once the time is up" } } }, "thematic:command": { "doc": "An order to the wearer's own mobs. Which of the wearer's mobs: select (owned: every mob tamed to them or naming them as its owner; companions: only the companion, tagged thematic_companion), types, tag and link narrow it, radius is how far from the wearer (48); with link, radius 0 finds the linked one wherever it is loaded in the wearer's world. else runs when attack finds nothing to go for, or when the wearer has none of those mobs: command(\"attack\", { at: [\"nearest_marked\", \"aimed\"], types: \"wolf\" }).", "fields": { "order": { "type": "CommandOrder", "required": true, "doc": "what they do" }, "at": { "type": "CommandAttackAt | CommandAttackAt[]", "doc": "attack, expend and use: what they go for, a list tried in order (target; expend and use left without it go for the target the action is aimed at, else their own)" }, "range": { "type": "Amount", "doc": "attack, expend and use: how far aimed and nearest_marked look (the tuned radius)" }, "seconds": { "type": "Amount", "doc": "gather and offline: how long it lasts (3)" }, "share": { "type": "Amount", "doc": "expend: the share of its own damage it goes off for (1)" }, "move": { "type": "string", "doc": "use: the id of the move it fires, one of its kit" }, "spread": { "type": "number", "doc": "use: how far off its target it aims, in degrees either way (0)" }, "idle_only": { "type": "boolean", "doc": "attack: only those not already fighting something alive (false: every one turns)" }, "mob": { "type": "\"aimed\"", "doc": "aimed: the one mob the action is aimed at takes the order -- each of the wearer's mobs inside ownedMobs(), a villager inside targets() -- instead of the ones the filter finds" }, "speed": { "type": "number", "doc": "follow, tempt and rally: how fast they go (1.2; tempt 1.25, rally 1.3)" }, "stop_at": { "type": "number", "doc": "follow and tempt: they stop this close to the wearer, in blocks (2; tempt 2.5)" }, "reach": { "type": "Amount", "doc": "fetch_items: how far from each mob a drop is noticed (the tuned radius)" }, "handover": { "type": "number", "doc": "fetch_items: a mob this close to the wearer hands over what it carries (6)" }, "carry": { "type": "number", "doc": "fetch_items: a drop this close to a mob counts as carried (2)" }, "pull": { "type": "number", "doc": "fetch_items: blocks a tick a drop is pulled toward its mob (0.35)" }, "beyond": { "type": "number", "doc": "fetch: how far off one has to be to be brought (40)" }, "select": { "type": "OwnedSelect", "doc": "which of the wearer's mobs (owned)" }, "types": { "type": "string | string[]", "doc": "only these entity types; \"#tag\" for a tag, a bare id is minecraft's" }, "tag": { "type": "string", "doc": "only those carrying this command tag (\"thematic_pack\")" }, "link": { "type": "string", "doc": "only the one whose id the wearer keeps under this data key" }, "radius": { "type": "Amount", "doc": "how far from the wearer they may be (48)" }, "else": { "type": "ActionObject[]", "doc": "what happens when there is nothing to go for or nobody to tell" } } }, "thematic:tame": { "doc": "Tames the target the action is aimed at to the wearer -- a wild wolf, cat or parrot, a horse -- healing it first. Anything already tamed, dead or that can't be tamed runs else instead.", "fields": { "heal": { "type": "Amount", "doc": "health it gets back first (0)" }, "else": { "type": "ActionObject[]", "doc": "what happens when it can't be tamed" } } }, "thematic:breed": { "doc": "Puts the target the action is aimed at into love mode for the wearer, as if fed its food: a grown animal that is ready to breed, then runs do. A young one, one already in love or cooling off, or anything else runs else instead.", "fields": { "do": { "type": "ActionObject[]", "doc": "what happens once it is in love" }, "else": { "type": "ActionObject[]", "doc": "what happens when it can't breed" } } }, "thematic:attract": { "doc": "Draws what lies within radius toward the wearer: items and experience through the air, to be picked up; animals walk over, unless already walking somewhere.", "fields": { "kind": { "type": "AttractKind", "required": true, "doc": "what it draws" }, "filter": { "type": "string | string[]", "doc": "items: item ids or \"#tag\"s; animals: entity type ids or \"#tag\"s (everything)" }, "radius": { "type": "Amount", "doc": "how far (the tuned radius)" }, "speed": { "type": "number", "doc": "items and xp: blocks a tick they're pulled (0.35); animals: how fast they walk (1.25)" }, "settle": { "type": "number", "doc": "left alone this close to the wearer, in blocks (1.5; animals 2.5)" }, "babies": { "type": "boolean", "doc": "animals: young ones come too (false)" } } }, "thematic:owned_mobs": { "doc": "Runs do at each of the wearer's own mobs, aimed at it as targets() aims at each one it picks -- buffs for the pack, a heal for the companion -- or else once when there are none: ownedMobs(\"owned\", { types: \"wolf\" }, wolf => wolf.effect(\"minecraft:strength\", { duration: 1.5, amplifier: 1 })). Which of the wearer's mobs: select (owned: every mob tamed to them or naming them as its owner; companions: only the companion, tagged thematic_companion), types, tag and link narrow it, radius is how far from the wearer (48); with link, radius 0 finds the linked one wherever it is loaded in the wearer's world.", "fields": { "select": { "type": "OwnedSelect", "doc": "which of the wearer's mobs: owned or companions" }, "types": { "type": "string | string[]", "doc": "only these entity types; \"#tag\" for a tag, a bare id is minecraft's" }, "tag": { "type": "string", "doc": "only those carrying this command tag (\"thematic_pack\")" }, "link": { "type": "string", "doc": "only the one whose id the wearer keeps under this data key" }, "radius": { "type": "Amount", "doc": "how far from the wearer they may be (48)" }, "pick": { "type": "TargetPick", "doc": "which of them: all, nearest, first or random (all)" }, "do": { "type": "ActionObject[]", "doc": "what happens at each one, aimed at it" }, "else": { "type": "ActionObject[]", "doc": "what happens once when the wearer has none" } } }, "thematic:unlink": { "doc": "The wearer forgets the id kept under a link key -- a summon's link -- whether or not the mob is still there: what a companion's death leaves to tidy.", "fields": { "key": { "type": "string", "required": true, "doc": "the data key, e.g. \"companion_wolf_uuid\"" } } }, "thematic:quarry": { "doc": "Breaks the matching blocks around a point, working outwards -- each only if the wearer's own tool could harvest it (a mob: only blocks that need no tool) and they may break it there -- and drops what they held at the wearer's feet. Extra Fortune goes on a copy of the held tool; the real one is not touched.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (self): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "radius": { "type": "Amount", "doc": "how far out it reaches, rounded, at most 32; left out, the tuned radius" }, "max": { "type": "number", "doc": "the most blocks it takes (64)" }, "fortune": { "type": "Amount", "doc": "Fortune levels added to the tool for the drops (0)" }, "filter": { "type": "string | string[]", "doc": "the blocks it takes (#thematic:quarry_ores, left out)" }, "except": { "type": "string | string[]", "doc": "never these blocks: ids and #tags" }, "with_property": { "type": "string", "doc": "only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like" } } }, "thematic:find_block": { "doc": "Finds the matching block nearest the point, in the cube radius around it: fixes it as the spot (at: \"spot\" later in the same press), stores it under key for a visual, and tells the wearer with notify. do runs at each matching block, working outwards. Nothing found: nothing happens, and required calls the list off.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (self): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "radius": { "type": "Amount", "doc": "how far out it looks, rounded, at most 32; left out, the tuned radius" }, "max": { "type": "number", "doc": "the most blocks do runs at (64)" }, "do": { "type": "ActionObject[]", "doc": "actions at each matching block: the block is the hit, its centre the point" }, "key": { "type": "string", "doc": "store the block's centre on the wearer, synced, under this key (as markSpot does)" }, "required": { "type": "boolean | { miss_cooldown?: number }", "doc": "nothing found calls the rest of the list off; miss_cooldown is the share of the cooldown that still costs" }, "notify": { "type": "{ message: string; color?: string }", "doc": "a line on the wearer's action bar: a translation key or plain text, with %1$s the block's name and %2$s the compass word (north, northeast, ...) toward it" }, "all": { "type": "boolean", "doc": "a sweep, not a search: do runs at every matching block in the cube, however many, and nothing is fixed as the spot, stored or told -- a glow on every ore in reach (false; takes no max, key, required or notify)" }, "filter": { "type": "string | string[]", "required": true, "doc": "what it looks for: block ids and #tags" }, "except": { "type": "string | string[]", "doc": "never these blocks: ids and #tags" }, "with_property": { "type": "string", "doc": "only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like" } } }, "thematic:replant": { "doc": "A grown crop that was just broken goes back as a seedling, paid for with one of its own seeds from the drops lying around it, where the wearer may build. Answers block_broken; outside it, the block hit.", "fields": { "radius": { "type": "number", "doc": "how far around the block the drops are looked for (1.5)" }, "filter": { "type": "string | string[]", "doc": "the blocks it replants (every crop, nether wart and cocoa, left out); with a filter, any matching block with an age, grown at its highest" }, "except": { "type": "string | string[]", "doc": "never these blocks: ids and #tags" }, "with_property": { "type": "string", "doc": "only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like" } } }, "thematic:collect_drops": { "doc": "Brings the items lying around the block -- the event's, or the block hit -- to the wearer's feet (or the spot), still, ready to be picked up at once.", "fields": { "radius": { "type": "number", "doc": "how far around the block the items are looked for (1.5)" }, "to": { "type": "CollectTo", "doc": "where they go (wearer)" } } }, "thematic:extra_drops": { "doc": "Rolls the block's drops again -- the block the event broke, or the block hit -- with the wearer's main-hand tool, for more of them where it stood.", "fields": { "rolls": { "type": "Amount", "doc": "how many more times it drops (1)" }, "above_same": { "type": "boolean", "doc": "only a block that stood on the same block pays: the part of a stalk (sugar cane, bamboo) that grew, not the planted base (false)" }, "filter": { "type": "string | string[]", "doc": "only these blocks (any, left out)" }, "except": { "type": "string | string[]", "doc": "never these blocks: ids and #tags" }, "with_property": { "type": "string", "doc": "only blocks with a state property of this name, e.g. \"axis\" for anything pillar-like" } } }, "thematic:use_item_on": { "doc": "Uses an item on a block as if the wearer held one -- bone meal grows what it grows, flint and steel lights what it lights -- where they may build. The held stack is not touched.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (look): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "item": { "type": "string", "required": true, "doc": "the item id" }, "consume": { "type": "boolean", "doc": "a use that took calls off the use_block it answers, so the block and the held item don't react too (true)" } } }, "thematic:light_trail": { "doc": "One tick of a trail of light following the wearer: a light in the air where they stand (or the nearest air), a new one each time they move on, the newest few kept, each gone lasts seconds after it was put down. Sent only to the players who can see it; nothing in the world changes. Run it every tick while it should glow, and with stop once it should not.", "fields": { "level": { "type": "number", "doc": "the light level, 0 to 15 (15)" }, "max": { "type": "number", "doc": "the most lights kept at once; the oldest goes first (6)" }, "lasts": { "type": "number", "doc": "seconds each light stays after it was put down (4.5)" }, "stop": { "type": "boolean", "doc": "take every light down now, and forget the trail (false)" } } }, "thematic:meter": { "doc": "One change to a meter kept on the wearer (declared by a meter part; a key nothing declared is a plain amount with no cap): add, consume (a spend, only when what is left keeps the reserve), cost (the same, but not being able to pay calls off the rest of the list), set, refill (to its max) -- or, for a window, open and close. A failed consume, cost or refill says fail_message. meter(\"green_ringCharge\", { cost: 40, failMessage: \"Not enough green!\", failChance: 0.05 }); meter(\"pact_momentum\", { open: { for: 1.5, onRefresh: \"bank\" } }).", "fields": { "key": { "type": "string", "required": true, "doc": "the meter's key" }, "add": { "type": "Amount", "doc": "added, up to its max; negative takes it away, to nothing" }, "consume": { "type": "Amount", "doc": "spent when it can be paid, keeping the reserve; a window is spent whole" }, "cost": { "type": "Amount", "doc": "as consume, and not being able to pay calls off the rest of the list" }, "set": { "type": "Amount", "doc": "set, between 0 and its max; a window: opened for that many seconds, or closed at 0" }, "refill": { "type": "boolean", "doc": "true: filled to its max; full already counts as failing" }, "open": { "type": "boolean | MeterOpen", "doc": "a window: opened, or -- already open -- banked, bled or refreshed as its on_refresh says" }, "close": { "type": "boolean", "doc": "true: a window dropped without spending it; an amount emptied" }, "who": { "type": "\"self\" | \"target\"", "doc": "whose meter: the wearer's (self), or the target the action is aimed at" }, "fail_message": { "type": "string", "doc": "said on the wearer's action bar when a consume, cost or refill fails: a translation key or text" }, "fail_chance": { "type": "number", "doc": "the share of failures that say it (1); a lantern ring said it one time in twenty" }, "color": { "type": "string", "doc": "the message's colour, a formatting name" } } }, "thematic:meter_spend": { "doc": "Spends a window whole -- the only way to, and it always closes -- and lets the openings banked into it as $charges (0 when nothing was open), for the rest of the list: meterSpend(\"pact_momentum\", { keepOwn: true }) then if({ ... }) on \"$charges\". Spend only after the move has committed, or a press that did nothing eats the window. An amount is spent down to its reserve, and $charges is what was taken.", "fields": { "key": { "type": "string", "required": true, "doc": "the meter's key" }, "store": { "type": "string", "doc": "the name what was spent is let as (charges)" }, "keep_own": { "type": "boolean", "doc": "true: a window this ability opened itself is left alone, and 0 is let (false)" }, "required": { "type": "boolean", "doc": "true: nothing to spend calls off the rest of the list (false)" } } }, "thematic:drive_meter": { "doc": "Run every tick: an amount meter fills over fill seconds while a watched move is active and drains at drain times that speed otherwise -- a cooldown that builds while a move runs. driveMeter(\"cooldown_fill\", { watchOption: \"watches\", fill: 5, endAtFull: true }).", "fields": { "key": { "type": "string", "required": true, "doc": "the meter's key (an amount)" }, "fill": { "type": "Amount", "required": true, "doc": "seconds a full run takes" }, "watch": { "type": "string", "doc": "the move whose active state drives it (this move)" }, "watch_option": { "type": "string", "doc": "instead, the suit option that names that move's id" }, "drain": { "type": "Amount", "doc": "how fast it drains while the move is off, as a multiple of the fill speed (1); 0 holds it" }, "end_at_full": { "type": "boolean", "doc": "true: a full meter switches the watched move off (false)" } } }, "thematic:vfx": { "doc": "Plays a VFX preset (a vfx/.json file) where the action happens: at the target inside targets(), the wearer otherwise. vfx(\"thematic:circle_ring\") plays it as the file says; to points it at somewhere and makes it as long as the gap (a ray, a blink's trail), direction points it a way keeping its own length, radius and height resize it. With a session it is held (a hold or loop preset) until vfx(id, { session, stop: true }). The old upper-case names work as ids (\"SONAR_BEAM\" is thematic:sonar_beam).", "fields": { "id": { "type": "string", "required": true, "doc": "the preset's id, e.g. \"thematic:dome\"" }, "at": { "type": "\"here\" | \"spot\"", "doc": "here (default): where the action happens; spot: the point markSpot fixed" }, "from": { "type": "Anchor", "doc": "a point on the wearer's body to start from instead" }, "forward": { "type": "number", "doc": "blocks along the wearer's look to move the start (0)" }, "anchor": { "type": "\"feet\" | \"body\" | number", "doc": "how high up the body it starts, as a fraction of its height (feet); not with from" }, "to": { "type": "\"wearer\" | \"target\" | \"spot\"", "doc": "points it from the start at the wearer's feet, the body the action is aimed at, or the marked spot, as long as the gap; nothing plays when there is no such place" }, "direction": { "type": "\"look\" | \"up\" | [number, number, number]", "doc": "points it along the wearer's look, straight up, or a fixed way, keeping the preset's length; not with to" }, "radius": { "type": "Amount", "doc": "replaces the preset's radius (blocks), a number or a worked-out one; left out, the preset's" }, "height": { "type": "Amount", "doc": "replaces the preset's height (blocks): an axial shape's length" }, "duration": { "type": "Amount", "doc": "replaces how long it hangs, in seconds (the preset's own, which its file gives in ticks); at least a tick: vfx(\"thematic:pyre_ring\", { radius: 8, duration: 1.2 }) for a bigger, slower ring" }, "session": { "type": "string", "doc": "holds the effect under this name, one per wearer, until a vfx with stop; a new start under the same name replaces it. A particle-system preset has no session and plays once" }, "stop": { "type": "boolean", "doc": "ends the effect held under session instead of playing anything" }, "layers": { "type": "Amount", "doc": "a fog_layers preset's bank count (replaces the preset's)" }, "wisps": { "type": "Amount", "doc": "a fog_layers preset's rising wisps (replaces the preset's)" }, "fade_in": { "type": "Amount", "doc": "a fog_layers preset's fade-in, in seconds (replaces the preset's)" }, "fade_out": { "type": "Amount", "doc": "a fog_layers preset's thinning-out, in seconds (replaces the preset's)" }, "hand": { "type": "\"right\" | \"left\"", "doc": "a rope preset only: the line starts at that fingertip of the wearer as the arm is posed this frame, running on to where it was thrown, instead of starting at the point" }, "follow": { "type": "\"wearer\" | \"target\"", "doc": "carries it along with the wearer or the body the action is aimed at, keeping its place beside them, while they are in sight; a bat_swarm flock heads the way they go" }, "color": { "type": "string", "doc": "replaces the preset's colour: \"#AARRGGBB\" (alpha first) or \"#RRGGBB\" (opaque), e.g. vfx(\"thematic:circle_ring\", { color: \"#999DB7FF\" }) for a pale blue-violet ring" }, "density": { "type": "Amount", "doc": "replaces the preset's density: its particles, a fractal_bolt's stretches, a fork_wall's bolts, a fork_burst's spokes (a quarter of it), a fork_cloud's puffs" } } }, "thematic:shake": { "doc": "Shakes the camera of every player within radius of where it happens -- the target inside targets(), the spot with at: \"spot\" -- easing out over duration, harder the nearer they stand (a quarter as hard at the edge): shake({ at: \"spot\", radius: 16, strength: 2, duration: 0.6 }) for a slam landing.", "fields": { "radius": { "type": "Amount", "doc": "blocks it reaches; left out, the tuned radius" }, "strength": { "type": "Amount", "doc": "degrees the view jolts at the centre (1.5)" }, "duration": { "type": "Amount", "doc": "seconds it takes to settle (0.5)" }, "at": { "type": "\"here\" | \"spot\"", "doc": "here (default): where the action happens; spot: the point markSpot fixed" }, "from": { "type": "Anchor", "doc": "a point on the wearer's body to centre it on instead" }, "forward": { "type": "number", "doc": "blocks along the wearer's look to move the centre (0)" }, "style": { "type": "ShakeStyle", "doc": "classic (default): the older jitter; trauma: smooth noise that swells with trauma squared and fades exponentially, yaw, pitch and roll plus a trace of drift; rumble: a long low swell in and out. Scaled by the player's Distortion Effects setting. With any of style, direction, kick or to, trauma is the default" }, "direction": { "type": "ShakeDirection", "doc": "none (default); away: also kicks the view away from where it happens, springing back; hit: for duration seconds (10) every hit the player takes kicks the view away from where it came from (nothing shakes now)" }, "kick": { "type": "Amount", "doc": "degrees of the direction kick (1.2 times strength)" }, "to": { "type": "ScreenTo", "doc": "shake only this player's screen, at full strength, instead of everyone within radius: the wearer, or the body the action is aimed at" } } }, "thematic:hitstop": { "doc": "A visual freeze of 30 to 120 ms, for a landed hit or a grab: the picture holds and then melts back, while the game itself keeps running (nothing is paused or delayed). At most one every quarter second.", "fields": { "duration": { "type": "Amount", "doc": "seconds, 0.03 to 0.12 (0.07)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:fov_punch": { "doc": "The field of view kicks by delta degrees and springs back, with no overshoot: negative narrows it (a grab, a pull in), positive widens it (a shockwave). Scaled by the player's FOV Effects setting.", "fields": { "delta": { "type": "Amount", "doc": "degrees, -25 to 25 (4)" }, "duration": { "type": "Amount", "doc": "seconds it takes to settle (0.45)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:screen_flash": { "doc": "A flash of colour over the screen that peaks at once and falls off exponentially in a few frames, never held and never fully opaque. Skipped for players who hide lightning flashes, and softened by the reduced-flash setting; at most three a second.", "fields": { "color": { "type": "number | string", "doc": "\"#RRGGBB\" or 0xRRGGBB (white); black makes a cut" }, "alpha": { "type": "Amount", "doc": "peak opacity, 0 to 0.85 (0.55)" }, "duration": { "type": "Amount", "doc": "seconds until it is gone, 0.05 to 0.4 (0.12)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:overlay": { "doc": "A texture, or a flat colour, laid over the screen for a while to one player, easing in and out and optionally throbbing. (The ability visual thematic:screen_overlay is the always-on-while-active form.)", "fields": { "texture": { "type": "string", "doc": "a texture id, e.g. \"thematic:textures/overlay/vignette.png\" (this or color is needed)" }, "color": { "type": "number | string", "doc": "a flat fill in this colour when there is no texture" }, "alpha": { "type": "Amount", "doc": "opacity at its fullest, 0 to 1 (0.5)" }, "duration": { "type": "Amount", "doc": "seconds in all, the fades included; 0 keeps it until screenClear() (2)" }, "fade_in": { "type": "Amount", "doc": "seconds easing in (0.25)" }, "fade_out": { "type": "Amount", "doc": "seconds easing out (0.6)" }, "pulse": { "type": "{ period?: number; min?: number; max?: number; shape?: \"sine\" | \"heartbeat\" }", "doc": "throbs between min and max (0.35, 1) times its opacity every period seconds (1.2, at least 0.6); heartbeat is a lub-dub" }, "blend": { "type": "OverlayBlend", "doc": "normal (default), or add to brighten what is behind it" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:grade": { "doc": "Grades the colour of the world -- not the HUD -- eased in and out: desaturate it, optionally keeping one hue in colour (grade({ keepHue: \"red\" }) for a grey world with red left in it), with contrast, a tint and lifted shadows. A new grade while one runs glides into it.", "fields": { "desaturate": { "type": "Amount", "doc": "0 to 1, how much colour is drained (0.6)" }, "keep_hue": { "type": "string | number", "doc": "a hue left in colour: red, orange, yellow, green, cyan, blue, purple, magenta, pink, a number of degrees or \"#RRGGBB\" (none)" }, "hue_width": { "type": "Amount", "doc": "degrees either side of keep_hue that stay in colour, edges softened (30)" }, "contrast": { "type": "Amount", "doc": "-0.5 flatter to 1 harder around mid grey (0)" }, "tint": { "type": "number | string", "doc": "a colour the picture is washed toward (none)" }, "tint_amount": { "type": "Amount", "doc": "0 to 1, how far toward tint (0.15)" }, "lift": { "type": "Amount", "doc": "0 to 0.3, how far the darkest parts are raised toward grey (in the tint's colour, when there is one) so shapes stay readable in the dark (0)" }, "duration": { "type": "Amount", "doc": "seconds in all, the fades included; 0 keeps it until screenClear() (3)" }, "fade_in": { "type": "Amount", "doc": "seconds easing in (0.8)" }, "fade_out": { "type": "Amount", "doc": "seconds easing out (1.2)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:letterbox": { "doc": "Black cinema bars at the top and bottom of the screen that ease in to a height and back out.", "fields": { "height": { "type": "Amount", "doc": "each bar's height as a share of the screen, 0 to 0.3 (0.11)" }, "duration": { "type": "Amount", "doc": "seconds in all, the fades included; 0 keeps them until screenClear() (3)" }, "fade_in": { "type": "Amount", "doc": "seconds easing in (0.7)" }, "fade_out": { "type": "Amount", "doc": "seconds easing out (0.7)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:fog": { "doc": "Closes the view in with fog to a distance, optionally toward a colour, eased in and out; never further out than the world's own fog, and left alone underwater and in lava. A new fog while one runs glides into it.", "fields": { "end": { "type": "Amount", "doc": "blocks where the fog is solid (20)" }, "start": { "type": "Amount", "doc": "blocks where it begins (a quarter of end)" }, "color": { "type": "number | string", "doc": "the fog's colour; left out, the world's own" }, "color_amount": { "type": "Amount", "doc": "0 to 1, how far the fog colour replaces the world's (0.8)" }, "duration": { "type": "Amount", "doc": "seconds in all, the fades included; 0 keeps it until screenClear() (3)" }, "fade_in": { "type": "Amount", "doc": "seconds easing in (1.5)" }, "fade_out": { "type": "Amount", "doc": "seconds easing out (2)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:muffle": { "doc": "Ducks the game's audio -- everything but interface sounds -- smoothly, as if heard through a wall. (A volume duck, not a filter.)", "fields": { "amount": { "type": "Amount", "doc": "0 to 0.88, the share of the volume taken away (0.6)" }, "duration": { "type": "Amount", "doc": "seconds in all, the fades included; 0 keeps it until screenClear() (3)" }, "fade_in": { "type": "Amount", "doc": "seconds easing in (0.25)" }, "fade_out": { "type": "Amount", "doc": "seconds easing out (0.8)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:film_grain": { "doc": "Animated film grain over the world, with optional scanlines and static. Slowed and softened for players with the reduced-flash setting.", "fields": { "amount": { "type": "Amount", "doc": "grain strength, 0 to 1 (0.25)" }, "scanlines": { "type": "Amount", "doc": "0 to 1 (0)" }, "static": { "type": "Amount", "doc": "0 to 1 (0)" }, "duration": { "type": "Amount", "doc": "seconds in all, the fades included; 0 keeps it until screenClear() (3)" }, "fade_in": { "type": "Amount", "doc": "seconds easing in (0.8)" }, "fade_out": { "type": "Amount", "doc": "seconds easing out (1)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:screen_look_at": { "doc": "Draws the player's look round to a point, smoothly, on their own client (no rotation packet from the server): it eases onto the point, holds there, and is let go. At strength 1 the player cannot turn away from it while it holds; below 1 the pull only takes the view that share of the way and lets their own turning through. Their look stays where it was drawn when it is let go. A new screen_look_at while one runs glides to the new point.", "fields": { "at": { "type": "LookAtPoint | { x: number; y: number; z: number }", "doc": "the point (anchor)" }, "up": { "type": "Amount", "doc": "blocks added above the point (0): the top of a block rather than its middle" }, "strength": { "type": "Amount", "doc": "0 to 1, how far the pull takes the view and how hard it holds (1)" }, "duration": { "type": "Amount", "doc": "seconds in all, the eases included; 0 keeps it until screenClear() (3)" }, "ease_in": { "type": "Amount", "doc": "seconds turning onto the point (0.8)" }, "hold": { "type": "Amount", "doc": "instead of duration: seconds held on the point, the eases added to make the total" }, "ease_out": { "type": "Amount", "doc": "seconds letting the player's own turning back in (0.8)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:cinematic_hud": { "doc": "Hides the whole HUD (hotbar, health, crosshair, boss bars, chat, effect icons, ability HUDs) like F1 for a cinematic beat, then restores it. The screen effects (bars, flashes, overlays, grade, grain) keep drawing. Ended by screenClear(), death or a disconnect.", "fields": { "duration": { "type": "Amount", "doc": "seconds in all, the fade included; 0 keeps it until screenClear() (3)" }, "fade": { "type": "Amount", "doc": "seconds the HUD stays hidden through at either end (0.4)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:disorient": { "doc": "A drunken sway of the view: the head rolls and nods slowly, the field of view breathes, and the sound goes dull (ringing), easing in and out. Softened for players with the reduced-flash setting.", "fields": { "amount": { "type": "Amount", "doc": "0 to 1, how far the view sways (0.7)" }, "muffle": { "type": "Amount", "doc": "0 to 0.88, how dull the sound goes; 0 leaves it to muffle() (0.8 times amount)" }, "duration": { "type": "Amount", "doc": "seconds in all, the fades included (3)" }, "fade_in": { "type": "Amount", "doc": "seconds easing in (0.3)" }, "fade_out": { "type": "Amount", "doc": "seconds easing out (1.2)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:screen_splat": { "doc": "Gobs of sticky mass flung onto one player's screen from its edges -- irregular blobs, thick in the middle, joined by stringy tendrils, heaviest across the lower half -- held, then sliding down in drips as they fade: a face full of webbing, goo or mud. Drawn, not a texture, and different every time.", "fields": { "color": { "type": "number | string", "doc": "\"#RRGGBB\" or 0xRRGGBB (0xF2F2EE, wet white)" }, "alpha": { "type": "Amount", "doc": "the gobs' opacity, 0 to 1 (0.95)" }, "coverage": { "type": "Amount", "doc": "how much of the screen they cover, 0.05 to 1 (0.7)" }, "count": { "type": "Amount", "doc": "how many gobs, 1 to 9 (6)" }, "duration": { "type": "Amount", "doc": "seconds held before they start to go (1)" }, "fade_out": { "type": "Amount", "doc": "seconds sliding and fading away (1.5)" }, "drip": { "type": "Amount", "doc": "how far they slide down as they go, 0 to 1 (0.6)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:screen_jolt": { "doc": "Jagged lines jolting in from one player's screen edges, flickering and re-jagging, pulsing a few times over its length and thickest on the side a threat lies: a sense of danger, a static shock. With from, it says where: screenJolt({ from: \"target\" }) inside a targets() body gathers them toward that body.", "fields": { "color": { "type": "number | string", "doc": "\"#RRGGBB\" or 0xRRGGBB (white)" }, "alpha": { "type": "Amount", "doc": "their opacity at the peak of a pulse, 0 to 1 (0.85)" }, "count": { "type": "Amount", "doc": "how many lines, 4 to 40 (18)" }, "reach": { "type": "Amount", "doc": "how far in from the edge they reach, as a share of the screen, 0.05 to 0.6 (0.22)" }, "duration": { "type": "Amount", "doc": "seconds in all (1)" }, "pulses": { "type": "Amount", "doc": "how many times they flare over the duration, 1 to 8 (2)" }, "from": { "type": "\"target\" | \"pos\"", "doc": "where they gather: the body the action is aimed at, or where it happens (every edge alike)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:screen_clear": { "doc": "Eases out a sustained screen effect early, or all of them (and any freeze) at once.", "fields": { "effect": { "type": "ScreenEffectName", "doc": "which one (all)" }, "fade": { "type": "Amount", "doc": "seconds to ease out (0.8)" }, "to": { "type": "ScreenTo", "doc": "whose screen: the wearer's (default), or the body the action is aimed at -- inside targets(), or an item's on_hit victim; \"targets\" is the same as \"target\". A mob has no screen" } } }, "thematic:drain": { "doc": "Wears a body's health down in steps, from what it is when this runs toward a floor, and never past it: direct health, no damage (no flinch, no armour), and never below half a heart, so it cannot kill. A body already at or under the floor is left alone. On a player each step throbs a red vignette. A second drain on the same body replaces the first.", "fields": { "to": { "type": "ScreenTo", "doc": "whose health: the wearer's (default), or the body the action is aimed at" }, "floor": { "type": "Amount", "doc": "display units, what the action bar shows (1000 is a full bar): the level it will not go under (100)" }, "duration": { "type": "Amount", "doc": "seconds from the start to the floor (6)" }, "every": { "type": "Amount", "doc": "seconds between steps (0.5)" }, "pulse": { "type": "boolean", "doc": "throb a red vignette with each step (true)" }, "stop": { "type": "boolean", "doc": "instead of draining, ends a drain already running on the body (false)" } } }, "thematic:book_pose": { "doc": "Eases the floating book of the mission's anchor block (the book visual) to a pose for the player it is aimed at, holds it, and eases it back to normal when the duration ends; a private run's book moves only for its participant. A new pose eases from whatever the book is showing.", "fields": { "to": { "type": "ScreenTo", "doc": "whose book: the body the action is aimed at (default), or the wearer's" }, "at": { "type": "string | { x: number, y: number, z: number }", "doc": "the book's block: \"anchor\" (default) or a point" }, "height": { "type": "Amount", "doc": "blocks above its resting height (0)" }, "spin": { "type": "Amount", "doc": "degrees per second it turns (0); it ends on a whole turn" }, "tilt": { "type": "Amount", "doc": "degrees it leans (0)" }, "open": { "type": "Amount", "doc": "0 closed to 1 wide open; left out, the book opens as it normally would" }, "flip_speed": { "type": "Amount", "doc": "page turns per second added to its flipping (0)" }, "shake": { "type": "Amount", "doc": "blocks of jitter (0)" }, "duration": { "type": "Amount", "doc": "seconds the pose lasts in all, the eases inside it (4)" }, "ease_in": { "type": "Amount", "doc": "seconds easing into the pose (1)" }, "ease_out": { "type": "Amount", "doc": "seconds easing back out (1)" } } }, "thematic:page_burst": { "doc": "Parchment pages fly out of the floating book (the anchor's, or the point's) for one player: they spray, flutter down on paper physics, tint from one colour to another and fade. Starts at the book's current posed height.", "fields": { "to": { "type": "ScreenTo", "doc": "whose screen: the body the action is aimed at (default), or the wearer's" }, "at": { "type": "string | { x: number, y: number, z: number }", "doc": "the book's block: \"anchor\" (default) or a point" }, "count": { "type": "Amount", "doc": "pages (40, at most 120; thinned by the viewer's particle setting)" }, "speed": { "type": "Amount", "doc": "blocks per second they leave at (7)" }, "spread": { "type": "Amount", "doc": "0 straight up to 1 nearly flat out (0.7)" }, "duration": { "type": "Amount", "doc": "seconds a page lives (4)" }, "color_from": { "type": "Color", "doc": "colour a page starts as (#E8DCC0)" }, "color_to": { "type": "Color", "doc": "colour it ends as (#7A0A0A)" }, "color_delay": { "type": "Amount", "doc": "fraction of its life before it starts to change (0.2)" }, "texture": { "type": "string", "doc": "a texture drawn whole; left out, the book's own page" } } }, "thematic:leash_pause": { "doc": "For a while a player in a mission with a pull-back leash is not pulled back, so a blast that throws them clear of the fight is allowed to carry them; the pull takes over again afterwards.", "fields": { "seconds": { "type": "Amount", "doc": "how long (3)" }, "to": { "type": "ScreenTo", "doc": "whose leash: the wearer's (default), or the body the action is aimed at" } } }, "thematic:fake_crater": { "doc": "A crater made of nothing but looks: cracks spread out from the impact over a few ticks, some blocks turn into broken versions of themselves, debris flies and dust rises. Seen by one player only; the world is not changed and the ground feels exactly as solid. It heals outward by itself after lasts.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "radius": { "type": "Amount", "doc": "blocks across the surface, at most 12 (4)" }, "depth_visual": { "type": "Amount", "doc": "0 to 1: how much of it is swapped for broken block variants; 0 is cracks only (0.6)" }, "debris": { "type": "Amount", "doc": "chunks thrown (14); the viewer's client thins them for its particle setting and distance" }, "crack_stage": { "type": "Amount", "doc": "0 to 9, the deepest crack, at the middle (6)" }, "lasts": { "type": "Amount", "doc": "seconds until it starts to heal; 0 keeps it until fakeRevert() (20)" }, "heal": { "type": "Amount", "doc": "blocks per second the healing spreads out from the impact at; 0 heals it all at once (10)" }, "spread": { "type": "Amount", "doc": "ticks the cracks take to reach the rim (5)" }, "audience": { "type": "FakeAudience", "doc": "who sees it when the wearer is not a private entity (a private wearer's viewer always, and only them): self -- the wearer (default); target -- the player the action is aimed at; nearby -- players within 48 blocks" } } }, "thematic:fake_crack_line": { "doc": "A crack racing along the ground from one point to another, widest at the start and tapering, with the odd broken block and chunks kicked up along it. One player's screen only.", "fields": { "from": { "type": "BlockAt", "doc": "where it starts (self)" }, "to": { "type": "BlockAt", "doc": "where it ends; left out, length blocks along the wearer's look, level" }, "reach": { "type": "number", "doc": "with look: how far the look reaches (32)" }, "length": { "type": "Amount", "doc": "blocks, when there is no to (8); at most 48" }, "width": { "type": "Amount", "doc": "blocks across, 1 to 5 (1)" }, "crack_stage": { "type": "Amount", "doc": "0 to 9, the deepest crack, at the start (5)" }, "debris": { "type": "Amount", "doc": "chunks kicked up along it (8)" }, "lasts": { "type": "Amount", "doc": "seconds until it starts to heal; 0 keeps it until fakeRevert() (20)" }, "heal": { "type": "Amount", "doc": "blocks per second the healing spreads out from the impact at; 0 heals it all at once (10)" }, "audience": { "type": "FakeAudience", "doc": "who sees it when the wearer is not a private entity (a private wearer's viewer always, and only them): self -- the wearer (default); target -- the player the action is aimed at; nearby -- players within 48 blocks" } } }, "thematic:fake_splinter": { "doc": "Breaks leaves, fences, walls and glass within a radius as fakes: they vanish from one player's screen and fly apart. Only what the palettes allow (data//fake_palettes): leaves anywhere (they come back the moment the viewer gets near), fences, walls and glass only where the top is two or more above the ground the viewer can stand on; a fence the viewer could walk into is cracked instead. Call it again as something passes to splinter a path.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (self): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "radius": { "type": "Amount", "doc": "blocks, at most 8 (4)" }, "chance": { "type": "Amount", "doc": "0 to 1, the chance each block goes (0.6)" }, "max": { "type": "Amount", "doc": "the most blocks one run touches (24)" }, "debris": { "type": "Amount", "doc": "chunks flung from each block (4)" }, "lasts": { "type": "Amount", "doc": "seconds until they heal (15)" }, "heal": { "type": "Amount", "doc": "blocks per second the healing spreads out from the impact at; 0 heals it all at once (10)" }, "audience": { "type": "FakeAudience", "doc": "who sees it when the wearer is not a private entity (a private wearer's viewer always, and only them): self -- the wearer (default); target -- the player the action is aimed at; nearby -- players within 48 blocks" } } }, "thematic:debris_burst": { "doc": "Flying block chunks for one player: cut from the block's texture, thrown with weight (the heavier ones fly lower, tumble slowly and land with a thud), bounce once or twice, lie still, then fade. Made on the client; no entities.", "fields": { "at": { "type": "BlockAt | { groundBelow: number }", "doc": "which block it starts from (hit): hit -- the block hit, or the block an entity hit stands in, or (answering block_broken or use_block) the event's block, or the action's point when nothing was hit; pos -- the block the action's point is in; self -- the wearer's; below -- under the wearer's feet; look -- the block the wearer looks at; spot -- the point markSpot fixed; { groundBelow: n } (ground_below in a file) -- the air on top of the first block that is not air, looking down from the wearer's feet at most n blocks (nothing when the ground is further down)" }, "reach": { "type": "number", "doc": "with at: \"look\": how far the look reaches, in blocks (5)" }, "face": { "type": "boolean", "doc": "step one block out through the face that was hit -- the air beside a wall, the block on top of a floor" }, "count": { "type": "Amount", "doc": "chunks, at most 48 (12)" }, "speed": { "type": "Amount", "doc": "blocks per second for the lightest chunk (6)" }, "spread": { "type": "Amount", "doc": "0 a tight cone, 1 a full dome (0.5)" }, "size": { "type": "Amount", "doc": "1 is a handful of pixels across, 0.3 to 3 (1)" }, "rest": { "type": "Amount", "doc": "seconds a chunk lies still before it fades (4)" }, "block": { "type": "string", "doc": "the block whose texture they are cut from; left out, the block at the spot" }, "direction": { "type": "DebrisHeading", "doc": "which way they are thrown (face)" }, "audience": { "type": "FakeAudience", "doc": "who sees it when the wearer is not a private entity (a private wearer's viewer always, and only them): self -- the wearer (default); target -- the player the action is aimed at; nearby -- players within 48 blocks" } } }, "thematic:fake_revert": { "doc": "Puts a player's fake world back: every fake block and crack at once, or healing outward in a ring from a point, a puff of dust at each block as the real one returns.", "fields": { "mode": { "type": "FakeRevertMode", "doc": "ring (default) or all" }, "from": { "type": "BlockAt", "doc": "where the ring starts (self)" }, "reach": { "type": "number", "doc": "with look: how far the look reaches (32)" }, "speed": { "type": "Amount", "doc": "ring: blocks per second (12); 0 or less is all at once" }, "audience": { "type": "FakeAudience", "doc": "who sees it when the wearer is not a private entity (a private wearer's viewer always, and only them): self -- the wearer (default); target -- the player the action is aimed at; nearby -- players within 48 blocks" } } }, "thematic:mark": { "doc": "Marks the target the action is aimed at in the wearer's name, for a while: kept on the body, so anything can ask whose it is (the markedBy guard). Renewing a mark keeps it the wearer's; marking one another wearer holds takes it over. With radius, marks everything in that box around the action but the wearer and their own animals. The hunter's quarry: mark({ key: \"quarry_mark\", vfx: \"HUNT_MARK\" }).", "fields": { "key": { "type": "string", "doc": "what the mark is kept under, lower_snake_case (\"mark\"); the one markedBy names" }, "owner_key": { "type": "string", "doc": "what the owner's id is kept under (_owner for a key ending in _mark, so quarry_mark's is quarry_owner; else _owner)" }, "for": { "type": "Amount", "doc": "seconds it lasts (the tuned duration)" }, "keep_longer": { "type": "boolean", "doc": "never shortens a mark already there (false)" }, "glow": { "type": "boolean", "doc": "a hidden Glowing effect as long as the mark, visible to everyone (true)" }, "seen_by": { "type": "\"all\" | \"owner\"", "doc": "who sees the glow: everyone (\"all\"), or the wearer alone, through walls (\"owner\")" }, "vfx": { "type": "string", "doc": "a VFX preset played at the body's feet, sized to it, only when the mark is new" }, "radius": { "type": "Amount", "doc": "marks everyone in this box around the action instead of the target" }, "max": { "type": "number", "doc": "at most this many bodies carry the wearer's mark under the key at once (no cap)" }, "fifo": { "type": "boolean", "doc": "with max reached, the oldest mark goes to make room; false refuses the new one (false)" }, "clear": { "type": "boolean", "doc": "takes the wearer's own mark under the key off the target (or everyone in radius) instead; with none of the fields that put one on (false)" } } }, "thematic:gun_window": { "doc": "For a while, the wearer's held gun fires for free and hits harder. shots: the gun fires that many free shots now, itself (flash, recoil, animation), and the window closes on the last; unlimited: every shot is free until it runs out, the gun cycling fire_rate times faster (holding the trigger keeps firing). Neither: only the damage, knockback and bleed. One window per wearer: a new one replaces the old, except that an unlimited one outlasting it is kept. gunWindow({ shots: 1, for: 0.5 }) is a pressed blast; gunWindow({ unlimited: true, fireRate: 3.5, damageBonus: 0.35, closeOnEnd: true }) an ultimate's burst.", "fields": { "for": { "type": "Amount", "doc": "seconds it stays open (the tuned duration)" }, "shots": { "type": "number", "doc": "free shots the gun fires at once, 1 or more" }, "unlimited": { "type": "boolean", "doc": "every shot is free while it is open (false)" }, "fire_rate": { "type": "Amount", "doc": "how many times faster the gun cycles while it is open: fire rate, pump and their animations (1)" }, "damage_bonus": { "type": "Amount", "doc": "each landed shot hits this share harder: 0.35 is 35% more (0)" }, "knockback": { "type": "Amount", "doc": "knockback each landed shot adds, once per target, in blocks of impulse (0)" }, "bleed_chance": { "type": "Amount", "doc": "0 to 1: the chance a landed shot bleeds its target, once per target (0)" }, "close_on_end": { "type": "boolean", "doc": "ends the window, both halves, when the press's states are over (false)" } } }, "thematic:gun_action": { "doc": "Has the wearer's held gun do something now: gunAction(\"reload\") on a press is the reload move (while a gun is held, ability_0 is reload).", "fields": { "action": { "type": "GunAction", "required": true, "doc": "what the held gun does" } } }, "thematic:one_of": { "doc": "Runs one of its branches, picked at random: each branch an action or a list of them, as likely as its weight. In a script, oneOf([b => ..., b => ...], { weights: [3, 1] }).", "fields": { "of": { "type": "(ActionObject | ActionObject[])[]", "required": true, "doc": "the branches" }, "weights": { "type": "number[]", "doc": "one per branch, 0 or more; left out, all alike" } } }, "thematic:weather": { "doc": "Changes the weather for a while, and can put it back afterwards.", "fields": { "set": { "type": "WeatherSet", "doc": "cycle (default), clear, rain or thunder" }, "for": { "type": "Amount", "doc": "seconds the new weather lasts (300)" }, "restore": { "type": "boolean", "doc": "the weather it found comes back when that time is up (false)" } } }, "thematic:open_screen": { "doc": "Opens a screen for the wearer, with no block behind it: their ender chest, a 3x3 crafting grid that hands back what is left in it when it closes, or an inventory stored on them by name, shown as a chest of as many rows.", "fields": { "screen": { "type": "ScreenKind", "required": true, "doc": "which screen" }, "name": { "type": "string", "doc": "stored_inventory: the inventory's key, e.g. \"backpack\"" }, "size": { "type": "number", "doc": "stored_inventory: its slots the first time it is made, 1 to 54 (27)" }, "title": { "type": "string", "doc": "the screen's title, a translation key (container.enderchest, container.crafting, container.backpack)" } } }, "thematic:spectate": { "doc": "Hands the wearer's camera to something else: it rides with the entity hit (target; hidden from them while they look out through it), or is latched onto their own head (head), for a while or until a stop. Synced to their client. A still view without bob is camera({ noViewBob: true }) on the phase.", "fields": { "view": { "type": "SpectateView", "doc": "target or head; needed unless stop" }, "for": { "type": "Amount", "doc": "seconds; left out, until a spectate({ stop: true })" }, "stop": { "type": "boolean", "doc": "gives the camera back (false)" } } }, "thematic:repair_item": { "doc": "Takes durability damage off the damageable stacks in the wearer's hands: a fixed amount, or so much per experience point of the xp_gained being answered.", "fields": { "hands": { "type": "RepairHands", "doc": "main, off or both (default)" }, "amount": { "type": "Amount", "doc": "points of durability (1)" }, "per_xp": { "type": "number", "doc": "points per experience point of the event, in place of amount" } } }, "thematic:smelt": { "doc": "Smelts from the wearer's inventory as a furnace would, the results into the inventory (or at their feet when it is full): one item, or every smeltable stack whole.", "fields": { "one": { "type": "boolean", "doc": "only one item (true); false smelts every smeltable stack" }, "skip": { "type": "string | string[]", "doc": "items and #tags left alone, e.g. [\"#minecraft:logs_that_burn\", \"minecraft:cobblestone\"]" }, "skip_named": { "type": "boolean", "doc": "leave renamed items alone (true)" }, "xp": { "type": "boolean", "doc": "pay the recipe's experience, rounded up per item (true)" }, "required": { "type": "boolean | { miss_cooldown?: number }", "doc": "nothing smelted calls the rest of the list off; miss_cooldown is the share of the cooldown that still costs" } } }, "thematic:merge_stacks": { "doc": "Tops up every partial stack in the wearer's inventory from the matching stacks after it.", "fields": {} }, "thematic:compress": { "doc": "For each item the wearer carries enough of, crafts full grids of it into what the crafting recipe makes -- nine ingots into a block -- as many times as it can. Only plain stacks (no NBT) go in.", "fields": { "recipe": { "type": "\"3x3\" | \"2x2\"", "doc": "the grid it fills (3x3)" }, "filter": { "type": "string | string[]", "doc": "only these items and #tags; left out, any item with such a recipe" } } }, "thematic:press_ability": { "doc": "Presses whatever sits on a key of the kit, as the key would: a press presses, a toggle flips, a hold starts.", "fields": { "slot": { "type": "string | number", "required": true, "doc": "\"ultimate\", \"ability_1\", or a key number such as 1" }, "who": { "type": "Who", "doc": "self (default), or target: the player hit" }, "reset_cooldown": { "type": "boolean", "doc": "clear its cooldown first, so it goes off even while cooling down (false)" } } }, "thematic:use_move": { "doc": "Presses a registered move by id, whether or not it is in the wearer's kit, as the wearer's own. A move that is not pressable, or not registered, does nothing.", "fields": { "id": { "type": "string", "required": true, "doc": "the move's ability id, e.g. \"sneezing_powder\"" }, "delay": { "type": "Amount", "doc": "seconds before it is pressed (0)" }, "ready": { "type": "boolean", "doc": "only when its key would take it now: off its cooldown, not held or blocked (false: pressed regardless)" }, "do": { "type": "ActionObject[]", "doc": "run only once it was pressed" } } }, "thematic:wear_shape": { "doc": "Lends the wearer the shape one of their kit's morph moves wears, for a while, as part of another move (Bat Colony leaves Dracula a bat once the colony scatters). Borrowed: it costs the morph no cooldown however it ends, and leaves them on Slow Falling if they are in the air. Nothing happens while they are already in a shape.", "fields": { "id": { "type": "string", "required": true, "doc": "the morph move's ability id, e.g. \"bat_form\"" }, "seconds": { "type": "Amount", "doc": "how long the shape is lent (5)" } } }, "thematic:entity_clip": { "doc": "Triggers a GeckoLib clip on each nearby entity of this type summoned by the wearer.", "fields": { "entity": { "type": "string", "required": true, "doc": "the summoned entity type id" }, "controller": { "type": "string", "required": true, "doc": "the entity's animation controller" }, "clip": { "type": "string", "required": true, "doc": "the trigger name registered by that controller" }, "radius": { "type": "number", "doc": "how far from the action's target to search (4)" }, "at": { "type": "string", "doc": "\"spot\" to search around the point markSpot fixed (the trap's own place), or \"target\" (default)" } } }, "thematic:despawn_entity": { "doc": "Removes each nearby entity of this type summoned by the wearer.", "fields": { "entity": { "type": "string", "required": true, "doc": "the summoned entity type id" }, "radius": { "type": "number", "doc": "how far from the action's target to search (4)" }, "at": { "type": "string", "doc": "\"spot\" to search around the point markSpot fixed (the trap's own place), or \"target\" (default)" } } }, "thematic:drop_item": { "doc": "Drops an item in the world, with the usual pickup delay.", "fields": { "item": { "type": "string", "required": true, "doc": "the item id; one not registered (its pack missing) drops nothing" }, "count": { "type": "number", "doc": "(1)" }, "at": { "type": "DropAt", "doc": "self (default), hit, pos or spot" } } }, "thematic:transform_drops": { "doc": "Rewrites the items the entity hit -- a kill's victim -- has just dropped: some multiplied, food cooked. A multiplied stack is not cooked too.", "fields": { "multiply": { "type": "{ times?: number; items?: string | string[] }", "doc": "those items' stacks times over (2), up to a full stack; items left out, every item" }, "smelt_food": { "type": "boolean", "doc": "food with a smelting recipe becomes what it cooks into (false)" }, "radius": { "type": "number", "doc": "how far around the body the drops are looked for (1.5)" } } }, "thematic:item_clip": { "doc": "The item in a hand plays one of its own clips: a gun in the main hand the cue it declares under that name (sent to the wearer), any other geo item the clip on its controller.", "fields": { "clip": { "type": "string", "required": true, "doc": "the gun's cue, or the item's clip" }, "controller": { "type": "string", "doc": "the geo item's animation controller; without it only a gun answers" }, "hand": { "type": "Hand", "doc": "main (default) or off" }, "stop": { "type": "boolean", "doc": "stops the geo item's clip on its controller instead (a twirl that loops until the move ends); needs controller (false)" } } }, "thematic:throw_potion": { "doc": "Throws a splash (or lingering) potion of the effects given, from the wearer's eyes along their look.", "fields": { "effects": { "type": "{ effect: string; seconds?: number; amplifier?: number }[]", "required": true, "doc": "the effects it carries (5 seconds, amplifier 0)" }, "color": { "type": "number | string", "doc": "the potion's tint, an RGB number or \"#rrggbb\"" }, "lingering": { "type": "boolean", "doc": "a lingering cloud rather than a splash (false)" }, "velocity": { "type": "number", "doc": "(0.5)" }, "divergence": { "type": "number", "doc": "(1)" }, "pitch_offset": { "type": "number", "doc": "degrees added to the look's pitch (-20, vanilla's throw)" } } }, "thematic:launch_lock": { "doc": "Movement systems leave the body's velocity alone for a while, so a launch just given is not steered away at once.", "fields": { "for": { "type": "Amount", "doc": "seconds (0.5)" }, "who": { "type": "Who", "doc": "self (default) or target" } } }, "thematic:disable_shield": { "doc": "A player's shield is knocked down for a while, as an axe does.", "fields": { "who": { "type": "Who", "doc": "target (default) or self" }, "only_blocking": { "type": "boolean", "doc": "only while they are holding it up (true)" } } }, "thematic:ping": { "doc": "A direction ping on the wearer's own screen, pointing the way something is: chevrons on a ring around the crosshair, drawn with this ability's thematic:direction_ping options (the spider-sense's with none). Sent to the wearer only.", "fields": { "level": { "type": "number", "doc": "which of the visual's levels it shows as, from 1 (1); past the last, the last" }, "at": { "type": "PingAt", "doc": "what it points at: hit (default), pos or spot" } } }, "thematic:reset_constructs": { "doc": "Lifts any limits a move put on which constructs the wearer may make: what a lantern ring's charge did as the suit came off.", "fields": {} }, "thematic:lightning": { "doc": "Calls down bolts that strike for the wearer: each flashes one to three times where it lands and, each time, hits everyone in a small column round it the wearer may hit -- for damage, as the wearer's attack, holding them where they stand -- and never the wearer's side. lightning({ count: 3 }) inside targets() is three bolts on each target; lightning({ at: \"wearer\", count: 2, scatter: 4 }) two anywhere near the wearer.", "fields": { "at": { "type": "LightningAt", "doc": "what they land round (here)" }, "count": { "type": "Amount", "doc": "how many (1, or one per offset); a worked-out number is truncated, never below 1" }, "arrangement": { "type": "SummonArrangement", "doc": "where they land around their centre (ring), as a summon's stand" }, "radius": { "type": "Amount | number[]", "doc": "how far from their centre, in blocks (0: all on it), or [min, max] picked for each one" }, "stagger": { "type": "number", "doc": "with formation_v, how far back each rank lands, in blocks (half the radius)" }, "offsets": { "type": "number[][]", "doc": "fixed places added on top of the arrangement, each [right, up, forward] in blocks from the way the wearer's body faces, used in turn" }, "scatter": { "type": "number", "doc": "moves each one up to this many blocks at random on each level axis (0)" }, "every": { "type": "number", "doc": "seconds between one bolt and the next (0: all at once)" }, "damage": { "type": "Amount", "doc": "what each flash deals to each body it hits, in raw points (2)" }, "owner_credited": { "type": "boolean", "doc": "its hits are the wearer's attack -- their bonuses, hit_landed, kill credit (true); false makes them a lightning bolt's own, still never on the wearer's side" }, "stun": { "type": "boolean | Amount", "doc": "how long a struck body is held where it stands: true (1.5 seconds), false (not at all) or seconds" }, "scale": { "type": "LightningScale", "doc": "how big each bolt is (normal)" }, "cosmetic": { "type": "boolean", "doc": "for show: vanilla's cosmetic bolt, a flash and a crack that strikes, burns and charges nothing -- no damage, stun, owner_credited or scale beside it (false)" }, "entity": { "type": "string", "doc": "a thematic:strike entity id to call down instead of the stun lightning, for its own look, flashes, damage and stun (the verb's damage and stun still override); no scale beside it. With cosmetic it is drawn and strikes nobody" } } }, "thematic:strand": { "doc": "Strings a lasting strand (a thematic:strand entity) from a point to the block the wearer looks at. It stays after the move ends: bodies walk along a gentle one and climb a steep one, and it catches whoever crosses it fast, as its definition says. Repeated presses of strand({ from: \"chain\" }) lay a tightrope point to point: the first anchors, each later one strings on from the last point. Past the definition's max_per_owner the wearer's oldest goes. do runs at the new end, the strand as its source.", "fields": { "to": { "type": "StrandTo", "doc": "where it ends (look_hit)" }, "from": { "type": "StrandFrom", "doc": "where it starts (self)" }, "range": { "type": "Amount", "doc": "blocks the look reaches, and the longest a chained strand may be (the tuned range, else 24)" }, "lasts": { "type": "Amount", "doc": "seconds it stays (the definition's lifetime)" }, "window": { "type": "Amount", "doc": "seconds a press's point stays open for the next chained press (the tuned chain_window, else 3)" }, "entity": { "type": "string", "doc": "the strand entity id (thematic:web_strand)" }, "required": { "type": "boolean | { missCooldown: number }", "doc": "a press that strings nothing (missed, or only anchored) calls the rest off and costs no cooldown, or missCooldown's share of it" }, "do": { "type": "ActionObject[]", "doc": "run once it is strung, where it ends" } } }, "thematic:swap_suit": { "doc": "Puts the wearer in another suit: the one named (to), or the other of a pair of suits (pair; wearing neither, nothing happens). A swap to a base suit puts on the variant of it last worn, remembered on the stack (ThematicTransformVariant_), and the new stack remembers the variant taken off. With for, the suit is only borrowed: bound on for that long, then the wearer's own suit and health come back. Banner's turn: swapSuit({ pair: [\"jason_blood\", \"etrigan\"] }).", "fields": { "to": { "type": "string", "doc": "the suit to put on, a base suit or an alt (\"batson\"); give this or pair" }, "pair": { "type": "string[]", "doc": "two base suits, [\"jason_blood\", \"etrigan\"]: swaps to whichever is not worn; give this or to" }, "keep_nbt": { "type": "boolean", "doc": "the new stack keeps the old one's data -- colour, level, stored items (true)" }, "remember_variant": { "type": "boolean", "doc": "remember and restore which variant of each suit was worn (true)" }, "for": { "type": "Amount", "doc": "seconds the suit is borrowed for; left out, the swap is for good" }, "scale": { "type": "number", "doc": "with for: the wearer's health while it is borrowed, in health points (unchanged)" }, "required": { "type": "boolean | { miss_cooldown?: number }", "doc": "a swap that does not happen calls the rest of the list off; miss_cooldown is the share of the cooldown that still costs" } } }, "thematic:copy_suit": { "doc": "Lends the wearer a fresh copy of a suit -- the target's, or one by id -- bound on for a while; then their own suit and health come back. The copy carries none of the original's data. Fails for a wearer already borrowing one, or nearly dead.", "fields": { "from": { "type": "string", "doc": "\"target\" (default: the suit the entity hit wears) or a suit id, \"superman\"" }, "lasts": { "type": "Amount", "doc": "seconds it is worn (the tuned duration)" }, "scale": { "type": "number", "doc": "the wearer's health while it is worn, in health points (unchanged)" }, "end_on_return": { "type": "boolean", "doc": "this move ends when the suit comes back, and its tuned cooldown starts then (false)" }, "required": { "type": "boolean | { miss_cooldown?: number }", "doc": "a swap that does not happen calls the rest of the list off; miss_cooldown is the share of the cooldown that still costs" } } }, "thematic:set_active": { "doc": "Switches a move on or off: this one, one by id, or every move of the wearer's suit (\"kit\"), with a time written to its clock -- the cooldown it is left on when off, how long it runs when a timed move is on.", "fields": { "ability": { "type": "string", "doc": "a move's id, or \"kit\" for every move of the suit (default: this move)" }, "on": { "type": "boolean", "doc": "on (true) or off" }, "for": { "type": "Amount", "doc": "seconds on its clock; left out, the clock is left alone" }, "up_to": { "type": "number", "doc": "with for: the time is drawn at random between for and this many seconds" }, "clear_capture": { "type": "boolean", "doc": "first end the wearer's shape-shift capture (the form they copied), if they hold one, so the move starts from their own shape (false)" }, "who": { "type": "\"self\" | \"target\"", "doc": "whose moves: the wearer's (self, the default) or, inside targets(), the target's" }, "kind": { "type": "string", "doc": "instead of ability: every move of that body's suit of this kind, switched off from outside -- its clean-up runs, and a toggle's switching-off (equip_item: the moves that hand out items, which take them back); needs on: false" }, "take_back": { "type": "boolean", "doc": "with kind: also take off the body every stack still tied to those moves (false)" } } }, "thematic:end_ability": { "doc": "Ends a running move as running out would: it switches off, its clean-up runs, and its tuned cooldown starts.", "fields": { "ability": { "type": "string", "doc": "a move's id (default: this move)" } } }, "thematic:capture_menu": { "doc": "Opens a menu of forms for the wearer (a player), on behalf of this move: suits rolled at random, none of which can be taken. Picking one takes on its look for this move's tuned duration (the shape-shift capture) and runs this move again for as long; the menu stays open while this move runs. Mystique's Shapeshift: captureMenu() in the press, into a phase that lasts \"duration\".", "fields": { "slots": { "type": "number", "doc": "how many forms it offers, 1 to 5 (5)" }, "source": { "type": "\"random_suits\"", "doc": "where the forms come from: suits rolled at random (random_suits)" }, "inventory": { "type": "string", "doc": "the stored inventory the forms are kept in (\"shapeshift\")" }, "title": { "type": "string", "doc": "the menu's title, a translation key (container.shapeshift)" } } }, "thematic:end_capture": { "doc": "Lets go of the look a capture_menu pick took on, if the wearer holds one: they look like their own suit again.", "fields": {} } }, "types": { "Corps": { "doc": "A Lantern corps: the prefix its moves' ids start with, the colour they fly, and how it looks. data//corps/.json; the corp/ move scripts define each move once per corps. Only prefix and color are needed: a field left out is the colour's own. The file may also set text_color and shield_effects, which only the engine reads.", "fields": { "id": { "type": "string", "doc": "the file's id, :" }, "prefix": { "type": "string", "doc": "what its moves' ids start with: \"willpower\" makes willpower_beam" }, "color": { "type": "CorpsColor", "doc": "the corps' colour, which its moves fly: green, yellow, red, blue, indigo, violet, orange, black, white" }, "name": { "type": "string", "doc": "what the corps is called (\"Green Lantern Corps\")" }, "bar": { "type": "string", "doc": "the HUD bar its charge shows in, e.g. \"willpower_green\"" }, "tint": { "type": "string", "doc": "the colour its constructs and auras are tinted, \"#RRGGBB\"" }, "ring": { "type": "string", "doc": "its ring item's id" }, "particle": { "type": "ParticleSpec", "doc": "the particle its moves trail: an id, or a dust like dust(...) makes" }, "battery_block": { "type": "string | undefined", "doc": "its power battery block's id, which is also its item's; none for a corps without one" }, "flash": { "type": "string | undefined", "doc": "the status effect a surge flashes its target with; none for a corps without one" } } }, "SlowMotionSelf": { "doc": "The wearer's own time in slowMotion().", "fields": { "motion": { "type": "Amount", "doc": "their motion scale (0.8)" }, "jump": { "type": "Amount", "doc": "their jump scale; left out, 1/sqrt(motion), which keeps their jump height" }, "shed": { "type": "boolean", "doc": "as it starts, sheds the slow and kit lock another's slow motion left on them (true)" } } }, "SlowMotionVictims": { "doc": "Who slowMotion() catches, and what it does to them.", "fields": { "lock_moves": { "type": "LockMovesOptions | boolean", "doc": "their kit is locked as they are caught, for the same time; false for no lock ({}: dampen, sparing this move and stun-immune ones). Always the victim, so no who" }, "motion": { "type": "\"caught\" | Amount", "doc": "the motion scale they are held at: caught (default) works it out from their speed as they are caught -- a fifth for most, a walk for a speedster -- or a figure" }, "unless_active": { "type": "string[]", "doc": "spares anyone running one of these ability ids; \"self\" is this move (default [\"self\"])" } } }, "SlowMotionOptions": { "doc": "Options of phase.slowMotion(): the fields of thematic:slow_motion besides phase.", "fields": { "radius": { "type": "Amount", "doc": "how far it reaches, a box that far out each way (the tuned radius)" }, "for": { "type": "Amount", "doc": "seconds the slow, the lock and the held projectiles last; left out, what is left of the running phase, so they lapse on the tick it does" }, "self": { "type": "SlowMotionSelf | boolean", "doc": "the wearer's own time: false leaves it alone ({ motion: 0.8 })" }, "victims": { "type": "SlowMotionVictims", "doc": "what happens to those caught" }, "hold_projectiles": { "type": "boolean", "doc": "holds the projectiles in the radius in the air (true)" }, "sparks": { "type": "(ParticlesOptions & { particle?: ParticleSpec }) | boolean", "doc": "particles around the wearer each tick, over three bursts of five electric sparks scattered across the radius and up to two blocks up; false for none" }, "release_on_end": { "type": "boolean", "doc": "lets everyone in the radius go as it ends -- slow, held figure and kit lock (true)" } } }, "AbilityEffectEntry": { "doc": "An ability effect made for each firing from options written beside its id. Only the options the named effect takes are allowed.", "fields": { "id": { "type": "string", "doc": "the effect: one of [thematic:ability_lock, thematic:blindness, thematic:disarm, thematic:grounded, thematic:prone]" }, "duration": { "type": "Amount", "doc": "thematic:ability_lock: seconds (3); thematic:blindness: seconds (3.5); thematic:disarm: seconds (3); thematic:grounded: seconds (5); thematic:prone: seconds (2)" }, "amplifier": { "type": "Amount", "doc": "thematic:blindness: (0); thematic:grounded: 10 is fully grounded (10); thematic:prone: (0)" }, "players_only": { "type": "boolean", "doc": "thematic:blindness: only a player's shot blinds, as Heat Vision Blindness did (false)" }, "chance": { "type": "Amount", "doc": "thematic:disarm: 0 to 1 (0.1)" } } }, "SprayCone": { "doc": "One projectile of a spray's firing. Anything a cone leaves out is the spray's own field; a cone that writes effects (or optionEffects) carries only those, not the spray's list.", "fields": { "particle": { "type": "ParticleSpec", "doc": "the particle it is drawn with (minecraft:spit)" }, "spread": { "type": "Amount", "doc": "how far it strays from the look, as vanilla's divergence; it also tips the throw up by as many degrees, as the breaths always did (1)" }, "lifetime": { "type": "number", "doc": "seconds before it goes, to the nearest tick (3)" }, "lifetime_ticks": { "type": "number", "doc": "ticks before it goes, exactly; instead of lifetime" }, "speed": { "type": "Amount", "doc": "how fast it flies, blocks a tick (2); the wearer's own velocity is added" }, "damage": { "type": "Amount", "doc": "what the effects it carries are handed as the hit's damage (0)" }, "effects": { "type": "(string | AbilityEffectEntry)[]", "doc": "ability effects it carries: ids, e.g. [\"thematic:laser\", \"thematic:ignite\"], or an effect that takes options with them, e.g. { id: \"thematic:blindness\", duration: 3.5, amplifier: tuned(\"amplifier\") }" }, "option_effects": { "type": "string", "doc": "a suit option whose comma list of effect ids is added after these, e.g. \"laser_effects\"" }, "dedupe": { "type": "boolean", "doc": "an effect already in the list is not added again, e.g. when the suit option names it too (false: it fires twice)" } } }, "BeamSplash": { "doc": "The blast round a beam's first hit: everyone within radius of its hitbox takes the beam's effects and damage, straight on (Optic Beam's).", "fields": { "radius": { "type": "Amount", "doc": "how far round the first hit's hitbox, in blocks" }, "include_hit": { "type": "boolean", "doc": "the first hit is caught too, so it takes the effects twice (true, as Optic Beam's did)" }, "hittable": { "type": "boolean", "doc": "only those the wearer may hit (true); false catches allies and the wearer too, as the Java splash did" } } }, "BeamChain": { "doc": "A beam's jumps on from its first hit: each to the closest living thing within range of the last that it may hit and was not hit yet, taking the effects straight on (Optic Beam's).", "fields": { "jumps": { "type": "Amount", "doc": "how many jumps (the suit's beam assets' maxChains, 3)" }, "range": { "type": "Amount", "doc": "how far each jump reaches, in blocks (the beam assets' chainRange, 10)" } } }, "AbilityTraitOptions": { "doc": "What ability.traits() may say: the ability-scope traits. The wearer traits (silentSteps, environment, loot, drawSpeed...) hold while the ability is active; a passive always.", "fields": { "cooldown": { "type": "\"on_press\" | \"on_end\"", "doc": "\"on_press\": the cooldown starts on the press and runs while the phases play out; the phases keep their own time. \"on_end\", the default: it starts as they end" }, "ultimate": { "type": "boolean | { blocksKeys?: boolean }", "doc": "true, or {\"blocks_keys\": false}: the suit's ultimate. Its cooldown scales as one, and pressing it parks the rest of the kit unless blocks_keys is false" }, "ultimate_immune": { "type": "boolean", "doc": "true: an ultimate's press leaves this ability's cooldown alone" }, "equips": { "type": "boolean", "doc": "true: a toggle that puts the wearer's item out; a kit move refused only for the item in hand switches it on first" }, "equip_delay": { "type": "number", "doc": "seconds (0 to 5, default 0.1): on an equipping toggle, how long a kit move pressed without the item waits for it to come out" }, "immune_to": { "type": "string[]", "doc": "[damage type ids] the wearer takes no damage from while the ability is on the suit, e.g. [\"minecraft:fall\"]" }, "exclusive": { "type": "boolean | { message?: string; color?: Formatting }", "doc": "true, or {\"message\": translation key, \"color\": formatting}: while active, the rest of the suit can not be pressed" }, "steady_cooldown": { "type": "boolean", "doc": "true: this ability's cooldown is never slowed by a slowed-time field or another ability's slows_cooldowns" }, "while_active": { "type": "{ stillLimbs?: boolean; silentSteps?: boolean; capeAngle?: number }", "doc": "{\"still_limbs\", \"silent_steps\", \"cape_angle\"} -- the wearer's body while the ability is active" }, "stun_immune": { "type": "boolean", "doc": "true: stuns, an ultimate's lockout and move locks pass this ability by (Berserker Rage)" }, "two_handed": { "type": "boolean", "doc": "true: while active or held, first person draws the off arm too, as for a two-handed move" }, "locked_suffix": { "type": "string | { key: string; args?: (string | number)[]; color?: Formatting }", "doc": "a translation key, or {\"key\", \"args\": [...], \"color\": formatting (red)}: shown after the name, beside the padlock, while \"requires\" fails" }, "persistent_cooldown": { "type": "boolean", "doc": "true: the cooldown survives death, respawn and taking the suit off or swapping it (kept as a world-time deadline)" }, "off_steps": { "type": "{ at?: number; do: object[] }[]", "doc": "toggle only: what switching it off does, [{\"at\": seconds, \"do\": [actions]}] -- \"steps\" is what switching it on does" }, "on_equip": { "type": "boolean", "doc": "toggle only: true switches it on every time the suit is put on (its steps do not run; the phase it holds is live at once)" }, "bones": { "type": "{ show?: string[]; hide?: string[] }", "doc": "a toggle, or a press whose phases run it for a while: {\"show\": [bones drawn only while on], \"hide\": [bones hidden while on]}. The bones follow set_bones when the steps call it (a swap timed to an animation), and otherwise whether the toggle is on, or the press's phases are running (stretched arms for as long as the move lasts)" }, "wheel_icon": { "type": "string", "doc": "an item id: the ability's icon on the ability wheel when the suit's options give none (minecraft:feather)" }, "cosmetic_key": { "type": "boolean", "doc": "true: the ability wheel puts it on the cosmetic key, beside the hood and other looks" }, "requires_target": { "type": "boolean", "doc": "true: the move needs a locked target -- pressing it without one is refused, and the suit marks whoever is locked on to. Select that target with targets(\"locked\")" }, "body": { "type": "BodyOptions", "doc": "{\"still_limbs\", \"silent_steps\", \"no_sprint_particles\", \"cape\", \"cape_wrap\", \"cape_flare\", \"launch_lock\", \"pose_grace\", \"while\"} -- the wearer's body while the ability is active (\"while\": \"animating\": while its pose claim holds)" }, "camera": { "type": "CameraOptions", "doc": "{\"no_view_bob\", \"no_flight_sprint\", \"owns_flight_pose\", \"no_flight_tilt\"} -- what the camera and flight leave to the move while the ability is active (or held)" }, "lock_input": { "type": "InputLockOptions", "doc": "{\"move\", \"pin_position\", \"jump\", \"look\", \"attack\"} -- the wearer's own inputs taken away while the ability is active" }, "hide_bones": { "type": "string[] | HideBonesOptions", "doc": "[bone names], or {\"bones\": [...], \"flag\": wearer flag, \"while\": \"active\" | \"cooldown\"} -- suit bones hidden while the ability is active (or cooling down)" }, "damage_bonus": { "type": "{ times?: Amount; plus?: Amount; melee?: boolean; when?: Guard; by?: \"self\" | \"owned\"; within?: number; worn?: boolean }", "doc": "{\"times\": share, \"plus\": amount, \"melee\": bool, \"when\": guard, \"by\": \"self\" | \"owned\", \"within\": blocks, \"worn\": bool}: for as long as the suit has the ability (a toggle: while it is on, unless worn), each hit the wearer lands carries amount * times + plus more, inside the hit. when: a guard each hit must pass, asked with the body struck as the target ({\"marked_by\": \"quarry_mark\"}) and the hit's element and source as the event's ({\"source\": \"thematic:ballistic\"}: a gun's shot; the ballistic element also counts arrows). melee: true is only the wearer's own melee swings. by: \"owned\" rides the hits the wearer's own mobs land instead (a golem, a tamed wolf -- one landed in its own name, not credited to the wearer), while the mob is within within blocks of them (16). times and plus may read the wearer's body and held gun (health, gun_damage, gun_rpm...) and what the struck body carries ({effect_level: id, of: \"target\"}); a negative times cuts the hit. worn: true holds a toggle's bonus while it is off too (a standing stalk outlives the visor that made it)" }, "stats": { "type": "{ attack?: number; defense?: number; speed?: number; utility?: number; when?: Guard }", "doc": "{\"attack\", \"defense\", \"speed\", \"utility\": points, \"when\": guard}: added to the wearer's suit stats while the ability is active (a passive: always), and with when only while that guard holds of the wearer -- e.g. {\"attack\": 15, \"when\": {\"sunlit\": true}}" }, "attributes": { "type": "{ attribute: string; amount: number; operation?: \"add\" | \"multiply_base\" | \"multiply_total\"; uuid: string }[]", "doc": "attribute modifiers held on the wearer, [{\"attribute\": \"minecraft:generic.movement_speed\", \"amount\": -0.2, \"operation\": \"add\" | \"multiply_base\" | \"multiply_total\", \"uuid\": \"...\"}]: put on under their uuid while the ability is active (a passive: for as long as the suit has it), and taken off when it is not" }, "damage_taken": { "type": "{ times: number; when?: { attackerWithin?: Amount; melee?: boolean; element?: Element | Element[]; notElement?: Element | Element[]; notSource?: string | string[]; attacker?: Guard } }", "doc": "{\"times\": share, \"when\": {...}}: while the ability is active (a passive: for as long as the suit has it), every hit on the wearer lands at times its size -- under 1 soaks part of it, over 1 adds to it -- as a phase's damage_taken does while the wearer is in it, with the same when (e.g. {\"not_element\": [\"psychic\", \"magic\"]}: plating that turns everything but the mind and magic)" }, "wheel": { "type": "WheelOptions & { entries?: WheelEntryDefinition[] }", "doc": "a radial menu on the ability's key: hold to open, let go on an entry to pick it. {\"source\": \"construct_favourites\"} is the ring's starred constructs (a pick is the construct grid's summon); otherwise {\"entries\": [{\"id\", \"icon\", \"label\", \"cost\": {\"item\", \"count\"}, \"cooldown\": seconds, \"do\": [actions]}]} run on the server, which refuses a pick the wheel does not list. \"color\" and \"accent\" (\"#RRGGBB\") paint the wedges and the ready band; a suit's wheel_color and wheel_accent options override them. \"cooldown\": true makes a pick start the tuned cooldown. \"tap\": \"last\" makes a quick tap re-fire the entry picked last without opening the dial. A press only" }, "console": { "type": "{ widgets: object[]; pages?: object[]; windows?: object[]; theme?: object; group?: string; default_mode?: string; desktop?: boolean; programs?: { templates?: string[]; event_gate?: { effect: string; at_least?: number } } }", "doc": "a command console: a live overlay with a free cursor that expands into a desktop of windows and a tactical map. {\"widgets\": [{\"id\", \"kind\": button|toggle|choice|units|readout|map|draw|mode|programs, \"do\": actions...}], \"pages\", \"windows\", \"theme\", \"group\"}. The layout is synced to the client, which draws it; every press is checked again on the server against the widget's visible_when / enabled_when guards and runs its actions there. Written in a script with component.console(con => ...)" }, "hud_label": { "type": "{ if?: Guard; text: string; args?: ({ secondsUntil: string; round?: \"up\" | \"down\" } | { combatLeft: number })[]; color?: Formatting }[]", "doc": "[{\"if\": guard, \"text\": translation key, \"args\": [{\"seconds_until\": key, \"round\": \"up\" | \"down\"} | {\"combat_left\": seconds}], \"color\": formatting}]: text shown after the ability's name on the HUD, whatever it is doing -- the first rule whose guard holds, none for none. seconds_until counts down to a deadline mark_deadline stored (never below 1); combat_left is what is left of a fight window that long (dealt or took damage), rounded up" }, "environment": { "type": "{ breathe_underwater?: boolean; underwater_vision?: boolean; walk_on_fluid?: boolean; walk_on_powder_snow?: boolean; terrain_speed?: { blocks: string[]; bonus: number; per_level?: number; level?: number | { min: number | Amount; max: number | Amount; tiered?: boolean } | \"amplifier\" | Amount }[]; when?: Guard }", "doc": "{\"breathe_underwater\", \"underwater_vision\", \"walk_on_fluid\", \"walk_on_powder_snow\": true, \"terrain_speed\": [{\"blocks\": [ids or #tags], \"bonus\": speed, \"per_level\": share, \"level\": level}]}: breathing and seeing clearly under water, standing on fluids and on powder snow, and moving bonus * (1 + level * per_level) faster on the named blocks (level defaults to the ability's authored level; a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down); \"when\": a guard asked of the wearer each time, so they hold only while it does (a speedster's water running above a speed). While the ability is active (a passive: always)" }, "neutral_mobs": { "type": "boolean | { mobs: string[] }", "doc": "true, or {\"mobs\": [entity type ids or #tags]}: mobs leave the wearer alone -- true is every mob, hostile NPCs included; mobs names only those. While the ability is active (a passive: always)" }, "silent_steps": { "type": "boolean", "doc": "true: no footstep sounds. While the ability is active (a passive: always)" }, "force_run": { "type": "boolean", "doc": "true: the wearer keeps running forward whatever the keys say. While the ability is active (a passive: always)" }, "vibrating": { "type": "boolean", "doc": "true: the wearer's body vibrates through attacks, as a speedster's mirage copies. While the ability is active (a passive: always)" }, "invisible": { "type": "boolean", "doc": "true: unseen -- others draw no name tag for the wearer. While the ability is active (a passive: always)" }, "fully_invisible": { "type": "boolean", "doc": "true: not drawn at all -- the suit, the body and what it holds (invisible only hides the name tag). While the ability is active (a passive: always)" }, "slow_motion_immune": { "type": "boolean", "doc": "true: slowed time never catches the wearer (the slow_motion move and the slow_time verb skip them). While the ability is active (a passive: always)" }, "heavy": { "type": "boolean", "doc": "true: moves barely shift the wearer -- a push, launch or blast knockback keeps only what their knockback resistance lets through, and never lifts them off the ground. While the ability is active (a passive: always)" }, "loot": { "type": "{ chest_luck?: number | { min: number | Amount; max: number | Amount; tiered?: boolean } | \"amplifier\" | Amount; looting?: number | { min: number | Amount; max: number | Amount; tiered?: boolean } | \"amplifier\" | Amount; when?: Guard }", "doc": "{\"chest_luck\": level, \"looting\": level, \"when\": guard}: extra Luck while opening a loot chest, and extra Looting levels on a kill -- with when, only on a kill whose body passes it, asked as the target ({\"marked_by\": \"quarry_mark\"}); every such move the wearer has adds. a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down. While the ability is active (a passive: always)" }, "enchant_bonus": { "type": "{ item?: \"main_hand\" | \"off_hand\"; when?: Guard; [enchantment: string]: number | { min: number | Amount; max: number | Amount; tiered?: boolean } | \"amplifier\" | Amount | Guard | string | undefined }", "doc": "{\"\": level, ..., \"item\": \"main_hand\" | \"off_hand\", \"when\": guard}: the held item counts as having that many more levels of each enchantment while a block is broken (Fortune on a pickaxe), put back after, and when the wearer attacks with it (Sharpness on a mace: its damage, knockback, fire aspect and sweep count them); with when, only while that guard holds of the wearer. a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down. While the ability is active (a passive: always)" }, "draw_speed": { "type": "number | { times: number; when?: Guard }", "doc": "{\"times\": multiplier, \"when\": guard}: the bow draws times as fast (2 reaches a full draw in half the time); every draw speed the wearer has multiplies; with when, only while that guard holds of the wearer (e.g. {\"riding\": true}). While the ability is active (a passive: always)" }, "movement": { "type": "{ double_jump?: boolean | number | \"level\" | { per_level?: number; level?: number | { min: number | Amount; max: number | Amount; tiered?: boolean } | \"amplifier\" | Amount; min_level?: number }; wall_cling?: boolean; dodge_roll?: boolean | { cooldown?: number; clip_prefix?: string }; climb?: boolean | { speed?: number; while?: Guard }; wall_run?: boolean; charge?: { speed: number; ramp?: number; max?: number; toward?: \"locked\" | \"marked\"; key?: string; face?: boolean }; lunge?: { ticks: number; distance?: number; speed?: number; along?: \"yaw\" | \"look\"; keep_vertical?: boolean }; swim_boost?: boolean | { per_speed?: number; vertical?: number }; tunnel?: boolean | { floor?: number; blocked_by?: string[] }; no_sprint?: boolean; step_height?: number; drift?: boolean | { friction?: number; accel?: number }; gravity?: number; wall_crawl?: boolean | { sounds?: { left?: string[]; right?: string[] }; backflip?: boolean } }", "doc": "{\"double_jump\": true or jumps or \"level\" or {\"per_level\": jumps, \"level\": level, \"min_level\": level}, \"wall_cling\": true, \"dodge_roll\": true or {\"cooldown\": seconds, \"clip_prefix\": \"dodge_\"}, \"climb\": true or {\"speed\": pull, \"while\": guard}, \"wall_run\": true, \"charge\": {\"speed\": blocks a tick, \"ramp\": per tick, \"max\": blocks a tick, \"toward\": \"locked\" | \"marked\", \"key\": data key, \"face\": true}, \"lunge\": {\"ticks\": n, \"distance\": blocks or \"speed\": blocks a tick, \"along\": \"yaw\" | \"look\", \"keep_vertical\": true}, \"swim_boost\": true or {\"per_speed\": 0.15, \"vertical\": 3}, \"tunnel\": true or {\"floor\": blocks, \"blocked_by\": [block ids]}, \"no_sprint\": true, \"step_height\": blocks, \"drift\": true or {\"friction\": 0.5, \"accel\": 1}, \"gravity\": scale, \"wall_crawl\": true or {\"sounds\": {\"left\": [sound ids], \"right\": [sound ids]}, \"backflip\": true}}: double_jump gives one jump in the air before landing (a number gives that many; 2 is a triple jump; {per_level, level} gives per_level jumps a level, rounded down, none below min_level (default 0), and \"level\" one a level of the ability's own authored level -- a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down); wall_cling holds the wearer on a wall while they sneak in the air, and kicks them off it when they let go moving; dodge_roll rolls them forward or back on the dodge key (default 1.5 s apart, clips forward / back, _air in the air); climb grips the wall ahead (jump climbs, sneak slides down; speed defaults to 0.49; while must hold to grip); wall_run sprints them along walls; charge drives them along where they look every tick, speed blocks a tick growing by ramp a tick up to max -- with toward, straight at a body instead, on all three axes: \"locked\" their lock-on, \"marked\" the one markTarget() stored under key (charge_target), turned to face it unless face is false, and with no such body nothing happens that tick; lunge drives them for ticks ticks from when it starts, at speed (or distance spread over the ticks) along their yaw (level, the default) or look as it started, their own rise and fall kept unless keep_vertical is false; swim_boost, sprinting under water, adds the suit's speed times per_speed (0.15) of their look to their velocity each tick, the vertical vertical (3) times that; tunnel lets them walk through blocks held on top of a floor found up to floor (2) blocks under their feet, with no jumping, and touching a blocked_by block (bedrock, barriers, structure voids, command blocks) ends the move and starts its cooldown. charge, lunge and swim_boost are steered by the wearer's own client, so they read as their own running; no_sprint stops them sprinting at all (the sprint key and double-tap are ignored, no sprint pose, field-of-view kick or sprint particles; pair it with a movement_speed attribute to keep their pace); step_height is how many blocks they walk straight up without jumping (vanilla 0.6, 1 a full block; the higher of theirs and vanilla's); drift eases their speed on the ground in and out on their own client, so they drift on a little when they stop -- friction (0.5) is how much of vanilla's ground friction still applies, accel (1) their top speed times vanilla's; gravity scales how hard they fall while moving down (0.75 a quarter lighter; jumps rise as usual); wall_crawl grips a wall the wearer walks into (forward climbs, back descends, no keys cling, strafe moves along the face and round corners, jump leaps off, sneak lets go, or with backflip leaps back off the face in the swing's back flip) with no web line out, at the ability's amplifier times its base speed, the sounds played on alternate footfalls; put one on a phase to have it for that phase. While the ability is active (a passive: always)" }, "adjust_value": { "type": "string", "doc": "a meter key: the raise and lower speed keys turn this meter up and down (2 a press, 8 sneaking) instead of the speedster dial. \"speed\" is the speedster dial itself. While the ability is active (a passive: always)" }, "flight": { "type": "boolean | { hover?: boolean; fast?: boolean; sprint_to_enter?: boolean; windup?: { ticks: number; requires?: Guard; animation?: string; stages?: Array<{ at: number | \"launch\"; every?: number; do: ActionObject[] }> } }", "doc": "true, or {\"hover\": true, \"fast\": true, \"sprint_to_enter\": bool, \"windup\": {\"ticks\": n, \"requires\": guard, \"animation\": clip, \"stages\": [{\"at\": tick | \"launch\", \"every\": ticks, \"do\": [actions]}]}}: the wearer flies -- hovering as in creative (hover), and tearing along while sprinting in the air (fast; with sprint_to_enter, sprinting in the air starts it by itself, otherwise the suit's flight profile decides). A windup makes fast flight wait until the wearer has sprinted for ticks with requires holding, playing animation as it starts; each of its stages runs its actions (written as action objects) when the wind-up has counted at ticks (0: as it starts), or at \"launch\" -- the first tick fast flight takes over -- and then every every ticks while it lasts. Falls and flying into walls do the flyer no harm, and a hit from a mob or player grounds them for 2 seconds. Speeds come from the suit's flight profile. While the ability is active (a passive: always)" }, "glide": { "type": "boolean | { needs_air_below?: boolean; immune?: boolean; when?: Guard }", "doc": "true, or {\"needs_air_below\": true, \"immune\": true, \"when\": guard}: the wearer glides as on an elytra once airborne (with needs_air_below, only over two blocks of air; with when, only while it holds); immune: flying into a wall does no harm. While the ability is active (a passive: always)" }, "deflect": { "type": "boolean | { projectiles?: boolean; beams?: boolean; reverse?: boolean; take_ownership?: boolean; chance?: number | { per_level: number; level?: number | { min: number | Amount; max: number | Amount; tiered?: boolean } | \"amplifier\" | Amount }; when?: Guard }", "doc": "true, or {\"projectiles\": true, \"beams\": false, \"reverse\": true, \"take_ownership\": true, \"chance\": share or {\"per_level\": share, \"level\": level}, \"when\": guard}: projectiles that would hit the wearer are turned back the way they came (reverse; otherwise they just miss) and become the wearer's (take_ownership); with beams, beams are bounced back at the shooter. chance is the odds of each (default always; per_level x the level, which defaults to the ability's; a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down); with when, only while that guard holds of the wearer. While the ability is active (a passive: always)" }, "affinity": { "type": "{ kind: \"weakness\" | \"resistance\"; element: string; level?: 1 | 2 | 3 | string }", "doc": "{\"kind\": \"weakness\" | \"resistance\", \"element\": damage element, \"level\": 1-3}: how an element treats the suit that has this ability. A weakness makes the element's hits land 16/33/50% harder and brings its debuffs; a resistance soaks as much. level also takes the names: vulnerable/damaging/deadly, mild/normal/strong (1)" } } }, "StateTraitOptions": { "doc": "What phase.traits() may say: the phase-scope traits, true while the wearer is in it. The wearer traits (silentSteps, environment, loot, drawSpeed...) hold for as long.", "fields": { "slows_cooldowns": { "type": "number", "doc": "a fraction 1/n, e.g. 0.2: the wearer's other abilities' cooldowns tick one tick in every n while here" }, "stun_immune": { "type": "boolean", "doc": "true: while here, stuns, an ultimate's lockout and move locks pass this ability by (Run Wild's charge)" }, "unstoppable": { "type": "boolean | { clear: string[] }", "doc": "true, or {\"clear\": [effect ids or groups]}: every tick here, those effects come off the wearer. true clears [stun, thematic:immobile]; groups are [flash, stun]" }, "immune": { "type": "true | { damage?: \"all\" | string[]; grace?: number; tally?: string | { name: string; mode?: \"sum\" | \"last\" }; if?: Guard; unless?: HurtGuard; soak?: boolean }", "doc": "true, or {\"damage\": \"all\" | [damage type ids or #tags], \"grace\": seconds, \"tally\": name | {\"name\", \"mode\": \"sum\"|\"last\"}}: the wearer takes none of that damage while here, nor for grace seconds after. tally writes what was absorbed to _, zeroed on the press. Also \"if\": a guard about the wearer the immunity waits on; \"unless\": a guard about the hit (as a hurt reaction's, e.g. {element: \"emp\"}) whose hits are taken after all; \"soak\": true scales the hit to nothing where armour applies instead of calling it off, so it still lands -- knockback, the flash, the attacker's on-hit effects" }, "hides_swing": { "type": "boolean", "doc": "true: while here, the wearer's own main-hand swing at a living thing under the crosshair is not drawn (pair with cancelEvent() on attack, so the move's own animation shows instead of a punch)" }, "body": { "type": "BodyOptions", "doc": "{\"still_limbs\", \"silent_steps\", \"no_sprint_particles\", \"cape\", \"cape_wrap\", \"cape_flare\", \"launch_lock\", \"pose_grace\", \"pose_claim\"} -- the wearer's body while in this phase" }, "camera": { "type": "CameraOptions", "doc": "{\"no_view_bob\", \"no_flight_sprint\", \"owns_flight_pose\", \"no_flight_tilt\"} -- what the camera and flight leave to the move while in this phase" }, "lock_input": { "type": "InputLockOptions", "doc": "{\"move\", \"pin_position\", \"jump\", \"look\", \"attack\"} -- the wearer's own inputs taken away while in this phase" }, "hide_bones": { "type": "string[] | HideBonesOptions", "doc": "[bone names], or {\"bones\": [...], \"flag\": wearer flag} -- suit bones hidden while in this phase" }, "damage_bonus": { "type": "{ vs?: \"tracked\" | \"any\"; times?: Amount; plus?: Amount; for?: number; track?: string; melee?: boolean; when?: Guard }", "doc": "{\"vs\": \"tracked\" | \"any\", \"times\": share, \"plus\": amount, \"for\": seconds, \"track\": name}: while here, each hit the wearer lands on that target carries amount * times + plus more, inside the hit. vs tracked (default) is the entity thematic:track holds (the track named track, default the ability's id), for seconds counted from when the track started; vs any is everyone, for seconds counted from entering the phase. for left out: the whole phase. melee: true is only the wearer's own melee swings. when: a guard each hit must pass, asked with the body struck as the target and the hit's element and source as the event's" }, "holds_cooldown": { "type": "boolean", "doc": "true: with \"cooldown\": \"on_press\", the cooldown the press started does not count down while here (a dash that has not landed yet); it runs on from the first tick after" }, "attributes": { "type": "{ attribute: string; amount: number; operation?: \"add\" | \"multiply_base\" | \"multiply_total\"; uuid: string }[]", "doc": "attribute modifiers held on the wearer, [{\"attribute\": \"minecraft:generic.movement_speed\", \"amount\": -0.2, \"operation\": \"add\" | \"multiply_base\" | \"multiply_total\", \"uuid\": \"...\"}]: put on under their uuid as the wearer enters the phase, and taken off as they leave it" }, "damage_taken": { "type": "{ times: number; when?: { attackerWithin?: Amount; melee?: boolean; element?: Element | Element[]; notElement?: Element | Element[]; notSource?: string | string[]; attacker?: Guard } }", "doc": "{\"times\": share, \"when\": {\"attacker_within\": blocks, \"melee\": true, \"element\": words, \"not_element\": words}}: while here, every hit on the wearer lands at times its size -- under 1 soaks part of it (where armour counts, so the hit still lands and can be answered), over 1 adds to it (inside the hit); with when, only the hits whose attacker stands within that many blocks (any worked-out number), with melee, that a living body delivers itself rather than anything thrown or shot, with element, made of one of those elements, with not_element, made of none of those, and with attacker, a guard whoever struck it must pass (asked with the attacker as the target: {\"attacker\": {\"marked_by\": \"example_mark\"}} is a hit from someone the wearer marked)" }, "phase": { "type": "true | { if?: Guard; solid?: boolean; density?: boolean }", "doc": "true, or {\"if\": guard, \"solid\": false, \"density\": true}: while here the wearer is phased -- they pass through blocks (noclip, falling through the floor) and their body is drawn density-shifted. solid: true keeps them colliding with the world, the shift only; density: false leaves the body drawn as it is; if: a guard about the wearer the phase waits on (e.g. a suit's option)" }, "environment": { "type": "{ breathe_underwater?: boolean; underwater_vision?: boolean; walk_on_fluid?: boolean; walk_on_powder_snow?: boolean; terrain_speed?: { blocks: string[]; bonus: number; per_level?: number; level?: number | { min: number | Amount; max: number | Amount; tiered?: boolean } | \"amplifier\" | Amount }[]; when?: Guard }", "doc": "{\"breathe_underwater\", \"underwater_vision\", \"walk_on_fluid\", \"walk_on_powder_snow\": true, \"terrain_speed\": [{\"blocks\": [ids or #tags], \"bonus\": speed, \"per_level\": share, \"level\": level}]}: breathing and seeing clearly under water, standing on fluids and on powder snow, and moving bonus * (1 + level * per_level) faster on the named blocks (level defaults to the ability's authored level; a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down); \"when\": a guard asked of the wearer each time, so they hold only while it does (a speedster's water running above a speed). While the wearer is in this phase" }, "neutral_mobs": { "type": "boolean | { mobs: string[] }", "doc": "true, or {\"mobs\": [entity type ids or #tags]}: mobs leave the wearer alone -- true is every mob, hostile NPCs included; mobs names only those. While the wearer is in this phase" }, "silent_steps": { "type": "boolean", "doc": "true: no footstep sounds. While the wearer is in this phase" }, "force_run": { "type": "boolean", "doc": "true: the wearer keeps running forward whatever the keys say. While the wearer is in this phase" }, "vibrating": { "type": "boolean", "doc": "true: the wearer's body vibrates through attacks, as a speedster's mirage copies. While the wearer is in this phase" }, "invisible": { "type": "boolean", "doc": "true: unseen -- others draw no name tag for the wearer. While the wearer is in this phase" }, "fully_invisible": { "type": "boolean", "doc": "true: not drawn at all -- the suit, the body and what it holds (invisible only hides the name tag). While the wearer is in this phase" }, "slow_motion_immune": { "type": "boolean", "doc": "true: slowed time never catches the wearer (the slow_motion move and the slow_time verb skip them). While the wearer is in this phase" }, "heavy": { "type": "boolean", "doc": "true: moves barely shift the wearer -- a push, launch or blast knockback keeps only what their knockback resistance lets through, and never lifts them off the ground. While the wearer is in this phase" }, "loot": { "type": "{ chest_luck?: number | { min: number | Amount; max: number | Amount; tiered?: boolean } | \"amplifier\" | Amount; looting?: number | { min: number | Amount; max: number | Amount; tiered?: boolean } | \"amplifier\" | Amount; when?: Guard }", "doc": "{\"chest_luck\": level, \"looting\": level, \"when\": guard}: extra Luck while opening a loot chest, and extra Looting levels on a kill -- with when, only on a kill whose body passes it, asked as the target ({\"marked_by\": \"quarry_mark\"}); every such move the wearer has adds. a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down. While the wearer is in this phase" }, "enchant_bonus": { "type": "{ item?: \"main_hand\" | \"off_hand\"; when?: Guard; [enchantment: string]: number | { min: number | Amount; max: number | Amount; tiered?: boolean } | \"amplifier\" | Amount | Guard | string | undefined }", "doc": "{\"\": level, ..., \"item\": \"main_hand\" | \"off_hand\", \"when\": guard}: the held item counts as having that many more levels of each enchantment while a block is broken (Fortune on a pickaxe), put back after, and when the wearer attacks with it (Sharpness on a mace: its damage, knockback, fire aspect and sweep count them); with when, only while that guard holds of the wearer. a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down. While the wearer is in this phase" }, "draw_speed": { "type": "number | { times: number; when?: Guard }", "doc": "{\"times\": multiplier, \"when\": guard}: the bow draws times as fast (2 reaches a full draw in half the time); every draw speed the wearer has multiplies; with when, only while that guard holds of the wearer (e.g. {\"riding\": true}). While the wearer is in this phase" }, "movement": { "type": "{ double_jump?: boolean | number | \"level\" | { per_level?: number; level?: number | { min: number | Amount; max: number | Amount; tiered?: boolean } | \"amplifier\" | Amount; min_level?: number }; wall_cling?: boolean; dodge_roll?: boolean | { cooldown?: number; clip_prefix?: string }; climb?: boolean | { speed?: number; while?: Guard }; wall_run?: boolean; charge?: { speed: number; ramp?: number; max?: number; toward?: \"locked\" | \"marked\"; key?: string; face?: boolean }; lunge?: { ticks: number; distance?: number; speed?: number; along?: \"yaw\" | \"look\"; keep_vertical?: boolean }; swim_boost?: boolean | { per_speed?: number; vertical?: number }; tunnel?: boolean | { floor?: number; blocked_by?: string[] }; no_sprint?: boolean; step_height?: number; drift?: boolean | { friction?: number; accel?: number }; gravity?: number; wall_crawl?: boolean | { sounds?: { left?: string[]; right?: string[] }; backflip?: boolean } }", "doc": "{\"double_jump\": true or jumps or \"level\" or {\"per_level\": jumps, \"level\": level, \"min_level\": level}, \"wall_cling\": true, \"dodge_roll\": true or {\"cooldown\": seconds, \"clip_prefix\": \"dodge_\"}, \"climb\": true or {\"speed\": pull, \"while\": guard}, \"wall_run\": true, \"charge\": {\"speed\": blocks a tick, \"ramp\": per tick, \"max\": blocks a tick, \"toward\": \"locked\" | \"marked\", \"key\": data key, \"face\": true}, \"lunge\": {\"ticks\": n, \"distance\": blocks or \"speed\": blocks a tick, \"along\": \"yaw\" | \"look\", \"keep_vertical\": true}, \"swim_boost\": true or {\"per_speed\": 0.15, \"vertical\": 3}, \"tunnel\": true or {\"floor\": blocks, \"blocked_by\": [block ids]}, \"no_sprint\": true, \"step_height\": blocks, \"drift\": true or {\"friction\": 0.5, \"accel\": 1}, \"gravity\": scale, \"wall_crawl\": true or {\"sounds\": {\"left\": [sound ids], \"right\": [sound ids]}, \"backflip\": true}}: double_jump gives one jump in the air before landing (a number gives that many; 2 is a triple jump; {per_level, level} gives per_level jumps a level, rounded down, none below min_level (default 0), and \"level\" one a level of the ability's own authored level -- a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down); wall_cling holds the wearer on a wall while they sneak in the air, and kicks them off it when they let go moving; dodge_roll rolls them forward or back on the dodge key (default 1.5 s apart, clips forward / back, _air in the air); climb grips the wall ahead (jump climbs, sneak slides down; speed defaults to 0.49; while must hold to grip); wall_run sprints them along walls; charge drives them along where they look every tick, speed blocks a tick growing by ramp a tick up to max -- with toward, straight at a body instead, on all three axes: \"locked\" their lock-on, \"marked\" the one markTarget() stored under key (charge_target), turned to face it unless face is false, and with no such body nothing happens that tick; lunge drives them for ticks ticks from when it starts, at speed (or distance spread over the ticks) along their yaw (level, the default) or look as it started, their own rise and fall kept unless keep_vertical is false; swim_boost, sprinting under water, adds the suit's speed times per_speed (0.15) of their look to their velocity each tick, the vertical vertical (3) times that; tunnel lets them walk through blocks held on top of a floor found up to floor (2) blocks under their feet, with no jumping, and touching a blocked_by block (bedrock, barriers, structure voids, command blocks) ends the move and starts its cooldown. charge, lunge and swim_boost are steered by the wearer's own client, so they read as their own running; no_sprint stops them sprinting at all (the sprint key and double-tap are ignored, no sprint pose, field-of-view kick or sprint particles; pair it with a movement_speed attribute to keep their pace); step_height is how many blocks they walk straight up without jumping (vanilla 0.6, 1 a full block; the higher of theirs and vanilla's); drift eases their speed on the ground in and out on their own client, so they drift on a little when they stop -- friction (0.5) is how much of vanilla's ground friction still applies, accel (1) their top speed times vanilla's; gravity scales how hard they fall while moving down (0.75 a quarter lighter; jumps rise as usual); wall_crawl grips a wall the wearer walks into (forward climbs, back descends, no keys cling, strafe moves along the face and round corners, jump leaps off, sneak lets go, or with backflip leaps back off the face in the swing's back flip) with no web line out, at the ability's amplifier times its base speed, the sounds played on alternate footfalls; put one on a phase to have it for that phase. While the wearer is in this phase" }, "flight": { "type": "boolean | { hover?: boolean; fast?: boolean; sprint_to_enter?: boolean; windup?: { ticks: number; requires?: Guard; animation?: string; stages?: Array<{ at: number | \"launch\"; every?: number; do: ActionObject[] }> } }", "doc": "true, or {\"hover\": true, \"fast\": true, \"sprint_to_enter\": bool, \"windup\": {\"ticks\": n, \"requires\": guard, \"animation\": clip, \"stages\": [{\"at\": tick | \"launch\", \"every\": ticks, \"do\": [actions]}]}}: the wearer flies -- hovering as in creative (hover), and tearing along while sprinting in the air (fast; with sprint_to_enter, sprinting in the air starts it by itself, otherwise the suit's flight profile decides). A windup makes fast flight wait until the wearer has sprinted for ticks with requires holding, playing animation as it starts; each of its stages runs its actions (written as action objects) when the wind-up has counted at ticks (0: as it starts), or at \"launch\" -- the first tick fast flight takes over -- and then every every ticks while it lasts. Falls and flying into walls do the flyer no harm, and a hit from a mob or player grounds them for 2 seconds. Speeds come from the suit's flight profile. While the wearer is in this phase" }, "glide": { "type": "boolean | { needs_air_below?: boolean; immune?: boolean; when?: Guard }", "doc": "true, or {\"needs_air_below\": true, \"immune\": true, \"when\": guard}: the wearer glides as on an elytra once airborne (with needs_air_below, only over two blocks of air; with when, only while it holds); immune: flying into a wall does no harm. While the wearer is in this phase" }, "deflect": { "type": "boolean | { projectiles?: boolean; beams?: boolean; reverse?: boolean; take_ownership?: boolean; chance?: number | { per_level: number; level?: number | { min: number | Amount; max: number | Amount; tiered?: boolean } | \"amplifier\" | Amount }; when?: Guard }", "doc": "true, or {\"projectiles\": true, \"beams\": false, \"reverse\": true, \"take_ownership\": true, \"chance\": share or {\"per_level\": share, \"level\": level}, \"when\": guard}: projectiles that would hit the wearer are turned back the way they came (reverse; otherwise they just miss) and become the wearer's (take_ownership); with beams, beams are bounced back at the shooter. chance is the odds of each (default always; per_level x the level, which defaults to the ability's; a level is a whole number, {\"min\", \"max\"} (the ability's level on the starter ladder, scaled between them -- each may be worked out, e.g. the suit's own {\"option\": \"halves_min\", \"else\": 2}; anyone else gets the ability's authored level; \"tiered\": true counts min and max in half levels, an odd half a coin flip each time), \"amplifier\" (the ability's amplifier for the wearer), or any worked-out number ({\"expr\": \"amplifier * level(1, 5)\"}, {\"tuned\": \"amplifier\"}), worked out for the wearer each time and rounded down); with when, only while that guard holds of the wearer. While the wearer is in this phase" } } }, "ThenOptions": { "doc": "How a way out to \"cooldown\" charges it.", "fields": { "fraction": { "type": "number", "doc": "the share of the tuned cooldown charged (1): 0.25 for an armed window that lapsed" }, "seconds": { "type": "number", "doc": "a fixed cooldown instead of the tuned one, unscaled: then(\"cooldown\", { seconds: 30 }) for a lockout" } } }, "LastsOptions": { "doc": "How a phase's deadline runs.", "fields": { "steady": { "type": "boolean", "doc": "true (the default): it runs on every tick, whatever throttles the cooldowns. false: it waits out the throttled ticks" } } }, "UntilOptions": { "doc": "When an until() is checked, and what its way out charges.", "fields": { "check": { "type": "\"before\" | \"after\"", "doc": "after the phase's work this tick (the default), or before it" }, "fraction": { "type": "number", "doc": "for an exit to \"cooldown\": the share of it charged" } } }, "HoldOpenOptions": { "doc": "What keeps a timed phase from running out.", "fields": { "while": { "type": "Guard", "doc": "while it holds, the phase can't run out" }, "end_when": { "type": "Guard", "doc": "while held open, holding ends the phase at once" }, "max": { "type": "number", "doc": "the oldest the phase may be held open, in seconds on the phase clock; left out, no limit" }, "grace": { "type": "number", "doc": "seconds the phase has left while held, so it ends that long after while stops holding (0.1)" }, "then": { "type": "Exit", "doc": "where end_when leads; left out, the phase's own then()" } } }, "RepeatOptions": { "doc": "A running order said over and over on a fixed rhythm.", "fields": { "times": { "type": "number", "doc": "how many repetitions" }, "every": { "type": "number", "doc": "seconds between them. Each lands on tick floor(i * every * 20) ticks" }, "alternate": { "type": "unknown[]", "doc": "values handed to the repetitions in turn, e.g. [\"right_hand\", \"left_hand\"]" } } }, "ArmedOptions": { "doc": "An armed window: the press opens it, the first answer to the event within it pays off.", "fields": { "window": { "type": "\"duration\" | number", "doc": "how long it stays open, in seconds (5)" }, "lapse": { "type": "number", "doc": "the share of the cooldown charged when it lapses with nothing (0.25)" }, "steady": { "type": "boolean", "doc": "the window runs on every tick, whatever throttles the cooldowns (true)" }, "event": { "type": "AbilityEvent", "doc": "what pays it off (attack)" }, "when": { "type": "Guard", "doc": "a guard the event must pass" }, "state": { "type": "string", "doc": "the phase's name (armed)" } } }, "LetValue": { "doc": "How a let() value is drawn: exactly one of these.", "fields": { "random_hue": { "type": "{ saturation?: [number, number]; value?: [number, number]; hue?: [number, number]; as?: \"rgb\" | \"int\" }", "doc": "{\"saturation\": [min, max], \"value\": [min, max], \"hue\": [min, max], \"as\": \"rgb\" | \"int\"} -- a colour of random hue (saturation and value 1 and hue 0..1 when left out), as [r, g, b] each 0 to 1 (\"rgb\", the default; what a dust particle's colour takes) or 0xRRGGBB (\"int\")" }, "random": { "type": "[number, number]", "doc": "[min, max] -- a number drawn between them" }, "pick": { "type": "unknown[]", "doc": "[a, b, ...] -- one of these, any JSON value, picked at random" } } }, "Refusal": { "doc": "What a press turned away by a requirement says on the action bar.", "fields": { "message": { "type": "string", "doc": "a translation key, e.g. \"message.thematic.claws_required\"" }, "color": { "type": "Formatting", "doc": "the message's colour, e.g. \"red\"" } } }, "SoundCycle": { "doc": "A set of sounds, played in turn: each play is the next one, per wearer and per key. A suit re-voices a set with the option sounds: { : id | [ids] }, or mutes it with \"none\".", "fields": { "cycle": { "type": "string[] | string", "doc": "the sound ids in order, or a numbered family's name: \"wolverine_slash\" is wolverine_slash_1, _2, ... as far as sounds.json defines them" }, "key": { "type": "string", "doc": "what the rotation and the suit's sounds option are keyed by; moves sharing a key share one rotation (the family's name, or the first id)" } } }, "SoundLoop": { "doc": "A sound replayed while a phase lasts: run it every tick and it plays on the first, then every so often.", "fields": { "every": { "type": "number | { gauge: number }", "doc": "seconds between plays, counted on the phase's own ticks; or { gauge: n }: whenever a held move's gauge is a multiple of n (Heat Vision's hum every 30)" } } }, "AnimationFit": { "doc": "A clip played at whatever speed makes it fill a window exactly, so it starts and ends with the move however its duration is tuned.", "fields": { "length": { "type": "number", "doc": "the clip's own length, in seconds, as authored (required)" }, "into": { "type": "\"duration\" | \"state\" | number", "doc": "the window: the tuned duration (default), what the running phase has left, or seconds" }, "cycles": { "type": "number | \"round\"", "doc": "how many times it plays in the window (1); round: as many whole times as fit, at least one" } } }, "BodyOptions": { "doc": "The wearer's body while the move runs: body({ stillLimbs: \"whole_body\", silentSteps: true }).", "fields": { "still_limbs": { "type": "boolean | LimbSet | Limb[]", "doc": "limbs held out of the walk cycle so the move's clip owns them; true is all of them" }, "while": { "type": "\"active\" | \"animating\"", "doc": "ability only: \"animating\" holds the body while the pose claim does (claimPose) rather than while the ability is active" }, "pose_claim": { "type": "number", "doc": "phase only: seconds the pose is claimed for on entering the phase (hands the pose over from any other move)" }, "pose_grace": { "type": "number", "doc": "seconds the still limbs outlast the phase, for a follow-through clip" }, "silent_steps": { "type": "boolean", "doc": "no step sounds" }, "no_sprint_particles": { "type": "boolean", "doc": "no sprint dust" }, "cape": { "type": "number", "doc": "degrees the cape is swept to, e.g. -60" }, "cape_wrap": { "type": "number", "doc": "0 to 1: how far the cape is drawn round the front of the body, eased in and out over a few ticks; 1 meets across the chest and face, the leading edge riding a raised right arm" }, "cape_flare": { "type": "number", "doc": "0 to 1: how far the cape is flung open behind like a bat's wings; it snaps open and settles back over half a second once the phase ends" }, "launch_lock": { "type": "boolean | { grace?: number }", "doc": "flight and movement leave the wearer's velocity alone while the move runs, and for grace seconds after" } } }, "CameraOptions": { "doc": "What the camera and flight leave to the move.", "fields": { "no_view_bob": { "type": "boolean", "doc": "the first-person view does not bob" }, "no_flight_sprint": { "type": "boolean", "doc": "hover does not hand over to fast flight" }, "owns_flight_pose": { "type": "boolean", "doc": "the flight clips stand aside so the move's clip poses the body" }, "no_flight_tilt": { "type": "boolean", "doc": "no fast-flight lean or hover bank on the body" } } }, "InputLockOptions": { "doc": "The wearer's own inputs taken away while the move runs.", "fields": { "move": { "type": "boolean", "doc": "walking keys do nothing" }, "pin_position": { "type": "boolean", "doc": "held at the x/z stood on when the lock began, knockback included" }, "jump": { "type": "boolean", "doc": "the jump key does nothing" }, "look": { "type": "boolean", "doc": "the mouse does not turn the view" }, "attack": { "type": "boolean", "doc": "the wearer lands no melee blow: a swing does nothing (a brace that cannot strike back)" } } }, "HideBonesOptions": { "doc": "When hidden suit bones are hidden.", "fields": { "bones": { "type": "string[]", "doc": "the bones; hideBones() fills this from its first argument" }, "flag": { "type": "string", "doc": "only while this wearer flag (setFlag) is also true" }, "while": { "type": "\"active\" | \"cooldown\"", "doc": "ability only: \"cooldown\" hides them while the ability cools down instead" } } }, "MobOptions": { "doc": "How a mob uses the move: mob(). What it does goes in mob()'s callback.", "fields": { "min_range": { "type": "number", "doc": "the mob only uses it on a target at least this far off, in blocks (0)" }, "max_range": { "type": "number", "doc": "and no further than this (16)" }, "cooldown": { "type": "number", "doc": "seconds before the mob may use it again; its own pacing, not the CSV cooldown (0)" }, "weight": { "type": "number", "doc": "how often the controller picks it, against the mob's other moves of the same priority in range (10)" }, "priority": { "type": "number | { value: number; when?: Guard } | Array", "doc": "how much the controller wants it: a number, {value, when}, or a list of those; the highest value whose when holds counts (0 with none). The highest-priority move that may be used now wins; weight breaks ties (0)" }, "lasts": { "type": "number", "doc": "seconds a channel runs; left out, a one-shot use" }, "active": { "type": "boolean", "doc": "true: the ability counts as active while the channel runs, so its visuals draw for the mob (false)" }, "until_blocked": { "type": "boolean", "doc": "a channel ends when the ability becomes blocked (true)" }, "until": { "type": "Guard", "doc": "a guard asked before each of a channel's ticks; once it holds, the channel ends" }, "needs_target": { "type": "boolean", "doc": "true: the mob only uses it with a target to aim at, and declines it otherwise (false)" }, "when": { "type": "Guard", "doc": "a guard the controller asks before it picks the move, of the mob with its target as the target (e.g. { target: { airborne: true } }); the move is left alone while it fails" } } }, "GaugeOptions": { "doc": "A hold's heat meter: gauge({ max: 8, fill: 2, drain: 2, startsAt: 0.5 }).", "fields": { "max": { "type": "Amount", "doc": "seconds of heat the gauge holds, a number or tuned(\"duration\"); a full gauge lets go of the key (required)" }, "fill": { "type": "Amount", "doc": "ticks of heat added per tick held, a number or tuned(\"amplifier\") (1); fractions are kept" }, "drain": { "type": "number", "doc": "whole ticks of heat taken off per tick not held, one at a time while there is heat left (1)" }, "drain_while_holding": { "type": "boolean", "doc": "false: it only cools while no ability key at all is held, as the breaths did (true)" }, "starts_at": { "type": "number", "doc": "seconds of heat the gauge must hold before the held phase's ticks run (0); the fill and loop start at once. Heat Vision's beam: 0.5" }, "restart": { "type": "\"empty\" | \"any\"", "doc": "when a released hold can be taken up again: empty (default), once the gauge has drained to nothing; any, whenever it is not full" }, "loop": { "type": "GaugeLoop", "doc": "{\"sound\", \"every\" (seconds of heat), \"volume\", \"pitch\", \"stop\"} replayed while held, each time the gauge reaches a multiple of every; see loop fields" }, "boosts": { "type": "GaugeBoost[]", "doc": "[{\"if\": guard, \"max_times\", \"fill\", \"drain\"}] -- changes while their guard holds, applied in order" } } }, "GaugeLoop": { "doc": "A sound replayed while the gauge fills: { sound: \"heat_vision\", every: 1.5 }.", "fields": { "sound": { "type": "string", "doc": "the sound id; a suit's sound option still re-voices it (required)" }, "every": { "type": "number", "doc": "seconds of heat between plays: it plays whenever the heat, before this tick's fill, is an exact multiple (required)" }, "volume": { "type": "number", "doc": "volume (1)" }, "pitch": { "type": "number", "doc": "pitch (1)" }, "stop": { "type": "\"released\" | \"blocked\"", "doc": "when every client cuts it off: released (default), when the key is let go of, the gauge is full or the move is blocked, as Heat Vision's hum; blocked, only when full or blocked, as the breaths' puffs" } } }, "GaugeBoost": { "doc": "A change to the gauge while a guard holds: { if: { active: \"solar_absorption\" }, fill: 1, drain: 4 }. Boosts apply in order; each one whose guard holds multiplies the max and replaces fill and drain.", "fields": { "if": { "type": "Guard", "doc": "while this holds" }, "max_times": { "type": "number", "doc": "the max multiplied by this, then floored to whole ticks (1)" }, "fill": { "type": "Amount", "doc": "the fill instead" }, "drain": { "type": "number", "doc": "the drain instead" } } }, "ProjectileLook": { "doc": "How a projectile is drawn. Settled when it is fired and carried with it, so the renderer never looks at the owner's suit. Only the chosen style's options are allowed.", "fields": { "style": { "type": "LookStyle", "doc": "which renderer draws it (bolt for a bolt, model for a thrown body)" }, "color": { "type": "Color | number", "doc": "bolt: the halo's colour (assets.beam endColor, else #FF0000); streak: the glow's colour (0x3373CC); rod: its colour ([0.25, 1, 0.35], starbolt green); crescent: its colour ([0.2, 0.45, 0.8]); lightning: its colour (white; give the projectile color: \"$suit_color\" for the wearer's suit colour, as the Java bolt took it); feather: multiplied into the texture (white: as painted); polka_dot: its colour (white; give the projectile color: [\"#FFFF00\", \"#0000FF\", \"#FF0000\"] to pick one per dot); bullet: multiplied into the texture (white: as painted); disc: its face's colour (#9DB7FF)" }, "core_color": { "type": "Color | number", "doc": "bolt: the core's colour (assets.beam startColor, else #FFFFFF); streak: the core's colour (0xFFFFFF)" }, "width": { "type": "number", "doc": "bolt: the core's half-width, blocks (assets.beam size, else 0.025)" }, "glow": { "type": "number", "doc": "bolt: how far the halo reaches past the core, blocks (assets.beam glowSize, else 0.25)" }, "count": { "type": "number", "doc": "bolt: bolts side by side (assets.beam count, else 2); particles: particles shed a tick (5)" }, "spacing": { "type": "number", "doc": "bolt: blocks between them (assets.beam spacing, else 0.1)" }, "opacity": { "type": "number", "doc": "bolt: the halo's opacity at its core, 0 to 1 (assets.beam thirdPersonOpacity, else 1)" }, "texture": { "type": "string", "doc": "bolt: a beam texture id; empty for the plain glow (assets.beam texture); feather: its texture id (thematic:textures/entity/nth_projectile.png); polka_dot: the disc's texture id (thematic:textures/particle/sonic_beam.png); bullet: its texture id (thematic:textures/effect/bullet_yellow.png)" }, "stretch": { "type": "number", "doc": "bolt: blocks of length per block a tick of speed (3)" }, "max_length": { "type": "number", "doc": "bolt: the longest it is drawn, blocks (3)" }, "halo": { "type": "number", "doc": "bolt: halo planes (8); disc: the soft halo's reach past the rim, as a share of the radius; 0 for none (0.6)" }, "appear_after": { "type": "number", "doc": "bolt: seconds of flight before it is drawn, so it does not start inside the shooter's head (0.1); streak: seconds of flight before it is drawn (0.05); rod: seconds of flight before it is drawn (0.05); disc: seconds of flight before it is drawn (0.05)" }, "radius": { "type": "number", "doc": "streak: the core's radius, blocks (0.06); rod: blocks (0.3); crescent: blocks (2.4); disc: blocks (0.55)" }, "glow_radius": { "type": "number", "doc": "streak: the glow's radius, blocks (0.18)" }, "length": { "type": "number", "doc": "streak: blocks (2); rod: blocks (1)" }, "helix": { "type": "boolean", "doc": "streak: the twin helix round it (true)" }, "alpha": { "type": "number", "doc": "rod: its opacity, 0 to 1 (1); crescent: its opacity at the peak of the flash, 0 to 1 (0.95); polka_dot: its opacity, 0 to 1 (200/255); disc: its opacity, 0 to 1 (0.8)" }, "caps": { "type": "boolean", "doc": "rod: discs closing both ends (true)" }, "grow": { "type": "[number, number]", "doc": "crescent: [from, to] the radius's scale across the sweep ([0.7, 1.2])" }, "horns": { "type": "[number, number]", "doc": "crescent: [from, to] the horns' half-angle, degrees, across the sweep ([35, 72])" }, "thickness": { "type": "[number, number]", "doc": "crescent: [from, to] its thickness as a share of the radius across the sweep ([0.16, 0.3])" }, "tilt": { "type": "number", "doc": "crescent: degrees it is rolled (45); disc: degrees it is rolled about its flight, outward from the thrower's side (25)" }, "y_offset": { "type": "number", "doc": "crescent: blocks above the projectile it is drawn; negative is below (-1.6)" }, "sweep": { "type": "number", "doc": "crescent: seconds it takes to open, fading out as it does (0.6)" }, "tint": { "type": "Color | number", "doc": "model: the colour of what it carries: 0xRRGGBB, \"#RRGGBB\", [r, g, b] 0 to 1, or \"$name\" for a press value" }, "intensity": { "type": "number", "doc": "lightning: how jagged it is, 0.1 to 2 (0.5); the line is 1 + 2.5 times this many blocks long" }, "item": { "type": "string", "doc": "orb: the item drawn (minecraft:snowball)" }, "scale": { "type": "number", "doc": "orb: its size (1); feather: its size (1); bullet: its size (1)" }, "model": { "type": "string", "doc": "feather: a GeckoLib model id (thematic:geo/entity/nth_projectile.geo.json); bullet: a GeckoLib model id (thematic:geo/entity/bullet.geo.json)" }, "layer": { "type": "string", "doc": "feather: cutout (its texture as painted) or beam (unlit and see-through over it, as a ring construct glows) (cutout); bullet: cutout (its texture as painted) or beam (unlit and see-through over it, as a ring construct glows) (cutout)" }, "size": { "type": "number", "doc": "polka_dot: its diameter, blocks (0.2)" }, "pulse": { "type": "number", "doc": "polka_dot: how much the diameter swells and shrinks, blocks (0.05)" }, "particle": { "type": "ParticleSpec", "doc": "particles: the particle shed: an id, or {\"type\": \"minecraft:dust\", \"color\": [r, g, b], \"scale\": 1} (minecraft:flame; a move firing it from Java code may hand it its own)" }, "rim_color": { "type": "Color | number", "doc": "disc: its rim's and blades' colour (#E6DEFF)" }, "spin": { "type": "number", "doc": "disc: degrees a tick its blades turn (40)" }, "rings": { "type": "number", "doc": "disc: concentric rings in its face, 0 to 6 (3)" }, "blades": { "type": "number", "doc": "disc: bright arcs spinning on its rim, 0 to 6 (3)" }, "ghosts": { "type": "number", "doc": "disc: fading copies trailing behind it, 0 to 6 (3)" }, "return_glow": { "type": "number", "doc": "disc: how much brighter it burns flying back towards its thrower (1.4)" } } }, "Ricochet": { "doc": "A bolt bouncing off blocks and re-aiming at someone else (Perfect Angle's defaults).", "fields": { "max": { "type": "number", "doc": "bounces before a block spends it (3)" }, "damp": { "type": "{ vertical?: number, horizontal?: number }", "doc": "the share of speed kept off a floor or ceiling (0.6) and off a wall (0.7)" }, "min_speed": { "type": "number", "doc": "the slowest it leaves a bounce, blocks a tick (0.6)" }, "retarget": { "type": "{ range?: number, speed?: number, prefer?: \"players\" | \"nearest\", lineOfSight?: \"owner\" | \"none\" }", "doc": "who it turns to after a bounce: within range blocks (15), someone it has not hit, the shooter may hit and (owner) can see; a player before anything nearer (players); re-aimed at their eyes at speed (1.4)" }, "discard_without_target": { "type": "boolean", "doc": "no one to turn to: it is gone (true)" }, "sound": { "type": "string | { id: string, volume?: number, pitch?: number }", "doc": "played at each bounce; \"none\" for silence (minecraft:block.anvil.land, 0.6, 1.8)" } } }, "Recoil": { "doc": "The shooter shoved back along a bolt's flight when it meets a block.", "fields": { "per": { "type": "\"cooldown\"", "doc": "what scale is per: each tick of the move's cooldown still to run" }, "scale": { "type": "number", "doc": "blocks a tick of push per tick of cooldown (0.005)" }, "max": { "type": "number", "doc": "the most it pushes, blocks a tick (0.75)" } } }, "Trail": { "doc": "Particles a projectile sheds in flight, spawned by the server so everyone watching sees them.", "fields": { "particle": { "type": "ParticleSpec", "doc": "the particle (minecraft:smoke); dust(\"$mixture\", 0.8) for drops of what it carries" }, "color": { "type": "Color", "doc": "recolours dust, as particles() does" }, "count": { "type": "number", "doc": "how many at a time (1)" }, "spread": { "type": "number", "doc": "blocks either side of it on each axis (0)" }, "y_offset": { "type": "number", "doc": "blocks above it (0)" }, "every": { "type": "number", "doc": "seconds between drops (0.05, every tick)" } } }, "ProjectilePattern": { "doc": "How the shots of one firing (count of them) are laid out. Written as the shape alone, e.g. \"ring\", or with its options.", "fields": { "shape": { "type": "PatternShape", "doc": "ring, fan, converge, rain or spiral" }, "pitch": { "type": "number", "doc": "ring: degrees they leave at, negative up (0, level)" }, "offset": { "type": "number", "doc": "ring: degrees round from the aim the first leaves at (0)" }, "lanes": { "type": "number", "doc": "fan: lanes the shots are dealt across, the nth down lane n % lanes (0: one each)" }, "spread": { "type": "number", "doc": "fan: degrees of yaw from the first lane to the last, centred on the aim (30)" }, "yaw_offsets": { "type": "number[]", "doc": "fan: the lanes by hand, degrees of yaw each, the nth shot down yawOffsets[n % length] (in place of lanes and spread); rain around look: degrees the nth shot's look is turned before it finds what it falls around -- [-10, 10] pairs the beats either side of the aim" }, "radius": { "type": "number | Amount", "doc": "converge: blocks round the anchor they leave from (2); rain: blocks round the centre they start within (the tuned radius); spiral: the circle's radius, blocks (8)" }, "distance": { "type": "number", "doc": "converge: with no target, blocks along the aim where they meet (16); a toward spot wins" }, "height": { "type": "number", "doc": "rain: blocks over the centre they start (12.5); spiral: blocks over the wearer's feet (15)" }, "around": { "type": "RainAround", "doc": "rain: what it falls around (self); nothing falls with no target or no spot" }, "reach": { "type": "number | Amount", "doc": "rain around look: how far the wearer's look reaches, blocks (32); a worked-out number is worked out as it fires" }, "turns": { "type": "number", "doc": "spiral: how many times round the circle the count shots are laid, the first due south of the wearer (1); 12 shots on 1.5 turns land 8 to a turn" }, "jitter": { "type": "number", "doc": "spiral: blocks either way on each level axis each one strays from straight down (1)" } } }, "Formation": { "doc": "The shots of one firing in a grid across the look (PowerMissile's clusters): columns x rows x clusters of them from each anchor, in place of count.", "fields": { "grid": { "type": "[number, number]", "doc": "[columns, rows]" }, "spacing": { "type": "number", "doc": "blocks between neighbours (1.2)" }, "clusters": { "type": "number", "doc": "grids side by side (1)" }, "cluster_spacing": { "type": "number", "doc": "blocks between the grids' middles (5)" }, "forward": { "type": "number", "doc": "blocks out along the look (0.75)" }, "flatten_low_rows": { "type": "boolean", "doc": "the rows below the middle stand at its height (false)" } } }, "Homing": { "doc": "Turning onto someone each tick: the velocity moved strength of the way toward their eyes at speed, then set back to speed. With nobody to turn to it flies on as it goes.", "fields": { "target": { "type": "HomingSeek", "doc": "who (target)" }, "strength": { "type": "number", "doc": "how much of the way it turns each tick, above 0 to 1 (0.2)" }, "speed": { "type": "number", "doc": "blocks a tick while homing (the speed it was fired at)" }, "range": { "type": "number", "doc": "nearest: blocks round it to look in (16)" } } }, "Hover": { "doc": "Held still where it was made, then let go.", "fields": { "seconds": { "type": "number", "doc": "how long (0.5)" }, "stagger": { "type": "number", "doc": "seconds more for each formation row below it (each shot before it, with no formation) (0)" }, "then": { "type": "FlightRelease", "doc": "how it is let go (keep)" } } }, "Orbit": { "doc": "Round the wearer's middle, bobbing (Triple Card's cards); gone with the wearer. It strikes what it meets on the way round, as it would in flight.", "fields": { "radius": { "type": "number", "doc": "blocks out (2.2)" }, "height": { "type": "number", "doc": "blocks above the wearer's middle (1.5)" }, "speed": { "type": "number", "doc": "radians a tick round (0.2)" }, "bob": { "type": "number", "doc": "blocks it bobs either way (0.8)" }, "bob_speed": { "type": "number", "doc": "radians a tick of the bob (0.05)" }, "count": { "type": "number", "doc": "how many share the ring, the nth starting n / count of the way round (the firing's count)" }, "seconds": { "type": "number", "doc": "how long it orbits (25)" }, "then": { "type": "FlightRelease", "doc": "how it is let go after (discard)" }, "step": { "type": "OrbitStep", "doc": "what each shot after the first adds to the numbers, the nth n times over (Triple Card: radius and height 0.15, speed 0.02, bob 0.1, bob_speed 0.01)" } } }, "OrbitStep": { "doc": "What each orbiting shot after the first adds to its orbit's numbers.", "fields": { "radius": { "type": "number", "doc": "blocks (0)" }, "height": { "type": "number", "doc": "blocks (0)" }, "speed": { "type": "number", "doc": "radians a tick (0)" }, "bob": { "type": "number", "doc": "blocks (0)" }, "bob_speed": { "type": "number", "doc": "radians a tick (0)" } } }, "BoltPierce": { "doc": "A bolt flying through the bodies a guard does not hold for and striking those it does (Conflagration's cinder: through a cold crowd, off on a burning body).", "fields": { "unless": { "type": "Guard", "doc": "asked of each body it meets, as the target ({ target: { onFire: true } }): it strikes those this holds for -- fully: on_hit, the direct hit (flat or none), the effects -- and flies straight through the rest, untouched; left out, it strikes every body" }, "max": { "type": "number", "doc": "bodies it strikes before it is spent (0: never by bodies); with a return it turns home instead" } } }, "BoltReturn": { "doc": "A bolt turning back to its shooter and caught there (the thrown body's return, for a bolt): on_return runs at the shooter. On the way home it passes its shooter by, and a body it strikes spends it.", "fields": { "mode": { "type": "\"direct\" | \"pull\"", "doc": "direct: straight at the shooter's chest at speed; pull: drawn home keeping its motion, rising toward their eyes (direct)" }, "after_ticks": { "type": "number", "doc": "ticks out before it turns by itself; -1 never (direct 17, pull -1)" }, "on_entity_hit": { "type": "boolean", "doc": "striking a body turns it home rather than spending it (after_hit is its other name)" }, "max_distance": { "type": "number", "doc": "blocks from where it left beyond which it turns (0: no limit)" }, "on_block": { "type": "boolean", "doc": "meeting a block turns it home, after on_block runs, rather than spending it (false)" }, "speed": { "type": "number", "doc": "blocks a tick home (direct 1; pull 0.07)" }, "catch_distance": { "type": "number", "doc": "blocks from the shooter's chest it is caught within (direct 1.5; 0: within a block of home)" }, "rise": { "type": "number", "doc": "pull: the share of the gap to the shooter's eye line it rises a tick (0.075)" }, "noclip": { "type": "boolean", "doc": "it passes through blocks on the way home (pull true, direct false); otherwise a wall spends it" }, "rehit": { "type": "boolean", "doc": "turning back forgets who it struck, so a piercing bolt strikes each body again on the way home (false)" }, "sound": { "type": "string", "doc": "played as it turns; \"none\" for silence (minecraft:item.trident.return)" }, "volume": { "type": "number", "doc": "(10)" } } }, "Wobble": { "doc": "Its heading nudged each tick along three sine waves, its speed kept (the polka dots); each projectile picks its own radius and speed from the ranges.", "fields": { "radius": { "type": "number | [number, number]", "doc": "how far it strays ([0.5, 2])" }, "speed": { "type": "number | [number, number]", "doc": "how fast the waves run ([0.2, 0.5])" } } }, "SpotOrigin": { "doc": "Leaving over the spot the press fixed (mark_spot, find_block), or from the ability's own flight_path model where it is now (flight); nothing is fired with no spot, or while it is not flying.", "fields": { "spot": { "type": "true", "doc": "from the spot" }, "flight": { "type": "true", "doc": "from the ability's thematic:flight_path model instead (its lead copy): what a flown craft fires from" }, "above": { "type": "number", "doc": "blocks over it (0)" }, "scatter": { "type": "number", "doc": "up to this many blocks either way on x and on z (0)" } } }, "SpotToward": { "doc": "Aimed at the spot the press fixed; with no spot it is aimed as it would have been.", "fields": { "spot": { "type": "true", "doc": "at the spot" }, "scatter": { "type": "number", "doc": "up to this many blocks either way on x and on z (0)" } } }, "ExplodeOnImpact": { "doc": "Thematic's explosion where it lands, added to on_hit and on_block: the tuned damage to everyone in the tuned radius the shooter may hit.", "fields": { "damage": { "type": "number", "doc": "left out, the tuned damage" }, "radius": { "type": "number", "doc": "left out, the tuned radius" }, "fire": { "type": "boolean", "doc": "sets fires (false)" }, "fire_seconds": { "type": "number", "doc": "sets those caught burning (0)" }, "break_blocks": { "type": "boolean", "doc": "breaks blocks (false)" }, "shockwave": { "type": "boolean", "doc": "knocks them back (false)" }, "shockwave_damage": { "type": "number", "doc": "what the shockwave itself deals (0)" } } }, "ConsumeHeld": { "doc": "An item each projectile takes out of the wearer's hands as it leaves.", "fields": { "item": { "type": "string", "doc": "an item id, or #tag" }, "required": { "type": "boolean", "doc": "not fired when neither hand holds one (true)" } } }, "BurstScatter": { "doc": "A spot at random around a point, at the same height: Containment Suit's vents.", "fields": { "around": { "type": "BurstAt", "doc": "around where (here)" }, "distance": { "type": "number | [number, number]", "doc": "how far out, in blocks: one distance, or [nearest, furthest]" } } }, "BurstEffect": { "doc": "The status effect a burst leaves on everyone it catches.", "fields": { "id": { "type": "string", "doc": "the effect, e.g. \"minecraft:slowness\"; \"none\" for none unless the suit's option names one" }, "duration": { "type": "Amount", "doc": "seconds; left out, the ability's tuned duration" }, "amplifier": { "type": "Amount", "doc": "0 is level I; left out, the tuned amplifier" }, "option": { "type": "string", "doc": "a suit option that re-picks it, e.g. \"blast_effect\": an effect id or \"none\"; with it,