def get_login_gift(activity_id, activity_type, response, player):
"""
领取登录奖励
"""
if activity_type == 1: # 累积登录
if player.login_gift.cumulative_received.count(
activity_id) == 0: # 未领取
if player.login_gift.cumulative_day[1]: # 是新手活动
res = False
err_no = 800
for i in activity_config.get(1):
if i.get('id') == activity_id:
if i.get('parameterA'
) <= player.login_gift.cumulative_day[0]:
player.login_gift.cumulative_received.append(
activity_id)
gain_data = i['reward']
return_data = gain(player, gain_data)
get_return(player, return_data, response.gain)
res = True
err_no = 0
else:
res = False
err_no = 802 # 条件没有达到
else: # 未知错误,不是新手活动的情况，目前代码不应该走这里
res = False
err_no = 800
else:
res = False
err_no = 801 # 已经领取过
else: # 连续登录奖励
if player.login_gift.continuous_received.count(
activity_id) == 0: # 未领取
if player.login_gift.continuous_day[1]: # 是新手活动
res = False
err_no = 800
for i in activity_config.get(2):
if i.get('id') == activity_id:
if i.get('parameterA'
) <= player.login_gift.continuous_day[0]:
player.login_gift.continuous_received.append(
activity_id)
gain_data = i['reward']
return_data = gain(player, gain_data)
get_return(player, return_data, response.gain)
res = True
err_no = 0
else:
res = False
err_no = 802 # 条件没有达到
else: # 未知错误,不是新手活动的情况，目前代码不应该走这里
res = False
err_no = 800
else:
res = False
err_no = 801 # 已经领取过
player.login_gift.save_data()
return res, err_no
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 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 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 func():
consume_return_data = consume(player, price,
get_reason(shop_item.get('type')),
multiple=item_count,
shop=shop,
luck_config=shop_type_item) # 消耗
return_data = gain(player,
shop_item.gain,
get_reason(shop_item.get('type')),
multiple=item_count,
lucky_attr_id=_lucky_attr) # 获取
get_return(player, consume_return_data, response.consume)
get_return(player, return_data, response.gain)
if shop_item.ExchangeValue:
lucky_data = gain(player,
shop_item.ExchangeValue,
get_reason(shop_item.get('type')))
get_return(player, lucky_data, response.gain)
for _ in range(item_count):
send_tlog(player, shop_item)
logger.debug("allBuyRefresh %s" % shop_type_item.allBuyRefresh)
if not shop['item_ids'] and shop_type_item.allBuyRefresh:
logger.debug("shop auto refresh =============")
player.shop.auto_refresh_items(shop_item.get('type'))
response.is_all_buy = True
def settle(player, result, response, conf, stage_type=1, star_num=0):
"""docstring for settle"""
# 保存关卡信息
player.stage_component.save_data()
# 保存活跃度
# 增加玩家和武将经验，增加金币
if not result and stage_type not in [4, 5]:
return
player.finance.coin += conf.currency
player.finance.save_data()
player.base_info.addexp(conf.playerExp, const.STAGE)
player.set_level_related()
player.base_info.save_data()
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(conf.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, 1, 0, 0, 0, 0)
hero.save_data()
# 更新等级相关属性
# 构造掉落
settlement_drops = player.fight_cache_component.fighting_settlement(
result, star_num)
logger.debug("stage_util.drops %s" % settlement_drops)
multiple, part_multiple = get_drop_activity(
player, player.fight_cache_component.stage_id, stage_type, star_num)
data = gain(player,
settlement_drops,
const.STAGE,
multiple=multiple,
part_multiple=part_multiple)
get_return(player, data, response.drops)
logger.debug("stage_util.drops %s" % response.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)
get_return(player, data, response.drops)
def add_items(player, task_id):
"""
添加道具给玩家
"""
add_items = []
if task_id in achievement_config:
task = achievement_config[task_id]
reward = data_helper.parse(task.reward)
item_group_helper.gain(player, reward, add_items)
return add_items
def sign_in_1401(pro_data, player):
"""签到"""
print "sign_in++++++++++++++"
response = SignInResponse()
# 签到
day = player.sign_in_component.current_day()
register_time = player.base_info.register_time
register_time = timestamp_to_date(register_time)
# 同一天签到校验
if player.sign_in_component.is_signd(day):
print "sign in error code:", 1405
response.res.result = False
response.res.result_no = 1405
return response.SerializePartialToString()
player.sign_in_component.sign_in(day)
player.sign_in_component.save_data()
sign_round = player.sign_in_component.sign_round
# 获取奖励
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双倍
print("vip================", player.base_info.vip_level,
sign_in_info.get("vipDouble"))
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.SIGN_GIFT,
multiple=2)
get_return(player, return_data, response.gain)
else:
return_data = gain(player, sign_in_info.get("reward"), const.SIGN_GIFT)
get_return(player, return_data, response.gain)
tlog_action.log('SignIn', player, day, is_double, sign_in_info.get('id'))
response.res.result = True
return response.SerializePartialToString()
def travel_settle_833(data, player):
""" settle"""
args = TravelSettleRequest()
args.ParseFromString(data)
stage_id = args.stage_id
event_id = args.event_id
response = TravelSettleResponse()
if player.travel_component.travel.get(stage_id):
stage_cache = player.travel_component.travel.get(stage_id)
else:
logger.error("travel stage id not found")
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
event_cache = 0
for event in stage_cache:
if event[0] == event_id:
event_cache = event
break
if not event_cache:
logger.error("travel ：event id not found")
response.res.result = False
response.res.result_no = 813
return response.SerializeToString()
event_info = travel_event_config.get('events').get(args.event_id)
if event_info.type == 1:
if int(time.time()) - event_cache[2] < \
event_info.parameter.items()[0][0]:
response.res.result = False
response.res.result_no = 814
return response.SerializeToString()
# elif event_info.type == 3:
# if not event_info.parameter.get(args.answer):
# response.res.result = False
# response.res.result_no = 815
# return response.SerializeToString()
# 结算
gain(player, event_cache[1])
stage_cache.remove(event_cache)
player.travel_component.save()
response.res.result = True
return response.SerializeToString()
def settle(player, result, response, conf, stage_type=1, star_num=0):
"""docstring for settle"""
# 保存关卡信息
player.stage_component.save_data()
# 保存活跃度
# 增加玩家和武将经验，增加金币
if not result and stage_type not in [4, 5]:
return
player.finance.coin += conf.currency
player.finance.save_data()
player.base_info.addexp(conf.playerExp, const.STAGE)
player.set_level_related()
player.base_info.save_data()
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(conf.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, 1, 0, 0, 0, 0)
hero.save_data()
# 更新等级相关属性
# 构造掉落
settlement_drops = player.fight_cache_component.fighting_settlement(result, star_num)
logger.debug("stage_util.drops %s" % settlement_drops)
multiple, part_multiple = get_drop_activity(player, player.fight_cache_component.stage_id, stage_type, star_num)
data = gain(player, settlement_drops, const.STAGE, multiple=multiple, part_multiple=part_multiple)
get_return(player, data, response.drops)
logger.debug("stage_util.drops %s" % response.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)
get_return(player, data, response.drops)
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 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 first_recharge_activity_2204(request_proto, player):
"""
首次充值
"""
response = recharge_pb2.GetRechargeGiftResponse()
response.res.result = True
if player.base_info.recharge == 0:
response.res.result = False
response.res.result_no = 22041
return response.SerializePartialToString()
if player.base_info._button_one_time[const.FIRST_RECHARGE_BUTTON] == 1:
response.res.result = False
response.res.result_no = 22042
return response.SerializePartialToString()
activity_info = game_configs.activity_config.get(7)[0]
if activity_info:
logger.error("activity not exist!")
player.base_info._button_one_time[const.FIRST_RECHARGE_BUTTON] = 1
player.base_info.save_data()
return_data = gain(player, activity_info.get('reward', {}),
const.FIRST_RECHARGE)
get_return(player, return_data, response.gain)
return response.SerializePartialToString()
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 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 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():
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 get_tomorrow_gift_1122(data, player):
response = online_gift_pb2.GetActivityResponse()
response.result = False
tomorrow_gift = game_configs.activity_config.get(15, [])
if not tomorrow_gift:
logger.error('tomorrow gift is not exist')
return response.SerializeToString()
else:
tomorrow_gift = game_configs.activity_config.get(15)[0]
# 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 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 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 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 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 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 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 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 pvp_rob_treasure_more_times_1504(data, player):
request = pvp_rank_pb2.RobTreasureMoreTimesRequest()
response = pvp_rank_pb2.RobTreasureMoreTimesResponse()
request.ParseFromString(data)
uid = request.uid
chip_id = request.chip_id
times = request.times
check_res, res_no, chip_conf = check_can_rob(player, uid, chip_id, times,
response)
if not check_res:
response.res.result = False
response.res.result_no = res_no
return response.SerializePartialToString()
player.rob_treasure.truce = [0, 1]
for _ in range(times):
one_times_response = response.one_time_info.add()
fight_response = one_times_response.fight_info
fight_result = deal_pvp_rob_fight(player, uid, chip_id, fight_response,
chip_conf)
if fight_result:
indiana_conf = get_indiana_conf(player, uid, chip_conf)
common_bag = BigBag(indiana_conf.reward)
drops = common_bag.get_drop_items()
x = random.randint(0, 2)
return_data = gain(player, [drops[x]], const.ROB_TREASURE_REWARD)
get_return(player, return_data, one_times_response.gain)
player.pvp.reset_rob_treasure()
player.pvp.save_data()
player.rob_treasure.save_data()
response.res.result = True
logger.debug("response ==================== : %s" % response)
return response.SerializeToString()
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 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 sign_in_1401(pro_data, player):
"""签到"""
print "sign_in++++++++++++++"
response = SignInResponse()
# 签到
date = datetime.datetime.now()
month = date.month
day = date.day
# 同一天签到校验
if player.sign_in_component.is_signd(month, day):
print "sign in error code:", 1405
response.res.result = False
response.res.result_no = 1405
return response.SerializePartialToString()
player.sign_in_component.sign_in(month, day)
player.sign_in_component.save_data()
# 获取奖励
if not sign_in_config.get(month) or not sign_in_config.get(month).get(day):
return
gain_data = sign_in_config.get(month).get(day)
return_data = gain(player, gain_data)
get_return(player, return_data, response.gain)
response.res.result = True
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 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 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 pvp_fight_revenge_1507(data, player):
request = pvp_rank_pb2.PvpFightRevenge()
response = pvp_rank_pb2.PvpFightResponse()
request.ParseFromString(data)
line_up = request.lineup
skill = request.skill
target_id = request.black_id
if not player.friends.can_revenge(target_id):
logger.error('black id is not in blacklist:%s', target_id)
response.res.result = False
response.res.result_no = 1516
return response.SerializePartialToString()
fight_result = pvp_fight(player, target_id, line_up, skill, response)
logger.debug("fight revenge result:%s" % fight_result)
if fight_result:
player.friends.del_blacklist(target_id)
player.friends.save_data()
revenge_reward = game_configs.base_config['arenaRevengeRewards']
return_data = gain(player, revenge_reward, const.FRIEND_REVENGE)
get_return(player, return_data, response.gain)
response.res.result = True
logger.debug("red_units: %s" % response.red)
return response.SerializeToString()
def continus_sign_in_1402(pro_data, player):
"""连续签到"""
request = ContinuousSignInRequest()
request.ParseFromString(pro_data)
days = request.sign_in_days
response = ContinuousSignInResponse()
sign_in_prize = base_config.get("signInPrize")
if not sign_in_prize:
return
# 验证连续签到日期
if player.sign_in_component.continuous_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()
drop_bag_id = sign_in_prize.get(days)
big_bag = BigBag(drop_bag_id)
gain_data = big_bag.get_drop_items()
return_data = gain(player, gain_data)
get_return(player, return_data, response.gain)
response.res.result = True
return response.SerializePartialToString()
def deal_pvp_rob_fight(player, uid, chip_id, one_times_response, chip_conf):
price = game_configs.base_config.get('indianaConsume')
return_data = consume(player, price, const.ROB_TREASURE) # 消耗
get_return(player, return_data, one_times_response.consume)
fight_result = pvp_fight(player,
uid, [],
0,
one_times_response,
is_copy_unit=True)
logger.debug("fight revenge result:%s" % fight_result)
indiana_conf = get_indiana_conf(player, uid, chip_conf)
if fight_result:
if indiana_conf.probability >= random.random():
gain_items = parse({104: [1, 1, chip_id]})
return_data = gain(player, gain_items, const.ROB_TREASURE)
get_return(player, return_data, one_times_response.gain)
# 处理被打玩家
deal_target_player(player, uid, chip_id)
return fight_result
def 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 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 get_prize(player, mail_ids, response):
"""领取奖励"""
for mail_id in mail_ids:
mail = player.mail_component.get_mail(mail_id)
prize = data_helper.parse(mail.prize)
return_data = gain(player, prize)
get_return(player, return_data, response.gain)
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 no_wait_835(data, player):
args = NoWaitRequest()
args.ParseFromString(data)
stage_id = args.stage_id
event_id = args.event_id
response = NoWaitResponse()
if player.travel_component.travel.get(stage_id):
stage_cache = player.travel_component.travel.get(stage_id)
else:
logger.error("travel stage id not found")
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
event_cache = 0
for event in stage_cache:
if event[0] == event_id:
event_cache = event
break
if not event_cache:
logger.error("travel ：event id not found")
response.res.result = False
response.res.result_no = 813
return response.SerializeToString()
event_info = game_configs.travel_event_config.get('events').get(event_id %
xs)
if player.finance.gold < event_info.price:
response.res.result = False
response.res.result_no = 102 # 充值币不足
return response.SerializeToString()
player.finance.consume_gold(event_info.price, const.TRAVEL)
gain(player, event_cache[1], const.TRAVEL)
player.finance.save_data()
stage_cache.remove(event_cache)
player.travel_component.save()
response.res.result = True
return response.SerializeToString()
def sign_in_1401(pro_data, player):
"""签到"""
print "sign_in++++++++++++++"
response = SignInResponse()
# 签到
day = player.sign_in_component.current_day()
register_time = player.base_info.register_time
register_time = timestamp_to_date(register_time)
# 同一天签到校验
if player.sign_in_component.is_signd(day):
print "sign in error code:", 1405
response.res.result = False
response.res.result_no = 1405
return response.SerializePartialToString()
player.sign_in_component.sign_in(day)
player.sign_in_component.save_data()
sign_round = player.sign_in_component.sign_round
# 获取奖励
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双倍
print("vip================", player.base_info.vip_level, sign_in_info.get("vipDouble"))
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.SIGN_GIFT, multiple=2)
get_return(player, return_data, response.gain)
else:
return_data = gain(player, sign_in_info.get("reward"), const.SIGN_GIFT)
get_return(player, return_data, response.gain)
tlog_action.log('SignIn', player, day, is_double, sign_in_info.get('id'))
response.res.result = True
return response.SerializePartialToString()
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 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 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 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 no_wait_835(data, player):
args = NoWaitRequest()
args.ParseFromString(data)
stage_id = args.stage_id
event_id = args.event_id
response = NoWaitResponse()
if player.travel_component.travel.get(stage_id):
stage_cache = player.travel_component.travel.get(stage_id)
else:
logger.error("travel stage id not found")
response.res.result = False
response.res.result_no = 800
return response.SerializeToString()
event_cache = 0
for event in stage_cache:
if event[0] == event_id:
event_cache = event
break
if not event_cache:
logger.error("travel ：event id not found")
response.res.result = False
response.res.result_no = 813
return response.SerializeToString()
event_info = game_configs.travel_event_config.get('events').get(event_id%xs)
if player.finance.gold < event_info.price:
response.res.result = False
response.res.result_no = 102 # 充值币不足
return response.SerializeToString()
player.finance.consume_gold(event_info.price, const.TRAVEL)
gain(player, event_cache[1], const.TRAVEL)
player.finance.save_data()
stage_cache.remove(event_cache)
player.travel_component.save()
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 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():
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 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 settle(self, result, response):
"""
战斗结算
"""
player = self._player
stage_id = self._stage_id
#conf = self.get_stage_config()
if player.travel_component.fight_cache[0] and player.travel_component.fight_cache[1]:
if player.travel_component.travel.get(player.travel_component.fight_cache[0]):
stage_cache = player.travel_component.travel.get(player.travel_component.fight_cache[0])
else:
logger.error("travel stage id not found")
response.res.result = False
response.res.result_no = 800
return
event_cache = 0
for event in stage_cache:
if event[0] == player.travel_component.fight_cache[1]:
event_cache = event
break
if not event_cache:
logger.error("travel ：event id not found")
response.res.result = False
response.res.result_no = 813
return
if game_configs.travel_event_config.get('events').get(player.travel_component.fight_cache[1]%xs) and \
stage_id == game_configs.travel_event_config.get('events').get(player.travel_component.fight_cache[1]%xs).parameter.items()[0][0]:
if result:
gain(player, event_cache[1], const.TRAVEL)
stage_cache.remove(event_cache)
player.travel_component.fight_cache = [0, 0]
player.travel_component.save()
else:
logger.error('stageid != travel fight cache stage id ')
response.res.result = False
response.res.result_no = 817
return
tlog_action.log('RoundFlow', player, stage_id, 4, 0, result)
def get_award_909(pro_data, player):
"""取得章节奖励
"""
request = stage_request_pb2.StarAwardRequest()
request.ParseFromString(pro_data)
chapter_id = request.chapter_id
award_type = request.award_type
response = stage_response_pb2.StarAwardResponse()
chapters_info = get_chapter_info(chapter_id, player)
if len(chapters_info) != 1 or chapter_id == 1 or len(
chapters_info[0].award_info) == 0:
logger.error("chapter_info dont find")
response.res.result = False
response.res.result_no = 831
return response.SerializePartialToString()
else:
chapter_obj = chapters_info[0]
conf = chapter_obj.get_conf()
chapter_obj.update(player.stage_component.calculation_star(chapter_id))
if 0 <= award_type <= 2:
if chapter_obj.award_info[award_type] != 0:
logger.error("already receive or can`t receive")
response.res.result = False
response.res.result_no = 832
return response.SerializePartialToString()
else:
chapter_obj.award_info[award_type] = 1
bag_id = conf.starGift[award_type]
drop = get_drop(bag_id)
return_data = gain(player, drop, const.CHAPTER_AWARD)
get_return(player, return_data, response.drops)
player.stage_component.save_data()
tlog_action.log('OpenStarChest', player, chapter_id, award_type)
else:
response.res.result = False
response.res.result_no = 800
return response.SerializePartialToString()
# 满星抽奖
# if chapter_obj.award_info[-1] == -1:
# logger.error("can`t receive")
# response.res.result = False
# response.res.result_no = 833
# return response.SerializePartialToString()
# else:
# pass
response.res.result = True
# logger.debug(response)
return response.SerializePartialToString()
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, const.HERO_SELL)
get_return(player, return_data, response.gain)
response.res.result = True
return response
def settle(player, fight_result):
logger.debug("fight revenge result:%s" % fight_result)
if fight_result:
player.friends.del_blacklist(target_id)
player.friends.save_data()
revenge_reward = game_configs.base_config['arenaRevengeRewards']
return_data = gain(player, revenge_reward, const.FRIEND_REVENGE)
get_return(player, return_data, response.gain)
response.res.result = True
logger.debug("red_units: %s" % response.red)
return response.SerializeToString()
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)
