pc_tiantian/tiantian/mj_huamajiang/luaScript/Protocol/huamajiangProtocol.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 HuaMaJiangRoomInfo = import("mj_huamajiang.luaScript.Data.huamajiangRoomInfo");

local Room = class("huamajiangRoom" , MJProtocol)

function Room:initRoomInfo ()
	Room.super.initRoomInfo(self)
	self.roomInfo = HuaMaJiangRoomInfo.getInstance(true);
	self.roomInfo:reset();
end

-- 视角转换
function Room:transPos(targetSeatId, seatId )
	local MaxCount = self.roomInfo:getMaxPlayerCount();
	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:getMaxPlayerCount();
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:setLeaveCardNum(response.nLeaveCardNum);
	self.roomInfo:setNeedOutCardId(response.nUserId);

	--logD("Room:onBankerOutCard(), ", table.tostring(response))
	local  myUserId = self:getMyUserId()

	if response.nUserId==myUserId then
		self.roomInfo:setTingCards(response.pushCardTing);
	end
	
	-- 发送广播通知，游戏开始了
	self:dispatchEvent({name = MJDefine.MJEvent.BankerOutCard ,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("Room: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("Room: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:setGameId(response.gameId);
	self.roomInfo:setShowTableId(response.nShowTableId);
	self.roomInfo:setMaxPlayerCount(response.nMaxPlayCount);
	self.roomInfo:setRoomOwnedUid(response.nRoomOwnedUid);
	self.roomInfo:setTotalGameNum(response.nTotalGameNum);
	self.roomInfo:setBaseChips(response.nBaseChips);
	self.roomInfo:setStrGameInfo(response.strGameInfo);
	self.roomInfo:setGameStartCount(response.nGameStartCount);
	self.roomInfo:setGameStatus(response.nStatus);
	self.roomInfo:setBankSeatId(response.nBankSeatId);
	self.roomInfo:setMySeatId(response.nMySeatId);
	self.roomInfo:setIsUserDisbandGame(response.bUserDisbandGame);
	self.roomInfo:setDismissStateTime(response.nDismissStateTime);
	self.roomInfo:setLeaveCards(response.leaveCards);
	self.roomInfo:setLeaveCardNum(#response.leaveCards);
	self.roomInfo:setOutCardUserId(response.outCardUserId);
	self.roomInfo:setOutCardSeatId(response.outCardSeatId);
	self.roomInfo:setLastOpCard(response.lastOpCard);
	--萝卜牌
	self.roomInfo:setLuoBoCards(response.luoboCards);
	self.roomInfo:setOperates(response.operates);
	self.roomInfo:setIsNeedOutCard(response.isNeedOutCard);
	self.roomInfo:setNeedOutCardId(response.needOutCardId);
	self.roomInfo:setStopFlag(response.stopFlag);
	self.roomInfo:setPlayerInfos(response.playerInfos);
	--胡牌玩家列表
	self.roomInfo:setResultInfos(response.resultInfos);
	self.roomInfo:setOpsCntMapString(response.opsCntMapString);
	self.roomInfo:setTingStatus(response.tingStatus==255 and 0 or 1)
	self.roomInfo:setTingCards(response.tingCard);
	
	--是否换过牌玩家列表
	self.roomInfo.swapCardList = response.SwapCard
	
	if self.roomInfo:getGameStartCount() > 0 then
		self.roomInfo:setMaxPlayerCount(table.nums(response.playerInfos));
	end
	
	self.roomInfo:setLuoBoCards(response.luoboCards);
	
	-- 桌子上其他玩家的信息
	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

		-- ljx 重连流水信息由服务端发送
		-- if v.nUserId == self:getMyUserId() then 
		-- 	self.roomInfo:setScoreInfo(v.scoreInfo);
		-- end
	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].isXiQian=v.isXiQian
		self.roomInfo.memberList[v.nUserId].luoboScore = v.luoboScore
	end
	]]
	
	self:addExtendData(response)
	
	local extInfo = json.decode(response.extJson or "") or {}
	self.roomInfo.extJson = extInfo
	local uid = self:getMyUserId()
	if extInfo and type(extInfo) == 'table' then
		local myInfo = extInfo[tostring(uid)] or {}
		self.roomInfo.hosting = myInfo.hosted or 0--托管状态
		self.roomInfo:setQuickStartInfo(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 gameRule = self.roomInfo:getGameRuleByKey("gamerule");
	-- 发送通知
	self:dispatchEvent({name = MJDefine.MJEvent.EnterRoomSuccess, gameId = app.gameId, gameType = gameRule})
end

function Room:addExtendData(response)
	
end

function Room:setMemberInfo(v)
	Room.super.setMemberInfo(self,v)
	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].isBaoPai = v.isBaoPai
	--是否可以爆牌
	self.roomInfo.memberList[v.nUserId].canBaoPai = v.canBaoPai
	--是否已飘
	self.roomInfo.memberList[v.nUserId].isPiao = v.isPiao
	--是否可以飘
	self.roomInfo.memberList[v.nUserId].canPiao = v.canPiao
	
	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].luoboNum = v.luoboNum or 0
	
	self.roomInfo.memberList[v.nUserId].ganginfo = v.gangInfo or ""
	
	self.roomInfo.memberList[v.nUserId].operates = v.operates or {};

	self.roomInfo.memberList[v.nUserId].scoreInfo = v.scoreInfo;

	self.roomInfo.memberList[v.nUserId].reserve = v.reserve;
	
	self.roomInfo.memberList[v.nUserId].huCards = {};
	for k, card in ipairs(v.huCards) do 
		table.insert(self.roomInfo.memberList[v.nUserId].huCards, card);
	end
	
	--[[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
		-- 统一一下格式
		local huCard = {
			huCard = response.huCard,
			huType = response.huType,
			dpSeatId = response.dpId,
		}
		response.huCard = huCard

		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].ext 			= json.decode(response.ext)
		self.roomInfo.memberList[response.nUserId].huIndex 		= response.huIndex
		self.roomInfo.memberList[response.nUserId].huCards 		= self.roomInfo.memberList[response.nUserId].huCards or {};
		table.insert(self.roomInfo.memberList[response.nUserId].huCards, response.huCard);
		
		self.roomInfo:setScoreInfo(response.scoreInfo);
	end
	
	
	
	self:dispatchEvent({name = MJDefine.MJEvent.HuResponse,response = response});
end


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

	-- 一局结束的原因
	self.roomInfo:setStopFlag(response.stopFlag);
	-- 房间信息
	self.roomInfo:setStrGameInfo(response.strGameInfo);
	---self.roomInfo.resultInfos = response.allPlayerInfo
	--玩家信息
	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;
			--总分
		    self.roomInfo.memberList[v.nUserId].nTotalMoney	= 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
			self.roomInfo.memberList[v.nUserId].operates 	= v.operates;
			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.isDaJiao
			-- --是否花猪
			-- self.roomInfo.memberList[v.nUserId].isHz 		= v.isHz
			-- --根次数
			-- self.roomInfo.memberList[v.nUserId].genCount 	= v.genCount
			-- self.roomInfo.memberList[v.nUserId].luoboScore 	= v.luoboScore
			-- self.roomInfo.memberList[v.nUserId].luoboNum 	= v.luoboNum or 0
			self.roomInfo.memberList[v.nUserId].isBaoPai 	= v.baoStatus;
			self.roomInfo.memberList[v.nUserId].isPiao 		= v.isPiao;
			-- self.roomInfo.memberList[v.nUserId].ganginfo 	= v.gangInfo or ""
			self.roomInfo.memberList[v.nUserId].scoreInfo 	= v.scoreInfo;
			self.roomInfo.memberList[v.nUserId].huCards 	= v.huCards;
		end	

		-- ljx 胡牌流水通过另外条协议 服务端主动推送过来 解决数据量过大问题
		if v.nUserId == self:getMyUserId() then
			local scoreInfo = self.roomInfo.allPlayerScoreInfo[v.nUserId]

			if scoreInfo then
				self.roomInfo:setScoreInfo(scoreInfo);
			else
				logD("onGameXiaoJuResponse 流水有问题,没推送完全")	
			end
		end

		-- if v.nUserId == self:getMyUserId() then 
		-- 	self.roomInfo:setScoreInfo(v.scoreInfo);
		-- end
	end

	--是否大局结束,结束是1
	self.roomInfo:setIsGameOver(response.isGameOver);
	--操作统计
	self.roomInfo:setOpsCntMapString(response.opsCntMapString);
	--萝卜牌
	self.roomInfo:setLuoBoCards(response.luoboCards);

	logD("Room: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:setGameStartCount(response.nGameStartCount);
	self.roomInfo:setTotalGameNum(response.nTotalGameNum);
	self.roomInfo:setRoomOwnedUid(response.nRoomOwnedUid);
	self.roomInfo:setBankSeatId(response.nBankSeatId);
	self.roomInfo:setLeaveCardNum(72);

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

	-- 清空上一局的手牌信息
	self.cards = {}
	-- 清空上一局的胡牌信息
	for k, v in pairs(self.roomInfo.memberList) do 
		v.huCards = {};
	end

	--清空上一局的胡牌过滤过的状态
	self.roomInfo.passGuo = false;

	self.roomInfo:setScoreInfo(nil);

	--ljx 增加所有人的流水信息
	self.roomInfo.allPlayerScoreInfo = {}
	
	-- 发送广播通知，游戏开始了
	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)
			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:setStopFlag(response.stopFlag);
	--解散状态
	local disbandStatus = json.decode(response.strDisbandStatus)
	for k,v in pairs(disbandStatus) do
		self.dismissInfo[tonumber(k)] = tonumber(v)
	end
	--结束时间
	self.roomInfo:setEndTime(response.nEndTime);
	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:setTingCards(response.pushTing);
	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:setGameId(response.gameId);
	self.roomInfo:setShowTableId(response.nShowTableId);
	self.roomInfo:setMaxPlayerCount(response.nMaxPlayCount);
	self.roomInfo:setRoomOwnedUid(response.nRoomOwnedUid);
	self.roomInfo:setTotalGameNum(response.nTotalGameNum);
	self.roomInfo:setStrGameInfo(response.strGameInfo);
	self.roomInfo:setGameStartCount(response.nGameStartCount or 0);
	self.roomInfo:setLeaveCardNum(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))
	
	-- 发送通知
	local gamerule = self.roomInfo:getGameRuleByKey("gamerule");
	self:dispatchEvent({name = MJDefine.MJEvent.EnterRoomSuccess, gameId = response.gameId, gameType = 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:onFanLuoBoResponse(status, response)
	logD("Room:onFanLuoBoResponse(), ", table.tostring(response))
	if self.roomInfo and self.roomInfo.setLuoBoCards then 
		self.roomInfo:setLuoBoCards(response.luoboCards);
	end
	self:dispatchEvent({name = MJDefine.MJEvent.FanLuoBoResponse ,response = response});
end

-- 其他玩家退出房间
function Room:onOtherLogoutResponse(status, response)
	logD("Room:onOtherLogoutResponse(), response = ", table.tostring(response))
	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	local nUserId = response.nUserId
	local nSeatShowId = self.userList[nUserId]

	if self.roomInfo.isGameOver ~= 1 then
		local memberList = self.roomInfo.memberList
		memberList[nUserId]=nil
	end
	self:updateGpsUserInfo(nil,false)
	self.roomInfo.nStartGameUid = response.nStartGameUid
	logD("30000000--runOtherLogoutResponse")
	self:dispatchEvent({name = MJDefine.MJEvent.OtherLogoutResponse , nUserId = nUserId, nSeatShowId = nSeatShowId});
end

function Room:onOperationCodeSuccess(status, response)
	Room.super.onOperationCodeSuccess(self, status, response);
	local scoreInfo = response.scoreInfo;
	self.roomInfo:setScoreInfo(scoreInfo);
end
-- 服务器下发玩家的准备状态
function Room:onUserReadyResponse(status, response)
	Room.super.onUserReadyResponse(self, status, response);
	if response.nUserId == self:getMyUserId() then 
		self.roomInfo:setScoreInfo(nil);
		self.roomInfo:setLuoBoCards(nil);
	end
end
-- 保存萝卜牌
-- @param count 萝卜牌
function Room:setLuoBoCards(luoboCards)
	if self.roomInfo and self.roomInfo.setLuoBoCards then 
		self.roomInfo:setLuoBoCards(luoboCards);
	end
end
-- 获取萝卜牌
function Room:getLuoBoCards()
	if self.roomInfo and self.roomInfo.getLuoBoCards then 
		return self.roomInfo:getLuoBoCards();
	end
	return {}
end
-- 获取萝卜牌张数
-- @params card 麻将牌值
function Room:getLuoBoCardCount( card )
	if self.roomInfo and self.roomInfo.getLuoBoCardCount then 
		return self.roomInfo:getLuoBoCardCount(card)
	end
    return 0
end
-- 获取萝卜牌汇总
function Room:getLuoBoCardsSummary (cards)
	if self.roomInfo and self.roomInfo.getLuoBoCardsSummary then
		return self.roomInfo:getLuoBoCardsSummary(cards);
	end 
	return {}
end

-- 托管
function Room:onHostingRequest( status, response )
	-- 是否托管
	if response.nUserId == self:getMyUserId() then
		self.roomInfo.hosting = response.status 
	end
	self:dispatchEvent({name = MJDefine.MJEvent.HostingRequest, 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: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:onGameFlowInfo(status, response)
	logD("onGameFlowInfo 收到服务端推送的流水信息", table.tostring(response))
	if not self.roomInfo then
		return
	end

	local nUserId = response.nUserId
	local scoreInfo = response.scoreInfo
	local stopFlag = response.stopFlag

	if nUserId == self:getMyUserId() then 
		self.roomInfo:setScoreInfo(scoreInfo);
	end

	self.roomInfo.allPlayerScoreInfo[nUserId] = scoreInfo

	--小局结算主动请求后这里打开
	if stopFlag == 1 then
		local roomInfo = app.room.roomInfo;
		local data = {};
		local luoboCards = roomInfo:getLuoBoCards();
		luoboCards = roomInfo:getLuoBoCardsSummary(luoboCards)
		data.luoboCards = luoboCards;
		local scoreData = {};
		for k, v in ipairs(scoreInfo) do
			table.insert(scoreData, json.decode(v));
		end
		data.detail = scoreData
		app.room:dispatchEvent({name = MJDefine.MJEvent.EVENT_BTN_SHOW_FLOW_VIEW_CLICKED, response = data});
	end
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.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.HuResponse,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)}
	-- 广播萝卜牌
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_FAN_LUO_BO,reader = MJMessage.FanLuoBoResponse,func = handler(self,self.onFanLuoBoResponse)}
	-- 请求托管
	self:defMsgFunc{name = MJDefine.MJEvent.HostingRequest, cmd = RoomCmd.GAME_COMMAND_USER_HOSTING_REQUEST, sender = MJMessage.HostingRequest}
	-- 收到托管回调
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_USER_HOSTING_REQUEST, reader = MJMessage.HostingRequest, func = handler(self,self.onHostingRequest)}

	--换三张,服务器会通过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)}

	-- 内容和0x8106保持统一 广播桌子上所有玩家庄家起手操作
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_START_ROUND_OPERATE, reader =  MJMessage.BankerOutCard,func = handler(self , self.onAfterDingQue)};


	-- 内容和0x8106保持统一 广播桌子上所有玩家庄家起手操作
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_FLOW_INFO, reader =  MJMessage.GameFlowInfo, func = handler(self , self.onGameFlowInfo)};

	-- 请求小局结算流水详情
	self:defMsgFunc{name = MJDefine.MJEvent.ReqFlowInfo,cmd = RoomCmd.GAME_COMMAND_FLOW_REQ,sender = MJMessage.GameFlowReq};	
end

return Room;