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