def add_player(self, player_info, protect_or_rob, rob_no=-1, guild_info={}):
if protect_or_rob == 1 and len(self._protecters) < 3:
if not self._protecters:
logger.debug("receive task add player==============")
self._protect_guild_info = guild_info
self._receive_task_time = int(get_current_timestamp())
self._protecters.append(player_info)
elif protect_or_rob == 2:
if rob_no == -1:
rob_task_info = {}
rob_task_info["robbers"] = []
rob_task_info["robbers"].append(player_info)
rob_task_info["rob_result"] = False
rob_task_info["rob_state"] = 1
rob_task_info["rob_receive_task_time"] = int(get_current_timestamp())
rob_task_info["rob_guild_info"] = guild_info
rob_no = len(self._rob_task_infos)
rob_task_info["rob_no"] = rob_no
self._rob_task_infos.append(rob_task_info)
else:
rob_task_info = self._rob_task_infos[rob_no]
if len(rob_task_info["robbers"]) < 3:
rob_task_info["robbers"].append(player_info)
# add player position to player_info
guild_position = 3
p_list = guild_info.get("p_list", {})
player_id = player_info.get("id")
if player_id in p_list:
guild_position = 1
if player_id in p_list:
guild_position = 2
player_info["guild_position"] = guild_position
return dict(rob_no=rob_no)
def is_started(self, task_item):
if self.state == 1 and \
self._receive_task_time + task_item.wait < get_current_timestamp() and \
self._receive_task_time + task_item.wait + task_item.taskTime > get_current_timestamp():
self._start_protect_time = int(get_current_timestamp())
return True
return False
def send_escort_task_invite_remote(guild_id, task_id, player_guild_id, rob_no,
protect_or_rob):
"""
发送邀请到玩家所在公会
"""
guild = guild_manager_obj.get_guild_obj(player_guild_id)
task_guild = guild_manager_obj.get_guild_obj(guild_id)
task = task_guild.get_task_by_id(task_id)
if protect_or_rob == 1:
guild.escort_tasks_invite_protect[task_id] = {
"guild_id": guild_id,
"rob_no": rob_no
}
task.last_send_invite_time = int(get_current_timestamp())
elif protect_or_rob == 2:
guild.escort_tasks_invite_rob[task_id] = {
"guild_id": guild_id,
"rob_no": rob_no
}
task.rob_task_infos[rob_no]["last_send_invite_time"] = int(
get_current_timestamp())
guild.save_data()
task_guild = guild_manager_obj.get_guild_obj(guild_id)
return construct_task_data(task_guild.get_task_by_id(task_id), rob_no)
def init_2101(pro_data, player):
"""获取hjqy信息
"""
request = hjqy_pb2.HjqyInitRequest()
request.ParseFromString(pro_data)
response = hjqy_pb2.HjqyInitResponse()
friend_ids = player.friends.friends
data = remote_gate['world'].hjqy_init_remote(player.base_info.id, friend_ids)
logger.debug("return data %s" % data)
for boss_data in data.values():
if (request.owner_id and request.owner_id == boss_data.get("player_id")) or (not request.owner_id):
construct_boss_pb(boss_data, response)
response.damage_hp = remote_gate['world'].hjqy_damage_hp_remote(player.base_info.id)
response.rank = remote_gate['world'].hjqy_rank_remote(player.base_info.id)
if is_next_day(get_current_timestamp(), player.hjqy_component.last_time):
player.hjqy_component.received_ids = []
player.hjqy_component.last_time = get_current_timestamp()
player.hjqy_component.save_data()
for temp in player.hjqy_component.received_ids:
response.hjqy_ids.append(temp)
return response.SerializeToString()
def init_2101(pro_data, player):
"""获取hjqy信息
"""
request = hjqy_pb2.HjqyInitRequest()
request.ParseFromString(pro_data)
response = hjqy_pb2.HjqyInitResponse()
friend_ids = player.friends.friends
data = remote_gate['world'].hjqy_init_remote(player.base_info.id,
friend_ids)
logger.debug("return data %s" % data)
for boss_data in data.values():
if (request.owner_id and request.owner_id
== boss_data.get("player_id")) or (not request.owner_id):
construct_boss_pb(boss_data, response)
response.damage_hp = remote_gate['world'].hjqy_damage_hp_remote(
player.base_info.id)
response.rank = remote_gate['world'].hjqy_rank_remote(player.base_info.id)
if is_next_day(get_current_timestamp(), player.hjqy_component.last_time):
player.hjqy_component.received_ids = []
player.hjqy_component.last_time = get_current_timestamp()
player.hjqy_component.save_data()
for temp in player.hjqy_component.received_ids:
response.hjqy_ids.append(temp)
return response.SerializeToString()
def is_started(self, task_item):
if self.state == 1 and \
self._receive_task_time + task_item.wait < get_current_timestamp() and \
self._receive_task_time + task_item.wait + task_item.taskTime > get_current_timestamp():
self._start_protect_time = int(get_current_timestamp())
return True
return False
def send_invite(player, task_id, protect_or_rob, task_guild_id, rob_no):
"""docstring for send_invite"""
AnnouncementCoolingTime = game_configs.base_config.get("AnnouncementCoolingTime", 0)
task = remote_gate["world"].get_task_by_id_remote(task_guild_id, task_id)
if protect_or_rob == 1:
last_send_invite_time = task.get("last_send_invite_time", 0)
if last_send_invite_time + AnnouncementCoolingTime > int(get_current_timestamp()):
logger.error("last_send_invite_time %s AnnouncementCoolingTime %s current %s" % (last_send_invite_time, AnnouncementCoolingTime, int(get_current_timestamp())))
return {'result': False, 'result_no': 1908041}
if protect_or_rob == 2:
last_send_invite_time = task.get("rob_task_infos")[0].get("last_send_invite_time", 0)
if last_send_invite_time + AnnouncementCoolingTime > int(get_current_timestamp()):
logger.error("last_send_invite_time %s AnnouncementCoolingTime %s current %s" % (last_send_invite_time, AnnouncementCoolingTime, int(get_current_timestamp())))
return {'result': False, 'result_no': 1908041}
task = remote_gate["world"].send_escort_task_invite_remote(task_guild_id, task_id, player.guild.g_id, rob_no, protect_or_rob)
if not task:
logger.error("can't find this task!")
return {'result': False, 'result_no': 190801}
push_response = escort_pb2.InviteEscortTaskPushResponse()
update_task_pb(task, push_response.task)
push_response.protect_or_rob = protect_or_rob
guild_info = {}
if protect_or_rob == 1:
guild_info = task.get("protect_guild_info")
if protect_or_rob == 2:
guild_info = task.get("rob_task_infos")[0].get("rob_guild_info")
remote_gate.push_object_character_remote(19082, push_response.SerializePartialToString(), player.guild.get_guild_member_ids(guild_info.get("p_list", {})))
logger.debug("push_response %s" % push_response)
return {'result': True}
def check_open_date(self, open_info):
logger.debug("open_info============%s" % open_info)
days = open_info.keys()[0]
ts = open_info.values()[0][0]
register_time = self._owner.base_info.register_time
logger.debug("days %s tocurrent_days %s %s %s" %
(days, days_to_current(register_time),
string_to_timestamp_hms(ts), get_current_timestamp()))
if days_to_current(register_time) > days - 1 or (
days_to_current(register_time) == days - 1 and
string_to_timestamp_hms(ts) < get_current_timestamp()):
logger.debug("check open date True")
return True
return False
def pvb_fight_remote(str_red_units, red_best_skill, red_best_skill_level, str_blue_units, player_info, boss_id, damage_rate, debuff_skill_no, seed1, seed2):
"""
战斗
"""
boss = get_boss(boss_id)
if not boss.open_or_not:
return -1, 0
red_units = cPickle.loads(str_red_units)
blue_units = cPickle.loads(str_blue_units)
res = world_boss_start(red_units, blue_units, red_best_skill, red_best_skill_level, 0, 1, debuff_skill_no, damage_rate, seed1, seed2, player_info.get("level"))
result = res.get("result")
hp_left = res.get("hp_left")
# 保存worldboss数据
boss.hp = hp_left
# 保存排行和玩家信息
demage_hp = blue_units.get(5).hp - hp_left # 伤害血量
player_info["demage_hp"] = demage_hp
boss.add_rank_item(player_info)
# 如果赢了，保存最后击杀
if result:
boss.last_shot_item = player_info
boss.boss_dead_time = get_current_timestamp()
push_all_object_message(1790,"")
boss.save_data()
return result, demage_hp
def check_time(self):
"""
时间改变，重置数据
"""
current_time_stamp = get_current_timestamp()
for k, v in self._act_lucky_heros.items():
stage_info = game_configs.special_stage_config.get('act_stages').get(k)
if v.get('time')[0] > current_time_stamp or v.get('time')[1] < current_time_stamp:
v['heros'], v['time'][0], v['time'][1] = update_lucky_hero(stage_info.type, k%10)
logger.debug("character_stage check time")
logger.debug(self._act_stage_info)
if is_next_day(current_time_stamp, self._elite_stage_info[2]):
self._elite_stage_info[0] = 0
self._elite_stage_info[1] = 0
self._elite_stage_info[2] = current_time_stamp
if is_next_day(current_time_stamp, self._act_stage_info[2]):
self._act_stage_info[0] = 0
self._act_stage_info[1] = 0
self._act_stage_info[2] = current_time_stamp
logger.debug("_act_lucky_heros %s" % self._act_lucky_heros)
logger.debug(self._elite_stage_info)
logger.debug(self._act_stage_info)
self.save_data()
def in_the_time_period(self):
stage_info = self.current_stage_info()
time_start, time_end = str_time_period_to_timestamp(stage_info.timeControl)
current = get_current_timestamp()
if self._boss_dead_time > time_start:
return time_start<=current and self._boss_dead_time>=current
return time_start<=current and time_end>=current
def set_next_stage(self, kill_or_not=False):
"""
根据id规则确定下一个关卡
如果boss未被击杀则不升级
"""
logger.debug("current_stage_id1%s" % self._stage_id)
current_stage_id = self._stage_id
if current_stage_id == 0:
self._stage_id_am = 800101
self._stage_id_pm = 800102
self._stage_id = 800101
return
if kill_or_not: #如果boss被击杀，则升级boss
if current_stage_id == self._stage_id_am: # am
self._stage_id_am = current_stage_id + 100
else: # pm
self._stage_id_pm = current_stage_id + 100
current_time = get_current_timestamp()
if current_stage_id == self._stage_id_am:
self._stage_id = self._stage_id_pm
else:
self._stage_id = self._stage_id_am
logger.debug("current_stage_id3%s" % self._stage_id)
logger.debug("current_stage_id_am%s" % self._stage_id_am)
logger.debug("current_stage_id_pm%s" % self._stage_id_pm)
def pvb_reborn_1704(data, player):
"""
使用元宝复活。
"""
response = CommonResponse()
# 1. 校验元宝
gold = player.finance.gold
money_relive_price = base_config.get('money_relive_price')
need_gold = money_relive_price
print need_gold, gold, "*" * 80
if gold < need_gold:
logger.debug("reborn error: %s" % 102)
response.result = False
response.result_no = 102
return response.SerializePartialToString()
#2. 校验CD
current_time = get_current_timestamp()
if current_time - player.world_boss.last_fight_time > base_config.get(
"free_relive_time"):
logger.debug("reborn error: %s" % 1701)
response.result = False
response.result_no = 1701
return response.SerializePartialToString()
player.finance.gold -= need_gold
player.finance.save_data()
response.result = True
print response
return response.SerializePartialToString()
def pvb_fight_remote(str_red_units, red_unpar_data, str_blue_units, player_info, boss_id, damage_rate, debuff_skill_no, seed1, seed2):
"""
战斗
"""
boss = get_boss(boss_id)
if not boss.open_or_not:
return -1, 0
red_units = cPickle.loads(str_red_units)
blue_units = cPickle.loads(str_blue_units)
res = world_boss_start(red_units, blue_units, red_unpar_data, {}, debuff_skill_no, damage_rate, seed1, seed2, player_info.get("level"))
result = res.get("result")
hp_left = res.get("hp_left")
# 保存worldboss数据
boss.hp = hp_left
# 保存排行和玩家信息
demage_hp = blue_units.get(5).hp - hp_left # 伤害血量
player_info["demage_hp"] = demage_hp
boss.add_rank_item(player_info)
# 如果赢了，保存最后击杀
if result:
boss.last_shot_item = player_info
boss.boss_dead_time = get_current_timestamp()
push_all_object_message(1790,"")
boss.save_data()
return result, demage_hp
def check_time(self):
"""docstring for check_time"""
logger.debug("login_time================== %s" %
days_to_current(self._last_login))
if days_to_current(self._last_login) > 1 and self.is_open(2001):
activity_infos = game_configs.activity_config.get(2, [])
for info in activity_infos:
if not self.is_open(info.id):
self._continuous_day[info.id] = -1
self._continuous_day[2001] = 0
self._continuous_day_num = 1
if days_to_current(self._last_login) > 1 and self.is_open(18001):
# 7天乐
activity_infos = game_configs.activity_config.get(18, [])
for info in activity_infos:
self._continuous_7day[info.id] = -1
self._continuous_7day[18001] = 0
self._continuous_7day_num = 1
elif days_to_current(self._last_login) == 1 and self.is_open(2001):
self._continuous_day_num += 1
for k in sorted(self._continuous_day.keys()):
v = self._continuous_day[k]
activity_info = game_configs.activity_config.get(k, [])
if v == -1 or activity_info.parameterA == 7:
self._continuous_day[k] = 0
break
if days_to_current(self._last_login) > 1 and self.is_open(18001):
# 7天乐
self._continuous_7day_num += 1
for k in sorted(self._continuous_7day.keys()):
v = self._continuous_7day[k]
activity_info = game_configs.activity_config.get(k, [])
if v == -1:
self._continuous_7day[k] = 0
break
if days_to_current(self._last_login) > 0 and self.is_open(1001):
self._cumulative_day_num += 1
for k in sorted(self._cumulative_day.keys()):
v = self._cumulative_day[k]
if v == -1:
self._cumulative_day[k] = 0
break
#activity_infos = game_configs.activity_config.get(2, [])
#days_to_register = days_to_current(self._owner.base_info.register_time)
#if activity_infos and days_to_register >= activity_infos[0].parameterB:
#self._cumulative_day_num = -1
#activity_infos = game_configs.activity_config.get(18, [])
#if activity_infos and days_to_register >= activity_infos[0].parameterB:
#self._continuous_7day_num = -1
self._last_login = get_current_timestamp()
self.save_data()
def check_time(self):
"""
时间改变，重置数据
"""
current_time_stamp = get_current_timestamp()
for k, v in self._act_lucky_heros.items():
stage_info = game_configs.special_stage_config.get(
'act_stages').get(k)
if v.get('time')[0] > current_time_stamp or v.get(
'time')[1] < current_time_stamp:
v['heros'], v['time'][0], v['time'][1] = update_lucky_hero(
stage_info.type, k % 10)
logger.debug("character_stage check time")
logger.debug(self._act_stage_info)
if is_next_day(current_time_stamp, self._elite_stage_info[2]):
self._elite_stage_info[0] = 0
self._elite_stage_info[1] = 0
self._elite_stage_info[2] = current_time_stamp
if is_next_day(current_time_stamp, self._act_stage_info[2]):
self._act_stage_info[0] = 0
self._act_stage_info[1] = 0
self._act_stage_info[2] = current_time_stamp
logger.debug("_act_lucky_heros %s" % self._act_lucky_heros)
logger.debug(self._elite_stage_info)
logger.debug(self._act_stage_info)
self.save_data()
def check_time(self):
"""docstring for check_time"""
logger.debug("login_time================== %s" % days_to_current(self._last_login))
if days_to_current(self._last_login) > 1 and self.is_open(2001):
activity_infos = game_configs.activity_config.get(2, [])
for info in activity_infos:
if not self.is_open(info.id):
self._continuous_day[info.id] = -1
self._continuous_day[2001] = 0
self._continuous_day_num = 1
if days_to_current(self._last_login) > 1 and self.is_open(18001):
# 7天乐
activity_infos = game_configs.activity_config.get(18, [])
for info in activity_infos:
self._continuous_7day[info.id] = -1
self._continuous_7day[18001] = 0
self._continuous_7day_num = 1
elif days_to_current(self._last_login) == 1 and self.is_open(2001):
self._continuous_day_num += 1
for k in sorted(self._continuous_day.keys()):
v = self._continuous_day[k]
activity_info = game_configs.activity_config.get(k, [])
if v == -1 or activity_info.parameterA == 7:
self._continuous_day[k] = 0
break
if days_to_current(self._last_login) > 1 and self.is_open(18001):
# 7天乐
self._continuous_7day_num += 1
for k in sorted(self._continuous_7day.keys()):
v = self._continuous_7day[k]
activity_info = game_configs.activity_config.get(k, [])
if v == -1:
self._continuous_7day[k] = 0
break
if days_to_current(self._last_login) > 0 and self.is_open(1001):
self._cumulative_day_num+= 1
for k in sorted(self._cumulative_day.keys()):
v = self._cumulative_day[k]
if v == -1:
self._cumulative_day[k] = 0
break
#activity_infos = game_configs.activity_config.get(2, [])
#days_to_register = days_to_current(self._owner.base_info.register_time)
#if activity_infos and days_to_register >= activity_infos[0].parameterB:
#self._cumulative_day_num = -1
#activity_infos = game_configs.activity_config.get(18, [])
#if activity_infos and days_to_register >= activity_infos[0].parameterB:
#self._continuous_7day_num = -1
self._last_login = get_current_timestamp()
self.save_data()
def start_rob_escort_remote(guild_id, task_id, rob_no, player_id):
guild = guild_manager_obj.get_guild_obj(guild_id)
task = guild.get_task_by_id(task_id)
# get robbed success num
robbed_num = task.rob_success_times()
if task.rob_success_times() >= 2:
# 接受劫运任务，如果该任务已经达到最大劫运次数
return {'result': False, 'result_no': 190803}
if task.has_robbed(player_id):
# 已经被劫了
return {"result": False, "result_no": 190804}
# construct battle units
# update rob task
task_item = game_configs.guild_task_config.get(task.task_no)
logger.debug("task rob task infos %s %s" % (task.rob_task_infos, len(task.rob_task_infos)))
rob_task_info = task.rob_task_infos[rob_no]
seed1, seed2 = get_seeds()
rob_task_info["seed1"] = seed1
rob_task_info["seed2"] = seed2
red_groups = []
blue_groups = []
for player_info in task.protecters:
blue_group = cPickle.loads(player_info.get("BattleUnitGrop"))
blue_groups.append(blue_group)
for player_info in rob_task_info.get("robbers"):
red_group = cPickle.loads(player_info.get("BattleUnitGrop"))
red_groups.append(red_group)
logger.debug("blue_groups %s" % blue_groups)
logger.debug("red_groups %s" % red_groups)
# pvp battle
rob_result = guild_pvp_start(red_groups, blue_groups, seed1, seed2)
rob_task_info["rob_result"] = rob_result
rob_task_info["rob_time"] = int(get_current_timestamp())
if rob_result:
robbers_num = len(rob_task_info.get("robbers"))
peoplePercentage = task_item.peoplePercentage.get(robbers_num)
robbedPercentage = task_item.robbedPercentage.get(robbed_num+1)
robber_guild = guild_manager_obj.get_guild_obj(rob_task_info.get("rob_guild_info").get("id"))
mail_arg1 = calculate_reward(peoplePercentage, robbedPercentage, "SnatchReward", task_item, robber_guild)
if robbed_num + 1 >= 2:
if task_id in guild.escort_tasks_can_rob:
guild.escort_tasks_can_rob.remove(task_id)
guild.save_data()
rob_task_info["rob_reward"] = mail_arg1
for player_info in rob_task_info.get("robbers"):
send_mail(conf_id=1002, receive_id=player_info.get("id"), prize=str(get_reward(mail_arg1, robber_guild)))
rob_task_info["rob_state"] = -1
task.update_reward(task_item)
task.save_data()
res = {"result": True, "protecters": task.protecters, "rob_task_info": rob_task_info, "task": construct_task_data(task, rob_no)}
logger.debug("res %s" % res)
return res
def send_invite(player, task_id, protect_or_rob, task_guild_id, rob_no):
"""docstring for send_invite"""
AnnouncementCoolingTime = game_configs.base_config.get(
"AnnouncementCoolingTime", 0)
task = remote_gate["world"].get_task_by_id_remote(task_guild_id, task_id)
if protect_or_rob == 1:
last_send_invite_time = task.get("last_send_invite_time", 0)
if last_send_invite_time + AnnouncementCoolingTime > int(
get_current_timestamp()):
logger.error(
"last_send_invite_time %s AnnouncementCoolingTime %s current %s"
% (last_send_invite_time, AnnouncementCoolingTime,
int(get_current_timestamp())))
return {'result': False, 'result_no': 1908041}
if protect_or_rob == 2:
last_send_invite_time = task.get("rob_task_infos")[0].get(
"last_send_invite_time", 0)
if last_send_invite_time + AnnouncementCoolingTime > int(
get_current_timestamp()):
logger.error(
"last_send_invite_time %s AnnouncementCoolingTime %s current %s"
% (last_send_invite_time, AnnouncementCoolingTime,
int(get_current_timestamp())))
return {'result': False, 'result_no': 1908041}
task = remote_gate["world"].send_escort_task_invite_remote(
task_guild_id, task_id, player.guild.g_id, rob_no, protect_or_rob)
if not task:
logger.error("can't find this task!")
return {'result': False, 'result_no': 190801}
push_response = escort_pb2.InviteEscortTaskPushResponse()
update_task_pb(task, push_response.task)
push_response.protect_or_rob = protect_or_rob
guild_info = {}
if protect_or_rob == 1:
guild_info = task.get("protect_guild_info")
if protect_or_rob == 2:
guild_info = task.get("rob_task_infos")[0].get("rob_guild_info")
remote_gate.push_object_character_remote(
19082, push_response.SerializePartialToString(),
player.guild.get_guild_member_ids(guild_info.get("p_list", {})))
logger.debug("push_response %s" % push_response)
return {'result': True}
def in_the_time_period(self):
stage_info = self.current_stage_info()
time_start, time_end = str_time_period_to_timestamp(
stage_info.timeControl)
current = get_current_timestamp()
if self._boss_dead_time > time_start:
return time_start <= current and self._boss_dead_time >= current
return time_start <= current and time_end >= current
def start_task(task, guild):
task.state = 2
logger.debug("task state %s" % task.state)
task.start_protect_time = int(get_current_timestamp())
task.update_reward()
guild.escort_tasks_can_rob.append(task.task_id)
guild.save_data()
task.save_data()
def start_task(task, guild):
task.state = 2
logger.debug("task state %s" % task.state)
task.start_protect_time = int(get_current_timestamp())
task.update_reward()
guild.escort_tasks_can_rob.append(task.task_id)
guild.save_data()
task.save_data()
def init_time(self):
am_period = self.get_stage_period(self._stage_id_am)
# pm_period = self.get_stage_period(self._stage_id_pm)
current = get_current_timestamp()
if current < am_period[1]:
self._stage_id = self._stage_id_am
elif current > am_period[1]:
self._stage_id = self._stage_id_pm
def send_escort_task_invite_remote(guild_id, task_id, player_guild_id, rob_no, protect_or_rob):
"""
发送邀请到玩家所在公会
"""
guild = guild_manager_obj.get_guild_obj(player_guild_id)
task_guild = guild_manager_obj.get_guild_obj(guild_id)
task = task_guild.get_task_by_id(task_id)
if protect_or_rob == 1:
guild.escort_tasks_invite_protect[task_id] = {"guild_id" : guild_id, "rob_no": rob_no}
task.last_send_invite_time = int(get_current_timestamp())
elif protect_or_rob == 2:
guild.escort_tasks_invite_rob[task_id] = {"guild_id" : guild_id, "rob_no": rob_no}
task.rob_task_infos[rob_no]["last_send_invite_time"] = int(get_current_timestamp())
guild.save_data()
task_guild = guild_manager_obj.get_guild_obj(guild_id)
return construct_task_data(task_guild.get_task_by_id(task_id), rob_no)
def reset_guild_boss_trigger_times(self):
"""
重置公会boss召唤次数
"""
str_time = game_configs.base_config.get("AnimalFresh")
if self._guild_boss_reset_time < str_time_to_timestamp(str_time):
self._guild_boss_reset_time = get_current_timestamp()
self._guild_boss_trigger_times = 0
self.save_data()
def add_boss(self, player_id, nickname, blue_units, stage_id):
"""docstring for add_boss"""
logger.debug("add boss %s %s %s %s" % (player_id, 1, blue_units, stage_id))
boss = HjqyBoss(player_id)
boss.nickname = nickname
boss.blue_units = blue_units
boss.stage_id = stage_id
boss.trigger_time = int(get_current_timestamp())
boss.hp_max = boss.hp
self._bosses[player_id] = boss
boss.save_data()
def check_time(self):
escort_refresh = game_configs.base_config.get("EscortFresh")
escort_refresh = str_time_to_timestamp(escort_refresh)
if self._refresh_task_time < escort_refresh:
self.refresh_tasks()
self._refresh_task_time = int(get_current_timestamp())
self._start_protect_times = 0
self._refresh_times = 0
self._protect_times = 0
self._rob_times = 0
self.save_data()
def func():
if player.base_info.buy_coin_times + free_times <= buy_times:
# 使用招财令
player.item_package.consume_item(item_no, 1)
player.buy_coin.buy_times = all_buy_times + 1
player.buy_coin.last_time = get_current_timestamp()
player.buy_coin.save_data()
add_coin_nums = coin_nums * xs
player.finance.add_coin(int(add_coin_nums), const.BUY_COIN_ACT)
player.finance.save_data()
def add_boss(self, player_id, nickname, blue_units, stage_id):
"""docstring for add_boss"""
logger.debug("add boss %s %s %s %s" %
(player_id, 1, blue_units, stage_id))
boss = HjqyBoss(player_id)
boss.nickname = nickname
boss.blue_units = blue_units
boss.stage_id = stage_id
boss.trigger_time = int(get_current_timestamp())
boss.hp_max = boss.hp
self._bosses[player_id] = boss
boss.save_data()
def func():
if player.base_info.buy_coin_times + free_times <= buy_times:
# 使用招财令
player.item_package.consume_item(item_no, 1)
player.buy_coin.buy_times = all_buy_times + 1
player.buy_coin.last_time = get_current_timestamp()
player.buy_coin.save_data()
add_coin_nums = coin_nums * xs
player.finance.add_coin(int(add_coin_nums), const.BUY_COIN_ACT)
player.finance.save_data()
tlog_action.log('BuyCoin', player, need_gold,
player.buy_coin.buy_times, int(add_coin_nums))
def add_times(self, act_id, arg):
"""docstring for add_times"""
if not self.owner.act.is_activiy_open(act_id):
return
act_item = game_configs.activity_config.get(act_id)
if arg not in act_item.parameterC:
logger.debug("cant meet the parameterC %s arg %s act_id %s" % (act_item.parameterC, arg, act_id))
return
act_info = self._act_info[act_id]
act_info["act_times"] = act_info["act_times"] + 1
act_info["last_time"] = int(get_current_timestamp())
logger.debug("act_id %s act_info %s" % (act_id, act_info))
self.save_data()
def add_player(self,
player_info,
protect_or_rob,
rob_no=-1,
guild_info={}):
if protect_or_rob == 1 and len(self._protecters) < 3:
if not self._protecters:
logger.debug("receive task add player==============")
self._protect_guild_info = guild_info
self._receive_task_time = int(get_current_timestamp())
self._protecters.append(player_info)
elif protect_or_rob == 2:
if rob_no == -1:
rob_task_info = {}
rob_task_info["robbers"] = []
rob_task_info["robbers"].append(player_info)
rob_task_info["rob_result"] = False
rob_task_info["rob_state"] = 1
rob_task_info["rob_receive_task_time"] = int(
get_current_timestamp())
rob_task_info["rob_guild_info"] = guild_info
rob_no = len(self._rob_task_infos)
rob_task_info["rob_no"] = rob_no
self._rob_task_infos.append(rob_task_info)
else:
rob_task_info = self._rob_task_infos[rob_no]
if len(rob_task_info["robbers"]) < 3:
rob_task_info["robbers"].append(player_info)
# add player position to player_info
guild_position = 3
p_list = guild_info.get("p_list", {})
player_id = player_info.get("id")
if player_id in p_list:
guild_position = 1
if player_id in p_list:
guild_position = 2
player_info["guild_position"] = guild_position
return dict(rob_no=rob_no)
def add_times(self, act_id, arg):
"""docstring for add_times"""
if not self.owner.act.is_activiy_open(act_id):
return
act_item = game_configs.activity_config.get(act_id)
if arg not in act_item.parameterC:
logger.debug("cant meet the parameterC %s arg %s act_id %s" %
(act_item.parameterC, arg, act_id))
return
act_info = self._act_info[act_id]
act_info["act_times"] = act_info["act_times"] + 1
act_info["last_time"] = int(get_current_timestamp())
logger.debug("act_id %s act_info %s" % (act_id, act_info))
self.save_data()
def reset_info(self):
"""
如果过期，则重设信息
"""
stage_info = special_stage_config.get("boss_stages").get(
self._stage_id)
time_start, time_end = str_time_period_to_timestamp(
stage_info.timeControl)
if time_start > self._last_request_time or time_end < self._last_request_time:
self._encourage_coin_num = 0
self._encourage_gold_num = 0
self._fight_times = 0
self._last_fight_time = 0
self._stage_id = 0
self._last_request_time = get_current_timestamp()
self.save_data()
def add_guild_boss(self, stage_id, blue_units, boss_type,
trigger_player_id, trigger_player_name):
"""docstring for add_boss"""
logger.debug("add boss %s %s" % (blue_units, stage_id))
boss = GuildBoss()
boss._boss_id = get_uuid()
boss.blue_units = blue_units
boss.stage_id = stage_id
boss.trigger_time = int(get_current_timestamp())
boss.hp_max = boss.hp
boss.boss_type = boss_type
boss.trigger_player_id = trigger_player_id
boss.trigger_player_name = trigger_player_name
self._guild_boss = boss
self._guild_boss_trigger_times = self._guild_boss_trigger_times + 1
self.save_data()
return boss
def add_num(self, act_type, res_type, num):
"""docstring for add_times"""
if res_type not in self._add_act[act_type]:
self._add_act[act_type][res_type] = dict(num=0, last_time=0, stages={})
act_item = self._add_act[act_type][res_type]
logger.debug("act_item %s" % act_item)
act_item["num"] = act_item.get("num", 0) + num
act_item["last_time"] = int(get_current_timestamp())
#acts = game_configs.activity_config.get(act_type, [])
#for act in acts:
#if act.parameterE.keys()[0] == res_type:
#if act.id not in act_item["stages"]:
#act_item["stages"][act.id] = False
#logger.debug("act_id %s act_info %s" % (act_id, act_info))
self.save_data()
def reset_info(self):
"""
如果过期，则重设信息
"""
stage_info = self.get_stage_info()
if self._boss_id != "world_boss":
return
time_start, time_end = str_time_period_to_timestamp(stage_info.timeControl)
if time_start > self._last_request_time or time_end < self._last_request_time:
self._encourage_coin_num = 0
self._encourage_gold_num = 0
self._fight_times = 0
self._last_fight_time = 0
self._last_request_time = get_current_timestamp()
self._gold_reborn_times = 0
self._last_coin_encourage_time = 0 # 上次金币鼓舞时间
self._debuff_skill = {}
def get_heros_101(pro_data, player):
"""取得武将列表 """
response = hero_response_pb2.GetHerosResponse()
clear_or_not = days_to_current(player.base_info._hero_awake_time) > 0
for hero in player.hero_component.get_heros():
if clear_or_not:
logger.debug("clear hero awake")
hero.awake_exp = 0
hero.save_data()
hero_pb = response.heros.add()
hero.update_pb(hero_pb)
#if hero_pb.hero_no == 10045:
#logger.debug("%s %s " % (hero.hero_no, hero_pb.is_guard))
player.base_info._hero_awake_time = get_current_timestamp()
player.base_info.save_data()
return response.SerializePartialToString()
def pvb_reborn_1704(data, player):
"""
使用元宝复活。
"""
request = PvbRequest()
request.ParseFromString(data)
boss_id = request.boss_id
boss = player.world_boss.get_boss(boss_id)
base_config = boss.get_base_config()
response = CommonResponse()
gold = player.finance.gold
money_relive_price = base_config.get('gold_relive_price')
need_gold = money_relive_price[-1] if boss.gold_reborn_times >= len(
money_relive_price) else money_relive_price[boss.gold_reborn_times]
current_time = get_current_timestamp()
not_free = current_time - boss.last_fight_time < base_config.get(
"free_relive_time")
if not_free and gold < need_gold:
logger.debug("reborn CD error: %s" % 1701)
response.result = False
response.result_no = 1701
return response.SerializePartialToString()
if not_free and need_gold == -1:
logger.debug("reborn times max : %s" % 1702)
response.result = False
response.result_no = 1702
if not_free:
def func():
boss.last_fight_time = 0
boss.gold_reborn_times += 1
player.world_boss.save_data()
player.pay.pay(need_gold, const.PVB_REBORN, func)
response.result = True
print response
return response.SerializePartialToString()
def pvb_reborn_1704(data, player):
"""
使用元宝复活。
"""
request = PvbRequest()
request.ParseFromString(data)
boss_id = request.boss_id
boss = player.world_boss.get_boss(boss_id)
base_config = boss.get_base_config()
response = CommonResponse()
gold = player.finance.gold
money_relive_price = base_config.get('gold_relive_price')
need_gold = money_relive_price[-1] if boss.gold_reborn_times >= len(money_relive_price) else money_relive_price[boss.gold_reborn_times]
print need_gold, gold, "*"*80
current_time = get_current_timestamp()
not_free = current_time - boss.last_fight_time < base_config.get("free_relive_time")
if not_free and gold < need_gold:
logger.debug("reborn CD error: %s" % 1701)
response.result = False
response.result_no = 1701
return response.SerializePartialToString()
if not_free and need_gold == -1:
logger.debug("reborn times max : %s" % 1702)
response.result = False
response.result_no = 1702
if not_free:
def func():
boss.last_fight_time = 0
boss.gold_reborn_times += 1
player.world_boss.save_data()
player.pay.pay(need_gold, const.PVB_REBORN, func)
response.result = True
print response
return response.SerializePartialToString()
def encourage_heros_1703(data, player):
"""
使用金币或者元宝鼓舞士气。
"""
# 1. 校验金币或者元宝
# 3. 减少金币
# 4. 更新战斗力
response = CommonResponse()
request = EncourageHerosRequest()
request.ParseFromString(data)
boss_id = request.boss_id
boss = player.world_boss.get_boss(boss_id)
base_config = boss.get_base_config()
times = 0
if request.finance_type == 1:
# 金币鼓舞
goldcoin_inspire_price = base_config.get("coin_inspire_price")
goldcoin_inspire_price_multiple = base_config.get(
"coin_inspire_price_multi")
goldcoinInspireLimited = base_config.get("coin_inspire_limit")
goldcoin_inspire_CD = base_config.get("coin_inspire_cd")
if get_current_timestamp(
) - boss.last_coin_encourage_time < goldcoin_inspire_CD:
logger.debug("coin encourage CD not enough %s, %s" %
(boss.last_coin_encourage_time, goldcoin_inspire_CD))
response.result = False
response.result_no = 1704
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
if boss.encourage_coin_num >= goldcoinInspireLimited:
logger.debug("coin encourage too many times %s, %s" %
(boss.encourage_coin_num, goldcoinInspireLimited))
response.result = False
response.result_no = 1703
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
coin = player.finance.coin
need_coin = goldcoin_inspire_price * (pow(
goldcoin_inspire_price_multiple, boss.encourage_coin_num))
if coin < need_coin:
response.result = False
response.result_no = 101
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
player.finance.coin -= need_coin
player.finance.save_data()
boss.encourage_coin_num += 1
times = boss.encourage_coin_num
boss.last_coin_encourage_time = get_current_timestamp()
if request.finance_type == 2:
# 钻石鼓舞
money_inspire_price = base_config.get("gold_inspire_price")
moneyInspireLimited = base_config.get("gold_inspire_limit")
#money_inspire_price_multiple = base_config.get("money_inspire_price_multiple")
if boss.encourage_gold_num >= moneyInspireLimited:
logger.error("gold encourage too many times %s, %s" %
(boss.encourage_gold_num, moneyInspireLimited))
response.result = False
response.result_no = 1704
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
gold = player.finance.gold
need_gold = money_inspire_price
if gold < need_gold:
response.result = False
response.result_no = 102
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
def func():
boss.encourage_gold_num += 1
times = boss.encourage_gold_num
player.pay.pay(need_gold, const.ENCOURAGE_HEROS, func)
tlog_action.log('WorldBossEncourage', player, request.finance_type, times)
player.world_boss.save_data()
response.result = True
logger.debug("encourage_coin_num %s" % boss.encourage_coin_num)
logger.debug("encourage_gold_num %s" % boss.encourage_gold_num)
return response.SerializePartialToString()
def check_time(self):
if not self._stage_id: return
remain_time = game_configs.base_config.get("AnimalChallengeTime").get(self._stage_id)
if remain_time + self._trigger_time <= get_current_timestamp():
self.reset()
def is_finished(self, task_item):
if self.state == -1: return False
if self._start_protect_time and self._start_protect_time + task_item.taskTime < get_current_timestamp():
return True
elif not self._start_protect_time and self._receive_task_time + task_item.wait + task_item.taskTime < get_current_timestamp():
self._start_protect_time = self._receive_task_time + task_item.wait
return True
return False
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 encourage_heros_1703(data, player):
"""
使用金币或者元宝鼓舞士气。
"""
# 1. 校验金币或者元宝
# 3. 减少金币
# 4. 更新战斗力
response = CommonResponse()
request = EncourageHerosRequest()
request.ParseFromString(data)
boss_id = request.boss_id
boss = player.world_boss.get_boss(boss_id)
base_config = boss.get_base_config()
if request.finance_type == 1:
# 金币鼓舞
goldcoin_inspire_price = base_config.get("coin_inspire_price")
goldcoin_inspire_price_multiple = base_config.get("coin_inspire_price_multi")
goldcoinInspireLimited = base_config.get("coin_inspire_limit")
goldcoin_inspire_CD = base_config.get("coin_inspire_cd")
if get_current_timestamp() - boss.last_coin_encourage_time < goldcoin_inspire_CD:
logger.debug("coin encourage CD not enough %s, %s" % (boss.last_coin_encourage_time, goldcoin_inspire_CD))
response.result = False
response.result_no = 1704
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
if boss.encourage_coin_num >= goldcoinInspireLimited:
logger.debug("coin encourage too many times %s, %s" % (boss.encourage_coin_num, goldcoinInspireLimited))
response.result = False
response.result_no = 1703
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
coin = player.finance.coin
need_coin = goldcoin_inspire_price * (
pow(goldcoin_inspire_price_multiple, boss.encourage_coin_num))
if coin < need_coin:
response.result = False
response.result_no = 101
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
player.finance.coin -= need_coin
player.finance.save_data()
boss.encourage_coin_num += 1
boss.last_coin_encourage_time = get_current_timestamp()
if request.finance_type == 2:
# 钻石鼓舞
money_inspire_price = base_config.get("gold_inspire_price")
moneyInspireLimited = base_config.get("gold_inspire_limit")
#money_inspire_price_multiple = base_config.get("money_inspire_price_multiple")
if boss.encourage_gold_num >= moneyInspireLimited:
logger.error("gold encourage too many times %s, %s" % (boss.encourage_gold_num, moneyInspireLimited))
response.result = False
response.result_no = 1704
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
gold = player.finance.gold
need_gold = money_inspire_price
if gold < need_gold:
response.result = False
response.result_no = 102
logger.debug("*" * 80)
print response
return response.SerializePartialToString()
def func():
boss.encourage_gold_num += 1
player.pay.pay(need_gold, const.ENCOURAGE_HEROS, func)
player.world_boss.save_data()
response.result = True
logger.debug("encourage_coin_num %s" % boss.encourage_coin_num)
logger.debug("encourage_gold_num %s" % boss.encourage_gold_num)
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 start_rob_escort_remote(guild_id, task_id, rob_no, player_id):
guild = guild_manager_obj.get_guild_obj(guild_id)
task = guild.get_task_by_id(task_id)
# get robbed success num
robbed_num = task.rob_success_times()
if task.rob_success_times() >= 2:
# 接受劫运任务，如果该任务已经达到最大劫运次数
return {'result': False, 'result_no': 190803}
if task.has_robbed(player_id):
# 已经被劫了
return {"result": False, "result_no": 190804}
# construct battle units
# update rob task
task_item = game_configs.guild_task_config.get(task.task_no)
logger.debug("task rob task infos %s %s" %
(task.rob_task_infos, len(task.rob_task_infos)))
rob_task_info = task.rob_task_infos[rob_no]
seed1, seed2 = get_seeds()
rob_task_info["seed1"] = seed1
rob_task_info["seed2"] = seed2
red_groups = []
blue_groups = []
for player_info in task.protecters:
blue_group = cPickle.loads(player_info.get("BattleUnitGrop"))
blue_groups.append(blue_group)
for player_info in rob_task_info.get("robbers"):
red_group = cPickle.loads(player_info.get("BattleUnitGrop"))
red_groups.append(red_group)
logger.debug("blue_groups %s" % blue_groups)
logger.debug("red_groups %s" % red_groups)
# pvp battle
rob_result = guild_pvp_start(red_groups, blue_groups, seed1, seed2)
rob_task_info["rob_result"] = rob_result
rob_task_info["rob_time"] = int(get_current_timestamp())
if rob_result:
robbers_num = len(rob_task_info.get("robbers"))
peoplePercentage = task_item.peoplePercentage.get(robbers_num)
robbedPercentage = task_item.robbedPercentage.get(robbed_num + 1)
robber_guild = guild_manager_obj.get_guild_obj(
rob_task_info.get("rob_guild_info").get("id"))
mail_arg1 = calculate_reward(peoplePercentage, robbedPercentage,
"SnatchReward", task_item, robber_guild)
if robbed_num + 1 >= 2:
if task_id in guild.escort_tasks_can_rob:
guild.escort_tasks_can_rob.remove(task_id)
guild.save_data()
rob_task_info["rob_reward"] = mail_arg1
for player_info in rob_task_info.get("robbers"):
send_mail(conf_id=1002,
receive_id=player_info.get("id"),
prize=str(get_reward(mail_arg1, robber_guild)))
rob_task_info["rob_state"] = -1
task.update_reward(task_item)
task.save_data()
res = {
"result": True,
"protecters": task.protecters,
"rob_task_info": rob_task_info,
"task": construct_task_data(task, rob_no)
}
logger.debug("res %s" % res)
return res
def update_rob_state(self, task_item):
for rob_task_info in self._rob_task_infos:
if rob_task_info.get("rob_state") == 1 and \
rob_task_info.get("rob_receive_task_time") + task_item.wait < get_current_timestamp():
rob_task_info["rob_state"] = 0
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 pvb_fight_start_1705(pro_data, player):
"""开始战斗
"""
logger.debug("fight start..")
request = stage_request_pb2.StageStartRequest()
request.ParseFromString(pro_data)
stage_id = request.stage_id # 关卡编号
unparalleled = request.unparalleled # 无双编号
logger.debug("unparalleled,%s" % unparalleled)
line_up = {} # {hero_id:pos}
for line in request.lineup:
if not line.hero_id:
continue
line_up[line.hero_id] = line.pos
stage_info = fight_start(stage_id, line_up, unparalleled, 0, player)
result = stage_info.get('result')
response = PvbFightResponse()
res = response.res
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')
logger.debug("--" * 40)
# 根据鼓舞次数，增加ATK百分比
atk_rate = player.world_boss.encourage_coin_num * base_config.get("worldbossInspireAtk", 0) + \
player.world_boss.encourage_gold_num * base_config.get("worldbossInspireAtkMoney", 0)
for slot_no, red_unit in red_units.items():
red_unit.atk *= (1 + atk_rate)
print red_units
print blue_units
for slot_no, red_unit in red_units.items():
red_add = response.red.add()
assemble(red_add, red_unit)
blue_units = blue_units[0]
for no, blue_unit in blue_units.items():
blue_add = response.blue.add()
assemble(blue_add, blue_unit)
response.red_best_skill = unparalleled
if unparalleled in player.line_up_component.unpars:
response.red_best_skill_level = player.line_up_component.unpars[
unparalleled]
# mock fight.
player_info = {}
player_info["player_id"] = player.base_info.id
player_info["nickname"] = player.base_info.base_name
player_info["level"] = player.level.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
result = remote_gate['world'].pvb_fight_remote(str_red_units, unparalleled,
str_blue_units, player_info)
response.fight_result = result
# 玩家信息更新
player.world_boss.fight_times += 1
player.world_boss.last_fight_time = get_current_timestamp()
player.world_boss.save_data()
print response
logger.debug("fight end..")
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()
