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 flowerboss_friendfb_reborn(self, msgtype, body): req = poem_pb.RebornFriendfb() req.ParseFromString(body) p = self.player try: hp, fbID = simple_load_friendfb(req.friendfbID, 'hp', 'fbID') except DoesNotExistsException: return fail_msg(msgtype, msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED) if hp <= 0: return fail_msg(msgtype, reason='BOSS已经被击杀了') if not player_is_dead(p, req.friendfbID): return fail_msg(msgtype, reason="无须复活") count = p.friendfb_reborn_counts[req.friendfbID] =\ p.friendfb_reborn_counts.get(req.friendfbID, 0) + 1 cost = get_cons_value("FlowerBossRebornCost") * count try: apply_reward(p, {}, cost={"gold": cost}, type=RewardType.FriendfbReborn) except AttrNotEnoughError: return fail_msg(msgtype, reason="钻石不足") p.friendfb_deads.remove(req.friendfbID) if fbID in p.friendfb_deadtimes: del p.friendfb_deadtimes[fbID] p.friendfb_buff = get_cons_value("GveBuffAddition") p.save() p.sync() return success_msg(msgtype, "")
def gve_reborn(self, msgtype, body): p = self.player if not gve_is_open(p): return fail_msg(msgtype, msgTips.FAIL_MSG_GROUP_GVE_NOT_OPEN) if gve_is_end(p): return fail_msg(msgtype, msgTips.FAIL_MSG_GROUP_GVE_ALREADY_END) end_time = g_campaignManager.gve_campaign.get_end_time() if p.gve_state != GveEntity.GveEntityStateDead: return fail_msg(msgtype, reason="没有死亡") if p.gve_reborn_rest_count <= 0: return fail_msg(msgtype, reason="没有复活次数了") try: apply_reward( p, {}, cost={"gold": get_cons_value("GveRebornCost")}, type=RewardType.GveReborn) except AttrNotEnoughError: return fail_msg(msgtype, reason="钻石不足") count = int(Group.pool.execute( "SREM", "gve_deads_g{%s}" % p.groupID, p.entityID)) g = Group.simple_load( p.groupID, ["gve_end_cd", "gve_activateds"]) g.gve_activateds.load() if count < len(g.gve_activateds): g.gve_end_cd = end_time g.save() p.gve_state = GveEntity.GveEntityStateNormal p.gve_buff = get_cons_value("GveBuffAddition") p.gve_reborn_rest_count -= 1 sync_gve_entity(g.gve_activateds, p.entityID) p.save() p.sync() return success_msg(msgtype, "")
def enchant(self, msgtype, body): p = self.player req = EnchantEquip() req.ParseFromString(body) need = pow(2, len(req.locks)) enchant_free_used_count = 0 if req.ex: need *= get_cons_value("EnchantExCostBase") else: if p.enchant_free_rest_count: need = 0 enchant_free_used_count = 1 else: need *= get_cons_value("EnchantCostBase") if need: if p.stone < need: gold = (need - p.stone) * get_cons_value("EnchantStoneToGold") cost = {"stone": p.stone, "gold": gold} else: cost = {"stone": need} try: apply_reward(p, {}, cost=cost, type=RewardType.EnchantEquip) except (AttrNotEnoughError, MatNotEnoughError): return fail_msg(msgtype, reason="消耗不足") enchant_equip(p, req.equipID, locks=req.locks, ex=req.ex) p.enchant_free_used_count += enchant_free_used_count p.save() p.sync() return success_msg(msgtype, "")
def treasure_enter(self, msgtype, body): p = self.player if not p.treasure_count: return fail_msg(msgtype, reason="not enough challenge times") now = int(time.time()) if p.treasure_cd > now: return fail_msg(msgtype, reason="CD冷却中") rsp = enter_treasure(p) rsp.verify_code = PlayerTreasureLock.lock(p.entityID, force=True) rsp.need_count = get_cons_value("TreasureNeedBuffCount") rsp.round_count = get_cons_value("TreasureRoundCount") logger.debug(rsp) p.save() p.sync() return success_msg(msgtype, rsp)
def __init__(self): self.campaigns = {} self.deadline = 0 self.reserved = 0 configs = get_config(RankingCampaignConfig) for day, config in configs.items(): campaign = self.campaigns[config.ranking] = RankingCampaign(config) campaign.start() deadline = config.final + get_cons_value( "RankingCampaignDeadlineTime") reserved = config.start + get_cons_value( "RankingCampaignReservedTime") if deadline > self.deadline: self.deadline = deadline if not reserved or reserved < self.reserved: self.reserved = reserved
def trigger_chests_recv(self, msgtype, body): p = self.player if not check_trigger_event_type(p, EventType.Chests): return fail_msg(msgtype, reason="无触发事件或错误的事件类型") config = get_config(TriggerEventConfig)[p.trigger_event] chest = get_config(TriggerChestsConfig).get(config.event_param) if len(p.trigger_chests) > 0: cost = {"gold": get_cons_value("TriggerChestsMoreCost")} else: cost = {} rests = set(range(len(chest.rewards))) - p.trigger_chests if not rests: return fail_msg(msgtype, reason="已经没有宝箱了") index = choice_one(list(rests)) is_best = False if index == 0: p.trigger_event = 0 is_best = True gain = parse_reward([chest.rewards[index]]) try: apply_reward(p, gain, cost=cost, type=RewardType.TriggerChests) except AttrNotEnoughError: return fail_msg(msgtype, reason="钻石不足") p.trigger_chests.add(index) p.save() p.sync() rsp = poem_pb.TriggerChestsRecv(is_best=is_best) build_reward_msg(rsp, gain) return success_msg(msgtype, rsp)
def mall_open(self, msgtype, body): p = self.player req = poem_pb.MallOpen() req.ParseFromString(body) logger.debug(req) cost = 0 if req.type == MallType.Golden: if p.mall_golden_open_cost: cost = p.mall_golden_open_cost f = 'mall_golden_opened' n = 'OpenGoldenMallCost' elif req.type == MallType.Silver: if p.mall_silver_open_cost: cost = p.mall_silver_open_cost f = 'mall_silver_opened' n = 'OpenSilverMallCost' if not cost: return fail_msg(msgtype, reason="不满足开启条件") try: apply_reward( p, {}, {'gold': get_cons_value(n)}, type=RewardType.MallOpen) except AttrNotEnoughError: return fail_msg(msgtype, reason="钻石不足") setattr(p, f, True) refresh_mall(p, req.type) p.save() p.sync() return success_msg(msgtype, '')
def reborn(self, msgtype, body): p = self.player cost = get_cons_value("DailyRebornCost") # if not g_campaignManager.dailypvp_campaign.is_open(): # return fail_msg(msgtype, msgTips.FAIL_MSG_DAILY_CAMPAIGN_CLOSED) try: apply_reward( p, {}, cost={"gold": cost}, type=RewardType.DailyPVPReborn) except AttrNotEnoughError: return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST) changeds = set() lineups = [ p.lineups.get(LineupType.Daily, []), p.lineups.get(LineupType.City, []), ] for lineup in lineups: for each in lineup: pet = p.pets.get(each) if pet: pet.daily_dead = False pet.daily_restHP = 0 changeds.add(pet) for pet in changeds: pet.save() pet.sync() p.daily_dead_cd = 0 p.save() p.sync() return success_msg(msgtype, "")
def friend_friendfb_detail(self, msgtype, body): p = self.player req = poem_pb.FriendfbDetailRequest() req.ParseFromString(body) rsp = poem_pb.FriendfbDetail() friendfb = load_friendfb(req.friendfbID) logger.debug("detail %r", friendfb) if not friendfb: return fail_msg(msgtype, msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED) config = get_config(FriendfbConfig)[friendfb['fbID']] friendfb.update(**config._asdict()) if p.entityID in friendfb['activists']: friendfb['done'] = True rsp.friendfb = poem_pb.Friendfb(**friendfb) rsp.rewards = config.rewards # # 排行榜 # ranks = load_ranks(req.friendfbID) # for rank in ranks: # rsp.ranks.add(**rank) rsp.is_dead = player_is_dead(p, req.friendfbID) rsp.reborn_cost = (p.friendfb_reborn_counts.get(req.friendfbID, 0) + 1) * get_cons_value("FriendfbRebornCost") logger.debug(rsp) return success_msg(msgtype, rsp)
def ambition_up(self, msgtype, body): p = self.player req = poem_pb.AmbitionUpRequest() req.ParseFromString(body) if not req.type: configs = get_config(AmbitionConfig) level = p.level ambition = str(p.ambition) or '' attr = "ambition" else: configs = get_config(VipAmbitionConfig) level = p.vip ambition = str(p.vip_ambition) or '' attr = "vip_ambition" index = req.index or 0 config = configs.get(index + 1) if not config: return fail_msg(msgtype, reason="没有下一个了") if level < config.level: return fail_msg(msgtype, reason="等级不足") random_configs = get_config(RandomAmbitionConfig) if req.use_gold: c = weighted_random2([[ i.step, i.golden_pro] for i in random_configs.values()]) cost = {"gold": get_cons_value("AmbitionGoldUpCost")} else: c = weighted_random2([[ i.step, i.pro] for i in random_configs.values()]) cost = {"soul": get_cons_value("AmbitionUpCost")} if c not in random_configs: return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST) try: ll = list(ambition) ll[index] = str(c) ambition = ''.join(ll) except IndexError: return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST) apply_reward(p, {}, cost, type=RewardType.AmbitionUp) setattr(p, attr, ambition) if c >= 5: p.ambition_count += 1 from task.manager import on_ambition on_ambition(p) p.save() p.sync() return success_msg(msgtype, "")
def trigger_chest_info(self, msgtype, body): p = self.player if not check_trigger_event_type(p, EventType.Chest): return fail_msg(msgtype, reason="无触发事件或错误的事件类型") # config = get_config(TriggerEventConfig)[p.trigger_event] rsp = poem_pb.TriggerChestInfo( double_cost=get_cons_value("TriggerChestDoubleCost")) return success_msg(msgtype, rsp)
def get_helper_cd(p, entityID, now=None): if not now: now = int(time.time()) dlc_cd = 0 last = p.dlc_helpers.get(entityID, 0) if last: dlc_cd = max( get_cons_value("DlcHelperCD") - (now - last), 0) return dlc_cd
def get_hurts(monster): prob = get_cons_value("TapCritProb") / float(100) hurts = [] while sum(hurts) < monster.hp: if guess(prob): hurts.append(HURT_CRIT) else: hurts.append(HURT_NORM) return hurts
def treasure_refresh(self, msgtype, body): p = self.player try: apply_reward( p, {}, cost={'gold': get_cons_value("TreasureRefreshGold")}, type=RewardType.TreasureRefresh) except AttrNotEnoughError: return fail_msg(msgtype, reason="钻石不足") refresh_treasure(p) return success_msg(msgtype, "")
def trigger_chests_info(self, msgtype, body): p = self.player if not check_trigger_event_type(p, EventType.Chests): return fail_msg(msgtype, reason="无触发事件或错误的事件类型") config = get_config(TriggerEventConfig)[p.trigger_event] chest = get_config(TriggerChestsConfig).get(config.event_param) reward = chest.rewards[0] # 默认第一个是最好的 rsp = poem_pb.TriggerChestsInfo( more_cost=get_cons_value("TriggerChestsMoreCost")) build_reward_msg(rsp, parse_reward([reward])) return success_msg(msgtype, rsp)
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 treasure_clean_cd(self, msgtype, body): p = self.player try: apply_reward( p, {}, cost={'gold': get_cons_value("TreasureCleanCDGold")}, type=RewardType.TreasureCleanCD) except AttrNotEnoughError: return fail_msg(msgtype, reason="钻石不足") p.treasure_cd = 0 p.save() p.sync() return success_msg(msgtype, '')
def recv_red(self, red): # -1 被领取完了, 0 超时, 1成功 rest = index_pool.execute("HINCRBY", red, "count", -1) if rest < 0: index_pool.execute("HINCRBY", red, "count", 1) return -1 t = index_pool.execute("HGET", red, "time") if time.time() > int(t): index_pool.execute("HINCRBY", red, "count", 1) return 0 return int( index_pool.execute("HGET", red, "drop") or get_cons_value("DailyRed"))
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 create_player(player): config = get_config(CreatePlayerConfig)[player.sex, player.career] player.mats[config.prototypeID] = 1 player.prototypeID = config.prototypeID player.mats[config.borderID] = 1 player.borderID = config.borderID player.money = config.money player.gold = config.gold player.level = config.level player.createtime = datetime.now() player.last_check_mail_time = time.mktime(player.createtime.timetuple()) player.sp = config.sp player.spmax = player.sp player.petmax = config.petmax player.new_role = True player.add_pets(*[{"prototypeID": p} for p in config.petIDs]) player.skillpoint = player.skillpoint_max player.maze_rest_count = player.maze_most_count player.lottery_gold_accumulating = config.accumulating # # 新号过滤已过期签到天数 # player.check_in_over_count = max(player.createtime.day - 1, 0) # player.check_in_used_count = player.check_in_over_count from task.manager import trigger_seven_task trigger_seven_task(player) init_lineups(player) if config.drop: from reward.manager import open_reward, RewardType reward = open_reward(RewardType.CreatePlayer, config.drop) reward.apply(player) # wish if get_cons_value("WishNewPlayerExperienceFlag"): player.wish_experience_time = time.mktime( player.createtime.timetuple()) + get_cons_value( "WishNewPlayerExperienceTime") player.save() return player
def get_panel(self, p, rsp): lives = self.get_lives(count=10) rsp.lives = lives rankers = self.get_rankers(count=10) rsp.ranks = rankers rsp.rewards = build_reward(p.daily_rewards) rsp.reds = g_redManager.get_red_messages() # 检查战斗期间内是否被已死亡 rsp.registers = PlayerDailyRankRanking.count() p.clear_daily_dead() if p.daily_dead and p.daily_count: now = int(time.time()) p.daily_dead_cd = now + get_cons_value("DailyDeadCD") self.pool.execute("DEL", "daily_dead_p{%d}" % p.entityID) p.clear_daily_dead() p.save() p.sync() return rsp
def faction_alter_name(self, msgtype, body): p = self.player factionID = self.player.factionID if not factionID: return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_HAS_NOT_FACTION) faction = Faction.simple_load(factionID, ['leaderID', 'name']) if self.player.entityID != faction.leaderID: return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_PERMISSION_DENIED) req = poem_pb.AlterNameFaction() req.ParseFromString(body) cost = get_cons_value("FactionAlterNameGold") if p.gold < cost: return fail_msg(msgtype, reason="钻石不足") name, err = validate_name(req.name) if err: return fail_msg(msgtype, err) try: FactionnameIndexing.register(factionID, req.name) except DuplicateIndexException: return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_DUPLICATE_FACTION_NAME) FactionnameIndexing.unregister(faction.name) apply_reward(p, {}, cost={"gold": cost}, type=RewardType.FactionAlterName) faction.name = req.name p.save() p.sync() faction.save() notify_change(factionID) gm_logger.info({ 'faction': { 'entityID': p.entityID, 'type': 'altername_faction', 'factionName': faction.name, 'factionID': faction.factionID, } }) return success_msg(msgtype, '')
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 on_recharge(p, gold): """累计充值""" flag = False configs = get_config(AccRechargeConfig) now = datetime.now() now_ts = time.mktime(now.timetuple()) if g_campaignManager.daily_acc_recharge_campaign.is_open(): origin = p.daily_acc_recharge_amount p.daily_acc_recharge_amount += gold current = p.daily_acc_recharge_amount reward_configs = g_campaignManager.\ daily_acc_recharge_campaign.get_reward_configs() for each in reward_configs: config = configs[each.ID] if origin < config.gold and current >= config.gold: p.daily_acc_recharge_rewards.add(each.ID) flag = True if g_campaignManager.cycle_acc_recharge_campaign.is_open(): origin = p.cycle_acc_recharge_amount p.cycle_acc_recharge_amount += gold current = p.cycle_acc_recharge_amount reward_configs = g_campaignManager.\ cycle_acc_recharge_campaign.get_reward_configs() for each in reward_configs: config = configs[each.ID] if origin < config.gold and current >= config.gold: p.cycle_acc_recharge_rewards.add(each.ID) p.cycle_acc_recharge_last_clean_time = now_ts flag = True if g_campaignManager.weeks_acc_recharge_campaign.is_open(): origin = p.weeks_acc_recharge_amount p.weeks_acc_recharge_amount += gold current = p.weeks_acc_recharge_amount reward_configs = g_campaignManager.\ weeks_acc_recharge_campaign.get_reward_configs() for each in reward_configs: config = configs[each.ID] if origin < config.gold and current >= config.gold: p.weeks_acc_recharge_rewards.add(each.ID) p.weeks_acc_recharge_last_clean_time = now_ts flag = True if g_campaignManager.month_acc_recharge_campaign.is_open(): origin = p.month_acc_recharge_amount p.month_acc_recharge_amount += gold current = p.month_acc_recharge_amount reward_configs = g_campaignManager.\ month_acc_recharge_campaign.get_reward_configs() for each in reward_configs: config = configs[each.ID] if origin < config.gold and current >= config.gold: p.month_acc_recharge_rewards.add(each.ID) p.month_acc_recharge_last_clean_time = now_ts flag = True if g_campaignManager.daily_recharge_campaign.is_open(): reward_configs = g_campaignManager.\ daily_recharge_campaign.get_reward_configs() for config in reward_configs: if gold == config.gold: used = p.daily_recharge_useds.get(config.id, 0) if used < config.count: p.daily_recharge_useds[config.id] = used + 1 p.daily_recharge_rewards.append(config.id) p.touch_daily_recharge_useds() p.touch_daily_recharge_rewards() break if not p.monthly_card: p.monthly_card_acc_amount += gold / 10 if p.monthly_card_acc_amount >= get_cons_value("MonthlyCardAccAmount"): p.monthly_card_time = now p.monthly_card_acc_amount = 0 p.monthly_card_received = False # 到期后同一日再次购买时重置 flag = True if flag: p.save() p.sync()
def step_mazes(p, attr, incr, count): mazes = get_config(MazeConfig) maze_step_count = p.maze_step_count results = [] while count > 0: remain = time.time() + 3600 data = {} config = mazes[maze_step_count % len(mazes)] append = False # 是否加入事件组 attr["money_rest_pool"] = min( attr.get("money_rest_pool", p.money_rest_pool) + get_cons_value("MazeMustDropMoney"), p.money_most_pool) attr["maze_rest_count"] = attr.get("maze_rest_count", p.maze_rest_count) data["attr"] = attr data["incr"] = incr if config.type == MazeEventType.DoubleMoney: v = int( attr.get("money_rest_pool", p.money_rest_pool) * config.argv) v = max(min(v, p.money_most_pool), 0) attr["money_rest_pool"] = v elif config.type == MazeEventType.AddMoney: v = int( attr.get("money_rest_pool", p.money_rest_pool) + config.argv) v = max(min(v, p.money_most_pool), 0) attr["money_rest_pool"] = v elif config.type == MazeEventType.DoubleCount: origin = attr.get("maze_rest_count", p.maze_rest_count) v = int(origin * config.argv) v = max(v, 0) if v > origin: attr["maze_rest_count"] = origin incr["maze_rest_count"] = incr.get("maze_rest_count", 0) + v - origin else: attr["maze_rest_count"] = v elif config.type == MazeEventType.AddCount: origin = attr.get("maze_rest_count", p.maze_rest_count) v = int(origin + config.argv) v = max(v, 0) if v > origin: attr["maze_rest_count"] = origin incr["maze_rest_count"] = incr.get("maze_rest_count", 0) + v - origin else: attr["maze_rest_count"] = v elif config.type == MazeEventType.Drop: data.update({"drop": int(config.argv)}) elif config.type == MazeEventType.Shop: if config.argv == MallType.Silver: attr["mall_silver_open_remain"] = remain elif config.argv == MallType.Golden: attr["mall_golden_open_remain"] = remain data.update({"argv": int(config.argv)}) append = True elif config.type == MazeEventType.Case: weights = [] for each in get_config(MazeCaseConfig): if p.level >= each.level: weights.append([each.drop, each.prob]) else: break drop = weighted_random2(weights) data.update({"argv": int(drop)}) append = True elif config.type == MazeEventType.Boss: weights = [] for each in get_config(MazeBossConfig): if p.level >= each.level: weights.append([each.boss, each.prob]) else: break boss = weighted_random2(weights) data.update({"argv": int(boss)}) append = True elif config.type == MazeEventType.Noop: pass else: break result = { "type": config.type, "time": remain, "append": append, } result.update(**data) result.setdefault("argv", config.argv) results.append(result) attr["maze_rest_count"] = max(attr["maze_rest_count"] - 1, 0) maze_step_count += 1 if "maze_rest_count" in attr and attr["maze_rest_count"] == 0: break if attr["money_rest_pool"] >= p.money_most_pool: break count -= 1 return results
def get_pvprankcount(update=False): global RANK_COUNT if RANK_COUNT is None or update: with PlayerRankRanking.pool.ctx() as conn: RANK_COUNT = conn.execute("ZCARD", PlayerRankRanking.key) or 0 return max(RANK_COUNT, get_cons_value("PvpMinRankerCount"))
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 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 get_bought_fund_count(): """开服基金购买人数""" with pool.ctx() as conn: return int(conn.execute("GET", FUND_BOUGHT_COUNT) or 0) +\ get_cons_value("FundFakeNumber")