查看“︁卡牌/中立”︁的源代码

local p = {}

-- 使用官方参数解析器
local getArgs = require('Module:Arguments').getArgs

-- 渲染模块
local displayModule = require('Module:卡牌/display')

-- 卡牌逻辑模块
local cardModule = require('Module:卡牌')

-- 安全的错误输出
local function err(msg)
    return '<span style="color: red;">' .. mw.text.encode(msg) .. '</span>'
end

-- 检查卡牌是否属于指定职业
local function hasClass(classStr, targetClass)
    if not classStr or classStr == "" then
        return false
    end
    
    -- 将顿号替换为逗号，统一处理
    classStr = classStr:gsub("、", ",")
    
    -- 分割职业字符串
    for className in classStr:gmatch("[^,]+") do
        className = mw.text.trim(className)
        if className == targetClass then
            return true
        end
    end
    
    return false
end

-- 显示单张中立卡牌
function p.main(frame)
    local args = getArgs(frame, { removeBlank = true })
    local cardName = args[1]
    
    if not cardName or cardName == "" then
        return err("错误: 未指定卡牌名")
    end
    
    -- 加载中立卡牌数据
    local success, neCardData = pcall(require, 'Module:卡牌/中立/data')
    if not success or not neCardData then
        return err('错误: 找不到模块 "Module:卡牌/中立/data"')
    end
    
    local cardDataWrapper = neCardData[cardName]
    if not cardDataWrapper then
        return err('错误: 找不到中立卡牌 "' .. cardName .. '"')
    end
    
    local baseData = cardDataWrapper.base
    if not baseData then
        return err('错误: 卡牌 "' .. cardName .. '" 没有 base 数据')
    end
    
    -- 构造模块信息（中立卡牌统一使用 basic 边框）
    local moduleInfo = {
        ego = "basic"
    }
    
    -- 解析卡牌数据
    local cardInfo = cardModule.parseCardData(baseData, "中立卡牌", cardName, moduleInfo, {
        isVariant = false,
        baseApText = nil,
        baseDictStr = ""
    })
    
    if not cardInfo then
        return err("错误: 解析卡牌数据失败")
    end
    
    -- 强制设置 ego 为 basic（确保边框正确）
    cardInfo.ego = "basic"
    
    -- 处理衍生卡牌
    local subCardInfo = nil
    if baseData.sub then
        subCardInfo = cardModule.parseSubCardData(baseData.sub, neCardData, moduleInfo)
    end
    
    -- 渲染卡牌
    return displayModule.render(cardInfo, subCardInfo)
end

-- 显示所有中立卡牌（支持职业筛选）
function p.showAll(frame)
    local args = getArgs(frame, { removeBlank = false })
    
    -- 获取职业筛选参数
    local filterClass = args.class or args['职业'] or args[1]
    if filterClass then
        filterClass = mw.text.trim(filterClass)
    end
    
    -- 加载中立卡牌数据
    local success, neCardData = pcall(require, 'Module:卡牌/中立/data')
    if not success or not neCardData then
        return err('错误: 找不到模块 "Module:卡牌/中立/data"')
    end
    
    -- 收集所有卡牌名称并排序
    local cardNames = {}
    for cardName, cardData in pairs(neCardData) do
        if type(cardData) == "table" and cardData.base then
            -- 如果指定了职业筛选，检查卡牌是否符合
            if filterClass then
                local classStr = cardData.base.class or ""
                if hasClass(classStr, filterClass) then
                    table.insert(cardNames, cardName)
                end
            else
                table.insert(cardNames, cardName)
            end
        end
    end
    table.sort(cardNames)
    
    -- 如果筛选后没有卡牌
    if #cardNames == 0 then
        if filterClass then
            return err('错误: 没有找到职业为 "' .. filterClass .. '" 的中立卡牌')
        else
            return err('错误: 没有找到任何中立卡牌')
        end
    end
    
    -- 构建 HTML
    local html = {}
    
    -- 渲染每张卡牌
    local moduleInfo = { ego = "basic" }
    for _, cardName in ipairs(cardNames) do
        local cardDataWrapper = neCardData[cardName]
        local baseData = cardDataWrapper.base
        
        if baseData then
            -- 解析卡牌数据
            local cardInfo = cardModule.parseCardData(baseData, "中立卡牌", cardName, moduleInfo, {
                isVariant = false,
                baseApText = nil,
                baseDictStr = ""
            })
            
            if cardInfo then
                -- 强制设置 ego 为 basic
                cardInfo.ego = "basic"
                
                -- 处理衍生卡牌
                local subCardInfo = nil
                if baseData.sub then
                    subCardInfo = cardModule.parseSubCardData(baseData.sub, neCardData, moduleInfo)
                end
                
                -- 提取筛选参数
                local rarity = mw.text.trim(baseData.rarity or "")
                local classStr = mw.text.trim(baseData.class or "")
                
                -- 将中文顿号替换为英文逗号
                classStr = classStr:gsub("、", ",")
                
                table.insert(html, string.format(
                    '<div class="deck-card-wrapper" data-param1="%s" data-param2="%s" data-card="%s" data-module="中立卡牌">',
                    mw.text.encode(rarity),
                    mw.text.encode(classStr),
                    mw.text.encode(cardName)
                ))
                table.insert(html, displayModule.render(cardInfo, subCardInfo))
                table.insert(html, '</div>')
            end
        end
    end
    
    return table.concat(html, '')
end

-- 按职业显示中立卡牌（专门的职业筛选函数）
function p.showByClass(frame)
    local args = getArgs(frame, { removeBlank = true })
    local targetClass = args[1] or args.class or args['职业']
    
    if not targetClass or targetClass == "" then
        return err("错误: 未指定职业")
    end
    
    targetClass = mw.text.trim(targetClass)
    
    -- 调用 showAll 并传递职业参数
    return p.showAll(frame:newChild{
        title = frame:getTitle(),
        args = { class = targetClass }
    })
end

-- 批量显示指定的中立卡牌
function p.batch(frame)
    local args = getArgs(frame, { removeBlank = false })
    
    -- 加载中立卡牌数据
    local success, neCardData = pcall(require, 'Module:卡牌/中立/data')
    if not success or not neCardData then
        return err('错误: 找不到模块 "Module:卡牌/中立/data"')
    end
    
    local html = {}
    table.insert(html, '<div style="display:flex;gap:10px;flex-wrap:wrap;">')
    
    local moduleInfo = { ego = "basic" }
    
    -- 遍历所有参数（每个参数是一个卡牌名）
    local i = 1
    while args[i] do
        local cardName = args[i]
        
        if cardName and cardName ~= "" then
            local cardDataWrapper = neCardData[cardName]
            
            if cardDataWrapper and cardDataWrapper.base then
                local baseData = cardDataWrapper.base
                
                -- 解析卡牌数据
                local cardInfo = cardModule.parseCardData(baseData, "中立卡牌", cardName, moduleInfo, {
                    isVariant = false,
                    baseApText = nil,
                    baseDictStr = ""
                })
                
                if cardInfo then
                    -- 强制设置 ego 为 basic
                    cardInfo.ego = "basic"
                    
                    -- 处理衍生卡牌
                    local subCardInfo = nil
                    if baseData.sub then
                        subCardInfo = cardModule.parseSubCardData(baseData.sub, neCardData, moduleInfo)
                    end
                    
                    -- 渲染并添加到 HTML
                    table.insert(html, displayModule.render(cardInfo, subCardInfo))
                end
            else
                table.insert(html, err('错误: 找不到卡牌 "' .. cardName .. '"'))
            end
        end
        
        i = i + 1
    end
    
    table.insert(html, '</div>')
    return table.concat(html, '')
end

return p