def OnGetUseSessonCb(dictRet, listBindData):
# print("OnGetUseSessonCb ", dictRet, listBindData)
szAuthKey, online_time, ip, gate_name, cb_id = listBindData
nFlag = dictRet[dbs_def.FLAG]
if nFlag is True:
pass
else:
ffext.LOGINFO("FFSCENE", "session not test falg flase.")
ffext.on_verify_auth_callback(0, "", cb_id)
return
session_id = dictRet[dbs_def.RESULT]
if session_id == 0:
ffext.on_verify_auth_callback(0, "err.", cb_id)
return
if _loginMgr.get(session_id) is not None:
ffext.on_verify_auth_callback(0, "player is online.", cb_id)
real_session_offline(session_id, 0)
return
player = player_in_login.PlayerInLogin(session_id, online_time, ip,
gate_name)
_loginMgr.add(session_id, player)
ffext.on_verify_auth_callback(player.GetGlobalID(), "", cb_id)
ffext.LOGINFO("FFSCENE", "session auth ok {0}".format(session_id))
def RequestGangAll(self, nPlayerGID, nTargetMember, nCardID):
nPosOwner = self.m_roomObj.GetMemberPos(nPlayerGID)
listCardOwner = self.m_dictPosCarList[nPosOwner]
if listCardOwner.count(nCardID) != 4:
return
self.RemoveCardFromList(listCardOwner, nCardID, 4)
for _ in xrange(0, 4):
self.m_dictPosCarListEx[nPosOwner].append(nCardID)
nCard = self.GetNextCard()
self.m_dictPosCarList[nPosOwner].append(nCard)
while True:
bHaveHuaPai, nCard = self.CheckBuHua(nPosOwner, nCard)
if bHaveHuaPai is False:
break
self.RecordTouchEvent(nPosOwner,
[EMjEvent.ev_gang_all, nTargetMember, nCardID])
self.ChangeOrder(nPosOwner, nPosOwner)
self.StopEventTick()
self.SynOtherTouchEvent(EMjEvent.ev_gang_all, 0, nPlayerGID,
str(nCardID))
self.SerialEventList2Client()
self.SynCardInfoByType2All(
self.m_roomObj.GetMemberPos(nPlayerGID),
common_info_pb2.card_list_type.Value("eTypeShow"))
ffext.LOGINFO(
"FFSCENE_PYTHON", "GasMj.RequestGangAll {0}".format(
json.dumps([nPlayerGID, nTargetMember, nCardID, nPosOwner])))
ffext.LOGINFO(
"FFSCENE_PYTHON",
"GasMj.RequestGangRetAll {0}".format(self.DumpPos(nPosOwner)))
def TouchEventMoPai(self, mjMgr, listData):
nPos, nCard = listData
roomObj = mjMgr.GetRoomObj()
nOptMember = roomObj.GetMemberIDByPos(nPos)
nCardType = check_hu_mgr.GetCardType(nCard)
if nCardType == ECardType.eHuaPai:
return
# 摸到这张牌是不是能胡牌
listCard = mjMgr.GetPosCardList(nPos)
assert ((len(listCard) - 2) % 3 == 0)
listJinPai = mjMgr.GetJinPaiList()
import time
nTimeCheckPre = time.clock()
bCanHu = check_hu_mgr.testHu(0, listCard, listJinPai)
nTimeENd = time.clock()
framework.LOGINFO(
"FFSCENE_PYTHON",
"GasMj.CheckHU {0} ".format(nTimeENd - nTimeCheckPre))
if bCanHu is True:
evObj = MjEventObj(EMjEvent.ev_hu_normal, nOptMember, str(nCard))
mjMgr.AddEventNotic2Poll(nPos, evObj)
mjMgr.SetCurEventOptMember(nOptMember)
# 单游
if check_hu_mgr.CheckDanYou(listCard, listJinPai) is True:
evObj = MjEventObj(EMjEvent.ev_dan_you, nOptMember, str(nCard))
mjMgr.AddEventNotic2Poll(nPos, evObj)
if mjMgr.IsTuoGuan(nOptMember) is True:
tick_mgr.RegisterOnceTick(1000, mjMgr.RequestHu, [nOptMember])
framework.LOGINFO(
"FFSCENE_PYTHON", "GasMj.CanHu {0}, {1} ".format(
json.dumps(listJinPai), json.dumps(mjMgr.DumpPos(nPos))))
if listCard.count(nCard) == 4:
evObj = MjEventObj(EMjEvent.ev_gang_all, nOptMember, str(nCard))
mjMgr.AddEventNotic2Poll(nPos, evObj)
mjMgr.SetCurEventOptMember(nOptMember)
if mjMgr.IsTuoGuan(nOptMember):
tick_mgr.RegisterOnceTick(1000, mjMgr.RequestGang,
[nOptMember, nOptMember, nCard])
framework.LOGINFO(
"FFSCENE_PYTHON",
"GasMj.GangAll {0}, {1} ".format(json.dumps(listCard), nCard))
return True
def MoPai(self, nPos, bCheckEventAndBuHua):
assert self.m_nNextCardIndex < self.m_nMaxCardNum
if self.m_nNextCardIndex >= self.m_nMaxCardNum - 12:
self.OneJuEnd()
return
nCard = self.GetNextCard()
self.m_dictPosCarList[nPos].append(nCard)
self.StartQiPaiTick(nPos)
self.SynOtherTouchEvent(EMjEvent.ev_mo_pai,
self.m_roomObj.GetMemberIDByPos(nPos), 0,
str(nCard))
self.SynOrder()
ffext.LOGINFO(
"FFSCENE_PYTHON", "GasMj.MoPai {0}, {1}, {2} {3}".format(
nPos, self.m_roomObj.GetMemberIDByPos(nPos),
check_hu.GetCardNameChinese(nCard),
len(self.m_dictPosCarList[nPos])))
if bCheckEventAndBuHua is True:
gas_mj_event_mgr.TouchEvent(self, EMjEvent.ev_mo_pai,
[nPos, nCard])
while True:
bHaveHuaPai, nCard = self.CheckBuHua(nPos, nCard)
if bHaveHuaPai is False:
break
self.SynOrder()
self.SerialEventList2Client()
def MemberEnter(self, nMember):
roomObj = self.GetOwner()
if len(roomObj.m_dictMember) >= roomObj.m_nMaxMember:
return False
if nMember in roomObj.m_dictMember:
dictState = roomObj.m_dictMember[nMember]
dictState[RoomMemberProperty.eStatus] = EStatusInRoom.eUnReady
else:
roomObj.m_dictMember[nMember] = {
RoomMemberProperty.ePos: roomObj.GenPos(),
RoomMemberProperty.eStatus: EStatusInRoom.eUnReady
}
Player = entity_mgr.GetEntity(nMember)
Player.SetRoomID(roomObj.GetRoomID())
roomObj.SynGameInfo(nMember, bSynAll=True)
roomObj.SynMemberState2All(nMember, EStatusInRoom.eUnReady)
import json
ffext.LOGINFO(
"FFSCENE_PYTHON", "RoomStateWaiting.MemberEnter {0} -> {1}".format(
nMember, json.dumps(roomObj.m_dictMember)))
return True
def ExeCode(szCode, nPlayerGID=None):
Player = None
if nPlayerGID is not None:
import entity.entity_mgr as entity_mgr
Player = entity_mgr.GetEntity(nPlayerGID)
exec(szCode)
framework.LOGINFO("FFSCENE_PYTHON", "GmTool.ExeCode {0}".format(szCode))
def MemberExit(self, nMember):
roomObj = self.GetOwner()
Player = entity_mgr.GetEntity(nMember)
Player.SetRoomID(None)
assert nMember in roomObj.m_dictMember
roomObj.SynMemberState2All(nMember, EStatusInRoom.eExitRoom)
if 1 == len(roomObj.m_dictMember):
roomObj.Dismiss()
else:
roomObj.m_dictMember.pop(nMember)
# all is robot ?
bAllIsRobot = True
for nOneMember in roomObj.m_dictMember.iterkeys():
if util.IsRobot(nOneMember) is False:
bAllIsRobot = False
break
print("member exit all is robot ", bAllIsRobot)
if bAllIsRobot is True and len(roomObj.m_dictMember) != 0:
roomObj.Dismiss()
import json
ffext.LOGINFO(
"FFSCENE_PYTHON", "RoomStateWaiting.MemberExit {0} -> {1}".format(
nMember, json.dumps(roomObj.m_dictMember)))
def OnSessionOnline(self, szGate, session):
ffext.LOGINFO(
"FFSCENE_PYTHON",
" GateMgr.OnSessionOnline {0}, {1}".format(szGate, session))
if szGate not in self.m_dictGate2SessionNum:
self.m_dictGate2SessionNum[szGate] = 0
self.m_dictGate2SessionNum[szGate] += 1
def OnPlayerTrueOffline(self, nPlayerGID):
ffext.LOGINFO("FFSCENE_PYTHON",
"GccSceneMgr.OnPlayerTrueOffline {0}".format(nPlayerGID))
gccPlayer = entity_mgr.GetEntity(nPlayerGID)
self.m_dictGasOnlineNum[gccPlayer.GetGasID()] -= 1
assert gccPlayer is not None
gccPlayer.Destroy()
entity_mgr.DelEntity(nPlayerGID)
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 RemoveResidualPlayer(self, nPlayerGID):
assert nPlayerGID in self.m_dictRsidualPlayer
tick_mgr.UnRegisterOnceTick(self.m_dictRsidualPlayer[nPlayerGID])
self.m_dictRsidualPlayer.pop(nPlayerGID)
Player = entity_mgr.GetEntity(nPlayerGID)
Player.SetResidual(False)
ffext.LOGINFO("FFSCENE_PYTHON",
"RemoveResidualPlayer {0}".format(nPlayerGID))
def MemberOffline(self, nMember):
ffext.LOGINFO("FFSCENE_PYTHON",
"RoomStateRunning.MemberOffline {0}".format(nMember))
roomObj = self.GetOwner()
assert nMember in roomObj.m_dictMember
dictState = roomObj.m_dictMember[nMember]
dictState[RoomMemberProperty.eStatus] = EStatusInRoom.eOffline
roomObj.SynMemberState2All(nMember, EStatusInRoom.eOffline)
roomObj.GetGameRule().OnMemberExit(nMember)
def TouchEventBaXianGuoHai(self, mjMgr, listData):
nPos = listData[0]
roomObj = mjMgr.GetRoomObj()
nOptMember = roomObj.GetMemberIDByPos(nPos)
evObj = MjEventObj(EMjEvent.ev_hu_ba_xian_guo_hai, nOptMember, "")
mjMgr.AddEventNotic2Poll(nPos, evObj)
framework.LOGINFO(
"FFSCENE_PYTHON",
"GasMj.BaXianGuoHai {0} {1}".format(nPos, mjMgr.DumpPos(nPos)))
def AddResidualPlayer(self, nPlayerGID):
assert nPlayerGID not in self.m_dictRsidualPlayer
nTickID = tick_mgr.RegisterOnceTick(RESIDUAL_TIME,
self.OnResdualTimeOut, nPlayerGID)
self.m_dictRsidualPlayer[nPlayerGID] = nTickID
Player = entity_mgr.GetEntity(nPlayerGID)
Player.SetResidual(True)
ffext.LOGINFO("FFSCENE_PYTHON",
"AddResidualPlayer {0}".format(nPlayerGID))
def RequestPeng(self, listData):
nPlayerGID, nTargetMember, nCardID = listData
print("RequestPeng ", listData)
nPosTarget = self.m_roomObj.GetMemberPos(nTargetMember)
tupleTmp = self.GetLastHistCardData(nPosTarget)
nTurnIndex, nHistCardID = tupleTmp
if nTurnIndex != self.m_nNextCardIndex - 1:
return
if nCardID != nHistCardID:
return
nPosOwner = self.m_roomObj.GetMemberPos(nPlayerGID)
listCardOwner = self.m_dictPosCarList[nPosOwner]
if check_hu.testPeng(nCardID, listCardOwner,
self.m_listJinPai) is False:
return
self.RemoveLastHistCardData(nPosTarget)
self.RemoveCardFromList(listCardOwner, nCardID, 2)
for _ in xrange(0, 3):
self.m_dictPosCarListEx[nPosOwner].append(nCardID)
self.StopEventTick()
self.ChangeOrder(nPosTarget, nPosOwner)
self.RecordTouchEvent(nPosOwner,
[EMjEvent.ev_peng, nTargetMember, nCardID])
self.SynOtherTouchEvent(EMjEvent.ev_be_peng, nTargetMember, nPlayerGID,
str(nCardID))
self.SerialEventList2Client()
self.SynCardInfoByType2All(
nPosTarget, common_info_pb2.card_list_type.Value("eTypeHist"))
self.SynCardInfoByType2All(
self.m_roomObj.GetMemberPos(nPlayerGID),
common_info_pb2.card_list_type.Value("eTypeShow"))
ffext.LOGINFO(
"FFSCENE_PYTHON", "GasMj.RequestPeng {0}".format(
json.dumps([nPlayerGID, nTargetMember, nCardID, nPosOwner])))
ffext.LOGINFO(
"FFSCENE_PYTHON",
"GasMj.RequestPengRet {0}".format(self.DumpPos(nPosOwner)))
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 RequestHu(self, nPlayerGID):
nPlayerGID = nPlayerGID[0]
nPos = self.m_roomObj.GetMemberPos(nPlayerGID)
listCard = self.m_dictPosCarList[nPos]
if check_hu.testHu(0, listCard, self.m_listJinPai) is False:
return
self.SynOtherTouchEvent(EMjEvent.ev_be_hu_normal, 0, nPlayerGID, "")
ffext.LOGINFO(
"FFSCENE_PYTHON",
"GasMj.Hu@@@@@ {0}, {1}, {2}".format(nPlayerGID,
self.DumpPos(nPos),
self.m_listJinPai))
self.OneJuEnd(nPos)
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 MemberEnter(self, nMember):
ffext.LOGINFO("FFSCENE_PYTHON",
"RoomStateRunning.MemberEnter {0}".format(nMember))
roomObj = self.GetOwner()
if nMember not in roomObj.m_dictMember:
return False
Player = entity_mgr.GetEntity(nMember)
Player.SetRoomID(roomObj.GetRoomID())
dictState = roomObj.m_dictMember[nMember]
dictState[RoomMemberProperty.eStatus] = EStatusInRoom.ePlaying
roomObj.GetGameRule().OnMemberEnter(nMember)
roomObj.SynGameInfo(nMember, bSynAll=True)
roomObj.SynMemberState2All(nMember, EStatusInRoom.ePlaying)
return True
def MemberReady(self, nMember):
roomObj = self.GetOwner()
if nMember not in roomObj.m_dictMember:
return
dictState = roomObj.m_dictMember[nMember]
if EStatusInRoom.eReady == dictState[RoomMemberProperty.eStatus]:
return
dictState[RoomMemberProperty.eStatus] = EStatusInRoom.eReady
roomObj.SynMemberState2All(nMember, EStatusInRoom.eReady)
import json
ffext.LOGINFO(
"FFSCENE_PYTHON", "RoomStateWaiting.MemberReady {0} -> {1}".format(
nMember, json.dumps(roomObj.m_dictMember)))
if roomObj.CanStartGame() is True:
roomObj.StartGameOnRoom()
def XiPai(self):
self.m_listGlobalCard = check_hu.GenCardArr()
nLen = self.m_nMaxCardNum - 1
while nLen > 0:
if random.randint(1, 10) <= 8:
nLen -= 1
continue
nPos = random.randint(0, nLen)
nTmpVal = self.m_listGlobalCard[nLen]
self.m_listGlobalCard[nLen] = self.m_listGlobalCard[nPos]
self.m_listGlobalCard[nPos] = nTmpVal
nLen -= 1
ffext.LOGINFO(
"FFSCENE_PYTHON",
"GasMj.XiPai {0}".format(json.dumps(self.m_listGlobalCard)))
def Login2GccSessionConn(self, nPlayerGID, szSerial):
ffext.LOGINFO(
"FFSCENE_PYTHON",
"GccSceneMgr.Login2GccSessionConn {0}, {1}".format(
nPlayerGID, szSerial))
gccPlayer = entity_mgr.GetEntity(nPlayerGID)
if gccPlayer is not None:
gccPlayer.SetState(enum_def.EPlayerState.eOnline)
ffext.change_session_scene(nPlayerGID, gccPlayer.GetGasID(), "")
else:
dictSerial = json.loads(szSerial)
gccPlayer = gcc_player_entity.GccPlayerEntity()
gccPlayer.SetIp(dictSerial[PlayerPro.IP])
gccPlayer.SetGateName(dictSerial[PlayerPro.GATE_NAME])
gccPlayer.SetState(enum_def.EPlayerState.eOnline)
entity_mgr.AddEntity(nPlayerGID, gccPlayer)
ffext.change_session_scene(nPlayerGID, self.ChooseOneGas(),
szSerial)
def DingZhuang(self):
"""
定庄
:return:
"""
listRoomMember = self.m_roomObj.GetMemberList()
nRoomMemberNum = len(listRoomMember)
assert nRoomMemberNum in (2, 4)
if self.GetConfig().get("zhuang_pos") is not None:
nRanPos = self.GetConfig().get("zhuang_pos")
else:
nRanPos = random.randint(0, nRoomMemberNum - 1)
nZhuang = listRoomMember[nRanPos]
self.m_nZhuang = nZhuang
ffext.LOGINFO(
"FFSCENE_PYTHON", "GasMj.DingZhuang {0}, pos {1}".format(
nZhuang, self.m_roomObj.GetMemberPos(nZhuang)))
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 __init__(self):
import conf as conf
nRobotNum = conf.dict_cfg["gas"]["robot_num"]
self.m_nRobotStartID = (int(ff.service_name[-1:]) + 1) * 100
self.m_dictRobotGID = {}
import gas.gas_scene.gas_scene_mgr as gas_scene_mgr
for i in xrange(1, nRobotNum + 1):
import json
dict = {"ip": "127.0.0.1", "gate": "gate@0"}
gas_scene_mgr._gasSceneMgr.Gcc2GasSessionConn(
self.m_nRobotStartID, json.dumps(dict))
self.m_dictRobotGID[self.m_nRobotStartID] = False
self.m_nRobotStartID += 1
ffext.LOGINFO("FFSCENE_PYTHON",
"RobotMgr.CreateRobot {0} done.".format(nRobotNum))
for nGID in self.m_dictRobotGID.keys():
tick_mgr.RegisterOnceTick(5 * 1000, self.CheckEnterRoom, nGID)
def KaiJin(self):
nNum = self.GetJinPaiNum()
self.m_listJinPai = []
for _ in xrange(0, nNum):
nCard = None
while True:
nCard = self.GetNextCard()
if check_hu.GetCardType(
nCard
) != ECardType.eHuaPai and nCard not in self.m_listJinPai:
break
assert nCard is not None
self.m_listJinPai.append(nCard)
gas_mj_event_mgr.TouchEvent(self, EMjEvent.ev_kai_jin,
self.m_listJinPai[:])
ffext.LOGINFO("FFSCENE_PYTHON",
"GasMj.KaiJin {0}".format(json.dumps(self.m_listJinPai)))
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 OnGetRoomIDRet(self, nRoomID, nPlayerGID, dictCfg):
print("start room with config ", dictCfg)
ffext.LOGINFO(
"FFSCENE_PYTHON",
" GasRoomMgr.OnGetRoomIDRet {0}, {1}".format(nRoomID, nPlayerGID))
roomObj = gas_room_obj.RoomObj(nRoomID, nPlayerGID, self, dictCfg)
self.m_dictRoomID2Room[nRoomID] = roomObj
rsp = create_room_pb2.create_room_rsp()
rsp.ret = 0
rsp.game_type = 1
rsp.room_id = nRoomID
rsp.pos = roomObj.GetMemberPos(nPlayerGID)
rsp.cfg.member_num = dictCfg["member_num"]
rsp.cfg.multi = dictCfg["multi"]
rsp.cfg.total_start_game_num = dictCfg["total_start_game_num"]
rsp.cfg.avg = dictCfg["avg"]
rsp.cfg.opt = dictCfg["opt"]
ffext.send_msg_session(nPlayerGID, rpc_def.Gas2GacRetCreateRoom,
rsp.SerializeToString())
def OnCreateUserSessionCb(dictRet, listBindData):
online_time, ip, gate_name, cb_id = listBindData
nFlag = dictRet[dbs_def.FLAG]
if nFlag is True:
pass
else:
ffext.on_verify_auth_callback(0, "", cb_id)
return
if dictRet[dbs_def.SESSION] == 0:
# no session
ffext.on_verify_auth_callback(0, "", cb_id)
return
# {u'cb': 1, u'c': [u'SESSION_ID'], u'r': [[u'65601537']], u's': 0, u'f': True}
session_id = int(dictRet[dbs_def.SESSION])
player = player_in_login.PlayerInLogin(session_id, online_time, ip,
gate_name)
_loginMgr.add(session_id, player)
ffext.on_verify_auth_callback(player.GetGlobalID(), "", cb_id)
ffext.LOGINFO("FFSCENE", "session auth ok {0}".format(session_id))
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()
})
