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():
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_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 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 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 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 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():
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 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()
