pc_tiantian/tiantian/mj_ncmaj/luaScript/Protocol/ncmajProtocol.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("ncmajRoom" , 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
	
	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
	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
		self.roomInfo.tings = response.pushCardTing
		--这里自己摸牌后，不隐藏听牌提示
		--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		
		self.roomInfo.tings = response.pushCardTing
	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("ncmaJRoom: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("ncmaJRoom:onBankerBaoPai(), response = ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.BankerBaoPai ,response = response});
end

-- 获取听牌信息
function Room:getTingCards()
    return self.roomInfo.tings or {};
end
--- Room:getTingCardsByCard 通过指定牌，获取听牌信息
-- @param card int
function Room:getTingCardsByCard (card)
    local curTingCards = {};
    for k, v in pairs(self.roomInfo.tings) do
		if v.outCard == card then 
			curTingCards = v.tingCards;
			break;
		end
    end
    return curTingCards;
end

--- Room:getAllTingCards 获取所有可能听的牌
function Room:getAllTingCards()
    local curTingCards = {};
    for k, v in pairs(self.roomInfo.tings) do
		for i,j in pairs(v.tingCards) do
			local isHave = false
			for ii,jj in pairs(curTingCards) do
				if jj.card == j.card then
					isHave = true
					break
				end
			end
			if not isHave then
				table.insert(curTingCards,j)
			end
		end
    end
    return curTingCards;
end

--断线重连
function Room:onGameReconnection(status,response)
	logD("===============重连成功，清空之前所有存在的队列==================")
	
	app.net:onMsgClear()
	app.net:onMsgPause()
	logD("Room:onGameReconnection(), response = ", table.tostring(response))
	self:initRoomInfo();
	
	-- 获取到的房间信息
	self.roomInfo.isEapCreate = response.isEapCreate --是否由电竞SDK创建的房间 1是 0否
	self.roomInfo.EapTime = response.EapTime		-- 电竞倒计时时间
	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.paoCards		= response.paoCards

	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 = response.tingCard
	--杠信息
	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
	
	local myUserId = self:getMyUserId();
	self.roomInfo.memberList[myUserId].nTingStatus = self.roomInfo.tingStatus--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
		--重连胡牌着，胡的牌也在手中，需要删掉
		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)
	--[[-- 飘信息
	for k,v in pairs(response.PiaoInfo) do
		self.roomInfo.memberList[v.nUserId].canPiao=v.canPiao
		self.roomInfo.memberList[v.nUserId].isPiao=v.isPiao
	end--]]
	
	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      = v.nTurnScore--/10
	self.roomInfo.memberList[v.nUserId].nTotalMoney 	= v.nTotalMoney--/10
	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
	--服务器推荐的最佳定缺牌
	self.roomInfo.memberList[v.nUserId].nZjQue = v.nZjQue or 0
	self.roomInfo.memberList[v.nUserId].canPiao = v.isPiao
	self.roomInfo.memberList[v.nUserId].isPiao = v.piaoType
	--是否已爆牌
	self.roomInfo.memberList[v.nUserId].isBaoPai = v.baoJiao
	--是否可以爆牌
	self.roomInfo.memberList[v.nUserId].canBaoPai = v.canBaoJiao
	--躺牌
	self.roomInfo.memberList[v.nUserId].tangCards = v.tangCards
	--摆牌 0没有摆1摆牌2独摆
	self.roomInfo.memberList[v.nUserId].isBaiPai = v.isBaiPai or 0
	
	
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("--------------------ncmaj 小局结算 ------------------------")
	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=v.nTurnScore--/10
			--总分
		    self.roomInfo.memberList[v.nUserId].nTotalMoney=v.nTotalMoney--/10
		    --番数
			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].isBaoPai = v.isBaoJiao
			--子胡牌类型（天胡、地胡等）
			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
			--摆牌 0没有摆1摆牌2独摆
			self.roomInfo.memberList[v.nUserId].isBaiPai = v.isBaiPai 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
	-- self.roomInfo.playerInfos",VT_Vector(message.XiaojuPlayerInfo),{})

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

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

	logD("ncmajRoom: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.nLeaveCardNum     = 108--72

	self.roomInfo.shuffleList 		= response.shuffleList;
	self.roomInfo.shuffleNum 		= response.shuffleNum;	

	-- 清空上一局的手牌信息
	self.cards = {}
	
	-- 发送广播通知，游戏开始了
	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 = v.nTotalScore--/10 --血战总分服务器乘以了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)
	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={}
	for k,v in pairs(response.pushTing) do
		self.roomInfo.tings=response.pushTing
		--self.roomInfo.tings[v.outCard]=v.tingCards.Datas
	end
	self:dispatchEvent({name = MJDefine.MJEvent.OutCardTings})
	self:dispatchEvent({name = MJDefine.MJEvent.ClearBaiView,showValue = 10})
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.isEapCreate 				= response.isEapCreate --是否由电竞SDK创建的房间 1是 0否
	self.roomInfo.EapTime 					= response.EapTime		-- 电竞倒计时时间
	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))

	if self.roomInfo.isEapCreate == 1 then
		self:sendResponse{cmd = RoomCmd.GAME_COMMAND_USER_READY}	
	end
	
	-- 发送通知
	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:requestTangCards(tangCards,curSelectCard)
	local request = MJMessage.TangRequest:new()
	request.operateCodes = 2
	request.curOutCard = curSelectCard
	for _,v in ipairs(tangCards) do
		table.insert(request.curTangCards.Datas, v)
	end
	self:sendResponse{cmd = RoomCmd.GAME_COMMAND_USER_TANG_CARD , sender = request}
end
--躺返回
function Room:onTangResponse(status, response)
	logD("Room:onTangResponse(), ", table.tostring(response))
	
	self:dispatchEvent({name = MJDefine.MJEvent.TangPaiResponse ,response = response});
end
--躺错误
function Room:onTangError(status, response)
	logD("Room:onTangError(), ", table.tostring(response))
	local errCode = response.errCode
	if errCode == 1 then
		local tips = "摆牌错误,请重新摆牌!"--请选择正确牌型
		local view = require("mj_ncmaj.luaScript.Views.Compnent.ncmajShowTipsView"):new(tips)
		local winSize = cc.Director:getInstance():getVisibleSize()
		local pos = cc.p(winSize.width/2,winSize.height/2+150)
		view:setPosition(pos)
		app.mainScene:addChild(view)
	end
	self:dispatchEvent({name = MJDefine.MJEvent.BaiError ,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

-- 托管
function Room:onHostingRequest( status, response )
	-- 是否托管
	for k,v in pairs(response.userCnt) do
		if v.nUserID == self:getMyUserId() then
			self.roomInfo.hosting = v.aiStatus;
		end
	end
	self.roomInfo.hostInfos = response.userCnt
	self:dispatchEvent({name = MJDefine.MJEvent.HostingRequest, response = response});
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:defMsgFunc{name = MJDefine.MJEvent.TangPaiRequest , cmd = RoomCmd.GAME_COMMAND_USER_TANG_CARD, sender = MJMessage.TangRequest};
	
	--玩家出牌的听牌信息
	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:defPushMsg{cmd = RoomCmd.GAME_COMMAND_USER_TANG_CARD,reader = MJMessage.TangResponse,func = handler(self,self.onTangResponse)}
	--躺牌失败
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_USER_TANG_ERROR,reader = MJMessage.TangError,func = handler(self,self.onTangError)}
	-- 请求托管
	self:defMsgFunc{name = MJDefine.MJEvent.HostingRequest, cmd = RoomCmd.GAME_COMMAND_REQUEST_TUOGUAN, sender = MJMessage.HostingRequest}
	-- 收到托管回调
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_TUOGUAN_RESPONSE, reader = MJMessage.TuoGuanResponse, func = handler(self,self.onHostingRequest)}
end

return Room;