-
Notifications
You must be signed in to change notification settings - Fork 6
ActionLists.wiki
This documentation is a part of the TCI reference.
Is there an error? Something missing? Funky grammar? Do not hesitate to leave a comment.
Actions lists are priorities lists: periodically, Simulationcraft scans your character's actions list, starting with the first action (the highest priority ) and continuing until an available action is found, or to the end otherwise. Actions that are not possible at the moment (cooldown not ready, execute phase only, conditions not met) are just considered as not available and the applications jumps to the next one.
Here is a simplified warrior actions list:
# If the character has no flask already, use a titanic strength one
actions=flask,type=titanic_strength
# Otherwise, if still out of combat, or if bloolust/heroism has just been started, uses a golem blood potion.
actions+=/golemblood_potion,if=!in_combat|buff.bloodlust.react
# Otherwise, starts autoattack if not done already.
actions+=/auto_attack
# Otherwise, pops up the "death wish" 2min cooldown if ready.
actions+=/death_wish
# Otherwise, uses heroic strike if ready and [rage greater than 60, or the battle trance proc is up, or the incite proc is up] and target health is above 20%.
actions+=/heroic_strike,if=target.adds=0&(rage>60|buff.battle_trance.up|buff.incite.up)&target.health_pct>=20
# Otherwise, use colossus smash if ready.
actions+=/colossus_smash
# Otherwise, use execute (only available when target health is below 20% health but it is always implicit)
actions+=/execute
# Otherwise, use raging blow, but only if target is above 20% health
actions+=/raging_blow,if=target.health_pct>=20
# Otherwise, use bloodthirst
actions+=/bloodthirst
A couple of advices for writing actions lists:
- Do not forget, it is priority-based, it's as simple as that!
- Do not try to optimize your actions lists for computations performances. Just focus on correctly modeling the gameplay you want.
- Have doubts ? Make Simulationcraft writes a combat log for you, with the log option, see Output.
- actions (scope: current character; default: depends on class and spec) is the list of actions your character will follow. It is a multi-line string and a sequence of commands using the "/" separator, see scripting basics> long strings and scripting basics> sequences.
# Note how we use the "/" separator and the "+=" appending operator.
actions=dosomething
actions+=/dosomethingelse
-
auto_attack triggers the auto-attack when it's not already activated. It cannot be used to stopping or resetting auto attacks. Options are:
- sync_weapons (optional, default: 0), when different from zero, will synchronize weapons swings for ambidextrous classes with two weapons with the same swing speed. When zero, the offhand will be delayed by half of its swing time. In game, you always start with your weapons synchronized but target switching and parry rushes often lead you to go unsynchronized. Some mechanics are pretty sensible to weapons being synchronized or note, such as flurry or munched deep wounds ticks for warriors.
# Ensure the player will always auto attack and will start with synched weapons.
actions+=/auto_attack,sync_weapons=1
- snapshot_stats forces simulation craft to capture your buffed stats values just before the combat actually begins. It has no influence on the simulation itself si it's totally optional. However you need to include it if you want the reports and output to display the correct (non-zero) values for raid-buffed stats. It should be located after all other out-of-combat actions (food, flasks, etc).
# Ensure the reports will display correct values for "raid-buffed" stats.
actions+=/snapshot_stats
-
cancel_buff cancels a buff, just like "/cancelaura" would do in game.
- name is the name of the buff to cancel.
# Cancels out inner rage if deadly calm is down (used between patches 4.0.3 and 4.0.6 for arms warriors).
actions+=/cancel_buff,name=inner_rage,if=!buff.deadly_calm.up
-
use_item trigers the use of an item.
- name is the item's name
# Uses the "shard of woe" trinket
/use_item,name=shard_of_woe,if=cooldown.evocation.remains>86
-
restore_mana forcefully and instantly restores mana.
- mana (default: 0) is the amount of mana to restore. When left to zero, mana will be restored to its maximum. The purpose of this actions is to let you test out infinite mana scenarios or fights with special mana regeneration mechanics. Since this action has no cooldown, it can be performed many times every second.
# This will restore 500 mana anytime it is trigger.
actions+=/restore_mana,mana=500
See the relevant page for each class for more information on non-trivial spells.
Spells are added on a per-class basis. Those keywords are the spells' names, where white spaces are replaced with underscores (_) and non-alphanumeric characters are ignored. The list would obviously be too long to write and boring to maintain but you can check your class' source code file (sc_mage.cpp for mages for example) for the "create_action" function.
# This will make a feral druid cast Toger's fury.
actions+=/tigers_fury
- arcane_torrent triggers arcane torrent (blood elf racial)
actions+=/arcane_torrent
- berserking triggers berserking (troll tracial)
actions+=/berserking
- blood_fury triggers blood fury (orc racial)
actions+=/blood_fury
- stoneform triggers stoneform (dwarf racial)
actions+=/stoneform
Pets' actions can be used through a specific syntax:
<petname>:<petaction>. Relevant options are the ones for the specified pet action.
actions+=/spider:wolverine_bite
However most pets actions actually have shortcut keywords you will probably prefer:
actions+=/wolverine_bite
Note that pets come with their own default actions lists! You can modify them as you do with any regular character.
-
food can trigger the use of a food.
- type is the name of the food to use.
actions+=/food,type=beer_basted_crocolisk
-
flask can trigger the use of a flask.
- type is the name of the flask to use.
actions+=/flask,type=titanic_strength
-
health_stone can trigger the use of a health stone.
- health or trigger is the absolute hp deficit you must suffer to allow the use of the stone.
# If a character has his health 60k below his maximum, he will use the stone
actions+=/health_stone,trigger=60000
- destruction_potion, golemblood_potion, speed_potion, etc. You can use those keywords to trigger the use of some potions. They have no options.
# Triggers the potion use when out of combat or when bloodlust has just started.
actions+=/destruction_potion,if=!in_combat|buff.bloodlust.react
- start_moving triggers a movement phase, it will end only with stop_moving.
- stop_moving ends the movement phase.
# Here are fragments of the shadowpriest rotation. When the target health is below 25%, sw:d deals three times more damages and has a chance to make apparitions spawn. This chance is increased while the sp moves.
# Do not move when sw:d is on cooldown
actions+=/stop_moving,health_percentage<=25,if=cooldown.shadow_word_death.remains>=0.2
# Start moving when the sw:d cooldown is going to end (we need to stand still to fire it)
actions+=/start_moving,health_percentage<=25,if=cooldown.shadow_word_death.remains<=0.1
Actions sequences are sub-actions chains to execute in a given order. Use the following keyword:
-
sequence declares and triggers a sequence of actions to use in the specified order. Actions are separated with ":".
- name (optional, default: "default") is used to name the sequence.
Once one of the sub-actions has been performed, Simulationcraft does not immediately perform the next sub-action in the chain. Instead, it restarts at the beginning of the whole actions list (not the sequence). If the sequence is executed again, then it will trigger the actions which have not been performed yet.
# So, some class has three spells: yellow, blue and red. They all share the global cooldown.
actions+=/yellow
actions+=/sequence:red:blue
# On the first gcd, yellow is not ready, red and blue are: the application will execute "red"
# On the second gcd, all spells are ready: the application will execute "yellow"
# On the third gcd, yellow is not ready, red and blue are: the application will execute "blue"
# From now on, the application will only perform "yellow".
When all spells have been performed, the sequence is not automatically reinitialized and it will be skipped from now on! You need to use the following keyword:
-
restart_sequence will restart the specified sequence.
- name is the name of the sequence to restart.
# Here are fragments of the 4.0.6 mage rotation
actions+=/sequence,name=attack:fire_melee:fire_nova:fire_blast
actions+=/restart_sequence,name=attack,moving=0
Finally, you can use wait_on_ready (default: -1) on a sequence or one of its sub-actions. When equal to 1, it will force the the application to restart at the beginning of the actions list processing if this spell is not ready. Practically, actions below this one will never be executed. However, things are slightly different for sequences:
- If the sequence itself is flagged as wait_on_ready, all spells with wait_on_ready=-1 will be flagged with the value you specified whenever the sequence is restarted.
- The sequence will be considered as flagged whenever the next remaining spell is flagged with wait_on_ready=1.
# Here is a sample of an old death knight sequence. Spells have been replaced with their abbreviations to make things easier.
actions+=/sequence,wait_on_ready=1:PS:IT:BS:BS:SS
actions+=/DC
actions+=/restart_sequence,name=default
# At first, because of wait_on_ready, the application will flag all spells with wait_on_ready=1. It means the application will have to wait on every step and until the sequence has been completed. It will never reach the "DC" line even if one of the spells is not ready yet.
# So, the application will perform PS-IT-BS-BS-SS. Then, as long as it can do DC, it will. Once there is not enough runic power left for DC, the sequence will be restarted.
Do you have headaches already ? Yes, sequences are tricky, they are rarely used. If you do use them, do it with caution.
-
cycle can be used to create cycling sequences. Notes:
- Contrary to sequences, you do not specify a list of actions to cycle. Instead, all actions located below the cycle declaration in the actions list will be part of the cycle.
- Just as with sequences, once a sub-action has been performed, the application will restart at the beginning of the whole actions list. The next time it reaches the "cycle" action, it will try to execute the next sub-action in the cycle.
- If, at some point, the next sub-action in the cycle is not ready, then the application will not skip it: instead, it will let the times goes by and restart at the beginning of the whole actions list. The sub-action will be executed the next time it is ready and the applications reaches the cycle declaration.
- Once the last sub-action in a cycle has been performed, the cycle is reinitialized and the application will restart with the first sub-action the next time.
# So, some class has three spells: yellow, blue and red. They all share the global cooldown.
actions+=/yellow
actions+=/cycle
actions+=/red
actions+=/blue
# On the first gcd, yellow is not ready, red and blue are: the application will execute "red"
# On the second gcd, all spells are ready: the application will execute "yellow"
# On the third gcd, yellow is not ready, red and blue are: the application will execute "blue"
# On the fourth gcd, yellow is not ready, red and blue are: the application will execute "red"
-
wait orders the application to stop processing the actions list for a given time. Auto-attacks and such will still be performed.
- sec (default: 1) is the number of seconds to wait. It can be a constant or an expression (see the conditional expressions section).
# This orders Simulationcraft to stop processing the actions list for 5s
actions+=/wait,sec=5
# This orders Simulationcraft to stop processing the actions list until only 2s remains before somebuff expires (if 5s remaining, wait 3s).
actions+=/wait,sec=buff.somebuff.remains-2
-
wait_until_ready orders the player to stop processing the actions list until some cooldown or dot expires. Its only purpose is to improve performances but beware: conditions such as a buff expiration, reaction to heroism/bloodlust, etc, won't be checked.
- sec (default: 1) is the maximum time, in seconds, the player will wait. One second is enough, it reduces the actions list processing cost by an order of magnitude. And since some conditions won't automatically wake up the application, it is advised to keep it low. Just as for wait, this option can be an expression as well as a simple number.
actions+=/wait_until_ready,sec=0.5
All actions have additional options, we're listing them here.
- target (default: "") is the action's target. When empty, it will be the default target (the player himself for healers, the main target for damage dealers and tanks).
actions+=/power_infusion,target=John
- rank (default: -1), when different from -1, allows you to specify the rank to use for a spell. When left to -1, the maximum rank will be used. Since spell ranks have been removed with Cataclysm, this option should not be of use anymore but who knows...
# Dedicated to downranking lovers...
actions+=/life_tap,rank=1
- invulnerable (default: 0), when different from zero, will flag the action as usable only when the target is invulnerable (happens only when you specified an invulnerability raid event). When left to zero, the action will be usable anytime.
# Using this at the top of the actions list will force the player to wait (through 0.5s steps) and do nothing while the target is invulnerable.
actions+=/wait,sec=0.5,invulnerable=1
- vulnerable (default: 0), when different from zero, will flag the action as usable only when the target is vulnerable (suffers twice more damages, it happens only when you specified a vulnerability raid event). When left to zero, the action will be usable anytime.
# Let's use recklessness only when the target is vulnerable.
actions+=/recklessness,vulnerable=1
- moving (default: -1), when different from -1, will flag the action as usable only when the players are moving (moving=1) or not moving (moving=0). When left to -1, the action will be usable anytime. The players happen to move either because of a "movement" raid event, or because of "start_moving" actions. Note that actions which are not usable while moving do not need to be flagged with "move=0", Simulationcraft is already aware of those restrictions.
# Let's use typhoon only when the player is moving.
actions+=/typhoon,moving=1
- sync (default: "") can be used to flag an action as unusable while another specified action is not ready. The given value must be the name of the synchronized action.
# Warriors tend to pop their cooldowns at the same time. Recklessness has a 4 mins cooldown, death wish has a 2.4 mins cooldown. Let's force recklessness to wait for dw to be ready.
actions+=/recklessness,sync=death_wish
- interrupt can be used on channeled spells, when set to a non-zero value, to interrupt the channeling as soon any other action with a higher priority is ready. The interrupt will only occur after the first tick.
# Stop channeling mind flay when any other action with a higher priority is made available.
actions+=/mind_flay,interrupt=1
- interrupt_if can be used on channeled spells to interrupt the channeling as soon as the specified conditions are met. The conditions are provided using the syntax for conditional expressions.
# Stop channeling when there is less than 1s remaining on the mind blast cooldown.
actions+=/mind_flay,interrupt_if=cooldown.mind_blast.remains<1
- travel_speed (default: ingame flight speed) is the flight speed, in yards per second, of the spell (a fireball for example).
# Let's make our fireballs instant.
actions+=/fireball,travel_speed=0
- wait_on_ready (default: -1), when equal to 1, will force the the application to restart at the beginning of the actions list processing if this spell is not ready. Practically, actions below this one will never be executed. You can use it to quickly make the end of the list inactive but the main purpose of this option is for sequences, see the related section.
# Let's put wait_on_ready=1 on this line near the end of the balance druid's actions list.
actions+=/wrath,wait_on_ready=1,if=eclipse_dir=-1
# Those last lines will never be executed.
actions+=/starfire
actions+=/wild_mushroom,moving=1,if=buff.wild_mushroom.stack<3
actions+=/moonfire,moving=1
actions+=/sunfire,moving=1
Conditional expressions are added through the "if" keyword, using the following syntax:
# Uses faerie fire if:
# * There are less than three stacks
# * And neither "expose armor" nor "sunder armor" are on the target
actions+=/faerie_fire,if=debuff.faerie_fire.stack<3&!(debuff.sunder_armor.up|debuff.expose_armor.up)
Note: the same syntax is used for the interrupt_if action modifier and the the sec modifier for wait_fixed actions.
Most known operators are the arithmetic ones, so we're going to use them to introduce you to some operators properties. Here are the arithmetic operators accepted by Simulationcraft:
-
*is the multiplication operator: it returns the product of the left and right member. -
/is the division operator: it returns the division of the left by the right member. -
-is the either the binary subtraction operator (returns the difference between the left and right members) or the unary negation operator ("-7" returns the opposite of the right member, 7). -
+is either the binary addition operator (returns the sum of the left and right members) or the unary "plus", which has no effect (+7 transforms 7 into 7).
About the vocabulary we used: binary operators are applied to a left and a right member while unary operators are applied to their right member only.
Now, let's imagine that you read the "7 + 4 * 5" calculus. You know it has to be read as "7 + (4 * 5)". Why ? Because the multiplication and division have a higher priority and take precedence over the addition and subtraction operator. In the same way, you know that "5 * -7" has to be read as "5 * (-7)" because unary operators have a higher priority than binary operators.
Finally, what about "500 / 5 * 10" ? Multiplication and division operators both have the same priority so there are two ways to read it: "500 / (5 * 10)" or "(500 / 5) * 10". We need to set up a conventional reading order : for Simulationcraft, it will be from left to right: when two operators have the same priority, the leftmost one is given a higher priority. We have to understand our calculus as "(500 / 5) * 10".
The first example displayed the use of logical operators. Logical operators are:
-
&is the binary AND operator: returns true when both left and right members are true. -
|is the binary OR operator: returns true when at least one of the left and right members are true. -
!is the unary NOT operator: returns true when the right member is false.
# The following condition:
actions+=/faerie_fire,if=debuff.faerie_fire.stack<3&!(debuff.sunder_armor.up|debuff.expose_armor.up)
# That means (remember that unary operators take precedence over binary ones):
debuff.faerie_fire.stack <3 AND (NOT(debuff.sunder_armor.up OR debuff.expose_armor.up))
# (debuff.sunder_armor.up OR debuff.expose_armor.up) is true when sunder_armor or expose_armor are up on the target.
# (NOT(debuff.sunder_armor.up OR debuff.expose_armor.up)) is true if none of the two debuffs are up, false if at least one is up.
# As a result, the condition is true when there are less than three stacks of faerie fire and neither sunder_armor nor expose_armor are up.
One important note: false is zero. True is anything different from zero. Which means that you can test regular numbers as if they were boolean.
# Both syntaxes are valid and do the same thing:
actions=/stance,choose=berserker,if=!in_combat
actions=/stance,choose=berserker,if=in_combat=0
Besides the logical operators, let's mention some specific operators we didn't mention so far:
-
=is the equality comparison operator. -
!=is the inequality comparison operator. -
@is the absolute unary operator: it returns the absolute value of its right member.
We also didn't mention the comparison operators: "=" is the equality comparison operator, "<=" is "lesser than or equal", etc... Unequality is achieved through the concatenation of the NOT operator with the equality operator: "!=".
Finally, here is the full operators priorities list, from the highest ones to the lowest ones:
- Unary operators (
+ , - , @ , !) - Multiplication and division (
* , /) - Addition and subtraction (
+ , -) - Comparison operators (
= , != , < , <= , >= , >) - Binary logical operators (
& , |)
General properties require no specific syntax. The available properties are:
- time is the elapsed time, in seconds, since the beginning of the fight
# Use bloodlust after at least 20s minimum
actions+=/bloodlust,if=time>20
Character properties require no specific syntax. The available properties are:
- level is the player level.
# Shadow fiend is only acquired on lv66 so if we want to test low-level toons...
actions+=/shadowfiend,if=level>=66
- in_combat is zero when not in combat, 1 otherwise.
# Set stance before we enter combat
actions=/stance,choose=berserker,if=!in_combat
- ptr is zero when using the mechanics from the live server, 1 when using the modifications on ptr.
# Starfall is going to be nerfed in the next patch? Then we won't use it anymore.
actions+=/starfall,if=ptr=0
- multiplier is the player's damages/healing multiplier. A buff that would increase your damages by 20% would give you a 1.2 multiplier. All damages multipliers are multiplicative (5% and 20% give 1.2*1.05).
# Consumes a potion as soon as we have enough stacked buffs to reach a minimum 30% multiplier.
actions+=/golemblood_potion,if=multiplier>1.3
- spell_haste and attack_haste are the player's attack and spell factors (30% haste gives a 1.3 factor).
# Only cast some_slow_spell if spell haste is higher than 30%.
actions+=/some_slow_spell,if=spell_haste>1.3
-
ammo, energy, focus, force, heat, rage and health are the corresponding resources.
-
<resource>is the currently available amount of the named resource.
-
# Use Chain Lightning if we have a large enough force pool
actions+=/chain_lightning,if=force>100
* _`<resource>.max`_ is the named resource's maximum amount.
* _`<resource>.pct`_ is the fraction (between 0 and 1) of the maximum amount that is currently available.
# Use Chain Lightning if we have a large enough force pool
actions+=/chain_lightning,if=force.pct>target.health.pct
* _`<resource>.deficit`_ is the difference between maximum and current value.
* _`<resource>.regen`_ is the named resource's current regeneration rate in units per second.
* _`<resource>.time_to_max`_ is how long the resource would take to fill to max at the current regen rate, assuming no expenditures.
# Those two statements are equivalent.
actions+=/berserk,if=time_to_max_energy>=2.0
actions+=/berserk,if=(max_energy-energy)/energy_regen>=2.0
Action properties are related to the action you want to perform. They require no specific syntax. The available properties are:
# If sw:p has not been used so far or its last occurrence missed, then recast it, provided it's not active or close to expiration.
actions+=/shadow_word_pain,if=(!ticking|dot.shadow_word_pain.remains<gcd+0.5)&miss_react
- gcd is the time, in seconds (with the origin, 0, being the combat start), the global cooldown will expire.
- cooldown, for a spell or an usable item, is the initial cooldown duration, in seconds.
- ticking, for a dot or a hot, will return 1 if the dot is currently active on your target, 0 otherwise.
- ticks, for a dot or a hot, will return the number of ticks done so far since the last time the dot was refreshed.
- ticks_remain, for a dot or a hot, will return the number of remaining ticks before the dot expires.
- remains, for a dot or a hot, will return the remaining time, in seconds, before the dot expires. It does NOT apply to buffs and debuffs.
- tick_time, for a dot or a hot, is the time, in seconds (with the origin, 0, being the combat start), the next tick will occur.
- travel_time is the timespan, in seconds, the spell will need to reach its target (a fireball for example).
- miss_react is 1 if the last occurrence of this action missed or has never been used, 0 otherwise, taking into account the reaction time, as specified through reaction_time. If you specified 0.5s and the miss only occurred 0.3s ago, this property will return 1.
- cast_delay is 1 if sufficient time has elapsed after the previous player executable action's cast time (including gcd). The time is controlled by two separate parameters, brain_lag and brain_lag_stddev.
The character's buffs and the raid-friendly debuffs on your target (sunder armor, curses, etc) can all be used through the following syntax: buff.<aura_name>.<aura_property> (recommended) or aura.<aura_name>.<aura_property> (not recommended, see below). As usual, for the aura name, use underscores instead of white spaces and ignore non-alphanumeric characters.
# Here is how we can check the number of stacks of faerie fire on the target.
actions+=/faerie_fire,if=debuff.faerie_fire.stack<3
Regarding the list of buffs...
- The "buff "list will contains a smartly filtered list of buffs and target debuffs. For example, if many warriors are in the raid, every one of them will only have his own version of colossus smash, so that he cannot react to a CS from another warrior. However, this list will contain "sunder_armor", "expose_armor" and "faerie_fire" and those ones will be updated whenever someone in the raid applies it on the target. Finally, it will contains all buffs the character has.
- The "aura" list, however, is kinda strange and it is advised you not use it unless you're sure you should.
- The "buff" list also contains special buffs such as "bleeding" (target is bleeding), "casting" (character is casting), "raid_movement" (character is moving because of a "movement" raid event), "poisoned" (target is poisoned), "self_movement" (character is moving because of a start_move action), "stunned" (character is stunned), "vulnerable" (target is vulnerable), "stealthed" (character is stealthed)
- The "buff" list also contains buffs for potions (speed_potion, tolvir_potion, etc), trinkets (crushing_matter, etc), stances (defensive_stance, etc), shapes (moonkin_form, etc), enchants (landslide_mh for main hand, etc) and some buffs are split into multiple components (bloodfury_ap, bloodfury_sp).
- If you want to check the complete "buff" and "aura" lists, examine the application's output (not the html report). Under every player's detail, you will see a listing of constant and dynamic buffs: those are the content of the "buff" list. Now, past the players' and targets' details, is a "Auras:" label, with also constant and dynamic buffs: those are the content of the "aura" list.
For every buff/debuff, the available properties are:
- remains is the remaining time, in seconds, for this debuff. Debuffs with a an infinite duration have a zero value.
- cooldown_remains is the remaining time, in seconds, for spell's cooldown triggering this buff.
- up is 1 when the debuff currently exists and is active, 0 otherwise.
- down is 0 when the debuff currently exists and is active, 1 otherwise.
- stack is the number of stacks of this buff.
- react is the number of stacks of this buff, taking into account your reaction time, as specified through reaction_time. If you specified 0.5s, the returned value will be the number of stacks there were 0.5s ago.
- value is the buff's value. For a 1200 spell power buff, for example, it will be 1200.
The dots and hots applied by the character on the target can be used through the following syntax: dot.<dot_name>.<dot_property>. As usual, for the dot name, use underscores instead of white spaces and ignore non-alphanumeric characters.
# If frost fever is going to expire on the target (less than 2 seconds remaining), refresh it with howling blast.
actions+=/howling_blast,if=dot.frost_fever.remains<=2
The available properties are:
- duration is the initial duration, in seconds (not the remaining duration).
- modifier is the damages or healing modifier. If your character has a 20% general modifier and a 30% modifier for this dot, it will have a total of 1.2*1.3=1.56.
- remains is the remaining duration, in seconds, before the dot/hot expires.
- ticking is 1 if the dot is still active on the target, 0 if it faded out.
The remaining time, in seconds, on character's cooldowns can be used through the following syntax: cooldown.<spell_name>.remains. As usual, for the spell name, use underscores instead of white spaces and ignore non-alphanumeric characters.
# Use "aimed shot" if at least 5 seconds remain on "chimera shot".
actions+=/aimed_shot,if=cooldown.chimera_shot.remains>5
The remaining time, in seconds, on weapon swings can be checked through the following syntax: swing.<weapon>.remains. The weapon can be one of the following values: "mh", "oh", "mainhand", "offhand", "main_hand", "off_hand".
# Arms warriors in burning crusade (at the time slam used to reset the swing timer) could use this to only fire slam if at least 3s were remaining before the next swing:
actions+=/slam,if=swing.mh.remains>3
You can check whether a casted spell is still flying towards its target (a fireball for example) with the following syntax: action.<spell_name>.in_flight. It will return 1 if the spell if flying, 0 otherwise.
You can check whether the character currently has a set bonus with the following syntax: set_bonus.tier<number>_[2pc/4pc]_[caster/melee/tank]. It will return 1 if the set bonus is active, 0 otherwise.
# Only use some_spell if the character currently has the T11 2pc caster bonus
actions+=/some_spell,if=set_bonus.tier11_2pc_caster
See also equipment - set bonuses.
You can always refer to your pet's properties through the pet.<pet_name>.<pet_property> syntax. The pet's name is formatted using underscores instead of white spaces and ignoring non-alphanumeric characters.
# Use ice lance if the water elemental's "freeze" cooldown will expired before the end of the gcd.
actions+=/ice_lance,if=pet.water_elemental.cooldown.freeze.remains<gcd
Also, note that pets have one additional properties: active is zero when not active, 1 otherwise.
# Use "some_spell" if "some_pet" is active.
actions+=/some_spell,if=pet.some_pet.active
Finally, within a pet's actions list, you can always use its owner's properties through the owner.<owner_property> syntax.
# Use some_spell if the owner's level is higher than 60.
actions+=/some_spell,if=owner.level>60
You can check the target's properties with the following syntax: target.<property>
# Use cleave if the target has at least 1 add
actions+=/cleave,if=target.adds>0
The available properties are:
- level is the target's level.
- health_pct is the target's health percent, between 0 and 100.
- adds is the number of adds the target has.
- adds_never is 0 if the target will never have adds (no initial adds and no "adds" raid event), 1 otherwise.
- time_to_die is the estimated remaining time, in seconds, before the target dies.
See the relevant page for each class.
- reaction_time (scope: global; default: 0.5) is the reaction time, in seconds. It is the time your players will need to notice an aura application (for action conditional expressions using the react keyword) or a spell miss (for action conditional expressions using the miss_react keyword).
# No, I am not that slow!
reaction_time=0.25
- skip_actions (scope: current character; default: "") is a sequence of action names to ignore, separated by "/". Actions mentioned in this string will never be performed.
# With only three adds, it is wise for John the warrior to still use his poor aoe spells? Let's check!
armory=us,illidan,John
skip_actions=cleave/whirldwind
- default_actions (scope: global; default: 0), when different from zero, will force the application to ignore your custom action lists and only use the default action lists for all characters and pets.
default_actions=1