def load(self):
""" 加载数据 """
v = self.player.play_attr.get(PLAYER_ATTR_SIT)
log.debug('player-login-exp1 pid = %s, exp = %s', self.player.data.id, self.player.data.exp)
if not v:
v = self.make_sit_data()
self.player.play_attr.set(PLAYER_ATTR_SIT, v)
self.sit_data = v
self._save_logout_time()
tResLevelExp = self._get_res_exp(self.player.data.level)
#vip提速
self.vip_addexp = self.fetch_res(SIT_ADD_EXP, SIT_ADD_EXP_V)
if not tResLevelExp or not tResLevelExp.siteExp:
return
#提前更新玩家状态
self._update_player_state()
#判断离线之前是否处于打坐状态，并且做处理
#延迟5秒 是因为此模块会抛出消息如果先执行别的模块获得不到消息
def _delay():
try:
self.online_add_sitexp()
except:
log.log_except()
if not self.player.no_game:
spawn_later(5, _delay)
def add_task(self, aTid, aRid=None, pid=0, forced=False, send_msg=False):
""" 创建新任务
aRid:奖励id, 有则是兵符符任务
pid:父任务id
send_msg:是否发送,并且用于表示延迟秒数
"""
res_task = self.get_res_task(aTid)
if not res_task:
return
task = self.add_task_by_res(res_task, aRid=aRid, forced=forced or bool(pid))
if pid:
if not task:
log.error(u'(%s)玩家任务(%s)完成后,接后续任务(%s)失败:%s, %s',
self.player.data.id,
pid,
res_task.id,
self.tid_bm.to_base64(), self.tids.keys())
else:
self.task_active(task)
if not task:
return
if send_msg:#延迟发送,保证先完成任务再发下一任务
if type(send_msg) is bool:
self.send_accept_tasks([task])
else:
spawn_later(float(send_msg), self.send_accept_tasks, [task])
return task
def start(self):
self.data = ModelYwBoss.load(Game.store, ModelYwBoss.TABLE_KEY)
if not self.data:
self.data = ModelYwBoss()
self.data.set_owner(self)
self.load_from_dict(self.data.dataDict)
self._loop_task = spawn(self._loop)
resInterval = Game.res_mgr.res_common.get("ywBossInterval")
resRunaway = Game.res_mgr.res_common.get("ywBossRunaway")
#到下一个 xx:25 xx:55
now = int(time.time())
next_runaway = resInterval.i - (now % resInterval.i) - (resInterval.i -
resRunaway.i)
if next_runaway <= 60:
next_runaway = 60 #预留10秒钟起服
# 到下一个 xx:00 xx:30
next_refresh = resInterval.i - (now % resInterval.i)
if next_runaway <= 15 and next_runaway > next_refresh:
next_refresh = next_runaway + 3 #时序问题处理
self.runaway_timer = spawn_later(next_runaway,
self.runaway) # 逃跑定时器 xx:25 xx:55
self.refresh_timer = spawn_later(next_refresh,
self.refresh) # 刷新定时器 xx:00 xx:30
def load(self):
""" 加载数据 """
v = self.player.play_attr.get(PLAYER_ATTR_SIT)
log.debug('player-login-exp1 pid = %s, exp = %s', self.player.data.id,
self.player.data.exp)
if not v:
v = self.make_sit_data()
self.player.play_attr.set(PLAYER_ATTR_SIT, v)
self.sit_data = v
self._save_logout_time()
tResLevelExp = self._get_res_exp(self.player.data.level)
#vip提速
self.vip_addexp = self.fetch_res(SIT_ADD_EXP, SIT_ADD_EXP_V)
if not tResLevelExp or not tResLevelExp.siteExp:
return
#提前更新玩家状态
self._update_player_state()
#判断离线之前是否处于打坐状态，并且做处理
#延迟5秒 是因为此模块会抛出消息如果先执行别的模块获得不到消息
def _delay():
try:
self.online_add_sitexp()
except:
log.log_except()
if not self.player.no_game:
spawn_later(5, _delay)
def add_task(self, aTid, aRid=None, pid=0, forced=False, send_msg=False):
""" 创建新任务
aRid:奖励id, 有则是兵符符任务
pid:父任务id
send_msg:是否发送,并且用于表示延迟秒数
"""
res_task = self.get_res_task(aTid)
if not res_task:
return
task = self.add_task_by_res(res_task,
aRid=aRid,
forced=forced or bool(pid))
if pid:
if not task:
log.error(u'(%s)玩家任务(%s)完成后,接后续任务(%s)失败:%s, %s',
self.player.data.id, pid, res_task.id,
self.tid_bm.to_base64(), self.tids.keys())
else:
self.task_active(task)
if not task:
return
if send_msg: #延迟发送,保证先完成任务再发下一任务
if type(send_msg) is bool:
self.send_accept_tasks([task])
else:
spawn_later(float(send_msg), self.send_accept_tasks, [task])
return task
def __init__(self, app):
self.app = app
self.prefix = '/config/'
self.pre_len = len(self.prefix)
self.pre_ver = None
self.file_path = None
self.servers_json = None
spawn_later(3, self._refresh)
def _on_close(self, app):
if app not in self.apps:
return
pid, key, addr, names = self.apps.pop(app)
log.warn('close app:pid=%s, key=%s, addr=%s', pid, key, addr)
self.names.pop(key, None)
if self.free_addrs is not None and key not in self.key_addrs:
self.free_addrs.append(addr)
spawn_later(5, self.proc_mgr.kill_process, pid)
def _on_close(self, app):
if app not in self.apps:
return
pid, key, addr, names = self.apps.pop(app)
log.warn('close app:pid=%s, key=%s, addr=%s', pid, key, addr)
self.names.pop(key, None)
if self.free_addrs is not None and key not in self.key_addrs:
self.free_addrs.append(addr)
spawn_later(5, self.proc_mgr.kill_process, pid)
def load_from_dict(self, data):
self.cycleDay.load_from_dict(data.get("cycleDay", ""))
grBoss = data.get("grBoss", {}) # {个人bossId:{是否首通:0}}
for k, v in grBoss.items():
self.grBoss[int(k)] = v
self.qmBoss = data.get("qmBoss", {}) #{num:1, remind:[], time:0}
ssjBoss = data.get("ssjBoss", {}) # {配置表id: {是否首通:0}}
for k, v in ssjBoss.items():
self.ssjBoss[int(k)] = v
#处理初始化次数
resQmBossTzCnt = Game.res_mgr.res_common.get("qmBossTzCnt")
if not self.qmBoss:
self.addQmBossTZ(resQmBossTzCnt.i)
# 处理全民boss离线增加的挑战次数
now = int(time.time())
resQmBossCD = Game.res_mgr.res_common.get("qmBossCD")
qmBossTZ = self.GetQmBossTZ()
if qmBossTZ < resQmBossTzCnt.i:
iNextTime = self.GetQmBossTime()
if not iNextTime:
iNextTime = now + resQmBossCD.i
self.SetQmBossTime(iNextTime)
self.qmboss_num_timer = spawn_later(resQmBossCD.i,
self.addQmBossTZ, 1)
else:
if iNextTime > now: #还没到时间
idelay = iNextTime - now
self.qmboss_num_timer = spawn_later(
idelay, self.addQmBossTZ, 1)
else: #到时间了
self.addQmBossTZ(1) #增加一次
#然后再判断 次数是否满了
qmBossTZ = self.GetQmBossTZ()
if qmBossTZ >= resQmBossTzCnt.i:
return
#次数没满的情况下 判断超过多个周期
iOffLine = now - iNextTime
iAdd = int(iOffLine / resQmBossCD.i)
if iAdd:
self.addQmBossTZ(iAdd)
qmBossTZ = self.GetQmBossTZ()
#如果还是没满，启动定时器
if qmBossTZ < resQmBossTzCnt.i:
idelay = resQmBossCD.i - iOffLine % resQmBossCD.i
iNextTime = now + idelay
self.SetQmBossTime(iNextTime)
self.qmboss_num_timer = spawn_later(
idelay, self.addQmBossTZ, 1)
def auto(self, mgr, player):
""" 自动挂机, 返回:wasteTimes """
if self.data.auto:
return False, errcode.EC_DEEP_NO_AUTO
if self.data.fl >= FLOOR_BOSS_START - 1:
return False, errcode.EC_DEEP_BOSS_NO_AUTO
if self.is_auto:
log.info("pid %s, is_auto :%s", player.data.id, self.is_auto)
return False, errcode.EC_VALUE
#从当前层开始挂机,不理会返回上层的问题
c_floor = self.auto_floors()
#TODO: 测试用，60秒完成
#waste_times = 60
waste_times = c_floor * mgr.auto_times(player)
#waste_times = c_floor * mgr.times_per_floor(player)
auto_time = int(time.time() + waste_times)
if common.is_pass_day_time(auto_time): #挂机结束时间超过今天
return False, errcode.EC_DEEP_OVER_DAY
#扣费
coin = int(c_floor * mgr.auto_cost)
if not player.cost_coin(aCoin2=coin, log_type=COIN_DEEP_AUTO):
return False, errcode.EC_COST_ERR
self.data.at = auto_time
self._auto_task = spawn_later(waste_times + 5, self.auto_complete, mgr,
player)
self.data.auto = 1
self.modified = True
return True, waste_times
def auto(self, mgr, player):
""" 自动挂机, 返回:wasteTimes """
if self.data.auto:
return False, errcode.EC_DEEP_NO_AUTO
if self.data.fl >= FLOOR_BOSS_START - 1:
return False, errcode.EC_DEEP_BOSS_NO_AUTO
if self.is_auto:
log.info("pid %s, is_auto :%s", player.data.id, self.is_auto)
return False, errcode.EC_VALUE
#从当前层开始挂机,不理会返回上层的问题
c_floor = self.auto_floors()
#TODO: 测试用，60秒完成
#waste_times = 60
waste_times = c_floor * mgr.auto_times(player)
#waste_times = c_floor * mgr.times_per_floor(player)
auto_time = int(time.time() + waste_times)
if common.is_pass_day_time(auto_time):#挂机结束时间超过今天
return False, errcode.EC_DEEP_OVER_DAY
#扣费
coin = int(c_floor * mgr.auto_cost)
if not player.cost_coin(aCoin2=coin, log_type=COIN_DEEP_AUTO):
return False, errcode.EC_COST_ERR
self.data.at = auto_time
self._auto_task = spawn_later(waste_times + 5, self.auto_complete, mgr, player)
self.data.auto = 1
self.modified = True
return True, waste_times
def login(self, mgr, player):
if self.is_auto:
waste_times = int(self.data.at - time.time())
if waste_times <= 0:
self.auto_complete(mgr, player, send_msg=False)
else:
self._auto_task = spawn_later(waste_times + 5, self.auto_complete, mgr, player)
def reset(self):
self.questions = []
self.startTimePoint = []
now = int(time.time())
todayOpenTs = custom_today_ts(12, 0, 0)
# 初始下期活动开始时间
self.nextOpenTime = todayOpenTs
if now > todayOpenTs:
self.nextOpenTime += 3600 * 24
# 初始化题库
self.questions = random.sample(
list(Game.res_mgr.res_examQuestionPool.keys()),
constant.QUESTION_NUM)
# 初始化每题开始时间
for x in range(constant.QUESTION_NUM):
self.startTimePoint.append(
self.nextOpenTime + x *
(self.answerInterval + self.readyInterval))
interval = self.nextOpenTime - now
self._openTimer = spawn_later(interval - 5, self.open)
def refresh(self):
"""刷新"""
refreshKeys = []
#刷新boss
for bossobj in self.boss.values():
rs = bossobj.refresh()
if rs:
refreshKeys.append(bossobj.id)
# 刷新通知
n = datetime.datetime.now()
resStTime = Game.res_mgr.res_common.get("ywBossStTime")
resEndTime = Game.res_mgr.res_common.get("ywBossEndTime")
if resEndTime.i > resStTime.i: # 不跨天
if n.hour in range(resStTime.i, resEndTime.i): # 活动时间内才推送通知
# 调用所有逻辑服 通知玩家boss刷新
for addr, logic in Game.rpc_logic_game:
if logic:
logic.YwBossRefresh(refreshKeys, _no_result=True)
else: # 跨天
if n.hour in range(0, resEndTime.i) or n.hour in range(
resStTime.i, 24):
# 调用所有逻辑服 通知玩家boss刷新
for addr, logic in Game.rpc_logic_game:
if logic:
logic.YwBossRefresh(refreshKeys, _no_result=True)
if self.refresh_timer:
self.refresh_timer.kill(block=False)
self.refresh_timer = None
# 到下一个 xx:00 xx:30
resInterval = Game.res_mgr.res_common.get("ywBossInterval")
now = int(time.time())
next_refresh = resInterval.i - (now % resInterval.i)
self.refresh_timer = spawn_later(next_refresh,
self.refresh) # 刷新定时器 xx:00 xx:30
def beKill(self, pid, name, fa):
now = int(time.time())
if self.reborn_timer:
self.reborn_timer.kill(block=False)
self.reborn_timer = None
res = Game.res_mgr.res_qmBoss.get(self.id)
if res:
self.time = now + res.cdtime
self.reborn_timer = spawn_later(res.cdtime, self.reBorn)
#设置击杀状态
self.status = 1
# 更新击杀列表 玩家id(pid, int) 击杀时间戳(time, int) 玩家名称(name, string) 战力(fa, int)
one = dict(pid=pid, name=name, fa=fa, time=now)
self.killList.insert(0, one)
self.killList = self.killList[:5] #只保留最近5条
# 调用所有逻辑服 通知玩家boss被击杀
for addr, logic in Game.rpc_logic_game:
if logic:
logic.QmBossBeKill(self.id, self.time, _no_result=True)
#发排名邮件奖励
fighters = self.GetFighterData()
for fighter in fighters:
pid = fighter.get("pid", 0)
rank = fighter.get("rank", 0)
self.sendQmBossKillRankingReward(pid, self.id, rank)
def load(self):
""" 加载数据(执行中的任务) """
store = self.player._game.rpc_store
end_tasks = self.player.play_attr.setdefault(PLAYER_ATTR_TASKS, '')
self.tid_bm.from_base64(end_tasks)
querys = dict(pid=self.player.data.id, status=1)
tasks = store.query_loads(TN_P_TASK, querys)
for data in tasks:
tid = data['tid']
if tid in self.tids: #重复记录...
log.warn('[task]player(%s) task(%s) repeat',
self.player.data.id, tid)
spawn(store.delete, TN_P_TASK, data['id'])
continue
task = Task.new_by_dict(data)
if not task:
log.warn('[task]res_task not found:%s', tid)
continue
if tid in self.tid_bm: #记录异常
self.player.log_task(tid, data['id'], t=PL_ERROR)
self.tasks[data['id']] = task
self.tids[tid] = task
if task.data.isRun:
self.run_task = task
if not end_tasks: #新玩家
#log.debug(u'new player accept_tasks')
def _fun():
if not (self.player and self.player.logined):
return
self.accept_tasks(TUL_LEVEL, 1)
spawn_later(2, _fun)
init_data = {
TASK_BFTASK_FINISH: 0,
TASK_ZXTASK_FINISH: 0,
TASK_YCTASK_FINISH: 0
}
self.p_attr_task = self.player.play_attr.setdefault(
PLAYER_ATTR_TASK, init_data)
if not self.p_attr_task:
self.p_attr_task = init_data
def _remove_logic(self, app, app_exist=True):
pid, game = self.logics.pop(app, None)
log.debug('remove_logic:%s, %s', pid, game)
#self.mgr.apps.pop(app, None)
#反注册
try:
if game:
Game.unreg_other_game(game.get_addr())
except:
log.log_except()
if app_exist:
game.stop()
app.stop()
app.get_service().stop()
spawn(self.mgr._del_game, app)
spawn_later(5, self.mgr._del_subgame, pid, app)
def _remove_logic(self, app, app_exist=True):
pid, game = self.logics.pop(app, None)
log.debug('remove_logic:%s, %s', pid, game)
#self.mgr.apps.pop(app, None)
#反注册
try:
if game:
Game.unreg_other_game(game.get_addr())
except:
log.log_except()
if app_exist:
game.stop()
app.stop()
app.get_service().stop()
spawn(self.mgr._del_game, app)
spawn_later(5, self.mgr._del_subgame, pid, app)
def login(self, mgr, player):
if self.is_auto:
waste_times = int(self.data.at - time.time())
if waste_times <= 0:
self.auto_complete(mgr, player, send_msg=False)
else:
self._auto_task = spawn_later(waste_times + 5,
self.auto_complete, mgr, player)
def new_logic(self):
""" 新建游戏逻辑进程 """
log.info(u'新建游戏逻辑进程')
mgr = self.mgr
app, pid = mgr._new_subgame(self._get_key())
name = mgr._app_register(app, new_logic_game)[0]
game = app.get_proxy(name)
self.mgr.init_subgame(app)
game.init()
game.start()
self.logics[app] = pid, game
#注册
Game.reg_other_game(game, pid)
log.debug('new_logic:%s, %s', pid, game)
app.sub_close(self._on_close)
spawn_later(1, self.mgr._new_game, app, game, pid)
return app
def new_logic(self):
""" 新建游戏逻辑进程 """
log.info(u'新建游戏逻辑进程')
mgr = self.mgr
app, pid = mgr._new_subgame(self._get_key())
name = mgr._app_register(app, new_logic_game)[0]
game = app.get_proxy(name)
self.mgr.init_subgame(app)
game.init()
game.start()
self.logics[app] = pid, game
#注册
Game.reg_other_game(game, pid)
log.debug('new_logic:%s, %s', pid, game)
app.sub_close(self._on_close)
spawn_later(1, self.mgr._new_game, app, game, pid)
return app
def arena_reward(self):
""" 定时发放奖励 """
#安装定时器
#t = self.next_reward_times
next_time = self.next_reward_time
times = next_time - time.time() if next_time > time.time() else 0
times += 10
log.info('arena_reward after %s times', times)
self._reward_task = spawn_later(times, self._reward_nomal, next_time)
def open(self):
self.players = {}
self.ranking = []
self.status = True
self.nextOpenTime += 3600 * 24
# 发开始公告
for addr, logic in Game.rpc_logic_game:
if logic:
logic.sendSystemTemplateMSG(1116, [])
closeTime = (self.answerInterval + self.readyInterval
) * constant.QUESTION_NUM - self.readyInterval + 1
self._closeTimer = spawn_later(closeTime + 5, self.close)
calTime = self.startTimePoint[0] + (
self.answerInterval + self.readyInterval - 2) - (time.time())
self.calTimer = spawn_later(calTime, self.cal, 1)
def rc_login1(self, user, key):
""" client登陆到逻辑进程
user: user id
"""
if self.inited:
return
resp_f = 'login1'
self.inited = 1
log.info(u'账号(%s)登陆', user)
self.key = key
self.data.id = user
if not self.logon():
log.error(u'账号(%s)登陆错误', user)
resp = pack_msg(resp_f, 0, err=errcode.EC_LOGIN_ERR)
else:
#resp.server_time = int(time.time())
resp = pack_msg(resp_f, 1)
self.inited = 2
spawn_later(1, self._init_waiter.set)
return resp
def delQmBossTZ(self, dele):
num = self.qmBoss.get("num", 0) # {num:1, remind:[], time:0}
num -= dele
resQmBossCD = Game.res_mgr.res_common.get("qmBossCD")
if not self.qmboss_num_timer:
self.qmboss_num_timer = spawn_later(resQmBossCD.i,
self.addQmBossTZ, 1)
now = int(time.time())
self.SetQmBossTime(now + resQmBossCD.i)
self.qmBoss["num"] = num
self.markDirty()
def recoverChallengeNum(self):
if self.recover_task:
self.recover_task.kill(block=False)
self.recover_task = None
numRes = Game.res_mgr.res_common.get("pvpChallengeNumMax")
self.challengeNum += 1
if self.challengeNum > numRes.i:
self.challengeNum = numRes.i
self.lastRecoverTime = int(time.time())
self.recover_task = spawn_later(7200, self.recoverChallengeNum)
self.markDirty()
def load(self):
""" 加载数据(执行中的任务) """
store = self.player._game.rpc_store
end_tasks = self.player.play_attr.setdefault(PLAYER_ATTR_TASKS, '')
self.tid_bm.from_base64(end_tasks)
querys = dict(pid=self.player.data.id, status=1)
tasks = store.query_loads(TN_P_TASK, querys)
for data in tasks:
tid = data['tid']
if tid in self.tids:#重复记录...
log.warn('[task]player(%s) task(%s) repeat', self.player.data.id, tid)
spawn(store.delete, TN_P_TASK, data['id'])
continue
task = Task.new_by_dict(data)
if not task:
log.warn('[task]res_task not found:%s', tid)
continue
if tid in self.tid_bm:#记录异常
self.player.log_task(tid, data['id'], t=PL_ERROR)
self.tasks[data['id']] = task
self.tids[tid] = task
if task.data.isRun:
self.run_task = task
if not end_tasks:#新玩家
#log.debug(u'new player accept_tasks')
def _fun():
if not (self.player and self.player.logined):
return
self.accept_tasks(TUL_LEVEL, 1)
spawn_later(2, _fun)
init_data = {TASK_BFTASK_FINISH:0, TASK_ZXTASK_FINISH:0, TASK_YCTASK_FINISH:0}
self.p_attr_task = self.player.play_attr.setdefault(PLAYER_ATTR_TASK, init_data)
if not self.p_attr_task:
self.p_attr_task = init_data
def cal(self, index):
ranking = list(self.players.values())
ranking.sort(key=cmp_to_key(self._comp))
print("cal exam rank ", ranking, int(time.time()))
for k in range(len(ranking)):
ranking[k]["rank"] = k + 1
self.ranking = ranking
index += 1
calTime = self.startTimePoint[index] + (
self.answerInterval + self.readyInterval - 2) - (time.time())
if self.status and index < constant.QUESTION_NUM - 1:
self.calTimer = spawn_later(calTime, self.cal, index)
def start(self, init=False):
if not self.stoped:
return
init_setting()
if not self.is_start: #开启自动启动线程
if self._auto_start_task is None:
self._auto_start_task = spawn_later(0, self._auto_start)
return
log.debug(u'arena_mgr start!')
spawn(self.lood_save)
Game.setting_mgr.sub(MSG_RES_RELOAD, self.reload)
if init:
self.init()
else:
self.load()
self.arena_reward()
Game.chat_mgr.sys_send(language.ARENA_START)
self.stoped = False
def load_from_dict(self, data):
self.cycleDay.load_from_dict(data.get("cycleDay", ""))
self.cycleWeek.load_from_dict(data.get("cycleWeek", ""))
numRes = Game.res_mgr.res_common.get("pvpChallengeNumMax")
self.challengeNum = data.get("challengeNum", numRes.i) # 挑战次数 初始3次
self.lastRecoverTime = data.get("lastRecoverTime", 0) # 最后一次恢复时间
self.TotalWin = data.get("TotalWin", 0) # 历史总战胜次数
self.TotalFightNum = data.get("TotalFightNum", 0) # 历史总挑战次数
self.winMax = data.get("winMax", 0) # 历史最大连胜次数
self.revengeNum = data.get("revengeNum", 0) # 历史复仇次数
try:
self.beChallengeData = data.get("beChallengeData", [])
if self.beChallengeData:
self.beChallengeData = pickle.loads(self.beChallengeData)
except:
self.beChallengeData = []
#判断离线时长
cdRes = Game.res_mgr.res_common.get("pvpChallengeNumCD")
now = int(time.time())
add = int((now - self.lastRecoverTime)/cdRes.i)
self.challengeNum += add
if self.challengeNum > numRes.i:
self.challengeNum = numRes.i
#设定最后一次恢复时间
nowhour = gtime.current_hour()
refresh = (0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22)
last = 0
for hour in refresh:
if nowhour < hour:
break
last = hour
#今日凌晨时间
zero_day_time = int(gtime.zero_day_time())
self.lastRecoverTime = zero_day_time + 3600*last
nextRecoverTime = self.lastRecoverTime + 7200
self.recover_task = spawn_later(nextRecoverTime-now, self.recoverChallengeNum)
def occupy(self, atkInfo, rid):
"""占领"""
#防止异步问题，如果占领者已经变更
if rid != self.rid:
return
self.rid = atkInfo.get("pid", 0) # 占领者id(rid, int)
self.sex = atkInfo.get("sex", 0) # 占领者性别(sex, int)
self.name = atkInfo.get("name", "") # 占领者名称(name, string)
self.fa = atkInfo.get("fa", 0) # 占领者战力(fa, int)
self.portrait = atkInfo.get("portrait", 0) # 占领者头像
self.headframe = atkInfo.get("headframe", 0) # 占领者头像框
if self.occupier_timer:
self.occupier_timer.kill(block=False)
self.occupier_timer = None
resBoss = Game.res_mgr.res_ywBoss.get(self.id)
if resBoss:
self.time = int(time.time()) + resBoss.occupy
self.occupier_timer = spawn_later(resBoss.occupy, self.beKill,
atkInfo)
self.markDirty()
def addQmBossTZ(self, add):
num = self.qmBoss.get("num", 0) #{num:1, remind:[], time:0}
num += add
resQmBossTzCnt = Game.res_mgr.res_common.get("qmBossTzCnt")
if num >= resQmBossTzCnt.i:
if self.qmboss_num_timer:
self.qmboss_num_timer.kill(block=False)
self.qmboss_num_timer = None
self.SetQmBossTime(0)
num = resQmBossTzCnt.i
else:
now = int(time.time())
if now >= self.GetQmBossTime() and self.qmboss_num_timer:
self.qmboss_num_timer.kill(block=False)
self.qmboss_num_timer = None
resQmBossCD = Game.res_mgr.res_common.get("qmBossCD")
self.qmboss_num_timer = spawn_later(resQmBossCD.i,
self.addQmBossTZ, 1)
self.SetQmBossTime(now + resQmBossCD.i)
self.qmBoss["num"] = num
self.markDirty()
def load_from_dict(self, data):
self.id = data.get("id", 0) # 全民bossid(id, int)
self.curHp = data.get("curHp", 0) # 当前血量(curHp, int)
self.maxHp = data.get("maxHp", 0) # 总血量(maxHp, int)
self.status = data.get("status", 0) # 状态(status, int)0=未击杀 1=已击杀
self.time = data.get("time", 0) # 重生时间戳(time, int)
self.killList = data.get(
"killList",
[]) # 击杀列表 击杀时间戳(time, int) 玩家名称(name, string) 战力(fa, int)
fighterData = data.get("fighterData",
[]) # 争夺列表 玩家名称(name, int) 伤害(hurt, int)
for one in fighterData:
self.fighterData[one["pid"]] = one
# 要对离线再回来的时间差进行处理
if self.time:
now = int(time.time())
if now >= self.time:
self.reSet()
else:
interval = self.time - now
self.reborn_timer = spawn_later(interval, self.reBorn)
def runaway(self):
"""逃跑"""
runawayKeys = []
# 刷新boss
for bossobj in self.boss.values():
if bossobj.status == 1:
rs = bossobj.runaway()
if rs:
runawayKeys.append(bossobj.id)
# 逃跑通知
n = datetime.datetime.now()
resStTime = Game.res_mgr.res_common.get("ywBossStTime")
resEndTime = Game.res_mgr.res_common.get("ywBossEndTime")
if resEndTime.i > resStTime.i: #不跨天
if n.hour in range(resStTime.i, resEndTime.i): #活动时间内才推送通知
# 调用所有逻辑服 通知玩家boss逃跑
for addr, logic in Game.rpc_logic_game:
if logic:
logic.YwBossRunaway(runawayKeys, _no_result=True)
else: #跨天
if n.hour in range(0, resEndTime.i) or n.hour in range(
resStTime.i, 24):
# 调用所有逻辑服 通知玩家boss逃跑
for addr, logic in Game.rpc_logic_game:
if logic:
logic.YwBossRunaway(runawayKeys, _no_result=True)
if self.runaway_timer:
self.runaway_timer.kill(block=False)
self.runaway_timer = None
# 到下一个 xx:25 xx:55
resInterval = Game.res_mgr.res_common.get("ywBossInterval")
resRunaway = Game.res_mgr.res_common.get("ywBossRunaway")
now = int(time.time())
next_runaway = resInterval.i - (now % resInterval.i) - (
resInterval.i - resRunaway.i) + resInterval.i
self.runaway_timer = spawn_later(next_runaway,
self.runaway) # 逃跑定时器 xx:00 xx:30
def _close():
self.msgs.put(None)
self.gw_mgr.del_process(self.gwid, self.pid)
spawn_later(0.2, _task.kill)
def connect(self, host, port):
""" 切换连接其它服 """
self.closing = True # 标识准备关闭,
gw = self.gw_mgr.rpc_gws[self.gwid]
gw.Connect(self.pid, '%s:%d' % (host, port))
spawn_later(5, self.close, client=False)
