From e7869ed830c143da4785537520d37ee2672b0fa4 Mon Sep 17 00:00:00 2001 From: Griatch Date: Sun, 25 Mar 2012 17:23:10 +0200 Subject: [PATCH] Removed the old base* start files from game/gamesrc. This is in line with the new API usage. Unfortunately this will likely lead to some collisions for people. --- game/gamesrc/commands/basecmdset.py | 113 ------------- game/gamesrc/commands/basecommand.py | 170 ------------------- game/gamesrc/objects/baseobjects.py | 240 --------------------------- game/gamesrc/scripts/basescript.py | 87 ---------- src/settings_default.py | 2 +- 5 files changed, 1 insertion(+), 611 deletions(-) delete mode 100644 game/gamesrc/commands/basecmdset.py delete mode 100644 game/gamesrc/commands/basecommand.py delete mode 100644 game/gamesrc/objects/baseobjects.py delete mode 100644 game/gamesrc/scripts/basescript.py diff --git a/game/gamesrc/commands/basecmdset.py b/game/gamesrc/commands/basecmdset.py deleted file mode 100644 index 0621c9dc4a..0000000000 --- a/game/gamesrc/commands/basecmdset.py +++ /dev/null @@ -1,113 +0,0 @@ -""" -This is the second component of using a Command in your game - a -command set. A cmdset groups any number of commands together. CmdSets -are stored on character and objects and all available cmdsets are -searched when Evennia tries to determine if a command is -available. Sets can be merged and combined in many different ways (see -the docs). - -You can use the classes below as templates for extending the game with -new command sets; you can also import the default Evennia cmdset and -extend/overload that. - -To change default cmdset (the one all character start the game with), -Create your custom commands in other modules -(inheriting from game.gamesrc.commands.basecommand), add them to a -cmdset class, then set your settings.CMDSET_DEFAULT to point to this -new cmdset class. - -""" - -from ev import CmdSet, Command -from ev import default_cmds - -#from contrib import menusystem, lineeditor -#from contrib import misc_commands -#from contrib import chargen - -class DefaultCmdSet(default_cmds.DefaultCmdSet): - """ - This is an example of how to overload the default command - set defined in src/commands/default/cmdset_default.py. - - Here we copy everything by calling the parent, but you can - copy&paste any combination of the default command to customize - your default set. Next you change settings.CMDSET_DEFAULT to point - to this class. - """ - key = "DefaultMUX" - - def at_cmdset_creation(self): - """ - Populates the cmdset - """ - # calling setup in src.commands.default.cmdset_default - super(DefaultCmdSet, self).at_cmdset_creation() - - # - # any commands you add below will overload the default ones. - # - #self.add(menusystem.CmdMenuTest()) - #self.add(lineeditor.CmdEditor()) - #self.add(misc_commands.CmdQuell()) - -class UnloggedinCmdSet(default_cmds.UnloggedinCmdSet): - """ - This is an example of how to overload the command set of the - unlogged in commands, defined in - src/commands/default/cmdset_unloggedin.py. - - Here we copy everything by calling the parent, but you can - copy&paste any combination of the default command to customize - your default set. Next you change settings.CMDSET_UNLOGGEDIN to - point to this class. - """ - key = "Unloggedin" - - def at_cmdset_creation(self): - """ - Populates the cmdset - """ - # calling setup in src.commands.default.cmdset_unloggedin - super(UnloggedinCmdSet, self).at_cmdset_creation() - - # - # any commands you add below will overload the default ones. - # - -class OOCCmdSet(default_cmds.OOCCmdSet): - """ - This is set is available to the player when they have no - character connected to them (i.e. they are out-of-character, ooc). - """ - key = "OOC" - - def at_cmdset_creation(self): - """ - Populates the cmdset - """ - # calling setup in src.commands.default.cmdset_ooc - super(OOCCmdSet, self).at_cmdset_creation() - # - # any commands you add below will overload the default ones. - # - -class BaseCmdSet(CmdSet): - """ - Implements an empty, example cmdset. - """ - - key = "ExampleSet" - - def at_cmdset_creation(self): - """ - This is the only method defined in a cmdset, called during - its creation. It should populate the set with command instances. - - Here we just add the base Command object. - """ - self.add(Command()) - - - - diff --git a/game/gamesrc/commands/basecommand.py b/game/gamesrc/commands/basecommand.py deleted file mode 100644 index 93b8ef987e..0000000000 --- a/game/gamesrc/commands/basecommand.py +++ /dev/null @@ -1,170 +0,0 @@ - -""" - - -Inherit from this and -overload the member functions to define your own commands. -See src/commands/default/muxcommand.py for an example. - -""" - -from ev import Command as BaseCommand -from ev import default_cmd -from ev import utils - -class MuxCommand(default_cmd.MuxCommand): - """ - This sets up the basis for a Evennia's 'MUX-like' command - style. The idea is that most other Mux-related commands should - just inherit from this and don't have to implement much parsing of - their own unless they do something particularly advanced. - - Note that the class's __doc__ string (this text) is used by - Evennia to create the automatic help entry for the command, so - make sure to document consistently here. - - Most of the time your child classes should not need to implement - parse() at all, but only the main func() method for doing useful - things. See examples in src/commands/default. - - """ - - def parse(self): - """ - This method is called by the cmdhandler once the command name - has been identified. It creates a new set of member variables - that can be later accessed from self.func() (see below) - - The following variables are available for our use when entering this - method (from the command definition, and assigned on the fly by the - cmdhandler): - self.key - the name of this command ('look') - self.aliases - the aliases of this cmd ('l') - self.locks - lock definition for this command, usually cmd: - self.help_category - overall category of command - - self.caller - the object calling this command - self.cmdstring - the actual command name used to call this - (this allows you to know which alias was used, - for example) - self.args - the raw input; everything following self.cmdstring. - self.cmdset - the cmdset from which this command was picked. Not - often used (useful for commands like 'help' or to - list all available commands etc) - self.obj - the object on which this command was defined. It is often - the same as self.caller. - - A MUX command has the following possible syntax: - - name[ with several words][/switch[/switch..]] arg1[,arg2,...] [[=|,] arg[,..]] - - The 'name[ with several words]' part is already dealt with by the - cmdhandler at this point, and stored in self.cmdname (we don't use - it here). The rest of the command is stored in self.args, which can start - with the switch indicator /. - - This parser breaks self.args into its constituents and stores them in the - following variables: - self.switches = [list of /switches (without the /)] - self.raw = This is the raw argument input, including switches - self.args = This is re-defined to be everything *except* the switches - self.lhs = Everything to the left of = (lhs:'left-hand side'). If - no = is found, this is identical to self.args. - self.rhs: Everything to the right of = (rhs:'right-hand side'). - If no '=' is found, this is None. - self.lhslist - [self.lhs split into a list by comma] - self.rhslist - [list of self.rhs split into a list by comma] - self.arglist = [list of space-separated args (stripped, including '=' if it exists)] - - All args and list members are stripped of excess whitespace around the - strings, but case is preserved. - """ - # parse all that makes it a MUX command (don't remove this) - super(MuxCommand, self).parse() - - def func(self): - """ - This is the hook function that actually does all the work. It is called - by the cmdhandler right after self.parser() finishes, and so has access - to all the variables defined therein. - """ - # this can be removed in your child class, it's just - # printing the ingoing variables as a demo - super(MuxCommand, self).func() - - - -class Command(BaseCommand): - """ - This is the basic command class (MuxCommand is a child of - this). Inherit from this if you want to create your own - command styles. - - Note that the class's __doc__ string (this text) is - used by Evennia to create the automatic help entry for - the command, so make sure to document consistently here. - """ - def access(self, srcobj, access_type="cmd", default=False): - """ - This is called by the cmdhandler to determine - if srcobj is allowed to execute this command. This - also determines if the command appears in help etc. - - By default, We use checks of the 'cmd' type of lock to determine - if the command should be run. - """ - return super(Command, self).access(srcobj, access_type=access_type, default=default) - - def at_pre_cmd(self): - """ - This hook is called before self.parse() on all commands - """ - pass - - def at_post_cmd(self): - """ - This hook is called after the command has finished executing - (after self.func()). - """ - pass - - def parse(self): - """ - This method is called by the cmdhandler once the command name - has been identified. It creates a new set of member variables - that can be later accessed from self.func() (see below) - - The following variables are available for our use when entering this - method (from the command definition, and assigned on the fly by the - cmdhandler): - self.key - the name of this command ('look') - self.aliases - the aliases of this cmd ('l') - self.permissions - permission string for this command - self.help_category - overall category of command - - self.caller - the object calling this command - self.cmdstring - the actual command name used to call this - (this allows you to know which alias was used, - for example) - self.args - the raw input; everything following self.cmdstring. - self.cmdset - the cmdset from which this command was picked. Not - often used (useful for commands like 'help' or to - list all available commands etc) - self.obj - the object on which this command was defined. It is often - the same as self.caller. - """ - pass - - - def func(self): - """ - This is the hook function that actually does all the work. It is called - by the cmdhandler right after self.parser() finishes, and so has access - to all the variables defined therein. - """ - - # this can be removed in your child class, it's just - # printing the ingoing variables as a demo - super(MuxCommand, self).func() - - diff --git a/game/gamesrc/objects/baseobjects.py b/game/gamesrc/objects/baseobjects.py deleted file mode 100644 index f7faf814a2..0000000000 --- a/game/gamesrc/objects/baseobjects.py +++ /dev/null @@ -1,240 +0,0 @@ -""" -These are the base object typeclasses, a convenient shortcut to the -objects in src/objects/objects.py. You can start building your game -from these bases if you want. - -To change these defaults to point to some other object, -change some or all of these variables in settings.py: -BASE_OBJECT_TYPECLASS -BASE_CHARACTER_TYPECLASS -BASE_ROOM_TYPECLASS -BASE_EXIT_TYPECLASS -BASE_PLAYER_TYPECLASS - -Some of the main uses for these settings are not hard-coded in -Evennia, rather they are convenient defaults for in-game commands -(which you may change) Example would be build commands like '@dig' -knowing to create a particular room-type object). - -New instances of Objects (inheriting from these typeclasses) -are created with src.utils.create.create_object(typeclass, ...) -where typeclass is the python path to the class you want to use. -""" -from ev import Object as BaseObject -from ev import Character as BaseCharacter -from ev import Room as BaseRoom -from ev import Exit as BaseExit -from ev import Player as BasePlayer - -class Object(BaseObject): - """ - This is the root typeclass object, implementing an in-game Evennia - game object, such as having a location, being able to be - manipulated or looked at, etc. If you create a new typeclass, it - must always inherit from this object (or any of the other objects - in this file, since they all actually inherit from BaseObject, as - seen in src.object.objects). - - The BaseObject class implements several hooks tying into the game - engine. By re-implementing these hooks you can control the - system. You should never need to re-implement special Python - methods, such as __init__ and especially never __getattribute__ and - __setattr__ since these are used heavily by the typeclass system - of Evennia and messing with them might well break things for you. - - - * Base properties defined/available on all Objects - - key (string) - name of object - name (string)- same as key - aliases (list of strings) - aliases to the object. Will be saved to database as AliasDB entries but returned as strings. - dbref (int, read-only) - unique #id-number. Also "id" can be used. - dbobj (Object, read-only) - link to database model. dbobj.typeclass points back to this class - typeclass (Object, read-only) - this links back to this class as an identified only. Use self.swap_typeclass() to switch. - date_created (string) - time stamp of object creation - permissions (list of strings) - list of permission strings - - player (Player) - controlling player (will also return offline player) - location (Object) - current location. Is None if this is a room - home (Object) - safety start-location - sessions (list of Sessions, read-only) - returns all sessions connected to this object - has_player (bool, read-only)- will only return *connected* players - contents (list of Objects, read-only) - returns all objects inside this object (including exits) - exits (list of Objects, read-only) - returns all exits from this object, if any - destination (Object) - only set if this object is an exit. - is_superuser (bool, read-only) - True/False if this user is a superuser - - * Handlers available - - locks - lock-handler: use locks.add() to add new lock strings - db - attribute-handler: store/retrieve database attributes on this self.db.myattr=val, val=self.db.myattr - ndb - non-persistent attribute handler: same as db but does not create a database entry when storing data - scripts - script-handler. Add new scripts to object with scripts.add() - cmdset - cmdset-handler. Use cmdset.add() to add new cmdsets to object - nicks - nick-handler. New nicks with nicks.add(). - - * Helper methods (see src.objects.objects.py for full headers) - - search(ostring, global_search=False, attribute_name=None, use_nicks=False, location=None, ignore_errors=False, player=False) - execute_cmd(raw_string) - msg(message, from_obj=None, data=None) - msg_contents(message, exclude=None, from_obj=None, data=None) - move_to(destination, quiet=False, emit_to_obj=None, use_destination=True) - copy(new_key=None) - delete() - is_typeclass(typeclass, exact=False) - swap_typeclass(new_typeclass, clean_attributes=False, no_default=True) - access(accessing_obj, access_type='read', default=False) - check_permstring(permstring) - - * Hooks (these are class methods, so their arguments should also start with self): - - basetype_setup() - only called once, used for behind-the-scenes setup. Normally not modified. - basetype_posthook_setup() - customization in basetype, after the object has been created; Normally not modified. - - at_object_creation() - only called once, when object is first created. Object customizations go here. - at_object_delete() - called just before deleting an object. If returning False, deletion is aborted. Note that all objects - inside a deleted object are automatically moved to their , they don't need to be removed here. - - at_init() - called whenever typeclass is cached from memory, at least once every server restart/reload - at_cmdset_get() - this is called just before the command handler requests a cmdset from this object - at_first_login() - (player-controlled objects only) called once, the very first time user logs in. - at_pre_login() - (player-controlled objects only) called every time the user connects, after they have identified, before other setup - at_post_login() - (player-controlled objects only) called at the end of login, just before setting the player loose in the world. - at_disconnect() - (player-controlled objects only) called just before the user disconnects (or goes linkless) - at_server_reload() - called before server is reloaded - at_server_shutdown() - called just before server is fully shut down - - at_before_move(destination) - called just before moving object to the destination. If returns False, move is cancelled. - announce_move_from(destination) - called in old location, just before move, if obj.move_to() has quiet=False - announce_move_to(source_location) - called in new location, just after move, if obj.move_to() has quiet=False - at_after_move(source_location) - always called after a move has been successfully performed. - at_object_leave(obj, target_location) - called when an object leaves this object in any fashion - at_object_receive(obj, source_location) - called when this object receives another object - - at_before_traverse(traversing_object) - (exit-objects only) called just before an object traverses this object - at_after_traverse(traversing_object, source_location) - (exit-objects only) called just after a traversal has happened. - at_failed_traverse(traversing_object) - (exit-objects only) called if traversal fails and property err_traverse is not defined. - - at_msg_receive(self, msg, from_obj=None, data=None) - called when a message (via self.msg()) is sent to this obj. - If returns false, aborts send. - at_msg_send(self, msg, to_obj=None, data=None) - called when this objects sends a message to someone via self.msg(). - - return_appearance(looker) - describes this object. Used by "look" command by default - at_desc(looker=None) - called by 'look' whenever the appearance is requested. - at_get(getter) - called after object has been picked up. Does not stop pickup. - at_drop(dropper) - called when this object has been dropped. - at_say(speaker, message) - by default, called if an object inside this object speaks - - """ - pass - - -class Character(BaseCharacter): - """ - This is the default object created for a new user connecting - the - in-game player character representation. The basetype_setup always - assigns the default_cmdset as a fallback to objects of this type. - The default hooks also hide the character object away (by moving - it to a Null location whenever the player logs off (otherwise the - character would remain in the world, "headless" so to say). - """ - pass - -class Room(BaseRoom): - """ - Rooms are like any object, except their location is None - (which is default). Usually this object should be - assigned to room-building commands by use of the - settings.BASE_ROOM_TYPECLASS variable. - """ - pass - -class Exit(BaseExit): - """ - Exits are connectors between rooms. Exits defines the - 'destination' property and sets up a command on itself with the - same name as the Exit object - this command allows the player to - traverse the exit to the destination just by writing the name of - the object on the command line. - - Relevant hooks: - at_before_traverse(traveller) - called just before traversing - at_after_traverse(traveller, source_loc) - called just after traversing - at_failed_traverse(traveller) - called if traversal failed for some reason. Will - not be called if the attribute 'err_traverse' is - defined, in which case that will simply be echoed. - """ - pass - -class Player(BasePlayer): - """ - This class describes the actual OOC player (i.e. the user connecting - to the MUD). It does NOT have visual appearance in the game world (that - - is handled by the character which is connected to this). Comm channels - are attended/joined using this object. - - It can be useful e.g. for storing configuration options for your game, but - should generally not hold any character-related info (that's best handled - on the character level). - - Can be set using BASE_PLAYER_TYPECLASS. - - - * available properties - - key (string) - name of player - name (string)- wrapper for user.username - aliases (list of strings) - aliases to the object. Will be saved to database as AliasDB entries but returned as strings. - dbref (int, read-only) - unique #id-number. Also "id" can be used. - dbobj (Player, read-only) - link to database model. dbobj.typeclass points back to this class - typeclass (Player, read-only) - this links back to this class as an identified only. Use self.swap_typeclass() to switch. - date_created (string) - time stamp of object creation - permissions (list of strings) - list of permission strings - - user (User, read-only) - django User authorization object - obj (Object) - game object controlled by player. 'character' can also be used. - sessions (list of Sessions) - sessions connected to this player - is_superuser (bool, read-only) - if the connected user is a superuser - - * Handlers - - locks - lock-handler: use locks.add() to add new lock strings - db - attribute-handler: store/retrieve database attributes on this self.db.myattr=val, val=self.db.myattr - ndb - non-persistent attribute handler: same as db but does not create a database entry when storing data - scripts - script-handler. Add new scripts to object with scripts.add() - cmdset - cmdset-handler. Use cmdset.add() to add new cmdsets to object - nicks - nick-handler. New nicks with nicks.add(). - - * Helper methods - - msg(outgoing_string, from_obj=None, data=None) - swap_character(new_character, delete_old_character=False) - execute_cmd(raw_string) - search(ostring, global_search=False, attribute_name=None, use_nicks=False, location=None, ignore_errors=False, player=False) - is_typeclass(typeclass, exact=False) - swap_typeclass(new_typeclass, clean_attributes=False, no_default=True) - access(accessing_obj, access_type='read', default=False) - check_permstring(permstring) - - * Hook methods (when re-implementation, remember methods need to have self as first arg) - - basetype_setup() - at_player_creation() - - - note that the following hooks are also found on Objects and are - usually handled on the character level: - - at_init() - at_cmdset_get() - at_first_login() - at_post_login() - at_disconnect() - at_message_receive() - at_message_send() - at_server_reload() - at_server_shutdown() - - """ - pass diff --git a/game/gamesrc/scripts/basescript.py b/game/gamesrc/scripts/basescript.py deleted file mode 100644 index 68058210df..0000000000 --- a/game/gamesrc/scripts/basescript.py +++ /dev/null @@ -1,87 +0,0 @@ -""" - -Template module for Scripts - -Copy this module up one level to gamesrc/scripts and name it -appropriately, then use that as a template to create your own script. - -Test scripts in-game e.g. with the @script command. In code you can -create new scripts of a given class with - script = ev.create.script("path.to.module.and.class") - -Scripts are objects that handle everything in the game having -a time-component (i.e. that may change with time, with or without -a player being involved in the change). Scripts can work like "events", -in that they are triggered at regular intervals to do a certain script, -but an Script set on an object can also be responsible for silently -checking if its state changes, so as to update it. Evennia use several -in-built scripts to keep track of things like time, to clean out -dropped connections etc. - -""" - -from ev import Script as BaseScript - -class Script(BaseScript): - """ - A script type is customized by redefining some or all of its hook methods and variables. - - * available properties - - key (string) - name of object - name (string)- same as key - aliases (list of strings) - aliases to the object. Will be saved to database as AliasDB entries but returned as strings. - dbref (int, read-only) - unique #id-number. Also "id" can be used. - dbobj (Object, read-only) - link to database model. dbobj.typeclass points back to this class - typeclass (Object, read-only) - this links back to this class as an identified only. Use self.swap_typeclass() to switch. - date_created (string) - time stamp of object creation - permissions (list of strings) - list of permission strings - - desc (string) - optional description of script, shown in listings - obj (Object) - optional object that this script is connected to and acts on (set automatically by obj.scripts.add()) - interval (int) - how often script should run, in seconds. <0 turns off ticker - start_delay (bool) - if the script should start repeating right away or wait self.interval seconds - repeats (int) - how many times the script should repeat before stopping. 0 means infinite repeats - persistent (bool) - if script should survive a server shutdown or not - is_active (bool) - if script is currently running - - * Handlers - - locks - lock-handler: use locks.add() to add new lock strings - db - attribute-handler: store/retrieve database attributes on this self.db.myattr=val, val=self.db.myattr - ndb - non-persistent attribute handler: same as db but does not create a database entry when storing data - - * Helper methods - - start() - start script (this usually happens automatically at creation and obj.script.add() etc) - stop() - stop script, and delete it - pause() - put the script on hold, until unpause() is called. If script is persistent, the pause state will survive a shutdown. - unpause() - restart a previously paused script. The script will continue as if it was never paused. - time_until_next_repeat() - if a timed script (interval>0), returns time until next tick - - * Hook methods (should also include self as the first argument): - - at_script_creation() - called only once, when an object of this - class is first created. - is_valid() - is called to check if the script is valid to be running - at the current time. If is_valid() returns False, the running - script is stopped and removed from the game. You can use this - to check state changes (i.e. an script tracking some combat - stats at regular intervals is only valid to run while there is - actual combat going on). - at_start() - Called every time the script is started, which for persistent - scripts is at least once every server start. Note that this is - unaffected by self.delay_start, which only delays the first call - to at_repeat(). - at_repeat() - Called every self.interval seconds. It will be called immediately - upon launch unless self.delay_start is True, which will delay - the first call of this method by self.interval seconds. If - self.interval==0, this method will never be called. - at_stop() - Called as the script object is stopped and is about to be removed from - the game, e.g. because is_valid() returned False. - at_server_reload() - Called when server reloads. Can be used to save temporary - variables you want should survive a reload. - at_server_shutdown() - called at a full server shutdown. - - """ - pass diff --git a/src/settings_default.py b/src/settings_default.py index 7dc00797c2..aa3e336890 100644 --- a/src/settings_default.py +++ b/src/settings_default.py @@ -200,7 +200,7 @@ SCRIPT_TYPECLASS_PATHS = ["game.gamesrc.scripts", "game.gamesrc.scripts.examples PLAYER_TYPECLASS_PATHS = ["game.gamesrc.objects", "contrib"] # Typeclass for player objects (linked to a character) (fallback) -BASE_PLAYER_TYPECLASS = "src.objects.players.Player" +BASE_PLAYER_TYPECLASS = "src.players.player.Player" # Typeclass and base for all objects (fallback) BASE_OBJECT_TYPECLASS = "src.objects.objects.Object" # Typeclass for character objects linked to a player (fallback)