Andreas/evennia
1
0
Fork 0
mirror of https://github.com/evennia/evennia.git synced 2026-03-27 18:26:32 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

* Updated and expanded the State system; the API changed a bit. You now have to first *create* the state using

Browse source 
GLOBAL_STATE_TABLE.add_state() before adding commands to it. The state can now be much more configured by including as much or as
little of the normal default commands into it as wanted (so you can now have states which are almost as normal, except some
commands are missing or change their behaviour ... illness or darkness comes to mind). The possibilities here are limitless.
* States now also optionally allow traversing exits as well as using command tables defined on objects.
* States now better handle error messages (so if you try 'look' in a state which does not contain a look command you will no
longer get the 'Huh?' but will be told that the command is not available at the moment).
* All examples in commands/examples/ have been updated to use the new State system. Also added a @test_state function for trying out
the functionality.
* Added hooks at_before_move() and at_after_move(), useful for character based move-restrictions and checks (e.g. movement speed)
* Minor tweaks to the event system; avoiding the counters to go negative should they hit an uncaught traceback.
* Small fixes of typos and minor extra safety checks.
/Griatch
This commit is contained in:
Griatch 2009-08-16 01:18:58 +00:00
parent f5b40648a6
commit 1d4f075ca7
16 changed files with 555 additions and 196 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -106,6 +106,9 @@ def print_menu(source_obj,choice=None):
#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)
#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. Since auto_help is on, we will have help entries for all commands
@ -113,3 +116,107 @@ GLOBAL_CMD_TABLE.add_command("entermenu", cmd_entermenu)
GLOBAL_STATE_TABLE.add_command(STATENAME, "option1", menu_cmd_option1,auto_help=True)
GLOBAL_STATE_TABLE.add_command(STATENAME, "option2", menu_cmd_option2,auto_help=True)
GLOBAL_STATE_TABLE.add_command(STATENAME, "menu", menu_cmd_menu,auto_help=True)
#-----------------------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
TSTATE1 = 'no_globals'
TSTATE2 = 'all_globals'
TSTATE3 = 'include_some_globals'
TSTATE4 = 'exclude_some_globals'
TSTATE5 = 'global_allow_exits'
TSTATE6 = 'noglobal_allow_exits_obj_cmds'
#the test command @test_state
def cmd_test_state(command):
"testing the new state system"
source_object = command.source_object
args = command.command_argument
if not args:
source_object.emit_to("Usage: @test_state [1..6]")
return
arg = args.strip()
if arg=='1':
state = TSTATE1
elif arg=='2':
state = TSTATE2
elif arg=='3':
state = TSTATE3
elif arg=='4':
state = TSTATE4
elif arg=='5':
state = TSTATE5
elif arg=='6':
state = TSTATE6
else:
source_object.emit_to("Usage: @test_state [1..6]")
return
#set the state
source_object.set_state(state)
source_object.emit_to("Now in state '%s' ..." % state)
#a simple command to include in all states.
def cmd_instate_cmd(command):
"test command in state"
command.source_object.emit_to("This command works!")
#define some global commands to filter for
cmdfilter = ['get','inventory']
#1: A simple, basic state
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')
#3: Include only the two global commands in 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)
#5: Include all global commands + ability to traverse exits
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)
#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)
#create the entry function for testing all states
GLOBAL_CMD_TABLE.add_command('@test_state',cmd_test_state)

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

@ -44,6 +44,24 @@ class CustomBasicObject(BasicObject):
"""
pass
def at_before_move(self, target_location):
"""
This hook is called just before the object is moved.
Input:
target_location (obj): The location the player is about to move to.
Return value:
If this function returns anything but None (no return value),
the move is aborted. This allows for character-based move
restrictions (not only exit locks).
"""
pass
def at_after_move(self):
"""
This hook is called just after the player has been successfully moved.
"""
pass
def class_factory(source_obj):
"""

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

@ -56,6 +56,13 @@ class CustomBasicPlayer(BasicPlayer):
#show us our surroundings
pobject.execute_cmd("look")
def at_move(self):
"""
This is triggered whenever the object is moved to a new location
(for whatever reason) using the src.objects.models.move_to() function.
"""
pass
def class_factory(source_obj):
"""

197
src/cmdhandler.py
View file

@ -18,6 +18,16 @@ class UnknownCommand(Exception):
Throw this when a user enters an an invalid command.
"""
pass
class CommandNotInState(Exception):
"""
Throw this when a user tries a global command that exists, but
don't happen to be defined in the current game state.
err_string: The error string returned to the user.
"""
def __init__(self,err_string):
self.err_string = err_string
class ExitCommandHandler(Exception):
"""
Thrown when something happens and it's time to exit the command handler.
@ -155,41 +165,7 @@ def match_idle(command):
command.session.count_command(silently=True)
raise ExitCommandHandler
def match_exits(command):
"""
See if we can find an input match to exits.
"""
# If we're not logged in, don't check exits.
source_object = command.source_object
location = source_object.get_location()
if location == None:
logger.log_errmsg("cmdhandler.match_exits(): Object '%s' no location." %
source_object)
return
exits = location.get_contents(filter_type=defines_global.OTYPE_EXIT)
Object = ContentType.objects.get(app_label="objects",
model="object").model_class()
exit_matches = Object.objects.list_search_object_namestr(exits,
command.command_string,
match_type="exact")
if exit_matches:
# Only interested in the first match.
targ_exit = exit_matches[0]
# An exit's home is its destination. If the exit has a None home value,
# it's not traversible.
if targ_exit.get_home():
# SCRIPT: See if the player can traverse the exit
if not targ_exit.scriptlink.default_lock(source_object):
source_object.emit_to("You can't traverse that exit.")
else:
source_object.move_to(targ_exit.get_home())
else:
source_object.emit_to("That exit leads to nowhere.")
# We found a match, kill the command handler.
raise ExitCommandHandler
def match_alias(command):
"""
Checks to see if the entered command matches an alias. If so, replaces
@ -225,6 +201,7 @@ def match_alias(command):
elif first_char == ':':
command.command_argument = get_aliased_message()
command.command_string = "pose"
# command.command_string = "emote"
# Pose without space alias.
elif first_char == ';':
command.command_argument = get_aliased_message()
@ -263,15 +240,62 @@ def match_channel(command):
command.command_string = "@cemit"
command.command_switches = ["sendername", "quiet"]
command.command_argument = second_arg
return True
def match_exits(command,test=False):
"""
See if we can find an input match to exits.
command - the command we are testing for.
if a match, move obj and exit
test - just return Truee if it is an exit command,
do not move the object there.
"""
# If we're not logged in, don't check exits.
source_object = command.source_object
location = source_object.get_location()
if location == None:
logger.log_errmsg("cmdhandler.match_exits(): Object '%s' has no location." %
source_object)
return
exits = location.get_contents(filter_type=defines_global.OTYPE_EXIT)
Object = ContentType.objects.get(app_label="objects",
model="object").model_class()
exit_matches = Object.objects.list_search_object_namestr(exits,
command.command_string,
match_type="exact")
if exit_matches:
if test:
return True
# Only interested in the first match.
targ_exit = exit_matches[0]
# An exit's home is its destination. If the exit has a None home value,
# it's not traversible.
if targ_exit.get_home():
# SCRIPT: See if the player can traverse the exit
if not targ_exit.scriptlink.default_lock(source_object):
source_object.emit_to("You can't traverse that exit.")
else:
source_object.move_to(targ_exit.get_home())
else:
source_object.emit_to("That exit leads nowhere.")
# We found a match, kill the command handler.
raise ExitCommandHandler
def command_table_lookup(command, command_table, eval_perms=True):
def command_table_lookup(command, command_table, eval_perms=True,test=False):
"""
Performs a command table lookup on the specified command table. Also
evaluates the permissions tuple.
The test flag only checks without manipulating the command
"""
# Get the command's function reference (Or False)
cmdtuple = command_table.get_command_tuple(command.command_string)
if cmdtuple:
if test:
return True
# If there is a permissions element to the entry, check perms.
if eval_perms and cmdtuple[1]:
if not command.source_object.has_perm_list(cmdtuple[1]):
@ -281,24 +305,30 @@ def command_table_lookup(command, command_table, eval_perms=True):
command.command_function = cmdtuple[0]
command.extra_vars = cmdtuple[2]
return True
def match_neighbor_ctables(command):
def match_neighbor_ctables(command,test=False):
"""
Looks through the command tables of neighboring objects for command
matches.
test mode just checks if the command is a match, without manipulating
any commands.
"""
source_object = command.source_object
if source_object.location != None:
neighbors = source_object.location.get_contents()
for neighbor in neighbors:
if command_table_lookup(command,
neighbor.scriptlink.command_table):
neighbor.scriptlink.command_table, test=test):
# If there was a command match, set the scripted_obj attribute
# for the script parent to pick up.
if test:
return True
command.scripted_obj = neighbor
return True
# No matches
return False
else:
#no matches
return False
def handle(command):
"""
@ -315,44 +345,52 @@ def handle(command):
# Nothing sent in of value, ignore it.
raise ExitCommandHandler
state = None #no state by default
if command.session and not command.session.logged_in:
# Not logged in, look through the unlogged-in command table.
command_table_lookup(command, cmdtable.GLOBAL_UNCON_CMD_TABLE,
eval_perms=False)
else:
command_table_lookup(command, cmdtable.GLOBAL_UNCON_CMD_TABLE,eval_perms=False)
else:
# User is logged in.
# Match against the 'idle' command.
match_idle(command)
# See if this is an aliased command.
match_alias(command)
state_name = command.source_object.get_state()
state_cmd_table = statetable.GLOBAL_STATE_TABLE.get_cmd_table(state_name)
state = command.source_object.get_state()
state_cmd_table = statetable.GLOBAL_STATE_TABLE.get_cmd_table(state)
if state_name and state_cmd_table:
# we are in a special state.
if state and state_cmd_table:
# Caller is in a special state.
# check idle command.
match_idle(command)
# check for channel commands
prev_command = command.command_string
match_channel(command)
if prev_command != command.command_string:
# a channel command is handled normally also in the state
state_allow_exits, state_allow_obj_cmds = \
statetable.GLOBAL_STATE_TABLE.get_state_flags(state)
state_lookup = True
if match_channel(command):
command_table_lookup(command, cmdtable.GLOBAL_CMD_TABLE)
else:
command_table_lookup(command, state_cmd_table)
state_lookup = False
# See if the user is trying to traverse an exit.
if state_allow_exits:
match_exits(command)
# check if this is a command defined on a nearby object.
if state_allow_obj_cmds and match_neighbor_ctables(command):
state_lookup = False
#if nothing has happened to change our mind, search the state table.
if state_lookup:
command_table_lookup(command, state_cmd_table)
else:
#normal operation
# Not in a state. Normal operation.
state = None #make sure, in case the object had a malformed statename.
# Match against the 'idle' command.
match_idle(command)
# See if this is an aliased command.
match_alias(command)
# Check if the user is using a channel command.
# Check if the user is using a channel command.
match_channel(command)
# See if the user is trying to traverse an exit.
# See if the user is trying to traverse an exit.
match_exits(command)
neighbor_match_found = match_neighbor_ctables(command)
if not neighbor_match_found:
# Retrieve the appropriate (if any) command function.
command_table_lookup(command, cmdtable.GLOBAL_CMD_TABLE)
# check if this is a command defined on a nearby object
if not match_neighbor_ctables(command):
command_table_lookup(command, cmdtable.GLOBAL_CMD_TABLE)
"""
By this point, we assume that the user has entered a command and not
@ -379,16 +417,37 @@ def handle(command):
raise ExitCommandHandler
else:
# If we reach this point, we haven't matched anything.
if state:
# if we are in a state, it could be that the command exists, but
# it is temporarily not available. If so, we want a different error message.
if match_exits(command,test=True):
raise CommandNotInState("Movement is not possible right now.")
if match_neighbor_ctables(command,test=True):
raise CommandNotInState("You can not do that at the moment.")
if command_table_lookup(command,cmdtable.GLOBAL_CMD_TABLE,test=True):
raise CommandNotInState("This command is not available right now.")
raise UnknownCommand
except ExitCommandHandler:
# When this is thrown, just get out and do nothing. It doesn't mean
# something bad has happened.
pass
except CommandNotInState, e:
# The command exists, but not in the current state
if command.source_object != None:
# The logged-in error message
command.source_object.emit_to(e.err_string)
elif command.session != None:
# States are not available before login, so this should never
# be reached. But better safe than sorry.
command.session.msg("%s %s" % (e.err_string," (Type \"help\" for help.)"))
else:
pass
except UnknownCommand:
# Default fall-through. No valid command match.
if command.source_object != None:
# A typical logged in or object-based error message.
# A typical logged in or object-based error message.
command.source_object.emit_to("Huh? (Type \"help\" for help.)")
elif command.session != None:
# This is hit when invalid commands are sent at the login screen

2
src/cmdtable.py
View file

@ -28,7 +28,7 @@ class CommandTable(object):
self.ctable = {}
def add_command(self, command_string, function, priv_tuple=None,
extra_vals=None, auto_help=False, staff_help=False, state=None):
extra_vals=None, auto_help=False, staff_help=False):
"""
Adds a command to the command table.

15
src/commands/objmanip.py
View file

@ -290,11 +290,6 @@ def cmd_create(command):
target_name = eq_args[0]
# Create and set the object up.
# TODO: This dictionary stuff is silly. Feex.
#odat = {"name": target_name,
# "type": defines_global.OTYPE_THING,
# "location": source_object,
# "owner": source_object}
new_object = Object.objects.create_object(target_name,
defines_global.OTYPE_THING,
source_object,
@ -434,11 +429,6 @@ def cmd_open(command):
source_object.emit_to("You can't open an exit to an exit!")
return
#odat = {"name": exit_name,
# "type": defines_global.OTYPE_EXIT,
# "location": source_object.get_location(),
# "owner": source_object,
# "home": destination}
new_object = Object.objects.create_object(exit_name,
defines_global.OTYPE_EXIT,
source_object.get_location(),
@ -466,11 +456,6 @@ def cmd_open(command):
else:
# Create an un-linked exit.
#odat = {"name": exit_name,
# "type": defines_global.OTYPE_EXIT,
# "location": source_object.get_location(),
# "owner": source_object,
# "home": None}
new_object = Object.objects.create_object(exit_name,
defines_global.OTYPE_EXIT,
source_object.get_location(),

8
src/events.py
View file

@ -4,6 +4,8 @@ Holds the global events scheduled in scheduler.py.
Events are sub-classed from IntervalEvent (which is not to be used directly).
Create your sub-class, call src.scheduler.add_event(YourEventClass()) to add
it to the global scheduler.
Use @ps to view the event list.
"""
import time
from twisted.internet import task
@ -58,7 +60,7 @@ class IntervalEvent(object):
"""
Returns a value in seconds when the event is going to fire off next.
"""
return (self.time_last_executed + self.interval) - time.time()
return max(0,(self.time_last_executed + self.interval) - time.time())
def set_lastfired(self):
"""
@ -73,8 +75,6 @@ class IntervalEvent(object):
self.set_lastfired()
self.event_function()
class IEvt_Check_Sessions(IntervalEvent):
"""
Event: Check all of the connected sessions.
@ -99,7 +99,7 @@ class IEvt_Destroy_Objects(IntervalEvent):
super(IEvt_Destroy_Objects, self).__init__()
self.name = 'IEvt_Destroy_Objects'
self.interval = 1800
self.description = "Destroy objects with the GOING flag set."
self.description = "Clean out objects marked for destruction."
def event_function(self):
"""

9
src/imc2/events.py
View file

@ -27,7 +27,12 @@ class IEvt_IMC2_Send_IsAlive(events.IntervalEvent):
"""
This is the function that is fired every self.interval seconds.
"""
imc2_conn.IMC2_PROTOCOL_INSTANCE.send_packet(IMC2PacketIsAlive())
try:
imc2_conn.IMC2_PROTOCOL_INSTANCE.send_packet(IMC2PacketIsAlive())
except AttributeError:
#this will happen if we are not online in the first place
#(like during development) /Griatch
pass
class IEvt_IMC2_Send_Keepalive_Request(events.IntervalEvent):
"""
@ -77,4 +82,4 @@ def add_events():
"""
scheduler.add_event(IEvt_IMC2_Send_IsAlive())
scheduler.add_event(IEvt_IMC2_Prune_Inactive_Muds())
scheduler.add_event(IEvt_IMC2_Send_Keepalive_Request())
scheduler.add_event(IEvt_IMC2_Send_Keepalive_Request())

10
src/initial_setup.py
View file

@ -1,5 +1,5 @@
"""
This module handles initial database propagation, which is only ran the first
This module handles initial database propagation, which is only run the first
time the game starts. It will create some default channels, objects, and
other things.
@ -30,11 +30,14 @@ def create_objects():
"""
# Set the initial User's account object's username on the #1 object.
god_user = get_god_user()
god_user.is_superuser = True
god_user.is_staff = True
# Create the matching PLAYER object in the object DB.
god_user_obj = Object(id=1, type=defines_global.OTYPE_PLAYER)
god_user_obj.set_name(god_user.username)
god_user_obj.set_attribute('desc', 'You are Player #1.')
god_user_obj.scriptlink.at_player_creation()
god_user_obj.save()
# Limbo is the initial starting room.
@ -91,8 +94,9 @@ def create_connect_screens():
Creates the default connect screen(s).
"""
ConnectScreen(name="Default",
text="%ch%cb==================================================================%cn\r\n Welcome to Evennia! Please type one of the following to begin:\r\n\r\n If you have an existing account, connect to it by typing:\r\n %chconnect <email> <password>%cn\r\n If you need to create an account, type (without the <>'s):\r\n %chcreate \"<username>\" <email> <password>%cn\r\n%ch%cb==================================================================%cn\r\n",
text="%ch%cb==================================================================%cn\r\n Welcome to %chEvennia%cn! Please type one of the following to begin:\r\n\r\n If you have an existing account, connect to it by typing:\r\n %chconnect <email> <password>%cn\r\n If you need to create an account, type (without the <>'s):\r\n %chcreate \"<username>\" <email> <password>%cn\r\n%ch%cb==================================================================%cn\r\n",
is_active=True).save()
def create_aliases():
"""
@ -107,7 +111,7 @@ def create_aliases():
CommandAlias(user_input="l", equiv_command="look").save()
CommandAlias(user_input="ex", equiv_command="examine").save()
CommandAlias(user_input="sa", equiv_command="say").save()
CommandAlias(user_input="emote", equiv_command="pose").save()
#CommandAlias(user_input="emote", equiv_command="pose").save()
CommandAlias(user_input="p", equiv_command="page").save()
def import_help_files():

21
src/objects/managers/object.py
View file

@ -8,6 +8,7 @@ from django.db import connection
from django.contrib.auth.models import User
from django.db.models import Q
from django.contrib.contenttypes.models import ContentType
from django.conf import settings
from src.config.models import ConfigValue
from src.objects.exceptions import ObjectNotExist
@ -83,7 +84,6 @@ class ObjectManager(models.Manager):
Searches through all objects returning those which has a certain script parent.
"""
o_query = self.filter(script_parent__exact=script_parent)
return o_query.exclude(type__in=[defines_global.OTYPE_GARBAGE,
defines_global.OTYPE_GOING])
@ -124,7 +124,6 @@ class ObjectManager(models.Manager):
return dbtotals
def player_alias_search(self, searcher, ostring):
"""
Search players by alias. Returns a list of objects whose "ALIAS"
@ -288,8 +287,10 @@ class ObjectManager(models.Manager):
if otype == defines_global.OTYPE_PLAYER:
new_object.owner = None
new_object.zone = None
new_object.script_parent = settings.SCRIPT_DEFAULT_PLAYER
else:
new_object.owner = owner
new_object.script_parent = settings.SCRIPT_DEFAULT_OBJECT
if new_object.get_owner().get_zone():
new_object.zone = new_object.get_owner().get_zone()
@ -308,7 +309,7 @@ class ObjectManager(models.Manager):
# Rooms have a NULL location.
if not new_object.is_room():
new_object.move_to(location, force_look=False)
new_object.move_to(location, quiet=True, force_look=False)
return new_object
@ -350,11 +351,6 @@ class ObjectManager(models.Manager):
user = User.objects.get(id=uid)
# Create a player object of the same ID in the Objects table.
#odat = {"id": uid,
# "name": uname,
# "type": defines_global.OTYPE_PLAYER,
# "location": start_room_obj,
# "owner": None}
user_object = self.create_object(uname,
defines_global.OTYPE_PLAYER,
start_room_obj,
@ -368,9 +364,12 @@ class ObjectManager(models.Manager):
command.session.login(user)
logger.log_infomsg('Registration: %s' % user_object.get_name())
user_object.emit_to("Welcome to %s, %s.\n\r" % (
ConfigValue.objects.get_configvalue('site_name'),
user_object.get_name(show_dbref=False)))
#Don't show the greeting; it messes with using the login hooks for
#making character creation wizards. /Griatch
#user_object.emit_to("Welcome to %s, %s.\n\r" % (
# ConfigValue.objects.get_configvalue('site_name'),
# user_object.get_name(show_dbref=False)))
# Add the user to all of the CommChannel objects that are flagged
# is_joined_by_default.

39
src/objects/models.py
View file

@ -127,7 +127,7 @@ class Object(models.Model):
objects = ObjectManager()
#state system can set a particular command table to be used.
#state system can set a particular command table to be used (not persistent).
state = None
def __cmp__(self, other):
@ -141,6 +141,12 @@ class Object(models.Model):
class Meta:
ordering = ['-date_created', 'id']
def dbref(self):
"""Returns the object's dbref id on the form #NN, directly
usable by Object.objects.dbref_search()
"""
return "#%s" % str(self.id)
"""
BEGIN COMMON METHODS
@ -245,8 +251,7 @@ class Object(models.Model):
Returns True if the object is a staff player.
"""
if not self.is_player():
return False
return False
try:
profile = self.get_user_account()
return profile.is_staff
@ -303,7 +308,7 @@ class Object(models.Model):
user. This form accepts an iterable of strings representing permissions,
if the user has any of them return true.
perm: (iterable) An iterable of strings of permissions.
perm_list: (iterable) An iterable of strings of permissions.
"""
if not self.is_player():
return False
@ -705,9 +710,9 @@ class Object(models.Model):
# in SQLite.
flags = str(self.flags).split()
nosave_flags = str(self.nosave_flags).split()
return flag in flags or flag in nosave_flags
return flag.upper() in flags or flag in nosave_flags
def set_flag(self, flag, value):
def set_flag(self, flag, value=True):
"""
Add a flag to our object's flag list.
@ -735,7 +740,7 @@ class Object(models.Model):
# Object doesn't have the flag to begin with.
pass
elif value == True and has_flag:
# We've already go it.
# We've already got it.
pass
else:
# Setting a flag.
@ -755,6 +760,9 @@ class Object(models.Model):
flags.append(flag)
self.flags = ' '.join(flags)
self.save()
def unset_flag(self, flag):
self.set_flag(flag,value=False)
def is_connected_plr(self):
"""
@ -885,8 +893,13 @@ class Object(models.Model):
target: (Object) Reference to the object to move to.
quiet: (bool) If true, don't emit left/arrived messages.
force_look: (bool) If true and target is a player, make them 'look'.
force_look: (bool) If true and self is a player, make them 'look'.
"""
#before the move, call the appropriate hook
if self.scriptlink.at_before_move(target) != None:
return
if not quiet:
location = self.get_location()
if location:
@ -897,17 +910,21 @@ class Object(models.Model):
(self.get_name()))
self.location = target
self.save()
self.save()
if not quiet:
arrival_message = "%s has arrived." % (self.get_name())
self.get_location().emit_to_contents(arrival_message, exclude=self)
if self.location.is_player():
self.location.emit_to("%s is now in your inventory." % (self.get_name()))
#execute eventual extra commands on this object after moving it
self.scriptlink.at_after_move()
if force_look:
self.execute_cmd('look')
def dbref_match(self, oname):
"""
Check if the input (oname) can be used to identify this particular object

5
src/scheduler.py
View file

@ -21,8 +21,9 @@ def add_event(event):
* event: (IntervalEvent) The event to add to the scheduler.
"""
#don't add multiple instances of the same event
if event in schedule:
#don't add multiple instances of the same event, instead replace
if event in schedule:
schedule[schedule.index(event)] = event
return
else:
schedule.append(event)

18
src/script_parents/basicobject.py
View file

@ -72,6 +72,24 @@ class EvenniaBasicObject(object):
#print "SCRIPT TEST: %s got %s." % (pobject, self.scripted_obj)
pass
def at_before_move(self, target_location):
"""
This hook is called just before the object is moved.
arg:
target_location (obj): the place where this object is to be moved
returns:
if this function returns anything but None, the move is cancelled.
"""
pass
def at_after_move(self):
"""
This hook is called just after the object was successfully moved.
No return values.
"""
pass
def at_drop(self, pobject):
"""
Perform this action when someone uses the DROP command on the object.

29
src/script_parents/basicplayer.py
View file

@ -44,3 +44,32 @@ class EvenniaBasicPlayer(object):
pobject.get_location().emit_to_contents("%s has connected." %
(pobject.get_name(show_dbref=False),), exclude=pobject)
pobject.execute_cmd("look")
def at_before_move(self, target_location):
"""
This hook is called just before the object is moved.
Input:
target_location (obj): The location the player is about to move to.
Return value:
If this function returns anything but None (no return value),
the move is aborted. This allows for character-based move
restrictions (not only exit locks).
"""
pass
def at_after_move(self):
"""
This hook is called just after the player has been successfully moved.
"""
pass
def at_disconnect(self):
"""
This is called just before the session disconnects, for whatever reason.
"""
pobject = self.scripted_obj
location = pobject.get_location()
if location != None:
location.emit_to_contents("%s has disconnected." % (pobject.get_name(show_dbref=False),), exclude=pobject)

27
src/session.py
View file

@ -20,7 +20,7 @@ import ansi
class SessionProtocol(StatefulTelnetProtocol):
"""
This class represents a player's sesssion. From here we branch down into
This class represents a player's session. From here we branch down into
other various classes, please try to keep this one tidy!
"""
@ -110,12 +110,12 @@ class SessionProtocol(StatefulTelnetProtocol):
"""
pobject = self.get_pobject()
if pobject:
pobject.set_flag("CONNECTED", False)
location = pobject.get_location()
if location != None:
location.emit_to_contents("%s has disconnected." % (pobject.get_name(show_dbref=False),), exclude=pobject)
#call hook function
pobject.scriptlink.at_disconnect()
pobject.set_flag("CONNECTED", False)
uaccount = pobject.get_user_account()
uaccount.last_login = datetime.now()
uaccount.save()
@ -169,9 +169,8 @@ class SessionProtocol(StatefulTelnetProtocol):
# This will cache with the first call of this function.
self.get_pobject()
#session_mgr.disconnect_duplicate_session(self)
self.pobject.scriptlink.at_pre_login(self)
self.pobject.scriptlink.at_post_login(self)
logger.log_infomsg("Logged in: %s" % self)
self.cemit_info('Logged in: %s' % self)
@ -184,6 +183,9 @@ class SessionProtocol(StatefulTelnetProtocol):
if self.pobject.name != user.username:
self.pobject.set_name(user.username)
self.pobject.save()
self.pobject.scriptlink.at_post_login(self)
def msg(self, message):
"""
@ -198,6 +200,15 @@ class SessionProtocol(StatefulTelnetProtocol):
Adds the player to the default channels.
"""
# Add the default channels.
if self.pobject.is_superuser():
"Have the super users join these too."
chan = CommChannel.objects(name=settings.COMMCHAN_MUD_INFO)
chan_alias = 'info'
src.comsys.plr_set_channel(self, chan_alias, chan.name, True)
chan = CommChannel.objects(name=settings.COMMCHAN_MUD_CONNECTIONS)
chan_alias = 'conns'
src.comsys.plr_set_channel(self, chan_alias, chan.name, True)
for chan in CommChannel.objects.filter(is_joined_by_default=True):
logger.log_infomsg("ADDING BY DEFAULT %s" % chan)
chan_alias = chan.get_default_chan_alias()

239
src/statetable.py
View file

@ -1,11 +1,13 @@
"""
The state system allows the player to enter a state where only a special set of commands
The state system allows the player to enter states/modes where only a special set of commands
are available. This can be used for all sorts of useful things:
- in-game menus (picking an option from a list)
- in-game menus (picking an option from a list, much more powerful than using 'rooms')
- inline text editors (entering text into a buffer)
- npc conversation (select replies)
- commands only available while in 'combat mode' etc
This allows for more power than using rooms to build 'menus'.
- only allowing certain commands in special situations (e.g. special attack commands
when in 'combat' mode)
- adding special commands to the normal set (e.g. a 'howl' command when in 'werewolf' state)
- deactivating certain commands (e.g. removing the 'say' command in said 'werewolf' state ...)
Basically the GLOBAL_STATE_TABLE contains a dict with command tables keyed after the
name of the state. To use, a function must set the 'state' variable on a player object
@ -15,97 +17,181 @@ of the normal global command table.
The state system is pluggable, in the same way that commands are added to the global command
table, commands are added to the GLOBAL_STATE_TABLE using add_command supplying in
addition the name of the state.
addition the name of the state. The main difference is that new states must first be created
using the GLOBAL_STATE_TABLE.add_state() command. See examples in game/gamesrc.
"""
from cmdtable import CommandTable
from cmdtable import CommandTable, GLOBAL_CMD_TABLE
from logger import log_errmsg
import src.helpsys.management.commands.edit_helpfiles as edit_help
class StateTable(object):
state_table = None
def __init__(self):
self.state_table = {}
self.help_index = StateHelpIndex()
def __init__(self):
self.state_table = {} #of the form {statename:CommandTable, ...}
self.help_index = StateHelpIndex()
self.state_flags = {}
def add_state(self, state_name,
global_cmds=None, global_filter=[],
allow_exits=False, allow_obj_cmds=False,
exit_command=False):
"""
Creates a new game state. Each state has its own unique set of commands and
can change how the game works.
state_name (str) : name of the state. If state already exists,
it will be overwritten.
global_cmds(None or str): A flag to control imports of global commands into the state.
None - Do not include any global commands in this state (default).
'all' - Include all global commands from GLOBAL_CMD_TABLE,
without using the global_filter argument at all.
'include' - Include only global commands from GLOBAL_CMD_TABLE
that are listed in global_filter. OBS:the global
'help' command will always automatically be included.
'exclude' - Include all global commands from GLOBAL_CMD_TABLE
/except/ those listed in global_filter.
global_filter (list): This should be a list of command strings (like
['look', '@create',...]). Depending on the global_cmds setting, this
list is used to control which global commands are imported from
GLOBAL_CMD_TABLE into this state.
allow_exits (bool): Evennia works so that an exit might have any name. A user
may just write e.g. 'outside' and if there is an exit in the room
named 'outside' the engine interprets this as a command for
traversing this exit. Normally a state disables this check, so
a user may not traverse exits while in the state. This switch turns
the check back on and allows users to move around also
while in the state. Observe that to make this work well you will
have to have at least a 'look' command defined in your state
(since this is called whenever you enter a new room).
allow_obj_cmds (bool): Any object in a room can have its own command table assigned
to it (such as the ability to 'play' on a flute). Normally these
commands are not accessible while in a state. This switch
allows the interpreter to also search objects for commands and will
use them before using any same-named state commands.
exit_command(bool): Adds a special '@exit' command that immediately quits the
state. This is useful for testing. Many states might however require
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.
"""
state_name = state_name.strip()
#create state
self.state_table[state_name] = CommandTable()
if global_cmds != None:
if global_cmds == 'all':
f = lambda c: True
elif global_cmds == 'include':
f = lambda c: c in global_filter
if not 'help' in global_filter:
global_filter.append('help')
elif global_cmds == 'exclude':
f = lambda c: c not in global_filter
else:
log_errmsg("ERROR: in statetable, state %s: Unknown global_cmds flag '%s'." %
(state_name, global_cmds))
return
for cmd in filter(f,GLOBAL_CMD_TABLE.ctable.keys()):
self.state_table[state_name].ctable[cmd] = \
GLOBAL_CMD_TABLE.get_command_tuple(cmd)
if exit_command:
#if we import global commands, we use the normal help index; thus add
#help for @exit to the global index.
self.state_table[state_name].add_command("@exit",
cmd_state_exit,
auto_help=True)
else:
#when no global cmds are imported, we create a small custom
#state-based help index instead
self.help_index.add_state(state_name)
self.add_command(state_name,'help',cmd_state_help)
if exit_command:
#add the @exit command
self.state_table[state_name].add_command("@exit",
cmd_state_exit)
self.help_index.add_state_help(state_name, "@exit",
cmd_state_exit.__doc__)
#store special state flags
self.state_flags[state_name] = {}
self.state_flags[state_name]['exits'] = allow_exits
self.state_flags[state_name]['obj_cmds'] = allow_obj_cmds
def del_state(self, state_name):
"""
Permanently deletes a state from the state table. Make sure no users are in
the state upon calling this command. Note that setting an object to a
non-existing state name is harmless, if the state does not exist the
interpreter ignores it and assumes normal operation.
Auto-created global help entries will have to be deleted manually.
"""
if self.state_table.has_key(state_name):
del self.state_table[state_name]
def del_command(self, state_name, command_string):
"""
Deactivate a command within a state. This is mostly useful for states that
also includes the full global command table, allowing for deactivating individual
commands dynamically.
state_name (str) : name of the state to delete a command from
command_string (str) : command name to deactivate, e.g. @edit, look etc
"""
if not self.state_table[state_name].has_key():
return
try:
del self.state_table[state_name].ctable[command_string]
err = self.help_index.del_state_help(state_name,command_string)
except KeyError:
pass
def add_command(self, state_name, command_string, function, priv_tuple=None,
extra_vals=None, auto_help=False, staff_help=False, help_global=False,
exit_command=True):
extra_vals=None, auto_help=False, staff_help=False):
"""
Access function; transparently add commands to a specific command table to
represent a particular state. This command is similar to the normal
Transparently add commands to a specific state.
This command is similar to the normal
command_table.add_command() function. See example in gamesrc/commands/examples.
state_name: (str) identifier of the state we tie this to.
command_string: (str) command name to run, like look, @list etc
function: (reference) command function object
state_name: (str) identifier of the state we tie this to.
priv_tuple: (tuple) String tuple of permissions required for command.
extra_vals: (dict) Dictionary to add to the Command object.
auto_help: (bool) Activate the auto_help system. By default this stores the
help inside the statetable only (not in the main help database), and so
the help entries are only available when the player is actually inside
the state. Note that the auto_help system of state-commands do not
support <<TOPIC:mytitle>> markup.
staff_help: (bool) Help entry is only available for staff players.
help_global: (bool) Also auto_add the help entry to the main help database. Be
careful with overwriting same-named help topics if you define special
versions of commands inside your state.
exit_command: (bool) Sets if the default @exit command is added to the state. Only
one command needs to include this statement in order to add @exit. This is
usually a good idea to make sure the player is not stuck, but you might want
to turn this off if you know what you're doing and want to avoid players
'escaping' the state (like in a combat state or similar), or when
you need to do some special final cleanup or save operations before
exiting (like in a text editor).
"""
if not state_name:
log_errmsg("Command %s was not given a state. Not added." % command_string)
if state_name not in self.state_table.keys():
log_errmsg("State %s is not a valid state for command %s. Not added." % \
(state_name, command_string))
return
state_name = state_name.strip()
if not self.state_table.has_key(state_name):
#create the state
self.state_table[state_name] = CommandTable()
#always add a help index even though it might not be used.
self.help_index.add_state(state_name)
if exit_command:
#add the @exit command
self.state_table[state_name].add_command("@exit",
cmd_state_exit,
auto_help=True)
if auto_help:
#add help for @exit command
self.help_index.add_state_help(state_name, "@exit",
cmd_state_exit.__doc__)
#handle auto-help for the state
#handle auto-help for the state commands
if auto_help:
if self.help_index.has_state(state_name):
#add the help text to state help index only, don't add
#it to the global help index
self.help_index.add_state_help(state_name,command_string,
function.__doc__,
staff_help=staff_help)
auto_help = False
#make sure the state's help command is in place
self.state_table[state_name].add_command('help',cmd_state_help)
#add the help text
helptext = function.__doc__
self.help_index.add_state_help(state_name,command_string,
helptext,staff_only=staff_help)
if not help_global:
#if we don't want global help access, we need to
#turn off auto_help before adding the command.
auto_help = False
#finally add the new command to the state
#finally add the new command to the state's command table
self.state_table[state_name].add_command(command_string,
function, priv_tuple,
extra_vals,auto_help,
staff_help)
function, priv_tuple,
extra_vals,auto_help=auto_help,
staff_help=staff_help)
def get_cmd_table(self, state_name):
"""
@ -115,6 +201,16 @@ class StateTable(object):
return self.state_table[state_name]
else:
return None
def get_state_flags(self, state_name):
"""
Return the state flags for a particular state.
"""
if self.state_flags.has_key(state_name):
return self.state_flags[state_name]['exits'],\
self.state_flags[state_name]['obj_cmds']
else:
return False, False
class StateHelpIndex(object):
@ -130,6 +226,9 @@ class StateHelpIndex(object):
"Create a new state"
self.help_index[state_name] = {}
def has_state(self,state_name):
return self.help_index.has_key(state_name)
def add_state_help(self, state,command,text,staff_only=False):
"""Store help for a command under a certain state.
Supports <<TOPIC:MyTopic>> and <<TOPIC:STAFF:MyTopic>> markup."""
@ -147,7 +246,7 @@ class StateHelpIndex(object):
self.help_index[state][command] = (staff_only, text)
def del_state_help(self, state, topic):
"""Manually delete an help topic from state help system. Note that this is
"""Manually delete a help topic from state help system. Note that this is
only going to last until the next @reload unless you also turn off auto_help
for the relevant topic."""
if self.help_index.has_key(state) and self.help_index[state].has_key(topic):
@ -185,21 +284,21 @@ class StateHelpIndex(object):
def cmd_state_exit(command):
"""@exit (when in a state)
This command only works when inside a special game 'state' (like a menu or
editor or similar place where you have fewer commands available than normal).
This command only works when inside certain special game 'states' (like a menu or
editor or similar situations).
It aborts what you were doing and force-exits back to the normal mode of
gameplay. Some states might deactivate the @exit command for various reasons.
In those cases, read the help when in the state to learn more."""
gameplay. Some states might deactivate the @exit command for various reasons."""
source_object = command.source_object
source_object.clear_state()
source_object.emit_to("... Exited.")
source_object.execute_cmd('look')
def cmd_state_help(command):
"""
help <topic> (while in a state)
help <topic> (while in a special state)
In-state help system. This is NOT tied to the normal help
system and is not stored in the database. It is intended as a quick
@ -248,5 +347,5 @@ def cmd_state_help(command):
else:
source_object.emit_to("No help available on %s." % args)
#import this into modules
GLOBAL_STATE_TABLE = StateTable()