def func(self):
"""
Implement the function.
"""
if not self.args:
return
effect = self.args[0]
if effect <= 0:
return
if not self.obj:
return
# calculate the damage
damage = float(self.caller.attack) / (self.caller.attack + self.obj.defence) * self.caller.attack
damage = round(damage * effect)
# hurt target
self.obj.hurt(damage)
result = {"type": "attacked", # attack result
"message": [LS("%s hitted %s.") % (self.caller.get_name(), self.obj.get_name()),
LS("%s lost %s HPs.") % (self.obj.get_name(), int(damage))],
"caller": self.caller.dbref, # caller's dbref
"target": self.obj.dbref, # target's dbref
"effect": damage, # effect
"hp": self.obj.db.hp, # current hp of the target
"max_hp": self.obj.max_hp} # max hp of the target
self.caller.skill_results([result])
def func(self):
"Cast a skill."
caller = self.caller
if not caller.is_alive():
caller.msg({"alert": LS("You are died.")})
return
if not self.args:
caller.msg({"alert": LS("You should select a skill to cast.")})
return
skill_key = None
if isinstance(self.args, basestring):
# If the args is a skill's key.
skill_key = self.args
else:
# If the args is skill's key and target.
if not "skill" in self.args:
caller.msg({"alert": LS("You should select a skill to cast.")})
return
skill_key = self.args["skill"]
# Get target
target = None
if "target" in self.args:
target = caller.search(self.args["target"])
try:
# Prepare to cast this skill.
caller.prepare_skill(skill_key, target)
except Exception, e:
caller.msg({"alert": LS("Can not cast this skill.")})
logger.log_tracemsg("Can not cast skill %s: %s" % (skill_key, e))
return
def func(self):
"Handle command"
caller = self.caller
if not caller:
return
if not self.args:
caller.msg({"alert":LS("You should select a target.")})
return
target = caller.search(self.args)
if not target:
caller.msg({"alert":LS("You should select a target.")})
return
# set up combat
if caller.is_in_combat():
# caller is in battle
message = {"alert": LS("You are already in a combat.")}
caller.msg(message)
return
if target.is_in_combat():
# caller is in battle
message = {"alert": LS("%s is already in a combat." % target.name)}
caller.msg(message)
return
# create a new combat handler
chandler = create_script("combat_handler.CombatHandler")
chandler.add_characters([target, self.caller])
self.caller.msg("You attack %s! You are in combat." % target)
target.msg("%s attacks you! You are in combat." % self.caller)
def use_object(self, obj, number=1):
"""
Use an object.
Args:
obj: (object) object to use
number: (int) number to use
Returns:
result: (string) the description of the result
"""
if not obj:
return LS("Can not find this object.")
if obj.db.number < number:
return LS("Not enough number.")
# take effect
try:
result, used = obj.take_effect(self, number)
if used > 0:
# remove used object
obj_list = [{"object": obj.get_data_key(), "number": used}]
self.remove_objects(obj_list)
return result
except Exception, e:
ostring = "Can not use %s: %s" % (obj.get_data_key(), e)
logger.log_tracemsg(ostring)
def func(self):
"Use an object."
caller = self.caller
if not caller.is_alive():
caller.msg({"alert": LS("You are died.")})
return
if not self.args:
caller.msg({"alert": LS("You should discard something.")})
return
obj = caller.search(self.args, location=caller)
if not obj:
# If the caller does not have this object.
caller.msg({"alert": LS("You don't have this object.")})
return
# remove used object
try:
caller.remove_object(obj.get_data_key(), 1)
except Exception, e:
caller.msg({"alert": LS("Can not discard this object.")})
logger.log_tracemsg("Can not discard object %s: %s" %
(obj.get_data_key(), e))
return
def take_off_position(self, position):
"""
Take off an object from position.
"""
if not position in self.db.equipments:
raise MudderyError(LS("Can not find this equipment."))
if not self.db.equipments[position]:
raise MudderyError(LS("Can not find this equipment."))
# Set object's attribute 'equipped' to False
dbref = self.db.equipments[position]
for obj in self.contents:
if obj.dbref == dbref:
obj.equipped = False
find = True
self.db.equipments[position] = None
# reset character's attributes
self.refresh_data()
message = {"status": self.return_status(),
"equipments": self.return_equipments(),
"inventory": self.return_inventory()}
self.msg(message)
def func(self):
"""
Implement the function.
"""
combat_handler = self.caller.ndb.combat_handler
if not combat_handler:
# caller is not in combat.
return
self.obj = self.caller
odd = 0.0
if self.args:
odd = self.args[0]
rand = random.random()
if rand >= odd:
# escape failed
result = self.result_message(effect=0, message_model=LS("%(c)s tried to escape, but failed."))
self.caller.send_skill_result(result)
return
# send skill's result to the combat handler manually
# before the handler is removed from the character
result = self.result_message(effect=1, message_model=LS("%(c)s tried to escape. Succeeded!"))
self.caller.send_skill_result(result)
combat_handler.skill_escape(self.caller)
def get_available_commands(self, caller):
"""
This returns a list of available commands.
"args" must be a string without ' and ", usually it is self.dbref.
"""
if getattr(self, "equipped", False):
commands = [{
"name": LS("Take Off"),
"cmd": "takeoff",
"args": self.dbref
}]
else:
commands = [{
"name": LS("Equip"),
"cmd": "equip",
"args": self.dbref
}]
# Can not discard when equipped
if self.location:
commands.append({
"name": LS("Discard"),
"cmd": "discard",
"args": self.dbref
})
return commands
def func(self):
"Use an object."
caller = self.caller
if not caller.is_alive():
caller.msg({"alert": LS("You are died.")})
return
if not self.args:
caller.msg({"alert": LS("You should use something.")})
return
obj = caller.search(self.args, location=caller)
if not obj:
# If the caller does not have this object.
caller.msg({"alert": LS("You don't have this object.")})
return
result = ""
try:
# Use the object and get the result.
result = caller.use_object(obj)
except Exception, e:
ostring = "Can not use %s: %s" % (obj.get_data_key(), e)
logger.log_tracemsg(ostring)
def func(self):
"Move caller to the exit."
caller = self.caller
if not caller.is_alive():
caller.msg({"alert": LS("You are died.")})
return
if not self.args:
caller.msg({"alert": LS("Should appoint an exit to go.")})
return
obj = caller.search(self.args, location=caller.location)
if not obj:
# Can not find exit.
caller.msg({"alert": LS("Can not find exit.")})
return
if obj.access(self.caller, 'traverse'):
# we may traverse the exit.
# MudderyLockedExit handles locks in at_before_traverse().
if obj.at_before_traverse(self.caller):
obj.at_traverse(caller, obj.destination)
else:
# exit is locked
if obj.db.err_traverse:
# if exit has a better error message, let's use it.
caller.msg({"alert": self.obj.db.err_traverse})
else:
# No shorthand error message. Call hook.
obj.at_failed_traverse(caller)
def func(self):
"Begin to talk to a NPC."
caller = self.caller
if not self.args:
caller.msg({"alert":LS("You should talk to someone.")})
return
npc = caller.search(self.args, location=caller.location)
if not npc:
caller.msg({"alert":LS("Can not find the one to talk.")})
return
sentences = DIALOGUE_HANDLER.get_default_sentences(caller, npc)
if sentences:
speaker = sentences[0]["speaker"];
if speaker == "n":
speaker = npc.name
elif speaker == "p":
speaker = caller.name
elif speaker[0] == '"' and speaker[-1] == '"':
speaker = speaker[1:-1]
dialogues = []
for s in sentences:
dlg = {"speaker": speaker,
"npc": npc.key,
"dialogue": s["dialogue"],
"sentence": s["sentence"],
"content": s["content"]}
dialogues.append(dlg)
caller.msg({"dialogue": dialogues})
def sell_to(self, caller):
"""
Buy this goods.
Args:
caller: the buyer
Returns:
"""
# check price
unit_number = caller.get_object_number(self.unit_key)
if unit_number < self.price:
caller.msg({"alert": LS("Sorry, %s is not enough.") % self.unit_name})
return
# check if can get these objects
if not caller.can_get_object(self.db.goods.get_data_key(), self.number):
caller.msg({"alert": LS("Sorry, you can not take more %s.") % self.db.goods.get_name()})
return
# Reduce price units.
if not caller.remove_object(self.unit_key, self.price):
caller.msg({"alert": LS("Sorry, %s is not enough.") % self.unit_name})
return
# Give goods.
obj_list = [{"object": self.db.goods.get_data_key(),
"number": self.number}]
caller.receive_objects(obj_list)
def func(self):
"Talk to NPC."
caller = self.caller
if not self.args:
caller.msg({"alert":LS("You should talk to someone.")})
return
if not "npc" in self.args:
caller.msg({"alert":LS("You should talk to someone.")})
return
# Get the npc at the player's location.
npc = caller.search(self.args["npc"], location=caller.location)
if not npc:
caller.msg({"alert":LS("Can not find the one to talk.")})
return
# Get the current sentence.
dialogue = ""
sentence = 0
have_current_dlg = False
try:
dialogue = self.args["dialogue"]
sentence = int(self.args["sentence"])
have_current_dlg = True
except Exception, e:
pass
def func(self):
"Cast a skill."
caller = self.caller
if not self.args:
caller.msg({"alert":LS("You should select a skill to cast.")})
return
skill_key = None
if isinstance(self.args, basestring):
skill_key = self.args
else:
if not "skill" in self.args:
caller.msg({"alert":LS("You should select a skill to cast.")})
return
skill_key = self.args["skill"]
target = None
if "target" in self.args:
target = caller.search(self.args["target"])
try:
caller.cast_skill(skill_key, target)
except Exception, e:
caller.msg({"alert":LS("Can not cast this skill.")})
return
def cast_combat_skill(self, skill, target):
"""
Cast a skill in combat.
"""
if not self.owner:
return
if not self.owner.ndb.combat_handler:
# Onwer is not in combat.
return
if self.GLOBAL_COOLING_DOWN:
# In GCD.
self.owner.msg({"msg": LS("This skill is not ready yet!")})
return
if self.skills[skill].is_cooling_down():
# Skill is cooling down.
self.owner.msg({"msg": LS("This skill is not ready yet!")})
return
# Cast skill.
result = self.owner.ndb.combat_handler.cast_skill(
skill, self.owner.dbref, target)
if result:
# Cast successed, set GCD
if settings.GLOBAL_CD > 0:
self.GLOBAL_COOLING_DOWN = True
# Set timer.
TICKER_HANDLER.add(self,
settings.GLOBAL_CD,
hook_key="global_cooled_down")
return result
def func(self):
"Continue a dialogue."
caller = self.caller
if not self.args:
caller.msg({"alert": LS("You should talk to someone.")})
return
npc = None
if "npc" in self.args:
if self.args["npc"]:
# get NPC
npc = caller.search(self.args["npc"], location=caller.location)
if not npc:
caller.msg({"msg": LS("Can not find it.")})
return
# Get the current sentence.
dialogue = ""
sentence = 0
have_current_dlg = False
try:
dialogue = self.args["dialogue"]
sentence = int(self.args["sentence"])
have_current_dlg = True
except Exception, e:
pass
def func(self):
"""
Uses the Django admin api. Note that unlogged-in commands
have a unique position in that their func() receives
a session object instead of a source_object like all
other types of logged-in commands (this is because
there is no object yet before the player has logged in)
"""
session = self.caller
try:
playername = self.args["playername"]
password = self.args["password"]
except Exception:
string = 'Can not log in.'
logger.log_errmsg(string)
session.msg({"alert": string})
return
# check for too many login errors too quick.
if _throttle(session,
maxlim=5,
timeout=5 * 60,
storage=_LATEST_FAILED_LOGINS):
# timeout is 5 minutes.
session.msg({
"alert":
LS("{RYou made too many connection attempts. Try again in a few minutes.{n"
)
})
return
# Guest login
if playername.lower() == "guest":
enabled, new_player = create_guest_player(session)
if new_player:
session.msg(
{"login": {
"name": playername,
"dbref": new_player.dbref
}})
session.sessionhandler.login(session, new_player)
if enabled:
return
if not password:
session.msg({"alert": LS("{Please input password.")})
return
player = create_normal_player(session, playername, password)
if player:
# actually do the login. This will call all other hooks:
# session.at_login()
# player.at_init() # always called when object is loaded from disk
# player.at_first_login() # only once, for player-centric setup
# player.at_pre_login()
# player.at_post_login(session=session)
session.msg({"login": {"name": playername, "dbref": player.dbref}})
session.sessionhandler.login(session, player)
def cast_skill(self, target):
"""
Cast this skill.
Args:
target: (object) skill's target
Returns:
(result, cd):
result: (dict) skill's result
cd: (dice) skill's cd
"""
owner = self.db.owner
time_now = time.time()
if not self.passive:
if owner:
gcd = getattr(owner, "gcd_finish_time", 0)
if time_now < gcd:
owner.msg({"msg": LS("This skill is not ready yet!")})
return
if time_now < self.db.cd_finish_time:
# skill in CD
if owner:
owner.msg({"msg": LS("This skill is not ready yet!")})
return
if not self.function_call:
logger.log_errmsg("Can not find skill function: %s" %
self.get_data_key())
if owner:
owner.msg({"msg": LS("Can not cast this skill!")})
return
result = {}
cd = {}
try:
# call skill function
result = self.function_call(owner, target, effect=self.effect)
if not self.passive:
# set cd
time_now = time.time()
if self.cd > 0:
self.db.cd_finish_time = time_now + self.cd
cd = {
"skill": self.get_data_key(), # skill's key
"cd": self.cd
} # global cd
except Exception, e:
ostring = "Can not cast skill %s: %s" % (self.get_data_key(), e)
logger.log_tracemsg(ostring)
if owner:
owner.msg({"msg": LS("Can not cast this skill!")})
return
def get_available_commands(self, caller):
"""
This returns a list of available commands.
"args" must be a string without ' and ", usually it is self.dbref.
"""
commands = []
if self.db.number > 0:
commands.append({"name": LS("Use"), "cmd": "use", "args": self.dbref})
if self.location and self.can_discard:
commands.append({"name": LS("Discard"), "cmd": "discard", "args": self.dbref})
return commands
def get_available_commands(self, caller):
"""
This returns a list of available commands.
"args" must be a string without ' and ", usually it is self.dbref.
"""
# commands = [{"name":"LOOK", "cmd":"look", "args":self.dbref}]
verb = getattr(self, "verb", LS("GOTO"))
if not verb:
verb = LS("GOTO")
commands = [{"name": verb, "cmd": "goto", "args": self.dbref}]
return commands
def func(self):
"Handle command"
caller = self.caller
if not caller:
return
if not caller.is_alive():
caller.msg({"alert": LS("You are died.")})
return
if not self.args:
caller.msg({"alert": LS("You should select a target.")})
return
target = caller.search(self.args)
if not target:
caller.msg({"alert": LS("You should select a target.")})
return
if not target.is_alive():
caller.msg({"alert": LS("%s is died." % target.get_name())})
return
if caller.location != target.location:
caller.msg(
{"alert": LS("You can not attack %s." % target.get_name())})
return
# Set caller's target.
caller.set_target(target)
# set up combat
if caller.is_in_combat():
# caller is in battle
message = {"alert": LS("You are already in a combat.")}
caller.msg(message)
return
if target.is_in_combat():
# caller is in battle
message = {"alert": LS("%s is already in a combat." % target.name)}
caller.msg(message)
return
# create a new combat handler
chandler = create_script(settings.COMBAT_HANDLER)
# set combat team and desc
chandler.set_combat({1: [target], 2: [self.caller]}, "")
self.caller.msg(
LS("You are attacking {c%s{n! You are in combat.") %
target.get_name())
target.msg(
LS("{c%s{n is attacking you! You are in combat.") %
self.caller.get_name())
def cast_skill(self, skill, target):
"""
Cast a skill.
Args:
skill: (string) skill's key
target: (object) skill's target
Returns:
(dict) result of the skill
"""
if not self.owner:
return
if time.time() < self.gcd_finish_time:
# In GCD.
self.owner.msg({"msg": LS("This skill is not ready yet!")})
return
if skill not in self.skills:
self.owner.msg({"alert": LS("You do not have this skill.")})
return
message = self.skills[skill].check_available()
if message:
# Skill is not available.
self.owner.msg({"msg": message})
return
result, cd = self.skills[skill].cast_skill(target)
if result:
if self.owner.ndb.combat_handler:
# send skill's result to the combat handler
self.owner.ndb.combat_handler.set_skill_result(result)
else:
# TODO: send result to the target too!
self.owner.msg({"skill_result": result})
# set GCD
if not cd:
cd = {}
cd["gcd"] = self.gcd
if self.gcd > 0:
self.gcd_finish_time = time.time() + self.gcd
# send CD to the player
self.owner.msg({"skill_cd": cd})
return
def learn_skill(self, skill, is_default=False):
"""
Learn a new skill.
Args:
skill: (string) skill's key
is_default: (boolean) if it is a default skill
Returns:
(boolean) learned skill
"""
if not self.owner:
return False
if skill in self.skills:
self.owner.msg(
{"alert": LS("You have already learned this skill.")})
return False
# Create skill object.
skill_obj = build_object(skill)
if not skill_obj:
self.owner.msg({"alert": LS("Can not learn this skill.")})
return False
# set default
if is_default:
skill_obj.set_default(is_default)
# Store new skill.
skill_obj.set_owner(self.owner)
self.skills[skill] = skill_obj
# If it is a passive skill, player's status may change.
if skill_obj.passive:
self.owner.refresh_data()
# Notify the player
if self.owner.has_player:
self.owner.show_status()
# Notify the player
if self.owner.has_player:
self.owner.show_skills()
self.owner.msg({
"msg":
LS("You learned skill {c%s{n.") % skill_obj.get_name()
})
return True
def func(self):
"Do shopping."
caller = self.caller
if not self.args:
caller.msg({"alert": LS("You should shopping in someplace.")})
return
shop = caller.search(self.args)
if not shop:
caller.msg({"alert": LS("Can not find this shop.")})
return
shop.show_shop(caller)
def localize_model_fields():
"""
Localize models field's verbose name and help text.
"""
for model_name in dir(models):
# get model classes
model = getattr(models, model_name)
if type(model) != type(Model):
continue
# get model fields
for field in model._meta.fields:
field.verbose_name = LS(field.name, "field_" + model.__name__)
field.help_text = LS(field.name, "help_" + model.__name__, "")
def func(self):
"Talk to an NPC."
caller = self.caller
if not self.args:
caller.msg({"alert": LS("You should talk to someone.")})
return
npc = caller.search(self.args, location=caller.location)
if not npc:
# Can not find the NPC in the caller's location.
caller.msg({"alert": LS("Can not find the one to talk.")})
return
caller.talk_to_npc(npc)
def check_available(self):
"""
Check this skill.
Returns:
message: (string) If the skill is not available, returns a string of reason.
If the skill is available, return "".
"""
if self.passive:
return LS("This is a passive skill!")
if self.is_cooling_down():
return LS("This skill is not ready yet!")
return ""
def skill_escape(caller, target, effect=0, *args, **kwargs):
"""
Escape from this combat.
args:
effect: the odds of fail.
"""
if not caller:
return
combat_handler = caller.ndb.combat_handler
if not combat_handler:
# caller is not in combat.
return
rand = random.random()
if rand < effect:
return [{
"type":
"escape",
"message":
[LS("%s tried to escape, but failed.") % caller.get_name()],
"caller":
caller.dbref,
"success":
False
}]
# send skill's result to the combat handler manually
# because the handler has been removed from the character
result = [{
"type":
"escape",
"message":
[LS("%s tried to escape. And succeeded!") % caller.get_name()],
"caller":
caller.dbref,
"success":
True
}]
combat_handler.msg_all_combat_process(result)
combat_handler.remove_character(caller)
if combat_handler.can_finish():
combat_handler.finish()
caller.msg({"combat_finish": {"escaped": True}})
return
def get_appearance(self, caller):
"""
This is a convenient hook for a 'look'
command to call.
"""
# Get name and description.
if caller.is_exit_unlocked(self.get_data_key()):
# If is unlocked, use common appearance.
return super(MudderyLockedExit, self).get_appearance(caller)
can_unlock = STATEMENT_HANDLER.match_condition(self.unlock_condition, caller, self)
if can_unlock and self.auto_unlock:
# Automatically unlock the exit when a character looking at it.
caller.unlock_exit(self)
# If is unlocked, use common appearance.
return super(MudderyLockedExit, self).get_appearance(caller)
cmds = []
if can_unlock:
# show unlock command
verb = self.unlock_verb
if not verb:
verb = LS("Unlock")
cmds = [{"name": verb, "cmd": "unlock_exit", "args": self.dbref}]
info = {"dbref": self.dbref,
"name": self.name,
"desc": self.locked_desc,
"cmds": cmds}
return info
def get_appearance(self, caller):
"""
This is a convenient hook for a 'look'
command to call.
"""
# get name and description
if caller.is_exit_unlocked(self.get_info_key()):
return super(MudderyLockedExit, self).get_appearance(caller)
can_unlock = script_handler.match_condition(
caller, self.exit_lock["condition"])
desc = self.exit_lock["message_lock"]
cmds = []
if can_unlock:
verb = self.exit_lock["verb"]
if not verb:
verb = LS("UNLOCK")
cmds = [{"name": verb, "cmd": "unlock_exit", "args": self.dbref}]
info = {
"dbref": self.dbref,
"name": self.name,
"desc": desc,
"cmds": cmds
}
return info
