def skill_up(self, msgtype, body): req = poem_pb.SkillUpRequest() req.ParseFromString(body) error = fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST) p = self.player pet = p.pets.get(req.petID) if not pet: return error configs = get_config(PetLevelOrSkillLevelUpConfig) skill_level = getattr(pet, "skill%d" % req.skill, None) if skill_level is None: return error count = req.count or 1 if skill_level + count > pet.level: return error cost = {} for l in range(skill_level, skill_level + count): config = configs[l] combine_reward([getattr(config, "skill%d_cost" % req.skill, {})], [], cost) cost["skillpoint"] = cost.setdefault("skillpoint", 0) + 1 try: apply_reward(p, {}, cost, type=RewardType.PetSkillUp) except AttrNotEnoughError: return error setattr(pet, "skill%d" % req.skill, skill_level + count) from task.manager import on_skillup on_skillup(p, count) # p.update_power() pet.save() pet.sync() p.save() p.sync() return success_msg(msgtype, "")
def uproar_reward_in_campaign(must=None, drop=None): config = g_campaignManager.uproar_campaign.get_current() result = {} if not must: must = {} else: must = dict(must) if not drop: drop = {} else: drop = dict(drop) if not config: result = drop result.update(must) return drop cmoney, cjiutian, cdrop = str(config.group) cmoney = int(cmoney) cjiutian = int(cjiutian) cdrop = int(cdrop) if must.get("money"): must["money"] *= cmoney if must.get("jiutian"): must["jiutian"] *= cjiutian result.update(must) for i in range(cdrop): combine_reward(drop, [], data=result) return result
def breed(self, msgtype, body): from protocol.poem_pb import BreedRequest req = BreedRequest() req.ParseFromString(body) player = self.player from entity.manager import save_guide save_guide(player, req.guide_type) # 保存新手引导进度 c = req.count or 1 pet = player.pets.get(req.petID) if not pet: return fail_msg(msgtype, reason='精灵不存在') if pet.level + c > pet.max_level: return fail_msg(msgtype, reason='超过最大等级') # info = get_config(PetConfig)[pet.prototypeID] # money, soul = breed_cost(info.cexp, pet.level, pet.level + c) cost = {} for level in range(pet.level, pet.level + c): linfo = get_config(PetLevelOrSkillLevelUpConfig)[level] combine_reward([linfo.units_cost1, linfo.units_cost2], {}, data=cost) try: apply_reward(player, None, cost=cost, type=RewardType.BreedPet) except AttrNotEnoughError: return fail_msg(msgtype, reason="金币或水晶不足") pet.level += c pet.save() from task.manager import on_breed on_breed(player, pet) # player.update_power() player.save() pet.sync() player.sync() return success_msg(msgtype, '')
def apply_dlc_reward(fbID, reward=None, isfirst=False): if not reward: reward = {} config = get_config(DlcFbInfoConfig).get(fbID) if not config: return reward if isfirst: reward = combine_reward(reward, config.first_rewards) return combine_reward(reward, config.rewards)
def maze_step(self, msgtype, body): p = self.player req = poem_pb.MazeStepRequest() req.ParseFromString(body) count = p.maze_rest_count if req.onekey else 1 # check count if count > p.maze_rest_count: return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST) gains = {} attr = {} mazes = [] incr = {} results = step_mazes(p, attr, incr, count) count = len(results) rsp = poem_pb.MazeStepResponse() for each in results: drop = each.get("drop", 0) if drop: maze_drop = open_reward(RewardType.MazeDrop, drop) rewards = maze_drop.apply_after() gains = combine_reward(rewards, {}, data=gains) if each.get("append", False): mazes.append(each) drop = get_cons_value("MazeMustDropID") must_drop = open_reward(RewardType.MazeDrop, drop) rewards = must_drop.apply_after() gains = combine_reward(rewards, {}, data=gains) rsp.events.add(**each) rsp.rewards = build_reward(gains) for each in mazes: p.mazes.append(each) apply_reward(p, gains, type=RewardType.MazeDrop) for each, value in attr.items(): setattr(p, each, value) for each, value in incr.items(): setattr(p, each, getattr(p, each) + value) if "mall_silver_open_remain" in attr: try: del p.malls[MallType.Silver] except KeyError: pass if "mall_golden_open_remain" in attr: try: del p.malls[MallType.Golden] except KeyError: pass p.touch_mazes() p.maze_step_count += count on_maze_count(p, count) p.save() p.sync() return success_msg(msgtype, rsp)
def advance_equip(p, petID, equipID, equips): pet = p.pets.get(petID) if not pet: return msgTips.FAIL_MSG_INVALID_REQUEST equip = get_or_create_equip(p, pet, equipID) if not equip: return msgTips.FAIL_MSG_INVALID_REQUEST equip_config = get_config(NewEquipConfig).get(equip.prototypeID) if not equip_config: return msgTips.FAIL_MSG_INVALID_REQUEST binding = p.equipeds.get(equip.entityID) if petID != binding: return msgTips.FAIL_MSG_INVALID_REQUEST advance_configs = get_config(EquipAdvanceConfig) advance_config = advance_configs.get(equip.step) if equip.step + 1 > max(advance_configs): return msgTips.FAIL_MSG_INVALID_REQUEST # 宠物必须满足等级要求 if pet.level < advance_config.level: return msgTips.FAIL_MSG_INVALID_REQUEST advance_cost_config = get_config(EquipAdvanceCostConfig).get( equip_config.gup_id) if not advance_cost_config: return msgTips.FAIL_MSG_INVALID_REQUEST cost = parse_reward(advance_cost_config.costs[equip.step - 1]) combine_reward({"money": advance_config.money}, {}, data=cost) equipList = sorted([i[0] for i in cost.pop("equipList", [])]) try: # 扣除装备,宠物 TODO equips = [p.equips[i] for i in equips] equips_prototypeID = sorted([i.prototypeID for i in equips]) if len(equips_prototypeID) != len(equipList): raise KeyError for i in range(len(equips_prototypeID)): if equips_prototypeID[i] != equipList[i]: raise KeyError apply_reward(p, {}, cost, type=RewardType.EquipAdvance) p.del_equips(*equips) except KeyError: return msgTips.FAIL_MSG_INVALID_REQUEST except (AttrNotEnoughError or MatNotEnoughError): return msgTips.FAIL_MSG_INVALID_REQUEST equip.step += 1 from task.manager import on_advance_equip on_advance_equip(p, equip) update_ranking_equip(p, equip) equip.save() equip.sync() p.save() p.sync() return SUCCESS
def trigger_chest_recv(self, msgtype, body): p = self.player if not check_trigger_event_type(p, EventType.Chest): return fail_msg(msgtype, reason="无触发事件或错误的事件类型") req = poem_pb.TriggerChestRecvRequest() req.ParseFromString(body) config = get_config(TriggerEventConfig)[p.trigger_event] chest = get_config(TriggerChestConfig).get(config.event_param) if not chest: return fail_msg(msgtype, reason="不存在的宝箱") if req.is_double: cost = {"gold": get_cons_value("TriggerChestDoubleCost")} gain = {} for i in range(get_cons_value("TriggerChestMultiple")): gain = combine_reward([chest.reward], [], data=gain) else: cost = {} gain = parse_reward([chest.reward]) try: apply_reward(p, gain, cost=cost, type=RewardType.TriggerChest) except AttrNotEnoughError: return fail_msg(msgtype, reason="钻石不足") p.trigger_event = 0 p.save() p.sync() rsp = poem_pb.TriggerChestRecv() build_reward_msg(rsp, gain) return success_msg(msgtype, rsp)
def visit(p, count): gain = {} cost = {} configs = get_config(VisitConfig) incr_groups = get_config(VisitIncrByGroupConfig) choices = [] campaign = g_campaignManager.visit_campaign campaign_opened = campaign.is_open() luck = {} for i in range(count): weighted_samples = [] rewards = None for k, config in configs.items(): if config.flag and campaign_opened: current = campaign.get_current() incr_configs = incr_groups.get(current.reward_group) VISIT_COUNT = incr_visit_flag() for incr_config in incr_configs: if VISIT_COUNT % incr_config.count == 0: choice = incr_config reward = open_reward(RewardType.Visit, choice.drop) rewards = reward.apply_after() combine_reward(rewards, {}, data=luck) break if rewards: break else: weighted_samples.append([config, config.prob]) if not rewards: choice = weighted_random2(weighted_samples) rewards = choice.rewards choices.append(choice.id) gain_pious = {"pious": 1} gain = combine_reward(rewards, gain_pious, data=gain) if p.visit_free_rest_count < count: count = count - p.visit_free_rest_count if p.dream: cost["dream"] = min(p.dream, count) count -= cost["dream"] if count: cost["gold"] = p.visit_cost * count return gain, cost, choices, luck
def city_contend_drop_event(self, msgtype, body): p = self.player if not p.factionID: return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_HAS_NOT_FACTION) if not g_campaignManager.city_contend_campaign.is_open(): return fail_msg(msgtype, msgTips.FAIL_MSG_CITY_CAMPAIGN_CLOSED) if not g_cityContend.check_event(p, CityContendEventType.Drop): return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST) event = g_cityContend.get_current_step(p) if g_cityContend.is_top_faction(p.factionID): result = open_reward(RewardType.CityContend, event["argv"]) else: result = open_reward(RewardType.CityContend, event["argv"]) rewards = result.apply(p) rsp = poem_pb.CityContendDropEventResponse() combine_reward(rewards, {}, p.city_contend_rewards) rsp.rewards = build_reward(p.city_contend_rewards) p.city_contend_step += 1 p.city_contend_total_step += 1 p.save() p.sync() return success_msg(msgtype, rsp)
def treasure_end(self, msgtype, body): p = self.player req = poem_pb.EndTreasure() req.ParseFromString(body) if not PlayerTreasureLock.unlock(p.entityID, req.verify_code): logger.debug("verify_code %s", req.verify_code) return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST) if not p.treasure_cache: logger.debug("not treasure_cache") return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST) rewards = [] for type, subtype, count in p.treasure_cache: if type == TreasureGrid.TreasureGridTypeReward: rewards.append(poem_pb.RewardData( type=subtype, count=count)) r1 = parse_reward(req.rewards) r2 = parse_reward(rewards) logger.debug("reward %r %r", r1, r2) if not compare_reward(r1, r2): logger.debug("compare reward fail") return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST) config = get_config(TreasureChestConfig)[p.treasure_type] gain_chest = bool(req.gain_chest) if gain_chest: reward = open_reward(RewardType.Treasure, config.drop) result = reward.apply_after() else: result = {} result = combine_reward(r1, result) rsp = poem_pb.EndTreasureResponse() finisheds = [] finisheds.append(gain_chest) finisheds.append(bool(req.kill_monster)) need = get_cons_value("TreasureNeedBuffCount") finisheds.append(len(req.rewards) >= need) rsp.stars = len(filter(lambda s: s, finisheds)) if rsp.stars == len(finisheds): rewardex = open_reward(RewardType.Treasure, config.dropex) rsp.rewardsex = build_reward(rewardex.apply(p)) rsp.finisheds = finisheds apply_reward(p, result, type=RewardType.Treasure) build_reward_msg(rsp, result) now = int(time.time()) p.treasure_used_count += 1 p.treasure_cd = now + 10 * 60 p.treasure_cache = [] refresh_treasure(p) on_treasure_count(p) p.save() p.sync() return success_msg(msgtype, rsp)
def cleanfbs(p, fbID, count, cost): assert count > 0 items = [] rewards = {} useless = poem_pb.EnterFbResponse() # cost_ = dict(cost) # cost.clear() for i in range(count): item = poem_pb.CleanFbRspStruct() set_fb_score(p, fbID, 3) item.curFbInfo = poem_pb.FbInfo(**get_fb_info(p, fbID)) reward = open_reward(RewardType.FB, p, fbID, False, useless) result = filter_cleanfb_reward(reward) item.rewards = build_reward(result) rewards = combine_reward(rewards, result) # combine_reward(cost_, [], cost) items.append(item) apply_reward(p, rewards, cost=cost, type=RewardType.CleanFB) p.save() p.sync() return items
def give_reward(self, season_key, player=None): logger.info('Give reward {}'.format(season_key)) hist = self.get_hist(season_key) if not hist: return ranks, configs = hist["ranks"], hist["configs"] if player: players = [player] else: players = g_entityManager.players.values() for p in players: rank = ranks.get(p.entityID) if not rank: continue title = "" content = "" rewards = {} for i in sorted(rank.get("rewards", []), reverse=True): title = configs[i]["title"] content = configs[i]["content"] rewards = combine_reward(rewards, configs[i]["rewards"]) if rewards: grad = rank.get("grad", 0) self.send_mail(p, title, content, rewards, grad, season_key)
def battle(self, p, targetID, fight, raw, rsp): target_win_count = 0 # 对手连胜次数 max_win_count = 0 history = None # 战斗记录 shutdown = False self_message = "" full_message = "" horn = False red_message = "" red_count = 0 self_shutdown_message = "" full_shutdown_message = "" peer_shutdown_message = "" count = 0 rsp.before_daily_win_count = p.daily_win_count if fight.fightResult: # 胜利 # 终结对手连胜 target_win_count = int(self.pool.execute( "GETSET", "daily_win_count_p{%d}" % targetID, 0) or 0) self.pool.execute("SET", "daily_dead_p{%d}" % targetID, 1) # 添加自己连胜 daily_win_count = int(self.pool.execute( "INCRBY", "daily_win_count_p{%d}" % p.entityID, 1) or 0) p.clear_daily_win_count() # 更新最大连胜次数 if p.daily_win_count > p.daily_max_win_count: p.daily_max_win_count = p.daily_win_count count = update_daily_rank( PlayerDailyRankRanking, p.entityID, p.daily_max_win_count) # PlayerDailyRankRanking.update_score( # p.entityID, p.daily_max_win_count) # 连胜任务 from task.manager import on_dailypvp_count on_dailypvp_count(p, p.daily_max_win_count) # 取全服最大次数 top = PlayerDailyRankRanking.get_range_by_score( "-inf", "+inf", withscores=True, count=1) if top: max_win_count = top[1] rsp.max_win_count = max_win_count daily_win_config = get_config(DailyWinConfig).get( p.daily_win_count) if not daily_win_config and \ p.daily_win_count > max(get_config(DailyWinConfig)): daily_win_config = get_config( DailyWinConfig)[max(get_config(DailyWinConfig))] if daily_win_config: if not daily_win_config.multiple or ( daily_win_config.multiple and count == 1): self_message = daily_win_config.single_desc full_message = daily_win_config.all_desc horn = daily_win_config.horn if daily_win_config.red_paper: red_message = daily_win_config.red_paper_desc red_count = daily_win_config.red_paper_count red_drop = daily_win_config.red_paper daily_lose_config = get_config(DailyLoseConfig).get( target_win_count) if not daily_lose_config and \ target_win_count > max(get_config(DailyLoseConfig)): daily_lose_config = get_config( DailyLoseConfig)[max(get_config(DailyLoseConfig))] if daily_lose_config: self_shutdown_message = daily_lose_config.single_win_desc peer_shutdown_message = daily_lose_config.single_lose_desc full_shutdown_message = daily_lose_config.all_desc # 增加胜利次数 p.daily_kill_count += 1 # 奖励加成系数 multi = min(40, 2 * daily_win_count) + min( 80, target_win_count * 4) shutdown = target_win_count > 2 history = { "active": False, "name": p.name, "win": not fight.fightResult, "faction_name": p.faction_name, "daily_win_count": p.daily_win_count, "fight": raw.encode("base64"), "prototypeID": p.prototypeID, "borderID": p.borderID, "shutdown": shutdown} for each in fight.player_team: pet = p.pets[each.entityID] if each.restHP == 0: pet.daily_dead = True else: pet.daily_restHP = each.restHP pet.save() pet.sync() else: if not p.daily_rank: PlayerDailyRankRanking.update_score( p.entityID, p.daily_max_win_count) # 自己连胜被终结 daily_win_count = int(self.pool.execute( "GETSET", "daily_win_count_p{%d}" % p.entityID, 0) or 0) # 死亡 self.pool.execute("SET", "daily_dead_p{%d}" % p.entityID, 1) p.clear_daily_win_count() # 奖励加成系数 multi = 0 daily_lose_config = get_config(DailyLoseConfig).get( daily_win_count) if not daily_lose_config and \ daily_win_count > max(get_config(DailyLoseConfig)): daily_lose_config = get_config( DailyLoseConfig)[max(get_config(DailyLoseConfig))] if daily_lose_config: self_shutdown_message = daily_lose_config.single_lose_desc peer_shutdown_message = daily_lose_config.single_win_desc full_shutdown_message = daily_lose_config.all_desc # 取对手数据 data = g_entityManager.get_players_info( [targetID], [ "entityID", "name", "daily_win_count", "faction_name", "prototypeID", "borderID"])[0] # 终结连胜 shutdown = target_win_count > 2 data.update({ "active": True, "shutdown": shutdown, "win": fight.fightResult, "fight": raw.encode("base64") }) # 自己的战斗记录 p.daily_histories.appendleft(data) p.daily_histories.ltrim(0, MAX_HIST_LEN - 1) # 更新排名 p.daily_rank = PlayerDailyRankRanking.get_rank(p.entityID) rewards = {} reward = open_reward( RewardType.DailyPVP, get_cons_value("DailyPVPDrop")) rewards = reward.apply_after() # 奖励加成 if multi: for k, v in rewards.items(): if isinstance(v, int) and k != 'exp': rewards[k] = int(v * (100 + multi) / float(100)) # 记录累计奖励 apply_reward(p, rewards, type=RewardType.DailyPVP) combine_reward(rewards, [], data=p.daily_rewards) p.daily_rewards = dict(p.daily_rewards) p.daily_count += 1 p.daily_cache_targetID = 0 p.save() p.sync() # 添加直播 self.add_live({ "self_name": p.name, "self_prototypeID": p.prototypeID, "self_borderID": p.borderID, "peer_name": data["name"], "peer_prototypeID": data["prototypeID"], "peer_borderID": data["borderID"], "is_win": fight.fightResult, }, top=p.daily_rank and p.daily_rank <= 5) rsp.daily_win_count = p.daily_win_count rsp.rewards = build_reward(rewards) if self_message: self_message = self_message.format(data["name"], p.daily_win_count) g_redManager.send_red_message( p, self_message, to_self=True, type=RedType.Normal) if full_message: full_message = full_message.format( p.name, data["name"], p.daily_win_count) _type = RedType.Horn if horn else RedType.Normal g_redManager.send_red_message( p, full_message, type=_type) if red_count and red_message: if daily_win_count == 1: red_message = red_message.format( p.name, red_count) else: red_message = red_message.format( p.name, daily_win_count, red_count) g_redManager.send_red_message( p, red_message, red_drop=red_drop, red_count=red_count, type=RedType.Red) if full_shutdown_message: if fight.fightResult: full_shutdown_message = full_shutdown_message.format( p.name, data["name"], target_win_count) else: full_shutdown_message = full_shutdown_message.format( data["name"], p.name, daily_win_count) _type = RedType.Horn if horn else RedType.Normal g_redManager.send_red_message( p, full_shutdown_message, type=_type) if fight.fightResult: if self_shutdown_message: self_shutdown_message = self_shutdown_message.format( data["name"], target_win_count) g_redManager.send_red_message( p.entityID, self_shutdown_message, to_self=True, type=RedType.Normal) if peer_shutdown_message: peer_shutdown_message = peer_shutdown_message.format( p.name, target_win_count) g_redManager.send_red_message( data["entityID"], peer_shutdown_message, to_self=True, type=RedType.Normal) else: if self_shutdown_message: self_shutdown_message = self_shutdown_message.format( data["name"], daily_win_count) g_redManager.send_red_message( p.entityID, self_shutdown_message, to_self=True, type=RedType.Normal) if peer_shutdown_message: peer_shutdown_message = peer_shutdown_message.format( p.name, daily_win_count) g_redManager.send_red_message( data["entityID"], peer_shutdown_message, to_self=True, type=RedType.Normal) proxy.sync_daily_rank(targetID, history) return rewards
def battle(self, p, fight, rsp): treasures = get_config(CityTreasureConfig) self_message = "" full_message = "" red_message = "" red_count = 0 horn = False target = p.city_contend_cache_target if self.is_top_faction(p.factionID): message_configs = get_config(CityContendDefendMessageConfig) message_config = message_configs.get(p.city_contend_count) if not message_config: message_config = message_configs[max(message_configs)] if fight.fightResult: event = self.get_current_step(p) drop = event["argv"] reward = open_reward(RewardType.CityContendDefend, drop) rewards = reward.apply(p) combine_reward(rewards, {}, p.city_contend_rewards) try: target_name = target.get("name", u"").decode("utf-8") target_faction_name = (target.get( "faction_name", u"") or u"").decode("utf-8") except UnicodeEncodeError: target_name = target.get("name", u"") target_faction_name = target.get("faction_name", u"") self_message = message_config.single_defend_win_desc.format( target_faction_name, target_name ) # {{ 使用每日PVP for each in fight.player_team: pet = p.pets[each.entityID] if each.restHP == 0: pet.daily_dead = True else: pet.daily_restHP = each.restHP pet.save() pet.sync() # }} rsp.rewards = build_reward(rewards) else: sub = p.city_contend_treasure * get_cons_value( "CityContendFailPunish") / float(100) p.city_contend_treasure = max( p.city_contend_treasure - sub, 1) # {{ 每日PVP now = int(time.time()) p.daily_dead_cd = now + get_cons_value("DailyDeadCD") # }} try: target_name = target.get("name", u"").decode("utf-8") target_faction_name = (target.get( "faction_name", u"") or u"").decode("utf-8") except UnicodeEncodeError: target_name = target.get("name", u"") target_faction_name = target.get("faction_name", u"") self_message = message_config.single_defend_lose_desc.format( target_faction_name, target_name ) module = RedModuleType.CityContendDefend else: message_configs = get_config(CityContendAttackMessageConfig) message_config = message_configs.get(p.city_contend_count + 1) if not message_config: message_config = message_configs[max(message_configs)] if fight.fightResult: p.city_contend_count += 1 self_count = CityContendAttackRanking.update_score( p.entityID, p.city_contend_count) count = CityContendAttackRanking.pool.execute( "ZCOUNT", CityContendAttackRanking.key, self_count, "+inf") CityContendFactionRanking.incr_score( p.factionID, 1) treasure = treasures.get( p.city_contend_cache_target.get("level", 1)) if not treasure: treasure = treasures[max(treasures)] money = treasure.attack_treasure * get_cons_value( "CityContendAttackMoney") soul = treasure.attack_treasure * get_cons_value( "CityContendAttackSoul") event = self.get_current_step(p) drop = event["argv"] gain = {"money": money, "soul": soul} reward = open_reward( RewardType.CityContendAttack, drop ) drop_reward = reward.apply_after() total_reward = apply_reward( p, combine_reward(gain, drop_reward), type=RewardType.CityContendAttack) combine_reward(total_reward, {}, p.city_contend_rewards) p.city_contend_total_treasure += treasure.attack_treasure rsp.rewards = build_reward(drop_reward) rsp.treasure_rewards = build_reward(gain) rsp.treasure_count = treasure.attack_treasure if not message_config.multiple1 or message_config.multiple1 \ and count == 1: full_message = message_config.attack_count_desc.format( p.faction_name, p.name, p.city_contend_count ) horn = message_config.horn1 try: target_name = target.get("name", u"").decode("utf-8") except UnicodeEncodeError: target_name = target.get("name", u"") self_message = message_config.single_attack_win_desc.format( target_name ) if not message_config.multiple2 or message_config.multiple2 \ and count == 1: red_count = message_config.red_paper_count red_drop = message_config.red_paper red_message = message_config.red_paper_desc.format( p.faction_name, p.name, p.city_contend_count, red_count ) # {{ 使用每日PVP for each in fight.player_team: pet = p.pets[each.entityID] if each.restHP == 0: pet.daily_dead = True else: pet.daily_restHP = each.restHP pet.save() pet.sync() # }} else: # {{ 每日PVP now = int(time.time()) p.daily_dead_cd = now + get_cons_value("DailyDeadCD") # }} # FIXME try: target_name = target.get("name", u"").decode("utf-8") except UnicodeEncodeError: target_name = target.get("name", u"") self_message = message_config.single_attack_lose_desc.format( target_name ) module = RedModuleType.CityContendAttack if self_message: g_redManager.send_red_message( p, self_message, to_self=True, module=module) if full_message: _type = RedType.Horn if horn else RedType.Normal g_redManager.send_red_message( p, full_message, type=_type, module=module) if red_message and red_count: g_redManager.send_red_message( p, red_message, red_drop=red_drop, red_count=red_count, type=RedType.Red, module=module) p.save() p.sync()
def battle(self, p, fight, rsp): mg = p.city_dungeon_mg_cache message_configs = get_config(CityDungeonMessageConfig) self_message = "" message_config = message_configs.get(mg["id"]) if not message_config: message_config = message_configs[max(message_configs)] if fight.fightResult: kills = len(mg.get("monsters", [])) config = self.get_mg_config_by_id(mg["id"]) rewards = parse_reward(config.rewards) self_message = message_config.single_win_desc.format(mg["id"]) # 玩家损血 # {{ 使用每日PVP for each in fight.player_team: pet = p.pets[each.entityID] if each.restHP == 0: pet.daily_dead = True else: pet.daily_restHP = each.restHP pet.save() pet.sync() # }} else: kills = 0 pending = [] for enemy in fight.enemy_team: for m in mg["monsters"]: if m["pos"] == enemy.posIndex: if not enemy.restHP: pending.append(m) kills += 1 else: m["restHP"] = enemy.restHP for m in pending: mg["monsters"].remove(m) self.add_mg_into_pool(p, mg) now = int(time.time()) # {{ 使用每日PVP p.daily_dead_cd = now + get_cons_value("DailyDeadCD") # }} rewards = {} self_message = message_config.single_lose_desc.format(mg["id"]) if fight.total_damage: CityDungeonSelfRanking.incr_score( p.entityID, fight.total_damage) if kills: self.incr_mg_kill(p, mg["id"], kills) if fight.fightResult: self.sync_city_dungeon_current_info(p) if rewards: rewards = combine_reward( rewards, config.must_rewards) rewards = apply_reward( p, rewards, type=RewardType.CityDungeon) build_reward_msg(rsp, rewards) combine_reward(rewards, {}, p.city_dungeon_rewards) if self_message: g_redManager.send_red_message( p, self_message, to_self=True, module=RedModuleType.CityDungeon) p.city_dungeon_mg_cache.clear() p.save() p.sync()
def refining(self, msgtype, body): from lineup.manager import in_lineup from config.configs import get_config from config.configs import RefineryConfig req = poem_pb.RefiningRequest() req.ParseFromString(body) player = self.player from entity.manager import save_guide save_guide(player, req.guide_type) # 保存新手引导进度 # 统计材料的种类和数量 total_mat = 0 mats = {} for matInfo in req.materials: total_mat += 1 if matInfo.id in mats: mats[matInfo.id] += matInfo.count else: mats[matInfo.id] = matInfo.count if len(req.pet_ids) + len(req.equip_ids) + total_mat > 6: return fail_msg(msgtype, reason='总共可以炼化6个精灵和装备') if len(req.pet_ids) != len(set(req.pet_ids)): return fail_msg(msgtype, reason='重复的精灵实体ID') if len(req.equip_ids) != len(set(req.equip_ids)): return fail_msg(msgtype, reason='重复的装备实体ID') refining_pet = [] configs = get_config(RefineryConfig) rewards = {} for petID in req.pet_ids: pet = player.pets.get(petID) if not pet: return fail_msg(msgtype, reason='找不到精灵炼化') if in_lineup(player, pet.entityID) and \ not in_lineup(player, pet.entityID, type=LineupType.ATK): return fail_msg(msgtype, reason='阵上将不可作为材料') petInfo = get_config(PetConfig)[pet.prototypeID] if not petInfo: return fail_msg(msgtype, msgTips.FAIL_MSG_PET_NOTCONFIG) refinery = configs.get(petInfo.cls) if not refinery: return fail_msg(msgtype, msgTips.FAIL_MSG_PET_NOTCONFIG) addition_rewards = {} # 升级消耗 level_configs = get_config(PetLevelOrSkillLevelUpConfig) level_configs = [level_configs[i] for i in filter( lambda s: s < pet.level, level_configs)] for each in level_configs: combine_reward( [each.units_cost1, each.units_cost2], {}, data=addition_rewards) # 技能消耗 level_configs = get_config(PetLevelOrSkillLevelUpConfig) for l in [1, 2, 3, 4, 5]: slevel = getattr(pet, "skill%d" % l, 1) skilllevel_configs = [ level_configs[i] for i in filter( lambda s: s < slevel, level_configs)] for each in skilllevel_configs: combine_reward( [getattr(each, "skill%d_cost" % l, {})], {}, data=addition_rewards) # 升阶消耗 step = petInfo.rarity * 10 + petInfo.step grow_configs = get_config(GrowthConfig) grow_configs = [grow_configs[i] for i in filter( lambda s: s < step, grow_configs)] for each in grow_configs: combine_reward( {"money": int(each.evo_cost * petInfo.cexp)}, {}, data=addition_rewards) # 升星消耗 break_configs = get_config(BreakConfig) break_configs = [break_configs[i] for i in filter( lambda s: s < pet.breaklevel, break_configs)] for each in break_configs: combine_reward( {"money": each.money}, {}, data=addition_rewards) for k, v in addition_rewards.items(): if isinstance(v, int): addition_rewards[k] = int(v * refinery.scale) for i in range(pet.star // petInfo.need_patch): combine_reward(refinery.rewards, {}, data=rewards) combine_reward(addition_rewards, {}, data=rewards) refining_pet.append(pet) # 神将身上的装备 equips = [] for pet in refining_pet: for e in pet.equipeds.values(): equips.append(player.equips[e]) from config.configs import EquRefineConfig equ_refine_config = get_config(EquRefineConfig) # 单个分解的装备 for equID in req.equip_ids: equ = player.equips[equID] if not equ: return fail_msg(msgtype, reason='找不到装备炼化') equips.append(equ) _equ_refine_config = equ_refine_config.get(equ.prototypeID) if not _equ_refine_config: return fail_msg(msgtype, msgTips.FAIL_MSG_PET_NOTCONFIG) combine_reward(_equ_refine_config.equ_rewards, {}, data=rewards) # 单个分解的材料 matList = [] for matID, count in mats.iteritems(): mat1 = player.mats.get(matID, 0) if mat1 < count: return fail_msg(msgtype, reason='材料数量不足炼化') matList.append([matID, count]) mat_refine_config = equ_refine_config.get(matID) if not mat_refine_config: return fail_msg(msgtype, msgTips.FAIL_MSG_PET_NOTCONFIG) for i in range(0, count): combine_reward(mat_refine_config.mat_rewards, {}, data=rewards) l = list(player.lineups.get(LineupType.ATK, [0, 0, 0, 0])) # 攻击阵型可以被炼化 flag = False for each in refining_pet: if in_lineup(player, each.entityID, type=LineupType.ATK): flag = True l[l.index(each.entityID)] = 0 if flag: save_lineup(player, l, LineupType.ATK) player.del_pets(*refining_pet) player.del_equips(*equips) apply_reward(player, rewards, cost={"matList": matList}, type=RewardType.REFINING) player.save() player.sync() rsp = poem_pb.RefiningResponse() build_reward_msg(rsp, rewards) logger.debug(rsp) return success_msg(msgtype, rsp)
def mall_info(self, msgtype, body): p = self.player req = poem_pb.MallInfoRequest() req.ParseFromString(body) logger.debug(req) type = req.type if not check_open(p, type): # 限制 return fail_msg(msgtype, reason="商店未开启") refresh_info = get_config(MallRefreshConfig)[type] times = p.mall_refresh_times.get(type, 0) now = int(time.time()) need_refresh = not p.malls.get(type) if req.refresh: cost_amount = refresh_info.cost try: if p.shopping > 0: cost = {"shopping": 1} else: cost = parse_reward([{ 'type': refresh_info.refresh_cost_type, 'count': cost_amount, }]) apply_reward( p, {}, cost, type=RewardType.RefreshMall) except AttrNotEnoughError: return fail_msg(msgtype, reason="消耗不足") need_refresh = True # 增加刷新次数 times += 1 p.mall_refresh_times[type] = times from task.manager import on_refresh_shop on_refresh_shop(p) # 刷新商店的时候 from campaign.manager import g_campaignManager if g_campaignManager.exchange_campaign.is_open(): start_time, end_time = g_campaignManager.exchange_campaign.get_current_time() if p.exchange_campaign_last_time < start_time or p.exchange_campaign_last_time > end_time: p.exchange_campaign_counter = 0 p.exchange_campaign_counter = p.exchange_campaign_counter + 1 p.exchange_campaign_last_time = now current = g_campaignManager.exchange_campaign.get_current() from config.configs import ExchangeCampaignByGroupConfig group = get_config(ExchangeCampaignByGroupConfig).get(current.group) ex_rsp = poem_pb.ExchangeCampaignItemResponse() rewards = {} for i in range(0, len(group.consumes)): tmp_count = group.refresh_counts[i] if not tmp_count or tmp_count <= 0: continue if p.exchange_campaign_counter % tmp_count == 0: tmp_config = group.consumes[i] print tmp_config r = parse_reward([{ "arg": tmp_config["arg"], "type": tmp_config["type"], "count": 1, }]) combine_reward(r, {}, rewards) info = {} info["arg"] = tmp_config["arg"] info["type"] = tmp_config["type"] info["count"] = 1 ex_rsp.items.add(**info) if len(rewards) > 0: apply_reward(p, rewards, type=RewardType.RefreshMall) from player.manager import g_playerManager ex_msg = success_msg(msgid.EXCHANGE_CAMPAIGN_ITEM_RESULT, ex_rsp) g_playerManager.sendto(p.entityID, ex_msg) if g_campaignManager.refresh_store_campaign.is_open(): start_time, end_time = g_campaignManager.refresh_store_campaign.get_current_time() if p.refresh_store_campaign_last_time < start_time or p.refresh_store_campaign_last_time > end_time: p.refresh_store_campaign_counter = 0 p.refresh_store_campaign_counter = p.refresh_store_campaign_counter + 1 p.refresh_store_campaign_last_time = now from config.configs import RefreshStoreConfig packs = get_config(RefreshStoreConfig) exempts = set(p.refresh_reward_end).union(p.refresh_reward_done) samples = sorted(set(packs).difference(exempts)) for i in samples: pack = packs[i] if p.refresh_store_campaign_counter >= pack.count: p.refresh_reward_done.add(i) else: break p.clear_refresh_reward_done_count() next = None dt = datetime.fromtimestamp(now) # NOTE 跨天问题 last_ts = p.mall_last_refresh.get(type, 0) if not last_ts: need_refresh = True last_ts = now last = datetime.fromtimestamp(last_ts) logger.debug("上次刷新时间 %s", last) flag = False for date, daytimes in ( [last.date(), refresh_info.daytimes], # 跨天不刷新 [last.date() + timedelta(days=1), refresh_info.daytimes], [dt.date(), refresh_info.daytimes], [dt.date() + timedelta(days=1), refresh_info.daytimes]): for each in daytimes: refresh_dt = datetime.combine(date, timetime(each)) if not flag and dt < refresh_dt: next = refresh_dt flag = True if last < refresh_dt and refresh_dt <= dt: need_refresh = True # 临时商店不自动刷新 if type == MallType.Golden: if now < p.mall_golden_open_remain: need_refresh = False or req.refresh elif type == MallType.Silver: if now < p.mall_silver_open_remain: need_refresh = False or req.refresh if need_refresh or not p.malls.get(type): refresh_mall(p, type) p.mall_last_refresh[type] = now mall = p.malls.get(type, []) configs = get_config(MallConfig) default_locked = (type == MallType.Faction) if default_locked: if p.factionID: mall_products = Faction.simple_load( p.factionID, ['mall_products']).mall_products else: mall_products = set() unlock_costs = {type: {k: v.cost for k, v in get_config( FactionMallUnlockConfig).items()}} rsp = poem_pb.MallInfoResponse() for productID in mall: config = configs[productID] count = p.mall_limits.get(productID, 0) last = p.mall_times.get(productID, 0) remain = 0 if last and config.cd: remain = max(config.cd - (now - last), 0) product = config._asdict() locked = default_locked and (config.pos not in mall_products) rsp.products.add( unlock_cost=unlock_costs.get(type, {}).get(config.pos, 0), count=count, remain=remain, locked=locked, **product) if next: rsp.time = next.hour rsp.cd = int(time.mktime(next.timetuple()) - now) else: # 不自动刷新 rsp.time = 25 logger.debug("下次刷新时间 %s", next) rsp.cost = refresh_info.cost rsp.cost_type = refresh_info.refresh_cost_type p.save() p.sync() return success_msg(msgtype, rsp)
def mall_buy_product(self, msgtype, body): p = self.player req = poem_pb.MallBuyProduct() req.ParseFromString(body) logger.debug(req) config = get_config(MallConfig)[req.ID] if not check_open(p, config.type): return fail_msg(msgtype, reason="商店未开启") # 限制 count = p.mall_limits.get(req.ID, 0) if config.limit > 0 and count >= config.limit: return fail_msg(msgtype, reason="超过购买次数") now = int(time.time()) last = p.mall_times.get(req.ID, 0) if last and now < last + config.cd: return fail_msg(msgtype, reason="购买冷却中") reward = parse_reward([{ 'type': config.product_type, 'arg': config.productID, 'count': config.product_amount}]) cost = parse_reward([{ 'type': config.item_type, 'count': config.price, }]) try: apply_reward( p, reward, cost, type=RewardType.MallBuy) except AttrNotEnoughError: return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST) from campaign.manager import g_campaignManager if g_campaignManager.exchange_campaign.is_open(): start_time, end_time = g_campaignManager.exchange_campaign.get_current_time() if p.exchange_campaign_last_time < start_time or p.exchange_campaign_last_time > end_time: p.exchange_campaign_counter = 0 p.exchange_campaign_counter = p.exchange_campaign_counter + 1 p.exchange_campaign_last_time = now current = g_campaignManager.exchange_campaign.get_current() from config.configs import ExchangeCampaignByGroupConfig group = get_config(ExchangeCampaignByGroupConfig).get(current.group) ex_rsp = poem_pb.ExchangeCampaignItemResponse() rewards = {} for i in range(0, len(group.consumes)): tmp_count = group.refresh_counts[i] if not tmp_count or tmp_count <= 0: continue if p.exchange_campaign_counter % tmp_count == 0: tmp_config = group.consumes[i] print tmp_config r = parse_reward([{ "arg": tmp_config["arg"], "type": tmp_config["type"], "count": 1, }]) combine_reward(r, {}, rewards) info = {} info["arg"] = tmp_config["arg"] info["type"] = tmp_config["type"] info["count"] = 1 ex_rsp.items.add(**info) if len(rewards) > 0: apply_reward(p, rewards, type=RewardType.RefreshMall) from player.manager import g_playerManager ex_msg = success_msg(msgid.EXCHANGE_CAMPAIGN_ITEM_RESULT, ex_rsp) g_playerManager.sendto(p.entityID, ex_msg) #if g_campaignManager.refresh_store_campaign.is_open(): # start_time, end_time = g_campaignManager.refresh_store_campaign.get_current_time() # if p.refresh_store_campaign_last_time < start_time or p.refresh_store_campaign_last_time > end_time: # p.refresh_store_campaign_counter = 0 # p.refresh_store_campaign_counter = p.refresh_store_campaign_counter + 1 # p.refresh_store_campaign_last_time = now # from config.configs import RefreshStoreConfig # packs = get_config(RefreshStoreConfig) # exempts = set(p.refresh_reward_end).union(p.refresh_reward_done) # samples = sorted(set(packs).difference(exempts)) # for i in samples: # pack = packs[i] # if p.refresh_store_campaign_counter >= pack.count: # p.refresh_reward_done.add(i) # else: # break # p.clear_refresh_reward_done_count() p.mall_limits[req.ID] = count + 1 p.mall_times[req.ID] = now from task.manager import on_shopping on_shopping(p) p.save() p.sync() return success_msg(msgtype, '')