Prism

A World of Warcraft Classic addon that makes action buttons visually respond to gameplay situations.

Optimal play requires tracking cooldowns, resources, buffs, debuffs, and enemy casts simultaneously - mental overhead that pulls attention away from positioning and split-second decisions. Prism moves that tracking to your peripheral vision: buttons glow when abilities should be used, turn red when blocked, or show a golden border when already active.

All action buttons benefit from automatic visual feedback (range, resources, cooldowns) without any configuration. Custom rules let you add ability-specific logic on top.

Installation

• Download Prism from CurseForge
• Extract to your World of Warcraft/_classic_/Interface/AddOns/ folder
• Restart WoW or type /reload if already in-game

To configure Prism in-game, type /prism to open the configuration window.

Ready-to-use Configurations

Ready-to-use configurations are available for various classes. For example, here's a complete Rogue configuration.

To use an example configuration:

• Type /prism in-game to open the configuration window
• Click "New Document" to create a new document
• Copy the content from the example file and paste it into the document
• Save the document

Example

Here's a practical example - configuring the Druid's Growl ability with a macro that automatically shifts into bear form:

#showtooltip Growl
/cast [noform:1] Bear Form
/cast Growl
/startattack

spell: "Growl"
blocked: @player{!canShiftInto(bear)} | @target{dead | !harm}
checked: @target{ownDebuff(infer) | targeting(@player)}
enabled: @target{!casting}
flashing: @player{!canShiftBackFrom(bear)}
glowing: @player{combat & grouped & druidForm(bear)}

This makes Growl:

• Red when lacking mana to shift into bear form or target is dead/friendly/missing
• Golden border when Growl debuff is active or target is already targeting the player
• Grayed out when target is casting
• Flashing when lacking mana to shift back from bear form after using Growl
• Glowing when in bear form during combat in a group

State Hierarchy and Rules

The visual state system follows a strict hierarchy:

• Default state - buttons are enabled by default unless a rule explicitly disables them
• Cascading effect - if an ability is blocked, depleted, or checked, it becomes disabled and cannot glow or flash
• Precedence - default rules always win - if the game determines that an ability is blocked, depleted, or checked, custom rules cannot override this

Default Behavior

Even without custom rules, Prism applies these defaults to all action buttons based on game mechanics:

• Out of range → Blocked (red, disabled)
• On taxi/flight path → Blocked (red, disabled)
• Out of mana/rage/energy → Depleted (blue, disabled)
• Currently casting/channeling → Checked (golden border, disabled)
• Auto-repeating actions → Checked (e.g., Attack, Auto Shot, Shoot)
• On cooldown → Disabled (grayed out, but only for cooldowns longer than the global cooldown)

Note on cooldowns: Abilities on cooldown are automatically disabled and grayed out, but only when the cooldown is longer than the global cooldown (1.5s). This preserves visual states (glowing, flashing) during the GCD so important cues aren't lost when global cooldown activates.

Combined states: When an ability is both blocked and depleted, the overlays combine to show purple (red + blue), giving immediate visual feedback about multiple issues.

Understanding Cascading Effects

The cascading system prevents conflicting visual states:

• Disabled states (blocked, depleted, checked) prevent flashing and glowing
• Flashing takes priority over glowing when both conditions are met

For example, with Aspect of the Hawk:

spell: "Aspect of the Hawk"
checked: @player{buff(infer)}     # Shows golden border when buff is active
glowing: @player{autoShooting}    # Glows when auto-shooting

One might think glowing: @player{autoShooting & !buff(infer)} is needed to prevent glowing when the buff is already active. But that's unnecessary! When checked is true (buff is active), the button becomes disabled and cannot glow anyway. The cascading effect handles this automatically, making configurations cleaner and easier to write.

DSL Basics

The Prism configuration language is built around a simple pattern: defining rules that evaluate predicates within scopes to control how action buttons appear.

Quick Terminology

• Predicate - the atomic check: combat
• Condition - combine predicates with logic: combat & health(<20%)
• Scope - evaluate conditions on specific units: @player{combat}
• Rule - combine scopes to control visual states: @player{combat} & @pet{dead}

Spell Configuration

Each spell configuration starts with the spell name, followed by optional visual state rules:

spell: "Aspect of the Hawk"
blocked: <rule>    # Optional
depleted: <rule>   # Optional
checked: <rule>    # Optional
enabled: <rule>    # Optional
flashing: <rule>   # Optional
glowing: <rule>    # Optional

Each configuration handles one spell only. Spell names must match the game's language - use "Aspect of the Hawk" for English clients, "Aspekt des Falken" for German, etc.

Item Configuration

Items use their item IDs instead of names:

# Healing Potions
item: 118, 858, 929
blocked: <rule>    # Optional
depleted: <rule>   # Optional
checked: <rule>    # Optional
enabled: <rule>    # Optional
flashing: <rule>   # Optional
glowing: <rule>    # Optional

Items use IDs for language compatibility (IDs work across all game languages), to handle multiple variants (many different healing potions can share one configuration), and for easier maintenance.

Finding Item IDs

Use Wowhead Classic - the ID is in the URL:

• https://www.wowhead.com/classic/item=118/minor-healing-potion → ID is 118
• https://www.wowhead.com/classic/item=858/lesser-healing-potion → ID is 858
• https://www.wowhead.com/classic/item=929/healing-potion → ID is 929

Minimal Configurations

Only the states that need customization need to be specified. All action buttons already benefit from Prism's default behaviors - custom rules add specific conditions on top:

spell: "Aspect of the Beast"
checked: @player{buff(infer)}

This simple configuration benefits from all the default addon rules (cooldown visualization, out of range indication, missing resource alerts) while adding just one custom rule to show when the aspect is active.

Boolean Operators

These operators combine predicates into conditions:

• & - AND (both must be true)
• | - OR (either can be true)
• ! - NOT (inverts the result)
• () - parentheses for grouping

Units

Units tell the game who to check - the player, the player's current target, the player's pet, etc.

Unit IDs

• @player - the player character
• @target - the player's current target
• @pet - the player's pet (Hunter, Warlock)
• @mouseover - unit under the mouse cursor
• @focus - the player's focus target (if supported)
• @party1 through @party4 - party members
• @raid1 through @raid40 - raid members

Unit Modifier

Units can have the :help modifier to enable smart targeting:

• :help - automatically targets yourself when holding self-cast modifier keys, when target doesn't exist, or when target can't be assisted

# Smart targeting, e.g. for bandages and healing spells
@target:help{health(<50%)}

Special Values

infer

The infer keyword automatically determines the appropriate buff/debuff name:

• Spell configurations: Uses the spell name
• Item configurations: Uses the item's spell effect name

spell: "Serpent Sting"
checked: @target{ownDebuff(infer)}  # Checks for "Serpent Sting" debuff

item: 8766  # Morning Glory Dew
checked: @player{buff(infer)}  # Checks for "Drink" buff

always

The always predicate is unconditionally true - useful for "always glow":

glowing: @target{always}  # Always glows when there is a hostile target

Numeric Values

• Percentages: 50%, 100%
• Durations: 2s, 10s
• Comparisons: >, <, >=, <=

When no comparison operator is specified, values check for equality. For "not equal", omit the operator and use the ! negation instead.

@player{health(<30%)}        # Health below 30%
@player{health(100%)}        # Health at full
@player{!health(100%)}       # Health not full (damaged)
@target{comboPoints(>=4)}    # Target has 4 or more combo points

Available Predicates

Predicates are the individual checks that evaluate to true or false. They're used within scopes to test specific properties of units.

Universal Predicates (any unit)

Existence

• alive - unit is alive
• dead - unit is dead
• existing - unit exists
• missing - unit doesn't exist

@pet{dead | missing}

Auras

• buff(name, count?, duration?) - unit has buff with optional stack count and remaining duration
• ownBuff(name, count?, duration?) - unit has buff cast by the player
• debuff(name, count?, duration?) - unit has debuff with optional stack count and remaining duration
• ownDebuff(name, count?, duration?) - unit has debuff cast by the player

@target:help{buff(infer)}
@target{ownDebuff("Sunder Armor", 5, >5s)}

Dispellable Auras

• cursed - unit has curse debuff
• diseased - unit has disease debuff
• magicBuff - unit has magic buff
• magicDebuff - unit has magic debuff
• poisoned - unit has poison debuff

@pet{!cursed & !diseased & !magicDebuff & !poisoned}

Resources

• energy(amount) - energy level
• health(percentage) - health percentage
• mana(percentage) - mana percentage
• rage(amount) - rage level

@player{mana(<20%) | health(<30%)}

Combat State

• attacking(@unit) - unit has highest threat on specified unit
• casting - unit is casting any spell
• combat - unit is in combat
• comboPoints(number) - unit has combo points
• targeting(@unit) - unit is targeting specified unit
• trivial - unit is too low level to award experience or honor

@target{targeting(@player) & !casting}
@target{!trivial}    # Target is worth experience/honor

Recent Actions

• blocked - unit blocked the last attack
• dodged - unit dodged the last attack
• parried - unit parried the last attack

@player{dodged}

Unit Type

• bleedable - unit can be affected by bleed effects
• creature(type) - unit is specific creature type (beast, critter, demon, dragonkin, elemental, giant, humanoid, mechanical, totem, undead)
• elite - unit is elite, rare elite, or world boss
• harm - unit is hostile
• help - unit is friendly
• is(@unit) - unit is the same as specified unit
• level(number) - unit's level
• npc - unit is an NPC (not a player)
• partyMember - unit is in the player's party

@target{creature(beast)}
@target{elite & level(>=59)}

Player-Only Predicates (@player)

Movement

• falling(duration?) - player is falling with optional duration check
• mounted - player is mounted
• running(duration?) - player is running (7+ yd/s, excluding mounted and taxi) with optional duration check
• swimming - player is swimming
• submerged - player is underwater

@player{falling(>2s)}
@player{running(>3s)}

Environment

• grouped - player is in a group
• indoors - player is indoors
• outdoors - player is outdoors
• resting - player is resting

@player{outdoors & !grouped}

Equipment & Form

• equipped(type) - player has equipment type equipped (dagger, meleeWeapon, shield)
• form(number) - player is in specific form
• stance(number) - player is in specific stance
• stealthed - player is stealthed

@player{stance(1) & equipped("shield")}
@player{equipped("meleeWeapon")}  # Checks if a usable melee weapon is equipped in main hand

Talents

• talent(name, rank?) - player has talent with optional rank check

@player{talent("Tactical Mastery", >=2)}

Combat Actions

• autoShooting - player is auto-shooting
• meleeAttacking - player is melee attacking

@player{autoShooting}

Resources

• ammo(amount?) - player has ammo with optional amount check

@player{ammo}           # Has any ammo
@player{ammo(>200)}     # Has more than 200 ammo
@player{ammo(<50)}      # Has less than 50 ammo (warning)

Inventory

• itemCount(itemId, amount) - item count in player's inventory

@player{itemCount(6265, >2)}    # Has any soul shards (Warlock)
@player{itemCount(8544, >0)}    # Has any Mageweave Bandages

Class-Specific

• canShiftInto(target) - player has enough mana to shift into target form and use ability (Druid)

  • target: druid form keyword (aquatic, bear, cat, humanoid, moonkin, travel)
  • if current form equals target form: only checks ability mana cost
  • if forms differ: checks target form cost + ability cost

• canShiftBackFrom(target) - player has enough mana for round-trip: shift to target form, use ability, and return to current form (Druid)

  • target: druid form keyword (aquatic, bear, cat, humanoid, moonkin, travel)
  • if current form equals target form: only checks ability mana cost
  • if forms differ: checks target form cost + ability cost + current form re-entry cost

• druidForm(target)

• rageSafe - player can switch stances without losing rage (Warrior)

@player{canShiftInto(bear)}
@player{canShiftBackFrom(bear)}
@player{druidForm(bear)}
@player{rageSafe}

Ability State

• usable(infer) - player's inferred ability is usable

@player{usable(infer)}

Pet-Only Predicates (@pet)

Happiness

• happy - pet is happy

@pet{!happy}