Effects

An effect is one action an enchant (or armor set, or crystal) performs when it fires. You list effects under the effects: key of a level, and each one is a block map shaped like { HEAD: { param: value } }:

levels:
  1:
    chance: 25                            # 25% chance to fire on the trigger
    effects:
      - { DAMAGE: { amount: 6 } }         # deal 6 extra damage
      - { IGNITE: { duration: 60 } }      # set the victim on fire for 60 ticks (3s)
      - { MESSAGE: { text: "&cBurn!" } }  # tell the player

• HEAD is the effect name (always uppercase), e.g. DAMAGE, POTION, BREAK_BLOCK.
• The body is a map of named parameters. Required params must be set; optional ones have sensible defaults you can omit. Each effect card below lists its parameters.
• Many effects also accept a target selector via the who: key to change who they act on — e.g. who: "@Aoe{r=6}" — see Selectors. When you don't set one, the effect uses its default target (shown in each card below).
• An optional wait: <ticks> key delays a single effect; the rest of the list keeps running.

:::tip Ticks are the unit of time Anywhere you see a duration, it's measured in ticks, and 20 ticks = 1 second. So { IGNITE: { duration: 60 } } burns for 3 seconds, and { FLY: { ticks: 200 } } grants 10 seconds of flight. :::

:::note Reading the "How it runs" line Each effect card shows where the effect runs:

• Runs inline — happens immediately as part of the triggering event (e.g. adjusting the combat hit). The fastest path.
• Acts on an entity — does something to a living target (heal, ignite, potion).
• Acts on the world — touches blocks or spawns things at a location.
• Runs globally — server-wide work, like console commands.

You don't have to manage any of this — it's just to help you picture what each effect touches. :::

• Combat & damage
• Debuffs & control on a target
• Movement
• Blocks & world
• Economy & items
• Health & survival
• Cosmetic & feedback
• Utility & flow
• Everything else

Combat & damage

Shape the hit itself — extra damage, the additive damage fold, lightning, explosions, and on-hit kills.

DAMAGE

Runs inline

Deal extra damage to the target: a flat amount and/or percent-of-max of the target's own maximum health (they sum when both are given).

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
amount	a number (decimals allowed)	optional	0	0 or more
percent-of-max	a number (decimals allowed)	optional	0	0 to 100
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ DAMAGE: { amount: 6, percent-of-max: 10 } }

DAMAGE_MOD

Runs inline

Contribute to the damage fold: side attack/defense, mode add (percent) or flat (raw amount). A NEGATIVE amount is a self-nerf — attack:add:-50 halves your own outgoing damage. Replaces ADD_DAMAGE/REDUCE_DAMAGE/FLAT_DAMAGE/FLAT_REDUCE.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
side	one of: attack, defense	required	—	attack | defense
mode	one of: add, flat	optional	add	add | flat
amount	a number (decimals allowed)	required	—	—

Example{ DAMAGE_MOD: { side: attack, mode: add, amount: 25 } }

IGNORE_ARMOR

Runs inline

Make the triggering hit ignore the victim's armor and enchant-protection reduction.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Takes no arguments.

Example{ IGNORE_ARMOR: {} }

KILL

Acts on an entity

Instantly kill the target.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ KILL: {} }

LIGHTNING

Acts on an entity

Strike the target(s) with lightning, optionally dealing extra damage (0 = cosmetic).

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
damage	a number (decimals allowed)	optional	0	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ LIGHTNING: { damage: 6 } }

EXPLODE

Acts on the world

Create an explosion at the target.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
power	a number (decimals allowed)	required	—	0 or more
breakBlocks	true or false	optional	false	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ EXPLODE: { power: 4, breakBlocks: false } }

PROJECTILE

Acts on an entity

Launch count projectiles of a type from the activator's eye (covers SPAWN_ARROWS via the ARROW type). For an explosive projectile, yield sets the blast (-1 = vanilla default) and incendiary lights fires.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at.

Argument	What to put	Required?	Default	Allowed
type	a mob/entity type (e.g. WOLF, IRON_GOLEM)	required	—	—
count	a whole number	optional	1	1 or more
speed	a number (decimals allowed)	optional	1.5	0 or more
yield	a number (decimals allowed)	optional	-1	—
incendiary	true or false	optional	false	—

Example{ PROJECTILE: { type: FIREBALL, count: 1, speed: 1.5, yield: 2, incendiary: true } }

SEEK

Runs inline

Make the projectile fired by this BOW_FIRE activation home onto the nearest target in sight.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Takes no arguments.

Example{ SEEK: {} }

IMMUNE

Runs inline

Make the target player(s) immune to a damage cause (sword/axe/projectile/potion/all) for duration ticks; fishhook additionally kills the rod-bobber reel pull (ADR-0053).

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
type	one of: sword, axe, projectile, potion, all, fishhook	required	—	sword | axe | projectile | potion | all | fishhook
duration	a duration in ticks (20 ticks = 1 second)	optional	100	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ IMMUNE: { type: potion, duration: 100 } }

INVINCIBLE

Acts on an entity

Make the target invulnerable for a span of ticks, then restore.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
ticks	a duration in ticks (20 ticks = 1 second)	optional	100	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ INVINCIBLE: { ticks: 100 } }

Debuffs & control on a target

Apply or strip status on whoever you hit — potions, fire, disarm, armour stripping, teleport-block, and suppressing their enchants.

POTION

Acts on an entity

Apply a potion effect to the target(s) at the given LEVEL (1-based: level 1 = the I tier), for a duration in ticks. The effect name is resolved to a handle at compile time. On a HELD/PASSIVE source it is removed again when the item is unequipped (§B lifecycle).

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
effect	a potion-effect name (e.g. STRENGTH, POISON)	required	—	—
level	a whole number	required	—	1 or more
duration	a duration in ticks (20 ticks = 1 second)	required	—	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ POTION: { effect: STRENGTH, level: 1, duration: 100 } }

REMOVE_POTION

Acts on an entity

Remove a potion effect from the target(s).

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
effect	a potion-effect name (e.g. STRENGTH, POISON)	required	—	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ REMOVE_POTION: { effect: POISON } }

CURE

Acts on an entity

Clear active potion effects of one category from the target(s): ALL (default), HARMFUL, BENEFICIAL, or NEUTRAL. category HARMFUL strips only debuffs (positive effects untouched). count bounds how many matching effects are removed (0 = all of them) in the server's own enumeration order — a count: 1 HARMFUL cure strips exactly one debuff, whichever the server lists first.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
category	one of: ALL, HARMFUL, BENEFICIAL, NEUTRAL	optional	ALL	ALL | HARMFUL | BENEFICIAL | NEUTRAL
count	a whole number — remove at most this many effects; 0 = every match	optional	0	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ CURE: { category: HARMFUL } }

IGNITE

Acts on an entity

Set the target(s) on fire for a duration in ticks.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
duration	a duration in ticks (20 ticks = 1 second)	required	—	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ IGNITE: { duration: 60 } }

EXTINGUISH

Acts on an entity

Put out the target's fire.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ EXTINGUISH: {} }

DISARM

Acts on an entity

Make the target(s) drop their held (main-hand) item.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ DISARM: {} }

REMOVE_ARMOR

Acts on an entity

Strip one random worn armour piece from the target(s) and drop it.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ REMOVE_ARMOR: {} }

TELEBLOCK

Runs inline

Block the target player(s) from teleporting (ender pearl / chorus fruit) for duration ticks.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
duration	a duration in ticks (20 ticks = 1 second)	optional	400	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ TELEBLOCK: { duration: 400 } }

SUPPRESS

Runs inline

Disable a target's enchant/group/type (the key) for a duration in ticks (DISABLE_ENCHANT/GROUP/TYPE), or with scope KIND every ability carrying the keyed effect head (e.g. MODIFY_FOOD). scope TYPE keys the ability's combat direction (DEFENSE / ATTACK) unless it authored a suppress-type of its own, so key: DEFENSE silences everything a victim's gear does back. mode: timed (the duration window) or next-hit (a one-shot that clears after the target's next `charges` incoming hits, Neutralize). The consumed-* params are emitted at the moment the suppression blocks something, not when it is armed, and fill {ATTACKER} with whoever armed it and {VICTIM} with the player it silenced. Default target the combat victim.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
scope	one of: ENCHANT, GROUP, TYPE, KIND	required	—	ENCHANT | GROUP | TYPE | KIND
key	text	required	—	—
duration	a duration in ticks (20 ticks = 1 second)	optional	200	0 or more
mode	one of: timed, next-hit	optional	timed	timed | next-hit
charges	a whole number	optional	1	1 or more
consumed-message-actor	text — line to whoever armed this, when it blocks	optional	(empty)	—
consumed-message-victim	text — line to the suppressed player, when it blocks	optional	(empty)	—
consumed-sound	a sound name (e.g. ENTITY_GENERIC_EXPLODE) — cue played at the block; omit for silence	optional	—	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ SUPPRESS: { scope: GROUP, key: lifesteal, duration: 200, who: "@Victim" } }

KNOCKBACK_CONTROL

Runs inline

Scale the target's incoming knockback for duration ticks: 0 cancels it, 0.5 halves it, 2 doubles it (default: cancel for 2 ticks). Use on DEFENSE for your own knockback, or on ATTACK with who: victim for the knockback you deal.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
multiplier	a number (decimals allowed)	optional	0	0 or more
duration	a duration in ticks (20 ticks = 1 second)	optional	2	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ KNOCKBACK_CONTROL: { multiplier: 0 } }

Movement

Move bodies around — flight, walk speed, knockback/velocity, and teleporting.

FLY

Acts on an entity

Grant the player temporary flight. speed overrides their fly speed for the window and is restored with it (0, the default, leaves the server's own fly speed alone).

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
ticks	a duration in ticks (20 ticks = 1 second)	optional	200	0 or more
speed	a number (decimals allowed) — fly speed while the window holds; 0 keeps the server's	optional	0	0 to 1
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ FLY: { ticks: 200 } }

MOVEMENT_SPEED

Acts on an entity

Set the player target's walk speed for a span of ticks, then restore the default (0.2). hold keeps it instead of scheduling that restore, for a debuff whose life is a STACK COUNT rather than a clock — the caller then owns handing it back, and the only thing the engine still guarantees is that a logout restores 0.2 rather than persisting an altered speed to disk. ticks is ignored when hold is set.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
speed	a number (decimals allowed)	required	—	-1 to 1
ticks	a duration in ticks (20 ticks = 1 second)	optional	200	0 or more
hold	true or false — keep the speed with NO timed revert; something else must hand it back	optional	false	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ MOVEMENT_SPEED: { speed: 0.4, ticks: 200 } }

VELOCITY

Acts on an entity

Apply velocity to the target(s): mode=add uses x/y/z; mode=away shoves them back from the anchor with strength and mode=toward drags them to it. anchor picks the point — the activator (default), the attacker that hit them, or the combat victim — so a defensive proc can launch the wearer away from whoever struck. Replaces THROW/LAUNCH/KNOCKBACK.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
mode	one of: add, away, toward	optional	add	add | away | toward
x	a number (decimals allowed)	optional	0	—
y	a number (decimals allowed)	optional	0	—
z	a number (decimals allowed)	optional	0	—
strength	a number (decimals allowed)	optional	0	0 or more
anchor	one of: activator, attacker, victim — the point away/toward is measured from	optional	activator	activator | attacker | victim
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ VELOCITY: { mode: add, x: 0, y: 1.2, z: 0 } }

TELEPORT

Acts on an entity

Teleport the target to the actor's or the victim's location.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
to	one of: VICTIM, ACTOR — destination party: the victim or the actor	optional	VICTIM	VICTIM | ACTOR
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ TELEPORT: { to: VICTIM } }

Blocks & world

Touch the world — break/place blocks, walkers, spawn entities and guardians, fireworks.

BREAK_BLOCK

Acts on the world

Break the target block(s) (default @Here; drops=false clears). @Vein/@Tunnel/@Trench/@Bore for shapes. void-materials is the per-block exception to `drops`: the listed types are destroyed dropless while everything else in the same volume still yields, which is how a bulk excavator keeps the ore and voids the stone. `smelt` is the volume's drop TRANSFORM — the excavation twin of the MINE-scoped SMELT read-back, which only ever addresses the one block a MINE event names: a smeltable block yields that many of its smelted product instead of its raw drop. Being a number rather than a flag, it takes a fact expression, so a co-enchant rule ('only alongside Fuse') is one authored product and needs no second ability.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: at -> @Here (override in the effect token).

Argument	What to put	Required?	Default	Allowed
drops	true or false	optional	true	—
void-materials	a block or item name (e.g. DIAMOND, OBSIDIAN) — these block types break WITHOUT drops even when drops is true (empty = none)	optional	(empty)	—
smelt	a whole number — smelted products per smeltable block in the volume; 0 = no transform	optional	0	0 to 64
smelt-materials	a block or item name (e.g. DIAMOND, OBSIDIAN) — restrict the smelt transform to these block types (empty = every type that smelts)	optional	(empty)	—

Example{ BREAK_BLOCK: { drops: true } }

SET_BLOCK

Acts on the world

Set the target block(s) to a material (default @Here = the activation block).

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: at -> @Here (override in the effect token).

Argument	What to put	Required?	Default	Allowed
material	a block or item name (e.g. DIAMOND, OBSIDIAN)	required	—	—

Example{ SET_BLOCK: { material: OBSIDIAN } }

WALKER

Acts on the world

Lay a temporary platform of a material under the target for a duration (then revert), out to a radius. replace = AIR_ONLY | REPLACEABLE (air/liquid) | ANY.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
material	a block or item name (e.g. DIAMOND, OBSIDIAN)	required	—	—
ticks	a duration in ticks (20 ticks = 1 second)	optional	60	0 or more
radius	a whole number	optional	1	0 to 4
replace	one of: AIR_ONLY, REPLACEABLE, ANY	optional	REPLACEABLE	AIR_ONLY | REPLACEABLE | ANY
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ WALKER: { material: ICE, ticks: 80, radius: 1 } }

SPAWN_ENTITY

Acts on the world

Spawn count entities of type at the target's (or activation) location; ttl ticks until removal (0 = permanent), optional starting health, and owner=activator to tame an owned summon to the activator. ADR-0052 summon flags: powered charges a creeper; ai=false disables mob AI; targeting=false stops the summon acquiring targets; saddled + mount=activator make a horse-type rideable and seat the activator; detonate=PLAYER_HIT makes a creeper explode ONLY when a player hits it (it never self-detonates); invincible=true zeroes all damage to the summon (it cannot die but still takes hits and knockback); speed is a multiplier on the spawned entity's vanilla movement-speed base (0 = untouched); name is shown above each summon and effects is a comma-separated potion loadout held for its whole life, each entry optionally levelled with NAME*LEVEL (SPEED*3) — the same styling GUARD takes, so the choice between the two is only about targeting. payload-phase attaches the owner's SUMMON_PAYLOAD abilities to a point in the summon's life: detonate REPLACES the vanilla explosion (no terrain damage, no vanilla entity damage), death fires as it dies, and periodic pulses every payload-period ticks. The payload runs once per entity in a payload-radius x payload-height box around the summon (height 0 reuses the radius), filtered by payload-filter and capped nearest-first by payload-max-targets; a payload needs owner=activator, since the owner is who runs it. payload-phase=strike is the odd rung out: it fires when the summon lands a MELEE hit on a player (its projectiles never count) and runs the owner's IMPACT abilities on the player struck, NOT their SUMMON_PAYLOAD ones — so the box params above do not apply and the target is always the one player hit. payload-cancel drops the summon's own melee damage so only the authored IMPACT lands, and payload-consume despawns the summon on that hit, which makes it a one-shot courier: exactly one strike per summon, never a second. Visuals for the strike belong on those IMPACT abilities, where they are fully authored. scatter spreads the summons over a random offset, air-scanned so none spawns inside terrain. fuse shortens (or lengthens) a primed TNT's countdown; it is a separate knob from ttl because ttl DESPAWNS, so any ttl at or under the fuse would remove the charge before it could ever explode. Replaces SPAWN/TNT.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
type	a mob/entity type (e.g. WOLF, IRON_GOLEM)	required	—	—
count	a whole number	optional	1	1 or more
ttl	a duration in ticks (20 ticks = 1 second)	optional	0	0 or more
health	a number (decimals allowed)	optional	0	0 or more
owner	one of: none, activator	optional	none	none | activator
powered	true or false	optional	false	—
ai	true or false	optional	true	—
targeting	true or false	optional	true	—
saddled	true or false	optional	false	—
mount	one of: none, activator	optional	none	none | activator
detonate	one of: NONE, PLAYER_HIT	optional	NONE	NONE | PLAYER_HIT
invincible	true or false	optional	false	—
speed	a number (decimals allowed)	optional	0	0 or more
name	text — custom name shown above each summon; {OWNER} fills in the summoner	optional	(empty)	—
effects	a potion-effect name (e.g. STRENGTH, POISON) — potion effects held for the summon's whole life	optional	(empty)	—
payload-phase	one of: none, detonate, death, periodic, strike — when the summon runs its owner's abilities (strike runs IMPACT, the rest SUMMON_PAYLOAD)	optional	none	none | detonate | death | periodic | strike
payload-period	a duration in ticks (20 ticks = 1 second) — ticks between payload pulses (periodic phase only)	optional	40	0 or more
payload-radius	a number (decimals allowed) — XZ half-extent of the payload's target box	optional	4	0 or more
payload-height	a number (decimals allowed) — Y half-extent; 0 reuses payload-radius	optional	0	0 or more
payload-filter	one of: ALL, PLAYERS, MONSTERS, MOBS, ENEMIES, ALLIES — which entities the payload targets; A+B keeps only what both admit	optional	ALL	ALL | PLAYERS | MONSTERS | MOBS | ENEMIES | ALLIES
payload-max-targets	a whole number — nearest-first cap on payload targets (0 = all)	optional	0	0 or more
payload-consume	true or false — strike phase only: the hit also despawns the summon	optional	true	—
payload-cancel	true or false — strike phase only: the summon's own melee damage is dropped	optional	true	—
scatter	a whole number — spread each summon over a random ±N XZ offset, air-scanned (0 = the exact point)	optional	0	0 to 8
fuse	a duration in ticks (20 ticks = 1 second) — primed TNT only: ticks until it detonates (0 = vanilla's 80). NOT ttl, which despawns	optional	0	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ SPAWN_ENTITY: { type: WOLF, count: 1, ttl: 0, health: 0, owner: activator } }

GUARD

Acts on the world

Summon count guardian mobs of type at the activation location, each targeting the attacker, auto-removed after ttl ticks (default 200; 0 = permanent); optional custom name. health sets each guard's starting and maximum health, speed multiplies its vanilla movement speed, and effects is a comma-separated potion loadout held for the guard's whole life, each entry optionally levelled with NAME*LEVEL (SPEED*3). A targeted SPAWN_ENTITY for retaliation — author on DEFENSE.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Attacker (override in the effect token).

Argument	What to put	Required?	Default	Allowed
type	a mob/entity type (e.g. WOLF, IRON_GOLEM)	required	—	—
count	a whole number	optional	1	1 or more
ttl	a duration in ticks (20 ticks = 1 second)	optional	200	0 or more
name	text — custom name shown above each guard; {OWNER} fills in the summoner	optional	(empty)	—
health	a number (decimals allowed) — starting (and maximum) health; 0 keeps the vanilla one	optional	0	0 or more
speed	a number (decimals allowed) — movement-speed multiplier; 0 keeps the vanilla one	optional	0	0 or more
effects	a potion-effect name (e.g. STRENGTH, POISON) — potion effects held for the guard's whole life	optional	(empty)	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ GUARD: { type: IRON_GOLEM, count: 1, ttl: 200, name: "&bGuardian" } }

SMELT

Runs inline

Auto-smelt the block broken by this MINE activation (ore→ingot, sand→glass, …).

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Takes no arguments.

Example{ SMELT: {} }

TELEPORT_DROPS

Runs inline

Send the block's drops straight to the breaker's inventory (this MINE activation).

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Takes no arguments.

Example{ TELEPORT_DROPS: {} }

Economy & items

Give, take, and move resources — items, money, experience, food, durability, and souls.

GIVE_ITEM

Acts on an entity

Give a material to the player target(s); overflow drops at their feet.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
material	a block or item name (e.g. DIAMOND, OBSIDIAN)	required	—	—
count	a whole number	optional	1	1 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ GIVE_ITEM: { material: DIAMOND, count: 1, who: "@Self" } }

REMOVE_ITEM

Acts on an entity

Remove up to count of a material from the player target(s)' inventory.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
material	a block or item name (e.g. DIAMOND, OBSIDIAN)	required	—	—
count	a whole number	optional	1	1 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ REMOVE_ITEM: { material: DIAMOND, count: 1, who: "@Self" } }

DROP_ITEM

Acts on the world

Drop a material as an item at the activation location. No-op if there is no location.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot.

Argument	What to put	Required?	Default	Allowed
material	a block or item name (e.g. DIAMOND, OBSIDIAN)	required	—	—
count	a whole number	optional	1	1 or more

Example{ DROP_ITEM: { material: DIAMOND, count: 1 } }

MODIFY_MONEY

Acts on an entity

Modify a player target's balance: give to them, take from them, transfer (move at most the target's balance to the activator — never more than they hold), steal_percent (give the activator that PERCENT of the target's balance — amount is a 0..100 percentage), or interest_percent (deposit the TARGET that percent of their OWN balance — minted income, ADR-0052 Fish; one deposit is ceilinged by the live pets.max-percent-money-cap). Replaces GIVE_MONEY/TAKE_MONEY/STEAL_MONEY[_PERCENT].

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
amount	a number (decimals allowed)	required	—	0 or more
mode	one of: give, take, transfer, steal_percent, interest_percent	optional	give	give | take | transfer | steal_percent | interest_percent
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ MODIFY_MONEY: { amount: 100, mode: give, who: "@Self" } }

MODIFY_EXP

Acts on an entity

Modify a player target's experience: give to them, take from them, or transfer (move at most the target's experience to the activator — never more than they hold). Replaces GIVE_EXP.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
amount	a whole number	required	—	0 or more
mode	one of: give, take, transfer	optional	give	give | take | transfer
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ MODIFY_EXP: { amount: 50, mode: give, who: "@Self" } }

MODIFY_FOOD

Acts on an entity

Modify a player target's hunger. give/take move the bar now (clamped to 20 / to 0). scale-gain multiplies the next food GAIN by factor for duration ticks; absolute instead multiplies the RESULTING food level (a bigger claim, so it wins if both are armed); cancel-drain cancels hunger LOSS for duration ticks. Author the window modes on REPEATING with duration at least the period for an always-on effect while worn — the engine has no unequip teardown, so the window lapses shortly after re-arming stops. Replaces FEED.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
amount	a whole number	optional	0	0 or more
mode	one of: give, take, scale-gain, cancel-drain, absolute	optional	give	give | take | scale-gain | cancel-drain | absolute
factor	a number (decimals allowed) — scale-gain: what a food-level gain is multiplied by; absolute: what the RESULTING level is	optional	1	0 or more
duration	a duration in ticks (20 ticks = 1 second) — scale-gain/cancel-drain/absolute: ticks the armed window lasts	optional	100	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ MODIFY_FOOD: { amount: 6, mode: give, who: "@Self" } }

DURABILITY

Acts on an entity

Modify durability of the player's held item and/or worn armor: restore (amount<0 = full) or damage, flat by amount or proportionally by percent of each item's max durability (percent-restore/percent-damage). select addresses ONE worn piece — a named slot, the most/least damaged, or a random one — instead of the whole set; skip-undamaged leaves pieces at full durability alone and out of that pick. Replaces ADD_DURABILITY/ADD_DURABILITY_ITEM/REPAIR/DAMAGE_ARMOR.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
amount	a whole number — durability points; negative fully restores (restore mode)	optional	-1	—
target	one of: item, armor, all	optional	item	item | armor | all
mode	one of: restore, damage, percent-restore, percent-damage	optional	restore	restore | damage | percent-restore | percent-damage
percent	a number (decimals allowed) — percent-* modes only: how much of each item's MAX durability to move	optional	0	0 or more
select	one of: whole-set, slot:helmet, slot:chestplate, slot:leggings, slot:boots, most-damaged, least-damaged, random-piece — which worn piece target: armor addresses	optional	whole-set	whole-set | slot:helmet | slot:chestplate | slot:leggings | slot:boots | most-damaged | least-damaged | random-piece
skip-undamaged	true or false — leave pieces already at full durability untouched	optional	false	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ DURABILITY: { amount: -1, target: item } }

REMOVE_SOULS

Runs inline

Debit souls from a soul gem: @Self (default) charges the activator's active gem, @Victim drains the target's own gem. A no-op when that player is not in soul mode.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
amount	a whole number	required	—	1 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ REMOVE_SOULS: { amount: 5 } }

Health & survival

Keep the wearer alive — heal/lifesteal, max-health buffs, oxygen, and death-keep.

MODIFY_HEALTH

Acts on an entity

Modify a target's health: give heals them, take deals direct health damage, transfer (lifesteal) damages the target and heals the activator by the same amount, set forces their health to the amount. Replaces HEAL.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
amount	a number (decimals allowed)	required	—	0 or more
mode	one of: give, take, transfer, set	optional	give	give | take | transfer | set
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ MODIFY_HEALTH: { amount: 4, mode: give, who: "@Self" } }

HEALTH

Acts on an entity

Bonus maximum health. On PASSIVE/HELD @Self it is a maintained worn bonus (reconciled, additive across sources, removed on unequip); on event triggers it is a permanent base shift.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
amount	a number (decimals allowed)	required	—	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ HEALTH: { amount: 4 } }

FILL_OXYGEN

Acts on an entity

Refill the target's air supply. amount adds that many air ticks instead, clamped to the target's maximum air (0, the default, refills the bar outright).

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
amount	a duration in ticks (20 ticks = 1 second) — air ticks to add; 0 refills the bar outright	optional	0	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ FILL_OXYGEN: {} }

KEEP_ON_DEATH

Runs inline

Keep the target's items + levels (no drops) if they die within duration ticks (default 200). Author on trigger REPEATING for an always-on death-keep while worn, or fire on a trigger for a timed grace window. A kept death never spends a holy scroll.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
duration	a duration in ticks (20 ticks = 1 second)	optional	200	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ KEEP_ON_DEATH: { duration: 200 } }

Cosmetic & feedback

Tell the player what happened — messages/titles, sounds, and particles.

MESSAGE

Runs inline

Send feedback on a channel: chat (default), actionbar, or title (with subtitle + fade/stay/fade timings). Default recipient self; `who` can name any party (e.g. @Victim). The `{ATTACKER}`/`{VICTIM}` tokens expand to the activating player and the other combat party, `{SELF}` to the name of whoever receives that copy, and `{RELATION_COLOR}` to `ally-color` or `enemy-color` depending on how that recipient stands to the actor — so one broadcast reads correctly to friend and foe. Replaces ACTIONBAR/TITLE.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
text	text	required	—	—
channel	one of: chat, actionbar, title	optional	chat	chat | actionbar | title
subtitle	text — title channel only	optional	(empty)	—
fadeIn	a duration in ticks (20 ticks = 1 second) — title channel only	optional	10	0 or more
stay	a duration in ticks (20 ticks = 1 second) — title channel only	optional	70	0 or more
fadeOut	a duration in ticks (20 ticks = 1 second) — title channel only	optional	20	0 or more
tokens	expr map — name=expression bindings; each {name} in the text becomes the evaluated number	optional	(empty)	—
ally-color	text — the {RELATION_COLOR} value for a recipient allied to the actor	optional	&a	—
enemy-color	text — the {RELATION_COLOR} value for every other recipient	optional	&c	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ MESSAGE: { text: "&aCritical hit!" } }

SOUND

Acts on the world

Play a sound at the activation location, or at each entity in `who` when given — world-audible there at the same volume and pitch. `dy` raises that anchor (an overhead cue is `dy: 4`). No-op if `who` resolves nothing and the activation has no location.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Here (override in the effect token).

Argument	What to put	Required?	Default	Allowed
sound	a sound name (e.g. ENTITY_GENERIC_EXPLODE)	required	—	—
volume	a number (decimals allowed)	optional	1	0 or more
pitch	a number (decimals allowed)	optional	1	0 or more
dy	a number (decimals allowed) — blocks to raise the anchor before the cue plays	optional	0	-16 to 16

Example{ SOUND: { sound: ENTITY_GENERIC_EXPLODE, volume: 1, pitch: 1 } }

PARTICLE

Acts on the world

Spawn particles at the activation location, or at each entity in `who` when given (centered on the body, not the feet). `block` carries a block material as crack/dust data. `spread` is the horizontal Gaussian offset (set 0 for a point burst); `spread-y` the vertical offset, where the -1 default means "use `spread`". `dy` moves the whole burst up, which is not what widening `spread-y` does. No-op if there is no location.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Here (override in the effect token).

Argument	What to put	Required?	Default	Allowed
particle	a particle name (e.g. FLAME, HEART)	required	—	—
count	a whole number	optional	1	0 or more
block	a block or item name (e.g. DIAMOND, OBSIDIAN)	optional	—	—
spread	a number (decimals allowed)	optional	0.4	0 to 4
spread-y	a number (decimals allowed)	optional	-1	-1 to 4
dy	a number (decimals allowed) — blocks to raise the anchor before the burst spawns	optional	0	-16 to 16

Example{ PARTICLE: { particle: BLOCK_CRACK, count: 20, block: REDSTONE_BLOCK, who: "@Victim" } }

FIREWORK

Acts on the world

Spawn a cosmetic firework at the activation location. No-op if there is no location.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot.

Argument	What to put	Required?	Default	Allowed
power	a whole number	optional	1	0 to 3

Example{ FIREWORK: { power: 1 } }

Utility & flow

Wiring and control — set/flip variables for later conditions, cancel the event, run console commands.

SET_VAR

Runs inline

Set (or with op=increment, add to) a variable on the target, readable in later conditions as %name% on the activator or %victim.var.name% on the victim. ttl ticks, 0 = forever; cap 0 = uncapped. Any living entity can carry one, so a mob holds its own stacks. clear-on-death ends the var when its CARRIER dies: a mob's vars always go, but a player's deliberately survive their death (a mark meant to outlast one, a window somebody else armed), so a counter that should not — a bleed ladder — has to say so.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
name	text	required	—	—
value	text	optional	(empty)	—
ttl	a duration in ticks (20 ticks = 1 second)	optional	0	0 or more
op	one of: set, increment	optional	set	set | increment
step	a whole number	optional	1	—
cap	a whole number	optional	0	0 or more
clear-on-death	true or false — the carrier's own death ends this var, not just its ttl	optional	false	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ SET_VAR: { name: bleedstacks, op: increment, step: 1, cap: 20, ttl: 200, who: "@Victim" } }

INVERT_VAR

Runs inline

Numerically invert a per-player variable (0↔1), preserving its remaining TTL.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
name	text	required	—	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ INVERT_VAR: { name: rage, who: "@Self" } }

CANCEL

Runs inline

Cancel the Bukkit event that triggered this activation.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Takes no arguments.

Example{ CANCEL: {} }

RUN_COMMAND

Runs globally

Run a command as the console (default) or as the activating player. The `{PLAYER}`/`{UUID}`/`{WORLD}` tokens expand to the actor's name, uuid, and world, and `{VICTIM}` to the other combat party's name (empty on a victimless activation). Affinity GLOBAL — the console path runs on the global thread; the player path runs on the actor's own thread. `{PLAYER}` and `{VICTIM}` both refuse to run the command when the name they would embed falls outside the standard `[A-Za-z0-9_]` (1-16) username charset.

How it runs: Runs on the server-wide thread — used for console commands and other global work.

Argument	What to put	Required?	Default	Allowed
command	text	required	—	—
as	one of: console, player — who runs it: console (default) or the player	optional	console	console | player

Example{ RUN_COMMAND: { command: "f focus {VICTIM}", as: player } }

Everything else

Newer effects that aren't sorted into a family yet.

BATTERY

Runs inline

Arm a damage battery on the wearer: the next `hits` landed hits they take each bank `bank-percent`% of the final damage; their next landed hit on an enemy unloads the entire bank as bonus damage on that hit, then the core resets — a hit with nothing banked still spends the core. No time limit; the ability cooldown paces re-arms. Cleared on death.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
bank-percent	a number (decimals allowed)	optional	20	0 to 100
hits	a whole number	optional	3	1 to 10
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ BATTERY: { bank-percent: 20, hits: 3 } }

BLINK

Acts on an entity

Blink (reforges): instantly teleport up to distance blocks along your facing if the path is clear — stops at the last open block, never phases into or through terrain. Walls stop it; the use is spent either way.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at.

Argument	What to put	Required?	Default	Allowed
distance	a number (decimals allowed) — max blink distance in blocks	optional	4	1 to 16
particle	a particle name (e.g. FLAME, HEART)	optional	REDSTONE	—
r	a whole number	optional	170	0 to 255
g	a whole number	optional	60	0 to 255
b	a whole number	optional	220	0 to 255
size	a number (decimals allowed)	optional	1	0 or more
count	a whole number — departure/arrival puff motes	optional	10	0 or more
arrival-sound	a sound name (e.g. ENTITY_GENERIC_EXPLODE) — played ON the player after the hop lands — a sound at the origin is never heard by someone who just teleported away from it	optional	ENTITY_ENDERMAN_TELEPORT	—
arrival-volume	a number (decimals allowed)	optional	0.6	0 or more
arrival-pitch	a number (decimals allowed)	optional	1.8	0 or more
arrival-accent	a sound name (e.g. ENTITY_GENERIC_EXPLODE) — the shimmer layer over the arrival body	optional	BLOCK_AMETHYST_BLOCK_CHIME	—
accent-volume	a number (decimals allowed)	optional	0.4	0 or more
accent-pitch	a number (decimals allowed)	optional	1.6	0 or more

Example{ BLINK: { distance: 4 } }

BOOK_RATE_MODIFIER

Runs inline

Arm a one-shot `percent`-point bonus on each target's next enchant-book roll at `site`: `generate` raises the success rate of the book a black scroll mints, `apply` raises the chance a book applies to gear. The charge is consumed by the next roll at that site whatever it returns — a failed apply spends it — and it survives a relog, since the roll it is waiting for may be days away. Both sites cap at the server's global books.max-success ceiling. Guard a second arm with %bookrate.generate% / %bookrate.apply%.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
site	one of: generate, apply — which roll the charge waits for: generate (a scroll minting a book) or apply	required	—	generate | apply
percent	a whole number — percentage points added to that roll's success chance	required	—	1 to 100
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ BOOK_RATE_MODIFIER: { site: generate, percent: 5, who: "@Self" } }

CAGE

Acts on the world

Trap the target AND the activator in a temporary cage: floor/roof plates, a walls ring, an air width × height × depth interior, base-centred rise blocks above the midpoint between the two, reverting after ticks. The full volume is safety-checked (every cell must be air) before anything is placed; both parties teleport to opposite interior cells facing each other. Gate the ability on a target existing (e.g. %nearbyenemies% >= 1) so a no-target use fails BEFORE the cooldown arms.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
floor	a block or item name (e.g. DIAMOND, OBSIDIAN)	required	—	—
walls	a block or item name (e.g. DIAMOND, OBSIDIAN)	required	—	—
roof	a block or item name (e.g. DIAMOND, OBSIDIAN)	required	—	—
width	a whole number	optional	3	1 to 8
height	a whole number	optional	4	2 to 8
depth	a whole number	optional	3	1 to 8
rise	a whole number	optional	2	0 to 8
ticks	a duration in ticks (20 ticks = 1 second)	optional	150	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ CAGE: { floor: STONE_BRICKS, walls: IRON_BARS, roof: STONE_BRICKS, ticks: 150, who: "@NearestPlayer{r=10}" } }

CONVERT_SUMMON

Runs inline

Convert EVERY mob within `radius` blocks of the wearer to the wearer's side, permanently: each rebinds its ownership (a hit on it now fires the wearer's GUARDIAN_HURT) and tamed mobs re-tame; an enemy summon turns on its former owner, a wild mob on the wearer's nearest enemy player, and bat swarm clouds permanently swarm their former owner. Only players, armour stands and the wearer are exempt.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
radius	a number (decimals allowed)	optional	12	1 to 32
whiff-sound	a sound name (e.g. ENTITY_GENERIC_EXPLODE) — played (low-pitched) when the ring converts nothing — the ring sound alone reads as success	optional	BLOCK_ANVIL_LAND	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ CONVERT_SUMMON: { radius: 12 } }

DAMAGE_CAP

Runs inline

Cap the wearer's next incoming hit at factor times the last damage they took, for a duration in ticks; with reflect, the overflow above the cap is dealt back to the attacker (Diminish). Self-only; no cap is armed until at least one hit has been taken. feedback is an optional line sent when the cap arms, with {damage} filled in with the cap value.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
factor	a number (decimals allowed)	optional	0.5	0 or more
reflect	true or false	optional	false	—
duration	a duration in ticks (20 ticks = 1 second)	optional	100	0 or more
feedback	text — line sent on arming; {damage} = the cap value just committed	optional	(empty)	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ DAMAGE_CAP: { factor: 0.5, reflect: true, duration: 100 } }

DAMAGE_SCALE

Runs inline

Contribute per resolved target in 'who' to the damage fold: total = per * count, clamped to cap (0 = uncapped). side attack/defense, mode add (percent, e.g. 10 = +10% each) or flat (raw). The count is the selector's resolved set, e.g. who: @AllPlayers{r=7}.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Aoe (override in the effect token).

Argument	What to put	Required?	Default	Allowed
side	one of: attack, defense	optional	attack	attack | defense
mode	one of: add, flat	optional	add	add | flat
per	a number (decimals allowed)	required	—	—
cap	a number (decimals allowed)	optional	0	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ DAMAGE_SCALE: { side: attack, mode: add, per: 10, cap: 100, who: "@AllPlayers{r=7}" } }

DELAYED_STRIKE_FIELD

Acts on the world

Mark `points` ground spots around each target, at an independent per-axis offset of offset-min..offset-max blocks (a spot over lower ground snaps down onto it, but never rises above the origin), play the `cue-` telegraph at each one and shout `warning` ({caster}) at everyone the `filter` admits within target-range. `delay` ticks later every spot detonates together: a damage-free lightning visual (unless lightning: false), the `strike-` cue, and `damage` raw half-hearts subtracted from every body within hit-radius of it — floored at health-floor, so the field cannot kill, and the filter is RE-CHECKED then, so walking into a spot during the delay gets you hit. Spots are independent: overlapping ones each land their own hit.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
points	a whole number — how many ground spots are marked	optional	16	1 to 64
offset-min	a whole number — closest a spot lands, per axis	optional	2	0 to 64
offset-max	a whole number — furthest a spot lands, per axis	optional	9	0 to 64
delay	a duration in ticks (20 ticks = 1 second) — ticks between the telegraph and the strike	optional	20	1 or more
hit-radius	a number (decimals allowed) — how far from a spot the strike reaches	optional	1.4142135623730951	0 or more
target-range	a number (decimals allowed) — how far the warning carries from the origin	optional	32	0 or more
filter	one of: ALL, PLAYERS, MONSTERS, MOBS, ENEMIES, ALLIES — who the warning and the strike admit; re-checked at the strike, not carried from the warning	optional	ENEMIES	ALL | PLAYERS | MONSTERS | MOBS | ENEMIES | ALLIES
damage	a number (decimals allowed) — raw half-hearts subtracted from a struck body's health	optional	16	0 or more
health-floor	a number (decimals allowed) — health a strike can never take a body below — the reason the field cannot kill	optional	1	0 or more
warning	text — line shouted at everyone in range ({caster}); empty = no warning	optional	(empty)	—
cue-sound	a sound name (e.g. ENTITY_GENERIC_EXPLODE) — telegraph cue at each spot; omit for silence	optional	—	—
cue-volume	a number (decimals allowed)	optional	1	0 or more
cue-pitch	a number (decimals allowed)	optional	1	0 or more
cue-particle	a particle name (e.g. FLAME, HEART) — telegraph burst at each spot; omit for none	optional	—	—
cue-particle-count	a whole number	optional	1	0 or more
strike-sound	a sound name (e.g. ENTITY_GENERIC_EXPLODE) — detonation cue at each spot; omit for silence	optional	—	—
strike-volume	a number (decimals allowed)	optional	1	0 or more
strike-pitch	a number (decimals allowed)	optional	1	0 or more
strike-particle	a particle name (e.g. FLAME, HEART) — detonation burst at each spot; omit for none	optional	—	—
strike-particle-count	a whole number	optional	1	0 or more
lightning	true or false — strike each spot with a damage-free lightning visual	optional	true	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ DELAYED_STRIKE_FIELD: { points: 16, offset-min: 2, offset-max: 9, delay: 20, damage: 16, health-floor: 1, filter: ENEMIES, target-range: 32, cue-sound: ENTITY_WITHER_SPAWN, cue-pitch: 0.4, cue-particle: SPELL_WITCH, cue-particle-count: 32, strike-sound: ENTITY_WITHER_DEATH, strike-pitch: 0.4, strike-particle: EXPLOSION_LARGE, strike-particle-count: 4, who: "@Self" } }

DESPAWN

Acts on an entity

Silently remove the target mob(s) — no drops, no experience, no death event, so nothing downstream (kill counters, other plugins' death hooks) sees a kill. Players are never removed. Pair with @Aoe{filter=MOBS} for an area mob-clear; use KILL when the drops and the death are the point.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ DESPAWN: { who: "@Aoe{r=8, filter=MOBS}" } }

DIG_HOME

Runs inline

Mark the activator's location as a temporary home for `window` ticks: the next right-click of the same pet within `range` blocks teleports the activator back and consumes the window. Pets only — the pets service owns the recall; this effect emits no intent of its own.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
window	a duration in ticks (20 ticks = 1 second)	optional	600	0 or more
range	a number (decimals allowed)	optional	50	0 or more

Example{ DIG_HOME: { window: 600, range: 50 } }

DISARM_SHUFFLE

Runs inline

Arm an unhanding window on the wearer for `duration` ticks: their next landed melee hit on a player knocks the victim's held item into a random other hotbar slot (the victim can re-select it — shuffled, not locked; weapon-gated combos like Rage break naturally) and that hit deals `damage-malus`% less damage. One shot; a dodged/negated hit keeps the window armed.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
duration	a duration in ticks (20 ticks = 1 second)	optional	80	0 or more
damage-malus	a number (decimals allowed)	optional	20	0 to 100
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ DISARM_SHUFFLE: { duration: 80, damage-malus: 20 } }

DOT_AMPLIFY_MARK

Runs inline

Mark the target so their incoming wither and/or poison damage is multiplied by factor for duration ticks. Amplifies EVERY source of those causes, not just the marker's own. Re-marking refreshes the window outright, weaker factor included — a re-infection is a fresh infection. Player targets only.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
causes	one of: wither, poison, dot — which damage-over-time causes are amplified; dot = both	optional	dot	wither | poison | dot
factor	a number (decimals allowed)	optional	2	1 or more
duration	a duration in ticks (20 ticks = 1 second)	optional	100	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ DOT_AMPLIFY_MARK: { causes: dot, factor: 3, duration: 60, who: "@Victim" } }

ECHO_STRIKE

Runs inline

Re-run the attack activation once over the same hit (enchants can re-proc); all damage folds into the one event. No effect off the attack side.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Takes no arguments.

Example{ ECHO_STRIKE: {} }

EQUIP_SWAP

Acts on an entity

Temporarily replace the target's `slot` armour piece with `material`, restoring it after `duration` ticks (death-safe: the real piece drops / is kept). Default target the victim.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
slot	one of: helmet, chestplate, leggings, boots	optional	helmet	helmet | chestplate | leggings | boots
material	a block or item name (e.g. DIAMOND, OBSIDIAN)	required	—	—
duration	a duration in ticks (20 ticks = 1 second)	optional	60	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ EQUIP_SWAP: { slot: helmet, material: CARVED_PUMPKIN, duration: 60, who: "@Victim" } }

EXP_MULTIPLY

Runs inline

Multiply the XP gained by a factor, on EXP_GAIN and on MINE. EXP_GAIN scales the amount already granted and ROUNDS to the nearest whole XP; MINE scales the broken block's own yield and TRUNCATES, because a block yields whole orbs.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
factor	a number (decimals allowed)	optional	2.0	0 or more

Example{ EXP_MULTIPLY: { factor: 2 } }

FACING_SET

Acts on an entity

Turn each target to face toward (or away from) the anchor, without moving them. Pitch is set too, so an anchor above or below is genuinely looked at. A target sharing the anchor's exact column keeps its current look — there is no direction to turn to — and an activation whose anchor does not resolve turns nobody.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
mode	one of: toward, away — whether the target ends up looking at the anchor or directly away from it	optional	toward	toward | away
anchor	one of: activator, attacker, victim — which combat party the direction is measured from	optional	activator	activator | attacker | victim
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ FACING_SET: { mode: away, anchor: activator, who: "@AOE{radius: 8, filter: ENEMIES}" } }

FALLING_BLOCK

Acts on the world

Spawn a (2*radius+1)² grid of falling blocks `height` blocks above each target (removed after `ttl` if they never land). A landing block fires the actor's IMPACT abilities on what it hit; `carry` is forwarded to that impact as %damage% (set carry: "%damage%"). The block-field profile turns the grid into a storm and is entirely opt-in: layers-min/max stack that many grids, each layer index rising by its own draw from layer-step-min..max (so layer 0 is always `height`, and a layer above the world simply does not rain); density below 100 rains only that percent of positions, drawn fresh per position per layer, so a re-cast field never falls in the same holes; material2/3/4 give the storm a palette, drawn per block. damage-percent adds that percent of the target's max health — capped at health-cap — to `carry`, so one field hurts a 20-heart player and a boss proportionally. rehit-max/rehit-window cap how many impacts ONE victim can take in a fixed window shared across every wearer raining on them (the field's lethality ceiling), and kill-material names a block that kills a falling block mid-flight, so standing in it is real counterplay.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
material	a block or item name (e.g. DIAMOND, OBSIDIAN)	required	—	—
material2	a block or item name (e.g. DIAMOND, OBSIDIAN)	optional	—	—
material3	a block or item name (e.g. DIAMOND, OBSIDIAN)	optional	—	—
material4	a block or item name (e.g. DIAMOND, OBSIDIAN)	optional	—	—
radius	a whole number	optional	1	0 to 4
height	a whole number	optional	4	0 to 64
ttl	a duration in ticks (20 ticks = 1 second)	optional	40	0 or more
carry	a number (decimals allowed)	optional	0	—
layers-min	a whole number — fewest grids stacked above the target	optional	1	1 to 8
layers-max	a whole number — most grids stacked above the target	optional	1	1 to 8
layer-step-min	a whole number — fewest blocks one layer rises per layer index	optional	0	0 to 24
layer-step-max	a whole number — most blocks one layer rises per layer index	optional	0	0 to 24
density	a number (decimals allowed) — percent of grid positions that actually rain, drawn per position per layer	optional	100	0 to 100
damage-percent	a number (decimals allowed) — percent of the target's (capped) max health added to carry — a victim-scaled impact	optional	0	0 or more
health-cap	a number (decimals allowed) — ceiling on the max health damage-percent reads; 0 = uncapped	optional	0	0 or more
rehit-max	a whole number — most impacts one victim can take per rehit-window, shared across every wearer; 0 = uncapped	optional	0	0 or more
rehit-window	a duration in ticks (20 ticks = 1 second) — length of that fixed bucket, anchored at the first impact	optional	200	0 or more
kill-material	a block or item name (e.g. DIAMOND, OBSIDIAN) — a block falling through this material dies without ever landing — the field's counterplay	optional	—	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ FALLING_BLOCK: { material: END_STONE, material2: NETHERRACK, radius: 4, height: 10, layers-min: 3, layers-max: 4, layer-step-min: 12, layer-step-max: 19, density: 50, damage-percent: 15, health-cap: 44, rehit-max: 4, rehit-window: 200, kill-material: COBWEB, ttl: 100, who: "@Aoe{r=25, filter=ENEMIES}" } }

FALL_SHIELD

Runs inline

Arm a ONE-SHOT cancel of each target's next fall damage within `window` ticks. The target need not carry any enchant — this is how a proc that displaces someone pays for their landing. Re-arming refreshes the window; it never banks a second shield.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
window	a duration in ticks (20 ticks = 1 second) — how long the unspent shield waits for a fall	optional	200	1 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ FALL_SHIELD: { window: 200, who: "@AOE{radius: 8, filter: ENEMIES}" } }

FLY_MODE

Acts on an entity

Grant flight to the target(s) while NOT in combat, revoke it while in combat (survival/adventure only). Author on trigger [REPEATING, PASSIVE] with a repeat period so it re-checks and tears down on unequip.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ FLY_MODE: { who: "@Self" } }

FREEZE

Acts on an entity

Fully freeze the target for a span of ticks (vanilla powder-snow visual: blue hearts + full vignette, held even while the victim burns), dealing dot damage every dot-period ticks (attributed to the activator; raw pre-armor half-hearts) and slowing them by slow percent. Re-procs refresh the window instead of stacking. neutralize-frost-slow cancels vanilla's own ~50% fully-frozen slow so the authored percent is the real one. breakout-chance rolls once per DoT pulse: on a hit the root shatters there and then, so a long freeze becomes a struggle the victim can win early instead of a fixed sentence. no-jump additionally pins the victim to the ground: a frozen player cannot jump out of the root. It is off by default because it re-tunes the feel of every freeze it is added to, and it is MODERN-ONLY — the 1.8.9 lane has no cancellable jump event, so a freeze there keeps its DoT and slow and the victim can still hop (the recorded era degrade, as with the powder-snow visual).

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
duration	a duration in ticks (20 ticks = 1 second)	optional	60	0 or more
dot	a number (decimals allowed)	optional	2	0 or more
dot-period	a duration in ticks (20 ticks = 1 second)	optional	20	0 or more
slow	a number (decimals allowed)	optional	5	0 to 100
neutralize-frost-slow	true or false	optional	true	—
breakout-chance	a number (decimals allowed) — percent chance per DoT pulse that the victim shatters the root early	optional	0	0 to 100
no-jump	true or false — also stop the victim jumping for the window (modern lane only; inert on 1.8.9)	optional	false	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ FREEZE: { duration: 100, dot: 2, dot-period: 20, slow: 5 } }

GRAPPLE

Runs inline

Leviathan's Reach (reforges): throw a grappling line along your facing (range blocks). An enemy in sight closer than the first block is reeled to reel-distance blocks in front of you with a brief slow and no damage; otherwise you zip to the terrain point. Open air wastes the throw. Reforge-service-owned: this effect emits no intent of its own.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
range	a number (decimals allowed) — hook range in blocks (both rays)	optional	14	1 or more
hook-speed	a number (decimals allowed) — hook flight speed, blocks per tick (cosmetic delay)	optional	2.0	0.5 or more
reel-distance	a number (decimals allowed) — where a hooked enemy lands, blocks in front of you	optional	2.0	0.5 or more
slow-effect	a potion-effect name (e.g. STRENGTH, POISON) — the brief debuff a reeled enemy gets	optional	SLOW	—
slow-level	a whole number — its amplifier + 1 (authoring convention)	optional	2	1 to 10
slow-duration	a duration in ticks (20 ticks = 1 second) — its length	optional	60	0 or more
zip-strength	a number (decimals allowed) — terrain mode: velocity per block of distance (capped)	optional	0.34	0 or more
zip-cap	a number (decimals allowed) — terrain mode: velocity magnitude cap	optional	3.2	0 or more
zip-rise	a number (decimals allowed) — terrain mode: extra upward boost	optional	0.25	0 or more
particle	a particle name (e.g. FLAME, HEART)	optional	REDSTONE	—
r	a whole number	optional	200	0 to 255
g	a whole number	optional	220	0 to 255
b	a whole number	optional	255	0 to 255
size	a number (decimals allowed)	optional	1	0 or more
density	a number (decimals allowed) — line motes per block	optional	3	0 or more

Example{ GRAPPLE: { range: 14, hook-speed: 2.0, reel-distance: 2.0 } }

GRAVITY_WELL

Runs inline

Singularity (reforges): throw a particle beam onto the block in your sights (max range); a collapsing star forms rise blocks above it, drags every living thing within radius toward the core for duration ticks, then implodes for damage (linear falloff to falloff-floor at the edge). Pulls — and hurts — the caster too unless self-pull/self-damage are off. Reforge-service-owned: this effect emits no intent of its own.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
range	a number (decimals allowed) — max block-selection distance (blocks)	optional	12	1 or more
radius	a number (decimals allowed) — pull + implosion radius around the core	optional	6	0.5 or more
rise	a number (decimals allowed) — core height above the selected block	optional	2.5	0 or more
duration	a duration in ticks (20 ticks = 1 second) — pull phase length before the implosion	optional	60	0 or more
period	a whole number — pull cadence in ticks	optional	2	1 to 20
pull	a number (decimals allowed) — per-pulse velocity magnitude toward the core	optional	0.28	0 or more
damage	a number (decimals allowed) — implosion damage at the core, RAW health-space (8.0 = 4 hearts)	optional	8.0	0 or more
falloff-floor	a number (decimals allowed) — damage fraction kept at the radius edge	optional	0.25	0 to 1
self-pull	true or false — the caster is dragged too (the authored downside)	optional	true	—
self-damage	true or false — the implosion hits the caster too if inside	optional	true	—
r	a whole number	optional	190	0 to 255
g	a whole number	optional	120	0 to 255
b	a whole number	optional	255	0 to 255

Example{ GRAVITY_WELL: { range: 12, radius: 6, duration: 60, damage: 8.0 } }

HEAD_TROPHY

Runs inline

Arm a head trophy on the target: on their next death from ANY cause a player head owned by them joins the drops, named and lored from these templates, and the mark clears. Tokens resolve at the death: {VICTIM}, {KILLER}, {MONTH}, {DAY}, {YEAR}, {X}, {Y}, {Z}, {ITEM} (the killer's held item, else Fists). Lore lines are separated by '|'. A killer-less death drops the bare head with no lore, since every lore token would be empty. Player targets only.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
name	text — display-name template for the dropped skull	optional	(empty)	—
lore	text — lore template; '|' separates lines	optional	(empty)	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ HEAD_TROPHY: { name: "&fSkull of {VICTIM}", lore: "&7Defeated by &f{KILLER}|&f{MONTH} {DAY}, {YEAR}" } }

HIT_TEMPO

Runs inline

Arm a hit-tempo window on the wearer for `duration` ticks: their melee victims' damage-immunity window is halved for the wearer's hits only (model MENTAL = the 1.8-combat half-window gate; VANILLA = the 1.9+ full-window cadence), each such hit deals `damage-percent`% of its normal damage, and on 1.9+ the wearer gains `attack-speed` (+1.0 = doubled) swing speed for the window. Third-party attackers are unaffected — their hits keep natural immunity.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
duration	a duration in ticks (20 ticks = 1 second)	optional	100	0 or more
model	one of: VANILLA, MENTAL	optional	VANILLA	VANILLA | MENTAL
damage-percent	a number (decimals allowed)	optional	33.3	0 to 100
attack-speed	a number (decimals allowed)	optional	1.0	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ HIT_TEMPO: { duration: 100, model: MENTAL, damage-percent: 33.3, attack-speed: 1.0 } }

IGNORE_HEROIC

Runs inline

Make the triggering hit ignore the victim's heroic-upgrade damage reduction (percent and flat).

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Takes no arguments.

Example{ IGNORE_HEROIC: {} }

INVENTORY_CONVERT

Runs inline

Replace up to `limit` of the activator's `from` items with `to`, walking the whole inventory. With `plain` only meta-less stacks are touched. A stack straddling the remaining limit converts up to the limit and returns the overflow as `from`; anything that no longer fits is dropped at their feet, pickable only by them for `protect-seconds`. The number converted lands in `count-var`, so the zero-converted failure branch and any count-scaled follow-up read it as %converted%.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
from	a block or item name (e.g. DIAMOND, OBSIDIAN) — the material consumed	required	—	—
to	a block or item name (e.g. DIAMOND, OBSIDIAN) — the material handed back in its place	required	—	—
limit	a whole number — the most items one activation may convert	required	—	1 or more
plain	true or false — true = skip any stack carrying meta (a named/enchanted/plugin item is never raw material)	optional	true	—
protect-seconds	a whole number — how long items that no longer fit stay owner-locked on the ground (0 = unprotected)	optional	0	0 or more
count-var	text — per-player variable the converted count is written to, read back as %name%	optional	converted	—

Example{ INVENTORY_CONVERT: { from: BUCKET, to: LAVA_BUCKET, limit: 1152, plain: true, protect-seconds: 60, count-var: converted } }

ITEM_XP_TRACK

Runs inline

Credit `amount` experience to the item the activator is holding — the item whose ability fired. At most ONE level per grant: the remainder is banked toward the next, and at the item's cap the bank simply keeps growing. `window` gates the grant to once per that many minutes using a stamp carried BY the item, so the gate follows it through a trade and a freshly minted item earns straight away; a grant inside the window is skipped whole, never scaled. Per-level thresholds and the level cap come from the item's own definition (a pet's `exp-curve` / `max-level`), falling back to the universal `pets.exp-per-level` and `pets.max-level`.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
amount	a whole number — experience credited to the held item	required	—	1 or more
window	a whole number — MINUTES between grants for this item (0 = ungated); 1440 = once a day	optional	0	0 or more
message	text — line sent on a grant ({xp}, {exp}, {needed}); empty = silent	optional	(empty)	—
level-up-message	text — line sent when the grant levels the item ({item} = its name BEFORE the level-up, {level})	optional	(empty)	—

Example{ ITEM_XP_TRACK: { amount: 500, window: 1440, message: "&a&l+ &a{xp} Pet EXP &a&l[&7{exp}/{needed}&a&l]" } }

JAVELIN

Runs inline

Javelin (reforges): a straight particle javelin at speed blocks/tick along the FULL facing (pitch included), max-travel blocks. On the first living hit: one weapon-swing's damage (or FLAT damage), knockback × along the flight angle, a lock-tick control lock (view snapped back + walk/jump locked; driven down a tracked arc), then nausea. Speed is authored (sidestep to dodge); a miss is wasted. Reforge-service-owned: this effect emits no intent of its own.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
speed	a number (decimals allowed) — flight speed, blocks per tick (0.15 = 3 blocks/s)	optional	0.15	0.05 or more
max-travel	a number (decimals allowed) — max flight distance in blocks	optional	12	1 or more
hit-radius	a number (decimals allowed) — hit detection radius around the tip	optional	0.9	0.1 or more
damage-mode	one of: WEAPON, FLAT — WEAPON = one swing of the held weapon (era-read); FLAT = the damage param	optional	WEAPON	WEAPON | FLAT
damage	a number (decimals allowed) — FLAT mode damage, RAW health-space	optional	7.0	0 or more
knockback	a number (decimals allowed) — knockback multiplier along the flight angle	optional	1.3	0 or more
knockback-base	a number (decimals allowed) — base knockback velocity one multiplier buys	optional	0.45	0 or more
lock	a duration in ticks (20 ticks = 1 second) — control-lock length: view snapped, walk+jump locked, driven down a tracked arc	optional	20	0 or more
lock-delay	a duration in ticks (20 ticks = 1 second) — ticks after impact before the lock arms (lets the knock land first)	optional	5	0 or more
nausea-effect	a potion-effect name (e.g. STRENGTH, POISON) — the post-lock debuff	optional	CONFUSION	—
nausea-duration	a duration in ticks (20 ticks = 1 second) — its length (100 = 5 s)	optional	100	0 or more
particle	a particle name (e.g. FLAME, HEART)	optional	REDSTONE	—
r	a whole number	optional	120	0 to 255
g	a whole number	optional	200	0 to 255
b	a whole number	optional	255	0 to 255
size	a number (decimals allowed)	optional	1.2	0 or more

Example{ JAVELIN: { speed: 0.15, max-travel: 12, knockback: 1.3, lock: 20 } }

LIGHTNING_MOD

Runs inline

While worn (PASSIVE): the wearer's LIGHTNING effects deal amount% more authored damage (summed across worn sources, suppression-aware, read when the bolt fires). Negative values reduce, floored at a cosmetic bolt; the vanilla splash is untouched.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
amount	a number (decimals allowed)	required	—	-100 or more

Example{ LIGHTNING_MOD: { amount: 10 } }

MARK

Runs inline

Mark the target(s) so the actor deals an extra `amount`% damage to them for `duration` ticks. Applied by the damage fold on the actor's later hits; default target the combat victim.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
amount	a number (decimals allowed)	required	—	—
duration	a duration in ticks (20 ticks = 1 second)	optional	60	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ MARK: { amount: 25, duration: 60, who: "@Victim" } }

MARK_ZONE

Runs inline

Lay an actor-owned cylinder of `radius` blocks under each target for `duration` ticks. Read by the %victim.inzone% fact, so a condition-gated bonus can deal more to an enemy inside it.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
radius	a number (decimals allowed)	optional	4	0 or more
duration	a duration in ticks (20 ticks = 1 second)	optional	100	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ MARK_ZONE: { radius: 4, duration: 100, who: "@Victim" } }

MAX_HEALTH_DRAIN

Acts on an entity

Temporarily remove `fraction` of the target's overhealth (max health above `baseline`) plus a flat `amount`, restoring it after `duration` ticks. Default target the combat victim.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
fraction	a number (decimals allowed)	optional	0.5	0 to 1
baseline	a number (decimals allowed)	optional	20	0 or more
amount	a number (decimals allowed)	optional	0	0 or more
duration	a duration in ticks (20 ticks = 1 second)	optional	60	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ MAX_HEALTH_DRAIN: { fraction: 0.5, baseline: 20, duration: 60, who: "@Victim" } }

OUTGOING_DEBUFF

Runs inline

Debuff the target's outgoing damage by a percent for a duration in ticks, priced only on their melee hits, their projectile hits, or both (cause). feedback is sent to them on every hit the window actually prices. Non-stacking with itself and with WEAKEN: a re-debuff keeps the stronger window and the later expiry, never the sum. Player targets only.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
percent	a number (decimals allowed)	required	—	0 or more
duration	a duration in ticks (20 ticks = 1 second)	optional	100	0 or more
cause	one of: all, melee, projectile — which of the target's own hits the nerf prices	optional	all	all | melee | projectile
feedback	text — line sent to the debuffed player on every hit it prices	optional	(empty)	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ OUTGOING_DEBUFF: { percent: 50, duration: 80, cause: projectile, feedback: "&2** UNFOCUSED **" } }

PARTICLE_LINE

Acts on the world

Draw a coloured-dust line from each 'who' target's hip to the actor's hip, `density` motes per block, tinted r/g/b (0-255). Pair with who: @AllPlayers{r=N} for a fan of tethers.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Aoe (override in the effect token).

Argument	What to put	Required?	Default	Allowed
particle	a particle name (e.g. FLAME, HEART)	required	—	—
r	a whole number	optional	255	0 to 255
g	a whole number	optional	255	0 to 255
b	a whole number	optional	255	0 to 255
size	a number (decimals allowed)	optional	1	0 or more
density	a number (decimals allowed)	optional	2	0 or more
height	a number (decimals allowed)	optional	1	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ PARTICLE_LINE: { particle: REDSTONE, r: 255, g: 255, b: 255, density: 2, who: "@AllPlayers{r=7}" } }

PARTICLE_RING

Acts on the world

Draw a horizontal ring of `count` coloured-dust motes of radius `radius` at `height` above the target's feet (default @Self), tinted r/g/b (0-255). A radius / aura indicator.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
particle	a particle name (e.g. FLAME, HEART)	required	—	—
r	a whole number	optional	255	0 to 255
g	a whole number	optional	255	0 to 255
b	a whole number	optional	255	0 to 255
size	a number (decimals allowed)	optional	1	0 or more
radius	a number (decimals allowed)	optional	3	0 or more
count	a whole number	optional	36	1 or more
height	a number (decimals allowed)	optional	1	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ PARTICLE_RING: { particle: REDSTONE, r: 255, g: 255, b: 255, radius: 7, count: 60 } }

PERIODIC_DAMAGE

Acts on an entity

Burn the target for amount raw half-hearts every period ticks over duration ticks, attributed to the activator (kill credit, era-combat delivery). replace is a comma-separated set of potion effects the burn converts — each named DoT's DAMAGE is cancelled for the whole window while the effect itself is left on the target, icon and particles intact; only WITHER and POISON tick damage, so any other name converts nothing. feedback is sent to a player target on every pulse, and tick-sound / tick-particle play there too (once per pulse, never deduped against the hit's other cues). Two burns on one victim both run: unlike FREEZE, this is not a refreshed window.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
amount	a number (decimals allowed) — raw pre-armor half-hearts per pulse (never attack-scaled)	required	—	0 or more
period	a duration in ticks (20 ticks = 1 second)	optional	20	0 or more
duration	a duration in ticks (20 ticks = 1 second)	optional	100	0 or more
replace	a potion-effect name (e.g. STRENGTH, POISON) — vanilla DoTs this burn converts: their damage ticks are cancelled, the effect stays visible	optional	(empty)	—
feedback	text — line sent to a player target on every pulse	optional	(empty)	—
tick-sound	a sound name (e.g. ENTITY_GENERIC_EXPLODE) — cue played at the target on every pulse; omit for silence	optional	—	—
tick-volume	a number (decimals allowed)	optional	1	0 or more
tick-pitch	a number (decimals allowed)	optional	1	0 or more
tick-particle	a particle name (e.g. FLAME, HEART) — burst spawned on the target every pulse; omit for none	optional	—	—
tick-particle-count	a whole number	optional	1	0 or more
tick-particle-2	a particle name (e.g. FLAME, HEART) — a SECOND burst on the same pulse, for a cue built from two particle types	optional	—	—
tick-particle-2-count	a whole number	optional	1	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ PERIODIC_DAMAGE: { amount: 6, period: 20, duration: 120, replace: WITHER, tick-particle: FLAME, tick-particle-count: 20 } }

PHANTOM_BLOCKS

Acts on the world

Show every nearby player a client-only overlay across the qualifying surface of the (2*radius+1)^2 patch under each target for `duration` ticks: material-ally to the actor and anyone allied to them, material-enemy to everyone else. A column qualifies when its first solid block down from the target's own level is a full opaque cube with a passable cell above it — see-through floors, roofed columns and anything more than a few steps below are skipped. NOTHING is written to the world: the patch blocks no movement, breaks nothing and survives no reload, and the window's close re-sends the ground as it really is then (so a block mined meanwhile is not stranded). A viewer who relogs is served the true chunk by the server. The patch IS the actor's owned ground for the window, so %actor.ownedground% and a STACKING_DOT laid over it both see who is standing in it.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
radius	a whole number — blocks each way from the target the overlay covers	optional	3	0 to 8
material-ally	a block or item name (e.g. DIAMOND, OBSIDIAN) — what the actor and their allies are shown	optional	GLOWSTONE	—
material-enemy	a block or item name (e.g. DIAMOND, OBSIDIAN) — what everyone else is shown	optional	END_STONE	—
duration	a duration in ticks (20 ticks = 1 second) — ticks before the real ground is sent back	optional	200	1 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ PHANTOM_BLOCKS: { radius: 4, material-ally: GLOWSTONE, material-enemy: END_STONE, duration: 100, who: "@Self" } }

POTION_AMP_REDUCE

Acts on an entity

Reduce the LEVEL of a potion effect the target already has by `amount` for `duration` ticks, then restore it. Re-applications during the window are held to the same reduced ceiling, and a reduction that leaves nothing denies the effect for the window. A target without the effect is untouched. Unlike POTION_LOCK this takes only part of the buff, so a Health Boost VI sapped by 2 keeps four of its six tiers.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
effect	a potion-effect name (e.g. STRENGTH, POISON)	required	—	—
amount	a whole number — levels to sap; at or above the source the effect is denied	optional	1	1 or more
duration	a duration in ticks (20 ticks = 1 second)	optional	60	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ POTION_AMP_REDUCE: { effect: HEALTH_BOOST, amount: 2, duration: 48, who: "@Victim" } }

POTION_LOCK

Acts on an entity

Strip a potion effect from the target(s) and continuously deny it for `ticks` — any re-application during the window is refused, so it cannot be maintained by a passive buff. Default target self.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
effect	a potion-effect name (e.g. STRENGTH, POISON)	required	—	—
ticks	a duration in ticks (20 ticks = 1 second)	optional	100	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ POTION_LOCK: { effect: SPEED, ticks: 100, who: "@Victim" } }

PROC_REBOUND

Runs inline

While worn, give incoming enchant activations a chance to be taken off you and re-run with the roles swapped — the attacker eats their own proc, and it is NOT applied to you for that hit. Gated by the attacking enchant's tier WEIGHT — the number its rung carries in tiers.yml, not a rung index — which must fall in tier-min..tier-max, and by level: this enchant's level must be at least the incoming one's (a levelless source — set, crystal, mask, pet — has no level to compare and answers its whole band). Several worn grades compose — the one whose band reaches the incoming weight with the highest tier-min wins. A maintained PASSIVE marker, armed on equip and lifted on unequip. Player-only.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
chance	a number (decimals allowed)	required	—	0 to 100
tier-max	a whole number	required	—	0 or more
tier-min	a whole number	optional	0	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ PROC_REBOUND: { chance: 4, tier-min: 10, tier-max: 70, who: "@Self" } }

PROJECTILE_DRESSING

Runs inline

Ride an entity of type on the projectile this BOW_FIRE activation is loosing — the rider is removed the moment the arrow lands, dies or unloads, and unconditionally after ttl ticks. invulnerable spares it from damage for that many ticks so its own flight cannot kill it; no-pickup stops it hoovering up items in mid-air. One rider per shot: a second PROJECTILE_DRESSING on the same shot replaces the first. fire-ticks lights the ARROW itself, which nothing else can reach — IGNITE takes its targets from a selector and no selector names a shot in flight — and needs no rider, so a flaming arrow is this effect with type omitted. Inert outside a bow shot.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
type	a mob/entity type (e.g. WOLF, IRON_GOLEM) — rider to seat on the shot; omit to dress the arrow only	optional	—	—
ttl	a duration in ticks (20 ticks = 1 second) — hard cap on the rider's life; the backstop when nothing reports a landing	optional	200	0 or more
invulnerable	a duration in ticks (20 ticks = 1 second) — how long the rider ignores damage (0 = never)	optional	200	0 or more
no-pickup	true or false	optional	true	—
fire-ticks	a duration in ticks (20 ticks = 1 second) — set the ARROW alight for this long (0 = as loosed); no rider needed	optional	0	0 or more

Example{ PROJECTILE_DRESSING: { type: COW, ttl: 200, invulnerable: 200 } }

PROXIMITY_ANNOUNCE

Acts on the world

Fire PROXIMITY_EVENT on every player within radius of each target — never the target themselves — with tag readable as %proximityevent%. The observer's activation carries the target as its victim, so %distance%, %victim.relation% and every %victim.*% read (including %victim.var.<name>%) describes the subject rather than the observer. The tag exists because one trigger carries several unrelated observations: without it an ally-death watcher and an ally-bleeding watcher would each proc on the other's event.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
tag	text — what happened, read by an observer as %proximityevent%	required	—	—
radius	a number (decimals allowed) — how far the news carries	optional	7	1 to 64
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ PROXIMITY_ANNOUNCE: { tag: "bleed", radius: 7, who: "@Victim" } }

REFLECT

Runs inline

Mark the target so a percent of their own outgoing damage is reflected back onto them for a duration in ticks (Hex). Player targets only; default target the combat victim. cap is a flat per-hit ceiling on the health returned (0 = uncapped); feedback is an optional chat line sent to the afflicted on each reflected hit, with {damage} filled in.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
percent	a number (decimals allowed)	required	—	0 or more
duration	a duration in ticks (20 ticks = 1 second)	optional	80	0 or more
cap	a number (decimals allowed) — flat per-hit ceiling on the health returned; 0 = uncapped	optional	0	0 or more
feedback	text — per-hit line to the afflicted; {damage} = health returned	optional	(empty)	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ REFLECT: { percent: 20, duration: 80, who: "@Victim" } }

REFUND_COOLDOWN

Runs inline

Hand back the cooldown this ability's own gate-6 reservation armed, unless `unless` evaluates non-zero. Author it AFTER the payload whose outcome decides the refusal — a condition cannot, because the fact it would read does not exist until the payload has run. It can only ever release THIS ability's window, and only in the tick the gate reserved it, so a WAIT tier between the payload and the refund silently forfeits it.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
unless	a number (decimals allowed) — skip the refund when this evaluates non-zero; the default (0) always refunds	optional	0	—

Example{ REFUND_COOLDOWN: { unless: "%lavapet.filled%" } }

SOUL_COST_EXEMPT

Runs inline

Waive every soul cost charged to each target for `duration`. Both debit paths are covered: a soul-cost ability's gate charge and a REMOVE_SOULS aimed at the holder's own gem. While exempt a soul-cost ability fires even with no gem active, and its escalating price stops advancing — a free activation cannot raise the next one. Each waiver above `feedback-threshold` sends `message` with {souls} filled in, so the small change stays quiet. Re-arming replaces the window rather than extending it.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
duration	a duration in ticks (20 ticks = 1 second) — how long the holder's soul costs are waived	required	—	1 or more
feedback-threshold	a whole number — a waiver must EXCEED this many souls to send `message`	optional	10	0 or more
message	text — line sent on each waiver above the threshold ({souls} = the amount waived); empty = silent	optional	(empty)	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ SOUL_COST_EXEMPT: { duration: 300, feedback-threshold: 10, message: "&a&lPET (&aTesla&a&l): &a+{souls} souls!", who: "@Self" } }

SOUL_MODE_DISABLE

Acts on an entity

Force the target out of soul mode: pending spends settle to their gems, the pool is dropped and they are told, with the same lines and cues a manual toggle-off sends. A no-op on a target who is not in soul mode. Pair with REMOVE_SOULS to drain the wallet AND flip the switch — draining alone leaves the mode running.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ SOUL_MODE_DISABLE: { who: "@Victim" } }

SOUL_TRANSFER

Acts on an entity

Move min(target's souls, cap) souls out of the target's gems and credit the actor floor(ratio x stolen) — the remainder is destroyed, not banked. Unlike REMOVE_SOULS this does not require either party to be in soul mode: it reads the gems themselves. overflow=mint gives the actor a fresh gem carrying the credit when they carry none; overflow=discard loses it. A target with no souls is a silent no-op, so the authored condition decides what a dry victim costs.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
cap	a whole number — the most souls one activation may take	required	—	1 or more
ratio	a number (decimals allowed) — fraction of the take the actor keeps; the rest is destroyed	optional	1.0	0 to 1
overflow	one of: mint, discard — what happens when the actor carries no gem to credit	optional	mint	mint | discard
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ SOUL_TRANSFER: { cap: 50, ratio: 0.5, who: "@Victim" } }

SPAWNER_YIELD

Runs inline

While worn (PASSIVE): every spawner spawn near the wearer rolls `chance`% to add `extra` copies of the same mob at the same spot. `scope: chunk` counts a wearer standing in the spawn's own chunk; `scope: radius` counts one within `radius` blocks of it. The wearer test is asked PER SPAWN against live worn state, so walking away stops it immediately. Grants do NOT stack — two wearers at one spawner get the stronger one's yield, not both. The added copies spawn as CUSTOM, so they never re-trigger this, but they DO count toward the spawner's nearby-entity cap: a wearer fills that cap sooner and the spawner then idles until the area clears.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
chance	a number (decimals allowed) — percent of spawns that come out multiplied	optional	65	0 to 100
extra	a whole number — copies added on a winning roll	optional	1	1 to 8
scope	one of: chunk, radius — where the wearer counts as present	optional	chunk	chunk | radius
radius	a number (decimals allowed) — blocks, for scope: radius; ignored for scope: chunk	optional	16	0 or more

Example{ SPAWNER_YIELD: { chance: 65, extra: 1, scope: chunk } }

SPAWN_SWARM

Acts on the world

Summon count entities of type evenly spaced on a radius-block ring around the activator, raised rise blocks (chest height), each facing directly outward, with VANILLA AI, auto-removed after ttl ticks. speed < 1 slows each to that fraction of its vanilla AI speed via a per-tick velocity damp (Bat-style AI ignores the speed attribute). cloud: true makes the summons orbit the 1x2x1 pillar directly in front of whoever attacked the activator most recently within cloud-range blocks (vision cloud); with no such attacker they keep vanilla AI. While clouding, the orbit's own pacing overrides speed. name is shown above each summon and effects is a comma-separated potion loadout held for its whole life, each entry optionally levelled with NAME*LEVEL (SPEED*3) — the same styling GUARD and SPAWN_ENTITY take. owner: activator binds every summon to the summoner, so vanilla AI never turns the ring on the player standing inside it, and {OWNER} in name fills with their name.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot.

Argument	What to put	Required?	Default	Allowed
type	a mob/entity type (e.g. WOLF, IRON_GOLEM)	required	—	—
count	a whole number	optional	1	1 or more
radius	a number (decimals allowed)	optional	0.5	0 or more
rise	a number (decimals allowed)	optional	1.2	0 or more
ttl	a duration in ticks (20 ticks = 1 second)	optional	300	0 or more
speed	a number (decimals allowed)	optional	1	0 to 1
cloud	true or false	optional	false	—
cloud-range	a number (decimals allowed)	optional	16	1 or more
owner	one of: none, activator — activator binds each summon to the summoner: vanilla AI can no longer target them, and {OWNER} fills	optional	none	none | activator
name	text — custom name shown above each summon; {OWNER} fills in the summoner	optional	(empty)	—
effects	a potion-effect name (e.g. STRENGTH, POISON) — potion effects held for each summon's whole life	optional	(empty)	—

Example{ SPAWN_SWARM: { type: BAT, count: 10, radius: 0.5, ttl: 300, speed: 0.5 } }

STACKING_DOT

Acts on an entity

Watch each target for `duration` and, every `period` ticks they spend standing on ground the ACTIVATOR placed with `TEMP_BLOCK`, deal `step` x their live stack count as real (pre-armour) damage credited to the activator. Stacks climb one per damaging pulse to `cap` and lapse `stack-ttl` after the last one, so leaving the field pauses the ramp rather than resetting it. The ladder is PER VICTIM and shared across every attacker — two overlapping fields ramp one ladder, not two. The first pulse waits `lead-in`, which is what lets one activation lay its field and its watcher together.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
step	a number (decimals allowed) — damage added per live stack, in raw half-hearts	optional	2	0 or more
period	a duration in ticks (20 ticks = 1 second) — ticks between pulses	optional	10	1 or more
cap	a whole number — the most stacks one victim's ladder can reach	optional	6	1 or more
stack-ttl	a duration in ticks (20 ticks = 1 second) — how long a ladder survives after its last pulse — the grace for stepping off the ground	optional	60	1 or more
lead-in	a duration in ticks (20 ticks = 1 second) — delay before the first pulse reads the ground	optional	20	1 or more
duration	a duration in ticks (20 ticks = 1 second) — how long each target is watched	optional	200	1 or more
message	text — line sent to the victim on each damaging pulse ({damage}, {stacks}); empty = silent	optional	(empty)	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ STACKING_DOT: { step: 2, period: 10, cap: 6, stack-ttl: 60, lead-in: 20, duration: 200, message: "&c&l* DECAYING [&7-{damage}HP ({stacks} stacks)&c&l] *", who: "@Aoe" } }

STATUS_CLEAR

Runs inline

Remove an active engine status window from each target: TELEBLOCK (the teleport denial), POTION_LOCK (every potion denial held on them), DISARM (the armed disarm window), or FREEZE (a live freeze, with its damage-over-time and both movement modifiers). Unlike CURE this touches no potion EFFECT — it lifts the plugin state that was denying one. Clearing a window nobody holds is a silent no-op, so the authored condition decides what a wasted use costs.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
status	one of: TELEBLOCK, POTION_LOCK, DISARM, FREEZE — which engine window to lift	required	—	TELEBLOCK | POTION_LOCK | DISARM | FREEZE
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ STATUS_CLEAR: { status: TELEBLOCK, who: "@Self" } }

STRIP_SCROLL

Acts on an entity

Remove one protection scroll marker from a random protected piece of the target's worn armour (+ held item unless hand: false): scroll HOLY strips a Holy White Scroll, WHITE a White Scroll (its guard flag included). A target with no protected piece is a no-op. Rate-limit with the ability's chance gate (the Anubis per-hit percent).

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
scroll	one of: HOLY, WHITE	optional	HOLY	HOLY | WHITE
hand	true or false	optional	true	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ STRIP_SCROLL: { scroll: HOLY, who: "@Victim" } }

SUMMON_PURGE

Runs inline

Despawn every summon within `radius` blocks of the wearer whose owner the `filter` does not spare, leaving the particle / extra-particle burst where each one stood. The filter is a ladder of exemptions: not-own spares only the wearer's summons, not-own-or-ally also spares an ONLINE ally's, and not-own-or-ally-or-offline additionally spares one whose owner has logged off (an abandoned summon is left to its own TTL). Only summons the engine can attribute to a player are touched — a wild mob, and a summon spawned with owner=none, are not summons anyone owns and are left alone. The removal is a DESPAWN: no drops, no experience and no death event, so nothing the owner hung on a death fires. An invincible summon survives, exactly as it survives DESPAWN and KILL. CONVERT_SUMMON is the inverse — it keeps the summons and flips them onto your side.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
radius	a number (decimals allowed) — how far the sweep reaches from the wearer	optional	15	1 to 32
filter	one of: not-own, not-own-or-ally, not-own-or-ally-or-offline — which owners are SPARED, weakest sweep last	optional	not-own-or-ally-or-offline	not-own | not-own-or-ally | not-own-or-ally-or-offline
particle	a particle name (e.g. FLAME, HEART) — burst left where each purged summon stood; omit for none	optional	—	—
particle-count	a whole number	optional	1	0 or more
particle-spread	a number (decimals allowed) — per-axis spread of the burst (0 = a point)	optional	0	0 or more
extra-particle	a particle name (e.g. FLAME, HEART) — second burst layered on the first; omit for none	optional	—	—
extra-particle-count	a whole number	optional	1	0 or more
extra-particle-spread	a number (decimals allowed)	optional	0	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ SUMMON_PURGE: { radius: 15, filter: not-own-or-ally-or-offline, particle: LARGE_SMOKE, particle-count: 10, particle-spread: 0.3, extra-particle: SPELL_WITCH, extra-particle-count: 12, extra-particle-spread: 0.7 } }

SUMMON_REBIND

Acts on an entity

Replace each target summon the activator OWNS with a fresh one of type, rise blocks above it: the old body is removed silently (no death, no drops, no kill credit) and the replacement spawns at full health with a restarted ttl. health, speed, name and effects are GUARD's loadout params. A summon the activator does not own is skipped unless steal is set, which widens the precondition from 'mine' to 'somebody's' — the target must still be a tracked summon, so a farmed wild mob can never be turned into a free top-tier guardian. steal-message is the only place both names exist at once, which is why the broadcast rides the effect instead of a MESSAGE line. CONVERT_SUMMON rebinds ownership in place; this replaces the body.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
type	a mob/entity type (e.g. WOLF, IRON_GOLEM)	required	—	—
ttl	a duration in ticks (20 ticks = 1 second)	optional	600	0 or more
name	text — custom name shown above the replacement; {OWNER} fills in the summoner	optional	(empty)	—
health	a number (decimals allowed) — starting (and maximum) health; 0 keeps the vanilla one	optional	0	0 or more
speed	a number (decimals allowed) — movement-speed multiplier; 0 keeps the vanilla one	optional	0	0 or more
effects	a potion-effect name (e.g. STRENGTH, POISON) — potion effects held for the replacement's whole life	optional	(empty)	—
rise	a number (decimals allowed) — blocks above the old body to place the replacement	optional	2	0 to 8
steal	true or false — also take summons owned by SOMEONE ELSE (a summon it must still be — never a wild mob)	optional	false	—
steal-message	text — steal only: broadcast near the replacement; {FROM} is the robbed owner, {OWNER} the thief	optional	(empty)	—
steal-radius	a number (decimals allowed) — how far the steal-message carries	optional	24	0 to 64
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ SUMMON_REBIND: { type: IRON_GOLEM, ttl: 600, health: 90, name: "&b&l{OWNER}'s Guardian" } }

SUPPRESS_IMMUNE

Runs inline

Make the target(s) immune to suppression (DISABLE_ENCHANT/GROUP/TYPE) while worn — a maintained PASSIVE flag, armed on equip and lifted on unequip. An optional chance (default 100) makes it a per-suppression roll instead of absolute. Player-only.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
chance	a whole number	optional	100	0 to 100
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ SUPPRESS_IMMUNE: { chance: 4, who: "@Self" } }

SUPPRESS_INCOMING

Runs inline

Make each target IMMUNE to abilities aimed at them: for `duration` ticks, an ability whose enchant/group/type (or, with scope KIND, whose effect head) matches `key` is blocked whenever it lands on the holder. Aimed at them directly it is stopped outright; when they are merely one of several bodies a chain or area effect resolved onto, they alone are skipped and the rest still take it. `chance` rolls per incoming target application. The mirror of SUPPRESS, which silences what its target DOES; this silences what is done TO them, including the opening proc a defensive SUPPRESS can never reach. Re-arming extends the window, so a PASSIVE may hold it open. The consumed-* lines fill {ATTACKER} with whoever armed the window — here, the protected holder — and {VICTIM} with the activator it blocked.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
scope	one of: ENCHANT, GROUP, TYPE, KIND	required	—	ENCHANT | GROUP | TYPE | KIND
key	text	required	—	—
duration	a duration in ticks (20 ticks = 1 second)	optional	200	0 or more
chance	a whole number — percent rolled per incoming target application; 100 is absolute	optional	100	1 to 100
consumed-message-actor	text — line to the protected holder, when it blocks	optional	(empty)	—
consumed-message-victim	text — line to the blocked activator, when it blocks	optional	(empty)	—
consumed-sound	a sound name (e.g. ENTITY_GENERIC_EXPLODE) — cue played at the block; omit for silence	optional	—	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ SUPPRESS_INCOMING: { scope: GROUP, key: lifesteal, duration: 100, who: "@Self" } }

SWAP_POSITION

Runs inline

Castling (reforges): lock the enemy in your crosshair (range, line of sight), channel for channel ticks with audible countdown cues and a warning to the victim, then both of you swap positions — velocities zeroed, each keeps their own facing. Line of sight broken, range + slack exceeded, a world change or a death aborts it; the use stays spent. Reforge-service-owned: this effect emits no intent of its own.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
range	a number (decimals allowed) — crosshair target acquisition + max channel distance	optional	12	1 or more
channel	a duration in ticks (20 ticks = 1 second) — channel length (the 2-second countdown)	optional	40	0 or more
check-period	a whole number — LOS/validity re-check cadence, ticks	optional	2	1 to 10
cue-period	a duration in ticks (20 ticks = 1 second) — countdown tick-cue cadence	optional	10	0 or more
range-slack	a number (decimals allowed) — extra blocks past range before a drift aborts	optional	2	0 or more

Example{ SWAP_POSITION: { range: 12, channel: 40 } }

TELEPORT_BEHIND

Acts on an entity

Teleport the mover(s) `distance` blocks behind the reference (of: VICTIM — the attacker on a DEFENSE trigger — or ACTOR), facing as it faces. Unsafe (blocked / wall between) → onFail ONTOP lands on the reference, NONE cancels.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
of	one of: VICTIM, ACTOR	optional	VICTIM	VICTIM | ACTOR
distance	a number (decimals allowed)	optional	1	0 or more
onFail	one of: ONTOP, NONE	optional	ONTOP	ONTOP | NONE
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ TELEPORT_BEHIND: { of: VICTIM, distance: 1, onFail: ONTOP, who: "@Self" } }

TEMP_BLOCK

Acts on the world

Place a temporary block shape that reverts after `ticks`: shape POINT / FOOTPRINT (radius) / COLUMN (height, ahead in the target's facing) / BOX (width × height × depth filled volume horizontally centred on the target — the ADR-0052 Spider webs), at feet level + dy. airOnly only replaces air (safe placement); a non-airOnly FOOTPRINT replaces only the solid ground under the feet (never air, so a trail can't scaffold); other shapes replace anything and restore on revert. A radius-0 FOOTPRINT trails as a snake — consecutive stamps join into a gapless, 4-connected footprint path even at sprint speed and on diagonals. Give material2/3/4 to place a mixed palette: each block independently picks a material from a deterministic per-block hash of its coordinates — a noisy, random-looking scatter (re-placing the same block always picks the same material). A BOX is always single-material (palette[0]). fill-chance below 100 places only that percent of the shape's columns, for a ragged, partial field instead of a solid one; the choice is per column and stable for a given coordinate, so re-stamping the same ground extends the same field rather than filling in its holes. A radius-0 FOOTPRINT trail ignores it — a snake with gaps is not a path.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
shape	one of: POINT, FOOTPRINT, COLUMN, BOX	optional	POINT	POINT | FOOTPRINT | COLUMN | BOX
material	a block or item name (e.g. DIAMOND, OBSIDIAN)	required	—	—
material2	a block or item name (e.g. DIAMOND, OBSIDIAN)	optional	—	—
material3	a block or item name (e.g. DIAMOND, OBSIDIAN)	optional	—	—
material4	a block or item name (e.g. DIAMOND, OBSIDIAN)	optional	—	—
ticks	a duration in ticks (20 ticks = 1 second)	optional	60	0 or more
radius	a whole number	optional	0	0 to 5
width	a whole number	optional	3	1 to 8
height	a whole number	optional	1	1 to 8
depth	a whole number	optional	3	1 to 8
ahead	a whole number	optional	0	0 to 8
dy	a whole number	optional	0	-4 to 4
airOnly	true or false	optional	true	—
fill-chance	a number (decimals allowed) — percent of columns actually placed — a partial, scattered field	optional	100	0 to 100
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ TEMP_BLOCK: { shape: COLUMN, material: ICE, height: 2, ahead: 1, ticks: 60, who: "@Attacker" } }

TRAP_BREAK

Runs inline

Break every confining trap currently on the wearer — encasing webs, web boxes, cage cells — restoring the trapped blocks to their true originals immediately. Area floors and trails are unaffected. Works through ability silence (it is a block restore, not an ability negation).

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
whiff-sound	a sound name (e.g. ENTITY_GENERIC_EXPLODE) — played (low-pitched) when nothing confining was found — a silent no-op is indistinguishable from a broken feature	optional	BLOCK_ANVIL_LAND	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ TRAP_BREAK: { } }

TURRET_RING

Acts on the world

Stand `count` invulnerable `type` emplacements on open ground, evenly spaced on a ring-radius ring around each target, for `ttl` ticks. A site with no open ground, or one the protection gate denies the actor, is SKIPPED (logged) — the ring is gated spot by spot, not once for the cast. After `initial-delay` ticks each emplacement fires a `projectile` at `projectile-speed` toward the nearest body the `filter` admits within acquire-range that has line of sight to it, then re-fires every period-min..period-max ticks (a fresh draw per volley, so a ring never fires as one salvo). A shot that strikes a body runs the ACTOR's IMPACT abilities on it ONCE — that payload is the whole damage; emplacements take no damage and neither they nor their shots ever break blocks. The `spawn-` cue plays where each one lands (plus a damage-free lightning flash unless spawn-lightning: false) and the `despawn-` cue where it expires. Era note: a fireball-family projectile is propelled with setDirection, whose scaling changed in the 1.21 line — the shot flies everywhere, but reads faster there than the authored speed.

How it runs: Touches blocks/world at a location (breaks, particles, spawns). Runs safely on the region that owns that spot. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
type	a mob/entity type (e.g. WOLF, IRON_GOLEM) — what each emplacement is	optional	ENDER_CRYSTAL	—
count	a whole number — how many emplacements the ring tries to place	optional	3	1 to 16
ring-radius	a number (decimals allowed) — blocks from the actor to each emplacement	optional	7	0 or more
ttl	a duration in ticks (20 ticks = 1 second) — how long the ring stands before it despawns	optional	200	1 or more
acquire-range	a number (decimals allowed) — how far an emplacement looks for a target	optional	8	0 or more
initial-delay	a duration in ticks (20 ticks = 1 second) — ticks before the FIRST volley — the arming window	optional	30	0 or more
period-min	a duration in ticks (20 ticks = 1 second) — shortest gap between volleys	optional	8	1 or more
period-max	a duration in ticks (20 ticks = 1 second) — longest gap between volleys	optional	13	1 or more
filter	one of: ALL, PLAYERS, MONSTERS, MOBS, ENEMIES, ALLIES — who an emplacement will shoot at	optional	ENEMIES	ALL | PLAYERS | MONSTERS | MOBS | ENEMIES | ALLIES
projectile	a mob/entity type (e.g. WOLF, IRON_GOLEM) — what an emplacement fires	optional	WITHER_SKULL	—
projectile-speed	a number (decimals allowed) — how hard each shot is launched	optional	0.06	0 or more
spawn-sound	a sound name (e.g. ENTITY_GENERIC_EXPLODE) — cue as the ring lands; omit for silence	optional	—	—
spawn-volume	a number (decimals allowed)	optional	1	0 or more
spawn-pitch	a number (decimals allowed)	optional	1	0 or more
spawn-particle	a particle name (e.g. FLAME, HEART) — burst at each emplacement; omit for none	optional	—	—
spawn-particle-count	a whole number	optional	1	0 or more
spawn-particle-spread	a number (decimals allowed)	optional	0	0 or more
spawn-lightning	true or false — flash a damage-free lightning visual at each emplacement	optional	true	—
despawn-sound	a sound name (e.g. ENTITY_GENERIC_EXPLODE) — cue as an emplacement expires; omit for silence	optional	—	—
despawn-volume	a number (decimals allowed)	optional	1	0 or more
despawn-pitch	a number (decimals allowed)	optional	1	0 or more
despawn-particle	a particle name (e.g. FLAME, HEART) — burst as an emplacement expires; omit for none	optional	—	—
despawn-particle-count	a whole number	optional	16	0 or more
despawn-particle-spread	a number (decimals allowed)	optional	0.75	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ TURRET_RING: { type: ENDER_CRYSTAL, count: 5, ring-radius: 8, ttl: 300, acquire-range: 11, initial-delay: 30, period-min: 8, period-max: 13, filter: ENEMIES, projectile: WITHER_SKULL, projectile-speed: 0.065, spawn-sound: ENTITY_GHAST_SHOOT, spawn-volume: 3.0, spawn-pitch: 0.9, spawn-particle: FLAME, spawn-particle-count: 24, spawn-lightning: true, despawn-particle: SPELL_WITCH, despawn-particle-count: 16, despawn-particle-spread: 0.75, who: "@Self" } }

VANISH

Acts on an entity

Hide the target from EVERY online player for `duration` ticks — a packet-level hide, so worn armour vanishes with the body. The window breaks early once `break-hits` of the target's own hits LAND (0 = never); damage they take never spends one, so hiding survives being hit but not hitting back. A player who joins mid-window is re-synced, so a vanish cannot be beaten by relogging. While it is live `var` reads 1, and it drops to 0 the moment it ends by any route (timer, hit, quit). A re-proc REPLACES the window: fresh duration, fresh hit allowance. `end-message` is sent to the target once the window ends, whichever route ended it — exactly once, never on the refusal path.

How it runs: Acts on a living target (heal, ignite, potion, teleport). Runs on whoever the effect is aimed at. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
duration	a duration in ticks (20 ticks = 1 second) — ticks the target stays hidden from every player	optional	30	1 or more
break-hits	a whole number — landed outgoing hits the window absorbs before it breaks; 0 = only the timer ends it	optional	1	0 or more
var	text — player variable reading 1 while the window is live; empty = none	optional	(empty)	—
end-message	text — line sent to the target when the window ends, by ANY route; empty = silent	optional	(empty)	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ VANISH: { duration: 60, break-hits: 2, end-message: "&4&l* Feign Death - UNVANISHED *", who: "@Self" } }

VIEWER_HIDE

Runs inline

Hide the target player from the attacker (viewer=attacker) or from every online player (viewer=all) for duration ticks, restoring them at the window's close. A packet-level hide: worn armour vanishes with the body, unlike an INVISIBILITY potion. A relog on either side ends it early. viewer=attacker with no attacker in scope hides nothing.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
duration	a duration in ticks (20 ticks = 1 second)	optional	20	0 or more
viewer	one of: attacker, all	optional	attacker	attacker | all
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ VIEWER_HIDE: { duration: 60, viewer: attacker } }

VULNERABILITY

Runs inline

Mark each player target to take `percent`% more damage from EVERY source (fall, fire and the void included) for `duration`. NON-STACKING: a re-mark keeps the stronger window and the later expiry, never the sum. The contribution is additive with the victim's own reductions, so armour still counts — this is a fragility mark, not a bypass.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
percent	a number (decimals allowed) — extra incoming damage, e.g. 100 for double	required	—	0 or more
duration	a duration in ticks (20 ticks = 1 second) — how long the mark holds	optional	60	1 or more
hit-message	text — line sent to the marked player on each hit the mark amplifies ({damage} = the hit); empty = silent	optional	(empty)	—
expiry-message	text — line sent when the mark lapses; empty = silent	optional	(empty)	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ VULNERABILITY: { percent: 100, duration: 60, hit-message: "&cmarked (-{damage})", expiry-message: "&7mark off", who: "@Victim" } }

WARD

Runs inline

Ward the target player(s) with a typed guard flag for duration ticks: mob-target (mobs don't aggro unless provoked), invsee (others can't open their inventory), near (hidden from the proximity listing), splash-heal (healing splash potions boosted by amount%).

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Self (override in the effect token).

Argument	What to put	Required?	Default	Allowed
type	one of: mob-target, invsee, near, splash-heal	required	—	mob-target | invsee | near | splash-heal
duration	a duration in ticks (20 ticks = 1 second)	optional	100	0 or more
amount	a number (decimals allowed)	optional	0	—
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ WARD: { type: splash-heal, duration: 100, amount: 50 } }

WATER_SPEED

Runs inline

Underwater movement boost while worn (PASSIVE/HELD): efficiency feeds the vanilla water_movement_efficiency attribute through one reconciled plugin-owned modifier (1.21+ only; older servers and 1.8.9 keep everything else and skip the boost). 0.09 ~ +10%, 0.14 ~ +15%, 0.20 ~ +20%, 0.26 ~ +25% swim speed.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop.

Argument	What to put	Required?	Default	Allowed
efficiency	a number (decimals allowed)	required	—	0 to 1

Example{ WATER_SPEED: { efficiency: 0.09 } }

WEAKEN

Runs inline

Debuff the target's outgoing damage by a percent for a duration in ticks (non-stacking). Player targets only; default target the combat victim.

How it runs: Runs immediately, in line with the event that triggered it (e.g. shaping the combat hit). No extra thread hop. Default target: who -> @Victim (override in the effect token).

Argument	What to put	Required?	Default	Allowed
percent	a number (decimals allowed)	required	—	0 or more
duration	a duration in ticks (20 ticks = 1 second)	optional	100	0 or more
each-if	condition — Per-target filter: each resolved target is tested with the %target.*% subject bound, and a target that fails is dropped from THIS effect only. It cannot un-activate the ability, release its cooldown or refund its souls.	optional	—	—
each-chance	a number (decimals allowed) — Per-target chance, sugar for each-if: "%target.roll% < <this>" over the ONE draw each body carries for the whole ability — so this row and its complement partition instead of rolling twice. Declaring each-if too ANDs them.	optional	—	0 to 100
each-cooldown	a duration in ticks (20 ticks = 1 second) — Per-target cooldown in ticks: a target hit within its own window is dropped. Keyed on the ability's cooldown scope, so declaring it without one is a load error.	optional	—	0 or more

Example{ WEAKEN: { percent: 15, duration: 100, who: "@Victim" } }

See also

• Triggers — when these effects fire.
• Selectors — who an effect targets.
• Conditions & variables — gate an effect on game state.