def harvest_1245(data, player):
"""
收获符文石,待测试
"""
request = mine_pb2.positionRequest()
request.ParseFromString(data)
response = mine_pb2.drawStones()
response.position = request.position
detail_info = player.mine.detail_info(request.position)
ret, stype, last_increase, limit, normal, lucky, lineup, guard_time = detail_info
num = sum(normal.values()) + sum(lucky.values())
if player.runt.bag_is_full(num):
response.res.result = False
response.res.result_no = 12451
return response.SerializePartialToString()
stones = player.mine.harvest(request.position)
# print 'stones', stones
if stones:
if not add_stones(player, stones, response):
response.res.result = False
response.res.result_no = 824
return response.SerializePartialToString()
else:
response.res.result = False
response.res.result_no = 12450
response.res.message = u"没有可以领取的符文石"
player.mine.save_data()
player.runt.save()
hook_task(player, CONDITIONId.GAIN_RUNT, 1)
return response.SerializePartialToString()
def settle(self, result, response, star_num=0):
"""
战斗结算
"""
player = self._player
stage_id = self._stage_id
conf = self.get_stage_config()
# todo: 更新战斗次数
# 体力
if result:
#player.stamina.stamina -= conf.vigor
player.finance.consume(const.STAMINA, conf.vigor, const.STAGE)
player.finance.save_data()
player.stamina.save_data()
# 活跃度
# 结算
stage_util.settle(player,
result,
response,
conf,
star_num=star_num)
# hook task
hook_task(player, CONDITIONId.ANY_STAGE, 1)
hook_task(player, CONDITIONId.STAGE, stage_id)
# 更新 七日奖励
target_update(player, [45])
tlog_action.log('RoundFlow', player, stage_id, 1, 0, 1)
else:
tlog_action.log('RoundFlow', player, stage_id, 1, 0, 0)
def read_mail(mail_idss, mail_type, player):
"""读取邮件"""
response = mailbox_pb2.ReadMailResponse()
mail_ids = []
for mail_id in mail_idss:
mail = player.mail_component.get_mail(mail_id)
if mail:
mail_ids.append(mail_id)
mail.is_readed = True
player.mail_component.save_mail(mail_id)
if mail_type == 1:
# 领取赠送体力
result = check_gives(mail_ids, player)
if not result.get('result'):
response.res.result = False
response.res.result_no = result.get('result_no')
return response.SerializePartialToString()
# player.stamina.add_stamina(len(mail_ids)*2)
get_prize(player, mail_ids, response)
last_times = player.stamina.get_stamina_times
player.stamina.get_stamina_times = last_times + len(mail_ids)
player.stamina.save_data()
player.mail_component.delete_mails(mail_ids)
response.target = game_configs.base_config['times_get_vigor_from_friend']
response.current = player.stamina.get_stamina_times
response.mail_type = mail_type
hook_task(player, CONDITIONId.RECEIVE_STAMINA, 1)
response.res.result = True
return response.SerializePartialToString()
def settle(self, result, response):
"""
战斗结算
"""
player = self._player
stage_id = self._stage_id
conf = self.get_stage_config()
# todo: 更新战斗次数
# 体力
if result:
player.stamina.stamina -= conf.vigor
player.stamina.save_data()
# 活跃度
# 结算
stage_util.settle(player, result, response, conf, stage_type=1)
# hook task
hook_task(player, CONDITIONId.ANY_STAGE, 1)
hook_task(player, CONDITIONId.STAGE, stage_id)
tlog_action.log('RoundFlow', player, stage_id, 1, 0, 1)
else:
tlog_action.log('RoundFlow', player, stage_id, 1, 0, 0)
def settle(self, result, response, star_num=0):
"""
战斗结算
"""
player = self._player
stage_id = self._stage_id
conf = self.get_stage_config()
# todo: 更新战斗次数
# 体力
if result:
#player.stamina.stamina -= conf.vigor
player.finance.consume(const.STAMINA, conf.vigor, const.STAGE)
player.finance.save_data()
player.stamina.save_data()
# 活跃度
# 结算
stage_util.settle(player, result, response, conf, star_num=star_num)
# hook task
hook_task(player, CONDITIONId.ANY_STAGE, 1)
hook_task(player, CONDITIONId.STAGE, stage_id)
# 更新 七日奖励
target_update(player, [45])
tlog_action.log('RoundFlow', player, stage_id, 1, 0, 1)
else:
tlog_action.log('RoundFlow', player, stage_id, 1, 0, 0)
def add_equipment(self, equipment_no, lucky_attr=0):
"""添加装备
"""
character_id = self.owner.base_info.id
equipment_id = get_uuid()
equipment_obj = Equipment(character_id, equipment_id, '', equipment_no)
self._equipments_obj[equipment_id] = equipment_obj
equipment_obj.add_data(self.owner.base_info.id, lucky_attr)
equ_conf = game_configs.equipment_config.get(equipment_no)
cid = 0
color = equ_conf.color
color_num = 0
star6_num = 0
if equ_conf.color == 1:
cid = CONDITIONId.GREEN_EQU
elif equ_conf.color == 2:
cid = CONDITIONId.BLUE_EQU
for _, equ_obj in self._equipments_obj.items():
e_conf = game_configs.equipment_config. \
get(equ_obj.base_info.equipment_no)
if e_conf.color == color and cid:
color_num += 1
if e_conf.quality == 6:
star6_num += 1
if color_num:
hook_task(self.owner, cid, color_num)
if star6_num:
hook_task(self.owner, CONDITIONId.STAR6_EQU, star6_num)
return equipment_obj
def save_data(self, prop_names=[]):
props = {
'line_up_slots': dict([(slot_no, slot.dumps()) for
slot_no, slot in
self._line_up_slots.items()]),
'sub_slots': dict([(slot_no, sub_slot.dumps()) for
slot_no, sub_slot in self._sub_slots.items()]),
'line_up_order': self._line_up_order,
'unpar_level': self._unpar_level,
'unpar_type': self._unpar_type,
'unpar_other_id': self._unpar_other_id,
'ever_have_heros': self._ever_have_heros,
'unpar_names': self._unpar_names,
'friend_fight_times': self._friend_fight_times,
'hight_power': self._hight_power,
'caption_pos': self._caption_pos,
}
if not prop_names or 'line_up_slots' in prop_names or 'sub_slots' in prop_names:
power = self.combat_power
props['attackPoint'] = power
hook_task(self.owner, CONDITIONId.FIGHT_POWER, power)
if ('copy_units' in prop_names) or (not prop_names):
props['copy_units'] = self.owner.fight_cache_component.red_unit
props['copy_slots'] = line_up_info(self.owner).SerializeToString()
line_up_obj = tb_character_info.getObj(self.character_id)
line_up_obj.hmset(props)
def add_hero(self, hero_no):
hero = Hero(self.owner.base_info.id)
hero.hero_no = hero_no
self._heros[hero_no] = hero
self.new_hero_data(hero)
hero_conf = game_configs.hero_config.get(hero_no)
if hero_conf.color == 3:
if not (hero_no in self.owner.base_info.heads.head):
self.owner.base_info.heads.head.append(hero_no)
self.owner.base_info.save_data()
cid = 0
color = hero_conf.color
color_num = 0
star6_num = 0
if hero_conf.color == 1:
cid = CONDITIONId.GREEN_HERO
elif hero_conf.color == 2:
cid = CONDITIONId.BLUE_HERO
for hero_no, hero_obj in self._heros.items():
h_conf = game_configs.hero_config.get(hero_no)
if h_conf.color == color:
color_num += 1
if h_conf.quality == 6:
star6_num += 1
if cid and color_num:
hook_task(self.owner, cid, color_num)
if star6_num:
hook_task(self.owner, CONDITIONId.STAR6_HERO, star6_num)
return hero
def set_vip_level(self, gold):
"""
充值后升级vip
"""
for i in range(16):
vip_content = game_configs.vip_config.get(i)
if gold >= vip_content.rechargeAmount:
self._vip_level = i
self.save_data()
hook_task(self.owner, CONDITIONId.VIP_LEVEL, self._vip_level)
def taken_brew_1602(data, player):
response = brew_pb2.BrewInfo()
response.res.result = player.brew.taken_brew()
if response.res.result:
response.brew_times = player.brew.brew_times
response.brew_step = player.brew.brew_step
response.nectar_num = player.brew.nectar
response.nectar_cur = player.brew.nectar_cur
response.gold = player.finance.gold
hook_task(player, CONDITIONId.BREW, 1)
return response.SerializePartialToString()
def level(self, value):
if self._level != value:
logger.info('player id:%s level up ++ %s>>%s', self.id,
self._level, value)
# hook task
hook_task(self.owner, CONDITIONId.LEVEL, self._level)
target_update(self.owner, [43])
self._level = value
tb_character_level.zadd(self._level, self.id)
# feature open
if feature_open.is_not_open(self.owner, feature_open.FO_MINE):
self.owner.mine.reset_data()
def settle(self, result, response, star_num=0):
"""docstring for 结算"""
player = self._player
conf = self.get_stage_config()
stage_id = self._stage_id
if self.stage_type == 4:
player.stage_component.act_stage_info[0] += conf.timesExpend
elif self.stage_type == 5:
player.stage_component.act_stage_info[1] += conf.timesExpend
stage_util.settle(player, result, response, conf, stage_type=self.stage_type, star_num=star_num)
hook_task(player, CONDITIONId.STAGE, stage_id)
hook_task(player, CONDITIONId.ANY_ACT_STAGE, 1)
tlog_action.log('RoundFlow', player, stage_id, 3, 0, 1)
def add_guild_activity_times_remote(task_no, protect_or_rob, is_online, player):
"""
添加活动信息
"""
logger.debug("add_guild_activity_times_remote============%s %s" % (task_no, protect_or_rob))
if protect_or_rob == 1:
player.guild_activity.add_protect_escort_times(task_no)
player.act.add_protect_escort_times(task_no)
hook_task(player, CONDITIONId.PROTECT_ESCORT, 1)
elif protect_or_rob == 2:
player.guild_activity.add_rob_escort_times(task_no)
player.act.add_rob_escort_times(task_no)
hook_task(player, CONDITIONId.ROB_ESCORT, 1)
def harvest_1245(data, player):
"""
收获符文石,待测试
"""
request = mine_pb2.positionRequest()
request.ParseFromString(data)
response = mine_pb2.drawStones()
response.position = request.position
detail_info = player.mine.detail_info(request.position)
normal = detail_info['normal']
lucky = detail_info['lucky']
num = sum(normal.values()) + sum(lucky.values())
if player.runt.bag_is_full(num):
response.res.result = False
response.res.result_no = 124501
logger.error('mine harvest bag is full!')
return response.SerializePartialToString()
normal, lucky = player.mine.harvest(request.position)
if normal:
if not add_stones(player, normal, response.normal):
response.res.result = False
response.res.result_no = 124502
logger.error('mine harvest add stones fail!')
return response.SerializePartialToString()
if not add_stones(player, lucky, response.lucky):
response.res.result = False
response.res.result_no = 124503
logger.error('mine harvest add stones fail!')
return response.SerializePartialToString()
else:
response.res.result = False
response.res.result_no = 124504
response.res.message = u"没有可以领取的符文石"
logger.error('mine harvest no stones to harvest!')
return response.SerializePartialToString()
player.mine.save_data()
player.runt.save()
player.act.mine_get_runt()
target_update(player, [58])
hook_task(player, CONDITIONId.GAIN_RUNT, 1)
tlog_action.log('MineHarvest',
player,
request.position,
str(normal),
str(lucky))
response.res.result = True
logger.debug('mine harvest:%s', response)
return response.SerializePartialToString()
def add_guild_activity_times_remote(task_no, protect_or_rob, is_online,
player):
"""
添加活动信息
"""
logger.debug("add_guild_activity_times_remote============%s %s" %
(task_no, protect_or_rob))
if protect_or_rob == 1:
player.guild_activity.add_protect_escort_times(task_no)
player.act.add_protect_escort_times(task_no)
hook_task(player, CONDITIONId.PROTECT_ESCORT, 1)
elif protect_or_rob == 2:
player.guild_activity.add_rob_escort_times(task_no)
player.act.add_rob_escort_times(task_no)
hook_task(player, CONDITIONId.ROB_ESCORT, 1)
def settle(self, result, response):
"""docstring for 结算"""
player = self._player
conf = self.get_stage_config()
stage_id = self._stage_id
tm_time = time.localtime(player.stage_component.act_stage_info[1])
if result:
if tm_time.tm_yday == time.localtime().tm_yday:
player.stage_component.act_stage_info[0] += conf.timesExpend
else:
player.stage_component.act_stage_info = [conf.timesExpend, int(time.time())]
stage_util.settle(player, result, response, conf)
hook_task(player, CONDITIONId.STAGE, stage_id)
hook_task(player, CONDITIONId.ANY_ACT_STAGE, 1)
tlog_action.log('RoundFlow', player, stage_id, 3, 0, 1)
else:
tlog_action.log('RoundFlow', player, stage_id, 3, 0, 0)
def settle(self, result, response, star_num=0):
"""docstring for 结算"""
player = self._player
stage_id = self._stage_id
conf = self.get_stage_config()
tm_time = time.localtime(player.stage_component.elite_stage_info[2])
if result:
if tm_time.tm_yday == time.localtime().tm_yday:
player.stage_component.elite_stage_info[0] += conf.timesExpend
else:
player.stage_component.elite_stage_info = [conf.timesExpend, 0, int(time.time())]
stage_util.settle(player, result, response, conf, star_num=star_num)
# hook task
hook_task(player, CONDITIONId.STAGE, stage_id)
hook_task(player, CONDITIONId.ANY_ELITE_STAGE, 1)
tlog_action.log('RoundFlow', player, stage_id, 2, 0, 1)
else:
tlog_action.log('RoundFlow', player, stage_id, 2, 0, 0)
def settle(self, result, response, star_num=0):
"""docstring for 结算"""
player = self._player
conf = self.get_stage_config()
stage_id = self._stage_id
if self.stage_type == 4:
player.stage_component.act_stage_info[0] += conf.timesExpend
elif self.stage_type == 5:
player.stage_component.act_stage_info[1] += conf.timesExpend
stage_util.settle(player,
result,
response,
conf,
stage_type=self.stage_type,
star_num=star_num)
hook_task(player, CONDITIONId.STAGE, stage_id)
hook_task(player, CONDITIONId.ANY_ACT_STAGE, 1)
tlog_action.log('RoundFlow', player, stage_id, 3, 0, 1)
def given_stamina_1108(data, player):
response = CommonResponse()
response.result = True
response.result_no = 0
request = friend_pb2.FriendCommon()
request.ParseFromString(data)
target_id = request.target_ids[0]
player_data = tb_character_info.getObj(target_id)
stamina_db = Stamina_DB()
stamina_db.ParseFromString(player_data.hget('stamina'))
open_receive = stamina_db.open_receive
if not player.friends.given_stamina(target_id, if_present=open_receive):
response.result = False
response.result_no = 1 # fail
return response.SerializePartialToString() #
player.friends.save_data()
hook_task(player, CONDITIONId.SEND_STAMINA, 1)
return response.SerializePartialToString()
def search_1241(data, player):
""" 搜索矿点,ok """
# print 'search_1241'
request = mine_pb2.positionRequest()
request.ParseFromString(data)
response = mine_pb2.searchResponse()
response.position = request.position
logger.debug('response.position:%s', response.position)
if player.mine.can_search(request.position):
player.mine.search_mine(request.position)
player.mine.save_data()
one_mine = player.mine.mine_info(request.position)
one_mine_info(player, one_mine, response.mine)
response.res.result = True
hook_task(player, CONDITIONId.MINE_EXPLORE, 1)
else:
response.res.result = False
response.res.result_no = 12410
response.res.message = u"超出探索范围"
# print '1241-response', response
player.mine.save_data()
return response.SerializePartialToString()
def save_data(self, prop_names=[]):
power = self.combat_power
hook_task(self.owner, CONDITIONId.FIGHT_POWER, power)
props = {
'line_up_slots': dict([(slot_no, slot.dumps()) for
slot_no, slot in
self._line_up_slots.items()]),
'sub_slots': dict([(slot_no, sub_slot.dumps()) for
slot_no, sub_slot in self._sub_slots.items()]),
'line_up_order': self._line_up_order,
'unpars': self._unpars,
'current_unpar': self._current_unpar,
'friend_fight_times': self._friend_fight_times,
'attackPoint': power,
'hight_power': self._hight_power,
'best_skill': self.get_skill_id_by_unpar(self._current_unpar),
}
if ('copy_units' in prop_names) or (not prop_names):
props['copy_units'] = self.owner.fight_cache_component.red_unit
props['copy_slots'] = line_up_info(self.owner).SerializeToString()
line_up_obj = tb_character_info.getObj(self.character_id)
line_up_obj.hmset(props)
def save_data(self, prop_names=[]):
props = {
'line_up_slots':
dict([(slot_no, slot.dumps())
for slot_no, slot in self._line_up_slots.items()]),
'sub_slots':
dict([(slot_no, sub_slot.dumps())
for slot_no, sub_slot in self._sub_slots.items()]),
'line_up_order':
self._line_up_order,
'unpar_level':
self._unpar_level,
'unpar_type':
self._unpar_type,
'unpar_other_id':
self._unpar_other_id,
'ever_have_heros':
self._ever_have_heros,
'unpar_names':
self._unpar_names,
'friend_fight_times':
self._friend_fight_times,
'hight_power':
self._hight_power,
'caption_pos':
self._caption_pos,
}
if not prop_names or 'line_up_slots' in prop_names or 'sub_slots' in prop_names:
power = self.combat_power
props['attackPoint'] = power
hook_task(self.owner, CONDITIONId.FIGHT_POWER, power)
if ('copy_units' in prop_names) or (not prop_names):
props['copy_units'] = self.owner.fight_cache_component.red_unit
props['copy_slots'] = line_up_info(self.owner).SerializeToString()
line_up_obj = tb_character_info.getObj(self.character_id)
line_up_obj.hmset(props)
def settle(self, result, response, star_num=0):
"""docstring for 结算"""
player = self._player
stage_id = self._stage_id
conf = self.get_stage_config()
tm_time = time.localtime(player.stage_component.elite_stage_info[2])
if result:
if tm_time.tm_yday == time.localtime().tm_yday:
player.stage_component.elite_stage_info[0] += conf.timesExpend
else:
player.stage_component.elite_stage_info = [
conf.timesExpend, 0, int(time.time())
]
stage_util.settle(player,
result,
response,
conf,
star_num=star_num)
# hook task
hook_task(player, CONDITIONId.STAGE, stage_id)
hook_task(player, CONDITIONId.ANY_ELITE_STAGE, 1)
tlog_action.log('RoundFlow', player, stage_id, 2, 0, 1)
else:
tlog_action.log('RoundFlow', player, stage_id, 2, 0, 0)
def add_hero(self, hero_no):
hero = Hero(self.owner.base_info.id)
hero.hero_no = hero_no
self._heros[hero_no] = hero
self.new_hero_data(hero)
self.save_hero_to_line_up(hero_no)
hero_conf = game_configs.hero_config.get(hero_no)
if hero_conf.color == 3:
if not (hero_no in self.owner.base_info.heads.head):
self.owner.base_info.heads.head.append(hero_no)
self.owner.base_info.save_data()
cid = 0
color = hero_conf.color
color_num = 0
star6_num = 0
if hero_conf.color == 1:
cid = CONDITIONId.GREEN_HERO
elif hero_conf.color == 2:
cid = CONDITIONId.BLUE_HERO
elif hero_conf.color == 3:
cid = CONDITIONId.PURPLE_HERO
for hero_no, hero_obj in self._heros.items():
h_conf = game_configs.hero_config.get(hero_no)
if h_conf.color == color:
color_num += 1
if h_conf.quality == 6:
star6_num += 1
if cid and color_num:
hook_task(self.owner, cid, color_num)
if star6_num:
hook_task(self.owner, CONDITIONId.STAR6_HERO, star6_num)
return hero
def shop_oper(pro_data, player, reason):
"""商城所有操作"""
request = ShopRequest()
request.ParseFromString(pro_data)
response = ShopResponse()
shop_id = request.ids[0]
shop_item = game_configs.shop_config.get(shop_id)
# logger.debug(shop_id)
# logger.debug("---------")
if shop_id == 10001 and player.shop.first_coin_draw:
is_consume(player, shop_item)
card_draw = game_configs.base_config.get("CoinCardFirst")
return_data = gain(player, card_draw, reason) # 获取
get_return(player, return_data, response.gain)
player.shop.single_coin_draw_times += 1
player.shop.first_coin_draw = False
player.shop.save_data()
hook_task(player, CONDITIONId.HERO_GET_LIANG, 1)
response.res.result = True
return response.SerializeToString()
if shop_id == 50001 and player.shop.first_gold_draw:
is_consume(player, shop_item)
card_draw = game_configs.base_config.get("CardFirst")
return_data = gain(player, card_draw, reason) # 获取
get_return(player, return_data, response.gain)
player.shop.first_gold_draw = False
player.shop.single_gold_draw_times += 1
player.shop.save_data()
hook_task(player, CONDITIONId.HERO_GET, 1)
response.res.result = True
return response.SerializeToString()
_is_consume_result = is_consume(player, shop_item)
price = shop_item.consume
if _is_consume_result:
result = is_afford(player, price) # 校验
if not result.get('result'):
if not shop_item.alternativeConsume:
logger.error('shop oper is not enough consume')
response.res.result = False
response.res.result_no = result.get('result_no')
response.res.message = u'消费不足！'
return response.SerializeToString()
else:
price = shop_item.alternativeConsume
result = is_afford(player, price)
if not result.get('result'):
response.res.result = False
response.res.result_no = result.get('result_no')
response.res.message = u'消费不足2！'
return response.SerializeToString()
player_type_shop = player.shop.get_shop_data(shop_item.get('type'))
if not player_type_shop:
response.res.result = False
logger.error('no type shop:%s', shop_item.get('type'))
return response.SerializeToString()
shop_type_item = game_configs.shop_type_config.get(shop_item.get('type'))
# 消耗
need_gold = get_consume_gold_num(price)
if not _is_consume_result:
need_gold = 0
def func():
# consume_data = []
if _is_consume_result:
return_data = consume(player, price,
player_type_shop, reason, shop_type_item)
get_return(player, return_data, response.consume)
# consume_data = return_data
# logger.debug("hero-draw2")
return_data = []
extra_return_data = []
CoinCardCumulateTimes = game_configs.base_config.get("CoinCardCumulateTimes", 0)
CardCumulateTimes = game_configs.base_config.get("CardCumulateTimes", 0)
if shop_item.type == 5:
# todo: 如何判断shop类型：单抽、十连抽
# logger.debug("hero_draw: shop_item_id %s, item_no %s" % (shop_item.id, shop_item.gain[0].item_no))
gain_items = player.shop.get_draw_drop_bag(shop_item.gain[0].item_no)
if shop_item.id == 50001:
# 单抽达到指定次数，获得指定武将
player.shop.single_gold_draw_times += 1
if player.shop.single_gold_draw_times == CardCumulateTimes:
gain_items = game_configs.base_config.get("CardCumulate", [])
player.shop.single_gold_draw_times = 0
logger.debug("tenth gold draw %s %s" % (player.shop.single_gold_draw_times, gain_items))
player.shop.save_data()
return_data = gain(player, gain_items, reason)
extra_return_data = gain(player, shop_item.extraGain, reason) # 额外获取
get_return(player, return_data, response.gain)
get_return(player, extra_return_data, response.gain)
if need_gold > 0 and shop_item.ExchangeValue:
lucky_data = gain(player,
shop_item.ExchangeValue,
reason)
get_return(player, lucky_data, response.gain)
if shop_item.id == 50001:
hook_task(player, CONDITIONId.HERO_GET, 1)
else:
hook_task(player, CONDITIONId.HERO_GET, 10)
else:
gain_items = shop_item.gain
if shop_item.id == 10001:
# 单抽达到指定次数，获得指定武将
player.shop.single_coin_draw_times += 1
if player.shop.single_coin_draw_times == CoinCardCumulateTimes:
gain_items = game_configs.base_config.get("CoinCardCumulate", [])
player.shop.single_coin_draw_times = 0
logger.debug("tenth coin draw %s %s" % (player.shop.single_coin_draw_times, gain_items))
player.shop.save_data()
return_data = gain(player, gain_items, reason) # 获取
extra_return_data = gain(player, shop_item.extraGain, reason) # 额外获取
get_return(player, return_data, response.gain)
get_return(player, extra_return_data, response.gain)
if need_gold > 0 and shop_item.ExchangeValue:
lucky_data = gain(player,
shop_item.ExchangeValue,
reason)
get_return(player, lucky_data, response.gain)
if shop_item.id == 10001:
hook_task(player, CONDITIONId.HERO_GET_LIANG, 1)
else:
hook_task(player, CONDITIONId.HERO_GET_LIANG, 10)
send_tlog(player, shop_item)
player.pay.pay(need_gold, reason, func)
response.res.result = True
logger.debug("response gain %s" % response.gain)
return response.SerializeToString()
def travel_831(data, player):
"""游历"""
args = TravelRequest()
args.ParseFromString(data)
stage_id = args.stage_id
response = TravelResponse()
open_stage_id = game_configs.base_config.get('travelOpenStage')
if player.stage_component.get_stage(open_stage_id).state != 1:
response.res.result = False
response.res.result_no = 837
return response.SerializeToString()
if game_configs.base_config.get('travelOpenLevel') > player.base_info.level:
response.res.result = False
response.res.result_no = 811 # 等级不够
return response.SerializeToString()
# ====================判断够不够
need_items = game_configs.base_config.get('travelExpend')
result = is_afford(player, need_items) # 校验
if not result.get('result'):
response.res.result = False
response.res.result_no = 888
return response.SerializePartialToString()
travel_cache = player.travel_component.travel
travel_event_id = get_travel_event_id()
flag = 10
if travel_cache.get(stage_id):
for event in travel_cache.get(stage_id):
if travel_event_id == event[0] % xs:
flag += 1
else:
travel_cache[stage_id] = []
res_travel_event_id = flag * xs + travel_event_id
event_info = game_configs.travel_event_config.get('events').get(travel_event_id)
if not event_info:
logger.error('get travel event config error')
response.res.result = False
response.res.result_no = 800 # 未知错误
return response.SerializeToString()
response.event_id = res_travel_event_id
res_drops = response.drops
drops = get_drops(stage_id)
drop_data = get_drop_data(drops)
get_return(player, drop_data, res_drops)
# 等待 战斗 答题 领取
if event_info.type == 4:
gain(player, drops, const.TRAVEL)
else:
travel_cache.get(stage_id).append([res_travel_event_id, drops])
# ====================消耗
return_data = consume(player, need_items, const.TRAVEL)
get_return(player, return_data, response.consume)
player.travel_component.save()
hook_task(player, CONDITIONId.TRAVEL, 1)
response.res.result = True
return response.SerializeToString()
def pvb_fight_start_1705(pro_data, player):
"""开始战斗
"""
logger.debug("fight start..")
request = world_boss_pb2.PvbStartRequest()
request.ParseFromString(pro_data)
best_skill_id = request.unparalleled # 无双编号
line_up = request.lineup
boss_id = request.boss_id
boss = player.world_boss.get_boss(boss_id)
base_config = boss.get_base_config()
debuff_skill_no = boss.debuff_skill_no
response = PvbFightResponse()
res = response.res
if player.base_info.is_firstday_from_register(
const.OPEN_FEATURE_WORLD_BOSS):
response.res.result = False
response.res.result_no = 150901
return response.SerializeToString()
stage_id = boss.stage_id
logger.debug("stage_id,%s" % stage_id)
WORLD_BOSS = 7
stage_info = pve_process(stage_id, WORLD_BOSS, line_up, 0, player)
result = stage_info.get('result')
res.result = result
if stage_info.get('result_no'):
res.result_no = stage_info.get('result_no')
if not result:
logger.info('进入关卡返回数据:%s', response)
return response.SerializePartialToString(), stage_id
red_units = stage_info.get('red_units')
blue_units = stage_info.get('blue_units')
blue_units = blue_units[0]
blue_units[5].hp = remote_gate['world'].get_hp_left_remote(boss_id)
logger.debug("blue_units===========%s" % blue_units[5].hp)
logger.debug("--" * 40)
if blue_units[5].hp <= 0:
logger.debug("world boss already dead!")
response.res.result = False
response.res.result_no = 1705
return response.SerializePartialToString()
# 根据鼓舞次数，增加伤害百分比
damage_rate = boss.encourage_coin_num * base_config.get("coin_inspire_atk", 0) + \
boss.encourage_gold_num * base_config.get("gold_inspire_atk", 0)
# mock fight.
player_info = {}
player_info["player_id"] = player.base_info.id
player_info["vip_level"] = player.base_info.vip_level
player_info["now_head"] = player.base_info.heads.now_head
player_info["nickname"] = player.base_info.base_name
player_info["level"] = player.base_info.level
player_info["line_up_info"] = line_up_info(
player).SerializePartialToString()
str_red_units = cPickle.dumps(red_units)
str_blue_units = cPickle.dumps(blue_units)
logger.debug("--" * 40)
print red_units
print blue_units
#red_best_skill_no, red_best_skill_level = player.line_up_component.get_skill_info_by_unpar(best_skill_id)
seed1, seed2 = get_seeds()
#def pvb_fight_remote(str_red_units, red_best_skill, red_best_skill_level, str_blue_units, player_info, boss_id, seed1, seed2):
red_unpar_data = player.line_up_component.get_red_unpar_data()
result, demage_hp = remote_gate['world'].pvb_fight_remote(
str_red_units, red_unpar_data, str_blue_units, player_info, boss_id,
damage_rate, debuff_skill_no, seed1, seed2)
if result == -1:
logger.debug("world boss already gone!")
response.res.result = False
response.res.result_no = 1706
return response.SerializePartialToString()
response.fight_result = result
# 玩家信息更新
boss.fight_times += 1
boss.demages.append(demage_hp)
boss.last_fight_time = get_current_timestamp()
player.world_boss.save_data()
logger.debug("fight end..")
pvp_assemble_units(red_units, blue_units, response)
response.red_best_skill = best_skill_id
response.red_best_skill_level = 0
response.debuff_skill_no = debuff_skill_no
response.seed1 = seed1
response.seed2 = seed2
response.damage_rate = damage_rate
if boss_id == 'world_boss':
hook_task(player, CONDITIONId.PVBOSS_TIMES, 1)
return response.SerializePartialToString()
def func():
# 武将乱入
fight_cache_component = player.fight_cache_component
fight_cache_component.stage_id = stage_id
red_units, blue_units, drop_num, monster_unpara = fight_cache_component.fighting_start(
)
multiple, part_multiple = get_drop_activity(
player, player.fight_cache_component.stage_id, 1,
stage_obj.star_num)
for _ in range(times):
drop = []
drops = response.drops.add()
low = stage_config.low
high = stage_config.high
drop_num = random.randint(low, high)
for __ in range(drop_num):
common_bag = BigBag(stage_config.commonDrop)
common_drop = common_bag.get_drop_items()
drop.extend(common_drop)
fight_cache_component.get_stage_drop(stage_config, drop)
data = gain(player,
drop,
const.STAGE_SWEEP,
event_id=tlog_event_id,
multiple=multiple,
part_multiple=part_multiple)
get_return(player, data, drops)
# 乱入武将按概率获取碎片
break_stage_id = player.fight_cache_component.break_stage_id
if break_stage_id:
break_stage_info = game_configs.stage_break_config.get(
break_stage_id)
ran = random.random()
if ran <= break_stage_info.reward_odds:
# logger.debug("break_stage_info=============%s %s" % (break_stage_info.reward, 1))
data = gain(player, break_stage_info.reward,
const.STAGE_SWEEP)
get_return(player, data, drops)
player.finance.consume(const.STAMINA, stage_config.vigor,
const.STAGE_SWEEP)
# 经验
for (slot_no, lineUpSlotComponent
) in player.line_up_component.line_up_slots.items():
hero = lineUpSlotComponent.hero_slot.hero_obj
if hero:
beforelevel = hero.level
hero.upgrade(stage_config.HeroExp, player.base_info.level)
afterlevel = hero.level
changelevel = afterlevel - beforelevel
hero.save_data()
if changelevel:
tlog_action.log('HeroUpgrade', player, hero.hero_no,
changelevel, afterlevel, 3, 0, 0, 0, 0)
# 玩家金钱
player.finance.coin += stage_config.currency
# 玩家经验
player.base_info.addexp(stage_config.playerExp, const.STAGE_SWEEP)
# 更新等级相关属性
player.set_level_related()
# hook task
hook_task(player, CONDITIONId.ANY_STAGE, times)
logger.debug("sweep time %s %s" % (times, sweep_item))
return_data = consume(player,
sweep_item,
const.STAGE_SWEEP,
multiple=times)
get_return(player, return_data, response.consume)
player.stage_component.get_stage(stage_id).attacks += times
player.stage_component.save_data()
player.stamina.save_data()
player.base_info.save_data()
player.finance.save_data()
def battle_2103(pro_data, player):
"""
开始战斗
request:HjqyBattleRequest
response:HjqyBattleResponse
"""
request = hjqy_pb2.HjqyBattleRequest()
request.ParseFromString(pro_data)
response = hjqy_pb2.HjqyBattleResponse()
if player.base_info.is_firstday_from_register(const.OPEN_FEATURE_HJQY):
response.res.result = False
response.res.result_no = 150901
return response.SerializeToString()
boss_id = request.owner_id
attack_type = request.attack_type # 全力一击，普通攻击
logger.debug("request %s" % request)
hjqyExchangeBUFFTime = game_configs.base_config.get("hjqyExchangeBUFFTime")
hjqyItemRate = game_configs.base_config.get("hjqyItemRate")
hjqyExchangeBUFFNumber = game_configs.base_config.get(
"hjqyExchangeBUFFNumber")
hjqyExchangeNumber = game_configs.base_config.get("hjqyExchangeNumber")
need_hjqy_fight_token = hjqyExchangeNumber
if attack_type == 2:
need_hjqy_fight_token = hjqyExchangeBUFFNumber
if is_in_period(hjqyExchangeBUFFTime) and attack_type == 2:
need_hjqy_fight_token = need_hjqy_fight_token * hjqyItemRate
if need_hjqy_fight_token > player.finance[const.HJQYFIGHTTOKEN]:
logger.error("hjqy coin not enough！")
response.res.result = False
response.res.result_no = 210301
return response.SerializePartialToString()
data = remote_gate['world'].get_boss_info_remote(boss_id)
if not data or data.get('state') == const.BOSS_DEAD:
logger.error("hjqy boss dead！")
response.res.result = False
response.res.result_no = 210302
return response.SerializePartialToString()
if data.get('state') == const.BOSS_RUN_AWAY:
logger.error("hjqy boss run away！")
response.res.result = False
response.res.result_no = 210303
return response.SerializePartialToString()
stage_id = data.get("stage_id")
player.fight_cache_component.stage_id = stage_id
red_units = player.fight_cache_component.get_red_units()
blue_units = cPickle.loads(remote_gate['world'].blue_units_remote(boss_id))
seed1, seed2 = get_seeds()
player_info = dict(player_id=player.base_info.id,
nickname=player.base_info.base_name,
user_icon=player.base_info.heads.now_head,
level=player.base_info.level)
str_red_units = cPickle.dumps(red_units)
red_unpar_data = player.line_up_component.get_red_unpar_data()
fight_result, boss_state, current_damage_hp, is_kill = remote_gate[
'world'].hjqy_battle_remote(player_info, boss_id, str_red_units,
red_unpar_data, attack_type, seed1, seed2)
logger.debug("============battle over")
# 消耗讨伐令
player.finance.consume(const.HJQYFIGHTTOKEN, need_hjqy_fight_token,
const.HJQY_BATTLE)
# 功勋奖励
hjqyMeritoriousServiceOpenTime = game_configs.base_config.get(
"hjqyMeritoriousServiceOpenTime")
hjqyMeritoriousServiceRate = game_configs.base_config.get(
"hjqyMeritoriousServiceRate")
meritorious_service = player.fight_cache_component._get_stage_config(
).meritorious_service
logger.debug("========= %s %s ========" %
(is_in_period(hjqyMeritoriousServiceOpenTime),
hjqyMeritoriousServiceOpenTime))
if is_in_period(hjqyMeritoriousServiceOpenTime): # 增加功勋的活动
meritorious_service = meritorious_service * hjqyMeritoriousServiceRate
player.finance.add(const.HJQYCOIN,
meritorious_service,
reason=const.HJQY_BATTLE)
player.finance.save_data()
response.fight_result = fight_result
pvp_assemble_units(red_units, blue_units, response)
response.seed1 = seed1
response.seed2 = seed2
response.attack_type = attack_type
response.hjqy_coin = meritorious_service
response.stage_id = stage_id
response.res.result = True
hook_task(player, CONDITIONId.HJQY, 1)
tlog_action.log('BattleHJQY', player, boss_id, is_kill)
# start target
all_current_damage_hp = remote_gate['world'].\
hjqy_damage_hp_remote(player.base_info.id)
player.act.condition_update(38, current_damage_hp)
player.act.condition_update(39, all_current_damage_hp)
# 更新 七日奖励
target_update(player, [38, 39])
return response.SerializePartialToString()
def settle(player, fight_result):
rank_incr = 0
response.top_rank = player.pvp.pvp_high_rank
if fight_result:
logger.debug("fight result:True:%s:%s",
before_player_rank, request.challenge_rank)
_arena_win_points = game_configs.base_config.get('arena_win_points')
if _arena_win_points:
return_data = gain(player, _arena_win_points, const.ARENA_WIN)
get_return(player, return_data, response.gain)
else:
logger.debug('arena win points is not find')
push_config = game_configs.push_config[1003]
rank_count = push_config.conditions[0]
if request.challenge_rank - before_player_rank >= rank_count:
txt = game_configs.push_config[1003].text
message = game_configs.language_config.get(str(txt)).get('cn')
remote_gate['push'].add_push_message_remote(player.base_info.id, 3,
message, int(time.time()))
push_message('add_blacklist_request_remote', target_id,
player.base_info.id)
if request.challenge_rank < before_player_rank:
tb_pvp_rank.zadd(request.challenge_rank, player.base_info.id,
before_player_rank, target_id)
send_mail(conf_id=123, receive_id=target_id,
pvp_rank=before_player_rank,
nickname=player.base_info.base_name)
if request.challenge_rank < player.pvp.pvp_high_rank:
rank_incr = player.pvp.pvp_high_rank - request.challenge_rank
if player.pvp.pvp_high_rank > request.challenge_rank:
hook_task(player, CONDITIONId.PVP_RANK, request.challenge_rank)
player.pvp.pvp_high_rank = min(player.pvp.pvp_high_rank,
request.challenge_rank)
logger.debug(" history_high_rank %s current %s" % (player.pvp.pvp_high_rank, before_player_rank))
# 首次达到某名次的奖励
arena_rank_up_rewards = game_configs.base_config.get('arenaRankUpRewards')
if arena_rank_up_rewards:
return_data = gain(player, arena_rank_up_rewards,
const.ARENA_WIN, multiple=rank_incr)
get_return(player, return_data, response.award)
else:
logger.debug('arena rank up points is not find')
else:
logger.debug("fight result:False")
send_mail(conf_id=124, receive_id=target_id,
nickname=player.base_info.base_name)
hook_task(player, CONDITIONId.PVP_RANk_TIMES, 1)
player.pvp.pvp_times -= 1
player.pvp.pvp_refresh_time = time.time()
player.pvp.save_data()
response.res.result = True
# response.top_rank = player.pvp.pvp_high_rank
response.rank_incr = rank_incr
logger.debug(response)
return response.SerializeToString()
def boss_task_remote(num, is_online, player):
if is_online:
hook_task(player, CONDITIONId.PVBOSS, num)
else:
update_condition(player, CONDITIONId.PVBOSS, num)
return True
def gain(player, item_group, reason,
result=None,
multiple=1,
event_id='',
part_multiple=[],
lucky_attr_id=0):
"""获取
@param item_group: [obj,obj]
act 掉落翻倍. [[type_ids], xs] [[翻倍类型列表]，系数]
"""
if result is None:
result = []
after_num = 0
itid = 0
for group_item in item_group:
type_id = group_item.item_type
num = int(group_item.num * multiple)
item_no = group_item.item_no
multiple2 = 1
for _part_multiple in part_multiple:
_times = _part_multiple["times"]
_item_type = _part_multiple["item_type"]
_item_ids = _part_multiple["item_ids"]
if type_id == _item_type:
if not _item_ids[0] or item_no in _item_ids:
multiple2 = _times
logger.debug("multiple %s multiple2 %s" % (multiple, multiple2))
num = int(multiple2 * num)
front_type_id = type_id # 记录类型，用于武将已存在的情况。
if type_id == const.COIN:
player.finance.coin += num
player.finance.save_data()
after_num = player.finance.coin
elif type_id == const.RESOURCE:
if item_no == 27:
hook_task(player, CONDITIONId.GGZJ, num)
elif item_no == const.TEAM_EXPERIENCE:
player.base_info.addexp(num, reason)
player.base_info.save_data()
after_num = player.base_info.exp
else:
player.finance.add(item_no, num)
player.finance.save_data()
after_num = player.finance[item_no]
if item_no == 1 or item_no == 2:
tlog_action.log('MoneyFlow', player, after_num, num, reason,
const.ADD, item_no)
elif type_id == const.GOLD:
player.finance.add_gold(num, 0)
player.finance.save_data()
elif type_id == const.HERO_SOUL:
player.finance.hero_soul += num
player.finance.save_data()
elif type_id == const.PVP:
player.finance.pvp_score += num
player.finance.save_data()
elif type_id == const.HERO_CHIP:
if game_configs.chip_config.get('chips').get(item_no):
hero_chip = HeroChip(item_no, num)
player.hero_chip_component.add_chip(hero_chip)
player.hero_chip_component.save_data()
after_num = player.hero_chip_component.get_chip(item_no).num
else:
logger.error('chip config not found:%', item_no)
elif type_id == const.ITEM:
item = Item(item_no, num)
player.item_package.add_item(item)
player.item_package.save_data()
after_num = player.item_package.get_item(item_no).num
elif type_id == const.HERO:
is_have = player.hero_component.contain_hero(item_no)
if not is_have:
num -= 1
if num != 0:
# 已经存在该武将，自动转换为武将碎片
# 获取hero对应的hero_chip_no, hero_chip_num
hero_chip_config_item = game_configs.chip_config.get("mapping").get(item_no)
hero_chip_no = hero_chip_config_item.id
CardImparirment = 1
if reason == const.SHOP_DRAW_HERO:
CardImparirment = game_configs.base_config.get("CardImparirment")
hero_chip_num = int(hero_chip_config_item.needNum * num * CardImparirment)
hero_chip = HeroChip(hero_chip_no, hero_chip_num)
player.hero_chip_component.add_chip(hero_chip)
player.hero_chip_component.save_data()
after_num = player.hero_chip_component.get_chip(hero_chip_no).num
result.append([const.HERO_CHIP, hero_chip_num, hero_chip_no])
tlog_action.log('ItemFlow', player, const.ADD, type_id,
hero_chip_num, hero_chip_no, itid, reason,
after_num, event_id)
if not is_have:
hero = player.hero_component.add_hero(item_no)
notice_item = game_configs.notes_config.get(2002)
logger.debug("=================%s %s %s" % (reason, hero.hero_info.quality, notice_item.parameter1))
if reason == const.SHOP_DRAW_HERO and hero.hero_info.quality in notice_item.parameter1:
push_notice(2002, player_name=player.base_info.base_name, hero_no=item_no)
after_num = 1
result.append([type_id, 1, item_no])
tlog_action.log('ItemFlow', player, const.ADD, type_id,
1, item_no, itid, reason,
after_num, event_id)
elif type_id == const.BIG_BAG:
big_bag = BigBag(item_no)
for i in range(num):
temp = big_bag.get_drop_items()
gain(player, temp, reason, result)
return result
elif type_id == const.EQUIPMENT:
for _ in range(num):
itid = item_no
equipment = player.equipment_component.add_equipment(itid, lucky_attr_id)
equ_item_no = equipment.base_info.id
after_num = player.equipment_component.get_equipment_num(itid)
notice_item = game_configs.notes_config.get(2004)
if reason == const.COMMON_BUY_PVP and equipment.equipment_config_info.quality in notice_item.parameter1:
push_notice(2004, player_name=player.base_info.base_name, equipment_no=itid)
notice_item = game_configs.notes_config.get(2005)
if reason ==const.COMMON_BUY_MELT and equipment.equipment_config_info.quality in notice_item.parameter1:
push_notice(2005, player_name=player.base_info.base_name, equipment_no=itid)
notice_item = game_configs.notes_config.get(2006)
if reason == const.COMMON_BUY_EQUIPMENT and equipment.equipment_config_info.quality in notice_item.parameter1:
push_notice(2006, player_name=player.base_info.base_name, equipment_no=itid)
result.append([type_id, 1, equ_item_no])
tlog_action.log('ItemFlow', player, const.ADD, type_id, 1,
itid, item_no, reason, after_num, event_id)
elif type_id == const.EQUIPMENT_CHIP:
if game_configs.chip_config.get('chips').get(item_no):
chip = EquipmentChip(item_no, num)
player.equipment_chip_component.add_chip(chip)
player.equipment_chip_component.save_data()
after_num = player.equipment_chip_component.get_chip(item_no).chip_num
else:
logger.error('chip config not found:%', item_no)
elif type_id == const.STAMINA:
player.stamina.stamina += num
# logger.debug(str(num)+" , stamina+++++++++++")
player.stamina.save_data()
elif type_id == const.TEAM_EXPERIENCE:
player.base_info.addexp(num, reason)
player.base_info.save_data()
elif type_id == const.TRAVEL_ITEM:
after_num = num
stage_id = game_configs.travel_item_config.get('items').get(item_no).stageId
flag1 = 1
flag2 = 0
stage_item_info = player.travel_component.travel_item.get(stage_id)
for [travel_item_id, travel_item_num] in stage_item_info:
if travel_item_id == item_no:
the_num = travel_item_num + num
stage_item_info[flag2] = \
[travel_item_id, the_num]
flag1 = 0
after_num = the_num
break
flag2 += 1
if flag1:
stage_item_info.append([item_no, num])
player.travel_component.save()
elif type_id == const.RUNT:
for _ in range(num):
runt_id = player.runt.add_runt(item_no)
result.append([type_id, 1, runt_id])
player.runt.save()
after_num = player.runt.get_runt_num(item_no)
if type_id == const.COIN or type_id == const.GOLD:
tlog_action.log('MoneyFlow', player, after_num, num, reason,
const.ADD, item_no)
is_over = False # 是否累加
for i in result:
if i[0] == type_id and i[2] == item_no and (front_type_id != const.HERO and type_id != const.HERO_CHIP and type_id != const.RUNT and type_id != const.EQUIPMENT and type_id != const.HERO):
i[1] += num
is_over = True
continue
if not is_over and type_id !=const.RUNT and type_id != const.HERO and type_id != const.EQUIPMENT:
result.append([type_id, num, item_no])
# ====tlog======
if type_id != const.TEAM_EXPERIENCE and type_id != const.EQUIPMENT and type_id != const.HERO:
tlog_action.log('ItemFlow', player, const.ADD, type_id, num,
item_no, itid, reason, after_num, event_id)
# ==============
return result
def travel_831(data, player):
"""游历"""
args = TravelRequest()
args.ParseFromString(data)
stage_id = args.stage_id
response = TravelResponse()
if is_not_open(player, FO_TRAVEL):
response.res.result = False
response.res.result_no = 811 # 等级不够
return response.SerializeToString()
# ====================判断够不够
need_items = game_configs.base_config.get('travelExpend')
result = is_afford(player, need_items) # 校验
if not result.get('result'):
response.res.result = False
response.res.result_no = 888
return response.SerializePartialToString()
travel_cache = player.travel_component.travel
travel_event_id = get_travel_event_id()
flag = 10
if travel_cache.get(stage_id):
for event in travel_cache.get(stage_id):
if travel_event_id == event[0] % xs:
flag += 1
else:
travel_cache[stage_id] = []
res_travel_event_id = flag * xs + travel_event_id
event_info = game_configs.travel_event_config.get('events').get(
travel_event_id)
if not event_info:
logger.error('get travel event config error')
response.res.result = False
response.res.result_no = 800 # 未知错误
return response.SerializeToString()
response.event_id = res_travel_event_id
res_drops = response.drops
drops = get_drops(stage_id)
drop_data = get_drop_data(drops)
get_return(player, drop_data, res_drops)
# 等待 战斗 答题 领取
if event_info.type == 4:
gain(player, drops, const.TRAVEL)
else:
travel_cache.get(stage_id).append([res_travel_event_id, drops])
# ====================消耗
return_data = consume(player, need_items, const.TRAVEL)
get_return(player, return_data, response.consume)
player.travel_component.save()
hook_task(player, CONDITIONId.TRAVEL, 1)
response.res.result = True
return response.SerializeToString()
def trigger_boss_2402(pro_data, player):
"""召唤圣兽
"""
guild_boss_open_time_item = game_configs.base_config.get("AnimalOpenTime")
response = guild_pb2.TriggerGuildBossResponse()
response.res.result = False
if not is_in_period(guild_boss_open_time_item):
logger.debug("feature not open!")
response.res.result_no = 30000
return response.SerializeToString()
request = guild_pb2.TriggerGuildBossRequest()
request.ParseFromString(pro_data)
logger.debug("request %s" % request)
boss_type = request.boss_type
trigger_stone_num = player.finance[const.GUILD_BOSS_TRIGGER_STONE]
data = remote_gate['world'].guild_boss_init_remote(player.guild.g_id)
build = data.get("build")
guild_boss_trigger_times = data.get("guild_boss_trigger_times")
guild_boss_item = game_configs.guild_config.get(4).get(build.get(4))
logger.debug("guild_boss_item %s" % guild_boss_item)
boss_open_item = guild_boss_item.animalOpen.get(boss_type)
stage_id = boss_open_item[0]
consume_num = boss_open_item[2]
# 召唤石是否足够
if trigger_stone_num < boss_open_item[2]:
logger.debug("trigger stone is not enough!")
response.res.result_no = 240201
return response.SerializeToString()
# 召唤次数是否达到上限
if guild_boss_trigger_times >= guild_boss_item.animalOpenTime:
logger.debug("trigger times reach the max!")
response.res.result_no = 240202
return response.SerializeToString()
# 军团等级是否满足此类型boss
if not boss_open_item[1]:
logger.debug("guild level is not enough!")
response.res.result_no = 240204
return response.SerializeToString()
res = remote_gate['world'].guild_boss_add_remote(
player.guild.g_id, stage_id, boss_type, player.base_info.id,
player.base_info.base_name)
response.res.result = res.get("result")
if not res.get("result"):
response.res.result_no = res.get("result_no")
return response.SerializeToString()
player.finance.consume(const.GUILD_BOSS_TRIGGER_STONE, consume_num, 0)
return_data = [[const.RESOURCE, consume_num, 15]]
logger.debug(return_data)
get_return(player, return_data, response.consume)
player.guild.guild_boss_last_attack_time["boss_id"] = res.get(
"guild_boss").get("boss_id")
player.guild.guild_boss_last_attack_time["time"] = 0
logger.debug("guild_boss_last_attack_time %s " %
(player.guild.guild_boss_last_attack_time))
construct_boss_pb(res.get("guild_boss"), response.guild_boss)
logger.debug("response %s" % response)
remote_gate.push_object_character_remote(
24021, construct_init_data(player),
player.guild.get_guild_member_ids(res.get("p_list", {})))
# add guild activity times
player.guild_activity.add_guild_boss_times(
res.get("guild_boss").get("boss_type"))
player.act.add_guild_boss_times(res.get("guild_boss").get("boss_type"))
hook_task(player, CONDITIONId.GUILD_BOSS, 1)
tlog_action.log('TriggerBoss', player, player.guild.g_id, boss_type)
return response.SerializeToString()
def pvb_fight_start_1705(pro_data, player):
"""开始战斗
"""
logger.debug("fight start..")
request = world_boss_pb2.PvbStartRequest()
request.ParseFromString(pro_data)
print request, "request"
best_skill_id = request.unparalleled # 无双编号
line_up = request.lineup
boss_id = request.boss_id
boss = player.world_boss.get_boss(boss_id)
base_config = boss.get_base_config()
debuff_skill_no = boss.debuff_skill_no
response = PvbFightResponse()
res = response.res
print("world_boss_line_up:", line_up)
open_stage_id = game_configs.base_config.get('worldbossOpenStage')
if player.stage_component.get_stage(open_stage_id).state != 1:
response.res.result = False
response.res.result_no = 837
return response.SerializeToString()
if player.base_info.is_firstday_from_register(const.OPEN_FEATURE_WORLD_BOSS):
response.res.result = False
response.res.result_no = 150901
return response.SerializeToString()
stage_id = boss.stage_id
logger.debug("stage_id,%s" % stage_id)
WORLD_BOSS = 6
stage_info = pve_process(stage_id, WORLD_BOSS, line_up, 0, player, best_skill_id)
result = stage_info.get('result')
res.result = result
if stage_info.get('result_no'):
res.result_no = stage_info.get('result_no')
if not result:
logger.info('进入关卡返回数据:%s', response)
return response.SerializePartialToString(), stage_id
red_units = stage_info.get('red_units')
blue_units = stage_info.get('blue_units')
blue_units = blue_units[0]
blue_units[5].hp = remote_gate['world'].get_hp_left_remote(boss_id)
logger.debug("blue_units===========%s" % blue_units[5].hp)
logger.debug("--" * 40)
if blue_units[5].hp <= 0:
logger.debug("world boss already dead!")
response.res.result = False
response.res.result_no = 1705
return response.SerializePartialToString()
# 根据鼓舞次数，增加伤害百分比
damage_rate = boss.encourage_coin_num * base_config.get("coin_inspire_atk", 0) + \
boss.encourage_gold_num * base_config.get("gold_inspire_atk", 0)
# mock fight.
player_info = {}
player_info["player_id"] = player.base_info.id
player_info["now_head"] = player.base_info.heads.now_head
player_info["nickname"] = player.base_info.base_name
player_info["level"] = player.base_info.level
player_info["line_up_info"] = line_up_info(player).SerializePartialToString()
str_red_units = cPickle.dumps(red_units)
str_blue_units = cPickle.dumps(blue_units)
logger.debug("--" * 40)
print red_units
print blue_units
red_best_skill_no, red_best_skill_level = player.line_up_component.get_skill_info_by_unpar(best_skill_id)
seed1, seed2 = get_seeds()
#def pvb_fight_remote(str_red_units, red_best_skill, red_best_skill_level, str_blue_units, player_info, boss_id, seed1, seed2):
result, demage_hp = remote_gate['world'].pvb_fight_remote(str_red_units,
best_skill_id, red_best_skill_level, str_blue_units, player_info, boss_id, damage_rate, debuff_skill_no, seed1, seed2)
if result == -1:
logger.debug("world boss already gone!")
response.res.result = False
response.res.result_no = 1706
return response.SerializePartialToString()
response.fight_result = result
# 玩家信息更新
boss.fight_times += 1
boss.demages.append(demage_hp)
boss.last_fight_time = get_current_timestamp()
player.world_boss.save_data()
logger.debug("fight end..")
pvp_assemble_units(red_units, blue_units, response)
response.red_best_skill= best_skill_id
response.red_best_skill_level = red_best_skill_level
response.debuff_skill_no = debuff_skill_no
response.seed1 = seed1
response.seed2 = seed2
response.damage_rate = damage_rate
if boss_id == 'world_boss':
hook_task(player, CONDITIONId.PVBOSS_TIMES, 1)
return response.SerializePartialToString()
def battle_2103(pro_data, player):
"""
开始战斗
request:HjqyBattleRequest
response:HjqyBattleResponse
"""
request = hjqy_pb2.HjqyBattleRequest()
request.ParseFromString(pro_data)
response = hjqy_pb2.HjqyBattleResponse()
if player.base_info.is_firstday_from_register(const.OPEN_FEATURE_HJQY):
response.res.result = False
response.res.result_no = 150901
return response.SerializeToString()
boss_id = request.owner_id
attack_type = request.attack_type # 全力一击，普通攻击
logger.debug("request %s" % request)
hjqyExchangeBUFFTime = game_configs.base_config.get("hjqyExchangeBUFFTime")
hjqyItemRate = game_configs.base_config.get("hjqyItemRate")
hjqyExchangeBUFFNumber = game_configs.base_config.get("hjqyExchangeBUFFNumber")
hjqyExchangeNumber = game_configs.base_config.get("hjqyExchangeNumber")
need_hjqy_fight_token = hjqyExchangeNumber
if attack_type == 2:
need_hjqy_fight_token = hjqyExchangeBUFFNumber
if is_in_period(hjqyExchangeBUFFTime) and attack_type == 2:
need_hjqy_fight_token = need_hjqy_fight_token * hjqyItemRate
if need_hjqy_fight_token > player.finance[const.HJQYFIGHTTOKEN]:
logger.error("hjqy coin not enough！")
response.res.result = False
response.res.result_no = 210301
return response.SerializePartialToString()
data = remote_gate['world'].get_boss_info_remote(boss_id)
if not data or data.get('state') == const.BOSS_DEAD:
logger.error("hjqy boss dead！")
response.res.result = False
response.res.result_no = 210302
return response.SerializePartialToString()
if data.get('state') == const.BOSS_RUN_AWAY:
logger.error("hjqy boss run away！")
response.res.result = False
response.res.result_no = 210303
return response.SerializePartialToString()
stage_id = data.get("stage_id")
player.fight_cache_component.stage_id = stage_id
red_units = player.fight_cache_component.get_red_units()
blue_units = cPickle.loads(remote_gate['world'].blue_units_remote(boss_id))
seed1, seed2 = get_seeds()
player_info = dict(player_id=player.base_info.id,
nickname=player.base_info.base_name,
user_icon=player.base_info.heads.now_head,
level=player.base_info.level)
str_red_units = cPickle.dumps(red_units)
red_unpar_data = player.line_up_component.get_red_unpar_data()
fight_result, boss_state, current_damage_hp, is_kill = remote_gate['world'].hjqy_battle_remote(player_info, boss_id, str_red_units, red_unpar_data, attack_type, seed1, seed2)
logger.debug("============battle over")
# 消耗讨伐令
player.finance.consume(const.HJQYFIGHTTOKEN, need_hjqy_fight_token, const.HJQY_BATTLE)
# 功勋奖励
hjqyMeritoriousServiceOpenTime = game_configs.base_config.get("hjqyMeritoriousServiceOpenTime")
hjqyMeritoriousServiceRate = game_configs.base_config.get("hjqyMeritoriousServiceRate")
meritorious_service = player.fight_cache_component._get_stage_config().meritorious_service
logger.debug("========= %s %s ========"%(is_in_period(hjqyMeritoriousServiceOpenTime), hjqyMeritoriousServiceOpenTime ))
if is_in_period(hjqyMeritoriousServiceOpenTime): # 增加功勋的活动
meritorious_service = meritorious_service * hjqyMeritoriousServiceRate
player.finance.add(const.HJQYCOIN, meritorious_service, reason=const.HJQY_BATTLE)
player.finance.save_data()
response.fight_result = fight_result
pvp_assemble_units(red_units, blue_units, response)
response.seed1 = seed1
response.seed2 = seed2
response.attack_type = attack_type
response.hjqy_coin = meritorious_service
response.stage_id = stage_id
response.res.result = True
hook_task(player, CONDITIONId.HJQY, 1)
tlog_action.log('BattleHJQY', player, boss_id, is_kill)
# start target
all_current_damage_hp = remote_gate['world'].\
hjqy_damage_hp_remote(player.base_info.id)
player.act.condition_update(38, current_damage_hp)
player.act.condition_update(39, all_current_damage_hp)
# 更新 七日奖励
target_update(player, [38, 39])
return response.SerializePartialToString()
def battle_2403(pro_data, player):
"""
开始战斗
"""
request = guild_pb2.GuildBossBattleRequest()
request.ParseFromString(pro_data)
logger.debug("request %s" % request)
response = guild_pb2.GuildBossBattleResponse()
stage_id = request.stage_id
coolingTime = game_configs.base_config.get("AnimalCoolingTime")
# 冷却时间
if player.guild.guild_boss_last_attack_time.get("time") + coolingTime >= get_current_timestamp():
logger.error("attack still in colding time!")
response.res.result = False
response.res.result_no = 240301
return response.SerializePartialToString()
data = remote_gate['world'].guild_boss_init_remote(player.guild.g_id)
logger.debug("return data %s" % data)
boss_info = data.get("guild_boss")
line_up = player.line_up_component
player.fight_cache_component.stage_id = stage_id
red_units = player.fight_cache_component.get_red_units()
str_red_units = cPickle.dumps(red_units)
seed1, seed2 = get_seeds()
red_unpar_data = line_up.get_red_unpar_data()
res = remote_gate['world'].guild_boss_battle_remote(player.guild.g_id, str_red_units, red_unpar_data, seed1, seed2)
#boss_info = res.get("guild_boss")
blue_units = cPickle.loads(boss_info.get("blue_units"))
pvp_assemble_units(red_units, blue_units, response)
fight_result = res.get("fight_result")
stage_item = game_configs.special_stage_config.get("guild_boss_stages").get(stage_id)
return_data = gain(player,stage_item.Animal_Participate, const.GUILD_BOSS_IN)
get_return(player, return_data, response.gain)
response.fight_result = fight_result
if fight_result:
player.guild.guild_boss_last_attack_time["time"] = 0
player.guild.guild_boss_last_attack_time["time"] = int(get_current_timestamp())
player.guild.save_data()
response.seed1 = seed1
response.seed2 = seed2
response.guild_skill_point = res.get('guild_skill_point')
response.res.result = res.get("result")
if not res.get("result"):
response.res.result_no = res.get("result_no")
return response.SerializePartialToString()
# add guild activity times
player.guild_activity.add_guild_boss_times(boss_info.get("boss_type"))
player.act.add_guild_boss_times(boss_info.get("boss_type"))
hook_task(player, CONDITIONId.GUILD_BOSS, 1)
result = 0
if fight_result:
result = 1
tlog_action.log('GuildBossBattle', player, player.guild.g_id,
boss_info.get("boss_type"), result)
logger.debug("response %s" % response)
return response.SerializePartialToString()
def shop_oper(pro_data, player, reason):
"""商城所有操作"""
request = shop_pb2.ShopRequest()
request.ParseFromString(pro_data)
response = shop_pb2.ShopResponse()
shop_id = request.ids[0]
shop_item = game_configs.shop_config.get(shop_id)
# logger.debug(shop_id)
# logger.debug("---------")
# if shop_id == 10001 and player.shop.first_coin_draw:
# is_consume(player, shop_item)
# card_draw = game_configs.base_config.get("CoinCardFirst")
# return_data = gain(player, card_draw, reason) # 获取
# get_return(player, return_data, response.gain)
# player.shop.single_coin_draw_times += 1
# player.shop.first_coin_draw = False
# player.shop.save_data()
# hook_task(player, CONDITIONId.HERO_GET_LIANG, 1)
# response.res.result = True
# return response.SerializeToString()
if shop_id == 50001 and player.shop.first_gold_draw:
is_consume(player, shop_item)
card_draw = game_configs.base_config.get("CardFirst")
return_data = gain(player, card_draw, reason) # 获取
get_return(player, return_data, response.gain)
extra_return_data = gain(player, shop_item.extraGain, reason) # 额外获取
get_return(player, extra_return_data, response.gain)
player.shop.first_gold_draw = False
player.shop.single_gold_draw_times += 1
player.shop.save_data()
hook_task(player, CONDITIONId.HERO_GET, 1)
player.add_activity.add_pick_card(2, 1)
player.act.add_pick_card(2, 1)
response.res.result = True
return response.SerializeToString()
_is_consume_result = is_consume(player, shop_item)
price = shop_item.consume
if _is_consume_result:
result = is_afford(player, price) # 校验
if not result.get('result'):
if not shop_item.alternativeConsume:
logger.error('shop oper is not enough consume')
response.res.result = False
response.res.result_no = result.get('result_no')
response.res.message = u'消费不足！'
return response.SerializeToString()
else:
price = shop_item.alternativeConsume
result = is_afford(player, price)
if not result.get('result'):
response.res.result = False
response.res.result_no = result.get('result_no')
response.res.message = u'消费不足2！'
return response.SerializeToString()
player_type_shop = player.shop.get_shop_data(shop_item.get('type'))
if not player_type_shop:
response.res.result = False
logger.error('no type shop:%s', shop_item.get('type'))
return response.SerializeToString()
shop_type_item = game_configs.shop_type_config.get(shop_item.get('type'))
# 消耗
need_gold = get_consume_gold_num(price)
if not _is_consume_result:
need_gold = 0
def func():
# consume_data = []
if _is_consume_result:
return_data = consume(player,
price,
reason,
shop=player_type_shop,
luck_config=shop_type_item)
get_return(player, return_data, response.consume)
# consume_data = return_data
# logger.debug("hero-draw2")
return_data = []
extra_return_data = []
CoinCardCumulateTimes = game_configs.base_config.get(
"CoinCardCumulateTimes", 0)
CardCumulateTimes = game_configs.base_config.get(
"CardCumulateTimes", 0)
if shop_item.type == 5:
# todo: 如何判断shop类型：单抽、十连抽
# logger.debug("hero_draw: shop_item_id %s, item_no %s" % \
# (shop_item.id, shop_item.gain[0].item_no))
gain_items = player.shop.get_draw_drop_bag(
shop_item.gain[0].item_no)
if shop_item.id == 50001:
# 单抽达到指定次数，获得指定武将
player.shop.single_gold_draw_times += 1
if player.shop.single_gold_draw_times == CardCumulateTimes:
gain_items = game_configs.base_config.get(
"CardCumulate", [])
player.shop.single_gold_draw_times = 0
logger.debug(
"tenth gold draw %s %s" %
(player.shop.single_gold_draw_times, gain_items))
player.shop.save_data()
return_data = gain(player, gain_items, reason)
extra_return_data = gain(player, shop_item.extraGain,
reason) # 额外获取
get_return(player, return_data, response.gain)
get_return(player, extra_return_data, response.gain)
if need_gold > 0 and shop_item.ExchangeValue:
lucky_data = gain(player, shop_item.ExchangeValue, reason)
get_return(player, lucky_data, response.gain)
if shop_item.id == 50001:
player.add_activity.add_pick_card(2, 1)
player.act.add_pick_card(2, 1)
hook_task(player, CONDITIONId.HERO_GET, 1)
else:
player.add_activity.add_pick_card(2, 10)
player.act.add_pick_card(2, 10)
hook_task(player, CONDITIONId.HERO_GET, 10)
else:
gain_items = shop_item.gain
if shop_item.id == 10001:
# 单抽达到指定次数，获得指定武将
player.shop.single_coin_draw_times += 1
if player.shop.single_coin_draw_times == CoinCardCumulateTimes:
gain_items = game_configs.base_config.get(
"CoinCardCumulate", [])
player.shop.single_coin_draw_times = 0
logger.debug(
"tenth coin draw %s %s" %
(player.shop.single_coin_draw_times, gain_items))
player.shop.save_data()
return_data = gain(player, gain_items, reason) # 获取
extra_return_data = gain(player, shop_item.extraGain,
reason) # 额外获取
get_return(player, return_data, response.gain)
get_return(player, extra_return_data, response.gain)
if need_gold > 0 and shop_item.ExchangeValue:
lucky_data = gain(player, shop_item.ExchangeValue, reason)
get_return(player, lucky_data, response.gain)
if shop_item.id == 10001:
player.add_activity.add_pick_card(1, 1)
player.act.add_pick_card(1, 1)
hook_task(player, CONDITIONId.HERO_GET_LIANG, 1)
else:
player.add_activity.add_pick_card(1, 10)
player.act.add_pick_card(1, 10)
hook_task(player, CONDITIONId.HERO_GET_LIANG, 10)
send_tlog(player, shop_item)
tlog_action.log('ShopBuy1', player, shop_id)
player.pay.pay(need_gold, reason, func)
response.res.result = True
logger.debug("response gain %s" % response.gain)
return response.SerializeToString()
def func():
# consume_data = []
if _is_consume_result:
return_data = consume(player,
price,
reason,
shop=player_type_shop,
luck_config=shop_type_item)
get_return(player, return_data, response.consume)
# consume_data = return_data
# logger.debug("hero-draw2")
return_data = []
extra_return_data = []
CoinCardCumulateTimes = game_configs.base_config.get(
"CoinCardCumulateTimes", 0)
CardCumulateTimes = game_configs.base_config.get(
"CardCumulateTimes", 0)
if shop_item.type == 5:
# todo: 如何判断shop类型：单抽、十连抽
# logger.debug("hero_draw: shop_item_id %s, item_no %s" % \
# (shop_item.id, shop_item.gain[0].item_no))
gain_items = player.shop.get_draw_drop_bag(
shop_item.gain[0].item_no)
if shop_item.id == 50001:
# 单抽达到指定次数，获得指定武将
player.shop.single_gold_draw_times += 1
if player.shop.single_gold_draw_times == CardCumulateTimes:
gain_items = game_configs.base_config.get(
"CardCumulate", [])
player.shop.single_gold_draw_times = 0
logger.debug(
"tenth gold draw %s %s" %
(player.shop.single_gold_draw_times, gain_items))
player.shop.save_data()
return_data = gain(player, gain_items, reason)
extra_return_data = gain(player, shop_item.extraGain,
reason) # 额外获取
get_return(player, return_data, response.gain)
get_return(player, extra_return_data, response.gain)
if need_gold > 0 and shop_item.ExchangeValue:
lucky_data = gain(player, shop_item.ExchangeValue, reason)
get_return(player, lucky_data, response.gain)
if shop_item.id == 50001:
player.add_activity.add_pick_card(2, 1)
player.act.add_pick_card(2, 1)
hook_task(player, CONDITIONId.HERO_GET, 1)
else:
player.add_activity.add_pick_card(2, 10)
player.act.add_pick_card(2, 10)
hook_task(player, CONDITIONId.HERO_GET, 10)
else:
gain_items = shop_item.gain
if shop_item.id == 10001:
# 单抽达到指定次数，获得指定武将
player.shop.single_coin_draw_times += 1
if player.shop.single_coin_draw_times == CoinCardCumulateTimes:
gain_items = game_configs.base_config.get(
"CoinCardCumulate", [])
player.shop.single_coin_draw_times = 0
logger.debug(
"tenth coin draw %s %s" %
(player.shop.single_coin_draw_times, gain_items))
player.shop.save_data()
return_data = gain(player, gain_items, reason) # 获取
extra_return_data = gain(player, shop_item.extraGain,
reason) # 额外获取
get_return(player, return_data, response.gain)
get_return(player, extra_return_data, response.gain)
if need_gold > 0 and shop_item.ExchangeValue:
lucky_data = gain(player, shop_item.ExchangeValue, reason)
get_return(player, lucky_data, response.gain)
if shop_item.id == 10001:
player.add_activity.add_pick_card(1, 1)
player.act.add_pick_card(1, 1)
hook_task(player, CONDITIONId.HERO_GET_LIANG, 1)
else:
player.add_activity.add_pick_card(1, 10)
player.act.add_pick_card(1, 10)
hook_task(player, CONDITIONId.HERO_GET_LIANG, 10)
send_tlog(player, shop_item)
tlog_action.log('ShopBuy1', player, shop_id)
def battle_2403(pro_data, player):
"""
开始战斗
"""
request = guild_pb2.GuildBossBattleRequest()
request.ParseFromString(pro_data)
logger.debug("request %s" % request)
response = guild_pb2.GuildBossBattleResponse()
stage_id = request.stage_id
coolingTime = game_configs.base_config.get("AnimalCoolingTime")
# 冷却时间
if player.guild.guild_boss_last_attack_time.get(
"time") + coolingTime >= get_current_timestamp():
logger.error("attack still in colding time!")
response.res.result = False
response.res.result_no = 240301
return response.SerializePartialToString()
data = remote_gate['world'].guild_boss_init_remote(player.guild.g_id)
logger.debug("return data %s" % data)
boss_info = data.get("guild_boss")
line_up = player.line_up_component
player.fight_cache_component.stage_id = stage_id
red_units = player.fight_cache_component.get_red_units()
str_red_units = cPickle.dumps(red_units)
seed1, seed2 = get_seeds()
red_unpar_data = line_up.get_red_unpar_data()
res = remote_gate['world'].guild_boss_battle_remote(
player.guild.g_id, str_red_units, red_unpar_data, seed1, seed2)
#boss_info = res.get("guild_boss")
blue_units = cPickle.loads(boss_info.get("blue_units"))
pvp_assemble_units(red_units, blue_units, response)
fight_result = res.get("fight_result")
stage_item = game_configs.special_stage_config.get(
"guild_boss_stages").get(stage_id)
return_data = gain(player, stage_item.Animal_Participate,
const.GUILD_BOSS_IN)
get_return(player, return_data, response.gain)
response.fight_result = fight_result
if fight_result:
player.guild.guild_boss_last_attack_time["time"] = 0
player.guild.guild_boss_last_attack_time["time"] = int(
get_current_timestamp())
player.guild.save_data()
response.seed1 = seed1
response.seed2 = seed2
response.guild_skill_point = res.get('guild_skill_point')
response.res.result = res.get("result")
if not res.get("result"):
response.res.result_no = res.get("result_no")
return response.SerializePartialToString()
# add guild activity times
player.guild_activity.add_guild_boss_times(boss_info.get("boss_type"))
player.act.add_guild_boss_times(boss_info.get("boss_type"))
hook_task(player, CONDITIONId.GUILD_BOSS, 1)
result = 0
if fight_result:
result = 1
tlog_action.log('GuildBossBattle', player, player.guild.g_id,
boss_info.get("boss_type"), result)
logger.debug("response %s" % response)
return response.SerializePartialToString()
def trigger_boss_2402(pro_data, player):
"""召唤圣兽
"""
guild_boss_open_time_item = game_configs.base_config.get("AnimalOpenTime")
response = guild_pb2.TriggerGuildBossResponse()
response.res.result = False
if not is_in_period(guild_boss_open_time_item):
logger.debug("feature not open!")
response.res.result_no = 30000
return response.SerializeToString()
request = guild_pb2.TriggerGuildBossRequest()
request.ParseFromString(pro_data)
logger.debug("request %s" % request)
boss_type = request.boss_type
trigger_stone_num = player.finance[const.GUILD_BOSS_TRIGGER_STONE]
data = remote_gate['world'].guild_boss_init_remote(player.guild.g_id)
build = data.get("build")
guild_boss_trigger_times = data.get("guild_boss_trigger_times")
guild_boss_item = game_configs.guild_config.get(4).get(build.get(4))
logger.debug("guild_boss_item %s" % guild_boss_item)
boss_open_item = guild_boss_item.animalOpen.get(boss_type)
stage_id = boss_open_item[0]
consume_num = boss_open_item[2]
# 召唤石是否足够
if trigger_stone_num < boss_open_item[2]:
logger.debug("trigger stone is not enough!")
response.res.result_no = 240201
return response.SerializeToString()
# 召唤次数是否达到上限
if guild_boss_trigger_times >= guild_boss_item.animalOpenTime:
logger.debug("trigger times reach the max!")
response.res.result_no = 240202
return response.SerializeToString()
# 军团等级是否满足此类型boss
if not boss_open_item[1]:
logger.debug("guild level is not enough!")
response.res.result_no = 240204
return response.SerializeToString()
res = remote_gate['world'].guild_boss_add_remote(player.guild.g_id, stage_id, boss_type, player.base_info.id, player.base_info.base_name)
response.res.result = res.get("result")
if not res.get("result"):
response.res.result_no = res.get("result_no")
return response.SerializeToString()
player.finance.consume(const.GUILD_BOSS_TRIGGER_STONE, consume_num, 0)
return_data = [[const.RESOURCE, consume_num, 15]]
logger.debug(return_data)
get_return(player, return_data, response.consume)
player.guild.guild_boss_last_attack_time["boss_id"] = res.get("guild_boss").get("boss_id")
player.guild.guild_boss_last_attack_time["time"] = 0
logger.debug("guild_boss_last_attack_time %s " % (player.guild.guild_boss_last_attack_time))
construct_boss_pb(res.get("guild_boss"), response.guild_boss)
logger.debug("response %s" % response)
remote_gate.push_object_character_remote(24021, construct_init_data(player), player.guild.get_guild_member_ids(res.get("p_list", {})))
# add guild activity times
player.guild_activity.add_guild_boss_times(res.get("guild_boss").get("boss_type"))
player.act.add_guild_boss_times(res.get("guild_boss").get("boss_type"))
hook_task(player, CONDITIONId.GUILD_BOSS, 1)
tlog_action.log('TriggerBoss', player, player.guild.g_id, boss_type)
return response.SerializeToString()
def func():
# consume_data = []
if _is_consume_result:
return_data = consume(player, price,
player_type_shop, reason, shop_type_item)
get_return(player, return_data, response.consume)
# consume_data = return_data
# logger.debug("hero-draw2")
return_data = []
extra_return_data = []
CoinCardCumulateTimes = game_configs.base_config.get("CoinCardCumulateTimes", 0)
CardCumulateTimes = game_configs.base_config.get("CardCumulateTimes", 0)
if shop_item.type == 5:
# todo: 如何判断shop类型：单抽、十连抽
# logger.debug("hero_draw: shop_item_id %s, item_no %s" % (shop_item.id, shop_item.gain[0].item_no))
gain_items = player.shop.get_draw_drop_bag(shop_item.gain[0].item_no)
if shop_item.id == 50001:
# 单抽达到指定次数，获得指定武将
player.shop.single_gold_draw_times += 1
if player.shop.single_gold_draw_times == CardCumulateTimes:
gain_items = game_configs.base_config.get("CardCumulate", [])
player.shop.single_gold_draw_times = 0
logger.debug("tenth gold draw %s %s" % (player.shop.single_gold_draw_times, gain_items))
player.shop.save_data()
return_data = gain(player, gain_items, reason)
extra_return_data = gain(player, shop_item.extraGain, reason) # 额外获取
get_return(player, return_data, response.gain)
get_return(player, extra_return_data, response.gain)
if need_gold > 0 and shop_item.ExchangeValue:
lucky_data = gain(player,
shop_item.ExchangeValue,
reason)
get_return(player, lucky_data, response.gain)
if shop_item.id == 50001:
hook_task(player, CONDITIONId.HERO_GET, 1)
else:
hook_task(player, CONDITIONId.HERO_GET, 10)
else:
gain_items = shop_item.gain
if shop_item.id == 10001:
# 单抽达到指定次数，获得指定武将
player.shop.single_coin_draw_times += 1
if player.shop.single_coin_draw_times == CoinCardCumulateTimes:
gain_items = game_configs.base_config.get("CoinCardCumulate", [])
player.shop.single_coin_draw_times = 0
logger.debug("tenth coin draw %s %s" % (player.shop.single_coin_draw_times, gain_items))
player.shop.save_data()
return_data = gain(player, gain_items, reason) # 获取
extra_return_data = gain(player, shop_item.extraGain, reason) # 额外获取
get_return(player, return_data, response.gain)
get_return(player, extra_return_data, response.gain)
if need_gold > 0 and shop_item.ExchangeValue:
lucky_data = gain(player,
shop_item.ExchangeValue,
reason)
get_return(player, lucky_data, response.gain)
if shop_item.id == 10001:
hook_task(player, CONDITIONId.HERO_GET_LIANG, 1)
else:
hook_task(player, CONDITIONId.HERO_GET_LIANG, 10)
send_tlog(player, shop_item)
def boss_task_remote(num, is_online, player):
if is_online:
hook_task(player, CONDITIONId.PVBOSS, num)
else:
update_condition(player, CONDITIONId.PVBOSS, num)
return True
def pvp_fight_request_1505(data, player):
"""
pvp战斗开始
"""
request = pvp_rank_pb2.PvpFightRequest()
response = pvp_rank_pb2.PvpFightResponse()
request.ParseFromString(data)
# player.pvp.check_time()
if is_not_open(player, FO_PVP_RANK):
response.res.result = False
response.res.result_no = 837
return response.SerializePartialToString()
arena_consume = game_configs.base_config.get('arenaConsume')
result = is_afford(player, arena_consume) # 校验
if not result.get('result'):
logger.error('not enough consume:%s', arena_consume)
response.res.result = False
response.res.result_no = 150501
return response.SerializePartialToString()
# if player.pvp.pvp_times <= 0:
# logger.error('not enough pvp times:%s-%s', player.pvp.pvp_times,
# game_configs.base_config.get('arena_free_times'))
# response.res.result = False
# response.res.result_no = 836
# return response.SerializeToString()
challenge_rank = request.challenge_rank
if challenge_rank < 0 and player.pvp.pvp_upstage_challenge_rank != 0:
challenge_rank = player.pvp.pvp_upstage_challenge_rank
if challenge_rank < 0:
logger.error('pvp challenge rank error!!%s-%s', challenge_rank,
player.pvp.pvp_upstage_challenge_rank)
response.res.result = False
response.res.result_no = 839
return response.SerializeToString()
line_up = request.lineup
skill = request.skill
target_id = int(
tb_pvp_rank.zrangebyscore(challenge_rank, challenge_rank)[0])
if target_id != request.challenge_id:
logger.error('pvp challenge id changed!!%s-%s', target_id,
request.challenge_id)
response.res.result = False
response.res.result_no = 150508
return response.SerializeToString()
before_player_rank = tb_pvp_rank.zscore(player.base_info.id)
if not before_player_rank:
before_player_rank = int(tb_pvp_rank.getObj('incr').incr())
tb_pvp_rank.zadd(before_player_rank, player.base_info.id)
player.pvp.pvp_high_rank = before_player_rank
elif before_player_rank != request.self_rank:
logger.error('pvp self rank changed!!%s-%s', before_player_rank,
request.self_rank)
response.res.result = False
response.res.result_no = 150509
return response.SerializeToString()
before_player_rank = int(before_player_rank)
if before_player_rank == challenge_rank:
logger.error('cant not fight self')
response.res.result = False
response.res.result_no = 1505
return response.SerializeToString()
return_data = consume(player, arena_consume, const.PVP)
get_return(player, return_data, response.consume)
fight_result = pvp_fight(player, target_id, line_up, skill, response)
rank_incr = 0
response.top_rank = player.pvp.pvp_high_rank
response.before_rank = before_player_rank
if fight_result:
logger.debug("fight result:True:%s:%s", before_player_rank,
challenge_rank)
_arena_win_points = game_configs.base_config.get('arena_win_points')
if _arena_win_points:
return_data = gain(player, _arena_win_points, const.ARENA_WIN)
get_return(player, return_data, response.gain)
else:
logger.debug('arena win points is not find')
push_config = game_configs.push_config[1003]
rank_count = push_config.conditions[0]
if challenge_rank - before_player_rank >= rank_count:
txt = game_configs.push_config[1003].text
message = game_configs.language_config.get(str(txt)).get('cn')
remote_gate['push'].add_push_message_remote(
player.base_info.id, 3, message, int(time.time()))
push_message('add_blacklist_request_remote', target_id,
player.base_info.id)
if challenge_rank < before_player_rank:
tb_pvp_rank.zadd(challenge_rank, player.base_info.id,
before_player_rank, target_id)
send_mail(conf_id=123,
receive_id=target_id,
pvp_rank=before_player_rank,
nickname=player.base_info.base_name)
if challenge_rank < player.pvp.pvp_high_rank:
rank_incr = player.pvp.pvp_high_rank - challenge_rank
if player.pvp.pvp_high_rank > challenge_rank:
hook_task(player, CONDITIONId.PVP_RANK, challenge_rank)
formula = game_configs.formula_config.get(
"arenaRankUpRewardsValue").get("formula")
gain_num = eval(
formula,
dict(upRank=challenge_rank, highestRank=player.pvp.pvp_high_rank))
# stage award
stage_info_before = get_player_pvp_stage(player.pvp.pvp_high_rank)
stage_info_current = get_player_pvp_stage(challenge_rank)
before_gradient = stage_info_before.get('Gradient')
current_gradient = stage_info_current.get('Gradient')
if stage_info_current and stage_info_current \
and before_gradient > current_gradient:
arena_stage_reward = stage_info_current.get('Reward')
stage_reward_data = gain(player, arena_stage_reward,
const.ARENA_WIN)
get_return(player, stage_reward_data, response.award2)
logger.debug('stage award %s %s', stage_info_current,
stage_info_before)
player.pvp.pvp_high_rank = min(player.pvp.pvp_high_rank,
challenge_rank)
logger.debug("history_high_rank %s current %s" %
(player.pvp.pvp_high_rank, before_player_rank))
# 首次达到某名次的奖励
arena_rank_rewards = game_configs.base_config.get('arenaRankUpRewards')
if arena_rank_rewards:
return_data = gain(player,
arena_rank_rewards,
const.ARENA_WIN,
multiple=int(gain_num))
get_return(player, return_data, response.award)
else:
logger.debug('arena rank up points is not find')
else:
logger.debug("fight result:False")
send_mail(conf_id=124,
receive_id=target_id,
nickname=player.base_info.base_name)
hook_task(player, CONDITIONId.PVP_RANk_TIMES, 1)
player.pvp.pvp_times -= 1
player.pvp.pvp_refresh_time = time.time()
player.pvp.save_data()
response.res.result = True
# response.top_rank = player.pvp.pvp_high_rank
response.rank_incr = rank_incr
logger.debug(response)
return response.SerializeToString()
def become_friends_remote(target_id, is_online, player):
result = player.friends.add_friend(target_id, False)
# assert(result)
player.friends.save_data()
hook_task(player, CONDITIONId.ADD_FRIEND, 1)
return True
