模块:卡牌/怪物

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

local p = {}

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

-- 引入核心卡牌模块
local cardModule = require('Module:卡牌')

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

-- 加载怪物数据
local function loadMonsterData()
    local ok, monsterData = pcall(require, 'Module:卡牌/怪物/data')
    if not ok or not monsterData then
        return nil, '错误: 无法加载 Module:卡牌/怪物/data'
    end
    return monsterData, nil
end

-- 将怪物数据转换为标准卡牌数据格式
local function convertMonsterToCardData(monsterName, monsterCardData)
    if not monsterCardData or not monsterCardData.base then
        return nil
    end
    
    local base = monsterCardData.base
    
    -- 构造标准卡牌数据结构
    local cardDataWrapper = {
        base = {
            displayname = base.displayname or monsterName,
            art = base.art,
            ap = base.ap,
            type = base.type,
            dict = base.dict or "",
            desc_global = base.desc_global or "",
            rarity = "彩",  -- 怪物卡牌稀有度固定为彩
            ego = "all",     -- 使用统一边框
            group = "",
            tag = "",
            sub = base.sub,
            isinspiration = 0,
            isgod_inspiration = 0,
            isgod_god_inspiration = 0
        }
    }
    
    return cardDataWrapper
end

-- 主入口函数
function p.main(frame)
    local args = getArgs(frame, { removeBlank = true })
    
    local monsterName = args[1]
    
    if not monsterName or monsterName == "" then
        return err("错误: 未指定怪物名称")
    end
    
    -- 加载怪物数据
    local monsterData, loadErr = loadMonsterData()
    if loadErr then
        return err(loadErr)
    end
    
    -- 获取指定怪物的数据
    local monsterCardData = monsterData[monsterName]
    if not monsterCardData then
        return err('错误: 找不到怪物 "' .. monsterName .. '"')
    end
    
    -- 转换为标准卡牌格式
    local cardDataWrapper = convertMonsterToCardData(monsterName, monsterCardData)
    if not cardDataWrapper then
        return err('错误: 怪物数据格式不正确')
    end
    
    -- 创建临时模块信息
    local moduleInfo = {
        ego = "all"  -- 统一使用 all 边框
    }
    
    local baseData = cardDataWrapper.base
    
    -- 解析卡牌数据
    local cardInfo = cardModule.parseCardData(baseData, "怪物", monsterName, moduleInfo, {
        isVariant = false,
        baseApText = nil,
        baseDictStr = ""
    })
    
    if not cardInfo then
        return err("错误: 解析怪物卡牌数据失败")
    end
    
    -- 处理衍生卡牌
    local subCardInfo = nil
    if baseData.sub then
        -- 直接传入整个怪物数据模块
        subCardInfo = cardModule.parseSubCardData(baseData.sub, monsterData, moduleInfo)
    end
    
    -- 使用现有的渲染系统
    local displayModule = require('Module:卡牌/display')
    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 monsterData, loadErr = loadMonsterData()
    if loadErr then
        table.insert(html, '</div>')
        return table.concat(html, '') .. err(loadErr)
    end
    
    -- 遍历所有怪物名称
    local i = 1
    while args[i] do
        local monsterName = args[i]
        
        if monsterName and monsterName ~= "" then
            local monsterCardData = monsterData[monsterName]
            if monsterCardData then
                -- 转换为标准卡牌格式
                local cardDataWrapper = convertMonsterToCardData(monsterName, monsterCardData)
                if cardDataWrapper then
                    local moduleInfo = { ego = "all" }
                    local baseData = cardDataWrapper.base
                    
                    -- 解析卡牌数据
                    local cardInfo = cardModule.parseCardData(baseData, "怪物", monsterName, moduleInfo, {
                        isVariant = false,
                        baseApText = nil,
                        baseDictStr = ""
                    })
                    
                    if cardInfo then
                        -- 处理衍生卡牌
                        local subCardInfo = nil
                        if baseData.sub then
                            subCardInfo = cardModule.parseSubCardData(baseData.sub, monsterData, moduleInfo)
                        end
                        
                        -- 渲染
                        local displayModule = require('Module:卡牌/display')
                        table.insert(html, displayModule.render(cardInfo, subCardInfo))
                    end
                end
            end
        end
        
        i = i + 1
    end
    
    -- 结束包裹容器
    table.insert(html, '</div>')
    
    return table.concat(html, '')
end

-- 获取所有怪物名称（按添加顺序）
local function getAllMonsterNames(monsterData)
    local names = {}
    
    for name, data in pairs(monsterData) do
        -- 过滤掉非卡牌数据
        if type(data) == "table" and data.base then
            table.insert(names, name)
        end
    end
    
    -- 按名称排序
    table.sort(names)
    
    return names
end

-- 按类型分组怪物
local function groupMonstersByType(monsterData)
    local groups = {
        ["攻击"] = {},
        ["技能"] = {},
        ["强化"] = {},
        ["状态异常"] = {},
        ["其他"] = {}
    }
    
    for name, data in pairs(monsterData) do
        if type(data) == "table" and data.base then
            local cardType = data.base.type or "其他"
            if not groups[cardType] then
                groups[cardType] = {}
            end
            table.insert(groups[cardType], name)
        end
    end
    
    -- 对每组内的名称排序
    for _, group in pairs(groups) do
        table.sort(group)
    end
    
    return groups
end

-- 显示所有怪物卡牌
function p.all(frame)
    local args = getArgs(frame, { removeBlank = true })
    
    -- 可选参数：groupByType (是否按类型分组)
    local groupByType = args.groupByType or args[1]
    groupByType = (groupByType == "true" or groupByType == "1" or groupByType == "yes")
    
    -- 加载怪物数据
    local monsterData, loadErr = loadMonsterData()
    if loadErr then
        return err(loadErr)
    end
    
    local html = {}
    local displayModule = require('Module:卡牌/display')
    
    if groupByType then
        -- 按类型分组显示（不显示标题）
        local groups = groupMonstersByType(monsterData)
        local typeOrder = {"攻击", "技能", "强化", "状态异常", "其他"}
        
        for _, cardType in ipairs(typeOrder) do
            local monsters = groups[cardType]
            if monsters and #monsters > 0 then
                -- 添加该类型的所有卡牌（不添加标题）
                table.insert(html, '<div style="display:flex;gap:10px;flex-wrap:wrap;margin-bottom:20px;">')
                for _, name in ipairs(monsters) do
                    local monsterCardData = monsterData[name]
                    if monsterCardData then
                        local cardDataWrapper = convertMonsterToCardData(name, monsterCardData)
                        if cardDataWrapper then
                            local moduleInfo = { ego = "all" }
                            local baseData = cardDataWrapper.base
                            
                            local cardInfo = cardModule.parseCardData(baseData, "怪物", name, moduleInfo, {
                                isVariant = false,
                                baseApText = nil,
                                baseDictStr = ""
                            })
                            
                            if cardInfo then
                                local subCardInfo = nil
                                if baseData.sub then
                                    subCardInfo = cardModule.parseSubCardData(baseData.sub, monsterData, moduleInfo)
                                end
                                table.insert(html, displayModule.render(cardInfo, subCardInfo))
                            end
                        end
                    end
                end
                table.insert(html, '</div>')
            end
        end
    else
        -- 不分组，直接显示所有（不显示标题）
        local allNames = getAllMonsterNames(monsterData)
        
        table.insert(html, '<div style="display:flex;gap:10px;flex-wrap:wrap;">')
        for _, name in ipairs(allNames) do
            local monsterCardData = monsterData[name]
            if monsterCardData then
                local cardDataWrapper = convertMonsterToCardData(name, monsterCardData)
                if cardDataWrapper then
                    local moduleInfo = { ego = "all" }
                    local baseData = cardDataWrapper.base
                    
                    local cardInfo = cardModule.parseCardData(baseData, "怪物", name, moduleInfo, {
                        isVariant = false,
                        baseApText = nil,
                        baseDictStr = ""
                    })
                    
                    if cardInfo then
                        local subCardInfo = nil
                        if baseData.sub then
                            subCardInfo = cardModule.parseSubCardData(baseData.sub, monsterData, moduleInfo)
                        end
                        table.insert(html, displayModule.render(cardInfo, subCardInfo))
                    end
                end
            end
        end
        table.insert(html, '</div>')
    end
    
    return table.concat(html, '')
end

-- 统计信息函数
function p.stats(frame)
    local monsterData, loadErr = loadMonsterData()
    if loadErr then
        return err(loadErr)
    end
    
    local groups = groupMonstersByType(monsterData)
    local total = 0
    
    local html = {}
    table.insert(html, '<div style="background:#2a2a2a;color:white;padding:15px;border-radius:8px;margin:10px 0;">')
    table.insert(html, '<h3 style="color:#cb75e1;margin-top:0;">怪物卡牌统计</h3>')
    table.insert(html, '<ul style="list-style:none;padding:0;">')
    
    local typeOrder = {"攻击", "技能", "强化", "状态异常", "其他"}
    for _, cardType in ipairs(typeOrder) do
        local count = groups[cardType] and #groups[cardType] or 0
        total = total + count
        if count > 0 then
            table.insert(html, '<li style="padding:5px 0;"><strong>' .. cardType .. '：</strong>' .. count .. ' 张</li>')
        end
    end
    
    table.insert(html, '<li style="padding:5px 0;border-top:1px solid #444;margin-top:10px;"><strong>总计：</strong>' .. total .. ' 张</li>')
    table.insert(html, '</ul>')
    table.insert(html, '</div>')
    
    return table.concat(html, '')
end

return p