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 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 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 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 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()
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
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)
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 deal_pvp_rob_fight(player, uid, chip_id, one_times_response, chip_conf): price = game_configs.base_config.get('indianaConsume') return_data = consume(player, price, const.ROB_TREASURE) # 消耗 get_return(player, return_data, one_times_response.consume) fight_result = pvp_fight(player, uid, [], 0, one_times_response, is_copy_unit=True) logger.debug("fight revenge result:%s" % fight_result) indiana_conf = get_indiana_conf(player, uid, chip_conf) if fight_result: if indiana_conf.probability >= random.random(): gain_items = parse({104: [1, 1, chip_id]}) return_data = gain(player, gain_items, const.ROB_TREASURE) get_return(player, return_data, one_times_response.gain) # 处理被打玩家 deal_target_player(player, uid, chip_id) return fight_result
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 func(): consume_return_data = item_group_helper.consume(player, price, const.MINE_ACC) item_group_helper.get_return(player, consume_return_data, response.consume) response.res.result = player.mine.acc_mine_time(pos)
def func(): consume_return_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_return_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()
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
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()
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()
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 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 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 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()
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 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()
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 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 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 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 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()
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
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 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)
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)
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 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()