Javascript

Overview
If you've become accustom to using the Warlock Scripting Language, but want more power, then Javascript is the way to go. It has all the features of a object-oriented scripting language, and provides all the same functionality that a standard script offers as well, making it a very powerful (and superior) alternative.

Javascript Tutorials
If you're unfamiliar with Javascript, and would like a general tutorial (not Warlock-oriented), we recommend any of the following links:
 * W3Schools Javascript Tutorial
 * Javascript Crash Course

Note that some of these tutorials are browser-based, but the language basics are all the same.

WSL Primer
It would be best to understand all of the concepts in the Warlock Scripting Language if you want to understand all that's available to you in Javascript, as some of the more advanced concepts (match/matchWait, actions) are also available in Javascript.

Javascript API
Warlock pre-defines several special variables and lists that are usable by your script for retrieving data from the game, performing game-related functions, and other misc. utilities.

The "arguments" array
Arguments passed to your script via the entry in Warlock are put into this array. It is a basic Javascript array, so you can loop through it and access it like a normal array, i.e.: for (i in arguments) { if (arguments[i] == "-help") { printHelp; } }

The "script" object
The script object is basically a 1-to-1 mapping of functions from the Warlock Scripting Language. In general, the syntax is exactly what you would expect. For example, in WSL you might have the following script: put prep spell 10 waitfor You are fully prepared put cast

pause 5 echo Spell has been cast!

Which would map to the following Javascript: script.put("prep spell 10"); script.waitFor("You are fully prepared"); script.put("cast");

script.pause(5); script.echo("Spell has been cast!");

Basic Command Table
This table shows the mapping from a 1 line WSL example to a Javascript example

Actions and Matches
The biggest difference in the Javascript interace is the way that actions and match/matchWait are performed. The basic execution/flow is similar, but in Javascript we use function objects rather than labels, and a match array for match/matchWait. Let's first take a look at an example matchWait

match Locked mind lock match NotLocked Overall state of mind: clear put exp primary matchwait

Locked: # do something

NotLocked: # do something else

In this script, we are telling Warlock to wait for a match from a list of 2 possible text matches, and when that match happens, to jump to the specified label. In Javascript, we create a match array, where each match is associated with a function instead of a label, and pass that to matchWait. The above script would look like this in Javascript: function locked { // do something }

function notLocked { // do something else }

var matches = new MatchList; // starts recording text to be compared at matchWait matches.match("mind lock", locked); matches.match("Overall state of mind: clear", notLocked); script.put("exp primary"); matches.matchWait;

or

var matches = new MatchList; // starts recording text to be compared at matchWait var locked = matches.match("mind lock"); var notLocked = matches.match("Overall state of mind: clear"); script.put("exp primary"); var match = matches.matchWait;

if(match == locked) { // do something } else if(match == notLocked) { // do something else }

In addition to match is matchRe which compiles the given text as a Regular Expression. The function passed to matchRe should have an argument that stores the matches from the regex.
 * matchRe(regex, function)
 * regex: a regular expression in string form
 * matchRe(regex, ignoreCase, function) - Not implemented
 * ignoreCase: true/false. whether or not to ignore case when matching text against the regular expression (default: false)

ex. function mindState(groups) { script.echo("State of mind is " + groups[1]); } var matches = new MatchList; matches.matchRe("Overall state of mind: (\\w+)", mindState); script.put("exp"); matches.matchWait;

If you need to reuse a MatchList object, the method restart is available to restart recording. Also match, matchRe, and matchWait will restart recording if it isn't recording already.

If you need to pass some arguments to your function, you can use an anonymous function to call your function.

function talk(person, message) { script.put("'}" + person + " " + message); }

matches = new MatchList; matches.match("Eanur just arrived", new Function { talk("Eanur", "Nice boots."); }); matches.matchWait;

An action in Javascript looks the same as a match, but due to the nature, a matchWait is not required (since it is more of an event-based API). In WSL you might have the following code: action goto ReadPaths when Obvious paths:

ReadPaths:
 * 1) executed when the game receives "Obvious paths" like a match

Which, when translated to Javascript would look like: function readPaths { // executed when the game receives "Obvious paths" like a match }

script.addAction(readPaths, "Obvious paths:");

In WSL, you also have the ability to read regex match-groups from Actions via the $1-$9 special variables. An example snippet from WSL below: action goto MovedRoom when Obvious paths: (.+). move north

MovedRoom: setvariable paths $1 # $0 == Obvious paths: northwest. # $1 == northwest echo paths = %paths

Instead of using special variables, we pass in all match groups as arguments to your action function. The first argument is always the "entire" match (also known as regex group 0), then every argument after that is a group matching from your regex. The above script would translate to:

function movedRoom (text, paths) { // text == Obvious paths: northwest. // path == northwest script.echo("paths = " + paths); }

script.addAction(movedRoom, "Obvious paths: (.+)."); script.move("north");

Include
Including another JS script into your initial script is possible using the built in include function. // Include ranged.js include("ranged.js");

Timer
WSL has the command TIMER to keep track of elapsed time. JS has script.setInterval(command, period) and script.setTimeout(command, delay). They have the same semantics as the typical usage as in.

Special Variables
This is a table of all the other special variables provided by Warlock, and an explanation of each variable's value.