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