- 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.
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:
- They are made to persisted nodes on an Area Server, while the developer who is typing the command is in an edit instance of that Area Server
- They are made to persisted nodes which are associated to a character in an area.
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).
|(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.|
||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 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 fall into five major categories:
- Creation commands - these will create nodes, prototypes, associations, and also definitions for fields and enum types
- Deletion commands - for deleting nodes, prototypes, classes, associations, and definitions
- Modification commands - for modifying nodes, prototypes, and definitions
- Show commands - these will display data for a specific definition of a node, prototype, or class
- Query commands - these will list currently created nodes, prototypes, associations, and miscellaneous definitions
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.
|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|| |
|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> ...
- Commands are case-insensitve
- Commas are not required to separate parameters; white space can be used.
- The semicolon is required to separate the required arguments from the optional arguments.
- For Boolean arguments, either the syntax +arg, -arg, or the syntax arg=true, arg=false may be used.
- Named optional parameters may be mixed in with the unnamed optional parameters in any order.
- A double quote (") starts and ends a single value; for example,
arg="this is the value", will use the entire quoted string as its value. This can be useful when white space is needed inside the arguments value.
- If you enter a command with invalid arguments, it will print a warning about unused arguments and the command will not be executed.
- If you are lacking required arguments, a warning will be printed and the command will not be executed.
- The semicolon that marks the end of the required arguments is optional if there are no optional arguments on the command line.
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.
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.