def Gac2GasOptGameConf(nPlayerGID, reqObj):
# required gm_config_opt opt_type = 1;
# optional config_data conf_data = 2;
dictData = {
"opt_type": reqObj.opt_type,
"config_name": reqObj.conf_data.config_name,
"pos_1_card": reqObj.conf_data.pos_1_card,
"pos_2_card": reqObj.conf_data.pos_2_card,
"pos_3_card": reqObj.conf_data.pos_3_card,
"pos_4_card": reqObj.conf_data.pos_4_card,
"card_order": reqObj.conf_data.card_order,
}
def _cb(err, data):
rsp = gm_config_pb2.opt_config_rsp()
rsp.opt_type = data["opt_type"]
if data["conf_name"] is None:
rsp.cur_use_conf = ""
else:
rsp.cur_use_conf = data["conf_name"].encode("utf-8")
data = data["dict_data"]
rsp.ret_data.config_name = data["config_name"].encode("utf-8")
rsp.ret_data.pos_1_card = data["pos_1_card"].encode("utf-8")
rsp.ret_data.pos_2_card = data["pos_2_card"].encode("utf-8")
rsp.ret_data.pos_3_card = data["pos_3_card"].encode("utf-8")
rsp.ret_data.pos_4_card = data["pos_4_card"].encode("utf-8")
rsp.ret_data.card_order = data["card_order"].encode("utf-8")
ffext.send_msg_session(nPlayerGID, rpc_def.Gas2GacRetModifyConfig, rsp.SerializeToString())
ffext.call_service(scene_def.GCC_SCENE, rpc_def.Gas2GccModifyGmConfig, dictData, _cb)
def OnPlayerOffline(self, nPlayerGID):
ffext.LOGINFO("FFSCENE_PYTHON",
"GccSceneMgr.OnPlayerOffline {0}".format(nPlayerGID))
gccPlayer = entity_mgr.GetEntity(nPlayerGID)
assert gccPlayer is not None
gccPlayer.SetState(enum_def.EPlayerState.eDisConnect)
ffext.call_service(gccPlayer.GetGasID(), rpc_def.Gcc2GasPlayerOffline,
{"id": nPlayerGID})
def Gac2GasQueryRoomScene(nPlayerGID, reqObj):
nRoomID = reqObj.room_id
ffext.call_service(scene_def.GCC_SCENE,
rpc_def.Gas2GccGetRoomSceneByRoomID, {
"room_id": nRoomID,
"gas_id": ff.service_name,
"player_id": nPlayerGID
})
def SendCode(szScene, szCode):
if "all_gas" == szScene:
import conf as conf
nGasNum = conf.dict_cfg["gas"]["num"]
for i in xrange(0, nGasNum):
szScene = "gas@{0}".format(i)
framework.call_service(szScene, rpc_def.All2ExeCode, {"code": szCode})
else:
framework.call_service(szScene, rpc_def.All2ExeCode, {"code": szCode})
def test_call_scene():
ffext.dump_stdout_to_log()
def cb(err_, msg_):
if err_:
print('error=%s' % (err_))
else:
print(err_, msg_)
ffext.call_service('scene@0', 200, {'hello': 'world'}, cb)
def OnRoomDismiss(self, nRoomID, listRoomPlayers):
ffext.LOGINFO("FFSCENE_PYTHON",
" GasRoomMgr.OnRoomDismiss {0}".format(nRoomID))
self.m_dictRoomID2Room.pop(nRoomID)
for nPlayerGID in listRoomPlayers:
Player = entity_mgr.GetEntity(nPlayerGID)
assert Player is not None
Player.SetRoomID(None)
Player.GetScene().OnPlayerGameEnd(nPlayerGID)
ffext.call_service(scene_def.GCC_SCENE, rpc_def.Gas2GccOnRoomDismiss, {
"room_id": nRoomID,
"gas_id": ff.service_name
})
def OnOneDbQueryDone(self, dictSerial, job):
if job.GetSceneName() is not None:
dictSerial[dbs_def.SESSION] = job.GetSession()
dictSerial[dbs_def.CB_ID] = job.GetCbID()
ffext.call_service(job.GetSceneName(), rpc_def.OnDbAsynCallReturn,
json.dumps(dictSerial))
if job.GetQueueID() is not None:
self.m_dictQueueWorkStatus[job.GetQueueID()] = False
nDstQueue = self.RandomChoose()
if nDstQueue is None:
nDstQueue = self.ChooseMaxLen()
if nDstQueue is not None:
self.GrapJobFromQueue(nDstQueue)
def GenJob(self, dictSerial, szFunName):
funObj = getattr(dbs_opt, szFunName)
assert funObj is not None
szScene = dictSerial[dbs_def.SRC_SCENE]
szSceneCbID = dictSerial[dbs_def.CB_ID]
nSessionID = dictSerial[dbs_def.SESSION]
param = dictSerial[dbs_def.PARAMS]
job = SyncJob()
job.Init(funObj, 0, nSessionID, szScene, szSceneCbID, param)
dictRet = job.exe(self.m_nConn)
if szScene is not None:
dictRet[dbs_def.SESSION] = job.GetSession()
dictRet[dbs_def.CB_ID] = job.GetCbID()
ffext.call_service(szScene, rpc_def.OnDbAsynCallReturn,
json.dumps(dictRet))
def OnEnterLoginScene(session, src, data):
loginPlayer = GetPlayer(session)
assert loginPlayer is not None
# gate master
ffext.call_service(
scene_def.GATE_MASTER, rpc_def.OnSessionConnectGate, {
"player_id": loginPlayer.GetGlobalID(),
"gate_id": loginPlayer.GetGateName()
})
ffext.change_session_scene(session, scene_def.GCC_SCENE,
json.dumps(loginPlayer.Serial2Dict()))
ffext.LOGINFO(
"FFSCENE_PYTHON",
"Auth done, request change scene 2 gcc {0}, {1}".format(
session, json.dumps(loginPlayer.Serial2Dict())))
def DispathWorkRet(self):
tick_mgr.RegisterOnceTick(self.m_nTick2CheckWorkQueue,
self.DispathWorkRet)
nQueueRandom = 0 # random.randint(0, self.m_nQueueNum - 1)
queueRet = self.m_dictChannel2QueueRet[0]
c = 0
while queueRet.empty() is False:
szScene, szSerial = self.m_dictChannel2QueueRet[nQueueRandom].get()
ffext.call_service(szScene, rpc_def.OnDbAsynCallReturn,
json.dumps(szSerial))
self.m_nProcessedJobNum += 1
c += 1
if c > 50:
break
print("dbs self.m_nProcessedJobNum ", self.m_nProcessedJobNum,
self.m_dictChannel2QueueRet[nQueueRandom].qsize())
def Gas2GccGenRoomID(self, szGasID, nPlayerGID, dictCfg):
if self.m_nRoomIDBegin > self.m_nRoomIDEnd:
self.m_nRoomIDBegin, self.m_nRoomIDEnd = room_id_mgr.GenRoomIDSector()
nRoomId = self.m_nRoomIDBegin
self.m_nRoomIDBegin += 1
gccRoomObj = gcc_room_obj.GccRoomObj()
gccRoomObj.SetGasID(szGasID)
self.m_dictRoomID2RoomObj[nRoomId] = gccRoomObj
self.m_dictGas2RoomNum[szGasID] = self.m_dictGas2RoomNum.get(szGasID, 0) + 1
import robot.gm_opt_config as gm_opt_config
dictCurCfg = gm_opt_config.GetCurrentConfig()
dictCurCfg.update(dictCfg)
dictTmp = {"room_id": nRoomId,
"player_id": nPlayerGID,
"cfg": dictCurCfg}
ffext.call_service(szGasID, rpc_def.Gcc2GasRetGenRoomID, dictTmp)
def Gas2GccGetRoomSceneByRoomID(self, szGasID, nPlayerGID, nRoomID):
if 0 == nRoomID:
listRet = self.AutoSelectRoom()
if listRet is None:
return
nRoomID, szRoomInGas = listRet
else:
roomObj = self.m_dictRoomID2RoomObj.get(nRoomID)
if roomObj is not None:
szRoomInGas = roomObj.GetGasID()
else:
szRoomInGas = None
if szRoomInGas is None:
return
ffext.call_service(szGasID, rpc_def.Gcc2GasRetGetRoomScene, {"player_id": nPlayerGID,
"gas_id": szRoomInGas,
"room_id": nRoomID})
def StartGameOnRoom(self):
ffext.LOGINFO("FFSCENE_PYTHON", "StartGameOnRoom {0}".format(self.GetRoomID()))
if self.m_bIsFirstStart is True:
bIsAvg = True if self.GetConfig()["avg"] != 0 else False
if bIsAvg is True:
nRoomMasterDel = self.GetCreateRoomNeedMoney() / self.GetConfig()["member_num"]
assert nRoomMasterDel > 0
nRoomOtherDel = nRoomMasterDel
else:
nRoomMasterDel = self.GetCreateRoomNeedMoney()
nRoomOtherDel = 0
for nMember in self.m_dictMember.iterkeys():
Player = entity_mgr.GetEntity(nMember)
if nMember == self.m_nMaster:
nDelNum = nRoomMasterDel
else:
nDelNum = nRoomOtherDel
# if Player.IsMoneyEnough(EMoneyType.eZhuanShi, nDelNum) is False:
# return
for nMember in self.m_dictMember.iterkeys():
Player = entity_mgr.GetEntity(nMember)
if nMember == self.m_nMaster:
nDelNum = nRoomMasterDel
else:
nDelNum = nRoomOtherDel
if nDelNum != 0:
pass
# if Player.AddMoney(EMoneyType.eZhuanShi, -nDelNum, "开场扣除") is False:
# return
self.m_sm.ChangeState(room_state_running.RoomStateRunning(self))
for nMember in self.m_dictMember.iterkeys():
Player = entity_mgr.GetEntity(nMember)
Player.SetRoomID(self.GetRoomID())
else:
self.m_bIsFirstStart = False
self.m_gameRuleObj.GameStart()
ffext.call_service(scene_def.GCC_SCENE, rpc_def.Gas2GccStartGameOnRoom, {"room_id": self.GetRoomID()})
def Gas2GccSynPlayerGasID(self, nPlayerGID, szGasID):
ffext.LOGINFO(
"FFSCENE_PYTHON",
"GccSceneMgr.Gas2GccSynPlayerGasID {0}, {1}".format(
nPlayerGID, szGasID))
gccPlayer = entity_mgr.GetEntity(nPlayerGID)
assert gccPlayer is not None
szPrevGasID = gccPlayer.GetGasID()
gccPlayer.SetGasID(szGasID)
if szPrevGasID is not None:
self.m_dictGasOnlineNum[szPrevGasID] -= 1
self.m_dictGasOnlineNum[szGasID] += 1
# check state
if gccPlayer.GetState() == enum_def.EPlayerState.eDisConnect:
ffext.call_service(szGasID, rpc_def.Gcc2GasRetSynPlayerState, {
"state": gccPlayer.GetState(),
"player_id": nPlayerGID
})
def real_session_offline(session_id, online_time):
import rpc.scene_def as scene_def
import rpc.rpc_def as rpc_def
ffext.LOGINFO(
"FFSCENE_PYTHON", "real_session_offline {0}, last scene {1}".format(
session_id, ff.service_name))
loginPlayer = GetPlayer(session_id)
if loginPlayer is None:
return
_loginMgr.remove(session_id)
ffext.call_service(scene_def.GCC_SCENE, rpc_def.Login2GccPlayerOffline,
{"id": session_id})
# gate master
ffext.call_service(
scene_def.GATE_MASTER, rpc_def.OnSessionDisConnGate, {
"player_id": loginPlayer.GetGlobalID(),
"gate_id": loginPlayer.GetGateName()
})
def Gac2GasQueryGameConf(nPlayerGID, reqObj):
def _cb(err, dictData):
rsp = gm_config_pb2.syn_all_gm_config_rsp()
rsp.ret = 0
if dictData["g_szCurConfigName"] is None:
rsp.cur_use_conf = ""
else:
rsp.cur_use_conf = dictData["g_szCurConfigName"].encode("utf-8")
dictData.pop("g_szCurConfigName")
for szName, dictTmp in dictData.iteritems():
confObj = rsp.config_arr.add()
confObj.config_name = szName.encode("utf-8")
confObj.pos_1_card = SerialList2String(dictTmp["pos_1_card"])
confObj.pos_2_card = SerialList2String(dictTmp["pos_2_card"])
confObj.pos_3_card = SerialList2String(dictTmp["pos_3_card"])
confObj.pos_4_card = SerialList2String(dictTmp["pos_4_card"])
confObj.card_order = SerialList2String(dictTmp["card_order"])
print("rsp.SerializeToString() ", rsp.SerializeToString())
ffext.send_msg_session(nPlayerGID, rpc_def.Gas2GacSynAllConfig, rsp.SerializeToString())
ffext.call_service(scene_def.GCC_SCENE, rpc_def.Gas2GccQueryGmConfig, {}, _cb)
def CreateRoom(self, nRoomMaster, dictRoomCfg):
Player = entity_mgr.GetEntity(nRoomMaster)
if Player.GetRoomID() is not None:
return
nNeedZhuanShiNum = self.GetCreateRoomNeedMoney()
bIsAvg = True if dictRoomCfg.get('avg', 0) == 1 else False
if bIsAvg is True:
nDelZhuanShiNum = nNeedZhuanShiNum / dictRoomCfg.get(
"member_num", 4)
else:
nDelZhuanShiNum = nNeedZhuanShiNum
# if Player.IsMoneyEnough(EMoneyType.eZhuanShi, nDelZhuanShiNum) is False:
# return
ffext.LOGINFO("FFSCENE_PYTHON",
" GasRoomMgr.CreateRoom {0}".format(nRoomMaster))
ffext.call_service(
scene_def.GCC_SCENE, rpc_def.Gas2GccGenRoomID, {
"player_id": nRoomMaster,
"gas_id": ff.service_name,
"cfg": dictRoomCfg
})
def real_session_verify(szAuthKey, online_time, ip, gate_name, cb_id):
"""
Auth.
:param szAuthKey:
:param online_time:
:param ip:
:param gate_name:
:param cb_id:
:return:
"""
if _loginMgr.size() > 3000:
ffext.on_verify_auth_callback(0, "", cb_id)
return []
print("real_session_verify ", szAuthKey, online_time, ip, gate_name, cb_id)
req_login = login_pb2.login_req()
try:
req_login.ParseFromString(szAuthKey)
except:
print("req_login.ParseFromString error! ")
return []
print("req_login.type ", req_login.type)
nType = req_login.type
if nType == login_pb2.login_type.Value("get_gate_info"):
def _retGetGateAddr(err, msg):
szGateAddr = msg["gate_info"]
rsp = login_pb2.login_rsp()
rsp.ret = 0
rsp.gate_info = szGateAddr.encode("utf-8")
ffext.on_verify_auth_callback(0, rsp.SerializeToString(), cb_id)
ffext.call_service(scene_def.GATE_MASTER, rpc_def.GetGateIp, {"0": 0},
_retGetGateAddr)
return []
elif nType == login_pb2.login_type.Value("login"):
szAuthKey = req_login.auth_info
dbs_client.DoAsynCall(
rpc_def.DbsGetUserSession,
0,
szAuthKey,
funCb=OnGetUseSessonCb,
callbackParams=[szAuthKey, online_time, ip, gate_name, cb_id])
return []
elif nType == login_pb2.login_type.Value("gm_code"):
# gm
szToken, szScene, szCode = req_login.auth_info.split("#")
if gm_tool.IsTokenValid(szToken, ip) is False:
ffext.on_verify_auth_callback(0, "", cb_id)
else:
gm_tool.SendCode(szScene, szCode)
return []
else:
ffext.on_verify_auth_callback(0, "", cb_id)
return []
def ServiceCheckTick():
tick_mgr.RegisterOnceTick(10000, ServiceCheckTick)
ffext.call_service(g_szServiceMgr, 0, "test aaa")
def Peer(self):
tick_mgr.RegisterOnceTick(self.m_nPeerGap * 1000, self.Peer)
for szService in self.m_dictAllService.iterkeys():
ffext.call_service(szService, rpc_def.Peer, {})
def A():
ffext.call_service(scene_def.GATE_MASTER, rpc_def.OnServiceConn,
{"service": ff.service_name})
def Peer(dictSerial):
ffext.call_service(scene_def.GATE_MASTER, rpc_def.RspPeer,
{"service": ff.service_name})
def NoticeAll(self):
for szService in self.m_dictAllService.iterkeys():
ffext.call_service(szService, rpc_def.OnAllServiceStartUp, {})
tick_mgr.RegisterOnceTick(5000, self.Peer)
