Configuring

Sequences

The step syntax: every token, every shape, the parameters that move a display, and the choreography of a body.

An effect is a list of steps, played in order. Every step is a token in brackets, then what it is drawn with, then parameters separated by ;:

- '[CIRCLE] NETHERITE_SWORD;as:item;radius:3;points:12;from:0,10,0;ease:in'

(0,0,0) is where the victim fell. Positive Y is up.

Displays or particles

A shape line draws displays when it carries as:, and particles when it does not.

Written	Drawn with
`as:item`	An item model.
`as:block`	A block model.
`as:head`	A player head: a base64 texture, or `{killer}` / `{victim}` for a face.
`as:text`	A line of text.
(nothing)	The particle named at the head of the line.

- '[CIRCLE] FLAME;radius:2.0;points:32;color:255,80,0'      # particles
- '[CIRCLE] DEEPSLATE;as:block;radius:3.4;points:12'         # displays

Shapes

Twenty-five of them, plus DISPLAY for a single object at the anchor and PIXELS for a picture or a word:

CIRCLE SPHERE DOME CUBE LINE RIBBON SCATTER BEAM SPIRAL DOUBLE_HELIX TORNADO STAR CAGE DISC VORTEX WAVE CROSS GALAXY TORUS BURST PYRAMID RING_PULSE WINGS ARCH CLAW DISPLAY PIXELS

Each has its own parameters:

Shape	Parameters
`CIRCLE`, `SPHERE`, `DOME`	`radius` `points`
`BEAM`	`height` `points`
`SPIRAL`	`height` `radius` `turns` `points`
`DOUBLE_HELIX`	`height` `radius` `turns` `points` `strands`
`TORNADO`	`height` `radius` `top_radius` `turns` `points`
`STAR`	`radius` `spikes` `inner` `points`
`CAGE`	`radius` `height` `columns` `points`
`DISC`	`radius` `rings` `points`
`VORTEX`	`radius` `turns` `points`
`WAVE`	`length` `amplitude` `frequency` `arms` `angle` `points`
`CROSS`	`radius` `arms` `angle` `points`
`GALAXY`	`radius` `turns` `arms` `points`
`TORUS`	`radius` `tube` `segments` `tube_segments`
`BURST`	`radius` `beams` `angle` `points`
`PYRAMID`	`base` `height` `points`
`RING_PULSE`	`radius` `rings` `spacing` `points`
`WINGS`	`span` `arch` `depth` `dir` `points`
`ARCH`	`radius` `arc` `dir` `points`
`CLAW`	`radius` `claws` `spread` `curve` `dir` `drop` `points`
`CUBE`	`width` `points` `edges`
`LINE`	`length` `dir` `climb` `points`
`RIBBON`	`radius` `points` `waves` `amplitude`
`SCATTER`	`radius` `height` `points` `seed` `floor`
`DISPLAY`	(none — one object at the anchor)
`PIXELS`	`art` or `word`, `pixel` `pick` `depth` — below

What every shape understands

y scale color size count ticks interval face rotate

Parameter	What it does
`y`	Lifts the whole shape. `SPHERE` and `TORUS` sit a block up by default; everything else at zero.
`scale`	Grows or shrinks the geometry itself.
`ticks`	`1` draws the whole shape in one frame; higher spreads it over time, so a spiral looks drawn rather than dropped.
`interval`	Seconds between those frames. Defaults to `0.05`.
`rotate`	Turns the whole shape, in degrees.
`face`	Turns it to face whoever caused the kill.
`color`, `size`, `count`	Particle lines only: `DUST` takes `color:255,80,0`, `size` is the dot, `count` the particles per point.

Moving a display

Everything below works on any shape drawn with as:.

Parameter	What it does
`life`	Seconds it exists.
`from:x,y,z`	Where it starts, relative to its point.
`to:x,y,z`	Where it ends. `rise:` is shorthand for a vertical `to`.
`ease`	`in`, `out` or `in_out`. `ease:in` aims a slam.
`gravity`	Debris only. It is added to the movement rather than replacing it.
`spin`	Turns, or `x,y,z` to tumble. `axis` picks the one axis.
`orbit`	Turns carried around the anchor.
`pull`	`1` reaches the centre; a negative number throws it outwards.
`size`	One number, or `x,y,z` for a plate, a pillar or a blade.
`size_to`	The size it ends at.
`vary`	How much individual pieces differ from one another.
`roll`, `tilt`, `turn`	Fixed rotation in degrees.
`face_out`	Faces away from the centre.
`glow`	An outline colour.
`light`	`0` to `15`. Use `light:15` for anything that must read at night.
`model`, `billboard`, `hold`	The display's own model, billboard mode and how long it is held.

Three rules that save an afternoon

ease:in aims a slam and ease:out settles one. gravity: adds to a movement that already descends, so a fall of eight blocks plus gravity goes through the floor — half of gravity times the life squared is how far it drops. And roll: aims a blade, not tilt:: an item model is a flat plate facing south with its tip up and to the right, so roll:135 points it down.

Scenery is written on the world's own axes: x is east, z is south. A body is not — it faces whoever killed it — so scenery that has to line up with one is kept round it (circles, beams, anything straight above) or written as text, which faces whoever is looking.

`[PIXELS]` — pictures and words

A picture or a word built out of blocks, cell by cell. SLAPPED grows its word in, then lets it drift up and shrink away:

- '[PIXELS] RED_CONCRETE;as:block;word:SLAP;pixel:0.12;face:true;y:2.7;ease:out;life:0.25;size:0.02;size_to:0.12;light:15'
- '[DELAY] 0.25'
- '[PIXELS] RED_CONCRETE;as:block;word:SLAP;pixel:0.12;face:true;y:2.7;from:0,0,0;to:0,0.4,0;ease:in;life:0.8;size:0.12;size_to:0.02;light:15'

Parameter	What it does
`art`	A picture: `heart` `heart_big` `broken_heart` `star` `crown` `skull` `bolt` `note` `cloud` `trophy` `ufo` `moon` `guillotine` `blade` `grave` `portal` `eye` `clock` `rift` `flag`.
`word`	Letters instead of a picture.
`pixel`	The size of one cell, in blocks.
`pick`	Which characters of the picture this line draws: `#` the body, `o` the outline, `w` the shine, `y` the gems. Two lines in two materials colour one picture.
`depth`	Moves it towards whoever it faces.
`face:true`	Turns it to whoever did it, which keeps a word the right way round.

Everything in Moving a display applies to it.

Repeating a line

repeat every turn_each work on any step — a sound, a shape, a ring of blades:

- '[CIRCLE] NETHERITE_SWORD;as:item;radius:2;points:6;repeat:3;every:0.2;turn_each:15'

Parameter	What it does
`repeat`	How many times the line plays.
`every`	Seconds between plays. Defaults to `0.15`.
`turn_each`	Degrees added each time, so the copies fan out.

The other tokens

Token	Parameters
`[DELAY] 0.15`	Seconds to wait before the next line.
`[PARTICLE] FLAME`	`count` `speed` `y` `color` `size` `offset:x,y,z` `block`
`[SOUND] NAME;volume;pitch`	Also `volume:` `pitch:`. A volume above `1.0` is read as `1.0`: a louder sound only carries further, sixteen blocks per point.
`[LIGHTNING]`	`volume:` `pitch:` — flash, sparks and thunder. No strike, no fire, no damage.
`[EXPLOSION]`	`count:` `y:`
`[FIREWORK]`	`color:` `fade:` `type:` `trail:` `flicker:` `power:`
`[BLOCK_BREAK] STONE`	`count:` `y:` `offset:`
`[POTION] speed;100;1`	Also `duration:` `amplifier:`
`[TITLE] title;subtitle;in;stay;out`	Times in seconds.
`[ACTION_BAR] text`
`[MESSAGE] text`	A chat line.
`[COMMAND] give {player} …`	`{player}` `{world}` `{x}` `{y}` `{z}`
`[RAGDOLL] {victim}`	The body itself, choreographed, below.
`[NPC] {victim}`	A whole fake player, below.

`[RAGDOLL]` — the body itself

The victim's own body with every joint kept — head, torso, two arms, two legs, each wearing the colours of their own skin — moved frame by frame as a scene of its own. All 110 shipped effects are built on it.

- '[RAGDOLL] {victim};intact:0.1;detail:2;light:15;then:burst;keys:0.25 crouch ease=anticipate | 0.4 stand up=1.6 flip=~-360 ease=out | 0.35 up=0 ease=bounce'

Whose body

The first word is whose body it is:

Head	Body
`{victim}`	Whoever died.
`{killer}`	A copy of whoever did it, acting the death out.
`{crowd}`	With `seat:N`, the Nth player watching nearby — or a stranger when nobody is.

Every body faces the killer's side, so at=0,0,2 turn=180 is someone two blocks away looking at the victim.

`keys` — the choreography

Frames are separated by |. Each starts with the seconds it takes to reach it from the one before — the same numbers the effect's [DELAY] lines add up to — and then lists only what changes. The body starts standing where it died, once intact is over. A frame of 0 seconds is where it starts instead, which is how a second body stands across the room from the very first tick.

Channel	What it moves
`at=right,up,forward`	The hips, in blocks. Also `right=` `up=` `forward=` on their own.
`flip=` `turn=` `lean=`	The whole body: forwards, to its left, to its right.
`head=` `body=`	`pitch,yaw,roll`: nods forward, turns left, tilts right.
`arm_r=` `arm_l=` `leg_r=` `leg_l=`	`pitch,yaw,roll`: swings forward and up, swings a raised limb outwards, raises it away from the body.
`arms=` `legs=`	Both sides at once, mirrored.
`<joint>_at=out,up,forward`	Pulls a part off its joint.
`size=` `<joint>_size=`	How big the body, or one part of it, is.
`shake=`	How hard it trembles, in blocks.
`ease=`	`in_out` (default), `in`, `out`, `linear`, `back`, `anticipate`, `elastic`, `bounce`, `snap`, `smooth`.

Angles are degrees. ~90 adds to where a channel already is, so turn=~360 is one more full turn. smooth flows through a frame instead of stopping at it, which is what a sway or a path needs.

A bare word is a whole pose, and whatever follows it in the frame is written on top of it:

stand tpose star cheer reach zombie hug crouch sit kneel lie prone bow pray dab superman splits float limp fetal swoon heart arabesque

How it ends

then: is what happens after the last frame, worked out from how each piece was moving.

Value	What happens
`hold`	It stays as the last frame left it.
`burst`	Thrown apart. Reads `speed` `up` `spread` `gravity` `bounce` `spin`.
`collapse`	Falls to the floor where it is.
`implode`	Pulled into itself. Reads `turns`.
`dissolve`	Comes away to nothing.
`spell`	Every piece lays itself out into the word in `sign:` — `letters:` tall, `rise:` off the floor — with the head floating over it, holds, and drops.

Props, strings and chains

Parameter	What it does
`follow`	How much the loose joints lag and overshoot: arms left behind by a jump, a head that nods on landing. `1` is a body, `2` is a cartoon.
`hold`, `offhand`, `hat`	An item in a hand or on the head, carried wherever the body goes. `hold_size`, `hat_size` and `hat_y` size and place them.
`strings`	Puppet strings from the hands and the head, up to that height.
`chains`	Shackles both wrists to the floor that far out to each side, dragged along by every move of the arms.
`snip`	The second the strings or chains break.

The rest

Parameter	What it does
`intact`	Seconds the body stands whole before its frames begin.
`life`	Seconds it lasts. Leave it out and the body lives as long as its frames and its finish need.
`detail`	Cells each part is cut into, `1` to `4`. `1` is six boxes and the cheapest a death can be; `2` keeps a sleeve apart from a hand.
`size`, `glow`, `light`, `y`, `face`	As on any display.

The head is the real head, face and all. Everything else is the nearest block to the colour that part of the skin actually is, and every cell is a display — so detail:3 in front of a crowd is what the display ceiling is there for.

The older poses still work — pose:burst, spread, knocked, vortex, balloon, helicopter, plane, flatten, melt, sign and thrown — with their parameters in Displays and NPCs.

Time the rest of the scene to the frames

Frames and [DELAY] lines count the same seconds. In SLAPPED the body stands whole for intact:0.1, and the frame that snaps its head round begins 1.22 seconds into its frames — 1.32 in all. The slap's sound sits behind [DELAY] lines that add up to exactly 1.32. That is the whole difference between a body that flinches and a body that is hit.

`[NPC]` — a whole fake player

None of the shipped effects uses it any more, but it still works: a whole copy of the player, wearing what they wore, moved by teleporting it.

- '[NPC] {victim};pose:lying;life:2.2;equip:true;face:false'

Parameter	What it does
(the head)	`{victim}`, `{killer}`, or a base64 texture. A player name is refused: it would need a lookup an effect cannot wait for.
`pose`	`lying` by default. `pose_to` with `after` collapses into a second pose.
`life`	Seconds it stays. Defaults to `5`.
`equip`	Whether it wears what the victim wore. On by default.
`face`	Whether it turns to face. On by default.
`from`, `to`, `over`, `ease`, `gravity`, `turn`	How it is thrown or how it falls. `over` defaults to `0.7` seconds.
`glow`	An outline colour.
`hurt`	Plays the damage flash.
`y`	Lifts it.
`spin`	Degrees a second it keeps turning, for its whole life — `turn` finishes, `spin` never does.
`bob`, `bob_every`	Blocks it rises and falls on a loop, and how long one rise and fall takes.
`swing`	Seconds between arm swings.
`scale`	How big it is drawn, `1` being player-sized. Needs a 1.20.5 client.
`hold`, `offhand`	A material put in each hand.
`pitch`	Head pitch in degrees, negative being up.

It is a display, not an entity: nothing can hit it, loot it or walk into it.

When a line is wrong

A step that cannot be read is dropped and reported to the console with the line that caused it — an unknown token, a particle that does not exist, a shape that produced no points, a parameter the token does not understand. The rest of the effect still plays, so one typo costs one line rather than the whole catalogue.

Cost is per line, per kill

A display is cheap to animate — the client does it — but every line is still a packet per viewer. The shipped effects sit around twenty to thirty lines, three to five and a half seconds end to end; that is a deliberate ceiling.

Something missing on this page? Tell us on Discord