Default Command Help

``_

This page is auto-generated. Do not modify - your changes will be lost. Report problems to the `issue tracker`_.
The full set of default Evennia commands currently contains 92 commands in 9 source
files. Our policy for adding default commands is outlined here. More
information about how commands work can be found in the documentation for Commands.

A-Z

  • ```__unloggedin_look_command```_ - look when in unlogged-in state
  • about - show Evennia info
  • access - show your current game access
  • addcom - add a channel alias and/or subscribe to a channel
  • alias - adding permanent aliases for object
  • allcom - perform admin operations on all channels
  • ban - ban an account from the server
  • batchcode - build from batch-code file
  • batchcommands - build from batch-command file
  • boot - kick an account from the server.
  • cboot - kick an account from a channel you control
  • ccreate - create a new channel
  • cdesc - describe a channel you control
  • cdestroy - destroy a channel you created
  • cemit - send an admin message to a channel you control
  • channels - list all channels available to you
  • charcreate - create a new character
  • chardelete - delete a character - this cannot be undone!
  • clock - change channel locks of a channel you control
  • cmdsets - list command sets defined on an object
  • color - testing which colors your client support
  • command - This is a parent class for some of the defining objmanip commands
  • connect - connect to the game
  • copy - copy an object and its properties
  • cpattr - copy attributes between objects
  • create - create a new account account
  • create - create new objects
  • cwho - show who is listening to a channel
  • delcom - remove a channel alias and/or unsubscribe from channel
  • desc - describe an object or the current room.
  • destroy - permanently delete objects
  • dig - build new rooms and connect them to the current location
  • drop - drop something
  • emit - admin command for emitting message to multiple objects
  • examine - get detailed information about an object
  • find - search the database for objects
  • force - forces an object to execute a command
  • get - pick up something
  • give - give away something to someone
  • help - get help when in unconnected-in state
  • help - View help or a list of topics
  • home - move to your character’s home location
  • ic - control an object you have permission to puppet
  • inventory - view inventory
  • irc2chan - Link an evennia channel to an external IRC channel
  • link - link existing rooms together with exits
  • lock - assign a lock definition to an object
  • look - look at location or object
  • look - look while out-of-character
  • mvattr - move attributes between objects
  • name - change the name and/or aliases of an object
  • nick - define a personal alias/nick by defining a string to
  • objects - statistics on objects in the database
  • ooc - stop puppeting and go ooc
  • open - open a new exit from the current room
  • option - Set an account option
  • page - send a private message to another account
  • password - change your password
  • perm - set the permissions of an account/object
  • pose - strike a pose
  • py - execute a snippet of python code
  • quell - use character’s permissions instead of account’s
  • quit - quit when in unlogged-in state
  • quit - quit the game
  • reload - reload the server
  • reset - reset and reboot the server
  • rss2chan - link an evennia channel to an external RSS feed
  • say - speak as your character
  • script - attach a script to an object
  • scripts - list and manage all running scripts
  • server - show server load and memory statistics
  • service - manage system services
  • sessions - check your connected session(s)
  • set - set attribute on an object or account
  • setdesc - describe yourself
  • sethelp - Edit the help database.
  • sethome - set an object’s home location
  • shutdown - stop the server completely
  • spawn - spawn objects from prototype
  • style - In-game style options
  • tag - handles the tags of an object
  • tel - teleport object to another location
  • time - show server time statistics
  • tunnel - create new rooms in cardinal directions only
  • typeclass - set or change an object’s typeclass
  • unban - remove a ban from an account
  • unlink - remove exit-connections between rooms
  • userpassword - change the password of an account
  • wall - make an announcement to all
  • whisper - Speak privately as your character to another
  • who - list who is currently online
  • wipe - clear all attributes from an object

Command details

These are generated from the auto-documentation and are ordered by their source file location in

account.py

View account.py source

charcreate (CmdCharCreate)

create a new character

Usage:
  charcreate <charname> [= desc]

Create a new character, optionally giving it a description. You
may use upper-case letters in the name - you will nevertheless
always be able to access your character using lower-case letters
if you want.
  • key: charcreate
  • aliases:
  • `locks`_: “cmd:pperm(Player)”
  • ```help_category```_: “General”
  • Source: class CmdCharCreate in account.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

chardelete (CmdCharDelete)

delete a character - this cannot be undone!

Usage:
    chardelete <charname>

Permanently deletes one of your characters.
  • key: chardelete
  • aliases:
  • `locks`_: “cmd:pperm(Player)”
  • ```help_category```_: “General”
  • Source: class CmdCharDelete in account.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

color (CmdColorTest)

testing which colors your client support

Usage:
  color ansi||xterm256

Prints a color map along with in-mud color codes to use to produce
them.  It also tests what is supported in your client. Choices are
16-color ansi (supported in most muds) or the 256-color xterm256
standard. No checking is done to determine your client supports
color - if not you will see rubbish appear.
  • key: color
  • aliases:
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdColorTest in account.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

ic (CmdIC)

control an object you have permission to puppet

Usage:
  ic <character>

Go in-character (IC) as a given Character.

This will attempt to "become" a different object assuming you have
the right to do so. Note that it's the ACCOUNT character that puppets
characters/objects and which needs to have the correct permission!

You cannot become an object that is already controlled by another
account. In principle <character> can be any in-game object as long
as you the account have access right to puppet it.
  • key: ic
  • aliases: puppet
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdIC in account.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

look (CmdOOCLook)

look while out-of-character

Usage:
  look

Look in the ooc state.
  • key: look
  • aliases: l, ls
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdOOCLook in account.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

ooc (CmdOOC)

stop puppeting and go ooc

Usage:
  ooc

Go out-of-character (OOC).

This will leave your current character and put you in a incorporeal OOC state.
  • key: ooc
  • aliases: unpuppet
  • `locks`_: “cmd:pperm(Player)”
  • ```help_category```_: “General”
  • Source: class CmdOOC in account.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

option (CmdOption)

Set an account option

Usage:
  option[/save] [name = value]

Switches:
  save - Save the current option settings for future logins.
  clear - Clear the saved options.

This command allows for viewing and setting client interface
settings. Note that saved options may not be able to be used if
later connecting with a client with different capabilities.
  • key: option
  • aliases: options
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdOption in account.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

password (CmdPassword)

change your password

Usage:
  password <old password> = <new password>

Changes your password. Make sure to pick a safe one.
  • key: password
  • aliases:
  • `locks`_: “cmd:pperm(Player)”
  • ```help_category```_: “General”
  • Source: class CmdPassword in account.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

quell (CmdQuell)

use character's permissions instead of account's

Usage:
  quell
  unquell

Normally the permission level of the Account is used when puppeting a
Character/Object to determine access. This command will switch the lock
system to make use of the puppeted Object's permissions instead. This is
useful mainly for testing.
Hierarchical permission quelling only work downwards, thus an Account cannot
use a higher-permission Character to escalate their permission level.
Use the unquell command to revert back to normal operation.
  • key: quell
  • aliases: unquell
  • `locks`_: “cmd:pperm(Player)”
  • ```help_category```_: “General”
  • Source: class CmdQuell in account.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

quit (CmdQuit)

quit the game

Usage:
  quit

Switch:
  all - disconnect all connected sessions

Gracefully disconnect your current session from the
game. Use the /all switch to disconnect from all sessions.
  • key: quit
  • aliases:
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdQuit in account.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

sessions (CmdSessions)

check your connected session(s)

Usage:
  sessions

Lists the sessions currently connected to your account.
  • key: sessions
  • aliases:
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdSessions in account.py. Belongs to command set ‘DefaultSession’ of class SessionCmdSet in cmdset_session.py.

style (CmdStyle)

In-game style options

Usage:
  style
  style <option> = <value>

Configure stylings for in-game display elements like table borders, help
entriest etc. Use without arguments to see all available options.
  • key: style
  • aliases:
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdStyle in account.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

who (CmdWho)

list who is currently online

Usage:
  who
  doing

Shows who is currently online. Doing is an alias that limits info
also for those with all permissions.
  • key: who
  • aliases: doing
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdWho in account.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

admin.py

View admin.py source

ban (CmdBan)

ban an account from the server

Usage:
  ban [<name or ip> [: reason]]

Without any arguments, shows numbered list of active bans.

This command bans a user from accessing the game. Supply an optional
reason to be able to later remember why the ban was put in place.

It is often preferable to ban an account from the server than to
delete an account with accounts/delete. If banned by name, that account
account can no longer be logged into.

IP (Internet Protocol) address banning allows blocking all access
from a specific address or subnet. Use an asterisk (*) as a
wildcard.

Examples:
  ban thomas             - ban account 'thomas'
  ban/ip 134.233.2.111   - ban specific ip address
  ban/ip 134.233.2.*     - ban all in a subnet
  ban/ip 134.233.*.*     - even wider ban

A single IP filter can be easy to circumvent by changing computers
or requesting a new IP address. Setting a wide IP block filter with
wildcards might be tempting, but remember that it may also
accidentally block innocent users connecting from the same country
or region.
  • key: ban
  • aliases: bans
  • `locks`_: “cmd:perm(ban) or perm(Developer)”
  • ```help_category```_: “Admin”
  • Source: class CmdBan in admin.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

boot (CmdBoot)

kick an account from the server.

Usage
  boot[/switches] <account obj> [: reason]

Switches:
  quiet - Silently boot without informing account
  sid - boot by session id instead of name or dbref

Boot an account object from the server. If a reason is
supplied it will be echoed to the user unless /quiet is set.
  • key: boot
  • aliases:
  • `locks`_: “cmd:perm(boot) or perm(Admin)”
  • ```help_category```_: “Admin”
  • Source: class CmdBoot in admin.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

emit (CmdEmit)

admin command for emitting message to multiple objects

Usage:
  emit[/switches] [<obj>, <obj>, ... =] <message>
  remit           [<obj>, <obj>, ... =] <message>
  pemit           [<obj>, <obj>, ... =] <message>

Switches:
  room     -  limit emits to rooms only (default)
  accounts -  limit emits to accounts only
  contents -  send to the contents of matched objects too

Emits a message to the selected objects or to
your immediate surroundings. If the object is a room,
send to its contents. remit and pemit are just
limited forms of emit, for sending to rooms and
to accounts respectively.
  • key: emit
  • aliases: remit, pemit
  • `locks`_: “cmd:perm(emit) or perm(Builder)”
  • ```help_category```_: “Admin”
  • Source: class CmdEmit in admin.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

force (CmdForce)

forces an object to execute a command

Usage:
    force <object>=<command string>

Example:
    force bob=get stick
  • key: force
  • aliases:
  • `locks`_: “cmd:perm(spawn) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdForce in admin.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

perm (CmdPerm)

set the permissions of an account/object

Usage:
  perm[/switch] <object> [= <permission>[,<permission>,...]]
  perm[/switch] *<account> [= <permission>[,<permission>,...]]

Switches:
  del     -  delete the given permission from <object> or <account>.
  account -  set permission on an account (same as adding * to name)

This command sets/clears individual permission strings on an object
or account. If no permission is given, list all permissions on <object>.
  • key: perm
  • aliases: setperm
  • `locks`_: “cmd:perm(perm) or perm(Developer)”
  • ```help_category```_: “Admin”
  • Source: class CmdPerm in admin.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

unban (CmdUnban)

remove a ban from an account

Usage:
  unban <banid>

This will clear an account name/ip ban previously set with the ban
command.  Use this command without an argument to view a numbered
list of bans. Use the numbers in this list to select which one to
unban.
  • key: unban
  • aliases:
  • `locks`_: “cmd:perm(unban) or perm(Developer)”
  • ```help_category```_: “Admin”
  • Source: class CmdUnban in admin.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

userpassword (CmdNewPassword)

change the password of an account

Usage:
  userpassword <user obj> = <new password>

Set an account's password.
  • key: userpassword
  • aliases:
  • `locks`_: “cmd:perm(newpassword) or perm(Admin)”
  • ```help_category```_: “Admin”
  • Source: class CmdNewPassword in admin.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

wall (CmdWall)

make an announcement to all

Usage:
  wall <message>

Announces a message to all connected sessions
including all currently unlogged in.
  • key: wall
  • aliases:
  • `locks`_: “cmd:perm(wall) or perm(Admin)”
  • ```help_category```_: “Admin”
  • Source: class CmdWall in admin.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

batchprocess.py

View batchprocess.py source

batchcode (CmdBatchCode)

build from batch-code file

Usage:
 batchcode[/interactive] <python path to file>

Switch:
   interactive - this mode will offer more control when
                 executing the batch file, like stepping,
                 skipping, reloading etc.
   debug - auto-delete all objects that has been marked as
           deletable in the script file (see example files for
           syntax). This is useful so as to to not leave multiple
           object copies behind when testing out the script.

Runs batches of commands from a batch-code text file (*.py).
  • key: batchcode
  • aliases: batchcodes
  • `locks`_: “cmd:superuser()”
  • ```help_category```_: “Building”
  • Source: class CmdBatchCode in batchprocess.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

batchcommands (CmdBatchCommands)

build from batch-command file

Usage:
 batchcommands[/interactive] <python.path.to.file>

Switch:
   interactive - this mode will offer more control when
                 executing the batch file, like stepping,
                 skipping, reloading etc.

Runs batches of commands from a batch-cmd text file (*.ev).
  • key: batchcommands
  • aliases: batchcmd, batchcommand
  • `locks`_: “cmd:perm(batchcommands) or perm(Developer)”
  • ```help_category```_: “Building”
  • Source: class CmdBatchCommands in batchprocess.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

building.py

View building.py source

alias (CmdSetObjAlias)

adding permanent aliases for object

Usage:
  alias <obj> [= [alias[,alias,alias,...]]]
  alias <obj> =
  alias/category <obj> = [alias[,alias,...]:<category>

Switches:
  category - requires ending input with :category, to store the
    given aliases with the given category.

Assigns aliases to an object so it can be referenced by more
than one name. Assign empty to remove all aliases from object. If
assigning a category, all aliases given will be using this category.

Observe that this is not the same thing as personal aliases
created with the 'nick' command! Aliases set with alias are
changing the object in question, making those aliases usable
by everyone.
  • key: alias
  • aliases: setobjalias
  • `locks`_: “cmd:perm(setobjalias) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdSetObjAlias in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

cmdsets (CmdListCmdSets)

list command sets defined on an object

Usage:
  cmdsets <obj>

This displays all cmdsets assigned
to a user. Defaults to yourself.
  • key: cmdsets
  • aliases: listcmsets
  • `locks`_: “cmd:perm(listcmdsets) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdListCmdSets in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

command (ObjManipCommand)

This is a parent class for some of the defining objmanip commands
since they tend to have some more variables to define new objects.

Each object definition can have several components. First is
always a name, followed by an optional alias list and finally an
some optional data, such as a typeclass or a location. A comma ','
separates different objects. Like this:

    name1;alias;alias;alias:option, name2;alias;alias ...

Spaces between all components are stripped.

A second situation is attribute manipulation. Such commands
are simpler and offer combinations

    objname/attr/attr/attr, objname/attr, ...

copy (CmdCopy)

copy an object and its properties

Usage:
  copy[/reset] <original obj> [= <new_name>][;alias;alias..]
  [:<new_location>] [,<new_name2> ...]

switch:
  reset - make a 'clean' copy off the object, thus
          removing any changes that might have been made to the original
          since it was first created.

Create one or more copies of an object. If you don't supply any targets,
one exact copy of the original object will be created with the name *_copy.
  • key: copy
  • aliases:
  • `locks`_: “cmd:perm(copy) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdCopy in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

cpattr (CmdCpAttr)

copy attributes between objects

Usage:
  cpattr[/switch] <obj>/<attr> = <obj1>/<attr1> [,<obj2>/<attr2>,<obj3>/<attr3>,...]
  cpattr[/switch] <obj>/<attr> = <obj1> [,<obj2>,<obj3>,...]
  cpattr[/switch] <attr> = <obj1>/<attr1> [,<obj2>/<attr2>,<obj3>/<attr3>,...]
  cpattr[/switch] <attr> = <obj1>[,<obj2>,<obj3>,...]

Switches:
  move - delete the attribute from the source object after copying.

Example:
  cpattr coolness = Anna/chillout, Anna/nicety, Tom/nicety
  ->
  copies the coolness attribute (defined on yourself), to attributes
  on Anna and Tom.

Copy the attribute one object to one or more attributes on another object.
If you don't supply a source object, yourself is used.
  • key: cpattr
  • aliases:
  • `locks`_: “cmd:perm(cpattr) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdCpAttr in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

create (CmdCreate)

create new objects

Usage:
  create[/drop] <objname>[;alias;alias...][:typeclass], <objname>...

switch:
   drop - automatically drop the new object into your current
          location (this is not echoed). This also sets the new
          object's home to the current location rather than to you.

Creates one or more new objects. If typeclass is given, the object
is created as a child of this typeclass. The typeclass script is
assumed to be located under types/ and any further
directory structure is given in Python notation. So if you have a
correct typeclass 'RedButton' defined in
types/examples/red_button.py, you could create a new
object of this type like this:

   create/drop button;red : examples.red_button.RedButton
  • key: create
  • aliases:
  • `locks`_: “cmd:perm(create) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdCreate in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

desc (CmdDesc)

describe an object or the current room.

Usage:
  desc [<obj> =] <description>

Switches:
  edit - Open up a line editor for more advanced editing.

Sets the "desc" attribute on an object. If an object is not given,
describe the current room.
  • key: desc
  • aliases: describe
  • `locks`_: “cmd:perm(desc) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdDesc in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

destroy (CmdDestroy)

permanently delete objects

Usage:
   destroy[/switches] [obj, obj2, obj3, [dbref-dbref], ...]

Switches:
   override - The destroy command will usually avoid accidentally
              destroying account objects. This switch overrides this safety.
   force - destroy without confirmation.
Examples:
   destroy house, roof, door, 44-78
   destroy 5-10, flower, 45
   destroy/force north

Destroys one or many objects. If dbrefs are used, a range to delete can be
given, e.g. 4-10. Also the end points will be deleted. This command
displays a confirmation before destroying, to make sure of your choice.
You can specify the /force switch to bypass this confirmation.
  • key: destroy
  • aliases: del, delete
  • `locks`_: “cmd:perm(destroy) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdDestroy in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

dig (CmdDig)

build new rooms and connect them to the current location

Usage:
  dig[/switches] <roomname>[;alias;alias...][:typeclass]
        [= <exit_to_there>[;alias][:typeclass]]
           [, <exit_to_here>[;alias][:typeclass]]

Switches:
   tel or teleport - move yourself to the new room

Examples:
   dig kitchen = north;n, south;s
   dig house:myrooms.MyHouseTypeclass
   dig sheer cliff;cliff;sheer = climb up, climb down

This command is a convenient way to build rooms quickly; it creates the
new room and you can optionally set up exits back and forth between your
current room and the new one. You can add as many aliases as you
like to the name of the room and the exits in question; an example
would be 'north;no;n'.
  • key: dig
  • aliases:
  • `locks`_: “cmd:perm(dig) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdDig in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

examine (CmdExamine)

get detailed information about an object

Usage:
  examine [<object>[/attrname]]
  examine [*<account>[/attrname]]

Switch:
  account - examine an Account (same as adding *)
  object - examine an Object (useful when OOC)

The examine command shows detailed game info about an
object and optionally a specific attribute on it.
If object is not specified, the current location is examined.

Append a * before the search string to examine an account.
  • key: examine
  • aliases: exam, ex
  • `locks`_: “cmd:perm(examine) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdExamine in building.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

find (CmdFind)

search the database for objects

Usage:
  find[/switches] <name or dbref or *account> [= dbrefmin[-dbrefmax]]
  locate - this is a shorthand for using the /loc switch.

Switches:
  room       - only look for rooms (location=None)
  exit       - only look for exits (destination!=None)
  char       - only look for characters (BASE_CHARACTER_TYPECLASS)
  exact      - only exact matches are returned.
  loc        - display object location if exists and match has one result
  startswith - search for names starting with the string, rather than containing

Searches the database for an object of a particular name or exact #dbref.
Use *accountname to search for an account. The switches allows for
limiting object matches to certain game entities. Dbrefmin and dbrefmax
limits matches to within the given dbrefs range, or above/below if only
one is given.
  • key: find
  • aliases: locate, search
  • `locks`_: “cmd:perm(find) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdFind in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

lock (CmdLock)

assign a lock definition to an object

Usage:
  lock <object or *account>[ = <lockstring>]
  or
  lock[/switch] <object or *account>/<access_type>

Switch:
  del - delete given access type
  view - view lock associated with given access type (default)

If no lockstring is given, shows all locks on
object.

Lockstring is of the form
   access_type:[NOT] func1(args)[ AND|OR][ NOT] func2(args) ...]
Where func1, func2 ... valid lockfuncs with or without arguments.
Separator expressions need not be capitalized.

For example:
   'get: id(25) or perm(Admin)'
The 'get' lock access_type is checked e.g. by the 'get' command.
An object locked with this example lock will only be possible to pick up
by Admins or by an object with id=25.

You can add several access_types after one another by separating
them by ';', i.e:
   'get:id(25); delete:perm(Builder)'
  • key: lock
  • aliases: locks
  • `locks`_: “cmd: perm(locks) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdLock in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

mvattr (CmdMvAttr)

move attributes between objects

Usage:
  mvattr[/switch] <obj>/<attr> = <obj1>/<attr1> [,<obj2>/<attr2>,<obj3>/<attr3>,...]
  mvattr[/switch] <obj>/<attr> = <obj1> [,<obj2>,<obj3>,...]
  mvattr[/switch] <attr> = <obj1>/<attr1> [,<obj2>/<attr2>,<obj3>/<attr3>,...]
  mvattr[/switch] <attr> = <obj1>[,<obj2>,<obj3>,...]

Switches:
  copy - Don't delete the original after moving.

Move an attribute from one object to one or more attributes on another
object. If you don't supply a source object, yourself is used.
  • key: mvattr
  • aliases:
  • `locks`_: “cmd:perm(mvattr) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdMvAttr in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

name (CmdName)

change the name and/or aliases of an object

Usage:
  name <obj> = <newname>;alias1;alias2

Rename an object to something new. Use *obj to
rename an account.
  • key: name
  • aliases: rename
  • `locks`_: “cmd:perm(rename) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdName in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

open (CmdOpen)

open a new exit from the current room

Usage:
  open <new exit>[;alias;alias..][:typeclass] [,<return exit>[;alias;..][:typeclass]]] = <destination>

Handles the creation of exits. If a destination is given, the exit
will point there. The <return exit> argument sets up an exit at the
destination leading back to the current room. Destination name
can be given both as a #dbref and a name, if that name is globally
unique.
  • key: open
  • aliases:
  • `locks`_: “cmd:perm(open) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdOpen in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

script (CmdScript)

attach a script to an object

Usage:
  script[/switch] <obj> [= script_path or <scriptkey>]

Switches:
  start - start all non-running scripts on object, or a given script only
  stop - stop all scripts on objects, or a given script only

If no script path/key is given, lists all scripts active on the given
object.
Script path can be given from the base location for scripts as given in
settings. If adding a new script, it will be started automatically
(no /start switch is needed). Using the /start or /stop switches on an
object without specifying a script key/path will start/stop ALL scripts on
the object.
  • key: script
  • aliases: addscript
  • `locks`_: “cmd:perm(script) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdScript in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

set (CmdSetAttribute)

set attribute on an object or account

Usage:
  set <obj>/<attr> = <value>
  set <obj>/<attr> =
  set <obj>/<attr>
  set *<account>/<attr> = <value>

Switch:
    edit: Open the line editor (string values only)
    script: If we're trying to set an attribute on a script
    channel: If we're trying to set an attribute on a channel
    account: If we're trying to set an attribute on an account
    room: Setting an attribute on a room (global search)
    exit: Setting an attribute on an exit (global search)
    char: Setting an attribute on a character (global search)
    character: Alias for char, as above.

Sets attributes on objects. The second example form above clears a
previously set attribute while the third form inspects the current value of
the attribute (if any). The last one (with the star) is a shortcut for
operating on a player Account rather than an Object.

The most common data to save with this command are strings and
numbers. You can however also set Python primitives such as lists,
dictionaries and tuples on objects (this might be important for
the functionality of certain custom objects).  This is indicated
by you starting your value with one of |c'|n, |c"|n, |c(|n, |c[|n
or |c{ |n.

Once you have stored a Python primitive as noted above, you can include
|c[<key>]|n in <attr> to reference nested values in e.g. a list or dict.

Remember that if you use Python primitives like this, you must
write proper Python syntax too - notably you must include quotes
around your strings or you will get an error.
  • key: set
  • aliases:
  • `locks`_: “cmd:perm(set) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdSetAttribute in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

sethome (CmdSetHome)

set an object's home location

Usage:
  sethome <obj> [= <home_location>]
  sethom <obj>

The "home" location is a "safety" location for objects; they
will be moved there if their current location ceases to exist. All
objects should always have a home location for this reason.
It is also a convenient target of the "home" command.

If no location is given, just view the object's home location.
  • key: sethome
  • aliases:
  • `locks`_: “cmd:perm(sethome) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdSetHome in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

spawn (CmdSpawn)

spawn objects from prototype

Usage:
  spawn[/noloc] <prototype_key>
  spawn[/noloc] <prototype_dict>

  spawn/search [prototype_keykey][;tag[,tag]]
  spawn/list [tag, tag, ...]
  spawn/show [<prototype_key>]
  spawn/update <prototype_key>

  spawn/save <prototype_dict>
  spawn/edit [<prototype_key>]
  olc     - equivalent to spawn/edit

Switches:
  noloc - allow location to be None if not specified explicitly. Otherwise,
          location will default to caller's current location.
  search - search prototype by name or tags.
  list - list available prototypes, optionally limit by tags.
  show, examine - inspect prototype by key. If not given, acts like list.
  save - save a prototype to the database. It will be listable by /list.
  delete - remove a prototype from database, if allowed to.
  update - find existing objects with the same prototype_key and update
           them with latest version of given prototype. If given with /save,
           will auto-update all objects with the old version of the prototype
           without asking first.
  edit, olc - create/manipulate prototype in a menu interface.

Example:
  spawn GOBLIN
  spawn {"key":"goblin", "typeclass":"monster.Monster", "location":"#2"}
  spawn/save {"key": "grunt", prototype: "goblin"};;mobs;edit:all()

Dictionary keys:
  |wprototype_parent  |n - name of parent prototype to use. Required if typeclass is
                    not set. Can be a path or a list for multiple inheritance (inherits
                    left to right). If set one of the parents must have a typeclass.
  |wtypeclass  |n - string. Required if prototype_parent is not set.
  |wkey        |n - string, the main object identifier
  |wlocation   |n - this should be a valid object or #dbref
  |whome       |n - valid object or #dbref
  |wdestination|n - only valid for exits (object or dbref)
  |wpermissions|n - string or list of permission strings
  |wlocks      |n - a lock-string
  |waliases    |n - string or list of strings.
  |wndb_|n<name>  - value of a nattribute (ndb_ is stripped)

  |wprototype_key|n   - name of this prototype. Unique. Used to store/retrieve from db
                        and update existing prototyped objects if desired.
  |wprototype_desc|n  - desc of this prototype. Used in listings
  |wprototype_locks|n - locks of this prototype. Limits who may use prototype
  |wprototype_tags|n  - tags of this prototype. Used to find prototype

  any other keywords are interpreted as Attributes and their values.

The available prototypes are defined globally in modules set in
settings.PROTOTYPE_MODULES. If spawn is used without arguments it
displays a list of available prototypes.
  • key: spawn
  • aliases: olc
  • `locks`_: “cmd:perm(spawn) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdSpawn in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

tag (CmdTag)

handles the tags of an object

Usage:
  tag[/del] <obj> [= <tag>[:<category>]]
  tag/search <tag>[:<category]

Switches:
  search - return all objects with a given Tag
  del - remove the given tag. If no tag is specified,
        clear all tags on object.

Manipulates and lists tags on objects. Tags allow for quick
grouping of and searching for objects.  If only <obj> is given,
list all tags on the object.  If /search is used, list objects
with the given tag.
The category can be used for grouping tags themselves, but it
should be used with restrain - tags on their own are usually
enough to for most grouping schemes.
  • key: tag
  • aliases: tags
  • `locks`_: “cmd:perm(tag) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdTag in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

tel (CmdTeleport)

teleport object to another location

Usage:
  tel/switch [<object> to||=] <target location>

Examples:
  tel Limbo
  tel/quiet box = Limbo
  tel/tonone box

Switches:
  quiet  - don't echo leave/arrive messages to the source/target
           locations for the move.
  intoexit - if target is an exit, teleport INTO
             the exit object instead of to its destination
  tonone - if set, teleport the object to a None-location. If this
           switch is set, <target location> is ignored.
           Note that the only way to retrieve
           an object from a None location is by direct #dbref
           reference. A puppeted object cannot be moved to None.
  loc - teleport object to the target's location instead of its contents

Teleports an object somewhere. If no object is given, you yourself are
teleported to the target location.
  • key: tel
  • aliases: teleport
  • `locks`_: “cmd:perm(teleport) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdTeleport in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

tunnel (CmdTunnel)

create new rooms in cardinal directions only

Usage:
  tunnel[/switch] <direction>[:typeclass] [= <roomname>[;alias;alias;...][:typeclass]]

Switches:
  oneway - do not create an exit back to the current location
  tel - teleport to the newly created room

Example:
  tunnel n
  tunnel n = house;mike's place;green building

This is a simple way to build using pre-defined directions:
 |wn,ne,e,se,s,sw,w,nw|n (north, northeast etc)
 |wu,d|n (up and down)
 |wi,o|n (in and out)
The full names (north, in, southwest, etc) will always be put as
main name for the exit, using the abbreviation as an alias (so an
exit will always be able to be used with both "north" as well as
"n" for example). Opposite directions will automatically be
created back from the new room unless the /oneway switch is given.
For more flexibility and power in creating rooms, use dig.
  • key: tunnel
  • aliases: tun
  • `locks`_: “cmd: perm(tunnel) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdTunnel in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

typeclass (CmdTypeclass)

set or change an object's typeclass

Usage:
  typeclass[/switch] <object> [= typeclass.path]
  typeclass/prototype <object> = prototype_key

  typeclass/list/show [typeclass.path]
  swap - this is a shorthand for using /force/reset flags.
  update - this is a shorthand for using the /force/reload flag.

Switch:
  show, examine - display the current typeclass of object (default) or, if
        given a typeclass path, show the docstring of that typeclass.
  update - *only* re-run at_object_creation on this object
          meaning locks or other properties set later may remain.
  reset - clean out *all* the attributes and properties on the
          object - basically making this a new clean object.
  force - change to the typeclass also if the object
          already has a typeclass of the same name.
  list - show available typeclasses. Only typeclasses in modules actually
         imported or used from somewhere in the code will show up here
         (those typeclasses are still available if you know the path)
  prototype - clean and overwrite the object with the specified
           prototype key - effectively making a whole new object.

Example:
  type button = examples.red_button.RedButton
  type/prototype button=a red button

If the typeclass_path is not given, the current object's typeclass is
assumed.

View or set an object's typeclass. If setting, the creation hooks of the
new typeclass will be run on the object. If you have clashing properties on
the old class, use /reset. By default you are protected from changing to a
typeclass of the same name as the one you already have - use /force to
override this protection.

The given typeclass must be identified by its location using python
dot-notation pointing to the correct module and class. If no typeclass is
given (or a wrong typeclass is given). Errors in the path or new typeclass
will lead to the old typeclass being kept. The location of the typeclass
module is searched from the default typeclass directory, as defined in the
server settings.
  • key: typeclass
  • aliases: swap, parent, type, update
  • `locks`_: “cmd:perm(typeclass) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdTypeclass in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

wipe (CmdWipe)

clear all attributes from an object

Usage:
  wipe <object>[/<attr>[/<attr>...]]

Example:
  wipe box
  wipe box/colour

Wipes all of an object's attributes, or optionally only those
matching the given attribute-wildcard search string.
  • key: wipe
  • aliases:
  • `locks`_: “cmd:perm(wipe) or perm(Builder)”
  • ```help_category```_: “Building”
  • Source: class CmdWipe in building.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

comms.py

View comms.py source

addcom (CmdAddCom)

add a channel alias and/or subscribe to a channel

Usage:
   addcom [alias=] <channel>

Joins a given channel. If alias is given, this will allow you to
refer to the channel by this alias rather than the full channel
name. Subsequent calls of this command can be used to add multiple
aliases to an already joined channel.
  • key: addcom
  • aliases: aliaschan, chanalias
  • `locks`_: “cmd:not pperm(channel_banned)”
  • ```help_category```_: “Comms”
  • Source: class CmdAddCom in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

allcom (CmdAllCom)

perform admin operations on all channels

Usage:
  allcom [on | off | who | destroy]

Allows the user to universally turn off or on all channels they are on, as
well as perform a 'who' for all channels they are on. Destroy deletes all
channels that you control.

Without argument, works like comlist.
  • key: allcom
  • aliases:
  • `locks`_: “cmd: not pperm(channel_banned)”
  • ```help_category```_: “Comms”
  • Source: class CmdAllCom in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

cboot (CmdCBoot)

kick an account from a channel you control

Usage:
   cboot[/quiet] <channel> = <account> [:reason]

Switch:
   quiet - don't notify the channel

Kicks an account or object from a channel you control.
  • key: cboot
  • aliases:
  • `locks`_: “cmd: not pperm(channel_banned)”
  • ```help_category```_: “Comms”
  • Source: class CmdCBoot in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

ccreate (CmdChannelCreate)

create a new channel

Usage:
 ccreate <new channel>[;alias;alias...] = description

Creates a new channel owned by you.
  • key: ccreate
  • aliases: channelcreate
  • `locks`_: “cmd:not pperm(channel_banned) and pperm(Player)”
  • ```help_category```_: “Comms”
  • Source: class CmdChannelCreate in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

cdesc (CmdCdesc)

describe a channel you control

Usage:
  cdesc <channel> = <description>

Changes the description of the channel as shown in
channel lists.
  • key: cdesc
  • aliases:
  • `locks`_: “cmd:not pperm(channel_banned)”
  • ```help_category```_: “Comms”
  • Source: class CmdCdesc in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

cdestroy (CmdCdestroy)

destroy a channel you created

Usage:
  cdestroy <channel>

Destroys a channel that you control.
  • key: cdestroy
  • aliases:
  • `locks`_: “cmd: not pperm(channel_banned)”
  • ```help_category```_: “Comms”
  • Source: class CmdCdestroy in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

cemit (CmdCemit)

send an admin message to a channel you control

Usage:
  cemit[/switches] <channel> = <message>

Switches:
  sendername - attach the sender's name before the message
  quiet - don't echo the message back to sender

Allows the user to broadcast a message over a channel as long as
they control it. It does not show the user's name unless they
provide the /sendername switch.
  • key: cemit
  • aliases: cmsg
  • `locks`_: “cmd: not pperm(channel_banned) and pperm(Player)”
  • ```help_category```_: “Comms”
  • Source: class CmdCemit in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

channels (CmdChannels)

list all channels available to you

Usage:
  channels
  clist
  comlist

Lists all channels available to you, whether you listen to them or not.
Use 'comlist' to only view your current channel subscriptions.
Use addcom/delcom to join and leave channels
  • key: channels
  • aliases: chanlist, channellist, clist, comlist, all channels
  • `locks`_: “cmd: not pperm(channel_banned)”
  • ```help_category```_: “Comms”
  • Source: class CmdChannels in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

clock (CmdClock)

change channel locks of a channel you control

Usage:
  clock <channel> [= <lockstring>]

Changes the lock access restrictions of a channel. If no
lockstring was given, view the current lock definitions.
  • key: clock
  • aliases:
  • `locks`_: “cmd:not pperm(channel_banned)”
  • ```help_category```_: “Comms”
  • Source: class CmdClock in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

cwho (CmdCWho)

show who is listening to a channel

Usage:
  cwho <channel>

List who is connected to a given channel you have access to.
  • key: cwho
  • aliases:
  • `locks`_: “cmd: not pperm(channel_banned)”
  • ```help_category```_: “Comms”
  • Source: class CmdCWho in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

delcom (CmdDelCom)

remove a channel alias and/or unsubscribe from channel

Usage:
   delcom <alias or channel>
   delcom/all <channel>

If the full channel name is given, unsubscribe from the
channel. If an alias is given, remove the alias but don't
unsubscribe. If the 'all' switch is used, remove all aliases
for that channel.
  • key: delcom
  • aliases: delaliaschan, delchanalias
  • `locks`_: “cmd:not perm(channel_banned)”
  • ```help_category```_: “Comms”
  • Source: class CmdDelCom in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

irc2chan (CmdIRC2Chan)

Link an evennia channel to an external IRC channel

Usage:
  irc2chan[/switches] <evennia_channel> = <ircnetwork> <port> <#irchannel> <botname>[:typeclass]
  irc2chan/delete botname|#dbid

Switches:
  /delete     - this will delete the bot and remove the irc connection
                to the channel. Requires the botname or #dbid as input.
  /remove     - alias to /delete
  /disconnect - alias to /delete
  /list       - show all irc<->evennia mappings
  /ssl        - use an SSL-encrypted connection

Example:
  irc2chan myircchan = irc.dalnet.net 6667 #mychannel evennia-bot
  irc2chan public = irc.freenode.net 6667 #evgaming #evbot:accounts.mybot.MyBot

This creates an IRC bot that connects to a given IRC network and
channel. If a custom typeclass path is given, this will be used
instead of the default bot class.
The bot will relay everything said in the evennia channel to the
IRC channel and vice versa. The bot will automatically connect at
server start, so this command need only be given once. The
/disconnect switch will permanently delete the bot. To only
temporarily deactivate it, use the  |wservices|n command instead.
Provide an optional bot class path to use a custom bot.
  • key: irc2chan
  • aliases:
  • `locks`_: “cmd:serversetting(IRC_ENABLED) and pperm(Developer)”
  • ```help_category```_: “Comms”
  • Source: class CmdIRC2Chan in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

page (CmdPage)

send a private message to another account

Usage:
  page[/switches] [<account>,<account>,... = <message>]
  tell        ''
  page <number>

Switch:
  last - shows who you last messaged
  list - show your last <number> of tells/pages (default)

Send a message to target user (if online). If no
argument is given, you will get a list of your latest messages.
  • key: page
  • aliases: tell
  • `locks`_: “cmd:not pperm(page_banned)”
  • ```help_category```_: “Comms”
  • Source: class CmdPage in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

rss2chan (CmdRSS2Chan)

link an evennia channel to an external RSS feed

Usage:
  rss2chan[/switches] <evennia_channel> = <rss_url>

Switches:
  /disconnect - this will stop the feed and remove the connection to the
                channel.
  /remove     -                                 "
  /list       - show all rss->evennia mappings

Example:
  rss2chan rsschan = http://code.google.com/feeds/p/evennia/updates/basic

This creates an RSS reader  that connects to a given RSS feed url. Updates
will be echoed as a title and news link to the given channel. The rate of
updating is set with the RSS_UPDATE_INTERVAL variable in settings (default
is every 10 minutes).

When disconnecting you need to supply both the channel and url again so as
to identify the connection uniquely.
  • key: rss2chan
  • aliases:
  • `locks`_: “cmd:serversetting(RSS_ENABLED) and pperm(Developer)”
  • ```help_category```_: “Comms”
  • Source: class CmdRSS2Chan in comms.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

general.py

View general.py source

access (CmdAccess)

show your current game access

Usage:
  access

This command shows you the permission hierarchy and
which permission groups you are a member of.
  • key: access
  • aliases: groups, hierarchy
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdAccess in general.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

drop (CmdDrop)

drop something

Usage:
  drop <obj>

Lets you drop an object from your inventory into the
location you are currently in.
  • key: drop
  • aliases:
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdDrop in general.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

get (CmdGet)

pick up something

Usage:
  get <obj>

Picks up an object from your location and puts it in
your inventory.
  • key: get
  • aliases: grab
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdGet in general.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

give (CmdGive)

give away something to someone

Usage:
  give <inventory obj> <to||=> <target>

Gives an items from your inventory to another character,
placing it in their inventory.
  • key: give
  • aliases:
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdGive in general.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

home (CmdHome)

move to your character's home location

Usage:
  home

Teleports you to your home location.
  • key: home
  • aliases:
  • `locks`_: “cmd:perm(home) or perm(Builder)”
  • ```help_category```_: “General”
  • Source: class CmdHome in general.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

inventory (CmdInventory)

view inventory

Usage:
  inventory
  inv

Shows your inventory.
  • key: inventory
  • aliases: i, inv
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdInventory in general.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

look (CmdLook)

look at location or object

Usage:
  look
  look <obj>
  look *<account>

Observes your location or objects in your vicinity.
  • key: look
  • aliases: l, ls
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdLook in general.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

nick (CmdNick)

define a personal alias/nick by defining a string to
match and replace it with another on the fly

Usage:
  nick[/switches] <string> [= [replacement_string]]
  nick[/switches] <template> = <replacement_template>
  nick/delete <string> or number
  nicks

Switches:
  inputline - replace on the inputline (default)
  object    - replace on object-lookup
  account   - replace on account-lookup
  list      - show all defined aliases (also "nicks" works)
  delete    - remove nick by index in /list
  clearall  - clear all nicks

Examples:
  nick hi = say Hello, I'm Sarah!
  nick/object tom = the tall man
  nick build $1 $2 = create/drop $1;$2
  nick tell $1 $2=page $1=$2
  nick tm?$1=page tallman=$1
  nick tm\=$1=page tallman=$1

A 'nick' is a personal string replacement. Use $1, $2, ... to catch arguments.
Put the last $-marker without an ending space to catch all remaining text. You
can also use unix-glob matching for the left-hand side <string>:

    * - matches everything
    ? - matches 0 or 1 single characters
    [abcd] - matches these chars in any order
    [!abcd] - matches everything not among these chars
    \= - escape literal '=' you want in your <string>

Note that no objects are actually renamed or changed by this command - your nicks
are only available to you. If you want to permanently add keywords to an object
for everyone to use, you need build privileges and the alias command.
  • key: nick
  • aliases: nicks, nickname
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdNick in general.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

pose (CmdPose)

strike a pose

Usage:
  pose <pose text>
  pose's <pose text>

Example:
  pose is standing by the wall, smiling.
   -> others will see:
  Tom is standing by the wall, smiling.

Describe an action being taken. The pose text will
automatically begin with your name.
  • key: pose
  • aliases: :, emote
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdPose in general.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

say (CmdSay)

speak as your character

Usage:
  say <message>

Talk to those in your current location.
  • key: say
  • aliases: , *“*
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdSay in general.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

setdesc (CmdSetDesc)

describe yourself

Usage:
  setdesc <description>

Add a description to yourself. This
will be visible to people when they
look at you.
  • key: setdesc
  • aliases:
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdSetDesc in general.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

whisper (CmdWhisper)

Speak privately as your character to another

Usage:
  whisper <character> = <message>
  whisper <char1>, <char2> = <message>

Talk privately to one or more characters in your current location, without
others in the room being informed.
  • key: whisper
  • aliases:
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdWhisper in general.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

help.py

View help.py source

help (CmdHelp)

View help or a list of topics

Usage:
  help <topic or command>
  help list
  help all

This will search for help on commands and other
topics related to the game.
  • key: help
  • aliases: ?
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdHelp in help.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

sethelp (CmdSetHelp)

Edit the help database.

Usage:
  help[/switches] <topic>[[;alias;alias][,category[,locks]] [= <text>]

Switches:
  edit - open a line editor to edit the topic's help text.
  replace - overwrite existing help topic.
  append - add text to the end of existing topic with a newline between.
  extend - as append, but don't add a newline.
  delete - remove help topic.

Examples:
  sethelp throw = This throws something at ...
  sethelp/append pickpocketing,Thievery = This steals ...
  sethelp/replace pickpocketing, ,attr(is_thief) = This steals ...
  sethelp/edit thievery

This command manipulates the help database. A help entry can be created,
appended/merged to and deleted. If you don't assign a category, the
"General" category will be used. If no lockstring is specified, default
is to let everyone read the help file.
  • key: sethelp
  • aliases:
  • `locks`_: “cmd:perm(Helper)”
  • ```help_category```_: “Building”
  • Source: class CmdSetHelp in help.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

system.py

View system.py source

about (CmdAbout)

show Evennia info

Usage:
  about

Display info about the game engine.
  • key: about
  • aliases: version
  • `locks`_: “cmd:all()”
  • ```help_category```_: “System”
  • Source: class CmdAbout in system.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

objects (CmdObjects)

statistics on objects in the database

Usage:
  objects [<nr>]

Gives statictics on objects in database as well as
a list of <nr> latest objects in database. If not
given, <nr> defaults to 10.
  • key: objects
  • aliases: db, listobjs, stats, listobjects
  • `locks`_: “cmd:perm(listobjects) or perm(Builder)”
  • ```help_category```_: “System”
  • Source: class CmdObjects in system.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

py (CmdPy)

execute a snippet of python code

Usage:
  py [cmd]
  py/edit
  py/time <cmd>
  py/clientraw <cmd>
  py/noecho

Switches:
  time - output an approximate execution time for <cmd>
  edit - open a code editor for multi-line code experimentation
  clientraw - turn off all client-specific escaping. Note that this may
    lead to different output depending on prototocol (such as angular brackets
    being parsed as HTML in the webclient but not in telnet clients)
  noecho - in Python console mode, turn off the input echo (e.g. if your client
    does this for you already)

Without argument, open a Python console in-game. This is a full console,
accepting multi-line Python code for testing and debugging. Type `exit()` to
return to the game. If Evennia is reloaded, the console will be closed.

Enter a line of instruction after the 'py' command to execute it
immediately.  Separate multiple commands by ';' or open the code editor
using the /edit switch (all lines added in editor will be executed
immediately when closing or using the execute command in the editor).

A few variables are made available for convenience in order to offer access
to the system (you can import more at execution time).

Available variables in py environment:
  self, me                   : caller
  here                       : caller.location
  evennia                    : the evennia API
  inherits_from(obj, parent) : check object inheritance

You can explore The evennia API from inside the game by calling
the `__doc__` property on entities:
    py evennia.__doc__
    py evennia.managers.__doc__

|rNote: In the wrong hands this command is a severe security risk.  It
should only be accessible by trusted server admins/superusers.|n
  • key: py
  • aliases: !
  • `locks`_: “cmd:perm(py) or perm(Developer)”
  • ```help_category```_: “System”
  • Source: class CmdPy in system.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

reload (CmdReload)

reload the server

Usage:
  reload [reason]

This restarts the server. The Portal is not
affected. Non-persistent scripts will survive a reload (use
reset to purge) and at_reload() hooks will be called.
  • key: reload
  • aliases: restart
  • `locks`_: “cmd:perm(reload) or perm(Developer)”
  • ```help_category```_: “System”
  • Source: class CmdReload in system.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

reset (CmdReset)

reset and reboot the server

Usage:
  reset

Notes:
  For normal updating you are recommended to use reload rather
  than this command. Use shutdown for a complete stop of
  everything.

This emulates a cold reboot of the Server component of Evennia.
The difference to shutdown is that the Server will auto-reboot
and that it does not affect the Portal, so no users will be
disconnected. Contrary to reload however, all shutdown hooks will
be called and any non-database saved scripts, ndb-attributes,
cmdsets etc will be wiped.
  • key: reset
  • aliases: reboot
  • `locks`_: “cmd:perm(reload) or perm(Developer)”
  • ```help_category```_: “System”
  • Source: class CmdReset in system.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

scripts (CmdScripts)

list and manage all running scripts

Usage:
  scripts[/switches] [#dbref, key, script.path or <obj>]

Switches:
  start - start a script (must supply a script path)
  stop - stops an existing script
  kill - kills a script - without running its cleanup hooks
  validate - run a validation on the script(s)

If no switches are given, this command just views all active
scripts. The argument can be either an object, at which point it
will be searched for all scripts defined on it, or a script name
or #dbref. For using the /stop switch, a unique script #dbref is
required since whole classes of scripts often have the same name.

Use script for managing commands on objects.
  • key: scripts
  • aliases: globalscript, listscripts
  • `locks`_: “cmd:perm(listscripts) or perm(Admin)”
  • ```help_category```_: “System”
  • Source: class CmdScripts in system.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

server (CmdServerLoad)

show server load and memory statistics

Usage:
   server[/mem]

Switches:
    mem - return only a string of the current memory usage
    flushmem - flush the idmapper cache

This command shows server load statistics and dynamic memory
usage. It also allows to flush the cache of accessed database
objects.

Some Important statistics in the table:

|wServer load|n is an average of processor usage. It's usually
between 0 (no usage) and 1 (100% usage), but may also be
temporarily higher if your computer has multiple CPU cores.

The |wResident/Virtual memory|n displays the total memory used by
the server process.

Evennia |wcaches|n all retrieved database entities when they are
loaded by use of the idmapper functionality. This allows Evennia
to maintain the same instances of an entity and allowing
non-persistent storage schemes. The total amount of cached objects
are displayed plus a breakdown of database object types.

The |wflushmem|n switch allows to flush the object cache. Please
note that due to how Python's memory management works, releasing
caches may not show you a lower Residual/Virtual memory footprint,
the released memory will instead be re-used by the program.
  • key: server
  • aliases: serverprocess, serverload
  • `locks`_: “cmd:perm(list) or perm(Developer)”
  • ```help_category```_: “System”
  • Source: class CmdServerLoad in system.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

service (CmdService)

manage system services

Usage:
  service[/switch] <service>

Switches:
  list   - shows all available services (default)
  start  - activates or reactivate a service
  stop   - stops/inactivate a service (can often be restarted)
  delete - tries to permanently remove a service

Service management system. Allows for the listing,
starting, and stopping of services. If no switches
are given, services will be listed. Note that to operate on the
service you have to supply the full (green or red) name as given
in the list.
  • key: service
  • aliases: services
  • `locks`_: “cmd:perm(service) or perm(Developer)”
  • ```help_category```_: “System”
  • Source: class CmdService in system.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

shutdown (CmdShutdown)

stop the server completely

Usage:
  shutdown [announcement]

Gracefully shut down both Server and Portal.
  • key: shutdown
  • aliases:
  • `locks`_: “cmd:perm(shutdown) or perm(Developer)”
  • ```help_category```_: “System”
  • Source: class CmdShutdown in system.py. Belongs to command set ‘DefaultAccount’ of class AccountCmdSet in cmdset_account.py.

time (CmdTime)

show server time statistics

Usage:
  time

List Server time statistics such as uptime
and the current time stamp.
  • key: time
  • aliases: uptime
  • `locks`_: “cmd:perm(time) or perm(Player)”
  • ```help_category```_: “System”
  • Source: class CmdTime in system.py. Belongs to command set ‘DefaultCharacter’ of class CharacterCmdSet in cmdset_character.py.

unloggedin.py

View unloggedin.py source

__unloggedin_look_command (CmdUnconnectedLook)

look when in unlogged-in state

Usage:
  look

This is an unconnected version of the look command for simplicity.

This is called by the server and kicks everything in gear.
All it does is display the connect screen.
  • key: *__unloggedin_look_command*
  • aliases: l, look
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdUnconnectedLook in unloggedin.py. Belongs to command set ‘DefaultUnloggedin’ of class UnloggedinCmdSet in cmdset_unloggedin.py.

OBS: This is a [[System Command|Commands]]. System commands have fixed keys and are called by the server in specific situations.

connect (CmdUnconnectedConnect)

connect to the game

Usage (at login screen):
  connect accountname password
  connect "account name" "pass word"

Use the create command to first create an account before logging in.

If you have spaces in your name, enclose it in double quotes.
  • key: connect
  • aliases: con, conn, co
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdUnconnectedConnect in unloggedin.py. Belongs to command set ‘DefaultUnloggedin’ of class UnloggedinCmdSet in cmdset_unloggedin.py.

create (CmdUnconnectedCreate)

create a new account account

Usage (at login screen):
  create <accountname> <password>
  create "account name" "pass word"

This creates a new account account.

If you have spaces in your name, enclose it in double quotes.
  • key: create
  • aliases: cre, cr
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdUnconnectedCreate in unloggedin.py. Belongs to command set ‘DefaultUnloggedin’ of class UnloggedinCmdSet in cmdset_unloggedin.py.

help (CmdUnconnectedHelp)

get help when in unconnected-in state

Usage:
  help

This is an unconnected version of the help command,
for simplicity. It shows a pane of info.
  • key: help
  • aliases: ?, h
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdUnconnectedHelp in unloggedin.py. Belongs to command set ‘DefaultUnloggedin’ of class UnloggedinCmdSet in cmdset_unloggedin.py.

quit (CmdUnconnectedQuit)

quit when in unlogged-in state

Usage:
  quit

We maintain a different version of the quit command
here for unconnected accounts for the sake of simplicity. The logged in
version is a bit more complicated.
  • key: quit
  • aliases: qu, q
  • `locks`_: “cmd:all()”
  • ```help_category```_: “General”
  • Source: class CmdUnconnectedQuit in unloggedin.py. Belongs to command set ‘DefaultUnloggedin’ of class UnloggedinCmdSet in cmdset_unloggedin.py.