pc_tiantian/tiantian/mj_yibinmajiang/luaScript/Protocol/yibinmajiangProtocol.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 yibinmajiangRoomInfo = import("mj_yibinmajiang.luaScript.Data.yibinmajiangRoomInfo");

local MJProtocol = MJFramework.MJFrameworkClassImprot("mj.luaScript.Protocol.MJProtocol")
local Room = class("yibinmajiangRoom" , MJProtocol)

function Room:initRoomInfo ()
	Room.super.initRoomInfo(self)
	self.roomInfo = yibinmajiangRoomInfo.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:checkIsAllChooseDingQue()
	local playerCount = self:getPlayerCount()
	local chooseQuePlayerCount = table.nums(self.roomInfo:getDingQueInfo()) or 0
	if playerCount == chooseQuePlayerCount then
		return true
	else
		return false
	end
end

-- 抓牌，还有初始发牌，如果是初始发牌则不会有操作数据，需要借用811a协议
function Room:onBankerOutCard(status, response)
	logD("-------------------- 游戏庄家起手操作 ------------------------")
	logD("Room:onBankerOutCard(), ", table.tostring(response))

	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	self.roomInfo:setLeaveCardNum(response.nLeaveCardNum)
	self.roomInfo:setNeedOutCardId(response.nUserId);

	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:onGameRoundStartOperate(status, response)
	logD("-------------------- 庄家初始操作 ------------------------")
	logD("Room:onBankerOutCard(), ", table.tostring(response))

	if not self.roomInfo then
		logD("self.roomInfo no exist,容错处理!")
		return
	end
	self.roomInfo:setLeaveCardNum(response.nLeaveCardNum)
	self.roomInfo:setNeedOutCardId(response.nUserId);

	local myUserId = self:getMyUserId()
	if response.nUserId == myUserId then
		self.roomInfo:setTingCards(response.pushCardTing);
	end
	
	-- 发送广播通知，游戏开始了
	self:dispatchEvent({name = MJDefine.MJEvent.GameRoundStartOperate ,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:setBenJinCard(response.benjinCard)
	self.roomInfo:setTingYongCard(response.tingyongCard)
	self.roomInfo:setPlayerInfos(response.playerInfos);
	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:setOperates(response.operates);
	self.roomInfo:setIsNeedOutCard(response.isNeedOutCard);
	self.roomInfo:setStopFlag(response.stopFlag);
	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:setNeedOutCardId(response.needOutCardId);

	if self.roomInfo:getGameStartCount() > 0 then
		self.roomInfo:setMaxPlayerCount(table.nums(response.playerInfos));
	end
	
	-- 桌子上其他玩家的信息
	for k,v in pairs(response.playerInfos) do
		-- 补充外部的数据，没有在playerinfo里面发送，而是在外部的
		v.Datas.huCardsInfo = response.resultInfos[k] or {}  -- 胡牌内容
		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

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

		-- 更新定缺数据
		if v.dingquetype ~= -1 then
			self.roomInfo:setDingQueInfo(v.nUserId, v.dingquetype)
		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
	end
	]]
	
	self:addExtendData(response)
	
	local extInfo = json.decode(response.ext 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: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.isDaJiao
	--是否花猪
	self.roomInfo.memberList[v.nUserId].isHz = v.isHuaZhu
	--点炮次数
	self.roomInfo.memberList[v.nUserId].dpCount = v.dpCount
	--点炮顺序
	self.roomInfo.memberList[v.nUserId].dpOrder = v.dpOrder
	--是否操作过飘
	self.roomInfo.memberList[v.nUserId].isPiao = v.isPiao
	--飘的选择
	self.roomInfo.memberList[v.nUserId].piaostate = v.piaostate
	-- 是否可以定缺
	self.roomInfo.memberList[v.nUserId].isDingQue = v.isDingQue
	-- 定缺类型
	self.roomInfo.memberList[v.nUserId].dingquetype = v.dingquetype
	-- 定缺最优选
	self.roomInfo.memberList[v.nUserId].nice_choose = v.nice_choose

	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].ganginfo = v.gangInfo or ""
	
	self.roomInfo.memberList[v.nUserId].operates = v.operates or {};

	self.roomInfo.memberList[v.nUserId].scoreInfo = v.scoreInfo or {};  -- 没有这个数据

	self.roomInfo.memberList[v.nUserId].reserve = v.reserve or '';  -- 没有这个数据
	
	self.roomInfo.memberList[v.nUserId].huCards = {};

	self.roomInfo.memberList[v.nUserId].paiType = 0
	self.roomInfo.memberList[v.nUserId].subPaiType = 0
	self.roomInfo.memberList[v.nUserId].genCount    = v.genCount  -- 根
	self.roomInfo.memberList[v.nUserId].gangCount    = v.gangCount  -- 杠
	self.roomInfo.memberList[v.nUserId].isOperated = v.isOperated or ''  -- 断线重连前操作过的数据
	
	-- 插入胡牌，这些还是用的花麻将多胡，之后要删除jxtd
	if v.huCardsInfo.huCard then
		-- 胡牌数据格式
		local temp = {
			huCard = v.huCardsInfo.huCard,
			huType = v.huCardsInfo.huType,
			dpSeatId = v.huCardsInfo.dpId,
		}

		table.insert(self.roomInfo.memberList[v.nUserId].huCards, temp)
		self.roomInfo.memberList[v.nUserId].paiType = v.huCardsInfo.paiType
		self.roomInfo.memberList[v.nUserId].subPaiType = v.huCardsInfo.subPaiType
		self.roomInfo.memberList[v.nUserId].huType = v.huCardsInfo.huType
		self.roomInfo.memberList[v.nUserId].huIndex = v.huCardsInfo.huIndex
		self.roomInfo.memberList[v.nUserId].dpId = v.huCardsInfo.dpId  -- 放炮玩家(seatid)
		self.roomInfo.memberList[v.nUserId].genCount = v.huCardsInfo.genCount
		self.roomInfo.memberList[v.nUserId].gangCount = v.huCardsInfo.gangCount
	end
	
	-- 保存胡牌顺序信息
	self.roomInfo:setHuIndexInfo(v.nUserId, v.huCardsInfo.huIndex or 0)

	-- dump(self.roomInfo.memberList, 'aaaaaaaaaaaaaaaaaaaaaaa')
	-- for k, card in pairs(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

-- 胡牌通知
--[[
	需注意huCards是个胡牌数组，针对某些游戏单个玩家可以多胡(血流等)，服务端一般不会发这个数据，由客户端这边自己拼接
	拼接完之后，将拼接好后的字段赋值给huCard
]]
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 dpSeatId = self:getSeatIdByUserId(response.dpUserId)

		-- 胡牌数据格式
		local huCard = {
			huCard = response.huCard,
			huType = response.huType,
			dpSeatId = dpSeatId,
		}
		response.huCard = huCard

		-- 定义的数据
		self.roomInfo.memberList[response.nUserId].nUserId 		= response.nUserId
		self.roomInfo.memberList[response.nUserId].huType 		= response.huType
		self.roomInfo.memberList[response.nUserId].fanshu 		= response.fanshu
		self.roomInfo.memberList[response.nUserId].paiType 		= response.paiType
		self.roomInfo.memberList[response.nUserId].subPaiType	= response.subPaiType
		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].dpId 		= dpSeatId
		self.roomInfo.memberList[response.nUserId].huIndex 		= response.huIndex
		self.roomInfo.memberList[response.nUserId].ext 			= json.decode(response.ext or '')
		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);

		-- 保存胡牌顺序信息
		self.roomInfo:setHuIndexInfo(response.nUserId, response.huIndex)
	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:setIsGameOver(response.isGameOver)  -- 是否大局结束,结束是1
	self.roomInfo:setOpsCntMapString(response.opsCntMapString)	-- 操作统计

	-- 玩家信息
	for k,v in pairs(response.allPlayerInfo) do		
		if self.roomInfo.memberList[v.nUserId] then

			-- 胡牌数据格式(拼接)
			local huCard = {
				huCard = v.huCard,
				huType = v.huType,
				dpSeatId = v.dpId,
			}
			v.huCard = huCard

			self.roomInfo.memberList[v.nUserId].nUserId 	= v.nUserId      -- 玩家的id
			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].result		= v.result  	 -- 玩家本局输赢情况(0为默认, 1为胡, 2为听叫)
			self.roomInfo.memberList[v.nUserId].paiType		= v.paiType  	 -- 胡牌类型
			self.roomInfo.memberList[v.nUserId].subPaiType	= v.subPaiType   -- 胡牌子类型(0x01:本金;0x02:接本金)
			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].huIndex     = v.huIndex  	 -- 胡牌顺序
			self.roomInfo.memberList[v.nUserId].huType      = v.huType  	 -- 自摸还是点炮胡
			self.roomInfo.memberList[v.nUserId].dpCount 	= v.dpCount 	 -- 点炮次数
			self.roomInfo.memberList[v.nUserId].dpId        = v.dpId  	 	 -- 谁点炮给该玩家(座位号seatId)
			self.roomInfo.memberList[v.nUserId].dpIndex     = v.dpIndex  	 -- 点炮顺序(后3个bit位标识顺序)
			self.roomInfo.memberList[v.nUserId].isDj 		= v.isDaJiao  	 -- 是否大叫
			self.roomInfo.memberList[v.nUserId].isHz 		= v.isHuaZhu  	 -- 是否花猪
			self.roomInfo.memberList[v.nUserId].genCount    = v.genCount  	 -- 根次数
			self.roomInfo.memberList[v.nUserId].gangCount   = v.gangCount  	 -- 杠次数
			
			-- 胡牌总数据
			self.roomInfo.memberList[v.nUserId].huCards 	= {}  -- 这里做一次初始化处理，不然正常流程通知胡后，在进入小结算会添加相同的胡牌
			table.insert(self.roomInfo.memberList[v.nUserId].huCards, v.huCard);

		end	

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

		-- 保存胡牌顺序信息
		self.roomInfo:setHuIndexInfo(v.nUserId, v.huIndex)
	end

	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(MJDefine.totalCard);

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

	self.roomInfo:setScoreInfo(nil);
	self.roomInfo:setBenJinCard(nil)
	self.roomInfo:setTingYongCard(nil)
	self.roomInfo:setDingQueInfo(nil, nil)

	self.roomInfo.shuffleList 		= response.shuffleList;
	self.roomInfo.shuffleNum 		= response.shuffleNum;	
	
	-- 发送广播通知，游戏开始了
	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:onStartPiao(status, response)
	logD("--------------------开始飘--------------------")
	logD("Room:onStartPiao(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.StartPiao ,response = response});
end

function  Room:onPiaoResponse(status, response)
	logD("--------------------飘结果--------------------")
	logD("Room:onPiaoResponse(), ", table.tostring(response))

	if self.roomInfo.memberList[response.nUserId] then
		self.roomInfo.memberList[response.nUserId].piaostate = response.piaostate
	end
	self:dispatchEvent({name = MJDefine.MJEvent.PiaoResponse ,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);
	end
end

-- 开始定缺
function Room:onDingQueStart(status, response)
	logD("--------------------开始定缺--------------------")
	logD("Room:onDingQueStart(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.DingQueStart, response = response})
end

-- 定缺结果
function Room:onDingQueResponseResult(status, response)
	logD("--------------------定缺结果--------------------")
	logD("Room:onDingQueResult(), ", table.tostring(response))
	for i, v in pairs(response.DingQueData) do
		self.roomInfo:setDingQueInfo(v.nUserId, v.result)
	end
	self:dispatchEvent({name = MJDefine.MJEvent.DingQueResponse, response = response})
end

-- 广播游戏庄家
function Room:onBankReponse(status, response)

end

-- 广播本金牌
function Room:onBenJinCardResponse(status, response)
	logD("--------------------广播本金牌--------------------")
	logD("Room:onBenJinCardResponse(), ", table.tostring(response))
	self.roomInfo:setBenJinCard(response.benjinCard)
	self.roomInfo:setTingYongCard(response.tingCard)
	self:dispatchEvent({name = MJDefine.MJEvent.BenJinStart, response = response})
end

-- 提操作成功后收到操作
function Room:onNoticeTiAfterOp(status, response)
	logD("--------------------提操作成功后收到操作--------------------")
	logD("Room:onNoticeTiAfterOp(), ", table.tostring(response))
	self:dispatchEvent({name = MJDefine.MJEvent.NoticeTiAfterOp, 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:ctor(net)
	Room.super.ctor(self, net)
	self:defRequestEvent()  -- 注册客户端向服务端发送的请求事件
	self:defResponseEvent()  -- 注册服务端返回到客户端的返回事件
end

-- 注册请求事件
function Room:defRequestEvent()
	-- 请求飘[0x8204]
	self:defMsgFunc{name = MJDefine.MJEvent.PiaoRequest, cmd = RoomCmd.GAME_COMMAND_NOTIFY_PIAO, sender = MJMessage.PiaoRequest}
	-- 请求定缺[0x8206]
	self:defMsgFunc{name = MJDefine.MJEvent.DingQueRequest, cmd = RoomCmd.GAME_COMMAND_NOTICE_SELECT_QUE, sender = MJMessage.DingQueRequest}
	-- 请求桌子信息[0x802a]，用于切换2d/3d
	self:defMsgFunc{name = MJDefine.MJEvent.GetTableInfo, cmd = RoomCmd.GAME_COMMAND_GET_TABLE_INFO}

	-- 待定
end

-- 注册返回事件
function Room:defResponseEvent()
	-- 通知玩家漂操作[0x8204]
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_NOTIFY_PIAO, reader = MJMessage.PiaoStart, func = handler(self, self.onStartPiao)}
	-- 广播玩家飘结果[0x8205]
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_USER_PIAO_RESULT, reader = MJMessage.PiaoResponse, func = handler(self, self.onPiaoResponse)}
	-- 广播游戏庄家[0x8208]
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_BROADCAST_BANK, reader = MJMessage.BankResponse, func = handler(self, self.onBankReponse)}
	-- 广播本金牌和听用牌[0x8209]
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_BROADCAST_JING_CARD, reader = MJMessage.BenJinCard, func = handler(self, self.onBenJinCardResponse)}
	-- 通知玩家开始定缺[0x8206]
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_NOTICE_SELECT_QUE, reader = MJMessage.DingQueStart, func = handler(self, self.onDingQueStart)}
	-- 广播玩家定缺结果[0x8207]
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_USER_SELECT_QUE_RESULT, reader = MJMessage.DingQueResponse, func = handler(self, self.onDingQueResponseResult)}
	-- 通知等待其他玩家操作[0x8116]
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_WAIT_OPREATE, reader = MJMessage.WaitOperate, func = handler(self, self.onWaitOperate)}
	-- 广播玩家胡[0x8130]
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_BROADCAST_HU, reader = MJMessage.HuResponse, func = handler(self, self.onHuResponse)}
	-- 玩家出牌/操作后的听牌信息[0x8132]
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_OUT_CARD_TING_INFO, reader = MJMessage.OutCardTingInfo, func = handler(self, self.pushTing)}
	-- 广播桌子上所有玩家庄家起手操作[0x811a]
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_START_ROUND_OPERATE, reader = MJMessage.BankerOutCard,func = handler(self , self.onGameRoundStartOperate)};
	-- 提操作成功后收到操作[0x811C]
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_NOTICE_TI_AFTER_OP, reader = MJMessage.NoticeTiAfterOp,func = handler(self , self.onNoticeTiAfterOp)};

	-- 待定
	self:defPushMsg{cmd = RoomCmd.GAME_COMMAND_QIANG_DUAN_OPREATE,reader = MJMessage.QiangDuanOperates,func = handler(self,self.onQiangDuanOperates)}
end

return Room;