Toggle search
Toggle menu
115
248
25
2.7K
SpiritVale Wiki
Toggle preferences menu
Toggle personal menu
Not logged in
Your IP address will be publicly visible if you make any edits.

Join the Playtest on Steam Now: SpiritVale

Module:GameInfo: Difference between revisions

From SpiritVale Wiki
More actions
← Older editNewer edit →
No edit summary
No edit summary
Line 1: Line 1:
-- Module:GameInfo
-- Module:GameInfo
-- Base container + shared scaffolding for all GameInfo.* renderers (Phase 4.1).
-- Phase 4.1 (Refactor): stable entrypoint + strict routing + shared scaffolding.
--
--
-- Routing:
-- Contract (new, strict):
--   Skill pages (recommended):
-- - Pages are generated/updated by SVWT + pywikibot (compiled artifacts).
--    {{#invoke:GameInfo|Skills|notes=...|data=...}}
-- - No legacy wrappers: read args from frame.args ONLY.
-- - Submodules are pure renderers:
--    return require("Module:GameInfo/Skills").render(frame)
--  Optional:
--    return require("Module:GameInfo/Skills").STYLE_SRC = "Module:GameInfo/skills.css"
--
--
--   Category pages (generic):
-- Entry points:
--     {{#invoke:GameInfo|Category|name=Skills|...}} -> Module:GameInfo/Skills
--   {{#invoke:GameInfo|Skills|id=...|index=...|notes=...|data=...}}
--     {{#invoke:GameInfo|Category|name=Monsters|...}} -> Module:GameInfo/Monsters (future)
--   {{#invoke:GameInfo|Category|name=Skills|...}} -- allowlist only
--
-- Notes:
-- - This module is the stable entrypoint. Render logic lives in submodules.
-- - Submodules are expected to return a string of wikitext/HTML.
--
-- Compat:
-- - Some call sites pass args via frame:getParent().args (template wrappers, routers).
-- - Use _get_arg/_get_name to reliably read args either way.


local p = {}
local p = {}


-- Shared TemplateStyles page (Module space per Phase 4.1).
-- Default TemplateStyles source (may be overridden by submodules via STYLE_SRC).
local DEFAULT_STYLE_SRC = "Module:GameInfo/styles.css"
local DEFAULT_STYLE_SRC = "Module:GameInfo/styles.css"


local function _to_int(v, fallback)
-- Allowlist routes (no dynamic require by user input).
if v == nil then return fallback end
local ROUTES = {
local n = tonumber(v)
Skills = "Module:GameInfo/Skills",
if not n then return fallback end
-- Future:
n = math.floor(n + 0.0)
-- Monsters = "Module:GameInfo/Monsters",
return n
-- Equips  = "Module:GameInfo/Equips",
end
}
 
-- -----------------------------------------------------------------------------
-- Small utils
-- -----------------------------------------------------------------------------


local function _trim(v)
local function _trim(v)
if v == nil then return nil end
if v == nil then return "" end
local s = tostring(v)
local s = tostring(v)
return mw.text and mw.text.trim(s) or s:match("^%s*(.-)%s*$")
if mw.text and mw.text.trim then
return mw.text.trim(s)
end
return (s:gsub("^%s+", ""):gsub("%s+$", ""))
end
end


local function _is_html_node(x)
local function _to_int(v, fallback)
-- mw.html nodes are Lua tables with common builder methods.
local n = tonumber(v)
return type(x) == "table" and type(x.tag) == "function" and type(x.wikitext) == "function"
if not n then return fallback end
return math.floor(n + 0.0)
end
end


local function _add_content(container, content)
local function _is_html_node(x)
if content == nil then return end
return type(x) == "table"
if _is_html_node(content) then
and type(x.tag) == "function"
container:node(content)
and type(x.wikitext) == "function"
return
end
container:wikitext(tostring(content))
end
end


local function _error_box(msg)
local function _error_box(msg)
-- Keep this simple and obvious on-wiki while troubleshooting.
-- Keep obvious + wiki-friendly (TemplateStyles will still load).
local div = mw.html.create("div")
return tostring(
:addClass("error")
mw.html.create("div")
:wikitext(tostring(msg))
:addClass("sv-gi-error")
return tostring(div)
:wikitext(tostring(msg))
)
end
end


-- -----------------------------------------------------------------------------
-- -----------------------------------------------------------------------------
-- COMPAT: args may live on frame.args OR frame:getParent().args
-- Args (strict: frame.args only)
-- -----------------------------------------------------------------------------
-- -----------------------------------------------------------------------------


local function _get_arg(frame, key)
function p.arg(frame, key, fallback)
local args = frame and frame.args or {}
local args = frame and frame.args or {}
local v = _trim(args[key])
local v = _trim(args[key])
if v and v ~= "" then return v end
if v ~= "" then return v end
return fallback
end


local parent = frame and frame.getParent and frame:getParent() or nil
function p.int(frame, key, fallback, minv, maxv)
local pargs = parent and parent.args or {}
local n = _to_int(p.arg(frame, key, nil), fallback)
v = _trim(pargs[key])
if minv ~= nil and n < minv then n = minv end
if v and v ~= "" then return v end
if maxv ~= nil and n > maxv then n = maxv end
return n
end


return nil
function p.bool(frame, key, fallback)
local v = p.arg(frame, key, nil)
if v == nil then return fallback end
v = _trim(v):lower()
if v == "1" or v == "true" or v == "yes" or v == "y" then return true end
if v == "0" or v == "false" or v == "no" or v == "n" then return false end
return fallback
end
end


local function _get_name(frame)
-- -----------------------------------------------------------------------------
-- Supports |name=, |category=, or positional |1=.
-- TemplateStyles
local v = _get_arg(frame, "name")
-- -----------------------------------------------------------------------------
if v and v ~= "" then return v end
v = _get_arg(frame, "category")
if v and v ~= "" then return v end


local args = frame and frame.args or {}
local p1 = _trim(args[1])
if p1 and p1 ~= "" then return p1 end
local parent = frame and frame.getParent and frame:getParent() or nil
local pargs = parent and parent.args or {}
p1 = _trim(pargs[1])
if p1 and p1 ~= "" then return p1 end
return nil
end
-- Emit TemplateStyles. Submodules should include this once at the top of output.
function p.styles(frame, src)
function p.styles(frame, src)
frame = frame or mw.getCurrentFrame()
frame = frame or mw.getCurrentFrame()
Line 102: Line 98:
end
end


-- Core builder: returns { root = <div>, top = <div>, bottom = <div> }
-- -----------------------------------------------------------------------------
-- Caller fills top/bottom and tostring(root) to return.
-- Shared container builder
function p.new_box(opts)
-- -----------------------------------------------------------------------------
 
-- Canonical builder: returns { root=<div>, top=<div>, bottom=<div> }.
-- Submodules fill top/bottom and tostring(root).
function p.box(opts)
opts = opts or {}
opts = opts or {}


Line 118: Line 118:
:addClass("sv-gi-card")
:addClass("sv-gi-card")
:attr("data-gi", "1")
:attr("data-gi", "1")
:attr("data-gi-phase", "4.1")
:attr("data-level", tostring(level))
:attr("data-level", tostring(level))
:attr("data-max-level", tostring(max_level))
:attr("data-max-level", tostring(max_level))


if root_id and root_id ~= "" then
if root_id and tostring(root_id) ~= "" then
root:attr("id", root_id)
root:attr("id", tostring(root_id))
end
end


-- Optional variant class for category modules (e.g. "sv-gi--skills").
if opts.variant and tostring(opts.variant) ~= "" then
if opts.variant and opts.variant ~= "" then
root:addClass("sv-gi--" .. tostring(opts.variant))
root:addClass("sv-gi--" .. tostring(opts.variant))
end
end
Line 133: Line 133:
local bottom = root:tag("div"):addClass("sv-gi-bottom")
local bottom = root:tag("div"):addClass("sv-gi-bottom")


return {
return { root = root, top = top, bottom = bottom }
root = root,
top = top,
bottom = bottom,
}
end
end


-- Convenience wrapper: build a full box in one call.
-- Backward-friendly alias for your own codebase (not “reverse wiki compat”).
-- opts.top / opts.bottom can be strings or mw.html nodes.
p.new_box = p.box
 
function p.render_box(opts)
function p.render_box(opts)
local box = p.new_box(opts)
local box = p.box(opts)
_add_content(box.top, opts and opts.top)
if opts and opts.top ~= nil then
_add_content(box.bottom, opts and opts.bottom)
if _is_html_node(opts.top) then box.top:node(opts.top) else box.top:wikitext(tostring(opts.top)) end
end
if opts and opts.bottom ~= nil then
if _is_html_node(opts.bottom) then box.bottom:node(opts.bottom) else box.bottom:wikitext(tostring(opts.bottom)) end
end
return tostring(box.root)
return tostring(box.root)
end
end


-- -----------------------------------------------------------------------------
-- -----------------------------------------------------------------------------
-- Routing / Dispatch
-- Dispatch
-- -----------------------------------------------------------------------------
-- -----------------------------------------------------------------------------


local ROUTES = {
local function _require_submodule(module_title)
-- Canonical category -> submodule
local ok, mod = pcall(require, module_title)
["Skills"] = "Module:GameInfo/Skills",
if not ok then
-- Future:
return nil, "GameInfo: failed to require " .. tostring(module_title)
-- ["Monsters"] = "Module:GameInfo/Monsters",
end
-- ["Equips"]  = "Module:GameInfo/Equips",
if type(mod) ~= "table" then
}
return nil, "GameInfo: " .. tostring(module_title) .. " did not return a table"
 
end
local function _pick_entry(mod)
if type(mod.render) ~= "function" then
-- Support a few common entrypoint names.
return nil, "GameInfo: " .. tostring(module_title) .. " must export render(frame)"
if type(mod) ~= "table" then return nil end
end
if type(mod.main) == "function" then return mod.main end
return mod, nil
if type(mod.render) == "function" then return mod.render end
if type(mod.Skills) == "function" then return mod.Skills end
if type(mod.Category) == "function" then return mod.Category end
return nil
end
end


local function _invoke_submodule(frame, module_title)
local function _invoke(frame, module_title)
local ok_mod, mod = pcall(require, module_title)
local mod, err = _require_submodule(module_title)
if not ok_mod then
if not mod then
return _error_box("GameInfo: failed to require " .. module_title)
return p.styles(frame) .. _error_box(err)
end
end


local fn = _pick_entry(mod)
local style_src = mod.STYLE_SRC or DEFAULT_STYLE_SRC
if type(fn) ~= "function" then
return _error_box("GameInfo: " .. module_title .. " has no entry function (main/render).")
end


local ok_call, out = pcall(fn, frame)
local ok, out = pcall(mod.render, frame)
if not ok_call then
if not ok then
return _error_box("GameInfo: error inside " .. module_title)
return p.styles(frame, style_src) .. _error_box("GameInfo: error inside " .. tostring(module_title))
end
end


return out
return p.styles(frame, style_src) .. tostring(out or "")
end
end


-- Explicit entrypoint for skill pages.
-- -----------------------------------------------------------------------------
-- Public entrypoints
-- -----------------------------------------------------------------------------
 
function p.Skills(frame)
function p.Skills(frame)
frame = frame or mw.getCurrentFrame()
frame = frame or mw.getCurrentFrame()
return _invoke_submodule(frame, "Module:GameInfo/Skills")
return _invoke(frame, ROUTES.Skills)
end
end


-- Generic entrypoint for category pages (not limited to Skills).
-- Usage:
--  {{#invoke:GameInfo|Category|name=Skills|...}}
-- If name matches ROUTES, we use that mapping.
-- Otherwise, we attempt Module:GameInfo/<name> (safe, limited characters).
function p.Category(frame)
function p.Category(frame)
frame = frame or mw.getCurrentFrame()
frame = frame or mw.getCurrentFrame()
 
local name = p.arg(frame, "name", p.arg(frame, "category", nil))
local name = _get_name(frame)
if not name or name == "" then
if not name or name == "" then
return _error_box("GameInfo.Category: missing |name=CategoryName")
return p.styles(frame) .. _error_box("GameInfo.Category: missing |name=")
end
end


-- First: known route table (exact match).
local module_title = ROUTES[name]
local module_title = ROUTES[name]
-- Second: case-insensitive match on known routes.
if not module_title and mw.ustring then
local want = mw.ustring.lower(name)
for k, v in pairs(ROUTES) do
if mw.ustring.lower(k) == want then
module_title = v
break
end
end
end
-- Third: dynamic fallback to Module:GameInfo/<name>
if not module_title then
if not module_title then
-- Allow letters, numbers, spaces, underscores, hyphens, and slashes.
return p.styles(frame) .. _error_box("GameInfo.Category: unsupported name=" .. tostring(name))
-- (Spaces are fine in page titles; MediaWiki normalizes.)
if not tostring(name):match("^[%w %_%-/]+$") then
return _error_box("GameInfo.Category: invalid name=" .. tostring(name))
end
module_title = "Module:GameInfo/" .. tostring(name)
end
end


return _invoke_submodule(frame, module_title)
return _invoke(frame, module_title)
end
end


-- Optional: #invoke test entrypoint to verify box + CSS wiring.
-- Optional: sanity test for box + CSS wiring
-- {{#invoke:GameInfo|skeleton|id=sv-gi-test-1|level=1|max=10}}
-- {{#invoke:GameInfo|skeleton|id=sv-gi-test-1|level=1|max=10|variant=skills}}
function p.skeleton(frame)
function p.skeleton(frame)
frame = frame or mw.getCurrentFrame()
frame = frame or mw.getCurrentFrame()


local id = _get_arg(frame, "id") or "sv-gi-skeleton-1"
local id = p.arg(frame, "id", "sv-gi-skeleton-1")
local level = _get_arg(frame, "level") or _get_arg(frame, "data_level") or 1
local level = p.int(frame, "level", 1, 1, 999)
local max_level = _get_arg(frame, "max") or _get_arg(frame, "max_level") or 10
local max_level = p.int(frame, "max", 10, 1, 999)
local variant = _get_arg(frame, "variant")
local variant = p.arg(frame, "variant", nil)


local top = mw.html.create("div"):wikitext("GameInfo Top (locked container)")
local top = mw.html.create("div"):wikitext("GameInfo Top (locked container)")
Line 250: Line 222:


return p.styles(frame) .. p.render_box({
return p.styles(frame) .. p.render_box({
root_id = id,
id = id,
level = level,
level = level,
max_level = max_level,
max_level = max_level,
Retrieved from "https://spiritvale.info/wiki/Module:GameInfo"