def onCmdQuickStart(cls, msg, userId, gameId, roomId, tableId, playMode,
clientId):
'''
拦截父类处理的选择房间逻辑，先于父类处理，若选择成功，则不进行父类的选择房间处理逻辑，否则正常走父类的处理逻辑
'''
if not pokerconf.isOpenMoreTable(clientId):
loc = onlinedata.checkUserLoc(userId, clientId, gameId)
ftlog.debug(
'DizhuQuickStartV4_0.onCmdQuickStart:old client, checkUserLoc->',
loc,
caller=cls)
if isinstance(loc, basestring):
lgameId, lroomId, ltableId, lseatId = loc.split('.')
lgameId, lroomId, ltableId, lseatId = strutil.parseInts(
lgameId, lroomId, ltableId, lseatId)
if lgameId == gameId and lroomId > 0:
roomId = lroomId
tableId = ltableId
ftlog.debug(
'DizhuQuickStartV4_0.onCmdQuickStartold client, reset roomId, tableId->',
roomId,
tableId,
caller=cls)
_, version, _ = strutil.parseClientId(clientId)
ftlog.debug("DizhuQuickStartV4_0.onCmdQuickStart: clientId=", clientId,
"userId=", userId, "roomId=", roomId,
"tableId=", tableId, "version=", version, "type:",
type(version), "playMode=", playMode)
# 地主会优先去匹配比赛的房间，客户端是3.76及更高版本才支持
if (playMode == None or playMode == "match" or playMode
== "straightMatch") and roomId == 0 and gameId == 6 and (
version >= 3.76 or
(version >= 3.73
and not (clientId in _DIZHU_QMATCH_V3_73_IGNORE))):
chose_roomid, ok = cls._chooseDizhuMatchRoom(
userId, gameId, playMode)
ftlog.debug(
"DizhuQuickStartV4_0._chooseDizhuMatchRoom:chosen|room_id=",
chose_roomid, "userId=", userId, "ok=", ok)
if ok:
bigroomid = gdata.getBigRoomId(chose_roomid)
ftlog.debug(
"DizhuQuickStartV4_0._chooseDizhuMatchRoom: userId=",
userId, "roomId=", chose_roomid)
cls.notifyQuickGotoDizhuMatch(gameId, userId, bigroomid)
return
if playMode == "match":
playMode = dizhuconf.PLAYMODE_123
super(DizhuQuickStartV4_0,
cls).onCmdQuickStart(msg, userId, gameId, roomId, tableId,
playMode, clientId)
return
def onCmdQuickStart1(cls, msg, userId, gameId, roomId, tableId, playMode,
clientId):
'''
拦截父类处理的选择房间逻辑，先于父类处理，若选择成功，则不进行父类的选择房间处理逻辑，否则正常走父类的处理逻辑
'''
if not pokerconf.isOpenMoreTable(clientId):
ok, loc = cls.checkUserLoc(userId, gameId, roomId, tableId,
clientId)
if not ok:
# 弹框
tipsPlaying = dizhuconf.getPublicConf('tips.playing',
'您正在其它房间对局，是否回去？')
showInfo = TodoTaskShowInfo(tipsPlaying)
showInfo.setSubCmd(
TodoTaskQuickStart(loc[0], loc[1], loc[2], loc[3]))
TodoTaskHelper.sendTodoTask(gameId, userId, showInfo)
ftlog.debug('DizhuQuickStartV4_0.onCmdQuickStart Fail userId=',
userId, 'roomId=', roomId, 'tableId=', tableId,
'clientId=', clientId, 'loc=', loc)
return
if loc:
tableId = loc[2]
_, version, _ = strutil.parseClientId(clientId)
ftlog.debug("DizhuQuickStartV4_0.onCmdQuickStart: clientId=", clientId,
"userId=", userId, "roomId=", roomId,
"tableId=", tableId, "version=", version, "type:",
type(version), "playMode=", playMode)
# 地主会优先去匹配比赛的房间，客户端是3.76及更高版本才支持
if (playMode == None or playMode == "match" or playMode
== "straightMatch") and roomId == 0 and gameId == 6 and (
version >= 3.76 or
(version >= 3.73
and not (clientId in _DIZHU_QMATCH_V3_73_IGNORE))):
chose_roomid, ok = cls._chooseDizhuMatchRoom(
userId, gameId, playMode)
ftlog.debug(
"DizhuQuickStartV4_0._chooseDizhuMatchRoom:chosen|room_id=",
chose_roomid, "userId=", userId, "ok=", ok)
if ok:
bigroomid = gdata.getBigRoomId(chose_roomid)
ftlog.debug(
"DizhuQuickStartV4_0._chooseDizhuMatchRoom: userId=",
userId, "roomId=", chose_roomid)
cls.notifyQuickGotoDizhuMatch(gameId, userId, bigroomid)
return
if playMode == "match":
playMode = dizhuconf.PLAYMODE_123
super(DizhuQuickStartV4_0,
cls).onCmdQuickStart(msg, userId, gameId, roomId, tableId,
playMode, clientId)
return
def sendRoomLeave(self, seat, reason, returnFee=False):
if not seat.player:
return
if not pokerconf.isOpenMoreTable(seat.player.clientId) :
mo = self.buildTableMsgRes('room_leave')
else:
mo = self.buildTableMsgRes('room', 'leave')
mo.setResult('reason', reason)
mo.setResult('returnFee', 1 if returnFee else 0)
mo.setResult('userId', seat.userId)
self.sendToSeat(mo, seat)
def onCmdQuickStart(cls, msg, userId, gameId, roomId, tableId, playMode, clientId):
# 单开, 无论何时quick_start进入都检查loc
if not pokerconf.isOpenMoreTable(clientId):
loc = onlinedata.checkUserLoc(userId, clientId, gameId)
if ftlog.is_debug():
ftlog.debug('DizhuQuickStart old client, checkUserLoc->', loc, caller=cls)
if isinstance(loc, basestring):
lgameId, lroomId, ltableId, lseatId = loc.split('.')
lgameId, lroomId, ltableId, lseatId = strutil.parseInts(lgameId, lroomId, ltableId, lseatId)
if lgameId == gameId and lroomId > 0:
if ftlog.is_debug():
ftlog.debug('DizhuQuickStart _quickStart re-connected |userId, loc:', userId, loc,
'|roomId, tableId:', roomId, tableId, caller=cls)
roomId = lroomId
tableId = ltableId
msg.setParam('isReConnected', True)
if ftlog.is_debug():
ftlog.debug('DizhuQuickStart old client, reset roomId, tableId->', roomId, tableId, caller=cls)
if not tableId and game.isShutDown():
cls._sendTodoTaskToUser(userId, ENTER_ROOM_REASON_GAME_SHUTDOWN_GO)
return
# 带有roomId
if roomId:
cls._quickStart(msg, userId, gameId, roomId, tableId, playMode, clientId)
return
# 不带 roomId 服务器来选择房间
ctrlRoomIds, mixRoomReversed = cls._getQuickStartRoomList(userId, playMode, rankId=msg.getParam('rankId', '-1')) # 快开列表
chose_roomid, ok, mixId = cls._chooseRoom(userId, ctrlRoomIds, rankId=msg.getParam('rankId', '-1'), mixRoomReversed=mixRoomReversed) # 选择一个
if ok == ENTER_ROOM_REASON_OK:
bigroomid = gdata.getBigRoomId(chose_roomid)
ismatch = gdata.roomIdDefineMap()[chose_roomid].configure.get('ismatch', 0)
if ftlog.is_debug():
ftlog.debug("DizhuQuickStart._chooseRoom: userId=", userId, "roomId=", chose_roomid, 'mixId=', mixId)
if ismatch:
cls.notifyQuickGotoDizhuMatch(gameId, userId, bigroomid, mixId=mixId)
else:
msg.setParam('mixId', mixId)
ctrRoomIds = gdata.bigRoomidsMap()[bigroomid]
ctrlRoomId = ctrRoomIds[userId % len(ctrRoomIds)]
TYRoomMixin.queryRoomQuickStartReq(msg, ctrlRoomId, 0) # 请求发给 GR
elif ok == ENTER_ROOM_REASON_QUIT_ROOM_ERROR:
cls._sendTodoTaskToUser(userId, ok)
elif (ok == ENTER_ROOM_REASON_LESS_MIN or ok == ENTER_ROOM_REASON_LESS_MIN_QUICKSTART) and msg.getParam('rankId', '-1') in ['0', '1']:
cls._sendTodoTaskBuyChip(userId, chose_roomid, clientId, mixId)
elif ok == ENTER_ROOM_REASON_LESS_MIN_QUICKSTART:
cls._sendTodoTaskBuyChip(userId, chose_roomid, clientId, mixId)
else:
cls._sendTodoTaskJumpHighRoom(userId, playMode, clientId, rankId='-1')
return
def _checkUserLoc(cls, userId, clientId, gameId):
''' 检查用户位置信息，返回所在房间roomId以及tableId '''
if not pokerconf.isOpenMoreTable(clientId):
loc = onlinedata.checkUserLoc(userId, clientId, gameId)
if isinstance(loc, basestring):
locGameId, locRoomId, locTableId, locSeatId = loc.split('.')
locGameId, locRoomId, locTableId, locSeatId = strutil.parseInts(locGameId, locRoomId, locTableId, locSeatId)
if locGameId == gameId and locRoomId > 0:
if ftlog.is_debug():
ftlog.debug('DizhuQuickStartWx.checkUserLoc'
'userId=', userId,
'clientId=', clientId,
'locRoomId=', locRoomId,
'locTableId=', locTableId,
'locSeatId=', locSeatId)
return locRoomId, locTableId, locSeatId
return 0, 0, 0
def _doStandupAndRoomLeave(self,
player,
clientId,
reason=TableStandUpEvent.REASON_GAME_OVER):
userId = player.userId
self.gamePlay.doStandUp(player.userId, player.seatId, reason, clientId)
msgRes = MsgPack()
if not pokerconf.isOpenMoreTable(clientId):
msgRes.setCmd("room_leave")
else:
msgRes.setCmd("room")
msgRes.setResult("action", "leave")
msgRes.setResult("reason", TableStandUpEvent.REASON_GAME_OVER)
msgRes.setResult("gameId", self.gameId)
msgRes.setResult(
"roomId",
self.roomId) # 处理结果返回给客户端时，部分游戏（例如德州、三顺）需要判断返回的roomId是否与本地一致
msgRes.setResult("userId", userId)
router.sendToUser(msgRes, userId)
def doLeave(self, userId, msg):
ftlog.hinfo("doLeave |userId, msg:", userId, msg, caller=self)
reason = msg.getParam("reason", TYRoom.LEAVE_ROOM_REASON_ACTIVE)
assert isinstance(reason, int)
needSendRes = msg.getParam("needSendRes", True)
assert isinstance(needSendRes, bool)
clientRoomId = msg.getParam("clientRoomId", self.roomId)
assert isinstance(clientRoomId, int)
if not self._leave(userId, reason, needSendRes):
reason = TYRoom.LEAVE_ROOM_REASON_FORBIT
TYPluginCenter.event(
TYPluginUtils.updateMsg(cmd='EV_LEAVE_ROOM',
params=TYPluginUtils.mkdict(
userId=userId,
roomId=self.roomId,
reason=reason)), self.gameId)
msgRes = MsgPack()
if not pokerconf.isOpenMoreTable(sessiondata.getClientId(userId)):
msgRes.setCmd("room_leave")
else:
msgRes.setCmd("room")
msgRes.setResult("action", "leave")
msgRes.setResult("reason", reason)
msgRes.setResult("gameId", self.gameId)
msgRes.setResult(
"roomId",
clientRoomId) # 处理结果返回给客户端时，部分游戏（例如德州、三顺）需要判断返回的roomId是否与本地一致
msgRes.setResult("userId", userId)
if needSendRes or TYPlayer.isRobot(userId): # 需要通知机器人stop
router.sendToUser(msgRes, userId)
def createTableQuickStart(cls, msg, itemParams, userId, roomId, tableId,
playMode, clientId):
'''UT server中处理来自客户端的create_table请求
Args:
msg
cmd : create_table
if roomId == 0:
表示玩家创建房间，服务器为玩家选择房间，然后将请求转给GR
if roomId > 0 and tableId == 0 :
表示玩家选择了房间，将请求转给GR
if roomId > 0 and tableId == roomId * 10000 :
表示玩家在队列里断线重连，将请求转给GR
if roomId > 0 and tableId > 0:
if onlineSeatId > 0:
表示玩家在牌桌里断线重连，将请求转给GT
else:
表示玩家选择了桌子，将请求转给GR
'''
assert isinstance(userId, int) and userId > 0
assert isinstance(roomId, int) and roomId >= 0
assert isinstance(tableId, int) and tableId >= 0
ftlog.debug("<< |clientId:",
clientId,
"|userId, roomId, tableId:",
userId,
roomId,
tableId,
"|gameId, playMode:",
playMode,
caller=cls)
isReconnect = False
gameId = msg.getResult('gameId')
# 单开, 无论何时quick_start进入都检查loc
if not pokerconf.isOpenMoreTable(clientId):
loc = onlinedata.checkUserLoc(userId, gameId)
ftlog.debug('old client, checkUserLoc->', loc, caller=cls)
if isinstance(loc, basestring):
lgameId, lroomId, ltableId, lseatId = loc.split('.')
lgameId, lroomId, ltableId, lseatId = strutil.parseInts(
lgameId, lroomId, ltableId, lseatId)
if lgameId == gameId and lroomId > 0:
roomId = lroomId
tableId = ltableId
isReconnect = True
ftlog.debug('old client, reset roomId, tableId->',
roomId,
tableId,
caller=cls)
if (not isReconnect) and roomId > 0 and tableId > 0:
reason = cls._canQuickEnterCreateRoom(userId, gameId, roomId)
if reason != TYRoom.ENTER_ROOM_REASON_OK:
cls._onEnterCreateRoomFailed(reason, userId, gameId, clientId,
roomId)
return
tempShadowRoomId = 0
if roomId == 0: # 第一个玩家创建房间牌桌
chosenRoomId, checkResult = cls._chooseCreateRoom(
userId, gameId, playMode)
ftlog.info("after choose room",
"|userId, chosenRoomId, checkResult:",
userId,
chosenRoomId,
checkResult,
caller=cls)
if checkResult == TYRoom.ENTER_ROOM_REASON_OK:
#得到房间ID,找合适的tableId
roomDef = gdata.roomIdDefineMap()[chosenRoomId]
shadowRoomIds = roomDef.shadowRoomIds
if shadowRoomIds:
for shadowRoomId in shadowRoomIds:
tableId = table_rpc.getTableByRoomId(shadowRoomId)
if isinstance(tableId, int) and tableId > 0:
tempShadowRoomId = shadowRoomId
break
shadowRoomId = tableId / 10000
if shadowRoomId == tempShadowRoomId: # 验证
ctrRoomId = gdata.roomIdDefineMap()[shadowRoomId].parentId
TYRoomMixin.queryRoomQuickStartReq(
msg, ctrRoomId, tableId,
shadowRoomId=shadowRoomId) # 请求转给GR
return
else:
cls._onEnterCreateRoomFailed(checkResult, userId, gameId,
clientId, roomId)
return
else:
cls._onEnterCreateRoomFailed(checkResult, userId, gameId,
clientId, roomId)
return
else:
onlineSeat = onlinedata.getOnlineLocSeatId(userId, gameId, roomId,
tableId)
if onlineSeat:
extParam = {}
extParam['seatId'] = onlineSeat
moParams = msg.getKey('params')
for k, v in moParams.items():
if not k in extParam:
extParam[k] = v
ftlog.debug('extParam=', extParam)
TYRoomMixin.querySitReq(userId, roomId, tableId, clientId,
extParam) # 玩家断线重连，请求转给GT
return
if tableId == roomId * 10000: # 玩家在队列里断线重连
TYRoomMixin.queryRoomQuickStartReq(msg, roomId, tableId) # 请求转给GR
return
# 玩家选择了桌子,进桌
shadowRoomId = tableId / 10000
ctrRoomId = gdata.roomIdDefineMap()[shadowRoomId].parentId
TYRoomMixin.queryRoomQuickStartReq(msg,
ctrRoomId,
tableId,
shadowRoomId=shadowRoomId) # 请求转给GR
def onCmdQuickStart(cls, msg, userId, gameId, roomId, tableId, playMode,
clientId):
'''UT server中处理来自客户端的quick_start请求
Args:
msg
cmd : quick_start
if roomId == 0:
表示快速开始，服务器为玩家选择房间，然后将请求转给GR
if roomId > 0 and tableId == 0 :
表示玩家选择了房间，将请求转给GR
if roomId > 0 and tableId == roomId * 10000 :
表示玩家在队列里断线重连，将请求转给GR
if roomId > 0 and tableId > 0:
if onlineSeatId > 0:
表示玩家在牌桌里断线重连，将请求转给GT
else:
表示玩家选择了桌子，将请求转给GR
'''
assert isinstance(userId, int) and userId > 0
assert isinstance(roomId, int) and roomId >= 0
assert isinstance(tableId, int) and tableId >= 0
ftlog.debug("MajiangQuickStartV4_0.onCmdQuickStart clientId:",
clientId, " userId:", userId, " roomId:", roomId,
" tableId:", tableId, " gameId:", gameId, " playMode:",
playMode)
isCreate = False
if roomId > 0:
isCreate = cls.isFriendRoom(roomId)
isReconnect = False
# 单开, 无论何时quick_start进入都检查loc
if not pokerconf.isOpenMoreTable(clientId):
loc = onlinedata.checkUserLoc(userId, clientId, gameId)
ftlog.debug('MajiangQuickStartV4_0.onCmdQuickStart checkUserLoc:',
loc,
caller=cls)
if isinstance(loc, basestring):
lgameId, lroomId, ltableId, lseatId = loc.split('.')
lgameId, lroomId, ltableId, lseatId = strutil.parseInts(
lgameId, lroomId, ltableId, lseatId)
if isCreate and (lroomId == 0) and (ltableId == 0):
# 好友桌的快速开始必须有loc，没有loc则进桌失败
ftlog.debug(
'MajiangQuickStartV4_0.onCmdQuickStart room is friendTable, loc is 0, means, table is dissolved...'
)
cls._onEnterRoomFailed(
msg, TYRoom.ENTER_ROOM_REASON_FRIEND_DISSOLVE, userId,
clientId, roomId)
return
if lgameId == gameId and lroomId > 0:
roomId = lroomId
tableId = ltableId
isReconnect = True
ftlog.debug(
'MajiangQuickStartV4_0.onCmdQuickStart old client roomId:',
roomId,
' tableId:',
tableId,
caller=cls)
if (not isReconnect) and roomId > 0 and tableId > 0:
reason = cls._canQuickEnterRoom(userId, gameId, roomId, 1)
if reason != TYRoom.ENTER_ROOM_REASON_OK:
cls._onEnterRoomFailed(msg, reason, userId, gameId, clientId,
roomId)
return
if roomId == 0: # 玩家点击快速开始
chosenRoomId, checkResult = cls._chooseRoom(
userId, gameId, playMode)
ftlog.info(
"MajiangQuickStartV4_0.onCmdQuickStart after choose room userId:",
userId,
" chosenRoomId:",
chosenRoomId,
" checkResult:",
checkResult,
caller=cls)
if checkResult == TYRoom.ENTER_ROOM_REASON_OK:
#找到合适的房间 根据roomId找到合适的table
TYRoomMixin.queryRoomQuickStartReq(msg, chosenRoomId,
0) # 请求转给GR
else:
candidateRoomIds = cls._getCandidateRoomIds(gameId, playMode)
if candidateRoomIds:
rid = candidateRoomIds[0]
msg.setParam('candidateRoomId', rid)
cls._onEnterRoomFailed(msg, checkResult, userId, clientId,
roomId)
return
if tableId == 0: # 玩家只选择了房间
bigRoomId = gdata.getBigRoomId(roomId)
if bigRoomId == 0:
cls._onEnterRoomFailed(msg,
TYRoom.ENTER_ROOM_REASON_ROOM_ID_ERROR,
userId, gameId, clientId, roomId)
return
ctrRoomIds = gdata.bigRoomidsMap()[bigRoomId]
ctrlRoomId = ctrRoomIds[userId % len(ctrRoomIds)]
reason = cls._canQuickEnterRoom(userId, gameId, ctrlRoomId, 1)
if reason == TYRoom.ENTER_ROOM_REASON_OK:
TYRoomMixin.queryRoomQuickStartReq(msg, ctrlRoomId,
0) # 请求转给GR或GT
else:
cls._onEnterRoomFailed(msg, reason, userId, gameId, clientId,
roomId)
return
if tableId == roomId * 10000: # 玩家在队列里断线重连
TYRoomMixin.queryRoomQuickStartReq(msg, roomId, tableId) # 请求转给GR
return
onlineSeat = onlinedata.getOnlineLocSeatId(userId, roomId, tableId)
if onlineSeat:
extParam = {}
extParam['seatId'] = onlineSeat
moParams = msg.getKey('params')
for k, v in moParams.items():
if not k in extParam:
extParam[k] = v
ftlog.debug('extParam=', extParam)
TYRoomMixin.querySitReq(userId, roomId, tableId, clientId,
extParam) # 玩家断线重连，请求转给GT
else: # 玩家选择了桌子,
shadowRoomId = tableId / 10000
ctrRoomId = gdata.roomIdDefineMap()[shadowRoomId].parentId
TYRoomMixin.queryRoomQuickStartReq(
msg, ctrRoomId, tableId, shadowRoomId=shadowRoomId) # 请求转给GR
def createTableQuickStart(cls, msg, itemParams, userId, roomId, tableId, playMode, clientId):
"""
UT server中处理来自客户端的create_table请求
Args:
msg
cmd : create_table
if roomId == 0:
表示玩家创建房间，服务器为玩家选择房间，然后将请求转给GR
if roomId > 0 and tableId == 0 :
表示玩家选择了房间，将请求转给GR
if roomId > 0 and tableId == roomId * 10000 :
表示玩家在队列里断线重连，将请求转给GR
if roomId > 0 and tableId > 0:
if onlineSeatId > 0:
表示玩家在牌桌里断线重连，将请求转给GT
else:
表示玩家选择了桌子，将请求转给GR
"""
assert isinstance(userId, int) and userId > 0
assert isinstance(roomId, int) and roomId >= 0
assert isinstance(tableId, int) and tableId >= 0
ftlog.debug("<< |clientId:", clientId,
"|userId, roomId, tableId:", userId, roomId, tableId,
"|gameId, playMode:", playMode, caller=cls)
isReconnect = False
gameId = msg.getResult('gameId')
# 单开, 无论何时quick_start进入都检查loc
if not pokerconf.isOpenMoreTable(clientId):
loc = onlinedata.checkUserLoc(userId, gameId)
ftlog.debug('old client, checkUserLoc->', loc, caller=cls)
if isinstance(loc, basestring):
lgameId, lroomId, ltableId, lseatId = loc.split('.')
lgameId, lroomId, ltableId, lseatId = strutil.parseInts(lgameId, lroomId, ltableId, lseatId)
if lgameId == gameId and lroomId > 0:
roomId = lroomId
tableId = ltableId
isReconnect = True
ftlog.debug('old client, reset roomId, tableId->', roomId, tableId, caller=cls)
if (not isReconnect) and roomId > 0 and tableId > 0:
reason = cls._canQuickEnterCreateRoom(userId, gameId, roomId)
if reason != TYRoom.ENTER_ROOM_REASON_OK:
cls._onEnterCreateRoomFailed(reason, userId, gameId, clientId, roomId)
return
tempShadowRoomId = 0
if roomId == 0: # 第一个玩家创建房间牌桌
chosenRoomId, checkResult = cls._chooseCreateRoom(userId, gameId, playMode)
ftlog.info("after choose room", "|userId, chosenRoomId, checkResult:", userId, chosenRoomId, checkResult,
caller=cls)
if checkResult == TYRoom.ENTER_ROOM_REASON_OK:
# 得到房间ID,找合适的tableId
roomDef = gdata.roomIdDefineMap()[chosenRoomId]
shadowRoomIds = roomDef.shadowRoomIds
if shadowRoomIds:
for shadowRoomId in shadowRoomIds:
tableId = table_rpc.getTableByRoomId(shadowRoomId)
if isinstance(tableId, int) and tableId > 0:
tempShadowRoomId = shadowRoomId
break
shadowRoomId = tableId / 10000
if shadowRoomId == tempShadowRoomId: # 验证
ctrRoomId = gdata.roomIdDefineMap()[shadowRoomId].parentId
TYRoomMixin.queryRoomQuickStartReq(msg, ctrRoomId, tableId, shadowRoomId=shadowRoomId) # 请求转给GR
return
else:
cls._onEnterCreateRoomFailed(checkResult, userId, gameId, clientId, roomId)
return
else:
cls._onEnterCreateRoomFailed(checkResult, userId, gameId, clientId, roomId)
return
else:
onlineSeat = onlinedata.getOnlineLocSeatId(userId, gameId, roomId, tableId)
if onlineSeat:
extParam = {}
extParam['seatId'] = onlineSeat
moParams = msg.getKey('params')
for k, v in moParams.items():
if not k in extParam:
extParam[k] = v
ftlog.debug('extParam=', extParam)
TYRoomMixin.querySitReq(userId, roomId, tableId, clientId, extParam) # 玩家断线重连，请求转给GT
return
if tableId == roomId * 10000: # 玩家在队列里断线重连
TYRoomMixin.queryRoomQuickStartReq(msg, roomId, tableId) # 请求转给GR
return
# 玩家选择了桌子,进桌
shadowRoomId = tableId / 10000
ctrRoomId = gdata.roomIdDefineMap()[shadowRoomId].parentId
TYRoomMixin.queryRoomQuickStartReq(msg, ctrRoomId, tableId, shadowRoomId=shadowRoomId) # 请求转给GR
def onCmdQuickStart(cls, msg, userId, gameId, roomId, tableId, playMode, clientId):
'''UT server中处理来自客户端的quick_start请求
Args:
msg
cmd : quick_start
if roomId == 0:
表示快速开始，服务器为玩家选择房间，然后将请求转给GR
if roomId > 0 and tableId == 0 :
表示玩家选择了房间，将请求转给GR
if roomId > 0 and tableId == roomId * 10000 :
表示玩家在队列里断线重连，将请求转给GR
if roomId > 0 and tableId > 0:
if onlineSeatId > 0:
表示玩家在牌桌里断线重连，将请求转给GT
else:
表示玩家选择了桌子，将请求转给GR
'''
assert isinstance(userId, int) and userId > 0
assert isinstance(roomId, int) and roomId >= 0
assert isinstance(tableId, int) and tableId >= 0
ftlog.debug("<< |clientId:", clientId,
"|userId, roomId, tableId:", userId, roomId, tableId,
"|gameId, playMode:", gameId, playMode, caller=cls)
isReconnect = False
# 单开, 无论何时quick_start进入都检查loc
if not pokerconf.isOpenMoreTable(clientId):
loc = onlinedata.checkUserLoc(userId, clientId, gameId)
ftlog.debug('old client, checkUserLoc->', loc, caller=cls)
if isinstance(loc, basestring):
lgameId, lroomId, ltableId, lseatId = loc.split('.')
lgameId, lroomId, ltableId, lseatId = strutil.parseInts(lgameId, lroomId, ltableId, lseatId)
if lgameId == gameId and lroomId > 0:
roomId = lroomId
tableId = ltableId
isReconnect = True
ftlog.debug('old client, reset roomId, tableId->', roomId, tableId, caller=cls)
if (not isReconnect) and roomId > 0 and tableId > 0:
reason = cls._canQuickEnterRoom(userId, gameId, roomId, 1)
if reason != TYRoom.ENTER_ROOM_REASON_OK:
cls._onEnterRoomFailed(msg, reason, userId, gameId, clientId, roomId)
return
if roomId == 0: # 玩家点击快速开始
chosenRoomId, checkResult = cls._chooseRoom(userId, gameId, playMode)
ftlog.info("after choose room", "|userId, chosenRoomId, checkResult:", userId, chosenRoomId, checkResult,
caller=cls)
if checkResult == TYRoom.ENTER_ROOM_REASON_OK:
# 找到合适的房间 根据roomId找到合适的table
TYRoomMixin.queryRoomQuickStartReq(msg, chosenRoomId, 0) # 请求转给GR
else:
candidateRoomIds = cls._getCandidateRoomIds(gameId, playMode)
if candidateRoomIds:
rid = candidateRoomIds[0]
msg.setParam('candidateRoomId', rid)
cls._onEnterRoomFailed(msg, checkResult, userId, clientId, roomId)
return
if tableId == 0: # 玩家只选择了房间
bigRoomId = gdata.getBigRoomId(roomId)
if bigRoomId == 0:
cls._onEnterRoomFailed(msg, TYRoom.ENTER_ROOM_REASON_ROOM_ID_ERROR, userId, gameId, clientId, roomId)
return
ctrRoomIds = gdata.bigRoomidsMap()[bigRoomId]
ctrlRoomId = ctrRoomIds[userId % len(ctrRoomIds)]
reason = cls._canQuickEnterRoom(userId, gameId, ctrlRoomId, 1)
if reason == TYRoom.ENTER_ROOM_REASON_OK:
TYRoomMixin.queryRoomQuickStartReq(msg, ctrlRoomId, 0) # 请求转给GR或GT
else:
cls._onEnterRoomFailed(msg, reason, userId, gameId, clientId, roomId)
return
if tableId == roomId * 10000: # 玩家在队列里断线重连
TYRoomMixin.queryRoomQuickStartReq(msg, roomId, tableId) # 请求转给GR
return
onlineSeat = onlinedata.getOnlineLocSeatId(userId, roomId, tableId)
if onlineSeat:
extParam = {}
extParam['seatId'] = onlineSeat
moParams = msg.getKey('params')
for k, v in moParams.items():
if not k in extParam:
extParam[k] = v
ftlog.debug('extParam=', extParam)
TYRoomMixin.querySitReq(userId, roomId, tableId, clientId, extParam) # 玩家断线重连，请求转给GT
else: # 玩家选择了桌子,
shadowRoomId = tableId / 10000
ctrRoomId = gdata.roomIdDefineMap()[shadowRoomId].parentId
TYRoomMixin.queryRoomQuickStartReq(msg, ctrRoomId, tableId, shadowRoomId=shadowRoomId) # 请求转给GR
def onCmdQuickStart(cls, msg, userId, gameId, roomId, tableId, clientId,
kindId):
"""UT server中处理来自客户端的quick_start请求
Args:
msg
cmd : quick_start
if roomId == 0:
表示快速开始，服务器为玩家选择房间，然后将请求转给GR
if roomId > 0 and tableId == 0 :
表示玩家选择了房间，将请求转给GR
if roomId > 0 and tableId == roomId * 10000 :
表示玩家在队列里断线重连，将请求转给GR
if roomId > 0 and tableId > 0:
if onlineSeatId > 0:
表示玩家在牌桌里断线重连，将请求转给GT
else:
表示玩家选择了桌子，将请求转给GR
"""
assert isinstance(userId, int) and userId > 0
assert isinstance(roomId, int) and roomId >= 0
assert isinstance(tableId, int) and tableId >= 0
if ftlog.is_debug():
ftlog.debug("onCmdQuickStart->", userId, "msg =", msg, "roomId =",
roomId, "tableId =", tableId, "clientId =", clientId)
isRobot = userId < config.ROBOT_MAX_USER_ID
if not isRobot and not util.isUsableClientVersion(userId):
cls.onQuickStartFailed(cls.ENTER_ROOM_REASON_VERSION_DISABLE,
userId, clientId, roomId)
return
# 单开, 无论何时quick_start进入都检查loc
if not pokerconf.isOpenMoreTable(clientId):
locList = onlinedata.getOnlineLocList(userId)
if ftlog.is_debug():
ftlog.debug("onCmdQuickStart->getOnlineLocList->", userId,
locList)
try:
for lRoomId, lTableId, lSeatId in locList:
roomGameId = strutil.getGameIdFromInstanceRoomId(lRoomId)
if roomGameId == FISH_GAMEID:
roomId = lRoomId
tableId = lTableId
ftlog.info(
"onCmdQuickStart->reconnect roomId, tableId->",
userId, roomId, tableId)
else:
cls.onQuickStartFailed(
cls.ENTER_ROOM_REASON_STATE_ERROR, userId,
clientId, roomId)
return
break
except:
ftlog.warn("onCmdQuickStart->error", userId, roomId, tableId)
redState = gamedata.getGameAttrInt(userId, FISH_GAMEID,
GameData.redState)
if isRobot is False and redState == 0:
ctrlRoomId = config.getCommonValueByKey("newbieRoomId")
chosenTableId = 0
shadowRoomId = None
if gdata.getBigRoomId(roomId) == gdata.getBigRoomId(
ctrlRoomId) and tableId:
chosenTableId = tableId
shadowRoomId = tableId / 10000
TYRoomMixin.queryRoomQuickStartReq(
msg, ctrlRoomId, chosenTableId,
shadowRoomId=shadowRoomId) # 请求转给GR
return
if roomId == 0: # 玩家点击快速开始
chosenRoomId, reason = cls._chooseRoom(userId, gameId)
ftlog.info("onCmdQuickStart->chosenRoomId", chosenRoomId,
"userId =", userId, "reason =", reason)
if reason == cls.ENTER_ROOM_REASON_OK:
TYRoomMixin.queryRoomQuickStartReq(msg, chosenRoomId,
0) # 请求转给GR
else:
cls.onQuickStartFailed(reason, userId, clientId, roomId)
return
if tableId == 0: # 玩家只选择了房间
bigRoomId = gdata.getBigRoomId(roomId)
if bigRoomId == 0:
cls.onQuickStartFailed(cls.ENTER_ROOM_REASON_ROOM_ID_ERROR,
userId, clientId, roomId)
return
ctrlRoomIds = gdata.bigRoomidsMap()[bigRoomId]
ctrlRoomId = ctrlRoomIds[userId % len(ctrlRoomIds)]
reason = cls.canQuickEnterRoom(userId, gameId, ctrlRoomId, kindId)
if reason == cls.ENTER_ROOM_REASON_OK:
roomConf = gdata.roomIdDefineMap()[roomId].configure
fee = roomConf.get("fee_%s" % kindId, {}) or roomConf.get(
"fee", {})
rewards = fee.get("rewards", [])
if fee:
_consume = [{"name": fee["kindId"], "count": fee["count"]}]
ret = util.consumeItems(userId, _consume, "ROOM_GAME_FEE")
if ret and rewards:
util.addRewards(userId, rewards,
"BI_NFISH_VOUCHER_REWARDS", kindId)
TYRoomMixin.queryRoomQuickStartReq(msg, ctrlRoomId,
0) # 请求转给GR或GT
else:
cls.onQuickStartFailed(reason, userId, clientId, roomId)
return
if tableId == roomId * 10000: # 玩家在队列里断线重连
TYRoomMixin.queryRoomQuickStartReq(msg, roomId, tableId) # 请求转给GR
return
onlineSeat = onlinedata.getOnlineLocSeatId(userId, roomId, tableId)
if onlineSeat:
TYRoomMixin.querySitReq(userId, roomId, tableId, clientId,
{"seatId": onlineSeat}) # 玩家断线重连，请求转给GT
else: # 玩家选择了桌子
shadowRoomId = tableId / 10000
ctrlRoomId = gdata.roomIdDefineMap()[shadowRoomId].parentId
TYRoomMixin.queryRoomQuickStartReq(
msg, ctrlRoomId, tableId, shadowRoomId=shadowRoomId) # 请求转给GR
def onCmdQuickStart(cls, msg, userId, gameId, roomId, tableId, playMode,
clientId):
'''UT server中处理来自客户端的quick_start请求
Args:
msg
cmd : quick_start
if roomId == 0:
表示快速开始，服务器为玩家选择房间，然后将请求转给GR
if roomId > 0 and tableId == 0 :
表示玩家选择了房间，将请求转给GR
if roomId > 0 and tableId == roomId * 10000 :
表示玩家在队列里断线重连，将请求转给GR
if roomId > 0 and tableId > 0:
if onlineSeatId > 0:
表示玩家在牌桌里断线重连，将请求转给GT
else:
表示玩家选择了桌子，将请求转给GR
'''
assert isinstance(userId, int) and userId > 0
assert isinstance(roomId, int) and roomId >= 0
assert isinstance(tableId, int) and tableId >= 0
if ftlog.is_debug():
ftlog.debug("<< |clientId:",
clientId,
"|userId, roomId, tableId:",
userId,
roomId,
tableId,
"|gameId, playMode:",
gameId,
playMode,
caller=cls)
# 单开, 无论何时quick_start进入都检查loc
if not pokerconf.isOpenMoreTable(clientId):
loc = onlinedata.checkUserLoc(userId, clientId, gameId)
if ftlog.is_debug():
ftlog.debug('old client, checkUserLoc->', loc, caller=cls)
if isinstance(loc, basestring):
lgameId, lroomId, ltableId, lseatId = loc.split('.')
lgameId, lroomId, ltableId, lseatId = strutil.parseInts(
lgameId, lroomId, ltableId, lseatId)
if lgameId == gameId and lroomId > 0:
ftlog.debug('onCmdQuickStart re-connected |userId, loc:',
userId,
loc,
'|roomId, tableId:',
roomId,
tableId,
caller=cls)
roomId = lroomId
tableId = ltableId
msg.setParam('isReConnected', True)
if ftlog.is_debug():
ftlog.debug('old client, reset roomId, tableId->',
roomId,
tableId,
caller=cls)
if roomId == 0: # 玩家点击快速开始
chosenRoomId, checkResult = cls._chooseRoom(
userId, gameId, playMode)
ftlog.debug("after choose room",
"|userId, chosenRoomId, checkResult:",
userId,
chosenRoomId,
checkResult,
caller=cls)
if checkResult == TYRoom.ENTER_ROOM_REASON_OK:
TYRoomMixin.queryRoomQuickStartReq(msg, chosenRoomId,
0) # 请求转给GR
else:
candidateRoomIds = cls._getCandidateRoomIds(gameId, playMode)
if candidateRoomIds:
rid = candidateRoomIds[0]
msg.setParam('candidateRoomId', rid)
cls._onEnterRoomFailed(msg, checkResult, userId, clientId,
roomId)
return
bigRoomId = gdata.getBigRoomId(roomId)
ftlog.debug('bigRoomId:', bigRoomId)
if bigRoomId == 0:
cls._onEnterRoomFailed(msg, TYRoom.ENTER_ROOM_REASON_ROOM_ID_ERROR,
userId, clientId, roomId)
return
if strutil.getGameIdFromBigRoomId(bigRoomId) != gameId:
cls._onEnterRoomFailed(msg, TYRoom.ENTER_ROOM_REASON_ROOM_ID_ERROR,
userId, clientId, roomId)
return
if tableId == 0: # 玩家只选择了房间
if gameId == 6 and roomId != bigRoomId:
ctrlRoomId = gdata.roomIdDefineMap()[roomId].parentId or roomId
queryRoomId = roomId
else:
ctrRoomIds = gdata.bigRoomidsMap()[bigRoomId]
ctrlRoomId = ctrRoomIds[userId % len(ctrRoomIds)]
queryRoomId = ctrlRoomId
reason = cls._canQuickEnterRoom(userId, gameId, ctrlRoomId, 1)
if reason == TYRoom.ENTER_ROOM_REASON_OK:
if gameId == 6:
TYRoomMixin.queryRoomQuickStartReq(msg, queryRoomId,
0) # 请求转给GR或GT
else:
TYRoomMixin.queryRoomQuickStartReq(msg, ctrlRoomId,
0) # 请求转给GR或GT
elif reason == TYRoom.ENTER_ROOM_REASON_LESS_MIN or reason == TYRoom.ENTER_ROOM_REASON_GREATER_MAX:
if gameId == 6:
innerTable = msg.getParam("innerTable",
0) # innerTable 区分不同版本弹窗
if innerTable == 1:
roomDef = gdata.roomIdDefineMap()[ctrlRoomId]
playMode = roomDef.configure.get('playMode', None)
if ftlog.is_debug():
ftlog.debug('enter_less_min userId=', userId,
'roomId=', ctrlRoomId, 'msg=', msg,
'playmode=', playMode)
msgpack = MsgPack()
msgpack.setCmd("quick_start")
msgpack.setParam("userId", userId)
msgpack.setParam("gameId", gameId)
msgpack.setParam("clientId", clientId)
msgpack.setParam("innerTable", 1)
msgpack.setParam("apiver", msg.getParam("apiver",
3.7)) # 驱动
cls.onCmdQuickStart(msgpack, userId, gameId, 0, 0,
playMode, clientId)
if ftlog.is_debug():
ftlog.debug('reenter_less_min userId=', userId,
'roomId=', ctrlRoomId, 'msgpack=',
msgpack.pack())
else:
cls._onEnterRoomFailed(msg, reason, userId, clientId,
roomId)
else:
cls._onEnterRoomFailed(msg, reason, userId, clientId,
roomId)
else:
cls._onEnterRoomFailed(msg, reason, userId, clientId, roomId)
return
if tableId == roomId * 10000: # 玩家在队列里断线重连 4400150010001
TYRoomMixin.queryRoomQuickStartReq(msg, roomId, tableId) # 请求转给GR
return
onlineSeat = onlinedata.getOnlineLocSeatId(userId, roomId, tableId)
if onlineSeat:
if onlineSeat == gdata.roomIdDefineMap(
)[roomId].configure['tableConf']['maxSeatN'] + 1:
# 牌桌里旁观的玩家断线重连，请求转给GT
TYRoomMixin.sendTableCallObserveReq(userId, roomId, tableId,
clientId)
else:
# 牌桌里坐着的玩家断线重连，请求转给GT
# TYRoomMixin.querySitReq(userId, roomId, tableId, clientId) # GT人多时会有超时异常
TYRoomMixin.sendSitReq(userId, roomId, tableId, clientId)
else: # 玩家选择了桌子,
shadowRoomId = tableId / 10000
ctrRoomId = gdata.roomIdDefineMap()[shadowRoomId].parentId
TYRoomMixin.queryRoomQuickStartReq(
msg, ctrRoomId, tableId, shadowRoomId=shadowRoomId) # 请求转给GR
def onCmdQuickStart(cls, msg, userId, gameId, roomId, tableId, playMode, clientId):
'''UT server中处理来自客户端的quick_start请求
Args:
msg
cmd : quick_start
if roomId == 0:
表示快速开始，服务器为玩家选择房间，然后将请求转给GR
if roomId > 0 and tableId == 0 :
表示玩家选择了房间，将请求转给GR
if roomId > 0 and tableId == roomId * 10000 :
表示玩家在队列里断线重连，将请求转给GR
if roomId > 0 and tableId > 0:
if onlineSeatId > 0:
表示玩家在牌桌里断线重连，将请求转给GT
else:
表示玩家选择了桌子，将请求转给GR
'''
assert isinstance(userId, int) and userId > 0
assert isinstance(roomId, int) and roomId >= 0
assert isinstance(tableId, int) and tableId >= 0
if ftlog.is_debug():
ftlog.debug("<< |clientId:", clientId,
"|userId, roomId, tableId:", userId, roomId, tableId,
"|gameId, playMode:", gameId, playMode, caller=cls)
# 单开, 无论何时quick_start进入都检查loc
if not pokerconf.isOpenMoreTable(clientId):
loc = onlinedata.checkUserLoc(userId, clientId, gameId)
if ftlog.is_debug():
ftlog.debug('old client, checkUserLoc->', loc, caller=cls)
if isinstance(loc, basestring):
lgameId, lroomId, ltableId, lseatId = loc.split('.')
lgameId, lroomId, ltableId, lseatId = strutil.parseInts(lgameId, lroomId, ltableId, lseatId)
if lgameId == gameId and lroomId > 0:
ftlog.debug('onCmdQuickStart re-connected |userId, loc:', userId, loc,
'|roomId, tableId:', roomId, tableId, caller=cls)
roomId = lroomId
tableId = ltableId
msg.setParam('isReConnected', True)
if ftlog.is_debug():
ftlog.debug('old client, reset roomId, tableId->', roomId, tableId, caller=cls)
if roomId == 0: # 玩家点击快速开始
chosenRoomId, checkResult = cls._chooseRoom(userId, gameId, playMode)
ftlog.debug("after choose room", "|userId, chosenRoomId, checkResult:", userId, chosenRoomId, checkResult,
caller=cls)
if checkResult == TYRoom.ENTER_ROOM_REASON_OK:
TYRoomMixin.queryRoomQuickStartReq(msg, chosenRoomId, 0) # 请求转给GR
else:
candidateRoomIds = cls._getCandidateRoomIds(gameId, playMode)
if candidateRoomIds:
rid = candidateRoomIds[0]
msg.setParam('candidateRoomId', rid)
cls._onEnterRoomFailed(msg, checkResult, userId, clientId, roomId)
return
bigRoomId = gdata.getBigRoomId(roomId)
ftlog.debug('bigRoomId:', bigRoomId)
if bigRoomId == 0:
cls._onEnterRoomFailed(msg, TYRoom.ENTER_ROOM_REASON_ROOM_ID_ERROR, userId, clientId, roomId)
return
if strutil.getGameIdFromBigRoomId(bigRoomId) != gameId:
cls._onEnterRoomFailed(msg, TYRoom.ENTER_ROOM_REASON_ROOM_ID_ERROR, userId, clientId, roomId)
return
if tableId == 0: # 玩家只选择了房间
if gameId == 6 and roomId != bigRoomId:
ctrlRoomId = gdata.roomIdDefineMap()[roomId].parentId
queryRoomId = roomId
else:
ctrRoomIds = gdata.bigRoomidsMap()[bigRoomId]
ctrlRoomId = ctrRoomIds[userId % len(ctrRoomIds)]
queryRoomId = ctrlRoomId
reason = cls._canQuickEnterRoom(userId, gameId, ctrlRoomId, 1)
if reason == TYRoom.ENTER_ROOM_REASON_OK:
if gameId == 6:
TYRoomMixin.queryRoomQuickStartReq(msg, queryRoomId, 0) # 请求转给GR或GT
else:
TYRoomMixin.queryRoomQuickStartReq(msg, ctrlRoomId, 0) # 请求转给GR或GT
elif reason == TYRoom.ENTER_ROOM_REASON_LESS_MIN or reason == TYRoom.ENTER_ROOM_REASON_GREATER_MAX:
if gameId == 6:
innerTable = msg.getParam("innerTable", 0) # innerTable 区分不同版本弹窗
if innerTable == 1:
roomDef = gdata.roomIdDefineMap()[ctrlRoomId]
playMode = roomDef.configure.get('playMode', None)
if ftlog.is_debug():
ftlog.debug('enter_less_min userId=', userId, 'roomId=', ctrlRoomId, 'msg=', msg,
'playmode=', playMode)
msgpack = MsgPack()
msgpack.setCmd("quick_start")
msgpack.setParam("userId", userId)
msgpack.setParam("gameId", gameId)
msgpack.setParam("clientId", clientId)
msgpack.setParam("innerTable", 1)
msgpack.setParam("apiver", msg.getParam("apiver", 3.7))
cls.onCmdQuickStart(msgpack, userId, gameId, 0, 0, playMode, clientId)
if ftlog.is_debug():
ftlog.debug('reenter_less_min userId=', userId, 'roomId=', ctrlRoomId, 'msgpack=',
msgpack.pack())
else:
cls._onEnterRoomFailed(msg, reason, userId, clientId, roomId)
else:
cls._onEnterRoomFailed(msg, reason, userId, clientId, roomId)
else:
cls._onEnterRoomFailed(msg, reason, userId, clientId, roomId)
return
if tableId == roomId * 10000: # 玩家在队列里断线重连
TYRoomMixin.queryRoomQuickStartReq(msg, roomId, tableId) # 请求转给GR
return
onlineSeat = onlinedata.getOnlineLocSeatId(userId, roomId, tableId)
if onlineSeat:
if onlineSeat == gdata.roomIdDefineMap()[roomId].configure['tableConf']['maxSeatN'] + 1:
# 牌桌里旁观的玩家断线重连，请求转给GT
TYRoomMixin.sendTableCallObserveReq(userId, roomId, tableId, clientId)
else:
# 牌桌里坐着的玩家断线重连，请求转给GT
# TYRoomMixin.querySitReq(userId, roomId, tableId, clientId) # GT人多时会有超时异常
TYRoomMixin.sendSitReq(userId, roomId, tableId, clientId)
else: # 玩家选择了桌子,
shadowRoomId = tableId / 10000
ctrRoomId = gdata.roomIdDefineMap()[shadowRoomId].parentId
TYRoomMixin.queryRoomQuickStartReq(msg, ctrRoomId, tableId, shadowRoomId=shadowRoomId) # 请求转给GR
def _checkUserLoc(userId, clientId, matchGameId=0):
'''Why：
玩家断线重连时，loc的信息可能与table不一致，conn server需要与table server通讯检查一致性；
导致不一致的原因：服务端重启（特别是roomId、tableId变更）
如果玩家在队列房间或者比赛房间的等待队列中, 此处不做一致性检查，等玩家发起quick_start时由room server检查
What：
与table server通讯检查桌子对象里是否有这个玩家的数据
如果不一致，则回收牌桌金币并清空loc；
Return：
如果玩家在房间队列里，返回gameId.roomId.roomId*10000.1
如果玩家在座位上，返回gameId.roomId.tableId.seatId
如果玩家在旁观，返回gameId.roomId.tableId.0
玩家不在table对象里，返回0.0.0.0
'''
truelocs = []
loclist = _getOnlineLocList(userId)
for locs in loclist:
rid, tid, sid = locs[0], locs[1], locs[2]
gid = strutil.getGameIdFromInstanceRoomId(rid)
if gid > 0 and rid > 0 and tid > 0:
# 到具体的房间或桌子的服务上去查询, 是否是真的在桌子上
if tid == rid * 10000: # 玩家在队列房间或者比赛房间的等待队列中, 此处不做一致性检查，玩家发起quick_start时检查。
truelocs.append('%d.%d.%d.%d' % (gid, rid, tid, sid))
else:
seatId, isObserving = 0, 0
try:
seatId, isObserving = roommgr.doCheckUserLoc(
userId, gid, rid, tid, clientId)
except:
ftlog.error()
continue
ftlog.debug('_checkUserLoc->userId=', userId, 'seatId=',
seatId, 'isObserving=', isObserving)
if seatId > 0 or isObserving == 1:
# 还在桌子上游戏, 返回断线重连的信息
if matchGameId > 0:
if matchGameId == gid:
truelocs.append('%d.%d.%d.%d' %
(gid, rid, tid, seatId))
else:
truelocs.append('%d.%d.%d.%d' %
(gid, rid, tid, seatId))
else:
# 已经不再桌子上了, 清理所有的桌子带入金币
if sid > 0:
from poker.entity.dao import userchip
userchip.moveAllTableChipToChip(
userId, gid, 'TABLE_TCHIP_TO_CHIP', 0, clientId,
tid)
# 清理当前的在线数据
_removeOnlineLoc(userId, rid, tid)
else:
# 到这儿, 数据是错误的, 删除处理
_removeOnlineLoc(userId, rid, tid)
ftlog.debug('_checkUserLoc->', userId, clientId, truelocs)
if pokerconf.isOpenMoreTable(clientId):
# 新的客户端协议, 对于断线重连支持的时列表格式, 即客户端可以进行多开
return strutil.dumps(truelocs)
else:
# 老的客户端, 只支持一个桌子
if truelocs:
return truelocs[0]
return '0.0.0.0'