def start(self):
self.init_frame()
self.frame.start()
self._init_web()
self.web_svr.start()
log.info('app started')
# spawn_later(2, self.stop)
while 1:
try:
self._waiter.wait()
break
except KeyboardInterrupt:
log.info('app stoped:KeyboardInterrupt')
except SystemExit:
log.info('app stoped:SystemExit')
except:
log.log_except()
break
log.info('spawn app stop')
spawn(self.stop)
sleep(0.2)
cmd = ' '.join(list(map(str, [
sys.executable,
] + sys.argv)))
log.info('*****app(%s) stoped', cmd)
self.stop()
#守护进程方式,重启服务
if self.restarted and hasattr(self, 'daemon_runner'):
self.daemon_runner.domain_restart()
def start(self):
if not self.stoped:
return
self._sock.settimeout(self.timeout + self.delay_time)
self._loop_task = corelib.spawn(self._loop)
self._heartbeat_task = corelib.spawn(self.heartbeat)
self._send_task = corelib.spawn(self._send_let)
def over1(start, end, host, port):
""" 压力测试1:模拟多个角色进入 """
func_times = range(8, 20)
move_times = range(1, 2)
wait_event = Event()
count = 0
tasks = []
TESTS = TestCase.get_tests()
def _show_info():
while 1:
sleep(10)
log.info(u'******tasks(%s / %s) runing', len(tasks), count)
def _test_one(name):
tasks.append(name)
try:
p = enter(name, host, port)
log.debug(u'玩家(%s)进入', name)
p.valid_gm()
while 1:
_test(name, p, TESTS[:], func_times)
#close(p.user)
except KeyboardInterrupt:
wait_event.set()
except:
log.log_except()
finally:
tasks.remove(name)
for i in xrange(start, end+1):
count += 1
name = 'over1_%s' % i
spawn(_test_one, name)
spawn(_show_info)
wait_event.wait()
def SetTodayAct(self, num):
self.cycleDay.Set("guildTodayAct", num)
spawn(self.owner.call,
"guildTodayActPush", {"todayAct": num},
noresult=True)
# 抛事件
self.owner.safe_pub(msg_define.MSG_GUILD_TODAY_ACTEXP_CHANGE)
def init_monitor():
global client_monitor_export, grpc_monitor, monitor_store
if not getattr(app_config, 'monitor', None):
return
if client_monitor_export == monitor_export:
log.info('init_monitor has done')
return
log.info('init_monitor')
client_monitor_export = monitor_export
grpc_monitor = _grpc_monitor
monitor_store = _monitor_store
def report():
try:
import app
except ImportError:
return
st = 30 * 60
m = Monitor.instance()
while not app.stoped:
data = m.pop_report()
for fn, (t, total, use, err) in data.iteritems():
Game.glog.log_rpc(
dict(func=fn, t=t, total=total, use=use, err=err))
sleep(st)
spawn(report)
def start(self):
if not self.stoped:
return
self._sock.settimeout(self.timeout + self.delay_time)
self._loop_task = corelib.spawn(self._loop)
self._heartbeat_task = corelib.spawn(self.heartbeat)
self._send_task = corelib.spawn(self._send_let)
def player_login(self, pid):
resp_f = 'enter'
player_data = PlayerData.load(pid)
player = Player()
player.data.update(player_data)
if player.data.id is None:
log.error('player(%d)player_login load error:%s', pid, player_data)
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
if player.is_forbid_login:
return pack_msg(resp_f, 0, err=errcode.EC_FORBID_LOGON)
if not self.mgr.add_player(player):
return pack_msg(resp_f, 0, err=errcode.EC_TIME_UNDUE)
self.player = player
try:
player.set_rpc(self._rpc)
player.login(self)
map_id = player.data.mapId if player.data.mapId else 1
player.scene_enter(map_id, login=True)
self.mgr.logon_player(player)
log.debug(u'(%s)玩家(%s)登陆成功', player.data.id, player.data.name)
player.send_msg(player.get_init_msg())
spawn(self.mgr.logoned_player, player)
return pack_msg(resp_f, 1)
except:
log.log_except(u'玩家(%s)登陆初始化失败', player.data.id)
self.player_logout()
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
def _check_loop(self):
""" 检查 """
pass_time = 60
while 1:
spawn(self._check_set)
sleep(pass_time)
self._log_info(pass_time)
def Use(self, xnum, select):
reward = {}
cnum = 0
for i in range(xnum):
r = self.getSelect(select)
if not r:
continue
cnum += 1
for k, v in r.items():
reward[k] = reward.get(k, 0) + v
if not cnum:
return
respBag = self.ownerMode.owner.bag.costItem(
{self.resID: cnum}, constant.ITEM_COST_OPEN_BOX, wLog=True)
if not respBag.get("rs", 0):
return
respBag2 = self.ownerMode.owner.bag.add(reward,
constant.ITEM_ADD_OPEN_BOX,
wLog=True,
mail=True)
respBag = self.ownerMode.owner.mergeRespBag(respBag, respBag2)
# 打包返回信息
dUpdate = self.ownerMode.owner.packRespBag(respBag)
resp = {
"allUpdate": dUpdate,
}
spawn(self.ownerMode.owner.call, "itemUse", resp, noresult=True)
def run(self):
import game
game.init(self)
sys.modules['app'] = self
self.names = None #subgame names
self.sub_mgr = subgame.SubGameMgr(self)
self.sub_mgr.start()
self.rpc_svr.bind(self.admin_addr)
self.rpc_svr.register(self)
self.rpc_svr.start()
self._init_web()
self.web_svr.start()
log.info('app started')
while 1:
try:
self._waiter.wait()
break
except KeyboardInterrupt:
log.info('app stoped:KeyboardInterrupt')
except SystemExit:
log.info('app stoped:SystemExit')
except:
log.log_except()
break
log.info('spawn app stop')
spawn(self.stop)
sleep(0.2)
cmd = ' '.join(map(str, [sys.executable,] + sys.argv))
log.info('*****app(%s) stoped', cmd)
self.stop()
#守护进程方式,重启服务
if self.restarted and hasattr(self, 'daemon_runner'):
self.daemon_runner.domain_restart()
def _check_loop(self):
""" 检查 """
pass_time = 60
while 1:
spawn(self._check_set)
sleep(pass_time)
self._log_info(pass_time)
def start(self):
self._game.rpc_player_mgr.rpc_sub(logon_by_boss, MSG_LOGON, _proxy=True)
self._game.rpc_player_mgr.rpc_sub(logout_by_boss, MSG_LOGOUT, _proxy=True)
self._game.rpc_ally_mgr.rpc_sub(ally_up, MSG_ALLY_UP, _proxy=True)
self.load()
self._loop_task_ally = spawn(self._a_boss)
self._loop_task_world = spawn(self._w_boos)
def AddItem(who, dAdd):
dAdd = eval(dAdd)
respBag = who.bag.add(dAdd, constant.ITEM_ADD_GM)
cost_update = who.packRespBag(respBag)
resp = {
"allUpdate": cost_update,
}
spawn(who.call, "roleAllUpdate", resp, noresult=True)
def start(self):
""" 开启 """
self.load()
spawn(self.loop)
#保存前十
spawn(self.rank_save)
Game.rpc_horn_mgr.rpc_sub(deep_enter, MSG_DEEP_FLOOR, _proxy=True)
Game.rpc_boss_mgr.rpc_sub(boss_rank, MSG_WBOSS_RANK, _proxy=True)
def testFight(who, barrID):
import time
t1 = time.time()
barrID = int(barrID)
from game.fight import createFight
# position = [{1: '38030013-1', 2: '38030013-2', 3: '38030013-3'}]
# who._handler.rc_uploadBattleArray (1, position)
fightobj = createFight(constant.FIGHT_TYPE_100)
rs = fightobj.init_data(
who.GetFightData(constant.BATTLE_ARRAY_TYPE_NORMAL), barrID)
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
fightLog = fightobj.doFight()
log_end = fightLog.get("end", {})
winerList = log_end.get("winerList", [])
fightResult = 1 if who.id in winerList else 0
barrRes = Game.res_mgr.res_barrier.get(barrID)
rewardRes = Game.res_mgr.res_reward.get(barrRes.rewardId)
respBag = {}
if fightResult:
dReward = rewardRes.doReward()
respBag = who.bag.add(dReward,
constant.ITEM_ADD_MORMAL_SCENE_FIGHT,
wLog=True)
# 打包返回信息
dUpdate = who.packRespBag(respBag)
resp = {
"fightLog": fightLog,
"allUpdate": dUpdate,
}
spawn(who.call, "mapNormalFight", resp, noresult=True)
t2 = time.time()
import ujson
dump_log = ujson.dumps(fightLog)
t3 = time.time()
import config
if config.serverNo == '030013':
fp = open("D:\\work\\pokemon2\\server\\code\\log\\testFight.log", "a")
fp.write(dump_log)
fp.write("\n")
fp.write(str(t2 - t1))
fp.write("\n")
fp.write(str(t3 - t2))
fp.write("\n")
fp.close()
from corelib import log
log.debug(t2 - t1)
log.debug(t3 - t2)
def SetActExp(self, actExp):
self.actExp = actExp
self.markDirty()
spawn(self.owner.call,
"guildActInfoPush", {
"actLv": self.actLv,
"actExp": self.actExp
},
noresult=True)
def loop(self):
try:
while 1:
sleep(self.loop_time)
if not self.resp_and_sends:
continue
self.flush()
finally:
spawn(self.stop)
def rescueKv(who, k, v):
who.rescue.rescueSystemKey({int(k): int(v)})
dUpdate = {}
dUpdate["rescue"] = who.rescue.to_init_data()
resp = {
"allUpdate": dUpdate,
}
spawn(who.call, "roleAllUpdate", resp, noresult=True)
def start(self, room, pid, data=None):
""" 开战 """
self.room = room
self.group = data
self.group.win_node(room.aid)
self.war_node = self.group.get_node(room.aid)
self.is_choose = False
self.smap_broad()
spawn(self.auto_choose_node)
return True, None
def rescueAuto(who):
who.rescue.rescueAuto()
dUpdate = {}
dUpdate["rescue"] = who.rescue.to_init_data()
resp = {
"allUpdate": dUpdate,
}
spawn(who.call, "roleAllUpdate", resp, noresult=True)
def _process(self, data):
msgs = self._unpacker.unpack(data)
#log.debug('read data:%s, msgs=%s', len(data), msgs)
for m in msgs:
full_name = m.DESCRIPTOR.full_name
if full_name.startswith('com.shendian.protobuf.'):
func_name = full_name.replace('com.shendian.protobuf.', '')
func = self._get_handle(full_name)
if func:
corelib.spawn(self._call_func, func, m)
def start(self, room, pid, data=None):
""" 开战 """
self.room = room
self.group = data
self.group.win_node(room.aid)
self.war_node = self.group.get_node(room.aid)
self.is_choose = False
self.smap_broad()
spawn(self.auto_choose_node)
return True, None
def loop(self):
""" 定时获取排名数据 """
level_rank = RankData()
cbe_rank = RankData()
while 1:
level_rank.init()
cbe_rank.init()
spawn(self.loop_data, level_rank, cbe_rank)
spawn(self.save)
sleep(RESET_LOAD_TIME)
def _process(self, data):
msgs = self._unpacker.unpack(data)
#log.debug('read data:%s, msgs=%s', len(data), msgs)
for m in msgs:
full_name = m.DESCRIPTOR.full_name
if full_name.startswith('com.shendian.protobuf.'):
func_name = full_name.replace('com.shendian.protobuf.', '')
func = self._get_handle(full_name)
if func:
corelib.spawn(self._call_func, func, m)
def _process(self, data):
msgs = self._unpacker.unpack(data)
if DEBUG_PACK: log.debug('read data:%s, msgs=%s', len(data), msgs)
for m in msgs:
tag = m.pop('_tag')
full_name = m['f']
func = self._get_handle(full_name)
if func:
corelib.spawn(self._call_func, func, tag, m)
else:
self.send(self.pack_msg(full_name, 0, err=1, tag=tag))
def _process(self, data):
msgs = self._unpacker.unpack(data)
if DEBUG_PACK: log.debug('read data:%s, msgs=%s', len(data), msgs)
for m in msgs:
tag = m.pop('_tag')
full_name = m['f']
func = self._get_handle(full_name)
if func:
corelib.spawn(self._call_func, func, tag, m)
else:
self.send(self.pack_msg(full_name, 0, err=1, tag=tag))
def rescueScore(who, s):
who.rescue.score = int(s)
who.rescue.markDirty()
dUpdate = {}
dUpdate["rescue"] = who.rescue.to_init_data()
resp = {
"allUpdate": dUpdate,
}
spawn(who.call, "roleAllUpdate", resp, noresult=True)
def AddExp(who, add):
add = int(add)
iCurExp = who.base.GetExp()
iNewExp = iCurExp + add
who.base.SetExp(iNewExp)
dUpdate = {}
dUpdate["base"] = {"exp": who.base.GetExp()}
resp = {
"allUpdate": dUpdate,
}
spawn(who.call, "roleAllUpdate", resp, noresult=True)
def start_broad(self, pid=0):
""" 开战或和进入下一场广播 """
resp_f = 'awarStartB'
self.war_data.start()
self._loop_task_broad = spawn(self._loop_broad)
for pid in self.war_data.war_pids:
data = self.get_data(pid)
data.update(dict(asid=self.room.res_warstart_config.id))
self.send_msg(resp_f, data, send_pids=[pid])
if self.war_per_config.hurts:
spawn(self.boss_hurt_boat)
spawn(self._loop_war)
def time_start(self):
""" 根据当前时间和配置表数据对应开启活动 """
now_sec = common.current_time() - common.zero_day_time()
for res_config in self.res_warstart_configs.itervalues():
notice_time = res_config.stime - res_config.ntime
if notice_time <= now_sec < res_config.etime:
self.warstart_config = res_config
l_sec = now_sec - res_config.stime
spawn(self._notice, l_sec)
log.debug('start----- %s, %s', res_config.stime, res_config.type)
return True
return False
def start_broad(self, pid=0):
""" 开战或和进入下一场广播 """
resp_f = 'awarStartB'
self.war_data.start()
self._loop_task_broad = spawn(self._loop_broad)
for pid in self.war_data.war_pids:
data = self.get_data(pid)
data.update(dict(asid=self.room.res_warstart_config.id))
self.send_msg(resp_f, data, send_pids=[pid])
if self.war_per_config.hurts:
spawn(self.boss_hurt_boat)
spawn(self._loop_war)
def start(self):
self.data = self.DATA_CLS.load(Game.store, self.DATA_CLS.TABLE_KEY)
if not self.data:
self.data = self.DATA_CLS()
else:
self.load_from_dict(self.data.dataDict)
self.data.set_owner(self)
self._save_loop_task = spawn(self._saveLoop)
self.loop_ChengzhangjijinNum_timer = spawn(
self.ChengzhangjijinNum_loop)
def time_start(self):
""" 根据当前时间和配置表数据对应开启活动 """
now_sec = common.current_time() - common.zero_day_time()
for res_config in self.res_warstart_configs.itervalues():
notice_time = res_config.stime - res_config.ntime
if notice_time <= now_sec < res_config.etime:
self.warstart_config = res_config
l_sec = now_sec - res_config.stime
spawn(self._notice, l_sec)
log.debug('start----- %s, %s', res_config.stime,
res_config.type)
return True
return False
def cron_clean_data_zero(self, inited=False):
"""
定在每天凌晨0点初始化的处理
"""
now = datetime.datetime.now()
refresh_time = custom_today(hour=0, minute=0)
refresh_time += ONE_DAY_DELTA
sleep_times = (refresh_time - now).seconds + 5
self.timer_set.call_later(sleep_times, self.cron_clean_data_zero)
#执行游戏逻辑刷新
if not inited:
log.info(u"每日0点定时刷新开始")
spawn(self.on_cron_clean_data_zero)
def stop(self):
self.stoped = True
for sub_frame in list(self.sub_proxys.values())[::-1]:
try:
sub_frame.stop(_no_result=1)
except:
log.log_except()
for part_proxy in self.part_proxys.values():
spawn(part_proxy.stop, _no_result=1)
sleep(1)
self.rpc_svr.stop()
grpc.uninit()
self.cell_mgr.stop()
def del_sub_proxy(self, sub_proxy):
""" 子进程删除 """
addr = sub_proxy.get_addr()
if addr not in self.sub_proxys:
return
self.sub_proxys.pop(addr)
app_name = sub_proxy._app_name
names = sub_proxy._app_names
if not self.stoped:
#通知更新
self.application.del_addr_names(app_name, addr, names)
for sub_frame in self.sub_proxys.values():
spawn(sub_frame.del_other_proxy, app_name, addr, names)
def gw_close(self, rpc_gw):
""" 网关断开 """
svc = rpc_gw.get_service()
close_gwid = getattr(svc, self.GWID)
log.warning('网关(%s - %s)断开', rpc_gw.get_addr(), close_gwid)
self.rpc_gws.pop(close_gwid)
for key in self.processers.values():
gwid, pid = key
if gwid != close_gwid:
continue
p = self.del_process(gwid, pid)
if p:
spawn(p.close, client=False)
def charge(self, id, rmb, test=False):
Game.glog.log2File("charge_begin",
"%s|%s|%s" % (self.owner.id, id, rmb))
res = Game.res_mgr.res_charge.get(id)
if not res:
return constant.CHARGE_INSIDE_ERR_NOT_FOUND_ID
if test:
rmb = res.rmb
if res.rmb != rmb:
return constant.CHARGE_INSIDE_ERR_RMB
modresAll = getattr(Game.res_mgr, "res_%s" % res.type, None)
if not modresAll:
return constant.CHARGE_INSIDE_ERR_MODRES
modres = modresAll.get(res.typeid)
if not modres:
return constant.CHARGE_INSIDE_ERR_MODRESID
moddef = getattr(self, "%s" % res.type, None)
if not moddef:
return constant.CHARGE_INSIDE_ERR_MODDEF
Game.glog.log2File("charge_process",
"%s|%s|%s" % (self.owner.id, id, rmb))
self.owner.vip.addExp(res.exp)
dUpdate = moddef(modres, res.rmb)
dUpdate["vipInfo"] = self.owner.vip.to_init_data()
spawn(self.owner.call,
"PushCharge", {
"id": id,
"allUpdate": dUpdate
},
noresult=True)
if not test:
Game.glog.log2File(
"playerPay",
"%s|%s|%s|%s|%s" %
(self.owner.id, self.owner.name, int(time.time()), rmb, id),
flag=1)
self.markDirty()
return constant.CHARGE_INSIDE_OK
def rc_loginSNS(self, t, sid, session, UDID, DT,
MAC='', DEV='', VER='', **kw):
""" 平台登录接口 """
resp_f = 'loginSNS'
if not self.area_legal():
return pack_msg(resp_f, 0, err=errcode.EC_LOGIN_AREA_ERR)
if not self.is_debug_time():
return pack_msg(resp_f, 0, err=errcode.EC_LOGIN_DEBUG_TIME)
log.debug(u'平台(%s)用户登录请求:%s, %s, %s, %s, %s, %s, %s, %s',
t, sid, session, UDID, DT, MAC, DEV, VER, kw)
if self.count >= self.max_players:
return pack_msg(resp_f, 0, err=errcode.EC_TEAM_ROLE_FULL)
if not sid and t not in SNS_LOGINS:#游客登录
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
#u = Game.rpc_store.query_loads(TN_USER, dict(UDID=UDID, name=''))
else:
rs, data = self.sns_client.login(t, sid, session)
if not rs:
return pack_msg(resp_f, 0, err=data)
if data:#login返回sid
sid = data
u = UserData.user_by_sns(t, sid)
if not u:
#不存在自动增加
u = self._new_user(t, sid, '', UDID, DT, MAC, DEV, VER)
else:
u = u[0]
u = User(adict=u)
#如果mac地址不同,记录
if u.data.UDID != UDID or u.data.DT != DT or \
u.data.DEV != DEV or \
u.data.MAC != MAC or u.data.VER != VER:
def _log_mac():
if 1: #强制保存更新信息, not u.data.MAC:
u.data.UDID = UDID
u.data.DT = DT
u.data.MAC = MAC
u.data.DEV = DEV
u.data.VER = VER
u.save(Game.rpc_store)
else:
self.glog(PM_MAC, u=u.data.id,
UDID=UDID, MAC=MAC, DEV=DEV, VER=VER)
spawn(_log_mac)
params = self._get_login_params(sid, u.data.id, t)
log.debug(u'loginSNS finish:%s', params)
return pack_msg(resp_f, 1, data=params)
def start_broad(self, pid=0):
""" 开战或进入下一场广播 """
resp_f = 'awarStartB'
if self.war_data:
self.enter_next_scene()
else:
self.data_init()
self.war_data.start()
self._loop_task_broad = spawn(self._loop_broad)
sleep(1)
for pid in self.war_data.war_pids:
data = self.pack_data(pid)
self.send_msg(resp_f, data, send_pids=[pid])
spawn(self._loop_war)
def set(self, key, value, timeout=None):
""" timeout:过期时间(单位秒),如果为0，不过期 """
if timeout is None or timeout < 0:
timeout = self.default_timeout
if timeout > 0:
timeout = time.time() + abs(timeout)
self._times[key] = timeout
self._caches[key] = (value, timeout)
if len(self._caches) > self.size and \
self._gc_time + self.gc_time < time.time():
log.warn(u'TimeMemCache缓存(%s-%s)不足，开始清理缓存', self.name, len(self._caches))
spawn(self.gc)
#sleep(0.01)
return value
def stop(self):
if self.stoped:
return
self._loop_task.kill(block=False)
self._loop_task = None
self._heartbeat_task.kill(block=False)
self._heartbeat_task = None
self._send_task.kill(block=False)
self._send_task = None
if self._sock is not None:
self._sock.close()
self._sock = None
on_close = getattr(self._export, 'on_close', None)
if on_close:
corelib.spawn(on_close, self)
def gm_start_activity(self, war_type, time=300):
""" gm开启活动 """
if time > 300:
time = 300
self.stop_activity()
now_sec = common.current_time() - common.zero_day_time()
for res_warstart in self.res_warstart_configs.itervalues():
if war_type == res_warstart.type:
self.warstart_config = copy.copy(res_warstart)
self.warstart_config.etime = now_sec + 60 * 60
start_time = now_sec + time
self.warstart_config.stime = start_time
log.debug('gm-start----- %s, %s', start_time, res_warstart.type)
break
l_sec = self.warstart_config.stime - now_sec
if l_sec <= self.warstart_config.ntime:
spawn(self._notice, l_sec)
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 start(self):
self._svr = new_stream_server_by_ports('0.0.0.0',
config.player_ports,
self._on_client_accept)
self.address = config.inet_ip, self._svr.address[1]
self.key = Game.rpc_player_mgr.reg_sub_mgr(self, self._game.name,
self._game.get_addr(), _proxy=True)
Game.sub_rpc_mgr_init(Game.rpc_player_mgr, self._rpc_mgr_init)
self._loop_task = spawn(self._loop)
def choose_node(self, node, type, pid=None):
""" 降龙战队长选择路线 """
if self.is_choose:
return False, errcode.EC_ALLY_WAR_OUTTIME
log.debug('choos-node %s',pid)
self.is_choose = True
self.war_node = node
self.node_type = type
self.hit_nodes.append(node)
res_map = Game.res_mgr.awar_strong_maps.get(self.war_node)
res_war_per = Game.res_mgr.awar_per_configs.get(int(float(res_map.apcid)))
if res_war_per is None:
return False, errcode.EC_NORES
#记录选择时该节点是否已被占据
if self.group.copy_mgr.get_copys(node):
self.start_is_copy = True
self.war_per_config = res_war_per
spawn(self.choose_node_broad, pid)
return True, None
def start(self, l_sec):
""" 开启同盟boss战并初始化数据 """
max_hp = self._get_max_hp()
self._init_boss(self.data.aid, l_sec, max_hp)
#广播boss战斗开始通知
self.handle_horn(HORN_TYPE_ALLYNOTICE, aid=self.data.aid)
#广播通知即将开始
self.notice(l_sec)
#开启等待数据的广播
self.loop_task = spawn(self._notice_data, l_sec)
def pass_scene(self, aid):
""" 通过本场 """
if self.war_data.war_end:
return
log.debug('pass_scene-node-type %s',self.node_type)
if self.node_type == NODE_TYPE_COPY:
self._copy_reward()
#当战胜隐分身或者开战前该点未被占领 时占领此节点
if self.node_type == NODE_TYPE_COPY or not self.start_is_copy:
self.group.win_node(aid, self.war_node)
log.debug('time1------------')
self.start_is_copy = False
#广播势力地图
self.is_choose = False
self.smap_broad()
spawn(self.auto_choose_node)
log.debug('time2------------')
self.group.copy_mgr.new_copys(aid, self.war_node)
log.debug('time3------------')
def load(self):
Game.res_mgr.sub(MSG_RES_RELOAD, self.lood)
self.lood()
init_vip_sett()
allys = self.rpc_store.load_all(TN_ALLY)
for one_ally in allys:
ally = Ally(self, adict = one_ally)
ally.load()
self._stream_in_mgrs(ally)
self._loop_sort = spawn(self.refurbish)
def start(self, l_sec):
""" 开启boss战并初始化数据 """
self.init()
max_hp = self._get_max_hp()
self._init_boss(AID_WORLD_BOSS, l_sec, max_hp)
#大喇叭广播boss战斗开始通知
self.handle_horn(HORN_TYPE_WORLDNOTICE)
#广播通知即将开始
self.notice(l_sec)
#开启等待数据的广播
self.loop_task = spawn(self._notice_data, l_sec)
def heartbeat(self):
""" 心跳 """
fmt = hb_fmt
packet_size = hb_packet_size
pkt = hb_pkt
htime = int(self.timeout / 2)
while True:
gevent.sleep(htime)
try:
with self._slock:
if self.stoped:
break
self._sock.sendall(pkt)
except GreenletExit:
break
except:
log.log_except()
break
log.info('[client_rpc]heartbeat stop:%s' % (self.addr, ))
corelib.spawn(self.stop)
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 get(self, key, default=None, add_time = None):
""" """
if self._gc_time + self.gc_max_time < time.time():
# log.debug(u'TimeMemCache(%s)缓存(%s)定时清理',
# self.name, len(self._caches))
#定时清理
spawn(self.gc)
self.total += 1
try:
cache = self._caches[key]
except KeyError:
self.miss += 1
return default
timeout = cache[1]
if add_time:
value = cache[0]
self.set(key, value, add_time)
if timeout and time.time() >= timeout:
self.delete(key)
return default
self.hit += 1
return cache[0]
def send_imme(self, msg):
""" 立即发送
msg:必须为字符串或者protobuf对象,
在外部将protobuf对象序列化后，直接发送字符串，能优化速度
"""
if isinstance(msg, str):
if msg.startswith(PRE_MSG):
data = msg[PRE_MSG_LEN:]
data, self._w_token, self.adler_value = \
self._packer.safe_pack_raw(data, self._w_token, self.adler_value)
else:
raise ValueError, 'can not send str type:%s' % repr(msg)
else:
data, self._w_token, self.adler_value = \
self._packer.safe_pack(msg, self._w_token, self.adler_value)
try:
with self._slock:
self._sock.sendall(data)
return True
except socket.error, e:
log.error('[clientRpc]error:%s' % e)
corelib.spawn(self.stop)
return False
def send_imme(self, msg):
""" 立即发送
msg:必须为字符串或者protobuf对象,
在外部将protobuf对象序列化后，直接发送字符串，能优化速度
"""
if isinstance(msg, str):
if msg.startswith(PRE_MSG):
data = msg[PRE_MSG_LEN:]
else:
raise ValueError, 'can not send str type:%s' % repr(msg)
else:
data = self._packer.pack(msg)
## length = len(data)
#log.debug('[rpc]send:%s-%s' % (self.addr, msg.DESCRIPTOR.full_name))
try:
with self._slock:
# self._sock.sendall(hb_pkt+data) #TODO: 测试
self._sock.sendall(data)
return True
except socket.error, e:
log.error('[clientRpc]error:(%s)%s' % (id(self), e))
corelib.spawn(self.stop)
return False
def load(self, app=None):
if self._loop_task is None:
self._loop_task = spawn(self._loop)
for tname, load_func in self.tables.iteritems():
try:
load_func()
except error: #网络错误
log.log_except()
return 0
except:
log.log_except()
if app and app.stoped:
return 0
self.db_ver = self._get_db_ver()
return 1
def start(self):
if config.subgame_addrs:
self.free_addrs = config.subgame_addrs[:]
else:
self.free_addrs = None
self.proc_mgr = LocalProcessMgr(config.root_path)
self.logic_mgr = LogicMgr(self)
self.union_mgr = UnionMgr(self)
if not self.is_single:
self._init_normal()
else:
self._init_single()
self.logic_mgr.start()
self._loop_task = spawn(self._loop)
