pc_tiantian/tiantian/mj_dazhou/luaScript/Protocol/dazhouProtocol.lua

local RoomCmd=MJFramework.MJImport("mj.luaScript.Protocol.MJCmd")
local MJMessage=MJFramework.MJImport("mj.luaScript.Protocol.MJMessage")
local MJDefine=MJFramework.MJImport("mj.luaScript.MJDefine")
local MJProtocol=MJFramework.MJFrameworkClassImprot("mj.luaScript.Protocol.MJProtocol")
local Room = class("dazhouRoom" , MJProtocol)

-- 视角转换
function Room:transPos(targetSeatId, seatId)
	local MaxCount = self.roomInfo.nMaxPlayCount
	local showPos = 4
    local target = targetSeatId
    if target <= seatId then
        showPos = seatId - target 
    elseif target > seatId then
        showPos = MaxCount - target + seatId
    end 
    return showPos
end

-- 根据uid获取座位号
function Room:getSeatIdByUserId( nUserId )
	return self:getSeatIdByViewId(self:getViewIdByUserId(nUserId))
end

-- 获取房间最大玩家人数
function Room:getMaxPlayerCount()
	return self.roomInfo.nMaxPlayCount
end

-- 获取房间人数
function Room:getPlayerCount()
	local count = 0
	for k,v in pairs(self.roomInfo.memberList) do
		count = count + 1 
	end
	return count
end

function Room:cleanTingStatus()
	local myUserId = app.user.loginInfo.uid
	if self.roomInfo.memberList[myUserId] and self.roomInfo.memberList[myUserId].nTingStatus then
		self.roomInfo.memberList[myUserId].nTingStatus = MJDefine.MJTingStatus.NoTing
	end
end

function Room:onTingCardResult( status, response )
	logD("Room:onTingCardResult(), ", table.tostring(response))
	print("--------onTingCardResult--------")
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	if not self:isCanTing() then
		return
	end
	
	self:dispatchEvent({name = MJDefine.MJEvent.TingResult,response = response})
end

function Room:onTingCardStatus(status, response)
	logD("Room:onTingCardStatus(), ", table.tostring(response))
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end

	local myUserId = app.user.loginInfo.uid
	self.roomInfo.memberList[myUserId].nTingStatus=response.nTingStatus

	if not self:isCanTing() then
		return
	end

	self:dispatchEvent({name = MJDefine.MJEvent.TingSatus})
end

-- 游戏发牌结果
function Room:onGameSendCardResponse(status, response)
	logD("-------------------- 游戏发牌 ------------------------")
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	
	logD("Room:onGameSendCardResponse(), ", table.tostring(response))
	
	-- self.roomInfo.nbankFirstGrabCard = response.nbankFirstGrabCard
	
	--目前server只发自己过来，后续战绩回放考虑到会发所有玩家来，故以userid为key于扩展
	-- local cardData = self:serverCardToMyCard(response.cardList)
	-- logD("Room:onGameSendCardResponse : "..table.tostring(cardData))
	for k,v in pairs(response.playerCards) do
		self.roomInfo.memberList[v.nUserId].handCards = v.handCards
		self.roomInfo.memberList[v.nUserId].isBaoPai = v.isTing
		logD("------isBaoPai= ",self.roomInfo.memberList[v.nUserId].isBaoPai)
		--[[if v.isTing == 1 then
			self.roomInfo.memberList[v.nUserId].isBaoPai = 1
		end--]]
	end
	
	-- self.cards[response.nUserId] = cardData
	
	-- 发送广播通知，发牌开始了
	self:dispatchEvent({name = MJDefine.MJEvent.GameSendCardResponse});
end

function Room:onBankerOutCard(status, response)
	logD("-------------------- 游戏庄家起手操作------------------------")
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	self.roomInfo.nLeaveCardNum     = response.nLeaveCardNum
	self.roomInfo.needOutCardId     = response.nUserId

	--logD("Room:onBankerOutCard(), ", table.tostring(response))
	local  myUserId = self:getMyUserId()
	self.roomInfo.tings={}
	if response.nUserId==myUserId then		
		-- for k,v in pairs(response.pushCardTing) do
		-- 	self.roomInfo.tings[v.outCard]=v.tingCards.Datas
		-- end

		if self:isCanTing() then
			self.roomInfo.tings = response.pushCardTing
		end

		--这里自己摸牌后，不隐藏听牌提示
		--self.roomInfo.memberList[myUserId].nTingStatus=MJDefine.MJTingStatus.NoTing
		-- dump(self.roomInfo.memberList[myUserId])
		--self:dispatchEvent({name = MJDefine.MJEvent.TingSatus})
	end
	
	-- 发送广播通知，游戏开始了
	self:dispatchEvent({name = MJDefine.MJEvent.BankerOutCard ,response = response});	
end

function Room:onAfterDingQue(status, response)
	logD("-------------------- onAfterDingQue------------------------")
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	self.roomInfo.nLeaveCardNum     = response.nLeaveCardNum
	self.roomInfo.needOutCardId     = response.nUserId

	local myUserId = self:getMyUserId()
	self.roomInfo.tings={}
	if response.nUserId==myUserId then	
		if self:isCanTing() then	
			self.roomInfo.tings = response.pushCardTing
		end
	end
	-- 发送广播通知，游戏开始了
	self:dispatchEvent({name = MJDefine.MJEvent.AfterDingQue ,response = response});	
end

function Room:onBaoPai(status,response)
	logD("-------------------- 广播爆牌 ------------------------")
	if not self.roomInfo then
		print("容错处理")
		return
	end
	local  myUserId = self:getMyUserId()
	if response.nUserId == myUserId  then
		self.roomInfo.memberList[myUserId].isBaoPai = response.isBaoPai
	end
	logD("luzhouRoom:onBaoPai(), response = ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.BaoPaiResponse ,response = response});	
end

function Room:onBankerBaoPai(status,response)
	logD("-------------------- 通知庄家爆牌 ------------------------")
	if not self.roomInfo then
		print("容错处理")
		return
	end
	logD("luzhouRoom:onBankerBaoPai(), response = ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.BankerBaoPai ,response = response});
end

--断线重连
function Room:onGameReconnection(status,response)
	logD("===============重连成功，清空之前所有存在的队列==================")
	
	app.net:onMsgClear()
	app.net:onMsgPause()
	logD("Room:onGameReconnection(), response = ", table.tostring(response))
	self:initRoomInfo();
	
	-- 获取到的房间信息
	self.roomInfo.shuffleNum = response.shuffleNum
	self.roomInfo.gameId = response.gameId
	self.roomInfo.nShowTableId 		= response.nShowTableId
	self.roomInfo.nMaxPlayCount 		= response.nMaxPlayCount
	self.roomInfo.nRoomOwnedUid 		= response.nRoomOwnedUid
	self.roomInfo.nTotalGameNum 		= response.nTotalGameNum
	self.roomInfo.nBaseChips 			= response.nBaseChips
	self.roomInfo.strGameInfo 			= response.strGameInfo
	self.roomInfo.nGameStartCount 			= response.nGameStartCount
	self.roomInfo.nStatus 		= response.nStatus
	self.roomInfo.nBankSeatId 		= response.nBankSeatId
	self.roomInfo.nMySeatId 		= response.nMySeatId
	self.roomInfo.bUserDisbandGame 		= response.bUserDisbandGame
	self.roomInfo.nDismissStateTime 			= response.nDismissStateTime
	self.roomInfo.leaveCards 			= response.leaveCards
	self.roomInfo.nLeaveCardNum         =  #self.roomInfo.leaveCards
	self.roomInfo.outCardUserId 			= response.outCardUserId
	self.roomInfo.outCardSeatId 		= response.outCardSeatId
	self.roomInfo.lastOpCard 			= response.lastOpCard
	--萝卜牌
	self.roomInfo.luoboCards 			= response.luoboCards

	self.roomInfo.operates 		= response.operates

	self.roomInfo.isNeedOutCard 			= response.isNeedOutCard
	self.roomInfo.needOutCardId  = response.needOutCardId
	--self.roomInfo.lastOutCard  = response.lastOutCard
	self.roomInfo.stopFlag 			= response.stopFlag
	self.roomInfo.playerInfos 			= response.playerInfos
	--胡牌玩家列表
	self.roomInfo.resultInfos 		= response.resultInfos
	self.roomInfo.opsCntMapString 	= response.opsCntMapString
	self.roomInfo.tingStatus = response.tingStatus==255 and 0 or 1 --服务器-1为没听 0为听

	self.roomInfo.tings = self:isCanTing() and response.tingCard or {}
	--杠信息
	self.roomInfo.ganginfo = response.opsCntMapString or ""
	--快速开局信息
	self.roomInfo.bUserFastStartGame = response.bUserFastStartGame--是否在快开始界面,1是0否
	self.roomInfo.leftFastStartGameTime = response.leftFastStartGameTime--当前快速开始等待时间
	self.roomInfo.pList = response.pList--快速开始状态
	
	if self.roomInfo.nGameStartCount > 0 then
        self.roomInfo.nMaxPlayCount = table.nums(response.playerInfos)
	end

	-- 桌子上其他玩家的信息
	for k,v in pairs(response.playerInfos) do
		self:setMemberInfo(v)
	
		self.dismissInfo[v.nUserId] = v.nDisbandStatus
		--这里只记录，暂时没用到。可能战绩回放的时候是需要用的
		-- local cardData = self:serverCardToMyCard(v.handCard)
		-- self.roomInfo.memberList[v.nUserId].cardList		= {}
		-- self.roomInfo.memberList[v.nUserId].cardList 		= cardData
	end
	--爆牌信息
	for k,v in pairs(response.playerBaoInfos) do
		--是否已爆牌
		self.roomInfo.memberList[v.nUserId].isBaoPai = v.isBaoPai
		--是否可以爆牌
		self.roomInfo.memberList[v.nUserId].canBaoPai = v.canBaoPai
	end
	
	local myUserId = self:getMyUserId();
	self.roomInfo.memberList[myUserId].nTingStatus = response.tingStatus;

	--结算信息
	for k,v in pairs(response.resultInfos) do
		--胡牌者的用户id
		self.roomInfo.memberList[v.nUserId].nUserId=v.nUserId
		--1胡牌  2听叫   0默认
		self.roomInfo.memberList[v.nUserId].userStatus = v.userStatus
		--玩家本局输赢情况 0不胡不输 1胡，2点炮或者输
		self.roomInfo.memberList[v.nUserId].result=v.result
		-- 胡牌牌类型-7对胡、平胡，0为输或者不胡不输
		self.roomInfo.memberList[v.nUserId].huType=v.huType
		--胡的牌
		self.roomInfo.memberList[v.nUserId].huCard=v.huCard
		--胡牌顺序
		self.roomInfo.memberList[v.nUserId].huOrder=v.huOrder
		--谁点的炮
		self.roomInfo.memberList[v.nUserId].dpSeatId=v.dpSeatId
		--根次数
		self.roomInfo.memberList[v.nUserId].genCount=v.genCount
		
		--子胡牌类型（天胡、地胡等）
		self.roomInfo.memberList[v.nUserId].subPaiType = v.subPaiType
		--是否绝张
		self.roomInfo.memberList[v.nUserId].isJueZhang = v.isJueZhang or 0
		--是否金钩钓
		self.roomInfo.memberList[v.nUserId].isJinGouDiao = v.isJinGouDiao or 0
		--是否海底捞月
		self.roomInfo.memberList[v.nUserId].isHaiDiLaoYue = v.isHaiDiLaoYue or 0
		--是否海底炮
		self.roomInfo.memberList[v.nUserId].isHaiDiPao = v.isHaiDiPao or 0
		--是否杠上开花
		self.roomInfo.memberList[v.nUserId].isGangShangKaiHua = v.isGangShangKaiHua or 0
		--是否杠上炮
		self.roomInfo.memberList[v.nUserId].isGangShangPao = v.isGangShangPao or 0
		--是否抢杠胡
		self.roomInfo.memberList[v.nUserId].isQiangGangHu = v.isQiangGangHu or 0
		--是否门清
		self.roomInfo.memberList[v.nUserId].isMenQing = v.isMenQing or 0
		--是否中张
		self.roomInfo.memberList[v.nUserId].isZhongZhang = v.isZhongZhang or 0
		--是否死叫
		self.roomInfo.memberList[v.nUserId].isSiJiao = v.isSiJiao or 0
		--重连胡牌着，胡的牌也在手中，需要删掉
		local isDeleted = false
		if self.roomInfo.memberList[v.nUserId].result > 0 then--胡牌了
			for i,t in pairs(self.roomInfo.memberList[v.nUserId].handCards) do
				if t.card == v.huCard then
					table.remove(self.roomInfo.memberList[v.nUserId].handCards.Datas,i)
					isDeleted = true
					break
				end
			end
			--table.removeItem(self.roomInfo.memberList[v.nUserId].handCards,self.roomInfo.memberList[v.nUserId].huCard)
			if not isDeleted then
				table.remove(self.roomInfo.memberList[v.nUserId].handCards.Datas,1)
			end
		end
	end
	
	self:addExtendData(response)
	
	local extInfo = json.decode(response.extJson or "")
	local uid = self:getMyUserId()
	if extInfo and type(extInfo) == 'table' then
		--local myInfo = extInfo[tostring(uid)]
		--self.roomInfo.hosting = myInfo.hosted or 0--托管状态
		self.roomInfo.quickStartInfo = extInfo.faststart

		if extInfo.offlinetime then
			for nUserId,offlinetime in pairs(extInfo.offlinetime) do
				self.roomInfo.memberList[tonumber(nUserId)].offlinetime = offlinetime or 0
			end
		end
	end
	
	--更新自己的数据
	-- local myUserId = app.user.loginInfo.uid
	-- self.cards[myUserId] = self.roomInfo.memberList[myUserId].handCards
	
	print("self.cards[myUserId]:"..table.tostring(self.cards[myUserId]))
	
	-- 更新椅子号
	self:updateUserSeateShowId()
	local jsonInfo = json.decode(self.roomInfo.strGameInfo)
	-- 发送通知
	self:dispatchEvent({name = MJDefine.MJEvent.EnterRoomSuccess, gameId = self.roomInfo.gameId or app.gameId, gameType = jsonInfo.gamerule})
end

function Room:addExtendData(response)
	
end

function Room:setMemberInfo(v)
	Room.super.setMemberInfo(self,v)
	self.roomInfo.memberList[v.nUserId].nTurnScore      = self:isUseDivision10() and v.nTurnScore/10 or v.nTurnScore
	self.roomInfo.memberList[v.nUserId].nTotalMoney 	= self:isUseDivision10() and v.nTotalMoney/10 or v.nTotalMoney
	self.roomInfo.memberList[v.nUserId].fanshu = v.fanshu
	--是否大叫
	self.roomInfo.memberList[v.nUserId].isDj = v.isDj
	--是否花猪
	self.roomInfo.memberList[v.nUserId].isHz = v.isHz
	--点炮次数
	self.roomInfo.memberList[v.nUserId].dpCount = v.dpCount
	--点炮顺序
	self.roomInfo.memberList[v.nUserId].dpOrder = v.dpOrder
	
	self.roomInfo.memberList[v.nUserId].result = v.result or 0
	self.roomInfo.memberList[v.nUserId].huType = v.huType or 0
	
	--是否换过牌
	self.roomInfo.memberList[v.nUserId].isSwapCard = v.isSwapCard or 0
	--是否定缺
	self.roomInfo.memberList[v.nUserId].isDingQue = v.isDingQue or 0
	--定缺牌类型 0万 1筒 2条
	self.roomInfo.memberList[v.nUserId].nQue = v.nQue or 0
	
	
	--[[if self.roomInfo.tableGroupCards then
		for i,k in pairs(self.roomInfo.tableGroupCards) do
			if v.nUserId == k.nUserId then
				self.roomInfo.memberList[v.nUserId].gruoupCards = k.operates
			end
		end
	else
		self.roomInfo.memberList[v.nUserId].gruoupCards = v.gruoupCards
	end--]]
end

function Room:onHuResponse(status,response)
	logD("--------------------血战 通知胡 ------------------------")
	logD("Room:onHuResponse(), response = ", table.tostring(response))
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	if self.roomInfo.memberList[response.nUserId] then
		self.roomInfo.memberList[response.nUserId].nUserId = response.nUserId
		self.roomInfo.memberList[response.nUserId].huCard = response.huCard
		self.roomInfo.memberList[response.nUserId].isQiangGng = response.isQiangGng
		self.roomInfo.memberList[response.nUserId].isGspHu = response.isGspHu
		self.roomInfo.memberList[response.nUserId].isGskhHu = response.isGskhHu
		self.roomInfo.memberList[response.nUserId].redRealCard = response.redRealCard
	end
	
	self:dispatchEvent({name = MJDefine.MJEvent.HuResponse,response = response});	
end


-- 小局结算
function Room:onGameXiaoJuResponse(status, response)
	logD("--------------------dazhou 小局结算 ------------------------")
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end

	-- 一局结束的原因
	self.roomInfo.stopFlag=response.stopFlag
	-- 房间信息
    self.roomInfo.strGameInfo=response.strGameInfo
	---self.roomInfo.resultInfos = response.allPlayerInfo
	--杠信息
	self.roomInfo.ganginfo = response.opsCntMapString or ""
	--玩家信息
	for k,v in pairs(response.allPlayerInfo) do		
		if self.roomInfo.memberList[v.nUserId] then
			self.roomInfo.memberList[v.nUserId].nUserId = v.nUserId
			--当前局分数
			self.roomInfo.memberList[v.nUserId].nTurnScore= self:isUseDivision10() and v.nTurnScore/10 or v.nTurnScore
			--总分
		    self.roomInfo.memberList[v.nUserId].nTotalMoney= self:isUseDivision10() and v.nTotalMoney/10 or v.nTotalMoney
		    --番数
			self.roomInfo.memberList[v.nUserId].fanshu=v.fanshu
			self.roomInfo.memberList[v.nUserId].userStatus = v.userStatus
			-- 胡牌牌类型-7对胡、平胡，0为输或者不胡不输
			self.roomInfo.memberList[v.nUserId].huType=v.huType
			if v.gruoupCards then
				for _,group in ipairs(v.gruoupCards) do
					group.targetSeatId = self:getSeatIdByUserId(v.nUserId)
				end
			end
			self.roomInfo.memberList[v.nUserId].gruoupCards = v.gruoupCards
			self.roomInfo.memberList[v.nUserId].handCards = v.handCards
			self.roomInfo.memberList[v.nUserId].outCards = v.outCards
			self.roomInfo.memberList[v.nUserId].huCard = v.huCard
			--胡牌顺序
			self.roomInfo.memberList[v.nUserId].huOrder = v.huOrder
			--玩家本局输赢情况 0不胡不输 1胡，2点炮或者输
			self.roomInfo.memberList[v.nUserId].result=v.result
			--点炮次数
			self.roomInfo.memberList[v.nUserId].dpCount = v.dpCount
			--谁点炮
			self.roomInfo.memberList[v.nUserId].dpSeatId = v.dpSeatId
			--点炮顺序
			self.roomInfo.memberList[v.nUserId].dpOrder = v.dpOrder
			--是否大叫
			self.roomInfo.memberList[v.nUserId].isDj = v.isDj
			--是否花猪
			self.roomInfo.memberList[v.nUserId].isHz = v.isHz
			--根次数
			self.roomInfo.memberList[v.nUserId].genCount = v.genCount
			--子胡牌类型（天胡、地胡等）
			self.roomInfo.memberList[v.nUserId].subPaiType = v.subPaiType
			--是否绝张
			self.roomInfo.memberList[v.nUserId].isJueZhang = v.isJueZhang or 0
			--是否金钩钓
			self.roomInfo.memberList[v.nUserId].isJinGouDiao = v.isJinGouDiao or 0
			--是否海底捞月
			self.roomInfo.memberList[v.nUserId].isHaiDiLaoYue = v.isHaiDiLaoYue or 0
			--是否海底炮
			self.roomInfo.memberList[v.nUserId].isHaiDiPao = v.isHaiDiPao or 0
			--是否杠上开花
			self.roomInfo.memberList[v.nUserId].isGangShangKaiHua = v.isGangShangKaiHua or 0
			--是否杠上炮
			self.roomInfo.memberList[v.nUserId].isGangShangPao = v.isGangShangPao or 0
			--是否抢杠胡
			self.roomInfo.memberList[v.nUserId].isQiangGangHu = v.isQiangGangHu or 0
			--是否门清
			self.roomInfo.memberList[v.nUserId].isMenQing = v.isMenQing or 0
			--是否中张
			self.roomInfo.memberList[v.nUserId].isZhongZhang = v.isZhongZhang or 0
			--是否死叫
			self.roomInfo.memberList[v.nUserId].isSiJiao = v.isSiJiao or 0
			if self.roomInfo.memberList[v.nUserId].result > 0 then--胡牌了
				for i,t in pairs(self.roomInfo.memberList[v.nUserId].handCards) do
					if t.card == v.huCard then
						table.remove(self.roomInfo.memberList[v.nUserId].handCards.Datas,i)
						break
					end
				end
				--table.removeItem(self.roomInfo.memberList[v.nUserId].handCards,self.roomInfo.memberList[v.nUserId].huCard)
			end
		end	
		--[[self.roomInfo.resultInfos[v.nUserId].nUserId = v.nUserId
		self.roomInfo.resultInfos[v.nUserId].huType=v.huType
		--根次数
		self.roomInfo.resultInfos[v.nUserId].genCount = v.genCount
		--胡牌顺序
		self.roomInfo.resultInfos[v.nUserId].huOrder = v.huOrder
		--玩家本局输赢情况 0不胡不输 1胡，2点炮或者输
		self.roomInfo.resultInfos[v.nUserId].result=v.result
		self.roomInfo.resultInfos[v.nUserId].isXiQian=v.isXiQian]]--
	end
	--玩家信息
	for k,v in pairs(response.xjBaoInfo) do		
		if self.roomInfo.memberList[v.nUserId] then
			self.roomInfo.memberList[v.nUserId].isBaoPai = v.isBaoPai
			self.roomInfo.memberList[v.nUserId].isShaBao = v.isShaBao
		end
	end

	--是否大局结束,结束是1
	self.roomInfo.isGameOver=response.isGameOver

	--操作统计
	self.roomInfo.opsCntMapString=response.opsCntMapString
	
	--萝卜牌
	self.roomInfo.luoboCards = response.luoboCards

	logD("dazhouRoom:onGameXiaoJuResponse() :", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.GameXiaoJuResponse,response = response});
	
end

-- 游戏正式开始
function Room:onGameStartResponse(status, response)
	logD("-------------------- 新的一局开始了 ------------------------")
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	
	logD("Room:onGameStartResponse(), ", table.tostring(response))
	
	self.roomInfo.nGameStartCount 	= response.nGameStartCount;
	self.roomInfo.nTotalGameNum 	= response.nTotalGameNum;
	self.roomInfo.nRoomOwnedUid 	= response.nRoomOwnedUid;
	self.roomInfo.nBankSeatId 		= response.nBankSeatId;
	self.roomInfo.shuffleList 		= response.shuffleList;
	self.roomInfo.shuffleNum 		= response.shuffleNum;
	self.roomInfo.nLeaveCardNum     = 108 - self:getPlayerCount() * 13 - 1

	-- 清空上一局的手牌信息
	self.cards = {}
	
	-- 清空上一局的换牌数据
	for i, v in pairs(self.roomInfo.memberList) do
		v.isSwapCard = 0
	end

	-- 发送广播通知，游戏开始了
	self:dispatchEvent({name = MJDefine.MJEvent.GameStartResponse});	
end


--大局结算
function Room:onGameDaJuResponse(status, response)
	logD("-------------------- 大局结算 ------------------------")
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end

	for k,v in pairs(response.nTotalPlayerInfos) do
		if self.roomInfo.memberList[v.nUserId] then
			--self.roomInfo.memberList[v.nUserId].nTotalInfo=json.decode(v.nTotalInfo)
			v.nTotalScore = self:isUseDivision10() and v.nTotalScore/10 or v.nTotalScore --血战总分服务器乘以了10，客户端除以10
			self.roomInfo.memberList[v.nUserId].nTotalScore = v.nTotalScore
			self.roomInfo.memberList[v.nUserId].roomCard = v.roomCard
			--self.roomInfo.memberList[v.nUserId].costCard = v.requireCard
		end
	end
	--房卡消耗 
	for k,v in pairs(response.costCardInfos) do
		if self.roomInfo.memberList[v.nUserId] then
			self.roomInfo.memberList[v.nUserId].costCard = v.costCard
		end
	end

	self.roomInfo.stopFlag = response.stopFlag
	--解散状态
	local disbandStatus = json.decode(response.strDisbandStatus) or {}
	for k,v in pairs(disbandStatus) do
		self.dismissInfo[tonumber(k)] = tonumber(v)
	end

	--结束时间
	self.roomInfo.nEndTime = response.nEndTime or os.time()
	logD("Room:onGameDaJuResponse() :", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.GameDaJuResponse ,response = response});
end

function Room:pushTing(status,response)
	logD("-------------------- Room:pushTing ------------------------")
	logD("Room:pushTing(), ", table.tostring(response))
	if not self.roomInfo then
		print("容错处理")
		return
	end
	self.roomInfo.tings={}
	if self:isCanTing() then
		for k,v in pairs(response.pushTing) do
			self.roomInfo.tings=response.pushTing
			--self.roomInfo.tings[v.outCard]=v.tingCards.Datas
		end
	end

	self:dispatchEvent({name = MJDefine.MJEvent.OutCardTings})
end

-- 玩家进入桌子成功
function Room:onSitDownSuccessResponse(status, response)
	logD("--------------------玩家进入桌子成功--------------------")
	logD("Room:onSitDownSuccessResponse(), ", table.tostring(response))
	
	app.net:onMsgClear()
	app.net:onMsgPause()
	
	-- 记录当前桌子号
	self:initRoomInfo()
	
	-- 获取到的房间信息
	-- self.gameId = response.gameId
	self.roomInfo.gameId 			= response.gameId
	self.roomInfo.nShowTableId 			= response.nShowTableId
	self.roomInfo.nMaxPlayCount 			= response.nMaxPlayCount
	self.roomInfo.nRoomOwnedUid 			= response.nRoomOwnedUid
	self.roomInfo.nTotalGameNum 			= response.nTotalGameNum
	self.roomInfo.strGameInfo 				= response.strGameInfo
	self.roomInfo.nGameStartCount 			= response.nGameStartCount or 0
	self.roomInfo.nLeaveCardNum 			= response.nLeaveCardNum or 0

	
	-- 桌子上其他玩家的信息
	for k,v in pairs(response.memberList) do
		self.roomInfo.memberList[v.nUserId] = v
		self.roomInfo.memberList[v.nUserId].nTingStatus=MJDefine.MJTingStatus.NoTing
	end
	
	-- 更新椅子号
	self:updateUserSeateShowId()
	
	logD("Room:onSitDownSuccessResponse() roomInfo = ", table.tostring(self.roomInfo))
	
	-- 发送通知
	self:dispatchEvent({name = MJDefine.MJEvent.EnterRoomSuccess, gameId = self.roomInfo.gameId or app.gameId, gameType = self.roomInfo.strGameInfo.gamerule})	
end


function Room:onWaitOperate(status, response)
	logD("Room:onWaitOperate(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.WaitOperate ,response = response});
end

function  Room:onQiangDuanOperates(status, response)
	logD("Room:onQiangDuanOperates(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.QiangDuanOperates ,response = response});
end

function Room:onStartPiao(status, response)
	logD("Room:onStartPiao(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.StartPiao ,response = response});
end

function Room:onPiaoResponse(status, response)
	logD("Room:onPiaoResponse(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.PiaoResponse ,response = response});
end

--通知换三张
function Room:onNoticeSwapCardResponse(status, response)
	logD("Room:onNoticeSwapCardResponse(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.NoticeSwapCard ,response = response});
end

--请求换三张
function Room:requestSwapCards( cards )
	local request = MJMessage.GetSwapCards:new()
	for _,v in ipairs(cards) do
		table.insert(request.bySwapCard.Datas, v)
		--table.insert(request.byOutCard.Datas, v)
	end
	self:sendResponse{cmd = RoomCmd.GAME_COMMAND_REQUEST_CHANGE_CARD , sender = request}
end

--换三张错误
function Room:onChangeCardError(status,response)
	logD("-------------------- 换三张错误 ------------------------")
	if not self.roomInfo then
		print("容错处理")
		return
	end
	logD("Room:onChangeCardError(), ", table.tostring(response))
	local msg = {
		[1] = "换牌数量小于3",
		[2] = "牌面值错误",
	}
	
	local m = msg[response.errFlag] or "换三张未知错误"
	showTooltip(""..m)
	self:dispatchEvent({name = MJDefine.MJEvent.SwapCardErr ,response = response});
end

--换三张成功
function Room:onChangeCardSucc(status,response)
	logD("Room:onChangeCardSucc(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.SwapCardSucc ,response = response});
end

--换三张成功后的信息
function Room:onChangeCardInfo(status,response)
	logD("Room:onChangeCardInfo(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.SwapCardSuccInfo ,response = response});
end

--服务器通知定缺
function Room:onNoticeDingQueResponse(status,response)
	logD("Room:onNoticeDingQueResponse(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.NoticeDingQue ,response = response});
end

--广播定缺成功
function Room:onDingQueSuccResponse(status,response)
	logD("Room:onDingQueSuccResponse(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.DingQueSucc ,response = response});
end

--定缺成功广播告诉玩家定缺类型
function Room:onDingQueSuccInfoResponse(status,response)
	logD("Room:onDingQueSuccInfoResponse(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.DingQueSuccInfo ,response = response});
end

---
-- 托管通知
-- @return
--
function Room:onHostingResponse (status, response)
	local userList = response.userList
	for k, v in ipairs(userList) do 
		-- 是否托管
		if v.nUserId == self:getMyUserId() then
			self.roomInfo.hosting = v.status 
		end
		self:dispatchEvent({name = MJDefine.MJEvent.HostingRequest, response = {nUserId = v.nUserId, status = v.status}});
	end
end

--发送操作
function Room:sendOperateCard(curOperate,allOperate)
	local request = MJMessage.OperateRequest:new()
	request.opType = curOperate.opType
	request.opCard = curOperate.opCard
	--request.opNum = 2--curOperate.nRedUseNum
	for _,v in pairs(allOperate or {}) do
		if v.opType ~= MJDefine.MJOperateType.OPREATE_CANCEL then
			table.insert(request.operates.Datas, v)
		end
	end
	
	logD("dazhouRoom sendOperateCard" .. table.tostring(request))
	self:sendResponse{cmd = RoomCmd.GAME_COMMAND_SEND_CODE_RESPONSE , sender = request}
end

--操作错误
function Room:onOperationError(status)
	logD("-------------------- onOperationError ------------------------")
	if not self.roomInfo then
		print("容错处理")
		return
	end
	showTooltip("操作发生了错误...")
	--错误的时候如何处理
	self:dispatchEvent({name = MJDefine.MJEvent.OperationError})
end

function Room:ctor(net)
	Room.super.ctor(self , net);
	-- 请求爆牌
	self:defMsgFunc{name = MJDefine.MJEvent.BaoPaiRequest,cmd = RoomCmd.GAME_COMMAND_REQUEST_BAO_PAI,sender = MJMessage.BaoPaiRequest};
	--请求换三张
	--self:defMsgFunc{name = MJDefine.MJEvent.RequestSwapCard , cmd = RoomCmd.GAME_COMMAND_REQUEST_CHANGE_CARD, sender = MJMessage.SwapCards};
	--客户端请求定缺
	self:defMsgFunc{name = MJDefine.MJEvent.RequestDingQue , cmd = RoomCmd.GAME_COMMAND_REQUEST_DINGQUE, sender = MJMessage.QueCard};
	-- 请求飘
	self:defMsgFunc{name = MJDefine.MJEvent.PiaoRequest,cmd = RoomCmd.GAME_COMMAND_NOTIFY_PIAO,sender = MJMessage.PiaoRequest};
	-- 请求刷新桌子
	self:defMsgFunc{name = MJDefine.MJEvent.GetTableInfo,cmd = RoomCmd.GAME_COMMAND_GET_TABLE_INFO};
	
	--玩家出牌的听牌信息
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_OUT_CARD_TING_INFO,reader = MJMessage.OutCardTingInfo,func = handler(self,self.pushTing)}
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_BROADCAST_HU,reader = MJMessage.HuRespone,func = handler(self,self.onHuResponse)}
	--广播玩家爆牌
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_BROADCAST_BAO_PAI,reader = MJMessage.BaoPaiResponse,func = handler(self,self.onBaoPai)}
	--通知庄家爆牌
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_BANKER_BAO_PAI,reader = MJMessage.BankerBaoPai,func = handler(self,self.onBankerBaoPai)}
	--通知等待操作
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_WAIT_OPREATE,reader = MJMessage.WaitOperate,func = handler(self,self.onWaitOperate)}
	--通知抢断操作
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_QIANG_DUAN_OPREATE,reader = MJMessage.QiangDuanOperates,func = handler(self,self.onQiangDuanOperates)}
	
	--广播玩家开始飘
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_NOTIFY_PIAO,reader = MJMessage.PiaoRequest,func = handler(self,self.onStartPiao)}
	--广播玩家飘结果
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_USER_PIAO_RESULT,reader = MJMessage.PiaoResponse,func = handler(self,self.onPiaoResponse)}
	--换三张,服务器会通过0x8122通知换牌
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_BROADCAST_CHANGE_CARD,reader = MJMessage.SwapCards,func = handler(self,self.onNoticeSwapCardResponse)}
	--换三张错误
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_CHANGE_CARD_ERR,reader = MJMessage.SwapCardsErr,func = handler(self,self.onChangeCardError)}
	--换三张成功
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_CHANGE_CARD_SUCC,reader = MJMessage.SwapCardsSucc,func = handler(self,self.onChangeCardSucc)}
	--换三张成功后的信息
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_CHANGE_CARD_INFO,reader = MJMessage.SwapCardsSuccInfo,func = handler(self,self.onChangeCardInfo)}
	--服务器通知定缺
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_BROADCAST_DINGQUE,reader = MJMessage.QueCard,func = handler(self,self.onNoticeDingQueResponse)}
	--当玩家操作成功后，通过0x8131广播定缺成功
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_DINGQUE_SUCC,reader = MJMessage.DingQueSucc,func = handler(self,self.onDingQueSuccResponse)}
	--当所有玩家定缺成功后，服务器会通过广播告诉玩家定缺类型
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_DINGQUE_RESULT,reader = MJMessage.DingQueSuccInfo,func = handler(self,self.onDingQueSuccInfoResponse)}
	-- 内容和0x8106保持统一 广播桌子上所有玩家庄家起手操作
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_START_ROUND_OPERATE, reader =  MJMessage.BankerOutCard,func = handler(self , self.onAfterDingQue)};
	-- 请求托管
	self:defMsgFunc{name = MJDefine.MJEvent.HostingRequest, cmd = RoomCmd.GAME_COMMAND_USER_HOSTING_REQUEST, sender = MJMessage.HostingRequest}
	-- 收到托管回调
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_USER_HOSTING_RESPONSE, reader = MJMessage.HostingResponse, func = handler(self,self.onHostingResponse)}
end

-- 可能返回""或者nil
function Room:isUseDivision10()
	local gameId = tonumber(self.roomInfo.gameId)
	local gameConfig = getSubGameConfig(gameId)

	if not gameConfig then
		logE("Error :: getSubGameRoomLogo() 没有找到对应的子游戏配置信息 ", gameId)
		return nil
	end
	
	local isUseDivision10 = gameConfig.isUseDivision10 or false

	return isUseDivision10
end

-- 是否可以显示听箭头和按钮
function Room:isCanTing()
	return true
end

return Room;