Trigger reference

This page lists every node in the trigger language. It is generated from the same catalog the validator uses, so it cannot fall out of step with the game. The JSON Schema for whole scripts is at /schemas/v1/trigger-script.json.

Every node is a JSON object with a k naming its kind. Unknown properties are errors. Wherever a field takes an expression, you can write a bare number, string or boolean instead: 5 means {"k":"int","v":5}, 1.5 means {"k":"real","v":1.5}, "hi" means {"k":"str","v":"hi"}. A string is always text; to read a variable, use {"k":"var","name":"score"}. Wherever a field takes text, a bare string is shorthand for a one-part template.

Every example below passes validateTriggerScript when placed into this script (events go in events, expressions in conditions, actions in actions):

{
  "version": 1,
  "vars": [
    {
      "name": "score",
      "type": "int"
    },
    {
      "name": "squad",
      "type": "unitGroup"
    },
    {
      "name": "code",
      "type": "string"
    }
  ],
  "regions": [
    {
      "id": "arena",
      "x": 0,
      "y": 0,
      "w": 8,
      "h": 8
    }
  ],
  "functions": [
    {
      "name": "double",
      "params": [
        {
          "name": "n",
          "type": "int"
        }
      ],
      "returns": "int",
      "actions": [
        {
          "k": "return",
          "value": {
            "k": "mul",
            "a": {
              "k": "var",
              "name": "n"
            },
            "b": {
              "k": "int",
              "v": 2
            }
          }
        }
      ]
    }
  ],
  "hashtables": [
    {
      "name": "scores",
      "valueType": "int"
    }
  ],
  "triggers": [
    {
      "id": "main",
      "events": [
        {
          "k": "mapInit"
        }
      ],
      "actions": []
    }
  ]
}

Events#

What makes a trigger fire. A trigger fires when any one of its events happens.

Map events#

mapInit#

Map initialisation. Fires once on the first tick, after every global initialiser.

Editor: the map starts

No fields.

{"k":"mapInit"}

Time events#

periodic#

Every N ticks. Fires when (tick − offset) is a multiple of everyTicks, from tick offsetTicks on.

Editor: every ‹Interval (ticks)› ticks, phase-shifted by ‹Phase offset›

{"k":"periodic","everyTicks":1}

atTick#

At tick. Fires once on an exact tick.

Editor: at tick ‹Tick›

{"k":"atTick","tick":1}

timerExpires#

Timer expires. Fires when a named timer reaches zero.

Editor: timer ‹Timer› expires

{"k":"timerExpires","timer":"wave_timer"}

Region events#

unitEntersRegion#

Unit enters region. Fires for each unit whose tile moved into the region this tick. Units that start inside do not count.

Editor: a unit enters ‹Region› matching ‹Filter›

{"k":"unitEntersRegion","region":"arena"}

unitLeavesRegion#

Unit leaves region. Fires for each unit that left the region this tick — including by dying or being removed (matched against its last snapshot).

Editor: a unit leaves ‹Region› matching ‹Filter›

{"k":"unitLeavesRegion","region":"arena"}

Unit events#

unitDies#

Unit dies. Fires when a unit or building dies. The filter is matched against the unit as it was at death (aliveOnly is ignored); event unit = the dead unit, other unit = killer.

Editor: a unit dies matching ‹Filter›

{"k":"unitDies"}

unitTrained#

Unit trained. Fires when production completes a unit.

Editor: a unit finishes training matching ‹Filter›

{"k":"unitTrained"}

buildingComplete#

Building completes. Fires when construction finishes.

Editor: a building completes matching ‹Filter›

{"k":"buildingComplete"}

unitAttacked#

Unit attacked. Fires when a unit takes an attack; event value = damage, other unit = attacker.

Editor: a unit is attacked matching ‹Filter›

{"k":"unitAttacked"}

heroLevels#

Hero levels up. Fires when a hero gains a level; event value = new level.

Editor: a hero gains a level matching ‹Filter›

{"k":"heroLevels"}

Item events#

itemPickedUp#

Item picked up. Fires when a hero picks up an item.

Editor: an item is picked up — ‹Item›

{"k":"itemPickedUp"}

Player events#

playerEliminated#

Player eliminated. Fires when a seat is eliminated.

Editor: a player is eliminated — ‹Player›

{"k":"playerEliminated"}

upgradeComplete#

Upgrade completes. Fires when research completes; event text = upgrade id.

Editor: an upgrade completes — ‹Upgrade›

{"k":"upgradeComplete"}

playerChats#

Player chats. Fires when a player sends a chat line; event text = the line.

Editor: player ‹Player› sends chat matching "‹Pattern›" (‹Match mode›)

{"k":"playerChats","pattern":"-reset","matchMode":"prefix"}

playerKeyPress#

Player presses key. Fires when a player presses or releases a key (through lockstep); event text = key, value = 1 down / 0 up.

Editor: player ‹Player› presses ‹Key› (‹Key state›)

{"k":"playerKeyPress","key":"Space","state":"down"}

Variable events#

variableChanges#

Variable changes. Fires (in the cascade phase) when a GLOBAL variable is written with a different value.

Editor: variable ‹Variable› changes

{"k":"variableChanges","name":"score"}

UI events#

dialogButton#

Dialog button clicked. Fires when a player clicks a trigger dialog button (arrives through lockstep); event value = button index.

Editor: a dialog button is clicked on ‹Dialog›, button ‹Button index›

{"k":"dialogButton"}

Combat events#

projectileHits#

Projectile hits. Fires when a projectile strikes its target or a bomb detonates. Event unit = target, other unit = shooter, value = damage.

Editor: a projectile hits matching ‹Tag›

{"k":"projectileHits"}

Custom events#

custom#

Custom event. Fires when raiseEvent raises this name (same tick, capped cascade).

Editor: custom event ‹Event name› is raised

{"k":"custom","name":"boss_down"}

Cutscene events#

cutsceneFinished#

Cutscene finished. Fires when a cutscene ends. Event value: 0 played out, 1 skipped by every human viewer, 2 replaced by another scene, 3 stopped by a trigger.

Editor: cutscene ‹Scene› finishes

{"k":"cutsceneFinished"}

Conditions and expressions#

Values. A trigger condition is any expression; the trigger runs only when all of its conditions are true.

Literal expressions#

int#

Integer — returns int. An integer literal. Non-integers are truncated.

Editor: ‹Value›

{"k":"int","v":1}

real#

Real number — returns real. A real-number literal.

Editor: ‹Value›

{"k":"real","v":1}

bool#

Boolean — returns bool. true or false.

Editor: ‹Value›

{"k":"bool","v":true}

str#

Text — returns string. A string literal.

Editor: "‹Value›"

{"k":"str","v":"text"}

Geometry expressions#

point#

Point — returns point. A tile coordinate built from two numbers.

Editor: (‹Tile X›, ‹Tile Y›)

{"k":"point","x":1,"y":1}

distance#

Distance — returns real. Euclidean tile distance; either side may be a unit or a point.

Editor: distance from ‹From› to ‹To›

{"k":"distance","a":1,"b":1}

pointX#

Point X — returns number. X of a point.

Editor: X of ‹Point›

{"k":"pointX","p":{"k":"regionCenter","region":"arena"}}

pointY#

Point Y — returns number. Y of a point.

Editor: Y of ‹Point›

{"k":"pointY","p":{"k":"regionCenter","region":"arena"}}

regionCenter#

Region centre — returns point. Integer centre tile of a region.

Editor: centre of ‹Region›

{"k":"regionCenter","region":"arena"}

randomPointInRegion#

Random point in region — returns point. Random tile inside the region (always two PRNG draws).

Editor: a random point in ‹Region›

{"k":"randomPointInRegion","region":"arena"}

pointInRegion#

Point in region — returns bool. True when the point (or unit) lies inside the region.

Editor: ‹Point› is inside ‹Region›

{"k":"pointInRegion","p":{"k":"regionCenter","region":"arena"},"region":"arena"}

offsetPoint#

Offset point — returns point. A point moved by (dx, dy) tiles.

Editor: ‹Point› offset by (‹Tiles X›, ‹Tiles Y›)

{"k":"offsetPoint","p":{"k":"regionCenter","region":"arena"},"dx":1,"dy":1}

Unit expressions#

nullUnit#

No unit — returns unit. Entity id 0. Every property of it reads as a zero value.

Editor: no unit

No fields.

{"k":"nullUnit"}

unitProp#

Unit property — returns any. Read a property of a unit. A unit that died THIS tick answers from its death snapshot; otherwise a missing unit gives the zero value.

Editor: ‹Property› of ‹Unit›

{"k":"unitProp","unit":{"k":"eventUnit"},"prop":"hp"}

unitPoint#

Unit position — returns point. Tile position of a unit.

Editor: position of ‹Unit›

{"k":"unitPoint","unit":{"k":"eventUnit"}}

entityByAid#

Unit by authored id — returns unit. The placed entity carrying this authored id, or no unit.

Editor: the unit with authored id ‹Authored id›

{"k":"entityByAid","aid":"north_gate"}

Variable expressions#

var#

Variable — returns any. Read a variable: a trigger/function local, a function parameter, a loop variable or a global (resolved in that order).

Editor: ‹Variable›[‹Index›]

{"k":"var","name":"score"}

Arithmetic expressions#

add#

A + B — returns number. Sum. If either side is a string the two are concatenated.

Editor: ‹A› + ‹B›

{"k":"add","a":1,"b":1}

sub#

A − B — returns number. Difference.

Editor: ‹A› − ‹B›

{"k":"sub","a":1,"b":1}

mul#

A × B — returns number. Product.

Editor: ‹A› × ‹B›

{"k":"mul","a":1,"b":1}

div#

A ÷ B — returns number. Quotient. Division by zero yields 0 — never Infinity or NaN.

Editor: ‹A› ÷ ‹B›

{"k":"div","a":1,"b":1}

mod#

A mod B — returns number. Remainder (sign of A). Modulo by zero yields 0.

Editor: ‹A› mod ‹B›

{"k":"mod","a":1,"b":1}

neg#

Negate — returns number. Arithmetic negation.

Editor: −‹A›

{"k":"neg","a":1}

abs#

Absolute value — returns number. Absolute value.

Editor: |‹A›|

{"k":"abs","a":1}

min#

Minimum — returns number. The smaller of A and B.

Editor: min(‹A›, ‹B›)

{"k":"min","a":1,"b":1}

max#

Maximum — returns number. The larger of A and B.

Editor: max(‹A›, ‹B›)

{"k":"max","a":1,"b":1}

clamp#

Clamp — returns number. A limited to [lo, hi]; reversed bounds are swapped.

Editor: clamp(‹A›, ‹Minimum›, ‹Maximum›)

{"k":"clamp","a":{"k":"var","name":"score"},"lo":0,"hi":100}

trunc#

Truncate — returns int. Real to integer toward zero (Math.trunc) — the one real→int rule in the language.

Editor: trunc(‹A›)

{"k":"trunc","a":1.5}

Comparison expressions#

eq#

A = B — returns bool. Equality. Strings compare by code unit; groups element-wise; points by x then y.

Editor: ‹A› = ‹B›

{"k":"eq","a":1,"b":1}

ne#

A ≠ B — returns bool. Inequality.

Editor: ‹A› ≠ ‹B›

{"k":"ne","a":1,"b":1}

lt#

A < B — returns bool. Less than.

Editor: ‹A› < ‹B›

{"k":"lt","a":1,"b":1}

le#

A ≤ B — returns bool. Less than or equal.

Editor: ‹A› ≤ ‹B›

{"k":"le","a":1,"b":1}

gt#

A > B — returns bool. Greater than.

Editor: ‹A› > ‹B›

{"k":"gt","a":1,"b":1}

ge#

A ≥ B — returns bool. Greater than or equal.

Editor: ‹A› ≥ ‹B›

{"k":"ge","a":1,"b":1}

Logic expressions#

and#

A and B — returns bool. Logical AND. Short-circuits: B is not evaluated when A is false.

Editor: ‹A› and ‹B›

{"k":"and","a":true,"b":true}

or#

A or B — returns bool. Logical OR. Short-circuits: B is not evaluated when A is true.

Editor: ‹A› or ‹B›

{"k":"or","a":true,"b":true}

not#

Not A — returns bool. Logical negation.

Editor: not ‹A›

{"k":"not","a":true}

Time expressions#

tick#

Game tick — returns int. The current simulation tick (20 per second) — the only clock in the language.

Editor: the game tick

No fields.

{"k":"tick"}

rand#

Random integer — returns int. Inclusive random integer from the synchronised game PRNG. Always consumes exactly one draw.

Editor: random ‹Minimum› to ‹Maximum›

{"k":"rand","min":1,"max":6}

timerRemaining#

Timer ticks left — returns int. Ticks until the timer expires (0 if not running).

Editor: ticks left on ‹Timer›

{"k":"timerRemaining","timer":"wave_timer"}

timerRunning#

Timer is running — returns bool. True while the timer runs and is not paused.

Editor: ‹Timer› is running

{"k":"timerRunning","timer":"wave_timer"}

Player expressions#

playerResource#

Player's resource — returns int. Current stock of one resource.

Editor: ‹Player›'s ‹Resource›

{"k":"playerResource","player":0,"resource":"gold"}

playerPop#

Player's population — returns int. Population in use.

Editor: ‹Player›'s population

{"k":"playerPop","player":0}

playerMaxPop#

Player's population cap — returns int. Population cap.

Editor: ‹Player›'s population cap

{"k":"playerMaxPop","player":0}

playerAlive#

Player is alive — returns bool. True while the seat has not been eliminated or defeated.

Editor: ‹Player› is still alive

{"k":"playerAlive","player":0}

playerTeam#

Player's team — returns int. Team id of the seat, or -1.

Editor: ‹Player›'s team

{"k":"playerTeam","player":0}

playerHasUpgrade#

Player has upgrade — returns bool. True once the seat has completed the research.

Editor: ‹Player› has researched ‹Upgrade›

{"k":"playerHasUpgrade","player":0,"upgradeId":"dwarf_forged_weapons_1"}

isAllied#

Players are allied — returns bool. True when seats A and B are on the same team.

Editor: ‹A› is allied with ‹B›

{"k":"isAllied","a":0,"b":0}

isEnemy#

Players are enemies — returns bool. True when seats A and B are not allied.

Editor: ‹A› is an enemy of ‹B›

{"k":"isEnemy","a":0,"b":0}

Group expressions#

unitsInRegion#

Units in region — returns unitGroup. Sorted group of units whose tile is inside the region.

Editor: units in ‹Region› matching ‹Filter›

{"k":"unitsInRegion","region":"arena"}

unitsWithTag#

Units with tag — returns unitGroup. Sorted group of placed entities sharing an authored tag.

Editor: units tagged ‹Tag› matching ‹Filter›

{"k":"unitsWithTag","tag":"wave"}

unitsOfPlayer#

Units of player — returns unitGroup. Sorted group of units owned by the seat.

Editor: units owned by ‹Player› matching ‹Filter›

{"k":"unitsOfPlayer","player":0}

unitsOfType#

Units of type — returns unitGroup. Sorted group of units or buildings of one type id.

Editor: units of type ‹Unit type› matching ‹Filter›

{"k":"unitsOfType","unitTypeId":"dwarf_ironguard"}

groupCount#

Group size — returns int. Number of units in a group.

Editor: number of units in ‹Unit group›

{"k":"groupCount","group":{"k":"unitsInRegion","region":"arena"}}

groupAt#

Unit at index — returns unit. 0-based element of the sorted group; out of range gives no unit.

Editor: unit ‹Index› of ‹Unit group›

{"k":"groupAt","group":{"k":"unitsInRegion","region":"arena"},"index":1}

groupRandom#

Random unit of group — returns unit. A random member (one PRNG draw, even for an empty group).

Editor: a random unit in ‹Unit group›

{"k":"groupRandom","group":{"k":"unitsInRegion","region":"arena"}}

groupUnion#

Group union — returns unitGroup. Members of A or B.

Editor: ‹A› together with ‹B›

{"k":"groupUnion","a":{"k":"unitsInRegion","region":"arena"},"b":{"k":"unitsInRegion","region":"arena"}}

groupDiff#

Group difference — returns unitGroup. Members of A not in B.

Editor: ‹A› except ‹B›

{"k":"groupDiff","a":{"k":"unitsInRegion","region":"arena"},"b":{"k":"unitsInRegion","region":"arena"}}

groupHas#

Group contains — returns bool. True when the unit is in the group.

Editor: ‹Unit group› contains ‹Unit›

{"k":"groupHas","group":{"k":"unitsInRegion","region":"arena"},"unit":{"k":"eventUnit"}}

groupEmpty#

Empty group — returns unitGroup. A group with no units.

Editor: an empty group

No fields.

{"k":"groupEmpty"}

Event expressions#

eventUnit#

Triggering unit — returns unit. The unit the event is about (entered, died, trained, was attacked…). No unit when the event has none.

Editor: the triggering unit

No fields.

{"k":"eventUnit"}

eventOtherUnit#

Other unit — returns unit. The killer for unitDies, the attacker for unitAttacked, the shooter for projectileHits.

Editor: the other unit

No fields.

{"k":"eventOtherUnit"}

eventPlayer#

Triggering player — returns player. The seat the event is about, or -1.

Editor: the triggering player

No fields.

{"k":"eventPlayer"}

eventValue#

Event value — returns number. Numeric payload: dialog button index, hero level, damage, raised value.

Editor: the event value

No fields.

{"k":"eventValue"}

eventString#

Event text — returns string. String payload: upgrade id, item id, chat text, custom event name.

Editor: the event text

No fields.

{"k":"eventString"}

UI expressions#

counter#

Counter value — returns number. Current value of an on-screen counter.

Editor: counter ‹Counter›

{"k":"counter","id":"lives"}

Trigger expressions#

triggerFireCount#

Trigger fire count — returns int. How many times a trigger has fired.

Editor: times ‹Trigger› has fired

{"k":"triggerFireCount","triggerId":"main"}

Text expressions#

concat#

Concatenate — returns string. A joined with B as strings.

Editor: ‹A› joined with ‹B›

{"k":"concat","a":"text","b":"text"}

toStr#

To text — returns string. Value as text. Non-integers print with decimals places (default 2).

Editor: ‹Value› as text to ‹Decimal places› dp

{"k":"toStr","a":1}

subStr#

Substring — returns string. 0-based slice; out-of-range start gives empty text.

Editor: substring of ‹String› from ‹Start index› length ‹Length›

{"k":"subStr","text":"Hello world","start":0,"length":5}

strLen#

Text length — returns int. Length in UTF-16 code units.

Editor: length of ‹String›

{"k":"strLen","text":"text"}

hashString#

Hash text — returns int. Deterministic 32-bit FNV-1a hash.

Editor: hash of ‹String›

{"k":"hashString","text":"text"}

Physics expressions#

unitVelocity#

Unit velocity — returns real. Kinematic velocity component or speed (tiles/tick); 0 without kinematics.

Editor: ‹Axis› velocity of ‹Unit›

{"k":"unitVelocity","unit":{"k":"eventUnit"},"axis":"x"}

Save codes expressions#

verifySaveCode#

Read save code — returns any. Validate a save code for this map. With field, returns that field (or 0); without, returns 1 for a valid code and 0 otherwise.

Editor: save code ‹Code› field ‹Field› (valid?)

{"k":"verifySaveCode","code":{"k":"var","name":"code"}}

Function expressions#

call#

Call function — returns any. Call a user-defined function that declares a return type and yield its return value. Arguments are evaluated left to right and coerced to the parameter types. Recursion past the depth cap yields the zero value.

Editor: ‹Function›(‹Arguments›)

{"k":"call","fn":"double","args":[2]}

Hashtable expressions#

hashtableGet#

Hashtable value — returns any. Value stored under (key1, key2), or the zero value of the table type. Keys are integers or strings.

Editor: ‹Hashtable›[‹Parent key›][‹Child key›]

{"k":"hashtableGet","table":"scores","key1":1,"key2":1}

hashtableHas#

Hashtable has key — returns bool. True when a value is stored under (key1, key2).

Editor: ‹Hashtable› has [‹Parent key›][‹Child key›]

{"k":"hashtableHas","table":"scores","key1":1,"key2":1}

hashtableCount#

Hashtable size — returns int. Number of entries in the table, or under one parent key when key1 is set.

Editor: number of entries in ‹Hashtable› under ‹Parent key›

{"k":"hashtableCount","table":"scores"}

Actions#

What a trigger does, run top to bottom.

Control flow actions#

if#

If / then / else. Run then when cond is true, else else.

Editor: if ‹Condition›

{"k":"if","cond":true,"then":[]}

while#

While. Repeat the body while cond holds, at most maxIterations (hard cap 10000) times per run.

Editor: while ‹Condition›

{"k":"while","cond":true,"body":[]}

forEachUnit#

For each unit. Run the body once per unit of a group (snapshotted and sorted before the first iteration).

Editor: for each unit ‹Loop variable› in ‹Unit group›

{"k":"forEachUnit","group":{"k":"unitsInRegion","region":"arena"},"varName":"u","body":[]}

forEachInt#

For each integer. Run the body for each integer from..to inclusive (at most 10000).

Editor: for ‹Loop variable› from ‹From› to ‹To›

{"k":"forEachInt","varName":"i","from":1,"to":1,"body":[]}

wait#

Wait. Suspend this trigger for N ticks (min 1) and resume at the next action. Locals and loop state survive, including across save/load. Not allowed inside functions.

Editor: wait ‹Ticks› ticks

{"k":"wait","ticks":1}

raiseEvent#

Raise custom event. Fire the custom event of this name later in the same tick.

Editor: raise custom event ‹Event name› with value ‹Value› and text ‹Text›

{"k":"raiseEvent","name":"boss_down"}

comment#

Comment. Does nothing; documents the script.

Editor: // ‹Comment›

{"k":"comment","text":"text"}

Variable actions#

setVar#

Set variable. Write a variable (local, parameter, loop or global). Writing a global with a new value raises variableChanges.

Editor: set ‹Variable›[‹Index›] to ‹Value›

{"k":"setVar","name":"score","value":1}

addVar#

Add to variable. Add a number to a numeric variable.

Editor: add ‹Amount› to ‹Variable›[‹Index›]

{"k":"addVar","name":"score","delta":1}

Trigger actions#

enableTrigger#

Enable/disable trigger. Turn a trigger on or off.

Editor: set trigger ‹Trigger› enabled to ‹Enabled›

{"k":"enableTrigger","triggerId":"main","on":true}

runTrigger#

Run trigger. Run another trigger's actions inline in this event context.

Editor: run trigger ‹Trigger› (checking its conditions: ‹Check conditions›)

{"k":"runTrigger","triggerId":"main"}

stopTrigger#

Stop trigger. Abandon the rest of this trigger. Not allowed inside functions (use return).

Editor: stop running this trigger

No fields.

{"k":"stopTrigger"}

Function actions#

callFunction#

Call function. Call a user-defined function as a statement, optionally storing its return value.

Editor: call ‹Function›(‹Arguments›) and store the result in ‹Store result in›[‹Index›]

{"k":"callFunction","fn":"double","args":[2]}

return#

Return. Leave the current function, yielding value. At trigger level (no value allowed) it stops the trigger.

Editor: return ‹Value›

{"k":"return"}

Hashtable actions#

hashtableSet#

Hashtable set. Store a value under (key1, key2). New keys past the table cap are dropped.

Editor: set ‹Hashtable›[‹Parent key›][‹Child key›] to ‹Value›

{"k":"hashtableSet","table":"scores","key1":1,"key2":1,"value":1}

hashtableRemove#

Hashtable remove. Remove the value under (key1, key2).

Editor: remove ‹Hashtable›[‹Parent key›][‹Child key›]

{"k":"hashtableRemove","table":"scores","key1":1,"key2":1}

hashtableClear#

Hashtable clear. Remove every entry, or only those under key1.

Editor: clear ‹Hashtable› under ‹Parent key›

{"k":"hashtableClear","table":"scores"}

Units actions#

createUnits#

Create units. Spawn N units (max 500) for a player at a point.

Editor: create ‹Count› × ‹Unit type› for ‹Player› at ‹At point› facing ‹Facing (degrees)›° and store them in ‹Store in›

{"k":"createUnits","unitTypeId":"dwarf_ironguard","count":1,"player":0,"at":{"k":"regionCenter","region":"arena"}}

removeUnit#

Remove unit. Remove a unit outright — no death, corpse or bounty.

Editor: remove ‹Unit› from the game

{"k":"removeUnit","unit":{"k":"eventUnit"}}

killUnit#

Kill unit. Kill a unit through the normal death path.

Editor: kill ‹Unit›

{"k":"killUnit","unit":{"k":"eventUnit"}}

setUnitHp#

Set unit HP. Set HP (clamped to 0..max).

Editor: set HP of ‹Unit› to ‹Value› (as a percentage: ‹Value is a percentage›)

{"k":"setUnitHp","unit":{"k":"eventUnit"},"value":1}

setUnitMana#

Set unit mana. Set mana (clamped).

Editor: set mana of ‹Unit› to ‹Value›

{"k":"setUnitMana","unit":{"k":"eventUnit"},"value":1}

setUnitOwner#

Change owner. Give a unit to another seat.

Editor: give ‹Unit› to ‹Player›