复活队列

meinvwudi

ReliveMain = {}
local equaldata = include("QuestDiary/cfgcsv/cfg_FuHuoZhuangBei.lua")
--遍历删除队列
--[[
    查找复活装备在队列中的位置
    
    参数：
    @param tbl 复活装备队列表
    @param key 要查找的装备名称
    
    返回值：
    @return number|nil 装备在队列中的位置索引，如果未找到则返回nil
    
    功能：
    1. 遍历复活装备队列
    2. 根据装备优先级(Priority)进行匹配
    3. 返回匹配装备的位置索引
]]
local function findPosition(tbl, key)
    -- 遍历复活装备队列
    for i, item in ipairs(tbl) do
        -- 比较装备优先级是否匹配
        if item.value == equaldata[key].Priority then
            return i  -- 找到匹配项，返回位置索引
        end
    end
    return nil  -- 未找到匹配项，返回nil
end

--获取复活数据
--[[
    获取玩家的复活状态数据
    
    功能：
    从玩家变量中获取复活相关的JSON数据表
    
    参数：
    @param actor 玩家对象
    
    返回值：
    @return table 复活状态数据表
    
    说明：
    1. 使用KFZF3作为跨服数据存储键
    2. 原本使用T_复活状态存储，现已改为跨服变量存储
    3. 确保数据在跨服场景下的一致性
]]
function ReliveMain.GetReliveTable(actor)
    -- 原本使用本地变量存储，现已注释
    -- return Player.getJsonTableByVar(actor, VarCfg["T_复活状态"])
    -- 使用跨服变量KFZF3存储复活状态数据
    return Player.getJsonTableByPlayVar(actor, "KFZF3")
end
--[[
    设置玩家的复活状态数据
    
    功能：
    同时更新本地和跨服的复活状态数据
    
    参数：
    @param actor 玩家对象
    @param ReliveQueue 复活队列数据表
    
    说明：
    1. 同时保存到两个位置：
       - T_复活状态：本地服务器变量
       - KFZF3：跨服变量
    2. 确保本地和跨服数据的一致性
    3. 用于维护复活装备队列的状态
]]
function ReliveMain.SetReliveTable(actor, ReliveQueue)
    -- 保存到本地服务器变量
    Player.setJsonVarByTable(actor, VarCfg["T_复活状态"], ReliveQueue)
    -- 保存到跨服变量
    Player.setJsonPlayVarByTable(actor, "KFZF3", ReliveQueue)
end

-- 入队操作
--[[
    复活装备入队操作函数
    
    功能：
    1. 将新的复活装备添加到复活队列中
    2. 维护队列的优先级顺序
    3. 同步复活状态数据
    
    参数：
    @param actor 玩家对象
    @param itemname 复活装备名称
    
    工作流程：
    1. 获取当前复活队列
    2. 检查装备是否已在队列中（防重复）
    3. 按优先级插入新装备
    4. 重新排序队列
    5. 保存并同步状态
]]
local function AddQueue(actor, itemname)
    -- 获取玩家当前的复活队列
    local ReliveQueue = ReliveMain.GetReliveTable(actor)
    -- 检查装备是否已在队列中
    local state = findPosition(ReliveQueue, itemname)
    -- 如果装备不在队列中，则添加
    if state == nil then                                                                    
        table.insert(ReliveQueue, { key = itemname, value = equaldata[itemname].Priority }) 
    end
    -- 按优先级对队列重新排序（优先级值越小越优先）
    table.sort(ReliveQueue, function(a, b)
        return a.value < b.value
    end)
    -- 保存更新后的队列数据
    ReliveMain.SetReliveTable(actor, ReliveQueue)
    -- 同步复活状态到客户端
    ReliveMain.SyncResponse(actor)
end

-- 出队操作
--[[
    复活装备出队操作函数
    
    功能：
    1. 从复活队列中移除指定位置的装备
    2. 更新复活状态数据
    
    参数：
    @param actor 玩家对象
    @param ReliveQueue 复活装备队列
    @param num 要移除的装备在队列中的位置
    
    工作流程：
    1. 检查队列是否为空
    2. 移除指定位置的装备
    3. 保存更新后的队列数据
    4. (可选)同步状态到客户端
]]
local function DelQueue(actor, ReliveQueue, num)
    if #ReliveQueue > 0 then                          -- 确保队列不为空
        table.remove(ReliveQueue, num)                -- 移除指定位置的装备
        ReliveMain.SetReliveTable(actor, ReliveQueue) -- 保存更新后的队列数据
        -- ReliveMain.SyncResponse(actor)             -- 同步状态到客户端（当前已注释）
    end
end
--------------------------------------------------------------衣服--------------------------------------------------------------
-- 衣服位置 --穿
--[[
    衣服位置装备穿戴事件处理函数
    
    功能：
    处理玩家穿戴带有复活功能的衣服装备时的逻辑
    
    参数：
    @param actor 玩家对象
    @param itemobj 装备对象
    
    工作流程：
    1. 获取装备名称
    2. 检查是否为复活装备
    3. 设置复活CD时间
    4. 启动复活CD计时器
    5. 同步复活状态到客户端
]]
local function _onTakeOn0(actor, itemobj)
    -- 获取装备名称
    local ItemName = getiteminfo(actor, itemobj, 7)
    -- 检查是否为复活装备
    if equaldata[ItemName] then
        -- 设置复活CD时间
        setplaydef(actor, VarCfg["U_复活队列1"], equaldata[ItemName].times)
        -- 启动101号定时器（衣服位置复活CD计时器）
        setontimer(actor, 101, 1, 0, 1)
        -- 同步复活状态到客户端
        ReliveMain.SyncResponse(actor)
    end
end
-- 注册衣服位置装备穿戴事件
GameEvent.add(EventCfg.onTakeOn0, _onTakeOn0, ReliveMain)

-- 衣服位置 --脱
--[[
    衣服位置装备卸下事件处理函数
    
    功能：
    处理玩家卸下带有复活功能的衣服装备时的逻辑
    
    参数：
    @param actor 玩家对象
    @param itemobj 装备对象
    
    工作流程：
    1. 获取当前复活队列
    2. 获取装备名称并检查是否为复活装备
    3. 从复活队列中移除该装备
    4. 清理相关状态和定时器
    5. 同步复活状态到客户端
]]
local function _onTakeOff0(actor, itemobj)
    -- 获取当前复活队列
    local ReliveQueue = ReliveMain.GetReliveTable(actor)
    -- 获取装备名称
    local ItemName = getiteminfo(actor, itemobj, 7)
    -- 检查是否为复活装备
    if equaldata[ItemName] then
        -- 查找装备在复活队列中的位置
        local number = findPosition(ReliveQueue, ItemName)
        -- 如果找到则从队列中移除
        if number ~= nil then
            DelQueue(actor, ReliveQueue, number)
        end
        -- 关闭衣服位置的复活CD定时器
        setofftimer(actor, 101)
        -- 清除复活CD时间
        setplaydef(actor, VarCfg["U_复活队列1"], 0)
        -- 同步复活状态到客户端
        ReliveMain.SyncResponse(actor)
    end
end
-- 注册衣服位置装备卸下事件
GameEvent.add(EventCfg.onTakeOff0, _onTakeOff0, ReliveMain)

--------------------------------------------------------------龙之心--------------------------------------------------------------
--穿戴龙之心位置
local function _onTakeOn9(actor, itemobj)
    local ItemName = getiteminfo(actor, itemobj, 7)
    if equaldata[ItemName] then
        setplaydef(actor, VarCfg["U_复活队列2"], equaldata[ItemName].times)
        setontimer(actor, 102, 1, 0, 1) --添加102号定时器
        ReliveMain.SyncResponse(actor)
    end
end
GameEvent.add(EventCfg.onTakeOn9, _onTakeOn9, ReliveMain)

-- 龙之心 --脱
local function _onTakeOff9(actor, itemobj)
    local ReliveQueue = ReliveMain.GetReliveTable(actor)
    local ItemName = getiteminfo(actor, itemobj, 7)
    if equaldata[ItemName] then
        local number = findPosition(ReliveQueue, ItemName)
        if number ~= nil then
            DelQueue(actor, ReliveQueue, number)
        end
        setofftimer(actor, 102) --关闭102定时器
        setplaydef(actor, VarCfg["U_复活队列2"], 0)
        ReliveMain.SyncResponse(actor)
    end
end
GameEvent.add(EventCfg.onTakeOff9, _onTakeOff9, ReliveMain)

--升级龙之心的时候 处理一次脱下操作
local function _LongZhiXinUp(actor, ItemName)
    local ReliveQueue = ReliveMain.GetReliveTable(actor)
    if equaldata[ItemName] then
        local number = findPosition(ReliveQueue, ItemName)
        if number ~= nil then
            DelQueue(actor, ReliveQueue, number)
        end
        setofftimer(actor, 102) --关闭102定时器
        setplaydef(actor, VarCfg["U_复活队列2"], 0)
        ReliveMain.SyncResponse(actor)
    end
end
GameEvent.add(EventCfg.LongZhiXinUp, _LongZhiXinUp, ReliveMain)

--六道轮回盘
local function _onTakeOnEx(actor, itemobj, where, itemname, makeid)
    if itemname == "六道轮回盘" then
        if equaldata[itemname] then
            setplaydef(actor, VarCfg["U_复活队列3"], equaldata[itemname].times)
            setontimer(actor, 103, 1, 0, 1) --添加103号定时器
            ReliveMain.SyncResponse(actor)
        end
    end
end

GameEvent.add(EventCfg.onTakeOnEx, _onTakeOnEx, ReliveMain)

--六道轮回盘
local function _onTakeOffEx(actor, itemobj, where, itemname, makeid)
    if itemname == "六道轮回盘" then
        local ReliveQueue = ReliveMain.GetReliveTable(actor)
        if equaldata[itemname] then
            local number = findPosition(ReliveQueue, itemname)
            if number ~= nil then
                DelQueue(actor, ReliveQueue, number)
            end
            setofftimer(actor, 103) --关闭103定时器
            setplaydef(actor, VarCfg["U_复活队列3"], 0)
            ReliveMain.SyncResponse(actor)
        end
    end
end
GameEvent.add(EventCfg.onTakeOffEx, _onTakeOffEx, ReliveMain)


--定时器    101号
local function _ReliveCountdown_1(actor)
    local item_num = getplaydef(actor, VarCfg["U_复活队列1"])
    -- release_print("1号倒计时" .. item_num)
    if item_num > 0 then
        setplaydef(actor, VarCfg["U_复活队列1"], item_num - 1)
    elseif item_num == 0 then
        local ItemName = getconst(actor, "<$DRESS>")
        setofftimer(actor, 101) --关闭101定时器
        if equaldata[ItemName] then
            AddQueue(actor, ItemName)
        end
    end
end
GameEvent.add(EventCfg.ReliveCountdown_1, _ReliveCountdown_1, ReliveMain)


--定时器    102号
local function _ReliveCountdown_2(actor)
    local item_num = getplaydef(actor, VarCfg["U_复活队列2"])
    -- release_print("跨服2号倒计时" .. item_num)
    if item_num > 0 then
        setplaydef(actor, VarCfg["U_复活队列2"], item_num - 1)
    elseif item_num == 0 then
        local ItemName = getconst(actor, "<$BUJUK>")
        setofftimer(actor, 102) --关闭102定时器
        if equaldata[ItemName] then
            AddQueue(actor, ItemName)
        end
    end
end
GameEvent.add(EventCfg.ReliveCountdown_2, _ReliveCountdown_2, ReliveMain)

--定时器    103号
local function _ReliveCountdown_3(actor)
    local item_num = getplaydef(actor, VarCfg["U_复活队列3"])
    -- release_print("跨服3号倒计时" .. item_num)
    if item_num > 0 then
        setplaydef(actor, VarCfg["U_复活队列3"], item_num - 1)
    elseif item_num == 0 then
        local ItemName = "六道轮回盘"
        if checkitemw(actor, ItemName, 1) then
            setofftimer(actor, 103) --关闭103定时器
            if equaldata[ItemName] then
                AddQueue(actor, ItemName)
            end
        end
    end
end
GameEvent.add(EventCfg.ReliveCountdown_3, _ReliveCountdown_3, ReliveMain)



-- 死亡前触发
--[[
    玩家死亡前的复活处理函数
    
    功能：
    处理玩家死亡时的复活机制，包括复活状态设置和复活装备CD管理
    
    参数：
    @param actor 死亡的玩家对象
    @param hiter 击杀者对象
    @param isplay 是否为玩家击杀
    
    工作流程：
    1. 检查复活队列
    2. 设置复活相关状态
    3. 处理复活装备CD
    4. 更新客户端显示
]]
local function _onNextDie(actor, hiter, isplay)
    -- 获取玩家的复活队列
    local ReliveQueue = ReliveMain.GetReliveTable(actor)
    
    if ReliveQueue[1] ~= nil then                                 -- 检查是否有可用的复活装备
        setplaydef(actor, VarCfg.Die_Flag, 1)                    -- 设置死亡标记
        setplaydef(actor, VarCfg["N$是否被破复活"], 1)          -- 设置可被破复活标记
        changemode(actor, 23, 1, 1, 1)                           -- 添加复活状态模式
        
        -- 检查并处理队首复活装备
        if checkitemw(actor, ReliveQueue[1].key, 1) then
            if equaldata[ReliveQueue[1].key] then
                -- 设置装备对应的复活CD时间
                setplaydef(actor, VarCfg["U_复活队列" .. equaldata[ReliveQueue[1].key].Priority .. ""],
                    equaldata[ReliveQueue[1].key].times)
                -- 启动对应的复活CD定时器（10X号，X为优先级）
                setontimer(actor, "10" .. equaldata[ReliveQueue[1].key].Priority, 1, 0, 1)
            end
        end
        
        DelQueue(actor, ReliveQueue, 1)                          -- 移除已使用的复活装备
        ReliveMain.SyncResponse(actor)                           -- 同步复活状态到客户端
    else
        -- 没有可用的复活装备时的处理
        setplaydef(actor, VarCfg.Die_Flag, 1)                    -- 设置死亡标记
        setplaydef(actor, VarCfg["N$是否被破复活"], 0)          -- 设置不可被破复活标记
    end
end
-- 注册死亡前触发事件
GameEvent.add(EventCfg.onNextDie, _onNextDie, ReliveMain)

--破复活
--[[
    破复活处理函数
    
    功能：
    处理玩家被破复活时的逻辑，包括重置复活CD和更新复活队列
    
    参数：
    @param actor 玩家对象
    @param target 目标对象（破复活的目标）
    
    工作流程：
    1. 检查复活队列是否有可用装备
    2. 重置复活装备的CD时间
    3. 启动新的复活CD计时器
    4. 更新复活队列和客户端显示
]]
function ReliveMain.DelRelive(actor, target)
    -- 获取当前复活队列
    local ReliveQueue = ReliveMain.GetReliveTable(actor)
    if ReliveQueue[1] ~= nil then                                -- 检查队列是否有可用装备
        if checkitemw(actor, ReliveQueue[1].key, 1) then        -- 验证玩家是否持有该装备
            if equaldata[ReliveQueue[1].key] then               -- 检查装备配置是否存在
                -- 设置新的复活CD时间
                setplaydef(actor, VarCfg["U_复活队列" .. equaldata[ReliveQueue[1].key].Priority .. ""],
                    equaldata[ReliveQueue[1].key].times)
                -- 启动对应优先级的10X号定时器
                setontimer(actor, "10" .. equaldata[ReliveQueue[1].key].Priority, 1, 0, 1)
            end
        end
        DelQueue(actor, ReliveQueue, 1)                         -- 移除已使用的复活装备
        ReliveMain.SyncResponse(actor)                          -- 同步状态到客户端
    end
end

--获取当前复活是否可复活
function ReliveMain.GetReliveState(actor)
    local ReliveQueue = ReliveMain.GetReliveTable(actor)
    if ReliveQueue[1] ~= nil then
        return true
    else
        return false
    end
end

--查找最小的复活CD
local function findMinCd(equipments)
    local min_cd = nil
    -- 遍历所有装备
    for _, equipment in ipairs(equipments) do
        local name = ""
        if equipment.name == "" or not equipment.name then
            name = "空"
        else
            name = equipment.name
        end
        if equaldata[name] then
            if equipment.cd then
                if not min_cd or equipment.cd < min_cd then
                    min_cd = equipment.cd
                end
            end
        end
    end
    return min_cd
    --如果返回nil就是没穿戴
end

--[[
    复活状态同步函数
    
    功能：
    1. 收集并同步玩家当前的复活装备状态
    2. 计算并发送复活状态到客户端
    3. 处理跨服数据同步
    
    参数：
    @param actor 玩家对象
    @param logindatas 登录数据表（可选）
    
    工作流程：
    1. 获取所有复活装备位置的状态
    2. 收集所有复活装备的CD时间
    3. 计算当前复活状态
    4. 同步状态到客户端
]]
function ReliveMain.SyncResponse(actor, logindatas)
    -- 获取各个位置的装备名称
    local ItemName1 = getconst(actor, "<$DRESS>")              -- 衣服位置
    local ItemName2 = getconst(actor, "<$BUJUK>")             -- 毒符位置
    local ItemName3 = "空"
    if checkitemw(actor, "六道轮回盘", 1) then
        ItemName3 = "六道轮回盘"                              -- 六道轮回盘位置
    end
    
    -- 获取各个位置的CD时间
    local time1 = getplaydef(actor, VarCfg["U_复活队列1"])    -- 衣服位置CD
    local time2 = getplaydef(actor, VarCfg["U_复活队列2"])    -- 毒符位置CD
    local time3 = getplaydef(actor, VarCfg["U_复活队列3"])    -- 六道轮回盘CD
    
    -- 获取复活队列
    local ReliveQueue = ReliveMain.GetReliveTable(actor)
    
    -- 构建装备状态表
    local equipments = {
        { name = ItemName1, cd = time1 },
        { name = ItemName2, cd = time2 },
        { name = ItemName3, cd = time3 },
    }
    
    -- 计算复活状态
    local state = nil
    local reliveState = "1"
    if #ReliveQueue > 0 then
        -- 有可用复活次数时
        state = "可复活+" .. #ReliveQueue
        reliveState = "1"
    else
        -- 无可用复活次数时，显示最短CD
        local min_cd = findMinCd(equipments)
        if not min_cd then
            state = "未穿戴"
        else
            state = min_cd
        end
        reliveState = "0"
    end
    
    -- 触发复活状态改变事件
    if checkkuafu(actor) then
        -- 跨服场景下的事件触发
        FKuaFuToBenFuEvent(actor, EventCfg.onRliveNotice, reliveState)
    else
        -- 本服场景下的事件触发
        GameEvent.push(EventCfg.onRliveNotice, actor, reliveState)
    end
    
    -- 构建并发送网络消息
    local _login_data = { ssrNetMsgCfg.LeftAttr_FuHuo, 0, 0, 0, { state } }
    if logindatas then
        -- 登录时添加到登录数据包
        table.insert(logindatas, _login_data)
    else
        -- 非登录时直接发送
        Message.sendmsg(actor, ssrNetMsgCfg.LeftAttr_FuHuo, 0, 0, 0, { state })
    end
end

--登录触发
local function _onLoginEnd(actor, logindatas)
    local item_num1 = getplaydef(actor, VarCfg["U_复活队列1"])
    local item_num2 = getplaydef(actor, VarCfg["U_复活队列2"])
    local item_num3 = getplaydef(actor, VarCfg["U_复活队列3"])
    if item_num1 > 0 then
        setontimer(actor, 101, 1, 0, 1) --添加101号定时器
    end
    if item_num2 > 0 then
        setontimer(actor, 102, 1, 0, 1) --添加102号定时器
    end
    if item_num3 > 0 then
        setontimer(actor, 103, 1, 0, 1) --添加103号定时器
    end
    ReliveMain.SyncResponse(actor, logindatas)
end
GameEvent.add(EventCfg.onLoginEnd, _onLoginEnd, ReliveMain)

GameEvent.add(EventCfg.onKuaFuEnd, _onLoginEnd, ReliveMain)

local function _onRliveNotice(actor, reliveState)
    -- release_print(actor, reliveState,Player.GetNameEx(actor))
    local Tbl = {31083, 31089, 31090, 31091}
    for _, v in ipairs(Tbl) do
        if hasbuff(actor, v) then
            delbuff(actor, v)
        end
    end
    if reliveState == "0" then
        if checkitemw(actor, "无序的邪力", 1) then
            addbuff(actor, 31083)
        end

        --〝回魂〞 复活后,不可复活状态下，增加100%防御
        if checkitemw(actor, "〝回魂〞", 1) then
            addbuff(actor, 31089)
        end
 
        --無上生霊″魂灭生 不可用时增加15%神魂血量
        if checkitemw(actor, "無上生霊″魂灭生", 1) then
            addbuff(actor, 31091)
        end
    else
        if checkitemw(actor, "無上生霊″魂灭生", 1) then
            addbuff(actor, 31090)
        end
    end
end
--复活状态改变触发
GameEvent.add(EventCfg.onRliveNotice, _onRliveNotice, ReliveMain)

--注册网络消息
Message.RegisterNetMsg(ssrNetMsgCfg.LeftAttr, ReliveMain)

return ReliveMain