hengyang_client/lua_probject/extend_project/extend/zipai/fulushou/EXGameController.lua

local RB_Protocol = import(".Protocol")
local FZTipList = import(".main.FZData")
local RB_GameEvent = import(".RunBeard_GameEvent")
local M = {}

--- Create a new HZ_GameController
function M.new()
    setmetatable(M, { __index = GameController })
    local self = setmetatable({}, { __index = M })
    self:init("福禄寿")
    self.class = "RB_GameController"
    return self
end

function M:init(name)
    GameController.init(self, name)

    self._eventmap[RB_Protocol.GAME_EVT_PLAYER_DEAL] = self.OnEventSendCards
    self._eventmap[RB_Protocol.GAME_EVT_CHANGE_ACTIVE_PLAYER] = self.OnEventTurn

    self._eventmap[RB_Protocol.GAME_EVT_DRAW] = self.OnEventTakeCard
    self._eventmap[RB_Protocol.GAME_EVT_DISCARD_TIP] = self.OnEventOutHint
    self._eventmap[RB_Protocol.GAME_EVT_DISCARD] = self.OnEventOutCard

    self._eventmap[RB_Protocol.GAME_EVT_FZTIPS] = self.OnEventFzTips

    self._eventmap[RB_Protocol.GAME_EVT_ACTION] = self.OnEventFzAction

    self._eventmap[RB_Protocol.GAME_EVT_HU] = self.OnEventHu

    self._eventmap[RB_Protocol.GAME_EVT_RESULT1] = self.OneventResult1
    self._eventmap[RB_Protocol.GAME_EVT_QIPAI] = self.OnEventQIPAI
    --self._eventmap[RB_Protocol.GAME_EVT_ADD_CARD] = self.OnAddCard

    self._eventmap[RB_Protocol.GAME_EVT_Piao_Tip] = self.OnPiaoTip
    self._eventmap[RB_Protocol.GAME_EVT_Piao_Action] = self.OnPiaoAction

    self._eventmap[RB_Protocol.GAME_EVENT_XIPAI] = self.OnEventXiPai
    self._eventmap[RB_Protocol.GAME_EVENT_NOTIFY_XIPAI] = self.OnEventXiPaiAnim
end

function M:SendXiPaiAction(callBack)
    local _data = {}
    local _client = ControllerManager.GameNetClinet
    _client:send(RB_Protocol.GAME_XIPAI, _data)
    self.XiPaiCallBack = callBack
end

function M:OnEventXiPai(evt_data)
    if evt_data["result"] == 0 then
        if self.XiPaiCallBack then
            self.XiPaiCallBack()
        end
    else
        ViewUtil.ErrorTip(1000000, "申请洗牌失败")
    end
end

function M:OnEventXiPaiAnim(evt_data)
    printlog("洗牌动画===》》》》")
    pt(evt_data)
    local playeridList = evt_data["list"]
    local my_isXiPai = false
    local other_isXiPai = false
    if playeridList and #playeridList > 0 then
        for i = 1, #playeridList do
            local p = self._room:GetPlayerById(playeridList[i])
            if p == self._room.self_player then
                my_isXiPai = true
            else
                other_isXiPai = true
            end
        end
    end

    self._cacheEvent:Enqueue(function()
        DispatchEvent(self._dispatcher, RB_GameEvent.EventXiPai, my_isXiPai, other_isXiPai)
    end)
end

-- 发送出牌指令到服务器
function M:SendOutCard(card)
    local _data = {}
    _data["card"] = card
    local _room = self._room
    local _client = ControllerManager.GameNetClinet
    if _client ~= nil then
        _client:send(RB_Protocol.GAME_DIS_CARD, _data)
    end
end

--GAME_CHANGE_CARD GAME_DIS_CARD
function M:SendChangeCards(card_list)
    local _data = {}
    if card_list then
        _data["card_list"] = card_list
    else
        _data["card_list"] = {}
    end
    local _client = ControllerManager.GameNetClinet
    if _client ~= nil then
        _client:send(RB_Protocol.GAME_CHANGE_CARD, _data)
    end
end

function M:SendChangeTypeFace(TypeFace)
    -- body
    local _data = {}
    _data["typeface"] = TypeFace
    local _client = ControllerManager.GameNetClinet
    if _client ~= nil then
        _client:send(RB_Protocol.GAME_CHANGE_TYPEfACE, _data)
    end
end

function M:ConformToNextGame()
    local _client = ControllerManager.GameNetClinet
    if _client ~= nil then
        _client:send(RB_Protocol.GAME_EVT_CHUI)
    end
end

-- 发送放子选择到服务器
function M:SendAction(id, num)
    local _data = {}
    _data["id"] = id
    if num ~= nil then
        _data["biid"] = num
    end
    local _client = ControllerManager.GameNetClinet
    if _client ~= nil then
        _client:send(RB_Protocol.GAME_ACTION, _data)
    end
end

function M:SendPiao(piao, callBack)
    local _data = {}
    _data["id"] = piao
    local _client = ControllerManager.GameNetClinet
    _client:send(RB_Protocol.GAME_EVT_Send_Piao, _data)
    self.PiaoTipsCallBack = callBack
end

function M:OnPiaoTip(evt_data)
    if ViewManager.GetCurrenView().dview_class == LobbyView then
        self:ReturnToRoom()
        return
    end
    printlog("飘分提示===>>>>")
    pt(evt_data)

    local piao = evt_data["piao"]
    local reload = evt_data["reload"]
    local last_piao = evt_data["last_piao"]
    local last_winer = evt_data["last_winer"]
    self._cacheEvent:Enqueue(
        function()
            DispatchEvent(self._dispatcher, RB_GameEvent.OnPiaoTips, piao, reload, last_piao, last_winer)
            ControllerManager.IsSendCard = true
        end
    )
end

function M:OnPiaoAction(evt_data)
    local seat = evt_data["seat"]
    local piao = evt_data["piao"]
    if seat == DataManager.CurrenRoom.self_player.seat then
        if self.PiaoTipsCallBack then
            self.PiaoTipsCallBack()
            self.PiaoTipsCallBack = nil
        end
    end
    self._cacheEvent:Enqueue(
        function()
            DispatchEvent(self._dispatcher, RB_GameEvent.OnPiaoAction, seat, piao)
        end
    )
end

function M:OnEventSendCards(evt_data)
    printlog("发牌事件===》》》")
    pt(evt_data)
    if ViewManager.GetCurrenView().dview_class == LobbyView then
        self:ReturnToRoom()
        return
    end

    local _room = self._room
    _room.curren_round = _room.curren_round + 1
    if _room.curren_round > 0 then _room.playing = true end

    local handcards = {}
    if evt_data.card_list and #evt_data.card_list > 0 then
        handcards = evt_data["card_list"]
    else
        ViewUtil.ErrorTip(100000, "发牌数据异常")
    end

    local p = _room.self_player
    local seat = nil
    if evt_data.bank_seat then
        seat = evt_data["bank_seat"]
    else
        ViewUtil.ErrorTip(100001, "发牌座位异常")
    end

    _room.banker_seat = seat
    for i = 1, #_room.player_list do
        _room.self_player.handcard_list = {}
        _room.self_player.card_list = {}
        _room.player_list[i].hand_left_count = 18
        _room.player_list[i].fz_list = {}
        _room.player_list[i].card_list = {}
        _room.player_list[i].outcard_list = {}
        _room.player_list[i].hu_xi = 0
    end
    self._cacheEvent:Enqueue(function()
        _room.self_player.handcard_list = handcards
        self._room.self_player.hand_left_count = #handcards
        DispatchEvent(self._dispatcher, RB_GameEvent.SendCards, p)
        -- print("发牌结束=====打开标志")
        ControllerManager.IsSendCard = true
    end)
end

function M:OnEventOutCard(evt_data)
    printlog("出牌===>>>")
    pt(evt_data)
    local seat = evt_data["seat"]
    local card = evt_data["card"]

    local p = self._room:GetPlayerBySeat(seat)
    self._cacheEvent:Enqueue(function()
        local _room = self._room
        if (seat == _room.self_player.seat) then
            list_remove(_room.self_player.handcard_list, card)
        end
        p.DiceCard = card
        p.hand_left_count = p.hand_left_count - 1

        if (not p.outcard_list) then p.outcard_list = {} end
        p.outcard_list[#p.outcard_list + 1] = card

        DispatchEvent(self._dispatcher, RB_GameEvent.OutCard, p, card)
    end)
end

function M:OnEventQIPAI(evt_data)
    printlog("弃牌===>>>")
    local seat = evt_data["seat"]
    local card = evt_data["card"]
    local p = self._room:GetPlayerBySeat(seat)
    self._cacheEvent:Enqueue(function()
        local _room = self._room
        if (not p.outcard_list) then p.outcard_list = {} end
        p.outcard_list[#p.outcard_list + 1] = card
        DispatchEvent(self._dispatcher, RB_GameEvent.QiCard, seat, card)
    end)
end

function M:OnEventTakeCard(evt_data)
    printlog("抓牌====>>>>")
    pt(evt_data)

    self._room.self_player.CardTingList = {}
    self._room.self_player.allTingPaiList = {}
    self._room.self_player.tingPaiList = evt_data.ting_list

    if evt_data.ting_list and #evt_data.ting_list > 0 then
        local tempTingList = {}
        local tempCardTingList = {}
        for i = 1, #DataManager.CurrenRoom.self_player.tingPaiList do
            local tempCard = DataManager.CurrenRoom.self_player.tingPaiList[i].card
            local tempV = DataManager.CurrenRoom.self_player.tingPaiList[i].value
            tempCardTingList[tempCard] = tempV
            if tempV and #tempV > 0 then
                for j = 1, #tempV do
                    if IsHasDictionary(tempV[j], tempTingList) == false then
                        table.insert(tempTingList, tempV[j])
                    end
                end
            end
        end
        if #tempTingList > 0 then
            DispatchEvent(self._dispatcher, RB_GameEvent.TuoGuanTipsEvt, true)
            self._room.self_player.allTingPaiList = tempTingList
            self._room.self_player.CardTingList = tempCardTingList
            --pt(tempCardTingList)
        end
    else
        DispatchEvent(self._dispatcher, RB_GameEvent.TuoGuanTipsEvt, false)
    end

    ----------
    local _room = self._room
    local seat = evt_data["seat"]
    local card = evt_data["card"]
    local left_count = evt_data["left_count"]
    local handcard_list = evt_data["card_list"]
    local outcard_list = evt_data["outcard_list"]
    local p = _room:GetPlayerBySeat(seat)
    p.hand_left_count = p.hand_left_count + 1
    if seat == _room.self_player.seat then
        self._cacheEvent:Enqueue(function()
            if card ~= 0 then
                p.DiceCard = card
            end

            if (seat == _room.self_player.seat) then
                p.hand_left_count = #handcard_list
                --_room.self_player.handcard_list[#_room.self_player.handcard_list+1] = card
                _room.self_player.handcard_list = handcard_list
            end

            p.outcard_list = outcard_list

            DispatchEvent(self._dispatcher, RB_GameEvent.GetCard, seat, card, left_count)
        end)
    else
        DispatchEvent(self._dispatcher, RB_GameEvent.ShowremainCard, seat, left_count)
    end
end

function M:OnAddCard(evt_data)
    local _room = self._room
    local seat = evt_data["seat"]
    local card = evt_data["card"]
    local p = _room:GetPlayerBySeat(seat)

    self._cacheEvent:Enqueue(function()
        p.DiceCard = 0
        p.hand_left_count = p.hand_left_count + 1
        if (seat == _room.self_player.seat) then
            _room.self_player.handcard_list[#_room.self_player.handcard_list + 1] = card
        end
        DispatchEvent(self._dispatcher, RB_GameEvent.AddCard, seat, card)
    end)
end

function M:OnEventOutHint(evt_data)
    printlog("出牌提示事件===》》》")
    pt(evt_data)
    self._cacheEvent:Enqueue(function()
        DispatchEvent(self._dispatcher, RB_GameEvent.OutHint)
    end)
end

function M:OnEventTurn(evt_data)
    local seat = evt_data["seat"]
    self._cacheEvent:Enqueue(function()
        DispatchEvent(self._dispatcher, RB_GameEvent.EventTurn, seat)
    end)
end

function M:OnEventFzTips(evt_data)
    printlog("放子提示事件===》》》")
    pt(evt_data)
    self._cacheEvent:Enqueue(function()
        local tiplist = FZTipList.new()
        local list = evt_data["tip_list"]
        --local uid =  evt_data["uid"]
        for i = 1, #list do
            local dtip = list[i]
            local tip = {}
            tip.id = dtip["id"]
            tip.weight = dtip["weight"]
            tip.card = dtip["card"]
            tip.type = dtip["type"]
            --tip.bi_list = dtip["bi_list"]
            if (dtip["opcard"]) then
                local opcard = dtip["opcard"]
                tip.OpCard = opcard
                table.sort(tip.OpCard)
                tip.OpCard[3] = tip.Card
            end
            tiplist:AddTip(tip)
        end
        DispatchEvent(self._dispatcher, RB_GameEvent.FZTips, tiplist)
    end)
end

function M:OnEventFzAction(evt_data)
    printlog("放子行为事件===》》》")
    pt(evt_data)


    self._room.self_player.CardTingList = {}
    self._room.self_player.allTingPaiList = {}
    self._room.self_player.tingPaiList = evt_data.ting_list

    if evt_data.ting_list and #evt_data.ting_list > 0 then
        local tempTingList = {}
        local tempCardTingList = {}
        for i = 1, #DataManager.CurrenRoom.self_player.tingPaiList do
            local tempCard = DataManager.CurrenRoom.self_player.tingPaiList[i].card
            local tempV = DataManager.CurrenRoom.self_player.tingPaiList[i].value
            tempCardTingList[tempCard] = tempV
            if tempV and #tempV > 0 then
                for j = 1, #tempV do
                    if IsHasDictionary(tempV[j], tempTingList) == false then
                        table.insert(tempTingList, tempV[j])
                    end
                end
            end
        end
        if #tempTingList > 0 then
            DispatchEvent(self._dispatcher, RB_GameEvent.TuoGuanTipsEvt, true)
            self._room.self_player.allTingPaiList = tempTingList
            self._room.self_player.CardTingList = tempCardTingList
            --pt(tempCardTingList)
        end
    else
        DispatchEvent(self._dispatcher, RB_GameEvent.TuoGuanTipsEvt, false)
    end


    ---------

    local _room = self._room
    _room.self_player.currentNotPutCardList = evt_data["notput"]
    local playerid = evt_data["playerid"]
    local card = evt_data["card"]
    local ftype = evt_data["type"]
    local from_seat = evt_data["from_seat"]
    local opcard = evt_data["opcard"]
    local outcard_list = evt_data["outcard_list"]
    local huxi = evt_data["hu_xi"]
    local actice_card = membe_clone(opcard)
    table.insert(actice_card, card)
    local p = _room:GetPlayerById(playerid)
    self._cacheEvent:Enqueue(function()
        local isNeedDelHandCard = 0
        p.hu_xi                 = huxi
        local fz                = {}
        fz.card                 = card
        fz.type                 = ftype
        fz.active_card          = actice_card
        fz.from_seat            = from_seat
        fz.opcard               = opcard
        local remove_num        = #opcard
        if ftype == RB_FZTypeFLS.Chi then
            p.fz_list[#p.fz_list + 1] = fz
            if (p == _room.self_player) then
                for i = 1, remove_num do
                    list_remove(_room.self_player.handcard_list, opcard[i])
                end
            end
        elseif ftype == RB_FZTypeFLS.Peng then
            p.fz_list[#p.fz_list + 1] = fz
            if (p == _room.self_player) then
                for i = 1, remove_num do
                    list_remove(_room.self_player.handcard_list, opcard[i])
                end
            end
        elseif ftype == RB_FZTypeFLS.Gang or ftype == RB_FZTypeFLS.SGang or ftype == RB_FZTypeFLS.Zhao or ftype == RB_FZTypeFLS.SZhao then
            p.fz_list[#p.fz_list + 1] = fz
            if (p == _room.self_player) then
                for i = 1, remove_num do
                    list_remove(_room.self_player.handcard_list, opcard[i])
                end
            end
        end

        p.tempOutcartList = outcard_list
        p.hand_left_count = p.hand_left_count - remove_num
        DispatchEvent(self._dispatcher, RB_GameEvent.FangziAction, fz, p)
    end)
end

function M:OnEventHu(evt_data)
    local cards = evt_data["card"]
    local win_p = self._room:GetPlayerBySeat(evt_data["seat"])
    local lose_p = self._room:GetPlayerBySeat(evt_data["from_seat"])
    -- -- print(win_p.hand_left_count)

    self._cacheEvent:Enqueue(function()
        win_p.card_list = cards
        table.sort(win_p.card_list, ViewUtil.HandCardSort)
        DispatchEvent(self._dispatcher, RB_GameEvent.ZPHuCard, evt_data["seat"], evt_data["from_seat"], cards)
    end)
end

function M:OneventResult1(evt_data)
    printlog("结算=============>>>")
    pt(evt_data)
    local over = evt_data.type
    --0：小结算   1：小大结算    2：大结算
    self._room.playing = false
    if 0 == over then
        local result = evt_data.result
        for i = 1, #self._room.player_list do
            local p = self._room.player_list[i]
            p.hand_left_count = 0
            p.outcard_list = {}
        end
        self._cacheEvent:Enqueue(function()
            DispatchEvent(self._dispatcher, RB_GameEvent.ZPResult1, result);
        end)
    elseif 1 == over or 2 == over then
        DataManager.CurrenRoom.Over = true
        ControllerManager.SetGameNetClient(nil, true)
        local total_result = evt_data.total_result
        local result = evt_data.result
        self._cacheEvent:Enqueue(function()
            DispatchEvent(self._dispatcher, RB_GameEvent.ZPResult2, result, total_result, over);
        end)
    end
end

return M