Difference between revisions of "Module:Test"

From RimWorld Wiki
Jump to navigation Jump to search
Line 3: Line 3:
 
---------------
 
---------------
  
-- wiki --
+
-- wiki environment --
 +
 
 
local Biomes = mw.loadData('Module:Test/data/biomes')
 
local Biomes = mw.loadData('Module:Test/data/biomes')
 
--local Buildings = mw.loadData('Module:Test/data/buildings')
 
--local Buildings = mw.loadData('Module:Test/data/buildings')
 
local Races = mw.loadData('Module:Test/data/races')
 
local Races = mw.loadData('Module:Test/data/races')
  
-- dev --
+
-- dev environment --
 +
 
 
--local Biomes = loadfile("./data/BiomeDefs.lua")()
 
--local Biomes = loadfile("./data/BiomeDefs.lua")()
 
--local Buildings = loadfile("./data/ThingDefs_Buildings.lua")()
 
--local Buildings = loadfile("./data/ThingDefs_Buildings.lua")()
 
--local Races = loadfile("./data/ThingDefs_Races.lua")()
 
--local Races = loadfile("./data/ThingDefs_Races.lua")()
 +
 +
-- aggregate the categories --
  
 
local data = {}
 
local data = {}
Line 17: Line 21:
 
--data["Buildings"] = Buildings
 
--data["Buildings"] = Buildings
 
data["Races"] = Races
 
data["Races"] = Races
 +
 +
------------------------
 +
-- pretty print table --
 +
------------------------
 +
 +
--[[ procedure: tprint ]]--
 +
 +
function tprint (tbl, indent)
 +
  if not indent then indent = 0 end
 +
  for k, v in pairs(tbl) do
 +
    formatting = string.rep("  ", indent) .. k .. ": "
 +
    if type(v) == "table" then
 +
      print(formatting)
 +
      tprint(v, indent+1)
 +
    elseif type(v) == 'boolean' then
 +
      print(formatting .. tostring(v))
 +
    else
 +
      print(formatting .. v)
 +
    end
 +
  end
 +
end
 +
 +
--[[ function: shallowcopy ]]--
 +
 +
function shallowcopy(original_table)
 +
    local orig_type = type(original_table)
 +
    local copy
 +
    if orig_type == 'table' then
 +
        copy = {}
 +
        for orig_key, orig_value in pairs(original_table) do
 +
            copy[orig_key] = orig_value
 +
        end
 +
    else -- number, string, boolean, etc
 +
        copy = original_table
 +
    end
 +
    return copy
 +
end
 +
 +
--[[ function: reverse_numeric_table ]]--
 +
 +
function reverse_numeric_table(tbl)
 +
    local reversed_table = {}
 +
    local length = #tbl
 +
    for i,v in ipairs(tbl) do
 +
        reversed_table[length + 1 - i] = v
 +
    end
 +
    return reversed_table
 +
end
  
 
-----------------------------
 
-----------------------------
Line 22: Line 74:
 
-----------------------------
 
-----------------------------
  
-- returns the value (or nothing) found by first occurrence of a key within a table
+
--[[ function: find_key_name_of_value ]]--
local function search_table_recursive(key, table)
+
local function find_key_name_of_value(value, tbl)
   for k, v in pairs(table) do
+
  for k,v in pairs(tbl) do
 +
    if v == value then return k end
 +
  end
 +
end
 +
 
 +
--[[ function: search_table_recursive ]]--
 +
 
 +
-- returns the value found by first occurrence of a key within a table (recursive)
 +
local function search_table_recursive(key, tbl)
 +
   for k, v in pairs(tbl) do
 
     if k == key then return v
 
     if k == key then return v
 
     elseif type(v) == "table" then
 
     elseif type(v) == "table" then
Line 33: Line 94:
 
end
 
end
  
-- returns the immediate parent table (or nothing) of an element specified by a key and its value
+
--[[ function: find_parent_table ]]--
local function find_parent_table(key, value, table)
+
 
   for k, v in pairs(table) do
+
-- returns the parent table of an element specified by key, value (recursive)
     if k == key and v == value then return table
+
local function find_parent_table(key, value, tbl)
 +
   for k, v in pairs(tbl) do
 +
     if k == key and v == value then return tbl
 
     elseif type(v) == "table" then
 
     elseif type(v) == "table" then
 
       local found = find_parent_table(key, value, v)
 
       local found = find_parent_table(key, value, v)
Line 44: Line 107:
 
end
 
end
  
local function getParentName(defTable)
+
--[[ procedure: vardefine ]]--
  return defTable["ParentName"]
 
end
 
 
 
-- '#' operator seems to work for numerically indexed tables so it can be used instead
 
-- this count function counts all the keys (of any type)
 
local function count(table)
 
  if type(table) ~= "table" then
 
    return "count(table): argument #1 is not a table"
 
  else
 
    local length = 0;
 
    for i, v in pairs(table) do
 
      length = length + 1
 
    end
 
    return length
 
  end
 
end
 
 
 
-- "delimiter" must be a single character or the removal of the final delimiter won't work
 
-- it's simpler this way but it could be reworked to enable multi-byte delimiters
 
local function format_csv_string(simple_table, delimiter)
 
  local list = ""
 
 
 
    for k,v in pairs(simple_table) do
 
      list = list .. v .. delimiter
 
    end
 
    if string.sub(list, -1) == delimiter then
 
      list = string.sub(list, 1, -2)
 
    end
 
    return list
 
end
 
  
 
local function vardefine(var_name, var_value)
 
local function vardefine(var_name, var_value)
Line 86: Line 119:
 
end
 
end
  
------------------
+
--[[ procedure: overwrite_first_table_with_second ]]--
-- search logic --
+
 
------------------
+
local function overwrite_first_table_with_second(first_table, second_table, ignore_keys)
 +
  ignore_keys = ignore_keys or {}
 +
 
 +
  for k,v in pairs(second_table) do
 +
    local ignore = false
 +
 
 +
    for _, ignored_key in ipairs(ignore_keys) do
 +
      if k == ignored_key then ignore = true end
 +
    end
 +
 
 +
    if not ignore then
 +
      if type(v) == "table" then
 +
        if type(first_table[k]) == "table" then
 +
          overwrite_first_table_with_second(first_table[k], v)
 +
        else
 +
          first_table[k] = {}
 +
          overwrite_first_table_with_second(first_table[k], v)
 +
        end
 +
      else
 +
        first_table[k] = v
 +
      end
 +
    end
 +
  end
 +
end
 +
 
 +
----------------------
 +
-- dataset specific --
 +
----------------------
 +
 
 +
--[[ function: find_def_table ]]--
  
local function find_defTable(def)
+
local function find_def_table(def)
 +
  -- hidden variables: data
 
   for k1,v1 in pairs(data) do
 
   for k1,v1 in pairs(data) do
 
     if type(v1) == "table" then
 
     if type(v1) == "table" then
Line 100: Line 163:
 
end
 
end
  
local function searchParentDef(key, defTable)
+
local function find_def_category_table(def)
  local ParentName = getParentName(defTable)
+
  for k1,v1 in pairs(data) do
  if not ParentName then return nil end
+
    if type(v1) == "table" then
   local parentDefTable = search_table_recursive(ParentName, data)
+
      for k2,v2 in pairs(v1) do
   if not parentDefTable then return nil end
+
        if k2 == def then return v1 end
 +
      end
 +
    end
 +
   end
 +
end
 +
 
 +
--[[ function: merge_def_with_parents ]]--
 +
 
 +
local function merge_def_with_parents(def, ignore_keys)
 +
  -- hidden variables: ParentName and global data
 +
 
 +
  local def_table = find_def_table(def)
 +
  local def_category_table = find_def_category_table(def)
 +
   local parent_names = {}
 +
  local parent_name = def_table["ParentName"]
 +
  local parent_table = def_category_table[parent_name]
  
   local found = search_table_recursive(key, parentDefTable)
+
   while parent_name do
  if found then return found
+
    table.insert(parent_names, parent_name)
  else
+
     parent_name = parent_table["ParentName"]
     found = searchParentDef(key, parentDefTable)
+
     parent_table = def_category_table[parent_name]
     if found then return found end
 
 
   end
 
   end
 +
 +
  local inheritance_chain = shallowcopy(reverse_numeric_table(parent_names))
 +
  table.insert(inheritance_chain, def)
 +
 +
  local merged = {}
 +
  local chain_length = #inheritance_chain
 +
  for i,v in ipairs(inheritance_chain) do
 +
    overwrite_first_table_with_second(merged, def_category_table[inheritance_chain[i]], ignore_keys)
 +
  end
 +
 +
  return merged
 
end
 
end
  
Line 122: Line 210:
 
function p.query(frame)
 
function p.query(frame)
 
   local fName = debug.getinfo(1,"n").name
 
   local fName = debug.getinfo(1,"n").name
  assert(frame.args[1], string.format("bad argument #1 to '%s' (argument missing, def)", fName))
 
  assert(frame.args[2], string.format("bad argument #2 to '%s' (argument missing)", fName))
 
  
   local defTable = find_defTable(frame.args[1], data)
+
   if not (frame.args["defName"] or frame.args["label"]) then
  if not defTable then
+
     assert(frame.args["defName"], string.format("bad argument to '%s' (missing named argument 'defName' or 'label' needed to find a Def)", fName))
     return "'" .. frame.args[1] .. "' not found"
 
 
   end
 
   end
  
   local found = search_table_recursive(frame.args[2], defTable)
+
   local def_table
  if not found then
+
  if frame.args["defName"] then
    found = searchParentDef(frame.args[2], defTable)
+
    def_table = find_def_table(frame.args["defName"])
     if not found then
+
    if def_table then
      return "'" .. frame.args[2] .. "'" .. " not found in '" .. frame.args[1] .. "'"
+
      def_table = merge_def_with_parents(frame.args["defName"], {"ParentName", "Abstract"})
 +
     end
 +
  end
 +
  if not def_table then
 +
    def_table = find_parent_table(find_key_name_of_value(frame.args["label"], frame.args), frame.args["label"], data["Races"])
 +
    if def_table then
 +
      def_table = merge_def_with_parents(def_table["defName"], {"ParentName", "Abstract"})
 
     end
 
     end
 
   end
 
   end
  
   -- multi-step query
+
  assert(def_table, "Def not found")
 +
 
 +
   -- if there are no numeric arguments, output the def to log
 +
  local args_length = #frame.args
 +
  if args_length == 0 then
 +
    tprint(def_table)
 +
  end
 +
 
 +
  -- get filtered data based on numeric arguments
 +
  local filtered = def_table
 
   for i,v in ipairs(frame.args) do
 
   for i,v in ipairs(frame.args) do
     if i > 2 then
+
    filtered = search_table_recursive(v, filtered)
       found = search_table_recursive(v, found)
+
     if type(filtered) == "string" or type(filtered) == "number" and i < args_length then
 +
       error(string.format("too many numeric arguments to '%s' (string, number or boolean already found)", fName), 0)
 
     end
 
     end
 
   end
 
   end
  
   return found
+
   return filtered
 
end
 
end
  
Line 152: Line 253:
 
-------------
 
-------------
  
mw.log("Module:DefInfo:os.clock() " .. os.clock()*1000 .. " ms")
+
--mw.log("Module:DefInfo:os.clock() " .. os.clock()*1000 .. " ms")
--print("Module:DefInfo:os.clock() " .. os.clock()*1000 .. " ms")
+
print("Module:DefInfo:os.clock() " .. os.clock()*1000 .. " ms")
  
 
return p
 
return p

Revision as of 23:42, 9 April 2021

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}}

Lua error at line 256: attempt to call global 'print' (a nil value).

Data is in the log.

Retrieve a simple value

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

Lua error at line 256: attempt to call global 'print' (a nil value).

Dealing with lists

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

Lua error at line 256: attempt to call global 'print' (a nil value).

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}}

Lua error at line 256: attempt to call global 'print' (a nil value).


---------------
-- load data --
---------------

-- wiki environment --

local Biomes = mw.loadData('Module:Test/data/biomes')
--local Buildings = mw.loadData('Module:Test/data/buildings')
local Races = mw.loadData('Module:Test/data/races')

-- dev environment --

--local Biomes = loadfile("./data/BiomeDefs.lua")()
--local Buildings = loadfile("./data/ThingDefs_Buildings.lua")()
--local Races = loadfile("./data/ThingDefs_Races.lua")()

-- aggregate the categories --

local data = {}
data["Biomes"] = Biomes
--data["Buildings"] = Buildings
data["Races"] = Races

------------------------
-- pretty print table --
------------------------

--[[ procedure: tprint ]]--

function tprint (tbl, indent)
  if not indent then indent = 0 end
  for k, v in pairs(tbl) do
    formatting = string.rep("  ", indent) .. k .. ": "
    if type(v) == "table" then
      print(formatting)
      tprint(v, indent+1)
    elseif type(v) == 'boolean' then
      print(formatting .. tostring(v))
    else
      print(formatting .. v)
    end
  end
end

--[[ function: shallowcopy ]]--

function shallowcopy(original_table)
    local orig_type = type(original_table)
    local copy
    if orig_type == 'table' then
        copy = {}
        for orig_key, orig_value in pairs(original_table) do
            copy[orig_key] = orig_value
        end
    else -- number, string, boolean, etc
        copy = original_table
    end
    return copy
end

--[[ function: reverse_numeric_table ]]--

function reverse_numeric_table(tbl)
    local reversed_table = {}
    local length = #tbl
    for i,v in ipairs(tbl) do
        reversed_table[length + 1 - i] = v
    end
    return reversed_table
end

-----------------------------
-- small utility functions --
-----------------------------

--[[ function: find_key_name_of_value ]]--
local function find_key_name_of_value(value, tbl)
  for k,v in pairs(tbl) do
    if v == value then return k end
  end
end

--[[ function: search_table_recursive ]]--

-- returns the value found by first occurrence of a key within a table (recursive)
local function search_table_recursive(key, tbl)
  for k, v in pairs(tbl) do
    if k == key then return v
    elseif type(v) == "table" then
      local found = search_table_recursive(key, v)
      if found then return found end
    end
  end
end

--[[ function: find_parent_table ]]--

-- returns the parent table of an element specified by key, value (recursive)
local function find_parent_table(key, value, tbl)
  for k, v in pairs(tbl) do
    if k == key and v == value then return tbl
    elseif type(v) == "table" then
      local found = find_parent_table(key, value, v)
      if found then return found end
    end
  end
end

--[[ procedure: vardefine ]]--

local function vardefine(var_name, var_value)
  local fName = debug.getinfo(1,"n").name
  assert(var_name, string.format("bad argument #1 to '%s' (argument missing, name of variable to define)", fName))
  assert(var_name == "string", string.format("bad argument #1 to '%s' (string expected, got %s)", fName, type(var_name)))
  assert(var_value, string.format("bad argument #2 to '%s' (argument missing, value to assign to variable)", fName))
  assert(var_value == "string" or var_value == "number", string.format("bad argument #2 to '%s' (string or number expected, got %s)", fName, type(var_value)))

  frame:callParserFunction('#vardefine', var_name, var_value)
end

--[[ procedure: overwrite_first_table_with_second ]]--

local function overwrite_first_table_with_second(first_table, second_table, ignore_keys)
  ignore_keys = ignore_keys or {}

  for k,v in pairs(second_table) do
    local ignore = false

    for _, ignored_key in ipairs(ignore_keys) do
      if k == ignored_key then ignore = true end
    end

    if not ignore then
      if type(v) == "table" then
        if type(first_table[k]) == "table" then
          overwrite_first_table_with_second(first_table[k], v)
        else
          first_table[k] = {}
          overwrite_first_table_with_second(first_table[k], v)
        end
      else
        first_table[k] = v
      end
    end
  end
end

----------------------
-- dataset specific --
----------------------

--[[ function: find_def_table ]]--

local function find_def_table(def)
  -- hidden variables: data
  for k1,v1 in pairs(data) do
    if type(v1) == "table" then
      for k2,v2 in pairs(v1) do
        if k2 == def then return v2 end
      end
    end
  end
end

local function find_def_category_table(def)
  for k1,v1 in pairs(data) do
    if type(v1) == "table" then
      for k2,v2 in pairs(v1) do
        if k2 == def then return v1 end
      end
    end
  end
end

--[[ function: merge_def_with_parents ]]--

local function merge_def_with_parents(def, ignore_keys)
  -- hidden variables: ParentName and global data

  local def_table = find_def_table(def)
  local def_category_table = find_def_category_table(def)
  local parent_names = {}
  local parent_name = def_table["ParentName"]
  local parent_table = def_category_table[parent_name]

  while parent_name do
    table.insert(parent_names, parent_name)
    parent_name = parent_table["ParentName"]
    parent_table = def_category_table[parent_name]
  end

  local inheritance_chain = shallowcopy(reverse_numeric_table(parent_names))
  table.insert(inheritance_chain, def)

  local merged = {}
  local chain_length = #inheritance_chain
  for i,v in ipairs(inheritance_chain) do
    overwrite_first_table_with_second(merged, def_category_table[inheritance_chain[i]], ignore_keys)
  end

  return merged
end

--------------------------------
-- publicly exposed functions --
--------------------------------

local p = {}

function p.query(frame)
  local fName = debug.getinfo(1,"n").name

  if not (frame.args["defName"] or frame.args["label"]) then
    assert(frame.args["defName"], string.format("bad argument to '%s' (missing named argument 'defName' or 'label' needed to find a Def)", fName))
  end

  local def_table
  if frame.args["defName"] then
    def_table = find_def_table(frame.args["defName"])
    if def_table then
      def_table = merge_def_with_parents(frame.args["defName"], {"ParentName", "Abstract"})
    end
  end
  if not def_table then
    def_table = find_parent_table(find_key_name_of_value(frame.args["label"], frame.args), frame.args["label"], data["Races"])
    if def_table then
      def_table = merge_def_with_parents(def_table["defName"], {"ParentName", "Abstract"})
    end
  end

  assert(def_table, "Def not found")

  -- if there are no numeric arguments, output the def to log
  local args_length = #frame.args
  if args_length == 0 then
    tprint(def_table)
  end

  -- get filtered data based on numeric arguments
  local filtered = def_table
  for i,v in ipairs(frame.args) do
    filtered = search_table_recursive(v, filtered)
    if type(filtered) == "string" or type(filtered) == "number" and i < args_length then
      error(string.format("too many numeric arguments to '%s' (string, number or boolean already found)", fName), 0)
    end
  end

  return filtered
end

-------------
-- logging --
-------------

--mw.log("Module:DefInfo:os.clock() " .. os.clock()*1000 .. " ms")
print("Module:DefInfo:os.clock() " .. os.clock()*1000 .. " ms")

return p