Main/Assets/GameAssets/Resources/Lua/Logic/XianPo/XianPoSystem.lua

------------------------------------------------
-- 作者： 陈宇
-- 日期： 2019-07-18
-- 文件： XianPoSystem.lua
-- 模块： XianPoSystem
-- 描述： 仙魄系统
------------------------------------------------
local XianPoData = require("Logic.XianPo.XianPoData")
local XianPoSyntheticData = require("Logic.XianPo.XianPoSyntheticData")
local L_JianCore = require "Logic.XianPo.JianCoreData"
local L_BattlePropTools = CS.Thousandto.Code.Logic.BattlePropTools
local RedPointItemCondition = CS.Thousandto.Code.Logic.RedPointItemCondition

local XianPoSystem = {
    EquipedXianPoDic = Dictionary:New(), -- 已装备的仙魄字典，key = 位置，value = XianPoData
    BagXianPoDic = Dictionary:New(), -- 背包内的仙魄字典，key = uid，value = XianPoData
    XianPoOverviewDic = Dictionary:New(), -- 仙魄预览字典，key = 解锁层数，value = 配置表id
    XianPoExchangeDic = Dictionary:New(), -- 仙魄兑换字典，key = 排序，value = 配置表id
    XianPoSyntheticTypeDic = Dictionary:New(), -- 仙魄合成类型字典，key = 大分类id，value = List<合成表id>
    XianPoSyntheticDic = Dictionary:New(), -- 仙魄合成字典，key = 合成id，value = XianPoSyntheticData
    GetXianPoConditionType = 0, -- 获取仙魄所需条件的类型（functionVariable表中的类型）
    HoleDataDic = nil, -- 镶嵌孔数据

    XianPoMaxInlayIndex = 10, -- 仙魄最大镶嵌位置
    MaxBagCount = 200, -- 最大背包格子

    -- 当前请求合成的CfgId
    ReqCompoundCfgId = 0,

    -- 红点索引Id
    ListRedPointIds = List:New(),
    -- 通关剑灵阁层数
    JianLingGeLevel = 0,
    -- 每个剑灵可镶嵌的格子总数
    HoleCount = 7,
    -- 剑灵列表 (暂时只包含名字)
    JianLingList = List:New(),
    JianLingModelIdList = List:New(),
    -- 可以升级的镶嵌孔列表
    CanLvList = List:New(),
    -- 可镶嵌（替换）的剑灵列表
    ValidJianLingList = List:New(),
    -- 总揽数据
    ViewDic = Dictionary:New(),
    -- 是否显示合成红点
    preShowSynRedPoint = false,
    IsShowSynRedPoint = false,
    -- 背包灵魄是否改变了
    IsLingPoChange = false,
    -- update检测红点时间
    CheckTime = 1,
    -- 剑灵总数量
    JianLingCount = 6,

    --剑是否显示的条件
    DicJianCore = nil,
    --背包灵魄总数
    BagSoulCount = 0,
    --配置id对应灵魄在背包中的数量
    SoulBagDic = Dictionary:New(),
}

function XianPoSystem:Initialize()
    self.BagSoulCount = 0
    self.SoulBagDic:Clear()
    -- 消息注册
    GameCenter.RegFixEventHandle(LogicLuaEventDefine.EID_EVEMT_UPDATE_SWORDMANDATE, self.SwordChange, self)
    self.MaxBagCount = DataConfig.DataGlobal[1581].Params
    DataConfig.DataImmortalSoulAttribute:Foreach(function(key, value)
        -- 非经验仙魄，预览用仙魄
        if value.Type ~= 2 then
            if self.GetXianPoConditionType == 0 then
                if value.ExchangeConditions ~= "" then
                    local _condition = Utils.SplitNumber(value.ExchangeConditions, "_")
                    self.GetXianPoConditionType = _condition[1]
                end
            end
            if not self.XianPoOverviewDic:ContainsKey(value.OverviewConditions) then
                local _cfgIdList = List:New()
                _cfgIdList:Add(key)
                self.XianPoOverviewDic:Add(value.OverviewConditions, _cfgIdList)
            else
                local _cfgIdList = self.XianPoOverviewDic[value.OverviewConditions]
                _cfgIdList:Add(key)
            end
        end
        -- 可兑换仙魄
        if value.ExchangeRanking > 0 then
            if not self.XianPoExchangeDic:ContainsKey(value.ExchangeRanking) then
                self.XianPoExchangeDic:Add(value.ExchangeRanking, key)
            end
        end
    end)
    -- 兑换仙魄字典排序
    self.XianPoExchangeDic:SortKey(function(a, b)
        return a < b
    end)

    DataConfig.DataImmortalSoulSynthesis:Foreach(function(key, value)
        if not self.XianPoSyntheticTypeDic:ContainsKey(value.Type) then
            local _idList = List:New()
            _idList:Add(key)
            self.XianPoSyntheticTypeDic:Add(value.Type, _idList)
        else
            local _idList = self.XianPoSyntheticTypeDic[value.Type]
            _idList:Add(key)
        end
        if not self.XianPoSyntheticDic:ContainsKey(key) then
            local _data = XianPoSyntheticData:New()
            _data:SetAllData(value)
            self.XianPoSyntheticDic:Add(key, _data)
        end
    end)
    GameCenter.RegFixEventHandle(LogicEventDefine.EVENT_COIN_CHANGE_UPDATE, self.CoinChange, self)

    -- 灵魄抽取红点
    local _huntCfg = DataConfig.DataImmortalSoulHunt[2]
    if _huntCfg ~= nil then
        local _costItems = Utils.SplitNumber(_huntCfg.BasicAttributes, '_')
        GameCenter.RedPointSystem:AddFuncCondition(FunctionStartIdCode.LingPoLottery, 0,
            RedPointItemCondition(_costItems[1], _costItems[2]))
    end
end

function XianPoSystem:UnInitialize()
    self.BagSoulCount = 0
    self.SoulBagDic:Clear()
    self.EquipedXianPoDic:Clear()
    self.BagXianPoDic:Clear()
    GameCenter.UnRegFixEventHandle(LogicLuaEventDefine.EID_EVEMT_UPDATE_SWORDMANDATE, self.SwordChange, self)
    GameCenter.UnRegFixEventHandle(LogicEventDefine.EVENT_COIN_CHANGE_UPDATE, self.CoinChange, self)
end

function XianPoSystem:CoinChange(obj, sender)
    if obj == ItemTypeCode.LingPoSw then
        self:LingPoChange()
    end
end

-- 剑阁层数改变
function XianPoSystem:SwordChange(obj, sender)
    self.JianLingGeLevel = GameCenter.SwordMandateSystem.CurLevel
    self.IsShowSynRedPoint = self:SetXianPoSyntheticRedPoint()
    if self.preShowSynRedPoint ~= self.IsShowSynRedPoint then
        GameCenter.MainFunctionSystem:SetAlertFlag(FunctionStartIdCode.XianPoSynthetic, self.IsShowSynRedPoint)
        self.preShowSynRedPoint = self.IsShowSynRedPoint
    end
end

-- 获取剑灵名字列表
function XianPoSystem:GetNameList()
    if #self.JianLingList == 0 then
        local dic = GameCenter.FlySowardSystem:GetTypeDic()
        if dic ~= nil then
            local list = dic:GetKeys()
            for i = 1, #list do
                local cfg = GameCenter.FlySowardSystem:GetActiveCfgByType(list[i])
                if cfg ~= nil then
                    self.JianLingList:Add(cfg.Name)
                end
            end
        end
    end
    return self.JianLingList
end

-- 获取剑灵模型ID列表
function XianPoSystem:GetModelList()
    if #self.JianLingModelIdList == 0 then
        local dic = GameCenter.FlySowardSystem:GetTypeDic()
        if dic ~= nil then
            local list = dic:GetKeys()
            for i = 1, #list do
                local cfg = GameCenter.FlySowardSystem:GetActiveCfgByType(list[i])
                if cfg ~= nil then
                    self.JianLingModelIdList:Add(cfg.Id)
                end
            end
        end
    end
    return self.JianLingModelIdList
end

-- 获取激活的剑灵最大索引
function XianPoSystem:GetActiveJianlingIndex()
    local index = 1
    local dic = GameCenter.FlySowardSystem:GetTypeDic()
    if dic ~= nil then
        local list = dic:GetKeys()
        for i = 1, #list do
            local type = list[i]
            for m = 1, self.HoleCount do
                local holeId = i * 100 + m
                if self:GetJianValid(i) then
                    local isValid = self:GetHoleIsValid(holeId)
                    if isValid then
                        index = type
                    end
                end
            end
        end
    end
    return index
end

-- 获取镶嵌孔数据
function XianPoSystem:GetHoleDataDic()
    if self.HoleDataDic == nil then
        self.HoleDataDic = Dictionary:New()
        local nameList = self:GetNameList()
        local isActive = false
        for i = 1, #nameList do
            local index = i
            for m = 1, self.HoleCount do
                local holeId = i * 100 + m
                local data = self.HoleDataDic[holeId]
                if data == nil then
                    local cfg = DataConfig.DataImmortalSoulIattice[holeId]
                    if cfg ~= nil then
                        local list = Utils.SplitNumber(cfg.Condition, '_')
                        local level = list[2]
                        data = {
                            ActiveLv = level
                        }
                    end
                    self.HoleDataDic[holeId] = data
                end
            end
        end
    end
    return self.HoleDataDic
end

function XianPoSystem:Sort(list)
    if list ~= nil then
        list:Sort(function(a, b)
            return a.SortId < b.SortId
        end)
    end
end

-- 排序
function XianPoSystem:SortUid(uidlist)
    local list = List:New()
    local retList = List:New()
    for i = 1, #uidlist do
        local data = self:GetBagXianPoDataByUID(uidlist[i])
        if data ~= nil then
            data.SortId = self:GetSortId(data)
            list:Add(data)
        end
    end
    list:Sort(function(a, b)
        return a.SortId < b.SortId
    end)
    for i = 1, #list do
        local data = list[i]
        if data ~= nil then
            retList:Add(data.Uid)
        end
    end
    return retList
end

function XianPoSystem:SortUid2(uidlist, holeId, index)
    local list = List:New()
    local retList = List:New()
    for i = 1, #uidlist do
        local data = self:GetBagXianPoDataByUID(uidlist[i])
        if data ~= nil then
            data.SortId = self:GetSortId2(data, holeId, index)
            list:Add(data)
        end
    end
    list:Sort(function(a, b)
        return a.SortId < b.SortId
    end)
    for i = 1, #list do
        local data = list[i]
        if data ~= nil then
            retList:Add(data.Uid)
        end
    end
    return retList
end

function XianPoSystem:GetSortId(data)
    local sortId = 0
    if data.Quality == XianPoQuality.Blue then
        sortId = 1000000000000
    elseif data.Quality == XianPoQuality.Purple then
        sortId = 2000000000000
    elseif data.Quality == XianPoQuality.Gold then
        sortId = 3000000000000
    elseif data.Quality == XianPoQuality.Red then
        sortId = 4000000000000
    end
    sortId = sortId + data.CfgId - data.Level
    return sortId
end

function XianPoSystem:GetSortId2(data, holeId, index)
    local sortId = 0
    if data.Quality == XianPoQuality.Blue then
        sortId = 4000000000000
    elseif data.Quality == XianPoQuality.Purple then
        sortId = 3000000000000
    elseif data.Quality == XianPoQuality.Gold then
        sortId = 2000000000000
    elseif data.Quality == XianPoQuality.Red then
        sortId = 1000000000000
    end
    local visable, equal = self:CanEquipOrRepalce(data.Uid, holeId, index)
    if equal then
        sortId = sortId + 4000000000000
    end
    sortId = sortId + data.CfgId - data.Level * 10000000000 - data.Star * 100000000000
    return sortId
end

-- 判断指定ID的仙魄是否可以替换或者镶嵌
function XianPoSystem:CanEquipOrRepalce(uid, holeId, index)
    local ret = false
    local haveEqualAtt = false
    local data = self.BagXianPoDic[uid]
    if data == nil then
        return false
    end
    if not self:GetHoleIsValid(holeId) then
        -- 这个空无效
        return false
    end
    -- 先检查所有剑灵项是否有可镶嵌的孔
    ret = self:HaveFreeHole(holeId)
    if ret then
        -- 判断当前孔是否可以镶嵌
        ret = false
        for n = 1, self.HoleCount do
            local otherHole = index * 100 + n
            if otherHole ~= holeId then
                local otherEquiptItem = self.EquipedXianPoDic[otherHole]
                if otherEquiptItem ~= nil and otherEquiptItem.Type2 == data.Type2 then
                    -- 如果属性相同 并且不是同一个孔
                    haveEqualAtt = true
                end
            end
        end
        if not haveEqualAtt then
            -- 如果没有相同的属性 就可以替换
            ret = true
        end
    end
    if not ret then
        -- 不能镶嵌 就检查是否可以替换
        local equipItem = self.EquipedXianPoDic[holeId]
        if equipItem ~= nil then
            ret, haveEqualAtt = self:CanReplace(data, equipItem, index, holeId)
        end
    end
    return ret, haveEqualAtt
end

-- 获取可以升级灵魄的孔
function XianPoSystem:GetCanLvHole()
    self.CanLvList:Clear()
    local nameList = self:GetNameList()
    local isActive = false
    for i = 1, #nameList do
        local index = i
        for m = 1, self.HoleCount do
            local holeId = i * 100 + m
            local isValid = self:GetHoleIsValid(holeId)
            if isValid then
                -- 激活了
                isActive = true
                break
            end
        end
        if isActive then
            for m = 1, self.HoleCount do
                local holeId = index * 100 + m
                if self:GetHoleIsValid(holeId) then
                    if self:IsIndexXianPoCanUpgrade(holeId) then
                        self.CanLvList:Add(holeId)
                    end
                end
            end
        end
    end
    return self.CanLvList
end

-- 判断当前孔是否有可替换的灵魄
function XianPoSystem:HaveReplaceItem(index, holeId)
    local ret = false
    if self:GetHoleIsValid(holeId) then
        local equipItem = self.EquipedXianPoDic[holeId]
        -- 从未灵魄背包中获取等级比当前孔等级更高的灵魄
        local bagKeys = self.BagXianPoDic:GetKeys()
        for i = 1, #bagKeys do
            local key = bagKeys[i]
            local bagItem = self.BagXianPoDic[key]
            ret = self:CanReplace(bagItem, equipItem, index, holeId)
            if ret then
                break
            end
        end
    end
    return ret
end

function XianPoSystem:CanReplace(bagItem, equipItem, index, holeId)
    local ret = false
    local haveEqualAtt = false
    if bagItem ~= nil and bagItem.Typ ~= 2 then
        -- 如果是属性灵魄
        if equipItem == nil or (bagItem.Level > equipItem.Level and bagItem.Quality > equipItem.Quality) then
            -- 如果背包中的该仙魄等级更高 判断其他格子里面是否有相同属性的仙魄
            for n = 1, self.HoleCount do
                local otherHole = index * 100 + n
                if otherHole ~= holeId then
                    local otherEquiptItem = self.EquipedXianPoDic[otherHole]
                    if otherEquiptItem ~= nil and otherEquiptItem.Type2 == bagItem.Type2 then
                        -- 如果属性相同 并且不是同一个孔
                        haveEqualAtt = true
                    end
                end
            end
            if not haveEqualAtt then
                -- 如果没有相同的属性 就可以替换
                ret = true
            end
        end
        if equipItem == nil or bagItem.Quality > equipItem.Quality or (bagItem.Quality == equipItem.Quality and bagItem.Star > equipItem.Star) then
            -- 如果背包中的该仙魄品质更高 判断其他格子里面是否有相同属性的仙魄

            for n = 1, self.HoleCount do
                local otherHole = index * 100 + n
                if otherHole ~= holeId then
                    local otherEquiptItem = self.EquipedXianPoDic[otherHole]
                    if otherEquiptItem ~= nil and otherEquiptItem.Type2 == bagItem.Type2 then
                        -- 如果属性相同 并且不是同一个孔
                        haveEqualAtt = true
                    end
                end
            end
            if not haveEqualAtt then
                -- 如果没有相同的属性 就可以替换
                ret = true
            end
        end
        if not haveEqualAtt then
            for n = 1, self.HoleCount do
                local otherHole = index * 100 + n
                if otherHole ~= holeId then
                    local otherEquiptItem = self.EquipedXianPoDic[otherHole]
                    if otherEquiptItem ~= nil and otherEquiptItem.Type2 == bagItem.Type2 then
                        -- 如果属性相同 并且不是同一个孔
                        haveEqualAtt = true
                        break
                    end
                end
            end
        end
    end
    return ret, haveEqualAtt
end

-- 判断传入剑灵index对应的剑灵是否有可以替换或者镶嵌的灵魄
function XianPoSystem:GetEquiptHoleList(index)
    local holeList = List:New()
    local ret = false
    for i = 1, self.HoleCount do
        -- 格子id
        -- 先判断是否有格子没有镶嵌
        local haveHole = false
        local holeId = index * 100 + i
        haveHole = self:GetHoleIsValid(holeId)
        if haveHole then
            haveHole = self.EquipedXianPoDic:ContainsKey(holeId)
            if haveHole then
                -- 镶嵌了灵魄 判断是否有可以替换的灵魄
                local equipItem = self.EquipedXianPoDic[holeId]
                -- 从未灵魄背包中获取等级比当前孔等级更高的灵魄
                local bagKeys = self.BagXianPoDic:GetKeys()
                for m = 1, #bagKeys do
                    local key = bagKeys[m]
                    local item = self.BagXianPoDic[key]
                    if item ~= nil and item.Typ ~= 2 then
                        haveHole = self:CanReplace(item, equipItem, index, holeId)
                        if haveHole then
                            holeList:Add(holeId)
                        end
                    end
                end
            else
                -- 没有镶嵌灵魄 检查背包里面的灵魄是否可以镶嵌
                local bagKeys = self.BagXianPoDic:GetKeys()
                for k = 1, #bagKeys do
                    local key = bagKeys[k]
                    local item = self.BagXianPoDic[key]
                    if item ~= nil and item.Typ ~= 2 then
                        -- 如果是属性灵魄 判断和其他孔是否有属性冲突
                        haveHole = true
                        for m = 1, self.HoleCount do
                            if i ~= m then
                                local otherEquipItem = self.EquipedXianPoDic[index * 100 + m]
                                if otherEquipItem ~= nil and otherEquipItem.Type2 == item.Type2 then
                                    haveHole = false
                                end
                            end
                        end
                        if haveHole then
                            holeList:Add(holeId)
                            break
                        end
                    end
                end
            end
        end
    end
    return holeList
end

-- 一次性返回有可镶嵌的剑灵序号
function XianPoSystem:GetValidJianLingIndexs()
    self.ValidJianLingList:Clear()
    local bagKeys = self.BagXianPoDic:GetKeys()
    -- 先检查所有剑灵项是否有可镶嵌的孔
    local nameList = self:GetNameList()
    local activeIndex = self:GetActiveJianlingIndex()
    for i = 1, #nameList do
        local index = i
        if activeIndex >= index then
            local ret = false
            for m = 1, self.HoleCount do
                local holeId = index * 100 + i
                ret = self:HaveFreeHole(holeId)
                if ret then
                    -- 没有镶嵌灵魄 检查背包里面的灵魄是否可以镶嵌
                    for k = 1, #bagKeys do
                        local key = bagKeys[k]
                        local item = self.BagXianPoDic[key]
                        if item ~= nil and item.Typ ~= 2 then
                            -- 如果是属性灵魄 判断和其他孔是否有属性冲突
                            for n = 1, self.HoleCount do
                                if i ~= n then
                                    local otherEquipItem = self.EquipedXianPoDic[index * 100 + n]
                                    if otherEquipItem ~= nil and otherEquipItem.Type2 == item.Type2 then
                                        ret = false
                                    end
                                end
                            end
                            if ret then
                                self.ValidJianLingList:Add(index)
                                break
                            end
                        end
                    end
                    break
                end
            end
        end
    end

    for i = 1, #bagKeys do
        local bagKey = bagKeys[i]
        local bagItem = self.BagXianPoDic[bagKey]
        -- 和所有的剑灵项比较
        for m = 1, #nameList do
            local index = m
            if activeIndex >= index then
                local ret = false
                if not self.ValidJianLingList:Contains(m) then
                    -- 如果没有可镶嵌的孔 检查是否可以替换
                    ret = self:HaveBetterItem(index, bagItem)
                    if ret then
                        self.ValidJianLingList:Add(m)
                    end
                end
            end
        end
    end
    return self.ValidJianLingList
end

function XianPoSystem:GetValidJianLingStateList()
    local bagKeys = self.BagXianPoDic:GetKeys()
    local bagCount = #bagKeys
    -- 先检查所有剑灵项是否有可镶嵌的孔
    local activeIndex = self:GetActiveJianlingIndex()
    for i = 1, self.JianLingCount do
        local index = i
        if activeIndex >= index then
            local ret = false
            -- 获取可镶嵌孔列表
            local freeHoleList = self:GetFreeHoleList(index)
            if #freeHoleList > 0 then
                -- 有可镶嵌的孔
                ret = true
                for k = 1, bagCount do
                    local key = bagKeys[k]
                    local item = self.BagXianPoDic[key]
                    if item ~= nil and item.Typ ~= 2 then
                        -- 如果是属性灵魄 判断和其他孔是否有属性冲突
                        for m = 1, self.HoleCount do
                            local otherEquipItem = self.EquipedXianPoDic[index * 100 + m]
                            if otherEquipItem ~= nil and otherEquipItem.Type2 == item.Type2 then
                                ret = false
                                break
                            end
                        end
                        if ret then
                            return true
                        end
                    end
                end
                if not ret then
                    --不能镶嵌 判断是否有更好的灵魄
                    for k = 1, bagCount do
                        local bagKey = bagKeys[k]
                        local bagItem = self.BagXianPoDic[bagKey]
                        ret = self:HaveBetterItem(index, bagItem)
                        if ret then
                            return true
                        end
                    end
                end
            else
                -- 没有可镶嵌的孔
                for k = 1, bagCount do
                    local bagKey = bagKeys[k]
                    local bagItem = self.BagXianPoDic[bagKey]
                    ret = self:HaveBetterItem(index, bagItem)
                    if ret then
                        return true
                    end
                end
            end
            -- 判断是否有可以升级的
            for m = 1, self.HoleCount do
                local holeId = index * 100 + m
                if self:GetHoleIsValid(holeId) then
                    if self:IsIndexXianPoCanUpgrade(holeId) then
                        return true
                    end
                end
            end
        end
    end
    return false
end

-- 获取可镶嵌孔列表
function XianPoSystem:GetFreeHoleList(index)
    local list = List:New()
    for m = 1, self.HoleCount do
        local holeId = index * 100 + m
        local ret = self:HaveFreeHole(holeId)
        if ret then
            list:Add(holeId)
        end
    end
    return list
end

-- 判断是否有空闲的孔洞
function XianPoSystem:HaveFreeHole(holeId)
    local ret = false
    -- 先判断该孔是否可用
    ret = self:GetHoleIsValid(holeId)
    if ret then
        -- 如果该孔有效 判断是否装备了灵魄
        if self.EquipedXianPoDic:ContainsKey(holeId) then
            ret = false
        end
    end
    return ret
end

-- 判断是否有更高级的灵魄
function XianPoSystem:HaveBetterItem(index, bagItem)
    local ret = false
    for k = 1, self.HoleCount do
        local holeId = index * 100 + k
        -- 判断当前孔是否激活
        if self:GetHoleIsValid(holeId) then
            local equipItem = self.EquipedXianPoDic[holeId]
            -- 从未灵魄背包中获取等级比当前孔等级更高的灵魄
            if bagItem ~= nil and bagItem.Typ ~= 2 then
                -- 如果是属性灵魄
                ret = self:CanReplace(bagItem, equipItem, index, holeId)
                if ret then
                    break
                end
            end
        end
    end
    return ret
end

-- 判断是否有更好品质的灵魄
function XianPoSystem:HaveBetterQualityItem(index, bagItem)
    local ret = false
    for k = 1, self.HoleCount do
        local holeId = index * 100 + k
        -- 判断当前孔是否激活
        if self:GetHoleIsValid(holeId) then
            local equipItem = self.EquipedXianPoDic[holeId]
            -- 从未灵魄背包中获取等级比当前孔等级更高的灵魄
            if bagItem ~= nil and bagItem.Typ ~= 2 then
                -- 如果是属性灵魄
                if bagItem.Quality > equipItem.Quality then
                    -- 如果背包中的该仙魄等级更高 判断其他格子里面是否有相同属性的仙魄
                    local haveEqualAtt = false
                    local equipedKeys = self.EquipedXianPoDic:GetKeys()
                    for n = 1, self.HoleCount do
                        if n ~= k then
                            local otherEquiptItem = self.EquipedXianPoDic[equipedKeys[n]]
                            if otherEquiptItem ~= nil and otherEquiptItem.Type2 == bagItem.Type2 then
                                -- 如果属性相同 并且不是同一个孔
                                haveEqualAtt = true
                            end
                        end
                    end
                    if not haveEqualAtt then
                        -- 如果没有相同的属性 就可以替换
                        ret = true
                        break
                    end
                end
            end
        end
    end
    return ret
end

-- 获取灵魄镶嵌格子是否激活
function XianPoSystem:GetHoleIsValid(holeId)
    local ret = false
    local dic = self:GetHoleDataDic()
    if dic ~= nil then
        local data = dic[holeId]
        if data ~= nil then
            ret = self.JianLingGeLevel > data.ActiveLv
        end
    end
    return ret
end

-- 获取总揽数据
function XianPoSystem:GetViewData()
    if self.ViewDic:Count() == 0 then
        DataConfig.DataImmortalSoulAttribute:Foreach(function(key, value)
            if value.OverviewConditions ~= nil and value.OverviewConditions ~= "" then
                local params = Utils.SplitNumber(value.OverviewConditions, "_")
                local floor = params[1]
                local row = params[2]
                local col = params[3]
                local subDic = self.ViewDic[floor]
                if subDic ~= nil then
                    local list = subDic[row]
                    if list ~= nil then
                        list:Add(key)
                    else
                        list = List:New()
                        list:Add(key)
                        subDic:Add(row, list)
                    end
                else
                    local list = List:New()
                    list:Add(key)
                    subDic = Dictionary:New()
                    subDic:Add(row, list)
                    self.ViewDic:Add(floor, subDic)
                end
            end
        end)
    end
    return self.ViewDic
end

function XianPoSystem:GetAllItemDic()
    local index = 0
    local retDic = Dictionary:New()
    local dic = self:GetViewData()
    local keys = dic:GetKeys()
    keys:Sort(function(a, b)
        return a < b
    end)
    for i = 1, #keys do
        if self.JianLingGeLevel > keys[i] then
            local floorDic = dic[keys[i]]
            if floorDic ~= nil then
                local floorKeys = floorDic:GetKeys()
                for m = 1, #floorKeys do
                    local list = floorDic[floorKeys[m]]
                    if list ~= nil then
                        retDic:Add(index, list)
                        index = index + 1
                    end
                end
            end
        end
    end
    return retDic
end

function XianPoSystem:AddBag(uId, data)
    if data == nil then
        return
    end
    local _soul = self.BagXianPoDic[uId]
    if _soul == nil then
        self.BagXianPoDic:Add(uId, data)
        self.BagSoulCount = self.BagSoulCount + 1
    else
        self.BagXianPoDic[uId] = data
    end
    local _soulCount = self.SoulBagDic[data.CfgId]
    if _soulCount == nil then
        self.SoulBagDic[data.CfgId] = 1
    else
        self.SoulBagDic[data.CfgId] = _soulCount + 1
    end
end

function XianPoSystem:RemoveBag(uId)
    local _soul = self.BagXianPoDic[uId]
    if _soul ~= nil then
        self.BagXianPoDic:Remove(uId)
        self.BagSoulCount = self.BagSoulCount - 1
        local _soulCount = self.SoulBagDic[_soul.CfgId]
        if _soulCount ~= nil and _soulCount > 0 then
            self.SoulBagDic[_soul.CfgId] = _soulCount - 1
        end
    end
end

function XianPoSystem:GetAnalyseXianPo()
    local _list = List:New()
    if self.BagXianPoDic ~= nil then
        local _keys = self.BagXianPoDic:GetKeys()
        if _keys ~= nil then
            for i = 1, #_keys do
                local _xianPo = self.BagXianPoDic[_keys[i]]
                if _xianPo.Quality >= 4 and _xianPo.Star >= 2 then
                    _list:Add(_xianPo)
                end
            end
        end
    end
    return _list
end

function XianPoSystem:GetDecomposeXianPo()
    local _list = List:New()
    if self.BagXianPoDic ~= nil then
        local _keys = self.BagXianPoDic:GetKeys()
        if _keys ~= nil then
            for i = 1, #_keys do
                local _xianPo = self.BagXianPoDic[_keys[i]]
                if _xianPo.Quality >= 4 and _xianPo.Star >= 2 then
                else
                    _list:Add(_xianPo)
                end
            end
        end
    end
    return _list
end

-- 心跳
function XianPoSystem:Update(dt)
    local isShow = false
    -- 每0.5秒检查一次是否有激活的剑灵
    if self.CheckTime > 0 then
        self.CheckTime = self.CheckTime - dt
    else
        self.CheckTime = 1
        -- 检查灵魄镶嵌是否有红点
        local isShow = self:GetValidJianLingStateList()
        GameCenter.MainFunctionSystem:SetAlertFlag(FunctionStartIdCode.XianPoInlay, isShow)
    end

    if self.IsLingPoChange then
        self.IsShowSynRedPoint = self:SetXianPoSyntheticRedPoint()
        if self.preShowSynRedPoint ~= self.IsShowSynRedPoint then
            GameCenter.MainFunctionSystem:SetAlertFlag(FunctionStartIdCode.XianPoSynthetic, self.IsShowSynRedPoint)
            self.preShowSynRedPoint = self.IsShowSynRedPoint
        end

        GameCenter.PushFixEvent(LogicLuaEventDefine.EID_EVENT_XIANPO_EXCHANGE)
        self:SetXianPoDecompositionRedPoint()
        local isShow = self:GetValidJianLingStateList()
        GameCenter.MainFunctionSystem:SetAlertFlag(FunctionStartIdCode.XianPoInlay, isShow)
        GameCenter.PushFixEvent(LogicLuaEventDefine.EID_EVENT_LINGPO_EXCHANGE)
        self.IsLingPoChange = false
    end

    -- 检查分解 
    -- 检查对话
    -- 检查合成
end

-- 上线初始化所有仙魂
function XianPoSystem:ResAllImmortalSoul(msg)
    if msg.soulEquipmentList then
        for i = 1, #msg.soulEquipmentList do
            local _xianPoInfos = msg.soulEquipmentList[i]
            local _data = XianPoData:New()
            _data:SetAllData(_xianPoInfos)
            if not self.EquipedXianPoDic:ContainsKey(_xianPoInfos.location) then
                self.EquipedXianPoDic:Add(_xianPoInfos.location, _data)
            end
        end
    end
    if msg.soulBagList then
        for i = 1, #msg.soulBagList do
            local _xianPoInfos = msg.soulBagList[i]
            local _data = XianPoData:New()
            _data:SetAllData(_xianPoInfos)
            if not self.BagXianPoDic:ContainsKey(_xianPoInfos.uid) then
                self:AddBag(_xianPoInfos.uid, _data)
            end
        end
    end
    -- self:SetXianPoDecompositionRedPoint()
    self:LingPoChange()
end

-- 请求镶嵌仙魄，location = 位置
function XianPoSystem:ReqInlaySoul(uid, location)
    local _req = ReqMsg.MSG_ImmortalSoul.ReqInlaySoul:New()
    _req.soulUID = uid
    _req.location = location
    _req:Send()
end

-- 镶嵌仙魂结果反馈
function XianPoSystem:ResInlaySoulReuslt(msg)
    if msg.isSucceed then
        local _inlayIndex = -1
        for i = 1, #msg.soulInlayList do
            local _xianPoInfos = msg.soulInlayList[i]
            local _data = XianPoData:New()
            _data:SetAllData(_xianPoInfos)
            if _xianPoInfos.location ~= 0 then
                _inlayIndex = _xianPoInfos.location
                -- 如果不在背包(穿在身上的)
                -- 先替换身上的仙魄
                if self.EquipedXianPoDic:ContainsKey(_xianPoInfos.location) then
                    self.EquipedXianPoDic[_xianPoInfos.location] = _data
                else
                    self.EquipedXianPoDic:Add(_xianPoInfos.location, _data)
                end
                -- 在删除背包内的仙魄
                if self.BagXianPoDic:ContainsKey(_xianPoInfos.uid) then
                    self:RemoveBag(_xianPoInfos.uid)
                end
            else
                -- 如果是背包里的，那就加到背包里去
                if not self.BagXianPoDic:ContainsKey(_xianPoInfos.uid) then
                    self:AddBag(_xianPoInfos.uid, _data)
                end
            end
            -- 发送背包中仙魄改变的消息
            -- GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_XIANPO_BAG_ITEM_CHANGED, _xianPoInfos.CfgId)
        end
        GameCenter.PushFixEvent(LogicLuaEventDefine.EID_EVENT_XIANPOINFO_REFRESH, _inlayIndex)
        Utils.ShowPromptByEnum("InlaySucced")
        -- self:SortBagXianPoDic()
        -- self:SetXianPoInlayRedPoint()
        -- self:SetXianPoDecompositionRedPoint()
        self:LingPoChange()
    end
end

-- 请求分解仙魄
function XianPoSystem:ReqResolveSoul(uidList)
    local _req = ReqMsg.MSG_ImmortalSoul.ReqResolveSoul:New()
    _req.uids = uidList
    _req:Send()
end

-- 分解仙魄返回
function XianPoSystem:ResResolveSoulReuslt(msg)
    if msg.isSucceed then
        for i = 1, #msg.uids do
            local _data = self.BagXianPoDic[msg.uids[i]]
            if _data ~= nil then
                local _cfgId = _data.CfgId
                self:RemoveBag(msg.uids[i])
                -- GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_XIANPO_BAG_ITEM_CHANGED, _cfgId)
            end
        end
        Utils.ShowPromptByEnum("ResolveSucceed")
        -- self:SortBagXianPoDic()
        GameCenter.PushFixEvent(LogicLuaEventDefine.EID_EVENT_XIANPO_DECOMPOSITION)
        -- self:SetXianPoInlayRedPoint()
        -- self:SetXianPoDecompositionRedPoint()
        self:LingPoChange()
    end
end

-- 请求仙魄升级
function XianPoSystem:ReqUpSoul(location)
    local _req = ReqMsg.MSG_ImmortalSoul.ReqUpSoul:New()
    _req.location = location
    _req:Send()
end

-- 仙魄升级返回
function XianPoSystem:ResUpSoulReuslt(msg)
    if msg.isSucceed then
        local _data = XianPoData:New()
        _data:SetAllData(msg.soul)
        if self.EquipedXianPoDic:ContainsKey(_data.Location) then
            self.EquipedXianPoDic[_data.Location] = _data
        end
        Utils.ShowPromptByEnum("LevelUpSucceed")
        -- self:SortBagXianPoDic()
        GameCenter.PushFixEvent(LogicLuaEventDefine.EID_EVENT_XIANPOINFO_REFRESH, _data.Location)
        -- self:SetXianPoInlayRedPoint()
        self:LingPoChange()
    end
end

-- 请求兑换仙魄
function XianPoSystem:ReqExchangeSoul(cfgId, num)
    local _req = ReqMsg.MSG_ImmortalSoul.ReqExchangeSoul:New()
    _req.itemId = cfgId
    _req.num = num
    _req:Send()
end

-- 仙魄兑换返回
function XianPoSystem:ResExchangeSoulReuslt(msg)
    if msg.isSucceed then
        local _reason = msg.reason or 0
        local _data = XianPoData:New()
        _data:SetAllData(msg.soul)
        if not self.BagXianPoDic:ContainsKey(_data.Uid) then
            self:AddBag(_data.Uid, _data)
            -- 增加灵魄获取效果
            GameCenter.GetNewItemSystem:AddShowItem(_reason, nil, _data.CfgId, 1);
        end
        GameCenter.PushFixEvent(LogicLuaEventDefine.EID_EVENT_XIANPOINFO_REFRESH, 0)
        self:LingPoChange()
    end
end

-- 请求合成仙魄
function XianPoSystem:ReqCompoundSoul(cfgId)
    self.ReqCompoundCfgId = cfgId
    local _req = ReqMsg.MSG_ImmortalSoul.ReqCompoundSoul:New()
    _req.itemId = cfgId
    _req:Send()
end

-- 合成仙魄返回
function XianPoSystem:ResCompoundSoulReuslt(msg)
    if msg.isSucceed then
        local _data = XianPoData:New()
        _data:SetAllData(msg.soul)
        if not self.BagXianPoDic:ContainsKey(_data.Uid) then
            self:AddBag(_data.Uid, _data)
            GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_XIANPO_BAG_ITEM_CHANGED, _data.CfgId)
        end
        for i = 1, #msg.deleteUid do
            if self.BagXianPoDic:ContainsKey(msg.deleteUid[i]) then
                local _cfgId = self.BagXianPoDic:Get(msg.deleteUid[i]).CfgId
                self:RemoveBag(msg.deleteUid[i])
                GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_XIANPO_BAG_ITEM_CHANGED, _cfgId)
            end
        end
        Utils.ShowPromptByEnum("CompoundSucceed", _data.Name)
        self:SortBagXianPoDic()
        -- self:SetXianPoDecompositionRedPoint()
        -- GameCenter.PushFixEvent(LogicLuaEventDefine.EID_EVENT_XIANPO_SYNTHETIC, _data.CfgId)
        GameCenter.PushFixEvent(LogicLuaEventDefine.EID_EVENT_XIANPO_SYNTHETIC, {
            id = _data.CfgId,
            success = true
        })
        -- self:SetXianPoInlayRedPoint()
    else
        for i = 1, #msg.deleteUid do
            if self.BagXianPoDic:ContainsKey(msg.deleteUid[i]) then
                local _cfgId = self.BagXianPoDic:Get(msg.deleteUid[i]).CfgId
                self:RemoveBag(msg.deleteUid[i])
                GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_XIANPO_BAG_ITEM_CHANGED, _cfgId)
            end
        end
        self:SortBagXianPoDic()
        -- self:SetXianPoDecompositionRedPoint()
        -- GameCenter.PushFixEvent(LogicLuaEventDefine.EID_EVENT_XIANPO_SYNTHETIC, self.ReqCompoundCfgId)
        GameCenter.PushFixEvent(LogicLuaEventDefine.EID_EVENT_XIANPO_SYNTHETIC, {
            id = self.ReqCompoundCfgId,
            success = false
        })
        -- self:SetXianPoInlayRedPoint()
    end
    self:LingPoChange()

end

-- 请求脱下仙魄
function XianPoSystem:ReqGetOffSoul(location)
    local _req = ReqMsg.MSG_ImmortalSoul.ReqGetOffSoul:New()
    _req.location = location
    _req:Send()
end

-- 脱下仙魄返回
function XianPoSystem:ResGetOffReuslt(msg)
end

-- =============红点函数=============--
-- 灵魄背包改变
function XianPoSystem:LingPoChange()
    if not self.IsLingPoChange then
        self.IsLingPoChange = true
    end
end
-- 设置仙魄镶嵌的红点
function XianPoSystem:SetXianPoInlayRedPoint()
    local _haveRedPoint = false
    self.ListRedPointIds:Clear()
    if self:IsCanInlayXianPo() or self:IsEquipXianPoCanUpgrade() then
        _haveRedPoint = true
    end
    GameCenter.MainFunctionSystem:SetAlertFlag(FunctionStartIdCode.XianPoInlay, _haveRedPoint)
    self:SetXianPoSyntheticRedPoint()
end

-- 设置仙魄合成的红点
function XianPoSystem:SetXianPoSyntheticRedPoint()
    local _haveRedPoint = false
    local _cache = Dictionary:New()
    local _synKeys = self.XianPoSyntheticDic:GetKeys()
    for m = 1, #_synKeys do
        local _value = self.XianPoSyntheticDic[_synKeys[m]]
        local _needList = _value.NeedXianPoIdCountList
        local _isShow = true
        for i = 1, #_needList do
            local _cfgId = _needList[i].Id
            local _haveCount = 0
            local _needNum = _needList[i].NeedNum
            local _cacheData = _cache[_needList[i].Id]
            if _cacheData == nil then
                _cacheData = {Id = _cfgId, Left = self:GetXianPoCountByCfgId(_cfgId)}
                _cache:Add(_cfgId, _cacheData)
            end
            _haveCount = _cacheData.Left
            if _haveCount < _needNum then
                _isShow = false
                break
            end
            _cacheData.Left = _haveCount > _needNum and _haveCount - _needNum or 0
        end
        if _isShow then
            local _itemCount = GameCenter.ItemContianerSystem:GetItemCountFromCfgId(_value.NeedItemId)
            if _itemCount < _value.NeedItemNum then
                _isShow = false
            end
            if self.JianLingGeLevel <= _value.Limit then
                _isShow = false
            end
        end
        if _isShow then
            _haveRedPoint = true
            break
        end
    end
    return _haveRedPoint
end

function XianPoSystem:GetSyntheticRedPointList()
    local list = List:New()
    local _cache = Dictionary:New()
    local _haveRedPoint = false
    self.XianPoSyntheticDic:ForeachCanBreak(function(_, _value)
        local id = _
        local _needList = _value.NeedXianPoIdCountList
        local isShow = true
        for i = 1, #_needList do
            local _haveCount = 0
            local _cacheData = _cache[_needList[i].Id]
            if _cacheData == nil then
                _cacheData = {Id = _needList[i].Id, Left = self:GetXianPoCountByCfgId(_needList[i].Id)}
                _cache:Add(_needList[i].Id, _cacheData)
            end
            _haveCount = _cacheData.Left
            if _haveCount < _needList[i].NeedNum then
                isShow = false
            end
            _cacheData.Left = _haveCount > _needList[i].NeedNum and _haveCount - _needList[i].NeedNum or 0
        end
        local _haveCount = GameCenter.ItemContianerSystem:GetItemCountFromCfgId(_value.NeedItemId)
        if _haveCount < _value.NeedItemNum then
            isShow = false
        end
        if self.JianLingGeLevel <= _value.Limit then
            isShow = false
        end
        if isShow then
            _haveRedPoint = true
            list:Add(id)
        end
    end)
    return list
end

-- 判定所有位置是否为空，并有可镶嵌仙魄
function XianPoSystem:IsCanInlayXianPo()
    local _ret = false
    for i = 1, self.XianPoMaxInlayIndex do
        if self:IsIndexEmptyCanInlay(i) then
            _ret = true
            break
        end
    end
    return _ret
end

-- 判定一个位置是否为空，并且背包内有对应仙魄可镶嵌
function XianPoSystem:IsIndexEmptyCanInlay(index)
    local _canInlay = false
    if self:IsIndexUnlock(index) then
        -- 该位置已解锁
        if self:GetXianPoDataByIndex(index) == nil then
            -- 该位置没有镶嵌仙魄，遍历背包内的仙魄
            self.BagXianPoDic:ForeachCanBreak(function(key, value)
                if value.CanInlayLocationList:Contains(index) then
                    -- 如果这个仙魄可以镶嵌到这个格子
                    _canInlay = true
                    return true
                end
            end)
        end
    end
    return _canInlay
end

-- 判定所有位置的仙魄是否可升级
function XianPoSystem:IsEquipXianPoCanUpgrade()
    local _ret = false
    for i = 1, self.XianPoMaxInlayIndex do
        if self:IsIndexXianPoCanUpgrade(i) then
            _ret = true
            break
        end
    end
    return _ret
end

-- 判定一个位置的仙魄是否可升级
function XianPoSystem:IsIndexXianPoCanUpgrade(index)
    local _canUpgrade = false
    local _data = self:GetXianPoDataByIndex(index)
    if _data then
        local _nextLvNeedExp = self:GetNextLvNeedExp(_data.Quality, _data.Level)
        local _myExp = GameCenter.ItemContianerSystem:GetEconomyWithType(ItemTypeCode.LingPoJc)
        if _myExp >= _nextLvNeedExp and _data.Level < _data.MaxLevel then
            _canUpgrade = true
            self.ListRedPointIds:Add(_data.CfgId)
        end
    end
    return _canUpgrade
end

-- 设置仙魄分解的红点
function XianPoSystem:SetXianPoDecompositionRedPoint()
    local _haveRedPoint = false
    self.BagXianPoDic:ForeachCanBreak(function(key, value)
        if value.Typ == 2 then
            -- 是经验仙魄
            _haveRedPoint = true
            return true
        else
            -- 不是经验仙魄，判断是不是蓝色
            if value.Quality == XianPoQuality.Blue then
                _haveRedPoint = true
                return true
            end
        end
    end)
    GameCenter.MainFunctionSystem:SetAlertFlag(FunctionStartIdCode.XianPoDecomposition, _haveRedPoint)
end

-- =============接口函数=============--
-- 根据位置获取 该位置是否已镶嵌仙魄
-- function XianPoSystem:IsHaveXianPoByIndex(index)
--     local _ret = false
--     if self.EquipedXianPoDic:ContainsKey(index) then
--         if self.EquipedXianPoDic[index].Uid > 0 then
--             _ret = true
--         end
--     end
--     return _ret
-- end

-- 判断该位置是否已解锁
function XianPoSystem:IsIndexUnlock(index)
    local _unLockCfg = DataConfig.DataImmortalSoulIattice[index]
    if _unLockCfg then
        local _variableSystem = GameCenter.VariableSystem
        local _unLockCondition = Utils.SplitNumber(_unLockCfg.Condition, "_")
        return _variableSystem.IsVariableReach(_unLockCondition[1], _unLockCondition[2])
    end
    return false
end

-- 根据位置获取该位置的仙魄
function XianPoSystem:GetXianPoDataByIndex(index)
    local _ret = nil
    if self.EquipedXianPoDic:ContainsKey(index) then
        _ret = self.EquipedXianPoDic[index]
    end
    return _ret
end

-- 根据uid获取背包内的某个仙魄
function XianPoSystem:GetBagXianPoDataByUID(uid)
    local _ret = nil
    if self.BagXianPoDic:ContainsKey(uid) then
        _ret = self.BagXianPoDic[uid]
    end
    return _ret
end

-- 根据配置表id，获取背包内有多少个这个id的仙魄
function XianPoSystem:GetXianPoCountByCfgId(cfgId)
    local _count = self.SoulBagDic[cfgId]
    if _count == nil then
        _count = 0
    end
    return _count
end

-- 根据配置表id，判定当前身上是否已有相同属性的仙魄
-- prams:cfgId 背包中的仙魄配置表ID
function XianPoSystem:IsHaveSameAttrXianPo(cfgId, selectIndex)
    if selectIndex == nil then
        return false
    end
    local _have = false
    -- 根据配置表Type2再加一个判断，用于仙魄互斥的判定,type2相等那么就是同一类型的仙魄，不能穿戴
    local _cfg = DataConfig.DataImmortalSoulAttribute
    -- 经验仙魄
    local _curType1 = 1
    -- 道具仙魄
    local _curType2 = 0
    if _cfg:IsContainKey(cfgId) then
        _curType1 = _cfg[cfgId].Type
        _curType2 = _cfg[cfgId].Type2
    end
    local _selectedData = self:GetXianPoDataByIndex(selectIndex)
    -- 装备了的仙魄
    self.EquipedXianPoDic:ForeachCanBreak(function(key, value)
        -- 1. 有互斥ID，不能装备
        if value.MutexIdList:Contains(cfgId) then
            _have = true
            return true
        end
        -- 3. 未镶嵌格子的点击，单独处理两个特殊位置，不是9和10的只要背包里面没有就不能点击
        if _selectedData == nil then
            if selectIndex == 9 and _curType2 ~= 9 then
                _have = true
                return true
            elseif selectIndex == 10 and _curType2 ~= 10 then
                _have = true
                return true
            end
            -- 镶嵌的时候判断下是否是特殊仙魄
            if selectIndex < 9 and _curType2 >= 9 then
                _have = true
                return true
            end
            if value.Type2 == _curType2 then
                _have = true
                return true
            end
        else
            -- 4. 选中的需要替换的这个和背包中的对比
            if _selectedData.Type2 == _curType2 then
                -- 没有属性更高的了
                if not self:CheckChangeBtnRedPoint(cfgId) then
                    _have = true
                    return true
                end
                -- 5. 中间两个特殊的类型单独判断下
            elseif _selectedData.Type2 == 9 or _selectedData.Type2 == 10 and value.Type2 < _selectedData.Type2 then
                _have = true
                return true
                -- 6. 替换的时候判断下是否是特殊的仙魄
            elseif selectIndex < 9 and _curType2 >= 9 then
                _have = true
                return true
                -- 已装备的这个和背包中有相同类型的仙魄
            elseif value.Type2 == _curType2 then
                _have = true
                return true
            end
        end
    end)
    -- 7. 经验仙魄不能被装备
    if _curType1 > 1 then
        _have = true
    end
    -- 8. 什么都还没装备，判断下特定的
    if _selectedData == nil then
        if selectIndex == 9 and _curType2 ~= 9 then
            _have = true
        elseif selectIndex == 10 and _curType2 ~= 10 then
            _have = true
        end
        -- 镶嵌的时候判断下是否是特殊仙魄
        if selectIndex < 9 and _curType2 >= 9 then
            _have = true
            return true
        end
    end
    return _have
end

-- 替换按钮的红点
function XianPoSystem:CheckChangeBtnRedPoint(cfgId)
    local _cfg = DataConfig.DataImmortalSoulAttribute
    local _curCfg = nil
    if _cfg:IsContainKey(cfgId) then
        _curCfg = _cfg[cfgId]
    end
    local _haveRedPoint = false
    local _totalAttr = 0
    local _curTotalAttr = 0
    self.BagXianPoDic:ForeachCanBreak(function(key, _bagValue)
        -- 相同类型的仙魄对比属性看是否可以替换
        if _bagValue.Type2 == _curCfg.Type2 then
            _bagValue.TotalAddAttrDic:Foreach(function(_id, _attr)
                _totalAttr = _totalAttr + _attr
            end)
            local _cfgId = _curCfg.Id
            self.EquipedXianPoDic:ForeachCanBreak(function(key, _equipedValue)
                if _equipedValue.CfgId == _curCfg.Id then
                    _equipedValue.TotalAddAttrDic:ForeachCanBreak(
                        function(_id, _attr)
                            _curTotalAttr = _curTotalAttr + _attr
                            -- return true
                        end)
                    return true
                end
            end)
            if _totalAttr > _curTotalAttr then
                _haveRedPoint = true
                return true
            end
        end
    end)
    return _haveRedPoint
end

-- 未镶嵌的卡槽红点处理
function XianPoSystem:CheckUnEquipXianPoRedPoint()
    local _count = 0
    -- 装备了的仙魄
    local _equipDict = GameCenter.XianPoSystem.EquipedXianPoDic
    -- 背包里面的仙魄
    local _bagDict = GameCenter.XianPoSystem.BagXianPoDic
    local _typeList = List:New()
    -- 装备仙魄的所有type
    _equipDict:Foreach(function(_key, _value)
        if not _typeList:Contains(_value.Type2) then
            _typeList:Add(_value.Type2)
        end
    end)
    _bagDict:ForeachCanBreak(function(_key, _value)
        -- 非已装备的仙魄并且非经验仙魄
        if not _typeList:Contains(_value.Type2) and _value.Typ ~= 2 then
            _count = _count + 1
        end
    end)
    return _count
end

-- 获取预览界面的条件名称
function XianPoSystem:GetOverviewFormConditionName(value)
    if value == 0 then
        return DataConfig.DataMessageString.Get("UnlockDefault")
    else
        local _text = GameCenter.VariableSystem.GetVariableShowText(self.GetXianPoConditionType, value)
        return UIUtils.CSFormat(DataConfig.DataMessageString.Get("UnlockByThroughPass"), _text)
    end
end

-- 根据品质、等级，获取升到下一级所需经验
function XianPoSystem:GetNextLvNeedExp(quality, level)
    local _ret = 0
    local _cfg = DataConfig.DataImmortalSoulExp[level]
    if _cfg then
        if quality == XianPoQuality.Blue then
            -- 蓝色
            local _exp = Utils.SplitNumber(_cfg.BlueExp, "_")
            _ret = _exp[1]
        elseif quality == XianPoQuality.Purple then
            -- 紫色
            local _exp = Utils.SplitNumber(_cfg.VioletExp, "_")
            _ret = _exp[1]
        elseif quality == XianPoQuality.Gold then
            -- 金色
            local _exp = Utils.SplitNumber(_cfg.GoldenExp, "_")
            _ret = _exp[1]
        elseif quality == XianPoQuality.Red then
            -- 红色
            local _exp = Utils.SplitNumber(_cfg.GulesExp, "_")
            _ret = _exp[1]
        end
    end
    return _ret
end

-- 根据品质、等级，获取当前等级总经验
function XianPoSystem:GetCurLvTotalExp(quality, level)
    local _ret = 0
    local _cfg = DataConfig.DataImmortalSoulExp[level]
    if _cfg then
        if quality == XianPoQuality.Blue then
            -- 蓝色
            local _exp = Utils.SplitNumber(_cfg.BlueExp, "_")
            _ret = _exp[2]
        elseif quality == XianPoQuality.Purple then
            -- 紫色
            local _exp = Utils.SplitNumber(_cfg.VioletExp, "_")
            _ret = _exp[2]
        elseif quality == XianPoQuality.Gold then
            -- 金色
            local _exp = Utils.SplitNumber(_cfg.GoldenExp, "_")
            _ret = _exp[2]
        elseif quality == XianPoQuality.Red then
            -- 红色
            local _exp = Utils.SplitNumber(_cfg.GulesExp, "_")
            _ret = _exp[2]
        end
    end
    return _ret
end

-- 根据类型获取该种类型仙魄的类型名，1：属性仙魄，2：经验仙魄
function XianPoSystem:GetXianPoTypeName(typ)
    if typ == 1 then
        return "PropertyXianPo"
    elseif typ == 2 then
        return "PropertyExp"
    else
        return "PropertyXianPo"
    end
end

-- =============功能函数=============--
-- 对背包里的仙魄排序
function XianPoSystem:SortBagXianPoDic()
    self.BagXianPoDic:SortValue(function(a, b)
        if a.Quality == b.Quality then
            if a.Level == b.Level then
                return a.CfgId < b.CfgId
            else
                return a.Level > b.Level
            end
        else
            return a.Quality > b.Quality
        end
    end)
end

-- 设置仙魄的图标
function XianPoSystem:SetXianPoIcons(trans, cfgId)
    -- 后面可能会增加背景品质框
    local _cfg = DataConfig.DataImmortalSoulAttribute[cfgId]
    local _uiIcon = UIUtils.RequireUIIconBase(trans)
    local _qualitySpr = UIUtils.FindSpr(trans, "Quality")
    if _uiIcon and _cfg then
        _uiIcon:UpdateIcon(_cfg.Icon)
        _qualitySpr.spriteName = Utils.GetQualitySpriteName(tonumber(_cfg.Quality))
    end
end

-- 设置仙魄的tips
function XianPoSystem:SetXianPoTips(trans, cfgId)
    local _tipsRoot = UIUtils.FindTrans(trans, "Tips")
    local _iconTrs = UIUtils.FindTrans(_tipsRoot, "Icon")
    self:SetXianPoIcons(_iconTrs, cfgId)
    local _cfg = DataConfig.DataImmortalSoulAttribute[cfgId]
    if _cfg then
        -- 名字
        local _nameLab = UIUtils.FindLabel(_tipsRoot, "Name")
        UIUtils.SetTextByStringDefinesID(_nameLab, _cfg._Name)
        -- 等级
        -- local _levelLab = UIUtils.FindLabel(_tipsRoot, "Level")
        -- 类型
        local _typeLab = UIUtils.FindLabel(_tipsRoot, "Type")
        UIUtils.SetTextByEnum(_typeLab, self:GetXianPoTypeName(_cfg.Type))
        -- 属性
        local _attrCloneGo = UIUtils.FindGo(_tipsRoot, "AttrClone")
        local _attrCloneRoot = UIUtils.FindTrans(_tipsRoot, "AttrCloneGrid")
        local _attrCloneRootGrid = UIUtils.FindGrid(_tipsRoot, "AttrCloneGrid")
        -- 先隐藏所有属性
        for i = 0, _attrCloneRoot.childCount - 1 do
            _attrCloneRoot:GetChild(i).gameObject:SetActive(false)
        end
        if _cfg.DemandValue and _cfg.DemandValue ~= "" then
            local _attrList = Utils.SplitStrByTableS(_cfg.DemandValue)
            for i = 1, #_attrList do
                local _go
                if i - 1 < _attrCloneRoot.childCount then
                    _go = _attrCloneRoot:GetChild(i - 1).gameObject
                else
                    _go = UnityUtils.Clone(_attrCloneGo, _attrCloneRoot)
                end
                local _label = UIUtils.FindLabel(_go.transform)
                UIUtils.SetTextByPropNameAndValue(_label, _attrList[i][1], _attrList[i][2])
                _go:SetActive(true)
            end
        end
        _attrCloneRootGrid.repositionNow = true
        -- 获得方式
        local _getMethodLab = UIUtils.FindLabel(_tipsRoot, "GetMethod")
        UIUtils.SetTextByString(_getMethodLab, self:GetOverviewFormConditionName(_cfg.OverviewConditions))
    end
end

function XianPoSystem:GetCoreDic()
    if self.DicJianCore == nil then
        self.DicJianCore = Dictionary:New()
        DataConfig.DataImmortalSoulCore:Foreach(function(k, v)
            local _data = L_JianCore:New()
            _data.JianId = k
            self.DicJianCore:Add(k,_data)
        end)
    end
    return self.DicJianCore
end

function XianPoSystem:GetJianCoreData(index)
    local _ret = nil
    local _dic = self:GetCoreDic()
    if _dic ~= nil then
        _ret = _dic[index]
    end
    return _ret
end

function XianPoSystem:GetJianValid(index)
    local _ret = false
    local _jianCore = nil
    local _dic = self:GetCoreDic()
    if _dic ~= nil then
        _jianCore = _dic[index]
        if _jianCore ~= nil then
            _ret = _jianCore:GetJianValid()
        end
    end
    return _ret
end

function XianPoSystem:GetJianName(index)
    local _ret = ""
    for i = 1, #self.JianLingList do
        if index == i then
            _ret = self.JianLingList[i]
            break
        end
    end
    return _ret
end

--获取所有装备仙魄的等级
function XianPoSystem:GetAllEquipLv(index)
    local _ret = 0
    local _keys = self.EquipedXianPoDic:GetKeys()
    for i = 1, #_keys do
        local _key = _keys[i]
        if math.floor( _key / 100 ) == index then
            local _data = self.EquipedXianPoDic[_key]
            if _data ~= nil then
                _ret = _ret + _data.Level
            end
        end
    end
    return _ret
end

--获取激活条件
function XianPoSystem:GetJianActiveDes(index)
    local _ret = ""
    local _lv = 0
    local _jianName = ""
    local _preJianName = ""
    local _coreName = ""
    local _cfg = DataConfig.DataGlobal[GlobalName.immortal_soul_core_limit]
    if _cfg  ~= nil then
        local _list = Utils.SplitStr(_cfg.Params, ';')
        if _list ~= nil then
            for i = 1, #_list do
                local _values = Utils.SplitNumber(_list[i], '_')
                if _values ~= nil then
                    if _values[1] == index then
                        _lv = _values[2]
                        break
                    end
                end
            end
        end
    end
    local _nameList = self:GetNameList()
    if _nameList ~= nil then
        if index <= #_nameList then
            _jianName = _nameList[index]
        end
        if index - 1 > 0 and index - 1 <= #_nameList then
            _preJianName = _nameList[index - 1]
        end
    end
    local _preCfg = DataConfig.DataImmortalSoulCore[index - 1]
    if _preCfg ~= nil then
        _coreName = _preCfg.Name
    end
    _ret = UIUtils.CSFormat(DataConfig.DataMessageString.Get("LING_PO_CORE_open_next"), _coreName, _lv, _jianName)
    return _ret
end

function XianPoSystem:ResSoulCore(msg)
    if msg == nil then
        return
    end
    local _dic = self:GetCoreDic()
    if _dic ~= nil then
        if msg.info ~= nil then
            for i = 1, #msg.info do
                local _data = _dic[i]
                _data.JianId = i
                _data.CoreId = msg.info[i].core
            end
        end
    end
end

function XianPoSystem:ResSoulCoreUpdate(msg)
    if msg == nil then
        return
    end
    local _dic = self:GetCoreDic()
    if _dic == nil then
        return
    end
    local _data = _dic[msg.info.type]
    if _data ~= nil then
        _data.CoreId = msg.info.core
    end
    GameCenter.PushFixEvent(LogicLuaEventDefine.EID_EVENT_LINGPO_CORE_LV_RESULT)
end

function XianPoSystem:ReqDismountingSoul(id)
    GameCenter.Network.Send("MSG_ImmortalSoul.ReqDismountingSoul", {
        uid = id
    })
end

function XianPoSystem:ResDismountingSoulReuslt(msg)
    if msg == nil then
        return
    end
    if msg.isSucceed then
        self:RemoveBag(msg.uid)
    end
    GameCenter.PushFixEvent(LogicLuaEventDefine.EID_EVENT_XIANPO_DECOMPOSITION)
end

return XianPoSystem