Home > Articles > Security > Software Security

  • Print
  • + Share This
This chapter is from the book

Tooling Up

By now we have described a number of common "game cheating 101" attacks. We've even shown you how simple macros work. But explaining how these things work is not quite the same as seeing how they are constructed. Toward that end, we present a simple macro for WoW. Warning: Use of this macro is cheating and is against the rules. Your character may be banned from the game if you use this macro.

Note that these kinds of tools are in common use every day in all kinds of games. It's not just in WoW that cheating happens.

AC Tool: Macro Construction

There are a number of popular macro construction tools on the Internet. These include macro express (which costs money), AC Tool, AutoHotKey, AutoIt3.0, LTool-0.3, and xautomation. All of the ones mentioned here have been nicely collected on a wiki at <http://wiki.atitd.net/tale2/Macros>.

AC Tool is particularly popular. You can download it for free from <http://www.actool.net>. Once you have installed AC Tool, you can create macros for WoW using its macro language. The FAQ on the AC Tool Web site describes the tool as follows:

  • AC Tool is a utility that allows you to list a series of keystrokes and mouse clicks in advance and send them to Asheron's Call at a later time. The list of keystrokes and mouse clicks is called a macro or a script.

Here is a simple grinding/farming macro (called Hoglund's WoW_Agro Macro) designed to be used with AC Tool. This macro controls a character that camps out waiting for monsters to appear and kills them when they do. We'll interleave commentary with the code so you can understand what's happening.

// -------------------------
// hoglund's WoW_Agro Macro
// -------------------------
//RESOLUTION: 1024x768

SETActiveWindow World of Warcraft
delay 4 sec

// put all your 'globals' here
       gPCHealth = "NoValue"
       // the current health of the PC ( HIGH | MEDIUM | LOW |
       gMobHealth = "NoValue"
       // the current health of the current targeted mob ( HIGH |
       gPCPosture = "Standing"
       // current/starting posture of the PC character
       gMachineState = "START"
       // global machine state, core of the system
       gSelectedTarget = "NoTarget"
       pc_name = xanier

The first part of the code sets up global variables, most importantly the currently selected target, the name of the character being automated, and the current state of the state machine. This script implements a classic architecture that many macros follow—that is, it is designed to operate as a state machine. This means that the script maintains a single state variable while automating the character. States can have mnemonic labels such as "attacking," "healing," or "running away for dear life." Only one state can be active at any one time, and there are rules for transitioning from one state to another.

// hot keys
keyExecAttack = 1
// set your F1 key to attack before using this MACRO
keyExecPickup = {F2}

The part of the script above indicates which keys need to be used in order to automate the game. When the F2 key is pressed, the character picks up items, and when the number 1 key is pressed, the character attacks. This kind of key binding is very common in macros like this. Simple macros operate the software using only keystrokes and mouse movements—there is nothing invasive that exploits the game software directly. More advanced methods of cheating are nowhere near as simple.

       // screen coordinates
       coord_MobHPMin           = 262, 50
       coord_MobHPFull          = 370, 50
       coord_SafeHP             = 200, 50
       //if green at or above this mark, you're fine
       coord_HalfHP             = 146, 50
       //half hp if lower than this mark
       coord_LowHP              = 116, 50
       //low hp if at or lower than this mark
       coord_DeadHP             = 96, 50
       //you're dead :(
       coord_temp               = 0,0
       // colors
       color_AliveGreen         = 150
       color_AttackRed          = 147
       // temp stuff
       TempTarget               = NoValue
       //holds the value for target before placing into list
       tCount                   = 1
       //used to traverse the targetList index
       Total                    = 1
       //used to find the ListCount
       redDifference            = 0
       blueDifference           = 0
       greenDifference          = 0
       numAttacks               = 0
       Returned                 = 0
       aCount                   = 0

The section of the script above is quite fascinating. It designates x- and y-coordinates on the screen. Furthermore, it designates exact color thresholds for pixels. This information is used to sample pixels on the screen at precise x- and y-coordinates. The pixels in question happen to correspond to locations where health and enemy health are displayed on the screen for the game user. This information, along with the color threshold, is then used to determine whether the character is at full health, is partially damaged, or is in critical condition—all via sampling pixels on the screen and figuring out color matches while the macro runs.

While 1=1
  Processmessages    //required for AC Tool operation
  Call Lazy8_Main    //the main lazy8 machine handler

// the main lazy8 machine handler
Procedure Lazy8_Main

       //KeyDown /whisper $pc_name Lazy8_Main {RETURN}
       //KeyDown /whisper $pc_name current state: $gMachineState

You see this sort of thing all over the place in the macro; the whisper command prints a message on the screen and is used to output debug messages while the macro is under development. You can see the results of a whisper call in the screenshot in Figure 2-5.

Figure 2-5

Figure 2-5 A screenshot from WoW showing what happens when the WoW_Agro macro runs. Virtual bodies pile up as the macro runs all night long.

       // perform effective switch() on machine state
       // START
       if $gMachineState = "START"
       Call LazyStart

       // IDLE
       // bored, we need to do something
       if $gMachineState = "DRAWING"
       Call LazyDraw

       // END
       // game over, man
       if $gMachineState = "END"
       call LazyEnd
End //end Lazy8_Main

Procedure LazyStart
       KeyDown /stand {RETURN}
       delay 100
       // go directly to draw agro mode
       Set gMachineState = "DRAWING"

Procedure LazyDraw
       KeyDown /whisper $pc_name LazyDraw {RETURN}

       //Call LureIfNoMonster

       //target last agro, this targets nearest also
       KeyDown {TAB}
       Delay 400

       Call EnsureAttackMode

       // hero strike
       KeyDown 2
       Delay 400


In the above section of the macro, we perform a pixel test to determine whether the character is currently in "agro" mode—that is, attacking a monster. If not, we call a routine to target the nearest monster and begin attacking. The script presses the 2 key in order to perform a hero strike—a powerful form of attack in the game.

// run forward and back to lure agro
Procedure Lure
       KeyDown {UP} 3 sec
       KeyDown {DOWN} 3 sec

// put the PC into attack mode
Procedure EnsureAttackMode
       LoadRGB 34,64
       Compute $redDifference = Abs ( $color_AttackRed -
       if $redDifference < 80
               KeyDown /whisper $pc_name im currently in attack
mode {RETURN}
               KeyDown /whisper $pc_name im attempting to start
attack mode {RETURN}
              KeyDown $keyExecAttack 150

// perform a random move if no monster is targeted
Procedure LureIfNoMonster
       Call util_GetMobHealth
       if $gMobHealth = "DEAD"
               KeyDown /whisper $pc_name Rest in Peace! .. luring
               Call Lure
               KeyDown /whisper $pc_name still going... {RETURN}

The section of the macro above is used to "draw agro" from nearby monsters. Essentially this amounts to getting the monster's attention by moving nearby. Such movement causes the monster to attack the character. Once the attack occurs, the character can attack the monster and kill it.

// END - kill the engine
Procedure LazyEnd
       KeyDown /whisper $pc_name LazyEnd {RETURN}


// Utility Function
// Get target mob health
Procedure util_GetMobHealth
       //KeyDown /whisper $pc_name util_GetMobHealth {RETURN}

       LoadRGB $coord_MobHPMin
       Compute $greenDifference = ABS ( $color_AliveGreen -

       //KeyDown /whisper $pc_name sample monster {RGBRED}

       if {RGBRED} = 0 AND {RGBBLUE} = 0 AND $greenDifference < 80
              Set gMobHealth = "ALIVE"
              //KeyDown /whisper $pc_name monster is still alive
              // we never found any green
              Set gMobHealth = "DEAD"
              KeyDown /whisper $pc_name monster is dead {RETURN}



This section of the macro detects whether or not the target monster is dead yet. Like monitoring character health, this is done through the simple technique of sampling pixels. In this case we pull a sample at the location that displays the monster's health bar.

And that's it, a complete macro for automating the attraction and killing of monsters in WoW. By running this macro, a character can accumulate experience and gold without human intervention.

Figure 2-5 shows a screenshot taken while the WoW_Agro macro is running. Notice the pile of dead monsters near the character. You should note that running a macro like this is against the rules and can cause you to be banned from the game. The WoW character's name displayed on the screen, Xanier, is no secret. Blizzard banned Hoglund's Xanier account just before the character was to reach level 60 (which at the time was the ultimate level for a WoW character). In this case, Hoglund was a little too flagrant with his cheating. Hoglund had spent over $400 on game-card registered accounts by this point. All of the accounts were banned for various reasons.

Time for another pesky question: Why is farming with a macro cheating? Some would argue that Blizzard made the game boring in the first place, so fair is fair.

  • + Share This
  • 🔖 Save To Your Account