evennia.commands.default.building

Building and world design commands

class evennia.commands.default.building.ObjManipCommand(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

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, …

default_typeclasses = {'character': 'typeclasses.characters.Character', 'exit': 'typeclasses.exits.Exit', 'object': 'typeclasses.objects.Object', 'room': 'typeclasses.rooms.Room'}

parse()

We need to expand the default parsing to get all the cases, see the module doc.

get_object_typeclass(obj_type: str = 'object', typeclass: str = None, method: str = 'cmd_create', **kwargs) → tuple

This hook is called by build commands to determine which typeclass to use for a specific purpose. For instance, when using dig, the system can use this to autodetect which kind of Room typeclass to use based on where the builder is currently located.

Note: Although intended to be used with typeclasses, as long as this hook returns a class with a create method,

which accepts the same API as DefaultObject.create(), build commands and other places should take it.

Parameters

• obj_type (str, optional) – The type of object that is being created. Defaults to “object”. Evennia provides “room”, “exit”, and “character” by default, but this can be extended.

• typeclass (str, optional) – The typeclass that was requested by the player. Defaults to None. Can also be an actual class.

• method (str, optional) – The method that is calling this hook. Defaults to “cmd_create”. Others are “cmd_dig”, “cmd_open”, “cmd_tunnel”, etc.

Returns

results_tuple (tuple[Optional[Builder], list[str]]) –

A tuple containing the typeclass to use and a list of

errors. (which might be empty.)

aliases = []

help_category = 'general'

key = 'command'

lock_storage = 'cmd:all();'

search_index_entry = {'aliases': '', 'category': 'general', 'key': 'command', 'no_prefix': ' ', 'tags': '', 'text': "\n This is a parent class for some of the defining objmanip commands\n since they tend to have some more variables to define new objects.\n\n Each object definition can have several components. First is\n always a name, followed by an optional alias list and finally an\n some optional data, such as a typeclass or a location. A comma ','\n separates different objects. Like this:\n\n name1;alias;alias;alias:option, name2;alias;alias ...\n\n Spaces between all components are stripped.\n\n A second situation is attribute manipulation. Such commands\n are simpler and offer combinations\n\n objname/attr/attr/attr, objname/attr, ...\n\n "}

class evennia.commands.default.building.CmdSetObjAlias(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

adding permanent aliases for object

Usage:

alias <obj> [= [alias[,alias,alias,…]]] alias <obj> = alias/category <obj> = [alias[,alias,…]:<category> alias/delete <obj> = <alias>

Switches:

category - requires ending input with :category, to store the

given aliases with the given category.

delete - deletes all occurrences of the given alias, regardless

of 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']

switch_options = ('category', 'delete')

locks = 'cmd:perm(setobjalias) or perm(Builder)'

help_category = 'building'

method_type = 'cmd_create'

func()

Set the aliases.

lock_storage = 'cmd:perm(setobjalias) or perm(Builder)'

search_index_entry = {'aliases': 'setobjalias', 'category': 'building', 'key': '@alias', 'no_prefix': 'alias setobjalias', 'tags': '', 'text': "\n adding permanent aliases for object\n\n Usage:\n alias <obj> [= [alias[,alias,alias,...]]]\n alias <obj> =\n alias/category <obj> = [alias[,alias,...]:<category>\n alias/delete <obj> = <alias>\n\n Switches:\n category - requires ending input with :category, to store the\n given aliases with the given category.\n delete - deletes all occurrences of the given alias, regardless\n of category\n\n Assigns aliases to an object so it can be referenced by more\n than one name. Assign empty to remove all aliases from object. If\n assigning a category, all aliases given will be using this category.\n\n Observe that this is not the same thing as personal aliases\n created with the 'nick' command! Aliases set with alias are\n changing the object in question, making those aliases usable\n by everyone.\n "}

class evennia.commands.default.building.CmdCopy(**kwargs)

Bases: evennia.commands.default.building.ObjManipCommand

copy an object and its properties

Usage:

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

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'

locks = 'cmd:perm(copy) or perm(Builder)'

help_category = 'building'

func()

Uses ObjManipCommand.parse()

aliases = []

lock_storage = 'cmd:perm(copy) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': '@copy', 'no_prefix': 'copy ', 'tags': '', 'text': "\n copy an object and its properties\n\n Usage:\n copy <original obj> [= <new_name>][;alias;alias..]\n [:<new_location>] [,<new_name2> ...]\n\n Create one or more copies of an object. If you don't supply any targets,\n one exact copy of the original object will be created with the name *_copy.\n "}

class evennia.commands.default.building.CmdCpAttr(**kwargs)

Bases: evennia.commands.default.building.ObjManipCommand

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'

switch_options = ('move',)

locks = 'cmd:perm(cpattr) or perm(Builder)'

help_category = 'building'

check_from_attr(obj, attr, clear=False)

Hook for overriding on subclassed commands. Checks to make sure a caller can copy the attr from the object in question. If not, return a false value and the command will abort. An error message should be provided by this function.

If clear is True, user is attempting to move the attribute.

check_to_attr(obj, attr)

Hook for overriding on subclassed commands. Checks to make sure a caller can write to the specified attribute on the specified object. If not, return a false value and the attribute will be skipped. An error message should be provided by this function.

check_has_attr(obj, attr)

Hook for overriding on subclassed commands. Do any preprocessing required and verify an object has an attribute.

get_attr(obj, attr)

Hook for overriding on subclassed commands. Do any preprocessing required and get the attribute from the object.

func()

Do the copying.

aliases = []

lock_storage = 'cmd:perm(cpattr) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': '@cpattr', 'no_prefix': 'cpattr ', 'tags': '', 'text': "\n copy attributes between objects\n\n Usage:\n cpattr[/switch] <obj>/<attr> = <obj1>/<attr1> [,<obj2>/<attr2>,<obj3>/<attr3>,...]\n cpattr[/switch] <obj>/<attr> = <obj1> [,<obj2>,<obj3>,...]\n cpattr[/switch] <attr> = <obj1>/<attr1> [,<obj2>/<attr2>,<obj3>/<attr3>,...]\n cpattr[/switch] <attr> = <obj1>[,<obj2>,<obj3>,...]\n\n Switches:\n move - delete the attribute from the source object after copying.\n\n Example:\n cpattr coolness = Anna/chillout, Anna/nicety, Tom/nicety\n ->\n copies the coolness attribute (defined on yourself), to attributes\n on Anna and Tom.\n\n Copy the attribute one object to one or more attributes on another object.\n If you don't supply a source object, yourself is used.\n "}

class evennia.commands.default.building.CmdMvAttr(**kwargs)

Bases: evennia.commands.default.building.ObjManipCommand

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'

switch_options = ('copy',)

locks = 'cmd:perm(mvattr) or perm(Builder)'

help_category = 'building'

func()

Do the moving

aliases = []

lock_storage = 'cmd:perm(mvattr) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': '@mvattr', 'no_prefix': 'mvattr ', 'tags': '', 'text': "\n move attributes between objects\n\n Usage:\n mvattr[/switch] <obj>/<attr> = <obj1>/<attr1> [,<obj2>/<attr2>,<obj3>/<attr3>,...]\n mvattr[/switch] <obj>/<attr> = <obj1> [,<obj2>,<obj3>,...]\n mvattr[/switch] <attr> = <obj1>/<attr1> [,<obj2>/<attr2>,<obj3>/<attr3>,...]\n mvattr[/switch] <attr> = <obj1>[,<obj2>,<obj3>,...]\n\n Switches:\n copy - Don't delete the original after moving.\n\n Move an attribute from one object to one or more attributes on another\n object. If you don't supply a source object, yourself is used.\n "}

class evennia.commands.default.building.CmdCreate(**kwargs)

Bases: evennia.commands.default.building.ObjManipCommand

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'

switch_options = ('drop',)

locks = 'cmd:perm(create) or perm(Builder)'

help_category = 'building'

func()

Creates the object.

aliases = []

lock_storage = 'cmd:perm(create) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': '@create', 'no_prefix': 'create ', 'tags': '', 'text': "\n create new objects\n\n Usage:\n create[/drop] <objname>[;alias;alias...][:typeclass], <objname>...\n\n switch:\n drop - automatically drop the new object into your current\n location (this is not echoed). This also sets the new\n object's home to the current location rather than to you.\n\n Creates one or more new objects. If typeclass is given, the object\n is created as a child of this typeclass. The typeclass script is\n assumed to be located under types/ and any further\n directory structure is given in Python notation. So if you have a\n correct typeclass 'RedButton' defined in\n types/examples/red_button.py, you could create a new\n object of this type like this:\n\n create/drop button;red : examples.red_button.RedButton\n\n "}

class evennia.commands.default.building.CmdDesc(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

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'

switch_options = ('edit',)

locks = 'cmd:perm(desc) or perm(Builder)'

help_category = 'building'

edit_handler()

func()

Define command

aliases = []

lock_storage = 'cmd:perm(desc) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': '@desc', 'no_prefix': 'desc ', 'tags': '', 'text': '\n describe an object or the current room.\n\n Usage:\n desc [<obj> =] <description>\n\n Switches:\n edit - Open up a line editor for more advanced editing.\n\n Sets the "desc" attribute on an object. If an object is not given,\n describe the current room.\n '}

class evennia.commands.default.building.CmdDestroy(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

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 = ['@delete', '@del']

switch_options = ('override', 'force')

locks = 'cmd:perm(destroy) or perm(Builder)'

help_category = 'building'

confirm = True

default_confirm = 'yes'

func()

Implements the command.

lock_storage = 'cmd:perm(destroy) or perm(Builder)'

search_index_entry = {'aliases': '@delete @del', 'category': 'building', 'key': '@destroy', 'no_prefix': 'destroy delete del', 'tags': '', 'text': '\n permanently delete objects\n\n Usage:\n destroy[/switches] [obj, obj2, obj3, [dbref-dbref], ...]\n\n Switches:\n override - The destroy command will usually avoid accidentally\n destroying account objects. This switch overrides this safety.\n force - destroy without confirmation.\n Examples:\n destroy house, roof, door, 44-78\n destroy 5-10, flower, 45\n destroy/force north\n\n Destroys one or many objects. If dbrefs are used, a range to delete can be\n given, e.g. 4-10. Also the end points will be deleted. This command\n displays a confirmation before destroying, to make sure of your choice.\n You can specify the /force switch to bypass this confirmation.\n '}

class evennia.commands.default.building.CmdDig(**kwargs)

Bases: evennia.commands.default.building.ObjManipCommand

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'

switch_options = ('teleport',)

locks = 'cmd:perm(dig) or perm(Builder)'

help_category = 'building'

method_type = 'cmd_dig'

new_room_lockstring = 'control:id({id}) or perm(Admin); delete:id({id}) or perm(Admin); edit:id({id}) or perm(Admin)'

func()

Do the digging. Inherits variables from ObjManipCommand.parse()

aliases = []

lock_storage = 'cmd:perm(dig) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': '@dig', 'no_prefix': 'dig ', 'tags': '', 'text': "\n build new rooms and connect them to the current location\n\n Usage:\n dig[/switches] <roomname>[;alias;alias...][:typeclass]\n [= <exit_to_there>[;alias][:typeclass]]\n [, <exit_to_here>[;alias][:typeclass]]\n\n Switches:\n tel or teleport - move yourself to the new room\n\n Examples:\n dig kitchen = north;n, south;s\n dig house:myrooms.MyHouseTypeclass\n dig sheer cliff;cliff;sheer = climb up, climb down\n\n This command is a convenient way to build rooms quickly; it creates the\n new room and you can optionally set up exits back and forth between your\n current room and the new one. You can add as many aliases as you\n like to the name of the room and the exits in question; an example\n would be 'north;no;n'.\n "}

class evennia.commands.default.building.CmdTunnel(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

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']

switch_options = ('oneway', 'tel')

locks = 'cmd: perm(tunnel) or perm(Builder)'

help_category = 'building'

method_type = 'cmd_tunnel'

directions = {'d': ('down', 'u'), 'e': ('east', 'w'), 'i': ('in', 'o'), 'n': ('north', 's'), 'ne': ('northeast', 'sw'), 'nw': ('northwest', 'se'), 'o': ('out', 'i'), 's': ('south', 'n'), 'se': ('southeast', 'nw'), 'sw': ('southwest', 'ne'), 'u': ('up', 'd'), 'w': ('west', 'e')}

func()

Implements the tunnel command

lock_storage = 'cmd: perm(tunnel) or perm(Builder)'

search_index_entry = {'aliases': '@tun', 'category': 'building', 'key': '@tunnel', 'no_prefix': 'tunnel tun', 'tags': '', 'text': '\n create new rooms in cardinal directions only\n\n Usage:\n tunnel[/switch] <direction>[:typeclass] [= <roomname>[;alias;alias;...][:typeclass]]\n\n Switches:\n oneway - do not create an exit back to the current location\n tel - teleport to the newly created room\n\n Example:\n tunnel n\n tunnel n = house;mike\'s place;green building\n\n This is a simple way to build using pre-defined directions:\n |wn,ne,e,se,s,sw,w,nw|n (north, northeast etc)\n |wu,d|n (up and down)\n |wi,o|n (in and out)\n The full names (north, in, southwest, etc) will always be put as\n main name for the exit, using the abbreviation as an alias (so an\n exit will always be able to be used with both "north" as well as\n "n" for example). Opposite directions will automatically be\n created back from the new room unless the /oneway switch is given.\n For more flexibility and power in creating rooms, use dig.\n '}

class evennia.commands.default.building.CmdLink(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

link existing rooms together with exits

Usage:

link[/switches] <object> = <target> link[/switches] <object> = link[/switches] <object>

Switch:

twoway - connect two exits. For this to work, BOTH <object>

and <target> must be exit objects.

If <object> is an exit, set its destination to <target>. Two-way operation instead sets the destination to the locations of the respective given arguments. The second form (a lone =) sets the destination to None (same as the unlink command) and the third form (without =) just shows the currently set destination.

key = '@link'

locks = 'cmd:perm(link) or perm(Builder)'

help_category = 'building'

func()

Perform the link

aliases = []

lock_storage = 'cmd:perm(link) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': '@link', 'no_prefix': 'link ', 'tags': '', 'text': '\n link existing rooms together with exits\n\n Usage:\n link[/switches] <object> = <target>\n link[/switches] <object> =\n link[/switches] <object>\n\n Switch:\n twoway - connect two exits. For this to work, BOTH <object>\n and <target> must be exit objects.\n\n If <object> is an exit, set its destination to <target>. Two-way operation\n instead sets the destination to the *locations* of the respective given\n arguments.\n The second form (a lone =) sets the destination to None (same as\n the unlink command) and the third form (without =) just shows the\n currently set destination.\n '}

class evennia.commands.default.building.CmdUnLink(**kwargs)

Bases: evennia.commands.default.building.CmdLink

remove exit-connections between rooms

Usage:

unlink <Object>

Unlinks an object, for example an exit, disconnecting it from whatever it was connected to.

key = 'unlink'

locks = 'cmd:perm(unlink) or perm(Builder)'

help_key = 'Building'

func()

All we need to do here is to set the right command and call func in CmdLink

aliases = []

help_category = 'building'

lock_storage = 'cmd:perm(unlink) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': 'unlink', 'no_prefix': ' ', 'tags': '', 'text': '\n remove exit-connections between rooms\n\n Usage:\n unlink <Object>\n\n Unlinks an object, for example an exit, disconnecting\n it from whatever it was connected to.\n '}

class evennia.commands.default.building.CmdSetHome(**kwargs)

Bases: evennia.commands.default.building.CmdLink

set an object’s home location

Usage:

sethome <obj> [= <home_location>] sethome <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'

locks = 'cmd:perm(sethome) or perm(Builder)'

help_category = 'building'

func()

implement the command

aliases = []

lock_storage = 'cmd:perm(sethome) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': '@sethome', 'no_prefix': 'sethome ', 'tags': '', 'text': '\n set an object\'s home location\n\n Usage:\n sethome <obj> [= <home_location>]\n sethome <obj>\n\n The "home" location is a "safety" location for objects; they\n will be moved there if their current location ceases to exist. All\n objects should always have a home location for this reason.\n It is also a convenient target of the "home" command.\n\n If no location is given, just view the object\'s home location.\n '}

class evennia.commands.default.building.CmdListCmdSets(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

list command sets defined on an object

Usage:

cmdsets <obj>

This displays all cmdsets assigned to a user. Defaults to yourself.

key = '@cmdsets'

locks = 'cmd:perm(listcmdsets) or perm(Builder)'

help_category = 'building'

func()

list the cmdsets

aliases = []

lock_storage = 'cmd:perm(listcmdsets) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': '@cmdsets', 'no_prefix': 'cmdsets ', 'tags': '', 'text': '\n list command sets defined on an object\n\n Usage:\n cmdsets <obj>\n\n This displays all cmdsets assigned\n to a user. Defaults to yourself.\n '}

class evennia.commands.default.building.CmdName(**kwargs)

Bases: evennia.commands.default.building.ObjManipCommand

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'

func()

change the name

lock_storage = 'cmd:perm(rename) or perm(Builder)'

search_index_entry = {'aliases': '@rename', 'category': 'building', 'key': '@name', 'no_prefix': 'name rename', 'tags': '', 'text': '\n change the name and/or aliases of an object\n\n Usage:\n name <obj> = <newname>;alias1;alias2\n\n Rename an object to something new. Use *obj to\n rename an account.\n\n '}

class evennia.commands.default.building.CmdOpen(**kwargs)

Bases: evennia.commands.default.building.ObjManipCommand

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'

locks = 'cmd:perm(open) or perm(Builder)'

help_category = 'building'

method_type = 'cmd_open'

new_obj_lockstring = 'control:id({id}) or perm(Admin);delete:id({id}) or perm(Admin)'

create_exit(exit_name, location, destination, exit_aliases=None, typeclass=None)

Helper function to avoid code duplication. At this point we know destination is a valid location

parse()

We need to expand the default parsing to get all the cases, see the module doc.

func()

This is where the processing starts. Uses the ObjManipCommand.parser() for pre-processing as well as the self.create_exit() method.

aliases = []

lock_storage = 'cmd:perm(open) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': '@open', 'no_prefix': 'open ', 'tags': '', 'text': '\n open a new exit from the current room\n\n Usage:\n open <new exit>[;alias;alias..][:typeclass] [,<return exit>[;alias;..][:typeclass]]] = <destination>\n\n Handles the creation of exits. If a destination is given, the exit\n will point there. The <return exit> argument sets up an exit at the\n destination leading back to the current room. Destination name\n can be given both as a #dbref and a name, if that name is globally\n unique.\n\n '}

class evennia.commands.default.building.CmdSetAttribute(**kwargs)

Bases: evennia.commands.default.building.ObjManipCommand

set attribute on an object or account

Usage:

set[/switch] <obj>/<attr>[:category] = <value> set[/switch] <obj>/<attr>[:category] = # delete attribute set[/switch] <obj>/<attr>[:category] # view attribute set[/switch] *<account>/<attr>[:category] = <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.

Example

set self/foo = “bar” set/delete self/foo set self/foo = $dbref(#53)

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.

If you want <value> to be an object, use $dbef(#dbref) or $search(key) to assign it. You need control or edit access to the object you are adding.

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'

locks = 'cmd:perm(set) or perm(Builder)'

help_category = 'building'

nested_re = re.compile('\\[.*?\\]')

not_found = <object object>

check_obj(obj)

This may be overridden by subclasses in case restrictions need to be placed on whether certain objects can have attributes set by certain accounts.

This function is expected to display its own error message.

Returning False will abort the command.

check_attr(obj, attr_name, category)

This may be overridden by subclasses in case restrictions need to be placed on what attributes can be set by who beyond the normal lock.

This functions is expected to display its own error message. It is run once for every attribute that is checked, blocking only those attributes which are not permitted and letting the others through.

split_nested_attr(attr)

Yields tuples of (possible attr name, nested keys on that attr). For performance, this is biased to the deepest match, but allows compatibility with older attrs that might have been named with []’s.

> list(split_nested_attr(“nested[‘asdf’][0]”)) [

(‘nested’, [‘asdf’, 0]), (“nested[‘asdf’]”, [0]), (“nested[‘asdf’][0]”, []),

]

do_nested_lookup(value, *keys)

view_attr(obj, attr, category)

Look up the value of an attribute and return a string displaying it.

rm_attr(obj, attr, category)

Remove an attribute from the object, or a nested data structure, and report back.

set_attr(obj, attr, value, category)

edit_handler(**kwargs)

search_for_obj(objname)

Searches for an object matching objname. The object may be of different typeclasses. :param objname: Name of the object we’re looking for

Returns

A typeclassed object, or None if nothing is found.

func()

Implement the set attribute - a limited form of py.

aliases = []

lock_storage = 'cmd:perm(set) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': '@set', 'no_prefix': 'set ', 'tags': '', 'text': '\n set attribute on an object or account\n\n Usage:\n set[/switch] <obj>/<attr>[:category] = <value>\n set[/switch] <obj>/<attr>[:category] = # delete attribute\n set[/switch] <obj>/<attr>[:category] # view attribute\n set[/switch] *<account>/<attr>[:category] = <value>\n\n Switch:\n edit: Open the line editor (string values only)\n script: If we\'re trying to set an attribute on a script\n channel: If we\'re trying to set an attribute on a channel\n account: If we\'re trying to set an attribute on an account\n room: Setting an attribute on a room (global search)\n exit: Setting an attribute on an exit (global search)\n char: Setting an attribute on a character (global search)\n character: Alias for char, as above.\n\n Example:\n set self/foo = "bar"\n set/delete self/foo\n set self/foo = $dbref(#53)\n\n Sets attributes on objects. The second example form above clears a\n previously set attribute while the third form inspects the current value of\n the attribute (if any). The last one (with the star) is a shortcut for\n operating on a player Account rather than an Object.\n\n If you want <value> to be an object, use $dbef(#dbref) or\n $search(key) to assign it. You need control or edit access to\n the object you are adding.\n\n The most common data to save with this command are strings and\n numbers. You can however also set Python primitives such as lists,\n dictionaries and tuples on objects (this might be important for\n the functionality of certain custom objects). This is indicated\n by you starting your value with one of |c\'|n, |c"|n, |c(|n, |c[|n\n or |c{ |n.\n\n Once you have stored a Python primitive as noted above, you can include\n |c[<key>]|n in <attr> to reference nested values in e.g. a list or dict.\n\n Remember that if you use Python primitives like this, you must\n write proper Python syntax too - notably you must include quotes\n around your strings or you will get an error.\n\n '}

class evennia.commands.default.building.CmdTypeclass(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

set or change an object’s typeclass

Usage:

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

typeclasses or 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. This will also reset cmdsets!

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 = ['@parent', '@swap', '@typeclasses', '@update', '@type']

switch_options = ('show', 'examine', 'update', 'reset', 'force', 'list', 'prototype')

locks = 'cmd:perm(typeclass) or perm(Builder)'

help_category = 'building'

func()

Implements command

lock_storage = 'cmd:perm(typeclass) or perm(Builder)'

search_index_entry = {'aliases': '@parent @swap @typeclasses @update @type', 'category': 'building', 'key': '@typeclass', 'no_prefix': 'typeclass parent swap typeclasses update type', 'tags': '', 'text': "\n set or change an object's typeclass\n\n Usage:\n typeclass[/switch] <object> [= typeclass.path]\n typeclass/prototype <object> = prototype_key\n\n typeclasses or typeclass/list/show [typeclass.path]\n swap - this is a shorthand for using /force/reset flags.\n update - this is a shorthand for using the /force/reload flag.\n\n Switch:\n show, examine - display the current typeclass of object (default) or, if\n given a typeclass path, show the docstring of that typeclass.\n update - *only* re-run at_object_creation on this object\n meaning locks or other properties set later may remain.\n reset - clean out *all* the attributes and properties on the\n object - basically making this a new clean object. This will also\n reset cmdsets!\n force - change to the typeclass also if the object\n already has a typeclass of the same name.\n list - show available typeclasses. Only typeclasses in modules actually\n imported or used from somewhere in the code will show up here\n (those typeclasses are still available if you know the path)\n prototype - clean and overwrite the object with the specified\n prototype key - effectively making a whole new object.\n\n Example:\n type button = examples.red_button.RedButton\n type/prototype button=a red button\n\n If the typeclass_path is not given, the current object's typeclass is\n assumed.\n\n View or set an object's typeclass. If setting, the creation hooks of the\n new typeclass will be run on the object. If you have clashing properties on\n the old class, use /reset. By default you are protected from changing to a\n typeclass of the same name as the one you already have - use /force to\n override this protection.\n\n The given typeclass must be identified by its location using python\n dot-notation pointing to the correct module and class. If no typeclass is\n given (or a wrong typeclass is given). Errors in the path or new typeclass\n will lead to the old typeclass being kept. The location of the typeclass\n module is searched from the default typeclass directory, as defined in the\n server settings.\n\n "}

class evennia.commands.default.building.CmdWipe(**kwargs)

Bases: evennia.commands.default.building.ObjManipCommand

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'

locks = 'cmd:perm(wipe) or perm(Builder)'

help_category = 'building'

func()

inp is the dict produced in ObjManipCommand.parse()

aliases = []

lock_storage = 'cmd:perm(wipe) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'building', 'key': '@wipe', 'no_prefix': 'wipe ', 'tags': '', 'text': "\n clear all attributes from an object\n\n Usage:\n wipe <object>[/<attr>[/<attr>...]]\n\n Example:\n wipe box\n wipe box/colour\n\n Wipes all of an object's attributes, or optionally only those\n matching the given attribute-wildcard search string.\n "}

class evennia.commands.default.building.CmdLock(**kwargs)

Bases: evennia.commands.default.building.ObjManipCommand

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'

func()

Sets up the command

lock_storage = 'cmd: perm(locks) or perm(Builder)'

search_index_entry = {'aliases': '@locks', 'category': 'building', 'key': '@lock', 'no_prefix': 'lock locks', 'tags': '', 'text': "\n assign a lock definition to an object\n\n Usage:\n lock <object or *account>[ = <lockstring>]\n or\n lock[/switch] <object or *account>/<access_type>\n\n Switch:\n del - delete given access type\n view - view lock associated with given access type (default)\n\n If no lockstring is given, shows all locks on\n object.\n\n Lockstring is of the form\n access_type:[NOT] func1(args)[ AND|OR][ NOT] func2(args) ...]\n Where func1, func2 ... valid lockfuncs with or without arguments.\n Separator expressions need not be capitalized.\n\n For example:\n 'get: id(25) or perm(Admin)'\n The 'get' lock access_type is checked e.g. by the 'get' command.\n An object locked with this example lock will only be possible to pick up\n by Admins or by an object with id=25.\n\n You can add several access_types after one another by separating\n them by ';', i.e:\n 'get:id(25); delete:perm(Builder)'\n "}

class evennia.commands.default.building.CmdExamine(**kwargs)

Bases: evennia.commands.default.building.ObjManipCommand

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) script - examine a Script channel - examine a Channel

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'

arg_regex = re.compile('(/\\w+?(\\s|$))|\\s|$', re.IGNORECASE)

switch_options = ['account', 'object', 'script', 'channel']

object_type = 'object'

detail_color = '|c'

header_color = '|w'

quell_color = '|r'

separator = '-'

msg(text)

Central point for sending messages to the caller. This tags the message as ‘examine’ for eventual custom markup in the client.

text

The text to send.

Type

str

format_key(obj)

format_aliases(obj)

format_typeclass(obj)

format_sessions(obj)

format_email(obj)

format_last_login(obj)

format_account_key(account)

format_account_typeclass(account)

format_account_permissions(account)

format_location(obj)

format_home(obj)

format_destination(obj)

format_permissions(obj)

format_locks(obj)

format_scripts(obj)

format_single_tag(tag)

format_tags(obj)

format_single_cmdset_options(cmdset)

format_single_cmdset(cmdset)

format_stored_cmdsets(obj)

format_merged_cmdsets(obj, current_cmdset)

format_current_cmds(obj, current_cmdset)

format_single_attribute_detail(obj, attr)

format_single_attribute(attr)

format_attributes(obj)

format_nattributes(obj)

format_exits(obj)

format_chars(obj)

format_things(obj)

format_script_desc(obj)

format_script_is_persistent(obj)

format_script_timer_data(obj)

format_channel_sub_totals(obj)

format_channel_account_subs(obj)

format_channel_object_subs(obj)

get_formatted_obj_data(obj, current_cmdset)

Calls all other format_* methods.

format_output(obj, current_cmdset)

Formats the full examine page return.

parse()

We need to expand the default parsing to get all the cases, see the module doc.

func()

Process command

lock_storage = 'cmd:perm(examine) or perm(Builder)'

search_index_entry = {'aliases': '@exam @ex', 'category': 'building', 'key': '@examine', 'no_prefix': 'examine exam ex', 'tags': '', 'text': '\n get detailed information about an object\n\n Usage:\n examine [<object>[/attrname]]\n examine [*<account>[/attrname]]\n\n Switch:\n account - examine an Account (same as adding *)\n object - examine an Object (useful when OOC)\n script - examine a Script\n channel - examine a Channel\n\n The examine command shows detailed game info about an\n object and optionally a specific attribute on it.\n If object is not specified, the current location is examined.\n\n Append a * before the search string to examine an account.\n\n '}

class evennia.commands.default.building.CmdFind(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

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 = ['@search', '@locate']

switch_options = ('room', 'exit', 'char', 'exact', 'loc', 'startswith')

locks = 'cmd:perm(find) or perm(Builder)'

help_category = 'building'

func()

Search functionality

lock_storage = 'cmd:perm(find) or perm(Builder)'

search_index_entry = {'aliases': '@search @locate', 'category': 'building', 'key': '@find', 'no_prefix': 'find search locate', 'tags': '', 'text': '\n search the database for objects\n\n Usage:\n find[/switches] <name or dbref or *account> [= dbrefmin[-dbrefmax]]\n locate - this is a shorthand for using the /loc switch.\n\n Switches:\n room - only look for rooms (location=None)\n exit - only look for exits (destination!=None)\n char - only look for characters (BASE_CHARACTER_TYPECLASS)\n exact - only exact matches are returned.\n loc - display object location if exists and match has one result\n startswith - search for names starting with the string, rather than containing\n\n Searches the database for an object of a particular name or exact #dbref.\n Use *accountname to search for an account. The switches allows for\n limiting object matches to certain game entities. Dbrefmin and dbrefmax\n limits matches to within the given dbrefs range, or above/below if only\n one is given.\n '}

class evennia.commands.default.building.CmdTeleport(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

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.

To lock an object from being teleported, set its teleport lock, it will be checked with the caller. To block a destination from being teleported to, set the destination’s teleport_here lock - it will be checked with the thing being teleported. Admins and higher permissions can always teleport.

key = '@teleport'

aliases = ['@tel']

switch_options = ('quiet', 'intoexit', 'tonone', 'loc')

rhs_split = ('=', ' to ')

locks = 'cmd:perm(teleport) or perm(Builder)'

help_category = 'building'

parse()

Breaking out searching here to make this easier to override.

func()

Performs the teleport

lock_storage = 'cmd:perm(teleport) or perm(Builder)'

search_index_entry = {'aliases': '@tel', 'category': 'building', 'key': '@teleport', 'no_prefix': 'teleport tel', 'tags': '', 'text': "\n teleport object to another location\n\n Usage:\n tel/switch [<object> to||=] <target location>\n\n Examples:\n tel Limbo\n tel/quiet box = Limbo\n tel/tonone box\n\n Switches:\n quiet - don't echo leave/arrive messages to the source/target\n locations for the move.\n intoexit - if target is an exit, teleport INTO\n the exit object instead of to its destination\n tonone - if set, teleport the object to a None-location. If this\n switch is set, <target location> is ignored.\n Note that the only way to retrieve\n an object from a None location is by direct #dbref\n reference. A puppeted object cannot be moved to None.\n loc - teleport object to the target's location instead of its contents\n\n Teleports an object somewhere. If no object is given, you yourself are\n teleported to the target location.\n\n To lock an object from being teleported, set its `teleport` lock, it will be\n checked with the caller. To block\n a destination from being teleported to, set the destination's `teleport_here`\n lock - it will be checked with the thing being teleported. Admins and\n higher permissions can always teleport.\n\n "}

class evennia.commands.default.building.CmdScripts(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

List and manage all running scripts. Allows for creating new global scripts.

Usage:

script[/switches] [script-#dbref, key, script.path] script[/start||stop] <obj> = [<script.path or script-key>]

Switches:

start - start/unpause an existing script’s timer. stop - stops an existing script’s timer pause - pause a script’s timer delete - deletes script. This will also stop the timer as needed

Examples

script - list all scripts script foo.bar.Script - create a new global Script script/pause foo.bar.Script - pause global script script scriptname|#dbref - examine named existing global script script/delete #dbref[-#dbref] - delete script or range by #dbref

script myobj = - list all scripts on object script myobj = foo.bar.Script - create and assign script to object script/stop myobj = name|#dbref - stop named script on object script/delete myobj = name|#dbref - delete script on object script/delete myobj = - delete ALL scripts on object

When given with an <obj> as left-hand-side, this creates and assigns a new script to that object. Without an <obj>, this manages and inspects global scripts.

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 the script build-level command for managing scripts attached to objects.

key = '@scripts'

aliases = ['@script']

switch_options = ('create', 'start', 'stop', 'pause', 'delete')

locks = 'cmd:perm(scripts) or perm(Builder)'

help_category = 'system'

excluded_typeclass_paths = ['evennia.prototypes.prototypes.DbPrototype']

switch_mapping = {'create': '|gCreated|n', 'delete': '|rDeleted|n', 'pause': '|Paused|n', 'start': '|gStarted|n', 'stop': '|RStopped|n'}

hide_script_paths = ('evennia.prototypes.prototypes.DbPrototype',)

func()

implement method

lock_storage = 'cmd:perm(scripts) or perm(Builder)'

search_index_entry = {'aliases': '@script', 'category': 'system', 'key': '@scripts', 'no_prefix': 'scripts script', 'tags': '', 'text': "\n List and manage all running scripts. Allows for creating new global\n scripts.\n\n Usage:\n script[/switches] [script-#dbref, key, script.path]\n script[/start||stop] <obj> = [<script.path or script-key>]\n\n Switches:\n start - start/unpause an existing script's timer.\n stop - stops an existing script's timer\n pause - pause a script's timer\n delete - deletes script. This will also stop the timer as needed\n\n Examples:\n script - list all scripts\n script foo.bar.Script - create a new global Script\n script/pause foo.bar.Script - pause global script\n script scriptname|#dbref - examine named existing global script\n script/delete #dbref[-#dbref] - delete script or range by #dbref\n\n script myobj = - list all scripts on object\n script myobj = foo.bar.Script - create and assign script to object\n script/stop myobj = name|#dbref - stop named script on object\n script/delete myobj = name|#dbref - delete script on object\n script/delete myobj = - delete ALL scripts on object\n\n When given with an `<obj>` as left-hand-side, this creates and\n assigns a new script to that object. Without an `<obj>`, this\n manages and inspects global scripts.\n\n If no switches are given, this command just views all active\n scripts. The argument can be either an object, at which point it\n will be searched for all scripts defined on it, or a script name\n or #dbref. For using the /stop switch, a unique script #dbref is\n required since whole classes of scripts often have the same name.\n\n Use the `script` build-level command for managing scripts attached to\n objects.\n\n "}

class evennia.commands.default.building.CmdObjects(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

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'

locks = 'cmd:perm(listobjects) or perm(Builder)'

help_category = 'system'

func()

Implement the command

aliases = []

lock_storage = 'cmd:perm(listobjects) or perm(Builder)'

search_index_entry = {'aliases': '', 'category': 'system', 'key': '@objects', 'no_prefix': 'objects ', 'tags': '', 'text': '\n statistics on objects in the database\n\n Usage:\n objects [<nr>]\n\n Gives statictics on objects in database as well as\n a list of <nr> latest objects in database. If not\n given, <nr> defaults to 10.\n '}

class evennia.commands.default.building.CmdTag(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

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']

options = ('search', 'del')

locks = 'cmd:perm(tag) or perm(Builder)'

help_category = 'building'

arg_regex = re.compile('(/\\w+?(\\s|$))|\\s|$', re.IGNORECASE)

func()

Implement the tag functionality

lock_storage = 'cmd:perm(tag) or perm(Builder)'

search_index_entry = {'aliases': '@tags', 'category': 'building', 'key': '@tag', 'no_prefix': 'tag tags', 'tags': '', 'text': '\n handles the tags of an object\n\n Usage:\n tag[/del] <obj> [= <tag>[:<category>]]\n tag/search <tag>[:<category]\n\n Switches:\n search - return all objects with a given Tag\n del - remove the given tag. If no tag is specified,\n clear all tags on object.\n\n Manipulates and lists tags on objects. Tags allow for quick\n grouping of and searching for objects. If only <obj> is given,\n list all tags on the object. If /search is used, list objects\n with the given tag.\n The category can be used for grouping tags themselves, but it\n should be used with restrain - tags on their own are usually\n enough to for most grouping schemes.\n '}

class evennia.commands.default.building.CmdSpawn(**kwargs)

Bases: evennia.commands.default.muxcommand.MuxCommand

spawn objects from prototype

Usage:

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

spawn/search [prototype_keykey][;tag[,tag]] spawn/list [tag, tag, …] spawn/list modules - list only module-based prototypes 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. raw - show the raw dict of the prototype as a one-line string for manual editing. 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, menu, 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']

switch_options = ('noloc', 'search', 'list', 'show', 'raw', 'examine', 'save', 'delete', 'menu', 'olc', 'update', 'edit')

locks = 'cmd:perm(spawn) or perm(Builder)'

help_category = 'building'

func()

Implements the spawner

lock_storage = 'cmd:perm(spawn) or perm(Builder)'

search_index_entry = {'aliases': '@olc', 'category': 'building', 'key': '@spawn', 'no_prefix': 'spawn olc', 'tags': '', 'text': '\n spawn objects from prototype\n\n Usage:\n spawn[/noloc] <prototype_key>\n spawn[/noloc] <prototype_dict>\n\n spawn/search [prototype_keykey][;tag[,tag]]\n spawn/list [tag, tag, ...]\n spawn/list modules - list only module-based prototypes\n spawn/show [<prototype_key>]\n spawn/update <prototype_key>\n\n spawn/save <prototype_dict>\n spawn/edit [<prototype_key>]\n olc - equivalent to spawn/edit\n\n Switches:\n noloc - allow location to be None if not specified explicitly. Otherwise,\n location will default to caller\'s current location.\n search - search prototype by name or tags.\n list - list available prototypes, optionally limit by tags.\n show, examine - inspect prototype by key. If not given, acts like list.\n raw - show the raw dict of the prototype as a one-line string for manual editing.\n save - save a prototype to the database. It will be listable by /list.\n delete - remove a prototype from database, if allowed to.\n update - find existing objects with the same prototype_key and update\n them with latest version of given prototype. If given with /save,\n will auto-update all objects with the old version of the prototype\n without asking first.\n edit, menu, olc - create/manipulate prototype in a menu interface.\n\n Example:\n spawn GOBLIN\n spawn {"key":"goblin", "typeclass":"monster.Monster", "location":"#2"}\n spawn/save {"key": "grunt", prototype: "goblin"};;mobs;edit:all()\n \x0c\n Dictionary keys:\n |wprototype_parent |n - name of parent prototype to use. Required if typeclass is\n not set. Can be a path or a list for multiple inheritance (inherits\n left to right). If set one of the parents must have a typeclass.\n |wtypeclass |n - string. Required if prototype_parent is not set.\n |wkey |n - string, the main object identifier\n |wlocation |n - this should be a valid object or #dbref\n |whome |n - valid object or #dbref\n |wdestination|n - only valid for exits (object or dbref)\n |wpermissions|n - string or list of permission strings\n |wlocks |n - a lock-string\n |waliases |n - string or list of strings.\n |wndb_|n<name> - value of a nattribute (ndb_ is stripped)\n\n |wprototype_key|n - name of this prototype. Unique. Used to store/retrieve from db\n and update existing prototyped objects if desired.\n |wprototype_desc|n - desc of this prototype. Used in listings\n |wprototype_locks|n - locks of this prototype. Limits who may use prototype\n |wprototype_tags|n - tags of this prototype. Used to find prototype\n\n any other keywords are interpreted as Attributes and their values.\n\n The available prototypes are defined globally in modules set in\n settings.PROTOTYPE_MODULES. If spawn is used without arguments it\n displays a list of available prototypes.\n\n '}