GongFuServer/script/module/absAct/DrumBlastingLogic.lua

--[[
    absAct[id] = {
        drum = {
            [id] = cnt,state
            [id] = cnt,state
        }
        blasting = {
            [id] = cnt,state
        }
        box = {
            [id] = state
        }
        blastingCnt = 0
        buling = 0
    }

]]

local AbsActLogic = require("absAct.AbsActLogic")
local AbsActExcel = require("excel.absAct")
local BuyExcel = require("excel.buy")
local Util = require("common.Util")
local Msg = require("core.Msg")
local Grid = require("bag.Grid")
local BagLogic = require("bag.BagLogic")
local BuyLogic = require("topup.BuyLogic")
local YunYingLogic = require("yunying.YunYingLogic")

function isOpen(human, YYInfo, funcConfig)
    local state, endTime, startTime = AbsActLogic.isStarted(human, funcConfig.funcID)
    if not state then return end
    local absAct = human.db.absAct[funcConfig.funcID]
    if absAct and absAct.dayCnt and absAct.dayCnt <= 0 and #absAct.item <= 0 then
        return false
    end
    return true, endTime, startTime
end

function isActive(human, YYInfo, funcConfig)
    return not isOpen(human, YYInfo, funcConfig)
end


-- 锟斤拷始锟斤拷锟斤拷锟捷匡拷
function initDB(human,id)
    local absAct = human.db.absAct[id]
    absAct.drum = absAct.drum or {} 
    absAct.blasting = absAct.blasting or {} 
    absAct.box = absAct.box or {} 
    absAct.blastingCnt = absAct.blastingCnt or 0 
    absAct.buling = absAct.buling or 0 
end

-- 锟斤拷锟斤拷锟斤拷锟斤拷
function getAndSendMsg(human,id,actID)
    -- 锟叫断活动锟角凤拷锟斤拷
    local state, endTime, starTime = AbsActLogic.isStarted(human, id)
    if not state then return end

    local absConfig = AbsActExcel.absActivity[id]
    if not absConfig then return end

    local absAct = human.db.absAct[id]
    if not absAct then
        return
    end
    initDB(human,id)
    
    local nowDay = Util.diffDay(starTime) + 1
    -- 锟斤拷锟斤拷锟斤拷锟斤拷
    local msgRet = Msg.gc.GC_ABS_ND_TASK_QUERY
    -- 锟斤拷锟斤拷锟斤拷
    local taskConfig = AbsActExcel.drum
    local len = #taskConfig
    local count = 0
    msgRet.day = nowDay
    BuyLogic.fontBuyItem(human, msgRet.buyItem, AbsActExcel.blastingBox[1].buyID)
    for i = 1,len do
        local v = taskConfig[i]
        if v.day == nowDay then
            count = count + 1
            local net = msgRet.drumList[count]
            net.id = i
            net.desc = v.desc
            net.name = v.name
            net.needCnt = v.needCnt
            net.panelID = v.panelID
            net.nowCnt = absAct.drum[i] and absAct.drum[i].cnt or 0
            net.state = absAct.drum[i] and absAct.drum[i].state or 0
            for j = 1,#v.item do
                Grid.makeItem(net.item[j],v.item[j][1],v.item[j][2])
            end
            net.item[0] = #v.item
        end
    end
    msgRet.drumList[0] = count
    -- 锟斤拷锟斤拷锟斤拷
    taskConfig = AbsActExcel.blasting
    len = #taskConfig
    for i = 1,len do
        local v = taskConfig[i]
        local net = msgRet.blastingList[i]
        net.id = i 
        net.desc = v.desc
        net.name = v.name
        net.needCnt = v.needCnt
        net.nowCnt = absAct.blasting[i] and absAct.blasting[i].cnt or 0
        net.state = absAct.blasting[i] and absAct.blasting[i].state or 0
        local itemLen = type(v.item[nowDay]) == "table" and #v.item[nowDay] or 0
        for j = 1,itemLen do
            Grid.makeItem(net.item[j],v.item[nowDay][j][1],v.item[nowDay][j][2])
        end
        net.item[0] = itemLen --#v.item[nowDay]
        net.panelID = v.panelID or 0
    end
    msgRet.blastingList[0] = len
    -- 锟斤拷锟斤拷锟斤拷锟斤拷
    taskConfig = AbsActExcel.blastingBox
    len = #taskConfig
    for i = 1,len do
        local v = taskConfig[i]
        local net = msgRet.boxList[i]
        net.id = i
        net.needCnt = v.needCnt
        net.state = absAct.box[i] or 0
        for j = 1,#v.item do
            Grid.makeItem(net.item[j],v.item[j][1],v.item[j][2])
        end
        net.item[0] = #v.item
    end
    msgRet.boxList[0] = len
    msgRet.blastingCnt = absAct.blastingCnt
    Msg.send(msgRet,human.fd)
end

-- 锟斤拷取锟斤拷品
-- type 1锟斤拷,2锟斤拷,3锟斤拷
function get(human,index,type,id)
    -- 锟叫断活动锟角凤拷锟斤拷
    local state, endTime, starTime = AbsActLogic.isStarted(human, id)
    if not state then return end

    local absConfig = AbsActExcel.absActivity[id]
    if not absConfig then return end

    local absAct = human.db.absAct[id]
    if not absAct then
        return
    end
    initDB(human,id)

    local nowDay = Util.diffDay(starTime) + 1
    local allItems = {}  -- 用于批量领取时收集所有奖励
    
    -- 如果index为0或nil，则批量领取该type下所有可领取的奖励
    if not index or index == 0 then
        local hasReward = false
        
        if type == 1 then
            -- 福袋任务：遍历所有drum任务，领取状态为1的
            local taskConfig = AbsActExcel.drum
            for i = 1, #taskConfig do
                local v = taskConfig[i]
                if v.day == nowDay then
                    -- 确保数据结构存在
                    absAct.drum[i] = absAct.drum[i] or {}
                    local taskState = absAct.drum[i].state or 0
                    if taskState == 1 then
                        hasReward = true
                        -- 收集奖励
                        for j = 1, #v.item do
                            table.insert(allItems, v.item[j])
                        end
                        -- 更新状态
                        absAct.drum[i].state = 2
                    end
                end
            end
        elseif type == 2 then
            -- 礼炮奖励：遍历所有blasting，领取状态为1的
            local taskConfig = AbsActExcel.blasting
            for i = 1, #taskConfig do
                local v = taskConfig[i]
                -- 确保数据结构存在
                absAct.blasting[i] = absAct.blasting[i] or {}
                local blastingState = absAct.blasting[i].state or 0
                if blastingState == 1 then
                    hasReward = true
                    -- 收集奖励
                    local itemLen = type(v.item[nowDay]) == "table" and #v.item[nowDay] or 0
                    for j = 1, itemLen do
                        table.insert(allItems, v.item[nowDay][j])
                    end
                    -- 更新状态
                    absAct.blasting[i].state = 2
                    -- 增加一次，累计放炮次数，判断是否达到进度奖励领取值
                    absAct.blastingCnt = (absAct.blastingCnt or 0) + 1
                    for j = 1, #AbsActExcel.blastingBox do
                        if absAct.blastingCnt - 1 < AbsActExcel.blastingBox[j].needCnt and absAct.blastingCnt == AbsActExcel.blastingBox[j].needCnt then
                            absAct.box[j] = 1
                            break
                        end
                    end
                end
            end
        elseif type == 3 then
            -- 进度奖励：遍历所有box，领取状态为1的
            local taskConfig = AbsActExcel.blastingBox
            for i = 1, #taskConfig do
                local v = taskConfig[i]
                local boxState = absAct.box[i] or 0
                if boxState == 1 then
                    hasReward = true
                    -- 收集奖励
                    for j = 1, #v.item do
                        table.insert(allItems, v.item[j])
                    end
                    -- 更新状态
                    absAct.box[i] = 2
                end
            end
        end
        
        -- 如果有奖励，则发放
        if hasReward and #allItems > 0 then
            BagLogic.addItemList(human, allItems, "abs_drumblasting")
            getAndSendMsg(human, id, absConfig.actID)
            YunYingLogic.sendBanner(human)
            YunYingLogic.sendGroupUpdate(YYInfo[id], human, absConfig.panelID)
        end
        return
    end
    
    -- 原有逻辑：单个领取
    local item = nil

    -- 选锟斤拷锟接︼拷锟斤拷锟?
    local config = nil
    local state = nil
    if type == 1 then
        config = AbsActExcel.drum[index]
        state = absAct.drum[index] and absAct.drum[index].state or 0
    elseif type == 2 then
        config = AbsActExcel.blasting[index]
        state = absAct.blasting[index] and absAct.blasting[index].state or 0
    elseif type == 3 then
        config = AbsActExcel.blastingBox[index]
        state = absAct.box[index] or 0
    end

    -- 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟?
    if not config then
        return 
    end

    -- 状态锟斤拷为锟斤拷锟斤拷取
    if state ~= 1 then
        return
    end

    -- 锟侥憋拷状态
    if type == 1 then
        item = config.item
        absAct.drum[index].state = 2
    elseif type == 2 then
        item = config.item[nowDay]
        absAct.blasting[index].state = 2
        -- 锟斤拷锟斤拷一锟斤拷,锟斤拷锟斤拷锟桔计达拷锟斤拷锟斤拷锟斤拷锟叫讹拷锟角凤拷锏斤拷锟斤拷锟斤拷锟饺★拷锟街?
        absAct.blastingCnt = absAct.blastingCnt + 1
        for i = 1,#AbsActExcel.blastingBox do
            if absAct.blastingCnt - 1 < AbsActExcel.blastingBox[i].needCnt and absAct.blastingCnt == AbsActExcel.blastingBox[i].needCnt then
                absAct.box[i] = 1
                break
            end
        end
    elseif type == 3 then
        item = config.item
        absAct.box[index] = 2
    else
        return
    end

    BagLogic.addItemList(human, item, "abs_drumblasting")
    getAndSendMsg(human,id,absConfig.actID)
    
    YunYingLogic.sendBanner(human)
    YunYingLogic.sendGroupUpdate(YYInfo[id], human, absConfig.panelID)
end

-- 每锟斤拷锟斤拷锟斤拷锟皆撅拷锟?
function onDailyTask(human,funcID, parameter)
    drumTaskCallBack(human,funcID,1,parameter)
end

-- 锟劫伙拷
function onDrawCard(human,funcID, parameter)
    drumTaskCallBack(human,funcID,2,parameter)
end

-- 锟斤拷魔之锟斤拷
function onHuangjingTower(human,funcID, parameter)
    drumTaskCallBack(human,funcID,3,parameter)
end

-- 锟斤拷值
function onCharge(human, parameter,funcID)
    -- 涓存椂澶勭悊 
    drumTaskCallBack(human,funcID,4,parameter)
end

-- 锟斤拷锟斤拷锟斤拷锟斤拷
function onDrill(human,funcID, parameter)
    drumTaskCallBack(human,funcID,5,parameter)
end

-- 女锟斤拷森锟斤拷
function onCopyChallenge(human,funcID, parameter)
    drumTaskCallBack(human,funcID,6,parameter)
end

-- 锟节撅拷锟斤拷锟斤拷
function onJjcFight(human,funcID, parameter)
    drumTaskCallBack(human,funcID,7,parameter)
end

-- 锟斤拷锟斤拷痰旯猴拷锟?
function onShopBuy(human,funcID,parameter)
    drumTaskCallBack(human,funcID,8,parameter)
end

-- 冒锟斤拷扫锟斤拷
function onMopup(human,funcID,parameter)
    drumTaskCallBack(human,funcID,9,parameter)
end

-- 锟斤拷锟斤拷锟斤拷穴
function onBinglong(human,funcID,parameter)
    drumTaskCallBack(human,funcID,10,parameter)
end

-- 锟斤拷锟?
function onExchangeJinbi(human,funcID,parameter)
    drumTaskCallBack(human,funcID,11,parameter)
end

-- 锟斤拷锟斤拷
function onBarTaskgetDo(human,funcID,parameter)
    drumTaskCallBack(human,funcID,12,parameter)
end

-- 锟斤拷锟斤拷
function onUnionDonate(human,funcID,parameter)
    drumTaskCallBack(human,funcID,13,parameter)
end

-- 锟斤拷锟结副锟斤拷
function onUnionEctypeFight(human,funcID,parameter)
    drumTaskCallBack(human,funcID,14,parameter)
end

-- 占锟斤拷
function onZhanBuBuyCard(human,funcID,parameter)
    -- ZhanbuLogic.lua  436琛? 浼犵殑鏁板€间负璐?, 涓嶇煡閬撳摢涓?鐩戝惉璇ヤ簨浠剁殑鍦版柟闇€瑕佹暟鍊间负璐燂紝鎵€浠ュ彧澶勭悊褰撳墠妯″潡
    if parameter < 0 then
        return
    end
    drumTaskCallBack(human,funcID,15,parameter)
end

-- 锟斤拷锟斤拷锟斤拷石
function onDecZuanshi(human,funcID,parameter)
    drumTaskCallBack(human,funcID,16,parameter)
end

-- 锟斤拷锟斤拷锟斤拷渊
function onLianyu(human,funcID,parameter)
    drumTaskCallBack(human,funcID,17,parameter)
end

-- 锟较成凤拷锟斤拷
function onFuwenHecheng(human,funcID,parameter)
    drumTaskCallBack(human,funcID,18,parameter)
end



-- 锟截碉拷
function drumTaskCallBack(human,id,type,cnt)
    AbsActLogic.checkAbsActClean(human, id)
   

    local state, endTime, starTime = AbsActLogic.isStarted(human, id)
    -- 娲诲嫊鏈?闁嬪晸
    if not state or os.time() > endTime then 
        return
    end
    
    local absConfig = AbsActExcel.absActivity[id]
    if not absConfig then return end

    local absActData = human.db.absAct[id]
    if not absActData then 
        return
    end

    initDB(human,id)

    local nowDay = Util.diffDay(starTime) + 1
    -- 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
    local taskConfig = AbsActExcel.drum
    for k = 1,#taskConfig do
        if taskConfig[k].type == type and taskConfig[k].day == nowDay then
            local taskID = k
            human.db.absAct[id].drum[taskID] = human.db.absAct[id].drum[taskID] or {}
            human.db.absAct[id].drum[taskID].cnt = human.db.absAct[id].drum[taskID].cnt or 0
            human.db.absAct[id].drum[taskID].state = human.db.absAct[id].drum[taskID].state or 0
            human.db.absAct[id].drum[taskID].cnt = human.db.absAct[id].drum[taskID].cnt + cnt
            if human.db.absAct[id].drum[taskID].state ~= 0 and cnt < 0 then
                human.db.absAct[id].drum[taskID].cnt = human.db.absAct[id].drum[taskID].cnt - cnt
            end
            local config = AbsActExcel.drum[taskID]
            -- 锟斤拷锟斤拷锟斤拷锟斤拷
            if human.db.absAct[id].drum[taskID].cnt >= config.needCnt and human.db.absAct[id].drum[taskID].state == 0 then
                human.db.absAct[id].drum[taskID].state = 1
                -- 锟叫讹拷锟角凤拷锟斤拷锟斤拷锟斤拷锟斤拷
                for i = 1,#config.blasting do
                    local blastingID = config.blasting[i]
                    local blastingConfig = AbsActExcel.blasting[blastingID]
                    human.db.absAct[id].blasting[blastingID] = human.db.absAct[id].blasting[blastingID] or {}
                    human.db.absAct[id].blasting[blastingID].cnt = human.db.absAct[id].blasting[blastingID].cnt or 0
                    human.db.absAct[id].blasting[blastingID].state = human.db.absAct[id].blasting[blastingID].state or 0
                    human.db.absAct[id].blasting[blastingID].cnt = human.db.absAct[id].blasting[blastingID].cnt + 1
                    if human.db.absAct[id].blasting[blastingID].cnt >= 3 and human.db.absAct[id].blasting[blastingID].state ~= 2 then
                        human.db.absAct[id].blasting[blastingID].state = 1
                    end
                end
            end
        end
    end
    
    YunYingLogic.sendBanner(human)
    YunYingLogic.sendGroupUpdate(YYInfo[id], human, absConfig.panelID)
end

-- 每锟斤拷锟斤拷锟矫鼓ｏ拷锟斤拷状态
function updateDaily(human,id)
    local state, endTime, starTime = AbsActLogic.isStarted(human, id)
    if not state then return end

    local config = AbsActExcel.absActivity[id]
    if not config then return end

    AbsActLogic.checkAbsActClean(human, id)

    local absAct = human.db.absAct[id] or {}
    absAct.drum = {} 
    absAct.blasting = {} 
    absAct.box = absAct.box or {} 
    absAct.blastingCnt = absAct.blastingCnt or 0
    human.db.absAct[id] = absAct
end

 -- 鍥犱负鐜╁?跺湪娲诲姩鏈?寮€鍚?鍓嶅畬鎴愪簡娲昏穬搴︿换鍔★紝娲诲姩寮€鍚?鍚庢病娉曞畬鎴愭椿璺冨害浠诲姟,鎵€浠ュ湪鐜╁?朵笂绾挎椂,鍋氫竴娆℃洿鏂版椿璺冨害鏁版嵁鎿嶄綔
function specialFunc(human, id)
    AbsActLogic.checkAbsActClean(human, id)
    local state, endTime, starTime = AbsActLogic.isStarted(human, id)
    -- 娲诲嫊鏈?闁嬪晸
    if not state or os.time() > endTime then 
        return
    end
    
    local absConfig = AbsActExcel.absActivity[id]
    if not absConfig then return end

    local absActData = human.db.absAct[id]
    if not absActData then 
        return
    end

    initDB(human,id)
    local nowHuoYue = human.db.dailyTask and human.db.dailyTask.nowHuoYue or 0
    if nowHuoYue > 0 then
        local nowDay = Util.diffDay(starTime) + 1
        local actType = 1
        -- 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
        local singleData
        local isChange = false
        local taskConfig = AbsActExcel.drum
        for k = 1,#taskConfig do
            if taskConfig[k].type == actType and taskConfig[k].day == nowDay then
                local taskID = k
                human.db.absAct[id].drum[taskID] = human.db.absAct[id].drum[taskID] or {}
                singleData = human.db.absAct[id].drum[taskID]
                singleData.cnt = singleData.cnt or 0
                singleData.state = singleData.state or 0
                if singleData.cnt > 0 then 
                    break 
                end
                singleData.cnt = nowHuoYue
                isChange = true

                -- if human.db.absAct[id].drum[taskID].state ~= 0 and cnt < 0 then
                --     human.db.absAct[id].drum[taskID].cnt = human.db.absAct[id].drum[taskID].cnt - cnt
                -- end
                local config = AbsActExcel.drum[taskID]
                -- 锟斤拷锟斤拷锟斤拷锟斤拷
                if singleData.cnt >= config.needCnt and singleData.state == 0 then
                    singleData.state = 1
                    -- 锟叫讹拷锟角凤拷锟斤拷锟斤拷锟斤拷锟斤拷
                    for i = 1,#config.blasting do
                        local blastingID = config.blasting[i]
                        local blastingConfig = AbsActExcel.blasting[blastingID]
                        human.db.absAct[id].blasting[blastingID] = human.db.absAct[id].blasting[blastingID] or {}
                        human.db.absAct[id].blasting[blastingID].cnt = human.db.absAct[id].blasting[blastingID].cnt or 0
                        human.db.absAct[id].blasting[blastingID].state = human.db.absAct[id].blasting[blastingID].state or 0
                        human.db.absAct[id].blasting[blastingID].cnt = human.db.absAct[id].blasting[blastingID].cnt + 1
                        if human.db.absAct[id].blasting[blastingID].cnt >= 3 and human.db.absAct[id].blasting[blastingID].state ~= 2 then
                            human.db.absAct[id].blasting[blastingID].state = 1
                        end
                    end
                end
            end
        end
        
        if isChange then
            YunYingLogic.sendBanner(human)
            YunYingLogic.sendGroupUpdate(YYInfo[id], human, absConfig.panelID)
        end
    end
end

function onLogin(human, id)
    specialFunc(human, id)
end


function isRed(human, YYInfo, funcConfig)
    local state = AbsActLogic.isStarted(human, funcConfig.funcID)
    if not state then return end
    local absConfig = AbsActExcel.absActivity[funcConfig.funcID]
    local absAct = human.db.absAct[funcConfig.funcID]
    if not absAct then  return true end

    initDB(human,funcConfig.funcID)

    for k,v in pairs(absAct.drum) do
        if v.state == 1 then
            return true
        end
    end

    for k,v in pairs(absAct.blasting) do
        if v.state == 1 then
            return true
        end
    end

    for k,v in pairs(absAct.box) do
        if v == 1 then
            return true
        end
    end

    return false
end

-- 锟斤拷锟斤拷锟斤拷
function buling(human,funcID,conf)
    -- 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷为30锟斤拷
    AbsActLogic.checkAbsActClean(human, funcID)
    initDB(human,funcID)
    local absConfig = AbsActExcel.absActivity[funcID]
    -- 
    local absAct = human.db.absAct[funcID]
    
    if absAct.buling == 1 then
        return
    end
    absAct.buling = 1

    local config = AbsActExcel.blastingBox
    local len = #config
    for i = 1,len do
        if config[i].needCnt > absAct.blastingCnt then
            absAct.blastingCnt = config[i].needCnt
            absAct.box[i] = 1
        end
    end
    getAndSendMsg(human,id,absConfig.actID)
end