Jump to: navigation, search
This page is about Command Line Interface commands, which are typed into the Console Panel, along with prefixes which route them to the appropriate database. For commands which are typed into the Console Panel without prefixes, see Client Console Commands. For commands which are typed into the Chat Panel (which trigger server-side scripts) see Chat Commands.

CLI commands (standing for Command Line Interface or Command Line Interpreter) are commands which are typed into the blue input box at the bottom of the HeroBlade Console Panel (not to be confused with the Chat Panel).



Dozens of different CLI commands can be typed into the HeroBlade Console Panel. These commands are generally used to view or modify the DOM definitions or GOM data. CLI commands may be routed to one of several different locations depending on the command's prefix.

Affected databases

There are two GOM/DOM databases: One on the server side, and one on the client side. Processes on either side each have a portion of their respective database loaded. Changes made to a process's data must be done carefully, as depending on which process the change is made in, the change may or may not be propagated to other processes, and may or may not be persisted (permanent).


On the server side, GOM/DOM data is maintained in:

Making a change to the DOM definitions in any of the server processes, is permanent, and will automatically be propagated to all of the other server processes (but not to the client processes).

Making a change to the GOM data in any of the server processes, takes effect only in that specific process. Further, changes may or may not be persisted (permanent), depending on the type of data being modified. Changes made to non-persisted nodes will be temporary only. Changes made to persisted nodes will be permanent if:


On the client side, GOM/DOM data is maintained in:

Changes to the DOM/GOM data in the HeroBlade client are never propagated to the Client HeroScript Compiler Server's DOM.

The Client HeroScript Compiler Server GOM does not contain any nodes, but making a change to the DOM definitions in the Client HeroScript Compiler Server, is always propagated to the client (within a fraction of a second).

CLI prefixes

Console inputbox.png
When a command is typed into the Console Window, it is first processed by the default HeroBlade interpreter that runs on the client. This interpreter decides whether it is going to deal with the command itself, or send it on to a different process or interpreter on one of the servers. If the command has a specific prefix, such as a slash (/) or dash (-), this is an instruction which tells the default client interpreter where to send the command.
Prefix Prefix Name Client/Server DOM/GOM Destination Description
(nothing)   n/a n/a The default HeroBlade Client interpreter No matter what is typed into the input box, and no matter which prefix it has (or if it has a prefix at all), this default interpreter is always the first thing to deal with it. This interpreter resides on the Client, and reads any input that is typed into the Console Panel input box. It then routes commands to the proper destination depending on their prefix, or, if there's no prefix, runs certain commands directly on the client. See Console Commands for more information.
/ (forward slash) Client GOM The client CLI interpreter Commands sent to this interpreter will modify nodes in the client's own version of the GOM - Note that these changes will not be persisted, and are only temporary. It is also worth noting that this slash character has nothing to do with the prefix slash that is used for GMCommands typed into the chat window, which has an entirely different purpose.
| (pipe) Client DOM The Client HeroScript Compiler Server Commands sent to this location make changes to the DOM definitions on this server. This server is the authoritative source for all client-side DOM definitions information, as well as handling client-side scripts.
\ (back slash) Server (Area) Either The Area Server CLI interpreter Commands to this interpreter are for modifying definitions in the Area Server's DOM or GOM. DOM definition changes will always be permanent. Changes to GOM data will be permanent if they are made to a persisted node.
- (hyphen) Server (World) Either The World Server CLI Interpreter For making changes to the World Server DOM definitions and GOM data. Note that changes made to nodes will only be permanent if they are persisted nodes, otherwise they will be temporary. See GOM and Node Persistence for more information.
HSCS   Server (Area) DOM The HeroScript Compiler Server For most cases, this is the same as using the backslash to manipulate the server side DOM. The notable exception is the special compile server commands. When using this command, follow it with a space, for example, "hscs qfd"


The CLI interpreters allow for the creation, modification, display, and deletion of DOM (Data Object Model) data types and GOM (Game Object Model) data (Nodes).

The DOM is where classes and fields are created and defined. There are multiple copies of the DOM at any one time, but in general, any modification of DOM data on one server, will then be propagated throughout all of the other locations.

The CLI interpreters can also be used to make changes to GOM (Game Object Model) data, such as to create nodes or prototypes based on the definitions of the DOM. The GOM data is divided up into various hierarchical sections, and a different section is loaded into each server as appropriate. For example, there could be a section of GOM data for the World Server, another for Area Server 1, another for Area Server 2, and so forth. Each section of GOM data is mutually exclusive -- there is no overlap of GOM data between Area Server 1 and Area Server 2.

When DOM data is modified, it is modified on all servers simultaneously, via the DOM Coordination Process, which handles changes by putting each server into a "wait state" while its data is being updated.

When GOM data is modified, it is modified only in the "in-memory" version of it on its specific server. Some GOM changes may be temporary (non-persistent), in which case they are never saved beyond the "in-memory" version. Some GOM changes are permanent (persistent), which means that they are actually saved to the database.

The primary Server GOM database is accessed by all of the servers, and can be modified by commands from any Area Server, World Server, or the HeroScript Compiler Server; however each server can only generate commands which affect its portion of the database. For example, if it is desired to change some data in Area Server 2, from Area Server 1, this can only be done by generating a RemoteCall from Area Server 1 to Area Server 2, instructing Area Server 2 to change its own portion of the database.

CLI Commands

CLI Commands fall into five major categories:

Nodes and Classes

Each node is defined by a certain class. Each class is defined by one of a set of approved Archetypes, and then has associated fields which contain different types of data depending on the field's datatype.

For more information, please see the section on Nodes and Classes.

The CLI Commands

Be sure to preface all of the following with the appropriate character to specify which process that the command should go to.

Important: If changes are made on the client (/-prefix), they are not persistent, and will disappear the next time that the client is rebooted. To make a DOM change persistent in the client database, it must be made on the Client HeroScript Compiler Server (|-prefix). See CLI prefixes for a complete list of the processes which can have their data modified via CLI commands.

Command Name Syntax
CNFC Create Node From Class CNFC <class> ; [+/-persistent]
CNFP Create Node From Prototype CNFP <prototype> ; [+/-persistent]
CNFN Create Node From Node CNFN <node id>; [+/-persistent]
CPFC Create Prototype From Class CPFC <class>, <prototype name>; description=<prototype description>
CPFN Create Prototype From Node This command has been deprecated and is no longer implemented CPFN <node id>, <prototype name>; description=<prototype description>
CCD Create Class Definition CCD <class name>, <archetype>; description=<class description> (<optional class identifier>)n (<optional field identifier>)n
CED Create Enum Definition CED <enum name>; description=<enum description> (<enum value>)n
CFD Create Field Definition CFD <field_name>, <fieldtype>; [description=<field description>] [+/-reflect] [writestrategy=<write strategy>] [watchingscript=<watching script name>] [+/-private] package=<distribution package>
CAD Create Association Definition CAD <association name>; description=<association description> +/-uniqueSource +/-uniqueTarget +/-hard associationgroup=<association group identifier>
CAG Create Association Group CAG <association group name>; description=<association group description> +/-exclusive
CA Create Association CA <source id>, <association type identifier>, <target id>;
CKD Create Keyword Definition CKD <name>; description=<keyword description> package=<distribution package>
DN Delete Node DN <node id>;
DP Delete Prototype DP <prototype identifier>;
DCD Delete Class Definition DCD <class identifier>;
DED Delete Enum Definition DED <enum identifier>;
DFD Delete Field Definition DFD <field identifier>;
DAD Delete Association Definition DAD <association type identifier>;
DAG Delete Association Group DAG <association group identifier>;
DA Delete Association DA <source id>, <association type identifier>, <target id>; qvalue=<value>
DAS Delete Associations of Source DAS <source id>;
DKD Delete Keyword Definition DKD <keyword id>;
AREADEL Delete Area AREADEL <area name>
DSD Delete Script Definition DSD <script identifier>
USD Undelete Script Definition USD <script identifier>
MN Modify Node MN <node id>; (<field variable specifier>=<value>)n
MNAC Modify Node Add Classes MNAC <node id>, <class identifier>;
MNRC Modify Node Remove Class MNRC <node id>, <class identifier>;
MLN Modify List Node MLN <node id> <field variable specifier>; <edit type> <arguments>
MP Modify Prototype MP <prototype identifier>; (<field variable specifier>=<value>)n
MPAC Modify Prototype Add Class MPAC <prototype identifier>, <name of class to add>;
MPRC Modify Prototype Remove Class MPRC <prototype identifier>, <name of class to remove>;
MPN Modify Prototype Name MPN <prototype identifier>, <new name>
MPD Modify Prototype Description MPD <prototype identifier>, <new description>
MPP Modify Prototype Distribution Package MPP <prototype identifier>, <new distribution package>
MLP Modify List Prototype MLP <prototype identifier> <field variable specifier>; <edit type> <arguments>
MCD Modify Class Definition MCD <class identifier>; name=<new name> description=<new description> package=<new distribution package>
MCDAF Modify Class Definition Add Fields MCDAF <class identifier>; (<field identifier>)n
MCDRF Modify Class Definition Remove Field MCDRF <class identifier>, <field identifier>;
MCDAP Modify Class Definition Add Parents MCDAP <class identifier>; (<class identifier>)n
MCDRP Modify Class Definition Remove Parent MCDRP <class identifier>, <class identifier>;
MCDRAF Modify Class Definition Replication Add Field MCDRAF <class identifier>; (<field identifier>)n
MCDRRF Modify Class Definition Replication Remove Field MCDRRF <class identifier>, <field identifier>;
MCDAA Modify Class Definition Replication Add Atomic Set MCDAA <class identifier>; (<field identifier>)n
MCDRA Modify Class Definition Replication Remove Atomic Set MCDRA <class identifier>, (<field identifier>)n
MCDSP Modify Class Definition Swap Parents MCDSP <class identifier>; (<class identifier>)n
MED Modify Enum Definition MED <enum identifier>; name=<new name> description=<new description> package=<new distribution package>
MEDAV Modify Enum Definition Add Value MEDAV <enum identifier>; (<enum value>)n
MEDRV Modify Enum Definition Remove Value MEDRV <enum identifier>, <enum value>;
MEDCV Modify Enum Definition Change Value MEDCV <enum identifier>, <old enum value>, <new enum value>;
MFD Modify Field Definition MFD <field identifier>; name=<new name> description=<new description> +/-reflect writestrategy=<write strategy name> +/-private watchingscript=<new watching script> package=<new distribution package> +/-discrete +/-changecallback +/-reversereplicate initialpriority=<replication initial priority> deltaPriority=<replication priority change per second> lifetime=<milliseconds to try to replicate> distancefactor=<priority influence of distance> destinationfield=<server field to receive replication> destinationfieldclient=<client field to receive replication>
MFDT Modify Field Definition Type MFDT <field identifier>, <fieldtype>;
MAD Modify Association Definition MAD <association type identifier>; name=<new name> description=<new description> package=<new distribution package>
MAG Modify Association Group MAG <association group identifier>; name=<new name> description=<new description> +/-exclusive package=<new distribution package>
MSD Modify Script Definition MSD <script identifier>; name=<new name> package=<new distribution package>
OSD Modify Script Definition Set Owner OSD <script identifier>, <new owner>
TSD Modify Script Definition Set Team TSD <script identifier>, <new team>
MKD Modify Keyword Definition MKD <keyword identifier>;name=<new name> description=<new description> package=<new distribution package>
SN Show Node SN <node id>;
SP Show Prototype SP <prototype identifier>;
SCD Show Class Definition SCD <class identifier>;
SED Show Enum Definition SED <enum identifier>;
SFD Show Field Definition SFD <field identifier>;
SAD Show Association Definition SAD <association type identifier>;
SAG Show Association Group SAG <association group identifier>;
SKD Show Keyword Definition SKD <keyword definition>;
QN Query Nodes List all nodes
QNDB Query Database Nodes List all nodes in the Javelin database
QP Query Prototypes List all prototypes
QCD Query Class Definitions List all classes
QFD Query Field Definitions List all fields
QED Query Enum Definitions List all enums
QAG Query Association Groups List all association groups
QAD Query Association Definitions List all association types
QA Query Associations QA <source id>, <association type identifier>, <target id>; qvalue=<value> comparisonoperator=<operator>
WHATIS What is something Gives information about something.
ISKINDOF Is Class a kind (child) of Parent Class ISKINDOF <class>, <possible parent class>;
WHEREUSED Where is something used Displays where something is being used.
WHERENOTUSED Where are instances of a type not used Displays all instances of a definition type that are not being used.
HELP Help Command HELP [<command>] (or ? <command>)
LCN Load all nodes based on a given class LCN <base class identifier>;
LNTA Load a node and all of its ancestors LNTA <node id>;

CLI Command Syntax

Basic syntax for a command is as follows:

<command name> <required parameter1>, <required parameter2>, ...; <optional unnamed parameter1> <optional unnamed paramter2> ... <optional parameter name1>=<optional parameter value1> ...

Definition Name Requirements

See the section on Definition Names


Both the numerical ID of a definition and its name can be used as an identifier. For Nodes, which have no names, only the ID number is a valid way of referencing a Node.

Example Usage

For an example of how the above commands could be used to create fields, a class, and then a node, please see the section on Node Creation.

Additional information

Personal tools