def approval(self, msg_id): mark = WinningChatApprovalMark(self.server_id, self.char_id, msg_id) if mark.is_marked(): raise GameException(ConfigErrorMessage.get_error_id("APPROVAL_ONLY_ONCE")) index = -1 for _index, message in enumerate(self.doc['value']): if message['msg_id'] == msg_id: index = _index break if index == -1: raise GameException(ConfigErrorMessage.get_error_id("INVALID_OPERATE")) try: with self.LOCK(self.server_id, self.char_id).lock(3, 3): self.doc['value'][index]['approval'] += 1 self.doc['value'][index]['last_update_at'] += arrow.utcnow().timestamp MongoCommon.db(self.server_id).update_one( {'_id': self.get_id()}, {'$set': { 'value': self.doc['value'] }} ) _data = self.make_notify_data(message=self.doc['value'][index]) self.broadcast(_data) except LockTimeOut: raise GameException(ConfigErrorMessage.get_error_id("SERVER_BUSY")) mark.mark()
def daily_buy(self): config = ConfigActivityDailyBuy.get(self.create_day) if not config: raise GameException(ConfigErrorMessage.get_error_id("INVALID_OPERATE")) if self.create_day in self.doc['daily_buy']: raise GameException(ConfigErrorMessage.get_error_id("ACTIVITY_DAILY_BUY_HAS_BOUGHT")) cost = [(money_text_to_item_id('diamond'), config.diamond_now), ] rc = ResourceClassification.classify(cost) rc.check_exist(self.server_id, self.char_id) rc.remove(self.server_id, self.char_id, message="ActivityNewPlayer.daily_buy") rc = ResourceClassification.classify(config.items) rc.add(self.server_id, self.char_id, message="ActivityNewPlayer.daily_buy") self.doc['daily_buy'].append(self.create_day) MongoActivityNewPlayer.db(self.server_id).update_one( {'_id': self.char_id}, {'$push': { 'daily_buy': self.create_day }} ) self.send_daily_buy_notify() return rc
def step_up(self): if self.step >= self.config.max_step: raise GameException(ConfigErrorMessage.get_error_id("STAFF_ALREADY_MAX_STEP")) if self.level < self.config.steps[self.step].level_limit: raise GameException(ConfigErrorMessage.get_error_id("STAFF_LEVEL_NOT_ENOUGH")) using_items = self.config.steps[self.step].update_item_need resource_classified = ResourceClassification.classify(using_items) resource_classified.check_exist(self.server_id, self.char_id) resource_classified.remove(self.server_id, self.char_id, message="Staff.step_up:{0}".format(self.oid)) self.step += 1 MongoStaff.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'staffs.{0}.step'.format(self.id): self.step }} ) # NOTE 升阶可能会导致 天赋技能 改变 # 不仅会影响自己,可能(如果在阵型中)也会影响到其他选手 # 所以这里不自己 calculate, 而是先让 club 重新 load staffs staff_step_up_signal.send( sender=None, server_id=self.server_id, char_id=self.char_id, staff_id=self.id, staff_oid=self.oid, new_step=self.step )
def skill_level_up(self, skill_id): config = ConfigUnionSkill.get(skill_id) if not config: raise GameException(ConfigErrorMessage.get_error_id("UNION_SKILL_NOT_EXIST")) current_level = self.member_doc['skills'].get(str(skill_id), 0) if current_level >= config.max_level: raise GameException(ConfigErrorMessage.get_error_id("UNION_SKILL_REACH_SELF_MAX_LEVEL")) if current_level >= self.union_doc['level'] * 3: raise GameException(ConfigErrorMessage.get_error_id("UNION_SKILL_LEVEL_LIMITED_BY_UNION_LEVEL")) rc = ResourceClassification.classify(config.levels[current_level].cost) rc.check_exist(self.server_id, self.char_id) rc.remove(self.server_id, self.char_id, message="UnionJoined.skill_level_up") self.member_doc['skills'][str(skill_id)] = current_level + 1 MongoUnionMember.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'skills.{0}'.format(skill_id): current_level + 1 }} ) Club(self.server_id, self.char_id, load_staffs=False).force_load_staffs(send_notify=True) self.send_skill_notify(skill_id=skill_id)
def sign_in(self, _id): """ :rtype: ResourceClassification """ if self.get_signed_id(): raise GameException(ConfigErrorMessage.get_error_id("UNION_ALREADY_SIGNED")) config = ConfigUnionSignin.get(_id) if not config: raise GameException(ConfigErrorMessage.get_error_id("BAD_MESSAGE")) if config.vip: VIP(self.server_id, self.char_id).check(config.vip) rc = ResourceClassification.classify(config.cost) rc.check_exist(self.server_id, self.char_id) rc.remove(self.server_id, self.char_id, message="Union.sign_in") self.add_contribution(config.contribution, send_notify=False) rc = ResourceClassification.classify(config.rewards) rc.add(self.server_id, self.char_id, message="Union.sign_in") ValueLogUnionSignInTimes(self.server_id, self.char_id).record(sub_id=_id) self.send_notify() return rc
def agree(self, char_id): if char_id not in self.union_doc['apply_list']: self.send_my_check_notify() raise GameException(ConfigErrorMessage.get_error_id("UNION_TARGET_ALREADY_JOIN_A_UNION")) self.union_doc['apply_list'].remove(char_id) MongoUnion.db(self.server_id).update_many( {'apply_list': char_id}, {'$pull': { 'apply_list': char_id }} ) self.send_my_check_notify() if self.get_members_amount() >= ConfigUnionLevel.get(self.union_doc['level']).members_limit: raise GameException(ConfigErrorMessage.get_error_id("UNION_MEMBERS_REACH_LIMIT")) u = Union(self.server_id, char_id) if isinstance(u, UnionJoined): raise GameException(ConfigErrorMessage.get_error_id("UNION_TARGET_ALREADY_JOIN_A_UNION")) MongoUnionMember.db(self.server_id).update_one( {'_id': char_id}, {'$set': { 'joined': self.union_doc['_id'], 'joined_at': arrow.utcnow().timestamp }} ) self.send_notify() Union(self.server_id, char_id).send_all_notify()
def apply_union(self, union_id): kick_flag = self.member_doc.get('kick_flag', False) quit_flag = self.member_doc.get('quit_flag', False) if kick_flag or quit_flag: raise GameException(ConfigErrorMessage.get_error_id("UNION_CANNOT_APPLY_QUIT_OR_KICK")) doc = MongoUnion.db(self.server_id).find_one({'_id': union_id}) if not doc: raise GameException(ConfigErrorMessage.get_error_id("UNION_NOT_EXIST")) config = ConfigUnionLevel.get(doc['level']) if MongoUnionMember.db(self.server_id).find({'joined': union_id}).count() >= config.members_limit: raise GameException(ConfigErrorMessage.get_error_id("UNION_CANNOT_APPLY_MEMBERS_LIMIT")) MongoUnion.db(self.server_id).update_one( {'_id': union_id}, {'$addToSet': { 'apply_list': self.char_id }} ) self.send_my_applied_notify() u = Union(self.server_id, doc['owner']) u.send_my_check_notify()
def start(self, dungeon_id, formation_slots=None): grade_conf = ConfigDungeonGrade.get(dungeon_id) if not grade_conf: raise GameException(ConfigErrorMessage.get_error_id("DUNGEON_NOT_EXIST")) map_name = ConfigDungeon.get(grade_conf.belong).map_name club_level = get_club_property(self.server_id, self.char_id, 'level') if grade_conf.need_level > club_level: raise GameException(ConfigErrorMessage.get_error_id("DUNGEON_CLUB_LEVEL_NOT_ENOUGH")) f = Formation(self.server_id, self.char_id) if formation_slots: f.sync_slots(formation_slots) Energy(self.server_id, self.char_id).check(ConfigDungeon.get(grade_conf.belong).cost) ri = TimesInfo(self.server_id, self.char_id, grade_conf.belong) if not ri.remained_match_times: # 购买 self.buy_times(grade_conf.belong) club_one = Club(self.server_id, self.char_id) club_two = ConfigNPCFormation.get(grade_conf.npc) msg = ClubMatch(club_one, club_two, 6, f.get_skill_sequence(), {}).start() msg.key = str(dungeon_id) msg.map_name = map_name return msg
def turntable_pick(self, star): if star not in [3, 6, 9]: raise GameException(ConfigErrorMessage.get_error_id("BAD_MESSAGE")) if star > self.doc['current_star']: raise GameException(ConfigErrorMessage.get_error_id("TOWER_STAR_NOT_ENOUGH")) turntable = self.doc.get('turntable', {}) if not turntable: raise GameException(ConfigErrorMessage.get_error_id("INVALID_OPERATE")) got = random.choice(turntable[str(star)]) index = turntable['all_list'].index(got) self.doc['current_star'] -= star self.doc['talents'].append(got) MongoTower.db(self.server_id).update_one( {'_id': self.char_id}, { '$set': { 'current_star': self.doc['current_star'], 'talents': self.doc['talents'], 'turntable': {}, } } ) self.send_notify(act=ACT_UPDATE, levels=[]) return index
def levelup_formation(self, fid): from core.challenge import Challenge config = ConfigFormation.get(fid) if not config: raise GameException(ConfigErrorMessage.get_error_id("FORMATION_NOT_EXIST")) level = self.doc['levels'].get(str(fid), 0) if level == 0: raise GameException(ConfigErrorMessage.get_error_id("FORMATION_NOT_ACTIVE")) if level >= config.max_level: raise GameException(ConfigErrorMessage.get_error_id("FORMATION_REACH_MAX_LEVEL")) Challenge(self.server_id, self.char_id).check_starts(config.levels[level].level_up_need_star) rc = ResourceClassification.classify(config.levels[level].level_up_need_items) rc.check_exist(self.server_id, self.char_id) rc.remove(self.server_id, self.char_id, message="Formation.levelup_formation:{0}".format(fid)) self.doc['levels'][str(fid)] = level + 1 self.MONGO_COLLECTION.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'levels.{0}'.format(fid): level + 1 }} ) self.send_formation_notify(formation_ids=[fid]) if fid == self.doc['using']: # 阵型改变,从而改变天赋 # 所以这里暴力重新加载staffs club = Club(self.server_id, self.char_id, load_staffs=False) club.force_load_staffs(send_notify=True)
def use_formation(self, fid): if fid != 0: config = ConfigFormation.get(fid) if not config: raise GameException(ConfigErrorMessage.get_error_id("FORMATION_NOT_EXIST")) level = self.doc['levels'].get(str(fid), 0) if level == 0: raise GameException(ConfigErrorMessage.get_error_id("FORMATION_NOT_ACTIVE")) if not self.is_formation_valid(fid): raise GameException(ConfigErrorMessage.get_error_id("FORMATION_CAN_NOT_USE")) updater = {'using': fid} self.doc['using'] = fid # 把格子策略设置为默认值 for k in self.doc['slots']: self.doc['slots'][k]['policy'] = 1 updater['slots.{0}.policy'.format(k)] = 1 self.MONGO_COLLECTION.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': updater} ) self.send_slot_notify(slot_ids=self.doc['slots'].keys()) self.send_formation_notify(formation_ids=[]) # 阵型改变,从而改变天赋 # 所以这里暴力重新加载staffs club = Club(self.server_id, self.char_id, load_staffs=False) club.force_load_staffs(send_notify=True)
def active_formation(self, fid): from core.challenge import Challenge config = ConfigFormation.get(fid) if not config: raise GameException(ConfigErrorMessage.get_error_id("FORMATION_NOT_EXIST")) if str(fid) in self.doc['levels']: raise GameException(ConfigErrorMessage.get_error_id("FORMATION_ALREADY_ACTIVE")) Challenge(self.server_id, self.char_id).check_starts(config.active_need_star) rc = ResourceClassification.classify(config.active_need_items) rc.check_exist(self.server_id, self.char_id) rc.remove(self.server_id, self.char_id, message="Formation.active_formation:{0}".format(fid)) self.doc['levels'][str(fid)] = 1 self.MONGO_COLLECTION.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'levels.{0}'.format(fid): 1 }} ) self.send_formation_notify(formation_ids=[fid])
def equipment_change(self, staff_id, slot_id, tp): from core.formation import Formation if tp not in [EQUIP_MOUSE, EQUIP_KEYBOARD, EQUIP_MONITOR, EQUIP_DECORATION, EQUIP_SPECIAL]: raise GameException(ConfigErrorMessage.get_error_id("INVALID_OPERATE")) staff = self.get_staff_object(staff_id) if not staff: raise GameException(ConfigErrorMessage.get_error_id("STAFF_NOT_EXIST")) other_staff_id = staff.equipment_change(slot_id, tp) if other_staff_id: # 把装备从 这个 staff 上撤下 self.get_staff_object(other_staff_id).equipment_change("", tp) changed = [staff_id] if other_staff_id: changed.append(other_staff_id) self.send_notify(ids=changed) in_formation_staff_ids = Formation(self.server_id, self.char_id).in_formation_staffs().keys() if staff.id in in_formation_staff_ids or other_staff_id in in_formation_staff_ids: self.after_staff_change(staff_id) task_condition_trig_signal.send( sender=None, server_id=self.server_id, char_id=self.char_id, condition_name='core.formation.Formation' )
def get_honor_reward(self, honor_id): config = ConfigArenaHonorReward.get(honor_id) if not config: raise GameException(ConfigErrorMessage.get_error_id("BAD_MESSAGE")) if honor_id > self.get_honor_points(): raise GameException(ConfigErrorMessage.get_error_id("ARENA_HONOR_REWARD_POINT_NOT_ENOUGH")) reward_info = self.get_today_honor_reward_info() if honor_id in reward_info: raise GameException(ConfigErrorMessage.get_error_id("ARENA_HONOR_REWARD_ALREADY_GOT")) resource_classified = ResourceClassification.classify(config.reward) resource_classified.add(self.server_id, self.char_id, message="Arena.get_honor_reward:{0}".format(honor_id)) today_key = str(get_start_time_of_today().timestamp) MongoArena.db(self.server_id).update_one( {'_id': str(self.char_id)}, { '$push': { 'honor_rewards.{0}'.format(today_key): honor_id } } ) reward_info.append(honor_id) self.send_honor_notify(reward_info=reward_info) return resource_classified
def level_reward_get(self, _id): config = ConfigWelfareLevelReward.get(_id) if not config: raise GameException(ConfigErrorMessage.get_error_id("BAD_MESSAGE")) status = self.get_level_reward_item_status(_id) if status == WELFARE_CAN_NOT: raise GameException(ConfigErrorMessage.get_error_id("WELFARE_LEVEL_REWARD_CAN_NOT")) if status == WELFARE_HAS_GOT: raise GameException(ConfigErrorMessage.get_error_id("WELFARE_LEVEL_REWARD_HAS_GOT")) self.doc['level_reward'].append(_id) rc = ResourceClassification.classify(config.reward) rc.add(self.server_id, self.char_id, message="Welfare.level_reward_get:{0}".format(_id)) MongoWelfare.db(self.server_id).update_one( {'_id': self.char_id}, {'$push': { 'level_reward': _id }} ) self.send_level_reward_notify(_id) return rc
def buy(self, item_id): config = ConfigTerritoryStore.get(item_id) if not config: raise GameException(ConfigErrorMessage.get_error_id("TERRITORY_STORE_ITEM_NOT_EXIST")) remained_times = self.get_remained_times(item_id) if not remained_times: raise GameException(ConfigErrorMessage.get_error_id("TERRITORY_STORE_ITEM_NO_TIMES")) resource_classified = ResourceClassification.classify(config.needs) resource_classified.check_exist(self.server_id, self.char_id) resource_classified.remove(self.server_id, self.char_id, message="TerritoryStore.buy:{0}".format(item_id)) got = [(config.item_id, config.item_amount), ] resource_classified = ResourceClassification.classify(got) resource_classified.add(self.server_id, self.char_id, message="TerritoryStore.buy:{0}".format(item_id)) if str(item_id) in self.times: self.times[str(item_id)] += 1 else: self.times[str(item_id)] = 1 ValueLogTerritoryStoreBuyTimes(self.server_id, self.char_id).record(sub_id=item_id) self.send_notify(item_id=item_id) return resource_classified
def get_reward(self, _id): if arrow.utcnow().timestamp >= self.reward_end_at: raise GameException(ConfigErrorMessage.get_error_id("ACTIVITY_NEW_PLAYER_REWARD_EXPIRE")) config = ConfigActivityNewPlayer.get(_id) if not config: raise GameException(ConfigErrorMessage.get_error_id("BAD_MESSAGE")) if config.day > self.create_day: raise GameException(ConfigErrorMessage.get_error_id("ACTIVITY_NEW_PLAYER_DAY_NOT_ARRIVE")) _, status = self.get_activity_status(_id) if status == ACTIVITY_COMPLETE: raise GameException(ConfigErrorMessage.get_error_id("ACTIVITY_NEW_PLAYER_HAS_GOT")) if status == ACTIVITY_DOING: raise GameException(ConfigErrorMessage.get_error_id("ACTIVITY_NEW_PLAYER_CONDITION_NOT_SATISFY")) rc = ResourceClassification.classify(config.rewards) rc.add(self.server_id, self.char_id, message="ActivityNewPlayer.get_reward:{0}".format(_id)) self.doc['done'].append(_id) MongoActivityNewPlayer.db(self.server_id).update_one( {'_id': self.char_id}, {'$push': { 'done': _id }} ) self.send_notify(ids=[_id]) return rc
def create(self, party_level): ret = api_handle.API.Party.CreateDone() ret.ret = 0 config = ConfigPartyLevel.get(party_level) if not config: ret.ret = ConfigErrorMessage.get_error_id("INVALID_OPERATE") return ret union = Union(self.server_id, self.char_id) union_id = union.get_joined_union_id() if not union_id: ret.ret = ConfigErrorMessage.get_error_id("PARTY_CANNOT_CREATE_NO_UNION") try: union.check_level(config.need_union_level) cost = [(money_text_to_item_id('diamond'), config.need_diamond), ] rc = ResourceClassification.classify(cost) rc.check_exist(self.server_id, self.char_id) except GameException as e: ret.ret = e.error_id return ret ret.union_id = union_id return ret
def skill_sequence_set_staff(self, seq_id, index_id, staff_id): if seq_id not in self.SKILL_SEQUENCE_IDS: raise GameException(ConfigErrorMessage.get_error_id("INVALID_OPERATE")) if index_id not in self.SKILL_SEQUENCE_INDEX_RANGE: raise GameException(ConfigErrorMessage.get_error_id("INVALID_OPERATE")) skill_sequence = self.doc.get('skill_sequence', {}) if staff_id == "": # 下人 try: skill_sequence[str(seq_id)][index_id] = "" except (KeyError, IndexError): raise GameException(ConfigErrorMessage.get_error_id("INVALID_OPERATE")) else: # 上人,检查是否在阵型中 if not self.is_staff_in_formation(staff_id): raise GameException(ConfigErrorMessage.get_error_id("FORMATION_STAFF_NOT_IN")) staffs = skill_sequence.get(str(seq_id), ["", "", ""]) if staff_id in staffs: raise GameException(ConfigErrorMessage.get_error_id("SKILL_SEQUENCE_CAN_NOT_SAME")) staffs[index_id] = staff_id skill_sequence[str(seq_id)] = staffs self.doc['skill_sequence'] = skill_sequence self.MONGO_COLLECTION.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'skill_sequence': skill_sequence }} )
def buy_reward(self, vip_level): self.check(vip_level) config = ConfigVIP.get(vip_level) if not config: raise GameException(ConfigErrorMessage.get_error_id("INVALID_OPERATE")) if vip_level in self.doc['rewards']: raise GameException(ConfigErrorMessage.get_error_id("VIP_ALREADY_BUY_REWARD")) needs = [(money_text_to_item_id('diamond'), config.diamond_now)] rc = ResourceClassification.classify(needs) rc.check_exist(self.server_id, self.char_id) rc.remove(self.server_id, self.char_id, message="VIP.buy_reward:{0}".format(vip_level)) got = [(config.item_id, 1)] rc = ResourceClassification.classify(got) rc.add(self.server_id, self.char_id, message="VIP.buy_reward:{0}".format(vip_level)) self.doc['rewards'].append(vip_level) MongoVIP.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'rewards': self.doc['rewards'] }} ) self.send_notify() return rc
def get_reward(self, task_id): config = ConfigTaskDaily.get(task_id) if not config: raise GameException(ConfigErrorMessage.get_error_id("INVALID_OPERATE")) _, status = self.get_task_status(task_id) if status == TASK_DONE: raise GameException(ConfigErrorMessage.get_error_id("TASK_GET_REWARD_ALREADY_GOT")) if status != TASK_FINISH: raise GameException(ConfigErrorMessage.get_error_id("TASK_GET_REWARD_NOT_FINISH")) self.doc['tasks'].remove(task_id) self.doc['done'].append(task_id) resource_classified = ResourceClassification.classify(config.rewards) resource_classified.add(self.server_id, self.char_id, message="TaskDaily.get_reward:{0}".format(task_id)) MongoTaskDaily.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'tasks': self.doc['tasks'], 'done': self.doc['done'], }} ) self.send_notify(task_ids=[task_id]) return resource_classified
def accept(self, char_id, verify=True): char_id = int(char_id) key = 'friends.{0}'.format(char_id) if verify: doc = MongoFriend.db(self.server_id).find_one({'_id': self.char_id}, {key: 1}) status = doc['friends'].get(str(char_id), FRIEND_STATUS_NOT) if status == FRIEND_STATUS_NOT or status == FRIEND_STATUS_PEER_CONFIRM: raise GameException(ConfigErrorMessage.get_error_id("FRIEND_ACCEPT_ERROR")) if status == FRIEND_STATUS_OK: raise GameException(ConfigErrorMessage.get_error_id("FRIEND_ALREADY_IS_FRIEND")) MongoFriend.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': {key: FRIEND_STATUS_OK}} ) self.send_notify(ids=[char_id]) FriendManager(self.server_id, char_id).someone_accept_me(self.char_id) friend_ok_signal.send( sender=None, server_id=self.server_id, char_id=self.char_id, friend_id=char_id )
def daily_reward_get(self, _id): config = ConfigPlunderDailyReward.get(_id) if not config: raise GameException(ConfigErrorMessage.get_error_id("INVALID_OPERATE")) key, info = self.get_daily_reward_info() win_ways = info.get('win_ways', 0) got_list = info.get('got_list', []) if _id in got_list: raise GameException(ConfigErrorMessage.get_error_id("PLUNDER_DAILY_REWARD_ALREADY_GOT")) if win_ways < _id: raise GameException(ConfigErrorMessage.get_error_id("PLUNDER_DAILY_REWARD_NOT_ENOUGH")) rc = ResourceClassification.classify(config.reward) rc.add(self.server_id, self.char_id, message="Plunder.daily_reward_get:{0}".format(_id)) got_list.append(_id) info['got_list'] = got_list self.doc['daily_reward'] = {key: info} MongoPlunder.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'daily_reward': {key: info} }} ) self.send_plunder_daily_reward_notify(info=info) return rc
def add(self, name): doc = MongoCharacter.db(self.server_id).find_one({'name': name}, {'_id': 1}) if not doc: raise GameException(ConfigErrorMessage.get_error_id("CHAR_NOT_EXIST")) char_id = doc['_id'] key = 'friends.{0}'.format(char_id) doc = MongoFriend.db(self.server_id).find_one({'_id': self.char_id}, {key: 1}) status = doc['friends'].get(str(char_id), FRIEND_STATUS_NOT) if status == FRIEND_STATUS_OK: raise GameException(ConfigErrorMessage.get_error_id("FRIEND_ALREADY_IS_FRIEND")) if status == FRIEND_STATUS_PEER_CONFIRM: raise GameException(ConfigErrorMessage.get_error_id("FRIEND_ADD_REQUEST_ALREADY_SENT")) if status == FRIEND_STATUS_SELF_CONFIRM: # 要添加的是,需要自己确认的,也就是对方也想添加我。那么就直接成为好友 self.accept(char_id, verify=False) return MongoFriend.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': {key: FRIEND_STATUS_PEER_CONFIRM}} ) self.send_notify(ids=[char_id]) FriendManager(self.server_id, char_id).someone_add_me(self.char_id)
def plunder_report(self, key, win): try: way = int(key) assert way in [1, 2, 3] except: raise GameException(ConfigErrorMessage.get_error_id("BAD_MESSAGE")) way_index = way - 1 result = 1 if win else 2 target_id = self.doc['matching']['id'] if not target_id: raise GameException(ConfigErrorMessage.get_error_id("INVALID_OPERATE")) updater = {} self.doc['matching']['result'][way_index] = result updater['matching.result.{0}'.format(way_index)] = result if win: daily_key, info = self.get_daily_reward_info() win_ways = info.get('win_ways', 0) info['win_ways'] = win_ways + 1 self.doc['daily_reward'] = {daily_key: info} updater['daily_reward'] = {daily_key: info} MongoPlunder.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': updater} ) self.send_plunder_daily_reward_notify() self.send_result_notify() WinningPlunder(self.server_id, self.char_id).set(win)
def speedup(self): if not self.doc['item_id']: raise GameException(ConfigErrorMessage.get_error_id("SPECIAL_EQUIPMENT_NOT_IN_PROCESS")) seconds = self.doc['finish_at'] - arrow.utcnow().timestamp if seconds <= 0: raise GameException(ConfigErrorMessage.get_error_id("SPECIAL_EQUIPMENT_ALREADY_FINISHED")) minutes, remained = divmod(seconds, 60) if remained: minutes += 1 diamond = minutes * GlobalConfig.value("EQUIPMENT_SPECIAL_SPEEDUP_PARAM") * 0.1 diamond = int(diamond) cost = [(money_text_to_item_id('diamond'), diamond)] rc = ResourceClassification.classify(cost) rc.check_exist(self.server_id, self.char_id) rc.remove(self.server_id, self.char_id, message="SpecialEquipmentGenerator.speedup") # make sure is finished self.doc['finish_at'] = arrow.utcnow().timestamp - 1 MongoSpecialEquipment.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'finish_at': self.doc['finish_at'] }} ) self.send_notify()
def new_player_get(self, _id): config = ConfigWelfareNewPlayer.get(_id) if not config: raise GameException(ConfigErrorMessage.get_error_id("BAD_MESSAGE")) status = self.get_new_player_item_status(_id) if status == WELFARE_CAN_NOT: raise GameException(ConfigErrorMessage.get_error_id("WELFARE_NEW_PLAYER_CAN_NOT")) if status == WELFARE_HAS_GOT: raise GameException(ConfigErrorMessage.get_error_id("WELFARE_NEW_PLAYER_HAS_GOT")) self.doc['new_player'].append(_id) rc = ResourceClassification.classify(config.reward) rc.add(self.server_id, self.char_id, message="Welfare.new_player_get:{0}".format(_id)) MongoWelfare.db(self.server_id).update_one( {'_id': self.char_id}, {'$push': { 'new_player': _id }} ) self.send_new_player_notify(_id) return rc
def start(self, challenge_id, formation_slots=None): config = ConfigChallengeMatch.get(challenge_id) if not config: raise GameException(ConfigErrorMessage.get_error_id("CHALLENGE_NOT_EXIST")) if config.condition_challenge: doc = MongoChallenge.db(self.server_id).find_one( {'_id': self.char_id}, {'challenge_star.{0}'.format(config.condition_challenge): 1} ) if str(config.condition_challenge) not in doc['challenge_star']: raise GameException(ConfigErrorMessage.get_error_id("CHALLENGE_NOT_OPEN")) rt = RemainedTimes(self.server_id, self.char_id, challenge_id) if not rt.remained_match_times: raise GameException(ConfigErrorMessage.get_error_id("CHALLENGE_WITHOUT_TIMES")) f = Formation(self.server_id, self.char_id) if formation_slots: f.sync_slots(formation_slots) Energy(self.server_id, self.char_id).check(config.energy) club_one = Club(self.server_id, self.char_id) club_two = ChallengeNPCClub(challenge_id) match = ClubMatch(club_one, club_two, 6, f.get_skill_sequence(), {}) msg = match.start() msg.key = str(challenge_id) msg.map_name = config.map_name return msg
def kick(self, char_id): if char_id == self.char_id: raise GameException(ConfigErrorMessage.get_error_id("BAD_MESSAGE")) u = Union(self.server_id, char_id) if not isinstance(u, UnionMember) or u.member_doc['joined'] != self.union_doc['_id']: raise GameException(ConfigErrorMessage.get_error_id("UNION_TARGET_NOT_MEMBER")) u.quit()
def register(name, password): if not name or not password: raise GameException(ConfigErrorMessage.get_error_id("BAD_MESSAGE")) try: with transaction.atomic(): account = AccountRegular.objects.create(name=name, passwd=password) except IntegrityError: raise GameException(ConfigErrorMessage.get_error_id("ACCOUNT_NAME_TAKEN")) return account
def find_search_target_index_by_target_id(self, target_id): target_id = str(target_id) for index, s in enumerate(self.doc['search']): if str(s['id']) == target_id: return index raise GameException( ConfigErrorMessage.get_error_id("PLUNDER_CANNOT_FIND_TARGET"))
def test_speedup_slot_empty(self): try: TrainingProperty(1, 1).speedup(self.staff_id, 1) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( 'TRAINING_PROPERTY_SPEEDUP_CANNOT_EMPTY') else: raise Exception('error')
def test_delte_not_exist(self): try: Notification(1, 1).delete("xxxxx") except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "NOTIFICATION_NOT_EXIST") else: raise Exception("can not be here!")
def test_cancel_not_broadcast(self): try: TrainingBroadcast(1, 1).cancel(1) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "TRAINING_BROADCAST_NOT_TRAINING") else: raise Exception('Error')
def check_work_card(self, amount): new_amount = self.doc['work_card'] - amount if new_amount < 0: raise GameException( ConfigErrorMessage.get_error_id( "TERRITORY_WORK_CARD_NOT_ENOUGH")) return new_amount
def test_start_not_open(self): sponsor_id = self.get_one_not_open_sponsor() try: TrainingSponsor(1, 1).start(sponsor_id) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id("TRAINING_SPONSOR_NOT_OPEN") else: raise Exception("error")
def set_unit(self, way_id, slot_id, unit_id): if slot_id not in [1, 2, 3]: raise GameException( ConfigErrorMessage.get_error_id("INVALID_OPERATE")) w = self.get_way_object(way_id) w.set_unit(slot_id, unit_id) self.send_formation_notify()
def test_get_reward(self): try: ActivityLoginReward(1, 1).get_reward(10) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "LOGIN_REWARD_NOT_TO_TIME") else: raise Exception("can not be here!")
def test_start_in_broadcasting(self): TrainingBroadcast(1, 1).start(1, self.staff_id) try: TrainingShop(1, 1).start(1, self.staff_id) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "TRAINING_DOING_BROADCAST") else: raise Exception('Error')
def test_set_staffs_not_own(self): staff_ids = random.sample(ConfigStaff.INSTANCES.keys(), 10) try: Club(1, 1).set_match_staffs(staff_ids) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "STAFF_NOT_EXIST") else: raise RuntimeError("can not be here!")
def auto_refresh(self, tp): if tp not in ALL_TYPES: raise GameException( ConfigErrorMessage.get_error_id("INVALID_OPERATE")) if self.next_auto_refresh_timestamp(tp) > arrow.utcnow().timestamp: return self.make_refresh(tp, set_timestamp=True)
def test_upgrade_speedup_can_not(self): skills = SkillManager(1, 1).get_staff_skills(self.staff_id) skill_id = random.choice(skills.keys()) try: SkillManager(1, 1).upgrade_speedup(self.staff_id, int(skill_id)) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id("SKILL_UPGRADE_SPEEDUP_CANNOT") else: raise Exception('error')
def test_buy_not_exist(self): l = LadderStore(1, 1) try: l.buy(9999999999) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "LADDER_STORE_ITEM_NOT_EXIST") else: raise Exception("can not be here!")
def test_start_item_not_enough(self): try: TrainingProperty(1, 1).start(self.staff_id, get_one_available_training(1)) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "ITEM_NOT_ENOUGH") else: raise Exception('error')
def check_product(self, items): # items: [(_id, amount),] for _id, amount in items: building_id = TERRITORY_PRODUCT_BUILDING_TABLE[_id] if self.doc['buildings'][str( building_id)]['product_amount'] < amount: raise GameException( ConfigErrorMessage.get_error_id( "ITEM_{0}_NOT_ENOUGH".format(_id)))
def test_start_signing(self): sponsor_id = self.open_sponsor() try: TrainingSponsor(1, 1).start(sponsor_id) TrainingSponsor(1, 1).start(sponsor_id) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id("TRAINING_SPONSOR_ALREADY_START") else: raise Exception("error")
def test_start_doing_shop(self): TrainingShop(1, 1).start(1, self.staff_id) try: TrainingBroadcast(1, 1).start(1, self.staff_id) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "TRAINING_DOING_SHOP") else: raise Exception('error')
def test_speedup_not_enough_diamond(self): try: TrainingBroadcast(1, 1).start(1, self.staff_id) TrainingBroadcast(1, 1).speedup(1) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "DIAMOND_NOT_ENOUGH") else: raise Exception('Error')
def test_get_reward_not_finish(self): TrainingBroadcast(1, 1).start(1, int(self.staff_id)) try: TrainingBroadcast(1, 1).get_reward(1) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "TRAINING_BROADCAST_NOT_FINISH") else: raise Exception('error')
def test_check_talent_points_not_enough(self): amount = 10000 try: TalentManager(self.server_id, self.char_id).check_talent_points(amount) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id("BAD_MESSAGE") else: Exception('Error')
def test_start_slot_not_empty(self): TrainingBroadcast(1, 1).start(1, self.staff_id) try: TrainingBroadcast(1, 1).start(1, self.staff_id) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "TRAINING_BROADCAST_NOT_EMPTY") else: raise Exception('Error')
def wrap(self, *args, **kwargs): now = arrow.utcnow().to(settings.TIME_ZONE) for (_h1, _m1), (_h2, _m2) in TIME_LIMIT: if _h1 <= now.hour <= _h2 and _m1 <= now.minute < _m2: raise GameException( ConfigErrorMessage.get_error_id( "CHAMPIONSHIP_FORMATION_FORBIDDEN")) return fun(self, *args, **kwargs)
def test_accept_error(self): self.make_friend_request() try: FriendManager(1, 1).accept(2) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id("FRIEND_ACCEPT_ERROR") else: raise Exception('test_accept_error error')
def test_add_request_already_sent(self): self.make_friend_request() try: FriendManager(1, 1).add('two') except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id('FRIEND_ADD_REQUEST_ALREADY_SENT') else: raise Exception('add_request_sended error')
def test_get_reward_can_not(self): i = random.choice(ConfigActiveReward.INSTANCES.keys()) try: ActiveValue(1, 1).get_reward(i) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "ACTIVE_REWARD_CAN_NOT_GET") else: raise Exception("can not be here!")
def set_staff(self, way_id, slot_id, staff_id): way_list = [1, 2, 3] if way_id not in way_list: raise GameException( ConfigErrorMessage.get_error_id("INVALID_OPERATE")) if slot_id not in [1, 2, 3]: raise GameException( ConfigErrorMessage.get_error_id("INVALID_OPERATE")) way_list.remove(way_id) for i in way_list: w = self.get_way_object(i) w.try_unset_staff(staff_id) w = self.get_way_object(way_id) w.set_staff(slot_id, staff_id) self.send_formation_notify()
def test_start_doing_exp(self): set_enough_gold_and_diamond(self.staff_id) TrainingExp(1, 1).start(1, self.staff_id) try: TrainingBroadcast(1, 1).start(1, self.staff_id) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "TRAINING_DOING_EXP") else: raise Exception('error')
def test_start_times_limit(self): Dungeon(self.server_id, self.char_id).report(1, 2) try: Dungeon(self.server_id, self.char_id).start(1) except GameException as e: print e.error_id assert e.error_id == ConfigErrorMessage.get_error_id( "DUNGEON_NO_TIMES") else: raise Exception('error')
def get_attachment(self, mail_id): this_mail = self.get_mail(mail_id) if not this_mail: raise GameException(ConfigErrorMessage.get_error_id("MAIL_NOT_EXISTS")) attachment = this_mail['attachment'] if not attachment: raise GameException(ConfigErrorMessage.get_error_id("MAIL_HAS_NO_ATTACHMENT")) rc = ResourceClassification.load_from_json(attachment) rc.add(self.server_id, self.char_id, message="MailManager.get_attachment") MongoMail.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': {'mails.{0}.attachment'.format(mail_id): ""}} ) self.send_notify(ids=[mail_id]) return rc
def test_start_staff_in_training(self): TrainingShop(1, 1).open([2]) TrainingShop(1, 1).start(2, self.staff_id) try: TrainingShop(1, 1).start(1, self.staff_id) except GameException as e: assert e.error_id == ConfigErrorMessage.get_error_id( "TRAINING_SHOP_STAFF_IN_TRAINING") else: raise Exception('error')