模块:卡牌

此模块的文档可以在模块:卡牌/doc创建

local p = {}

-- 使用官方参数解析器，自动合并父/子 frame 参数、去空白与空值
local getArgs = require('Module:Arguments').getArgs

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

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

-- 解析 dict 字段
local function parseDictTokens(dictStr)
    local s = tostring(dictStr or '')
    if s == '' then return {} end

    local tokens = {}
    local processedText = s

    -- 提取 {{词典|机制}} 形式的 token（保留为 template 类型）
    for token in s:gmatch('{{%s*词典%s*|%s*([^}|]+)%s*[^}]*}}') do
        token = mw.text.trim(token or '')
        if token ~= '' then
            table.insert(tokens, { type = 'template', value = token })
        end
    end

    -- 提取 {{文本|颜色|内容}} 形式的内容 token（保留为模板）
    for content in s:gmatch('{{%s*文本%s*|%s*[^|]+%s*|%s*([^}]+)%s*}}') do
        content = mw.text.trim(content or '')
        if content ~= '' then
            table.insert(tokens, { type = 'template', value = content })
        end
    end

    -- 移除所有模板，保留纯文本部分
    processedText = processedText:gsub('{{%s*词典%s*|%s*[^}]*}}', '')
    processedText = processedText:gsub('{{%s*文本%s*|%s*[^}]*}}', '')

    -- 处理剩余的纯文本（支持中文顿号和逗号）
    processedText = processedText:gsub('、', ','):gsub('，', ',')
    for token in processedText:gmatch('([^,]+)') do
        token = mw.text.trim(token or '')
        if token ~= '' then
            table.insert(tokens, { type = 'text', value = token })
        end
    end

    -- 去重，保持顺序
    local seen, out = {}, {}
    for _, t in ipairs(tokens) do
        local key = t.type .. ':' .. t.value
        if not seen[key] then
            seen[key] = true
            table.insert(out, t)
        end
    end
    return out
end

-- 加载 模块:词典/data
local dictData = nil
do
    local ok, dictModule = pcall(mw.loadData, 'Module:词典/data')
    if ok and type(dictModule) == 'table' then
        if type(dictModule.dictionary) == 'table' then
            dictData = dictModule.dictionary
        else
            dictData = dictModule
        end
    end
end

-- 根据 tokens 生成词典条目数组 { {key=..., desc=...}, ... }
-- tokens 可以是：字符串数组 或 结构化数组 [{type="text",value="x"}, {type="template",value="y"}]
local function buildDictEntries(tokens)
    if not tokens or #tokens == 0 then return nil end
    local entries = {}

    for _, t in ipairs(tokens) do
        local key = nil

        -- 判断 token 是否为结构化对象（新格式）
        if type(t) == "table" and t.type and t.value then
            key = t.value
        -- 判断 token 是否为字符串（旧格式兼容）
        elseif type(t) == "string" then
            key = t
        end

        -- 如果 key 为 nil，跳过这个 token
        if not key then
            -- 不做任何事，跳过
        else
            -- 去空格
            key = mw.text.trim(key)

            -- 如果去空格后为空，也跳过
            if key ~= '' then
                local desc = nil
                local d = dictData and dictData[key]

                if type(d) == 'table' then
                    if d[1] and type(d[1]) == 'table' then
                        desc = d[1]["描述"] or d[1].desc or desc
                    elseif type(d["描述"]) == 'string' then
                        desc = d["描述"]
                    elseif type(d.desc) == 'string' then
                        desc = d.desc
                    end
                end

                table.insert(entries, { key = key, desc = desc })
            end
        end
    end

    return #entries > 0 and entries or nil
end

-- 合并 base 数据与变体数据
local function mergeCardData(baseData, variantData, opts)
    if not baseData then return nil end
    local merged = {}
    -- 浅拷贝 base
    for k, v in pairs(baseData) do
        merged[k] = v
    end
    -- 清空衍生卡牌信息
    if opts and opts.clearSubUnlessSpecified then
        merged.sub = nil
    end
    -- 覆盖变体数据
    if variantData then
        for k, v in pairs(variantData) do
            merged[k] = v
        end
    end
    return merged
end

-- 根据 base AP 与目标 AP 文本计算发光样式
-- 返回: 'blue' | 'red' | 'green' | 'gray'
local function calcApStyle(apText, baseApText, isVariant)
    local text = apText ~= nil and tostring(apText) or ''
    if not isVariant then
        return 'blue'
    end
    if text == 'X' then
        return 'blue'
    end
    local n = tonumber(text)
    local baseN = baseApText ~= nil and tonumber(baseApText) or nil
    if n and baseN then
        if n > baseN then
            return 'red'
        elseif n < baseN then
            return 'green'
        else
            return 'blue'
        end
    end
    -- 其他内容（非数值且非X）不发光
    return 'gray'
end

-- 将单张卡牌的数据转换为 cardInfo 结构（在此完成词典解析）
-- opts:
--   isVariant: boolean
--   baseApText: string|number
--   baseDictStr: string
function p.parseCardData(cardData, moduleName, cardName, moduleInfo, opts)
    if not cardData then
        return nil
    end

    local ego = ""
    if moduleInfo and moduleInfo.ego then
        ego = moduleInfo.ego
    elseif cardData.ego then
        ego = cardData.ego
    end

    -- 展示名称：优先 displayname，否则使用卡牌名
    local displayTitle = (cardData.displayname and mw.text.trim(tostring(cardData.displayname)) ~= '' and cardData.displayname) or cardName or ''

    -- AP 文本与样式
    local apText = cardData.ap ~= nil and tostring(cardData.ap) or ''
    local isVariant = opts and opts.isVariant or false
    local baseApText = opts and opts.baseApText or nil
    local apStyle = calcApStyle(apText, baseApText, isVariant)

    -- 词典解析
    local rawDictStr = cardData.dict or ""
    local dictStr = mw.text.trim(rawDictStr)
    local dictTokens
    local dictEntries
    local dictColor = "default"

    if isVariant then
        -- 获取base的dict用于比较
        local baseDictStr = opts and opts.baseDictStr or ""
        baseDictStr = mw.text.trim(baseDictStr)
        
        if dictStr == "空" then
            -- 显式设置为"空"，说明是变体修改了
            dictTokens = {}
            dictEntries = nil
            dictColor = "green"
        elseif dictStr ~= "" and dictStr ~= baseDictStr then
            -- dict不为空，且与base不同，说明变体修改了
            dictTokens = parseDictTokens(dictStr)
            dictEntries = buildDictEntries(dictTokens)
            dictColor = "green"
        else
            -- dict为空或与base相同，说明是继承的
            dictTokens = parseDictTokens(dictStr)
            dictEntries = buildDictEntries(dictTokens)
            dictColor = "default"
        end
    else
        dictTokens = parseDictTokens(dictStr)
        dictEntries = buildDictEntries(dictTokens)
    end

    local cardInfo = {
        moduleName = moduleName or "",
        cardName = cardName or "",
        displayTitle = displayTitle or "",
        art = cardData.art or "",
        ego = ego or "",
        rarity = cardData.rarity or "",
        apText = apText,
        apStyle = apStyle,
        cardType = cardData.type or "",
        desc = cardData.desc_global or "",
        dict = dictStr,
        dictTokens = dictTokens,
        dictEntries = dictEntries,
        dictColor = dictColor,
        group = cardData.group or "",
        tag = cardData.tag or "",
        hasInspiration = false,
        inspirationVariants = {}
    }

    return cardInfo
end

-- 解析衍生卡牌列表（支持递归）
function p.parseSubCardData(subCardNames, dataModule, moduleInfo)
    if not subCardNames or not dataModule then
        return nil
    end
    local subCards = {}
    for subName in string.gmatch(subCardNames, '([^,]+)') do
        subName = mw.text.trim(subName)
        if subName ~= "" then
            local subCardData = dataModule[subName]
            if subCardData and subCardData.base then
                local parsedCard = p.parseCardData(subCardData.base, "", subName, moduleInfo, { isVariant = false })
                if parsedCard then
                    if subCardData.base.sub then
                        parsedCard.subCards = p.parseSubCardData(subCardData.base.sub, dataModule, moduleInfo)
                    end
                    table.insert(subCards, parsedCard)
                end
            end
        end
    end
    if #subCards == 0 then
        return nil
    end
    return subCards
end

-- 收集全部灵光一闪变体
local function collectInspirationVariants(baseData, cardDataWrapper, moduleName, cardName, moduleInfo, dataModule)
    local variants = {}
    if not cardDataWrapper.var or not cardDataWrapper.var.inspiration then
        return variants
    end
    for i, inspData in ipairs(cardDataWrapper.var.inspiration) do
        local mergedData = mergeCardData(baseData, inspData, { clearSubUnlessSpecified = true })
        if mergedData then
            local variantInfo = p.parseCardData(mergedData, moduleName, cardName, moduleInfo, {
                isVariant = true,
                baseApText = baseData.ap,
                baseDictStr = baseData.dict or ""
            })
            if variantInfo then
                if mergedData.sub then
                    variantInfo.subCards = p.parseSubCardData(mergedData.sub, dataModule, moduleInfo)
                end
                table.insert(variants, variantInfo)
            end
        end
    end
    return variants
end

-- 主入口
function p.main(frame)
    local args = getArgs(frame, { removeBlank = true })

    local moduleName = args[1]
    local cardName = args[2]
    local variantType = args[3]
    local variantParam = args[4]

    if not moduleName or moduleName == "" then
        return err("错误: 未指定模块名")
    end
    if not cardName or cardName == "" then
        return err("错误: 未指定卡牌名")
    end

    local success, dataModule = pcall(require, 'Module:卡牌/' .. moduleName)
    if not success or not dataModule then
        return err('错误: 找不到模块 "Module:卡牌/' .. moduleName .. '"')
    end

    local moduleInfo = dataModule.info or {}
    local cardDataWrapper = dataModule[cardName]
    if not cardDataWrapper then
        return err('错误: 在模块 "' .. moduleName .. '" 中找不到卡牌 "' .. cardName .. '"')
    end

    local baseData = cardDataWrapper.base
    if not baseData then
        return err('错误: 卡牌 "' .. cardName .. '" 没有 base 数据')
    end

    local finalCardData = baseData
    local isVariantFlag = false

    if variantType then
        variantType = mw.text.trim(variantType)
        if variantType == "灵光一闪" then
            if not cardDataWrapper.var or not cardDataWrapper.var.inspiration then
                return err('错误: 卡牌 "' .. cardName .. '" 没有灵光一闪变体')
            end
            local inspIndex = tonumber(variantParam)
            if not inspIndex or inspIndex < 1 or inspIndex > #cardDataWrapper.var.inspiration then
                return err('错误: 灵光一闪变体索引 "' .. tostring(variantParam) .. '" 无效')
            end
            finalCardData = mergeCardData(baseData, cardDataWrapper.var.inspiration[inspIndex], { clearSubUnlessSpecified = true })
            isVariantFlag = true
        else
            return err('错误: 未知变体类型 "' .. variantType .. '"')
        end
    end

    if not finalCardData then
        return err("错误: 最终卡牌数据为空")
    end

    local cardInfo = p.parseCardData(finalCardData, moduleName, cardName, moduleInfo, {
        isVariant = isVariantFlag,
        baseApText = baseData and baseData.ap or nil,
        baseDictStr = baseData and baseData.dict or ""
    })
    if not cardInfo then
        return err("错误: 解析卡牌数据失败")
    end

    -- 灵光一闪按钮集合
    if not variantType and cardDataWrapper.var and cardDataWrapper.var.inspiration and (baseData.isinspiration == 1) then
        cardInfo.hasInspiration = true
        cardInfo.inspirationVariants = collectInspirationVariants(baseData, cardDataWrapper, moduleName, cardName, moduleInfo, dataModule)
    end

    -- 主卡牌的衍生牌
    local subCardInfo = nil
    if finalCardData.sub then
        subCardInfo = p.parseSubCardData(finalCardData.sub, dataModule, moduleInfo)
    end

    return displayModule.render(cardInfo, subCardInfo)
end

function p.batch(frame)
    local args = getArgs(frame, { removeBlank = false })
    local html = {}
    
    -- 开始包裹容器
    table.insert(html, '<div style="display:flex;gap:10px;flex-wrap:wrap;">')
    
    -- 遍历所有参数组
    local i = 1
    while args[i] do
        local moduleName = args[i]
        local cardName = args[i+1]
        local variantType = args[i+2]
        local variantParam = args[i+3]
        
        if moduleName and cardName then
            -- 清理空字符串为 nil
            if variantType == "" then variantType = nil end
            if variantParam == "" then variantParam = nil end
            
            -- 构造子 frame 调用 p.main
            local subArgs = {moduleName, cardName}
            
            -- 只有在变体类型非空时才添加变体参数
            if variantType then
                table.insert(subArgs, variantType)
                if variantParam then
                    table.insert(subArgs, variantParam)
                end
            end
            
            local subFrame = {
                args = subArgs,
                getParent = function() return frame end
            }
            table.insert(html, p.main(subFrame))
        end
        
        i = i + 4  -- 每组4个参数(模块名,卡牌名,变体类型,变体参数)
    end
    
    -- 结束包裹容器
    table.insert(html, '</div>')
    
    return table.concat(html, '')
end

return p