Nox Wiki

The NoX map editor has the ability to edit all of the scripts used in single player, multiplayer, and quest maps. Scripts are what make the explosion of an NPC teleporting, the music in the area, the deadly arrow traps, almost anything possible!

To make use of the most recent function definitions, download the latest pack:

Script Use[]

Learning how to use scripts in NoX maps is, by far, the most difficult aspect of the editor. The simple functions, like unlocking a door, aren't that complicated; contrary to a boss NPC with a load of variables required to fulfill its purpose; but both require knowledge of proper syntax, variable use, math and logic, and a little uncommon sense to keep the whole thing from collapsing and crashing the game (though that last one comes up a little less often unless you're trying to be a revolutionary in NoX scripting). It isn't actually very overwhelming to make good use of all of them once you get used to how they work.


Before anything else is said, one thing must be stated first, as it may very well be one of the most important parts of NoX scripting; what is a pointer?

A pointer is basically a string or value that is used to reference an object, waypoint, wall, or group, among other things. Without pointers, a function is practically internal, and won't have any effect on what happens in the game.

The method of creating a pointer varies depending on what the pointer is being made for. For objects, you must select the target and go to its Properties menu. Then, you click the Xtra Bytes checkbox until the field labeled "Script Name" is not greyed out. In that field is where you input the name of the pointer. For waypoints, all you must do is select the waypoint you want to allocate the pointer to, and rename it. (Waypoints created afterwards will share the name in the field.) For groups, all you need to do is create a group (though groups have been known to be unreliable). For all of those, you can add the phrase "nameofthemap:" on the front without changing the pointer. Walls can only be referenced either in groups or directly in the script; this will be explained next.

Once pointers have been allocated, you can use them in the script, using functions with the explicit purpose of representing them. Such functions include:


For most of the functions, you only need to put the name of the pointer into the brackets (with quotations surrounding it). For individual walls, though, you must determine the wall coordinates of the wall you are trying to reference (more on that here) and place the x- and y-values in the blanks.

Using these functions in their entirety every time you want to mention a pointer can get cumbersome, and also bloat the script size. To prevent this from happening, and with many other uses, you can use variables to make a much quicker, much lighter reference. To use variables as pointers, you must allocate them as such:

Gvar4 = Object("Pointer")
Gvar5 = Waypoint("Pointer")
var0 = Wall(50,50)

Once you have done this, you can use them much more accessibly just by using Gvar4 (or whatever variable the pointer was allocated to) in place of the whole function. For example, a function could change from this:


to this:


Now, the script is much smaller and more manageable. These values can be used over and over again, in different parts of the scripts.


Learning how to use proper syntax is crucial if you intend to create anything more than rudimentary functions. It's necessary to learn how scripts are supposed to be built, and doing so can help to avoid numerous conflicts.

Syntax is actually relatively easy to understand in the script editor. There are a few basic structures for commands to follow; the first of which is the command alone:


Now, let's examine the structure of this mockup command:

  • The first part is, of course, the declaration of the command itself. This tells the script what to perform.
  • Next, there is an open bracket. This bracket will need to close at the end of the command.
  • Next up comes an argument. Arguments come in a variety of types; most commonly, in variables, values, strings, and certain commands. The type of argument each one is is dependent on the purpose of the function, and the amount of arguments required is dependent on the command. (More on arguments below.)
  • Every argument is followed by a comma, with no space after the comma, unless it's the last argument.
  • The above two repeat until they reach the end of the command. Then, a closed bracket is placed to complete the command.


Arguments are the part of each command that help to clarify exactly what that command is supposed to do. How they do this is specific on what the command desires. They may be specified as a value, a variable, a string, or even another command, depending on the function.

Values are the easiest to implement, since they don't rely on any other data or commands to act validly. However, a value can only consist of a number, and there are not many situations where a value will be useful by itself. Variables are similar to values, except that they represent specific data and must be declared beforehand. They aren't limited to numerical values like values; they can also be strings, objects, locations, and even other commands. Here is an example of a script making use of both types:


In this example, the first argument is a variable, and the second a value. The variable represents the entity that called the function the command is in, and the value represents how much gold that entity will receive.

Certain Commands are often used to designate variables within commands. They are similar to variables except that they will return a value in correspondence to their purpose, and only represent very specific data depending on what command is used. Some examples of commands suitable for use inside commands are:


Commands can also be designated to variables, which is a good idea if you plan to use the same command several times in a script:

Gvar4 = Object("Bear1")
var0 = Waypoint("Waypoint")

However, if the pointer being referred to is dynamic (such as an object's X coordinate), you must use the command itself to get an accurate value.

Finally, Strings are used to reference pointers and data using words and phrases. They are used very often to designate variables to pointers, such as in the example above. Strings must be surrounded by quotations ( "" ). Like commands, what they represent will differ from command to command; the most common uses for strings are for pointers, chat strings, objects, and spells or enchants. Following is an example for each of these uses:

var0 = Object("TheObject")
Chat(Gvar1,"This is a string.")
var1 = Create("RedPotion",Gvar4)


Learning proper syntax will give you limited access to what is possible in script modification; however, with a grasp on Logic, it is possible to create much more elaborate and impressive scripts than the simple, linear functions created with syntax alone. Much of this logic is fairly basic, but it isn't always easy to implement without knowing how it can be used. Following are some existing logical arguments:

=  : Used to represent something
== : Is equal to
>  : Is greater than
<  : Is less than
>= : Is greater than or equal to
<= : Is less than or equal to
!= : Is not equal to
+  : Add
-  : Subtract
/  : Divide
*  : Multiply
+= : Plus equals
&& : And
|| : Or
%  : Remainder
^  : ???
:  : Represents a key
NEG: Negative
f  : Added to many arguments to apply to floats

 Logical Syntax
if: Creates a conditional statement
not: Reverses the conditions for a conditional statement
jump: Jumps to a given key if conditions are met
call: Calls a function by name
return: Terminate function

Some of these logical arguments can be used with or without being used in a conditional statement (explained later), while some can only be used in one of the two ways; others still are special cases, and are used differently.

A single equal sign ( = ) and the plus equal sign ( += ) are the only ones on the list which can't be used in a conditional statement. " = " is mainly used to designate variables to various values in a standalone statement, and "+=" is used to add a number to a variable:

Gvar4 = Object("Object")
var0 += 2

All of the equality arguments ( ==, >, <, >=, <=, != ) can only be used in a conditional statement. They are used to check if a certain value has a certain relation to another certain value:

if CurrentHealth(GetHost()) == 50 jump 30
if var2 > 4 jump 12
if Gvar4 != Gvar5 jump 24

Plural reference arguments ( &&, || ) are also exclusive to conditional arguments; they detect whether or not the conditions apply to every -- or any, depending on which one is used -- reference specified:

if not Gvar65 == Gvar2 && Gvar66 == Gvar2 jump 22
if IsCaller(Gvar4) || IsCaller(Gvar5) jump 46

The math arguments ( + - / * % ) can be used both in declaration of variables and in commands. In standalone statements, they are often used to modify the original value of a variable; in some commands, they can be used inside arguments to specify more complex values:

var0 = var0 * var1
ChangeGold(Gvar1,CurrentHealth(Gvar1) + 1)
Gvar4 = Gvar5 % 4

The colon ( : ) isn't used in any statements, but in keys. Keys are used to jump to certain sections of the script without executing anything inbetween. (NOTE: It is possible to create recursive loops that never end; these will lock up the game!) They are used with the logical syntax "jump". One such use of keys is to implement a "staircase" structure, shown in example:

---Gem Machine---

var0 += 1
if var0 == 1 jump 10
if var0 == 2 jump 20
if var0 == 3 jump 30
jump 40
var0 = 0

When the script is refreshed, all keys will fix themselves to their correct value.

A negative value (NEG) isn't really logic; it simply represents a negative integer, since you cannot use the minus sign to represent a negative value:

ChangeScore(Gvar1,NEG 500)

Float values (marked with an 'f' ) aren't logic either; float values can have decimals, unlike integers. All float values MUST be marked with an 'f', including numbers, variables, and math. For numbers and math, the 'f' is put at the beginning of said entity, while variables have an 'f' placed before the variable number. However, variables must first be declared normally, but it must be declared with an ' f= ' instead of just ' = '. Here are some examples to further clarify this process:

var0 f= f30
var1 f= varF0 f+ f0.5
if not varF1 f>= varF0 jump 20

Logical syntax has been used many times throughout the examples, but has yet to have been discussed. There are five main arguments for logical syntax; if, not, jump, call, and return. The argument "if" begins a conditional statement; the contents that come afterwards is more or less arranged into an equality equation. If the equation is true, then the conditions are met, and the script will follow its rules. If it's false, then the script ignores the statement and moves on:

if Gvar4 == 1 jump 20
if GetCaller() != GetHost() jump 30

The argument "not" is placed, if necessary, right after "if", and the conditions to be met are the opposite of what is stated:

if not var0 >= 6 jump 13

The argument "jump" can be used either in a standalone statement or at the end of a conditional statement, and will jump to a specified key. If it is in a conditional statement, the conditions must first be met before "jump" is executed:

jump 56
if CurrentHealth(Gvar1) < 1 jump 37

The argument "call" may only be used alone; it calls another function by name. Make sure you do not use this argument on itself, for it is possible to create a recursive loop, which can lock up the game:

---Correct Use---
Function 3: Caller

call Receiver

Function 4: Receiver


---Incorrect Use---
Function 3: Repeater

call Repeater

The argument "return" is used alone, and is one of the most important in script; when this command is hit, the script ends. All scripts must end with this.

<Script Start>
Gvar4 += 1
<Script End>

One more important thing to note is this: YOU MAY NOT CAPITALIZE ANY LOGICAL SYNTAX! The syntax is only counted if all of the letters are lower-case; capitalizing any of the syntax can crash the game!


The use of variables has already been lightly described throughout the rest of the sections; however, one of the most important parts of using script has yet to be clarified on fully.

There are two different kinds of variables: global and local variables. Global Variables can be applied to every function in a map's script, and are represented by "Gvar#". Local Variables are specific to each single function, and are represented by "var#".

Creating Variables[]

Before you use a variable for anything, you must first create it. There is a box in the top left of the interface marked "Variables"; this is where the variables for each function will be listed. To add a local variable to a function, simply select that function and type in, "var#[1]", where " # " is the number after the last variable's. If there are no variables, you should start with "var0[1]".

Global variables are specially declared in the second "GLOBAL" function. When you select this function, there should already be 4 variables declared; you cannot use these as you would any other variables declared (see below). Aside from this, creating global variables is similar to creating local variables.

Special Global Variables[]

Upon creation of a map, there are four global variables that are automatically created; Gvar0, Gvar1, Gvar2, and Gvar3. These are variables with predefined purposes, and cannot be declared any other kind of pointer. However, they are still appropriate to use in your script, provided you know what their use is.

Gvar0 and Gvar1 are very similar to "GetTrigger()" and "GetCaller()" respectively. Sometimes, one or the other won't work within a script; I would recommend you try using the variables before trying the commands. Gvar0 has been used rather popularly with "SetProperty()" to command creatures created with the "Create()" command. The most recognized example of this is in the map "":

Function 3: CreateABear

var0 = Create("Bear",Gvar4)

Function 4: ReviveBear

Gvar2 and Gvar3 are flags for "true" and "false" respectively. They are used very often in conditional arguments to check if something is true or false; however, they are also used in some regular commands, such as Frozen():

if IsCaller(GetHost()) == Gvar3 jump 49


The number after each variable specifies how many partitions that variable has. Little is known about this feature, so it is a good idea to keep the value at [1].

List of Commands[]

Known Commands[]

Command Name Format Description
AggressionLevel obj,flt Makes $arg1 agressive at $arg2 level. Mostly ppl use 0, 0.5 and 0.83
AreOwnedBy obj_grp,obj Checks if $arg1 are owned by $arg2.
Attack obj,obj Makes $arg1 attack $arg2
AudioEvent str,wayp Produces audio event $arg1 at $arg2
AutoSave --- Forces the host to autosave. Solo only.
AwardSpell obj,str Raises $arg1's spell level of $arg2. $arg1 must be able to cast $arg2 in order for this work.
BecomeEnemy obj Makes $arg1 hostile
BecomePet obj Makes $arg1 friendly
Blind --- Blinds the host
CancelTimer timer Stops $arg1 from launching its function, if it's a timer.
CastSpellAt str,obj,flt,flt Makes $arg2 cast $arg1 at coords. $arg3 & $arg4
CastSpellFrom str,flt,flt,flt,flt Casts $arg1 from coords $arg2 and $arg3 to coords $arg4 and $arg5.
CastSpellOn str,obj,obj Makes $arg2 cast $arg1 on $arg3
CastSpellTo str,flt,flt,obj Casts $arg1 from coords $arg2 and $arg3 on $arg4
ChangeGold obj,int Gives $arg1 "$arg2" gold - using NEG takes gold away
ChangeScore obj,int Gives $arg1 "$arg2" points - using NEG takes points away
Chat obj,str Makes $arg1 say $arg2
ChatTimer obj,str,int Makes $arg1 say $arg2 for $arg3 frames
CheckObjectType obj,str Checks if $arg1 is an $arg2 kind of object, returns boolean
ClearOwner obj Makes $arg1 ownerless
ClearPrint obj Removes all print messages currently on $arg1's screen
Create str,wayp Creates $arg1 at $arg2
CreatureGroupHunt obj_grp Makes everyone in $arg1 hunt
CreatureGroupIdle obj_grp Makes everyone in $arg1 "idle"
CreatureHunt obj Makes $arg1 hunt
CreatureIdle obj Makes $arg1 idle
CurrentHealth obj Specifies $arg1's current health - returns integer
Damage obj,obj,int,int Damages $arg1 by $arg2 for $arg3 damage with $arg4-type damage
Delete obj Deletes $arg1
DeleteObjectTimer obj,flt Deletes $arg1 after $arg2 frames.
DestroyChat obj Destroys $arg1's chat bubble, if talking
DestroyEveryChat --- Destroys all chat bubbles
Distance flt,flt,flt,flt Checks the distance between coords. $arg1,$arg2 and $arg3,$arg4 - returns float
Drop obj,obj Forces $arg1 to drop $arg2 from inventory
Effect str,flt,flt,flt,flt Creates $arg1 effect using coords. $arg2,$arg3 and, if necessary, $arg4,$arg5; otherwise both are f0
Enchant obj,str,flt Enchants $arg1 with $arg2 for $arg3 seconds
EnchantOff obj,str Unenchants $arg1 of $arg2.
FloatToString flt Turns $arg1 into a string, then declares it.
Follow obj,obj Makes $arg1 follow $arg2*
FrameTimer int,int Calls $arg2 in $arg1 frames
Frozen obj,bool Freezes $arg1 in place if $arg2 is "true"
GetAnswer obj Checks the answer given to $arg1 in conversation; 0 = Goodbye, 1 = Yes, 2 = No - returns integer
GetCaller --- Retrieves the caller of a function - returns pointer
GetDirection obj Checks direction $arg1 is facing - returns byte
GetElevatorStatus obj Checks the status of $arg1 - returns integer
GetGold obj Checks $arg1's gold - returns integer
GetHost --- Retrieves the host - returns pointer
GetLastItem obj Retrieves the last item in $arg1's inventory - returns object
GetObjectX obj Checks $arg1's X coord. - returns float
GetObjectY obj Checks $arg1's Y coord. - returns float
GetPreviousItem obj Retrieves the item after $arg1 in an inventory - returns object*
GetQuestBoolStatus str Checks the state of $arg1 - returns boolean
GetQuestStatus str Checks the state of $arg1 - returns integer
GetScore obj Checks $arg1's score - returns integer
GetTrigger --- Retrieves the trigger of a function - returns pointer
GetWaypointX wayp Checks $arg1's X coord. - returns float
GetWaypointY wayp Checks $arg1's Y coord. - returns float
GiveXp obj,flt Gives $arg1 "$arg2" experience points; affects gold outcomes spawned with Create()
GoBackHome obj Sends $arg1 back to its creation point
GroupAggressionLevel obj_grp,flt Changes aggression level of $arg1
GroupAttack obj_grp,obj Makes everyone in $arg1 attack $arg2
GroupDamage obj_grp,obj,int,int Damages everyone in $arg1 by $arg2 for $arg3 damage with $arg4-type damage
GroupDelete grp Deletes everything in $arg1
GroupEnchant obj_grp,str,flt Enchants everyone in $arg1 with $arg2 for $arg3 seconds
GroupFollow obj_grp,obj Makes everyone in $arg1 follow $arg2
GroupHitFarLocation obj_grp,flt,flt Makes everyone in $arg1 use a ranged attack at coords. $arg2,$arg3
GroupHitLocation obj_grp,flt,flt Makes everyone in $arg1 use a melee attack at coords. $arg2,$arg3
GroupIdleLevel obj_grp,flt Makes everyone in $arg1 become "idle" when their health goes below the ratio "$arg2"
GroupLookAtDirection obj_grp,int Makes everyone in $arg1 look in the $arg2 direction*
GroupMove obj_grp,wayp Makes everyone in $arg1 move to $arg2
GroupPauseObject obj_grp,int Stops everyone in $arg1 from moving for $arg2 frames
GroupRunAway obj_grp,obj,int Makes everyone in $arg1 run away from $arg2 for $arg3 frames
GroupWander obj_grp Makes everyone in $arg1 wander aimlessly
HasEnchant obj,str Checks if $arg1 is enchanted with $arg2 - returns boolean
HasItem obj,obj Checks if $arg1 has the item designated by $arg2 - returns boolean
HitFarLocation obj,flt,flt Makes $arg1 use a ranged attack at coords. $arg2,$arg3
HitLocation obj,flt,flt Makes $arg1 use a melee attack at coords. $arg2,$arg3
IdleLevel obj,flt Makes $arg1 become "idle" when their health goes below the ratio "$arg2"
ImmediateBlind --- Blinds the host immediately
IntToString int Converts $arg1 into a string - returns string
IsCaller pointer Checks if $arg1 is the caller of the function - returns boolean
IsLocked obj Checks if $arg1 is locked - returns boolean
IsObjectOn obj Checks if $arg1 is "on" - returns boolean
IsOwnedBy obj,obj Checks if $arg1 is currently "owned" by $arg2 - returns boolean
IsSpotted obj,obj Checks if $arg1 is visible to $arg2 - returns boolean
IsTrigger pointer Checks if $arg1 is the trigger of the function - returns boolean
IsWaypointOn wayp Checks if $arg1 is "on" - returns boolean
JournalDelete obj,str Clears $arg1's journal of the entry "$arg2"*
JournalEdit obj,str,byte Modifies $arg1's journal entry "$arg2" to the state of $arg3*
JournalEntry obj,str,byte Adds to $arg1's journal the entry "$arg2" in the state of $arg3*
LockDoor obj Locks $arg1 with a mechanism
LookAtDirection obj,int Makes $arg1 look in the $arg2 direction*
LookAtObject obj,obj Makes $arg1 look at $arg2
LookWithAngle obj,byte Makes $arg1 look in the $arg2 direction*
MakeEnemy obj Makes $arg1 hostile to every player and their teams
MakeFriendly obj Makes $arg1 friendly to host and his team; if host changes team, unit will change team too
MaxHealth obj Specifies $arg1's max health - returns integer
Move obj,wayp Makes $arg1 move to $arg2
MoveObject obj,flt,flt Instantly moves $arg1 to coords. $arg2,$arg3
MoveWaypoint wayp,flt,flt Instantly moves $arg1 to coords. $arg2,$arg3
Music byte,int Plays music number $arg1 at the volume of $arg2
Object str Retrieves the object with script name "$arg1" - returns object
ObjectGroup str Retrieves the object group with the name "$arg1" - returns object group
ObjectGroupOff obj_grp Disables all objects in $arg1
ObjectGroupOn obj_grp Enables all objects in $arg1
ObjectGroupToggle obj_grp Toggles each object in $arg1 seperately
ObjectOff obj Turns $arg1 "off"
ObjectOn obj Turns $arg1 "on"
ObjectToggle obj Toggles $arg1 between "on" and "off"
PauseObject obj,int Stops $arg1 from moving for $arg2 frames
Pickup obj,obj Makes $arg1 pick up $arg2
Print str Prints "$arg1" onto the caller of the function's screen
PrintToAll str Prints "$arg1" onto everyone's screens
PushObject obj,flt,flt,flt Pushes $arg1 with $arg2 amount of force from coords. $arg3,$arg4
Raise obj,flt Raises $arg1 $arg2 pixels from the ground
RaiseZombie obj Reanimates $arg1 if it is a zombie and lying on the ground
Random int,int Produces a number between $arg1 and $arg2 - returns integer
RandomFloat flt,flt Produces a number between $arg1 and $arg2 - returns float
RestoreHealth obj,int Restores $arg1's health for $arg2 damage
RunAway obj,obj,int Makes $arg1 run away from $arg2 for $arg3 frames
SecondTimer int,int Calls $arg2 in $arg1 seconds
SetDialog obj,str,int,int Makes $arg1 conversible; uses $arg2 conversation when using tell story; initiate script is $arg3, exit script is $arg4*
SetGroupOwner obj,obj_grp Makes $arg1 "own" $arg2
SetGuardSpot obj,flt,flt,flt,flt,flt Makes $arg1 guard at coords. $arg2,$arg3 while looking at coords. $arg4,$arg5; will attack any enemy in range of $arg6
SetOwner obj,obj Makes $arg1 "own" $arg2
SetPathFlag obj,byte Causes $arg1 to use path flag $arg2
SetProperty obj,int,int Calls $arg3 when $arg1 is in state $arg2*
SetQuestBoolStatus bool,str Sets $arg2 in the state of $arg1*
SetQuestStatus int,str Sets $arg2 in the state of $arg1*
StoryPic obj,str Sets $arg1's portrait to $arg2 when being talked to
TellStory str,str Tells the story $arg2 in conversation*
TrapSpells obj,str,str,str Sets $arg1 to use spells $arg2, $arg3, and $arg4, if it is a bomber; unused spaces are marked with "NULL"
UnBlind --- Unblinds the host
UnlockDoor obj Unlocks $arg1
Walk obj,flt,flt Makes $arg1 walk to coords. $arg2,$arg3
Wall int,int Retrieves the wall at wall coords. $arg1,$arg2 - returns wall
WallBreak wall Breaks $arg1; the wall must be breakable
WallClose wall Closes $arg1
WallGroup wall_grp Declares the wall group with the name "$arg1" - returns wall group
WallGroupBreak wall_grp Breaks $arg1, if walls are breakable
WallGroupClose wall_grp Closes all walls in $arg1
WallGroupOpen wall_grp Opens all walls in $arg1
WallGroupToggle wall_grp Toggles the walls in $arg1 between "open" and "closed"
WallOpen wall Opens $arg1
WallToggle wall Toggles $arg1 between opened and closed
Wander obj Makes $arg1 wander aimlessly
Waypoint str Retrieves the waypoint with script name "$arg1" - returns waypoint
WaypointGroup str Retrieves the waypoint group with the name "$arg1" - returns waypoint group
WaypointGroupOff wayp_grp Turns all waypoints in $arg1 "off"
WaypointGroupOn wayp_grp Turns all waypoints in $arg1 "on"
WaypointGroupToggle wayp_grp Toggles all waypoints in $arg1 between "on" and "off"
WaypointOff wayp Turns $arg1 "off"
WaypointOn wayp Turns $arg1 "on"
WaypointToggle wayp Toggles $arg1 between "on" and "off"
ZombieStayDown obj Makes $arg1 never get up, if it is a zombie

    • -

Unknown Commands[]

This is where all of the unknown commands will be listed.

Command Suspected Format Suspected Use/Notes
Unknown1f ??
Unknown20 ??
Unknown2e ??,??,?? Is beside "Random"; Possibly similar function
Unknown35 ??,??,??
Unknown36 ??,??,??
Unknown38 ??,?? Is beside "AwardSpell" and "Enchant"; may be AwardAbility?..
Unknown41 ?? Surrounded by basic pointers
Unknown4c ?? Inbetween item-related commands
Unknown50 ---
Unknown58 ??,?? Unknown58 - Unknown5f are unclassified; likely related
Unknown59 ??,??
Unknown5a ??,??
Unknwon5b ??,??
Unknown5c ??,??
Unknwon5d ??,??
Unknown5e ??
Unknown5f ??
Unknown67 ??,?? Unknown67 + 68 are adjacent to SetGroupOwner and IsOwnedBy
Unknown68 ??,??
Unknown6b ??,?? Unknown6b + 6c are adjacent to AreOwnedBy and ClearOwner
Unknown6c ??,??
Unknown72 ??,??,?? Is beside group pointers and "ChatTimer"
Unknown74 ??,?? Is surrounded by chat commands
Unknowna2 ??,?? a2 + a3 are beside "IdleLevel" and "RunAway"; possibly related
Unknowna3 ??,??
Unknownb8 ??
Unknownb9 ??
Unknownc1 ---
Unknownc4 ---
Unknownc5 ??
Unknownca --- Commits current game music.
Unknowncb --- Sets up a game music that previously commited using Unknownca().
Unknowncc --- Apparent music function
Unknowncd ??
Unknownce ??


This is where step-by-step tutorials on how to accomplish a certain function will be listed.

Simple Functions[]

Simple tasks go here.

Intermediate Functions[]

Tasks requiring and providing greater understanding go here.

Setting Dialogue for NPC's and Other Things[]

Getting an NPC to talk is more complicated than it should be, since it requires multiple functions just to get one person to speak. It isn't difficult to do, but it can be intimidating if one doesn't understand how to use the commands properly.
Now, assuming you want an NPC to be able to talk at the very moment your map starts, you should start by creating a function that will ready all dialogues when called, then calling the function from MapInitialize. You can also set the dialogues directly from MapInitialize, but that leads to a messier script.
Example: Function 2 - MapInitialize

[Some stuff that's important]
call SetAllDialogs
Before going on, I recommend creating two more functions. One will be for the conversation start, and the other will be the conversation end.
Now, in the new function, put in the command "SetDialog(object,string,byte,byte)". This command makes talking to an object possible. The first field is the script name of the NPC who will be speaking. The second is the type of conversation they will have; it can be set to "NORMAL", "YESNO", or "NEXT". (If the NPC is just going to chat normally, pick "NORMAL".) The third is the script number that will be run when their conversation starts, and the fourth is that which is run when their conversation ends.
Another command that fits in this script is "StoryPic(object,string)". Again, the first field is the NPC talking. The second one is the picture used when speaking to them. If this command is not put in, the speaker will always be a bartender. If the NPC is to chat normally, this command has no use.
Keep in mind that you'll need to put these commands in for each NPC that will talk.
Example: Function 3 - StartTalking

Next, in the conversation start function (that I assume you already created), you will put in one of two things: "TellStory(string,string)" or "Chat(object,string)".
The Chat command is easy to use; it makes the NPC say something in a speech bubble. The first field represents the object talking, and the second is what they will say.
The TellStory command is more complicated. The first field's use is unknown, but it's safe to just put in "SwordsmanHurt". The second field is what they will talk about. It's probably a good idea to use an existing conversation and not a custom one, as any custom string will be cut short at 32 characters. Existing conversations can be found by looking through the original maps.
Example: Function 4 - Dude1Start

Chat(Gvar4,"So hau abaut them urchens, ehh?")
The conversation end script requires little substance most of the time. In fact, you may not need to put anything in except for "return". Well, unless SetDialog had a "YESNO" type conversation.
To make "YESNO" conversations work, and to make different choices lead to different consequences, you will need to use "GetAnswer(object)", which designates a variable to a byte. The only field actually represents the NPC receiving your answer, not the player. The result depends on what your answer was to the "YESNO" question given to you; it is 0 if you pick "Goodbye", 1 if you pick "Yes", and 2 if you pick "No". This can be used to make different things happen for different answers.
Example: Function 5 - Dude1End

[For a "NORMAL" conversation]

[For a "YESNO" conversation]
var0 = GetAnswer(Gvar4)
if var0 == 0 jump 10
if var0 == 1 jump 20
if var0 == 2 jump 40
These are the basics for preparing dialogue for NPC's (and other things).

Advanced Functions[]

Very complicated tasks go here.

Tips and Tricks[]

Fixing the Waypoints[]

Since the latest version of the NoX Map Editor is missing the ability to turn waypoints on, in order to make them work, you must create a function that will enable them. So, here's a little bit of a walkthrough to get your map working like it should.

  1. The first step is to put every waypoint into a group. First, list every waypoint number on Notepad or a piece of paper or whatever.
  2. On the top, click Map, then Groups. A dialogue box will pop up.
  3. In the very top field, put in a name for this group. Then, click the bubble labeled Waypoints. (It must be done in this order.)
  4. Copy your list into the large box. Make sure you press Enter for every number. Make sure there are no ancillary characters (such as commas).
  5. Click Save. If done correctly, you will not get an error upon doing so. Click Close.
  6. Now that we have created a group containing every waypoint, it is time to conduct a script to activate it. Click Map, then Scripts. Another dialogue box will pop up.
  7. Under Functions, double-click on MapInitialize. There should be a command called return, but there may be other functions as well.
  8. Above the return command, put in the following function: WaypointGroupOn(WaypointGroup("TheWaypoints")) , though replace the string in quotations with what you called your waypoint group. (Don't get rid of the quotations!)
  9. If done correctly, double-clicking MapInitialize again will cause no change in the script at all. Click OK.
  10. Now, save your map and enjoy having working waypoints!

You can also download the old editor. See