七日内新公告:全站维护公告
  • 你好~!欢迎来到萌娘百科镜像站!如需查看或编辑,请联系本站管理员注册账号。
  • 本镜像站和其他萌娘百科的镜像站无关,请注意分别。

Module:称呼表

猛汉♂百科,万男皆可猛的百科全书!转载请标注来源页面的网页链接,并声明引自猛汉百科。内容不可商用。
跳转到导航 跳转到搜索
模块文档  [查看] [编辑] [历史] [刷新]

这个模块用于在不同角色条目里生成对应的称呼表。

由于该模块不可用#invoke调用,因此你需要按照以下步骤创建一个数据模块来调用它。

模块调用

创建一个模块(例如Module:BanG Dream! 称呼表),然后用以下方式调用模块:

local getArgs = require('Module:Arguments').getArgs
local p = {}

-- 这里待会儿用于填写数据

function p.main(frame)
	local args = getArgs(frame)
	return p._main(args)
end
 
function p._main(args)
    return require('Module:称呼表').main(args, {
        member = member,
        group = group,
        groupmem = groupmem,
        call = call,
        lang = 'ja', -- 这里是语言标记,可以自定义
        groupColor = groupColor,
        selfColor = selfColor,
    })
end

return p

数据填写

角色与组别数据

首先,我们需要填写角色数据,包括角色名字已经你所期待的组别。以《BanG Dream!》系列中前两个乐队为例:

local member = {
	"户山香澄","花园多惠","牛込里美","山吹沙绫","市谷有咲",
	"美竹兰","青叶摩卡","上原绯玛丽","宇田川巴","羽泽鸫"
}
 
local group = {
	"{{BanG Dream!/Icon|ppp}}Poppin'Party",
	"{{BanG Dream!/Icon|ag}}Afterglow"
}
 
local groupmem = {
	[group[1]]={member[1],member[2],member[3],member[4],member[5]},
	[group[2]]={member[6],member[7],member[8],member[9],member[10]}
}

这样输入后,member[1]对应的就是户山香澄,member[7]对应的就是青叶摩卡,group[2]对应的是Afterglow,groupmem[group[1]]则存储了group[1]里含有哪些角色。

很显然,这样需要你记住每一个角色对应的位置,因此建议你在填写数据的时候按组别来换行,避免混淆。

组别颜色(可选)

在总表或子表模式下,可以设置同一个组别内互称染上特定的底色,同时自称染上另一种颜色,如果需要的话,可以添加以下数据:

local groupColor = {
    "#FFDDEE",
    "#FFDDDD",
}

local selfColor = "#999999"

groupColor的顺序和group是一一对应的,如果你希望中间几组不设置额外颜色,可以写成nil,跳过该组。不需要指定自称颜色时直接删掉selfColor这行,此时显示的是标题行底色。

组别别称(可选)

如果你的组别如样例一样带有模板等结构,那么当你需要调用某几个组的子表时,组名输入将非常麻烦,因此你可以在group后设置这样一个别称映射表:

local groupAlias = {
    ["ppp"]        = group[1],
    ["ag"]         = group[2],
}

这样一来,填写组别时可以用ppp和ag分别指代第一组和第二组。

称呼数据

称呼数据的格式为call[member[x]][member[y]],对应的是member[x]对member[y]的称呼,因此你可以用以下方式存储称呼:

local call = {
	[member[1]] = {
		[member[1]]="私",
        [member[2]]="おたえ",
        [member[3]]="りみりん",
        [member[4]]="さーや",
        [member[5]]="有咲",
		[member[6]]="蘭ちゃん",
        [member[7]]="モカちゃん",
        [member[8]]="ひまりちゃん",
        [member[9]]="巴ちゃん",
       -- [member[10]]=""
	},
-- 其他角色略去
}

注意这里的第10项,因为我们在这里假设称呼不明,但同时我们也不知道未来有没有可能补上,故为了代码排版整齐,我们保留了未来填写数据的位置,前方用--将其注释掉。称呼较少的时候可以直接不写这一项。

包装与使用

创建Template:BanG Dream! 称呼表,以#invoke方式调用模块,大功告成:

{{#invoke:BanG Dream!称呼表|main}}

使用时:

  • {{BanG Dream! 称呼表|from=户山香澄}}生成户山香澄对其他人的称呼。
  • {{BanG Dream! 称呼表|to=户山香澄}}生成其他人对户山香澄的称呼。
  • {{BanG Dream! 称呼表}}生成总表(不常用)。
  • {{BanG Dream! 称呼表|group=1,ag}}生成包含第一组(此处是Poppin'Party)和ag代表的组(此处是Afterglow)的子表格。
local p = {}

-- 预处理 wikitext
local function wikitext(text)
    return mw.getCurrentFrame():preprocess(text)
end

-- 生成角色对其他角色称呼的表格(保持原样)
function p.from(from, group, groupmem, call, lang)
    local parts = {";" .. from .. "对其他角色的称呼\n", '<div style="display:flex;flex-wrap:wrap;gap:0;align-items:flex-start;width:100%">', "\n"}
    for i, groupName in ipairs(group) do
        if groupmem[groupName] then
            table.insert(parts, string.format('{| class="wikitable" style="font-size:95%%; width:300px; text-align:center; margin:0"\n!colspan=2|%s\n', groupName))
            for j, member in ipairs(groupmem[groupName]) do
                table.insert(parts, "|-\n")
                table.insert(parts, string.format('|style="width:50%%"|%s\n', member))
                if call[from] and call[from][member] then
                    if lang then
                        table.insert(parts, string.format('|style="width:50%%"|{{lang|%s|%s}}\n', lang, call[from][member]))
                    else
                        table.insert(parts, string.format('|style="width:50%%"|%s\n', call[from][member]))
                    end
                else
                    table.insert(parts, '|style="width:50%"| -\n')
                end
            end
            table.insert(parts, "|}\n")
        end
    end
    table.insert(parts, "</div>")
    return wikitext(table.concat(parts))
end

-- 生成其他角色对指定角色称呼的表格(保持原样)
function p.to(to, group, groupmem, call, lang)
    local parts = {";其他角色对" .. to .. "的称呼\n", '<div style="display:flex;flex-wrap:wrap;gap:0;align-items:flex-start;width:100%">', "\n"}
    for i, groupName in ipairs(group) do
        if groupmem[groupName] then
            table.insert(parts, string.format('{| class="wikitable" style="font-size:95%%; width:300px; text-align:center; margin:0"\n!colspan=2|%s\n', groupName))
            for j, member in ipairs(groupmem[groupName]) do
                table.insert(parts, "|-\n")
                table.insert(parts, string.format('|style="width:50%%"|%s\n', member))
                if call[member] and call[member][to] then
                    if lang then
                        table.insert(parts, string.format('|style="width:50%%"|{{lang|%s|%s}}\n', lang, call[member][to]))
                    else
                        table.insert(parts, string.format('|style="width:50%%"|%s\n', call[member][to]))
                    end
                else
                    table.insert(parts, '|style="width:50%"| -\n')
                end
            end
            table.insert(parts, "|}\n")
        end
    end
    table.insert(parts, "</div>")
    return wikitext(table.concat(parts))
end

-- 生成完整总表:列标题“到XX” + 行标题“从XX” + 背景色
function p.total(member, call, lang, getColor)
    local parts = {'{|class="wikitable"\n'}

    -- 列标题行:一个空表头(对应“从XX”列),然后各“到XX”
    table.insert(parts, "|-\n! \n")
    for i, mem in ipairs(member) do
        table.insert(parts, "!到" .. mem .. "\n")
    end

    -- 数据行
    for j, fromMem in ipairs(member) do
        table.insert(parts, "|-\n")
        -- 行标题列(从XX)
        table.insert(parts, string.format('! scope="row" | 从%s\n', fromMem))

        -- 数据单元格
        for i, toMem in ipairs(member) do
            local text
            if call[fromMem] and call[fromMem][toMem] then
                if lang then
                    text = string.format("{{lang|%s|%s}}", lang, call[fromMem][toMem])
                else
                    text = call[fromMem][toMem]
                end
            else
                text = " -"
            end

            local bg = getColor and getColor(fromMem, toMem) or nil
            if bg then
                table.insert(parts, string.format("\n|style=\"background:%s\"|%s", bg, text))
            else
                table.insert(parts, "\n|" .. text)
            end
        end
        table.insert(parts, "\n")
    end
    table.insert(parts, "|}")
    return wikitext(table.concat(parts))
end

-- 生成指定 group 的方阵(可多个组别合并为一个方阵)
-- groupList: 要生成的 group 名数组(原始组名)
-- groupmem: 组名 -> 成员数组
-- groupColorMap: 组名 -> 颜色(可为 nil)
-- selfColor: 自称颜色(可为 nil)
function p.groupMatrix(groupList, groupmem, call, lang, groupColorMap, selfColor)
    groupColorMap = groupColorMap or {}

    -- 收集所有选中组的成员,并记录每个成员所属的组名
    local allMembers = {}
    local memberGroup = {}
    for _, groupName in ipairs(groupList) do
        local members = groupmem[groupName]
        if members then
            for _, m in ipairs(members) do
                table.insert(allMembers, m)
                memberGroup[m] = groupName
            end
        end
    end

    if #allMembers == 0 then
        return ""
    end

    local parts = {'{| class="wikitable" style="text-align:center; margin:0.5em 0"\n'}

    -- 列标题行:一个空表头(对应“从XX”列),然后各“到XX”
    table.insert(parts, "|-\n! \n")
    for _, m in ipairs(allMembers) do
        table.insert(parts, "!到" .. m .. "\n")
    end

    -- 数据行
    for _, fromMem in ipairs(allMembers) do
        table.insert(parts, "|-\n")
        -- 行标题列(从XX)
        table.insert(parts, string.format('! scope="row" | 从%s\n', fromMem))

        for _, toMem in ipairs(allMembers) do
            local text
            if call[fromMem] and call[fromMem][toMem] then
                if lang then
                    text = string.format("{{lang|%s|%s}}", lang, call[fromMem][toMem])
                else
                    text = call[fromMem][toMem]
                end
            else
                text = " -"
            end

            -- 决定背景色
            local bg = nil
            if fromMem == toMem then
                -- 对角线:自称
                bg = selfColor
            else
                local gf = memberGroup[fromMem]
                local gt = memberGroup[toMem]
                if gf and gt and gf == gt then
                    -- 同组:用该组颜色
                    bg = groupColorMap[gf]
                end
                -- 跨组:不着色
            end

            if bg then
                table.insert(parts, string.format('|style="background:%s"|%s\n', bg, text))
            else
                table.insert(parts, string.format('|%s\n', text))
            end
        end
    end

    table.insert(parts, "|}")
    return wikitext(table.concat(parts))
end

-- 统一入口:由数据模块调用
-- data = { member, group, groupmem, call, lang, groupColor, selfColor }
function p.main(args, data)
    local member = data.member
    local group = data.group
    local groupmem = data.groupmem
    local call = data.call
    local lang = data.lang or nil
    local selfColor = data.selfColor or "#e7e7ed"

    -- 构建成员 -> 组索引(用于判断是否同组)
    local memberGroupIndex = {}
    for i, g in ipairs(group) do
        local members = groupmem[g]
        if members then
            for _, m in ipairs(members) do
                memberGroupIndex[m] = i
            end
        end
    end

    -- 构建组名 -> 颜色映射
    -- 若某个组对应的颜色为 nil,则该组不做特别着色,走 wikitable 默认样式
    local groupColorMap = {}
    if data.groupColor then
        for i, g in ipairs(group) do
            groupColorMap[g] = data.groupColor[i]  -- 允许 nil
        end
    end

    -- 总表背景色函数
    local function getColor(fromMem, toMem)
        if fromMem == toMem then
            return selfColor
        end
        local gi = memberGroupIndex[fromMem]
        local gj = memberGroupIndex[toMem]
        if gi and gj and gi == gj then
            return groupColorMap[group[gi]]
        end
        return nil
    end

    -- 根据参数分发
    if args.from then
        return p.from(args.from, group, groupmem, call, lang)
    elseif args.to then
        return p.to(args.to, group, groupmem, call, lang)
    elseif args.group then
        local groupInput = args.group
        local groupAlias = data.groupAlias or {}
        local groupList = {}
        for name in mw.text.gsplit(groupInput, ",") do
            name = mw.text.trim(name)
            if name ~= "" then
                local resolved = nil
                -- 1. 序号
                local idx = tonumber(name)
                if idx and group[idx] then
                    resolved = group[idx]
                end
                -- 2. 别名映射
                if not resolved and groupAlias[name] then
                    resolved = groupAlias[name]
                end
                -- 3. 原始组名精确匹配
                if not resolved then
                    for _, g in ipairs(group) do
                        if g == name then
                            resolved = g
                            break
                        end
                    end
                end
                if resolved then
                    table.insert(groupList, resolved)
                end
            end
        end
        if #groupList > 0 then
            return p.groupMatrix(groupList, groupmem, call, lang, groupColorMap, selfColor)
        else
            return "未找到指定的 group"
        end
    else
        return p.total(member, call, lang, getColor)
    end
end

return p