pc_tiantian/tiantian/pk_luzhoupdk/luaScript/Views/Room/luzhouPdkRoomPlayView.lua

-- xx : 2018/5/7
-- 跑得快回放界面 
local PdkDef = require("luaScript.SubGameDefine.Poker.luzhouPdkWanFa")
local PdkPlayerNode = require("pk_luzhoupdk.luaScript.Views.Room.Node.luzhouPdkPlayerNode")
local PdkCardNode = require("pk_luzhoupdk.luaScript.Views.Room.Node.luzhouPdkCardNode")
local PdkRoomViewConfig = require("pk_luzhoupdk.luaScript.Views.Room.luzhouPdkRoomViewConfig")
local PdkEffectHelper = require("pk_luzhoupdk.luaScript.Views.Room.luzhouPdkEffectHelper"):new()
local ETS = PdkRoomViewConfig.EffectType
local PdkSoundHelper = require("pk_luzhoupdk.luaScript.Views.Room.luzhouPdkSoundHelper"):new()
require("luaScript.Views.Room.RoomFunctions")
local CENTER_X=640*g_radio_x
local CENTER_Y=360*g_radio_y 

-- 表ta中是否包含元素x
local function ownX( ta, x )
	local rst = false
	for _,v in ipairs(ta) do
		if tonumber(v) == tonumber(x) then
			rst = true
			break
		end
	end
	return rst 
end
-- 获取ta表中移除tb表的结果
local function getDelAdB( ta, tb )
	-- print("------------------getDelAdB---------------------------")
	-- print("----ta: ", table.concat(ta, "_"))
	-- print("----tb: ", table.concat(tb, "_"))

	local tmp = {}
	for _,v in ipairs(ta) do
		if not ownX(tb, v) then
			table.insert(tmp, v)
		end
	end
	-- print("----tmp: ", table.concat(tmp, "_"))
	-- print("------------------------------------------------------")
	return tmp 
end

--[[
	PASS = 0,--要不起
	SINGLE_CARD     	= 1,      			--//单牌
	DUI_ZI           	= 2,      			--//对子
	THREE 				= 3, 				--三个
	THREE_AND_TWO  		= 4,      			--//三带二张
	THREE_AND_DUI  		= 5,      			--//三带一对
	SHUN_ZI          	= 6,      			--//顺子
	LIAN_DUI         	= 7,      			--//连对(至少2连对)
	AIRPLANE         	= 8,      			--//飞机
	AIRPLANE_TOW        = 9,      			--//飞机带散牌
	AIRPLANE_DUI        = 10,      			--//飞机带对
	BOMB            	= 11,      			--//炸弹
	NONE				= 100,				--不适用类型
	]]
local OP_TYPE_STRING_NO = {
	single_card 		= ETS.SINGLE_CARD,
	three_and_two 		= ETS.THREE_AND_TWO,
	dui_zi 				= ETS.DUI_ZI,
	lian_dui			= ETS.LIAN_DUI,
	airplane 			= ETS.AIRPLANE,
	shun_zi 			= ETS.SHUN_ZI,
	bomb 				= ETS.BOMB,
	four_and_three 		= ETS.FOUR_AND_THREE,
}
--------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------
local PRoom = class("PdkRoomPlay")
function PRoom:ctor(  )
	-- 玩家信息
	self._players = {}
	-- 房间信息
	self.roomInfo = {}
end

-- 添加玩家，如果玩家存在则更新数据
-- key - value 缓存
function PRoom:addPlayer( pl )--and update 
	self._players = self._players or {}
	local player = self._players[tostring(pl.userId)]
	if player then
		for k,v in pairs(pl) do
			player[k] = v
		end
	else
		self._players[tostring(pl.userId)] = pl 
	end
end

-- 删除玩家
function PRoom:delPlayer( uid )
	local player = self._players[tostring(uid)]
	if player then
		self._players[tostring(uid)] = nil 
	end
end

-- 获取玩家
function PRoom:getPlayer( uid )
	local player = self._players[tostring(uid)]
	return player
end

-- 根据座位号获取玩家数据
function PRoom:getPlayerCid( cid )
	for _,v in pairs(self._players) do
		if v.seatId == cid then
			return v 
		end
	end
	return nil 
end

-- 根据视角获取玩家数据
function PRoom:getPlayerVpos( viewPos )
	for _,v in pairs(self._players) do
		if v.viewPos == viewPos then
			return v 
		end
	end
	return nil 
end

-- 获取所有玩家
function PRoom:getPlayers()
	return self._players or {}
end

-- 获取玩家数量
function PRoom:getPlayerNum()
	local count = 0 
	for _,_ in pairs(self._players) do
		count = count + 1 
	end
	return count 
end

-- 根据id判断是否是自己
function PRoom:isMyself( uid )
	return tonumber(app.user.loginInfo.uid) == tonumber(uid) 
end

-- 获取自己信息
function PRoom:getMyself()
	return self._players[tostring(app.user.loginInfo.uid)] or self._players[tostring(app.firstRecordUid)]
end

-- 视角转换
function PRoom:transPos( pos )
	local myself = self:getMyself()
	local MaxCount = self:getRoomInfo().nMaxPlayCount
	local showPos = 0
    local myPos = myself.seatId
    if myPos <= pos then
        showPos = pos - myPos 
    elseif myPos > pos then
        showPos = MaxCount - myPos + pos
    end 
    return showPos+1
end

-- 获取房间信息
function PRoom:getRoomInfo()
	return self.roomInfo
end

-- 缓存房间信息
function PRoom:setRoomInfo( roominfo )
	self.roomInfo = self.roomInfo or {}
	for k,v in pairs(roominfo) do
		self.roomInfo[k] = v
	end
end

-- 获取下一个轮次
function PRoom:getNextTurn(viewPos)
	local MaxCount = self:getRoomInfo().nMaxPlayCount
	if MaxCount == 4 then
		if viewPos == 4 then
			return 1
		else
			return viewPos+1
		end
	elseif MaxCount == 3 then
		if viewPos == 3 then
			return 1
		else
			return viewPos+1
		end
	else
		if viewPos == 2 then
			return 1
		else
			return viewPos+1
		end
	end
	--return (viewPos+1)%MaxCount==0 and MaxCount or (viewPos+1)%MaxCount
end
--------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------

local PdkRoomView = class("PdkRoomView", cc.UIView)
function PdkRoomView:ctor(recordData)
    PdkRoomView.super.ctor(self)
    self._recordData = recordData
    --房间信息
    self.roomInfo = {}
    -- 玩家节点
    self._playerNodes = {}
    -- 自己手牌集合
    self._selfCards = {}
    -- 玩家手牌集合
    self._otherCards = {{}, {}, {}, {}}
    -- 玩家出牌集合
    self._showCards = {{},{},{},{}}
    -- 上一次出牌viewPos
    self._lastOutPos = 0
    -- 上一次出牌类型
    self._lastOutType = 0
    -- 上一次出牌，用于提示
    self._lastCards = {} 
    -- 排序轮次用
    self._turnsQueue = {}
    -- 是否开始播放
    self._playStart = false
    -- 数据备份，以便重复播放
    self._backupData = nil 
    -- 是否已经最后展示
    self._gameResult = nil 
    -- 本轮所有操作次数
    self._allOps = 0 
    -- 当前所剩操作数
    self._leftOps = 0
    -- 结算数据
    self._resultData = nil

    -- 房间缓存
    self._room = PRoom:new()
    self:parseData(self._recordData)

    self.ui = loadUI("pk_luzhoupdk/res/ui/ui_room/ui_lzpdk_recordplayview.ui")
    self:addChild(self.ui)
	
	loadSpriteFrameFile("pk_luzhoupdk/res/ui/zy_game/lzroom_add.plist")
    self:initUi()
    self.roomInfo = self._room:getRoomInfo()
    self:setRoomInfo(self.roomInfo)

    loadSpriteFrameFile("pk_luzhoupdk/res/ui/zy_game/zy_lzpdk_cards.plist")
    loadSpriteFrameFile("pk_luzhoupdk/res/ui/zy_effect/lzpdk_effect.plist")
    loadSpriteFrameFile("pk_luzhoupdk/res/ui/zy_effect/lzpdk_effect_bomb.plist")
    loadSpriteFrameFile("pk_luzhoupdk/res/ui/zy_effect/lzpdk_effect_shunziliandui.plist")
    loadSpriteFrameFile("pk_luzhoupdk/res/ui/zy_effect/lzpdk_effect_plan.plist")

    --
	local rule = self.roomInfo.specialRule
	-- 是否选择三不带全
    self.ruleIsNotEnough = true--getNumBand(rule, 0x0008)>0
    -- 炸弹可拆
    self.ruleIsChaiBomb = getNumBand(rule, 0x0004)>0
    -- 是否选择4带3
    self.ruleIsFAT = getNumBand(rule, 0x0002)>0
    -- 玩法模式 经典 15张
    self.ruleType = self.roomInfo.gamerule
    -- 是否选择扎鸟
    self.ruleZhaniao = getNumBand(rule, 0x0001)>0
end

--[[
"recordData" = {
    "dipai"   = ""
    "endtime" = 1525689769
    "ext" = {
        "banker"      = "1025568"
        "clubId"      = 206231
        "deductRule"  = 0
        "gamerule"    = 1
        "playerNum"   = 1
        "specialRule" = 65
        "tableIdx"    = 1
    }
    "flag"    = 0
    "gameid"  = 9
    "idx"     = 1
    "ops"     = "1025568,outCard:{  0x21 0x31 },handType: dui_zi|1024796,outCard:{  0x03 0x33 },handType: dui_zi|1024798,outCard:{  0x05 0x25 },handType: dui_zi|1025568,outCard:{  0x26 0x36 },handType: dui_zi|1024796,outCard:{  0x28 0x38 },handType: dui_zi|1025568,outCard:{  0x1c 0x3c },handType: dui_zi|1025568,outCard:{  0x15 0x19 0x29 0x09 0x2a },handType: three_and_two|1024796,outCard:{  0x11 0x14 0x3b 0x1b 0x2b },handType: three_and_two|1024796,outCard:{  0x02 0x12 0x32 0x35 0x0d },handType: three_and_two|1024796,outCard:{  0x0a 0x3a },handType: dui_zi"
    "pid"     = "2568504031125505"
    "score" = {
        "1024796" = 33
        "1024798" = -28
        "1025568" = -5
    }
    "subid"   = "2550911843082241"
    "turn"    = 1
    "user" = {
        "1024796" = {
            "hand"   = "0x0d 0x1b 0x2b 0x3b 0x0a 0x3a 0x28 0x38 0x35 0x14 0x03 0x33 0x02 0x12 0x32 0x11"
            "seatid" = 1
        }
        "1024798" = {
            "hand"   = "0x2c 0x1a 0x39 0x08 0x18 0x07 0x27 0x06 0x16 0x05 0x25 0x34 0x13 0x23 0x22 0x01"
            "seatid" = 2
        }
        "1025568" = {
            "hand"   = "0x1c 0x3c 0x0b 0x2a 0x09 0x19 0x29 0x17 0x37 0x26 0x36 0x15 0x04 0x24 0x21 0x31"
            "seatid" = 0
        }
    }
}

"playerInfo" = {
    "head" = "http://thirdwx.qlogo.cn/mmopen/vi_32/Q0j4TwGTfTK9s9890abV3nHDBgZFOXuO3eAoCs2SsuFFbp0NUzChuCM4wAEUf02IQI7TYW8gelo75fTxKRQdDA/132"
    "name" = "名52688"
    "sex"  = 1
}
]]
function PdkRoomView:parseData( data )
	local roomInfo = {}
	roomInfo.nTableId = data.roomid
	roomInfo.clubId = data.ext.clubId
	roomInfo.banker = data.ext.banker--庄家
	roomInfo.gamerule = data.ext.gamerule -- 1 经典16张 2 15张玩法
	roomInfo.playnum = data.ext.playnum --0 两人  1 三人
	roomInfo.specialRule = data.ext.specialRule
	roomInfo.tableIdx = data.ext.tableIdx
	roomInfo.allowPass = data.ext.allowPass
	roomInfo.nGameStartCount = data.turn
	roomInfo.nTotalGameNum = data.nbound----------------------------
	roomInfo.deductRule = data.ext.deductRule
	roomInfo.endtime = data.endtime
	roomInfo.nMaxPlayCount = 0
	
	if roomInfo.playnum==1 then
		roomInfo.nMaxPlayCount = 4
	else
		roomInfo.nMaxPlayCount = roomInfo.playnum
	end
	
	for k,v in pairs(data.user) do
		local user = {}
		user.userId = tonumber(k)
		user.seatId = v.seatid
		local cstr = string.split(v.hand, " ")
		user.handCards = {}
		for _,v in ipairs(cstr) do
			if string.len(v) > 0 then
				table.insert(user.handCards, tonumber(v))
			end
		end
		user.leftCards = clone(user.handCards)
		user.leftNum = #user.handCards
		local oinfo = app.playerInfoManager:getPlayerInfo(tonumber(k))
		if oinfo then
			user.headimgurl = oinfo.head
			user.sex = oinfo.sex
			user.nickname = oinfo.name
		end	
		self._room:addPlayer(user)
	end
	roomInfo.nMaxPlayCount = table.nums(data.user)
	self._room:setRoomInfo(roomInfo)
	
	local firstId = false
	app.firstRecordUid = 0
	for k,v in pairs(data.user) do
		local user = {}
		user.userId = tonumber(k)
		if not firstId then
			app.firstRecordUid = user.userId--找到一个uid代替自己的uid，防止没有参加游戏的人看回放了报错
			firstId = true
		end
		user.viewPos = self._room:transPos(v.seatid)
		user.score = data.score[k]
		self._room:addPlayer(user)
	end
	if string.len(data.ops) <=0 then --没开始，提前解散
		-- result data
		local result = {}
		local players = self._room:getPlayers()
		local pt = {}
		for k,v in pairs(players) do
			local d = {}
			d.userId = tonumber(k)
			d.leftCards = clone(v.leftCards)
			d.totalScore = v.score
			d.sex = v.sex
			d.headimgurl = v.headimgurl
			d.nickname = v.nickname
			table.insert(pt, d)
		end
		result.players = pt 
		self._resultData = {response=result} 
		return 
	end

	--op data
	local opStrST = string.split(data.ops, "|")--1025568,outCard:{  0x21 0x31 },handType: dui_zi
	for _,opstr in ipairs(opStrST) do
		local opT = string.split(opstr, ",")
		local uid = opT[1]
		local cardstr = string.gsub(opT[2], "outCard:{  ", "")
		cardstr = string.gsub(cardstr, " }", "")
		local cardstrT = string.split(cardstr, " ")
		local cards = {}
		for _,cid in ipairs(cardstrT) do
			table.insert(cards, tonumber(cid))
		end
		local opstr = string.gsub(opT[3], "handType:", "")
		local opType = tonumber(opstr) or 0
		--
		local user = self._room:getPlayer(uid)
		if user then
			local pdata = {}
			pdata.userId = tonumber(uid)
			pdata.viewPos = user.viewPos
			pdata.seatId = user.seatId
			pdata.cards = cards 
			pdata.opType = opType
			pdata.leftNum = user.leftNum-#cards 

			local tmpLeft = getDelAdB(user.leftCards, cards)
			user.leftCards = clone(tmpLeft)
			user.leftNum = #tmpLeft
			self._room:addPlayer(user)

			local preData = self:getTurnLast()
			if preData then
				local preViewPos = preData.viewPos
				local nextTurn = self._room:getNextTurn(preViewPos)
				if nextTurn==pdata.viewPos then
					self:addTurnData(pdata)
				else--添加要不起
					while nextTurn~=pdata.viewPos do
						preData = self:getTurnLast()
						if preData then
							preViewPos = preData.viewPos
							nextTurn = self._room:getNextTurn(preViewPos)
							local player = self._room:getPlayerVpos(nextTurn)
							local passData = {}
							passData.userId = tonumber(player.userId)
							passData.viewPos = nextTurn
							passData.seatId = player.seatId
							passData.cards = {} 
							passData.opType = 0
							passData.leftNum = player.leftNum
							self:addTurnData(passData)
							nextTurn = self._room:getNextTurn(nextTurn)
						else
							break 
						end
					end
					self:addTurnData(pdata)
				end
			else
				self:addTurnData(pdata)
			end
		end
	end

	-- result data
	local result = {}
	local players = self._room:getPlayers()
	local pt = {}
	for k,v in pairs(players) do
		local d = {}
		d.userId = tonumber(k)
		d.leftCards = clone(v.leftCards)
		d.totalScore = v.score
		d.sex = v.sex
		d.headimgurl = v.headimgurl
		d.nickname = v.nickname
		table.insert(pt, d)
	end
	result.players = pt 
	self._resultData = {response=result} 
	-- 数据备份
	self._backupData = clone(self._turnsQueue)
	-- 总步骤
	self._allOps = #self._turnsQueue
end

function PdkRoomView:resetRoundData()
	-- 上一次出牌viewPos
    self._lastOutPos = 0
    -- 上一次出牌类型
    self._lastOutType = 0
    self._lastCards = {} 
    self.lastOutFlag = -1

    self:cleanSelfCards()
    self:cleanShowCards()
    self:stopTurn()
    self:showOtherCards(false)
    -- 清空玩家时钟
    for _,v in pairs(self._playerNodes) do 
    	v:setTurn(false)
    end
end

function PdkRoomView:getMode()
	return self._room:getRoomInfo().nMaxPlayCount or 4
	--[[local roomInfo = self._room:getRoomInfo()
	if roomInfo.nMaxPlayCount == 2 then
		return 0 
	elseif roomInfo.nMaxPlayCount == 3 then
		return 1
	end 
	return 1--]]
end

function PdkRoomView:initUi()
	self.cardRoot = self.ui.Items.cardRoot
    self.imgOtherCards = self.ui.Items.ImageView_other
    self.txtOtherCards = self.ui.Items.Text_otherNum
    self:showOtherCards(false)

    self.ui.Items.toolPanel:setLocalZOrder(101)

    self.ui.Items.btnReturn:registerClick(handler(self , self.onClickButtonReturn))
	self.ui.Items.btnPlay:registerClick(handler(self , self.onClickButtonPlay))
	self.ui.Items.ButtonToward:registerClick(handler(self , self.onClickButtonToward))

	self.ui.Items.btnDetail:registerClick(handler(self , self.onClickButtonDetails))
	self.ui.Items.btnDetail:setVisible(false)

	self.ui.Items.imgTip:setVisible(false)
	self.ui.Items.imgTip:setOpacity(0)
	self.ui.Items.imgTip:setLocalZOrder(200)

	--添加玩家节点
	local players = self._room:getPlayers()
	for _, info in pairs(players) do
		self:addPlayerNode( info )
	end
end 

function PdkRoomView:updateProgress()
	local over = 0 
	local overOps = self._allOps - self._leftOps
	-- local percent = math.floor((overOps/self._allOps)*100)
	self.ui.Items.Text_jindu:setString(string.format("进度：%d/%d", overOps, self._allOps))
	if overOps==self._allOps then
		showTooltip("回放结束")
	end
end

function PdkRoomView:onClickButtonPlay( sender, flag )
	if flag ~= 1 then
		playBtnEffect()
	end
	if sender.play == nil then
		sender.play = false
	end
	if sender.play then
		sender.play = false
		sender:loadTextureNormal("record_play.png", 1)
		self:stopTurn(false)
	else
		sender.play = true 
		sender:loadTextureNormal("record_pause.png", 1)
		if self._gameResult == true then
			self:resetRoundData()
			self._turnsQueue = clone(self._backupData)
		end
		if self._playStart==true then
			self:stopTurn(false)
			self:startTurns()
		else
			local myself = self._room:getMyself()
			if myself then
				local data = {}
				data.response = {}
				data.response.cards = myself.handCards
				local playerCards = {}
				local players = self._room:getPlayers()
				for _,v in pairs(players) do
					playerCards[v.viewPos] = clone(v.handCards)
				end
				data.response.playerCards = playerCards
				local banker = self._room:getPlayer(self._room:getRoomInfo().banker)
				data.response.bankerSeat = banker.seatId
				self:onResponseSendCards(data)
				self.ui:runDelay(2.5, function() self:startTurns() end )
			end
		end
	end
end

function PdkRoomView:onClickButtonToward( sender )
	playBtnEffect()
	if self.ui.Items.btnPlay.play == nil then
		return
	end
	self.ui.Items.btnPlay.play = true 
	self:onClickButtonPlay( self.ui.Items.btnPlay )
	local data = self:getTurnData()
	if data then 
		self:updateTurns(data)
	else
		self:onResponseGameResult(self._resultData)
	end
	self._leftOps = #self._turnsQueue
	-- show
	self:updateProgress()
	self:stopTurn(false)
end

-- 玩家点击房间详情
function PdkRoomView:onClickButtonDetails( sender )
	playBtnEffect()
	local node = self.ui.Items.btnDetail:getChildByTag(101)
	if node then
	else
		local rule = self:getRuleString()
		local view = import("pk_luzhoupdk.luaScript.Views.Room.Sub.luzhouPdkGameDetailView"):new(rule)
		view:setPosition(cc.p(view:getSizeWidth()+60, 60))
		view:setTag(101)
		self.ui.Items.btnDetail:addChild(view)
	end
end

function PdkRoomView:onClickButtonReturn( sender )
	playBtnEffect()
	self:removeFromParent()
end

--[[获取房间详情字符串--]]
function PdkRoomView:getRuleString()
	local rule = self.roomInfo.specialRule
	local ruleStr = ""
	ruleStr = ruleStr..PdkRoomViewConfig.RoonInfoConfig.play[tonumber(self.roomInfo.gamerule)]..","
	ruleStr = ruleStr..PdkRoomViewConfig.RoonInfoConfig.num[tonumber(self.roomInfo.playnum)]..","
	if getNumBand(rule, 0x0001)>0 then
		ruleStr = ruleStr..PdkRoomViewConfig.CreateParamsMean[0x0001]..","
	end
	if getNumBand(rule, 0x0002)>0 then
		ruleStr = ruleStr..PdkRoomViewConfig.CreateParamsMean[0x0002]..","
	end
	-- if getNumBand(rule, 0x0008)>0 then
	-- 	-- ruleStr = ruleStr..PdkRoomViewConfig.CreateParamsMean[0x0008]..","
	-- end
	if string.len(ruleStr) > 0 then
		ruleStr = string.sub(ruleStr, 1, string.len(ruleStr)-1)
	end
	return ruleStr
end

-- 设置房间信息
function PdkRoomView:setRoomInfo( info )
	self.ui.Items.roomNum:setString(string.format("房号：%06d", info.nTableId))
end

-- 显示轮次
function PdkRoomView:showTurnBtn( is )
	if is then --回放出牌
	end
end

-- 一键截屏
function PdkRoomView:onClickButtonShot( sender )
	playBtnEffect()
	showScreenShot()
end
-- 设置点击
function PdkRoomView:onClickButtonSetting( sender )
	playBtnEffect()
	self:showMenu(false)
	local view = import("pk_luzhoupdk.luaScript.Views.Room.Sub.luzhouPdkSettingView"):new()
	view:setAnchorPoint(cc.p(0.5, 0.5))
	app:showWaitDialog(view)
end
-- 上传日志点击
function PdkRoomView:onClickButtonUlog( sender )
	playBtnEffect()
	self:showMenu(false)
	local view = import("luaScript.Views.Room.UplogView"):new()
	view:setAnchorPoint(cc.p(0.5, 0.5))
	app:showWaitDialog(view)
end

-- 变暗不能出的牌
function PdkRoomView:downCanotOuts(canotOuts, isTouch)
	for _,v in pairs(canotOuts) do
		local node = self:getCardNode(v)
		if node then node:setNoTouch(isTouch) end
	end
end

function PdkRoomView:bindEvents()
	-- 游戏设置里更换桌面
	-- self:bindEvent(app.room , "pdkNormalEvent_changeDesktop" ,	handler(self , self.onNormalChangeDesktop))
end

-- 更换桌面
function PdkRoomView:onNormalChangeDesktop( data )
	--if data.idx >5 and data.idx<1 then return end 
	local changeDesk = tonumber(loadUserInfo("lzpdk_setting_bg_idx")) or 2
	self.ui.Items.ImageView_bg:loadTexture(string.format("pk_luzhoupdk/res/ui/zy_game/lzpdk_gamebg_%d.jpg", changeDesk), 0)
end

-- 通知玩家分数
function PdkRoomView:onResponseUpdateScore( data )
	local msg = data.response
	for _,pdata in ipairs(msg.players) do
		local node = self:getPlayerNode(pdata.userId)
		if node then node:setScore(pdata.totalScore) end
	end
end

-- 给玩家发牌
function PdkRoomView:onResponseSendCards( data )
	self._leftOps = self._allOps
	self:updateProgress()
	self:cleanOtherHands()
	self._gameResult = false
	self._passGameResult = nil 
	self._playStart = true 
	self.ui.Items.ButtonToward:setEnabled(false)
	for viewPos,v in pairs(data.response.playerCards) do
		self:sendCards(v, viewPos)
	end

	local bankerData = self._room:getPlayerCid(data.response.bankerSeat)
	for _,v in pairs( self._playerNodes ) do 
		v:setBanker(v:getInfo().userId==bankerData.userId)
		v:setTurn(false)
		v:setScore(0)
	end
	if self._room:isMyself(bankerData.userId) then
		self:runAction(cc.Sequence:create(cc.DelayTime:create(1), cc.CallFunc:create(function ()
			self:showTurnBtn(true)
			local node = self:getPlayerNodeVpos(1)
			if node then node:setTurn(true) end
		end)))
	else
		self:showTurnBtn(false)
		self:runAction(cc.Sequence:create(cc.DelayTime:create(1), cc.CallFunc:create(function ()
			local node = self:getPlayerNode(bankerData.userId)
			if node then node:setTurn(true) end
		end)))
	end 
	-- 发完牌后显示牌张数
	self.ui:runDelay(2, function ()
		local left = 13
		--if self.ruleType==2 then left = 15 end
		for uid,v in pairs(self._playerNodes) do 
			v:showLeft(left)
			self.ui.Items.ButtonToward:setEnabled(true)
		end
	end)
end

-- 将回放数据按照先后顺序处理成串行以便调度器调用
function PdkRoomView:addTurnData( data )
	table.insert(self._turnsQueue, data)
end

function PdkRoomView:getTurnData( isRemove )
	local data = nil 
	if #self._turnsQueue > 0 then
		data = clone(self._turnsQueue[1])
		if isRemove==nil then
			table.remove(self._turnsQueue, 1)
		end
	end
	return data 
end

function PdkRoomView:getTurnLast()
	local data = nil 
	if #self._turnsQueue > 0 then
		data = clone(self._turnsQueue[#self._turnsQueue])
	end
	return data 
end

function PdkRoomView:startTurns()
	local data = self:getTurnData()
	if data then 
		self:updateTurns(data)
	else
		return 
	end
	if not self._turnTimer then
		self._turnTimer = cc.Director:getInstance():getScheduler():scheduleScriptFunc(function()
			----------------------
			local data = self:getTurnData()
			if data then 
				self:updateTurns(data)
			else
				self:stopTurn()
				self:onResponseGameResult(self._resultData)
			end
		end,2,false)
	end
end

function PdkRoomView:stopTurn(isClean)
	isClean = isClean or true
	if self._turnTimer then
		cc.Director:getInstance():getScheduler():unscheduleScriptEntry(self._turnTimer)
		self._turnTimer = nil 
		if isClean then self._cmdQueue = {} end
	end
end

--[[
	,defVar("selfId", VT_Int, 0)--自己ID 
	,defVar("userId", VT_Int, 0)
	,defVar("cardType", VT_Short, 0)
	,defVar("leftNum", VT_Short, 0)--出牌者剩余多少张牌
	,defVar("cards", VT_Vector(VT_UChar), {})

	passData.userId = tonumber(player.userId)
	passData.viewPos = nextTurn
	passData.seatId = player.seatId
	passData.cards = {} 
	passData.opType = 0
]]
-- 处理是否是出牌，如果出牌，则显示对应玩家出牌，如果是pass,显示对应玩家pass
function PdkRoomView:updateTurns( data )
	local msg = data
	self._leftOps = #self._turnsQueue
	self:updateProgress()
	self.lastOutFlag = msg.opType--操作类型
	local viewPos = data.viewPos
	local node = self:getPlayerNode(data.userId)
	self:showTurns(viewPos)
	if node then
		local function show()
			if viewPos == 1 then--自己能出牌
				if self._lastOutPos == 1 then
					self:cleanLastCards()
					self.lastOutFlag = -1
				end
				self:clearPosShow(1)
				self:showTurnBtn(true)
			else--别人能出牌，对应位置出牌
				self:showTurnBtn(false)
			end
			local outData = {}
			outData.selfId = self._room:getMyself().userId
			outData.userId = msg.userId
			outData.cardType = msg.opType
			outData.leftNum = msg.leftNum
			outData.cards = clone(msg.cards)
			self:onResponseOutCards({response=outData})
		end
		local function passShow()
			if viewPos == 1 then
				self:showEffect(viewPos, ETS.PASS)
				self:showPass()
				self:cleanLastCards(false)
			else
				self:showEffect(viewPos, ETS.PASS)
			end
		end
		if msg.opType == 0 then
			node:runAction(cc.Sequence:create(cc.DelayTime:create(0.1), cc.CallFunc:create(passShow)))
		else
			show()
		end
	end
end

-- 显示轮次时钟
function PdkRoomView:showTurns( viewPos )
	for _,node in pairs(self._playerNodes) do
		local is = node:getInfo().viewPos==viewPos
		node:setTurn(is)
		if is then self:clearPosShow(viewPos) end
	end
end

-- 广播当前桌子轮次@userId@seatId@outFlag
function PdkRoomView:onResponseUpdateTurns( data )
	self:addTurn(data)
end

-- 清理上一次的出牌
function PdkRoomView:cleanLastCards(isClean)
	if isClean==nil then isClean = true end
	if self._lastOutPos > 0 then
		if isClean == true then 
			self:clearPosShow(self._lastOutPos) 
		end
		self._lastCards = {}
		self._lastOutType = 0
		self._lastOutPos = 0
	end
end

-- 玩家出牌成功
function PdkRoomView:onResponseOutCards( data )
	local msg = data.response
	local isContinue = #self._lastCards>0 and self._lastOutType>0
	-- 清理上一次的出牌
	self:cleanLastCards()
	if msg.isMustBomb and msg.isMustBomb == 1 then
		msg.cardType = ETS.NONE
	end
	local viewPos = self._room:getPlayer(msg.userId).viewPos
	-- 缓存上次出的牌
	self._lastOutPos = viewPos
	self._lastOutType = msg.cardType
	self._lastCards = msg.cards

	self:showTurns(0)
	if #msg.cards <= 0 then
		msg.cardType = 0
	end
	self:showCards(msg.cards, viewPos, msg.cardType, isContinue)
	
	--玩家剩余牌
	local node = self:getPlayerNode(msg.userId)
	if node then
		if not node:isAlarm() and msg.leftNum==1 then
			if self:getMode()==0 then
				if node:getInfo().viewPos==2 then PdkSoundHelper:single( node:getInfo().sex ) end
			elseif self:getMode()==1 then
				if node:getInfo().viewPos==3 then PdkSoundHelper:single( node:getInfo().sex ) end
			end
		end
		node:showLeft(msg.leftNum)
	end
	if viewPos == 1 then--判断是否自己出牌
		self:showTurnBtn(false)
		for _,v in pairs(msg.cards) do
			self:removeCardNode(v)
		end
		if msg.leftNum==1 then
			PdkSoundHelper:single( node:getInfo().sex )
		end
		--还原不可点
		self:downCanotOuts(self:getHandCards(), false)
		self:resetCardsPos()
	else
		self:removeOtherCards(viewPos, msg.cards)
	end

	-----------
	-- local d = self:getTurnData(false) 
	-- if d then
	-- 	local msg = d
	-- 	if self.lastOutFlag ~= 0 then--连续两次要不起要间隔
	-- 		if msg.opType == 0 then
	-- 			self:stopTurn(false)
	-- 			self:startTurns()
	-- 			return 
	-- 		end
	-- 	end
	-- end
end

-- 玩家自己显示要不起
function PdkRoomView:showPass()
	self.ui.Items.imgTip:setOpacity(0)
	self.ui.Items.imgTip:setVisible(true)
	local ac = cc.Sequence:create(cc.FadeIn:create(0.2), cc.DelayTime:create(1), cc.FadeOut:create(0.2))
	self.ui.Items.imgTip:runAction(ac)
	--手牌变暗
	local anFunc = function () 
		for k,v in pairs(self._selfCards) do
			v:setNoTouch(true)
		end
	end

	local mingFunc = function ()
		for k,v in pairs(self._selfCards) do
			v:setNoTouch(false)
		end
	end
	local ac = cc.Sequence:create(cc.CallFunc:create(anFunc), cc.DelayTime:create(0.1), cc.CallFunc:create(mingFunc))
	self.cardRoot:runAction(ac)
end

-- cards@单张或者对子需要
function PdkRoomView:showEffect( viewPos, effectType, dltWidth, cards, isContinue )
	if dltWidth == nil then
		dltWidth = 50
	end
	local rate = math.random(100)
	local stdRate = 70
	isContinue =  isContinue or false
	local pNode = self:getPlayerNodeVpos(viewPos)
	if pNode==nil then return end 
	local pInfo = pNode:getInfo()
	local sex = pInfo.sex
	local node = nil 
	if effectType == ETS.PASS then
		local cb = function ()
			local node = self:getPlayerNodeVpos(viewPos)
			if node then node:setTurn(false) end
		end
		node = PdkEffectHelper:getPass(cb)
		local idx = math.random(4)
		PdkSoundHelper:effectPass( sex, idx )
	elseif effectType == ETS.SINGLE_CARD then
		local _, val = pokerParse(cards[1])
		PdkSoundHelper:effectSingle( sex ,val )
	elseif effectType == ETS.DUI_ZI then
		local _, val = pokerParse(cards[1])
		if isContinue and rate >= stdRate and PdkSoundHelper:getLanguageType() == 1 then
			PdkSoundHelper:daNi( sex )
		else
			PdkSoundHelper:effectDouble( sex, val )
		end
	elseif effectType == ETS.SHUN_ZI then
		node = PdkEffectHelper:getShunzi()
		if viewPos==1 and node then
			node:setScale(1.2)
		end
		if isContinue and rate>=stdRate and PdkSoundHelper:getLanguageType() == 1 then
			PdkSoundHelper:daNi( sex )
		else
			PdkSoundHelper:effectShunzi( sex )
		end
	elseif effectType == ETS.LIAN_DUI then
		node = PdkEffectHelper:getLiandui()
		if isContinue and rate>=stdRate and PdkSoundHelper:getLanguageType() == 1 then
			PdkSoundHelper:daNi( sex )
		else
			PdkSoundHelper:effectLiandui( sex )
		end
	elseif effectType == ETS.THREE_AND_TWO or effectType == ETS.THREE_AND_DUI or effectType == ETS.THREE then
		--根据牌获取是否是三带一或三个
		local tp = PokerUtil:checkType(cards)
		if tp == ETS.THREE_AND_ONE then
			node = PdkEffectHelper:getSandaiyi()
			PdkSoundHelper:effect3And1( sex )
		elseif tp == ETS.THREE_AND_TWO or tp == ETS.THREE_AND_DUI then
			node = PdkEffectHelper:getSandaier()
			if isContinue and rate>=stdRate and PdkSoundHelper:getLanguageType() == 1 then
				PdkSoundHelper:daNi( sex )
			else
				PdkSoundHelper:effect3And2( sex,effectType )
			end
		elseif tp == ETS.THREE then
			local _, val = pokerParse(cards[1])
			PdkSoundHelper:effectThree( sex, val )
		end
	elseif effectType == ETS.FOUR_AND_THREE then
		node = PdkEffectHelper:getSidaisan()
		PdkSoundHelper:effect4And3( sex )
	elseif effectType == ETS.BOMB then
		node = PdkEffectHelper:getBomb()
		PdkSoundHelper:effectBomb( sex )
	elseif effectType == ETS.AIRPLANE then
		node = PdkEffectHelper:getPlan()
		PdkSoundHelper:effectPlane( sex )
	elseif effectType == ETS.FOUR_AND_ONE then --四带一
		node = PdkEffectHelper:getSidaiyi()
		PdkSoundHelper:effect4And1( sex )
--[[	elseif effectType == ETS.SPRING_HUA then
		node = PdkEffectHelper:getSpring()--]]
	end
	if node then
		local pt = clone(PdkRoomViewConfig.SHOW_CARD_POS[self:getMode()][viewPos])
		if self:getMode() >= 2 then
			pt = clone(PdkRoomViewConfig.RECORD_SHOW_CARD_POS4[self:getMode()][viewPos])
		end
		if effectType~=ETS.PASS then
			if effectType==ETS.SHUN_ZI then
				if viewPos == 2 then 
					-- if self:getMode()==0 then
					-- 	pt.x = pt.x
					-- else
						pt.x = pt.x - dltWidth*2
					-- end
				elseif viewPos == 3 then
					pt.x = pt.x
				else
					pt.x = pt.x-50
					pt.y = 320*g_radio_y
				end
			else
				if viewPos == 2 then 
					-- if self:getMode()==0 then
						-- pt.x = pt.x + dltWidth
					-- else
						pt.x = pt.x - dltWidth
					-- end
				elseif viewPos == 3 or viewPos == 4 then
					pt.x = pt.x + dltWidth
				end

			end
			pt.y = pt.y - (PdkRoomViewConfig.CARD_HEIGHT/5*1)*PdkRoomViewConfig.CARD_SCALE[2]
			if effectType==ETS.BOMB then
				pt.y = (pt.y+120)*g_radio_y
			end
			if viewPos == 1 then
				pt.x = CENTER_X 
				pt.y = 300*g_radio_y
			end 
		else
			pt.y = pt.y + 40
			if effectType==ETS.PASS then
				if viewPos == 1 then
					pt.y = 300*g_radio_y--自己pass位置调整
					pt.x = CENTER_X
				else
					if viewPos == 2  then --and self:getMode()==1
						pt.x = pt.x-80
						pt.y = (pt.y + 50)*g_radio_y
					end
					pt.y = (pt.y - 50)*g_radio_y
				end
			end
		end
		node:setPosition(pt)
		self:addChild(node)
		if node.onEnter and type(node.onEnter)=='function' then
			node:onEnter()
		end
	end
end

function PdkRoomView:cleanOtherHands()
	for _,hands in ipairs(self._otherCards) do 
		for _,node in ipairs(hands) do
			if node and node.getParent and node:getParent() then
				node:removeFromParent()
			end
		end
	end
	self._otherCards = {{}, {}, {}, {}}
end
-- 游戏单局结算
function PdkRoomView:onResponseGameResult( data )
	if self._gameResult==true then 
		return
	end
	self.ui.Items.btnPlay.play = false
	self.ui.Items.btnPlay:loadTextureNormal("record_play.png", 1)
	self:stopTurn(false)
	self._playStart = false
	self._gameResult = true 
	local msg = data.response
	for _,v in pairs(msg.players) do
		local node = self:getPlayerNode(v.userId)
		if node then
			node:setScore(v.totalScore)
			node:setTurn(false)
		end
		node:hideLeft()
	end
end

-- 总结算
function PdkRoomView:onResponseGameOver( data )
	local msg = data.response
	for _,player in ipairs(msg.players) do
		local pdata = self._room:getPlayer(player.userId)
		player.unionid = pdata.unionid
		player.headimgurl = pdata.headimgurl
		player.gpsInfo = pdata.gpsInfo
		player.sex = pdata.sex
		player.openid = pdata.openid
		player.nickname = pdata.nickname
		player.areano = pdata.areano
	end
	-- 缓存结算信息
	self._isGameOver = true 
	self._gameOverData = msg
	local roomInfo =  self.roomInfo
	self._gameOverData.nShowTableId = roomInfo.nTableId
	self._gameOverData.startCount = roomInfo.nGameStartCount
	self._gameOverData.totalCount = roomInfo.nTotalGameNum
	self._gameOverData.roomRule = self:getRuleString()
	if self._gameResult==false then--已经展示过小结算后解散房间
		self:onNormalShowGameOver()
	end
end

--[[先显示小局结算，再显示总结算--]]
function PdkRoomView:onNormalShowGameOver( data )
	self._gameResult = false
	local showFunc = function (msg)
		local view = import("pk_luzhoupdk.luaScript.Views.Room.Sub.luzhouPdkGameOverView"):new(msg)
		view:setAnchorPoint(cc.p(0.5, 0.5))
		app:showWaitDialog(view)
	end
	if self._isGameOver and self._gameOverData then
		showFunc(self._gameOverData)
	end
end

----------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------
-- 单局结算显示剩余牌
function PdkRoomView:showLeftCards( pos, cards )
	self:showTurnBtn(false)
	if #cards <=0 then return end 
	self:clearPosShow(pos)
	if  pos==2 then --self:getMode()==1 and
		local tmp = {}
		for _,v in ipairs(cards) do
			table.insert(tmp, 1, v)
		end
		cards = tmp 
	end
	local scaleWdt = PdkRoomViewConfig.CARD_DLT_WIDTH*PdkRoomViewConfig.CARD_SCALE[2]
	local root = cc.Node:create()
	local nodes = {}
	for i,card in ipairs(cards) do
		local node = self:genCard(card)
		local pt = cc.p(0, 0)
		if  pos==1 then --self:getMode() == 0 or
			pt.x = pt.x + (i-1)*scaleWdt
			node:setLocalZOrder(100+i)
		else
			if i>=9 then
				pt.y = pt.y - 80
				if pos ~= 2 then
					pt.x = pt.x + (i-math.floor(i/9)*9)*scaleWdt
				else
					pt.x = pt.x - (i-math.floor(i/9)*9)*scaleWdt
					node:setLocalZOrder(36-i)
				end
			else
				if pos ~= 2 then
					pt.x = pt.x + (i-math.floor(i/9)*9-1)*scaleWdt
				else
					pt.x = pt.x - (i-math.floor(i/9)*9-1)*scaleWdt
					node:setLocalZOrder(16-i)
				end
			end
		end
		node:setScale(PdkRoomViewConfig.CARD_SCALE[2])
		node:setPosition(pt)
		root:addChild(node)
		node:setVisible(false)
		table.insert(nodes, node)
	end
	local dltWidth = 0
	local rpt = clone(PdkRoomViewConfig.SHOW_CARD_POS[self:getMode()][pos])
	if pos == 1 then
		rpt.x = 200
		rpt.y = 110
	else
		dltWidth = #cards/2*scaleWdt
	end
	root:setPosition(rpt)
	self.cardRoot:addChild(root)
	table.insert(self._showCards[pos], root)
	for i,v in ipairs(nodes) do
		v:runAction(cc.Sequence:create(cc.DelayTime:create((i-1)*0.05), cc.CallFunc:create(function ()
				v:setVisible(true)
		end)))
	end
end

-- 根据位置显示一组牌 cards@出牌牌组  pos@出牌视角位置  tp@出牌的类型isContinue@是否接牌
function PdkRoomView:showCards( cards, pos, tp, isContinue )
	self:clearPosShow(pos)
	self._lastCards =cards 
	self._lastOutType = tp
	if pos==2 then -- self:getMode()==1 and
		local tmp = {}
		for _,v in ipairs(cards) do
			table.insert(tmp, 1, v)
		end
		cards = tmp 
	end
	local root = cc.Node:create()
	local scale = PdkRoomViewConfig.CARD_SCALE[2]
	local allCount = #cards
	for i,card in ipairs(cards) do
		local node = self:genCard(card)
		local pt = cc.p(0, 0)
		if pos == 1 then
			local midIdx = allCount/2
			if i<midIdx then--左边
				pt.x = 0 - (midIdx-i-1)*PdkRoomViewConfig.CARD_DLT_WIDTH*scale 
			else--右边
				pt.x = 0 + (i-midIdx+1)*PdkRoomViewConfig.CARD_DLT_WIDTH*scale
			end
			pt.x = pt.x - PdkRoomViewConfig.CARD_WIDTH/2*scale
		else
			if pos ==2 then -- self:getMode()==1 and
				node:setLocalZOrder(16-i)
				pt.x = pt.x - (i-1)*PdkRoomViewConfig.CARD_DLT_WIDTH*scale
			else
				pt.x = pt.x + (i-1)*PdkRoomViewConfig.CARD_DLT_WIDTH*scale
			end
		end
		node:setScale(scale)
		node:setPosition(pt)
		root:addChild(node)
	end
	local dltWidth = 0
	local rpt = clone(PdkRoomViewConfig.SHOW_CARD_POS[self:getMode()][pos])
	if self:getMode() >= 2 then
		rpt = clone(PdkRoomViewConfig.RECORD_SHOW_CARD_POS4[self:getMode()][pos])
	end
	if pos == 1 then
		rpt = cc.p(CENTER_X, 320*g_radio_y)
	else
		dltWidth = math.floor(#cards/2)*PdkRoomViewConfig.CARD_DLT_WIDTH*scale
	end
	root:setPosition(rpt)
	self.cardRoot:addChild(root)
	table.insert(self._showCards[pos], root)
	--牌型动画
	self:showEffect(pos, tp, dltWidth, cards, isContinue)
end

-- 清除某玩家的出牌
function PdkRoomView:clearPosShow(pos)
	local nodes = self._showCards[pos]
	for _,v in ipairs(nodes) do
		if v:getParent() then v:removeFromParent() end
	end
	self._showCards[pos] = {}
end


-- 添加玩家节点
function PdkRoomView:addPlayerNode( pInfo )
	local node = self._playerNodes[tonumber(pInfo.userId)]
	if node then return end 
	node = PdkPlayerNode:new()
	local rule = self._room:getRoomInfo().specialRule
	local allowPass = self._room:getRoomInfo().allowPass
	node:setGameInfo(json.encode({allowPass=allowPass}))
    node:setMaxPlayerCount(self._room:getRoomInfo().nMaxPlayCount)
    node:setShowNum(getNumBand(rule, 0x0020)>0)--是否显示牌张数
    node:setInfo(pInfo)

	node:setReady(pInfo.playFlag==1)
	node:setHost(pInfo.userId==self.roomInfo.nRoomOwnedUid)
	node:setPosition(PdkRoomViewConfig.PLAYER_POS[self:getMode()][pInfo.viewPos])
	self._playerNodes[pInfo.userId] = node
	node:setLocalZOrder(10)
	self.ui.Items.toolPanel:getParent():addChild(node)
end

-- 删除玩家节点
function PdkRoomView:delPlayerNode( uid )
	if self._gameResult or self._isGameOver then return end 
	local node = self._playerNodes[uid]
	if not node then return end 
	node:removeFromParent()
	self._playerNodes[uid] = nil 
end

-- 获取玩家节点
function PdkRoomView:getPlayerNode( uid )
	return self._playerNodes[tonumber(uid)]
end

-- 根据视图获取玩家节点
function PdkRoomView:getPlayerNodeVpos( viewPos )
	for _,v in pairs(self._playerNodes) do
		if v:getInfo().viewPos==viewPos then
			return v
		end
	end
	return nil 
end

-- 发牌
function PdkRoomView:sendCards( cards_, pos )
	local cards = pokerSortPdkCards(cards_)
	local CardsCount = #cards 
	for i,card in ipairs(cards) do
		local ac = cc.Sequence:create(cc.DelayTime:create(i*0.05), cc.CallFunc:create(function ()
			self:sendOneCard(card.cid, i, pos, i==CardsCount, CardsCount)
			if self:getMode()==0 then
				-- if i==CardsCount then self:showOtherCards(true) end
			end
		end))
		self.cardRoot:runAction(ac)
	end
end

-- 发一张牌
function PdkRoomView:sendOneCard( card, i, pos, islast, allCount )
	-- local node = self:genCard(card)
	local node = self:genCard(-1)--back
	node.cid = card
	node:setScale(PdkRoomViewConfig.CARD_SCALE[pos])--PdkRoomViewConfig.CARD_SCALE_START
	node:setLast(islast)
	local endX = CENTER_X + (allCount-allCount/2+1)*PdkRoomViewConfig.CARD_DLT_WIDTH*PdkRoomViewConfig.CARD_SCALE[1]
	local pt = cc.p(0, 0)
	local mode = self:getMode()
	local otherScale = 0.4
	if pos ~= 1 then
		node:setScale(otherScale)
		pt = clone(PdkRoomViewConfig.CARD_POS[mode][pos])
		-- if mode==0 then--两人
		-- 	pt.x = pt.x + i*PdkRoomViewConfig.CARD_DLT_WIDTH*otherScale
		-- 	node:setLocalZOrder(i)
		-- else--三人
			if pos == 2 then
				pt.x = pt.x - i*PdkRoomViewConfig.CARD_DLT_WIDTH*otherScale
				node:setLocalZOrder(16-i)
			else
				pt.x = pt.x + i*PdkRoomViewConfig.CARD_DLT_WIDTH*otherScale
				node:setLocalZOrder(i)
			end
		-- end
	else
		pt.x = CENTER_X
		local midIdx = allCount/2
		if i<=midIdx then--左边
			pt.x = pt.x - (midIdx-i-1)*PdkRoomViewConfig.CARD_DLT_WIDTH*PdkRoomViewConfig.CARD_SCALE[1]
		else--右边
			pt.x = pt.x + (i-midIdx+1)*PdkRoomViewConfig.CARD_DLT_WIDTH*PdkRoomViewConfig.CARD_SCALE[1]
		end
		pt.x = pt.x - PdkRoomViewConfig.CARD_WIDTH/2*PdkRoomViewConfig.CARD_SCALE[1]

		pt.y = PdkRoomViewConfig.CARD_POS[mode][pos].y
		node:setLocalZOrder(i)
	end
	node:setPosition(cc.p(endX, pt.y))
	node:setOpacity(0)
	self.cardRoot:addChild(node)
	
	local ac = nil 
	if pos ~=1 then
		ac = cc.Sequence:create(cc.Spawn:create(cc.MoveTo:create(0.1, pt), cc.FadeIn:create(0.1)), cc.CallFunc:create(function ()
			table.insert(self._otherCards[pos], node)
			PdkSoundHelper:playSend()
		end), cc.DelayTime:create((allCount-i)*0.08), cc.CallFunc:create(function() node:setCard(node.cid) end ))
		node:runAction(ac)
	else
		ac = cc.Sequence:create(cc.Spawn:create(cc.MoveTo:create(0.1, pt), cc.FadeIn:create(0.1)), cc.CallFunc:create(function ()
			table.insert(self._selfCards, node)
			PdkSoundHelper:playSend()
		end), cc.DelayTime:create((allCount-i)*0.08), cc.CallFunc:create(function() node:setCard(node.cid) end ))
		node:runAction(ac)
	end
end

-- 发一张牌没有动画
function PdkRoomView:sendOneCardNoAct( card, i, pos, islast, allCount )
	local node = self:genCard(card)
	node:setScale(PdkRoomViewConfig.CARD_SCALE[pos])
	node:setLast(islast)
	local pt = cc.p(0, 0)
	if pos ~= 1 then
		pt = clone(PdkRoomViewConfig.CARD_POS[self:getMode()][pos])
	else
		local midIdx = math.floor(allCount/2)
		if i<midIdx then--左边
			pt.x = CENTER_X - (midIdx-i-1)*PdkRoomViewConfig.CARD_DLT_WIDTH*PdkRoomViewConfig.CARD_SCALE[pos]
		else--右边
			pt.x = CENTER_X + (i-midIdx+1)*PdkRoomViewConfig.CARD_DLT_WIDTH*PdkRoomViewConfig.CARD_SCALE[pos]
		end
		pt.x = pt.x - PdkRoomViewConfig.CARD_WIDTH/2*PdkRoomViewConfig.CARD_SCALE[pos]
		pt.y = PdkRoomViewConfig.CARD_POS[1][pos].y
	end
	node:setPosition(pt)
	node:setLocalZOrder(i)
	self.cardRoot:addChild(node)
	table.insert(self._selfCards, node)
end

-- 创建一张牌
function PdkRoomView:genCard( card )
	local node = PdkCardNode:new()
	node:setCard(card)
	node:setSelectedHeight(PdkRoomViewConfig.SELECTED_HEIGHT)
	node:setNormalHeight(PdkRoomViewConfig.NORMAL_HEIGHT)
	return node 
end

-- 从手牌中获取一张牌
function PdkRoomView:getCardNode( card )
	if card > 0x00 and card <= 0x3d then
		for _,v in pairs(self._selfCards) do
			if v:getVal()==card then return v end
		end
		return nil 
	else
		return nil 
	end
end

-- 根据牌ID移除一张手牌，并重新调整手牌位置
function PdkRoomView:removeCardNode( card )
	local node = self:getCardNode(card)
	if not node then return end
	for i=#self._selfCards,1,-1 do
		if self._selfCards[i]:getVal()==card then
			table.remove(self._selfCards, i)
			break
		end
	end
	node:removeFromParent()
	--reset pos
	self:resetCardsPos()
end

-- 移除牌
function PdkRoomView:removeOtherCards( viewPos, cards )
	local nodeSet = self._otherCards[viewPos]
	for _,card in ipairs(cards) do
		if card > 0x00 and card <= 0x3d then
			for _,v in pairs(nodeSet) do
				if v:getVal()==card then 
					for i=#nodeSet,1,-1 do
						if nodeSet[i]:getVal()==card then
							table.remove(nodeSet, i)
							break
						end
					end
					v:removeFromParent()
				end
			end
		end
	end
	local pos = viewPos
	local mode = self:getMode()
	local otherScale = 0.4
	for i,v in ipairs(nodeSet) do
		local pt = cc.p(0, 0)
		if pos ~= 1 then
			pt = clone(PdkRoomViewConfig.CARD_POS[mode][pos])
			-- if mode==0 then--两人
				-- pt.x = pt.x + i*PdkRoomViewConfig.CARD_DLT_WIDTH*otherScale
				-- v:setLocalZOrder(i)
			-- else--三人
				if pos == 2 then
					pt.x = pt.x - i*PdkRoomViewConfig.CARD_DLT_WIDTH*otherScale
					v:setLocalZOrder(16-i)
				else
					pt.x = pt.x + i*PdkRoomViewConfig.CARD_DLT_WIDTH*otherScale
					v:setLocalZOrder(i)
				end
			-- end
			v:setPosition(pt)
		end
	end
end

-- 获取当前手牌
function PdkRoomView:getHandCards()
	local handCards = {}
	for _,v in pairs(self._selfCards) do
		table.insert(handCards, v:getVal())
	end
	return handCards
end

-- 重置手牌位置
function PdkRoomView:resetCardsPos( )
	if #self._selfCards<=0 then return end 
	local mode = self:getMode()
	local pos = 1
	local scale = PdkRoomViewConfig.CARD_SCALE[pos]
	local dtpx = (16 - #self._selfCards)/2*PdkRoomViewConfig.CARD_DLT_WIDTH*scale
	local allCount = #self._selfCards
	local midIdx = allCount/2
	for i,v in ipairs(self._selfCards) do
		local pt = cc.p(CENTER_X, 0)
		if i<midIdx then--左边
			pt.x = pt.x - (midIdx-i-1)*PdkRoomViewConfig.CARD_DLT_WIDTH*scale
		else--右边
			pt.x = pt.x + (i-midIdx+1)*PdkRoomViewConfig.CARD_DLT_WIDTH*scale
		end
		pt.x = pt.x - PdkRoomViewConfig.CARD_WIDTH/2*scale
		pt.y = PdkRoomViewConfig.CARD_POS[self:getMode()][pos].y
		v:setPosition(pt)
		v:setLast(i==allCount)
		v:setNormal()
	end
end

-- 提示对应的牌
function PdkRoomView:tipCards( cards )
	self:resetCardsPos()
	for _,v in pairs(cards) do
		local node = self:getCardNode(v.cid)
		if node and node:getVal()>0 then
			self._selectCards[node:getVal()] = node
			node:setDown()
		end
	end
end

-- 清除所有牌
function PdkRoomView:cleanSelfCards()
	for _,v in pairs(self._selfCards) do
		if v:getParent() then v:removeFromParent() end 
	end
	self._selfCards = {}
end
function PdkRoomView:cleanShowCards()
	for _,v in pairs(self._showCards) do
		for _,vv in pairs(v) do
			if vv and vv:getParent() then
				vv:removeFromParent()
			end
		end
	end
	self._showCards = {{},{},{},{}}
end

-- 二人玩显示另外一组牌
function PdkRoomView:showOtherCards(is)
	if is then
		self.imgOtherCards:setVisible(true)
		local num = 13
		--if self.ruleType==2 then num = 15 end
		self.txtOtherCards:setString(string.format("剩余%d张", num))
	else
		self.imgOtherCards:setVisible(false)
	end
end

function PdkRoomView:onEnter()
	PdkRoomView.super.onEnter()
	PokerUtil = require("pk_luzhoupdk.luaScript.Views.Room.luzhouPokerUtil"):new({isChai=self.ruleIsChaiBomb, isFAT=self.ruleIsFAT}) 
	self:bindEvents()

	local changeDesk = tonumber(loadUserInfo("lzpdk_setting_bg_idx")) or 2
	self:onNormalChangeDesktop({idx=changeDesk-1})
	PdkSoundHelper:playBgMusic()

	local roomInfo = self._room:getRoomInfo()
	self.ui.Items.systemTime:setText(string.format("%s    局数：%d/%d", os.date("%m-%d %H:%M:%S", roomInfo.endtime), roomInfo.nGameStartCount or 0, roomInfo.nTotalGameNum or 0 ))
	-- 默认开始回放
	self:onClickButtonPlay( self.ui.Items.btnPlay, 1 )
end

function PdkRoomView:onExit()
	if self.Time then
		cc.Director:getInstance():getScheduler():unscheduleScriptEntry(self.Time)
		self.Time = nil 
	end

	if self._gameResultTimer then
		cc.Director:getInstance():getScheduler():unscheduleScriptEntry(self._gameResultTimer)
		self._gameResultTimer = nil 
	end

	for _,node in pairs(self._playerNodes) do 
		if node then node:setTurn(false) end
	end
	self:stopTurn()
	PokerUtil = nil 
	
	stopBGMusic()
end

return PdkRoomView