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 open_chest_836(data, player):
response = OpenChestResponse()
chest_time = player.travel_component.chest_time
if time.localtime(chest_time).tm_year == time.localtime().tm_year \
and time.localtime(chest_time).tm_yday == time.localtime().tm_yday:
response.res.result = False
response.res.result_no = 816
return response.SerializeToString()
res_drops = response.drops
drops = []
common_bag = BigBag(game_configs.base_config.get('travelChest'))
common_drop = common_bag.get_drop_items()
drops.extend(common_drop)
drop_data = gain(player, drops, const.TRAVEL_OPEN_CHEST)
get_return(player, drop_data, res_drops)
player.travel_component.chest_time = int(time.time())
player.travel_component.save()
response.res.result = True
return response.SerializeToString()
def travel_init_830(data, player):
"""init travel"""
response = TravelInitResponse()
for (stage_id, item) in player.travel_component.travel.items():
chapter = response.chapter.add()
chapter.stage_id = stage_id
for tra in item:
res_travel = chapter.travel.add()
res_travel.event_id = tra[0]
res_drops = res_travel.drops
drop_data = get_drop_data(tra[1])
get_return(player, drop_data, res_drops)
if game_configs.travel_event_config.get('events').get(tra[0]%xs).type == 1:
if len(tra) == 3:
res_travel.time = tra[2]
response.chest_time = player.travel_component.chest_time
player.travel_component.update_travel_item(response)
update_auto(player, 1)
deal_auto_response(response, player)
player.travel_component.save()
response.res.result = True
# logger.debug(response)
return response.SerializeToString()
def hero_sacrifice_105(data, player):
"""武将献祭"""
args = hero_request_pb2.HeroSacrificeRequest()
args.ParseFromString(data)
response = hero_response_pb2.HeroSacrificeResponse()
heros = player.hero_component.get_heros_by_nos(args.hero_nos)
if len(heros) == 0:
logger.error("hero %s is not exists." % str(args.hero_nos))
response = hero_sacrifice_oper(heros, player)
# remove hero
player.hero_component.delete_heros_by_nos(args.hero_nos)
# hero chip
for hero_chip in args.hero_chips:
sacrifice_gain = game_configs.chip_config.get("chips").get(hero_chip.hero_chip_no).sacrificeGain
return_data = gain(player,
sacrifice_gain,
const.HERO_CHIP_SACRIFICE_OPER,
multiple=hero_chip.hero_chip_num)
get_return(player, return_data, response.gain)
# remove hero_chip
temp = player.hero_chip_component.get_chip(hero_chip.hero_chip_no)
if temp:
temp.consume_chip(hero_chip.hero_chip_num) # 消耗碎片
player.hero_chip_component.save_data()
logger.debug(response)
return response.SerializeToString()
def get_fund_activity_1850(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_item = game_configs.activity_config.get(activity_id)
if act_item is None:
response.res.result_no = 185000
return response.SerializeToString()
info = get_act_info(player, activity_id)
if info.get('state') != 2:
response.res.result = False
logger.error("条件不满足")
response.res.result_no = 800
return response.SerializeToString()
return_data = gain(player,
act_item.reward,
const.FUND)
get_return(player, return_data, response.gain)
player.act.act_infos[activity_id][0] = 3
player.act.save_data()
response.res.result = True
return response.SerializeToString()
def sign_in_box_1404(pro_data, player):
"""签到宝箱领奖"""
request = SignInBoxRequest()
request.ParseFromString(pro_data)
_id = request.id
response = SignInResponse()
activity_info = game_configs.activity_config.get(_id)
# 验证宝箱签到, 是否领取
if _id in player.sign_in_component.box_sign_in_prize:
response.res.result = False
response.res.result_no = 1404
logger.debug(response)
return response.SerializePartialToString()
# 验证宝箱签到条件
for day in activity_info.parameterC:
if day not in player.sign_in_component.sign_in_days:
response.res.result = False
response.res.result_no = 1405
logger.debug(response)
return response.SerializePartialToString()
return_data = gain(player, activity_info.reward, const.BOX_SIGN)
get_return(player, return_data, response.gain)
player.sign_in_component.box_sign_in_prize.append(_id)
player.sign_in_component.save_data()
response.res.result = True
logger.debug(response)
return response.SerializePartialToString()
def load_to_game_response(rewards, response):
return_data = []
for data in rewards:
for k, v in data.items():
return_data.append([k, v[0], v[2]])
get_return(None, return_data, response)
def melting_equipment(equipment_id, response, player):
"""熔炼
@param dynamic_id:
@param equipment_ids:
@param kwargs:
@return:
"""
if is_not_open(player, FO_EQUIP_SACRIFICE):
return {"result": False, "result_no": 837}
equipment_obj = player.equipment_component.get_equipment(equipment_id)
if not equipment_obj:
return {'result': False, 'result_no': 401, 'message': u''}
melting_items = equipment_obj.melting_item
gain = item_group_helper.gain(player, melting_items, const.MELTING_EQUIPMENT)
item_group_helper.get_return(player, gain, response.cgr)
tlog_action.log('EquipmentMelting', player,
equipment_obj.base_info.equipment_no,
equipment_obj.base_info.id)
# 删除装备
player.equipment_component.delete_equipment(equipment_id)
# 添加强化金币
strength_coin = 0
for record in equipment_obj.enhance_record.enhance_record:
strength_coin += record[2]
strength_coin = int(strength_coin*game_configs.base_config.get("equRefundRatio"))
return strength_coin
def get_tomorrow_gift_1122(data, player):
response = online_gift_pb2.GetActivityResponse()
response.result = False
tomorrow_gift = game_configs.activity_config.get(15)[0]
if not tomorrow_gift:
logger.error('tomorrow gift is not exist')
return response.SerializeToString()
if not tomorrow_gift.get('is_open'):
logger.error('tomorrow gift is not open')
return response.SerializeToString()
if player.base_info.tomorrow_gift != 0:
logger.error('tomorrow gift is taken!')
return response.SerializeToString()
register_time = time.localtime(player.base_info.register_time)
now_time = time.localtime()
if now_time.tm_yday <= register_time.tm_yday and now_time.tm_year <= register_time.tm_year:
logger.error('tomorrow gift is miss!')
return response.SerializeToString()
player.base_info.tomorrow_gift = tomorrow_gift.id
player.base_info.save_data()
gain_data = tomorrow_gift['reward']
return_data = gain(player, gain_data, const.TOMORROW_GIFT)
get_return(player, return_data, response.gain)
response.result = True
return response.SerializeToString()
def awakening_equipment_406(pro_data, player):
"""熔炼装备
@param dynamic_id:
@param pro_data:
@return:
"""
request = equipment_request_pb2.AwakeningEquipmentRequest
request.ParseFromString()
equipment_id = request.id
data = awakening_equipment(equipment_id, player)
result = data.get('result')
response = equipment_response_pb2.MeltingEquipmentResponse()
res = response.res
if not result:
res.result_no = data.get('result_no')
res.message = data.get('message')
return response.SerializePartialToString()
player = data.get('player')
gain = data.get('gain', [])
item_group_helper.get_return(player, gain, response.cgr)
logger.debug(response)
return response.SerializePartialToString()
def melting_equipment(equipment_id, response, player):
"""熔炼
@param dynamic_id:
@param equipment_ids:
@param kwargs:
@return:
"""
equipment_obj = player.equipment_component.get_equipment(equipment_id)
if not equipment_obj:
return {'result': False, 'result_no': 401, 'message': u''}
melting_items = equipment_obj.melting_item
gain = item_group_helper.gain(player, melting_items, const.MELTING_EQUIPMENT)
item_group_helper.get_return(player, gain, response.cgr)
tlog_action.log('EquipmentMelting', player,
equipment_obj.base_info.equipment_no,
equipment_obj.base_info.id)
# 删除装备
player.equipment_component.delete_equipment(equipment_id)
# 添加强化金币
strength_coin = 0
for record in equipment_obj.enhance_record.enhance_record:
strength_coin += record[2]
strength_coin = int(strength_coin*game_configs.base_config.get("equRefundRatio"))
player.finance.coin += strength_coin
player.finance.save_data()
response.cgr.finance.coin += strength_coin
change = response.cgr.finance.finance_changes.add()
change.item_type = 107
change.item_num = strength_coin
change.item_no = 1
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 func():
player.sign_in_component.sign_in(day)
player.sign_in_component.save_data()
sign_round = player.sign_in_component.sign_round
print game_configs.sign_in_config.get(sign_round), "---------"
print game_configs.sign_in_config.get(sign_round).get(day), "-------"
if not game_configs.sign_in_config.get(sign_round) or not game_configs.sign_in_config.get(sign_round).get(day):
return
sign_in_info = game_configs.sign_in_config.get(sign_round).get(day)
#vip双倍
if player.base_info.vip_level > 0 and \
sign_in_info.get("vipDouble") and \
player.base_info.vip_level >= sign_in_info.get("vipDouble"):
is_double = 1
else:
is_double = 0
if is_double:
return_data = gain(player, sign_in_info.get("reward"), const.REPAIR_SIGN, multiple=2)
get_return(player, return_data, response.gain)
else:
return_data = gain(player, sign_in_info.get("reward"), const.REPAIR_SIGN)
get_return(player, return_data, response.gain)
player.sign_in_component.repair_sign_in_times += 1
player.sign_in_component.save_data()
tlog_action.log('RepairSignIn', player, day, len(player.sign_in_component.sign_in_days), sign_in_info.get("id"))
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 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 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():
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)
def continus_sign_in_1402(pro_data, player):
"""累积签到"""
request = ContinuousSignInRequest()
request.ParseFromString(pro_data)
days = request.sign_in_days
response = ContinuousSignInResponse()
# 验证连续签到日期
if len(player.sign_in_component.sign_in_days) < days:
response.res.result = False
response.res.result_no = 1402
return response.SerializePartialToString()
if days in player.sign_in_component.continuous_sign_in_prize:
response.res.result = False
response.res.result_no = 1403
return response.SerializePartialToString()
player.sign_in_component.continuous_sign_in_prize.append(days)
player.sign_in_component.save_data()
reward, config_id = player.sign_in_component.get_sign_in_reward(days)
if not reward:
response.res.result = False
response.res.result_no = 1404
return response.SerializePartialToString()
return_data = gain(player, reward, const.CONTINUS_SIGN)
get_return(player, return_data, response.gain)
tlog_action.log('ContinusSignIn', player, days, config_id)
response.res.result = True
logger.debug(response)
return response.SerializePartialToString()
def get_level_gift_1131(data, player):
"""get online gift"""
request = level_gift_pb2.GetLevelGift()
request.ParseFromString(data)
response = level_gift_pb2.GetLevelGiftResponse()
activity_level_gift = game_configs.activity_config.get(3)
if request.gift_id in player.level_gift.received_gift_ids:
response.result = False
return response.SerializeToString()
for a in activity_level_gift:
if request.gift_id == a['id']:
gain_data = a['reward']
return_data = gain(player, gain_data, const.LEVEL_GIFT)
get_return(player, return_data, response.gain)
player.level_gift.received_gift_ids.append(request.gift_id)
player.level_gift.save_data()
tlog_action.log('LevelGift', player, request.gift_id)
response.result = True
return response.SerializeToString()
response.result = False
return response.SerializeToString()
def recharge_gain(self, recharge_item, response, is_tencent=False):
"""
充值掉落
"""
logger.debug("recharge_gain========1")
isfirst = 0
if not is_tencent:
return_data = gain(self._owner, recharge_item.get('setting'),
const.RECHARGE) # 获取
get_return(self._owner, return_data, response.gain)
if recharge_item.get('type') == 2:
logger.debug("recharge_gain========")
rebate_call(self._owner, recharge_item)
self._owner.recharge.send_mail(recharge_item) #发送奖励邮件
else:
rres = self._owner.base_info.first_recharge(recharge_item, response)
if rres:
#首次充值
isfirst = 1
self._owner.recharge.send_mail(recharge_item) #发送奖励邮件
tlog_action.log('Recharge', self._owner, isfirst,
recharge_item.get('id'))
charge_num = recharge_item.get('activity') # 充值元宝数量
# vip
self._owner.base_info.recharge += charge_num
self._owner.base_info.set_vip_level(self._owner.base_info.recharge)
# 活动
self._owner.recharge.charge(charge_num)
if not is_tencent:
self._owner.recharge.get_recharge_response(response.info) # recharge
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 use_item_302(pro_data, player):
"""使用道具"""
item_pb = item_pb2.ItemPB()
item_pb.ParseFromString(pro_data)
item_no = item_pb.item_no
item_num = item_pb.item_num
print("request:", item_pb)
item_config_item = game_configs.item_config.get(item_no)
if not item_config_item:
return
item_func = item_config_item.func
drop_id = item_config_item.dropId
func_args1 = item_config_item.funcArg1
func_args2 = item_config_item.funcArg2
response = ItemUseResponse()
common_response = response.res # = common_response
common_response.result = True
# 校验道具数量
item = player.item_package.get_item(item_no)
if not item or item.num < item_num:
common_response.result = False
common_response.result_no = 106
print("error:", 106)
# common_response.message = u"道具不足！"
return response.SerializeToString()
if item_func == 2:
# 宝箱
box_key_no = func_args1
box_key = player.item_package.get_item(box_key_no)
if not box_key or box_key.num < func_args2 * item_num:
print("error:", 107)
common_response.result = False
common_response.result_no = 107
# common_response.message = u"box key 不足！" + str(func_args2 * item_num) + "_" + str(box_key.num)
return response.SerializeToString()
# 消耗key
#box_key.num -= func_args2 * item_num
player.item_package.consume_item(box_key_no, item_num)
player.item_package.save_data()
big_bag = BigBag(drop_id)
for i in range(item_num):
drop_item_group = big_bag.get_drop_items()
return_data = gain(player, drop_item_group, const.USE_ITEM)
get_return(player, return_data, response.gain)
logger.debug("item_no:%s", item_no)
logger.debug("item_num:%s", item_num)
# 使用招财符
if item_config_item.canUse == 11:
player.buy_coin.extra_can_buy_times += item_num
player.item_package.consume_item(item_no, item_num)
return response.SerializeToString()
def get_21_gift(player, act_conf, response): # 通关关卡
if player.stage_component.get_stage(act_conf.parameterA).state != 1:
response.res.result_no = 800
return 0
gain_data = act_conf.reward
return_data = gain(player, gain_data, const.ACT21)
get_return(player, return_data, response.gain)
return 1
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 get_20_gift(player, act_conf, response): # 战力
# if act_conf.parameterA > player.line_up_component.combat_power:
if act_conf.parameterA > player.line_up_component.hight_power:
response.res.result_no = 802
return 0
gain_data = act_conf.reward
return_data = gain(player, gain_data, const.ACT20)
get_return(player, return_data, response.gain)
return 1
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 = 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
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 add_items(player, response, drop_ids):
""" 添加道具给玩家 """
for drop_id in drop_ids:
big_bag = BigBag(drop_id)
drop_item_group = big_bag.get_drop_items()
return_data = item_group_helper.gain(player,
drop_item_group,
const.MINE_REWARD)
item_group_helper.get_return(player, return_data, response.gain)
return response
def hero_sacrifice_oper(heros, player):
"""
武将献祭，返回总武魂、经验药水
:param heros: 被献祭的武将
:return total_hero_soul:总武魂数量, exp_item_no:经验药水编号, exp_item_num:经验药水数量
"""
total_exp = 0
exp_item_no = 0
exp_item_num = 0
response = hero_response_pb2.HeroSacrificeResponse()
gain_response = response.gain
for hero in heros:
sacrifice_gain = game_configs.hero_config.get(hero.hero_no).sacrificeGain
return_data = gain(player, sacrifice_gain, const.HERO_SACRIFICE_OPER)
get_return(player, return_data, gain_response)
# 经验
exp = hero.get_all_exp()
total_exp += exp
tlog_action.log('HeroSacrifice', player, hero.hero_no)
# baseconfig {1000000: 'item_id'}
exp_items = game_configs.base_config.get("sacrificeGainExp")
keys = []
try:
keys = sorted([int(item) for item in list(exp_items)], reverse=True)
except Exception:
logger.error("base_config sacrificeGainExp key must be int type:%s.",
str(exp_items))
return
for exp in keys:
item_no = exp_items.get(exp)
config = game_configs.item_config.get(item_no)
exp = config.get("funcArg1")
if total_exp/exp > 0:
exp_item_no = item_no
exp_item_num = total_exp/exp
break
player.item_package.add_item(Item(exp_item_no, exp_item_num))
player.item_package.save_data()
if exp_item_no:
item_pb = gain_response.items.add()
item_pb.item_no = exp_item_no
item_pb.item_num = exp_item_num
response.res.result = True
# print "*"*80
# print response
return response
def hero_sell_107(data, player):
"""武将出售"""
args = hero_request_pb2.HeroSellRequest()
args.ParseFromString(data)
hero_nos = args.hero_nos
response = hero_response_pb2.HeroSellResponse()
for hero_no in hero_nos:
sell_gain = game_configs.hero_config.get(hero_no).sellGain
return_data = gain(player, sell_gain)
get_return(player, return_data, response.gain)
response.res.result = True
return response
def hero_sacrifice_oper(heros, player):
"""
武将献祭，返回总武魂、经验药水
:param heros: 被献祭的武将
:return total_hero_soul:总武魂数量, exp_item_no:经验药水编号, exp_item_num:经验药水数量
"""
total_exp = 0
exp_item_no = 0
exp_item_num = 0
response = hero_response_pb2.HeroSacrificeResponse()
gain_response = response.gain
for hero in heros:
sacrifice_gain = game_configs.hero_config.get(
hero.hero_no).sacrificeGain
return_data = gain(player, sacrifice_gain)
get_return(player, return_data, gain_response)
# 经验
exp = hero.get_all_exp()
total_exp += exp
# baseconfig {1000000: 'item_id'}
exp_items = game_configs.base_config.get("sacrificeGainExp")
keys = []
try:
keys = sorted([int(item) for item in list(exp_items)], reverse=True)
except Exception:
logger.error("base_config sacrificeGainExp key must be int type:%s.",
str(exp_items))
return
for exp in keys:
item_no = exp_items.get(exp)
config = game_configs.item_config.get(item_no)
exp = config.get("funcArg1")
if total_exp / exp > 0:
exp_item_no = item_no
exp_item_num = total_exp / exp
break
player.item_package.add_item(Item(exp_item_no, exp_item_num))
player.item_package.save_data()
item_pb = gain_response.items.add()
item_pb.item_no = exp_item_no
item_pb.item_num = exp_item_num
response.res.result = True
return response
def get_reward(self, act_id, response):
"""docstring for get_reward"""
act_item = game_configs.activity_config.get(act_id)
act_info = self._act_info[act_id]
if act_info.get("act_times") < int(act_item.parameterA):
logger.error("activity times not enough!")
return dict(result=False, result_no=250101)
if act_info.get("finished"):
logger.error("activity has finished!")
return dict(result=False, result_no=250102)
act_info["finished"] = True
data = gain(self._owner, act_item.reward, const.GUILD_ACTIVITY)
get_return(self._owner, data, response.gain)
self.save_data()
return dict(result=True)
def PvpOvercomAward_1510(data, player):
request = pvp_rank_pb2.PvpOvercomeAwardRequest()
request.ParseFromString(data)
player.pvp.check_time()
response = pvp_rank_pb2.PvpOvercomeAwardResponse()
ggzj_item = game_configs.ggzj_config.get(request.index)
if not ggzj_item:
logger.error('ggzj config id err:%s', request.index)
response.res.result = False
response.res.result_no = 151001
return response.SerializePartialToString()
if ggzj_item.get('section') > player.pvp.pvp_overcome_current:
logger.error('ggzj award id err:%s(%s-%s)', request.index,
ggzj_item.get('section'), player.pvp.pvp_overcome_current)
response.res.result = False
response.res.result_no = 151002
return response.SerializePartialToString()
if request.index in player.pvp.pvp_overcome_awards:
logger.error('ggzj award id repeat:%s-%s', request.index,
player.pvp.pvp_overcome_awards)
response.res.result = False
response.res.result_no = 151003
return response.SerializePartialToString()
award = ggzj_item.get('database')
if not award:
logger.error('ggzj database is null:%s', request.index)
response.res.result = False
response.res.result_no = 151004
return response.SerializePartialToString()
logger.info('ggzj take award %s %s', request.index,
ggzj_item.get('database'))
return_data = gain(player, award, const.PVP_OVERCOME)
get_return(player, return_data, response.gain)
player.pvp.pvp_overcome_awards.append(request.index)
player.pvp.save_data()
tlog_action.log('OvercomeAward', player, request.index)
response.res.result = True
return response.SerializePartialToString()
def recharge_gain(self,
recharge_item,
response,
channel,
is_tencent=False):
"""
充值掉落
"""
logger.debug("recharge_gain========1")
isfirst = 0
if not is_tencent:
return_data = gain(self._owner, recharge_item.get('setting'),
const.RECHARGE) # 获取
get_return(self._owner, return_data, response.gain)
if recharge_item.get('type') == 2:
logger.debug("recharge_gain========")
rebate_call(self._owner, recharge_item)
self._owner.recharge.send_mail(recharge_item) # 发送奖励邮件
else:
rres = self._owner.base_info.first_recharge(recharge_item,
response)
if rres:
# 首次充值
isfirst = 1
self._owner.recharge.send_mail(recharge_item) # 发送奖励邮件
tlog_action.log('Recharge', self._owner, isfirst,
recharge_item.get('id'), channel)
charge_num = recharge_item.get('activity') # 充值元宝数量
# vip
self._owner.base_info.recharge += charge_num
self._owner.base_info.max_single_recharge = max(
charge_num, self._owner.base_info.max_single_recharge)
self._owner.base_info.set_vip_level(self._owner.base_info.recharge)
self._owner.act.condition_add(44, charge_num)
# 更新 七日奖励
target_update(self.owner, [44])
# 活动
self._owner.recharge.charge(charge_num)
if not is_tencent:
self._owner.recharge.get_recharge_response(
response.info) # recharge
def pvb_get_award_1708(data, player):
response = PvbAwardResponse()
boss = player.world_boss.get_boss("world_boss")
award_type, award, rank_no, is_over = boss.get_award()
player.world_boss.save_data()
logger.debug("award_type %s, award %s, is_over %s" %
(award_type, award, is_over))
response.is_over = is_over
if not award:
response.SerializePartialToString()
response.award_type = award_type # award_type
if award_type == const.PVB_IN_AWARD:
total_coin = 0
total_soul = 0
for demage_hp in award:
all_vars = dict(damage=demage_hp)
coin_world_boss_formula = game_configs.formula_config.get(
"coinWorldboss").get("formula")
assert coin_world_boss_formula != None, "isHit formula can not be None!"
coin = eval(coin_world_boss_formula, all_vars)
soul_world_boss_formula = game_configs.formula_config.get(
"soulWorldboss").get("formula")
assert soul_world_boss_formula != None, "isHit formula can not be None!"
soul = eval(soul_world_boss_formula, all_vars)
total_coin += int(coin)
total_soul += int(soul)
print("coin and soul", coin, soul)
change = response.gain.finance.finance_changes.add()
change.item_type = 107
change.item_num = int(total_coin)
change.item_no = const.COIN
change = response.gain.finance.finance_changes.add()
change.item_type = 107
change.item_num = int(total_soul)
change.item_no = const.HERO_SOUL
elif award_type != 0:
bigbag = BigBag(award)
drop_items = bigbag.get_drop_items()
return_data = gain(player, drop_items, const.WORLD_BOSS_AWARD)
get_return(player, return_data, response.gain)
#response.rank_no = remote_gate['world'].get_rank_no_remote(player.base_info.id, "world_boss")
response.rank_no = rank_no
logger.debug("pvb_get_award_1708:%s" % response)
return response.SerializePartialToString()
def hero_break_logic(hero_no, player, response):
if is_not_open(player, FO_HERO_BREAK):
return {'result': False, 'result_no': 837}
hero = player.hero_component.get_hero(hero_no)
hero_info = game_configs.hero_config.get(hero_no)
break_through = game_configs.base_config.get('breakthrough')
target_break_level = hero.break_level + 1
logger.debug("target_break_level %s" % target_break_level)
if target_break_level not in break_through:
logger.debug("hero_break_logic can find target break level %s" % target_break_level)
return {"result": False, "result_no": 10401}
if hero.level < break_through[target_break_level][0]:
logger.debug("hero_break_logic level is not enough %s" % hero.level)
return {"result": False, "result_no": 10402}
# 验证武将是否突破到上限
if hero.break_level == hero_info.breakLimit:
return {"result": False, "result_no": 201}
consume_info = hero_info.get('consume' + str(hero.break_level+1))
item_group = parse(consume_info)
hero_info = game_configs.hero_config.get(hero.hero_no)
# 判断是否足够
result = is_afford(player, item_group) # 校验
if not result.get('result'):
return {"result": False, "result_no": result.get('result_no')}
# 返回消耗
return_data = consume(player, item_group, const.HERO_BREAK)
get_return(player, return_data, response.consume)
for item in item_group:
if item.item_type == 105 and item.item_no == 20006:
hero.break_item_num += item.num
hero.save_data()
hero.break_level += 1
notice_item = game_configs.notes_config.get(2003)
if hero.break_level in notice_item.parameter1:
push_notice(2003, player_name=player.base_info.base_name, hero_no=hero.hero_no, hero_break_level=hero.break_level)
hero.save_data()
# 3、返回
tlog_action.log('HeroBreak', player, hero_no, hero.break_level)
return {"result": True, "break_level": hero.break_level, "break_item_num": hero.break_item_num}
def shop_equipment_oper(pro_data, player):
"""装备抽取"""
request = shop_pb2.ShopRequest()
request.ParseFromString(pro_data)
response = shop_pb2.ShopResponse()
shop_id = request.ids[0]
shop_num = request.num
shop_item = game_configs.shop_config.get(shop_id)
if shop_num == 1: # and not is_consume(player, shop_item):
# 免费抽取
return_data = gain(player, shop_item.gain,
const.SHOP_DRAW_EQUIPMENT) # 获取
extra_return_data = gain(player, shop_item.extraGain,
const.SHOP_DRAW_EQUIPMENT) # 额外获取
get_return(player, return_data, response.gain)
get_return(player, extra_return_data, response.gain)
# 多装备抽取
elif shop_num >= 1:
for i in range(shop_num):
result = is_afford(player, shop_item.consume) # 校验
if not result.get('result'):
response.res.result = False
response.res.result_no = 101
return response.SerializePartialToString()
for i in range(shop_num):
return_data = consume(player, shop_item.consume,
const.SHOP_DRAW_EQUIPMENT) # 消耗
get_return(player, return_data, response.consume)
for i in range(shop_num):
return_data = gain(player, shop_item.gain,
const.SHOP_DRAW_EQUIPMENT) # 获取
extra_return_data = gain(player, shop_item.extraGain,
const.SHOP_DRAW_EQUIPMENT) # 额外获取
get_return(player, return_data, response.gain)
get_return(player, extra_return_data, response.gain)
response.res.result = True
return response.SerializeToString()
def get_activity_28_gift_1834(data, player):
request = activity_pb2.GetActGiftRequest()
request.ParseFromString(data)
activity_id = request.act_id
quantity = request.quantity
response = activity_pb2.GetActGiftResponse()
response.res.result = False
activity_conf = game_configs.activity_config.get(activity_id)
if not activity_conf:
logger.error('not found activity id:%s', activity_id)
response.res.result_no = 183401
return response.SerializeToString()
if not player.act.is_activiy_open(activity_id):
logger.error('activity not open id:%s', activity_id)
response.res.result_no = 183402
return response.SerializeToString()
price = activity_conf.parameterA * activity_conf.parameterC[0]
activity_consume = parse({107: [price, price, 29]})
for i in range(30):
print player.finance[i]
result = is_afford(player, activity_consume, multiple=quantity)
if not result.get('result'):
logger.error('activity not enough res:%s', price)
response.res.result_no = 183403
return response.SerializeToString()
consume_data = consume(player,
activity_consume,
const.act_28,
multiple=quantity)
get_return(player, consume_data, response.consume)
return_data = gain(player,
activity_conf.reward,
const.act_28,
multiple=quantity)
get_return(player, return_data, response.gain)
tlog_action.log('GodHeroExchange', player, activity_id, quantity)
response.res.result = True
return response.SerializeToString()
def func():
return_data = consume(self.owner, _consume, const.DREW)
get_return(self.owner, return_data, response.consume)
self._brew_step += 1
rand = random.random() * sum(critical_type.values())
for critical_num, rand_range in critical_type.items():
if rand < rand_range:
increment = critical_num * game_configs.base_config.get(
'cookingWineOutput')
self._nectar_cur += int(increment)
break
else:
rand -= rand_range
logger.info(
'brew type:%s, rand:%s nectar:%s nectar\
cur:%s time:%s cri:%s', brew_type, rand, self.nectar, self._nectar_cur,
self.brew_times, critical_num)
self.save_data()
def sign_in_box_1404(pro_data, player):
"""签到宝箱领奖"""
request = SignInBoxRequest()
request.ParseFromString(pro_data)
_id = request.id
response = SignInResponse()
activity_info = game_configs.activity_config.get(_id)
# 验证宝箱签到, 是否领取
if _id in player.sign_in_component.box_sign_in_prize:
response.res.result = False
response.res.result_no = 1404
logger.error("sign in box has got!")
return response.SerializePartialToString()
# 验证宝箱签到条件
for day in activity_info.parameterC:
if day not in player.sign_in_component.sign_in_days:
response.res.result = False
response.res.result_no = 1405
logger.error("sign in box condition not enough!")
return response.SerializePartialToString()
## 验证宝箱累积抽奖轮数
#sign_round = player.sign_in_component.sign_round
#if activity_info.parameterB != sign_round:
#response.res.result = False
#response.res.result_no = 1406
#logger.error("sign in box condition has reached!")
#return response.SerializePartialToString()
return_data = gain(player, activity_info.reward, const.BOX_SIGN)
get_return(player, return_data, response.gain)
player.sign_in_component.box_sign_in_prize.append(_id)
player.sign_in_component.save_data()
tlog_action.log('SignInBox', player, _id, activity_info.id)
response.res.result = True
logger.debug(response)
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 get_online_gift_1121(data, player):
"""get online gift"""
player.online_gift.check_time()
request = online_gift_pb2.GetOnlineGift()
request.ParseFromString(data)
response = online_gift_pb2.GetOnlineGiftResponse()
activity_online_gift = game_configs.activity_config.get(4)
online_minutes = player.online_gift.online_time # / 60
if request.gift_id in player.online_gift.received_gift_ids:
logger.error('repeat onilne gift:%s,%s',
player.online_gift.received_gift_ids,
request.gift_id)
response.result = False
return response.SerializeToString()
for a in activity_online_gift:
if request.gift_id == a['id']:
if online_minutes >= a['parameterA']:
gain_data = a['reward']
return_data = gain(player, gain_data, const.ONLINE_GIFT)
get_return(player, return_data, response.gain)
data = dict(online_time=player.online_gift.online_time,
received_gift_ids=player.online_gift.received_gift_ids)
player.online_gift.received_gift_ids.append(request.gift_id)
# player.online_gift.reset()
player.online_gift.save_data()
tlog_action.log('OnlineGift', player, request.gift_id)
response.result = True
return response.SerializeToString()
break
else:
logger.error('cant find gift id:%s', request.gift_id)
response.result = False
logger.error(response)
return response.SerializeToString()
def open_chest_1811(pro_data, player):
request = stage_request_pb2.OpenStageChestRequest()
request.ParseFromString(pro_data)
stage_id = request.stage_id
response = stage_response_pb2.OpenStageChestResponse()
stage_type = 1
if game_configs.stage_config.get('stages').get(stage_id):
stage_config = game_configs.stage_config.get('stages').get(stage_id)
if game_configs.special_stage_config.get('elite_stages').get(stage_id):
stage_type = 2
stage_config = game_configs.special_stage_config.get(
'elite_stages').get(stage_id)
if not stage_config:
response.res.result = False
response.res.result_no = 800
return response.SerializePartialToString()
stage_obj = player.stage_component.get_stage(stage_id)
if stage_obj.chest_state:
response.res.result = False
response.res.result_no = 863
return response.SerializePartialToString()
if stage_obj.state != 1:
response.res.result = False
response.res.result_no = 864
return response.SerializePartialToString()
return_data = gain(player, stage_config.stageBox, const.StageChestGift)
get_return(player, return_data, response.drops)
stage_obj.chest_state = 1
player.stage_component.save_data()
tlog_action.log('OpenChest', player, stage_id, stage_type)
response.res.result = True
# logger.debug(response)
return response.SerializePartialToString()
def melting_equipment(equipment_ids, response, player):
"""熔炼
@param dynamic_id:
@param equipment_ids:
@param kwargs:
@return:
"""
equipment_obj = player.equipment_component.get_equipment(equipment_ids)
if not equipment_obj:
return {'result': False, 'result_no': 401, 'message': u''}
melting_items = equipment_obj.melting_item
gain = item_group_helper.gain(player, melting_items)
item_group_helper.get_return(player, gain, response.cgr)
# 添加强化金币
strength_coin = 0
for record in equipment_obj.enhance_record.enhance_record:
strength_coin += record[2]
response.cgr.finance.coin += strength_coin
def deal_auto_response(response, player):
for (stage_id, item) in player.travel_component.auto.items():
stage_travel = response.stage_travel.add()
stage_travel.stage_id = stage_id
for auto_info in item:
auto_travel = stage_travel.auto_travel.add()
auto_travel.start_time = auto_info.get('start_time')
auto_travel.continued_time = auto_info.get('continued_time')
auto_travel.already_times = auto_info.get('already_times')
for tra in auto_info.get('events'):
res_travel = auto_travel.travel.add()
res_travel.state = tra[0]
res_travel.event_id = tra[1]
res_drops = res_travel.drops
drop_data = get_drop_data(tra[2])
get_return(player, drop_data, res_drops)
if game_configs.travel_event_config.get('events').get(
tra[1] % xs).type == 1:
if len(tra) == 4:
res_travel.time = tra[3]
def get_prize(player, mail_ids, response):
"""领取奖励"""
for mail_id in mail_ids:
mail = player.mail_component.get_mail(mail_id)
if not mail:
continue
if mail.prize:
if isinstance(eval(mail.prize), dict):
prize = data_helper.parse(eval(mail.prize))
return_data = gain(player, prize, const.MAIL)
get_return(player, return_data, response.gain)
elif isinstance(eval(mail.prize), list):
for prize_data in eval(mail.prize):
prize = data_helper.parse(prize_data)
return_data = gain(player, prize, const.MAIL)
get_return(player, return_data, response.gain)
continue
if mail.config_id:
# if mail.config_id != game_configs.base_config.get('warFogRobbedMail'):
# 除了附文矿被抢
mail_conf = game_configs.mail_config.get(mail.config_id)
prize = data_helper.parse(mail_conf.rewards)
return_data = gain(player, prize, const.MAIL)
get_return(player, return_data, response.gain)
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):
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 get_reward(self, act_id, response):
"""docstring for get_reward"""
act_config_item = game_configs.activity_config.get(act_id)
res_type = act_config_item.parameterE.keys()[0]
act_item = self._add_act[act_config_item.type][res_type]
logger.debug("act_item %s" % act_item)
if act_item.get("num") < int(act_config_item.parameterA):
logger.error("activity times not enough!")
return dict(result=False, result_no=260101)
stage_info = act_item["stages"]
if act_id not in stage_info:
logger.error("can not find activity!")
return dict(result=False, result_no=260102)
if stage_info.get(act_id):
logger.error("activity has finished!")
return dict(result=False, result_no=260103)
stage_info[act_id] = True
data = gain(self._owner, act_config_item.reward, const.ADD_ACTIVITY)
get_return(self._owner, data, response.gain)
self.save_data()
return dict(result=True)
def new_level_gift_840(data, player):
"""get online gift"""
response = level_gift_pb2.NewLevelGiftResponse()
response.res.result = False
conf = game_configs.activity_config.get(5)
for a in range(1, player.base_info.level + 1):
if not player.level_gift.level_gift[a]:
if conf.get(a):
level_info = response.level_info.add()
level_info.level = a
gain_data = conf.get(a)['reward']
return_data = gain(player, gain_data, const.NEW_LEVEL_GIFT)
get_return(player, return_data, level_info.drops)
player.level_gift.level_gift[a] = 1
response.res.result = True
player.level_gift.save_data()
return response.SerializeToString()
def get_task_reward_1822(data, player):
"""获取任务奖励"""
args = task_pb2.TaskRewardRequest()
args.ParseFromString(data)
tid = args.tid
response = task_pb2.TaskRewardResponse()
player.task.update()
task_conf = game_configs.achievement_config.get('tasks').get(tid)
state = player.task.tasks.get(tid)
if state and state == 3:
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
res = get_condition_info(player, task_conf)
if state == 1 and not res.get('state'):
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
if player.base_info.is_firstday_from_register(
const.OPEN_FEATURE_TASK) and task_conf.sort != 4:
response.res.result = False
logger.debug('error_no:150901')
response.res.result_no = 150901
return response.SerializeToString()
gain_data = gain(player, task_conf.reward, const.TASK)
get_return(player, gain_data, response.gain)
player.task._tasks[tid] = 3
player.task.save_data()
response.tid = tid
response.res.result = True
return response.SerializeToString()
def draw_rebate_5433(data, player):
"""
领取返利卡日常奖励
"""
req = rebateDraw()
req.ParseFromString(data)
response = rebateResp()
response.rid = req.rid
response.res.result = True
recharge_item = None
plat = 'ios'
if player.base_info.plat_id == 1:
plat = 'android'
for item in game_configs.recharge_config[plat].values():
if item.get('id') == req.rid:
recharge_item = item
if recharge_item and recharge_item.get('type') == 2:
_, last, can_draw = player.rebate.rebate_status(
req.rid, recharge_item.get('giftDays'))
if last > 0 and can_draw:
rebate = player.rebate.rebate_info(req.rid)
rebate.draw()
player.rebate.set_rebate(req.rid, rebate)
player.rebate.save_data()
day_reward = data_helper.parse(recharge_item.get('everydayGift'))
return_data = gain(player, day_reward, const.RECHARGE) # 获取
get_return(player, return_data, response.gain)
tlog_action.log('DrawRebate', player, req.rid)
else:
response.res.result = False
response.res.result_no = 54332
else:
response.res.result = False
response.res.result_no = 54331
print 'draw_rebate_5433', response
return response.SerializePartialToString()
def func():
player.sign_in_component.sign_in(day)
player.sign_in_component.save_data()
sign_round = player.sign_in_component.sign_round
print game_configs.sign_in_config.get(sign_round), "---------"
print game_configs.sign_in_config.get(sign_round).get(day), "-------"
if not game_configs.sign_in_config.get(
sign_round) or not game_configs.sign_in_config.get(
sign_round).get(day):
return
sign_in_info = game_configs.sign_in_config.get(sign_round).get(day)
#vip双倍
if player.base_info.vip_level > 0 and \
sign_in_info.get("vipDouble") and \
player.base_info.vip_level >= sign_in_info.get("vipDouble"):
is_double = 1
else:
is_double = 0
if is_double:
return_data = gain(player,
sign_in_info.get("reward"),
const.REPAIR_SIGN,
multiple=2)
get_return(player, return_data, response.gain)
else:
return_data = gain(player, sign_in_info.get("reward"),
const.REPAIR_SIGN)
get_return(player, return_data, response.gain)
player.sign_in_component.repair_sign_in_times += 1
player.sign_in_component.save_data()
tlog_action.log('RepairSignIn', player, day,
len(player.sign_in_component.sign_in_days),
sign_in_info.get("id"))
def add_reward_2104(pro_data, player):
"""
获取累积奖励
request:HjqyAddRewardRequest
response:HjqyAddRewardResponse
"""
# 检查是否可领取
request = hjqy_pb2.HjqyAddRewardRequest()
request.ParseFromString(pro_data)
response = hjqy_pb2.HjqyAddRewardResponse()
damage_hp = remote_gate['world'].hjqy_damage_hp_remote(player.base_info.id)
hjqy_info = game_configs.hjqy_config.get(request.id)
if hjqy_info.output_requirements > damage_hp:
logger.debug("damage_hp is not enough!")
response.res.result = False
response.res.result_no = 21041
return response.SerializePartialToString()
# 检查奖励是否被领取
if request.id in player.hjqy_component.received_ids:
logger.debug("has got the reward!")
response.res.result = False
response.res.result_no = 21042
return response.SerializePartialToString()
# 掉落
data = gain(player, hjqy_info.get("rewards"), const.HJQY_ADD_REWARD)
get_return(player, data, response.gain)
# 保存已经获取的id
player.hjqy_component.received_ids.append(request.id)
player.hjqy_component.save_data()
response.res.result = True
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 draw_friend_lively_1199(data, player):
request = friend_pb2.DrawRewardReq()
request.ParseFromString(data)
response = friend_pb2.DrawRewardRsp()
response.fid = request.fid
today = time.strftime("%Y%m%d", time.localtime(time.time()))
stat, update = player.friends.get_reward(request.fid, today)
if stat:
response.res.result = False
response.res.result_no = 11991 # 已领取
else:
player_data = tb_character_info.getObj(request.fid)
friend_data = player_data.hmget(['conditions_day', 'last_day'])
conditions_day = friend_data.get('conditions_day', {})
lively = conditions_day.get(24, 0)
if today != time.strftime(
"%Y%m%d", time.localtime(friend_data.get('last_day', '0'))):
lively = 0
if lively < game_configs.base_config['friendActivityValue']:
logger.debug('error_no:11992,lively:%d' % lively)
response.res.result = False
response.res.result_no = 11992 # 未完成
else:
response.res.result = True
reward = game_configs.base_config['friendActivityReward']
lively_reward = data_helper.parse(reward)
return_data = gain(player, lively_reward,
const.LIVELY_REWARD) # 获取
get_return(player, return_data, response.gain)
player.friends.set_reward(request.fid, today, 1)
update = True
if update:
player.friends.save_data()
return response.SerializePartialToString()
def rob_treasure_reward_863(data, player):
"""选择战利品"""
response = rob_treasure_pb2.RobTreasureRewardResponse()
if not player.rob_treasure.can_receive:
logger.error('rob_treasure_reward_863, can not receive')
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
indiana_conf = game_configs.indiana_config.get('indiana').get(
player.rob_treasure.can_receive)
common_bag = BigBag(indiana_conf.reward)
drops = common_bag.get_drop_items()
# drops = []
# common_bag = BigBag(self._common_drop)
# common_drop = common_bag.get_drop_items()
# drops.extend(common_drop)
x = [0, 1, 2]
random.shuffle(x)
return_data = [[
drops[x[0]].item_type, drops[x[0]].num, drops[x[0]].item_no
]]
# gain(player, [drops[x[0]]], const.ROB_TREASURE_REWARD)
get_return(player, return_data, response.look_gain.add())
# return_data = gain(player, [drops[x[1]]], const.ROB_TREASURE_REWARD)
return_data = [[
drops[x[1]].item_type, drops[x[1]].num, drops[x[1]].item_no
]]
get_return(player, return_data, response.look_gain.add())
return_data = gain(player, [drops[x[2]]], const.ROB_TREASURE_REWARD)
get_return(player, return_data, response.gain)
player.rob_treasure.can_receive = 0
player.rob_treasure.save_data()
response.res.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 hero_sacrifice_oper(heros, player):
"""
武将献祭，返回总武魂、经验药水
:param heros: 被献祭的武将
:return total_hero_soul:总武魂数量, exp_item_no:经验药水编号, exp_item_num:经验药水数量
"""
total_exp = 0
exp_item_no = 0
exp_item_num = 0
awake_item_no = 90001
awake_item_num = 0
break_item_no = 20006
break_item_num = 0
response = hero_response_pb2.HeroSacrificeResponse()
if is_not_open(player, FO_HERO_SACRIFICE):
response.res.result = False
response.res.result_no = 837
return response
gain_response = response.gain
for hero in heros:
sacrifice_gain = game_configs.hero_config.get(hero.hero_no).sacrificeGain
return_data = gain(player, sacrifice_gain, const.HERO_SACRIFICE_OPER)
get_return(player, return_data, gain_response)
# 经验
exp = hero.get_all_exp()
total_exp += exp
tlog_action.log('HeroSacrifice', player, hero.hero_no)
# 觉醒丹
awake_item_num += hero.awake_item_num
# 突破丹
break_item_num += hero.break_item_num
# baseconfig {1000000: 'item_id'}
logger.debug("total_exp %s" % total_exp)
formula_info = game_configs.formula_config.get("sacrificeExp_3")
pre_formula = formula_info.get("precondition")
formula = formula_info.get("formula")
cal_vars = dict(expHero=total_exp)
if eval(pre_formula, cal_vars):
exp_item_no = 10003
exp_item_num = eval(formula, cal_vars)
formula_info = game_configs.formula_config.get("sacrificeExp_2")
pre_formula = formula_info.get("precondition")
formula = formula_info.get("formula")
cal_vars = dict(expHero=total_exp)
if eval(pre_formula, cal_vars):
exp_item_no = 10002
exp_item_num = eval(formula, cal_vars)
formula_info = game_configs.formula_config.get("sacrificeExp_1")
pre_formula = formula_info.get("precondition")
formula = formula_info.get("formula")
cal_vars = dict(expHero=total_exp)
if eval(pre_formula, cal_vars):
exp_item_no = 10001
exp_item_num = eval(formula, cal_vars)
heroAwakeBack = game_configs.base_config.get('heroAwakeBack')
heroBreakBack = game_configs.base_config.get('heroBreakBack')
awake_item_num = int(awake_item_num * heroAwakeBack)
break_item_num = int(break_item_num * heroBreakBack)
player.item_package.add_item(Item(exp_item_no, exp_item_num))
player.item_package.add_item(Item(awake_item_no, awake_item_num))
player.item_package.add_item(Item(break_item_no, break_item_num))
player.item_package.save_data()
if exp_item_no:
item_pb = gain_response.items.add()
item_pb.item_no = exp_item_no
item_pb.item_num = exp_item_num
if awake_item_num:
item_pb = gain_response.items.add()
item_pb.item_no = awake_item_no
item_pb.item_num = awake_item_num
if break_item_num:
item_pb = gain_response.items.add()
item_pb.item_no = break_item_no
item_pb.item_num = break_item_num
response.res.result = True
# print "*"*80
# print response
return response
