World of Warcraft Script Tutorials

nil value

2008-09-26T00:27:00.000-07:00

Description

A nil value means nothing. None. Null. Blank. void. But NOT zero.

For example, if you are not targeting a unit and you execute a macro with UnitHealth("target"), then it will return nil.

Any usage, of undeclared variables as parameters will cause error and the whole script will not run.
nil is not called with quote wrap. It is used like a variable(without wraps)

If you use functions that will return nil in if then else end statements, it will return nil and perform the else functions instead.

For example, if you don't have a target and you use this:

/run local x if UnitExists("target") then x="You have a target!" else x="You don't have a target" end message(x)

Because the UnitExists("target") will return nil,it will say "You don't have a target".

But if you have a target, function UnitExists("target") will return 1. Yeah as in ONE. When this is returned, then it will put to local variable x "You have a target!".

Local Variables

2008-09-26T00:19:00.000-07:00

Introduction

Variables, as I said in my tutorials, have two kinds, a global and a local variable.

And yes, you can guess it there difference by there name. Global variables will retain it's value after the script, while the local variables will be nil after the script.

Usage and Declaration

local variables are declared by adding "local" before the variable declaration

/run local x=1

to declare more than one local, instead declare them by commas

/run local x,y=1,2

DO NOT USE LONG CHARACTERS FOR LOCAL VARIABLES.
ONE CHARACTER VARIABLES IS THE BEST.

so instead of using

/run local targethp=UnitHealth("target")

use

/run local h=UnitHealth("target")

Global Variables

2008-09-25T23:40:00.000-07:00

Introduction

Variables, as I said in my variable tutorials , have two kinds, a global and a local variable.

And yes, you can guess it there diffrence by there name. Global variables will retain it's value after the script, while the local variables will be nil after the script.

Usage

As you might have guess, using global variables will be useful for storing information specially when you are trying to make a macro that will depend in every click.
For example, you can make a macro that counts like a lil child like this

/run if x==nil then x=1 else x=x+1 end SendChatMessage(x)

Characters

Unlike local variables, global can make WoW Addon errors. This is because if you declared a global variable that is same as an addon variable, it will record your declared variable as the new addon variable.

For example, if you made a global variable like DamageDone=100000000000000 and an add-on uses it on a damage meter, then your it will show you that the damage done is 100000000000000.

To prevent this problem,

Do not use unnecessary globals.

If you got enough space,Make global variables at least 3 characters long

Do not make global variables too readable. This kind of variables are often used in add-ons

If it still errors out your add-on, it's your add-on's fault. add-ons should have long global variables. This is because they do not have character limit unlike macros.

Now once you're good enough and proficient enough, you can now make

/run if x==nil then x=1 else x=x+1 end SendChatMessage(x)

into

/run if cou==nil then cou=1 else cou=cou+1 end SendChatMessage(cou)

Always make sure that your 3-character variable can still give a clue of what you want. For example, I made "cou" variable in above example to give a clue that it will be used in counting. Do not use "xxx" "yyy" or anything that won't give a definite clue because: When you are making alot of macros, you can accidentally replace your own variables.

VI: Arrays

2008-07-23T09:26:00.000-07:00

Arrays is a variable that is divided into many sections and this sections can be called separately and is represented by <Variable Name>[<index>] the best advantage of arrays versus ordinary variables is indexes can be called with a variable or function, therefore making it easier to put condition or make many variables.

Declaring an array:

Before you can call an array value, you should declare it first or else it will not work

/run x={}

Placing a value in the array:

To insert a data on the array right away at declaration, just make:

/run x={<value1>,<value2>,<value3>}

now, variable x[1] will be equal to <value1>, x[2] equal to <value2>. x[3] is equal to <value1>
Note: you can add more or less than 3 values

To insert a data on an index:

/run x={} x[1]="hello"

Note: you cannot call the array variable alone eg. SendChatMessage(x)

To call an indexed value:

/run x={} x[1]="hello" SendChatMessage(x[1])

This is same as:

/run x={"hello"} SendChatMessage(x[1])

To call an indexed value using a variable on index:

/run x={} x[1]="hello" y=1 SendChatMessage(x[y])

To get the number of values in the array(how many is indexed)

/run x={} x[1]="hello" x[2]="hi" message("array x has"..table.getn(x).." Values")

Note: One of the most useful usage of array is using them on loops.

V: Looping

2008-07-22T18:17:00.000-07:00

Introduction

Looping is doing a group of functions repeatedly until certain declared condition is achieved. This is useful in WoW macros to do functions that can be repeatedly done without delay.

The reason is, functions done in loop(or any other macro) are done in a very microscopic time distances. In other words every commands/functions are executed one by one but too fast to have anything to be done in between them, almost no time gap.

Three Kind of loops

for do end

/run for (variable name)=(starting value),(end value) do (block of codes) end

while do end

/run (variable name)=(starting value) while (condition) do (block of codes) end

repeat until

/run repeat (block of codes) until (condition)

for do end loop examples

Counting to 3

/run for x=1,3 do SendChatMessage(x) end

when loop executes x will be equal to the starting number which is 1
then it will send the chat message to say the value of variable x which is 1 so it will say in chat: 1
then it will increase x by one so now, value of x is 2
then it will send the chat message to say the value of variable x which is 1 so it will say in chat: 2
then it will increase x by one so now, value of x is 3
then it will send the chat message to say the value of variable x which is 1 so it will say in chat: 3

After that x reached the value of the end value, it will not return to the loop again.
After the loop is over, variable used for the loop will be nil
so you cannot use x anymore unless you declare a new value

While do end Loop Examples:

/run x=1 while x<=3 then SendChatMessage(x) x=x+1 end simulation:

variable x will be equal to 1
if variable x is less than or equal to 3, do if not, go proceed to end(step 6)
SendChatMessage(x) ==> say: 1
variable x = variable x(which is equal to 1) +1 so (x=1+1) so x=2
repeat step 2
end

Note: you can still add command blocks after the "end"
Advantage of using While Loop:
While loops can be added with conditions.
Counter used in while loops doesn't become nil after the loop

repeat until loop example

/run x=1 repeat SendChatMessage(x) x=x+1 until x>=4

Unlike other loop methods, this one doesn't execute if the condition is true, instead, if the condition is false. In the example above, the loop will not break until x is greater or equal to 4

x is equal to 1
SendChatMessage(1) ==> say: 1
x=x+1; x=1+1 ; x=2
check condition: is x>=4? ; False, continue loop (repeat step 2)
SendChatMessage(2) ==> say: 2
x=x+1;x=2+1; x=3
check condition: is x>=4? ; False, continue loop (repeat step 2)
SendChatMessage(3) ==> say:3
x=x+1;x=3+1; x=4
check condition: is x>=4? ; True: 4=4, break the loop, continue to next block(none)

IV: if then else

2008-07-21T06:52:00.001-07:00

if then else is a Lua function. The syntax format is if <condition> then <functions to be done if condition is right> else <function to be done if the condition is not right> end

Relational Operators

== means "is equal to" Note: it doesn't mean x will be 1 in x==1 it is only used to compare if "x is equal to 1"
~= means "is not equal to"
> means "greater than"
<= means "less than or equal to "
>= "greater than or equal to "

determining if you have full HP

/run p="Player" p=UnitHealth(p)*100/UnitHealthMax(p) if p==100 then SendChatMessage("I Have Full HP") else SendChatMessage("My Hp isn't full") end

Note: you don't have to make the "else" part if you don't have anything to put there, instead of adding it, just make if then end

Determining if variable is not nil

you can make a condition in if statement that will only allow the command run only if the variable has a value: like

/run if y then SendChatMessage("Variable Y contains this value: "..y) else SendChatmessage("VariableY doesn't have any value") end

this will say the else code "VariableY doesn't have any value" if y has no value

Using Functions

Functions like UnitIsDead(), UnitIsPlayer(), UnitIsVisible() returns nil if false and return 1 if true, therefore it is same as example above

/run if UnitIsDead("player") then message("you're dead") else SendChatMessage("You're alive") end

Note: always remember to add end after else or then

Adding more than one condition

Adding more than one condition on the script will require you to use logical operators:

Logical Operators

and -- Makes the code execute only if both of the condition is true
or -- Makes the code execute if one of the condition is true
not -- Makes the code execute if none of the condition is true

Logical Operator: And

/run if UnitIsDead("target") and UnitIsPlayer("target") and UnitCanAssist("target","player") then message(UnitName("target").." is dead, and is an allied player") end

Logical Operator: OR

/stopmacro [noharm]
/run if (UnitCreatureType("target") == "Humanoid") or (UnitCreatureType("target") == "Beast") then SendChatMessage("Casting Polymorph on %t! stop attacking!") end
/cast polymorph

III: Operators

2008-07-21T05:56:00.000-07:00

Introduction

Addition, Subtraction, Multiplication and Division and other math operations can only be done in numeric values and if you try it with strings you will get error and script will not run.

Basic Operators

+ -- Addition
- -- Subtraction
* -- Multiplication
/ -- Division

Simple Addition

Examples:

/run x=1+2 SendChatMessage(x)

This will say in chat

3

Simple Subtraction

/run x=10-6 message(x)

This will make a window with this message:

4

Simple Multiplication:

/run x=1*2 message(x)

This will open a window with message:

2

Simple Division

/run message(50/10)

This will open a window with message:

5

Simple multiple operators

/run x=(10-4)*3 message(x)

This will make a window with this message:

18

Note: you can also add it directly as a parameter to a function, it is not necessary to make an operation on a variable, BUT if the value is used TWICE or more in the script, make it a variable instead of direct ly using it as parameter

Function Operations

Using operators for functions is the same as using them on variables, just a lil bit confusing tho.

Getting HP % of your character

/run p="Player" h=UnitHealth(p)*100/UnitHealthMax(p) message(h.."% HP")

This will create a window with of your health % like:

100% HP

II: Variables

2008-07-21T05:29:00.000-07:00

Introduction

using variables is essential to save characters and prevent overflowing to 255 character limit. Variable names may contain numbers or letters but must start with a letter. Normal variables will remain at there value except redeclared or replaced, until you log out.

Declaring a Variable

/run x=1

in this example, variable x will contain a value of 1

Using a Variable

/run x=1 SendChatMessage(x)

In this example it will say in chat:

FAQ: what if you call an undeclared variable?
it will return nil.
What is nil?
nil means null,none,nothing,void BUT NOT ZERO. Any usage, of undeclared variables as parameters will cause error and the whole script will not run.
nil is not called with quote wrap. It is used like a variable(without wraps)

Making string(non-numeric characthers) variables

/run x="Hello World" message(x)

Note: you will wrap strings with quote to make them variables

Making function variables.

Some functions returns values if they are used. Like UnitHealth("target") which returns the health of your target.

/run x=UnitHealth("target") message(x)

This will make a warning window with the health of your target. Note: you mustn't wrap it with quotes

Conjucting(connecting) variables

/run a="I" b="Am" c=UnitName("player")

To conjunct or connect variables or constants, just add double period and the next variable or constant

/run a="I" b="Am" c=UnitName("player") SendChatMessage(a.." "..b.." "..c)

Note that: you will still proper quotations

This will make you say in chat:

I am <yourname>

Redeclaring Variables

/run x=1 x=x+1 message(x)

Value will be: 2

Creating a local variable(stays only in that script)

Creating local variables are useful for macros that will not be used later. Declaring local variable will make the variable volatile, and that variable will be nil after the script is done

/run local msg="This is a local Variable, variable x will be nil after it is declared local and will also be nil after this script is over"

now after the macro, even you connect a "/run message(msg)" , it will not return the msg

I: Basics

2008-07-21T05:00:00.001-07:00

Introduction

World of Warcraft is built with a programming language called LUA.
Calling a function is done by /run <FunctionName()>. Every function is case sensitive and won't work if not cased properly. Most ( but not all ) functions ends with () like LeaveParty() .
/run also works like /script, obviously, /run is shorter, so you must use it.

Note: Many functions are removed like casting spells on /run commands this also includes movement functions, targeting functions and many more that can be used for bots.These restricted functions are only accessible by Blizzard User Interface.

Note: Always remember that WoW scripts are typed in one line unlike other programming languages. Any incorrect line breaks ( pressed enter) will cause the script to break and may not work right.

Calling a Basic Function

To call a basic function like leaving a group, just type or make a macro with this code:

/run LeaveParty()

Adding Function Arguments

To call a function with parameter aka arguments, just put them inside the parenthesis:

/run SendChatMessage("hello")

Note: Strings(non number characters are always wrap in quotes or double quote or else they will work as variable(next chapter)
Note: Double quotes(") must be closed with double quote(") and single quote( ' ) must be closed with single quote( ' )

Calling Multiple Functions

To call two or more function, just add space or semi colon and add the function on the same line

/run SendChatMessage("hello") DoEmote("hi")

Note: each functions are called one by one, one after the other in a very microscopic time difference.

Adding Multiple Arguments

To call a function with more than one argument aka parameter, add comma between each parameters. Note that you will still wrap them in quotes

/run SendChatMessage("hello","yell")