def hero_break_logic(hero_no, player, response): hero = player.hero_component.get_hero(hero_no) hero_info = game_configs.hero_config.get(hero_no) # 验证武将是否突破到上限 if hero.break_level == hero_info.breakLimit: return {"result": False, "result_no": 201} consume_info = hero_info.get('consume' + str(hero.break_level+1)) item_group = parse(consume_info) hero_info = game_configs.hero_config.get(hero.hero_no) # 判断是否足够 result = is_afford(player, item_group) # 校验 if not result.get('result'): return {"result": False, "result_no": result.get('result_no')} # 返回消耗 return_data = consume(player, item_group, const.HERO_BREAK) get_return(player, return_data, response.consume) hero.break_level += 1 notice_item = game_configs.notes_config.get(2003) if hero.break_level in notice_item.parameter1: push_notice(2003, player_name=player.base_info.base_name, hero_no=hero.hero_no, hero_break_level=hero.break_level) hero.save_data() # 3、返回 tlog_action.log('HeroBreak', player, hero_no, hero.break_level) return {"result": True, "break_level": hero.break_level}
def hero_break_104(data, player): """武将突破""" args = hero_request_pb2.HeroBreakRequest() args.ParseFromString(data) hero_no = args.hero_no hero = player.hero_component.get_hero(hero_no) response = hero_response_pb2.HeroBreakResponse() # 验证武将是否突破到上限 if hero.break_level == game_configs.hero_config.get(hero_no).breakLimit: response.res.result = False response.res.result_no = 201 return response.SerializeToString() _hero_breakup = game_configs.hero_breakup_config.get(hero.hero_no) item_group = _hero_breakup.get_consume(hero.break_level) # 判断是否足够 result = is_afford(player, item_group) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = result.get('result_no') return response.SerializeToString() # 返回消耗 return_data = consume(player, item_group) get_return(player, return_data, response.consume) hero.break_level += 1 hero.save_data() # 3、返回 response.res.result = True response.break_level = hero.break_level return response.SerializeToString()
def shop_oper(pro_data, player): """商城所有操作""" request = ShopRequest() request.ParseFromString(pro_data) response = ShopResponse() shop_id = request.id shop_item = shop_config.get(shop_id) if is_consume(player, shop_item): # 判断是否消耗 result = is_afford(player, shop_item.consume) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = result.get('result_no') response.res.message = u'消费不足!' return_data = consume(player, shop_item.consume) # 消耗 get_return(player, return_data, response.consume) return_data = gain(player, shop_item.gain) # 获取 extra_return_data = gain(player, shop_item.extraGain) # 额外获取 get_return(player, return_data, response.gain) get_return(player, extra_return_data, response.gain) response.res.result = True return response.SerializeToString()
def do_hero_refine(player, hero_no, refine, response): hero = player.hero_component.get_hero(hero_no) _refine_item = game_configs.seal_config.get(refine) if not hero: logger.error('cant find hero:%s', hero_no) return {'result': False, 'result_no': 11801} if not _refine_item: logger.error('cant find refine item:%s', refine) return {'result': False, 'result_no': 11802} current_refine_item = game_configs.seal_config.get(hero.refine) if current_refine_item and _refine_item.id != current_refine_item.get('next'): logger.error('not next refine item:%s', refine) return {'result': False, 'result_no': 11803} result = is_afford(player, _refine_item.expend) # 校验 if not result.get('result'): logger.error('cant afford refine:%s:cur%s', _refine_item.expend, player.brew.nectar) return {'result': False, 'result_no': 11804} tlog_action.log('HeroRefine', player, hero_no, refine) return_data = consume(player, _refine_item.expend, const.HERO_REFINE) get_return(player, return_data, response.consume) hero.refine = refine player.brew.save_data() hero.save_data() return {'result': True}
def new_guide_step_1802(data, player): request = NewbeeGuideStepRequest() request.ParseFromString(data) response = NewbeeGuideStepResponse() new_guide_item = game_configs.newbee_guide_config.get(request.step_id) if not new_guide_item: logger.error('error newbee id:%s', request.step_id) response.res.result = False return response.SerializePartialToString() new_guide_type = new_guide_item.get('SequenceType') logger.info('newbee:%s step:%s=>%s', player.base_info.id, player.base_info.newbee_guide, request.step_id) my_newbee_sequence = 0 if player.base_info.newbee_guide.get(new_guide_type): my_newbee_sequence = game_configs.newbee_guide_config.get( player.base_info.newbee_guide[new_guide_type]).get('Sequence') if my_newbee_sequence < new_guide_item.get('Sequence'): gain_data = new_guide_item.get('rewards') return_data = gain(player, gain_data, const.NEW_GUIDE_STEP) get_return(player, return_data, response.gain) logger.debug('new bee id:%s step:%s reward:%s response:%s', player.base_info.id, request.step_id, gain_data, response.gain) else: response.res.result_no = 111 logger.debug("new bee reward repeated, id:%s step:%s %s %s", player.base_info.id, request.step_id, my_newbee_sequence, new_guide_item.get('Sequence')) consume_config = new_guide_item.get('consume') result = is_afford(player, consume_config) # 校验 if not result.get('result'): logger.error('newbee guide comsume:%s', consume_config) response.res.result = False response.res.result_no = 1802 return response.SerializePartialToString() need_gold = get_consume_gold_num(consume_config) def func(): consume_data = consume(player, consume_config, const.NEW_GUIDE_STEP) get_return(player, consume_data, response.consume) # logger.debug("gain_data %s %s" % (gain_data, request.step_id)) # logger.debug(player.finance.coin) tlog_action.log('NewGuide', player, new_guide_item.get('Sequence'), request.step_id) if my_newbee_sequence < new_guide_item.get('Sequence'): player.base_info.newbee_guide[new_guide_type] = request.step_id player.base_info.current_newbee_guide = request.step_id player.base_info.save_data() player.pay.pay(need_gold, const.NEW_GUIDE_STEP, func) response.res.result = True response.step_id = request.step_id return response.SerializePartialToString()
def buy_truce_item_861(data, player): """买休战符""" args = rob_treasure_pb2.BuyTruceItemRequest() args.ParseFromString(data) num = args.num response = rob_treasure_pb2.BuyTruceItemResponse() price = game_configs.base_config.get('indianaTrucePrice') is_afford_res = is_afford(player, price, multiple=num) # 校验 """ if not is_afford_res.get('result'): logger.error('rob_treasure_truce_841, item not enough') response.res.result = False response.res.result_no = is_afford_res.get('result_no') return response.SerializeToString() return_data = consume(player, price, const.BUY_TRUCE_ITEM, multiple=num) # 消耗 get_return(player, return_data, response.consume) """ gain_items = game_configs.base_config.get('indianaIteam') return_data = gain(player, gain_items, const.BUY_TRUCE_ITEM, multiple=num) get_return(player, return_data, response.gain) response.res.result = True return response.SerializeToString()
def buy_truce_item_861(data, player): """买休战符""" args = rob_treasure_pb2.BuyTruceItemRequest() args.ParseFromString(data) num = args.num response = rob_treasure_pb2.BuyTruceItemResponse() price = game_configs.base_config.get('indianaTrucePrice') is_afford_res = is_afford(player, price, multiple=num) # 校验 """ if not is_afford_res.get('result'): logger.error('rob_treasure_truce_841, item not enough') response.res.result = False response.res.result_no = is_afford_res.get('result_no') return response.SerializeToString() return_data = consume(player, price, const.BUY_TRUCE_ITEM, multiple=num) # 消耗 get_return(player, return_data, response.consume) """ gain_items = game_configs.base_config.get('indianaIteam') return_data = gain(player, gain_items, const.BUY_TRUCE_ITEM, multiple=num) get_return(player, return_data, response.gain) response.res.result = True return response.SerializeToString()
def refresh_price(self, shop_type, response): shop_item = game_configs.shop_type_config.get(shop_type) if not shop_item: raise Exception('error shop type:%s' % shop_type) price = 0 free_times = shop_item.get('freeRefreshTimes') __shop_data = self._shop_data[shop_type] if __shop_data['refresh_times'] >= free_times: refreshprice = shop_item.get('refreshPrice') if not refreshprice: logger.debug('no refresh price:shop type:%s', shop_type) # 道具 refresh_items = shop_item.get('refreshItem') has_refresh_item = is_afford(self._owner, refresh_items).get('result') if refresh_items and has_refresh_item: price = 0 # 如果有刷新令,则消耗刷新令 return_data = consume(self._owner, refresh_items, const.SHOP_REFRESH, shop=None, luck_config=None, multiple=1) get_return(self._owner, return_data, response.consume) elif not has_refresh_item or not refresh_items: price = get_consume_gold_num(refreshprice) xs = 1 if (not has_refresh_item or not refresh_items) and shop_type == 12: # 9活动 act_confs = game_configs.activity_config.get(22, []) for act_conf in act_confs: if self.owner.act.is_activiy_open(act_conf.id): xs = act_conf.parameterC[0] price = int(price * xs) break return_data = consume(self._owner, refreshprice, const.SHOP_REFRESH, shop=None, luck_config=None, multiple=xs) get_return(self._owner, return_data, response.consume) def func(): __shop_data['refresh_times'] += 1 __shop_data['last_refresh_time'] = time.time() __shop_data['items'] = {} if shop_item.itemNum > 0: __shop_data['item_ids'] = get_shop_item_ids( shop_type, self._shop_data[shop_type]['luck_num']) self.save_data() result = self._owner.pay.pay(price, const.SHOP_REFRESH, func) return result
def reset_1242(data, player): """ 重置地图,ok """ request = mine_pb2.resetMap() request.ParseFromString(data) response = mine_pb2.resetResponse() response.free = request.free # print '1242-request', request reset_pos = [] if request.free == 1: if player.mine.can_reset_free(): reset_pos = player.mine.reset_map() mine_status(player, response.mine) response.res.result = True else: response.res.result = False response.res.result_no = 12420 response.res.message = u"免费次数已用完" else: if not player.mine.can_reset(): response.res.result = False response.res.result_no = 12421 response.res.message = u"重置次数已用完" else: reset_price = player.mine.reset_price() price = CommonGroupItem(0, reset_price, reset_price, const.GOLD) result = item_group_helper.is_afford(player, [price]) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = result.get('result_no') response.res.message = u'消费不足!' else: need_gold = item_group_helper.get_consume_gold_num([price]) def func(): consume_data = item_group_helper.consume(player, [price], const.MINE_RESET) item_group_helper.get_return(player, consume_data, response.consume) reset_pos = player.mine.reset_map() mine_status(player, response.mine) response.res.result = True player.pay.pay(need_gold, const.MINE_RESET, func) player.mine.save_data() player.act.mine_refresh() target_update(player, [56]) reset_times, _, _ = player.mine.reset_times tlog_action.log('MineReset', player, reset_times, str(reset_pos)) return response.SerializePartialToString()
def acc_mine_1250(data, player): """ 增产, 只有主矿能增产, 增产累计时长,ok """ request = mine_pb2.positionRequest() request.ParseFromString(data) response = mine_pb2.IncreaseResponse() detail_info = player.mine.detail_info(request.position) last_increase = detail_info['increase'] now = xtime.timestamp() main_mine = game_configs.mine_config.get(10001) if last_increase + main_mine.increasTime * 60 - now > main_mine.increasMaxTime * 60: response.res.result = True response.result_no = 12501 return response.SerializePartialToString() mine_item = game_configs.mine_config[detail_info['mine_id']] increasePrice = mine_item.increasePrice price = CommonGroupItem(0, increasePrice, increasePrice, const.GOLD) result = item_group_helper.is_afford(player, [price]) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = result.get('result_no') response.res.message = u'消费不足!' return response.SerializePartialToString() else: response.res.result = True # print 'price', price need_gold = item_group_helper.get_consume_gold_num([price]) def func(): consume_return_data = item_group_helper.consume(player, [price], const.MINE_ACC) item_group_helper.get_return(player, consume_return_data, response.consume) player.pay.pay(need_gold, const.MINE_ACC, func) last_time = player.mine.increase_mine() player.mine.save_data() tlog_action.log('MineAcc', player, time.strftime("%Y-%m-%d %X", time.localtime(int(last_time)))) response.position = 0 response.last_time = int(last_time) return response.SerializePartialToString()
def exchange_1248(data, player): """ 神秘商人兑换,ok """ request = mine_pb2.exchangeRequest() request.ParseFromString(data) response = mine_pb2.exchangeResponse() response.position = request.position response.shop_id = request.shop_id common_response = response.res # print "mijing shop id:", request.shop_id shop_item = game_configs.shop_config.get(request.shop_id) result = item_group_helper.is_afford(player, shop_item.discountPrice) # 校验 if not result.get('result'): common_response.result = False common_response.result_no = result.get('result_no') common_response.message = u'消费不足!' return response.SerializePartialToString() if shop_item.type != 7: common_response.result = False common_response.result_no = 12480 common_response.message = u'非密境商店商品!' return response.SerializePartialToString() ret, message = player.mine.can_buy(request.position, request.shop_id) if ret != 0: common_response.result = False common_response.result_no = ret common_response.message = message return response.SerializePartialToString() need_gold = item_group_helper.get_consume_gold_num(shop_item.discountPrice) def func(): consume_data = item_group_helper.consume(player, shop_item.discountPrice, const.MINE_EXCHANGE) # 消耗 return_data = item_group_helper.gain(player, shop_item.gain, const.MINE_EXCHANGE) # 获取 # extra_return_data = gain(player, shop_item.extra_gain) # 额外获取 item_group_helper.get_return(player, consume_data, response.consume) item_group_helper.get_return(player, return_data, response.gain) # get_return(player, extra_return_data, response) player.mine.buy_shop(request.position, request.shop_id) player.mine.save_data() player.pay.pay(need_gold, const.MINE_EXCHANGE, func) return response.SerializePartialToString()
def get_activity_gift_1856(data, player): request = activity_pb2.GetActGiftRequest() request.ParseFromString(data) activity_id = request.act_id response = activity_pb2.GetActGiftResponse() response.res.result = False if not player.act.is_activiy_open(activity_id): response.res.result = False response.res.result_no = 800 return response.SerializeToString() act_conf = game_configs.activity_config.get(activity_id) info = get_act_info(player, activity_id) if info.get('state') != 2: response.res.result = False logger.error("this start target 条件不满足") response.res.result_no = 800 return response.SerializeToString() need_gold = 0 need_gold_acts = [30, 50] if act_conf.type in need_gold_acts: need_gold = act_conf.parameterB if need_gold: price = parse({107: [need_gold, need_gold, 2]}) if not is_afford(player, price): response.res.result = False response.res.result_no = 102 return response.SerializeToString() def func(): return_data = gain(player, act_conf.reward, const.ACTIVITY) # 获取 get_return(player, return_data, response.gain) if act_conf.type == 30: if act_conf.count <= (info.get('jindu') + 1): player.act.act_infos[activity_id][0] = 3 else: player.act.act_infos[activity_id] = [1, info.get('jindu') + 1] else: player.act.act_infos[activity_id][0] = 3 player.pay.pay(need_gold, const.ACTIVITY, func) player.act.save_data() response.res.result = True return response.SerializeToString()
def get_activity_gift_1856(data, player): request = activity_pb2.GetActGiftRequest() request.ParseFromString(data) activity_id = request.act_id response = activity_pb2.GetActGiftResponse() response.res.result = False if not player.act.is_activiy_open(activity_id): response.res.result = False response.res.result_no = 800 return response.SerializeToString() act_conf = game_configs.activity_config.get(activity_id) info = get_act_info(player, activity_id) if info.get('state') != 2: response.res.result = False logger.error("this start target 条件不满足") response.res.result_no = 800 return response.SerializeToString() need_gold = 0 need_gold_acts = [30, 50] if act_conf.type in need_gold_acts: need_gold = act_conf.parameterB if need_gold: price = parse({107: [need_gold, need_gold, 2]}) if not is_afford(player, price): response.res.result = False response.res.result_no = 102 return response.SerializeToString() def func(): return_data = gain(player, act_conf.reward, const.ACTIVITY) # 获取 get_return(player, return_data, response.gain) if act_conf.type == 30: if act_conf.count <= (info.get('jindu') + 1): player.act.act_infos[activity_id][0] = 3 else: player.act.act_infos[activity_id] = [1, info.get('jindu') + 1] else: player.act.act_infos[activity_id][0] = 3 player.pay.pay(need_gold, const.ACTIVITY, func) player.act.save_data() response.res.result = True return response.SerializeToString()
def unpar_upgrade_705(pro_data, player): """ 无双升级 """ response = CommonResponse() response.result = True _line_up = player.line_up_component peerless_grade_info = game_configs.skill_peerless_grade_config.get(_line_up._unpar_level) resource1 = peerless_grade_info.resource1 resource2 = peerless_grade_info.resource2 if not is_afford(player, resource1) or not is_afford(player, resource2): logger.error("resource not enough!") response.result = False response.result_no = 70501 return response.SerializePartialToString() consume(player, resource1, const.UNPAR_UPGRADE) consume(player, resource2, const.UNPAR_UPGRADE) _line_up.unpar_level = _line_up.unpar_level + 1 _line_up.save_data() tlog_action.log('UnparUpgrade', player, _line_up.unpar_level) logger.debug("response %s" % response) return response.SerializePartialToString()
def refresh_runt_844(data, player): """打造刷新""" response = RefreshRuntResponse() need_gold = 0 # 0 免费,1 招募令,2 元宝 refresh_times = copy.copy(player.runt.refresh_times) if time.localtime(player.runt.refresh_times[1]).tm_year == time.localtime().tm_year \ and time.localtime(player.runt.refresh_times[1]).tm_yday == time.localtime().tm_yday: refresh_times[0] += 1 if game_configs.base_config.get('totemRefreshFreeTimes') <= player.runt.refresh_times[0]: need_gold = 1 else: # player.runt.refresh_times = [1, int(time.time())] refresh_times = [1, int(time.time())] need_item = game_configs.base_config.get('totemRefreshItem') if need_gold == 1 and not is_afford(player, need_item).get('result'): need_gold = 2 if need_gold == 2 and player.finance.gold < game_configs.base_config.get('totemRefreshPrice'): response.res.result = False response.res.result_no = 102 # 充值币不足 return response.SerializeToString() if need_gold == 1: consume(player, need_item, const.RUNT_REFRESH) if need_gold == 2: player.finance.consume_gold(game_configs.base_config.get('totemRefreshPrice'), const.RUNT_REFRESH) player.runt.refresh_times = refresh_times while True: new_refresh_id = player.runt.build_refresh() if player.runt.refresh_runt: if not player.runt.refresh_runt[1] == new_refresh_id: break else: break runt_no = get_uuid() mainAttr, minorAttr = player.runt.get_attr(new_refresh_id) player.runt.refresh_runt = [runt_no, new_refresh_id, mainAttr, minorAttr] player.runt.deal_runt_pb(runt_no, new_refresh_id, mainAttr, minorAttr, response.refresh_runt) player.finance.save_data() player.runt.save() response.res.result = True return response.SerializeToString()
def hero_break_logic(hero_no, player, response): if is_not_open(player, FO_HERO_BREAK): return {'result': False, 'result_no': 837} hero = player.hero_component.get_hero(hero_no) hero_info = game_configs.hero_config.get(hero_no) break_through = game_configs.base_config.get('breakthrough') target_break_level = hero.break_level + 1 logger.debug("target_break_level %s" % target_break_level) if target_break_level not in break_through: logger.debug("hero_break_logic can find target break level %s" % target_break_level) return {"result": False, "result_no": 10401} if hero.level < break_through[target_break_level][0]: logger.debug("hero_break_logic level is not enough %s" % hero.level) return {"result": False, "result_no": 10402} # 验证武将是否突破到上限 if hero.break_level == hero_info.breakLimit: return {"result": False, "result_no": 201} consume_info = hero_info.get('consume' + str(hero.break_level+1)) item_group = parse(consume_info) hero_info = game_configs.hero_config.get(hero.hero_no) # 判断是否足够 result = is_afford(player, item_group) # 校验 if not result.get('result'): return {"result": False, "result_no": result.get('result_no')} # 返回消耗 return_data = consume(player, item_group, const.HERO_BREAK) get_return(player, return_data, response.consume) for item in item_group: if item.item_type == 105 and item.item_no == 20006: hero.break_item_num += item.num hero.save_data() hero.break_level += 1 notice_item = game_configs.notes_config.get(2003) if hero.break_level in notice_item.parameter1: push_notice(2003, player_name=player.base_info.base_name, hero_no=hero.hero_no, hero_break_level=hero.break_level) hero.save_data() # 3、返回 tlog_action.log('HeroBreak', player, hero_no, hero.break_level) return {"result": True, "break_level": hero.break_level, "break_item_num": hero.break_item_num}
def shop_equipment_oper(pro_data, player): """装备抽取""" request = shop_pb2.ShopRequest() request.ParseFromString(pro_data) response = shop_pb2.ShopResponse() shop_id = request.ids[0] shop_num = request.num shop_item = game_configs.shop_config.get(shop_id) if shop_num == 1: # and not is_consume(player, shop_item): # 免费抽取 return_data = gain(player, shop_item.gain, const.SHOP_DRAW_EQUIPMENT) # 获取 extra_return_data = gain(player, shop_item.extraGain, const.SHOP_DRAW_EQUIPMENT) # 额外获取 get_return(player, return_data, response.gain) get_return(player, extra_return_data, response.gain) # 多装备抽取 elif shop_num >= 1: for i in range(shop_num): result = is_afford(player, shop_item.consume) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = 101 return response.SerializePartialToString() for i in range(shop_num): return_data = consume(player, shop_item.consume, const.SHOP_DRAW_EQUIPMENT) # 消耗 get_return(player, return_data, response.consume) for i in range(shop_num): return_data = gain(player, shop_item.gain, const.SHOP_DRAW_EQUIPMENT) # 获取 extra_return_data = gain(player, shop_item.extraGain, const.SHOP_DRAW_EQUIPMENT) # 额外获取 get_return(player, return_data, response.gain) get_return(player, extra_return_data, response.gain) response.res.result = True return response.SerializeToString()
def shop_equipment_oper(pro_data, player): """装备抽取""" request = shop_pb2.ShopRequest() request.ParseFromString(pro_data) response = shop_pb2.ShopResponse() shop_id = request.ids[0] shop_num = request.num shop_item = game_configs.shop_config.get(shop_id) if shop_num == 1: # and not is_consume(player, shop_item): # 免费抽取 return_data = gain(player, shop_item.gain, const.SHOP_DRAW_EQUIPMENT) # 获取 extra_return_data = gain(player, shop_item.extraGain, const.SHOP_DRAW_EQUIPMENT) # 额外获取 get_return(player, return_data, response.gain) get_return(player, extra_return_data, response.gain) # 多装备抽取 elif shop_num >= 1: for i in range(shop_num): result = is_afford(player, shop_item.consume) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = 101 return response.SerializePartialToString() for i in range(shop_num): return_data = consume(player, shop_item.consume, const.SHOP_DRAW_EQUIPMENT) # 消耗 get_return(player, return_data, response.consume) for i in range(shop_num): return_data = gain(player, shop_item.gain, const.SHOP_DRAW_EQUIPMENT) # 获取 extra_return_data = gain(player, shop_item.extraGain, const.SHOP_DRAW_EQUIPMENT) # 额外获取 get_return(player, return_data, response.gain) get_return(player, extra_return_data, response.gain) response.res.result = True return response.SerializeToString()
def get_activity_28_gift_1834(data, player): request = activity_pb2.GetActGiftRequest() request.ParseFromString(data) activity_id = request.act_id quantity = request.quantity response = activity_pb2.GetActGiftResponse() response.res.result = False activity_conf = game_configs.activity_config.get(activity_id) if not activity_conf: logger.error('not found activity id:%s', activity_id) response.res.result_no = 183401 return response.SerializeToString() if not player.act.is_activiy_open(activity_id): logger.error('activity not open id:%s', activity_id) response.res.result_no = 183402 return response.SerializeToString() price = activity_conf.parameterA * activity_conf.parameterC[0] activity_consume = parse({107: [price, price, 29]}) for i in range(30): print player.finance[i] result = is_afford(player, activity_consume, multiple=quantity) if not result.get('result'): logger.error('activity not enough res:%s', price) response.res.result_no = 183403 return response.SerializeToString() consume_data = consume(player, activity_consume, const.act_28, multiple=quantity) get_return(player, consume_data, response.consume) return_data = gain(player, activity_conf.reward, const.act_28, multiple=quantity) get_return(player, return_data, response.gain) tlog_action.log('GodHeroExchange', player, activity_id, quantity) response.res.result = True return response.SerializeToString()
def get_activity_28_gift_1834(data, player): request = activity_pb2.GetActGiftRequest() request.ParseFromString(data) activity_id = request.act_id quantity = request.quantity response = activity_pb2.GetActGiftResponse() response.res.result = False activity_conf = game_configs.activity_config.get(activity_id) if not activity_conf: logger.error('not found activity id:%s', activity_id) response.res.result_no = 183401 return response.SerializeToString() if not player.act.is_activiy_open(activity_id): logger.error('activity not open id:%s', activity_id) response.res.result_no = 183402 return response.SerializeToString() price = activity_conf.parameterA * activity_conf.parameterC[0] activity_consume = parse({107: [price, price, 29]}) for i in range(30): print player.finance[i] result = is_afford(player, activity_consume, multiple=quantity) if not result.get('result'): logger.error('activity not enough res:%s', price) response.res.result_no = 183403 return response.SerializeToString() consume_data = consume(player, activity_consume, const.act_28, multiple=quantity) get_return(player, consume_data, response.consume) return_data = gain(player, activity_conf.reward, const.act_28, multiple=quantity) get_return(player, return_data, response.gain) tlog_action.log('GodHeroExchange', player, activity_id, quantity) response.res.result = True return response.SerializeToString()
def check_can_rob(player, uid, chip_id, times, response): if is_not_open(player, FO_ROB_TREASURE): return False, 837, None player_ids = player.pvp.rob_treasure flag = 0 for player_id, ap in player_ids: if uid == player_id: flag = 1 break if not flag: logger.error('pvp_rob_treasure_864, uid error') return False, 8641, None chip_conf = game_configs.chip_config.get('chips', {}).get(chip_id, None) if not chip_conf: logger.error('pvp_rob_treasure_864, chip_id error') return False, 8642, None treasure_id = chip_conf.combineResult chips = game_configs.chip_config.get('map').get(treasure_id) can_rob = 0 for x in chips: chip = player.equipment_chip_component.get_chip(x) # 没有碎片 if chip and chip.chip_num >= 1: can_rob = 1 default_chips = game_configs.base_config.get('indianaDefaultId') if not can_rob and treasure_id not in default_chips: logger.error('pvp_rob_treasure_864, dont have one chip') return False, 8643, None price = game_configs.base_config.get('indianaConsume') is_afford_res = is_afford(player, price, multiple=times) # 校验 if not is_afford_res.get('result'): logger.error('rob_treasure_truce_841, item not enough') return False, 8644, None print chip_conf, '=====================================chip config' return True, 0, chip_conf
def rob_treasure_truce_859(data, player): """夺宝休战""" args = rob_treasure_pb2.RobTreasureTruceRequest() args.ParseFromString(data) num = args.num response = rob_treasure_pb2.RobTreasureTruceResponse() price = game_configs.base_config.get('indianaIteam') is_afford_res = is_afford(player, price, multiple=num) # 校验 if not is_afford_res.get('result'): logger.error('rob_treasure_truce_859, item not enough') response.res.result = False response.res.result_no = is_afford_res.get('result_no') return response.SerializeToString() truce_item_num_day = player.rob_treasure.truce_item_num_day use_truce_item_max = game_configs.vip_config. \ get(player.base_info.vip_level).indiana_TruceTime if (truce_item_num_day + num) > use_truce_item_max: logger.error('rob_treasure_truce_859, use item times not enough') response.res.result = False response.res.result_no = is_afford_res.get('result_no') return response.SerializeToString() use_num, use_time, use_num_day = player.rob_treasure.do_truce(num) return_data = consume(player, price, const.ROB_TREASURE_TRUCE, multiple=num) get_return(player, return_data, response.consume) player.rob_treasure.save_data() tlog_action.log('RobTreasureTruce', player, num, use_num_day) response.truce_item_num = use_num response.start_truce = use_time response.truce_item_num_day = use_num_day response.res.result = True return response.SerializeToString()
def do_hero_refine(player, hero_no, refine, response): if is_not_open(player, FO_REFINE): return {"result": False, "result_no": 837} hero = player.hero_component.get_hero(hero_no) _refine_item = game_configs.seal_config.get(refine) if not hero: logger.error('cant find hero:%s', hero_no) return {'result': False, 'result_no': 11801} if not _refine_item: logger.error('cant find refine item:%s', refine) return {'result': False, 'result_no': 11802} if _refine_item.get('heroLevelRestrictions') > hero.level: logger.error('refine player level is error:%s-%s', _refine_item.get('heroLevelRestrictions'), hero.level) return {'result': False, 'result_no': 11805} current_refine_item = game_configs.seal_config.get(hero.refine) if current_refine_item and _refine_item.id != current_refine_item.get('next'): logger.error('not next refine item:%s', refine) return {'result': False, 'result_no': 11803} result = is_afford(player, _refine_item.expend) # 校验 if not result.get('result'): logger.error('cant afford refine:%s:cur%s', _refine_item.expend, player.brew.nectar) return {'result': False, 'result_no': 11804} tlog_action.log('HeroRefine', player, hero_no, refine) return_data = consume(player, _refine_item.expend, const.HERO_REFINE) get_return(player, return_data, response.consume) hero.refine = refine player.brew.save_data() hero.save_data() return {'result': True}
def acc_mine_1250(data, player): """ 增产, 只有主矿能增产, 增产累计时长,ok """ request = mine_pb2.positionRequest() request.ParseFromString(data) response = mine_pb2.IncreaseResponse() detail_info = player.mine.detail_info(request.position) ret, stype, last_increase, limit, normal, lucky, lineup, guard_time = detail_info now = xtime.timestamp() main_mine = game_configs.mine_config.get(10001) if last_increase + main_mine.increasTime * 60 - now > main_mine.increasMaxTime * 60: response.res.result = True response.result_no = 12501 return response.SerializePartialToString() increasePrice = player.mine.price(request.position) price = CommonGroupItem(0, increasePrice, increasePrice, const.GOLD) result = item_group_helper.is_afford(player, [price]) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = result.get('result_no') response.res.message = u'消费不足!' return response.SerializePartialToString() else: response.res.result = True # print 'price', price need_gold = item_group_helper.get_consume_gold_num([price]) def func(): consume_return_data = item_group_helper.consume(player, [price], const.MINE_ACC) # 消耗 item_group_helper.get_return(player, consume_return_data, response.consume) player.pay.pay(need_gold, const.MINE_ACC, func) last_time = player.mine.acc_mine() player.mine.save_data() response.position = 0 response.last_time = int(last_time) return response.SerializePartialToString()
def rob_treasure_truce_859(data, player): """夺宝休战""" args = rob_treasure_pb2.RobTreasureTruceRequest() args.ParseFromString(data) num = args.num response = rob_treasure_pb2.RobTreasureTruceResponse() price = game_configs.base_config.get('indianaIteam') is_afford_res = is_afford(player, price, multiple=num) # 校验 if not is_afford_res.get('result'): logger.error('rob_treasure_truce_859, item not enough') response.res.result = False response.res.result_no = is_afford_res.get('result_no') return response.SerializeToString() truce_item_num_day = player.rob_treasure.truce_item_num_day use_truce_item_max = game_configs.vip_config. \ get(player.base_info.vip_level).indiana_TruceTime if (truce_item_num_day + num) > use_truce_item_max: logger.error('rob_treasure_truce_859, use item times not enough') response.res.result = False response.res.result_no = is_afford_res.get('result_no') return response.SerializeToString() use_num, use_time, use_num_day = player.rob_treasure.do_truce(num) return_data = consume(player, price, const.ROB_TREASURE_TRUCE, multiple=num) get_return(player, return_data, response.consume) player.rob_treasure.save_data() tlog_action.log('RobTreasureTruce', player, num, use_num_day) response.truce_item_num = use_num response.start_truce = use_time response.truce_item_num_day = use_num_day response.res.result = True return response.SerializeToString()
def reset_pvp_time_1506(data, player): request = pvp_rank_pb2.ResetPvpTime() request.ParseFromString(data) player.pvp.check_time() response = ShopResponse() response.res.result = True reset_times_max = player.base_info.buy_arena_times() if player.pvp.pvp_refresh_count + request.times > reset_times_max: logger.error('over arenatime could buy:%s+%s>%s', player.pvp.pvp_refresh_count, request.times, reset_times_max) response.res.result = False response.res.result_no = 15061 return response.SerializePartialToString() _consume = game_configs.base_config.get('arena_times_buy_price') result = is_afford(player, _consume) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = 1506 return response.SerializePartialToString() need_gold = get_consume_gold_num(_consume) * request.times def func(): return_data = consume(player, _consume, const.RESET_PVP_TIME, multiple=request.times) # 消耗 get_return(player, return_data, response.consume) player.pvp.pvp_times += request.times player.pvp.pvp_refresh_time = time.time() player.pvp.pvp_refresh_count += request.times player.pvp.save_data() player.pay.pay(need_gold, const.RESET_PVP_TIME, func) return response.SerializePartialToString()
def reset_pvp_time_1506(data, player): request = pvp_rank_pb2.ResetPvpTime() request.ParseFromString(data) player.pvp.check_time() response = ShopResponse() response.res.result = True vip_level = player.base_info.vip_level reset_times_max = game_configs.vip_config.get(vip_level).get('buyArenaTimes') if player.pvp.pvp_refresh_count + request.times > reset_times_max: logger.error('over arenatime could buy:%s+%s>%s', player.pvp.pvp_refresh_count, request.times, reset_times_max) response.res.result = False response.res.result_no = 15061 return response.SerializePartialToString() _consume = game_configs.base_config.get('arena_times_buy_price') result = is_afford(player, _consume) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = 1506 return response.SerializePartialToString() need_gold = get_consume_gold_num(_consume) * request.times def func(): return_data = consume(player, _consume, const.RESET_PVP_TIME, multiple=request.times) # 消耗 get_return(player, return_data, response.consume) player.pvp.pvp_times += request.times player.pvp.pvp_refresh_time = time.time() player.pvp.pvp_refresh_count += request.times player.pvp.save_data() player.pay.pay(need_gold, const.RESET_PVP_TIME, func) return response.SerializePartialToString()
def soul_shop_506(pro_data, player): """武魂商店""" request = SoulShopRequest() request.ParseFromString(pro_data) response = SoulShopResponse() common_response = response.res shop_id = request.id print "soul shop id:", shop_id shop_item = soul_shop_config.get(shop_id) result = is_afford(player, shop_item.consume) # 校验 if not result.get('result'): common_response.result = False common_response.result_no = result.get('result_no') common_response.message = u'消费不足!' consume_return_data = consume(player, shop_item.consume) # 消耗 return_data = gain(player, shop_item.gain) # 获取 # extra_return_data = gain(player, shop_item.extra_gain) # 额外获取 get_return(player, consume_return_data, response.consume) get_return(player, return_data, response.gain) # get_return(player, extra_return_data, response) try: player.soul_shop.item_ids.remove(shop_id) player.soul_shop.save_data() except Exception: logger.debug("can not find shop id:" + str(shop_id) + str(player.soul_shop.item_ids)) common_response.result = False common_response.result_no = 501 return response.SerializeToString() common_response.result = True return response.SerializeToString()
def shop_buy_505(pro_data, player): """商店""" request = shop_pb2.ShopRequest() request.ParseFromString(pro_data) response = shop_pb2.ShopResponse() common_response = response.res if len(request.ids) != len(request.item_count): shop_items = dict(zip(request.ids, [1] * len(request.ids))) else: shop_items = dict(zip(request.ids, request.item_count)) # shop_items = {} # shop_items[request.ids[0]] = 2 for shop_id, item_count in shop_items.items(): logger.info("shop id:%s", shop_id) shop_item = game_configs.shop_config.get(shop_id) if not shop_item: common_response.result = False common_response.result_no = 911 logger.error('error shop id:%s', shop_id) return response.SerializeToString() if shop_item.get('limitLevel') > player.base_info.level: common_response.result = False common_response.result_no = 50501 logger.error('shop item level limit:%s-%s', player.base_info.level, shop_item.get('limitLevel')) return response.SerializeToString() shop_type = shop_item.get('type') price = shop_item.consume if not shop_item.discountPrice else shop_item.discountPrice result = is_afford(player, price, multiple=item_count) # 校验 if not result.get('result'): logger.error('not enough money:%s', price) if not shop_item.alternativeConsume: common_response.result = False common_response.result_no = result.get('result_no') common_response.message = u'消费不足!' return response.SerializeToString() else: price = shop_item.alternativeConsume result = is_afford(player, price, multiple=item_count) if not result.get('result'): common_response.result = False common_response.result_no = result.get('result_no') common_response.message = u'消费不足2!' return response.SerializeToString() shop_type_item = game_configs.shop_type_config.get( shop_item.get('type')) need_gold = get_consume_gold_num(price, item_count) def func(): vip_level = player.base_info.vip_level guild_id = player.guild.g_id if shop_type in guild_shops: res = remote_gate['world'].guild_shop_buy_remote( guild_id, shop_id, item_count, shop_type, vip_level) shop = res.get('shop') else: shop = player.shop.get_shop_data(shop_type) g_id = player.guild.g_id build_level = 0 if g_id != 0: remote_res = remote_gate['world'].get_guild_info_remote( g_id, 'build', 0) if remote_res.get('result'): build_level = remote_res.get('build').get(3) res = do_shop_buy(shop_id, item_count, shop, vip_level, build_level) common_response.result = res.get('res') if res.get('no'): common_response.result_no = res.get('no') if not res.get('res'): raise ValueError("shop buy error!") return _lucky_attr = res.get('lucky_attr') consume_return_data = consume(player, price, get_reason(shop_item.get('type')), multiple=item_count, shop=shop, luck_config=shop_type_item) # 消耗 return_data = gain(player, shop_item.gain, get_reason(shop_item.get('type')), multiple=item_count, lucky_attr_id=_lucky_attr) # 获取 get_return(player, consume_return_data, response.consume) get_return(player, return_data, response.gain) if shop_item.ExchangeValue: lucky_data = gain(player, shop_item.ExchangeValue, get_reason(shop_item.get('type'))) get_return(player, lucky_data, response.gain) for _ in range(item_count): send_tlog(player, shop_item) logger.debug("allBuyRefresh %s" % shop_type_item.allBuyRefresh) need_refresh = 1 if shop_item.batch != -1: # for item_id in shop['item_ids']: for shop_item_id in shop['item_ids']: shop_item_conf = game_configs.shop_config.get(shop_item_id) buyed_num = shop['items'].get(shop_item_conf.id, 0) if shop_item_conf.batch == -1 or not buyed_num or buyed_num < shop_item_conf.batch: need_refresh = 0 break #if not shop['items'].get(shop_item_conf.id, 0): if need_refresh and shop_type_item.allBuyRefresh: logger.debug("shop auto refresh =============") player.shop.auto_refresh_items(shop_item.get('type')) response.is_all_buy = True player.pay.pay(need_gold, get_reason(shop_item.get('type')), func) player.shop.save_data() tlog_action.log('ShopBuy', player, str(request.ids), str(request.item_count)) return response.SerializeToString()
def shop_buy_505(pro_data, player): """商店""" request = shop_pb2.ShopRequest() request.ParseFromString(pro_data) response = shop_pb2.ShopResponse() common_response = response.res if len(request.ids) != len(request.item_count): shop_items = dict(zip(request.ids, [1] * len(request.ids))) else: shop_items = dict(zip(request.ids, request.item_count)) # shop_items = {} # shop_items[request.ids[0]] = 2 for shop_id, item_count in shop_items.items(): logger.info("shop id:%s", shop_id) shop_item = game_configs.shop_config.get(shop_id) if not shop_item: common_response.result = False common_response.result_no = 911 logger.error('error shop id:%s', shop_id) return response.SerializeToString() if shop_item.get('limitLevel') > player.base_info.level: common_response.result = False common_response.result_no = 50501 logger.error('shop item level limit:%s-%s', player.base_info.level, shop_item.get('limitLevel')) return response.SerializeToString() shop_type = shop_item.get('type') price = shop_item.consume if not shop_item.discountPrice else shop_item.discountPrice result = is_afford(player, price, multiple=item_count) # 校验 if not result.get('result'): logger.error('not enough money:%s', price) if not shop_item.alternativeConsume: common_response.result = False common_response.result_no = result.get('result_no') common_response.message = u'消费不足!' return response.SerializeToString() else: price = shop_item.alternativeConsume result = is_afford(player, price, multiple=item_count) if not result.get('result'): common_response.result = False common_response.result_no = result.get('result_no') common_response.message = u'消费不足2!' return response.SerializeToString() shop_type_item = game_configs.shop_type_config.get(shop_item.get( 'type')) need_gold = get_consume_gold_num(price, item_count) def func(): vip_level = player.base_info.vip_level guild_id = player.guild.g_id if shop_type in guild_shops: res = remote_gate['world'].guild_shop_buy_remote( guild_id, shop_id, item_count, shop_type, vip_level) shop = res.get('shop') else: shop = player.shop.get_shop_data(shop_type) g_id = player.guild.g_id build_level = 0 if g_id != 0: remote_res = remote_gate['world'].get_guild_info_remote( g_id, 'build', 0) if remote_res.get('result'): build_level = remote_res.get('build').get(3) res = do_shop_buy(shop_id, item_count, shop, vip_level, build_level) common_response.result = res.get('res') if res.get('no'): common_response.result_no = res.get('no') if not res.get('res'): raise ValueError("shop buy error!") return _lucky_attr = res.get('lucky_attr') consume_return_data = consume(player, price, get_reason(shop_item.get('type')), multiple=item_count, shop=shop, luck_config=shop_type_item) # 消耗 return_data = gain(player, shop_item.gain, get_reason(shop_item.get('type')), multiple=item_count, lucky_attr_id=_lucky_attr) # 获取 get_return(player, consume_return_data, response.consume) get_return(player, return_data, response.gain) if shop_item.ExchangeValue: lucky_data = gain(player, shop_item.ExchangeValue, get_reason(shop_item.get('type'))) get_return(player, lucky_data, response.gain) for _ in range(item_count): send_tlog(player, shop_item) logger.debug("allBuyRefresh %s" % shop_type_item.allBuyRefresh) need_refresh = 1 if shop_item.batch != -1: # for item_id in shop['item_ids']: for shop_item_id in shop['item_ids']: shop_item_conf = game_configs.shop_config.get(shop_item_id) buyed_num = shop['items'].get(shop_item_conf.id, 0) if shop_item_conf.batch == -1 or not buyed_num or buyed_num < shop_item_conf.batch: need_refresh = 0 break #if not shop['items'].get(shop_item_conf.id, 0): if need_refresh and shop_type_item.allBuyRefresh: logger.debug("shop auto refresh =============") player.shop.auto_refresh_items(shop_item.get('type')) response.is_all_buy = True player.pay.pay(need_gold, get_reason(shop_item.get('type')), func) player.shop.save_data() tlog_action.log('ShopBuy', player, str(request.ids), str(request.item_count)) return response.SerializeToString()
def stage_sweep(stage_id, times, player, sweep_type): response = stage_response_pb2.StageSweepResponse() res = response.res stage_obj = player.stage_component.get_stage(stage_id) # 关于关卡挑战次数 if time.localtime(player.stage_component.stage_up_time ).tm_yday != time.localtime().tm_yday: player.stage_component.stage_up_time = int(time.time()) player.stage_component.update_stage_times() player.stage_component.save_data() # vip等级够不够 if times == 1: if not game_configs.vip_config.get( player.base_info.vip_level).openSweep: logger.error('result_no = 803') res.result = False res.result_no = 803 return response.SerializePartialToString() if times > 1: if not game_configs.vip_config.get( player.base_info.vip_level).openSweepTen: logger.error('result_no = 803') res.result = False res.result_no = 803 return response.SerializePartialToString() # 关卡打开没有 state = player.stage_component.check_stage_state(stage_id) if state != 1: logger.error('result_no = 803') res.result = False res.result_no = 803 return response.SerializePartialToString() stage_config = game_configs.stage_config.get('stages').get(stage_id) # 限制次数够不够 if stage_obj.attacks + times > stage_config.limitTimes: logger.error('result_no = 810') res.result = False res.result_no = 810 return response.SerializePartialToString() # 花费 if sweep_type == 1: # 扫荡卷 sweep_item = game_configs.base_config.get('sweepNeedItem') elif sweep_type == 2: sweep_item = game_configs.base_config.get('price_sweep') else: logger.error('result_no = 800 ,sweep type error===========') res.result = False res.result_no = 800 return response.SerializePartialToString() result = is_afford(player, sweep_item, multiple=times) # 校验 if not result.get('result'): logger.error('result_no = 839 ,===========') res.result = False res.result_no = 839 return response.SerializePartialToString() need_gold = get_consume_gold_num(sweep_item, times) tlog_event_id = get_uuid() def func(): # 武将乱入 fight_cache_component = player.fight_cache_component fight_cache_component.stage_id = stage_id red_units, blue_units, drop_num, monster_unpara = fight_cache_component.fighting_start( ) multiple, part_multiple = get_drop_activity( player, player.fight_cache_component.stage_id, 1, stage_obj.star_num) for _ in range(times): drop = [] drops = response.drops.add() low = stage_config.low high = stage_config.high drop_num = random.randint(low, high) for __ in range(drop_num): common_bag = BigBag(stage_config.commonDrop) common_drop = common_bag.get_drop_items() drop.extend(common_drop) fight_cache_component.get_stage_drop(stage_config, drop) data = gain(player, drop, const.STAGE_SWEEP, event_id=tlog_event_id, multiple=multiple, part_multiple=part_multiple) get_return(player, data, drops) # 乱入武将按概率获取碎片 break_stage_id = player.fight_cache_component.break_stage_id if break_stage_id: break_stage_info = game_configs.stage_break_config.get( break_stage_id) ran = random.random() if ran <= break_stage_info.reward_odds: # logger.debug("break_stage_info=============%s %s" % (break_stage_info.reward, 1)) data = gain(player, break_stage_info.reward, const.STAGE_SWEEP) get_return(player, data, drops) player.finance.consume(const.STAMINA, stage_config.vigor, const.STAGE_SWEEP) # 经验 for (slot_no, lineUpSlotComponent ) in player.line_up_component.line_up_slots.items(): hero = lineUpSlotComponent.hero_slot.hero_obj if hero: beforelevel = hero.level hero.upgrade(stage_config.HeroExp, player.base_info.level) afterlevel = hero.level changelevel = afterlevel - beforelevel hero.save_data() if changelevel: tlog_action.log('HeroUpgrade', player, hero.hero_no, changelevel, afterlevel, 3, 0, 0, 0, 0) # 玩家金钱 player.finance.coin += stage_config.currency # 玩家经验 player.base_info.addexp(stage_config.playerExp, const.STAGE_SWEEP) # 更新等级相关属性 player.set_level_related() # hook task hook_task(player, CONDITIONId.ANY_STAGE, times) logger.debug("sweep time %s %s" % (times, sweep_item)) return_data = consume(player, sweep_item, const.STAGE_SWEEP, multiple=times) get_return(player, return_data, response.consume) player.stage_component.get_stage(stage_id).attacks += times player.stage_component.save_data() player.stamina.save_data() player.base_info.save_data() player.finance.save_data() player.pay.pay(need_gold, const.STAGE_SWEEP, func) # 触发黄巾起义 hjqy_stage_id = trigger_hjqy(player, result, times) response.hjqy_stage_id = hjqy_stage_id if hjqy_stage_id: tlog_action.log('TriggerHJQY', player, stage_id, hjqy_stage_id) res.result = True tlog_action.log('SweepFlow', player, stage_id, times, tlog_event_id) return response.SerializePartialToString()
def fight_settlement_904(pro_data, player): request = stage_request_pb2.StageSettlementRequest() request.ParseFromString(pro_data) logger.debug("fight_settlement_904 id: %s player_id: %s" % (player.fight_cache_component.stage_id, player.base_info.id)) stage_id = request.stage_id result = request.result always_win = request.always_win # logger.debug("steps:%s", request.steps) # player.fight_cache_component.red_units stage = player.stage_component.get_stage(stage_id) stage_config = player.fight_cache_component._get_stage_config() response = stage_response_pb2.StageSettlementResponse() res = response.res check_res = (True, 1, 1, -1, {}) if not always_win: if (stage_config.type not in [1, 2, 3] or stage.star_num != 3) and request.is_skip: logger.error( "can not be skip error!================= common stage") res.result = False res.result_no = 9041 return response.SerializePartialToString() if (stage_config.type == 4 or stage.state != 1) and request.is_skip: logger.error("can not be skip error!=================hide stage") res.result = False res.result_no = 9041 return response.SerializePartialToString() if request.is_skip and stage.state != 1: logger.error("can not be skip error!=================2") res.result = False res.result_no = 9041 return response.SerializePartialToString() if not request.is_skip: check_res = pve_process_check(player, result, request.steps, const.BATTLE_PVE) if not request.is_skip and not check_res[0]: logger.error("pve_process_check error!=================") os.system("cp output ..") res.result = False res.result_no = 9041 return response.SerializePartialToString() # 小伙伴支援消耗 fid = player.fight_cache_component.fid if fid: player.friends.check_time() friend_fight_times = player.friends.fight_times if fid not in friend_fight_times: friend_fight_times[fid] = [] supportPrice = game_configs.base_config.get('supportPrice') f_times = len(friend_fight_times[fid]) price = None for _ in sorted(supportPrice.keys()): if f_times >= _: price = supportPrice[_] # todo calculate real price if not is_afford(player, price).get('result'): logger.error('stage 903 not enough money!:%s', price) response.res.result = False response.res.result_no = 101 return response.SerializePartialToString() return_data = consume(player, price, const.STAGE) get_return(player, return_data, response.consume) friend_fight_times[fid].append(int(time.time())) player.friends.save_data() logger.debug("damage percent: %s" % check_res[1]) logger.debug("red units: %s" % check_res[2]) player.fight_cache_component.damage_percent = check_res[1] star = 0 # star num stage_info = player.fight_cache_component.stage_info red_units = stage_info.get('red_units') round_to_kill_num = check_res[4] red_left_num = check_res[3] red_left_hp_percent = check_res[2] death_num = len(red_units) - red_left_num for i in range(1, 4): star_condition = game_configs.base_config.get('star_condition') v = star_condition[i] if death_num >= v and red_left_num != 0: star = i break if request.is_skip: star = 3 stage = get_stage_by_stage_type(stage_config.type, stage_id, player) if stage_config.type == 6 and result: logger.debug("it is a elite stage!") conditions = stage_config.ClearanceConditions for k, cond in conditions.items(): logger.debug("k %s %s condi %s" % (k, type(k), cond)) if k == 1 and (cond[0] in round_to_kill_num and round_to_kill_num[cond[0]] < cond[1]): logger.debug("elite condition 1 is not met!") result = False break if k == 2 and (death_num > cond[0]): logger.debug("elite condition 2 is not met!") result = False break if k == 3 and (red_left_hp_percent < cond[0]): logger.debug("elite condition 3 is not met!") result = False break if always_win and stage_id in game_configs.stage_show_config: # 新手引导中的假战斗,必胜,三星 result = True star = 3 res = fight_settlement(stage, result, player, star, response) logger.debug("steps:%s", request.steps) logger.debug("fight_settlement_904 end: %s" % time.time()) return res
def do_brew(self, brew_type, response): vip_level = self.owner.base_info.vip_level brew_times_max = game_configs.vip_config.get(vip_level).get( 'cookingTimes') MAX_STEPS = len( game_configs.base_config.get('cookingWinePrice')[brew_type]) self.check_time() if self._brew_step > MAX_STEPS: return False if self.owner.base_info.level < game_configs.base_config.get( 'cookingWineOpenLevel'): logger.error('char brew level error!!:%s', self.owner.base_info.level) return False critical = game_configs.base_config.get('cookingWineOutputCrit') if brew_type not in critical: logger.error('base config error type:%s', brew_type) return False if self.brew_times >= brew_times_max: logger.error('there is no times to brew:%s', self.brew_times) return False brew_prices = game_configs.base_config.get('cookingWinePrice') if brew_type not in brew_prices: logger.error('base config error step:%s', brew_type) return False _consume = brew_prices[brew_type][self._brew_step - 1] result = is_afford(self.owner, _consume) # 校验 if not result.get('result'): logger.error('not enough gold to do brew:%s', _consume) return False need_gold = get_consume_gold_num(_consume) critical_type = critical[brew_type] def func(): return_data = consume(self.owner, _consume, const.DREW) get_return(self.owner, return_data, response.consume) self._brew_step += 1 rand = random.random() * sum(critical_type.values()) for critical_num, rand_range in critical_type.items(): if rand < rand_range: increment = critical_num * game_configs.base_config.get( 'cookingWineOutput') self._nectar_cur += int(increment) break else: rand -= rand_range logger.info( 'brew type:%s, rand:%s nectar:%s nectar\ cur:%s time:%s cri:%s', brew_type, rand, self.nectar, self._nectar_cur, self.brew_times, critical_num) self.save_data() self.owner.pay.pay(need_gold, const.DREW, func) return True
def travel_831(data, player): """游历""" args = TravelRequest() args.ParseFromString(data) stage_id = args.stage_id response = TravelResponse() if is_not_open(player, FO_TRAVEL): response.res.result = False response.res.result_no = 811 # 等级不够 return response.SerializeToString() # ====================判断够不够 need_items = game_configs.base_config.get('travelExpend') result = is_afford(player, need_items) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = 888 return response.SerializePartialToString() travel_cache = player.travel_component.travel travel_event_id = get_travel_event_id() flag = 10 if travel_cache.get(stage_id): for event in travel_cache.get(stage_id): if travel_event_id == event[0] % xs: flag += 1 else: travel_cache[stage_id] = [] res_travel_event_id = flag * xs + travel_event_id event_info = game_configs.travel_event_config.get('events').get( travel_event_id) if not event_info: logger.error('get travel event config error') response.res.result = False response.res.result_no = 800 # 未知错误 return response.SerializeToString() response.event_id = res_travel_event_id res_drops = response.drops drops = get_drops(stage_id) drop_data = get_drop_data(drops) get_return(player, drop_data, res_drops) # 等待 战斗 答题 领取 if event_info.type == 4: gain(player, drops, const.TRAVEL) else: travel_cache.get(stage_id).append([res_travel_event_id, drops]) # ====================消耗 return_data = consume(player, need_items, const.TRAVEL) get_return(player, return_data, response.consume) player.travel_component.save() hook_task(player, CONDITIONId.TRAVEL, 1) response.res.result = True return response.SerializeToString()
def shop_buy_505(pro_data, player): """商店""" request = ShopRequest() request.ParseFromString(pro_data) response = ShopResponse() common_response = response.res if len(request.ids) != len(request.item_count): shop_items = dict(zip(request.ids, [1]*len(request.ids))) else: shop_items = dict(zip(request.ids, request.item_count)) # shop_items = {} # shop_items[request.ids[0]] = 2 for shop_id, item_count in shop_items.items(): logger.info("shop id:%s", shop_id) shop_item = game_configs.shop_config.get(shop_id) if not shop_item: common_response.result = False common_response.result_no = 911 logger.error('error shop id:%s', shop_id) return response.SerializeToString() shop = player.shop.get_shop_data(shop_item.get('type')) price = shop_item.consume if not shop_item.discountPrice else shop_item.discountPrice result = is_afford(player, price, multiple=item_count) # 校验 if not result.get('result'): logger.error('not enough money:%s', price) if not shop_item.alternativeConsume: common_response.result = False common_response.result_no = result.get('result_no') common_response.message = u'消费不足!' return response.SerializeToString() else: price = shop_item.alternativeConsume result = is_afford(player, price, multiple=item_count) if not result.get('result'): common_response.result = False common_response.result_no = result.get('result_no') common_response.message = u'消费不足2!' return response.SerializeToString() if shop_item.limitVIP: limit_num = shop_item.limitVIP.get(player.base_info.vip_level, 0) shop_id_buyed_num = shop['vip_limit_items'].get(shop_id, 0) if shop_id_buyed_num + item_count > limit_num: logger.error("vip limit shop item:%s:%s limit:%s:%s", shop_id, item_count, shop_id_buyed_num, limit_num) common_response.result = False common_response.result_no = 502 response.limit_item_current_num = shop_id_buyed_num response.limit_item_max_num = limit_num return response.SerializeToString() shop['vip_limit_items'][shop_id] = shop_id_buyed_num + item_count if shop_item.limitVIPeveryday: limit_num = shop_item.limitVIPeveryday.get(player.base_info.vip_level, 0) shop_id_buyed_num = shop['limit_items'].get(shop_id, 0) if shop_id_buyed_num + item_count > limit_num: logger.error("limit shop item:%s:%s limit:%s:%s", shop_id, item_count, shop_id_buyed_num, limit_num) common_response.result = False common_response.result_no = 502 response.limit_item_current_num = shop_id_buyed_num response.limit_item_max_num = limit_num return response.SerializeToString() shop['limit_items'][shop_id] = shop_id_buyed_num + item_count if shop_item.batch == 1: if shop_id in shop['item_ids']: shop['item_ids'].remove(shop_id) shop['buyed_item_ids'].append(shop_id) else: logger.error("can not find shop id:%s:%s", shop_id, shop['item_ids']) common_response.result = False common_response.result_no = 501 return response.SerializeToString() shop_type_item = game_configs.shop_type_config.get(shop_item.get('type')) need_gold = get_consume_gold_num(price, item_count) _lucky_attr = 0 shop_item_attr = shop_item.get('attr') # print 'luck attr', shop_item_attr if shop_item_attr: lucky_keys = sorted(shop_item_attr.keys()) for k in lucky_keys: # print k, shop_item_attr[k] if shop['luck_num'] >= k: _lucky_attr = shop_item_attr[k] # print 'luck Num attr', shop['luck_num'], shop_item_attr[k], shop_item_attr else: break def func(): consume_return_data = consume(player, price, get_reason(shop_item.get('type')), multiple=item_count, shop=shop, luck_config=shop_type_item) # 消耗 return_data = gain(player, shop_item.gain, get_reason(shop_item.get('type')), multiple=item_count, lucky_attr_id=_lucky_attr) # 获取 get_return(player, consume_return_data, response.consume) get_return(player, return_data, response.gain) if shop_item.ExchangeValue: lucky_data = gain(player, shop_item.ExchangeValue, get_reason(shop_item.get('type'))) get_return(player, lucky_data, response.gain) for _ in range(item_count): send_tlog(player, shop_item) logger.debug("allBuyRefresh %s" % shop_type_item.allBuyRefresh) if not shop['item_ids'] and shop_type_item.allBuyRefresh: logger.debug("shop auto refresh =============") player.shop.auto_refresh_items(shop_item.get('type')) response.is_all_buy = True player.pay.pay(need_gold, get_reason(shop_item.get('type')), func) player.shop.save_data() common_response.result = True return response.SerializeToString()
def travel_831(data, player): """游历""" args = TravelRequest() args.ParseFromString(data) stage_id = args.stage_id response = TravelResponse() open_stage_id = game_configs.base_config.get('travelOpenStage') if player.stage_component.get_stage(open_stage_id).state != 1: response.res.result = False response.res.result_no = 837 return response.SerializeToString() if game_configs.base_config.get('travelOpenLevel') > player.base_info.level: response.res.result = False response.res.result_no = 811 # 等级不够 return response.SerializeToString() # ====================判断够不够 need_items = game_configs.base_config.get('travelExpend') result = is_afford(player, need_items) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = 888 return response.SerializePartialToString() travel_cache = player.travel_component.travel travel_event_id = get_travel_event_id() flag = 10 if travel_cache.get(stage_id): for event in travel_cache.get(stage_id): if travel_event_id == event[0] % xs: flag += 1 else: travel_cache[stage_id] = [] res_travel_event_id = flag * xs + travel_event_id event_info = game_configs.travel_event_config.get('events').get(travel_event_id) if not event_info: logger.error('get travel event config error') response.res.result = False response.res.result_no = 800 # 未知错误 return response.SerializeToString() response.event_id = res_travel_event_id res_drops = response.drops drops = get_drops(stage_id) drop_data = get_drop_data(drops) get_return(player, drop_data, res_drops) # 等待 战斗 答题 领取 if event_info.type == 4: gain(player, drops, const.TRAVEL) else: travel_cache.get(stage_id).append([res_travel_event_id, drops]) # ====================消耗 return_data = consume(player, need_items, const.TRAVEL) get_return(player, return_data, response.consume) player.travel_component.save() hook_task(player, CONDITIONId.TRAVEL, 1) response.res.result = True return response.SerializeToString()
def draw_1813(data, player): """draw""" args = LimitHeroDrawRequest() args.ParseFromString(data) response = LimitHeroDrawResponse() draw_type = args.draw_type need_gold = 0 draw_flag = 1 # 免费,积分,元宝 free_time_conf = game_configs.base_config.get('CardTimeLimitFreeCountdown') \ * 60 * 60 integral = int(rank_helper.get_value('LimitHeroRank', player.base_info.id)) activity_id = netforwarding.get_activity_id() if not activity_id: response.res.result = False response.res.result_no = 864 # logger.debug(response) return response.SerializeToString() player.limit_hero.update(activity_id) act_conf = game_configs.activity_config.get(activity_id) shop_id = game_configs.base_config.get('CardTimeActivityShop') shop_conf = game_configs.shop_config.get(shop_id[activity_id]) if draw_type == 1 and \ time.time() < free_time_conf + player.limit_hero.free_time: response.res.result = False response.res.result_no = 889 # logger.debug(response) return response.SerializeToString() elif draw_type == 2: # 元宝 need_integral = game_configs.base_config.get('CardTimeLimit') times = integral/need_integral-player.limit_hero.integral_draw_times if times: draw_flag = 2 else: result = is_afford(player, shop_conf.consume) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = 888 return response.SerializePartialToString() need_gold = get_consume_gold_num(shop_conf.consume) draw_flag = 3 def func(): not_luck_times = (player.limit_hero.draw_times+1) % \ game_configs.base_config.get('CardTimeCumulateTimes') if not_luck_times: pseudo_bag_id = act_conf.reward[0].item_no drop = do_get_draw_drop_bag(pseudo_bag_id, player.limit_hero.draw_times+1) else: drop = game_configs.base_config.get('CardTimeCumulate') return_data = gain(player, drop, const.LIMIT_HERO) get_return(player, return_data, response.gain) player.limit_hero.draw_times += 1 if draw_flag == 1: free_time = int(time.time()) player.limit_hero.free_time = free_time response.free_time = free_time elif draw_flag == 2: player.limit_hero.integral_draw_times += 1 # else: add_integral = shop_conf.Integral[0].num rank_integral = integral + add_integral + 1 - time.time()/10000000000 rank_helper.add_rank_info('LimitHeroRank', player.base_info.id, rank_integral) player.limit_hero.save_data() deal_response(player, response) player.pay.pay(need_gold, const.LIMIT_HERO, func) response.res.result = True # logger.debug(response) return response.SerializeToString()
def pvp_fight_request_1505(data, player): """ pvp战斗开始 """ request = pvp_rank_pb2.PvpFightRequest() response = pvp_rank_pb2.PvpFightResponse() request.ParseFromString(data) # player.pvp.check_time() if is_not_open(player, FO_PVP_RANK): response.res.result = False response.res.result_no = 837 return response.SerializePartialToString() arena_consume = game_configs.base_config.get('arenaConsume') result = is_afford(player, arena_consume) # 校验 if not result.get('result'): logger.error('not enough consume:%s', arena_consume) response.res.result = False response.res.result_no = 150501 return response.SerializePartialToString() # if player.pvp.pvp_times <= 0: # logger.error('not enough pvp times:%s-%s', player.pvp.pvp_times, # game_configs.base_config.get('arena_free_times')) # response.res.result = False # response.res.result_no = 836 # return response.SerializeToString() challenge_rank = request.challenge_rank if challenge_rank < 0 and player.pvp.pvp_upstage_challenge_rank != 0: challenge_rank = player.pvp.pvp_upstage_challenge_rank if challenge_rank < 0: logger.error('pvp challenge rank error!!%s-%s', challenge_rank, player.pvp.pvp_upstage_challenge_rank) response.res.result = False response.res.result_no = 839 return response.SerializeToString() line_up = request.lineup skill = request.skill target_id = int( tb_pvp_rank.zrangebyscore(challenge_rank, challenge_rank)[0]) if target_id != request.challenge_id: logger.error('pvp challenge id changed!!%s-%s', target_id, request.challenge_id) response.res.result = False response.res.result_no = 150508 return response.SerializeToString() before_player_rank = tb_pvp_rank.zscore(player.base_info.id) if not before_player_rank: before_player_rank = int(tb_pvp_rank.getObj('incr').incr()) tb_pvp_rank.zadd(before_player_rank, player.base_info.id) player.pvp.pvp_high_rank = before_player_rank elif before_player_rank != request.self_rank: logger.error('pvp self rank changed!!%s-%s', before_player_rank, request.self_rank) response.res.result = False response.res.result_no = 150509 return response.SerializeToString() before_player_rank = int(before_player_rank) if before_player_rank == challenge_rank: logger.error('cant not fight self') response.res.result = False response.res.result_no = 1505 return response.SerializeToString() return_data = consume(player, arena_consume, const.PVP) get_return(player, return_data, response.consume) fight_result = pvp_fight(player, target_id, line_up, skill, response) rank_incr = 0 response.top_rank = player.pvp.pvp_high_rank response.before_rank = before_player_rank if fight_result: logger.debug("fight result:True:%s:%s", before_player_rank, challenge_rank) _arena_win_points = game_configs.base_config.get('arena_win_points') if _arena_win_points: return_data = gain(player, _arena_win_points, const.ARENA_WIN) get_return(player, return_data, response.gain) else: logger.debug('arena win points is not find') push_config = game_configs.push_config[1003] rank_count = push_config.conditions[0] if challenge_rank - before_player_rank >= rank_count: txt = game_configs.push_config[1003].text message = game_configs.language_config.get(str(txt)).get('cn') remote_gate['push'].add_push_message_remote( player.base_info.id, 3, message, int(time.time())) push_message('add_blacklist_request_remote', target_id, player.base_info.id) if challenge_rank < before_player_rank: tb_pvp_rank.zadd(challenge_rank, player.base_info.id, before_player_rank, target_id) send_mail(conf_id=123, receive_id=target_id, pvp_rank=before_player_rank, nickname=player.base_info.base_name) if challenge_rank < player.pvp.pvp_high_rank: rank_incr = player.pvp.pvp_high_rank - challenge_rank if player.pvp.pvp_high_rank > challenge_rank: hook_task(player, CONDITIONId.PVP_RANK, challenge_rank) formula = game_configs.formula_config.get( "arenaRankUpRewardsValue").get("formula") gain_num = eval( formula, dict(upRank=challenge_rank, highestRank=player.pvp.pvp_high_rank)) # stage award stage_info_before = get_player_pvp_stage(player.pvp.pvp_high_rank) stage_info_current = get_player_pvp_stage(challenge_rank) before_gradient = stage_info_before.get('Gradient') current_gradient = stage_info_current.get('Gradient') if stage_info_current and stage_info_current \ and before_gradient > current_gradient: arena_stage_reward = stage_info_current.get('Reward') stage_reward_data = gain(player, arena_stage_reward, const.ARENA_WIN) get_return(player, stage_reward_data, response.award2) logger.debug('stage award %s %s', stage_info_current, stage_info_before) player.pvp.pvp_high_rank = min(player.pvp.pvp_high_rank, challenge_rank) logger.debug("history_high_rank %s current %s" % (player.pvp.pvp_high_rank, before_player_rank)) # 首次达到某名次的奖励 arena_rank_rewards = game_configs.base_config.get('arenaRankUpRewards') if arena_rank_rewards: return_data = gain(player, arena_rank_rewards, const.ARENA_WIN, multiple=int(gain_num)) get_return(player, return_data, response.award) else: logger.debug('arena rank up points is not find') else: logger.debug("fight result:False") send_mail(conf_id=124, receive_id=target_id, nickname=player.base_info.base_name) hook_task(player, CONDITIONId.PVP_RANk_TIMES, 1) player.pvp.pvp_times -= 1 player.pvp.pvp_refresh_time = time.time() player.pvp.save_data() response.res.result = True # response.top_rank = player.pvp.pvp_high_rank response.rank_incr = rank_incr logger.debug(response) return response.SerializeToString()
def make_runt_857(data, player): """合成宝石""" args = MakeRuntRequest() args.ParseFromString(data) runts = args.runt_no num = args.num print args, '==================================', num response = MakeRuntResponse() price = game_configs.base_config.get('stonesynthesis') is_afford_res = is_afford(player, price, multiple=num) # 校验 if num and not is_afford_res.get('result'): logger.error('make_runt_857, item not enough') response.res.result = False response.res.result_no = is_afford_res.get('result_no') return response.SerializeToString() if len(runts) < 5: logger.error('make_runt_857, rune count dont enough') response.res.result = False response.res.result_no = 800 return response.SerializeToString() runt_conf = None runt_ids = [0, 0, 0, 0, 0] flag = 0 for runt_no in runts: runt_info = player.runt.m_runt.get(runt_no) if not runt_info: logger.error('make_runt_857,runt no dont find,runt no:%s', runt_no) response.res.result = False response.res.result_no = 800 return response.SerializeToString() if not runt_conf: runt_conf = game_configs.stone_config.get('stones').get(runt_info[0]) if runt_conf.id != runt_info[0]: logger.error('make_runt_857, rune different types') response.res.result = False response.res.result_no = 800 return response.SerializeToString() runt_ids[flag] = runt_info[0] flag += 1 is_afford_res = is_afford(player, runt_conf.consume) # 校验 if num and not is_afford_res.get('result'): logger.error('make_runt_857, item not enough') response.res.result = False response.res.result_no = is_afford_res.get('result_no') return response.SerializeToString() for runt_no in runts: del player.runt.m_runt[runt_no] if num: consume(player, price, const.RUNT_MAKE, multiple=num) # 消耗 consume(player, runt_conf.consume, const.RUNT_MAKE) # 消耗 new_runt_no = 0 random_num = runt_conf.synthesis[0]+runt_conf.synthesis[1]*num if random.random() <= random_num: get_runt_id = runt_conf.synthesis[2] else: get_runt_id = runt_conf.id new_runt_no = player.runt.add_runt(get_runt_id) runt_info = player.runt.m_runt.get(new_runt_no) runt_pb = response.runt [runt_id, main_attr, minor_attr] = runt_info player.runt.deal_runt_pb(new_runt_no, runt_id, main_attr, minor_attr, runt_pb) tlog_action.log('MakeRunt', player, runt_ids[0], runt_ids[1], runt_ids[2], runt_ids[3], runt_ids[4], num, runt_id, new_runt_no) player.runt.save() # 7日活动 new_runt_conf = game_configs.stone_config.get('stones').get(get_runt_id) player.act.mine_mix_runt(new_runt_conf.quality) response.res.result = True return response.SerializeToString()
def shop_oper(pro_data, player, reason): """商城所有操作""" request = shop_pb2.ShopRequest() request.ParseFromString(pro_data) response = shop_pb2.ShopResponse() shop_id = request.ids[0] shop_item = game_configs.shop_config.get(shop_id) # logger.debug(shop_id) # logger.debug("---------") # if shop_id == 10001 and player.shop.first_coin_draw: # is_consume(player, shop_item) # card_draw = game_configs.base_config.get("CoinCardFirst") # return_data = gain(player, card_draw, reason) # 获取 # get_return(player, return_data, response.gain) # player.shop.single_coin_draw_times += 1 # player.shop.first_coin_draw = False # player.shop.save_data() # hook_task(player, CONDITIONId.HERO_GET_LIANG, 1) # response.res.result = True # return response.SerializeToString() if shop_id == 50001 and player.shop.first_gold_draw: is_consume(player, shop_item) card_draw = game_configs.base_config.get("CardFirst") return_data = gain(player, card_draw, reason) # 获取 get_return(player, return_data, response.gain) extra_return_data = gain(player, shop_item.extraGain, reason) # 额外获取 get_return(player, extra_return_data, response.gain) player.shop.first_gold_draw = False player.shop.single_gold_draw_times += 1 player.shop.save_data() hook_task(player, CONDITIONId.HERO_GET, 1) player.add_activity.add_pick_card(2, 1) player.act.add_pick_card(2, 1) response.res.result = True return response.SerializeToString() _is_consume_result = is_consume(player, shop_item) price = shop_item.consume if _is_consume_result: result = is_afford(player, price) # 校验 if not result.get('result'): if not shop_item.alternativeConsume: logger.error('shop oper is not enough consume') response.res.result = False response.res.result_no = result.get('result_no') response.res.message = u'消费不足!' return response.SerializeToString() else: price = shop_item.alternativeConsume result = is_afford(player, price) if not result.get('result'): response.res.result = False response.res.result_no = result.get('result_no') response.res.message = u'消费不足2!' return response.SerializeToString() player_type_shop = player.shop.get_shop_data(shop_item.get('type')) if not player_type_shop: response.res.result = False logger.error('no type shop:%s', shop_item.get('type')) return response.SerializeToString() shop_type_item = game_configs.shop_type_config.get(shop_item.get('type')) # 消耗 need_gold = get_consume_gold_num(price) if not _is_consume_result: need_gold = 0 def func(): # consume_data = [] if _is_consume_result: return_data = consume(player, price, reason, shop=player_type_shop, luck_config=shop_type_item) get_return(player, return_data, response.consume) # consume_data = return_data # logger.debug("hero-draw2") return_data = [] extra_return_data = [] CoinCardCumulateTimes = game_configs.base_config.get( "CoinCardCumulateTimes", 0) CardCumulateTimes = game_configs.base_config.get( "CardCumulateTimes", 0) if shop_item.type == 5: # todo: 如何判断shop类型:单抽、十连抽 # logger.debug("hero_draw: shop_item_id %s, item_no %s" % \ # (shop_item.id, shop_item.gain[0].item_no)) gain_items = player.shop.get_draw_drop_bag( shop_item.gain[0].item_no) if shop_item.id == 50001: # 单抽达到指定次数,获得指定武将 player.shop.single_gold_draw_times += 1 if player.shop.single_gold_draw_times == CardCumulateTimes: gain_items = game_configs.base_config.get( "CardCumulate", []) player.shop.single_gold_draw_times = 0 logger.debug( "tenth gold draw %s %s" % (player.shop.single_gold_draw_times, gain_items)) player.shop.save_data() return_data = gain(player, gain_items, reason) extra_return_data = gain(player, shop_item.extraGain, reason) # 额外获取 get_return(player, return_data, response.gain) get_return(player, extra_return_data, response.gain) if need_gold > 0 and shop_item.ExchangeValue: lucky_data = gain(player, shop_item.ExchangeValue, reason) get_return(player, lucky_data, response.gain) if shop_item.id == 50001: player.add_activity.add_pick_card(2, 1) player.act.add_pick_card(2, 1) hook_task(player, CONDITIONId.HERO_GET, 1) else: player.add_activity.add_pick_card(2, 10) player.act.add_pick_card(2, 10) hook_task(player, CONDITIONId.HERO_GET, 10) else: gain_items = shop_item.gain if shop_item.id == 10001: # 单抽达到指定次数,获得指定武将 player.shop.single_coin_draw_times += 1 if player.shop.single_coin_draw_times == CoinCardCumulateTimes: gain_items = game_configs.base_config.get( "CoinCardCumulate", []) player.shop.single_coin_draw_times = 0 logger.debug( "tenth coin draw %s %s" % (player.shop.single_coin_draw_times, gain_items)) player.shop.save_data() return_data = gain(player, gain_items, reason) # 获取 extra_return_data = gain(player, shop_item.extraGain, reason) # 额外获取 get_return(player, return_data, response.gain) get_return(player, extra_return_data, response.gain) if need_gold > 0 and shop_item.ExchangeValue: lucky_data = gain(player, shop_item.ExchangeValue, reason) get_return(player, lucky_data, response.gain) if shop_item.id == 10001: player.add_activity.add_pick_card(1, 1) player.act.add_pick_card(1, 1) hook_task(player, CONDITIONId.HERO_GET_LIANG, 1) else: player.add_activity.add_pick_card(1, 10) player.act.add_pick_card(1, 10) hook_task(player, CONDITIONId.HERO_GET_LIANG, 10) send_tlog(player, shop_item) tlog_action.log('ShopBuy1', player, shop_id) player.pay.pay(need_gold, reason, func) response.res.result = True logger.debug("response gain %s" % response.gain) return response.SerializeToString()
def do_hero_awake(player, hero_no, awake_item_num, response): """docstring for do_hero_awake""" if is_not_open(player, FO_HERO_AWAKE): return {'result': False, 'result_no': 837} hero = player.hero_component.get_hero(hero_no) if not hero: logger.error("hero not exist! hero_no %s" % hero_no) return {'result': False, 'result_no': 11901} awake_info = game_configs.awake_config.get(hero.awake_level) logger.debug("hero.awake_level %s, hero_no %s, awake_item_num %s" % (hero.awake_level, hero_no, awake_item_num)) singleConsumption = awake_info.singleConsumption logger.debug("singleConsumption %s" % singleConsumption) singleCoin = awake_info.silver if not is_afford(player, singleConsumption).get("result"): logger.error("singleConsumption is not afford!") return {'result': False, 'result_no': 11902} if not is_afford(player, singleCoin).get("result"): logger.error("singleCoin is not afford!") return {'result': False, 'result_no': 11903} if hero.awake_level >= 10: logger.error("the hero has reached the max awake level!") return {'result': False, 'result_no': 11904} singleConsumptionNum = singleConsumption[0].num left_awake_item = awake_item_num before_num = hero.awake_item_num while left_awake_item >= singleConsumptionNum: # consume if not is_afford(player, singleConsumption) or \ not is_afford(player, singleCoin): break return_data1 = consume(player, singleConsumption, const.HERO_AWAKE) return_data2 = consume(player, singleCoin, const.HERO_AWAKE) get_return(player, return_data1, response.consume) get_return(player, return_data2, response.consume) # record awake item num hero.awake_item_num += singleConsumptionNum # trigger or not, add exp, add level exp_percent = hero.awake_exp * 1.0 / awake_info.experience is_trigger = False for k in sorted(awake_info.triggerProbability.keys(), reverse=True): if exp_percent > k: v = awake_info.triggerProbability[k] target_percent = random.uniform(v[0], v[1]) if random.random() < target_percent: is_trigger = True break if is_trigger: # 触发满级概率 logger.debug("is_trigger!") hero.awake_exp = 0 hero.awake_level += 1 break else: logger.debug("not is_trigger!") hero.awake_exp += singleConsumptionNum if hero.awake_exp >= awake_info.experience: hero.awake_exp = hero.awake_exp - awake_info.experience hero.awake_level += 1 left_awake_item -= singleConsumptionNum # actual_consume_item_num = 0 hero.save_data() response.awake_level = hero.awake_level response.awake_exp = hero.awake_exp response.awake_item_num = hero.awake_item_num use_num = hero.awake_item_num - before_num tlog_action.log('HeroAwake', player, hero_no, use_num, hero.awake_level-1) return {'result': True}
def draw_1813(data, player): """draw""" args = LimitHeroDrawRequest() args.ParseFromString(data) response = LimitHeroDrawResponse() draw_type = args.draw_type need_gold = 0 draw_flag = 1 # 免费,积分,元宝 free_time_conf = game_configs.base_config.get('CardTimeLimitFreeCountdown') \ * 60 * 60 integral = int(rank_helper.get_value('LimitHeroRank', player.base_info.id)) activity_id = netforwarding.get_activity_id() if not activity_id: response.res.result = False response.res.result_no = 864 # logger.debug(response) return response.SerializeToString() player.limit_hero.update(activity_id) act_conf = game_configs.activity_config.get(activity_id) shop_id = game_configs.base_config.get('CardTimeActivityShop') shop_conf = game_configs.shop_config.get(shop_id[activity_id]) if draw_type == 1 and \ time.time() < free_time_conf + player.limit_hero.free_time: response.res.result = False response.res.result_no = 889 # logger.debug(response) return response.SerializeToString() elif draw_type == 2: # 元宝 need_integral = game_configs.base_config.get('CardTimeLimit') times = integral / need_integral - player.limit_hero.integral_draw_times if times: draw_flag = 2 else: result = is_afford(player, shop_conf.consume) # 校验 if not result.get('result'): response.res.result = False response.res.result_no = 888 return response.SerializePartialToString() need_gold = get_consume_gold_num(shop_conf.consume) draw_flag = 3 def func(): not_luck_times = (player.limit_hero.draw_times+1) % \ game_configs.base_config.get('CardTimeCumulateTimes') if not_luck_times: pseudo_bag_id = act_conf.reward[0].item_no drop = do_get_draw_drop_bag(pseudo_bag_id, player.limit_hero.draw_times + 1) else: drop = game_configs.base_config.get('CardTimeCumulate') return_data = gain(player, drop, const.LIMIT_HERO) get_return(player, return_data, response.gain) player.limit_hero.draw_times += 1 if draw_flag == 1: free_time = int(time.time()) player.limit_hero.free_time = free_time response.free_time = free_time elif draw_flag == 2: player.limit_hero.integral_draw_times += 1 # else: add_integral = shop_conf.Integral[0].num rank_integral = integral + add_integral + 1 - time.time() / 10000000000 rank_helper.add_rank_info('LimitHeroRank', player.base_info.id, rank_integral) player.limit_hero.save_data() deal_response(player, response) player.pay.pay(need_gold, const.LIMIT_HERO, func) response.res.result = True # logger.debug(response) return response.SerializeToString()
def shop_oper(pro_data, player, reason): """商城所有操作""" request = ShopRequest() request.ParseFromString(pro_data) response = ShopResponse() shop_id = request.ids[0] shop_item = game_configs.shop_config.get(shop_id) # logger.debug(shop_id) # logger.debug("---------") if shop_id == 10001 and player.shop.first_coin_draw: is_consume(player, shop_item) card_draw = game_configs.base_config.get("CoinCardFirst") return_data = gain(player, card_draw, reason) # 获取 get_return(player, return_data, response.gain) player.shop.single_coin_draw_times += 1 player.shop.first_coin_draw = False player.shop.save_data() hook_task(player, CONDITIONId.HERO_GET_LIANG, 1) response.res.result = True return response.SerializeToString() if shop_id == 50001 and player.shop.first_gold_draw: is_consume(player, shop_item) card_draw = game_configs.base_config.get("CardFirst") return_data = gain(player, card_draw, reason) # 获取 get_return(player, return_data, response.gain) player.shop.first_gold_draw = False player.shop.single_gold_draw_times += 1 player.shop.save_data() hook_task(player, CONDITIONId.HERO_GET, 1) response.res.result = True return response.SerializeToString() _is_consume_result = is_consume(player, shop_item) price = shop_item.consume if _is_consume_result: result = is_afford(player, price) # 校验 if not result.get('result'): if not shop_item.alternativeConsume: logger.error('shop oper is not enough consume') response.res.result = False response.res.result_no = result.get('result_no') response.res.message = u'消费不足!' return response.SerializeToString() else: price = shop_item.alternativeConsume result = is_afford(player, price) if not result.get('result'): response.res.result = False response.res.result_no = result.get('result_no') response.res.message = u'消费不足2!' return response.SerializeToString() player_type_shop = player.shop.get_shop_data(shop_item.get('type')) if not player_type_shop: response.res.result = False logger.error('no type shop:%s', shop_item.get('type')) return response.SerializeToString() shop_type_item = game_configs.shop_type_config.get(shop_item.get('type')) # 消耗 need_gold = get_consume_gold_num(price) if not _is_consume_result: need_gold = 0 def func(): # consume_data = [] if _is_consume_result: return_data = consume(player, price, player_type_shop, reason, shop_type_item) get_return(player, return_data, response.consume) # consume_data = return_data # logger.debug("hero-draw2") return_data = [] extra_return_data = [] CoinCardCumulateTimes = game_configs.base_config.get("CoinCardCumulateTimes", 0) CardCumulateTimes = game_configs.base_config.get("CardCumulateTimes", 0) if shop_item.type == 5: # todo: 如何判断shop类型:单抽、十连抽 # logger.debug("hero_draw: shop_item_id %s, item_no %s" % (shop_item.id, shop_item.gain[0].item_no)) gain_items = player.shop.get_draw_drop_bag(shop_item.gain[0].item_no) if shop_item.id == 50001: # 单抽达到指定次数,获得指定武将 player.shop.single_gold_draw_times += 1 if player.shop.single_gold_draw_times == CardCumulateTimes: gain_items = game_configs.base_config.get("CardCumulate", []) player.shop.single_gold_draw_times = 0 logger.debug("tenth gold draw %s %s" % (player.shop.single_gold_draw_times, gain_items)) player.shop.save_data() return_data = gain(player, gain_items, reason) extra_return_data = gain(player, shop_item.extraGain, reason) # 额外获取 get_return(player, return_data, response.gain) get_return(player, extra_return_data, response.gain) if need_gold > 0 and shop_item.ExchangeValue: lucky_data = gain(player, shop_item.ExchangeValue, reason) get_return(player, lucky_data, response.gain) if shop_item.id == 50001: hook_task(player, CONDITIONId.HERO_GET, 1) else: hook_task(player, CONDITIONId.HERO_GET, 10) else: gain_items = shop_item.gain if shop_item.id == 10001: # 单抽达到指定次数,获得指定武将 player.shop.single_coin_draw_times += 1 if player.shop.single_coin_draw_times == CoinCardCumulateTimes: gain_items = game_configs.base_config.get("CoinCardCumulate", []) player.shop.single_coin_draw_times = 0 logger.debug("tenth coin draw %s %s" % (player.shop.single_coin_draw_times, gain_items)) player.shop.save_data() return_data = gain(player, gain_items, reason) # 获取 extra_return_data = gain(player, shop_item.extraGain, reason) # 额外获取 get_return(player, return_data, response.gain) get_return(player, extra_return_data, response.gain) if need_gold > 0 and shop_item.ExchangeValue: lucky_data = gain(player, shop_item.ExchangeValue, reason) get_return(player, lucky_data, response.gain) if shop_item.id == 10001: hook_task(player, CONDITIONId.HERO_GET_LIANG, 1) else: hook_task(player, CONDITIONId.HERO_GET_LIANG, 10) send_tlog(player, shop_item) player.pay.pay(need_gold, reason, func) response.res.result = True logger.debug("response gain %s" % response.gain) return response.SerializeToString()
def do_brew(self, brew_type, response): vip_level = self.owner.base_info.vip_level brew_times_max = game_configs.vip_config.get(vip_level).get('cookingTimes') MAX_STEPS = len(game_configs.base_config.get('cookingWinePrice')[brew_type]) self.check_time() if self._brew_step > MAX_STEPS: return False if self.owner.base_info.level < game_configs.base_config.get('cookingWineOpenLevel'): logger.error('char brew level error!!:%s', self.owner.base_info.level) return False critical = game_configs.base_config.get('cookingWineOutputCrit') if brew_type not in critical: logger.error('base config error type:%s', brew_type) return False if self.brew_times >= brew_times_max: logger.error('there is no times to brew:%s', self.brew_times) return False brew_prices = game_configs.base_config.get('cookingWinePrice') if brew_type not in brew_prices: logger.error('base config error step:%s', brew_type) return False _consume = brew_prices[brew_type][self._brew_step - 1] result = is_afford(self.owner, _consume) # 校验 if not result.get('result'): logger.error('not enough gold to do brew:%s', _consume) return False need_gold = get_consume_gold_num(_consume) critical_type = critical[brew_type] def func(): return_data = consume(self.owner, _consume, const.DREW) get_return(self.owner, return_data, response.consume) self._brew_step += 1 rand = random.random()*sum(critical_type.values()) for critical_num, rand_range in critical_type.items(): if rand < rand_range: increment = critical_num * game_configs.base_config.get('cookingWineOutput') self._nectar_cur += int(increment) break else: rand -= rand_range logger.info('brew type:%s, rand:%s nectar:%s nectar\ cur:%s time:%s cri:%s', brew_type, rand, self.nectar, self._nectar_cur, self.brew_times, critical_num) self.save_data() self.owner.pay.pay(need_gold, const.DREW, func) return True