Module:Test

This module is used for development.

Purpose

This module is used to query information from the uploaded and parsed game files.

Its main purpose is to populate the infoboxes.

Usage

A note on the order of named parameters. All of the parameters that look like ...=... are called named parameters and their order is not important (this is true for all templates).

query

{{#invoke:Test|query|<def ID>[|...|][|tag|][|sibling=...]}}

The work-horse. Output varies based on use:

If only the <def ID> parameter is set, it will show the whole Def in the log.

If simple values are queried it will return them.

If lists are queried it will return nothing but call {{#vardefine}} on all the simple values within it. What got defined can be seen in the page's log.

Named parameters:

<def ID>

This parameter identifies the Def so it is mandatory. It can take two forms, if both are defined then defName takes preference.

defName=<defName>

<defName> (case sensitive) should be replaced with the actual defName of a Def.

label=<label>

<label> (case insensitive) should be replaced with the actual label of a Def.

[sibling=...] (optional) (case sensitive)

Allows querying for something if we know its sibling's value (works only for values at the moment).

Anonymous parameters:

[|...|] (optional) (case sensitive)

Anonymous paramaters before the last one ([tag]) are here to help uniquely identify it. If the [tag] is already unique within a Def tree, then these additional parameters are not needed.

[|tag|] (optional) (case sensitive)

The final anonymous parameter defines what is to be queried.

count

{{#invoke:Test|count|<def ID>[|...|][|tag|][|sibling=...]}}

Parameters are the same as for query. It's basically a wrapped up query that behaves a bit differently.

The difference is in how it handles lists. If a list is queried, unlike query, it will return the length of the list.

How-to

Take a look at a Def

{{#invoke:Test|query|label=desert}}

Data is in the log.

Retrieve a simple value

{{#invoke:Test|query|defName=Caribou|description}}

Dealing with lists

{{#invoke:Test|query|defName=Mech_Scyther|tools}}

When a list is retrieved there will be no output but the log will contain a list of defined variables.

For convenience the list is reprinted here:

tools_1_linkedBodyPartsGroup = LeftBlade
tools_1_cooldownTime = 2
tools_1_label = left blade
tools_1_DPS = 10
tools_1_power = 20
tools_1_capacities_1 = Cut
tools_1_capacities_2 = Stab
tools_2_linkedBodyPartsGroup = RightBlade
tools_2_cooldownTime = 2
tools_2_label = right blade
tools_2_DPS = 10
tools_2_power = 20
tools_2_capacities_1 = Cut
tools_2_capacities_2 = Stab
tools_3_linkedBodyPartsGroup = HeadAttackTool
tools_3_capacities_1 = Blunt
tools_3_label = head
tools_3_DPS = 4.5
tools_3_chanceFactor = 0.2
tools_3_power = 9
tools_3_cooldownTime = 2

All of the above can be accessed with the use of {{#var:...}}.

{{#var:tools_1_DPS}}

DPS is not a normal member of this table but has been added with Lua. Let's call it a virtual field.

Retrieve something if a sibling is known

{{#invoke:Test|query|label=guinea pig|minAge|sibling=AnimalAdult}}

---

---@diagnostic disable: lowercase-global
local p = {}

frame = mw.getCurrentFrame()
util = require("Module:Test/lib/util")
search = require("Module:Test/lib/search")
data = mw.loadData('Module:Test/data')

------------------
-- virtual keys --
------------------

local virtual_store = {}
local virtual_keys = {
  ["Pawn"] = {

    function (def)
      virtField = "lives_in"
      biomes = {}
      for k,v in pairs(data) do
        prefix = string.match(k, '(.+):')
        if prefix == "BiomeDef" then
          table.insert(biomes, v)
        end
      end

      local list = {}
      for _,biome in pairs(biomes) do
        for animal,_ in pairs(biome.wildAnimals or {}) do
          if def.defName == animal then
            table.insert(list, biome.label)
          end
        end
      end

      if #list > 0 then
        def._virtual_[virtField] = list
      end
    end,

    function (def)
      virtField = "diet"
      diet = def.race.foodType
      flags = {}
      virtual_store.diet = {}

      for _,foodType in ipairs(diet) do
        if type(util.diet.foodType[foodType]) == "boolean" then
          flags[foodType] = true
        else
          for foodItem,_ in pairs(util.diet.foodType[foodType]) do
            flags[foodItem] = true
          end
        end
      end

      for flag,_ in pairs(flags) do
        table.insert(virtual_store.diet, flag)
      end

      if #virtual_store.diet > 0 then
        def._virtual_[virtField] = virtual_store.diet
      end
    end,

  }
}

-----------------------
-- private functions --
-----------------------

local function vardefine(name, value)
  assert(name, "vardefine: missing argument #1 (variable to definePrefix)")
  assert(type(name) == "string", string.format("vardefine: bad argument #1 (string expected, got %s)", type(name)))
  assert(value, "vardefine: missing argument #2 (value to assign)")
  assert(value == "string" or value == "number" or value =="boolean", string.format("vardefine: bad argument #2 (string, number or boolean expected, got %s)", type(value)))
  frame:callParserFunction('#vardefine', name, value)
end

local function mergeParents(baseDef, ignoreKeys)
  local ancestorIDs = {}
  local mergedDef = {}
  local def = baseDef

  while def._.ParentName do
    local parentID = def._.DefCategory .. ":" .. def._.ParentName
    table.insert(ancestorIDs, parentID)
    def = data[parentID]
  end

  ancestorIDs = util.table.reverse(ancestorIDs)
  table.insert(ancestorIDs, baseDef._.DefCategory .. ":" .. baseDef.defName)

  for _,parentID in ipairs(ancestorIDs) do
    util.table.overwrite(mergedDef, data[parentID], ignoreKeys)
  end

  return mergedDef
end

local function getByDefName(defIDsuffix, defIDprefix)
  local ignoreKeys = {"Abstract", "Name", "ParentName"}
  local baseDef
  local mergedDef

  if defIDprefix then
    local defID = defIDprefix .. ":" .. defIDsuffix
    baseDef = data[defID]
    assert(not baseDef, string.format("getByDefName: Def '%s' not found", defID))
  else
    for defID,def in pairs(data) do
      -- WARNING: this depends on there not being any preexisting colons in the relevant substrings
      prefix = string.match(defID, '(.+):')
      suffix = string.match(defID, ':(.+)')
      if suffix == defIDsuffix then
        assert(not baseDef, string.format("getByDefName: Def conflict (more than one '%s')", defIDsuffix))
        baseDef = def
      end
    end
    if not baseDef then
      -- mw.log(string.format("getByDefName: Def '%s' not found", defIDsuffix))
      return nil
    end
  end

  mergedDef = mergeParents(baseDef, ignoreKeys)

  if virtual_keys[mergedDef.category] then
    mergedDef._virtual_ = {}
    for k,func in ipairs(virtual_keys[mergedDef.category]) do
      func(mergedDef)
    end
  end

  return mergedDef
end

local function getByLabel(label)
  local defName
  local def

  if not label then return nil end

  for defID,def in pairs(data) do
    if string.upper(def.label or "") == string.upper(label) then
      defName = def.defName
    end
  end

  if defName then
    return getByDefName(defName)
  else
    return nil
  end
end

local function setPrefix(tbl, parentKey)
  local mt = getmetatable(tbl) or {}

  for k,v in pairs(tbl) do
    local prefix = parentKey .. "_" .. k
    if type(v) == 'table' then
      setPrefix(v, prefix)
    else
      mt[k] = prefix
    end
  end

  setmetatable(tbl, mt)
end

local function definePrefixed(tbl)
  for k,v in pairs(tbl) do
    if type(v) ~= 'table' then
      local mt = getmetatable(tbl)
      mw.log(string.format("%s = %s", mt[k], v))
      if ENV == "wiki" then vardefine(mt[k], v) end
    else 
      definePrefixed(v)
    end
  end
end

----------------------
-- public interface --
----------------------

function p.getDefName(frame)
  local defName
  local label = frame.args[1]

  if not label then
    mw.logObject(frame.args, "frame.args")
    mw.log("getDefName: missing argument #1 (label)")
    return nil
  end

  for defID,def in pairs(data) do
    if string.upper(def.label or "") == string.upper(label) then
      defName = def.defName
    end
  end

  if not defName then
    mw.logObject(frame.args, "frame.args")
    mw.log(string.format("getDefName: '%s' not found", label))
  end

  return defName
end

function p.describe(frame)
  local query = p.query(frame)
  if type(query) == 'table' then
    return #query
  else
    return type(query)
  end
end

function p.query(frame)
  local argLen = util.table.count(frame.args, "number") -- #frame.args won't work as expected, check the doc
  local def = getByDefName(frame.args['defName']) or getByLabel(frame.args['label'])

  if not def then
    mw.logObject(frame.args, "frame.args")
    mw.log(string.format("query: Def not found"))
    return nil
  end
  
  if def and argLen == 0 then
    mw.logObject(def)
    return nil
  end

  local prune = def

  for i,arg in ipairs(frame.args) do -- arguments
    arg = tonumber(arg) or arg -- frame.args are always strings on MediaWiki so convert back the numbers

    if i == argLen and frame.args["sibling"] then
      prune = search.conductor({nil, frame.args["sibling"]} , prune)
      if not prune then
        mw.logObject(frame.args, "frame.args")
        mw.log(string.format("query: bad argument 'sibling' ('%s' not found in '%s')", frame.args["sibling"], frame.args[i-1]))
        return nil
      else
        prune = prune.parent.table[arg]
        if not prune then
          mw.logObject(frame.args, "frame.args")
          mw.log(string.format("query: bad argument #%i ('%s' is not a sibling of '%s')", i, arg, frame.args["sibling"]))
          return nil
        end
      end
    end

    if i == argLen and not frame.args["sibling"] then
      prune = search.conductor(arg, prune)
      if not prune then
        mw.logObject(frame.args, "frame.args")
        mw.log(string.format("query: bad argument #%i ('%s' not found in '%s')", i, frame.args[i], frame.args[i-1]))
        return nil
      else
        prune = prune.value
      end
    end

    if i < argLen then
      prune = search.conductor(arg, prune)
      if not prune then
        mw.logObject(frame.args, "frame.args")
        mw.log(string.format("query: bad argument #%i ('%s' not found in '%s')", i, frame.args[i], frame.args[i-1]))
        return nil
      else
        prune = prune.value
        if type(prune) ~= 'table' then
          return prune
        end
      end
    end

  end -- for arguments

  if type(prune) == "table" then
    setPrefix(prune, frame.args[argLen])
    definePrefixed(prune)
    return nil
  end

  return prune
end


local clock = string.format("os.clock(): %i ms", os.clock() * 1000)
mw.log("--" .. string.rep("-", #clock) .. "--")
mw.log("- " .. clock .. " -")
mw.log("--" .. string.rep("-", #clock) .. "--")

----------------------------------------
-- simulate wiki log while developing --
----------------------------------------

if ENV == "dev" then
  util.hl("log")
  for _,v in ipairs(log) do
    print(v)
  end
end

return p -- return module