Andreas/evennia
1
0
Fork 0
mirror of https://github.com/evennia/evennia.git synced 2026-03-17 05:16:31 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Some cleanup. Fixed all examples to match the changes in the states and help systems, also

Browse source 
ran them through pylint to pretty them up.
/Griatch
This commit is contained in:
Griatch 2009-10-15 09:43:34 +00:00
parent 8074617285
commit 84aeabb272
11 changed files with 323 additions and 211 deletions
Download patch file Download diff file Expand all files Collapse all files

90
game/gamesrc/commands/examples/example.py
View file

@ -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] <text>
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.
<<TOPIC:example_auto_help>>
[[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)

331
game/gamesrc/commands/examples/state_example.py
View file

@ -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)

11
game/gamesrc/parents/base/basicobject.py
View file

@ -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

4
game/gamesrc/parents/base/basicplayer.py
View file

@ -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)
return BasicPlayer(source_obj)

8
game/gamesrc/parents/examples/custom_basicobject.py
View file

@ -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):
"""

12
game/gamesrc/parents/examples/custom_basicplayer.py
View file

@ -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

68
game/gamesrc/parents/examples/red_button.py
View file

@ -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

2
src/cmdhandler.py
View file

@ -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)

4
src/helpsys/helpsystem.py
View file

@ -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:

3
src/objects/models.py
View file

@ -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()

1
src/statetable.py
View file

@ -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()