def typeclass_search(self,
typeclass,
include_children=False,
include_parents=False):
"""
Searches through all objects returning those which has a
certain typeclass. If location is set, limit search to objects
in that location.
Args:
typeclass (str or class): A typeclass class or a python path to a typeclass.
include_children (bool, optional): Return objects with
given typeclass *and* all children inheriting from this
typeclass. Mutuall exclusive to `include_parents`.
include_parents (bool, optional): Return objects with
given typeclass *and* all parents to this typeclass.
Mutually exclusive to `include_children`.
Returns:
objects (list): The objects found with the given typeclasses.
"""
if callable(typeclass):
cls = typeclass.__class__
typeclass = "%s.%s" % (cls.__module__, cls.__name__)
elif not isinstance(typeclass, basestring) and hasattr(
typeclass, "path"):
typeclass = typeclass.path
# query objects of exact typeclass
query = Q(db_typeclass_path__exact=typeclass)
if include_children:
# build requests for child typeclass objects
clsmodule, clsname = typeclass.rsplit(".", 1)
cls = variable_from_module(clsmodule, clsname)
subclasses = cls.__subclasses__()
if subclasses:
for child in (child for child in subclasses
if hasattr(child, "path")):
query = query | Q(db_typeclass_path__exact=child.path)
elif include_parents:
# build requests for parent typeclass objects
clsmodule, clsname = typeclass.rsplit(".", 1)
cls = variable_from_module(clsmodule, clsname)
parents = cls.__mro__
if parents:
for parent in (parent for parent in parents
if hasattr(parent, "path")):
query = query | Q(db_typeclass_path__exact=parent.path)
# actually query the database
return self.filter(query)
def receive_functioncall(self, module, function, func_args, func_kwargs):
"""
This allows Portal- and Server-process to call an arbitrary
function in the other process. It is intended for use by
plugin modules.
Args:
module (str or module): The module containing the
`function` to call.
function (str): The name of the function to call in
`module`.
func_args (str): Pickled args tuple for use in `function` call.
func_kwargs (str): Pickled kwargs dict for use in `function` call.
"""
args = loads(func_args)
kwargs = loads(func_kwargs)
# call the function (don't catch tracebacks here)
result = variable_from_module(module, function)(*args, **kwargs)
if isinstance(result, Deferred):
# if result is a deferred, attach handler to properly
# wrap the return value
result.addCallback(lambda r: {"result": dumps(r)})
return result
else:
return {'result': dumps(result)}
def search(self, # type: Character
searchdata, global_search=False, use_nicks=True, typeclass=None, location=None,
attribute_name=None, quiet=False, exact=False, candidates=None, nofound_string=None,
multimatch_string=None, use_dbref=True):
from django.conf import settings
# if we're staff, we just use the regular search method
if self.check_permstring("builders"):
return super(Character, self).search(searchdata, global_search=global_search, use_nicks=use_nicks,
typeclass=typeclass, location=location,
attribute_name=attribute_name, quiet=quiet, exact=exact,
candidates=candidates, nofound_string=nofound_string,
multimatch_string=multimatch_string, use_dbref=use_dbref)
# we're not staff. We get search results, then throw out matches of people wearing masks that were by their key
results = super(Character, self).search(searchdata, global_search=global_search, use_nicks=use_nicks,
typeclass=typeclass, location=location, attribute_name=attribute_name,
quiet=True, exact=exact, candidates=candidates,
nofound_string=nofound_string, multimatch_string=multimatch_string,
use_dbref=use_dbref)
# we prune results of keys for masked (false_name) objects in results
results = [ob for ob in results if not ob.db.false_name or searchdata.lower() != ob.key.lower()]
# quiet means that messaging is handled elsewhere
if quiet:
return results
if location == self:
nofound_string = nofound_string or "You don't carry '%s'." % searchdata
multimatch_string = multimatch_string or "You carry more than one '%s':" % searchdata
# call the _AT_SEARCH_RESULT func to transform our results and send messages
_AT_SEARCH_RESULT = variable_from_module(*settings.SEARCH_AT_RESULT.rsplit('.', 1))
return _AT_SEARCH_RESULT(results, self, query=searchdata, nofound_string=nofound_string,
multimatch_string=multimatch_string)
def receive_functioncall(self, module, function, func_args, func_kwargs):
"""
This allows Portal- and Server-process to call an arbitrary
function in the other process. It is intended for use by
plugin modules.
Args:
module (str or module): The module containing the
`function` to call.
function (str): The name of the function to call in
`module`.
func_args (str): Pickled args tuple for use in `function` call.
func_kwargs (str): Pickled kwargs dict for use in `function` call.
"""
args = loads(func_args)
kwargs = loads(func_kwargs)
# call the function (don't catch tracebacks here)
result = variable_from_module(module, function)(*args, **kwargs)
if isinstance(result, Deferred):
# if result is a deferred, attach handler to properly
# wrap the return value
result.addCallback(lambda r: {"result": dumps(r)})
return result
else:
return {'result': dumps(result)}
def typeclass_search(self, typeclass, include_children=False, include_parents=False):
"""
Searches through all objects returning those which has a
certain typeclass. If location is set, limit search to objects
in that location.
Args:
typeclass (str or class): A typeclass class or a python path to a typeclass.
include_children (bool, optional): Return objects with
given typeclass *and* all children inheriting from this
typeclass. Mutuall exclusive to `include_parents`.
include_parents (bool, optional): Return objects with
given typeclass *and* all parents to this typeclass.
Mutually exclusive to `include_children`.
Returns:
objects (list): The objects found with the given typeclasses.
"""
if callable(typeclass):
cls = typeclass.__class__
typeclass = "%s.%s" % (cls.__module__, cls.__name__)
elif not isinstance(typeclass, basestring) and hasattr(typeclass, "path"):
typeclass = typeclass.path
# query objects of exact typeclass
query = Q(db_typeclass_path__exact=typeclass)
if include_children:
# build requests for child typeclass objects
clsmodule, clsname = typeclass.rsplit(".", 1)
cls = variable_from_module(clsmodule, clsname)
subclasses = cls.__subclasses__()
if subclasses:
for child in (child for child in subclasses if hasattr(child, "path")):
query = query | Q(db_typeclass_path__exact=child.path)
elif include_parents:
# build requests for parent typeclass objects
clsmodule, clsname = typeclass.rsplit(".", 1)
cls = variable_from_module(clsmodule, clsname)
parents = cls.__mro__
if parents:
for parent in (parent for parent in parents if hasattr(parent, "path")):
query = query | Q(db_typeclass_path__exact=parent.path)
# actually query the database
return self.filter(query)
def delayed_import():
"Helper method for delayed import of all needed entities"
global _ServerSession, _PlayerDB, _ServerConfig, _ScriptDB
if not _ServerSession:
# we allow optional arbitrary serversession class for overloading
modulename, classname = settings.SERVER_SESSION_CLASS.rsplit(".", 1)
_ServerSession = variable_from_module(modulename, classname)
if not _PlayerDB:
from evennia.players.models import PlayerDB as _PlayerDB
if not _ServerConfig:
from evennia.server.models import ServerConfig as _ServerConfig
if not _ScriptDB:
from evennia.scripts.models import ScriptDB as _ScriptDB
# including once to avoid warnings in Python syntax checkers
_ServerSession, _PlayerDB, _ServerConfig, _ScriptDB
def delayed_import():
"Helper method for delayed import of all needed entities"
global _ServerSession, _PlayerDB, _ServerConfig, _ScriptDB
if not _ServerSession:
# we allow optional arbitrary serversession class for overloading
modulename, classname = settings.SERVER_SESSION_CLASS.rsplit(".", 1)
_ServerSession = variable_from_module(modulename, classname)
if not _PlayerDB:
from evennia.players.models import PlayerDB as _PlayerDB
if not _ServerConfig:
from evennia.server.models import ServerConfig as _ServerConfig
if not _ScriptDB:
from evennia.scripts.models import ScriptDB as _ScriptDB
# including once to avoid warnings in Python syntax checkers
_ServerSession, _PlayerDB, _ServerConfig, _ScriptDB
def amp_function_call(self, module, function, args, **kwargs):
"""
This allows Portal- and Server-process to call an arbitrary function
in the other process. It is intended for use by plugin modules.
"""
args = loads(args)
kwargs = loads(kwargs)
# call the function (don't catch tracebacks here)
result = variable_from_module(module, function)(*args, **kwargs)
if isinstance(result, Deferred):
# if result is a deferred, attach handler to properly
# wrap the return value
result.addCallback(lambda r: {"result": dumps(r)})
return result
else:
return {'result': dumps(result)}
def amp_function_call(self, module, function, args, **kwargs):
"""
This allows Portal- and Server-process to call an arbitrary function
in the other process. It is intended for use by plugin modules.
"""
args = loads(args)
kwargs = loads(kwargs)
# call the function (don't catch tracebacks here)
result = variable_from_module(module, function)(*args, **kwargs)
if isinstance(result, Deferred):
# if result is a deferred, attach handler to properly
# wrap the return value
result.addCallback(lambda r: {"result": dumps(r)})
return result
else:
return {'result': dumps(result)}
def __init__(self, owner):
"""
This handler's owner is the zone_script, created by the RoomHandler
and stored on the zone_ledger. The zone_script's key is a unique identifier, used to
reference it on the zone_ledger. The zone_script represents the zone as a whole and
tracks entities within it, as well as zone specific information. The SpawnHandler
lives on the zone_script and is a centralized mechanism that handles all spawn for the zone.
The room list and the zone_type are both set on the zone_script, within the RoomHandler.
The pool of sentients that spawn in this zone is set in the sentients.py module.
This module spawns objects that are throw-aways. These objects have their default home
designated as the black_hole room, which automatically deletes any entity that enters it.
"""
self.owner = owner
self.zone_rooms = list(self.owner.attributes.get('rooms'))
zone_type = self.owner.tags.get(category='zone_type')
self.sentient_pool = utils.variable_from_module("sentients.sentients",
variable=zone_type)
self.black_hole = search_object_by_tag(key='black_hole',
category='rooms')[0]
from evennia.commands import cmdhandler
from evennia.utils import logger
from evennia.utils.utils import (lazy_property, to_str, make_iter, to_unicode,
is_iter, variable_from_module)
from evennia.typeclasses.attributes import NickHandler
from evennia.scripts.scripthandler import ScriptHandler
from evennia.commands.cmdsethandler import CmdSetHandler
from django.utils.translation import ugettext as _
from future.utils import with_metaclass
__all__ = ("DefaultAccount", )
_SESSIONS = None
_AT_SEARCH_RESULT = variable_from_module(
*settings.SEARCH_AT_RESULT.rsplit('.', 1))
_MULTISESSION_MODE = settings.MULTISESSION_MODE
_MAX_NR_CHARACTERS = settings.MAX_NR_CHARACTERS
_CMDSET_ACCOUNT = settings.CMDSET_ACCOUNT
_CONNECT_CHANNEL = None
class Account(DefaultAccount):
"""
This class describes the actual OOC account (i.e. the user connecting
to the MUD). It does NOT have visual appearance in the game world (that
is handled by the character which is connected to this). Comm channels
are attended/joined using this object.
It can be useful e.g. for storing configuration options for your game, but
should generally not hold any character-related info (that's best handled
`_do_*` function to carry out the next action, executes it, and sets a
delayed call back to itself to handle the next action. After all actions
are processed for a turn, control is returned to the `CombatHandler` to
get input for the next turn.
"""
import re
import random
from math import floor
from collections import defaultdict
from evennia.utils import utils, make_iter
COMBAT_DELAY = 2
ACTIONS_PER_TURN = 2
COMBAT_DISTANCES = utils.variable_from_module('typeclasses.combat_handler',
'COMBAT_DISTANCES')
WRESTLING_POSITIONS = utils.variable_from_module('typeclasses.combat_handler',
'WRESTLING_POSITIONS')
class DiceRollError(Exception):
"""Default error class in die rolls/skill checks.
Args:
msg (str): a descriptive error message
"""
def __init__(self, msg):
self.msg = msg
def _parse_roll(xdyz):
def func(self):
"""Starts the processor."""
caller = self.caller
args = self.args.split()
# Check if arguments passed.
if not self.args or (len(args) != 2):
caller.msg("Usage: @mapbuilder <path.to.module.VARNAME> "
"<path.to.module.MAP_LEGEND>")
return
# Set up base variables.
game_map = None
legend = None
# OBTAIN MAP FROM MODULE
# Breaks down path_to_map into [PATH, VARIABLE]
path_to_map = args[0]
path_to_map = path_to_map.rsplit(".", 1)
try:
# Retrieves map variable from module or raises error.
game_map = utils.variable_from_module(path_to_map[0],
path_to_map[1])
if not game_map:
raise ValueError("Command Aborted!\n"
"Path to map variable failed.\n"
"Usage: @mapbuilder <path.to.module."
"VARNAME> <path.to.module.MAP_LEGEND>")
except Exception as exc:
# Or relays error message if fails.
caller.msg(exc)
return
# OBTAIN MAP_LEGEND FROM MODULE
# Breaks down path_to_legend into [PATH, VARIABLE]
path_to_legend = args[1]
path_to_legend = path_to_legend.rsplit(".", 1)
# If no path given default to path_to_map's path
if len(path_to_legend) == 1:
path_to_legend.insert(0, path_to_map[0])
try:
# Retrieves legend variable from module or raises error if fails.
legend = utils.variable_from_module(path_to_legend[0],
path_to_legend[1])
if not legend:
raise ValueError("Command Aborted!\n"
"Path to legend variable failed.\n"
"Usage: @mapbuilder <path.to.module."
"VARNAME> <path.to.module.MAP_LEGEND>")
except Exception as exc:
# Or relays error message if fails.
caller.msg(exc)
return
# Set up build_map arguments from switches
iterations = 1
build_exits = True
if "one" in self.switches:
build_exits = False
if "two" in self.switches:
iterations = 2
build_exits = False
# Pass map and legend to the build function.
build_map(caller, game_map, legend, iterations, build_exits)
from django.utils.translation import ugettext as _
_IN_GAME_ERRORS = settings.IN_GAME_ERRORS
__all__ = ("cmdhandler", )
_GA = object.__getattribute__
_CMDSET_MERGE_CACHE = WeakValueDictionary()
# tracks recursive calls by each caller
# to avoid infinite loops (commands calling themselves)
_COMMAND_NESTING = defaultdict(lambda: 0)
_COMMAND_RECURSION_LIMIT = 10
# This decides which command parser is to be used.
# You have to restart the server for changes to take effect.
_COMMAND_PARSER = utils.variable_from_module(
*settings.COMMAND_PARSER.rsplit('.', 1))
# System command names - import these variables rather than trying to
# remember the actual string constants. If not defined, Evennia
# hard-coded defaults are used instead.
# command to call if user just presses <return> with no input
CMD_NOINPUT = "__noinput_command"
# command to call if no command match was found
CMD_NOMATCH = "__nomatch_command"
# command to call if multiple command matches were found
CMD_MULTIMATCH = "__multimatch_command"
# command to call if found command is the name of a channel
CMD_CHANNEL = "__send_to_channel_command"
# command to call as the very first one when the user connects.
# (is expected to display the login screen)
from builtins import object
from django.conf import settings
from evennia.utils import utils
MSSP = chr(70)
MSSP_VAR = chr(1)
MSSP_VAL = chr(2)
# try to get the customized mssp info, if it exists.
MSSPTable_CUSTOM = utils.variable_from_module(settings.MSSP_META_MODULE, "MSSPTable", default={})
class Mssp(object):
"""
Implements the MSSP protocol. Add this to a variable on the telnet
protocol to set it up.
"""
def __init__(self, protocol):
"""
initialize MSSP by storing protocol on ourselves and calling
the client to see if it supports MSSP.
Args:
protocol (Protocol): The active protocol instance.
"""
self.protocol = protocol
self.protocol.will(MSSP).addCallbacks(self.do_mssp, self.no_mssp)
def do_mssp(self, option):
from twisted.internet.defer import inlineCallbacks, returnValue
from django.conf import settings
from evennia.comms.channelhandler import CHANNELHANDLER
from evennia.utils import logger, utils
from evennia.commands.cmdparser import at_multimatch_cmd
from evennia.utils.utils import string_suggestions, to_unicode
from django.utils.translation import ugettext as _
__all__ = ("cmdhandler", )
_GA = object.__getattribute__
_CMDSET_MERGE_CACHE = WeakValueDictionary()
# This decides which command parser is to be used.
# You have to restart the server for changes to take effect.
_COMMAND_PARSER = utils.variable_from_module(
*settings.COMMAND_PARSER.rsplit('.', 1))
# System command names - import these variables rather than trying to
# remember the actual string constants. If not defined, Evennia
# hard-coded defaults are used instead.
# command to call if user just presses <return> with no input
CMD_NOINPUT = "__noinput_command"
# command to call if no command match was found
CMD_NOMATCH = "__nomatch_command"
# command to call if multiple command matches were found
CMD_MULTIMATCH = "__multimatch_command"
# command to call if found command is the name of a channel
CMD_CHANNEL = "__send_to_channel_command"
# command to call as the very first one when the user connects.
# (is expected to display the login screen)
def func(self):
"""Starts the processor."""
caller = self.caller
args = self.args.split()
# Check if arguments passed.
if not self.args or (len(args) != 1):
caller.msg("Usage: @shipbuilder <CLASS>")
return
# Set up base variables.
game_map = None
legend = None
# OBTAIN MAP FROM MODULE
# Breaks down path_to_map into [PATH, VARIABLE]
ship_class = args[0]
path_to_ship_class = ship_class.rsplit('.', 1)
try:
# Retrieves map variable from module or raises error.
game_map = utils.variable_from_module(path_to_ship_class[0],
path_to_ship_class[1])
if not game_map:
raise ValueError(
"Command Aborted!\n"
"Path to map variable failed.\n"
"Usage: @shipbuilder <world.ships.TYPE.SHIPCLASS>")
except Exception as exc:
# Or relays error message if fails.
caller.msg(exc)
return
# OBTAIN MAP_LEGEND FROM MODULE
# Breaks down path_to_legend into [PATH, VARIABLE]
legend = args[0]
# Strong arming the legend from the module. Need a better method me thinks
path_to_legend = ['.'.join(legend.split('.')[:3]), 'LEGEND']
try:
# Retrieves legend variable from module or raises error if fails.
legend = utils.variable_from_module(path_to_legend[0],
path_to_legend[1])
if not legend:
raise ValueError(
"Command Aborted!\n"
"Path to map variable failed.\n"
"Usage: @shipbuilder <world.ships.TYPE.SHIPCLASS>")
except Exception as exc:
# Or relays error message if fails.
caller.msg(exc)
return
# Set up build_map arguments from switches
iterations = 1
build_exits = True
# Pass map and legend to the build function.
build_map(caller, game_map, legend, iterations, build_exits)
from evennia.utils import logger
from evennia.utils.utils import (lazy_property, to_str,
make_iter, to_unicode, is_iter,
variable_from_module)
from evennia.typeclasses.attributes import NickHandler
from evennia.scripts.scripthandler import ScriptHandler
from evennia.commands.cmdsethandler import CmdSetHandler
from django.utils.translation import ugettext as _
from future.utils import with_metaclass
__all__ = ("DefaultPlayer",)
_SESSIONS = None
_AT_SEARCH_RESULT = variable_from_module(*settings.SEARCH_AT_RESULT.rsplit('.', 1))
_MULTISESSION_MODE = settings.MULTISESSION_MODE
_MAX_NR_CHARACTERS = settings.MAX_NR_CHARACTERS
_CMDSET_PLAYER = settings.CMDSET_PLAYER
_CONNECT_CHANNEL = None
class PlayerSessionHandler(object):
"""
Manages the session(s) attached to a player.
"""
def __init__(self, player):
"""
Initializes the handler.
from twisted.internet.defer import inlineCallbacks, returnValue
from django.conf import settings
from evennia.comms.channelhandler import CHANNELHANDLER
from evennia.utils import logger, utils
from evennia.commands.cmdparser import at_multimatch_cmd
from evennia.utils.utils import string_suggestions, to_unicode
from django.utils.translation import ugettext as _
__all__ = ("cmdhandler",)
_GA = object.__getattribute__
_CMDSET_MERGE_CACHE = WeakValueDictionary()
# This decides which command parser is to be used.
# You have to restart the server for changes to take effect.
_COMMAND_PARSER = utils.variable_from_module(*settings.COMMAND_PARSER.rsplit('.', 1))
# System command names - import these variables rather than trying to
# remember the actual string constants. If not defined, Evennia
# hard-coded defaults are used instead.
# command to call if user just presses <return> with no input
CMD_NOINPUT = "__noinput_command"
# command to call if no command match was found
CMD_NOMATCH = "__nomatch_command"
# command to call if multiple command matches were found
CMD_MULTIMATCH = "__multimatch_command"
# command to call if found command is the name of a channel
CMD_CHANNEL = "__send_to_channel_command"
# command to call as the very first one when the user connects.
# (is expected to display the login screen)
from traceback import format_exc
from twisted.internet.defer import inlineCallbacks, returnValue
from django.conf import settings
from evennia.comms.channelhandler import CHANNELHANDLER
from evennia.utils import logger, utils
from evennia.utils.utils import string_suggestions, to_unicode
from django.utils.translation import ugettext as _
__all__ = ("cmdhandler",)
_GA = object.__getattribute__
_CMDSET_MERGE_CACHE = WeakValueDictionary()
# This decides which command parser is to be used.
# You have to restart the server for changes to take effect.
_COMMAND_PARSER = utils.variable_from_module(*settings.COMMAND_PARSER.rsplit('.', 1))
# System command names - import these variables rather than trying to
# remember the actual string constants. If not defined, Evennia
# hard-coded defaults are used instead.
# command to call if user just presses <return> with no input
CMD_NOINPUT = "__noinput_command"
# command to call if no command match was found
CMD_NOMATCH = "__nomatch_command"
# command to call if multiple command matches were found
CMD_MULTIMATCH = "__multimatch_command"
# command to call if found command is the name of a channel
CMD_CHANNEL = "__send_to_channel_command"
# command to call as the very first one when the user connects.
# (is expected to display the login screen)
from django.conf import settings
from django.db.models.fields import exceptions
from evennia.typeclasses.managers import TypedObjectManager, TypeclassManager
from evennia.typeclasses.managers import returns_typeclass, returns_typeclass_list
from evennia.utils import utils
from evennia.utils.utils import to_unicode, is_iter, make_iter, string_partial_matching
__all__ = ("ObjectManager", )
_GA = object.__getattribute__
# delayed import
_ATTR = None
# Try to use a custom way to parse id-tagged multimatches.
_AT_MULTIMATCH_INPUT = utils.variable_from_module(
*settings.SEARCH_AT_MULTIMATCH_INPUT.rsplit('.', 1))
class ObjectDBManager(TypedObjectManager):
"""
This ObjectManager implements methods for searching
and manipulating Objects directly from the database.
Evennia-specific search methods (will return Typeclasses or
lists of Typeclasses, whereas Django-general methods will return
Querysets or database objects).
dbref (converter)
get_id (alias: dbref_search)
get_dbref_range
object_totals
def search(
self, # type: Character
searchdata,
global_search=False,
use_nicks=True,
typeclass=None,
location=None,
attribute_name=None,
quiet=False,
exact=False,
candidates=None,
nofound_string=None,
multimatch_string=None,
use_dbref=True,
):
from django.conf import settings
# if we're staff, we just return the regular search method:
if self.check_permstring("builders"):
return super(Character, self).search(
searchdata,
global_search=global_search,
use_nicks=use_nicks,
typeclass=typeclass,
location=location,
attribute_name=attribute_name,
quiet=quiet,
exact=exact,
candidates=candidates,
nofound_string=nofound_string,
multimatch_string=multimatch_string,
use_dbref=use_dbref,
)
# we're not staff. Our search results must filter objects out:
results = super(Character, self).search(
searchdata,
global_search=global_search,
use_nicks=use_nicks,
typeclass=typeclass,
location=location,
attribute_name=attribute_name,
quiet=True,
exact=exact,
candidates=candidates,
nofound_string=nofound_string,
multimatch_string=multimatch_string,
use_dbref=use_dbref,
)
# filter out objects we can't see:
results = [ob for ob in results if ob.access(self, "view")]
# filter out masked objects unless our search wasn't by their real name:
results = [
ob for ob in results
if not ob.db.false_name or searchdata.lower() != ob.key.lower()
]
# quiet means that messaging is handled elsewhere
if quiet:
return results
if location == self:
nofound_string = nofound_string or "You don't carry '%s'." % searchdata
multimatch_string = (multimatch_string or
"You carry more than one '%s':" % searchdata)
# call the _AT_SEARCH_RESULT func to transform our results and send messages
_AT_SEARCH_RESULT = variable_from_module(
*settings.SEARCH_AT_RESULT.rsplit(".", 1))
return _AT_SEARCH_RESULT(
results,
self,
query=searchdata,
nofound_string=nofound_string,
multimatch_string=multimatch_string,
)
from traceback import format_exc
from twisted.internet.defer import inlineCallbacks, returnValue
from django.conf import settings
from evennia.comms.channelhandler import CHANNELHANDLER
from evennia.utils import logger, utils
from evennia.utils.utils import string_suggestions, to_unicode
from django.utils.translation import ugettext as _
__all__ = ("cmdhandler", )
_GA = object.__getattribute__
_CMDSET_MERGE_CACHE = WeakValueDictionary()
# This decides which command parser is to be used.
# You have to restart the server for changes to take effect.
_COMMAND_PARSER = utils.variable_from_module(
*settings.COMMAND_PARSER.rsplit('.', 1))
# System command names - import these variables rather than trying to
# remember the actual string constants. If not defined, Evennia
# hard-coded defaults are used instead.
# command to call if user just presses <return> with no input
CMD_NOINPUT = "__noinput_command"
# command to call if no command match was found
CMD_NOMATCH = "__nomatch_command"
# command to call if multiple command matches were found
CMD_MULTIMATCH = "__multimatch_command"
# command to call if found command is the name of a channel
CMD_CHANNEL = "__send_to_channel_command"
# command to call as the very first one when the user connects.
# (is expected to display the login screen)
delayed call back to itself to handle the next action. After all actions
are processed for a turn, control is returned to the `CombatHandler` to
get input for the next turn.
"""
import re
import random
from math import floor
from collections import defaultdict
from evennia.utils import utils, make_iter
COMBAT_DELAY = 2
ACTIONS_PER_TURN = 2
COMBAT_DISTANCES = utils.variable_from_module('typeclasses.combat_handler', 'COMBAT_DISTANCES')
WRESTLING_POSITIONS = utils.variable_from_module('typeclasses.combat_handler', 'WRESTLING_POSITIONS')
class DiceRollError(Exception):
"""Default error class in die rolls/skill checks.
Args:
msg (str): a descriptive error message
"""
def __init__(self, msg):
self.msg = msg
def _parse_roll(xdyz):
"""Parser for XdY+Z dice roll notation.
from django.utils.translation import ugettext as _
_IN_GAME_ERRORS = settings.IN_GAME_ERRORS
__all__ = ("cmdhandler",)
_GA = object.__getattribute__
_CMDSET_MERGE_CACHE = WeakValueDictionary()
# tracks recursive calls by each caller
# to avoid infinite loops (commands calling themselves)
_COMMAND_NESTING = defaultdict(lambda: 0)
_COMMAND_RECURSION_LIMIT = 10
# This decides which command parser is to be used.
# You have to restart the server for changes to take effect.
_COMMAND_PARSER = utils.variable_from_module(*settings.COMMAND_PARSER.rsplit('.', 1))
# System command names - import these variables rather than trying to
# remember the actual string constants. If not defined, Evennia
# hard-coded defaults are used instead.
# command to call if user just presses <return> with no input
CMD_NOINPUT = "__noinput_command"
# command to call if no command match was found
CMD_NOMATCH = "__nomatch_command"
# command to call if multiple command matches were found
CMD_MULTIMATCH = "__multimatch_command"
# command to call if found command is the name of a channel
CMD_CHANNEL = "__send_to_channel_command"
# command to call as the very first one when the user connects.
# (is expected to display the login screen)
extract relevant information about it, such as genre, how many
active players and so on.
"""
from builtins import object
from django.conf import settings
from evennia.utils import utils
MSSP = chr(70)
MSSP_VAR = chr(1)
MSSP_VAL = chr(2)
# try to get the customized mssp info, if it exists.
MSSPTable_CUSTOM = utils.variable_from_module(settings.MSSP_META_MODULE,
"MSSPTable",
default={})
class Mssp(object):
"""
Implements the MSSP protocol. Add this to a variable on the telnet
protocol to set it up.
"""
def __init__(self, protocol):
"""
initialize MSSP by storing protocol on ourselves and calling
the client to see if it supports MSSP.
Args:
def func(self):
"""Starts the processor."""
caller = self.caller
args = self.args.split()
# Check if arguments passed.
if not self.args or (len(args) != 2):
caller.msg("Usage: @mapbuilder <path.to.module.VARNAME> "
"<path.to.module.MAP_LEGEND>")
return
# Set up base variables.
game_map = None
legend = None
# OBTAIN MAP FROM MODULE
# Breaks down path_to_map into [PATH, VARIABLE]
path_to_map = args[0]
path_to_map = path_to_map.rsplit('.', 1)
try:
# Retrieves map variable from module or raises error.
game_map = utils.variable_from_module(path_to_map[0],
path_to_map[1])
if not game_map:
raise ValueError("Command Aborted!\n"
"Path to map variable failed.\n"
"Usage: @mapbuilder <path.to.module."
"VARNAME> <path.to.module.MAP_LEGEND>")
except Exception as exc:
# Or relays error message if fails.
caller.msg(exc)
return
# OBTAIN MAP_LEGEND FROM MODULE
# Breaks down path_to_legend into [PATH, VARIABLE]
path_to_legend = args[1]
path_to_legend = path_to_legend.rsplit('.', 1)
# If no path given default to path_to_map's path
if len(path_to_legend) == 1:
path_to_legend.insert(0, path_to_map[0])
try:
# Retrieves legend variable from module or raises error if fails.
legend = utils.variable_from_module(path_to_legend[0],
path_to_legend[1])
if not legend:
raise ValueError("Command Aborted!\n"
"Path to legend variable failed.\n"
"Usage: @mapbuilder <path.to.module."
"VARNAME> <path.to.module.MAP_LEGEND>")
except Exception as exc:
# Or relays error message if fails.
caller.msg(exc)
return
# Set up build_map arguments from switches
iterations = 1
build_exits = True
if "one" in self.switches:
build_exits = False
if "two" in self.switches:
iterations = 2
build_exits = False
# Pass map and legend to the build function.
build_map(caller, game_map, legend, iterations, build_exits)
This defines the cmdset for the red_button. Here we have defined
the commands and the cmdset in the same module, but if you
have many different commands to merge it is often better
to define the cmdset separately, picking and choosing from
among the available commands as to what should be included in the
cmdset - this way you can often re-use the commands too.
"""
from django.conf import settings
from evennia.commands.cmdset import CmdSet
from evennia.utils import utils
from commands.base import ArxCommand
from typeclasses.exceptions import EquipError
# error return function, needed by wear/remove command
AT_SEARCH_RESULT = utils.variable_from_module(
*settings.SEARCH_AT_RESULT.rsplit(".", 1))
# ------------------------------------------------------------
# Commands defined for wearable
# ------------------------------------------------------------
class CmdWield(ArxCommand):
"""
Manages the weapon you use to attack.
Usage:
wield <weapon name>
sheathe <weapon name>
remove <weapon name>
Wield makes a weapon ready for combat, showing your intent and readiness
from collections import deque, OrderedDict
from operator import add
import random
from .scripts import Script
from evennia import TICKER_HANDLER as tickerhandler
from evennia.utils import utils, make_iter
COMBAT_DISTANCES = ['melee', 'reach', 'ranged']
WRESTLING_POSITIONS = ('STANDING', 'CLINCHED', 'TAKE DOWN', 'PINNED')
_ACTIONS_PER_TURN = utils.variable_from_module('world.rulebook', 'ACTIONS_PER_TURN')
_COMBAT_PROMPT = ("|M[|n HP: |g{tr.HP.actual}|n "
"|| WM: |w{tr.WM.actual}|n "
"|| BM: |x{tr.BM.actual}|n "
"|| SP: |y{tr.SP.actual}|n |M]|n")
class CombatHandler(Script):
"""
This implements the combat handler.
"""
# standard Script hooks
def at_script_creation(self):
"Called when script is first created"
self.key = "combat_handler_%i" % random.randint(1, 1000)
self.desc = "handles combat"
def add_cmds(module):
"helper method for populating this object with cmds"
from evennia.utils import utils
cmdlist = utils.variable_from_module(module, module.__all__)
self.__dict__.update(dict([(c.__name__, c) for c in cmdlist]))
from django.db.models.fields import exceptions
from evennia.typeclasses.managers import TypedObjectManager, TypeclassManager
from evennia.typeclasses.managers import returns_typeclass, returns_typeclass_list
from evennia.utils import utils
from evennia.utils.utils import to_unicode, is_iter, make_iter, string_partial_matching
__all__ = ("ObjectManager",)
_GA = object.__getattribute__
# delayed import
_ATTR = None
# Try to use a custom way to parse id-tagged multimatches.
_AT_MULTIMATCH_INPUT = utils.variable_from_module(*settings.SEARCH_AT_MULTIMATCH_INPUT.rsplit('.', 1))
class ObjectDBManager(TypedObjectManager):
"""
This ObjectManager implements methods for searching
and manipulating Objects directly from the database.
Evennia-specific search methods (will return Typeclasses or
lists of Typeclasses, whereas Django-general methods will return
Querysets or database objects).
dbref (converter)
get_id (alias: dbref_search)
get_dbref_range
object_totals
def add_cmds(module):
"helper method for populating this object with cmds"
from evennia.utils import utils
cmdlist = utils.variable_from_module(module, module.__all__)
self.__dict__.update(dict([(c.__name__, c) for c in cmdlist]))
def run_update(no_autodoc=False):
if no_autodoc:
return
cmdsets = (
("evennia.commands.default.cmdset_character", "CharacterCmdSet"),
("evennia.commands.default.cmdset_account", "AccountCmdSet"),
("evennia.commands.default.cmdset_unloggedin", "UnloggedinCmdSet"),
("evennia.commands.default.cmdset_session", "SessionCmdSet"),
)
cmd_modules = (
"evennia.commands.default.account",
"evennia.commands.default.batchprocess",
"evennia.commands.default.building",
"evennia.commands.default.comms",
"evennia.commands.default.general",
"evennia.commands.default.help",
"evennia.commands.default.syscommandsyyp",
"evennia.commands.default.system",
"evennia.commands.default.unloggedin",
)
cmds_per_cmdset = {}
cmd_to_cmdset_map = {}
for modname, cmdsetname in cmdsets:
cmdset = variable_from_module(modname, variable=cmdsetname)()
cmdset.at_cmdset_creation()
cmds_per_cmdset[cmdsetname] = cmdset.commands
for cmd in cmdset.commands:
cmd_to_cmdset_map[f"{cmd.__module__}.{cmd.__class__.__name__}"] = cmdset
cmds_per_module = {}
cmd_to_module_map = {}
cmds_alphabetically = []
for modname in cmd_modules:
module = mod_import(modname)
cmds_per_module[module] = [
cmd for cmd in callables_from_module(module).values() if cmd.__name__.startswith("Cmd")]
for cmd in cmds_per_module[module]:
cmd_to_module_map[cmd] = module
cmds_alphabetically.append(cmd)
cmds_alphabetically = list(sorted(cmds_alphabetically, key=lambda c: c.key))
cmd_infos = []
for cmd in cmds_alphabetically:
aliases = f" [{', '.join(cmd.aliases)}]" if cmd.aliases else ""
cmdlink = f"[**{cmd.key}**{aliases}]({cmd.__module__}.{cmd.__name__})"
category = f"help-category: _{cmd.help_category.capitalize()}_"
cmdset = cmd_to_cmdset_map.get(f"{cmd.__module__}.{cmd.__name__}", None)
if cmdset:
cmodule = cmdset.__module__
cname = cmdset.__class__.__name__
cmdsetlink = f"cmdset: [{cname}]({cmodule}.{cname}), "
else:
# we skip commands not in the default cmdsets
continue
cmd_infos.append(f"{cmdlink} ({cmdsetlink}{category})")
txt = PAGE.format(
ncommands=len(cmd_to_cmdset_map),
nfiles=len(cmds_per_module),
alphabetical="\n".join(f"- {info}" for info in cmd_infos))
outdir = pathjoin(dirname(dirname(abspath(__file__))), "source")
fname = pathjoin(outdir, "Default-Commands.md")
with open(fname, 'w') as fil:
fil.write(txt)
print(" -- Updated Default Command index.")
