Exemplo n.º 1
0
 def giftkey(self, msgtype, body):
     from protocol.poem_pb import Giftkey, GiftkeyResponse
     from config.configs import get_config, GiftkeyConfig
     from reward.manager import open_reward, build_reward_msg, RewardType
     from giftkey import use_key, InvalidGiftkeyError, ExceedUseCountError, ExceedDeallineError
     player = self.player
     req = Giftkey()
     req.ParseFromString(body)
     try:
         giftID = use_key(player, req.key)
     except InvalidGiftkeyError:
         return fail_msg(msgtype, reason='无效的兑换码')
     except ExceedUseCountError:
         return fail_msg(msgtype, reason='已经达到最大兑换次数了')
     except ExceedDeallineError:
         return fail_msg(msgtype, reason='已经超过有效期了')
     gift = get_config(GiftkeyConfig)[giftID]
     reward = open_reward(RewardType.Giftkey, gift)
     result = reward.apply(player)
     player.save()
     player.sync()
     rsp = GiftkeyResponse()
     build_reward_msg(rsp, result)
     gm_logger.info(
         {'giftkey': {
             'entityID': player.entityID,
             'giftkey': req.key
         }})
     return success_msg(msgtype, rsp)
Exemplo n.º 2
0
 def city_treasure_recv(self, msgtype, body):
     if g_campaignManager.city_dungeon_campaign.is_open():
         return fail_msg(msgtype, reason="活动开启中")
     if g_campaignManager.city_contend_campaign.is_open():
         return fail_msg(msgtype, reason="活动开启中")
     p = self.player
     info = g_cityDungeon.get_top_info()
     top_factionID = info.get("top_factionID", 0)
     if not top_factionID:
         return fail_msg(msgtype, reason="还没有公会获得宝藏")
     if p.factionID != top_factionID:
         return fail_msg(msgtype, reason="您不属于这个公会")
     if p.city_treasure_recv_flag:
         return fail_msg(msgtype, reason="今天已经领取过了")
     f = Faction.simple_load(p.factionID, ["faction_treasure"])
     if not f.faction_treasure:
         return fail_msg(msgtype, reason="还没有公会获得宝藏")
     current = None
     configs = get_config(CityTreasureRecvConfig)
     for config in configs.values():
         if f.faction_treasure >= config.treasure_count:
             current = config
         else:
             break
     if not current:
         return fail_msg(msgtype, reason="没有奖励可以领取")
     result = apply_reward(p,
                           parse_reward(current.rewards),
                           type=RewardType.CityTreasure)
     rsp = poem_pb.CityTreasureRecv()
     build_reward_msg(rsp, result)
     p.city_treasure_recv_flag = True
     p.save()
     p.sync()
     return success_msg(msgtype, rsp)
Exemplo n.º 3
0
 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)
Exemplo n.º 4
0
 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)
Exemplo n.º 5
0
 def maze_case_recv(self, msgtype, body):
     p = self.player
     req = poem_pb.MazeEventRequest()
     req.ParseFromString(body)
     index = req.index or 0
     try:
         event = p.mazes[index]
     except IndexError:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     count = 1
     cost = {}
     if req.treble:
         count = 3
         cost = {"gold": p.maze_case_cost}
     if event.get("type") != MazeEventType.Case:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     drop = event.get("argv", 0)
     drops = [drop] * count
     if drop:
         reward = open_reward(RewardType.MazeDrop, *drops)
     if cost:
         reward.cost_after(p, **cost)
     result = reward.apply(p)
     p.mazes.remove(event)
     p.touch_mazes()
     p.save()
     p.sync()
     rsp = poem_pb.MazeCaseResponse()
     build_reward_msg(rsp, result)
     return success_msg(msgtype, rsp)
Exemplo n.º 6
0
 def dlc_dispatch_end(self, msgtype, body):
     p = self.player
     req = poem_pb.DlcDispatchEndRequest()
     req.ParseFromString(body)
     # 检查关卡开启
     if not validate_prevs(p, req.fbID):
         return fail_msg(msgtype, reason="前置未通")
     if not validate_dlc_fb(p, req.fbID):
         return fail_msg(msgtype, reason="此关已通")
     dispatch = p.dlc_dispatch.get(req.fbID)
     if not dispatch:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     now = int(time.time())
     if now < dispatch["time"]:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     reward = apply_dlc_reward(req.fbID, isfirst=is_first(p, req.fbID))
     apply_reward(p, reward, type=RewardType.DlcDispatch)
     set_dlc_progress(p, req.fbID)
     set_fb_score(p, req.fbID, 1)   # FIXME
     from task.manager import on_end_dlc_fb
     from task.manager import on_dlc_score
     from task.manager import on_end_spec_fb_count
     from task.manager import on_end_fb_count
     on_end_spec_fb_count(p, req.fbID)
     on_end_fb_count(p, req.fbID)
     on_end_dlc_fb(p, req.fbID)
     on_dlc_score(p)
     p.save()
     p.sync()
     rsp = poem_pb.DlcDispatchEnd()
     build_reward_msg(rsp, reward)
     return success_msg(msgtype, rsp)
Exemplo n.º 7
0
 def friend_gift(self, msgtype, body):
     p = self.player
     req = poem_pb.GiftFriend()
     req.ParseFromString(body)
     logger.debug(req)
     count = len(req.ids)
     if p.friend_gift_used_count + count > p.friend_gift_max_count:
         return fail_msg(msgtype, reason="次数不足,无法赠送能量")
     for i in req.ids:
         if i not in p.friendset:
             return fail_msg(msgtype, reason="该玩家还不是你的好友")
         if i in p.friendgiftedset:
             return fail_msg(msgtype, reason="已经给该玩家赠送过能量")
     sp = 1
     money = 1000
     rewards = {"sp": sp, "money": money}
     for i in req.ids:
         proxy.gift_friend(i, p.name, rewards)
         p.friend_gift_used_count += 1
         p.friendgiftedset.add(i)
     self_rewards = {"sp": sp * count, "money": money * count}
     apply_reward(p, self_rewards, type=RewardType.GiftFriend)
     p.save()
     p.sync()
     rsp = poem_pb.GiftFriendResponse(ids=req.ids)
     build_reward_msg(rsp, self_rewards)
     return success_msg(msgtype, rsp)
Exemplo n.º 8
0
 def friend_friendfb_end(self, msgtype, body):
     p = self.player
     req = poem_pb.EndFriendfb()
     req.ParseFromString(body)
     if not PlayerFightLock.unlock(p.entityID, req.verify_code):
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     assert p.cache_friendfbID, "impossible"
     rsp = poem_pb.EndFriendfbResponse()
     try:
         createtime, hp, fbID = simple_load_friendfb(
             p.cache_friendfbID, 'createtime', 'hp', 'fbID')
     except DoesNotExistsException:
         error_code = msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED
     else:
         if hp <= 0:
             error_code = msgTips.FAIL_MSG_FRIENDFB_ALREADY_DEAD
             # return fail_msg(msgtype, reason='BOSS已经被击杀了')
         else:
             from pvp.manager import send_fight_verify
             from fightverifier.direct_verifier import verify
             send_fight_verify(p, req.fight)
             if not verify(p, req.fight):
                 return fail_msg(msgtype,
                                 msgTips.FAIL_MSG_FIGHT_VERIFY_FAILED)
             error_code = 0
             now = int(time.time())
             if if_boss(p.cache_friendfbID) and\
                     not if_boss_campaign_opened(p.cache_friendfbID) or \
                     not if_boss(p.cache_friendfbID) and \
                     now > createtime + FRIENDFB_INTERVAL:
                 error_code = msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED  # NOQA
             else:
                 info = get_config(FriendfbConfig)[fbID]
                 if info.drop:
                     r = open_reward(RewardType.Friendfb, info.drop)
                     result = r.apply(p)
                     build_reward_msg(rsp, result)
                 damage = max(req.fight.total_damage or 0, 0)
                 hp = hurt_boss(p, fbID, p.cache_friendfbID, damage)
                 if hp <= 0:
                     if if_boss(p.cache_friendfbID):
                         # 提前发奖
                         bc = get_boss_campaign(p.cache_friendfbID)
                         proxy.notify_boss_campaign_end(bc.config.ID)
                         entityID = bc.get_by_rank(1)
                         proxy.sync_on_task_change(entityID,
                                                   TaskCond.FriendfbFirst,
                                                   p.cache_friendfbID)
                     else:
                         give_reward(p.cache_friendfbID)
                     on_friendfb_count(p, fbID)
                 else:
                     p.friendfb_deads.add(p.cache_friendfbID)
                     p.friendfb_deadtimes[fbID] = now
     p.friendfb_buff = 0
     p.save()
     p.sync()
     rsp.error_code = error_code
     return success_msg(msgtype, rsp)
Exemplo n.º 9
0
 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)
Exemplo n.º 10
0
 def mail_list(self, msgtype, body):
     req = poem_pb.MailListRequest()
     req.ParseFromString(body)
     player = self.player
     mails = sorted(player.mails.values(), key=lambda s: s.addtime)
     rsp = poem_pb.MailList()
     now = int(time.time())
     # 删除过期邮件
     pending = []
     for mail in mails:
         if mail.cd and now > mail.addtime + mail.cd:
             if mail.isread and mail.isreceived:
                 pending.append(mail)
         else:
             data = {}
             config = get_config(MailConfig).get(mail.configID)
             if config:
                 data.update(**config._asdict())
             data.update(
                 mailID=mail.mailID,
                 title=mail.title,
                 type=mail.type,
                 content=mail.content,
                 cd=mail.cd - (now - mail.addtime),
                 isread=mail.isread,
                 isreceived=mail.isreceived,
                 addtime=mail.addtime,
             )
             each = rsp.mails.add(**data)
             tmp_transform = {
                 500026: 800026,
                 500027: 800027,
                 500028: 800028,
                 500029: 800029,
                 500030: 800030,
                 500031: 800031,
                 500032: 800032,
                 500021: 800021,
                 14000371: 21000371,
                 14000372: 21000372,
                 14000373: 21000373,
                 14000374: 21000374,
                 14000375: 21000375,
             }
             for item in mail.addition.get('matList', []):
                 item[0] = tmp_transform.get(item[0], item[0])
             build_reward_msg(each, mail.addition)
     if pending:
         player.del_mails(*pending)
         logger.debug("newmailcount %r", player.newmailcount)
         player.save()
         player.sync()
     return success_msg(msgtype, rsp)
Exemplo n.º 11
0
 def spar_request(self, msgtype, body):
     p = self.player
     req = poem_pb.SparRequest()
     req.ParseFromString(body)
     config = get_config(SparConfig).get(req.ID)
     if not config:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     logger.debug(req)
     spar_count = p.spar_counts.get(req.ID, 0)
     count = config.onekeycount if req.onekey else 1
     # cost = config.onekeycost if req.onekey else 1
     if not count:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     drops = []
     for i in range(count):
         if spar_count >= config.dropex_use_count:
             drops.append(config.dropex)
             spar_count = 0
         else:
             drops.append(config.drop)
             spar_count += 1
     if not drops:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     try:
         reward = open_reward(RewardType.Spar, *drops)
         reward.cost_after(
             p,
             matList=[[config.itemID, count]],
             money=config.money*count)
         result = reward.apply(p)
     except AttrNotEnoughError:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     except MatNotEnoughError:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     rsp = poem_pb.SparResponse()
     build_reward_msg(rsp, result)
     on_pet_spar(p, rsp.rewards)
     on_equip_spar(p, rsp.rewards)
     p.spar_counts[req.ID] = spar_count
     from task.manager import on_spar_count
     on_spar_count(p, spar_count)
     p.save()
     p.sync()
     logger.debug(rsp)
     count = config.dropex_use_count - p.spar_counts.get(req.ID, 0)
     info = config._asdict()
     if count == 0:
         info['tips'] = config.final_tips
     else:
         info['tips'] = config.tips.format(count + 1)
     rsp.item = poem_pb.SparItem(**info)
     return success_msg(msgtype, rsp)
Exemplo n.º 12
0
 def maze_pool_recv(self, msgtype, body):
     p = self.player
     if not p.money_rest_pool:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     result = apply_reward(
         p, {"money": p.money_rest_pool},
         type=RewardType.MazePool)
     p.money_rest_pool = 0
     p.save()
     p.sync()
     rsp = poem_pb.MazePoolResponse()
     build_reward_msg(rsp, result)
     return success_msg(msgtype, rsp)
Exemplo n.º 13
0
 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)
Exemplo n.º 14
0
 def tap_onekey(self, msgtype, body):
     p = self.player
     if not p.tap_onekey:
         return fail_msg(msgtype, msgTips.FAIL_MSG_CANT_TAP_ONEKEY)
     rsp = poem_pb.OnekeyTapResponse()
     reward, count = onekey_tap(p)
     m = get_config(TapMonsterConfig)[p.tap_monster]
     rsp.next = poem_pb.StartTapResponse(**m._asdict())
     rsp.next.hurts = p.tap_hurts
     rsp.next.index = p.tap_hurts_index
     build_reward_msg(rsp, reward)
     on_tap_count(p, count)
     p.save()
     p.sync()
     return success_msg(msgtype, rsp)
Exemplo n.º 15
0
 def tap_end(self, msgtype, body):
     p = self.player
     req = poem_pb.EndTap()
     req.ParseFromString(body)
     logger.debug("tap end")
     logger.debug(req)
     reward = end_tap(p, req.count)
     if not reward:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     rsp = poem_pb.EndTapResponse()
     build_reward_msg(rsp, reward)
     logger.debug(rsp)
     on_tap_count(p, req.count)
     p.save()
     p.sync()
     return success_msg(msgtype, rsp)
Exemplo n.º 16
0
 def use_mat(self, msgtype, body):
     p = self.player
     req = poem_pb.UseMatRequest()
     req.ParseFromString(body)
     config = get_config(MatConfig).get(req.matID)
     if not config:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     rsp = poem_pb.UseMatResponse()
     if config.type == MatType.Drop:
         drop = config.arg
         attr = ""
     elif config.type in USEINGS:
         drop = 0
         attr = USEINGS.get(config.type)
     elif config.type == MatType.RipeningAgent:
         if p.seed_state == poem_pb.SeedStateNormal or\
                 p.seed_state == poem_pb.SeedStateRipening or\
                 p.seed_state == poem_pb.SeedStateRoot:
             return fail_msg(msgtype, reason="无法使用!")
         p.seed_state = poem_pb.SeedStateRipening
         p.seed_state_last_change_time = 0
         p.seed_state_next_change_time = 0
         p.seed_state_ripening_time = 0
         drop = 0
         attr = ''
     else:
         return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
     reward = open_reward(RewardType.UseMat, drop)
     reward.cost_after(p, matList=[[req.matID, 1]])
     result = reward.apply(p)
     if attr:
         value = getattr(p, attr, 0) + config.arg
         setattr(p, attr, value)
     rsp.tips = config.tips
     build_reward_msg(rsp, result)
     p.save()
     p.sync()
     return success_msg(msgtype, rsp)
Exemplo n.º 17
0
    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)
Exemplo n.º 18
0
    def flowerboss_friendfb_end(self, msgtype, body):
        p = self.player
        req = poem_pb.EndFriendfb()
        req.ParseFromString(body)
        if not PlayerFightLock.unlock(p.entityID, req.verify_code):
            return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)
        assert p.cache_friendfbID, "impossible"

        from campaign.manager import g_campaignManager
        flower_boss_friendfbID = "bosscampaign:%d" % g_campaignManager.flower_boss_campaign.flower_boss_config_id
        if p.cache_friendfbID != flower_boss_friendfbID:
            return fail_msg(msgtype, msgTips.FAIL_MSG_INVALID_REQUEST)

        rsp = poem_pb.EndFriendfbResponse()
        try:
            createtime, hp, fbID = simple_load_friendfb(
                p.cache_friendfbID, 'createtime', 'hp', 'fbID')
        except DoesNotExistsException:
            error_code = msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED
        else:
            if hp <= 0:
                error_code = msgTips.FAIL_MSG_FRIENDFB_ALREADY_DEAD
                # return fail_msg(msgtype, reason='BOSS已经被击杀了')
            else:
                from pvp.manager import send_fight_verify
                from fightverifier.direct_verifier import verify
                send_fight_verify(p, req.fight)
                if not verify(p, req.fight):
                    return fail_msg(msgtype,
                                    msgTips.FAIL_MSG_FIGHT_VERIFY_FAILED)
                error_code = 0
                now = int(time.time())
                if if_boss(p.cache_friendfbID) and\
                        not if_boss_campaign_opened(p.cache_friendfbID) or \
                        not if_boss(p.cache_friendfbID) and \
                        now > createtime + FRIENDFB_INTERVAL:
                    error_code = msgTips.FAIL_MSG_FRIENDFB_ALREADY_DISAPPEARED  # NOQA
                else:
                    damage = max(req.fight.total_damage or 0, 0)

                    info = get_config(FriendfbConfig)[fbID]
                    if info.drop:
                        from config.configs import HandselMulRewardConfig
                        mr_configs = get_config(HandselMulRewardConfig)
                        mr_id = g_campaignManager.flower_boss_campaign.get_mulreward_id(
                        )
                        mr_config = mr_configs[mr_id]
                        mr = mr_config.mulreward

                        import math
                        r = open_reward(RewardType.Flower315Campaign,
                                        info.drop, int(math.ceil(mr * damage)))
                        result = r.apply(p)
                        build_reward_msg(rsp, result)

                        start_time, end_time = g_campaignManager.flower_boss_campaign.get_current_time(
                        )
                        if p.flower_boss_campaign_last_time < start_time or p.flower_boss_campaign_last_time > end_time:
                            p.flower_boss_campaign_total_hurt = 0
                        p.flower_boss_campaign_total_hurt += damage
                        p.flower_boss_campaign_last_time = now

                    hp = hurt_boss(p, fbID, p.cache_friendfbID, damage)
                    if hp <= 0:
                        if if_boss(p.cache_friendfbID):
                            # 提前发奖
                            bc = get_boss_campaign(p.cache_friendfbID)
                            proxy.notify_boss_campaign_end(bc.config.ID)
                            entityID = bc.get_by_rank(1)
                            proxy.sync_on_task_change(entityID,
                                                      TaskCond.FriendfbFirst,
                                                      p.cache_friendfbID)
                        else:
                            give_reward(p.cache_friendfbID)
                        on_friendfb_count(p, fbID)
                    else:
                        p.friendfb_deads.add(p.cache_friendfbID)
                        p.friendfb_deadtimes[fbID] = now
        p.friendfb_buff = 0
        p.save()
        p.sync()
        rsp.error_code = error_code
        return success_msg(msgtype, rsp)
Exemplo n.º 19
0
Arquivo: city.py Projeto: kimch2/x8623
 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()
Exemplo n.º 20
0
Arquivo: city.py Projeto: kimch2/x8623
 def get_end_panel(self, p, rsp):
     build_reward_msg(rsp, p.city_contend_rewards)