def _do_http_gm_room_list(self, gameId, httpRequest, httpArgs, httpResult):
'''获取房间列表'''
roomOnlineInfos = daobase._executeBiCmd('HGETALL', daoconst.BI_KEY_ROOM_ONLINES % (gameId))
roomOnlineInfos = dict(utils.pairwise(roomOnlineInfos))
bigRoomOnlineInfos = {}
for roomId, onlineInfo in roomOnlineInfos.items():
bigRoomId = gdata.getBigRoomId(roomId)
tcs = map(int, onlineInfo.split('|'))
ucount, tcount = tcs[0], tcs[-1]
if bigRoomId not in bigRoomOnlineInfos:
bigRoomOnlineInfos[bigRoomId] = [0, 0]
bigRoomOnlineInfos[bigRoomId][0] += ucount
bigRoomOnlineInfos[bigRoomId][1] += tcount
roomList = []
for bigRoomId in gdata.gameIdBigRoomidsMap()[gameId]:
ctrlRoomId = gdata.bigRoomidsMap()[bigRoomId][0]
roomDefine = gdata.roomIdDefineMap()[ctrlRoomId]
ucount, tcount = bigRoomOnlineInfos.get(roomDefine.bigRoomId, [0, 0])
roomInfo = {
'bigRoomId': bigRoomId,
'tableCount': roomDefine.configure['gameServerCount'] * roomDefine.configure['gameTableCount'],
'name': roomDefine.configure['tableConf'].get('tname', ''),
'playingPlayers': ucount,
'playingTables': tcount,
}
roomList.append(roomInfo)
httpResult['roomList'] = roomList
def buildMatch(cls, conf, room):
match = None
master = None
ctrlRoomIdList = gdata.bigRoomidsMap().get(room.bigRoomId, [])
if conf.start.isUserCountType():
conf.start.userMaxCountPerMatch = conf.start.userMaxCount
conf.start.signinMaxCount = conf.start.signinMaxCount
else:
conf.start.userMaxCountPerMatch = int(conf.start.userMaxCount / max(len(ctrlRoomIdList), 1))
conf.start.signinMaxCountPerMatch = int(conf.start.signinMaxCount / max(len(ctrlRoomIdList), 1))
if cls.isMaster(conf, room):
master, match = cls.buildMaster(conf, room)
room.matchMaster = master
else:
match = cls.buildArea(conf, room)
ftlog.info('GroupMatch.buildMatch roomId=', room.roomId,
'ctrlRoomIdList=', ctrlRoomIdList,
'ctrlRoomCount=', len(ctrlRoomIdList),
'userMaxCount=', conf.start.userMaxCount,
'userMaxCountPerMatch=', conf.start.userMaxCountPerMatch,
'signinMaxCount=', conf.start.signinMaxCount,
'signinMaxCountPerMatch=', conf.start.signinMaxCountPerMatch)
if master:
master.matchStatusDao = MatchStatusDaoDizhu(room)
match.signIF = SignIFDizhu(room, conf.tableId, conf.seatId)
match.tableController= TableControllerDizhu(room)
match.playerNotifier = PlayerNotifierDizhu(room)
match.matchRewards = MatchRewardsDizhu(room)
match.userInfoLoader = UserInfoLoaderDizhu()
return match, master
def buildMatch(self):
ctrlRoomIdList = gdata.bigRoomidsMap().get(self.bigRoomId, [])
if self.conf.start.isUserCountType():
self.conf.start.userMaxCountPerMatch = self.conf.start.userMaxCount
self.conf.start.signinMaxCount = self.conf.start.signinMaxCount
else:
self.conf.start.userMaxCountPerMatch = int(self.conf.start.userMaxCount / max(len(ctrlRoomIdList), 1))
self.conf.start.signinMaxCountPerMatch = int(self.conf.start.signinMaxCount / max(len(ctrlRoomIdList), 1))
master = None
if self.isMaster:
master, match = self.buildMaster()
else:
match = self.buildArea()
ftlog.info('DizhuGroupMatchCtrlRoom.buildMatch roomId=', self.roomId,
'ctrlRoomIdList=', ctrlRoomIdList,
'ctrlRoomCount=', len(ctrlRoomIdList),
'userMaxCount=', self.conf.start.userMaxCount,
'userMaxCountPerMatch=', self.conf.start.userMaxCountPerMatch,
'signinMaxCount=', self.conf.start.signinMaxCount,
'signinMaxCountPerMatch=', self.conf.start.signinMaxCountPerMatch)
if master:
master.matchStatusDao = MatchStatusDaoDizhu(self)
match.signIF = SignIFDizhu(self, self.conf.tableId, self.conf.seatId)
match.tableController= TableControllerDizhu(self)
match.playerNotifier = PlayerNotifierDizhu(self)
match.matchRankRewardsSelector = MatchRankRewardsSelectorDizhu(self)
match.matchRewards = MatchRewardsDizhu(self)
match.userInfoLoader = UserInfoLoaderDizhu()
return match, master
def getRealRoomIdListWithBigRoomId(cls, roomId):
'''
获取某个房间的真实房间ID
:param roomId是配置中的ID，如：6015
:return 返回真实ID的元组，如：(60151000, ...)
'''
return gdata.bigRoomidsMap()[roomId]
def collectCtrlRoomIdsByFTPlayMode(ftPlayMode):
bigRoomIds = gdata.gameIdBigRoomidsMap().get(DIZHU_GAMEID)
ctrlRoomIds = []
for bigRoomId in bigRoomIds:
roomConf = gdata.getRoomConfigure(bigRoomId)
if ((roomConf.get('typeName') in ('dizhuFT', 'dizhu_friend'))
and ftPlayMode == roomConf.get('ftPlayMode')):
ctrlRoomIds.extend(gdata.bigRoomidsMap().get(bigRoomId, []))
ctrlRoomIds.sort()
return ctrlRoomIds
def _communicateTableServer(userId,
roomId,
msgpack,
head1,
isQuery,
timeout=None,
notimeoutex=0):
if timeout == None:
timeout = _runenv._RPC_TIME_OUT
assert (isinstance(msgpack, (MsgPack, basestring)))
assert (isinstance(roomId, (int, long)) and roomId >= 0)
assert (isinstance(userId, (int, long)) and userId >= 0)
allrooms = gdata.roomIdDefineMap()
if roomId in allrooms:
roomDef = allrooms[roomId]
if roomDef.parentId == 0:
ftlog.warn('ERROR, cat not localtion the roomId of->', userId,
roomId, msgpack)
return
else: # this roomId is big roomId
assert (isinstance(userId, (int, long)) and userId >= 0)
bigrooms = gdata.bigRoomidsMap()
if roomId in bigrooms:
msgpack, shadowRoomId = __getRoomIdByTableId(msgpack)
ftlog.debug('_communicateTableServer allrooms = ', allrooms,
'shadowRoomId =', shadowRoomId)
if shadowRoomId:
roomDef = allrooms[shadowRoomId]
else:
ftlog.warn('ERROR, cat not localtion the roomId of->', userId,
roomId, msgpack)
return
else:
ftlog.warn('ERROR, cat not localtion the roomId of->', userId,
roomId, msgpack)
return
if isinstance(msgpack, MsgPack):
msgpack = msgpack.pack()
dst = roomDef.serverId
ftlog.debug('_communicateTableServer->dst=', dst, 'head1=', head1,
'roomId=', str(roomId), 'timeout=', timeout,
'msgpack=[' + msgpack + ']')
if isQuery:
response = wrapper.query(dst,
msgpack,
head1,
str(roomId),
timeout,
notimeoutex=notimeoutex)
ftlog.debug('_communicateTableServer->dst=', dst, 'head1=', head1,
'roomId=', str(roomId), 'response=[' + str(response) + ']')
return response
else:
return wrapper.send(dst, msgpack, head1, str(roomId))
def addOnlineLoc(userId, roomId, tableId, seatId, checkConfict=True):
'''
添加一个用户的在线位置,
注意: 子键值为roomId+'.'+tableId, 因此不允许用户再同一个桌子的不同桌位坐下
通常此方法在用户真实坐在某一个桌位后调用
'''
assert (isinstance(roomId, int) and roomId > 0)
assert (roomId in gdata.roomIdDefineMap() or roomId in gdata.bigRoomidsMap())
assert (isinstance(tableId, int) and tableId > roomId)
assert (isinstance(seatId, int) and seatId > 0)
return dbuser._addOnlineLoc(userId, roomId, tableId, seatId, checkConfict)
def addOnlineLoc(userId, roomId, tableId, seatId, checkConfict=True):
'''
添加一个用户的在线位置,
注意: 子键值为roomId+'.'+tableId, 因此不允许用户再同一个桌子的不同桌位坐下
通常此方法在用户真实坐在某一个桌位后调用
'''
assert (isinstance(roomId, int) and roomId > 0)
assert (roomId in gdata.roomIdDefineMap() or roomId in gdata.bigRoomidsMap())
assert (isinstance(tableId, int) and tableId > roomId)
assert (isinstance(seatId, int) and seatId > 0)
return dbuser._addOnlineLoc(userId, roomId, tableId, seatId, checkConfict)
def setBigRoomOnlineLoc(userId, roomId, tableId, seatId):
'''
添加一个用户的在线位置,
注意: 子键值为roomId+'.'+tableId, 因此不允许用户再同一个桌子的不同桌位坐下
此方法将会检查当前的所有loc，如果存在和roomId一直的bigRoomId的loc那么删除原loc设置新loc
'''
assert (isinstance(roomId, int) and roomId > 0)
assert (roomId in gdata.roomIdDefineMap() or roomId in gdata.bigRoomidsMap())
assert (isinstance(tableId, int) and tableId > roomId)
assert (isinstance(seatId, int) and seatId > 0)
return dbuser._setBigRoomOnlineLoc(userId, roomId, tableId, seatId)
def buildMaster(cls, conf, room):
ftlog.info('GroupMatch.buildMaster roomId=', room.roomId)
master = MatchMaster(room, room.bigmatchId, conf)
area = MatchArea(room, room.bigmatchId, conf, MatchMasterStubLocal(master))
master.addAreaStub(MatchAreaStubLocal(master, area))
if not conf.start.isUserCountType():
ctrlRoomIdList = gdata.bigRoomidsMap().get(room.bigRoomId, [])
for ctrlRoomId in ctrlRoomIdList:
if ctrlRoomId != area.roomId:
master.addAreaStub(MatchAreaStubRemote(master, ctrlRoomId))
return master, area
def setBigRoomOnlineLoc(userId, roomId, tableId, seatId):
'''
添加一个用户的在线位置,
注意: 子键值为roomId+'.'+tableId, 因此不允许用户再同一个桌子的不同桌位坐下
此方法将会检查当前的所有loc，如果存在和roomId一直的bigRoomId的loc那么删除原loc设置新loc
'''
assert (isinstance(roomId, int) and roomId > 0)
assert (roomId in gdata.roomIdDefineMap()
or roomId in gdata.bigRoomidsMap())
assert (isinstance(tableId, int) and tableId > roomId)
assert (isinstance(seatId, int) and seatId > 0)
return dbuser._setBigRoomOnlineLoc(userId, roomId, tableId, seatId)
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 getRpcDstRoomServerId(roomId, canChangeRoomId):
allrooms = gdata.roomIdDefineMap()
if roomId in allrooms:
roomDef = allrooms[roomId]
return roomDef.serverId
elif canChangeRoomId: # this roomId may be big roomId
bigrooms = gdata.bigRoomidsMap()
if roomId in bigrooms:
ctrlroomIds = bigrooms[roomId]
ctrlRoomId = ctrlroomIds[0] # ctrlRoom0 做为 ctrlRooms 的调度器
roomDef = allrooms[ctrlRoomId]
return roomDef.serverId
ftlog.warn('getRpcDstRoomServerId roomId error !!', roomId, canChangeRoomId)
def _communicateRoomServer(userId,
roomId,
msgpack,
head1,
isQuery,
timeout=None,
notimeoutex=0):
if timeout == None:
timeout = _runenv._RPC_TIME_OUT
assert (isinstance(msgpack, (MsgPack, basestring)))
assert (isinstance(roomId, (int, long)) and roomId >= 0)
allrooms = gdata.roomIdDefineMap()
if roomId in allrooms:
roomDef = allrooms[roomId]
if roomDef.parentId > 0: # this roomId is shadowRoomId
ctrlRoomId = roomDef.parentId
roomDef = allrooms[ctrlRoomId]
msgpack = __changeMsgRoomId(msgpack, ctrlRoomId, roomId)
else: # this roomId is big roomId
assert (isinstance(userId, (int, long)) and userId >= 0)
bigrooms = gdata.bigRoomidsMap()
if roomId in bigrooms:
ctrlroomIds = bigrooms[roomId]
ctrlRoomId = ctrlroomIds[
userId % len(ctrlroomIds)] # ctrlRoom0 做为 ctrlRooms 的调度器
roomDef = allrooms[ctrlRoomId]
msgpack = __changeMsgRoomId(msgpack, ctrlRoomId, roomId)
else:
ftlog.warn('ERROR, cat not localtion the roomId of->', userId,
roomId, msgpack)
return
if isinstance(msgpack, MsgPack):
msgpack = msgpack.pack()
dst = roomDef.serverId
ftlog.debug('_communicateRoomServer->dst=', dst, 'head1=', head1,
'roomId=', str(roomId), 'timeout=', timeout,
'msgpack=[' + msgpack + ']')
if isQuery:
response = wrapper.query(dst,
msgpack,
head1,
str(roomId),
timeout,
notimeoutex=notimeoutex)
ftlog.debug('_communicateRoomServer->dst=', dst, 'head1=', head1,
'roomId=', str(roomId), 'response=[' + str(response) + ']')
return response
else:
return wrapper.send(dst, msgpack, head1, str(roomId))
def buildMaster(self):
ftlog.info('DizhuGroupCtrlRoom.buildMaster'
'roomId=', self.roomId,
'masterRoomId=', self.masterRoomId,
'isMaster=', self.isMaster,
'bigmatchId=', self.bigmatchId)
master = MatchMaster(self, self.bigmatchId, self.conf)
area = MatchArea(self, self.bigmatchId, self.conf, MatchMasterStubLocal(master))
master.addAreaStub(MatchAreaStubLocal(master, area))
if not self.conf.start.isUserCountType():
ctrlRoomIdList = gdata.bigRoomidsMap().get(self.bigRoomId, [])
for ctrlRoomId in ctrlRoomIdList:
if ctrlRoomId != area.roomId:
master.addAreaStub(MatchAreaStubRemote(master, ctrlRoomId))
return master, area
def _canQuickStartDizhuMatch(cls, userId, gameId, roomId, playMode):
'''
检测比赛房间是否符合快开条件
@return ok{Bool} 是否满足条件进入地主比赛
'''
roomconf = gdata.roomIdDefineMap()[roomId].configure
bigRoomId = gdata.getBigRoomId(roomId)
ctrRoomIds = gdata.bigRoomidsMap()[bigRoomId]
ctrlRoomId = ctrRoomIds[userId % len(ctrRoomIds)]
reason = cls._canQuickEnterMatchRoom(userId, gameId, ctrlRoomId, 1)
ftlog.debug(
"DizhuQuickStartV4_0._canQuickStartDizhuMatch: roomCond|userId=",
userId, "roomId=", roomId, "bigRoomId=", bigRoomId, "ctrlRoomId=",
ctrlRoomId, "reason=", reason)
if reason != TYRoom.ENTER_ROOM_REASON_OK:
return False
# 若不存在开关，或者开关为0，代表房间关闭比赛快开
quickMatchToggle = roomconf.get("quickMatchToggle", 0)
ftlog.debug("DizhuQuickStartV4_0._canQuickStartDizhuMatch: userId=",
userId, "roomId=", roomId, "quickMatchToggle=",
quickMatchToggle)
if quickMatchToggle == 0:
return False
# 获取选择比赛快开的条件列表
coin_toplimit = roomconf.get("quickMatchCoinTopLimit", 0)
# 获得用户的coin
chip = userchip.getChip(userId)
ftlog.debug("DizhuQuickStartV4_0._canQuickStartDizhuMatch: userId=",
userId, "roomId=", roomId, "chip=", chip, "coin_toplimit",
coin_toplimit)
# 直接去比赛，不判断金币
if playMode == dizhuconf.PLAYMODE_STRAIGHT_MATCH:
return True
if chip < coin_toplimit:
return True
return False
def _do_http_gm_playing_table_list(self, gameId, httpRequest, httpArgs, httpResult):
'''获取某个房间正在玩的牌桌列表'''
bigRoomId = int(httpArgs['bigRoomId'])
ctrlRoomIds = gdata.bigRoomidsMap()[bigRoomId]
playingTableList = []
for ctrlRoomId in ctrlRoomIds:
roomDef = gdata.roomIdDefineMap()[ctrlRoomId]
for shadowRoomId in roomDef.shadowRoomIds:
msg = utils.updateMsg(cmd='table', params={
'action': 'gm',
'sa': 'playingTableList',
'gameId': gameId,
'roomId': shadowRoomId,
'tableId': shadowRoomId * 10000 + 1,
})
ret = router.queryTableServer(msg, shadowRoomId)
ftlog.debug('_do_http_gm_playing_table_list| shadowRoomId, ret:', shadowRoomId, ret)
playingTableList += strutil.loads(ret)['result']['playingTableList']
httpResult['playingTableList'] = playingTableList
def buildMatch(cls, conf, room):
ctrlRoomIdList = gdata.bigRoomidsMap().get(room.bigRoomId, [])
if conf.start.isUserCountType():
conf.start.userMaxCountPerMatch = conf.start.userMaxCount
conf.start.signinMaxCount = conf.start.signinMaxCount
else:
conf.start.userMaxCountPerMatch = int(conf.start.userMaxCount /
max(len(ctrlRoomIdList), 1))
conf.start.signinMaxCountPerMatch = int(
conf.start.signinMaxCount / max(len(ctrlRoomIdList), 1))
master = MatchMaster(room, conf)
master.matchStatusDao = MatchStatusDaoRedis(room)
master.matchFactory = ErdayiMatchFactory()
area = MatchAreaLocal(master, room, conf)
master.addArea(area)
if conf.matchId3:
cls.checkMatchingSequence(room, conf.matchId3)
ftlog.info('ErdayiMatch.buildMatch roomId=', room.roomId,
'ctrlRoomIdList=', ctrlRoomIdList, 'ctrlRoomCount=',
len(ctrlRoomIdList), 'userMaxCount=',
conf.start.userMaxCount, 'userMaxCountPerMatch=',
conf.start.userMaxCountPerMatch, 'signinMaxCount=',
conf.start.signinMaxCount, 'signinMaxCountPerMatch=',
conf.start.signinMaxCountPerMatch)
master.matchStatusDao = MatchStatusDaoRedis(room)
area.signinRecordDao = SigninRecordDaoRedis(room.gameId)
area.tableController = TableControllerErdayi(area)
area.playerNotifier = PlayerNotifierErday(room)
area.matchRewards = MatchRewardsErdayi(room)
area.matchUserIF = MatchUserIFErdayi(room, conf.tableId, conf.seatId)
area.signerInfoLoader = SignerInfoLoaderErdayi()
area.matchFactory = ErdayiMatchFactory()
area.signinFee = SigninFeeErdayi(room)
return area, master
def _communicateTableServer(userId, roomId, msgpack, head1, isQuery, timeout=None, notimeoutex=0):
if timeout == None:
timeout = _runenv._RPC_TIME_OUT
assert (isinstance(msgpack, (MsgPack, basestring)))
assert (isinstance(roomId, (int, long)) and roomId >= 0)
assert (isinstance(userId, (int, long)) and userId >= 0)
allrooms = gdata.roomIdDefineMap()
if roomId in allrooms:
roomDef = allrooms[roomId]
if roomDef.parentId == 0:
ftlog.warn('ERROR, cat not localtion the roomId of->', userId, roomId, msgpack)
return
else: # this roomId is big roomId
assert (isinstance(userId, (int, long)) and userId >= 0)
bigrooms = gdata.bigRoomidsMap()
if roomId in bigrooms:
msgpack, shadowRoomId = __getRoomIdByTableId(msgpack)
ftlog.debug('_communicateTableServer allrooms = ', allrooms, 'shadowRoomId =', shadowRoomId)
if shadowRoomId:
roomDef = allrooms[shadowRoomId]
else:
ftlog.warn('ERROR, cat not localtion the roomId of->', userId, roomId, msgpack)
return
else:
ftlog.warn('ERROR, cat not localtion the roomId of->', userId, roomId, msgpack)
return
if isinstance(msgpack, MsgPack):
msgpack = msgpack.pack()
dst = roomDef.serverId
ftlog.debug('_communicateTableServer->dst=', dst, 'head1=', head1, 'roomId=', str(roomId), 'timeout=', timeout,
'msgpack=[' + msgpack + ']')
if isQuery:
response = wrapper.query(dst, msgpack, head1, str(roomId), timeout, notimeoutex=notimeoutex)
ftlog.debug('_communicateTableServer->dst=', dst, 'head1=', head1, 'roomId=', str(roomId),
'response=[' + str(response) + ']')
return response
else:
return wrapper.send(dst, msgpack, head1, str(roomId))
def buildMatch(self):
ctrlRoomIdList = gdata.bigRoomidsMap().get(self.bigRoomId, [])
if self.conf.start.isUserCountType():
self.conf.start.userMaxCountPerMatch = self.conf.start.userMaxCount
self.conf.start.signinMaxCount = self.conf.start.signinMaxCount
else:
self.conf.start.userMaxCountPerMatch = int(
self.conf.start.userMaxCount / max(len(ctrlRoomIdList), 1))
self.conf.start.signinMaxCountPerMatch = int(
self.conf.start.signinMaxCount / max(len(ctrlRoomIdList), 1))
master = MatchMaster(self, self.conf)
master.matchStatusDao = MatchStatusDaoRedis(self)
master.matchFactory = ErdayiMatchFactory()
area = MatchAreaLocal(master, self, self.conf)
master.addArea(area)
if self.conf.matchId3:
self.checkMatchingSequence(self, self.conf.matchId3)
ftlog.info('DizhuErdayiMatchCtrlRoom.buildMatch roomId=', self.roomId,
'ctrlRoomIdList=', ctrlRoomIdList, 'ctrlRoomCount=',
len(ctrlRoomIdList), 'userMaxCount=',
self.conf.start.userMaxCount, 'userMaxCountPerMatch=',
self.conf.start.userMaxCountPerMatch, 'signinMaxCount=',
self.conf.start.signinMaxCount, 'signinMaxCountPerMatch=',
self.conf.start.signinMaxCountPerMatch)
area.signinRecordDao = SigninRecordDaoRedis(self.gameId)
area.tableController = TableControllerErdayi(area)
area.playerNotifier = PlayerNotifierErday(self)
area.matchRewards = MatchRewardsErdayi(self)
area.matchUserIF = MatchUserIFErdayi(self, self.conf.tableId,
self.conf.seatId)
area.signerInfoLoader = SignerInfoLoaderErdayi()
area.matchFactory = ErdayiMatchFactory()
area.signinFee = SigninFeeErdayi(self)
return area, master
def _chooseDizhuMatchRoom(cls, userId, gameId, playMode):
'''
地主专属，选择一个比赛场返回
@return1 roomid{int}: 比赛房间的ID
@return2 ok{Bool}: 是否成功匹配到房间
'''
if gameId != 6:
return 0, False
#1.获取所有符合条件的比赛场
ctrlroomid_list = cls._getDizhuMatchCandidateRoomIds()
ftlog.debug('DizhuQuickStartV4_0._chooseDizhuMatchRoom: userId=',
userId, 'ctrlroomid_list=', ctrlroomid_list)
#2.选快开比赛房间
for roomid in ctrlroomid_list:
ok = cls._canQuickStartDizhuMatch(userId, gameId, roomid, playMode)
if ok == True:
ftlog.debug(
"DizhuQuickStartV4_0._chooseDizhuMatchRoom: before userId=",
userId, "roomid=", roomid)
bigRoomId = gdata.getBigRoomId(roomid)
if bigRoomId == 0:
break
ctrRoomIds = gdata.bigRoomidsMap()[bigRoomId]
ctrlRoomId = ctrRoomIds[userId % len(ctrRoomIds)]
ftlog.debug(
"DizhuQuickStartV4_0._chooseDizhuMatchRoom: after userId=",
userId, "roomid=", roomid, "bigRoomId=", bigRoomId,
'ctrlRoomId=', ctrlRoomId)
return ctrlRoomId, True
ftlog.debug('DizhuQuickStartV4_0._chooseDizhuMatchRoom->exit', 0,
False, "userId=", userId)
return 0, False
def _communicateRoomServer(userId, roomId, msgpack, head1, isQuery, timeout=None, notimeoutex=0):
if timeout == None:
timeout = _runenv._RPC_TIME_OUT
assert (isinstance(msgpack, (MsgPack, basestring)))
assert (isinstance(roomId, (int, long)) and roomId >= 0)
allrooms = gdata.roomIdDefineMap()
if roomId in allrooms:
roomDef = allrooms[roomId]
if roomDef.parentId > 0: # this roomId is shadowRoomId
ctrlRoomId = roomDef.parentId
roomDef = allrooms[ctrlRoomId]
msgpack = __changeMsgRoomId(msgpack, ctrlRoomId, roomId)
else: # this roomId is big roomId
assert (isinstance(userId, (int, long)) and userId >= 0)
bigrooms = gdata.bigRoomidsMap()
if roomId in bigrooms:
ctrlroomIds = bigrooms[roomId]
ctrlRoomId = ctrlroomIds[userId % len(ctrlroomIds)] # ctrlRoom0 做为 ctrlRooms 的调度器
roomDef = allrooms[ctrlRoomId]
msgpack = __changeMsgRoomId(msgpack, ctrlRoomId, roomId)
else:
ftlog.warn('ERROR, cat not localtion the roomId of->', userId, roomId, msgpack)
return
if isinstance(msgpack, MsgPack):
msgpack = msgpack.pack()
dst = roomDef.serverId
ftlog.debug('_communicateRoomServer->dst=', dst, 'head1=', head1, 'roomId=', str(roomId), 'timeout=', timeout,
'msgpack=[' + msgpack + ']')
if isQuery:
response = wrapper.query(dst, msgpack, head1, str(roomId), timeout, notimeoutex=notimeoutex)
ftlog.debug('_communicateRoomServer->dst=', dst, 'head1=', head1, 'roomId=', str(roomId),
'response=[' + str(response) + ']')
return response
else:
return wrapper.send(dst, msgpack, head1, str(roomId))
def getMasterRoomId(self):
if self.conf.start.isUserCountType():
return self.roomId
ctrlRoomIdList = sorted(gdata.bigRoomidsMap().get(self.bigRoomId, []))
return ctrlRoomIdList[0]
def _check_param_bigRoomId(self, msg, key, params):
roomId = msg.getParam('roomId')
if roomId in gdata.bigRoomidsMap():
return None, roomId
return 'ERROR of big roomId !' + str(roomId), None
def getMasterRoomId(cls, conf, room):
if conf.start.isUserCountType():
return room.roomId
ctrlRoomIdList = sorted(gdata.bigRoomidsMap().get(room.bigRoomId, []))
return ctrlRoomIdList[0]
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 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 _check_param_bigRoomId(self, msg, key, params):
roomId = msg.getParam('roomId')
if roomId in gdata.bigRoomidsMap():
return None, roomId
return 'ERROR of big roomId !' + str(roomId), None
def _quickStart(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
mixId = msg.getParam('mixId', '')
_, version, _ = strutil.parseClientId(clientId)
if ftlog.is_debug():
ftlog.debug("DizhuQuickStart._quickStart: clientId=", clientId,
"userId=", userId, "roomId=", roomId, "tableId=",
tableId, "mixId=", mixId, "version=", version, "type:",
type(version), "playMode=", playMode)
if playMode == "match":
playMode = dizhuconf.PLAYMODE_123
if ftlog.is_debug():
ftlog.debug("DizhuQuickStart << |clientId:",
clientId,
"mixId:",
mixId,
"|userId, roomId, tableId:",
userId,
roomId,
tableId,
"|gameId, playMode:",
gameId,
playMode,
caller=cls)
bigRoomId = gdata.getBigRoomId(roomId)
if ftlog.is_debug():
ftlog.debug('DizhuQuickStart bigRoomId:', bigRoomId)
if bigRoomId == 0:
cls._onEnterRoomFailed(msg, ENTER_ROOM_REASON_ROOM_ID_ERROR, userId,
clientId, roomId)
return
if strutil.getGameIdFromBigRoomId(bigRoomId) != gameId:
cls._onEnterRoomFailed(msg, ENTER_ROOM_REASON_ROOM_ID_ERROR, userId,
clientId, roomId)
return
if tableId == 0: # 玩家只选择了房间
if roomId != bigRoomId:
ctrlRoomId = gdata.roomIdDefineMap()[roomId].parentId or roomId
queryRoomId = roomId
else:
ctrRoomIds = gdata.bigRoomidsMap()[bigRoomId]
ctrlRoomId = ctrRoomIds[userId % len(ctrRoomIds)]
queryRoomId = ctrlRoomId
buyin = msg.getParam("buyin", 0) # 兼容 pc
innerTable = msg.getParam("innerTable", 0) # innerTable 区分不同版本弹窗
if ftlog.is_debug():
ftlog.debug('DizhuQuickStart._quickStart', 'buyin=', buyin,
'innerTable=', innerTable, 'mixId=', mixId)
if buyin:
innerTable = 1
roomdef = gdata.roomIdDefineMap()[ctrlRoomId]
roomConf = roomdef.configure
# 免费场重起maxCoin配置
maxCoin = roomConf.get('maxCoin', 0)
userChip = userchip.getChip(userId)
if maxCoin > 0 and userChip >= maxCoin and innerTable == 0:
cls._onEnterRoomFailed(msg, ENTER_ROOM_REASON_GREATER_MAX, userId,
clientId, roomId)
return
# 混房的话从大到小选择一个mixId
if roomConf.get('isMix') and not mixId:
_, _, mixId = cls._chooseRoom(userId, [ctrlRoomId])
if mixId:
msg.setParam('mixId', mixId)
else:
msg.setParam('mixId', roomConf.get('mixConf')[0].get('mixId'))
if innerTable == 0:
cls._onEnterRoomFailed(msg, ENTER_ROOM_REASON_LESS_MIN,
userId, clientId, roomId)
else:
mixConf = cls.getMixConf(
roomConf,
roomConf.get('mixConf')[0].get('mixId'))
new_table_remote.processLoseRoundOver(
DIZHU_GAMEID,
userId,
clientId,
mixConf.get('roomId'),
minCoin=mixConf.get('minCoin'))
return
reasonType, reason = cls._canQuickEnterRoom(userId, ctrlRoomId,
innerTable, mixId)
if reason == ENTER_ROOM_REASON_OK:
TYRoomMixin.queryRoomQuickStartReq(msg, queryRoomId,
0) # 请求转给GR或GT
else:
if reasonType == ENTER_ROOM_REASON_TYPE_NORMAL:
if reason == ENTER_ROOM_REASON_NOT_OPEN and innerTable == 1:
if ftlog.is_debug():
ftlog.debug(
'DizhuQuickStart._quickStart not open userId=',
userId, 'roomId=', ctrlRoomId, 'msg=', msg,
'playmode=', playMode)
# 直接踢出房间
mp = MsgPack()
mp.setCmd('room')
mp.setParam('action', 'leave')
mp.setParam('reason', TYRoom.LEAVE_ROOM_REASON_ACTIVE)
mp.setParam('gameId', gameId)
mp.setParam('roomId', roomId)
mp.setParam('userId', userId)
router.sendRoomServer(mp, roomId)
return
if reason == ENTER_ROOM_REASON_LESS_MIN or reason == ENTER_ROOM_REASON_GREATER_MAX:
if innerTable == 1:
ctrRoomIds = gdata.bigRoomidsMap()[bigRoomId]
ctrlRoomId = ctrRoomIds[userId % len(ctrRoomIds)]
if roomdef.configure.get('isMix', 0):
continueLuckyGift = cls.getMixConf(
roomdef.configure,
mixId).get('continueLuckyGift', 0)
continueLuckyVer = cls.getMixConf(
roomdef.configure,
mixId).get('continueLuckyVer', 0)
else:
continueLuckyGift = roomdef.configure.get(
'continueLuckyGift', 0)
continueLuckyVer = roomdef.configure.get(
'continueLuckyVer', 0)
dizhuVersion = SessionDizhuVersion.getVersionNumber(
userId)
if continueLuckyGift and dizhuVersion >= continueLuckyVer:
# 发送转运礼包
if ftlog.is_debug():
ftlog.debug(
'DizhuQuickStart._quickStart _less_min userId=',
userId, 'roomId=', ctrlRoomId, 'msg=', msg,
'playmode=', playMode,
'continueLuckyGift=', continueLuckyGift,
'continueLuckyVer=', continueLuckyVer,
'dizhuVersion=', dizhuVersion)
if mixId and roomConf.get('isMix'):
mixConf = cls.getMixConf(roomConf, mixId)
new_table_remote.processLoseRoundOver(
DIZHU_GAMEID,
userId,
clientId,
mixConf.get('roomId'),
minCoin=mixConf.get('minCoin'))
else:
new_table_remote.processLoseRoundOver(
DIZHU_GAMEID, userId, clientId, roomId)
else:
roomDef = gdata.roomIdDefineMap()[ctrlRoomId]
playMode = roomDef.configure.get('playMode', None)
if ftlog.is_debug():
ftlog.debug(
'DizhuQuickStart._quickStart _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(
'DizhuQuickStart._quickStart 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._sendTodoTaskToUserWithTip(userId, reason)
return
if tableId == roomId * 10000: # 玩家在队列里断线重连
TYRoomMixin.queryRoomQuickStartReq(msg, roomId, tableId) # 请求转给GR
return
onlineSeat = onlinedata.getOnlineLocSeatId(userId, roomId, tableId)
if onlineSeat:
# 牌桌里坐着的玩家断线重连，请求转给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
return
def _onEnterRoomFailed(cls, msg, checkResult, userId, clientId, roomId=0):
# PC的补丁，需要返回一个失败的quick_start消息
mixId = msg.getParam('mixId')
# mo = MsgPack()
# mo.setCmd('quick_start')
# mo.setResult('gameId', DIZHU_GAMEID)
# mo.setResult('userId', userId)
# mo.setResult('roomId', 0)
# mo.setResult('seatId', 0)
# mo.setResult('tableId', 0)
# router.sendToUser(mo, userId)
if checkResult == ENTER_ROOM_REASON_CONFLICT:
cls._sendTodoTaskToUser(userId, checkResult)
elif checkResult == ENTER_ROOM_REASON_INNER_ERROR:
cls._sendTodoTaskToUser(userId, checkResult)
elif checkResult == ENTER_ROOM_REASON_QUIT_ROOM_ERROR:
cls._sendTodoTaskToUser(userId, checkResult)
elif checkResult == ENTER_ROOM_REASON_ROOM_FULL:
cls._sendTodoTaskToUser(userId, checkResult)
elif checkResult == ENTER_ROOM_REASON_LESS_MIN:
innerTable = msg.getParam("innerTable", 0)
if ftlog.is_debug():
ftlog.debug('DizhuQuickStart enter_less_min msg=', msg, 'innerTable=', innerTable)
if innerTable == 1:
return cls._sendToDoTaskJumpToStore(userId)
if roomId <= 0:
roomId = msg.getParam('roomId')
if not roomId:
roomId = msg.getParam('candidateRoomId')
if not roomId:
return
cls._sendTodoTaskBuyChip(userId, roomId, clientId, mixId)
# cls._sendChargeLeadTodoTask(userId, roomId, clientId)
elif checkResult == ENTER_ROOM_REASON_GREATER_MAX:
playMode = msg.getParam('playMode')
if not playMode:
# 找到当前要进入的房间的玩法
if roomId <= 0:
roomId = msg.getParam('roomId')
if not roomId:
roomId = msg.getParam('candidateRoomId')
if roomId > 0:
if roomId in gdata.roomIdDefineMap():
playMode = gdata.roomIdDefineMap()[roomId].configure.get('playMode', None)
elif roomId in gdata.bigRoomidsMap():
roomId = gdata.bigRoomidsMap()[roomId][0]
playMode = gdata.roomIdDefineMap()[roomId].configure.get('playMode', None)
cls._sendTodoTaskJumpHighRoom(userId, playMode, clientId)
elif checkResult == ENTER_ROOM_REASON_GREATER_ALL:
cls._sendTodoTaskToUser(userId, checkResult)
elif checkResult == ENTER_ROOM_REASON_TABLE_FULL:
cls._sendTodoTaskToUser(userId, checkResult)
elif checkResult == ENTER_ROOM_REASON_WRONG_TIME:
cls._sendTodoTaskToUser(userId, checkResult)
elif checkResult == ENTER_ROOM_REASON_NOT_QUALIFIED:
cls._sendTodoTaskToUser(userId, checkResult)
elif checkResult == ENTER_ROOM_REASON_ROOM_ID_ERROR:
cls._sendTodoTaskToUser(userId, checkResult)
elif checkResult == ENTER_ROOM_REASON_DASHIFEI_LEVEL:
if cls._sendTodoTaskToUserWithRoomKey(userId, roomId, msg, "vipOrDashifenTip"):
return
cls._sendTodoTaskToUser(userId, checkResult)
elif checkResult == ENTER_ROOM_REASON_NOT_OPEN:
if cls._sendTodoTaskToUserWithRoomKey(userId, roomId, msg, "openTimeListTip"):
return
cls._sendTodoTaskToUser(userId, checkResult)
elif checkResult == ENTER_ROOM_REASON_VIP_LEVEL:
if cls._sendTodoTaskToUserWithRoomKey(userId, roomId, msg, "vipOrDashifenTip"):
return
cls._sendTodoTaskToUser(userId, checkResult)
elif checkResult == ENTER_ROOM_REASON_LESS_MIN_QUICKSTART:
cls._sendTodoTaskBuyChip(userId, roomId, clientId, mixId)
else: # TYRoom.ENTER_ROOM_REASON_INNER_ERROR :
cls._sendTodoTaskToUser(userId, ENTER_ROOM_REASON_INNER_ERROR)
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, 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 _updateRoomDefine(keylist, sleepTime):
import json
from poker.entity.game import quick_start
isall = 1 if len(keylist) == 1 and keylist[0] == 'all' else 0
if _DEBUG:
debug('_syncConfigure._updateRoomDefine-> in', keylist)
_sleepnb(sleepTime)
keylist = set(keylist)
changedGameIds = []
changedBigRoomIds = []
for gid, bigRoomIds in gdata.gameIdBigRoomidsMap().items():
rkey = 'game:' + str(gid) + ':room:0'
if isall or rkey in keylist:
changedGameIds.append([rkey, gid])
for bigRoomId in bigRoomIds:
rkey = 'game:' + str(gid) + ':room:' + str(bigRoomId)
if isall or rkey in keylist:
changedBigRoomIds.append([rkey, bigRoomId])
changeRoomIds = set([])
for changed in changedGameIds:
rkey = changed[0]
gid = changed[1]
if _DEBUG:
debug('_syncConfigure._updateRoomDefine-> reload roomdef', rkey)
roomdict = ftcon.getConfNoCache('GET', rkey)
if roomdict:
roomdict = json.loads(roomdict)
if not isinstance(roomdict, dict):
continue
for roomIdStr, configure in roomdict.items():
bigRoomId = int(roomIdStr)
# 所有BIGROOMID下的configure是同一个对象，update第一个即可
roomid0 = gdata.bigRoomidsMap()[bigRoomId][0]
room0 = gdata.roomIdDefineMap()[roomid0]
room0.configure.update(configure)
changeRoomIds.add(bigRoomId)
if _DEBUG:
debug(
'_syncConfigure._updateRoomDefine-> reload roomdef by 0.json',
bigRoomId)
_sleepnb(sleepTime)
for changed in changedBigRoomIds:
rkey = changed[0]
bigRoomId = changed[1]
if _DEBUG:
debug('_syncConfigure._updateRoomDefine-> reload roomdef', rkey)
extdict = ftcon.getConfNoCache('GET', rkey)
if extdict:
extdict = json.loads(extdict)
if not isinstance(extdict, dict):
continue
# 所有BIGROOMID下的configure是同一个对象，update第一个即可
roomid0 = gdata.bigRoomidsMap()[bigRoomId][0]
room0 = gdata.roomIdDefineMap()[roomid0]
room0.configure.update(extdict)
changeRoomIds.add(bigRoomId)
if _DEBUG:
debug(
'_syncConfigure._updateRoomDefine-> reload roomdef by ' +
str(bigRoomId) + '.json', bigRoomId)
_sleepnb(sleepTime)
if changeRoomIds:
for _, roomIns in gdata.rooms().items():
if roomIns.bigRoomId in changeRoomIds:
if _DEBUG:
debug('_syncConfigure._updateRoomDefine-> reload roomins',
roomIns.roomId)
rdef = gdata.roomIdDefineMap().get(roomIns.roomId)
roomIns.doReloadConf(rdef)
_sleepnb(sleepTime)
quick_start._CANDIDATE_ROOM_IDS = {}
_sleepnb(sleepTime)
if _DEBUG:
debug('_syncConfigure._updateRoomDefine-> out')
def _updateRoomDefine(keylist, sleepTime):
import json
from poker.entity.game import quick_start
isall = 1 if len(keylist) == 1 and keylist[0] == 'all' else 0
if _DEBUG:
debug('_syncConfigure._updateRoomDefine-> in', keylist)
_sleepnb(sleepTime)
keylist = set(keylist)
changedGameIds = []
changedBigRoomIds = []
for gid, bigRoomIds in gdata.gameIdBigRoomidsMap().items():
rkey = 'game:' + str(gid) + ':room:0'
if isall or rkey in keylist:
changedGameIds.append([rkey, gid])
for bigRoomId in bigRoomIds:
rkey = 'game:' + str(gid) + ':room:' + str(bigRoomId)
if isall or rkey in keylist:
changedBigRoomIds.append([rkey, bigRoomId])
changeRoomIds = set([])
for changed in changedGameIds:
rkey = changed[0]
gid = changed[1]
if _DEBUG:
debug('_syncConfigure._updateRoomDefine-> reload roomdef', rkey)
roomdict = ftcon.getConfNoCache('GET', rkey)
if roomdict:
roomdict = json.loads(roomdict)
if not isinstance(roomdict, dict):
continue
for roomIdStr, configure in roomdict.items():
bigRoomId = int(roomIdStr)
# 所有BIGROOMID下的configure是同一个对象，update第一个即可
roomid0 = gdata.bigRoomidsMap()[bigRoomId][0]
room0 = gdata.roomIdDefineMap()[roomid0]
room0.configure.update(configure)
changeRoomIds.add(bigRoomId)
if _DEBUG:
debug('_syncConfigure._updateRoomDefine-> reload roomdef by 0.json', bigRoomId)
_sleepnb(sleepTime)
for changed in changedBigRoomIds:
rkey = changed[0]
bigRoomId = changed[1]
if _DEBUG:
debug('_syncConfigure._updateRoomDefine-> reload roomdef', rkey)
extdict = ftcon.getConfNoCache('GET', rkey)
if extdict:
extdict = json.loads(extdict)
if not isinstance(extdict, dict):
continue
# 所有BIGROOMID下的configure是同一个对象，update第一个即可
roomid0 = gdata.bigRoomidsMap()[bigRoomId][0]
room0 = gdata.roomIdDefineMap()[roomid0]
room0.configure.update(extdict)
changeRoomIds.add(bigRoomId)
if _DEBUG:
debug('_syncConfigure._updateRoomDefine-> reload roomdef by ' + str(bigRoomId) + '.json', bigRoomId)
_sleepnb(sleepTime)
if changeRoomIds:
for _, roomIns in gdata.rooms().items():
if roomIns.bigRoomId in changeRoomIds:
if _DEBUG:
debug('_syncConfigure._updateRoomDefine-> reload roomins', roomIns.roomId)
rdef = gdata.roomIdDefineMap().get(roomIns.roomId)
roomIns.doReloadConf(rdef)
_sleepnb(sleepTime)
quick_start._CANDIDATE_ROOM_IDS = {}
_sleepnb(sleepTime)
if _DEBUG:
debug('_syncConfigure._updateRoomDefine-> out')
def _getQueryRoomId(cls, userId, bigRoomId):
''' 获取 queryroomid '''
ctrRoomIds = gdata.bigRoomidsMap()[bigRoomId] # gr
return ctrRoomIds[userId % len(ctrRoomIds)]
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
