1446 lines
51 KiB
Lua
1446 lines
51 KiB
Lua
---
|
|
--- Created by 谌建军.
|
|
--- DateTime: 2017/12/13 17:04
|
|
---
|
|
local EXPlayerPokerInfoView = import('.EXPlayerPokerInfoView')
|
|
local EXCardType = import('.EXCardType')
|
|
local EXCardCheck = import(".CardCheck")
|
|
|
|
local CardView = {
|
|
btn_card = nil,
|
|
-- 牌号码 （大小）
|
|
card_code_number = 0,
|
|
-- 牌号码 （花色）
|
|
card_code_flower = 0,
|
|
-- 索引
|
|
index = 0
|
|
}
|
|
|
|
local function NewCardView(card, cardcodenum, cardcodeflower)
|
|
local self = {}
|
|
setmetatable(self, { __index = CardView })
|
|
self.btn_card = card
|
|
self.card_code_number = cardcodenum
|
|
self.card_code_flower = cardcodeflower
|
|
self.card_isTouchable = 0
|
|
return self
|
|
end
|
|
|
|
local function tableSortNumber(a, b)
|
|
return a.card_code_number > b.card_code_number
|
|
end
|
|
|
|
local EXPlayerSelfPokerInfoView = {
|
|
_view = nil,
|
|
_mainView = nil,
|
|
_mask_liangpai = nil
|
|
}
|
|
|
|
local M = EXPlayerSelfPokerInfoView
|
|
|
|
function M.new(view, mainView)
|
|
setmetatable(M, { __index = EXPlayerPokerInfoView })
|
|
local self = setmetatable({}, { __index = M })
|
|
self._view = view
|
|
self._mainView = mainView
|
|
self.gameCtr = ControllerManager.GetController(GameController)
|
|
self:init()
|
|
return self
|
|
end
|
|
|
|
function M:init()
|
|
self.Reset = false
|
|
self.ctr_outpoker = self._view:GetController('output')
|
|
self.outpoker_list = self._view:GetChild('out_card_list')
|
|
self.item_data = json.decode(self._view:GetChild('area_mask').text)
|
|
self.out_card_data = self.item_data['outcard_list']
|
|
self.hand_card_list = self._view:GetChild('hand_card_list')
|
|
self.ctr_hand_card_pos = self._view:GetChild('hand_card_list')
|
|
self._mask_liangpai = self._view:GetChild('mask_liangpai')
|
|
self.card_width = 171
|
|
self.cards_view = self._view:GetChild('hand_poker_c')
|
|
self.card_list = {}
|
|
self.out_card_list = {}
|
|
self.touchMoveFun = handler(self, self.TouchMoving)
|
|
self.ctr_put_card_option = self._view:GetController('out_card_option')
|
|
self.ctr_piao = self._view:GetController('piao')
|
|
self.ctr_piao_value = self._view:GetController('piao_value')
|
|
self.ctr_put_error = self._view:GetController('put_error')
|
|
self.put_error_text = self._view:GetChild('put_error')
|
|
|
|
self.ctr_select_card_type = self._view:GetController('select_card_type')
|
|
self.select_card_type_view = self._view:GetChild('choose_type')
|
|
|
|
self.text_bomb_score = self._view:GetChild('Score')
|
|
self.ani_bomb_score = self._view:GetTransition('score')
|
|
self.ani_result_score = self._view:GetTransition('score_1')
|
|
|
|
self.send_card = {}
|
|
self.tips_click_count = 0
|
|
self:BtnEvent()
|
|
|
|
------------------------------lingmeng------------------------
|
|
self.touchMoveEndFun = handler(self, self.TouchMoveEnd)
|
|
|
|
self._view_handCard = self._view:GetChild('List_HandCard')
|
|
self._view_Out = self._view:GetChild('List_Out')
|
|
|
|
self._cardCheck = EXCardCheck:InitFlag()
|
|
self._ctr_time_clock = self._view:GetController('time_clock')
|
|
self._view_comp_clock = self._view:GetChild('Comp_Clock')
|
|
--------------------------------------------------------------
|
|
end
|
|
|
|
function M:InitPoker(pokerList, isPlayAni, open)
|
|
if self.cor_init_poker ~= nil then
|
|
coroutine.stop(self.cor_init_poker)
|
|
end
|
|
-- -- print(vardump(self.card_list))
|
|
self.cor_init_poker = nil
|
|
self.card_list = {}
|
|
self.newCard_list = {}
|
|
self._ctr_canSendCard.selectedIndex = 0
|
|
self._flag_ruleCard = false
|
|
self._view_handCard:RemoveChildren(0, -1, true)
|
|
self.scaleW = (GRoot.inst.width * 0.85 - self._view_handCard.columnGap * 14) / 15
|
|
self.scaleH = self.scaleW * 1.3
|
|
if isPlayAni == true then
|
|
self.cor_init_poker =
|
|
coroutine.start(
|
|
function()
|
|
self._mainView._popEvent = false
|
|
if self._mainView._rightPanelView._settingView ~= nil then
|
|
self._mainView._rightPanelView._settingView:SetBtnDismissRoomEnable(false)
|
|
end
|
|
table.sort(pokerList)
|
|
table.sort(self.card_list, tableSortNumber)
|
|
for i = #pokerList, 1, -1 do
|
|
if pokerList[i] == 403 then
|
|
self._flag_ruleCard = true
|
|
end
|
|
local card_number_code = self:ChangeOneCodeByFrom(pokerList[i])
|
|
local card_flower_code = pokerList[i]
|
|
-- local btn_card = self:CreatPoker(card_number_code, cs, open)
|
|
local btn_card = self._view_handCard:AddItemFromPool()
|
|
self:FillPoker(btn_card, "", card_number_code)
|
|
btn_card.alpha = 0
|
|
btn_card.touchable = false
|
|
local card_view = NewCardView(btn_card, card_number_code, card_flower_code)
|
|
self.card_list[#self.card_list + 1] = card_view
|
|
btn_card.data = card_view
|
|
self:AddTouchMoveEvent(self._view_handCard)
|
|
|
|
if i == #pokerList then
|
|
for j = 1, #self.card_list do
|
|
local card = self.card_list[j]
|
|
card.btn_card.touchable = true
|
|
if open ~= 1 then
|
|
-- body
|
|
self:AddCardTouchEvent(card)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
for j = #self.card_list, 1, -1 do
|
|
local card_view = self.card_list[j]
|
|
card_view.index = j
|
|
|
|
card_view.btn_card:TweenMove(self:GetHandCardPos(j, #self.card_list), 0.10)
|
|
DSTween.To(
|
|
0.7,
|
|
1,
|
|
0.1,
|
|
function(value)
|
|
card_view.btn_card:SetScale(value, value)
|
|
end
|
|
)
|
|
DSTween.To(
|
|
0.7,
|
|
1,
|
|
0.1,
|
|
function(value)
|
|
card_view.btn_card.alpha = value
|
|
end
|
|
)
|
|
card_view.btn_card.alpha = 1
|
|
end
|
|
|
|
self._mainView._popEvent = true
|
|
if self._mainView._rightPanelView._settingView ~= nil then
|
|
self._mainView._rightPanelView._settingView:SetBtnDismissRoomEnable(true)
|
|
end
|
|
end
|
|
)
|
|
else
|
|
for i = #pokerList, 1, -1 do
|
|
if not self.newCard_list[pokerList[i] % 100] then
|
|
self.newCard_list[pokerList[i] % 100] = {}
|
|
end
|
|
self.newCard_list[pokerList[i] % 100][math.floor(pokerList[i] / 100)] = (self.newCard_list[pokerList[i] % 100][math.floor(pokerList[i] / 100)] or 0) +
|
|
1
|
|
end
|
|
self:UpdateHandCardsPos()
|
|
end
|
|
end
|
|
|
|
function M:updatePoker()
|
|
local templist = {}
|
|
for i = 1, #self.card_list do
|
|
templist[#templist + 1] = self.card_list[i].card_code_flower
|
|
end
|
|
self:InitPoker(templist, false, 0)
|
|
end
|
|
|
|
function M:AddTouchMoveEvent(list)
|
|
local send_card = {}
|
|
|
|
-- list.onTouchBegin:Set(
|
|
-- function(context)
|
|
-- self.send_card = {}
|
|
-- if list.touchable == false then
|
|
-- return
|
|
-- end
|
|
-- local xy = self._view_handCard:GlobalToLocal(Vector2.New(context.inputEvent.x, context.inputEvent.y))
|
|
-- self.touchBegin = xy
|
|
-- Stage.inst.onTouchMove:Add(self.touchMoveFun)
|
|
-- Stage.inst.onTouchEnd:Add(self.touchMoveEndFun)
|
|
-- end
|
|
-- )
|
|
end
|
|
|
|
function M:AddCardTouchEvent(card)
|
|
card.btn_card.onTouchBegin:Set(
|
|
function(context)
|
|
if card.btn_card.touchable == false then
|
|
return
|
|
end
|
|
local cardList = card.fatherList
|
|
local touchIndex = cardList:GetChildIndex(card.btn_card)
|
|
self._SendCards = {}
|
|
self.touchCard = card
|
|
self.touchIndex = touchIndex
|
|
for i = 0, touchIndex do
|
|
local oncard = cardList:GetChildAt(i)
|
|
self:SetBtnCardColor(oncard.data, 1)
|
|
if oncard.data.zha then
|
|
for j = 1, 4 do
|
|
table.insert(self._SendCards, oncard.data.card_code_flower)
|
|
end
|
|
else
|
|
table.insert(self._SendCards, oncard.data.card_code_flower)
|
|
end
|
|
end
|
|
local xy = self.touchCard.fatherList:GlobalToLocal(Vector2.New(context.inputEvent.x, context.inputEvent.y))
|
|
self.touchBegin = xy - card.btn_card.xy
|
|
Stage.inst.onTouchMove:Add(self.touchMoveFun)
|
|
Stage.inst.onTouchEnd:Add(self.touchMoveEndFun)
|
|
end
|
|
)
|
|
end
|
|
|
|
function M:zhizhanxuanpai() --智障选牌
|
|
-- body
|
|
local temp_send_card = {}
|
|
for i = 1, #self.send_card do
|
|
if self.send_card[i] ~= self.send_card[i - 1] then
|
|
-- body
|
|
temp_send_card[#temp_send_card + 1] = self.send_card[i]
|
|
end
|
|
end
|
|
|
|
local card_map, max_key = self:GetCardMapAndMaxKey(temp_send_card)
|
|
local list_ones = self:CheckOnes(card_map)
|
|
|
|
if list_ones ~= nil and #list_ones > 0 then
|
|
for i = 1, #self.card_list do
|
|
self:UpdateCardMove(self.card_list[i].btn_card, false, false)
|
|
end
|
|
for i = 1, #self.send_card do
|
|
for j = 1, #list_ones do
|
|
if self.send_card[i] == list_ones[j][1] then
|
|
-- body
|
|
self:UpdateCardMove(self.send_card[i].btn_card, true, false)
|
|
end
|
|
end
|
|
end
|
|
return list_ones
|
|
else
|
|
return {}
|
|
end
|
|
end
|
|
|
|
function M:TouchMoving(context)
|
|
if self._view_handCard == nil then
|
|
return
|
|
end
|
|
local send_card1 = {}
|
|
local xy = self.touchCard.fatherList:GlobalToLocal(Vector2.New(context.inputEvent.x,
|
|
context.inputEvent.y))
|
|
for i = self.touchIndex, 0, -1 do
|
|
local oncard = self.touchCard.fatherList:GetChildAt(i)
|
|
oncard.xy = xy - self.touchBegin - Vector2.New(0, (self.scaleH + self.linegap) * (self.touchIndex - i))
|
|
end
|
|
|
|
-- for i = 1, self._view_handCard.numItems do
|
|
-- local card = self._view_handCard:GetChildAt(i - 1).data
|
|
-- if card.btn_card.touchable == false or card.card_isTouchable == 1 then
|
|
-- else
|
|
-- if
|
|
-- (card.btn_card.x + oneCardWidth > min_x or (i == #self.card_list and card.btn_card.x + CardWidth > min_x))
|
|
-- and card.btn_card.x < max_x
|
|
-- then
|
|
-- self:SetBtnCardColor(card, 1)
|
|
-- if #send_card1 == 0 then
|
|
-- send_card1[1] = card
|
|
-- end
|
|
-- if send_card1[#send_card1] ~= card then
|
|
-- send_card1[#send_card1 + 1] = card
|
|
-- end
|
|
-- else
|
|
-- self:SetBtnCardColor(card, 0)
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- self.send_card = send_card1
|
|
end
|
|
|
|
function M:TouchMoveEnd(context)
|
|
local linexy = self._view_handCard:GlobalToLocal(Vector2.New(context.inputEvent.x,
|
|
context.inputEvent.y))
|
|
local allcards = {}
|
|
for k, v in pairs(self.newCard_list) do
|
|
for k1, v1 in pairs(v) do
|
|
if v1 > 0 then
|
|
for i = 1, v1 do
|
|
local card_flower_code = k1 * 100 + k
|
|
table.insert(allcards, card_flower_code)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if linexy.y < self._view:GetChild('n82').y then
|
|
self.gameCtr:SendCard(self._SendCards, allcards)
|
|
else
|
|
if self.touchCard.card_code_flower % 100 < 3 then
|
|
for i = self._view_handCard.numItems - 1, 0, -1 do
|
|
local oneCardList = self._view_handCard:GetChildAt(i):GetChild('list')
|
|
local listxy = oneCardList:GlobalToLocal(Vector2.New(context.inputEvent.x,
|
|
context.inputEvent.y))
|
|
if listxy.x > 0 and oneCardList:GetChildAt(0).data.card_code_flower % 100 > 2 then
|
|
for i = 0, oneCardList.numItems - 1 do
|
|
local oncard = oneCardList:GetChildAt(i)
|
|
if oncard.data.zha then
|
|
for j = 1, 4 do
|
|
table.insert(self._SendCards, oncard.data.card_code_flower)
|
|
end
|
|
else
|
|
table.insert(self._SendCards, oncard.data.card_code_flower)
|
|
end
|
|
end
|
|
self.gameCtr:SendCard(self._SendCards, allcards)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
for i = 0, self.touchIndex do
|
|
local oncard = self.touchCard.fatherList:GetChildAt(i)
|
|
self:SetBtnCardColor(oncard.data, 0)
|
|
oncard.xy = Vector2.New(0, (self.scaleH + self.linegap) * i)
|
|
end
|
|
-- local fristCard = self._view_handCard:GetChildAt(0)
|
|
-- local CardWidth = fristCard.width
|
|
-- local columnGap = self._view_handCard.columnGap
|
|
-- local oneCardWidth = CardWidth + columnGap
|
|
-- local xy = fristCard:GlobalToLocal(Vector2.New(context.inputEvent.x, context.inputEvent.y))
|
|
-- local downCards = #self.card_list
|
|
Stage.inst.onTouchMove:Remove(self.touchMoveFun)
|
|
Stage.inst.onTouchEnd:Remove(self.touchMoveEndFun)
|
|
|
|
-- local max_x
|
|
-- local min_x
|
|
-- if xy.x - self.touchBegin.x > 0 then
|
|
-- max_x = xy.x
|
|
-- min_x = self.touchBegin.x
|
|
-- else
|
|
-- max_x = self.touchBegin.x
|
|
-- min_x = xy.x
|
|
-- end
|
|
|
|
-- for k = 1, self._view_handCard.numItems do
|
|
-- local card = self._view_handCard:GetChildAt(k - 1).data
|
|
-- table.insert(currentCard, card.card_code_flower)
|
|
-- if not card.btn_card.selected then
|
|
-- downCards = downCards - 1
|
|
-- end
|
|
-- if card.btn_card.touchable == false or card.card_isTouchable == 1 then
|
|
-- else
|
|
-- self:SetBtnCardColor(card, 0)
|
|
-- if
|
|
-- (card.btn_card.x + oneCardWidth > min_x or (k == #self.card_list and card.btn_card.x + CardWidth > min_x))
|
|
-- and card.btn_card.x < max_x
|
|
-- then
|
|
-- self:UpdateCardMove(card.btn_card, not card.btn_card.selected, false)
|
|
-- if card.btn_card.selected then
|
|
-- send_card[#send_card + 1] = card
|
|
-- end
|
|
-- --ViewUtil.PlaySound("DuoDuo_PK", "extend/poker/paodekuai/sound/click.mp3")
|
|
-- else
|
|
-- if card.btn_card.selected then
|
|
-- send_card[#send_card + 1] = card
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
|
|
-- -- ViewUtil.PlaySound('DuoDuo_PK', 'extend/poker/duoduo/sound/click.mp3')
|
|
|
|
-- Stage.inst:ResetInputState()
|
|
|
|
-- if downCards == 0 then
|
|
-- xuan_card = self:zhizhanxuanpai()
|
|
-- end
|
|
|
|
-- if #send_card > 0 then
|
|
-- table.sort(send_card, tableSortNumber)
|
|
-- send_card = #xuan_card > 0 and xuan_card or send_card
|
|
-- self._cardCheck:initCards(send_card,
|
|
-- {
|
|
-- flag = #xuan_card > 0,
|
|
-- flag_allCards = #send_card == self._view_handCard.numItems,
|
|
-- flag_ruleCard = self
|
|
-- ._flag_ruleCard
|
|
-- })
|
|
|
|
-- self._ctr_canSendCard.selectedIndex = self._cardCheck:CheckCards() and 1 or 0
|
|
-- else
|
|
-- self._ctr_canSendCard.selectedIndex = 0
|
|
-- end
|
|
end
|
|
|
|
-- function M:SetBtnCardColor(card, num)
|
|
-- if
|
|
-- card.btn_card:GetChildAt(0) ~= nil and card.btn_card:GetChildAt(0):GetChildAt(0) ~= nil and
|
|
-- card.btn_card:GetChildAt(0):GetChildAt(0):GetChildAt(0) ~= nil
|
|
-- then
|
|
-- -- body
|
|
-- card.btn_card:GetChildAt(0):GetChildAt(0):GetChildAt(0).color = Color(num, num, num)
|
|
-- end
|
|
|
|
-- --if card.card_code_flower < 500 then
|
|
-- -- card.btn_card:GetChildAt(0):GetChildAt(2).color = Color(num,num,num)
|
|
-- -- card.btn_card:GetChildAt(0):GetChildAt(3).color = Color(num,num,num)
|
|
-- --end
|
|
-- end
|
|
function M:SetBtnCardColor(card, num)
|
|
card.btn_card:GetController('choose').selectedIndex = num
|
|
end
|
|
|
|
function M:ShowPiao(piao)
|
|
self.ctr_piao.selectedIndex = piao
|
|
end
|
|
|
|
function M:HidePiao()
|
|
self.ctr_piao.selectedIndex = 0
|
|
end
|
|
|
|
function M:ShowOutCardOption2(lastCardList, ctr_select, mustPutMaxCard)
|
|
-- self._cardCheck:InitLastCard(lastCardList, mustPutMaxCard)
|
|
-- self._cardCheck:CheckOutCard(self.card_list)
|
|
-- self.tips_card_list = self._cardCheck:GetTipsList()
|
|
-- self.touchCardSet = self._cardCheck:GetTouchSet()
|
|
-- self.touchCardMap = self._cardCheck:GetTouchCardMap()
|
|
-- self.tips_click_count = 0
|
|
|
|
-- print("lingmengShowOutCardOption2", #self.touchCardSet)
|
|
-- pt(self.touchCardSet)
|
|
-- pt(self.touchCardMap)
|
|
-- -- body --在这个方法里添加判断抬起牌是否符合出牌类型(少跑一次手牌循环)
|
|
-- self:UpdateHandCardsColor()
|
|
|
|
-- if #self.tips_card_list == 1 then
|
|
-- self:ShowTipsCard(1)
|
|
-- end
|
|
|
|
self.ctr_put_card_option.selectedIndex = ctr_select
|
|
end
|
|
|
|
function M:ShowOutCardOption(ctr_select, type, number, length, mustPutMaxCard, play, zdts)
|
|
--for i = 1, #self.out_card_list do
|
|
-- local card = self.out_card_list[i]
|
|
-- self.cards_view:RemoveChild(card.btn_card,true)
|
|
--end
|
|
--self.out_card_list = {}
|
|
|
|
-- self.zhizhanctr_select=ctr_select
|
|
-- self.zhizhantype=type
|
|
-- self.zhizhannumber=number
|
|
-- self.zhizhanlength=length
|
|
-- self.zhizhanmustPutMaxCard=mustPutMaxCard
|
|
-- self.zhizhanplay=play
|
|
-- self.zhizhanzdts=zdts
|
|
self.tips_click_count = 0
|
|
self.send_card = {}
|
|
self.tips_card_list = self:GetCardTips(type, number, length, mustPutMaxCard)
|
|
self._ctr_canSendCard.selectedIndex = 0
|
|
|
|
if #self.tips_card_list >= 1 then
|
|
-- body --在这个方法里添加判断抬起牌是否符合出牌类型(少跑一次手牌循环)
|
|
self:UpdateHandCardsColor()
|
|
end
|
|
--
|
|
-- 自动提示
|
|
-- if #self.tips_card_list ~= 0 and play~=0 and mustPutMaxCard==false and zdts==1 then
|
|
-- local index = self.tips_click_count % #self.tips_card_list + 1
|
|
-- self:ShowTipsCard(index)
|
|
-- self.tips_click_count = self.tips_click_count + 1
|
|
-- end
|
|
if #self.tips_card_list == 2 and self.tips_card_list[2][1].index == self.tips_card_list[1][1].index then
|
|
if #self.tips_card_list[2] == #self.tips_card_list[1] then
|
|
for i = 1, #self.tips_card_list[2] do
|
|
if self.tips_card_list[2][i].index == self.tips_card_list[1][i].index then
|
|
self:ShowTipsCard(1)
|
|
end
|
|
end
|
|
end
|
|
elseif #self.tips_card_list == 1 then
|
|
self:ShowTipsCard(1)
|
|
end
|
|
if mustPutMaxCard and play ~= 0 and zdts == 1 then
|
|
-- body
|
|
self:ShowTipsCard(#self.tips_card_list)
|
|
end
|
|
self.ctr_put_card_option.selectedIndex = ctr_select
|
|
end
|
|
|
|
function M:SetOutCardInfo(cardlist, isPass, isAnim)
|
|
self._view_Out:RemoveChildren(0, -1, true)
|
|
if cardlist == nil then
|
|
if isPass == true then
|
|
self.ctr_outpoker.selectedIndex = 2
|
|
else
|
|
self.ctr_outpoker.selectedIndex = 0
|
|
end
|
|
else
|
|
self.ctr_outpoker.selectedIndex = 1
|
|
-- if isAnim then
|
|
-- if self.move_cor then
|
|
-- coroutine.stop(self.move_cor)
|
|
-- self.move_cor = nil
|
|
-- end
|
|
|
|
-- for i = 1, #cardlist do
|
|
-- local poker_item = self._view_Out:AddItemFromPool()
|
|
-- local code = self:ChangeCodeByTo(cardlist[i])
|
|
|
|
-- self:FillPoker(poker_item, "", cardlist[i])
|
|
-- end
|
|
-- self.move_cor = coroutine.start(function()
|
|
-- coroutine.wait(0.1)
|
|
-- ViewUtil.PlaySound("DuoDuo_PK", "extend/poker/duoduo/sound/chupai.mp3")
|
|
-- end)
|
|
-- else
|
|
for i = 1, #cardlist do
|
|
local poker_item = self._view_Out:AddItemFromPool()
|
|
|
|
self:FillPoker2(poker_item, cardlist[i])
|
|
end
|
|
-- end
|
|
end
|
|
end
|
|
|
|
function M:SetOutCardBlack()
|
|
for i = 1, #self.out_card_list do
|
|
local card = self.out_card_list[i]
|
|
if card and card:GetChildAt(0) and card:GetChildAt(0):GetChildAt(0) and card:GetChildAt(0):GetChildAt(0):GetChildAt(0) then
|
|
card:GetChildAt(0):GetChildAt(0):GetChildAt(0).color = Color(0.7, 0.7, 0.7)
|
|
end
|
|
end
|
|
end
|
|
|
|
function M:SetOutCardList(cardlist, isAnim)
|
|
local pos_y = -320
|
|
if isAnim then
|
|
-- self.zhizhanctr_select=0
|
|
-- self.zhizhantype=0
|
|
-- self.zhizhannumber=0
|
|
-- self.zhizhanlength=0
|
|
-- self.zhizhanmustPutMaxCard=0
|
|
-- self.zhizhanplay=0
|
|
-- self.zhizhanzdts=0
|
|
if self.move_cor then
|
|
coroutine.stop(self.move_cor)
|
|
self.move_cor = nil
|
|
end
|
|
local time = 0.1
|
|
for i = 1, #cardlist do
|
|
local card_code_number = cardlist[i]
|
|
for j = 1, #self.card_list do
|
|
local card = self.card_list[j]
|
|
if card_code_number == card.card_code_number then
|
|
card.btn_card.onTouchBegin:Set(nil)
|
|
self.out_card_list[#self.out_card_list + 1] = card.btn_card
|
|
list_remove(self.card_list, card)
|
|
-- todo 出牌动画
|
|
local pos =
|
|
self:GetOutCardEndPokerPos(
|
|
i,
|
|
#cardlist,
|
|
self.cards_view,
|
|
card.btn_card,
|
|
self.out_card_data['maxcount_x'],
|
|
1.5
|
|
)
|
|
card.btn_card:TweenMove(Vector2.New(pos.x, pos_y), time)
|
|
-- self.tween = TweenUtils.TweenFloat(1, 0.7, time, function(x)
|
|
-- card.btn_card:GetChildAt(0):SetScale(x, x)
|
|
-- end)
|
|
card.btn_card:GetChildAt(0):SetScale(1.5, 1.5)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
self.move_cor =
|
|
coroutine.start(
|
|
function()
|
|
coroutine.wait(0.05)
|
|
for i = 1, #self.out_card_list do
|
|
local card = self.out_card_list[i]
|
|
self.cards_view:SetChildIndex(card, i - 1)
|
|
end
|
|
coroutine.wait(0.1)
|
|
ViewUtil.PlaySound('DuoDuo_PK', 'extend/poker/duoduo/sound/chupai.mp3')
|
|
end
|
|
)
|
|
else
|
|
for i = 1, #cardlist do
|
|
local poker_item = UIPackage.CreateObject('Extend_Poker_DuoDuo', 'poker7')
|
|
local code = self:ChangeCodeByTo(cardlist[i])
|
|
-- local card_code_obj = UIPackage.CreateObjectFromURL("ui://Extend_Poker_RunFast/" .. code)
|
|
local card_code_obj
|
|
-- if DataManager.CurrenRoom.pai==0 then
|
|
-- card_code_obj = UIPackage.CreateObjectFromURL("ui://Extend_Poker_RunFast/"..code)
|
|
-- else
|
|
-- card_code_obj = UIPackage.CreateObjectFromURL("ui://Main_Poker/" .. code .. "_2")
|
|
-- end
|
|
-- if code == 310 and DataManager.CurrenRoom.room_config.Heart10 == 2 then
|
|
-- -- body
|
|
-- card_code_obj = UIPackage.CreateObjectFromURL("ui://Extend_Poker_RunFast/" .. code .. "_1")
|
|
-- end
|
|
if DataManager.CurrenRoom.pai == 0 then
|
|
if code == 310 and DataManager.CurrenRoom.room_config.Heart10 == 2 then
|
|
-- body
|
|
card_code_obj = UIPackage.CreateObjectFromURL('ui://Extend_Poker_DuoDuo/' .. code .. '_1')
|
|
else
|
|
card_code_obj = UIPackage.CreateObjectFromURL('ui://Extend_Poker_DuoDuo/' .. code)
|
|
end
|
|
else
|
|
if code == 310 and DataManager.CurrenRoom.room_config.Heart10 == 2 then
|
|
-- body
|
|
card_code_obj = UIPackage.CreateObjectFromURL('ui://Extend_Poker_DuoDuo/' .. code .. '_2')
|
|
else
|
|
card_code_obj = UIPackage.CreateObjectFromURL('ui://Main_Poker/' .. code .. '_2')
|
|
end
|
|
end
|
|
if card_code_obj == nil then
|
|
card_code_obj = UIPackage.CreateObjectFromURL('ui://Main_Poker/00')
|
|
end
|
|
card_code_obj:SetScale(1.5, 1.5)
|
|
poker_item:AddChild(card_code_obj)
|
|
--local poker = self:CreatPoker(cardlist[i],0.7)
|
|
self.cards_view:AddChild(poker_item)
|
|
local pos =
|
|
self:GetOutCardEndPokerPos(
|
|
i,
|
|
#cardlist,
|
|
self.cards_view,
|
|
poker_item,
|
|
self.out_card_data['maxcount_x'],
|
|
1.5
|
|
)
|
|
poker_item.xy = Vector2.New(pos.x, pos_y)
|
|
self.out_card_list[#self.out_card_list + 1] = poker_item
|
|
end
|
|
end
|
|
end
|
|
|
|
-- function M:DeleteHandCards(cardlist)
|
|
-- for i = 1, #cardlist do
|
|
-- local card_code_number = cardlist[i]
|
|
-- for j = 1, #self.card_list do
|
|
-- local card = self.card_list[j]
|
|
-- if card_code_number == card.card_code_number then
|
|
-- --self.out_card_list[#self.out_card_list + 1] = card
|
|
-- list_remove(self.card_list, card)
|
|
-- -- todo 出牌动画
|
|
-- self.cards_view:RemoveChild(card.btn_card, true)
|
|
-- break
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- self:UpdateHandCardsPos()
|
|
-- end
|
|
function M:DeleteHandCards(cardlist)
|
|
self.ctr_put_card_option.selectedIndex = 0
|
|
for i = 1, #cardlist do
|
|
local tmpNum = nil
|
|
if self.newCard_list[cardlist[i] % 100] then
|
|
tmpNum = self.newCard_list[cardlist[i] % 100][math.floor(cardlist[i] / 100)]
|
|
end
|
|
if tmpNum then
|
|
if tmpNum == 1 then
|
|
self.newCard_list[cardlist[i] % 100][math.floor(cardlist[i] / 100)] = nil
|
|
else
|
|
self.newCard_list[cardlist[i] % 100][math.floor(cardlist[i] / 100)] = tmpNum - 1
|
|
end
|
|
else
|
|
ViewUtil:ErrorTip("牌型出错，重新加载页面")
|
|
ViewManager.refreshGameView()
|
|
end
|
|
if i == #cardlist then
|
|
if #self.newCard_list[cardlist[i] % 100] == 0 then
|
|
self.newCard_list[cardlist[i] % 100] = nil
|
|
end
|
|
end
|
|
end
|
|
self:UpdateHandCardsPos()
|
|
end
|
|
|
|
function M:UpdateHandCardsPos()
|
|
local maxHeight = 0
|
|
self._view_handCard:RemoveChildrenToPool()
|
|
self._newCardSize = {}
|
|
for k, v in pairs(self.newCard_list) do
|
|
local btn_cardListFather = self._view_handCard:AddItemFromPool()
|
|
btn_cardListFather.width = self.scaleW
|
|
-- btn_cardListFather.height = scaleH*12
|
|
local btn_cardList = btn_cardListFather:GetChild('list')
|
|
btn_cardList:RemoveChildrenToPool()
|
|
self.linegap = btn_cardList.lineGap
|
|
local tmpHeight = 0
|
|
for k1, v1 in pairs(v) do
|
|
local card_number_code = k * 10 + k1
|
|
local card_flower_code = k1 * 100 + k
|
|
if v1 ~= 4 then
|
|
for i = 1, v1 do
|
|
local btn_card = btn_cardList:AddItemFromPool()
|
|
btn_card.height = self.scaleH
|
|
self:FillPoker2(btn_card, card_flower_code)
|
|
-- self.cards_view:AddChild(btn_card)
|
|
local card_view = NewCardView(btn_card, card_number_code, card_flower_code)
|
|
card_view.fatherList = btn_cardList
|
|
self.card_list[#self.card_list + 1] = card_view
|
|
btn_card.data = card_view
|
|
tmpHeight = tmpHeight + 1
|
|
self:AddCardTouchEvent(card_view)
|
|
end
|
|
else
|
|
local btn_card = btn_cardList:GetFromPool('')
|
|
btn_cardList:AddChildAt(btn_card, 0)
|
|
btn_card.height = self.scaleH
|
|
self:FillPoker2(btn_card, card_flower_code, "_z")
|
|
-- self.cards_view:AddChild(btn_card)
|
|
local card_view = NewCardView(btn_card, card_number_code, card_flower_code)
|
|
card_view.fatherList = btn_cardList
|
|
card_view.zha = true
|
|
self.card_list[#self.card_list + 1] = card_view
|
|
btn_card.data = card_view
|
|
tmpHeight = tmpHeight + 1
|
|
self:AddCardTouchEvent(card_view)
|
|
end
|
|
self._newCardSize[k1] = tmpHeight
|
|
end
|
|
|
|
if tmpHeight > maxHeight then
|
|
maxHeight = tmpHeight
|
|
end
|
|
end
|
|
self._view:GetChild('n82').y = self._view_handCard.height -
|
|
(self.scaleH + (self.scaleH + self.linegap) * (maxHeight - 1) + 50)
|
|
end
|
|
|
|
function M:ResetPoker()
|
|
self.Reset = true
|
|
for i = 1, #self.card_list do
|
|
local card_view = self.card_list[i]
|
|
self:UpdateCardMove(card_view.btn_card, false, false)
|
|
end
|
|
self.send_card = {}
|
|
self.Reset = false
|
|
end
|
|
|
|
function M:UpdateCardMove(btn_card, isSelected, isPlay)
|
|
btn_card.selected = isSelected
|
|
-- local card_Move = btn_card
|
|
-- local xy = isSelected == true and Vector2.New(0, -65) or Vector2.New(0, 0)
|
|
-- if isPlay then
|
|
-- -- body
|
|
-- card_Move:TweenMove(xy, 0)
|
|
-- else
|
|
-- card_Move:TweenMove(xy, 0)
|
|
-- end
|
|
end
|
|
|
|
--
|
|
-- function M:UpdateHandCardsColor()
|
|
-- local send_card = {}
|
|
-- for i = 1, #self.card_list do
|
|
-- local card_view = self.card_list[i]
|
|
-- local num = card_view.btn_card.touchable == true and 0 or 1
|
|
-- self:SetBtnCardColor(card_view, num)
|
|
-- if card_view.btn_card.selected and card_view.btn_card.touchable then
|
|
-- table.insert(send_card, card_view)
|
|
-- end
|
|
-- end
|
|
-- if #send_card > 0 then
|
|
-- table.sort(send_card, tableSortNumber)
|
|
-- self._cardCheck:initCards(send_card, false, #send_card == self._view_handCard.numItems)
|
|
-- self._ctr_canSendCard.selectedIndex = self._cardCheck:CheckCards() and 1 or 0
|
|
-- else
|
|
-- self._ctr_canSendCard.selectedIndex = 0
|
|
-- end
|
|
-- end
|
|
|
|
function M:UpdateHandCardsColor()
|
|
local send_card = {}
|
|
for i = 1, #self.card_list do
|
|
local card_view = self.card_list[i]
|
|
if self.touchCardMap[math.floor(card_view.card_code_number / 10)] or #self.touchCardSet == 0 then
|
|
card_view.btn_card.touchable = true
|
|
self:SetBtnCardColor(card_view, 0)
|
|
else
|
|
card_view.btn_card.touchable = false
|
|
card_view.btn_card.selected = false
|
|
self:SetBtnCardColor(card_view, 1)
|
|
end
|
|
if card_view.btn_card.selected and card_view.btn_card.touchable then
|
|
table.insert(send_card, card_view)
|
|
end
|
|
end
|
|
if #send_card > 0 then
|
|
table.sort(send_card, tableSortNumber)
|
|
self._cardCheck:initCards(send_card, { flag = false, flag_allCards = #send_card == self._view_handCard.numItems })
|
|
self._ctr_canSendCard.selectedIndex = self._cardCheck:CheckCards() and 1 or 0
|
|
else
|
|
self._ctr_canSendCard.selectedIndex = 0
|
|
end
|
|
end
|
|
|
|
function M:BtnEvent()
|
|
self.btn_not_put = self._view:GetChild('btn_not_put')
|
|
self.btn_tips = self._view:GetChild('Btn_Tip') -- 覆盖
|
|
self.btn_sendCards = self._view:GetChild('Btn_SendCard')
|
|
self._ctr_canSendCard = self.btn_sendCards:GetController('can')
|
|
|
|
self.btn_sendCards.onClick:Set(
|
|
function()
|
|
if self.Reset then
|
|
return
|
|
end
|
|
if self._ctr_canSendCard.selectedIndex == 0 then
|
|
return
|
|
end
|
|
local send_card = {}
|
|
self.send_card = {}
|
|
local currentCard = {}
|
|
for i = 1, #self.card_list do
|
|
local card = self.card_list[i]
|
|
table.insert(currentCard, card.card_code_flower)
|
|
if card.btn_card.selected then
|
|
send_card[#send_card + 1] = card.card_code_flower
|
|
self.send_card[#self.send_card + 1] = card
|
|
end
|
|
end
|
|
|
|
if #send_card == 0 then
|
|
self:ErrorTip('请选择要出的牌')
|
|
else
|
|
self.gameCtr:SendCard(send_card, currentCard)
|
|
end
|
|
end
|
|
)
|
|
self.btn_tips.onClick:Set(
|
|
function()
|
|
--printlog("wwwwwwwwwww111111111111111111111111")
|
|
--pt(self.tips_card_list)
|
|
if self.tips_card_list ~= nil and #self.tips_card_list ~= 0 then
|
|
local index = self.tips_click_count % #self.tips_card_list + 1
|
|
self:ShowTipsCard(index)
|
|
self.tips_click_count = self.tips_click_count + 1
|
|
end
|
|
end
|
|
)
|
|
-- 过
|
|
self.btn_not_put.onClick:Set(
|
|
function()
|
|
self.ctr_put_card_option.selectedIndex = 0
|
|
self.gameCtr:SendPass()
|
|
end
|
|
)
|
|
|
|
local function click_piao()
|
|
self.ctr_piao.selectedIndex = 0
|
|
self.gameCtr:SendPiao(tonumber(self.ctr_piao_value.selectedPage))
|
|
end
|
|
|
|
local btn_piao0 = self._view:GetChild('piao0')
|
|
btn_piao0.onClick:Set(click_piao)
|
|
|
|
local btn_piao1 = self._view:GetChild('piao1')
|
|
btn_piao1.onClick:Set(click_piao)
|
|
|
|
local btn_piao2 = self._view:GetChild('piao2')
|
|
btn_piao2.onClick:Set(click_piao)
|
|
|
|
local btn_piao3 = self._view:GetChild('piao3')
|
|
btn_piao3.onClick:Set(click_piao)
|
|
|
|
local btn_piao5 = self._view:GetChild('piao5')
|
|
btn_piao5.onClick:Set(click_piao)
|
|
|
|
local btn_piao8 = self._view:GetChild('piao8')
|
|
btn_piao8.onClick:Set(click_piao)
|
|
end
|
|
|
|
function M:ShowTipsCard(index)
|
|
print("lingmengShowTipsCard")
|
|
local item = self.tips_card_list[index]
|
|
for i = 1, #self.card_list do
|
|
local card = self.card_list[i]
|
|
local isExsit = false
|
|
for j = 1, #item do
|
|
if item[j] == self.card_list[i] then
|
|
self:UpdateCardMove(card.btn_card, true, false)
|
|
isExsit = true
|
|
end
|
|
end
|
|
if isExsit == false then
|
|
self:UpdateCardMove(card.btn_card, false, false)
|
|
end
|
|
end
|
|
pt(item)
|
|
self._cardCheck:initCards(item)
|
|
self._ctr_canSendCard.selectedIndex = self._cardCheck:CheckCards() and 1 or 0
|
|
end
|
|
|
|
function M:GetHandCardOffset(count)
|
|
local start = -90 ---54
|
|
|
|
local offset = 0
|
|
if count > 10 then
|
|
offset = start - count + 26
|
|
else
|
|
offset = -30
|
|
end
|
|
return 20
|
|
end
|
|
|
|
function M:GetHandCardPos(index, card_count)
|
|
local x, y = 0, -20
|
|
local offset = self:GetHandCardOffset(card_count)
|
|
local middle_x = self.cards_view.width / 2
|
|
local start_x = middle_x - (card_count / 2 * (self.card_width + offset)) + (offset / 2)
|
|
x = start_x + (self.card_width + offset) * (index - 1)
|
|
return Vector2.New(x, y)
|
|
end
|
|
|
|
function M:GetHandCardPos1(index, card_count)
|
|
local x, y = 0, -18
|
|
local offset = self:GetHandCardOffset(card_count)
|
|
local middle_x = self.cards_view.width / 2
|
|
local start_x = middle_x - (card_count / 2 * (self.card_width + offset)) + (offset / 2)
|
|
x = start_x + (self.card_width + offset) * (index - 1)
|
|
return x, y
|
|
end
|
|
|
|
function M:ErrorTip(error_text)
|
|
if self.cor_init_poker ~= nil then
|
|
coroutine.stop(self.cor_init_poker)
|
|
end
|
|
self.cor_init_poker = nil
|
|
self.cor_init_poker =
|
|
coroutine.start(
|
|
function()
|
|
self.put_error_text.text = error_text
|
|
self.ctr_put_error.selectedIndex = 1
|
|
coroutine.wait(2)
|
|
self.ctr_put_error.selectedIndex = 0
|
|
end
|
|
)
|
|
end
|
|
|
|
--EXCardType
|
|
--None = 0,
|
|
--OneCard = 1,
|
|
--OnePair = 2,
|
|
--Three = 3,
|
|
--Pairs = 4,
|
|
--ThreeAndTwo = 5,
|
|
--ThreeAndOne = 6,
|
|
--Plane = 7,
|
|
--PlaneAndTwo = 8,
|
|
--PlaneAndOne = 9,
|
|
--Straight = 10,
|
|
--Bomb = 11
|
|
function M:GetCardTips(type, number, length, mustPutMaxCard, tip_templist)
|
|
local tip_list = {}
|
|
local sidaisan = false
|
|
local touch_key_list = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
|
|
--printlog("aaaaaaaaaaaaacccccccccccccccccccc11111111111111111111111111111")
|
|
--pt(self.card_list)
|
|
local card_map, max_key = self:GetCardMapAndMaxKey(self.card_list)
|
|
--printlog("aaaaaaaaaaaaaaaaaa222222222222222222222222222222222222222 ",max_key)
|
|
--pt(card_map)
|
|
if type == EXCardType.None then
|
|
if DataManager.CurrenRoom.is_new_bout then
|
|
tip_list = self:NewBoutTips(card_map)
|
|
end
|
|
return tip_list, touch_key_list
|
|
elseif type == EXCardType.Bomb then
|
|
tip_list, touch_key_list = self:CheckBomb(card_map, number, length)
|
|
else
|
|
local list_type, list_bomb = {}, {}
|
|
local touch_type, touch_bomb
|
|
list_bomb, touch_bomb = self:CheckBomb(card_map, 0, 4)
|
|
|
|
local card_templist = membe_clone(self.card_list)
|
|
|
|
if list_bomb ~= nil and tip_templist == nil then
|
|
-- body
|
|
for i = 1, #list_bomb do
|
|
local templist_bomb = list_bomb[i]
|
|
for j = 1, #templist_bomb do
|
|
for k = 1, #card_templist do
|
|
if templist_bomb[j] == card_templist[k] then
|
|
-- body
|
|
list_remove(card_templist, card_templist[k])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
card_map, max_key = self:GetCardMapAndMaxKey(card_templist)
|
|
end
|
|
|
|
if type == EXCardType.OneCard then
|
|
-- if mustPutMaxCard then
|
|
-- number = max_key - 1
|
|
-- self:ErrorTip("下家报单，请出最大的牌 ")
|
|
-- end
|
|
list_type, touch_type = self:CheckOneCard(card_map, number, length)
|
|
elseif type == EXCardType.OnePair then
|
|
list_type, touch_type = self:CheckOnePair(card_map, number, length)
|
|
elseif type == EXCardType.Three then
|
|
list_type, touch_type = self:CheckThree(card_map, number, length)
|
|
elseif type == EXCardType.Pairs then
|
|
list_type, touch_type = self:CheckPairs(card_map, number, length)
|
|
elseif type == EXCardType.ThreeAndTwo then
|
|
list_type, touch_type = self:CheckThreeAndTwo(card_map, number, length)
|
|
elseif type == EXCardType.ThreeAndOne then
|
|
list_type, touch_type = self:CheckThreeAndOne(card_map, number, length)
|
|
elseif type == EXCardType.Plane then
|
|
list_type, touch_type = self:CheckPlane(card_map, number, length, 0)
|
|
elseif type == EXCardType.PlaneAndTwo then
|
|
list_type, touch_type = self:CheckPlane(card_map, number, length, 2)
|
|
elseif type == EXCardType.PlaneAndOne then
|
|
list_type, touch_type = self:CheckPlane(card_map, number, length, 1)
|
|
elseif type == EXCardType.Straight then
|
|
list_type, touch_type = self:CheckStraight(card_map, number, length)
|
|
elseif type == EXCardType.FourAndtThree then
|
|
list_type, touch_type = self:CheckBomb(card_map, 0, 4)
|
|
if #list_type > 0 then
|
|
-- body
|
|
sidaisan = true
|
|
end
|
|
end
|
|
card_map, max_key = self:GetCardMapAndMaxKey(self.card_list)
|
|
tip_list = self:GetMergeAllList(list_type, list_bomb)
|
|
--list_bomb, touch_bomb = self:CheckBomb(card_map, 0, 4)
|
|
touch_key_list = self:GetMergeAllList(touch_type, touch_bomb)
|
|
local tip_templist2 = {}
|
|
if tip_templist == nil then
|
|
-- body
|
|
tip_templist2 = self:GetCardTips(type, number, length, mustPutMaxCard, tip_list)
|
|
end
|
|
if #tip_templist2 > 0 then
|
|
-- body
|
|
tip_list = self:GetMergeAllList(tip_list, tip_templist2)
|
|
end
|
|
end
|
|
|
|
if (tip_templist ~= nil and sidaisan == false and #tip_templist >= 1) then
|
|
-- body
|
|
self:SetNotTouchCard(touch_key_list, card_map)
|
|
end
|
|
|
|
return tip_list
|
|
end
|
|
|
|
-- 合并多个list
|
|
function M:GetMergeAllList(...)
|
|
local lists = { ... }
|
|
local merge_list = {}
|
|
for i = 1, #lists do
|
|
local list_item = lists[i]
|
|
for j = 1, #list_item do
|
|
merge_list[#merge_list + 1] = list_item[j]
|
|
end
|
|
end
|
|
|
|
return merge_list
|
|
end
|
|
|
|
function M:NewBoutTips(pokerMap)
|
|
local new_bout_list = {}
|
|
for k, v in pairs(pokerMap) do
|
|
new_bout_list[#new_bout_list + 1] = v
|
|
end
|
|
return new_bout_list
|
|
end
|
|
|
|
function M:CheckOneCard(pokerMap, num, length)
|
|
local one_card_list = {}
|
|
local touch_key_list = {}
|
|
if #self.card_list < length then
|
|
return one_card_list, touch_key_list
|
|
end
|
|
for k, v in pairs(pokerMap) do
|
|
if k > num and #v == 1 then
|
|
one_card_list[#one_card_list + 1] = { v[1] }
|
|
touch_key_list[#touch_key_list + 1] = k
|
|
end
|
|
end
|
|
for k, v in pairs(pokerMap) do
|
|
if k > num and #v ~= 1 then
|
|
one_card_list[#one_card_list + 1] = { v[1] }
|
|
touch_key_list[#touch_key_list + 1] = k
|
|
end
|
|
end
|
|
return one_card_list, touch_key_list
|
|
end
|
|
|
|
function M:CheckOnePair(pokerMap, num, length)
|
|
local one_pair_list = {}
|
|
local touch_key_list = {}
|
|
if #self.card_list < length then
|
|
return one_pair_list, touch_key_list
|
|
end
|
|
for k, v in pairs(pokerMap) do -- 从三条和对子里面提取
|
|
if #v > 1 and k > num then
|
|
one_pair_list[#one_pair_list + 1] = { v[1], v[2] }
|
|
touch_key_list[#touch_key_list + 1] = k
|
|
end
|
|
end
|
|
return one_pair_list, touch_key_list
|
|
end
|
|
|
|
function M:CheckThree(pokerMap, num, length)
|
|
local three_list = {}
|
|
local touch_key_list = {}
|
|
if #self.card_list < length then
|
|
return three_list, touch_key_list
|
|
end
|
|
for k, v in pairs(pokerMap) do
|
|
if #v > 2 and k > num then
|
|
three_list[#three_list + 1] = { v[1], v[2], v[3] }
|
|
touch_key_list[#touch_key_list + 1] = k
|
|
end
|
|
end
|
|
return three_list, touch_key_list
|
|
end
|
|
|
|
function M:CheckPairs(pokerMap, num, length)
|
|
local pairs_list = {}
|
|
local touch_key_list = {}
|
|
if #self.card_list < length then
|
|
return pairs_list, touch_key_list
|
|
end
|
|
local pair_length = length / 2
|
|
local number_start = num - pair_length + 2
|
|
local number_end = 15 - pair_length
|
|
for i = number_start, number_end do
|
|
local item_all_list = {}
|
|
for j = i, i + pair_length - 1 do
|
|
local item_list = pokerMap[j]
|
|
if item_list == nil then
|
|
break
|
|
elseif #item_list < 2 then
|
|
break
|
|
else
|
|
item_all_list[#item_all_list + 1] = item_list[1]
|
|
item_all_list[#item_all_list + 1] = item_list[2]
|
|
end
|
|
if j == i + pair_length - 1 then
|
|
pairs_list[#pairs_list + 1] = item_all_list
|
|
for k = i, i + pair_length - 1 do
|
|
touch_key_list[#touch_key_list + 1] = k
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return pairs_list, touch_key_list
|
|
end
|
|
|
|
function M:CheckThreeAndOne(pokerMap, num, length)
|
|
local three_and_one_list = {}
|
|
local touch_key_list = {}
|
|
if #self.card_list < length then
|
|
return three_and_one_list, touch_key_list
|
|
end
|
|
for k, v in pairs(pokerMap) do
|
|
if #v >= 3 and k > num then
|
|
three_and_one_list[#three_and_one_list + 1] = { v[1], v[2], v[3] }
|
|
touch_key_list = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
|
|
end
|
|
end
|
|
return three_and_one_list, touch_key_list
|
|
end
|
|
|
|
function M:CheckThreeAndTwo(pokerMap, num, length)
|
|
local three_and_two_list = {}
|
|
local touch_key_list = {}
|
|
if #self.card_list < length then
|
|
return three_and_two_list, touch_key_list
|
|
end
|
|
for k, v in pairs(pokerMap) do
|
|
if #v >= 3 and k > num then
|
|
three_and_two_list[#three_and_two_list + 1] = { v[1], v[2], v[3] }
|
|
touch_key_list = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
|
|
end
|
|
end
|
|
return three_and_two_list, touch_key_list
|
|
end
|
|
|
|
function M:CheckStraight(pokerMap, num, length)
|
|
local straight_list = {}
|
|
local touch_key_list = {}
|
|
if #self.card_list < length then
|
|
return straight_list, touch_key_list
|
|
end
|
|
local number_start = num - length + 2
|
|
local number_end = 15 - length
|
|
for i = number_start, number_end do
|
|
local item_all_list = {}
|
|
for j = i, i + length - 1 do
|
|
local item_list = pokerMap[j]
|
|
if item_list == nil then
|
|
break
|
|
else
|
|
item_all_list[#item_all_list + 1] = item_list[1]
|
|
end
|
|
if j == i + length - 1 then
|
|
straight_list[#straight_list + 1] = item_all_list
|
|
for k = i, i + length - 1 do
|
|
touch_key_list[#touch_key_list + 1] = k
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return straight_list, touch_key_list
|
|
end
|
|
|
|
function M:CheckBomb(pokerMap, num, length)
|
|
local bomb_list = {}
|
|
local touch_key_list = {}
|
|
local threeA = DataManager.CurrenRoom.room_config.threeA
|
|
if threeA == 0 then
|
|
-- body
|
|
if #self.card_list < length then
|
|
return bomb_list, touch_key_list
|
|
end
|
|
else
|
|
if #self.card_list < 3 then
|
|
return bomb_list, touch_key_list
|
|
end
|
|
end
|
|
|
|
for k, v in pairs(pokerMap) do
|
|
if #v == 4 and k > num then
|
|
bomb_list[#bomb_list + 1] = v
|
|
touch_key_list[#touch_key_list + 1] = k
|
|
end
|
|
if threeA == 1 and #v == 3 and k == 14 then
|
|
bomb_list[#bomb_list + 1] = v
|
|
touch_key_list[#touch_key_list + 1] = k
|
|
end
|
|
end
|
|
|
|
return bomb_list, touch_key_list
|
|
end
|
|
|
|
function M:CheckPlane(pokerMap, num, length, and_num)
|
|
local plane_list = {}
|
|
local touch_key_list = {}
|
|
local l = and_num + 3
|
|
local pair_length = length / l
|
|
local number_start = num - pair_length + 2
|
|
local number_end = 15 - pair_length
|
|
for i = number_start, number_end do
|
|
local item_all_list = {}
|
|
for j = i, i + pair_length - 1 do
|
|
local item_list = pokerMap[j]
|
|
if item_list == nil then
|
|
break
|
|
elseif #item_list < 3 then
|
|
break
|
|
else
|
|
item_all_list[#item_all_list + 1] = item_list[1]
|
|
item_all_list[#item_all_list + 1] = item_list[2]
|
|
item_all_list[#item_all_list + 1] = item_list[3]
|
|
end
|
|
if j == i + pair_length - 1 then
|
|
plane_list[#plane_list + 1] = item_all_list
|
|
touch_key_list = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
|
|
end
|
|
end
|
|
end
|
|
return plane_list, touch_key_list
|
|
end
|
|
|
|
function M:SetNotTouchCard(touch_key_list, card_map)
|
|
local all_key_list = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
|
|
for i = 1, #all_key_list do
|
|
local key = all_key_list[i]
|
|
local isExsit = self:IsExistByList(touch_key_list, key)
|
|
if isExsit == false then
|
|
local key_card_item = card_map[key]
|
|
if key_card_item ~= nil then
|
|
for j = 1, #key_card_item do
|
|
local card = key_card_item[j]
|
|
card.btn_card.touchable = false
|
|
self:UpdateCardMove(card.btn_card, false, false)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function M:IsExistByList(list, item)
|
|
for i = 1, #list do
|
|
if list[i] == item then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function M:GetCardByNumber(list, number)
|
|
for i = 1, #list do
|
|
if list[i].card_code_number == number then
|
|
return list[i]
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
function M:GetCardMapAndMaxKey(pokerList)
|
|
local map, max_key = {}, 0
|
|
for i = 1, #pokerList do
|
|
local number = math.floor(pokerList[i].card_code_number / 10)
|
|
if number > max_key then
|
|
max_key = number
|
|
end
|
|
if map[number] == nil then
|
|
map[number] = { pokerList[i] }
|
|
else
|
|
map[number][#map[number] + 1] = pokerList[i]
|
|
end
|
|
end
|
|
return map, max_key
|
|
end
|
|
|
|
-- function M:CheckOnes(pokerMap, num, length)
|
|
-- local one_card_list = {}
|
|
-- local touch_key_list = {}
|
|
-- local text = {}
|
|
-- local text2 = {}
|
|
-- local x = 0
|
|
-- if #self.card_list < length then
|
|
-- return one_card_list, touch_key_list
|
|
-- end
|
|
-- for k, v in pairs(pokerMap) do
|
|
-- text = {}
|
|
-- text2 = {}
|
|
-- if k > num then
|
|
-- for l, p in pairs(pokerMap) do
|
|
-- for i = 0, length - 1 do
|
|
-- if l == k + i and l ~= 15 and l ~= 16 then
|
|
-- -- body
|
|
-- text[#text + 1] = { p[1] }
|
|
-- text2[#text2 + 1] = l
|
|
-- if #text >= length then
|
|
-- -- body
|
|
-- local x = #one_card_list
|
|
-- local y = #touch_key_list
|
|
-- for i = 1, #text - 1 do
|
|
-- one_card_list[x + 1] = text[1]
|
|
-- touch_key_list[y + 1] = text2[2]
|
|
-- -- for i, v in pairs(text2[i + 1]) do
|
|
-- -- if v ~= nil then
|
|
-- -- table.insert(touch_key_list[x + 1], v)
|
|
-- -- end
|
|
-- -- end
|
|
-- for i, v in pairs(text[i + 1]) do
|
|
-- if v ~= nil then
|
|
-- table.insert(one_card_list[x + 1], v)
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- end
|
|
-- return one_card_list, touch_key_list, length
|
|
-- end
|
|
|
|
function M:CheckOnes(pokerMap)
|
|
local one_card_list = {}
|
|
local old_k = 0
|
|
for k, v in pairs(pokerMap) do
|
|
if #one_card_list == 0 then
|
|
table.insert(one_card_list, v)
|
|
old_k = k
|
|
else
|
|
if k == 15 then
|
|
break
|
|
end
|
|
if k ~= old_k + 1 and #one_card_list >= 5 then
|
|
break
|
|
end
|
|
if k ~= old_k + 1 then
|
|
one_card_list = {}
|
|
end
|
|
table.insert(one_card_list, v)
|
|
old_k = k
|
|
end
|
|
end
|
|
if #one_card_list < 5 then
|
|
one_card_list = {}
|
|
end
|
|
return one_card_list
|
|
end
|
|
|
|
function M:Clear()
|
|
self:PlayScore(nil)
|
|
self:SetOutCardInfo(nil, false)
|
|
self.card_list = {}
|
|
self.out_card_list = {}
|
|
self._view_handCard:RemoveChildren(0, -1, true)
|
|
self._flag_ruleCard = false
|
|
-- self.mask_liangpai:RemoveChildren(0,-1,true)
|
|
end
|
|
|
|
function M:ClearCheck()
|
|
self.card_list = {}
|
|
self.out_card_list = {}
|
|
self._view_handCard:RemoveChildren(0, -1, true)
|
|
end
|
|
|
|
function M:Destroy()
|
|
Stage.inst.onTouchMove:Remove(self.touchMoveFun)
|
|
Stage.inst.onTouchEnd:Remove(self.touchMoveEndFun)
|
|
end
|
|
|
|
return M
|