- Welcome to the Kancolle Wiki!
- If you have any questions regarding site content, account registration, etc., please visit the KanColle Wiki Discord
Module:MapBranchingTable
Jump to navigation
Jump to search
Documentation for this module may be created at Module:MapBranchingTable/doc
-- [[Category:Todo]]: have Module:Logger to expose syntax warnings, similarly to Module:DropList (use it there as well).
local getArgs = require("Module:GetArgs")
local format = require("Module:StringOperations").format
local Utils = require("Module:Utils")
local BaseData = require("Module:BaseData")
local MapBranchingTable = BaseData{
_grammar = {
split = "^%s*(.+)%s*->%s*(.+)%s*$",
comma_list = "[^,]+",
node_and_color = "^%s*(%a)%s*/%s*(%S+)%s*$",
node_and_color2 = "^%s*(%a)%s*/%s*(%S+)%s*/%s*(%S+)%s*$",
node = "^%s*([%a%d])%s*$",
digit_node = "^%s*%d%s*$",
},
_id = "mapbranchingtable", -- not supporting unique ids for now
_title = "Branching Rules",
_width = "auto",
_start = "'''Start'''",
-- .branching-table is defined in MediaWiki:Common.css
_template = [[{| class="wikitable typography-xl-optout branching-table" style="width:${width};"
|- class="mw-customtoggle-${id}" style="cursor:pointer;"
!colspan="3"|${title}
|- class="mw-collapsible mw-collapsed" id="mw-customcollapsible-${id}"
!colspan="2"|Nodes||Rules
${rows}
|}]],
_row_start_template = [[|- class="mw-collapsible mw-collapsed" id="mw-customcollapsible-${id}"
|rowspan="${rowspan}" style="text-align:center;vertical-align:middle;width:50px;"|${from}]],
_row_separator_template = [[|- class="mw-collapsible mw-collapsed" id="mw-customcollapsible-${id}"
]],
_row_template = [[${separator}|class="mw-collapsible mw-collapsed" id="mw-customcollapsible-${id}" style="text-align:center;width:50px;"|${to}${rules}]],
_rules = "\n|rowspan=\"${span}\" style=\"padding:10px;\"|\n${rules}",
-- .kcRoute is defined in MediaWiki:Common.css
_node_template = [[<div class="kcRoute" style="vertical-align:middle"><div class="kcRouteNode" style="background:${color};">${label}</div></div>]],
_node_color2 = [[linear-gradient(90deg, ${color1} 50%, ${color2} 50%)]],
_node_colors = {
grey = "grey",
battle = "#FF1744", -- Red A400
resource = "#64DD17", -- Light Green A700
storm = "#EA80FC", -- Purple A100
empty = "#40C4FF", -- Light Blue A200
},
}
function make_id_from_title(title)
return title:gsub("%s", ""):lower()
end
function MapBranchingTable:parse_node(node_string)
local node, color1, color2 = node_string:match(self._grammar.node_and_color2)
if not node then
node, color1 = node_string:match(self._grammar.node_and_color)
end
if not node then
node = node_string:match(self._grammar.node)
end
return node, color1, color2
end
function MapBranchingTable:parse(args)
self._vars = {
id = args.id or args.title and make_id_from_title(args.title) or self._id,
-- id = args.id or args.title and make_id_from_title(args.title) or remiLib.timeHash(args) or self._id,
title = args.title or self._title,
width = args.width or self._width,
branching = { index = {} },
}
local branching = self._vars.branching
for route, rules in pairs(args) do
if type(route) ~= "number" then
local from_node, to_nodes = route:match(self._grammar.split)
if from_node and to_nodes then
local from_node_color1, from_node_color2
from_node, from_node_color1, from_node_color2 = self:parse_node(from_node)
local first_node = nil
for to_node in string.gmatch(to_nodes, self._grammar.comma_list) do
local to_node_color1, to_node_colo2
to_node, to_node_color1, to_node_color2 = self:parse_node(to_node)
if from_node and to_node then
Utils.insertNew(branching.index, from_node)
if not branching[from_node] then
branching[from_node] = { color = from_node_color1, color2 = from_node_color2, index = {}, indexes = { index = {}, groups = {} } }
end
if not first_node then
first_node = to_node
branching[from_node][to_node] = { color = to_node_color1, color2 = to_node_color2, rules = rules, span = 1 }
if not branching[from_node].indexes.groups[first_node] then
table.insert(branching[from_node].indexes.index, first_node)
branching[from_node].indexes.groups[first_node] = { first_node }
end
else
branching[from_node][first_node].span = branching[from_node][first_node].span + 1
branching[from_node][to_node] = { color = to_node_color1, color2 = to_node_color2 }
if branching[from_node].indexes.groups[first_node] then
Utils.insertNew(branching[from_node].indexes.groups[first_node], to_node)
end
end
end
end
end
end
end
local sorting
if args.order then
local order_nodes = mw.text.split(args.order, "%s*,%s*")
sorting = function(a, b)
local ai = Utils.ifind(order_nodes, a)
local bi = Utils.ifind(order_nodes, b)
if ai and bi then
return ai < bi
else
return a < b
end
end
else
sorting = function(a, b)
return a < b
end
end
table.sort(branching.index, sorting)
for _, from in ipairs(branching.index) do
table.sort(branching[from].indexes.index, sorting)
for _, first_node in ipairs(branching[from].indexes.index) do
for _, node in ipairs(branching[from].indexes.groups[first_node]) do
table.insert(branching[from].index, node)
end
end
end
end
function MapBranchingTable:format_node(label, color, color2)
return label == "0" and self._start or format{
self._node_template,
label = label,
color = label:match(self._grammar.digit_node)
and self._node_colors.grey
or color2
and (format {
self._node_color2,
color1 = self._node_colors[color] or color or self._node_colors.battle,
color2 = self._node_colors[color2] or color2 or self._node_colors.battle,
})
or self._node_colors[color]
or color
or self._node_colors.battle
}
end
function MapBranchingTable:format_rows()
local branching = self._vars.branching
local rows = {}
for _, from_node in ipairs(branching.index) do
table.insert(rows, format{
self._row_start_template,
rowspan = #branching[from_node].index,
from = self:format_node(from_node, branching[from_node].color, branching[from_node].color2),
id = self._vars.id,
})
local first = true
for _, to_node in ipairs(branching[from_node].index) do
table.insert(rows, format{
self._row_template,
separator = first and "" or format{self._row_separator_template, id = self._vars.id},
to = self:format_node(to_node, branching[from_node][to_node].color, branching[from_node][to_node].color2),
rules = branching[from_node][to_node].rules and format{
self._rules,
rules = branching[from_node][to_node].rules,
span = branching[from_node][to_node].span,
} or "",
id = self._vars.id,
})
first = false
end
end
self._vars.rows = table.concat(rows, "\n")
end
function MapBranchingTable:format(args)
self:parse(args)
self:format_rows()
return format(self._template, self._vars)
end
function MapBranchingTable.Table(frame, args)
return MapBranchingTable:format(args or getArgs{frame = frame:getParent()})
end
--[[
Utils.registerTableTests(MapBranchingTable, {
{
["0 -> 1"] = "Fixed route",
["1 -> C/empty, D"] = "Random",
["1 -> A, B/battle, X/empty"] = "Random",
["C -> F, G/battle/empty"] = "...",
["B -> D, E"] = "...",
["title"] = "A Custom Title",
["order"] = "C, A, 1, B",
"?",
}
})
-- p.run_table_tests()
]]--
return MapBranchingTable