Module:Sandbox/Vergir: Difference between revisions

From The Deadlock Wiki
Jump to navigation Jump to search
Browse history interactively
← Older editNewer edit →

~2026-TierDashFortitude831 (talk)

13 edits
undo
m Mgpt moved page Module:Vergir to Module:Sandbox/Vergir: Deadlock:User pages
Throwaway test: how mw.ext.tabber.render handles HTML in a tab label (with help from vergir-bot LLM)
Tag: Replaced
Line 1: Line 1:
-- Provides generic access to game data files
-- Throwaway experiment. Checks how mw.ext.tabber.render treats a tab label that
-- contains HTML, which is what an untranslated string looks like once
-- Module:Dictionary appends Template:NeedsTranslationTooltip to it.
--
-- On a /ru page: 'Notes' has a Russian value, so its label is plain text.
-- 'Music' is English-only, so its label arrives with the tooltip markup attached.


local p = {}
local p = {}
local dictionary = require("Module:Dictionary")


-- Dataset descriptors. Values are the data file paths passed to mw.loadJsonData.
function p.test(frame)
-- Callers should use these constants rather than raw strings.
local tabs = {
p.Dataset = {
{ label = dictionary.translate('Notes'), content = 'panel one' },
    ITEMS    = "Data:ItemData.json",
{ label = dictionary.translate('Music'), content = 'panel two' },
    ABILITIES = "Data:AbilityData.json",
}
    HEROES    = "Data:HeroData.json",
return mw.ext.tabber.render(tabs)
    CONVARS  = "Data:Convars.json",
}
 
-- Street Brawl ships a partial overlay of ability properties rather than a full
-- dataset, so it is deliberately kept out of p.Dataset: its top-level keys are
-- sections ("ability-changes", "item-buckets"), not entity records, and it is
-- not usable with get_entities. Only get_prop consults it.
local STREET_BRAWL = "Data:StreetBrawlData.json"
 
-- Returns true if a record represents an active, usable entity.
-- Applies consistently across all datasets:
--  - IsDisabled must not be true
--  - Name must not be nil
--  - IsSelectable, if present, must not be false
 
-- Specifically for hero abilities, some of them are split into two entities, eg. Vexing Bolt has a sub-ability: Redirect Bolt.
-- The secondary sub-abilities most often have nil name and get filtered out by this function
local function is_active(record)
    if record["IsDisabled"] == true then return false end
    if record["Name"] == nil then return false end
    if record["IsSelectable"] ~= nil and record["IsSelectable"] == false then return false end
    return true
end
 
-- Recursively searches a record for a match against prop, which may be:
--  - a key name: matches if the key exists with a non-zero/non-empty value
--  - a plain value: matches if the string appears as a value anywhere in the record
-- Returns true if a match is found, false otherwise.
local function record_matches_prop(record, prop)
    for k, v in pairs(record) do
        -- Key match: property name exists with a meaningful value
        if k == prop then
            if type(v) == "table" then
                if v["Value"] ~= nil then
                    v = v["Value"]
                else
                    for _ in pairs(v) do return true end
                    return false
                end
            end
            if v ~= nil and v ~= 0 and v ~= "" and v ~= "0" and v ~= "0m" then
                return true
            end
        end
        if type(v) == "table" and k ~= "DisabledStateMask" then
            if record_matches_prop(v, prop) then return true end
        elseif type(v) == "string" then
            -- Value match: prop string appears as a value (e.g. Scale.Type = "melee")
            if v == prop then return true end
        end
    end
    return false
end
 
-- Returns true if a record matches at least one of the given properties,
-- using the same key-name-or-string-value semantics as get_entities.
-- Public so other modules (e.g. Module:AbilityTable membership) can reuse it.
function p.entity_matches(record, properties)
    for _, prop in ipairs(properties) do
        if record_matches_prop(record, prop) then
            return true
        end
    end
    return false
end
 
-- Returns all active entities from a dataset that match at least one of the
-- given properties. A property may be matched either as a key name (the
-- property exists with a non-zero value) or as a plain string value anywhere
-- in the record (e.g. "melee" matching Scale.Type = "melee").
-- @param  dataset    string  one of the GameData.Dataset constants
-- @param  properties  table  array of property strings
-- @return              table  array of matching entity records
function p.get_entities(dataset, properties)
    local data = mw.loadJsonData(dataset)
    local results = {}
 
    for _, record in pairs(data) do
        if is_active(record) and p.entity_matches(record, properties) then
            table.insert(results, record)
        end
    end
 
    return results
end
 
--------------------------------------------------------------------------------
-- Unified property lookup: get_prop
-- Uses ResourceLookup to route directly to the correct dataset.
-- Returns raw values for use in templates and expressions.
--------------------------------------------------------------------------------
 
-- Find an entity by display name or internal key.
-- Uses ResourceLookup type field to go directly to the right dataset.
-- Returns (entity_record, type_string, internal_key) or (nil, nil, nil).
local function find_entity(identifier)
    local resource = mw.loadJsonData("Data:ResourceLookup.json")[identifier:lower()]
    if resource then
        local data
        if resource.type == "ability" then
            data = mw.loadJsonData(p.Dataset.ABILITIES)
        elseif resource.type == "hero" then
            data = mw.loadJsonData(p.Dataset.HEROES)
        elseif resource.type == "item" then
            data = mw.loadJsonData(p.Dataset.ITEMS)
        end
        if data and data[resource.key] then
            return data[resource.key], resource.type, resource.key
        end
    end
 
    -- Fallback: try as direct internal key
    local datasets = {
        { p.Dataset.ABILITIES, "ability" },
        { p.Dataset.HEROES,    "hero" },
        { p.Dataset.ITEMS,    "item" },
    }
    for _, ds in ipairs(datasets) do
        local data = mw.loadJsonData(ds[1])
        if data[identifier] then return data[identifier], ds[2], identifier end
    end
 
    return nil, nil, nil
end
 
-- Traverse a table using dot notation, unwrap tables with a .Value field.
-- Supports numeric indices for arrays (e.g. "Upgrades.1.WeaponDamageBonus").
local function resolve_prop(tbl, prop)
    if not prop or prop == "" then return nil end
    local element = tbl
    for segment in string.gmatch(prop, "[^%.]+") do
        if type(element) ~= "table" then return nil end
        local next = element[segment]
        if next == nil then
            local num = tonumber(segment)
            if num then next = element[num] end
        end
        element = next
        if element == nil then return nil end
    end
    if type(element) == "table" then
        return element.Value or ""
    end
    return element
end
 
-- Looks up a console variable in Data:Convars.json. A convar value is stored
-- either as a plain scalar (e.g. "adsp_alley_min": 122) or as a table holding
-- the value plus a description (e.g. { value = 75, description = "..." }), in
-- which case only the value is returned. The exact key is tried first, then a
-- lower-case form. Returns (value, found).
local function lookup_convar(key)
    local data = mw.loadJsonData(p.Dataset.CONVARS)
    local entry = data[key]
    if entry == nil then
        entry = data[mw.ustring.lower(key)]
    end
    if entry == nil then
        return nil, false
    end
    if type(entry) == "table" then
        return entry.value, true
    end
    return entry, true
end
 
-- {{#invoke:GameData|get_prop|...}}
-- Two modes:
--  Entity:  {{#invoke:GameData|get_prop|ENTITY_NAME|PROPERTY|VARIANT}}
--            Finds entity via ResourceLookup, returns the raw value (no
--            formatting). Supports dot notation for nested properties
--            (e.g. "Scale.Value"); tables with a .Value field are unwrapped.
--            The optional VARIANT selects a game mode variant. "Street Brawl"
--            (case and spacing insensitive) returns the value changed for
--            Street Brawl, falling back to the base value when Street Brawl
--            does not change that property.
--  Convar:  {{#invoke:GameData|get_prop|Convar|CONVAR_NAME}}
--            Looks up the convar in Data:Convars.json and returns its value,
--            unwrapping the { value, description } form when present.
function p.get_prop(frame)
    local arg1 = frame.args[1]
    local arg2 = frame.args[2]
    local arg3 = frame.args[3]
    if not arg1 then return "" end
 
    -- Convar mode: first argument is the literal keyword "Convar".
    if mw.ustring.lower(arg1) == "convar" then
        if not arg2 or arg2 == "" then return "" end
        local value, found = lookup_convar(arg2)
        if not found then
            return '<span style="color:red;">Convar not found: ' .. arg2 .. '</span>'
        end
        if value == nil then return "" end
        return value
    end
 
    -- Entity mode: search abilities, heroes, and items.
    local name = arg1
    local prop = arg2
    if not prop then return "" end
 
    local entity, etype, ekey = find_entity(name)
    if not entity then
        return '<span style="color:red;">Entity not found: ' .. name .. '</span>'
    end
 
    -- Street Brawl changes a handful of ability properties. The overlay lists
    -- only what changed, so a miss here just means "unchanged" and the base
    -- record answers instead. That includes the empty string resolve_prop
    -- returns for a table with no Value field: the overlay records are partial,
    -- so an overridden table often holds nothing but a nested Scale.
    if arg3 and arg3 ~= "" then
        local mode = mw.ustring.lower(mw.text.trim(arg3))
        mode = mode:gsub("%s+", "")
        if mode ~= "streetbrawl" then
            return '<span style="color:red;">Unknown variant: ' .. arg3 .. '</span>'
        end
        if etype == "ability" then
            local changed = mw.loadJsonData(STREET_BRAWL)["ability-changes"][ekey]
            if changed then
                local value = resolve_prop(changed, prop)
                if value ~= nil and value ~= "" then return value end
            end
        end
    end
 
    local result = resolve_prop(entity, prop)
    if result ~= nil then return result end
 
    return '<span style="color:red;">Prop not found: ' .. name .. '/' .. prop .. '</span>'
end
end


return p
return p

Revision as of 21:04, 1 August 2026

Documentation for this module may be created at Module:Sandbox/Vergir/doc 

-- Throwaway experiment. Checks how mw.ext.tabber.render treats a tab label that
-- contains HTML, which is what an untranslated string looks like once
-- Module:Dictionary appends Template:NeedsTranslationTooltip to it.
--
-- On a /ru page: 'Notes' has a Russian value, so its label is plain text.
-- 'Music' is English-only, so its label arrives with the tooltip markup attached.

local p = {}
local dictionary = require("Module:Dictionary")

function p.test(frame)
	local tabs = {
		{ label = dictionary.translate('Notes'), content = 'panel one' },
		{ label = dictionary.translate('Music'), content = 'panel two' },
	}
	return mw.ext.tabber.render(tabs)
end

return p
Retrieved from "https://deadlock.wiki/Module:Sandbox/Vergir?oldid=104683"