diff --git a/game/gamesrc/commands/examples/example.py b/game/gamesrc/commands/examples/example.py index 098a9fe04a..250a195035 100644 --- a/game/gamesrc/commands/examples/example.py +++ b/game/gamesrc/commands/examples/example.py @@ -1,29 +1,40 @@ """ -This is an example command module for showing the pluggable command system -in action. +This is an example command module for showing the pluggable command +system in action. -You'll need to make sure that this or any new modules you create are added to -game/settings.py under CUSTOM_COMMAND_MODULES or CUSTOM_UNLOGGED_COMMAND_MODULES, -which are tuples of module import path strings. See src/config_defaults.py for more details. +You'll need to make sure that this or any new modules you create are +added to game/settings.py under CUSTOM_COMMAND_MODULES or +CUSTOM_UNLOGGED_COMMAND_MODULES, which are tuples of module import +path strings. See src/config_defaults.py for more details. -E.g. to add this example command for testing, your entry in game/settings.py would -look like this: +E.g. to add this example command for testing, your entry in +game/settings.py would look like this: CUSTOM_COMMAND_MODULES = ('game.gamesrc.commands.examples.example',) -(note the extra comma at the end to make this into a Python tuple. It's only -needed if you have only one entry.) You need to restart the Evennia server before new -files are recognized. - +(note the extra comma at the end to make this into a Python +tuple. It's only needed if you have only one entry.) You need to +restart the Evennia server before new files are recognized. Once this +is done once, you don't have to restart again, just use +@reload/commands to use the changes you make to your modules. """ # This is the common global CommandTable object which we'll be adding the -# example command to. We can add any number of commands this way in the -# same file. +# example command(s) to. from src.cmdtable import GLOBAL_CMD_TABLE +# The main command definition. We can add any number of commands this way in the +# same file. def cmd_example(command): """ + example - example command + + Usage: + example[/switches] + + switches: + use any string + This is the help text for the 'example' command, a command to show how the pluggable command system works. @@ -32,15 +43,17 @@ def cmd_example(command): > example/test/test2 Hello and see what is returned. - <> + [[example_auto_help]] - This is a subtopic to the main example command help entry. + This is a subtopic to the main example command help entry. It is + done by the help system splitting the text by markup of the + form [ [title ] ] (with no spaces between the square brackets) - Note that this text is auto-added since auto_help=True - was set in the call to add_function. Any number of subtopics like - this one can be added on the fly using the auto-help system. See - help topics on 'help' and 'help_staff' for more information and - options. + Note that this help entry is auto-added as long as HELP_AUTO + is not set to False in your game/settings.py file. + Any number of subtopics like this one can be added on the fly + using the auto-help system. See help topics on 'help' and + 'help_markup' for more information and options. """ # By building one big string and passing it at once, we cut down on a lot @@ -65,32 +78,35 @@ def cmd_example(command): command.source_object.emit_to(retval) # Add the command to the common global command table. Note that -# since auto_help=True, help entries named "example" and -# "example_auto_help" (as defined in the __doc__ string) will -# automatically be created for us. -GLOBAL_CMD_TABLE.add_command("example", cmd_example, auto_help=True), - -#another simple example +# this will auto-create help entries 'example' and +# "example_auto_help" for us. +GLOBAL_CMD_TABLE.add_command("example", cmd_example) +# +# another simple example +# def cmd_emote_smile(command): """ - Simplistic 'smile' emote. + smile - break a smile + + Usage: + smile + + A 'smile' emote. """ #get the source object (that is, the player using the command) - caller = command.source_object + source_object = command.source_object #find name of caller - name = caller.get_name(show_dbref=False) + name = source_object.get_name(show_dbref=False) #get the location caller is at - location = caller.get_location() + location = source_object.get_location() #build the emote text = "%s smiles." % name #emit the emote to everyone at the current location location.emit_to_contents(text) -#add to global command table (no auto_help activated) -GLOBAL_CMD_TABLE.add_command('smile', cmd_emote_smile) - - - - - +# add to global command table (we probably want an auto-help entry +# for this, but we are turning auto-help off anyway, to show +# how it works) +GLOBAL_CMD_TABLE.add_command('smile', cmd_emote_smile, + auto_help_override=False) diff --git a/game/gamesrc/commands/examples/state_example.py b/game/gamesrc/commands/examples/state_example.py index 4a40b37fd7..adb8cb0412 100644 --- a/game/gamesrc/commands/examples/state_example.py +++ b/game/gamesrc/commands/examples/state_example.py @@ -1,33 +1,42 @@ """ -Example of using the state system. The Event system allows a player object to be -'trapped' in a special environment where different commands are available than normal. -This is very useful in order to implement anything from menus to npc-conversational -choices and inline text-editors. +Example of using the state system. The State system allows a player +object to be 'trapped' in a special environment where different +commands are available than normal. This is very useful in order to +implement anything from menus and combat states to npc-conversational +choices and inline text-editors. -This example uses the State system to create a simple menu. +This example uses the State system to create a simple menu. -To test out this example, add this module to the CUSTOM_COMMAND_MODULES tuple in -your game/settings.py as 'game.gamesrc.commands.examples.state_example' (see ./example.py -for another example). You need to restart the Evennia server before new files are -recognized. +To test out this example, add this module to the +CUSTOM_COMMAND_MODULES tuple in your game/settings.py as +'game.gamesrc.commands.examples.state_example' (see ./example.py for +another example). You need to restart the Evennia server before new +files are recognized. Next enter the mud and give the command + > entermenu -Note that the help entries related to this little menu are not part of the normal -help database, they are stored with the state and only accessible -from inside it. If you want to describe the state itself in more detail you -should add a help entry about it to the main help index manually. +Note that the help entries related to this little menu are not part of +the normal help database, they are stored with the state and only +accessible from inside it. Try 'help entermenu' from outside the state +and 'help' and 'info' from inside the menu to see the auto-help system +in action. + +To further test the state system, try the command -To further test the state system, try the command > enterstate + +This takes arguments between 1-6 to set up various states with varying +access to different global commands. """ -#This is the normal command table, accessible by default +# This is the normal command table, accessible by default from src.cmdtable import GLOBAL_CMD_TABLE -#The statetable contains sets of cmdtables that is made available -#only when we are in a particular state, overriding the GLOBAL_CMD_TABLE +# The statetable contains sets of cmdtables that is made available +# only when we are in a particular state (possibly overriding +# same-named commands in GLOBAL_CMD_TABLE). from src.statetable import GLOBAL_STATE_TABLE # @@ -38,38 +47,47 @@ from src.statetable import GLOBAL_STATE_TABLE STATENAME = 'menu' # -# 'entry' command -# +# 'entry' command. This takes the player from the normal game +# mode into the menu state. This must be added to the +# GLOBAL_CMD_TABLE like any other command. +# def cmd_entermenu(command): """ - This is the 'entry' command that takes the player from the normal - gameplay mode into the 'menu' state. In order to do this, it - must be added to the GLOBAL_CMD_TABLE like any command. + entermenu - enter the example menu + + Usage: + entermenu + + This is the 'entry' command that takes the player from the normal + gameplay mode into the 'menu' state. """ - #get the player object calling the command + # get the player object calling the command source_object = command.source_object - #this is important: we use the set_state() command - #to shift the player into a state named 'menu'. Other useful - #access functions on source_object are get_state() + + # this is important: we use the set_state() command + # to shift the player into a state named 'menu'. Other useful + # access functions on source_object are get_state() # and clear_state(), the latter returns the player to # the normal mode of gameplay. source_object.set_state(STATENAME) - #show the menu. - s = """ - Welcome to the Demo menu! - In this small demo all you can do is select one of - the two options so it changes colour. - This is just intended to show off the - possibilities of the state system. More - interesting things should of course happen - in a real menu. - Use @exit to leave the menu.""" - source_object.emit_to(s) + + #show a welcome text . + string = """ + Welcome to the Demo menu! In this small demo all you can do is + select one of the two options so it changes colour. This is just + intended to show off the possibilities of the state system. More + interesting things should of course happen in a real menu. + + Use @exit to leave the menu. + """ + source_object.emit_to(string) + + # show the menu source_object.execute_cmd('menu') # -# Commands only available while in the 'menu' state. Note that -# these have auto_help, so the __doc__ strings of the functions +# Below are commands only available while in the 'menu' state. +# Note that the _doc__ strings of the functions # can be read as help entries when in the menu. # def menu_cmd_option1(command): @@ -79,6 +97,7 @@ def menu_cmd_option1(command): """ source_object = command.source_object print_menu(source_object, 1) + def menu_cmd_option2(command): """ option2 @@ -86,13 +105,20 @@ def menu_cmd_option2(command): """ source_object = command.source_object print_menu(source_object, 2) + def menu_cmd_menu(command): """ menu + Clears the options and redraws the menu. + [[autohelp]] + + Auto-help + This is an extra topic to test the auto-help functionality. The state-help - system supports nested ('related') topics just like the normal help index does. + system supports nested ('related') topics using [ [subtopic] ] markup, + just like the normal help index does. """ source_object = command.source_object print_menu(source_object) @@ -100,61 +126,50 @@ def menu_cmd_menu(command): # # helper function # -def print_menu(source_obj,choice=None): +def print_menu(source_obj, choice=None): """ Utility function to print the menu. More interesting things would happen here in a real menu. """ - if choice==1: - ch = "%s> option1\n %soption2" % ('%ch%cy','%cn%cy') #ansi colouring; see src.ansi - elif choice==2: - ch = " %soption1\n%s> option2" % ('%cn%cy','%ch%cy') + if choice == 1: + #ansi colouring; see src.ansi + chtext = "%s> option1\n %soption2" % ('%ch%cy','%cn%cy') + elif choice == 2: + chtext = " %soption1\n%s> option2" % ('%cn%cy','%ch%cy') else: - ch = " %soption1\n option2" % ('%cn%cy') + chtext = " %soption1\n option2" % ('%cn%cy') - s ="\n%sMenu: \n%s\n %shelp" % ('%ch%cr',ch,'%cn%cy') - source_obj.emit_to(s) + string ="\n%sMenu: \n%s\n %shelp \n @exit" % ('%ch%cr', chtext, '%cn%cy') + source_obj.emit_to(string) -#Add the 'entry' command to the normal command table +# Add the 'entry' command to the normal command table GLOBAL_CMD_TABLE.add_command("entermenu", cmd_entermenu) -#create the state. -GLOBAL_STATE_TABLE.add_state(STATENAME,exit_command=True) +# create the state. We make sure the player can exit it at +# any time by @exit. +GLOBAL_STATE_TABLE.add_state(STATENAME, exit_command=True) -#Add the menu commands to the state table by tying them to the 'menu' state. It is -#important that the name of the state matches what we set the player-object to in -#the 'entry' command. +# Add the menu commands to the state table by tying them to the 'menu' +# state. It is important that the name of the state matches what we +# set the player-object to in the 'entry' command. GLOBAL_STATE_TABLE.add_command(STATENAME, "option1", menu_cmd_option1) GLOBAL_STATE_TABLE.add_command(STATENAME, "option2", menu_cmd_option2) GLOBAL_STATE_TABLE.add_command(STATENAME, "menu", menu_cmd_menu) -#-----------------------testing the depth of the state system -# This is a test suite that shows off all the features of the state system. -# It sets up a test command @test_state that takes an argument 1-6 for moving into states -# with different characteristics. Note that the only difference as to how the -# various states are created lies in the options given to the add_state() function. -# Use @exit to leave any state. -# -# All states includes a small test function named "test". -# 1: A very limited state; only contains the "test" command. -# 2: All global commands are included (so this should be the same as normal operation, -# except you cannot traverse exits and use object-based cmds) -# 3: Only the global commands "get" and "inventory" are included into the state. -# 4: All global commands /except/ "get" and "inventory" are available -# 5: All global commands availabe + ability to traverse exits (not use object-based cmds). -# 6: Only the "test" command, but ability to both traverse exits and use object-based cmds. -# -# Examples of in-game use: -# 1: was used for the menu system above. -# 2: could be used in order to stop someone from moving despite exits being open (tied up?) -# 3: someone incapacitated or blinded might get only limited commands available -# 4: in e.g. a combat state, things like crafting should not be possible -# 5: Pretty much default operation, maybe limiting the use of magical weapons in a room etc? -# 6: A state of panic? You can move, but not take in your surroundings? -# ... the possibilities are endless. -#defining the test-state names so they are the same everywhere +# +# enterstate - testing the depth of the state system +# + +# This is a test suite that shows off all the features of the state +# system. It sets up a test command @test_state that takes an +# argument 1-6 for moving into states with different +# characteristics. Note that the only difference as to how the various +# states are created lies in the options given to the add_state() +# function. Use @exit to leave any state. + +# defining the test-state names so they are the same everywhere TSTATE1 = 'no_globals' TSTATE2 = 'all_globals' TSTATE3 = 'include_some_globals' @@ -163,83 +178,153 @@ TSTATE5 = 'global_allow_exits' TSTATE6 = 'noglobal_allow_exits_obj_cmds' # -#the test command @test_state +#the test command 'enterstate' # def cmd_test_state(command): - "testing the new state system" + """ + enterstate - testing the state system + + Usage: enterstate [1 - 6] + + Give arguments 1..6 to enter different game states. Use @exit to + get out of the state at any time. + + 1: A very limited state; only contains the 'test' state command. + 2: All global commands are included (so this should be the same as + normal operation, except you cannot traverse exits and use + object-based cmds) + 3: /Only/ the global commands 'get' and 'inventory' are included + into the state. + 4: All global commands /except/ 'get' and 'inventory' are available + 5: All global commands availabe + ability to traverse exits (not use + object-based cmds). + 6: Only the 'test' command available, but ability to + both traverse exits and use object-based cmds. + + Ideas for in-game use: + 1: Try out the 'entermenu' command for an example of this state. + 2: Could be used in order to stop someone from moving despite exits + being open (tied up? In combat?) + 3: someone incapacitated or blinded might get only limited commands + available + 4: in e.g. a combat state, things like crafting should not be + possible + 5: Pretty much default operation, just removing some global commands. + Maybe limiting the use of magical weapons in a room or similar. + 6: A state of panic - You can move, but not take in your surroundings. + + ... the possibilities are endless. + """ source_object = command.source_object args = command.command_argument + # check for missing arguments if not args: - source_object.emit_to("Usage: enterstate 1 - 6") - return - s = "\n Entering state ... \nThis state includes the commands 'test', 'help', '@exit' and " + source_object.emit_to("Usage: enterstate [1 - 6]") + return + # build up a return string + string = "\n Entering state ... \nThis state includes the" + string += " commands 'test', 'help', '@exit' and " arg = args.strip() - if arg=='1': - s += "no global commands at all. With some more state commands, this state would work well for e.g. a combat state or a menu where the player don't need access to the normal command definitions. Take a special look at the help command, which is in fact a state-only version of the normal help." + + # step through the various options + if arg == '1': + string += "no global commands at all. \nWith some more state commands, " + string += "this state would work well for e.g. a " + string += "combat state or a menu where the player don't need access " + string += "to the normal command definitions. Take a special " + string += "look at the help command, which is in fact a " + string += "state-only version of the normal help." state = TSTATE1 - elif arg=='2': - s += "all global commands. You should be able to do everything as normal, but not move around." + elif arg == '2': + string += "all global commands. You should be able to do " + string += "everything as normal, but not move around." state = TSTATE2 - elif arg=='3': - s += "the global commands 'inv' and 'get' only." + elif arg == '3': + string += "the global commands 'inv' and 'get' only." state = TSTATE3 - elif arg=='4': - s += "all global commands *except* 'inv' and 'get' (try using them). This allows you to disable commands that should not be possible at a certain time (like starting to craft while in a fight or something)." + elif arg == '4': + string += "all global commands *except* 'inv' and 'get' (try " + string += "using them). \nThis allows you to disable commands that " + string += "should not be possible at a certain time (like starting " + string += "to craft while in the middle of a fight or something)." state = TSTATE4 - elif arg=='5': - s += "all global commands as well as the ability to traverse exits. You do not have the ability to use commands defined on objects though." + elif arg == '5': + string += "all global commands as well as the ability to traverse " + string += "exits. You do not have the ability to use commands " + string += "defined on objects though." state = TSTATE5 - elif arg=='6': - s += "no globals at all, but you have the ability to both use exits and commands on items. This would maybe be interesting for a 'total darkness' state or maybe a 'panic' state where you can move around but cannot actually take in your surroundings." + elif arg == '6': + string += "no globals at all, but you have the ability to both " + string += "use exits and commands on items. \nThis would maybe be " + string += "interesting for a 'total darkness' state or maybe a " + string += "'panic' state where you can move around but cannot " + string += "actually take in your surroundings." state = TSTATE6 else: source_object.emit_to("Usage: enterstate 1 - 6") return #set the state source_object.set_state(state) - source_object.emit_to("%s\n (Now in state %s: '%s' ... use @exit to leave the state.)" % (s,arg,state)) - -#a simple command to include in all states. + info = "%s\n (Now in state %s: '%s' ... use @exit to leave the state.)" + source_object.emit_to(info % (string, arg, state)) +# +# define a simple command to include in all states. +# def cmd_instate_cmd(command): """ - This is the help text for the test command (created with the auto_help sytem). - This is a state-only command that does not exist outside this state. Since this state - is completely isolated from the normal gameplay, commands can also - harmlessly redefine any normal command - so if there was a normal command named + test + + Usage: + test + + This is the help text for the test command (created with the + auto_help sytem). This is a state-only command that does not + exist outside this state. Since this state is completely isolated + from the normal gameplay, commands can also harmlessly redefine + any normal command - so if there was a normal command named 'test', it would remain unchanged when we leave the state. """ - command.source_object.emit_to("This state command works!") + command.source_object.emit_to("This state command (test) works!") + +# +# Create the test states +# #define some global commands to filter for -cmdfilter = ['get','inventory'] - -#1: A simple, basic state -GLOBAL_STATE_TABLE.add_state(TSTATE1,exit_command=True) +CMDFILTER = ['get', 'inventory'] + +#1: A simple, basic state with no global commands +GLOBAL_STATE_TABLE.add_state(TSTATE1, exit_command=True) + #2: Include all normal commands in the state -GLOBAL_STATE_TABLE.add_state(TSTATE2,exit_command=True,global_cmds='all') +GLOBAL_STATE_TABLE.add_state(TSTATE2, exit_command=True, global_cmds='all') + #3: Include only the two global commands in cmdfilter -GLOBAL_STATE_TABLE.add_state(TSTATE3,exit_command=True, - global_cmds='include',global_filter=cmdfilter) +GLOBAL_STATE_TABLE.add_state(TSTATE3, exit_command=True, + global_cmds='include', global_filter=CMDFILTER) + #4: Include all global commands except the ones in cmdfilter -GLOBAL_STATE_TABLE.add_state(TSTATE4,exit_command=True, - global_cmds='exclude',global_filter=cmdfilter) +GLOBAL_STATE_TABLE.add_state(TSTATE4, exit_command=True, + global_cmds='exclude', global_filter=CMDFILTER) + #5: Include all global commands + ability to traverse exits -GLOBAL_STATE_TABLE.add_state(TSTATE5,exit_command=True, +GLOBAL_STATE_TABLE.add_state(TSTATE5, exit_command=True, global_cmds='all', allow_exits=True) + #6: No global commands, allow exits and commands defined on objects. -GLOBAL_STATE_TABLE.add_state(TSTATE6,exit_command=True, - allow_exits=True,allow_obj_cmds=True) +GLOBAL_STATE_TABLE.add_state(TSTATE6, exit_command=True, + allow_exits=True, allow_obj_cmds=True) #append the "test" function to all states -GLOBAL_STATE_TABLE.add_command(TSTATE1,'test',cmd_instate_cmd) -GLOBAL_STATE_TABLE.add_command(TSTATE2,'test',cmd_instate_cmd) -GLOBAL_STATE_TABLE.add_command(TSTATE3,'test',cmd_instate_cmd) -GLOBAL_STATE_TABLE.add_command(TSTATE4,'test',cmd_instate_cmd) -GLOBAL_STATE_TABLE.add_command(TSTATE5,'test',cmd_instate_cmd) -GLOBAL_STATE_TABLE.add_command(TSTATE6,'test',cmd_instate_cmd) +GLOBAL_STATE_TABLE.add_command(TSTATE1, 'test', cmd_instate_cmd) +GLOBAL_STATE_TABLE.add_command(TSTATE2, 'test', cmd_instate_cmd) +GLOBAL_STATE_TABLE.add_command(TSTATE3, 'test', cmd_instate_cmd) +GLOBAL_STATE_TABLE.add_command(TSTATE4, 'test', cmd_instate_cmd) +GLOBAL_STATE_TABLE.add_command(TSTATE5, 'test', cmd_instate_cmd) +GLOBAL_STATE_TABLE.add_command(TSTATE6, 'test', cmd_instate_cmd) #create the entry function for testing all states -GLOBAL_CMD_TABLE.add_command('enterstate',cmd_test_state) +GLOBAL_CMD_TABLE.add_command('enterstate', cmd_test_state) diff --git a/game/gamesrc/parents/base/basicobject.py b/game/gamesrc/parents/base/basicobject.py index f991467670..4fc54bcb66 100644 --- a/game/gamesrc/parents/base/basicobject.py +++ b/game/gamesrc/parents/base/basicobject.py @@ -3,8 +3,8 @@ This is the base object type/interface that all parents are derived from by default. Each object type sub-classes this class and over-rides methods as needed. -NOTE: This file should NOT be directly modified. Sub-class the BasicObject -class in game/gamesrc/parents/base/basicobject.py and change the +NOTE: This file should NOT be directly modified. Sub-class this in +your own class in game/gamesrc/parents and change SCRIPT_DEFAULT_OBJECT variable in settings.py to point to the new class. """ from src.script_parents.basicobject import EvenniaBasicObject @@ -18,5 +18,10 @@ def class_factory(source_obj): creates an instance of the class and returns it transparently. source_obj: (Object) A reference to the object being scripted (the child). + + Since this is the only place where the object is actually instantiated, + this is also the place to put commands you want to act on this object, + do this by obj.command_table.add_command('cmd', cmd_def). """ - return BasicObject(source_obj) + obj = BasicObject(source_obj) + return obj diff --git a/game/gamesrc/parents/base/basicplayer.py b/game/gamesrc/parents/base/basicplayer.py index e5e90cec2c..0445f44049 100644 --- a/game/gamesrc/parents/base/basicplayer.py +++ b/game/gamesrc/parents/base/basicplayer.py @@ -2,7 +2,7 @@ This is the basic Evennia-standard player parent. NOTE: This file should NOT be directly modified. Sub-class the BasicPlayer -class in game/gamesrc/parents/base/basicplayer.py and change the +class in your own class in game/gamesrc/parents and change the SCRIPT_DEFAULT_PLAYER variable in settings.py to point to the new class. """ from src.script_parents.basicobject import EvenniaBasicObject @@ -18,4 +18,4 @@ def class_factory(source_obj): source_obj: (Object) A reference to the object being scripted (the child). """ - return BasicPlayer(source_obj) \ No newline at end of file + return BasicPlayer(source_obj) diff --git a/game/gamesrc/parents/examples/custom_basicobject.py b/game/gamesrc/parents/examples/custom_basicobject.py index 7c07fec875..c98ec183cc 100644 --- a/game/gamesrc/parents/examples/custom_basicobject.py +++ b/game/gamesrc/parents/examples/custom_basicobject.py @@ -6,13 +6,15 @@ gamesrc/parents and set SCRIPT_DEFAULT_OBJECT = 'custom_basicobject' in game/settings.py. Generally, if you want to conveniently set future objects to inherit from this -script parent, this files and others like it need to be +script parent, this file and others like it need to be located under the game/gamesrc/parent directory. """ from game.gamesrc.parents.base.basicobject import BasicObject class CustomBasicObject(BasicObject): - + """ + This defines the base class of all non-player objects in game. + """ def at_object_creation(self): """ This function is called whenever the object is created. Use @@ -31,7 +33,7 @@ class CustomBasicObject(BasicObject): show_dbref=False, show_flags=False) #assign the name to the new attribute - obj.set_attribute('sdesc',name) + obj.set_attribute('sdesc', name) def at_object_destruction(self, pobject=None): """ diff --git a/game/gamesrc/parents/examples/custom_basicplayer.py b/game/gamesrc/parents/examples/custom_basicplayer.py index 458a61a518..2d4490d886 100644 --- a/game/gamesrc/parents/examples/custom_basicplayer.py +++ b/game/gamesrc/parents/examples/custom_basicplayer.py @@ -1,17 +1,19 @@ """ This is an example of customizing the basic player character object. You will want to do this to add all sorts of custom things like -attributes, skill values, injuries and so on. +attributes, skill values, injuries and so on. -If you want to make this the default player object for all players, move it -into gamesrc/parents and set SCRIPT_DEFAULT_PLAYER = 'custom_basicplayer' -in game/settings.py. +If you want to make this the default player object for all players, +move it into gamesrc/parents and set SCRIPT_DEFAULT_PLAYER = +'custom_basicplayer' in game/settings.py. """ from game.gamesrc.parents.base.basicplayer import BasicPlayer class CustomBasicPlayer(BasicPlayer): - + """ + This is the base class for all players in game. + """ def at_player_creation(self): """ Called when player object is first created. Use this diff --git a/game/gamesrc/parents/examples/red_button.py b/game/gamesrc/parents/examples/red_button.py index 02f2849d3d..cc9757a4fd 100644 --- a/game/gamesrc/parents/examples/red_button.py +++ b/game/gamesrc/parents/examples/red_button.py @@ -14,13 +14,17 @@ test button you must drop it before you will see its messages! """ from game.gamesrc.parents.base.basicobject import BasicObject -#you have to import the event definition(s) from somewhere covered by @reload, -# - this is as good a place as any. +# you have to import the event definition(s) from somewhere +# covered by @reload, and this is as good a place as any. +# Doing this will start the event ticking. + import game.gamesrc.events.example # -#commands on the button object -# +# commands for using the button object. These are added to +# the object in the class_factory function at the +# bottom of this module. +# def cmd_push_button(command): """ @@ -40,31 +44,22 @@ def cmd_pull_button(command): command.source_object.emit_to(retval) # -#The object itself +# Definition of the object itself # class RedButton(BasicObject): - - def __init__(self, scripted_obj, *args, **kwargs): - """ - This is called when class_factory() instantiates a temporary instance - of the script parent. This is typically not something you want to - mess with much. - """ - # Calling the super class' __init__ is critical! Never forget to do - # this or everything else from here on out will fail. - super(RedButton, self).__init__(scripted_obj, args, kwargs) - # Add the commands to the object's command table (this is about - #the only thing you should use the __init__ for). - self.command_table.add_command("pushbutton", cmd_push_button) - self.command_table.add_command("pullbutton", cmd_pull_button) - - + """ + This class describes an evil red button. + It will use the event definition in + game/gamesrc/events/example.py to blink + at regular intervals until the lightbulb + breaks. + """ def at_object_creation(self): """ This function is called when object is created. Use this preferably over __init__. - """ + """ #get stored object related to this class obj = self.scripted_obj @@ -73,9 +68,12 @@ class RedButton(BasicObject): obj.set_attribute("count", 0) def blink(self): - """If the event system is active, it will regularly call this function to make - the button blink. Note the use of attributes to store the variable count and - breakpoint in a persistent way.""" + """ + If the event system is active, it will regularly call this + function to make the button blink. Note the use of attributes + to store the variable count and breakpoint in a persistent + way. + """ obj = self.scripted_obj try: @@ -86,13 +84,13 @@ class RedButton(BasicObject): if count <= breakpoint: if int(count) == int(breakpoint): - s = "The button flashes, then goes dark. " - s += "Looks like the lamp just broke." + string = "The button flashes, then goes dark. " + string += "Looks like the lamp just broke." else: - s = "The red button flashes, demanding your attention." + string = "The red button flashes, demanding your attention." count += 1 - obj.set_attribute("count",count) - obj.get_location().emit_to_contents(s) + obj.set_attribute("count", count) + obj.get_location().emit_to_contents(string) def class_factory(source_obj): """ @@ -100,6 +98,12 @@ def class_factory(source_obj): creates an instance of the class and returns it transparently. source_obj: (Object) A reference to the object being scripted (the child). - """ - return RedButton(source_obj) + This is a good place for adding new commands to the button since this is + where it is actually instantiated. + """ + button = RedButton(source_obj) + # add the object-based commands to the button + button.command_table.add_command("pushbutton", cmd_push_button) + button.command_table.add_command("pullbutton", cmd_pull_button) + return button diff --git a/src/cmdhandler.py b/src/cmdhandler.py index 637e24be28..618f9bec9a 100755 --- a/src/cmdhandler.py +++ b/src/cmdhandler.py @@ -383,7 +383,7 @@ def handle(command, ignore_state=False): state_cmd_table = statetable.GLOBAL_STATE_TABLE.get_cmd_table(state) if state and state_cmd_table and not ignore_state: - # Caller is in a special state. + # Caller is in a special state. state_allow_exits, state_allow_obj_cmds = \ statetable.GLOBAL_STATE_TABLE.get_exec_rights(state) diff --git a/src/helpsys/helpsystem.py b/src/helpsys/helpsystem.py index bd1166ba11..0833519ed2 100644 --- a/src/helpsys/helpsystem.py +++ b/src/helpsys/helpsystem.py @@ -221,10 +221,10 @@ class EditHelp(object): # identify markup and do nice formatting as well as eventual # related entries to the help entries. - logger.log_infomsg("auto-help in: %s %s %s %s" % (topicstr, category, entrytext, permissions)) + #logger.log_infomsg("auto-help in: %s %s %s %s" % (topicstr, category, entrytext, permissions)) topics = self.format_help_entry(topicstr, category, entrytext, permissions) - logger.log_infomsg("auto-help: %s -> %s" % (topicstr,topics)) + #logger.log_infomsg("auto-help: %s -> %s" % (topicstr,topics)) # create the help entries: if topics: for topic in topics: diff --git a/src/objects/models.py b/src/objects/models.py index d8469830d0..9c7628382f 100755 --- a/src/objects/models.py +++ b/src/objects/models.py @@ -891,8 +891,7 @@ class Object(models.Model): script_parent: (string) String pythonic import path of the script parent assuming the python path is game/gamesrc/parents. """ - if script_parent != None and scripthandler.scriptlink(self, - str(script_parent).strip()): + if script_parent != None and scripthandler.scriptlink(self, str(script_parent).strip()): #assigning a custom parent self.script_parent = str(script_parent).strip() self.save() diff --git a/src/statetable.py b/src/statetable.py index f26a3b317f..cbd6846347 100644 --- a/src/statetable.py +++ b/src/statetable.py @@ -87,7 +87,6 @@ class StateTable(object): special conditions or clean-up operations before allowing a player to exit (e.g. combat states and text editors), in which case this feature should be turned off and handled by custom exit commands. - help_command """ state_name = state_name.strip()