Module:Item2: Difference between revisions

From Path of Exile Wiki
Jump to navigation Jump to search
>OmegaK2
(Support for utility flasks)
No edit summary
 
(454 intermediate revisions by 13 users not shown)
Line 1: Line 1:
-- SMW reworked item module
-------------------------------------------------------------------------------
--
--                                Module:Item2
--
-- This module implements Template:Item.
-------------------------------------------------------------------------------
 
require('Module:No globals')
local m_util = require('Module:Util')
local m_item_util -- Lazy load require('Module:Item util')
local m_cargo = require('Module:Cargo')


-- TODO:
-- Should we use the sandbox version of our submodules?
-- drop location (+drop difficulty) support
local use_sandbox = m_util.misc.maybe_sandbox('Item2')
-- divinatation card support
-- talisman tier and category
-- currency: description, stack_size_currency_tab, cosmetic_type
-- potentially include quality bonus in calcuations
-- singular for weapon class in infoboxes
-- Maps: Area level can be retrived eventually
-- Essence: Essence type prop/colunm


-- ----------------------------------------------------------------------------
local m_game = use_sandbox and mw.loadData('Module:Game/sandbox') or mw.loadData('Module:Game')
-- Imports
 
-- ----------------------------------------------------------------------------
-- Lazy loading
local xtable = require('Module:Table')
local f_process_skill_data -- require('Module:Skill').process_skill_data
local util = require('Module:Util')
local f_item_link -- require('Module:Item link').item_link
local getArgs = require('Module:Arguments').getArgs
local f_query_area_info -- require('Module:Area').query_area_info
local m_game = require('Module:Game')
local f_process_recipes -- require('Module:Item2/recipes').process_recipes
local m_skill = require('Module:Skill')
local f_append_schema -- require('Module:Item2/cargo').append_schema
 
-- The cfg table contains all localisable strings and configuration, to make it
-- easier to port this module to another wiki.
local cfg = use_sandbox and mw.loadData('Module:Item2/config/sandbox') or mw.loadData('Module:Item2/config')


local p = {}
local i18n = cfg.i18n
local v = {}
local g_frame, g_args


local core = use_sandbox and require('Module:Item2/core/sandbox') or require('Module:Item2/core')


-- Declare early to avoid errors
local c = {}
local c = {}
c.image_size = 39
-- 9 doesn't hit the query limit
c.max_mod_params = 11
c.max_stat_params = 8


-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------
-- Other stuff
-- Helper functions
-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------


local h = {}
local h = {}


function h.debug(func)
-- Lazy loading for Module:Skill
     if g_args.debug ==  nil then
function h.process_skill_data(tpl_args)
         return
     if not f_process_skill_data then
         f_process_skill_data = use_sandbox and require('Module:Skill/sandbox').process_skill_data or require('Module:Skill').process_skill_data
     end
     end
     func()
     return f_process_skill_data(tpl_args)
end
end


function h.new_color(label, text)
-- Lazy loading for Module:Item link
     if text == nil or text == '' then
function h.item_link(args)
        return nil
     if not f_item_link then
        f_item_link = require('Module:Item link').item_link
     end
     end
     return tostring(mw.html.create('span')
     return f_item_link(args)
        :attr('class', 'text-color -' .. label)
        :wikitext(text))
end
end


function h.na_or_val(tr, value, func)
-- Lazy loading for Module:Area
     if value == nil then
function h.query_area_info(args)
         tr:wikitext(util.html.td.na())
     if not f_query_area_info then
    else
         f_query_area_info = require('Module:Area').query_area_info
        local raw_value = value
        if func ~= nil then
            value = func(value)
        end
        tr
            :tag('td')
                :attr('data-sort-value', raw_value)
                :wikitext(value)
                :done()
     end
     end
    return f_query_area_info(args)
end
end


-- helper to loop over the range variables easier
-- Lazy loading for Module:Item2/cargo
h.range_map = {
function h.append_schema(tpl_args, tables)
    min = {
     if not f_append_schema then
        property = ' range minimum',
         f_append_schema = use_sandbox and require('Module:Item2/cargo/sandbox').append_schema or require('Module:Item2/cargo').append_schema
        var = '_range_minimum',
    },
    max = {
        property = ' range maximum',
        var = '_range_maximum',
    },
    avg = {
        property = ' range average',
        var = '_range_average',
    },
}
 
function h.stats_update(id, value, modid)
     if g_args._stats[id] == nil then
         value.references = {modid}
        g_args._stats[id] = value
    else
        if modid ~= nil then
            table.insert(g_args._stats[id].references, mod_data.result['Is Mod'])
        end
        g_args._stats[id].min = g_args._stats[id].min + value.min
        g_args._stats[id].max = g_args._stats[id].max + value.max
        g_args._stats[id].avg = g_args._stats[id].avg + value.avg
     end
     end
    return f_append_schema(tpl_args, tables)
end
end


h.stat = {}
-- Lazy loading for Module:Item2/recipes
function h.stat.add (value, stat_cached)  
function h.process_recipes(tpl_args)
     value.min = value.min + stat_cached.min
     if not f_process_recipes then
     value.max = value.max + stat_cached.max
        f_process_recipes = use_sandbox and require('Module:Item2/recipes/sandbox').process_recipes or require('Module:Item2/recipes').process_recipes
     end
    return f_process_recipes(tpl_args)
end
end


function h.stat.more (value, stat_cached)
function h.handle_range_args(tpl_args, key, field, value, options)
     value.min = value.min * (1 + stat_cached.min / 100)
    local opt = {}
     value.max = value.max * (1 + stat_cached.max / 100)
    for k, v in pairs(options or {}) do
        opt[k] = v
    end
    local html, val2 = m_util.html.format_value(tpl_args, value, opt)
     tpl_args[key .. '_html'] = html
    tpl_args[field .. '_html'] = html
    tpl_args[field .. '_range_colour'] = val2.color
    opt.color = false
     tpl_args[field .. '_range_text'] = m_util.html.format_value(tpl_args, value, opt)
end
end


h.tbl = {}
h.stat = {}
h.tbl.display = {}
function h.stat.add(value, magnitude)
function h.tbl.display.na_or_val(tr, value, data)
     value.min = value.min + magnitude.min
     return h.na_or_val(tr, value)
    value.max = value.max + magnitude.max
end
end


function h.tbl.display.seconds(tr, value, data)
function h.stat.add_distance(value, magnitude)
     return h.na_or_val(tr, value, function(value)
     -- Stats for distance are 10x the display value
        return string.format('%ss', value)
    value.min = value.min + (magnitude.min / 10)
    end)
    value.max = value.max + (magnitude.max / 10)
end
end


function h.tbl.display.percent(tr, value, data)
function h.stat.increased(value, magnitude)
     return h.na_or_val(tr, value, function(value)
     value.min = value.min * (1 + magnitude.min / 100)
        return string.format('%s%%', value)
    value.max = value.max * (1 + magnitude.max / 100)
    end)
end
end


function h.tbl.display.wikilink(tr, value, data)
function h.stat.increased_inverse(value, magnitude)
     return h.na_or_val(tr, value, function(value)
     value.min = value.min / (1 + magnitude.min / 100)
        return string.format('[[%s]]', value)
    value.max = value.max / (1 + magnitude.max / 100)
    end)
end
end


h.tbl.display.factory = {}
--
function h.tbl.display.factory.range(args)
-- Processing
  -- args: table
--
  -- property
  -- no_base: no base value given
  -- options: table, see h.format_value
  args.options = args.options or {}
 
  return function (tr, value, data)
        local value = {}
        local chk_keys = {}
       
        for key, range_data in pairs(h.range_map) do
            value[key] = tonumber(data[string.format('?Has %s%s', args.property, range_data.property)])
            chk_keys[#chk_keys+1] = key
        end
       
        if args.no_base == nil then
            value.base = tonumber(data['?Has base ' .. args.property])
            chk_keys[#chk_keys+1] = 'base'
        end
       
        if util.table.has_one_value(value, chk_keys, nil) then
            tr:wikitext(util.html.td.na())
            return
        end
       
        if args.no_base or value.avg == value.base then
            args.options.color = 'value'
        else
            args.options.color = 'mod'
        end
       
        tr
            :tag('td')
                :attr('data-sort-value', value.avg)
                :wikitext(h.format_value(value, args.options))
                :done()
  end
end


function h.format_value(value, options)
function h.process_arguments(tpl_args, params)
     -- value: table
     tpl_args._processed_args = tpl_args._processed_args or {}
    --  min:
     tpl_args._base_item_args = tpl_args._base_item_args or {}
    --  max:
     for _, k in ipairs(params) do
    -- options: table
         local arg_def = core.map[k]
    --  fmt: formatter to use for the value instead of valfmt
         if arg_def == nil then
    --  before: add this string before the coloured string with colour gray
             if tpl_args.debug then
    --  after: add this string after the coloured string with colour gray
                error(string.format(i18n.debug.invalid_argument_key, k))
    --  func: Function to adjust the value with before output
    --  color: colour code for h.new_color, overrides mod colour
    if options.color then
        value.color = options.color
     elseif value.base ~= value.min or value.base ~= value.max then
        value.color = 'mod'
     else
        value.color = 'value'
    end
   
    if options.func ~= nil then
        value.min = options.func(value.min)
        value.max = options.func(value.max)
    end
   
    if options.fmt == nil then
        options.fmt = '%s'
    elseif type(options.fmt) == 'function' then
        options.fmt = options.fmt()
    end
   
    if value.min == value.max then
        value.out = string.format(options.fmt, value.min)
    else
        value.out = string.format(string.format("(%s to %s)", options.fmt, options.fmt), value.min, value.max)
    end
   
    value.out = h.new_color(value.color, value.out)
   
    local before = ''
    if type(options.before) == 'string' then
        before = h.new_color('default', options.before)
    elseif type(options.before) == 'function' then
         before = h.new_color('default', options.before())
    end
   
    local after = ''
    if type(options.after) == 'string' then
        after = h.new_color('default', options.after)
    elseif type(options.after) == 'function' then
        after = h.new_color('default', options.after())
    end
   
    return before .. value.out .. after
end
 
-- ----------------------------------------------------------------------------
-- core
-- ----------------------------------------------------------------------------
 
local core = {}
 
function core.validate_mod(args)
    -- args:
    --  key  - implict or explicit
    --  i
    --  value
    local value = g_args[args.key .. args.i]
    local out = {
         result=nil,
        modid=nil,
        type=args.key,
    }
   
    if value ~= nil then
        table.insert(g_args.mods, value)
        table.insert(g_args[args.key .. '_mods'], value)
        out.modid = value
        --out.result = nil
        table.insert(g_args._mods, out)
        return true
    else
        value = g_args[args.key .. args.i .. '_text']
        if value ~= nil then
             --table.insert(g_args._subobjects, {
            --    ['Is mod number'] = args.i,
            --  ['Has mod text'] = value,
            --})
            out.result = value
            table.insert(g_args._mods, out)
            return true
        end
    end
   
    return false
end
 
function core.process_smw_mods()
    if #g_args.mods == 0 then  
        return
    end
   
    local mods = {}
    for _, mod_data in ipairs(g_args._mods) do
        if mod_data.result == nil then
            mods[mod_data.modid] = mod_data
        end
    end
   
    local results = {}
    local result
    local query
    local number_of_queries = math.ceil(#g_args.mods / c.max_mod_params)
    local pages = {}
   
    for query_number=1, number_of_queries do
        local offset = (query_number-1)*c.max_mod_params
        local mod_ids = {}
        for j=(1+offset), (c.max_mod_params+offset) do
            mod_ids[#mod_ids+1] = g_args.mods[j]
        end
   
        query = {
            string.format('[[Is mod::%s]]', table.concat(mod_ids, '||')),
            '?#=Page',
            '?Is mod#',
            '?Has mod group#',
            '?Has mod type#',
            '?Has stat text#',
            '?Has level requirement#',
        }
       
        result = util.smw.query(query, g_frame)
   
        -- remap this as table with modids as key
        for _, row in ipairs(result) do
            results[#results+1] = row
           
            local mod_data = mods[row['Is mod']]
            mod_data.result = row
           
            -- needed for the query
            pages[#pages+1] = row[1]
            -- needed for the mapping stats to mods
            pages[row[1]] = mod_data
           
            -- update item level requirement
            local keys = {'required_level_final'}
            -- only update base item requirement if this is an implicit
            if mod_data.key == 'implicit' then
                keys[#keys+1] = 'required_level'
             end
             end
           
        else
             for _, key in ipairs(keys) do
             if arg_def.inherit ~= false then
                 local req = math.floor(tonumber(row['Has level requirement']) * 0.8)
                 table.insert(tpl_args._base_item_args, k)
                if req > g_args[key] then
                    g_args[key] = req
                end
             end
             end
        end
            if tpl_args[k] ~= nil and arg_def.deprecated == true then
    end
                tpl_args._flags.uses_deprecated_parameters = true
   
                tpl_args._deprecated_args = tpl_args._deprecated_args or {}
    -- TODO: Can items have mods twice? I dont think so, if they do it would need to be accounted for here
                table.insert(tpl_args._deprecated_args, k)
    if #results ~= #g_args.mods then
        local missing = {}
        for _, modid in ipairs(g_args.mods) do
            if mods[modid].result == nil then
                missing[#missing+1] = modid
             end
             end
        end
             if arg_def.func ~= nil then
 
                 tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
        local duplicates = {}
        for _, row in ipairs(results) do
             if duplicates[row['Is mod']] == nil then
                 duplicates[row['Is mod']] = {row['Page']}
            else
                table.insert(duplicates[row['Is mod']], row['Page'])
             end
             end
        end
             if tpl_args[k] == nil then
       
                 if tpl_args.class_id and tpl_args._item_config.defaults[k] ~= nil and (not tpl_args._flags.is_derived or arg_def.inherit == false) then
        local text = {}
                    -- Defaults based on item class
        for modid, pages in pairs(duplicates) do
                    -- Ignore inherited fields if this is a derived item; these are set by the base item instead
             if #pages <= 1 then
                    tpl_args[k] = tpl_args._item_config.defaults[k]
                duplicates[modid] = nil
                elseif arg_def.default ~= nil then
            else
                    -- General defaults
                 text[#text+1] = string.format('%s (pages: %s)', modid, table.concat(pages, ', '))
                    if type(arg_def.default) == 'function' then
            end
                        tpl_args[k] = arg_def.default(tpl_args)
        end
                    else
       
                        tpl_args[k] = arg_def.default
        error(string.format('Number of mods found does not match number of queried mods. Not found: "%s", duplicates: "%s"', table.concat(missing, ', '), table.concat(text)))
                    end
    end
                 end
   
    -- fetch stats
   
    number_of_queries = math.ceil(#pages / c.max_stat_params)
   
    for query_number=1, number_of_queries do
        local offset = (query_number-1)*c.max_stat_params
        local temp_pages = {}
        for j=(1+offset), (c.max_stat_params+offset) do
            temp_pages[#temp_pages+1] = pages[j]
        end
       
        query = {
            string.format('[[-Has subobject::%s]] [[Has stat id::+]] [[Has minimum stat value::+]] [[Has maximum stat value::+]]', table.concat(temp_pages, '||')),
            '?Is stat number#',
            '?Has stat id#',
            '?Has minimum stat value#',
            '?Has maximum stat value#',
        }
       
        local stats = util.smw.query(query, g_frame)
       
        -- process and cache stats
        for _, stat in ipairs(stats) do
            local mod_data = pages[util.string.split(stat[1], '#')[1]]
            if mod_data.result.stats == nil then
                mod_data.result.stats = {stat, }
            else
                 mod_data.result.stats[#mod_data.result.stats+1] = stat
             end
             end
       
             tpl_args._processed_args[k] = true
             local id = stat['Has stat id']
            local value = {
                min = tonumber(stat['Has minimum stat value']),
                max = tonumber(stat['Has maximum stat value']),
            }
            value.avg = (value.min+value.max)/2
           
            h.stats_update(id, value, mod_data.result['Is Mod'])
         end
         end
     end
     end
end
end


function core.process_base_item(args)
--
    local query = {}
-- Display
--


    if g_args.base_item_id ~= nil then
function h.strip_random_stats(tpl_args, stat_text)
        query[#query+1] = string.format('[[Has metadata id::%s]]', g_args.base_item_id)
     if tpl_args._flags.random_mods then
     elseif g_args.base_item_page ~= nil then
         repeat
         query[#query+1] = string.format('[[%s]]', g_args.base_item_page)
            local text = string.match(stat_text, '<th class="mw%-customtoggle%-31">(.+)</th>')
    elseif g_args.base_item ~= nil then
            if text ~= nil then
        query[#query+1] = string.format('[[Has name::%s]]', g_args.base_item)
                stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1)
    elseif g_args.rarity ~= 'Normal' then
        error(core.err{msg='Rarity is set to above normal, but base item is not set. A base item for rarities above normal is required!'})
    else
        return
    end
   
    if #query > 1 and g_args.rarity == 'Normal' then
        error(core.err{msg='Base item parameter is set, but rarity is set to normal. A rarity above normal is required!'})
    end
   
    query[#query+1] = string.format('[[Has item class::%s]]', g_args['class'])
    query[#query+1] = '[[Has rarity::Normal]]'
    query[#query+1] = '?Has implicit mod ids#'
    query[#query+1] = '?Has metadata id'
    query[#query+1] = '?Has name'
   
    for _, k in ipairs(g_args._base_item_args) do
        query[#query+1] = string.format('?%s#', core.map[k].property)
    end
   
    local result = util.smw.query(query, g_frame)
   
    if #result > 1 then
        error(core.err{msg='More then one result found for the specified base item. Consider using base_item_page or base_item_id to narrow down the results.'})
        -- TODO be more explicit in the error?
    end
   
    result = result[1]
 
    --Copy values..
    for _, k in ipairs(g_args._base_item_args) do
        local data = core.map[k]
        local value = result[data.property]
        -- I can just use data.default since it will be nil if not provided. Neat! ;)
        if value ~= "" and g_args[k] == data.default then
            g_args[k] = value
            if data.property_func ~= nil then
                data.property_func()
            elseif data.func ~= nil then
                data.func()
             end
             end
         elseif value == "" then
         until text == nil
            h.debug(function ()
                mw.logObject(string.format("Base item property not found: %s", data.property))
            end)
        elseif g_args[k] ~= data.default then
            h.debug(function ()
                mw.logObject(string.format("Value for arg '%s' is set to something else then default: %s", k, tostring(g_args[k])))
            end)
        end
     end
     end
      
     return stat_text
    g_args.base_item_data = result
    core.process_arguments{array={'base_item', 'base_item_page', 'base_item_id'}}
end
end


function core.process_arguments(args)
function h.add_to_infobox_from_map(tpl_args, infobox, mapping)
     for _, k in ipairs(args.array) do
    local statcont = mw.html.create('span')
         local data = core.map[k]
        :addClass('item-stats')
         table.insert(g_args._total_args, k)
    local count = 0 -- Number of groups in infobox
        if data.no_copy == nil then
     for _, group in ipairs(mapping) do
             table.insert(g_args._base_item_args, k)
         local lines = {}
        end
         for _, line in ipairs(group) do
        if data.func ~= nil then
            local show = true
            local status, err = pcall(data.func)
            if line.show == false then
             -- an error was raised, return the error string instead of the template
                show = false
             if not status then
             elseif type(line.show) == 'function' then
                 return err
                show = line.show(tpl_args)
             end
             if show then
                 lines[#lines+1] = line.func(tpl_args)
             end
             end
         end
         end
         if data.default ~= nil and g_args[k] == nil then
         if #lines > 0 then
             g_args[k] = data.default
             count = count + 1
        end
            local heading = ''
    end
            if group.heading == nil then
end
             elseif type(group.heading) == 'function' then
       
                 heading = group.heading()
function core.process_mod_stats(args)
    local lines = {}
   
    local skip = core.class_specifics[g_args.class]
    if skip then
        skip = skip.skip_stat_lines
    end
   
    for _, modinfo in ipairs(g_args._mods) do
        if modinfo.type == args.type then
             if modinfo.modid == nil then
                 table.insert(lines, modinfo.result)
             else
             else
                 for _, line in ipairs(util.string.split(modinfo.result['Has stat text'], '<br>')) do
                 heading = string.format('<em class="header">%s</em><br>', group.heading)
                    if skip == nil then
                        table.insert(lines, line)
                    else
                        local skipped = false
                        for _, pattern in ipairs(skip) do
                            if string.match(line, pattern) then
                                skipped = true
                                break
                            end
                        end
                        if not skipped then
                            table.insert(lines, line)
                        end
                    end
                end
             end
             end
            statcont
                :tag('span')
                    :addClass('group ' .. (group.class or ''))
                    :wikitext(heading .. table.concat(lines, '<br>'))
                    :done()
         end
         end
     end
     end
   
    if #lines == 0 then
        return
    else
        return table.concat(lines, '<br>')
    end
end


function core.err(args)
    -- Add groups to infobox
    local err = mw.html.create('div')
     if count > 0 then
    err
        infobox:node(statcont)
        :attr('style', 'font-color: red; font-weight: bold;')
        :wikitext(args.msg or ('Argument ' .. args.key .. ' to item template is invalid. Please check the documention for acceptable values.'))
        :done()
       
     return tostring(err)
end
 
--
-- function factory
--
core.factory = {}
function core.factory.array_table_cast(k, args)
    -- Arguments:
    --
    -- tbl
    -- errmsg
    return function ()
        local elements
       
        if g_args[k] ~= nil then
            elements = util.string.split(g_args[k], ', ')
            for _, element in ipairs(elements) do
                local r = util.table.find_in_nested_array{value=element, tbl=args.tbl, key='full'}
                if r == nil then
                    error(core.err{msg=string.format(args.errmsg, element)})
                end
            end
            g_args[k] = xtable:new(elements)
        end
     end
     end
end
end


function core.factory.table_cast(k, args)
function h.make_main_infobox(tpl_args)
     return function ()
     local infobox = mw.html.create('span')
         args.value = g_args[k]
         :addClass('item-box -' .. tpl_args.frame_type)
         g_args[k] = util.table.find_in_nested_array(args)
   
         if g_args[k] == nil then
    if tpl_args.class_id == 'DivinationCard' then
            error(core.err{key=k})
         local divcard = infobox
            :tag('span')
                :addClass('divicard-wrapper')
        local card_background = tpl_args.card_background or {}
         if #card_background > 0 then
            divcard
                :tag('span')
                    :addClass('divicard-background')
                    :wikitext(string.format(
                        '[[%s|390px|gif]]',
                        string.format(
                            i18n.files.divination_card_background,
                            table.concat(card_background, '-')
                        )
                    ))
         end
         end
    end
        divcard
end
            :tag('span')
 
                :addClass('divicard-art')
 
                :wikitext(string.format('[[%s|link=|alt=]]', tpl_args.card_art))
function core.factory.number_cast(k)
                :done()
    return function ()
            :tag('span')
        g_args[k] = tonumber(g_args[k])
                :addClass('divicard-frame')
    end
                :done()
end
            :tag('span')
 
                :addClass('divicard-header')
function core.factory.boolean_cast(k)
                :wikitext(tpl_args.name)
    return function()
                :done()
         if g_args[k] ~= nil then
            :tag('span')
             g_args[k] = util.cast.boolean(g_args[k])
                :addClass('divicard-artlink')
                :wikitext(string.format('[[%s]]', tpl_args.card_art))
                :done()
            :tag('span')
                :addClass('divicard-stack')
                :wikitext(tpl_args.stack_size)
                :done()
            :tag('span')
                :addClass('divicard-face')
                :tag('span')
                    :addClass('divicard-reward')
                    :wikitext(tpl_args.description)
                    :done()
                :tag('span')
                    :addClass('divicard-flavour')
                    :wikitext(tpl_args.flavour_text)
                    :done()
    else
        local line_type
        local name_line
         if tpl_args._flags.is_derived and tpl_args.rarity_id ~= 'normal' then
             line_type = 'double'
            name_line = tpl_args.name .. '<br>' .. tpl_args.base_item
        else
            line_type = 'single'
            name_line = tpl_args.name
         end
         end
    end
end


function core.factory.percentage(k)
        -- Symbols - These are displayed in the item box header to indicate certain flags and/or item influences
    return function ()
        local symbols
        local v = tonumber(g_args[k])
        local influences = tpl_args.influences or {}
          
        if tpl_args.is_replica then
        if v == nil then
            symbols = {'replica', 'replica'}
             return core.err{key=k}
            if #influences > 0 then
                symbols[2] = influences[1]
            end
         elseif #influences > 0 then
            symbols = {influences[1], influences[1]}
            if #influences > 1 then
                symbols[2] = influences[2]
            end
        elseif tpl_args.is_fractured then
            symbols = {'fractured', 'fractured'}
        elseif tpl_args.is_synthesised then
             symbols = {'synthesised', 'synthesised'}
        elseif tpl_args.is_searing_exarch_item or tpl_args.is_eater_of_worlds_item then
            symbols = {
                tpl_args.is_searing_exarch_item and 'searingexarch' or 'eaterofworlds',
                tpl_args.is_eater_of_worlds_item and 'eaterofworlds' or 'searingexarch'
            }
        elseif tpl_args.is_veiled then
            symbols = {'veiled', 'veiled'}
         end
         end
          
          
         if v < 0 or v > 100 then
         infobox
             return core.err{msg=k .. ' must be in range 0-100.'}
             :tag('span')
         end
                :addClass('header -' .. line_type)
       
                :tag('span')
         g_args[k] = v
                    :addClass('symbol')
                    :addClass(symbols and '-' .. symbols[1] or nil)
                    :done()
                :wikitext(name_line)
                :tag('span')
                    :addClass('symbol')
                    :addClass(symbols and '-' .. symbols[2] or nil)
                    :done()
            :done()
           
         h.add_to_infobox_from_map(tpl_args, infobox, c.item_infobox_groups)
    end
   
    if tpl_args.skill_icon ~= nil then
         infobox:wikitext(string.format('[[%s]]', tpl_args.skill_icon))
     end
     end
   
    return infobox
end
end


function core.factory.display_value(args)
--  
    -- TODO: sane defaults for the prepend string "before" & after arguments
-- Factory
    --
--  
    -- args:
 
    --  type: Type of the keys (nil = regular, gem = skill gems, stat = stats)
h.factory = {}
    -- options<Array>:
    --   fmt: formatter to use for the value instead of valfmt
    --   allow_zero: allow zero values
    --  before: add this string before the coloured string with colour gray
    --  after: add this string after the coloured string with colour gray
    --  func: Function to adjust the value with before output
    --  hide_default: hide the value if this is set;
    --  color: colour code for h.new_color, overrides mod colour


      
function h.factory.maybe_show_infobox_line(args)
     for k, default in pairs({options = {}}) do
     -- Verifies that a list of keys are present in tpl_args and that the item
         if args[k] == nil then
     -- should use those keys. Returns true if all conditions are met, otherwise
             args[k] = default
    -- returns false.
    return function (tpl_args)
        local keys = args.keys or {}
        local conditions = args.conditions or {}
         if #keys == 0 then
             return false
         end
         end
    end
        for _, k in ipairs(keys) do
   
             if tpl_args[k] == nil then
    return function ()
                 return false
        local base_values = {}
        local temp_values = {}
        if args.type == 'gem' then
             if not core.class_groups.gems.keys[g_args.class] then
                 return
             end
             end
             for i, data in ipairs(args.options) do
             local t = type(tpl_args[k])
                local value = g_args['static_' .. data.key]
            if (t == 'table' or t == 'string') and #tpl_args[k] == 0 then
                if value ~= nil then
                 return false
                    base_values[#base_values+1] = value
                    temp_values[#temp_values+1] = {value={min=value,max=value}, index=i}
                else
                    value = {
                        min=g_args[string.format('level1_%s', data.key)],
                        max=g_args[string.format('level%s_%s', g_args.max_level, data.key)],
                    }
                    if value.min == nil or value.max == nil then
                    else
                        base_values[#base_values+1] = value.min
                        temp_values[#temp_values+1] = {value=value, index=i}
                    end
                 end
             end
             end
        elseif args.type == 'stat' then
             if conditions.processed == true and tpl_args._processed_args[k] == nil then
             for i, data in ipairs(args.options) do
                 return false
                local value = g_args._stats[data.key]
                if value ~= nil then
                    base_values[i] = value.min
                    temp_values[#temp_values+1] = {value=value, index=i}
                end
            end
        else
            for i, data in ipairs(args.options) do
                base_values[i] = g_args[data.key]
                local value = {}
                if g_args[data.key .. '_range_minimum'] ~= nil then
                    value.min = g_args[data.key .. '_range_minimum']
                    value.max = g_args[data.key .. '_range_maximum']
                elseif g_args[data.key] ~= nil then
                    value.min = g_args[data.key]
                    value.max = g_args[data.key]
                end
                if value.min == nil then
                else
                    temp_values[#temp_values+1] = {value=value, index=i}
                 end
             end
             end
         end
         end
          
         return true
        local final_values = {}
        for i, data in ipairs(temp_values) do
            local opt = args.options[data.index]
            local v = data.value
            if opt.hide_default ~= nil and opt.hide_default == v.min and opt.hide_default == v.max then
            else
                table.insert(final_values, data)
            end
        end
       
        -- all zeros = dont display and return early
        if #final_values == 0 then
            return nil
        end
       
        local out = {}
       
        if args.before then
            out[#out+1] = h.new_color('default', args.before)
        end
       
        for i, data in ipairs(final_values) do
            local value = data.value
            value.base = base_values[data.index]
           
            local options = args.options[data.index]
           
            if options.color == nil and args.type == 'gem' then
                value.color = 'value'
            end
           
            out[#out+1] = h.format_value(value, options)
        end
       
        if args.after then
            out[#out+1] = h.new_color('default', args.after)
        end
       
        return table.concat(out, '')
     end
     end
end
end


function core.factory.display_value_only(key)
function h.factory.display_raw_value(key)
     return function()
     return function(tpl_args)
         return g_args[key]
         return tpl_args[key]
     end
     end
end
end


function core.factory.descriptor_value(args)
function h.factory.descriptor_value(args)
     -- Arguments:
     -- Arguments:
     --  key
     --  key
     --  tbl
     --  tbl
     args = args or {}
     args = args or {}
     return function (value)
     return function (tpl_args, value)
         args.tbl = args.tbl or g_args
         args.tbl = args.tbl or tpl_args
         if args.tbl[args.key] then
         if args.tbl[args.key] then
             value = util.html.abbr(value, args.tbl[args.key])
             value = m_util.html.abbr(value, args.tbl[args.key])
         end
         end
         return value
         return value
Line 741: Line 379:
end
end


--
-- ----------------------------------------------------------------------------
-- argument mapping
-- Additional configuration
--
-- ----------------------------------------------------------------------------
-- format:
-- g_args key = {
--   no_copy = true or nil          -- When loading an base item, dont copy this key
--   property = 'prop',              -- Property associated with this key
--   property_func = function or nil -- Function to unpack the property into a native lua value.
--                                     If not specified, func is used.
--                                     If neither is specified, value is copied as string
--   func = function or nil          -- Function to unpack the argument into a native lua value and validate it.
--                                     If not specified, value will not be set.
--   default = object                -- Default value if the parameter is nil
-- }
core.map = {
    -- special params
    html = {
        no_copy = true,
        property = 'Has infobox HTML',
        func = nil,
    },
    implicit_stat_text = {
        property = 'Has implicit stat text',
        func = function ()
            g_args.implicit_stat_text = core.process_mod_stats{type='implicit'}
        end,
    },
    explicit_stat_text = {
        property = 'Has explicit stat text',
        func = function ()
            g_args.explicit_stat_text = core.process_mod_stats{type='explicit'}
           
            if g_args.is_talisman then
                g_args.explicit_stat_text = (g_args.explicit_stat_text or '') .. h.new_color('corrupted', 'Corrupted')
            end
        end,
    },
    stat_text = {
        property = 'Has stat text',
        func = function()
            local sep = ''
            if g_args.implicit_stat_text and g_args.explicit_stat_text then
                sep = string.format('<span class="item-stat-separator -%s"></span>', g_args.frame_type)
            end
            local text = (g_args.implicit_stat_text or '') .. sep .. (g_args.explicit_stat_text or '')
           
            if string.len(text) > 0 then
                g_args.stat_text = text
            end
        end,
    },
    -- generic
    class = {
        no_copy = true,
        property = 'Has item class',
        func = core.factory.table_cast('class', {key='full', tbl=m_game.constants.item.class}),
    },
    rarity = {
        no_copy = true,
        property = 'Has rarity',
        func = core.factory.table_cast('rarity', {key={'full', 'long_lower'}, tbl=m_game.constants.item.rarity, rtrkey='full'}),
    },
    name = {
        no_copy = true,
        property = 'Has name',
        func = nil,
    },
    size_x = {
        property = 'Has inventory width',
        func = core.factory.number_cast('size_x'),
    },
    size_y = {
        property = 'Has inventory height',
        func = core.factory.number_cast('size_y'),
    },
    drop_enabled = {
        property = 'Is drop enabled',
        func = core.factory.boolean_cast('drop_enabled'),
        default = true,
    },
    drop_level = {
        no_copy = true,
        property = 'Has drop level',
        func = core.factory.number_cast('drop_level'),
    },
    drop_level_maximum = {
        no_copy = true,
        property = 'Has maximum drop level',
        func = core.factory.number_cast('drop_level_maximum'),
    },
    required_level = {
        property = 'Has base level requirement',
        func = core.factory.number_cast('required_level'),
        default = 1,
    },
    required_level_final = {
        property = 'Has level requirement',
        func = function ()
            g_args.required_level_final = g_args.required_level
        end,
        default = 1,
    },
    required_dexterity = {
        property = 'Has base dexterity requirement',
        func = core.factory.number_cast('required_dexterity'),
        default = 0,
    },
    required_strength = {
        property = 'Has base strength requirement',
        func = core.factory.number_cast('required_strength'),
        default = 0,
    },
    required_intelligence = {
        property = 'Has base intelligence requirement',
        func = core.factory.number_cast('required_intelligence'),
        default = 0,
    },
    inventory_icon = {
        no_copy = true,
        property = 'Has inventory icon',
        func = function ()
            g_args.inventory_icon_id = g_args.inventory_icon or g_args.name
            g_args.inventory_icon = string.format('File:%s inventory icon.png', g_args.inventory_icon_id)
        end,
    },
    -- note: this must be called after inventory item to work correctly as it depends on g_args.inventory_icon_id being set
    alternate_art_inventory_icons = {
        no_copy = true,
        property = 'Has alternate inventory icons',
        func = function ()
            local icons = {}
            if g_args.alternate_art_inventory_icons ~= nil then
                local names = util.string.split(g_args.alternate_art_inventory_icons, ', ')
               
                for _, name in ipairs(names) do
                    icons[#icons+1] = string.format('File:%s %s inventory icon.png', g_args.inventory_icon_id, name)
                end
            end
            g_args.alternate_art_inventory_icons = icons
        end,
        default = {},
    },
    buff_icon = {
        property = 'Has buff icon',
        func = function()
            g_args.buff_icon = string.format('File:%s status icon.png', g_args.name)
        end,
    },
    help_text = {
        property = 'Has help text',
        func = nil,
    },
    flavour_text = {
        no_copy = true,
        property = 'Has flavour text',
        func = nil,
    },
    tags = {
        property = 'Has tags',
        property_func = function ()
            g_args.tags = util.string.split(g_args.tags, '<MANY>')
        end,
        func = core.factory.array_table_cast('tags', {
            tbl = m_game.constants.tags,
            errmsg = '%s is not a valid tag',
        }),
    },
    metadata_id = {
        no_copy = true,
        property = 'Has metadata id',
        func = nil,
    },
    --
    -- specific section
    --
    -- amulets
    is_talisman = {
        property = 'Is talisman',
        func = core.factory.boolean_cast('is_talisman'),
    },
   
    -- flasks
    charges_max = {
        property = 'Has base maximum flask charges',
        func = core.factory.number_cast('charges_max'),
    },
    charges_per_use = {
        property = 'Has base flask charges per use',
        func = core.factory.number_cast('charges_per_use'),
    },
    flask_mana = {
        property = 'Has base flask mana recovery',
        func = core.factory.number_cast('flask_mana'),
    },
    flask_life = {
        property = 'Has base flask life recovery',
        func = core.factory.number_cast('flask_life'),
    },
    flask_duration = {
        property = 'Has base flask duration',
        func = core.factory.number_cast('flask_duration'),
    },
    buff_id = {
        property = 'Has buff id',
        func = nil,
    },
    buff_values = {
        property = nil,
        func = function ()
            local values = {}
            local i = 0
            local value
            local key
            repeat
                i = i + 1
                key = 'buff_value' .. i
                value = tonumber(g_args[key])
                values[i] = value
                g_args[key] = value
                g_args._subobjects[key] = {
                    ['Is number'] = i,
                    ['Has buff value'] = value,
                }
            until values[i] == nil
           
            g_args.buff_values = values
        end,
    },
    buff_stat_text = {
        property = 'Has buff stat text',
        func = nil,
    },
   
    -- weapons & active skills
    critical_strike_chance = {
        property = 'Has base critical strike chance',
        func = core.factory.number_cast('critical_strike_chance'),
    },
    -- weapons
    attack_speed = {
        property = 'Has base attack speed',
        func = core.factory.number_cast('attack_speed'),
    },
    damage_min = {
        property = 'Has base minimum physical damage',
        func = core.factory.number_cast('damage_min'),
    },
    damage_max = {
        property = 'Has base maximum physical damage',
        func = core.factory.number_cast('damage_max'),
    },
    range = {
        property = 'Has base weapon range',
        func = core.factory.number_cast('range'),
    },
    -- armor-type stuff
    armour = {
        property = 'Has base armour',
        func = core.factory.number_cast('armour'),
        default = 0,
    },
    energy_shield = {
        property = 'Has base energy shield',
        func = core.factory.number_cast('energy_shield'),
        default = 0,
    },
    evasion = {
        property = 'Has base evasion',
        func = core.factory.number_cast('evasion'),
        default = 0,
    },
    -- shields
    block = {
        property = 'Has base block',
        func = core.factory.number_cast('block'),
    },
    -- skill gem stuff
    gem_description = {
        property = 'Has description',
        func = nil,
    },
    dexterity_percent = {
        property = 'Has dexterity percentage',
        func = core.factory.percentage('dexterity_percent'),
    },
    strength_percent = {
        property = 'Has strength percentage',
        func = core.factory.percentage('strength_percent'),
    },
    intelligence_percent = {
        property = 'Has intelligence percentage',
        func = core.factory.percentage('intelligence_percent'),
    },
    primary_attribute = {
        property = 'Has primary attribute',
        func = function()
            for _, attr in ipairs(m_game.constants.attributes) do
                local val = g_args[attr.long_lower .. '_percent']
                if val and val >= 60 then
                    g_args['primary_attribute'] = attr.long_upper
                    return
                end
            end
            g_args['primary_attribute'] = 'None'
        end,
    },
    gem_tags = {
        property = 'Has gem tags',
        -- TODO: default rework
        func = core.factory.array_table_cast('gem_tags', {
            tbl = m_game.constants.item.gem_tags,
            errmsg = '%s is not a valid tag',
        }),
        default = {},
    },
    experience = {
        property = 'Has maximum experience',
        func = core.factory.percentage('experience'),
    },
    skill_screenshot = {
        property = 'Has skill screenshot',
        func = function ()
            g_args.skill_screenshot = string.format('File:%s skill screenshot.jpg', g_args.name)
        end,
    },
    -- Active gems only
    gem_icon = {
        property = 'Has skill gem icon',
        func = function ()
            -- TODO readd support if needed.
            g_args.gem_icon = string.format('File:%s skill icon.png', g_args.name)
        end,
    },
    -- Support gems only
    support_gem_letter_html = {
        property = 'Has support gem letter HTML',
        func = function ()
            if g_args.support_gem_letter == nil then
                return
            end
       
            -- TODO replace this with a loop possibly
            local css_map = {
                strength = 'red',
                intelligence = 'blue',
                dexterity = 'green',
            }
            local id
            for k, v in pairs(css_map) do
                k = string.format('%s_percent', k)
                if g_args[k] and g_args[k] > 50 then
                    id = v
                    break
                end
            end
           
            if id ~= nil then
                local container = mw.html.create('span')
                container
                    :attr('class', string.format('support-gem-id-%s', id))
                    :wikitext(g_args.support_gem_letter)
                    :done()
                g_args.support_gem_letter_html = tostring(container)
            end
        end,
    },
    -- Maps
    map_tier = {
        property = 'Has map tier',
        func = core.factory.number_cast('tier'),
    },
    map_guild_character = {
        property = 'Has map guild character',
        func = nil,
    },
    map_area_id = {
        property = 'Has map area id',
        func = nil, -- TODO: Validate against a query?
    },
    map_area_level = {
        property = 'Has map area level',
        func = core.factory.number_cast('map_area_level'),
    },
    unique_map_guild_character = {
        property = 'Has unqiue map guild character',
        func = nil,
    },
    unique_map_area_id = {
        property = 'Has unique map area id',
        func = nil, -- TODO: Validate against a query?
    },
    unique_map_area_level = {
        property = 'Has unique map area level',
        func = core.factory.number_cast('unique_map_area_level'),
    },
    --
    -- Currency-like items
    --
    stack_size = {
        property = 'Has stack size',
        func = core.factory.number_cast('stack_size'),
    },
    stack_size_currency_tab = {
        property = 'Has currency tab stack size',
        func = core.factory.number_cast('stack_size_currency_tab'),
    },
    description = {
        property = 'Has description',
        func = nil,
    },
    cosmetic_type = {
        property = 'Has cosmetic type',
        func = nil,
    },
    -- for essences
    is_essence = {
        property = 'Is essence',
        func = core.factory.boolean_cast('is_essence'),
        default = false,
    },
    essence_level_restriction = {
        property = 'Has essence level restriction',
        func = core.factory.number_cast('essence_level_restriction'),
    },
    essence_tier = {
        property = 'Has essence tier',
        func = core.factory.number_cast('essence_tier'),
    },
    --
    -- hideout doodads (HideoutDoodads.dat)
    --
    is_master_doodad = {
        property = 'Is master doodad',
        func = core.factory.boolean_cast('is_master_doodad'),
    },
    master = {
        property = 'Is sold by master',
        -- todo validate against list of master names
        func = core.factory.table_cast('master', {key='full', tbl=m_game.constants.masters}),
    },
    master_level_requirement = {
        property = 'Has master level requirement',
        func = core.factory.number_cast('master_level_requirement'),
    },
    master_favour_cost = {
        property = 'Has master favour cost',
        func = core.factory.number_cast('master_favour_cost'),
    },
    variation_count = {
        property = 'Has variation count',
        func = core.factory.number_cast('variation_count'),
    },
    -- Propehcy
    prophecy_id = {
        property = 'Has prophecy id',
        func = nil,
    },
    prediction_text = {
        property = 'Has prophecy prediction text',
        func = nil,
    },
    seal_cost_normal = {
        property = 'Has prophecy seal cost in normal difficulty',
        func = core.factory.number_cast('seal_cost_normal'),
    },
    seal_cost_cruel = {
        property = 'Has prophecy seal cost in cruel difficulty',
        func = core.factory.number_cast('seal_cost_cruel'),
    },
    seal_cost_merciless = {
        property = 'Has prophecy seal cost in merciless difficulty',
        func = core.factory.number_cast('seal_cost_merciless'),
    },
    -- ------------------------------------------------------------------------
    -- derived stats
    -- ------------------------------------------------------------------------
   
    -- For rarity != normal, rarity already verified
    base_item = {
        no_copy = true,
        property = 'Has base item',
        func = function ()
            g_args.base_item = g_args.base_item_data['Has name']
        end,
    },
    base_item_id = {
        no_copy = true,
        property = 'Has base item metadata id',
        func = function()
            g_args.base_item_id = g_args.base_item_data['Has metadata id']
        end,
    },
    base_item_page = {
        no_copy = true,
        property = 'Has base item wiki page',
        func = function()
            g_args.base_item_page = g_args.base_item_data[1]
        end,
    },
   
    name_list = {
        no_copy = true,
        property = 'Has names',
        func = function ()
            if g_args.name_list ~= nil then
                g_args.name_list = util.string.split(g_args.name_list, ', ')
                g_args.name_list[#g_args.name_list+1] = g_args.name
            else
                g_args.name_list = {g_args.name}
            end
        end,
    },
    name_list_lower = {
        no_copy = true,
        property = 'Has lowercase names',
        func = function()
            g_args.name_list_lower = {}
            for index, value in ipairs(g_args.name_list) do
                g_args.name_list_lower[index] = string.lower(value)
            end
        end,
    },
    gem_tags_difference = {
        no_copy = true,
        property = 'Has gem tags difference',
        func = function()
            if g_args.gem_tags ~= nil then
                local gtags = {}
                -- copy tags
                for _, data in ipairs(m_game.constants.item.gem_tags) do
                    if data.full and data.full ~= '' then
                        gtags[data.full] = true
                    end
                end
                -- delete existing tags
                for _, tag in ipairs(g_args.gem_tags) do
                    gtags[tag] = nil
                end
               
                -- add them as ordered list and not as hash table so it is consistent with the other gem tag list
                g_args.gem_tags_difference = {}
                for key, value in pairs(gtags) do
                    g_args.gem_tags_difference[#g_args.gem_tags_difference+1] = key
                end
            end
        end,
    },
    frame_type = {
        no_copy = true,
        property = nil,
        func = function ()
            if g_args.name == 'Prophecy' or g_args.base_item == 'Prophecy' then
                g_args.frame_type = 'prophecy'
                return
            end
       
            local var = core.class_specifics[g_args.class]
            if var ~= nil and var.frame_type ~= nil then
                g_args.frame_type = var.frame_type
                return
            end
           
            g_args.frame_type = string.lower(g_args.rarity)
        end,
    },
    --
    -- args populated by mod validation
    --
    mods = {
        no_copy = true,
        property = 'Has mod ids',
        default = {},
    },
    implicit_mods = {
        property = 'Has implicit mod ids',
        property_func = function ()
            g_args.implicit_mods = util.string.split(g_args.implicit_mods, '<MANY>')
            for _, modid in ipairs(g_args.implicit_mods) do
                g_args.mods[#g_args.mods+1] = modid
                g_args._mods[#g_args._mods+1] = {
                    result=nil,
                    modid=modid,
                    type='implicit',
                }
            end
        end,
        default = {},
    },
    explicit_mods = {
        no_copy = true,
        property = 'Has explicit mod ids',
        default = {},
    },
}


core.stat_map = {
-- helper to loop over the range variables easier
    range = {
c.range_map = {
        property = 'Has weapon range',
     min = '_range_minimum',
        stats_add = {
     max = '_range_maximum',
            'local_weapon_range_+',
     avg = '_range_average',
        },
        minimum = 0,
    },
    damage_min = {
        property = 'Has minimum physical damage',
        stats_add = {
            'local_minimum_added_physical_damage',
        },
        stats_increased = {
            'local_physical_damage_+%',
        },
        minimum = 0,
    },
    damage_max = {
        property = 'Has maximum physical damage',
        stats_add = {
            'local_maximum_added_physical_damage',
        },
        stats_increased = {
            'local_physical_damage_+%',
        },
        minimum = 0,
    },
    fire_damage_min = {
        default = 0,
        property = 'Has minimum fire damage',
        stats_add = {
            'local_minimum_added_fire_damage',
        },
        minimum = 0,
    },
    fire_damage_max = {
        default = 0,
        property = 'Has maximum fire damage',
        stats_add = {
            'local_maximum_added_fire_damage',
        },
        minimum = 0,
    },
    cold_damage_min = {
        default = 0,
        property = 'Has minimum cold damage',
        stats_add = {
            'local_minimum_added_cold_damage',
        },
        minimum = 0,
    },
    cold_damage_max = {
        default = 0,
        property = 'Has maximum cold damage',
        stats_add = {
            'local_maximum_added_cold_damage',
        },
        minimum = 0,
    },
    lightning_damage_min = {
        default = 0,
        property = 'Has minimum lightning damage',
        stats_add = {
            'local_minimum_added_lightning_damage',
        },
        minimum = 0,
    },
    lightning_damage_max = {
        default = 0,
        property = 'Has maximum lightning damage',
        stats_add = {
            'local_maximum_added_lightning_damage',
        },
        minimum = 0,
    },
    chaos_damage_min = {
        default = 0,
        property = 'Has minimum chaos damage',
        stats_add = {
            'local_minimum_added_chaos_damage',
        },
        minimum = 0,
    },
    chaos_damage_max = {
        default = 0,
        property = 'Has maximum chaos damage',
        stats_add = {
            'local_maximum_added_chaos_damage',
        },
        minimum = 0,
    },
    critical_strike_chance = {
        property = 'Has critical strike chance',
        stats_add = {
            'local_critical_strike_chance',
        },
        stats_increased = {
            'local_critical_strike_chance_+%',
        },
        minimum = 0,
    },
    attack_speed = {
        property = 'Has attack speed',
        stats_increased = {
            'local_attack_speed_+%',
        },
        minimum = 0,
    },
    flask_life = {
        property = 'Has flask life recovery',
        stats_add = {
            'local_flask_life_to_recover',
        },
        stats_increased = {
            'local_flask_life_to_recover_+%',
        },
    },
    flask_mana = {
        property = 'Has flask mana recovery',
        stats_add = {
            'local_flask_mana_to_recover',
        },
        stats_increased = {
            'local_flask_mana_to_recover_+%',
        },
    },
     flask_duration = {
        property = 'Has flask duration',
        stats_increased = {
            'local_flask_recovery_speed_+%',
        },
        minimum = 0,
    },
     charges_per_use = {
        property = 'Has flask charges per use',
        stats_increased = {
            'local_charges_used_+%',
        },
        minimum = 0,
    },
     charges_max = {
        property = 'Has maximum flask charges',
        stats_add = {
            'local_extra_max_charges',
        },
        stats_increased = {
            'local_max_charges_+%',
            'local_charges_added_+%',
        },
        minimum = 0,
    },
    block = {
        property = 'Has block',
        stats_add = {
            'local_additional_block_chance_%',
        },
        minimum = 0,
    },
    armour = {
        property = 'Has armour',
        stats_add = {
            'local_base_physical_damage_reduction_rating',
        },
        stats_increased = {
            'local_physical_damage_reduction_rating_+%',
            'local_armour_and_energy_shield_+%',
            'local_armour_and_evasion_+%',
            'local_armour_and_evasion_and_energy_shield_+%',
        },
        minimum = 0,
    },
    evasion = {
        property = 'Has evasion',
        stats_add = {
            'local_base_evasion_rating',
        },
        stats_increased = {
            'local_evasion_rating_+%',
            'local_evasion_and_energy_shield_+%',
            'local_armour_and_evasion_+%',
            'local_armour_and_evasion_and_energy_shield_+%',
        },
        minimum = 0,
    },
    energy_shield = {
        property = 'Has energy shield',
        stats_add = {
            'local_energy_shield'
        },
        stats_increased = {
            'local_energy_shield_+%',
            'local_armour_and_energy_shield_+%',
            'local_evasion_and_energy_shield_+%',
            'local_armour_and_evasion_and_energy_shield_+%',
        },
        minimum = 0,
    },
    required_dexterity = {
        property = 'Has dexterity requirement',
        stats_add = {
            'local_dexterity_requirement_+'
        },
        stats_increased = {
            'local_attribute_requirements_+%',
        },
        minimum = 0,
    },
    required_intelligence = {
        property = 'Has intelligence requirement',
        stats_add = {
            'local_intelligence_requirement_+'
        },
        stats_increased = {
            'local_attribute_requirements_+%',
        },
        minimum = 0,
    },
    required_strength = {
        property = 'Has strength requirement',
        stats_add = {
            'local_strength_requirement_+'
        },
        stats_increased = {
            'local_attribute_requirements_+%',
        },
        minimum = 0,
    },
}
}


core.dps_map = {
    {
        name = 'physical_dps',
        property = 'physical damage per second',
        damage_args = {'damage', },
        label = util.html.abbr('pDPS', 'physical damage per second'),
    },
    {
        name = 'fire_dps',
        property = 'fire damage per second',
        damage_args = {'fire_damage'},
        label = util.html.abbr('Fire DPS', 'fire damage per second'),
    },
    {
        name = 'cold_dps',
        property = 'cold damage per second',
        damage_args = {'cold_damage'},
        label = util.html.abbr('Cold DPS', 'cold damage per second'),
    },
    {
        name = 'lightning_dps',
        property = 'lightning damage per second',
        damage_args = {'lightning_damage'},
        label = util.html.abbr('Light. DPS', 'lightning damage per second'),
    },
    {
        name = 'chaos_dps',
        property = 'chaos damage per second',
        damage_args = {'chaos_damage'},
        label = util.html.abbr('Chaos DPS', 'chaos damage per second'),
    },
    {
        name = 'elemental_dps',
        property = 'elemental damage per second',
        damage_args = {'fire_damage', 'cold_damage', 'lightning_damage'},
        label = util.html.abbr('eDPS', 'elemental damage (i.e. fire/cold/lightning) per second'),
    },
    {
        name = 'poison_dps',
        property = 'poison damage per second',
        damage_args = {'damage', 'chaos_damage'},
        label = util.html.abbr('Poison DPS', 'poison damage (i.e. physical/chaos) per second'),
    },
    {
        name = 'dps',
        property = 'damage per second',
        damage_args = {'damage', 'fire_damage', 'cold_damage', 'lightning_damage', 'chaos_damage'},
        label = util.html.abbr('DPS', 'total damage (i.e. physical/fire/cold/lightning/chaos) per second'),
    },
}
-- base item is default, but will be validated later
-- Notes:
--  inventory_icon must always be before alternate_art_inventory_icons
core.default_args = {'class', 'rarity', 'name', 'name_list', 'name_list_lower', 'size_x', 'size_y', 'drop_enabled', 'drop_level', 'drop_level_maximum', 'required_level', 'required_level_final', 'inventory_icon', 'alternate_art_inventory_icons', 'flavour_text', 'help_text', 'tags', 'metadata_id', 'mods', 'implicit_mods', 'explicit_mods'}
-- frame_type is needed in stat_text
core.late_args = {'frame_type', 'implicit_stat_text', 'explicit_stat_text', 'stat_text'}
core.prophecy_args = {'prophecy_id', 'prediction_text', 'seal_cost_normal', 'seal_cost_cruel', 'seal_cost_merciless'}
core.class_groups = {
    flasks = {
        keys = {['Life Flasks'] = true, ['Mana Flasks'] = true, ['Hybrid Flasks'] = true, ['Utility Flasks'] = true, ['Critical Utility Flasks'] = true},
        args = {'flask_duration', 'charges_max', 'charges_per_use'},
    },
    weapons = {
        keys = {['Claws'] = true, ['Daggers'] = true, ['Wands'] = true, ['One Hand Swords'] = true, ['Thrusting One Hand Swords'] = true, ['One Hand Axes'] = true, ['One Hand Maces'] = true, ['Bows'] = true, ['Staves'] = true, ['Two Hand Swords'] = true, ['Two Hand Axes'] = true, ['Two Hand Maces'] = true, ['Sceptres'] = true, ['Fishing Rods'] = true},
        args = {'required_dexterity', 'required_intelligence', 'required_strength', 'critical_strike_chance', 'attack_speed', 'damage_min', 'damage_max', 'range'},
    },
    gems = {
        keys = {['Active Skill Gems'] = true, ['Support Skill Gems'] = true},
        args = {'dexterity_percent', 'strength_percent', 'intelligence_percent', 'primary_attribute', 'gem_tags', 'gem_tags_difference'},
    },
    armor = {
        keys = {['Gloves'] = true, ['Boots'] = true, ['Body Armours'] = true, ['Helmets'] = true, ['Shields'] = true},
        args = {'required_dexterity', 'required_intelligence', 'required_strength', 'armour', 'energy_shield', 'evasion'},
    },
    stackable = {
        keys = {['Currency'] = true, ['Stackable Currency'] = true, ['Hideout Doodads'] = true, ['Microtransactions'] = true, ['Divination Card'] = true},
        args = {'stack_size', 'stack_size_currency_tab', 'description', 'cosmetic_type'},
    },
}
core.class_specifics = {
    ['Amulets'] = {
        args = {'is_talisman'},
    },
    ['Life Flasks'] = {
        args = {'flask_life'},
    },
    ['Mana Flasks'] = {
        args = {'flask_mana'},
    },
    ['Hybrid Flasks'] = {
        args = {'flask_life', 'flask_mana'},
    },
    ['Utility Flasks'] = {
        args = {'buff_id', 'buff_values', 'buff_stat_text', 'buff_icon'},
    },
    ['Critical Utility Flasks'] = {
        args = {'buff_id', 'buff_values', 'buff_stat_text', 'buff_icon'},
    },
    ['Active Skill Gems'] = {
        args = {'skill_screenshot', 'gem_icon'},
        defaults = {
            help_text = 'Place into an item socket of the right colour to gain this skill. Right click to remove from a socket.',
            size_x = 1,
            size_y = 1,
        },
        frame_type = 'gem',
    },
    ['Support Skill Gems'] = {
        args = {'support_gem_letter_html'},
        defaults = {
            help_text = 'This is a Support Gem. It does not grant a bonus to your character, but skills in sockets connected to it. Place into an item socket connected to a socket containing the Active Skill Gem you wish to augment. Right click to remove from a socket.',
            size_x = 1,
            size_y = 1,
        },
        frame_type = 'gem',
    },
    ['Shields'] = {
        args = {'block'},
    },
    ['Maps'] = {
        args = {'map_tier', 'map_guild_character', 'map_area_id', 'map_area_level', 'unique_map_area_id', 'unique_map_area_level', 'unique_map_guild_character'},
        skip_stat_lines = {
            '%d+%% increased Quantity of Items found in this Area',
            '%d+%% increased Rarity of Items found in this Area',
            '%+%d+%% Monster pack size',
            -- ranges
            '%(%d+%-%d+%)%% increased Quantity of Items found in this Area',
            '%(%d+%-%d+%)%% increased Rarity of Items found in this Area',
            '%+%(%d+%-%d+%)%% Monster pack size',
        },
    },
    ['Currency'] = {
        frame_type = 'currency',
    },
    ['Stackable Currency'] = {
        args = {'is_essence', 'essence_level_restriction', 'essence_tier'},
        frame_type = 'currency',
    },
    ['Microtransactions'] = {
        frame_type = 'currency',
    },
    ['Hideout Doodads'] = {
        args = {'is_master_doodad', 'master', 'master_level_requirement', 'master_favour_cost', 'variation_count'},
        defaults = {
            help_text = 'Right click on this item then left click on a location on the ground to create the object.',
        },
        frame_type = 'currency',
    },
    ['Jewel'] = {
        defaults = {
            help_text = 'Place into an allocated Jewel Socket on the Passive Skill Tree. Right click to remove from the Socket.',
        },
        skip_stat_lines = {
            'Limited to %d+ %(Hidden%)',
            'Jewel has a radius of %d+ %(Hidden%)',
        },
    },
    ['Quest Items'] = {
        frame_type = 'quest',
    },
    ['Divination Card'] = {
        frame_type = 'divicard',
    },
    ['Labyrinth Item'] = {
        frame_type = 'currency',
    },
    ['Labyrinth Trinket'] = {
        args = {'description', 'buff_icon'},
        frame_type = 'currency',
    },
}
-- add defaults from class specifics and class groups
core.item_classes = {}
for _, data in ipairs(m_game.constants.item.class) do
    core.item_classes[data['full']] = {
        args = xtable:new(),
        defaults = {},
    }
end
for _, row in pairs(core.class_groups) do
    for k, _ in pairs(row.keys) do
        core.item_classes[k].args:insertT(row.args)
    end
end
for k, row in pairs(core.class_specifics) do
    if row.args ~= nil then
        core.item_classes[k].args:insertT(row.args)
    end
    if row.defaults ~= nil then
        for key, value in pairs(row.defaults) do
            core.item_classes[k].defaults[key] = value
        end
  end
end
-- GroupTable -> RowTable -> formatter function
--
--
-- Contents here are meant to resemble the ingame infobox of items
--
--
 
c.item_infobox_groups = {
core.display_groups = {
     -- [n]:
     -- Tags, stats, level, etc
    --  class: Additional css class added to group tag
    --  heading: Group heading text (used for extras)
    --  lines:
    --  [n]:
    --    show: Show line if this function returns true; Always show if boolean true. Default: Always show
    --    func: Function that returns line text
     {
     {
        -- Item type (weapons, hideout decorations, abyss jewels)
         {
         {
             args = {'cosmetic_type'},
             show = function (tpl_args)
            func = core.factory.display_value{
                return i18n.item_class_map[tpl_args.class_id] ~= nil
                options = {
            end,
                    [1] = {
            func = function (tpl_args)
                        key = 'cosmetic_type',
                 return i18n.item_class_map[tpl_args.class_id]
                        fmt = '%s',
             end,
                        color = 'default'
                    },
                 },
             },
         },
         },
        -- Cosmetic item type
         {
         {
             args = function ()
             show = h.factory.maybe_show_infobox_line{
                if g_args.class == nil then
                 keys = {'cosmetic_type'},
                    return false
                 conditions = {processed = true},
                end
               
                return core.class_groups.weapons.keys[g_args.class] ~= nil
            end,
            func = core.factory.display_value{
                 options = {
                    [1] = {
                        key = 'class',
                        color = 'default',
                    },
                 },
             },
             },
            func = h.factory.display_raw_value('cosmetic_type'),
         },
         },
        -- Gems
         {
         {
             args = {'gem_tags'},
             show = h.factory.maybe_show_infobox_line{
             func = function ()
                keys = {'gem_tags'},
                conditions = {processed = true},
            },
             func = function (tpl_args)
                 local out = {}
                 local out = {}
                 for i, tag in ipairs(g_args.gem_tags) do
                 for i, tag in ipairs(tpl_args.gem_tags) do
                     out[#out+1] = string.format('[[:Category:%s (gem tag)|%s]]', tag, tag)
                     out[#out+1] = string.format(i18n.gem_tag_category, tag, tag)
                 end
                 end
               
                 return table.concat(out, ', ')
                 return table.concat(out, ', ')
             end,
             end,
         },
         },
         {
         {
             args = {'support_gem_letter_html'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'support_gem_letter_html'},
                 options = {
                conditions = {processed = true},
                     [1] = {
            },
             func = core.factory.infobox_line{
                 parts = {
                     {
                         key = 'support_gem_letter_html',
                         key = 'support_gem_letter_html',
                         before = 'Icon: ',
                         color = false,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.support_icon,
             },
             },
         },
         },
         {
         {
             args = {'radius'},
             show = function (tpl_args)
             func = core.factory.display_value{
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
                 options = {
            end,
                     [1] = {
            func = function (tpl_args)
                         key = 'radius',
                local value = {
                         before = 'Radius: ',
                    base = 1,
                         func = core.factory.descriptor_value{key='radius_description'},
                    min = 1,
                    max = tpl_args.max_level,
                }
                local options = {
                    fmt = '%i',
                    color = 'value',
                }
                return string.format(
                    i18n.tooltips.level,
                    m_util.html.format_value(tpl_args, value, options)
                )
             end,
        },
        {
            show = function (tpl_args)
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = function (tpl_args)
                 local parts = {}
                for k, v in pairs(m_game.constants.skill.cost_types) do
                     parts[#parts+1] = {
                         key = 'cost_' .. k,
                         func = function (tpl_args, value)
                            if string.find(k, 'PerMinute', 1, true) then
                                value = value / 60 -- Cost per second
                            end
                            return value
                        end,
                        fmt = '%i',
                         inline = string.format(
                            '%%s%s %s',
                            string.find(k, 'Percent', 1, true) and '%%' or '',
                            v.long_upper
                        ),
                    }
                end
                return core.factory.infobox_line{
                    type = 'gem',
                    parts = parts,
                    sep = ', ',
                    fmt = i18n.tooltips.cost,
                }(tpl_args)
            end,
        },
        {
            show = function (tpl_args)
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'mana_reservation_flat',
                        fmt = '%i',
                        inline = '%s ' .. m_game.constants.skill.cost_types['Mana'].long_upper,
                    },
                    {
                        key = 'mana_reservation_percent',
                        fmt = '%i',
                        inline = '%s%% ' .. m_game.constants.skill.cost_types['Mana'].long_upper,
                     },
                     },
                     [2] = {
                     {
                         key = 'radius_seceondary',
                         key = 'life_reservation_flat',
                         before = ' / ',
                         fmt = '%i',
                         func = core.factory.descriptor_value{key='radius_secondary_description'},
                         inline = '%s ' .. m_game.constants.skill.cost_types['Life'].long_upper,
                     },
                     },
                     [3] = {
                     {
                         key = 'radius_tertiary',
                         key = 'life_reservation_percent',
                         before = ' / ',
                         fmt = '%i',
                         func = core.factory.descriptor_value{key='radius_tertiary_description'},
                         inline = '%s%% ' .. m_game.constants.skill.cost_types['Life'].long_upper,
                     },
                     },
                 },
                 },
                sep = ', ',
                fmt = i18n.tooltips.reservation,
             },
             },
         },
         },
        -- TODO: gem level here. Maybe put max level here?
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has cost_multiplier
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 type='gem',
                 type = 'gem',
                 options = {
                 parts = {
                     [1] = {
                     {
                         key = 'mana_cost',
                         key = 'cost_multiplier',
                         hide_default = 100,
                         hide_default = 100,
                         fmt = function ()
                         fmt = '%i',
                            if g_args.has_percentage_mana_cost then
                         inline = '%s%%',
                                return '%i%%'
                            else
                                return '%i'
                            end
                        end,
                         before = function ()
                            if g_args.has_reservation_mana_cost then
                                return 'Mana Reserved: '
                            else
                                return 'Mana Cost: '
                            end
                        end,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.cost_multiplier,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has cooldown
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 type='gem',
                 type = 'gem',
                 options = {
                 parts = {
                     [1] = {
                     {
                         key = 'mana_multiplier',
                         key = 'cooldown',
                         hide_default = 100,
                         hide_default = 0,
                         fmt = '%i%%',
                         fmt = '%.2f ' .. m_game.units.seconds.short_lower,
                        before = 'Mana Multiplier: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.cooldown_time,
             },
             },
         },
         },
         {
         {
             args = nil,
             -- TODO: Combine with cooldown. Multi-use non-vaal skills display uses together with cooldown time. E.g., Cooldown Time: 8.00 sec (3 uses)
             func = core.factory.display_value{
            show = true,
                 type='gem',
             func = core.factory.infobox_line{
                 options = {
                 type = 'gem',
                     [1] = {
                 parts = {
                         key = 'vaal_souls_requirement',
                     {
                         key = 'stored_uses',
                         hide_default = 0,
                         hide_default = 0,
                         fmt = '%i (N) / ',
                         fmt = '%i',
                        before = 'Souls per use: ',
                     },
                     },
                     [2] = {
                },
                fmt = i18n.tooltips.stored_uses,
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_souls_requirement
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                     {
                         key = 'vaal_souls_requirement',
                         key = 'vaal_souls_requirement',
                         hide_default = 0,
                         hide_default = 0,
                         fmt = '%i (C) / ',
                         fmt = '%i',
                        func = function (value)
                            return value*1.5
                        end,
                    },
                    [3] = {
                        key = 'vaal_souls_requirement',
                        hide_default = 0,
                        fmt = '%i (M)',
                        func = function (value)
                            return value*2
                        end,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.vaal_souls_per_use,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has vaal_stored_uses
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 type='gem',
                 type = 'gem',
                 options = {
                 parts = {
                     [1] = {
                     {
                         key = 'vaal_stored_uses',
                         key = 'vaal_stored_uses',
                         hide_default = 0,
                         hide_default = 0,
                         fmt = '%i',
                         fmt = '%i',
                        before = 'Can store ',
                        after = ' use(s)',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.stored_uses, -- TODO: Singular or plural based on number
             },
             },
         },
         },
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has vaal_soul_gain_prevention_time
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 type='gem',
                 type = 'gem',
                 options = {
                 parts = {
                     [1] = {
                     {
                         key = 'stored_uses',
                         key = 'vaal_soul_gain_prevention_time',
                         hide_default = 0,
                         hide_default = 0,
                         fmt = '%i',
                         -- Technically it rounds to nearest, but it is given in milliseconds in the data,  
                        before = 'Can store ',
                         fmt = '%i ' .. m_game.units.seconds.short_lower,
                         after = ' use(s)',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.vaal_soul_gain_prevention_time,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = function (tpl_args)
             func = core.factory.display_value{
                return tpl_args.cast_time and tpl_args.gem_tags and (m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) or m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.warcry.tag))
                type='gem',
            end,
                options = {
             func = function (tpl_args)
                    [1] = {
                return core.factory.infobox_line{
                        key = 'cooldown',  
                    parts = {
                        hide_default = 0,
                        {
                        fmt = '%.2f sec',
                            key = 'cast_time',
                         before = 'Cooldown Time: ',
                            fmt = function (tpl_args, value)
                                if value.min == 0 then
                                    return i18n.tooltips.instant_cast_time
                                end
                                return '%.2f ' .. m_game.units.seconds.short_lower
                            end,
                         },
                     },
                     },
                 },
                    fmt = m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) and i18n.tooltips.cast_time or i18n.tooltips.use_time,
             },
                 }(tpl_args)
             end,
         },
         },
         {
         {
             args = {'cast_time'},
             show = true, -- TODO: Show only if has attack_time
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 options = {
                 type = 'gem',
                     [1] = {
                parts = {
                         key = 'cast_time',
                     {
                         key = 'attack_time',
                         hide_default = 0,
                         hide_default = 0,
                         fmt = '%.2f sec',
                         fmt = '%.2f ' .. m_game.units.seconds.short_lower,
                        before = 'Cast Time: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.attack_time,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has critical_strike_chance
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 type='gem',
                 type = 'gem',
                 options = {
                 parts = {
                     [1] = {
                     {
                         key = 'critical_strike_chance',
                         key = 'critical_strike_chance',
                         hide_default = 0,
                         hide_default = 0,
                         fmt = '%.2f%%',
                         fmt = '%.2f%%',
                        before = 'Critical Strike Chance: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.critical_strike_chance,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has attack_speed_multiplier
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 type='gem',
                 type = 'gem',
                 options = {
                 parts = {
                     [1] = {
                     {
                         key = 'damage_effectiveness',
                         key = 'attack_speed_multiplier',
                         hide_default = 100,
                         hide_default = 100,
                         fmt = '%i%%',
                         fmt = '%i',
                         before = 'Damage Effectiveness: ',
                         inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.attack_speed_multiplier,
             },
             },
         },
         },
         {
         {
             args = {'projectile_speed'},
             show = true, -- TODO: Show only if has damage_multiplier
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 options = {
                 type = 'gem',
                     [1] = {
                parts = {
                         key = 'projectile_speed',
                     {
                         before = 'Projectile Speed: ',
                         key = 'damage_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                         inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.damage_multiplier,
             },
             },
         },
         },
        -- Weapon only
         {
         {
             args = {'damage_min', 'damage_max'},
             show = true, -- TODO: Show only if has damage_effectiveness
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 options = {
                 type = 'gem',
                     [1] = {
                parts = {
                         key = 'damage_min',
                     {
                         hide_default = 0,
                         key = 'damage_effectiveness',
                         hide_default = 100,
                         fmt = '%i',
                         fmt = '%i',
                         after = '&ndash;',
                         inline = '%s%%',
                        before = 'Physical Damage: '
                     },
                     },
                    [2] = {
                },
                        key = 'damage_max',
                fmt = i18n.tooltips.damage_effectiveness,
                        hide_default = 0,
            },
                         fmt = '%i',
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'projectile_speed'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                         key = 'projectile_speed',
                     },
                     },
                 },
                 },
             },      
                fmt = i18n.tooltips.projectile_speed,
             },
         },
         },
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'radius'},
                 before='Elemental Damage: ',
            },
                options = {
             func = core.factory.infobox_line{
                     [1] = {
                 parts = {
                         key = 'fire_damage_min',
                     {
                         hide_default = 0,
                         key = 'radius',
                        fmt = '%i',
                         func = h.factory.descriptor_value{key='radius_description'},
                        after = h.new_color('fire', '&ndash;'),
                        color = 'fire',
                     },
                     },
                     [2] = {
                     {
                         key = 'fire_damage_max',
                         key = 'radius_secondary',
                         hide_default = 0,
                         func = h.factory.descriptor_value{key='radius_secondary_description'},
                        fmt = '%i',
                        after = ' ',
                        color = 'fire',
                     },
                     },
                     [3] = {
                     {
                         key = 'cold_damage_min',
                         key = 'radius_tertiary',
                        hide_default = 0,
                         func = h.factory.descriptor_value{key='radius_tertiary_description'},
                        fmt = '%i',
                         after = h.new_color('cold', '&ndash;'),
                        color = 'cold',
                     },
                     },
                     [4] = {
                },
                         key = 'cold_damage_max',
                sep = ' / ',
                fmt = i18n.tooltips.aoe_radius,
            },
        },
        -- Quality is before item stats, but after gem stuff and item class
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'quality'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                     {
                         key = 'quality',
                        fmt = '+%i%%',
                        color = 'mod',
                         hide_default = 0,
                         hide_default = 0,
                        fmt = '%i',
                        after = ' ',
                        color = 'cold',
                     },
                     },
                    [5] = {
                },
                        key = 'lightning_damage_min',
                fmt = i18n.tooltips.quality,
                        hide_default = 0,
            },
                        fmt = '%i',
        },
                         after = h.new_color('lightning', '&ndash;'),
        -- Weapons
                         color = 'lightning',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'physical_damage_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                         key = 'physical_damage_html',
                         color = false, -- html already has color
                     },
                     },
                     [6] = {
                },
                        key = 'lightning_damage_max',
                fmt = i18n.tooltips.physical_damage,
                        hide_default = 0,
            },     
                         fmt = '%i',
        },
                         color = 'lightning',
        {
            show = true, -- Elemental Damage
            func = function (tpl_args)
                local keys = {'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}
                local elements = {}
                for _, key in ipairs(keys) do
                     if tpl_args[key] then
                        elements[#elements+1] = tpl_args[key]
                    end
                end
                local text = table.concat(elements, ', ') -- returns empty string if elements is empty
                if text ~= '' then
                    return string.format(i18n.tooltips.elemental_damage, text)
                end
                return
            end,     
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'chaos_damage_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                         key = 'chaos_damage_html',
                         color = false, -- html already has color
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.chaos_damage,
             },       
             },       
         },
         },
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
            func = core.factory.display_value{
                 keys = {'critical_strike_chance_html'},
                 before='Chaos Damage: ',
            },
                options = {
            func = core.factory.infobox_line{
                    [1] = {
                parts = {
                        key = 'chaos_damage_min',
                     {
                        hide_default = 0,
                         key = 'critical_strike_chance_html',
                        fmt = '%i',
                         color = false, -- html already has color
                        after = h.new_color('chaos', '&ndash;'),
                        color = 'chaos',
                     },
                    [2] = {
                         key = 'chaos_damage_max',
                         hide_default = 0,
                        fmt='%i',
                        color = 'chaos',
                     },
                     },
                 },
                 },
             },      
                fmt = i18n.tooltips.critical_strike_chance,
             },
         },
         },
         {
         {
             args = {'critical_strike_chance'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'attack_speed_html'},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         key = 'critical_strike_chance',
                 parts = {
                        fmt = '%.2f%%',
                     {
                         before = 'Critical Strike Chance: ',
                         key = 'attack_speed_html',
                         color = false, -- html already has color
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.attacks_per_second,
             },
             },
         },
         },
         {
         {
             args = {'attack_speed'},
             show = function (tpl_args)
             func = core.factory.display_value{
                -- Do not show for ranged weapons
                 options = {
                if tpl_args.tags and m_util.table.contains(tpl_args.tags, 'ranged') then
                     [1] = {
                    return false
                         key = 'attack_speed',
                end
                         fmt = '%.2f',
                return h.factory.maybe_show_infobox_line{
                         before = 'Attacks per Second: ',
                    keys = {'weapon_range_html'},
                }(tpl_args)
            end,
             func = core.factory.infobox_line{
                 parts = {
                     {
                         key = 'weapon_range_html',
                         color = false, -- html already has color
                         inline = '%s ' .. m_game.units.metres.long_lower,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.weapon_range,
             },
             },
         },
         },
         -- Map only
         -- Maps
         {
         {
             args = {'map_area_level'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'map_area_level'},
                 options = {
                conditions = {processed = true},
                     [1] = {
            },
             func = core.factory.infobox_line{
                 parts = {
                     {
                         key = 'map_area_level',
                         key = 'map_area_level',
                         fmt = '%i',
                         fmt = '%i',
                        before = 'Map Level: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.map_level,
             },
             },
         },
         },
         {
         {
             args = {'map_tier'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'map_tier'},
                 options = {
                conditions = {processed = true},
                     [1] = {
            },
             func = core.factory.infobox_line{
                 parts = {
                     {
                         key = 'map_tier',
                         key = 'map_tier',
                         fmt = '%i',
                         fmt = '%i',
                        before = 'Map Tier: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.map_tier,
             },
             },
         },
         },
         {
         {
             args = {'map_guild_character'},
             show = function (tpl_args)
             func = core.factory.display_value{
                return tpl_args.map_guild_character ~= nil and tpl_args.rarity_id == 'normal'
                 options = {
            end,
                     [1] = {
             func = core.factory.infobox_line{
                 parts = {
                     {
                         key = 'map_guild_character',
                         key = 'map_guild_character',
                        fmt = '%s',
                        before = util.html.abbr('Guild Character', 'When used in guild creation, this map can be used for the listed character') .. ': ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.map_guild_character,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.unique_map_guild_character ~= nil and tpl_args.rarity_id == 'unique'
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'unique_map_guild_character',
                    },
                },
                fmt = i18n.tooltips.map_guild_character,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = function (tpl_args)
             func = core.factory.display_value{
                return tpl_args.class_id == 'Map'
            end,
             func = core.factory.infobox_line{
                 type = 'stat',
                 type = 'stat',
                 options = {
                 parts = {
                     [1] = {
                     {
                         key = 'map_item_drop_quantity_+%',
                         key = 'map_item_drop_quantity_+%',
                         fmt = '+%i%%',
                         fmt = '%i',
                         color = 'mod',
                         color = 'mod',
                         before = 'Item Quantity: ',
                         inline = '+%s%%',
                        hide_default = 0,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.item_quantity,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = function (tpl_args)
             func = core.factory.display_value{
                return tpl_args.class_id == 'Map'
            end,
             func = core.factory.infobox_line{
                 type = 'stat',
                 type = 'stat',
                 options = {
                 parts = {
                     [1] = {
                     {
                         key = 'map_item_drop_rarity_+%',
                         key = 'map_item_drop_rarity_+%',
                         fmt = '+%i%%',
                         fmt = '%i',
                         color = 'mod',
                         color = 'mod',
                         before = 'Item Rarity: ',
                         inline = '+%s%%',
                        hide_default = 0,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.item_rarity,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = function (tpl_args)
             func = core.factory.display_value{
                return tpl_args.class_id == 'Map'
            end,
             func = core.factory.infobox_line{
                 type = 'stat',
                 type = 'stat',
                 options = {
                 parts = {
                     [1] = {
                     {
                         key = 'map_pack_size_+%',
                         key = 'map_pack_size_+%',
                         fmt = '+%i%%',
                         fmt = '%i',
                         color = 'mod',
                         color = 'mod',
                         before = 'Mosnter Pack Size: ',
                         inline = '+%s%%',
                        hide_default = 0,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.monster_pack_size,
             },
             },
         },
         },
         -- Jewel Only
         -- Jewels
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
            func = core.factory.display_value{
                 keys = {'jewel_limit'},
                 type = 'stat',
                 conditions = {processed = true},
                 options = {
            },
                    [1] = {
            func = core.factory.infobox_line{
                        keys = {'local_unique_item_limit'},
                parts = {
                        fmt = '%i',
                    {
                         before = 'Limited to: ',
                         key = 'jewel_limit',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.limited_to,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
            func = core.factory.display_value{
                 keys = {'jewel_radius_html'},
                 type = 'stat',
                 conditions = {processed = true},
                 options = {
            },
                    [1] = {
            func = core.factory.infobox_line{
                        keys = {'local_jewel_effect_base_radius'},
                parts = {
                        fmt = '%s',
                    {
                         func = function(value)
                         key = 'jewel_radius_html',
                            return string.format('%s (%i)', (m_game.constants.item.jewel_radius_to_size[value] or '?'), value)
                         color = false, -- html already has color
                        end,
                         before = 'Radius: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.radius,
             },
             },
         },
         },
         -- Flask only
         -- Flasks
         {
         {
             args = {'flask_mana', 'flask_duration'},
             show = h.factory.maybe_show_infobox_line{
                keys = {'flask_mana_html', 'flask_duration_html'},
            },
             --func = core.factory.display_flask('flask_mana'),
             --func = core.factory.display_flask('flask_mana'),
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 options = {
                 parts = {
                     [1] = {
                     {
                         key = 'flask_mana',
                         key = 'flask_mana_html',
                         fmt = '%i',
                         color = false, -- html already has color
                        before = 'Recovers ',
                     },
                     },
                     [2] = {
                     {
                         key = 'flask_duration',
                         key = 'flask_duration_html',
                        fmt = '%.2f',
                         color = false, -- html already has color
                         before = ' Mana over ',
                        after = ' seconds',
                     },
                     },
                 }
                 },
                fmt = i18n.tooltips.flask_mana_recovery,
             },
             },
         },
         },
         {
         {
             args = {'flask_life', 'flask_duration'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'flask_life_html', 'flask_duration_html'},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         key = 'flask_life',
                 parts = {
                        fmt = '%i',
                     {
                         before = 'Recovers ',
                         key = 'flask_life_html',
                         color = false, -- html already has color
                     },
                     },
                     [2] = {
                     {
                         key = 'flask_duration',
                         key = 'flask_duration_html',
                        fmt = '%.2f',
                         color = false, -- html already has color
                         before = ' Life over ',
                        after = ' seconds',
                     },
                     },
                 }
                 },
                fmt = i18n.tooltips.flask_life_recovery,
             },
             },
         },
         },
         {
         {
             -- don't display for mana/life flasks
             -- don't display for mana/life flasks
             args = function ()
             show = function (tpl_args)
                 for _, k in ipairs({'flask_life', 'flask_mana'}) do
                 for _, k in ipairs({'flask_life_html', 'flask_mana_html'}) do
                     if g_args[k] ~= nil then
                     if tpl_args[k] ~= nil then
                         return false
                         return false
                     end
                     end
                 end
                 end
               
                 return tpl_args['flask_duration_html'] ~= nil
                 return g_args['flask_duration'] ~= nil
             end,
             end,
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 options = {
                 parts = {
                     [1] = {
                     {
                         key = 'flask_duration',
                         key = 'flask_duration_html',
                        before = 'Lasts ',
                         color = false, -- html already has color
                         after = ' Seconds',
                        fmt = '%.2f',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.flask_duration,
             },
             },
         },
         },
         {
         {
             args = {'charges_per_use', 'charges_max'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'charges_per_use_html', 'charges_max_html'},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         key = 'charges_per_use',
                 parts = {
                        before = 'Consumes ',
                     {
                         fmt = '%i',
                         key = 'charges_per_use_html',
                         color = false, -- html already has color
                     },
                     },
                     [2] = {
                     {
                         key = 'charges_max',
                         key = 'charges_max_html',
                        before = ' of ',
                         color = false, -- html already has color
                         after = ' Charges on use',
                        fmt = '%i',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.flask_charges_per_use,
             },
             },
         },
         },
         {
         {
             args = {'buff_stat_text'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'buff_stat_text'},
                 options = {
                conditions = {processed = true},
                     [1] = {
            },
             func = core.factory.infobox_line{
                 parts = {
                     {
                         key = 'buff_stat_text',
                         key = 'buff_stat_text',
                         color = 'mod',
                         color = 'mod',
Line 2,327: Line 1,094:
             },
             },
         },
         },
         -- armor
         -- Armor
         {
         {
             args = {'block'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'block_html'},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         key = 'block',
                 parts = {
                         before = 'Block: ',
                     {
                         fmt = '%i%%',
                         key = 'block_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'block',
                    },
                },
                fmt = i18n.tooltips.chance_to_block,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'armour_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                         key = 'armour_html',
                         color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'armour',
                    },
                },
                fmt = i18n.tooltips.armour,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'evasion_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'evasion_html',
                        color = false, -- html already has color
                         hide_default = 0,
                         hide_default = 0,
                        hide_default_key = 'evasion',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.evasion,
             },
             },
         },
         },
         {
         {
             args = {'armour'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'energy_shield_html'},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         key = 'armour',
                 parts = {
                        before = 'Armour: ',
                     {
                         fmt = '%i',
                         key = 'energy_shield_html',
                         color = false, -- html already has color
                         hide_default = 0,
                         hide_default = 0,
                        hide_default_key = 'energy_shield',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.energy_shield,
             },
             },
         },
         },
         {
         {
             args = {'evasion'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'ward_html'},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         key = 'evasion',
                 parts = {
                        before = 'Evasion: ',
                     {
                         fmt = '%i',
                         key = 'ward_html',
                         color = false, -- html already has color
                         hide_default = 0,
                         hide_default = 0,
                        hide_default_key = 'ward',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.ward,
             },
             },
         },
         },
         {
         {
             args = {'energy_shield'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'movement_speed'},
                 options = {
                conditions = {processed = true},
                     [1] = {
            },
                         key = 'energy_shield',
             func = core.factory.infobox_line{
                        before = 'Energy Shield: ',
                 parts = {
                         fmt = '%i',
                     {
                         key = 'movement_speed',
                         fmt = '%i%%',
                         hide_default = 0,
                         hide_default = 0,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.movement_speed,
             },
             },
         },
         },
         -- Misc
         -- Stackables
         {
         {
             args = {'stack_size'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'stack_size'},
                 options = {
                conditions = {processed = true},
                     [1] = {
            },
             func = core.factory.infobox_line{
                 parts = {
                     {
                         key = 'stack_size',
                         key = 'stack_size',
                        fmt = '%i',
                         hide_default = 1,
                         hide_default = 1,
                    },
                },
                fmt = i18n.tooltips.stack_size,
            },
        },
        -- Essences
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'essence_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'essence_level',
                         fmt = '%i',
                         fmt = '%i',
                        before = 'Stack Size: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.essence_level,
             },
             },
         },
         },
         -- Essence stuff
         -- Oils
         {
         {
             args = {'essence_tier'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'blight_item_tier'},
                 options = {
                conditions = {processed = true},
                     [1] = {
            },
                         key = 'essence_tier',
             func = core.factory.infobox_line{
                 parts = {
                     {
                         key = 'blight_item_tier',
                         fmt = '%i',
                         fmt = '%i',
                        before = 'Essence Tier: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.blight_item_tier,
            },
        },
        -- Tattoos
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_target'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_target',
                    },
                },
                fmt = i18n.tooltips.tattoo_target,
             },
             },
         },
         },
    },
    -- Requirements
    {
         {
         {
             args = {'master', 'master_level_requirement'},
             show = h.factory.maybe_show_infobox_line{
             func = function()
                keys = {'tattoo_limit'},
                 -- masters have been validated before
                conditions = {processed = true},
                 local data
            },
                 for i, rowdata in ipairs(m_game.constants.masters) do
             func = core.factory.infobox_line{
                    if g_args.master == rowdata.full then
                 parts = {
                        data = rowdata
                    {
                        break
                        key = 'tattoo_limit',
                    end
                    },
                 end
                 },
               
                 fmt = i18n.tooltips.tattoo_limit,
                return h.new_color('default', 'Requires ') .. string.format('[[%s|%s %s]]', data.full, data.short_upper, g_args.master_level_requirement)
            },
             end
        },
        -- Harvest seeds (upper section)
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                 parts = {
                    {
                        key = 'seed_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.seed_tier,
             },
         },
         },
         {
         {
             args = function ()
             show = h.factory.maybe_show_infobox_line{
                 if g_args.drop_enabled == true then
                 keys = {'seed_tier'},
                    return false
                 conditions = {processed = true},
                 end
             },
                return true
             func = function (tpl_args)
             end,
                 return i18n.tooltips.seed_monster
             func = function()
                 local span = mw.html.create('span')
                span
                    :attr('class', 'infobox-disabled-drop')
                    :wikitext('DROP DISABLED')
                    :done()
                return tostring(span)
             end,
             end,
         },
         },
        -- Instead of item level, show drop level if any
         {
         {
             args = {'drop_enabled'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'seed_type_html'},
                 options = {
                conditions = {processed = true},
                     [1] = {
            },
                         key = 'drop_level',
             func = core.factory.infobox_line{
                 parts = {
                     {
                        key = 'seed_type_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.seed_lifeforce_gained,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_growth_cycles'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_growth_cycles',
                    },
                },
                fmt = i18n.tooltips.seed_growth_cycles,
            },
        },
        -- Heist
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'heist_required_npcs'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_npcs',
                    },
                },
                fmt = i18n.tooltips.heist_required_npc,
            },
        },
        -- Sentinels
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_duration'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_duration',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_duration,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_empowers'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_empowers',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_empowers,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_empowerment'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_empowerment',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_empowerment,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_monster', 'sentinel_monster_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_monster',
                    },
                    {
                        key = 'sentinel_monster_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_can_only_empower,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_charge'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                         key = 'sentinel_charge',
                         fmt = '%i',
                         fmt = '%i',
                        before = 'Drop Level: ',
                     },
                     },
                     [2] = {
                },
                         key = 'drop_level_maximum',
                fmt = i18n.tooltips.sentinel_charge,
                         hide_default = 100,
            },
        },
        -- Corpse items
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'monster_category_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'monster_category_html',
                        color = false, -- html already has color
                     },
                },
                fmt = i18n.tooltips.monster_category,
            },
        },
        -- Embers of the Allflame
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'pack_size_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                         key = 'pack_size_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.pack_size,
            },
        },
 
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'pack_leader_chance'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                return core.factory.infobox_line{
                    parts = {
                         {
                            key = 'pack_leader_chance',
                            hide_default = 0,
                            fmt = '%i%%',
                        },
                    },
                    fmt = tpl_args['pack_leader_chance'] < 100 and i18n.tooltips.pack_chance_to_contain_pack_leader or i18n.tooltips.pack_contains_pack_leader,
                }(tpl_args)
            end,
        },
    },
    -- Requirements
    {
        -- Talismans display their tier right above requirements
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'talisman_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'talisman_tier',
                         fmt = '%i',
                         fmt = '%i',
                        before = ' / ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.talisman_tier,
             },
             },
         },
         },
        -- Equipment requirements
         {
         {
             args = nil,
             show = true, -- Requires...
             func = function ()
             func = function (tpl_args)
                 local opt = {
                 local parts = {
                     [1] = {
                     {
                         key = 'required_level_final',
                         key = 'required_level_final_html',
                        color = false, -- html already has color
                        inline = i18n.tooltips.level_inline,
                         hide_default = 1,
                         hide_default = 1,
                         before = 'Level ',
                         hide_default_key = 'required_level_final',
                     },
                     },
                 }
                 }
               
                 for _, attr in ipairs(m_game.constants.attribute_order) do
                 for _, attr in ipairs(m_game.constants.attributes) do
                     parts[#parts+1] = {
                     opt[#opt+1] = {
                         key = string.format('required_%s_html', attr),
                         key = 'required_' .. attr['long_lower'],
                         color = false, -- html already has color
                         hide_default = 0,
                         inline = '%s ' .. m_game.constants.attributes[attr].short_upper,
                         before = ', ',
                         hide = function (tpl_args, value)
                         after = ' ' .. attr['short_upper'],
                            local min = m_game.constants.characters.minimum_attributes[m_game.constants.attributes[attr].short_lower]
                            return value.min <= min and value.max <= min
                        end,
                        hide_key = string.format('required_%s', attr),
                     }
                     }
                 end
                 end
                  
                 return core.factory.infobox_line{
                local requirements = core.factory.display_value{options = opt}()
                    parts = parts,
               
                     sep = ', ',
                -- return early
                    fmt = i18n.tooltips.requires,
                if requirements == nil then
                 }(tpl_args)
                     return
                end
               
                requirements = string.gsub(requirements, '^, ', '')
               
                 return h.new_color('default', 'Requires ') .. requirements
             end,
             end,
        },
        -- Tattoo requirements
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_min_adjacent'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_min_adjacent',
                        fmt = '%i',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.tattoo_min_adjacent,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_max_adjacent'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_max_adjacent',
                        fmt = '%i',
                        color = 'value',
                        inline = i18n.tooltips.tattoo_maximum .. ' %s',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.tattoo_max_adjacent,
            },
        },
        -- Heist gear requirements
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'heist_required_job', 'heist_required_job_level'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_job_level',
                    },
                    {
                        key = 'heist_required_job',
                    },
                },
                fmt = i18n.tooltips.heist_required_job,
            },
         },
         },
     },
     },
     -- Gem description
     -- Gem description
     {
     {
         css_class = '-textwrap text-color -gemdesc',
         class = 'tc -gemdesc',
         {
         {
             args = {'gem_description'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value_only('gem_description'),
                keys = {'gem_description'},
            },
             func = h.factory.display_raw_value('gem_description'),
         },
         },
     },
     },
     -- Gem Quality Stats
     -- Gem stats
     {
     {
         css_class = '-textwrap text-color -mod',
         class = 'tc -mod',
         {
         {
             args = {'quality_stat_text'},
             show = function (tpl_args)
            func = function ()
                 return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.stat_text
                 lines = {}
                lines[#lines+1] = h.new_color('default', 'Per 1% Quality:')
                lines[#lines+1] = g_args.quality_stat_text
               
                return table.concat(lines, '<br>')
             end,
             end,
            func = h.factory.display_raw_value('stat_text'),
         },
         },
    },
    -- Gem Implicit Stats
    {
        css_class = '-textwrap text-color -mod',
         {
         {
             args = function ()
             -- Gem quality selector widget
                 return core.class_groups.gems.keys[g_args.class] and g_args.stat_text
            -- Show in full infobox if gem has alternate quality
            -- Never show in hover infobox
            show = function (tpl_args)
                 return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.quality_type1_stat_text and tpl_args._flags.is_alt_quality_gem and tpl_args._infobox_container == 'infobox'
             end,
             end,
             func = function ()
             func = function (tpl_args)
                 lines = {}
                 local html = mw.html.create()
                 lines[#lines+1] = g_args.stat_text
                    :tag('br'):done()
                if g_args.gem_tags:contains('Vaal') then
                local widget = html:tag('span')
                    lines[#lines+1] = h.new_color('corrupted', 'Corrupted')  
                    :addClass('gemqual-widget')
                    :wikitext(m_util.html.poe_color('value', string.format(i18n.tooltips.gem_quality_effect_bonus, '')))
                local qtypes = {}
                 for k, quality_data in ipairs(tpl_args.skill_quality) do
                    qtypes[#qtypes+1] = m_game.constants.item.gem_quality_types[k].long_upper
                    local stats = widget:tag('span')
                        :addClass('gemqual-widget__stats')
                        :attr('data-qid', k)
                        :wikitext(quality_data.stat_text)
                    if k == 1 then
                        stats:addClass('is-selected')
                    end
                 end
                 end
                 return table.concat(lines, '<br>')
                 widget:attr('data-qtypes', table.concat(qtypes, ','))
                return tostring(html)
             end,
             end,
        },
        {
            -- Superior quality bonus
            -- Show in full infobox if gem does not have alternate quality
            -- Always show in hover infobox
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.quality_type1_stat_text and (not tpl_args._flags.is_alt_quality_gem or tpl_args._infobox_container == 'inline')
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'quality_type1_stat_text',
                        color = 'mod',
                        inline = i18n.tooltips.gem_quality_effect_bonus,
                        inline_color = 'value',
                    },
                },
                fmt = ' <br> %s',
            },
         },
         },
     },
     },
     -- Implicit Stats
     -- Implicit stats
     {
     {
         css_class = 'text-color -mod',
         class = 'tc -mod',
         func = function ()
         {
            if g_args.implicit_stat_text ~= '' then
            show = h.factory.maybe_show_infobox_line{
                return {g_args.implicit_stat_text}
                keys = {'implicit_stat_text'},
            else
            },
                 return {}
            func = function (tpl_args)
             end
                if tpl_args._infobox_container == 'inline' then
         end,
                    return h.strip_random_stats(tpl_args, tpl_args.implicit_stat_text)
                end
                 return tpl_args.implicit_stat_text
             end,
         },
     },
     },
     -- Stats
     -- Explicit stats
     {
     {
         css_class = 'text-color -mod',
         class = 'tc -mod',
         func = function ()
         {
            if g_args.explicit_stat_text ~= '' then
            show = h.factory.maybe_show_infobox_line{
                return {g_args.explicit_stat_text}
                keys = {'explicit_stat_text'},
            else
            },
                 return {}
            func = function (tpl_args)
             end
                if tpl_args._infobox_container == 'inline' then
         end,
                    return h.strip_random_stats(tpl_args, tpl_args.explicit_stat_text)
                end
                 return tpl_args.explicit_stat_text
             end,
         },
     },
     },
     -- Experience
     -- Experience
     {
     --[[{
         {
         {
             args = {'experience'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'experience'},
                 key = 'experience',
            },
                options = {
             func = core.factory.infobox_line{
                    [1] = {
                 parts = {
                    {
                        key = 'experience',
                         fmt = '%i',
                         fmt = '%i',
                     },
                     },
Line 2,567: Line 1,682:
             },
             },
         },
         },
     },
     },]]--
     -- Description (currency, doodads)
     -- Harvest seeds (lower section)
     {
     {
         css_class = '-textwrap text-color -mod',
         class = 'tc -mod',
         {
         {
             args = {'description'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value_only('description'),
                keys = {'seed_consumed_wild_lifeforce_percentage'},
                conditions = {processed = true},
            },
             func = function (tpl_args)
                if tpl_args.seed_consumed_wild_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_wild_lifeforce_percentage, m_util.html.poe_color('wild', m_game.seed_types.wild))
                end
            end
         },
         },
    },
    -- Variations (for doodads)
    {
      css_class = 'text-color -mod',
         {
         {
             args = {'variation_count'},
             show = h.factory.maybe_show_infobox_line{
             func = function ()
                keys = {'seed_consumed_vivid_lifeforce_percentage'},
                local txt
                conditions = {processed = true},
                 if g_args.variation_count == 1 then
            },
                     txt = 'Variation'
             func = function (tpl_args)
                else
                 if tpl_args.seed_consumed_vivid_lifeforce_percentage > 0 then
                    txt = 'Variations'
                     return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_vivid_lifeforce_percentage, m_util.html.poe_color('vivid', m_game.seed_types.vivid))
                 end
                 end
                return string.format('%i %s', g_args.variation_count, txt)
             end
             end,
         },
         },
    },
    -- Flavour Text
    {
        css_class = '-textwrap text-color -flavour',
         {
         {
             args = {'flavour_text'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value_only('flavour_text'),
                keys = {'seed_consumed_primal_lifeforce_percentage'},
                conditions = {processed = true},
            },
             func = function (tpl_args)
                if tpl_args.seed_consumed_primal_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_primal_lifeforce_percentage, m_util.html.poe_color('primal', m_game.seed_types.primal))
                end
            end
         },
         },
    },
    -- Prophecy text
    {
        css_class = '-textwrap text-color -value',
         {
         {
             args = {'prediction_text'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value_only('prediction_text'),
                keys = {'seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_required_nearby_seed_amount',
                    },
                    {
                        key = 'seed_type_html',
                    },
                    {
                        key = 'seed_required_nearby_seed_tier',
                    },
                },
                fmt = i18n.tooltips.seed_required_seeds,
                color = 'mod',
            },
         },
         },
     },
     },
    -- Help text
     {
     {
         css_class = '-textwrap text-color -help',
         class = 'tc -crafted',
         {
         {
             args = {'help_text'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value_only('help_text'),
                keys = {'seed_effect'},
                conditions = {processed = true},
            },
             func = h.factory.display_raw_value('seed_effect'),
         },
         },
     },
     },
     -- Cost (i.e. vendor costs)
     -- Description
     {
     {
         --css_class = '',
         class = 'tc -mod',
         {
         {
             args = {'master_favour_cost'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'description'},
                options = {
                conditions = {processed = true},
                    [1] = {
            },
                        key = 'master_favour_cost',
             func = h.factory.display_raw_value('description'),
                        before = 'Favour cost: ',
        },
                         color = 'currency',
        --[[{
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_additional_crafting_options'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                         key = 'plant_booster_additional_crafting_options',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.plant_booster_additional_crafting_options,
             },
             },
         },
         },
         {
         {
             args = {'seal_cost_normal', 'seal_cost_cruel', 'seal_cost_merciless'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'plant_booster_extra_chances'},
                 options = {
                conditions = {processed = true},
                     [1] = {
            },
                         key = 'seal_cost_normal',
             func = core.factory.infobox_line{
                        before = 'Seal cost: <br>',
                 parts = {
                         fmt = '%dx/',
                     {
                        color = 'currency',
                         key = 'plant_booster_extra_chances',
                         fmt = '%s%%',
                     },
                     },
                    [2] = {
                },
                        key = 'seal_cost_cruel',
                fmt = i18n.tooltips.plant_booster_extra_chances,
                        fmt = '%dx/',
            },
                        color = 'currency',
        },
                    },
        {
                    [3] = {
            show = h.factory.maybe_show_infobox_line{
                        key = 'seal_cost_merciless',
                keys = {'plant_booster_lifeforce'},
                        fmt = '%dx',
                conditions = {processed = true},
                        color = 'currency',
            },
                        after = function ()
            func = core.factory.infobox_line{
                            -- direct call will mess up g_args
                parts = {
                            return g_frame:expandTemplate{title='Item link',args={item_name_exact='Silver Coin'}}
                    {
                        end,
                        key = 'plant_booster_lifeforce',
                        fmt = '%s%%',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.plant_booster_lifeforce,
            },
        },]]
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'monster_abilities'},
                conditions = {processed = true},
             },
             },
            func = h.factory.display_raw_value('monster_abilities'),
         },
         },
     },
     },
}
    -- Variations (for hideout decorations)
 
core.item_link_params = {'name', 'inventory_icon', 'html'}
core.item_link_broken_cat = '[[Category:Pages with broken item links]]'
 
core.result = {}
 
core.result.generic_item = {
     {
     {
         arg = 'essence',
         class = 'tc -mod',
         header = 'Essence<br>Tier',
         {
        property = 'Has essence tier',
            show = h.factory.maybe_show_infobox_line{
        cast = tonumber,
                keys = {'variation_count'},
        display = h.tbl.display.na_or_val,
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.variation_count > 1 then
                    return string.format('%i %s', tpl_args.variation_count, i18n.tooltips.variations)
                end
                return nil
            end,
        },
     },
     },
    -- Corrupted
     {
     {
         arg = 'drop_level',
         class = 'tc -corrupted',
         header = 'Drop<br>Level',
         {
        property = 'Has drop level',
            show = h.factory.maybe_show_infobox_line{
        cast = tonumber,
                keys = {'is_corrupted'},
        display = h.tbl.display.na_or_val,
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_corrupted then
                    return i18n.tooltips.corrupted
                end
                return nil
            end,
        },
     },
     },
    -- Mirrored
     {
     {
         arg = 'stack_size',
         class = 'tc -mod',
         header = 'Stack<br>Size',
         {
        property = 'Has stack size',
            show = h.factory.maybe_show_infobox_line{
        cast = tonumber,
                keys = {'is_mirrored'},
        display = h.tbl.display.na_or_val,
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_mirrored then
                    return i18n.tooltips.mirrored
                end
                return nil
            end,
        },
     },
     },
    -- Unmodifiable
     {
     {
         arg = 'stack_size_currency_tab',
         class = 'tc -mod',
         header = util.html.abbr('Tab<br>Stack<br>Size', 'Stack size in the currency stash tab'),
         {
        property = 'Has currency tab stack size',
            show = h.factory.maybe_show_infobox_line{
        cast = tonumber,
                keys = {'is_unmodifiable'},
        display = h.tbl.display.na_or_val,
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_unmodifiable then
                    return i18n.tooltips.unmodifiable
                end
                return nil
            end,
        },
     },
     },
    -- Flavour text
     {
     {
         arg = 'level',
         class = 'tc -flavour',
         header = m_game.level_requirement.icon,
         {
        property = 'Has level requirement',
            show = h.factory.maybe_show_infobox_line{
        cast = tonumber,
                keys = {'flavour_text'},
        display = h.tbl.display.na_or_val,
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('flavour_text'),
        },
     },
     },
    -- Prophecy text
     {
     {
         arg = 'ar',
         class = 'tc -value',
         header = util.html.abbr('AR', 'Armour'),
         {
        property = 'Has armour range average',
            show = h.factory.maybe_show_infobox_line{
        cast = nil,
                keys = {'prediction_text'},
        display = h.tbl.display.factory.range{property='armour'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('prediction_text'),
        },
     },
     },
    -- Can not be traded or modified
     {
     {
         arg = 'ev',
         class = 'tc -canttradeormodify',
         header = util.html.abbr('EV', 'Evasion Rating'),
         {
        property = 'Has evasion range average',
            show = h.factory.maybe_show_infobox_line{
        cast = nil,
                keys = {'cannot_be_traded_or_modified'},
        display = h.tbl.display.factory.range{property='evasion'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.cannot_be_traded_or_modified then
                    return i18n.tooltips.cannot_be_traded_or_modified
                end
                return nil
            end,
        },
     },
     },
    -- Help text
     {
     {
         arg = 'es',
         class = 'tc -help',
         header = util.html.abbr('ES', 'Energy Shield'),
         {
        property = 'Has energy shield range average',
            show = h.factory.maybe_show_infobox_line{
        cast = nil,
                keys = {'help_text'},
        display = h.tbl.display.factory.range{property='energy shield'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('help_text'),
        },
     },
     },
    -- Account-bound
     {
     {
         arg = 'block',
         class = 'tc -mod',
        header = 'Block',
         {
         property = 'Has block range average',
            show = h.factory.maybe_show_infobox_line{
        cast = nil,
                keys = {'is_account_bound'},
        display = h.tbl.display.factory.range{property='block'},
                conditions = {processed = true},
    },
    -- Todo: replace this with a proper range eventually.
    {
        arg = 'weapon',
        header = util.html.abbr('Min', 'Local minimum weapon damage'),
        property = 'Has minimum physical damage range average',
        cast = nil,
        display = h.tbl.display.factory.range{property='minimum physical damage'},
       
    },
    {
        arg = 'weapon',
        header = util.html.abbr('Max', 'Local maximum weapon damage'),
        property = 'Has maximum physical damage range average',
        cast = nil,
        display = h.tbl.display.factory.range{property='maximum physical damage'},
       
    },
    {
        arg = 'weapon',
        header = util.html.abbr('APS', 'Attacks per second'),
        property = 'Has attack speed range average',
        cast = nil,
        display = h.tbl.display.factory.range{property='attack speed'},
       
    },
    {
        arg = 'weapon',
        header = util.html.abbr('Crit', 'Local weapon critical strike'),
        property = 'Has critical strike chance range average',
        cast = nil,
        display = h.tbl.display.factory.range{
            property='critical strike chance',
            options={
                fmt = '%.2f%%',
             },
             },
            func = function (tpl_args)
                if tpl_args.is_account_bound then
                    return i18n.tooltips.account_bound
                end
                return nil
            end,
         },
         },
    },
    {
        arg = 'flask_life',
        header = util.html.abbr('Life', 'Life regenerated over the flask duration'),
        property = 'Has flask life recovery range average',
        cast = nil,
        display = h.tbl.display.factory.range{property='flask life recovery'},
    },
    {
        arg = 'flask_mana',
        header = util.html.abbr('Mana', 'Mana regenerated over the flask duration'),
        property = 'Has flask mana recovery range average',
        cast = nil,
        display = h.tbl.display.factory.range{property='flask mana recovery'},
    },
    {
        arg = 'flask',
        header = 'Duration',
        property = 'Has flask duration range average',
        cast = nil,
        display = h.tbl.display.factory.range{property='flask duration'},
    },
    {
        arg = 'flask',
        header = util.html.abbr('Usage', 'Number of charges consumed on use'),
        property = 'Has flask charges per use range average',
        cast = nil,
        display = h.tbl.display.factory.range{property='flask charges per use'},
    },
    {
        arg = 'flask',
        header = util.html.abbr('Capacity', 'Maximum number of flask charges held'),
        property = 'Has maximum flask charges range average',
        cast = nil,
        display = h.tbl.display.factory.range{property='maximum flask charges'},
    },
    {
        arg = 'buff',
        header = 'Buff Effects',
        property = 'Has buff stat text',
        cast = nil,
        display = function (tr, value, data)
            return h.na_or_val(tr, value, function (value)
                return h.new_color('mod', value)
            end)
        end,
    },
    {
        arg = 'stat',
        header = 'Stats',
        property = 'Has stat text',
        cast = nil,
        display = function (tr, value, data)
            return h.na_or_val(tr, value, function (value)
                return h.new_color('mod', value)
            end)
        end,
    },
    {
        arg = 'description',
        header = 'Effect(s)',
        property = 'Has description',
        cast = nil,
        display = function (tr, value, data)
            return h.na_or_val(tr, value, function (value)
                return h.new_color('mod', value)
            end)
        end,
    },
    {
        arg = 'flavour_text',
        header = 'Flavour Text',
        property = 'Has flavour text',
        cast = nil,
        display = function (tr, value, data)
            return h.na_or_val(tr, value, function (value)
                return h.new_color('flavour', value)
            end)
        end,
    },
    {
        arg = 'help_text',
        header = 'Help Text',
        property = 'Has help text',
        cast = nil,
        display = function (tr, value, data)
            return h.na_or_val(tr, value, function (value)
                return h.new_color('help', value)
            end)
        end,
    },
    {
        arg = 'buff_icon',
        header = 'Buff Icon',
        property = 'Has buff icon',
        cast = nil,
        display = function (tr, value, data)
            return h.na_or_val(tr, value, function (value)
                return string.format('[[%s]]', value)
            end)
        end,
     },
     },
}
}


for _, data in ipairs(core.dps_map) do
--
    table.insert(core.result.generic_item, #core.result.generic_item-5, {
-- This is meant to show additional information about the item in a separate infobox
        arg = data.name,
--
        header = data.label,
c.extra_display_groups = {
        property = nil,
        cast = nil,
        display = h.tbl.display.factory.range{property=data.property, no_base=true},
    })
end
 
core.result.skill_gem = {
     {
     {
         arg = 'icon',
         heading = i18n.tooltips.extra_info,
         header = util.html.abbr('L', 'Support gem letter.'),
        class = '',
        property = 'Has support gem letter HTML',
         {
        cast = nil,
            show = h.factory.maybe_show_infobox_line{
        display = h.tbl.display.na_or_val,
                keys = {'atlas_connections'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                local fields = {
                    [false] = {
                        value = '✗',
                        sort = 0,
                        class = 'table-cell-xmark',
                    },
                    [true] = {
                        value = '✓',
                        sort = 1,
                        class = 'table-cell-checkmark',
                    },
                }
               
                local tbl = mw.html.create('table')
                tbl
                    :addClass('wikitable')
                    :attr('style', 'width:100%;')
                    :tag('tr')
                        :tag('th')
                            :attr('colspan', 6)
                            :attr('style', 'text-decoration: underline;')
                            :wikitext(i18n.tooltips.header_overall)
                            :done()
                        :done()
                    :tag('tr')
                        :tag('th')
                            :wikitext(i18n.tooltips.header_upgrades)
                            :done()
                        :tag('th')
                            :wikitext(0)
                            :done()
                        :tag('th')
                            :wikitext(1)
                            :done()
                        :tag('th')
                            :wikitext(2)
                            :done()
                        :tag('th')
                            :wikitext(3)
                            :done()
                        :tag('th')
                            :wikitext(4)
                            :done()
                        :done()
                   
                for _, vtype in ipairs({'tier', 'level'}) do
                    local tr = tbl:tag('tr')
                    tr
                        :tag('th')
                            :wikitext(i18n.tooltips['header_map_' .. vtype])
                            :done()
                   
                    for i=0,4 do
                        local value = tpl_args['atlas_map_tier' .. i]
                        if value == 0 then
                            value = fields[false].value
                        elseif vtype == 'level' then
                            value = value + 67
                        end
                        tr
                            :tag('td')
                                :wikitext(value)
                                :done()
                    end
                    tr:done()
                end
               
                tbl
                    :tag('tr')
                        :tag('th')
                            :attr('colspan', 6)
                            :attr('style', 'text-decoration: underline;')
                            :wikitext(i18n.tooltips.header_connections)
                            :done()
                        :done()
               
                -- sort alphabetically
                local sorted = {}
                for key, value in pairs(tpl_args.atlas_connections) do
                    sorted[#sorted+1] = key
                end
                table.sort(sorted)
               
                for _, key in ipairs(sorted) do
                    local tr = tbl:tag('tr')
                    tr
                        :tag('th')
                            :wikitext(key)
                            :done()
                   
                    for i=0,4 do
                        local field = fields[tpl_args.atlas_connections[key]['region' .. i]]
                        tr
                            :tag('td')
                                :attr('data-sort-value', field.sort)
                                :addClass(field.class)
                                :wikitext(field.value)
                                :done()
                    end
                    tr:done()
                end
               
                return tostring(tbl)
            end
        },
     },
     },
    -- Acquisition
     {
     {
         arg = 'skill_icon',
         heading = i18n.tooltips.acquisition,
         header = 'Icon',
         {
        property = 'Has skill gem icon',
            show = function (tpl_args)
        cast = nil,
                if tpl_args.is_in_game == false then
        display = h.tbl.display.wikilink,
                    return true
    },
                end
    {
                return false
        arg = 'description',
            end,
        header = 'Description',
            func = function (tpl_args)
        property = 'Has description',
                local span = mw.html.create('span')
        cast = nil,
                span
        display = h.tbl.display.na_or_val,
                    :addClass('infobox-disabled-drop')
    },
                    :wikitext(i18n.tooltips.not_in_game)
    {
                    :done()
        arg = 'level',
                return tostring(span)
        header = m_game.level_requirement.icon,
            end,
         property = 'Has level requirement',
        },
         cast = tonumber,
        {
        display = h.tbl.display.na_or_val,
            show = function (tpl_args)
    },
                if tpl_args.drop_enabled == false and tpl_args.is_in_game ~= false then
    {
                    return true
        arg = 'crit',
                end
        header = util.html.abbr('Crit', 'Critical Strike Chance'),
                return false
         property = 'Has critical strike chance',
            end,
         cast = tonumber,
            func = function (tpl_args)
        display = h.tbl.display.percent,
                local span = mw.html.create('span')
    },
                span
    {
                    :addClass('infobox-disabled-drop')
        arg = 'cast_time',
                    :wikitext(i18n.tooltips.drop_disabled)
        header = util.html.abbr('Cast<br>Time', 'Casting time of the skill in seconds'),
                    :done()
        property = 'Has cast time',
                return tostring(span)
        cast = tonumber,
            end,
        display = h.tbl.display.seconds,
         },
    },
         {
    {
            show = function (tpl_args)
        arg = 'dmgeff',
                if tpl_args.is_drop_restricted == true and tpl_args.drop_enabled ~= false then
        header = util.html.abbr('Dmg.<br>Eff.', 'Damage Effectiveness'),
                    return true
        property = 'Has damage effectiveness',
                end
        cast = tonumber,
                return false
        display = h.tbl.display.percent,
            end,
    },
            func = function (tpl_args)
    {
                local span = mw.html.create('span')
        arg = 'mcm',
                span
        header = util.html.abbr('MCM', 'Mana cost multiplier - missing values indicate it changes on gem level'),
                    :addClass('infobox-restricted-drop')
         property = 'Has mana multiplier',
                    :wikitext(i18n.tooltips.drop_restricted)
         cast = tonumber,
                    :done()
        display = h.tbl.display.percent,
                return tostring(span)
    },
            end,
    {
         },
        arg = 'mana',
         {
        header = util.html.abbr('Mana', 'Mana cost'),
            show = h.factory.maybe_show_infobox_line{
        property = 'Has mana cost',
                keys = {'drop_level'},
        cast = tonumber,
                conditions = {processed = true},
        display = function (tr, value, data)
            },
            local appendix = ''
            func = core.factory.infobox_line{
            if data['?Has percentage mana cost'] then
                parts = {
                 appendix = appendix .. '%'
                    {
                        key = 'drop_level',
                        fmt = '%i',
                    },
                    {
                        key = 'drop_level_maximum',
                        fmt = '%i',
                        hide_default = 100,
                    },
                },
                sep = ' / ',
                fmt = i18n.tooltips.drop_level,
            },
         },
         {
            show = h.factory.maybe_show_infobox_line{
                keys = {'acquisition_tags'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                local tags = {}
                for _, v in pairs(tpl_args.acquisition_tags) do
                    if v then
                        tags[#tags+1] = string.format('[[%s|%s]]', cfg.acquisition_tags[v].page, cfg.acquisition_tags[v].name)
                    end
                end
                 return table.concat(tags, ' • ')
             end
             end
             if data['?Has reservation mana cost'] then
        },
                 appendix = appendix .. ' ' .. util.html.abbr('R', 'reserves mana')
        {
             end
             show = h.factory.maybe_show_infobox_line{
              
                keys = {'drop_areas_html'},
            local str
                 conditions = {processed = true},
           
            },
            if value ~= nil then
            func = h.factory.display_raw_value('drop_areas_html'),
                str = string.format('%d', value) .. appendix
        },
            end  
        {
             return h.na_or_val(tr, str)
            show = h.factory.maybe_show_infobox_line{
         end,
                keys = {'drop_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('drop_text'),
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seal_cost'},
                conditions = {processed = true},
             },
             func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seal_cost',
                        fmt = function (tpl_args, value)
                            return string.format('%s %s', i18n.fmt.item_count, h.item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''})
                        end,
                        color = 'currency',
                    },
                },
                fmt = i18n.tooltips.seal_cost,
             },
         },
     },
     },
     {
     {
         arg = 'vaal',
         -- Vendor prices
         header = util.html.abbr('Souls', 'Vaal souls requirement in Normal/Cruel/Merciless difficulty'),
        heading = i18n.tooltips.purchase_costs,
        property = 'Has vaal souls requirement',
         {
        cast = tonumber,
            show = function (tpl_args)
        display = function (tr, value, data)  
                for rarity, data in pairs(tpl_args.purchase_costs) do
            return h.na_or_val(tr, value, function (value)
                    if #data > 0 then
                return string.format('%d / %d / %d', value, value*1.5, value*2)
                        return true
             end)
                    end
         end,
                end
                return false
            end,
            func = function (tpl_args)
                local tbl = mw.html.create('table')
                tbl
                    --:addClass('wikitable')
                    :attr('style', 'width: 100%; margin-top: 0px;')
                   
                for _, rarity_id in ipairs(m_game.constants.rarity_order) do
                    local data = tpl_args.purchase_costs[rarity_id]
                    if #data > 0 then
                        local tr = tbl:tag('tr')
                        tr
                            :tag('td')
                                :wikitext(m_game.constants.rarities[rarity_id].long_upper)
                        local td = tr:tag('td')
                        for _, purchase_data in ipairs(data) do
                            td:wikitext(string.format('%dx [[%s]]<br />', purchase_data.amount, purchase_data.name))
                        end
                    end
                end
               
                return tostring(tbl)
             end,
         },
     },
     },
     {
     {
         arg = 'vaal',
         -- Vendor offer
         header = util.html.abbr('Uses', 'Maximum number of stored uses'),
        heading = i18n.tooltips.sell_price,
        property = 'Has vaal stored uses',
         {
        cast = tonumber,
            show = h.factory.maybe_show_infobox_line{
         display = h.tbl.display.na_or_val,
                keys = {'sell_price_order'},
            },
            func = function (tpl_args)
                local out = {}
                if #tpl_args.sell_price_order > 0 then
                    for _, item_name in ipairs(tpl_args.sell_price_order) do
                        out[#out+1] = string.format('%dx [[%s]]', tpl_args.sell_prices[item_name], item_name)
                    end
                end
                return table.concat(out, '<br />')
            end,
         },
     },
     },
    -- Damage per second
     {
     {
         arg = 'radius',
         heading = i18n.tooltips.damage_per_second,
         header = util.html.abbr('R1', 'Primary radius'),
        {
         property = 'Has primary radius',
            show = h.factory.maybe_show_infobox_line{
         cast = tonumber,
                keys = {'physical_dps_html'},
         display = function (tr, value, data)
            },
             return h.na_or_val(tr, value, core.factory.descriptor_value{key='?Has primary radius description', tbl=data})
            func = core.factory.infobox_line{
         end,
                parts = {
                    {
                        key = 'physical_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.physical_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'fire_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'fire_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.fire_dps,
            },
         },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cold_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'cold_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.cold_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'lightning_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'lightning_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.lightning_dps,
            },
         },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'chaos_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'chaos_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.chaos_dps,
            },
         },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'elemental_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'elemental_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.elemental_dps,
            },
         },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'poison_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'poison_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.poison_dps,
            },
        },
        {
             show = h.factory.maybe_show_infobox_line{
                keys = {'dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.dps,
            },
         },
     },
     },
    -- Metadata
     {
     {
         arg = 'radius',
         heading = i18n.tooltips.metadata,
         header = util.html.abbr('R2', 'Secondary radius'),
         {
        property = 'Has secondary radius',
            show = h.factory.maybe_show_infobox_line{
        cast = tonumber,
                keys = {'class'},
         display = function (tr, value, data)
                conditions = {processed = true},
             return h.na_or_val(tr, value, core.factory.descriptor_value{key='?Has secondary radius description', tbl=data})
            },
        end,
            func = core.factory.infobox_line{
    },
                parts = {
    {
                    {
        arg = 'radius',
                        key = 'class',
        header = util.html.abbr('R3', 'Tertiary radius'),
                    },
        property = 'Has tertiary radius',
                },
        cast = tonumber,
                fmt = i18n.tooltips.item_class,
        display = function (tr, value, data)
            },
            return h.na_or_val(tr, value, core.factory.descriptor_value{key='?Has tertiary radius description', tbl=data})
         },
         end,
        {
             show = h.factory.maybe_show_infobox_line{
                keys = {'metadata_id'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'metadata_id',
                            inline = m_util.html.abbr('%s', tpl_args.metadata_id),
                        },
                    },
                    fmt = tostring(
                        mw.html.create('span')
                            :addClass('u-truncate-line')
                            :wikitext(i18n.tooltips.metadata_id)
                    ),
                }(tpl_args)
            end,
         },
     },
     },
}
}
for _, attr in ipairs(m_game.constants.attributes) do
    table.insert(core.result.generic_item, 6, {
        arg = attr.short_lower,
        header = attr.icon,
        property = string.format('Has %s requirement', attr.long_lower),
        cast = tonumber,
        display = h.tbl.display.factory.range{property=string.format('%s requirement', attr.long_lower)},
    })
    table.insert(core.result.skill_gem, 3, {
        arg = attr.short_lower,
        header = attr.icon,
        property = string.format('Has %s percentage', attr.long_lower),
        cast = tonumber,
        display = function (tr, value)
            return h.na_or_val(tr, value, function (value)
                return '[[File:Yes.png|yes|link=]]'
            end)
        end,
    })
end


-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------
-- Page views
-- Subroutines
-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------


--
local s = {}
-- Template:Item
 
--
-- Subroutines for p.item. These exist to declutter the main function. Each one of these is only called once.
 
function s.get_item_config(tpl_args)
    -- Returns primary item configuration, based on item class


function p.itembox (frame)
     local config = {
    --
         tables = {}, -- Table names that data may be stored to
    -- Args/Frame
        args = {}, -- Args to process early
    --
        late_args = {}, -- Args to process late
     local t = os.clock()
        defaults = {}, -- Defaults based on item class
   
     }
    g_args = getArgs(frame, {
     for _, v in ipairs(cfg.tables) do
         parentFirst = true
        table.insert(config.tables, v)
    })
    g_frame = util.misc.get_frame(frame)
   
    --
    -- Shared args
    --
   
    g_args._total_args = {}
    g_args._base_item_args = {}
    g_args._mods = {}
     g_args._stats = {}
     g_args._subobjects = {}
    g_args._properties = {}
   
    -- Using general purpose function to handle release and removal versions
    util.args.version(g_args, {frame=g_frame, set_properties=true})
   
    -- Must validate some argument early. It is required for future things
    local err
   
    err = core.process_arguments{array=core.default_args}
    if err then
        return err
     end
     end
      
     for _, v in ipairs(cfg.default_args) do
    err = core.process_arguments{array=core.item_classes[g_args.class].args}
        table.insert(config.args, v)
    if err then
        return err
     end
     end
   
     for _, v in ipairs(cfg.late_args) do
    -- set defaults
         table.insert(config.late_args, v)
   
     for k, v in pairs(core.item_classes[g_args.class].defaults) do
         if g_args[k] == nil then
            g_args[k] = v
        end
     end
     end
   
    -- Base Item


     core.process_base_item()
     -- Process class_id
   
    h.process_arguments(tpl_args, {'class_id'})
     -- Prophecy special snowflake
 
     if g_args.base_item == 'Prophecy' then
     local extend_keys = {'tables', 'args', 'late_args'} -- We will do defaults separately to preserve order of args
        err = core.process_arguments{array=core.prophecy_args}
     for _, row in pairs(cfg.class_groups) do
        if err then
        if row.keys[tpl_args.class_id] then
             return err
            for _, k in ipairs(extend_keys) do
                if row[k] then
                    for _, v in ipairs(row[k]) do
                        table.insert(config[k], v)
                    end
                end
            end
            if row['defaults'] then
                for k, v in pairs(row['defaults']) do
                    config['defaults'][k] = v
                end
            end
             break
         end
         end
       
        g_args.inventory_icon = 'File:Prophecy inventory icon.png'
     end
     end
      
     local class_specifics = cfg.class_specifics[tpl_args.class_id]
     -- Mods
     if class_specifics then
 
        for _, k in ipairs(extend_keys) do
    for _, k in ipairs({'implicit', 'explicit'}) do
            if class_specifics[k] then
        local success = true
                for _, v in ipairs(class_specifics[k]) do
        local i = 1
                    table.insert(config[k], v)
        while success do
                end
            success = core.validate_mod{key=k, i=i}
             end
             i = i + 1
         end
         end
    end
         if class_specifics['defaults'] then
   
            for k, v in pairs(class_specifics['defaults']) do
    core.process_smw_mods()
                config['defaults'][k] = v
          
             end
    -- Add stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
    util.args.stats(g_args, {prefix='extra_'})
    for _, stat in ipairs(g_args.extra_stats) do
        if stat.value ~= nil then
            stat.min = stat.value
             stat.max = stat.value
            stat.avg = stat.value
         end
         end
        h.stats_update(stat.id, stat)
     end
     end
    return config
end


     -- Transpose stats into subobjects
function s.process_quest_rewards(tpl_args)
     for id, data in pairs(g_args._stats) do
     local rid = 1
         g_args._subobjects[id] = {
     local continue
             ['Has stat ids'] = id,
    tpl_args.quest_rewards = {}
            ['Has minimum stat values'] = data.min,
    tpl_args.vendor_rewards = {}
            ['Has maximum stat values'] = data.max,
    repeat
            ['Has average stat values'] = data.avg,
        continue = true
        local prefix = string.format('quest_reward%s_', rid)
          
        local input_args = {
            shared = {
                ['type'] = true,
                ['quest'] = false,
                ['quest_id'] = false,
                ['act'] = true,
                ['class_ids'] = false,
                },
            vendor = {
                ['npc'] = true,
            },
             quest = {
                ['sockets'] = false,  
                ['item_level'] = false,  
                ['rarity_id'] = false,  
                ['notes'] = false,
            },
         }
         }
    end
       
   
        local rdata = {}
    -- Handle extra stats (for gems)
       
   
        for key, is_required in pairs(input_args.shared) do
    if core.class_groups.gems.keys[g_args.class] then
            rdata[key] = tpl_args[prefix .. key]
        m_skill.skill(g_frame, g_args)
            if is_required then
    end
                if rdata[key] == nil then
   
                    continue = false
    for k, data in pairs(core.stat_map) do
                    break
         local value = g_args[k]
                end
            end
         if value == nil and data.default ~= nil then
        end
             value = data.default
          
            g_args[k] = data.default
         if rdata.quest == nil or rdata.quest_id == nil then
             continue = false
         end
         end
          
          
         if value ~= nil then
         if continue and rdata.type == 'vendor' or rdata.type == 'quest' then
            value = {min=value, max=value}
             for key, is_required in pairs(input_args[rdata.type]) do
            -- The simple cases; this must be using ipairs as "add" must apply before
                 rdata[key] = tpl_args[prefix .. key]
             for _, operator in ipairs({'add', 'more'}) do
                 if is_required then
                 local st = data['stats_' .. operator]
                     if rdata[key] == nil then
                 if st ~= nil then
                        continue = false
                     for _, statid in ipairs(st) do
                         break
                        if g_args._stats[statid] ~= nil then
                            h.stat[operator](value, g_args._stats[statid])
                         end
                     end
                     end
                 end
                 end
             end
             end
              
        else
            -- For increased stats we need to add them up first
             continue = false
             local st = data.stats_increased
        end
             if st ~= nil then
       
                 local total_increase = {min=0, max=0}
        if continue then
                 for _, statid in ipairs(st) do
             rdata.classes = {}
                     if g_args._stats[statid] ~= nil then
             if rdata.class_ids ~= nil then
                         for var, current_value in pairs(total_increase) do
                 rdata.class_ids = m_util.string.split(rdata.class_ids, ',%s*')
                            total_increase[var] = current_value + g_args._stats[statid][var]
                 for index, class_id in ipairs(rdata.class_ids) do
                        end
                     local class = m_game.constants.characters[class_id]  
                    if class == nil then
                         error(string.format('Class id %s is invalid', class_id))
                    else
                        rdata.class_ids[index] = class.str_id
                        rdata.classes[index] = class.name
                     end
                     end
                 end
                 end
                h.stat.more(value, total_increase)
             end
             end
              
              
             if data.minimum ~= nil then
           
                 for _, key in ipairs({'min', 'max'}) do
             if rdata.item_level then
                    if value[key] < data.minimum then
                 rdata.item_level = m_util.cast.number(rdata.item_level)
                        value[key] = data.minimum
            end
                     end
           
            if rdata.rarity_id then
                if m_game.constants.rarities[rdata.rarity_id] == nil then
                     error(string.format(i18n.errors.invalid_rarity_id, tostring(rdata.rarity_id)))
                 end
                 end
             end
             end
              
              
             value.avg = (value.min + value.max) / 2
             rdata._table = rdata.type .. '_rewards'
            rdata.type = nil
           
            tpl_args[rdata._table] = rdata
              
              
             -- don't add the properties unless we need to
             m_cargo.store(rdata)
            if (data.default ~= nil and (value.min ~= data.default or value.max ~= data.default)) or data.default == nil then
                for short_key, range_data in pairs(h.range_map) do
                    g_args._properties[data.property .. range_data.property] = value[short_key]
                end
            end
              
              
             for short_key, range_data in pairs(h.range_map) do
             -- TODO: Verify quests and quest ids?
                g_args[k .. range_data.var] = value[short_key]
        end
            end
       
        rid = rid + 1
    until continue == false
end
 
function s.process_base_item(tpl_args)
    if not tpl_args._flags.is_derived then
        if tpl_args.rarity_id ~= 'normal' then
            error(i18n.errors.missing_base_item)
        end
        return
    end
    m_item_util = m_item_util or require('Module:Item util')
    local qargs = {}
    qargs.tables = tpl_args._item_config.tables
    qargs.join = {}
    for _, tbl in ipairs(tpl_args._item_config.tables) do
        if tbl ~= 'items' then
            qargs.join[#qargs.join+1] = string.format('items._pageID=%s._pageID', tbl)
         end
         end
     end
     end
      
     qargs.join = #qargs.join > 0 and table.concat(qargs.join, ', ') or nil
    -- override attributes for tabula rasa
    qargs.fields = {
    if g_args._stats.local_unique_tabula_rasa_no_requirement_or_energy_shield ~= nil and g_args._stats.local_unique_tabula_rasa_no_requirement_or_energy_shield.min == 1 then
         'items._pageName',
         for _, arg in ipairs({'required_strength', 'required_intelligence', 'required_dexterity', 'energy_shield'}) do
        'items.name',
            for short_key, range_data in pairs(h.range_map) do
        'items.metadata_id',
                g_args[arg .. range_data.var] = 0
        'items.class_id',
                g_args._properties[core.stat_map[arg].property .. range_data.property] = 0
        'items.rarity_id',
            end
        'items.inventory_icon',
    }
    for _, k in ipairs(tpl_args._base_item_args) do
        local arg_def = core.map[k]
        if arg_def.field ~= nil then
            qargs.fields[#qargs.fields+1] = string.format('%s.%s', arg_def.table, arg_def.field)
         end
         end
        g_args.required_level_final = 1
     end
     end
      
     qargs.where = string.format('items.class_id = "%s"', tpl_args.class_id)
     -- late processing
     local result = m_item_util.query_item({
    err = core.process_arguments{array=core.late_args}
        metadata_id = tpl_args.base_item_id,
     if err then
        page = tpl_args.base_item_page,
         return err
        item_name_exact = tpl_args.base_item,
        debug = tpl_args.debug,
    }, qargs)
     if result.error then
         result.error:throw(true)
    end
    if result['items.rarity_id'] ~= 'normal' then
        error(i18n.errors.base_item_wrong_rarity)
     end
     end
      
 
     -- calculate and handle weapon dps
     tpl_args.base_item = result['items.name']
     if core.class_groups.weapons.keys[g_args.class] then
     tpl_args.base_item_page = result['items._pageName']
        for _, data in ipairs(core.dps_map) do
     tpl_args.base_item_id = result['items.metadata_id']
            local damage = {
    h.process_arguments(tpl_args, {'base_item', 'base_item_page', 'base_item_id'})
                min = {},
 
                max = {},
    tpl_args.base_item_icon = result['items.inventory_icon']
             }
 
       
    -- Copy values
             for var_type, value in pairs(damage) do
    for _, k in ipairs(tpl_args._base_item_args) do
                 -- covers the min/max/avg range
        local arg_def = core.map[k]
                 for short_key, range_data in pairs(h.range_map) do
        if arg_def.func_fetch ~= nil then
                     value[short_key] = 0
            arg_def.func_fetch(tpl_args)
                     for _, damage_key in ipairs(data.damage_args) do
        elseif arg_def.field ~= nil then
                         value[short_key] = value[short_key] + g_args[string.format('%s_%s%s', damage_key, var_type, range_data.var)]
            local value = result[string.format('%s.%s', arg_def.table, arg_def.field)]
             if value == nil then
                if tpl_args.debug then
                    mw.log(string.format(i18n.debug.base_item_field_not_found, arg_def.table, arg_def.field))
                end
             else
                local default = type(arg_def.default) == 'function' and arg_def.default(tpl_args) or arg_def.default
                 -- Inherit value from base item if derived item value is not equal to the default value.
                -- This verbose comparison is needed since two empty tables are not considered equal to one another.
                 if tpl_args[k] == arg_def.default or (type(tpl_args[k]) == 'table' and #tpl_args[k] == 0 and type(arg_def.default) == 'table' and #arg_def.default == 0) then
                     tpl_args[k] = value
                     if arg_def.func ~= nil then
                         tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
                    end
                    if arg_def.func_copy ~= nil then
                        arg_def.func_copy(tpl_args, tpl_args[k])
                     end
                     end
                elseif tpl_args.debug then
                    mw.log(string.format(i18n.debug.field_value_mismatch, k, tostring(tpl_args[k])))
                 end
                 end
             end
             end
        end
    end


             for short_key, range_data in pairs(h.range_map) do
    -- Fetch implicit mods from base item
                local result = (damage.min[short_key] + damage.max[short_key]) / 2 * g_args[string.format('attack_speed%s', range_data.var)]
    local mods = m_cargo.query(
                g_args[string.format('%s%s', data.name, range_data.var)] = result
        {'items' ,'item_mods'},
                -- It will set the property, even if 0.  
        {'item_mods.id', 'item_mods.is_random', 'item_mods.text'},
                -- Not sure if it is better to not set it, but on the other hand this way it can be queried for having no dps of a particular type
        {
                 g_args._properties[string.format('Has %s%s', data.property, range_data.property)] = result
             join = 'items._pageID=item_mods._pageID',
            where = string.format(
                'items._pageName="%s" AND item_mods.is_implicit=true',
                tpl_args.base_item_page
            ),
        }
    )
    tpl_args._base_implicit_mods = {}
    for _, row in ipairs(mods) do
        table.insert(tpl_args._base_implicit_mods, {
            id = row['item_mods.id'],
            stat_text = row['item_mods.text'],
            is_implicit = true,
            is_random = m_util.cast.boolean(row['item_mods.is_random']),
        })
    end
end
 
function s.process_mods(tpl_args)
    tpl_args._defined_implicit_mods = {}
    tpl_args._mods = {}
 
    local function parse_mod_arg(tpl_args, type, index)
        local prefix = type .. index
        local mod_data = {
            is_implicit = type == 'implicit',
            is_explicit = type == 'explicit',
            is_map_fragment_bonus = type == 'map_fragment_bonus',
            is_random = false,
        }
        local mods_table = mod_data.is_implicit and tpl_args._defined_implicit_mods or tpl_args._mods
 
        -- By mod id
        local value = tpl_args[prefix]
        if value ~= nil then
            mod_data.id = value
            mod_data.stat_text = tpl_args[prefix .. '_text']
            table.insert(mods_table, mod_data)
            return true
        end
 
        -- By list of possible mod ids
        value = tpl_args[prefix .. '_random_list']
        if value ~= nil then
            value = m_util.cast.table(value)
            for _, id in ipairs(value) do
                local mod_data_copy = {}
                for k, v in pairs(mod_data) do
                    mod_data_copy[k] = v
                end
                mod_data_copy.id = id
                mod_data_copy.is_random = true
                 mod_data_copy.stat_text = tpl_args[prefix .. '_text'] or string.format(i18n.tooltips.random_mod, index)
                table.insert(mods_table, mod_data_copy)
             end
             end
            tpl_args._flags.random_mods = true
            return true
         end
         end
    end
 
   
        -- By stat text
   
         value = tpl_args[prefix .. '_text']
    -- Setting semantic properties Part 1 (base values)
         if value ~= nil then
   
            mod_data.result = false -- Not stored in Cargo table
    local val
            mod_data.stat_text = value
   
             table.insert(mods_table, mod_data)
    for _, k in ipairs(g_args._total_args) do
             tpl_args._flags.text_modifier = true
         local prop = core.map[k].property
            return true
        val = g_args[k]
         if val == nil then
        elseif prop == nil then
             --mw.logObject(k)
        else
             g_args._properties[prop] = val
         end
         end
     end
 
      
        return false
    util.smw.set(g_frame, g_args._properties)
     end -- parse_mod_arg
   
 
    -- Subobjects
     local types = {
     local command
        'implicit',
     for key, properties in pairs(g_args._subobjects) do
        'explicit',
         command = ''
        'map_fragment_bonus',
         if type(key) ~= 'number' then
     }
             command = key
     for _, t in ipairs(types) do
         local i = 1
         while parse_mod_arg(tpl_args, t, i) do
             i = i + 1
         end
         end
        util.smw.subobject(g_frame, command, properties)
     end
     end
   
    --
    -- Validate arguments
    --
   
    local x = v.itembox()
   
    mw.logObject(os.clock() - t)
   
    return x
end


--
     -- If the item does not have its own implicit mods, fall back to the implicit mods on the base item.
-- Template:Item link & Template:Sl
     local implicit_mods = tpl_args._defined_implicit_mods or {}
--
     if #implicit_mods == 0 then
 
         implicit_mods = tpl_args._base_implicit_mods or {}
function p.item_link (frame)
     --
    -- Args/Frame
    --
   
    g_args = getArgs(frame, {
        parentFirst = true,
        removeBlanks = false,
    })
    g_frame = util.misc.get_frame(frame)
   
    -- Backwards compability
     g_args.item_name = g_args.item_name or g_args[1]
     if g_args.item_name ~= nil then
         g_args.item_name = string.lower(g_args.item_name)
     end
     end
     g_args.name = g_args.name or g_args[2]
     for _, v in ipairs(implicit_mods) do
   
         table.insert(tpl_args._mods, v)
    if util.table.has_all_value(g_args, {'page', 'item_name', 'item_name_exact'}) then
         error('page, item_name or item_name_exact must be specified')
     end
     end
   
     if #tpl_args._mods > 0 then
    g_args.large = util.cast.boolean(g_args.large)
         local mods = {}
   
         local mod_ids = {}
    local img
         local non_random_mod_ids = {}
    local result
        for _, mod_data in ipairs(tpl_args._mods) do
   
             if mod_data.result == nil then
     if util.table.has_one_value(g_args, core.item_link_params, nil) or g_args.item_name ~= nil then
                 mods[mod_data.id] = mod_data
         local query = {}
                table.insert(mod_ids, mod_data.id)
          
                if not mod_data.is_random then
         if g_args.page ~= nil then
                    table.insert(non_random_mod_ids, mod_data.id)
            -- TODO returns the result even if the + format is specified.
                end
            query[#query+1] = string.format('[[%s]]', g_args.page)
        else
             if g_args.item_name ~= nil then
                 query[#query+1] = string.format('[[Has lowercase names::%s]]', g_args.item_name)
            elseif g_args.item_name_exact ~= nil then
                query[#query+1] = string.format('[[Has name::%s]]', g_args.item_name_exact)
             end
             end
              
             table.insert(tpl_args._store_data, {
             query[#query] = query[#query] .. ' [[Has inventory icon::+]] [[Has infobox HTML::+]]'
                _table = 'item_mods',
              
                id = mod_data.id,
             if g_args.link_type == 'skill' then
                text = mod_data.stat_text,
                 query[#query] = query[#query] .. ' [[Concept:Skill gems]]'
                is_implicit = mod_data.is_implicit,
                is_explicit = mod_data.is_explicit,
                is_map_fragment_bonus = mod_data.is_map_fragment_bonus,
                is_random = mod_data.is_random,
             })
        end
        local results = m_cargo.query(
            {'mods'},
            {'mods._pageName', 'mods.id', 'mods.required_level', 'mods.stat_text'},
            {
                where = string.format(
                    'mods.id IN ("%s")',
                    table.concat(mod_ids, '","')
                )
            }
        )
        for _, row in ipairs(results) do
            local mod_data = mods[row['mods.id']]
             mod_data.result = row
             if mod_data.is_random == false then
                -- Modifiers contribute to level requirement
                -- Update base level requirement only if this is an implicit
                local args = {
                    'required_level_final',
                    mod_data.is_implicit and 'required_level' or nil,
                }
                 for _, v in ipairs(args) do
                    local req = math.floor(tonumber(row['mods.required_level']) * cfg.item_required_level_modifier_contribution)
                    if req > tpl_args[v] then
                        tpl_args[v] = req
                    end
                end
             end
             end
         end
         end
          
          
         query[#query+1] = '?Has name'
         -- fetch stats
         query[#query+1] = '?Has inventory icon'
         results = m_cargo.query(
        query[#query+1] = '?Has infobox HTML'
            {'mods', 'mod_stats'},
        query[#query+1] = '?Has alternate inventory icons'
            {'mods.id', 'mod_stats.id', 'mod_stats.min', 'mod_stats.max'},
        query[#query+1] = '?Has inventory width'
            {
        query[#query+1] = '?Has inventory height'
                join = 'mods._pageID=mod_stats._pageID',
       
                where = string.format(
        -- attributes
                    'mods.id IN ("%s") AND mod_stats.id IS NOT NULL',
        result = util.smw.query(query, g_frame)
                    table.concat(mod_ids, '","')
       
                 ),
        local err
             }
        if #result == 0 then
        )
            err = util.misc.raise_error_or_return{raise_required=true, args=g_args, msg=string.format(
         for _, row in ipairs(results) do
                'No results found for search parameter "%s".',  
            -- Stat data
                 g_args.page or g_args.item_name or g_args.item_name_exact
            local mod_data = mods[row['mods.id']]
             )}
             mod_data.result.stats = mod_data.result.stats or {}
         elseif #result > 1 then
            table.insert(mod_data.result.stats, row)
             err = util.misc.raise_error_or_return{raise_required=true, args=g_args, msg=string.format(
            local stat_id = row['mod_stats.id']
                 'Too many results for search parameter "%s". Consider using page parameter instead.',
            local value = {
                 g_args.page or g_args.item_name or g_args.item_name_exact
                 min = tonumber(row['mod_stats.min']),
             )}
                 max = tonumber(row['mod_stats.max']),
            }
            local tbl = mod_data.is_random and '_random_stats' or '_stats'
             core.add_stat(tpl_args, stat_id, value, {tbl=tbl, mod=mod_data})
         end
         end
          
          
         if err ~= nil then
         if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
            return err .. core.item_link_broken_cat
             -- fetch sell prices
        end
             results = m_cargo.query(
       
                 {'mods', 'mod_sell_prices'},
        result = result[1]
                 {'mods.id', 'mod_sell_prices.amount', 'mod_sell_prices.name'},
    else
                {
        result = {g_args.page or g_args.item_name_exact}
                    join='mods._pageID=mod_sell_prices._pageID',
    end
                    -- must be non random mods to avoid accumulating sell prices of randomized modifiers
   
                    where=string.format('mod_sell_prices.amount IS NOT NULL AND mods.id IN ("%s")', table.concat(non_random_mod_ids, '", "')),
    for _, k in ipairs(core.item_link_params) do
                }
        local prop = core.map[k].property
            )
        if g_args[k] ~= nil then
             result[prop] = g_args[k]
        end
    end
   
    if g_args.image ~= nil then
        if result['Has alternate inventory icons'] == '' then
             return util.misc.raise_error_or_return{raise_required=true, args=g_args, msg=string.format(
                 'Image parameter was specified, but there is no alternate art defined on page "%s"',
                 result[1]
            ) .. core.item_link_broken_cat}
        end
       
        result['Has alternate inventory icons'] = util.string.split(result['Has alternate inventory icons'], '<MANY>')
       
        local index = tonumber(g_args.image)
        if index ~= nil then
            img = result['Has alternate inventory icons'][index]
        else
            -- offset 1 is needed
            local suffix = string.len(' inventory icon.png') + 1
            -- add an extra offset by 1 to account for the space
            local prefix = string.len(string.sub(result['Has inventory icon'], 1, -suffix)) + 2
              
              
             for _, filename in ipairs(result['Has alternate inventory icons']) do
             for _, data in ipairs(results) do
                 if string.sub(filename, prefix, -suffix) == g_args.image then
                local mod_data = mods[data['mods.id']]
                     img = filename
                 if not mod_data.is_implicit then
                    break
                    local values = {
                        name = data['mod_sell_prices.name'],
                        amount = tonumber(data['mod_sell_prices.amount']),  
                    }
                    -- sell_prices is defined in core.map.sell_prices_override
                     tpl_args.sell_prices[values.name] = (tpl_args.sell_prices[values.name] or 0) + values.amount
                 end
                 end
             end
             end
        end
    end
    if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
        local missing_sell_price = true
        for _, _ in pairs(tpl_args.sell_prices) do
            missing_sell_price = false
            break
         end
         end
          
          
         if img == nil then
         if missing_sell_price then
             return util.misc.raise_error_or_return{raise_required=true, args=g_args, msg=string.format(
             tpl_args.sell_prices[i18n.tooltips.default_vendor_offer] = 1
                'Alternate art with index/name "%s" not found on page "%s"',
                g_args.image, result[1]
            ) .. core.item_link_broken_cat}
         end
         end
    elseif result['Has inventory icon'] ~= '' then
        img = result['Has inventory icon']
    end
   
    -- output
   
    local container = mw.html.create('span')
    container:attr('class', 'inline-infobox-container')
   
    if not g_args.large then
        container:wikitext(string.format('[[%s]]', img))
    end
     
    container:wikitext(string.format('[[%s|%s]]', result[1], result['Has name'] or result[1]))
          
          
    if result['Has infobox HTML'] ~= '' then
        -- Set sell price on page
         container
         for name, amount in pairs(tpl_args.sell_prices) do
            :tag('span')
            -- sell_price_order is defined in core.map.sell_prices_override
                :attr('class', 'inline-infobox-hover')
            tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
                :wikitext(result['Has infobox HTML'])
            tpl_args._store_data[#tpl_args._store_data+1] = {
                :wikitext(string.format('[[%s]]', img))
                _table = 'item_sell_prices',
                :done()
                amount = amount,
    end
                name = name,
   
             }
    if g_args.large then
        local width = tonumber(result['Has inventory width']) or tonumber(g_args.width)
        local height = tonumber(result['Has inventory height']) or tonumber(g_args.height)
       
        if width and height then
            img = string.format('[[%s|%sx%spx]]', img, width*c.image_size, height*c.image_size)
        elseif width then
            img = string.format('[[%s|%spx]]', img, width*c.image_size)
        elseif height then
            img = string.format('[[%s|x%spx]]', img, height*c.image_size)
        else
             img = string.format('[[%s]]', img)
         end
         end
   
         table.sort(tpl_args.sell_price_order)
         container:wikitext(img)
     end
     end
       
    return tostring(container)
end
end


--
function s.process_stats(tpl_args)
-- Template:Il
    tpl_args._stats = tpl_args._stats or {}
--


function p.item_link_compability (frame)
    -- Extra stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
     if util.misc.is_frame(frame) then
    m_util.args.stats(tpl_args, {prefix='extra_'}) -- Populates tpl_args.extra_stats
         frame.args.raise = true
     for _, stat in ipairs(tpl_args.extra_stats) do
    else
         core.add_stat(tpl_args, stat.id, stat.value or stat)
        frame.raise = true
     end
     end
      
      
     local result
     -- Handle local item stat math - additions, increases, etc.
    for key, stat_def in pairs(core.stat_map) do
        local arg = stat_def.arg or key
        local value = {}
        if type(arg) == 'table' then
            value.min = tpl_args[arg.min]
            value.max = tpl_args[arg.max]
            value.base_min = tpl_args[arg.min]
            value.base_max = tpl_args[arg.max]
        else
            value.min = tpl_args[arg]
            value.max = tpl_args[arg]
            value.base = tpl_args[arg]
        end
        if value.min ~= nil and value.max ~= nil then
            -- Determine whether stat is overridden; if so, other calculations can be ignored
            local overridden = false
            if stat_def.stats_override then
                for id, v in pairs(stat_def.stats_override) do
                    if tpl_args._stats[id] then
                        -- If for some reason there is more than one of the same override stat, apply the final one.
                        local stat_value = tpl_args._stats[id][#tpl_args._stats[id]]
                        if stat_value then
                            if type(v) == 'table' then
                                value.min = v.min
                                value.max = v.max
                                overridden = true
                            elseif v then -- Use the stat value
                                value.min = stat_value.min
                                value.max = stat_value.max
                                overridden = true
                            end
                        end
                    end
                end
            end
            if not overridden then
                local operations = {'add', 'add_distance', 'increased', 'increased_inverse'}
                for _, o in ipairs(operations) do
                    local stat_ids = stat_def['stats_' .. o]
                    if stat_ids then
                        local total = {min=0, max=0}
                        for _, id in ipairs(stat_ids) do
                            if tpl_args._stats[id] then
                                for _, s in ipairs(tpl_args._stats[id]) do
                                    total.min = total.min + s.min
                                    total.max = total.max + s.max
                                end
                            end
                        end
                        h.stat[o](value, total)
                    end
                end
                if stat_def.minimum ~= nil then
                    for _, k in ipairs({'min', 'max'}) do
                        if value[k] < stat_def.minimum then
                            value[k] = stat_def.minimum
                        end
                    end
                end
            end
            value.avg = (value.min + value.max) / 2


    local status, err = pcall(function ()  
            for short_key, range_def in pairs(c.range_map) do
        result = p.item_link(frame)
                tpl_args[stat_def.field .. range_def] = value[short_key]
    end)
            end
    mw.logObject(err)
           
   
            -- process to HTML to use on list pages or other purposes
    if status then
            h.handle_range_args(tpl_args, key, stat_def.field, value, stat_def.html_fmt_options)
        return result
         end
    elseif string.match(err, ".*Too many results.*") then
         return err .. core.item_link_broken_cat
    else
        return require('Module:Item').itemLink(frame)
     end
     end
end


 
     -- Transpose stats into cargo data
-- ----------------------------------------------------------------------------
     for _, tbl in ipairs({'_stats', '_random_stats'}) do
-- Result formatting templates for SMW queries
         if tpl_args[tbl] then
-- ----------------------------------------------------------------------------
            for stat_id, stats in pairs(tpl_args[tbl]) do
 
                for _, stat_data in ipairs(stats) do
--
                    table.insert(tpl_args._store_data, {
-- Template:
                        _table = 'item_stats',
--
                        id = stat_id,
 
                        min = stat_data.min,
function p.simple_item_list_row(frame)
                        max = stat_data.max,
     -- Args
                        avg = stat_data.avg,
     g_args = getArgs(frame, {
                        mod_id = stat_data.mod and stat_data.mod.id or nil
         parentFirst = true
                    })
    })
                end
    g_frame = util.misc.get_frame(frame)
            end
   
         end
    --
    local args = util.string.split_args(g_args.userparam, {sep=', '})
    g_args.userparam = args
   
    local link = p.item_link{page=g_args[1], name=g_args['?Has name'], inventory_icon=g_args['?Has inventory icon'] or '', html=g_args['?Has infobox HTML'] or ''}
    if args.format == nil then
        return '* ' .. link
    elseif args.format == 'none' then
        return link
    elseif args.format == 'li' then
        return string.format('<li>%s</li>', link)
    else
         error(string.format('Unrecognized format parameter "%s"', args.format))
     end
     end
end
end


-- ----------------------------------------------------------------------------
function s.process_weapon_dps(tpl_args)
-- Reponsibile for subtemplates of Template:SMW item table
     for key, dps_def in pairs(core.dps_map) do
--
         local damage = {
item_table_factory = {}
             min = {},
function item_table_factory.intro(args)
            max = {},
     -- args:
         }
    --  data_array
         for var_type, value in pairs(damage) do
    --  header
            -- covers the min/max/avg range
   
             for short_key, range_def in pairs(c.range_map) do
    return function (frame)
                 value[short_key] = 0
        -- Args
                 for _, damage_key in ipairs(dps_def.damage_args) do
         local tpl_args = getArgs(frame, {
                    value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_def)] or 0)
             parentFirst = true
                end
        })
        g_frame = util.misc.get_frame(frame)
       
        --
        tpl_args.userparam = util.string.split_args(tpl_args.userparam, {sep=', '})
          
         local tr = mw.html.create('tr')
        tr
             :tag('th')
                :wikitext(args.header)
                 :done()
                  
        for _, rowinfo in ipairs(args.data_array) do
            if rowinfo.arg == nil or tpl_args.userparam[rowinfo.arg] then
                tr
                    :tag('th')
                        :wikitext(rowinfo.header)
                        :done()
             end
             end
         end
         end
          
         local value = {}
         return '<table class="wikitable sortable item-table">' .. tostring(tr)
         for short_key, range_def in pairs(c.range_map) do
            local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_def)]
            value[short_key] = result
            tpl_args[string.format('%s%s', dps_def.field, range_def)] = result
        end
        if value.avg > 0 then
            h.handle_range_args(tpl_args, key, dps_def.field, value, dps_def.html_fmt_options)
        end
     end
     end
end
end


function item_table_factory.row(args)
function s.process_gem_variants(tpl_args)
     -- args:
     if not tpl_args._flags.is_derived and tpl_args.metadata_id == nil then
     --  data_array
        -- If this is a base item, then it needs a metadata ID in order to find its variants.
     return function (frame)
        return
         -- Args
    end
         local tpl_args = getArgs(frame, {
     local variants = {}
            parentFirst = true
     local title = mw.title.getCurrentTitle()
         })
    local current = {
         g_frame = util.misc.get_frame(frame)
        page = title.prefixedText,
          
        name = tpl_args.name,
         --
        id = tpl_args.metadata_id,
        tpl_args.userparam = util.string.split_args(tpl_args.userparam, {sep=', '})
         icon = tpl_args.inventory_icon,
       
         current = true,
        local tr = mw.html.create('tr')
    }
          
    local results
        local il_args = {
    local tables = {'items', 'skill_gems', 'skill'}
            page=tpl_args[1],  
    local fields = {
            name=tpl_args['?Has name'],  
        'items._pageName=page',
            inventory_icon=tpl_args['?Has inventory icon'],  
        'items.name=name',
             html=tpl_args['?Has infobox HTML'],
        'items.metadata_id=id',
            width=tpl_args['?Has inventory width'],
         'items.inventory_icon=icon'
            height=tpl_args['?Has inventory height'],
    }
         }
    local qargs = {
         if tpl_args.userparam.large then
         join = 'items._pageID=skill_gems._pageID, items._pageID=skill._pageID',
             il_args.large = tpl_args.userparam.large
         orderBy = 'skill.skill_id ASC',
    }
 
    if tpl_args.class_id == 'Active Skill Gem' then
         if tpl_args.is_vaal_skill_gem then
            variants.vaal = current
           
            -- Query base skill gem
            qargs.where = string.format(
                [[items.metadata_id IS NOT NULL
                  AND items.class_id = "Active Skill Gem"
                  AND skill_gems.vaal_variant_id = "%s"
                  AND skill_gems.is_vaal_skill_gem = false]],
                tpl_args.metadata_id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.base = results[1]
            end
         else
            -- Determine base skill gem
            if tpl_args._flags.is_derived then
                variants.base = {
                    page = tpl_args.base_item_page,
                    name = tpl_args.base_item,
                    id = tpl_args.base_item_id,
                    icon = tpl_args.base_item_icon,
                }
             else
                variants.base = current
            end
 
            if tpl_args.vaal_variant_id ~= nil then
                -- Query Vaal skill gem variant
                qargs.where = string.format(
                    [[items.metadata_id = "%s"
                      AND items.class_id = "Active Skill Gem"
                      AND skill_gems.is_vaal_skill_gem = true]],
                    tpl_args.vaal_variant_id
                )
                if title.namespace == 0 then
                    qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                end
                results = m_cargo.query(tables, fields, qargs)
                if #results > 0 then
                    variants.vaal = results[1]
                end
            end
         end
         if variants.base then
            -- Query transfigured skill gem variants
            qargs.where = string.format(
                [[items.metadata_id IS NULL
                  AND items.base_item_id = "%s"
                  AND items.class_id = "Active Skill Gem"]],
                variants.base.id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
             results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.transfigured = {}
                for _, row in ipairs(results) do
                    row.current = row.page == title.prefixedText
                    table.insert(variants.transfigured, row)
                end
            end
         end
         end
          
    elseif tpl_args.class_id == 'Support Skill Gem' then
        tr
         if tpl_args.is_awakened_support_gem then
             :tag('td')
            variants.awakened = current
                 :wikitext(p.item_link(il_args))
           
                :done()
            -- Query base support gem
               
             qargs.where = string.format(
        for _, rowinfo in ipairs(args.data_array) do
                 [[items.metadata_id IS NOT NULL
             if rowinfo.arg == nil or tpl_args.userparam[rowinfo.arg] then
                  AND items.class_id = "Support Skill Gem"
                 local value
                  AND skill_gems.awakened_variant_id = "%s"
                if rowinfo.property ~= nil then
                  AND skill_gems.is_awakened_support_gem = false]],
                     value = tpl_args['?' .. rowinfo.property]
                tpl_args.metadata_id
                     if rowinfo.cast then
            )
                        value = rowinfo.cast(value)
             if title.namespace == 0 then
                     end
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                 variants.base = results[1]
            end
        else
            variants.base = current
 
            if tpl_args.awakened_variant_id ~= nil then
                -- Query awakened support gem variant
                qargs.where = string.format(
                     [[items.metadata_id = "%s"
                      AND items.class_id = "Support Skill Gem"
                      AND skill_gems.is_awakened_support_gem = true]],
                     tpl_args.awakened_variant_id
                )
                if title.namespace == 0 then
                    qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                end
                results = m_cargo.query(tables, fields, qargs)
                if #results > 0 then
                     variants.awakened = results[1]
                 end
                 end
                rowinfo.display(tr, value, tpl_args)
             end
             end
         end
         end
       
        return tostring(tr)
     end
     end
    tpl_args._variants = {}
    table.insert(tpl_args._variants, variants.base)
    if variants.transfigured then
        for _, v in ipairs(variants.transfigured) do
            table.insert(tpl_args._variants, v)
        end
    end
    table.insert(tpl_args._variants, variants.vaal)
    table.insert(tpl_args._variants, variants.awakened)
end
end


-- Template:SMW item table/skill_gem/intro
function s.get_categories(tpl_args)
p.skill_gem_list_intro = item_table_factory.intro{data_array=core.result.skill_gem, header='Skill gem'}
    local cats = {}
-- Template:SMW item table/skill gem
    if tpl_args._flags.is_prophecy then
p.skill_gem_list_row = item_table_factory.row{data_array=core.result.skill_gem}
        table.insert(cats, i18n.categories.prophecies)
 
    elseif tpl_args._flags.is_blight_item then
-- Template:SMW item table/intro
        table.insert(cats, i18n.categories.oils)
p.item_list_intro = item_table_factory.intro{data_array=core.result.generic_item, header='Item'}
    elseif tpl_args._flags.is_talisman then
-- Template:SMW item table
        table.insert(cats, i18n.categories.talismans)
p.item_list_row = item_table_factory.row{data_array=core.result.generic_item}
    elseif tpl_args._flags.is_essence then
 
        table.insert(cats, i18n.categories.essences)
-- ----------------------------------------------------------------------------
    elseif tpl_args._flags.is_fossil then
-- Item lists
        table.insert(cats, i18n.categories.fossils)
-- ----------------------------------------------------------------------------
    elseif tpl_args._flags.is_scarab then
 
        table.insert(cats, i18n.categories.scarabs)
function p.skill_gem_list_by_gem_tag(frame)
    elseif tpl_args._flags.is_tattoo then
    -- Args
        table.insert(cats, i18n.categories.tattoos)
    g_args = getArgs(frame, {
    elseif tpl_args._flags.is_delirium_orb then
         parentFirst = true
        table.insert(cats, i18n.categories.delirium_orbs)
     })
    elseif tpl_args._flags.is_catalyst then
    g_frame = util.misc.get_frame(frame)
        table.insert(cats, i18n.categories.catalysts)
    elseif tpl_args.class_id == 'Map' and tpl_args.rarity_id == 'normal' then
        table.insert(cats, string.format(i18n.categories.maps_by_series, tpl_args.map_series))
    elseif tpl_args.class_id == 'Microtransaction' and tpl_args.cosmetic_type and m_game.constants.item.cosmetic_item_types[tpl_args.cosmetic_type].cats then
        for _, v in ipairs(m_game.constants.item.cosmetic_item_types[tpl_args.cosmetic_type].cats) do
            table.insert(cats, v)
        end
    elseif m_game.constants.item.classes[tpl_args.class_id].cats then
        for _, v in ipairs(m_game.constants.item.classes[tpl_args.class_id].cats) do
            if tpl_args.rarity_id == 'unique' then
                table.insert(cats, string.format(i18n.categories.unique_affix, v))
            else
                table.insert(cats, v)
            end
         end
     else
        table.insert(cats, tpl_args.class)
    end
      
      
     if g_args.class == 'Support Skill Gems' then
     if tpl_args._flags.is_derived then
    elseif g_args.class == 'Active Skill Gems' then
        table.insert(cats, i18n.categories.derived_items)
     else
     else
         error('invalid item class')
         table.insert(cats, i18n.categories.base_items)
     end
     end


     local query = {}
     for _, tag in ipairs(tpl_args.acquisition_tags) do
    query[#query+1] = string.format('[[Has item class::%s]]', g_args.class)
        if cfg.acquisition_tags[tag] and cfg.acquisition_tags[tag].cat then
    query[#query+1] = '?Has gem tags'
            table.insert(cats, cfg.acquisition_tags[tag].cat)
    query[#query+1] = '?Has name'
        end
    query[#query+1] = '?Has inventory icon'
     end
    --query[#query+1] = '?Has infobox HTML'
     query.limit = 5000
    query.sort = 'Has name'
      
      
     local results = util.smw.query(query, g_frame)
     for _, attr in ipairs(m_game.constants.attribute_order) do
        if tpl_args[attr .. '_percent'] then
            table.insert(cats, string.format('%s %s', m_game.constants.attributes[attr].long_upper, tpl_args.class))
        end
    end
      
      
     local tags = {}
     if cfg.class_groups.gems.keys[tpl_args.class_id] then
        for _, tag in ipairs(tpl_args.gem_tags) do
            table.insert(cats, string.format(i18n.categories.gem_tag_affix, tag))
        end
    end
 
    if tpl_args._flags.is_derived and #tpl_args._defined_implicit_mods > 0 then
        table.insert(cats, i18n.categories.implicit_modifier_override)
    end
      
      
     for _, row in ipairs(results) do
     if #tpl_args.alternate_art_inventory_icons > 0 then
         row['Has gem tags'] = util.string.split(row['Has gem tags'], '<MANY>')
         table.insert(cats, i18n.categories.alternate_artwork)
        for _, tag in ipairs(row['Has gem tags']) do
    end
            if tags[tag] == nil then
 
                tags[tag] = {}
    if tpl_args._flags.has_legacy_drop_areas == true then
            end
        mw.log('IDs of legacy map areas used in drop_areas:')
            table.insert(tags[tag], row)
        mw.logObject(tpl_args._legacy_drop_areas)
        end
        table.insert(cats, i18n.categories.legacy_drop_areas)
     end
     end
      
      
     local tags_sorted = {}
     if tpl_args.release_version == nil then
    for tag, _ in pairs(tags) do
         table.insert(cats, i18n.categories.missing_release_version)
         table.insert(tags_sorted, tag)
     end
     end
    table.sort(tags_sorted)
      
      
     local tbl = mw.html.create('table')
     if tpl_args._flags.text_modifier and not tpl_args.suppress_improper_modifiers_category then
    tbl
         table.insert(cats, i18n.categories.improper_modifiers)
         :attr('class', 'wikitable sortable')
    end
        :tag('tr')
            :tag('th')
                :wikitext('Tag')
                :done()
            :tag('th')
                :wikitext('Skills')
                :done()
            :done()
      
      
     for _, tag in ipairs(tags_sorted) do
     for _, k in ipairs({'invalid_recipe_parts', 'duplicate_recipes', 'duplicate_query_area_ids', 'sell_prices_override'}) do
        local rows = tags[tag]
        if tpl_args._flags[k] then
        local tr = tbl:tag('tr')
            table.insert(cats, i18n.categories[k])
        tr
            :tag('td')
                :wikitext(tag)
           
        local td = tr:tag('td')
        for i, row in ipairs(rows) do
            td:wikitext(p.item_link{page=row[1], name=row['Has Name'], inventory_icon=row['Has inventory icon'], html=row['Has infobox HTML'] or ''})
            if i < #rows then
                td:wikitext('<br>')
            end
         end
         end
     end
     end
 
 
     return tostring(tbl)
     if tpl_args.disable_automatic_recipes == true then
        table.insert(cats, i18n.categories.automatic_recipes_disabled)
    end
 
    if tpl_args._flags.uses_deprecated_parameters == true then
        mw.log('Deprecated parameters used:')
        mw.logObject(tpl_args._deprecated_args)
        table.insert(cats, i18n.categories.deprecated_parameters)
    end
 
    if tpl_args._flags.has_deprecated_skill_parameters then
        table.insert(cats, i18n.categories.deprecated_skill_parameters)
    end
    return cats
end
end


-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------
-- Misc. Item templates
-- Main functions
-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------


--  
local function _main(tpl_args)
-- Template:Item class
    local t = os.clock() -- Start time (for logging)
--
    tpl_args._flags = {}
    tpl_args._store_data = {}
    tpl_args._errors = {}
   
    -- Item configuration
    tpl_args._item_config = s.get_item_config(tpl_args)


function p.item_class (frame)
     -- Add table names to core.map and append range fields.
     -- Get args
     h.append_schema(tpl_args, tpl_args._item_config.tables)
     g_args = getArgs(frame, {
        parentFirst = true
    })
    g_frame = util.misc.get_frame(frame)
if not doInfoCard then
doInfoCard = require('Module:Infocard')._main
end
      
      
     core.factory.table_cast('name', {key='full', tbl=m_game.constants.item.class})()
     -- Using general purpose function to handle release and removal versions
    m_util.args.version(tpl_args)
 
    -- Assume this is meant to be a derived item if any base item parameters are set
    tpl_args._flags.is_derived = m_util.table.has_any_key(tpl_args, {'base_item_id', 'base_item_page', 'base_item'})
      
      
     if g_args.name_list ~= nil then
     -- Must validate some argument early. It is required for future things
        g_args.name_list = util.string.split(g_args.name_list, ', ')
    h.process_arguments(tpl_args, tpl_args._item_config.args)
     else
 
         g_args.name_list = {}
    -- Base item
    s.process_base_item(tpl_args)
 
     -- Process arguments that require a particular flag to be set
    -- Used for subsets of item classes that have additional fields
    for k, v in pairs(cfg.flagged_args) do
         if tpl_args._flags[k] then
            h.process_arguments(tpl_args, v.args)
        end
     end
     end
      
      
     --
     -- Mods
      
     s.process_mods(tpl_args)
    local ul = mw.html.create('ul')
 
     for _, item in ipairs(g_args.name_list) do
     -- Stats
        ul
    s.process_stats(tpl_args)
            :tag('li')
 
                :wikitext(item)
    -- Calculate and handle weapon dps
                :done()
    if cfg.class_groups.weapons.keys[tpl_args.class_id] then
        s.process_weapon_dps(tpl_args)
     end
     end
   


     -- Output Infocard
     -- Skill gems
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        h.process_skill_data(tpl_args)
    end
      
      
     local tplargs = {
     -- Late argument processing
        ['header'] = g_args.name,
    h.process_arguments(tpl_args, tpl_args._item_config.late_args)
        ['subheader'] = '[[Item class]] ' .. util.html.abbr('(?)', 'Item classes categorize items. Classes are often used to restrict items or skill gems to a specific class or by item filters'),
        [1] = 'Also reffered to as:' .. tostring(ul),
    }
      
      
     -- cats
     -- Recipes
    h.process_recipes(tpl_args)
      
      
     local cats = {
     -- Quest reward info
         'Item classes',
    s.process_quest_rewards(tpl_args)
     }
 
    -- Gem variants
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
         s.process_gem_variants(tpl_args)
     end
      
      
     -- Done
     -- ------------------------------------------------------------------------
      
     -- Infobox handling
     return doInfoCard(tplargs) .. util.misc.add_category(cats)
     -- ------------------------------------------------------------------------
end
 
    --
    -- Tabs
    --
 
    local tabs
    if type(tpl_args._variants) == 'table' and #tpl_args._variants > 1 then   
        tabs = mw.html.create('div')
            :addClass('itembox-tabs')
        for _, v in ipairs(tpl_args._variants) do
            local tab = tabs:tag('span')
            tab:addClass('itembox-tab')
            if v.current then
                tab:addClass('-selected')
            end
            if v.icon then
                tab:wikitext(string.format('[[%s|34x34px|link=%s|alt=%s]]', v.icon, v.page, v.name))
            else
                tab:wikitext(m_util.html.wikilink(v.page, v.name))
            end
        end
    end


-- ----------------------------------------------------------------------------
    --
-- Property views..
    -- Primary infobox
-- ----------------------------------------------------------------------------
    --


function v.itembox ()
    tpl_args._infobox_container = 'infobox'
     local container = v._itembox_core()
     local infobox = h.make_main_infobox(tpl_args)
   
     if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then
     if g_args.gem_icon ~= nil then
         infobox:tag('span')
         container:wikitext(string.format('[[%s]]', g_args.gem_icon))
            :addClass('images')
            :wikitext(string.format(
                '[[%s|%sx%spx]]',
                tpl_args.inventory_icon,
                cfg.image_size_full * tpl_args.size_x,
                cfg.image_size_full * tpl_args.size_y
            ))
     end
     end
    tpl_args.infobox_html = tostring(infobox)
      
      
     -- Store the infobox so it can be accessed with ease on other pages
     --
     g_frame:callParserFunction('#set:', {['Has infobox HTML'] = tostring(container)})
    -- Secondary infobox
     --
      
      
     if g_args.inventory_icon ~= nil then
     local extra_infobox = mw.html.create('div')
         container:wikitext(string.format('[[%s]]', g_args.inventory_icon))
         :addClass('item-box -' .. tpl_args.frame_type)
     end
    h.add_to_infobox_from_map(tpl_args, extra_infobox, c.extra_display_groups)
     tpl_args.metabox_html = tostring(extra_infobox)
      
      
     local infobox = tostring(container)
     --
    -- Output
    --
      
      
     local span = mw.html.create('span')
     local container = mw.html.create('div')
    span
         :addClass('infobox-page-container')
         :attr('class', 'infobox-page-container')
    if tabs then
         :wikitext(infobox)
         container:node(tabs)
    end
    container
        :node(infobox)
        :node(extra_infobox)
          
          
     if g_args.skill_screenshot then
    -- skill_screenshot is set in skill module
         span:wikitext(string.format('<br>[[%s|300px]]', g_args.skill_screenshot))
     if tpl_args.skill_screenshot then
         container:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
     end
     end
      
      
     return tostring(span) .. v._itembox_categories()
     local out = tostring(container)
end
   
    local cats = s.get_categories(tpl_args)
   
    out = out .. m_util.misc.add_category(cats, {ignore_blacklist=tpl_args.debug})
   
    --
    --  Misc
    --
   
    -- Also show the infobox for areas right away for maps, since they're both on the same page
    local query_id
    if tpl_args.rarity_id == 'normal' and tpl_args.map_area_id ~= nil then
        query_id = tpl_args.map_area_id
    elseif tpl_args.rarity_id == 'unique' and tpl_args.unique_map_area_id ~= nil then
        query_id = tpl_args.unique_map_area_id
    end


function v._itembox_core()
     if query_id then
     -- needed later for setting caculated properties
        out = out .. h.query_area_info{cats=true, where=string.format('areas.id="%s"', query_id)}
    g_args._properties = {}
    end
    local container = mw.html.create('span')
        :attr( 'class', 'item-box -' .. g_args.frame_type)
      
      
     if g_args.class == 'Divination Card' then
     -- ------------------------------------------------------------------------
        --TODO div card code
    -- Store cargo data
     else
     -- ------------------------------------------------------------------------
        local header_css
 
        if g_args.base_item and g_args.rarity ~= 'Normal' then
    -- Store the infobox so it can be accessed with ease on other pages
            line_type = 'double'
    tpl_args._infobox_container = 'inline'
        else
    tpl_args.html = tostring(h.make_main_infobox(tpl_args))
            line_type = 'single'
 
        end
    -- Map argument values for cargo storage
       
    for _, table_name in ipairs(tpl_args._item_config.tables) do
        local name_line = g_args.name
        tpl_args._store_data[table_name] = {
        if g_args.base_item and g_args.base_item ~= 'Prophecy' then
             _table = table_name,
            name_line = name_line .. '<br>' .. g_args.base_item
        }
        end
    end
       
    for k, v in pairs(tpl_args) do
        container
        local arg_def = core.map[k]
            :tag('span')
        if arg_def ~= nil then
                :attr( 'class', 'header -' .. line_type )
            if arg_def.table ~= nil and arg_def.field ~= nil then
:wikitext( name_line )
                if arg_def.type == 'Integer' then
            :done()
                    v = tonumber(string.format("%.0f", v))
           
                    if v ~= tpl_args[k] then
        local grpcont
                         mw.log(string.format('Float value "%s" for integer field "%s.%s"', tpl_args[k], arg_def.table, arg_def.field))
        local valid
        local statcont = container:tag('span')
        statcont
            :attr('class', 'item-stats')
            :done()
           
        for _, group in ipairs(core.display_groups) do
            grpcont = {}
             if group.func == nil then
                for _, disp in ipairs(group) do
                    valid = true
                    -- No args to verify which means always valid
                    if disp.args == nil then
                    elseif type(disp.args) == 'table' then
                        for _, key in ipairs(disp.args) do
                            if g_args[key] == nil then
                                valid = false
                                break
                            end
                         end
                    elseif type(disp.args) == 'function' then
                        valid = disp.args()
                    end
                    if valid then
                        grpcont[#grpcont+1] = disp.func()
                     end
                     end
                 end
                 end
            else
                 if tpl_args._store_data[arg_def.table] == nil then
                 grpcont = group.func()
                    error(string.format('Missing data for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
            end
                end
           
                if type(tpl_args._store_data[arg_def.table]) ~= 'table' then
            if #grpcont > 0 then
                     error(string.format('Unexpected format of data for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
                statcont
                end
                     :tag('span')
                tpl_args._store_data[arg_def.table][arg_def.field] = v
                    :attr('class', 'group ' .. (group.css_class or ''))
            elseif arg_def.table ~= nil and arg_def.field == nil then
                    :wikitext(table.concat(grpcont, '<br>'))
                error(string.format('Missing field for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
                    :done()
            elseif arg_def.table == nil and arg_def.field ~= nil then
                mw.log(string.format('Possibly redundant argument "%s", value:\n "%s"', k, mw.dumpObject(v)))
             end
             end
         end
         end
     end
     end
      
      
     g_frame:callParserFunction('#set:', g_args._properties)
     -- Don't store cargo data in testing mode
      
     if not tpl_args.test then
    return container
        local attach = {}
end
        for _, data in pairs(tpl_args._store_data) do
 
            if attach[data._table] == nil then
function v._itembox_categories()
                local i = 0
    cats = {}
                for _, _ in pairs(data) do
    if g_args.rarity == 'Unique' then
                    i = i + 1
        cats[#cats+1] = 'Unique ' .. g_args.class
                    -- Don't attach to tables we don't store data to. _table is always present so we need to check for 2 or more entries.
    elseif g_args.base_item == 'Prophecy' then
                    if i > 1 then
        cats[#cats+1] = 'Prophecies'
                        attach[data._table] = true
    else
                        -- One of the purposes of attaching is to facilitate table recreation.
        cats[#cats+1] = g_args.class
                        -- Unfortunately, the Cargo extension's table recreation tool is
    end
                        -- very slow and often fails to rebuild the entire table.
   
                        mw.getCurrentFrame():expandTemplate{
    for _, attr in ipairs(m_game.constants.attributes) do
                            title = string.format(i18n.templates.cargo_attach, data._table),
        if g_args[attr.long_lower .. '_percent'] then
                            args = {}
             cats[#cats+1] = string.format('%s %s', attr.long_upper, g_args.class)
                        }
                        break
                    end
                end
            end
             m_cargo.store(data, {
                debug = tpl_args.debug,
                sep = {
                    name_list = '�',
                },
            })
         end
         end
     end
     end
      
      
     local suffix
     -- Show additional error messages in console to help fixing them
     if g_args.class == 'Active Skill Gems' or g_args.class == 'Support Skill Gems' then
     if #tpl_args._errors > 0 then
         suffix = ' (gem tag)'
         mw.log(table.concat(tpl_args._errors, '\n'))
    end
    if suffix ~= nil then
        for _, tag in ipairs(g_args.gem_tags) do
            cats[#cats+1] = tag .. suffix
        end
     end
     end
      
      
     if #g_args.alternate_art_inventory_icons > 0 then
     if tpl_args.debug then
         cats[#cats+1] = 'Items with alternate artwork'
         mw.log(os.clock() - t)
        mw.log('Start logging tpl_args.')
        mw.logObject(tpl_args)
        mw.log('Stop logging tpl_args.')
        mw.log('Start logging core.map.')
        mw.logObject(core.map)
        mw.log('Stop logging core.map.')
     end
     end
   
     if tpl_args.test then
    -- TODO: add maintenance categories
         tpl_args.out = out
   
        return tpl_args
     if g_args.release_version == nil then
         cats[#cats+1] = 'Items without a release version'
     end
     end
   
     return out
    --
    -- Output formatting
    --
   
     return util.misc.add_category(cats, {ingore_blacklist=g_args.debug})
end
end
-- ----------------------------------------------------------------------------
-- Exported functions
-- ----------------------------------------------------------------------------
local p = {}
--
-- Template:Item
--
p.main = m_util.misc.invoker_factory(_main, {
    parentFirst = true,
})
p.item = p.main


return p
return p

Latest revision as of 23:36, 7 April 2024

Module documentation[view] [edit] [history] [purge]


This module is used on 13,000+ pages.

To avoid major disruption and server load, do not make unnecessary edits to this module. Test changes to this module first using its /sandbox and /testcases subpages . All of the changes can then be applied to this module in a single edit.

Consider discussing changes on the talk page or on Discord before implementing them.

Lua logo

This module depends on the following other modules:

The module implements {{item}}.

Overview

This module is responsible for creating item boxes, various item lists, item links and other item-related tasks. In the process a lot of the input data is verified and also added as semantic property to pages; as such, any templates deriving from this module should not be used on user pages other then for temporary testing purposes.

This template is also backed by an export script in PyPoE which can be used to export item data from the game files which then can be used on the wiki. Use the export when possible. de:Modul:Item2 ru:Модуль:Item2

The above documentation is transcluded from Module:Item2/doc. (edit | history)
Editors can experiment in this module's sandbox (edit | diff) and testcases (edit | run) pages.
Subpages of this module.

-------------------------------------------------------------------------------
-- 
--                                Module:Item2
-- 
-- This module implements Template:Item.
-------------------------------------------------------------------------------

require('Module:No globals')
local m_util = require('Module:Util')
local m_item_util -- Lazy load require('Module:Item util')
local m_cargo = require('Module:Cargo')

-- Should we use the sandbox version of our submodules?
local use_sandbox = m_util.misc.maybe_sandbox('Item2')

local m_game = use_sandbox and mw.loadData('Module:Game/sandbox') or mw.loadData('Module:Game')

-- Lazy loading
local f_process_skill_data -- require('Module:Skill').process_skill_data
local f_item_link -- require('Module:Item link').item_link
local f_query_area_info -- require('Module:Area').query_area_info
local f_process_recipes -- require('Module:Item2/recipes').process_recipes
local f_append_schema -- require('Module:Item2/cargo').append_schema

-- The cfg table contains all localisable strings and configuration, to make it
-- easier to port this module to another wiki.
local cfg = use_sandbox and mw.loadData('Module:Item2/config/sandbox') or mw.loadData('Module:Item2/config')

local i18n = cfg.i18n

local core = use_sandbox and require('Module:Item2/core/sandbox') or require('Module:Item2/core')

-- Declare early to avoid errors
local c = {}

-- ----------------------------------------------------------------------------
-- Helper functions
-- ----------------------------------------------------------------------------

local h = {}

-- Lazy loading for Module:Skill
function h.process_skill_data(tpl_args)
    if not f_process_skill_data then
        f_process_skill_data = use_sandbox and require('Module:Skill/sandbox').process_skill_data or require('Module:Skill').process_skill_data
    end
    return f_process_skill_data(tpl_args)
end

-- Lazy loading for Module:Item link
function h.item_link(args)
    if not f_item_link then
        f_item_link = require('Module:Item link').item_link
    end
    return f_item_link(args)
end

-- Lazy loading for Module:Area
function h.query_area_info(args)
    if not f_query_area_info then
        f_query_area_info = require('Module:Area').query_area_info
    end
    return f_query_area_info(args)
end

-- Lazy loading for Module:Item2/cargo
function h.append_schema(tpl_args, tables)
    if not f_append_schema then
        f_append_schema = use_sandbox and require('Module:Item2/cargo/sandbox').append_schema or require('Module:Item2/cargo').append_schema
    end
    return f_append_schema(tpl_args, tables)
end

-- Lazy loading for Module:Item2/recipes
function h.process_recipes(tpl_args)
    if not f_process_recipes then
        f_process_recipes = use_sandbox and require('Module:Item2/recipes/sandbox').process_recipes or require('Module:Item2/recipes').process_recipes
    end
    return f_process_recipes(tpl_args)
end

function h.handle_range_args(tpl_args, key, field, value, options)
    local opt = {}
    for k, v in pairs(options or {}) do
        opt[k] = v
    end
    local html, val2 = m_util.html.format_value(tpl_args, value, opt)
    tpl_args[key .. '_html'] = html
    tpl_args[field .. '_html'] = html
    tpl_args[field .. '_range_colour'] = val2.color
    opt.color = false
    tpl_args[field .. '_range_text'] = m_util.html.format_value(tpl_args, value, opt)
end

h.stat = {}
function h.stat.add(value, magnitude)
    value.min = value.min + magnitude.min
    value.max = value.max + magnitude.max
end

function h.stat.add_distance(value, magnitude)
    -- Stats for distance are 10x the display value
    value.min = value.min + (magnitude.min / 10)
    value.max = value.max + (magnitude.max / 10)
end

function h.stat.increased(value, magnitude)
    value.min = value.min * (1 + magnitude.min / 100)
    value.max = value.max * (1 + magnitude.max / 100)
end

function h.stat.increased_inverse(value, magnitude)
    value.min = value.min / (1 + magnitude.min / 100)
    value.max = value.max / (1 + magnitude.max / 100)
end

--
-- Processing
--

function h.process_arguments(tpl_args, params)
    tpl_args._processed_args = tpl_args._processed_args or {}
    tpl_args._base_item_args = tpl_args._base_item_args or {}
    for _, k in ipairs(params) do
        local arg_def = core.map[k]
        if arg_def == nil then
            if tpl_args.debug then
                error(string.format(i18n.debug.invalid_argument_key, k))
            end
        else
            if arg_def.inherit ~= false then
                table.insert(tpl_args._base_item_args, k)
            end
            if tpl_args[k] ~= nil and arg_def.deprecated == true then
                tpl_args._flags.uses_deprecated_parameters = true
                tpl_args._deprecated_args = tpl_args._deprecated_args or {}
                table.insert(tpl_args._deprecated_args, k)
            end
            if arg_def.func ~= nil then
                tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
            end
            if tpl_args[k] == nil then
                if tpl_args.class_id and tpl_args._item_config.defaults[k] ~= nil and (not tpl_args._flags.is_derived or arg_def.inherit == false) then
                    -- Defaults based on item class
                    -- Ignore inherited fields if this is a derived item; these are set by the base item instead
                    tpl_args[k] = tpl_args._item_config.defaults[k]
                elseif arg_def.default ~= nil then
                    -- General defaults
                    if type(arg_def.default) == 'function' then
                        tpl_args[k] = arg_def.default(tpl_args)
                    else
                        tpl_args[k] = arg_def.default
                    end
                end
            end
            tpl_args._processed_args[k] = true
        end
    end
end

--
-- Display
--

function h.strip_random_stats(tpl_args, stat_text)
    if tpl_args._flags.random_mods then
        repeat
            local text = string.match(stat_text, '<th class="mw%-customtoggle%-31">(.+)</th>')
            if text ~= nil then
                stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1)
            end
        until text == nil
    end
    return stat_text
end

function h.add_to_infobox_from_map(tpl_args, infobox, mapping)
    local statcont = mw.html.create('span')
        :addClass('item-stats')
    local count = 0 -- Number of groups in infobox
    for _, group in ipairs(mapping) do
        local lines = {}
        for _, line in ipairs(group) do
            local show = true
            if line.show == false then
                show = false
            elseif type(line.show) == 'function' then
                show = line.show(tpl_args)
            end
            if show then
                lines[#lines+1] = line.func(tpl_args)
            end
        end
        if #lines > 0 then
            count = count + 1
            local heading = ''
            if group.heading == nil then
            elseif type(group.heading) == 'function' then
                heading = group.heading()
            else
                heading = string.format('<em class="header">%s</em><br>', group.heading)
            end
            statcont
                :tag('span')
                    :addClass('group ' .. (group.class or ''))
                    :wikitext(heading .. table.concat(lines, '<br>'))
                    :done()
        end
    end

     -- Add groups to infobox
    if count > 0 then
        infobox:node(statcont)
    end
end

function h.make_main_infobox(tpl_args)
    local infobox = mw.html.create('span')
        :addClass('item-box -' .. tpl_args.frame_type)
    
    if tpl_args.class_id == 'DivinationCard' then
        local divcard = infobox
            :tag('span')
                :addClass('divicard-wrapper')
        local card_background = tpl_args.card_background or {}
        if #card_background > 0 then
            divcard
                :tag('span')
                    :addClass('divicard-background')
                    :wikitext(string.format(
                        '[[%s|390px|gif]]',
                        string.format(
                            i18n.files.divination_card_background,
                            table.concat(card_background, '-')
                        )
                    ))
        end
        divcard
            :tag('span')
                :addClass('divicard-art')
                :wikitext(string.format('[[%s|link=|alt=]]', tpl_args.card_art))
                :done()
            :tag('span')
                :addClass('divicard-frame')
                :done()
            :tag('span')
                :addClass('divicard-header')
                :wikitext(tpl_args.name)
                :done()
            :tag('span')
                :addClass('divicard-artlink')
                :wikitext(string.format('[[%s]]', tpl_args.card_art))
                :done()
            :tag('span')
                :addClass('divicard-stack')
                :wikitext(tpl_args.stack_size)
                :done()
            :tag('span')
                :addClass('divicard-face')
                :tag('span')
                    :addClass('divicard-reward')
                    :wikitext(tpl_args.description)
                    :done()
                :tag('span')
                    :addClass('divicard-flavour')
                    :wikitext(tpl_args.flavour_text)
                    :done()
    else
        local line_type
        local name_line
        if tpl_args._flags.is_derived and tpl_args.rarity_id ~= 'normal' then
            line_type = 'double'
            name_line = tpl_args.name .. '<br>' .. tpl_args.base_item
        else
            line_type = 'single'
            name_line = tpl_args.name
        end

        -- Symbols - These are displayed in the item box header to indicate certain flags and/or item influences
        local symbols
        local influences = tpl_args.influences or {}
        if tpl_args.is_replica then
            symbols = {'replica', 'replica'}
            if #influences > 0 then
                symbols[2] = influences[1]
            end
        elseif #influences > 0 then
            symbols = {influences[1], influences[1]}
            if #influences > 1 then
                symbols[2] = influences[2]
            end
        elseif tpl_args.is_fractured then
            symbols = {'fractured', 'fractured'}
        elseif tpl_args.is_synthesised then
            symbols = {'synthesised', 'synthesised'}
        elseif tpl_args.is_searing_exarch_item or tpl_args.is_eater_of_worlds_item then
            symbols = {
                tpl_args.is_searing_exarch_item and 'searingexarch' or 'eaterofworlds',
                tpl_args.is_eater_of_worlds_item and 'eaterofworlds' or 'searingexarch'
            }
        elseif tpl_args.is_veiled then
            symbols = {'veiled', 'veiled'}
        end
        
        infobox
            :tag('span')
                :addClass('header -' .. line_type)
                :tag('span')
                    :addClass('symbol')
                    :addClass(symbols and '-' .. symbols[1] or nil)
                    :done()
                :wikitext(name_line)
                :tag('span')
                    :addClass('symbol')
                    :addClass(symbols and '-' .. symbols[2] or nil)
                    :done()
            :done()
            
        h.add_to_infobox_from_map(tpl_args, infobox, c.item_infobox_groups)
    end
    
    if tpl_args.skill_icon ~= nil then
        infobox:wikitext(string.format('[[%s]]', tpl_args.skill_icon))
    end
    
    return infobox
end

-- 
-- Factory
-- 

h.factory = {}

function h.factory.maybe_show_infobox_line(args)
    -- Verifies that a list of keys are present in tpl_args and that the item 
    -- should use those keys. Returns true if all conditions are met, otherwise 
    -- returns false.
    return function (tpl_args)
        local keys = args.keys or {}
        local conditions = args.conditions or {}
        if #keys == 0 then
            return false
        end
        for _, k in ipairs(keys) do
            if tpl_args[k] == nil then
                return false
            end
            local t = type(tpl_args[k])
            if (t == 'table' or t == 'string') and #tpl_args[k] == 0 then
                return false
            end
            if conditions.processed == true and tpl_args._processed_args[k] == nil then
                return false
            end
        end
        return true
    end
end

function h.factory.display_raw_value(key)
    return function(tpl_args)
        return tpl_args[key]
    end
end

function h.factory.descriptor_value(args)
    -- Arguments:
    --  key
    --  tbl
    args = args or {}
    return function (tpl_args, value)
        args.tbl = args.tbl or tpl_args
        if args.tbl[args.key] then
            value = m_util.html.abbr(value, args.tbl[args.key])
        end
        return value
    end
end

-- ----------------------------------------------------------------------------
-- Additional configuration
-- ----------------------------------------------------------------------------

-- helper to loop over the range variables easier
c.range_map = {
    min = '_range_minimum',
    max = '_range_maximum',
    avg = '_range_average',
}

--
-- Contents here are meant to resemble the ingame infobox of items
--
c.item_infobox_groups = {
    -- [n]: 
    --  class: Additional css class added to group tag
    --  heading: Group heading text (used for extras)
    --  lines: 
    --   [n]: 
    --    show: Show line if this function returns true; Always show if boolean true. Default: Always show
    --    func: Function that returns line text
    {
        -- Item type (weapons, hideout decorations, abyss jewels)
        {
            show = function (tpl_args)
                return i18n.item_class_map[tpl_args.class_id] ~= nil
            end,
            func = function (tpl_args)
                return i18n.item_class_map[tpl_args.class_id]
            end,
        },
        -- Cosmetic item type
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cosmetic_type'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('cosmetic_type'),
        },
        -- Gems
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'gem_tags'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                local out = {}
                for i, tag in ipairs(tpl_args.gem_tags) do
                    out[#out+1] = string.format(i18n.gem_tag_category, tag, tag)
                end
                return table.concat(out, ', ')
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'support_gem_letter_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'support_gem_letter_html',
                        color = false,
                    },
                },
                fmt = i18n.tooltips.support_icon,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = function (tpl_args)
                local value = {
                    base = 1,
                    min = 1,
                    max = tpl_args.max_level,
                }
                local options = {
                    fmt = '%i',
                    color = 'value',
                }
                return string.format(
                    i18n.tooltips.level,
                    m_util.html.format_value(tpl_args, value, options)
                )
            end,
        },
        {
            show = function (tpl_args)
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = function (tpl_args)
                local parts = {}
                for k, v in pairs(m_game.constants.skill.cost_types) do
                    parts[#parts+1] = {
                        key = 'cost_' .. k,
                        func = function (tpl_args, value)
                            if string.find(k, 'PerMinute', 1, true) then
                                value = value / 60 -- Cost per second
                            end
                            return value
                        end,
                        fmt = '%i',
                        inline = string.format(
                            '%%s%s %s',
                            string.find(k, 'Percent', 1, true) and '%%' or '',
                            v.long_upper
                        ),
                    }
                end
                return core.factory.infobox_line{
                    type = 'gem',
                    parts = parts,
                    sep = ', ',
                    fmt = i18n.tooltips.cost,
                }(tpl_args)
            end,
        },
        {
            show = function (tpl_args)
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'mana_reservation_flat',
                        fmt = '%i',
                        inline = '%s ' .. m_game.constants.skill.cost_types['Mana'].long_upper,
                    },
                    {
                        key = 'mana_reservation_percent',
                        fmt = '%i',
                        inline = '%s%% ' .. m_game.constants.skill.cost_types['Mana'].long_upper,
                    },
                    {
                        key = 'life_reservation_flat',
                        fmt = '%i',
                        inline = '%s ' .. m_game.constants.skill.cost_types['Life'].long_upper,
                    },
                    {
                        key = 'life_reservation_percent',
                        fmt = '%i',
                        inline = '%s%% ' .. m_game.constants.skill.cost_types['Life'].long_upper,
                    },
                },
                sep = ', ',
                fmt = i18n.tooltips.reservation,
            },
        },
        {
            show = true, -- TODO: Show only if has cost_multiplier
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'cost_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                        inline = '%s%%',
                    },
                },
                fmt = i18n.tooltips.cost_multiplier,
            },
        },
        {
            show = true, -- TODO: Show only if has cooldown
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'cooldown',
                        hide_default = 0,
                        fmt = '%.2f ' .. m_game.units.seconds.short_lower,
                    },
                },
                fmt = i18n.tooltips.cooldown_time,
            },
        },
        {
            -- TODO: Combine with cooldown. Multi-use non-vaal skills display uses together with cooldown time. E.g., Cooldown Time: 8.00 sec (3 uses)
            show = true,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'stored_uses',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.stored_uses,
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_souls_requirement
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_souls_requirement',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.vaal_souls_per_use,
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_stored_uses
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_stored_uses',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.stored_uses, -- TODO: Singular or plural based on number
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_soul_gain_prevention_time
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_soul_gain_prevention_time',
                        hide_default = 0,
                        -- Technically it rounds to nearest, but it is given in milliseconds in the data, 
                        fmt = '%i ' .. m_game.units.seconds.short_lower,
                    },
                },
                fmt = i18n.tooltips.vaal_soul_gain_prevention_time,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.cast_time and tpl_args.gem_tags and (m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) or m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.warcry.tag))
            end,
            func = function (tpl_args)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'cast_time',
                            fmt = function (tpl_args, value)
                                if value.min == 0 then
                                    return i18n.tooltips.instant_cast_time
                                end
                                return '%.2f ' .. m_game.units.seconds.short_lower
                            end,
                        },
                    },
                    fmt = m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) and i18n.tooltips.cast_time or i18n.tooltips.use_time,
                }(tpl_args)
            end,
        },
        {
            show = true, -- TODO: Show only if has attack_time
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'attack_time',
                        hide_default = 0,
                        fmt = '%.2f ' .. m_game.units.seconds.short_lower,
                    },
                },
                fmt = i18n.tooltips.attack_time,
            },
        },
        {
            show = true, -- TODO: Show only if has critical_strike_chance
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'critical_strike_chance',
                        hide_default = 0,
                        fmt = '%.2f%%',
                    },
                },
                fmt = i18n.tooltips.critical_strike_chance,
            },
        },
        {
            show = true, -- TODO: Show only if has attack_speed_multiplier
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'attack_speed_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                        inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                    },
                },
                fmt = i18n.tooltips.attack_speed_multiplier,
            },
        },
        {
            show = true, -- TODO: Show only if has damage_multiplier
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'damage_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                        inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                    },
                },
                fmt = i18n.tooltips.damage_multiplier,
            },
        },
        {
            show = true, -- TODO: Show only if has damage_effectiveness
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'damage_effectiveness',
                        hide_default = 100,
                        fmt = '%i',
                        inline = '%s%%',
                    },
                },
                fmt = i18n.tooltips.damage_effectiveness,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'projectile_speed'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'projectile_speed',
                    },
                },
                fmt = i18n.tooltips.projectile_speed,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'radius'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'radius',
                        func = h.factory.descriptor_value{key='radius_description'},
                    },
                    {
                        key = 'radius_secondary',
                        func = h.factory.descriptor_value{key='radius_secondary_description'},
                    },
                    {
                        key = 'radius_tertiary',
                        func = h.factory.descriptor_value{key='radius_tertiary_description'},
                    },
                },
                sep = ' / ',
                fmt = i18n.tooltips.aoe_radius,
            },
        },
        -- Quality is before item stats, but after gem stuff and item class
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'quality'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'quality',
                        fmt = '+%i%%',
                        color = 'mod',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.quality,
            },
        },
        -- Weapons
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'physical_damage_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'physical_damage_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.physical_damage,
            },       
        },
        {
            show = true, -- Elemental Damage
            func = function (tpl_args)
                local keys = {'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}
                local elements = {}
                for _, key in ipairs(keys) do
                    if tpl_args[key] then
                        elements[#elements+1] = tpl_args[key]
                    end
                end
                local text = table.concat(elements, ', ') -- returns empty string if elements is empty
                if text ~= '' then
                    return string.format(i18n.tooltips.elemental_damage, text)
                end
                return
            end,      
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'chaos_damage_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'chaos_damage_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.chaos_damage,
            },       
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'critical_strike_chance_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'critical_strike_chance_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.critical_strike_chance,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'attack_speed_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'attack_speed_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.attacks_per_second,
            },
        },
        {
            show = function (tpl_args)
                -- Do not show for ranged weapons
                if tpl_args.tags and m_util.table.contains(tpl_args.tags, 'ranged') then
                    return false
                end
                return h.factory.maybe_show_infobox_line{
                    keys = {'weapon_range_html'},
                }(tpl_args)
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'weapon_range_html',
                        color = false, -- html already has color
                        inline = '%s ' .. m_game.units.metres.long_lower,
                    },
                },
                fmt = i18n.tooltips.weapon_range,
            },
        },
        -- Maps
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'map_area_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_area_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.map_level,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'map_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.map_tier,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.map_guild_character ~= nil and tpl_args.rarity_id == 'normal'
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_guild_character',
                    },
                },
                fmt = i18n.tooltips.map_guild_character,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.unique_map_guild_character ~= nil and tpl_args.rarity_id == 'unique'
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'unique_map_guild_character',
                    },
                },
                fmt = i18n.tooltips.map_guild_character,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.class_id == 'Map'
            end,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_item_drop_quantity_+%',
                        fmt = '%i',
                        color = 'mod',
                        inline = '+%s%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.item_quantity,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.class_id == 'Map'
            end,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_item_drop_rarity_+%',
                        fmt = '%i',
                        color = 'mod',
                        inline = '+%s%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.item_rarity,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.class_id == 'Map'
            end,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_pack_size_+%',
                        fmt = '%i',
                        color = 'mod',
                        inline = '+%s%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.monster_pack_size,
            },
        },
        -- Jewels
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'jewel_limit'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'jewel_limit',
                    },
                },
                fmt = i18n.tooltips.limited_to,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'jewel_radius_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'jewel_radius_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.radius,
            },
        },
        -- Flasks
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flask_mana_html', 'flask_duration_html'},
            },
            --func = core.factory.display_flask('flask_mana'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_mana_html',
                        color = false, -- html already has color
                    },
                    {
                        key = 'flask_duration_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.flask_mana_recovery,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flask_life_html', 'flask_duration_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_life_html',
                        color = false, -- html already has color
                    },
                    {
                        key = 'flask_duration_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.flask_life_recovery,
            },
        },
        {
            -- don't display for mana/life flasks
            show = function (tpl_args)
                for _, k in ipairs({'flask_life_html', 'flask_mana_html'}) do
                    if tpl_args[k] ~= nil then
                        return false
                    end
                end
                return tpl_args['flask_duration_html'] ~= nil
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_duration_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.flask_duration,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'charges_per_use_html', 'charges_max_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'charges_per_use_html',
                        color = false, -- html already has color
                    },
                    {
                        key = 'charges_max_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.flask_charges_per_use,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'buff_stat_text'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'buff_stat_text',
                        color = 'mod',
                    },
                },
            },
        },
        -- Armor
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'block_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'block_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'block',
                    },
                },
                fmt = i18n.tooltips.chance_to_block,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'armour_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'armour_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'armour',
                    },
                },
                fmt = i18n.tooltips.armour,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'evasion_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'evasion_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'evasion',
                    },
                },
                fmt = i18n.tooltips.evasion,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'energy_shield_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'energy_shield_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'energy_shield',
                    },
                },
                fmt = i18n.tooltips.energy_shield,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'ward_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'ward_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'ward',
                    },
                },
                fmt = i18n.tooltips.ward,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'movement_speed'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'movement_speed',
                        fmt = '%i%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.movement_speed,
            },
        },
        -- Stackables
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'stack_size'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'stack_size',
                        fmt = '%i',
                        hide_default = 1,
                    },
                },
                fmt = i18n.tooltips.stack_size,
            },
        },
        -- Essences
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'essence_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'essence_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.essence_level,
            },
        },
        -- Oils
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'blight_item_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'blight_item_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.blight_item_tier,
            },
        },
        -- Tattoos
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_target'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_target',
                    },
                },
                fmt = i18n.tooltips.tattoo_target,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_limit'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_limit',
                    },
                },
                fmt = i18n.tooltips.tattoo_limit,
            },
        },
        -- Harvest seeds (upper section)
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.seed_tier,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_tier'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                return i18n.tooltips.seed_monster
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_type_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_type_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.seed_lifeforce_gained,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_growth_cycles'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_growth_cycles',
                    },
                },
                fmt = i18n.tooltips.seed_growth_cycles,
            },
        },
        -- Heist
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'heist_required_npcs'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_npcs',
                    },
                },
                fmt = i18n.tooltips.heist_required_npc,
            },
        },
        -- Sentinels
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_duration'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_duration',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_duration,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_empowers'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_empowers',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_empowers,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_empowerment'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_empowerment',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_empowerment,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_monster', 'sentinel_monster_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_monster',
                    },
                    {
                        key = 'sentinel_monster_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_can_only_empower,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_charge'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_charge',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_charge,
            },
        },
        -- Corpse items
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'monster_category_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'monster_category_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.monster_category,
            },
        },
        -- Embers of the Allflame
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'pack_size_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'pack_size_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.pack_size,
            },
        },

        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'pack_leader_chance'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'pack_leader_chance',
                            hide_default = 0,
                            fmt = '%i%%',
                        },
                    },
                    fmt = tpl_args['pack_leader_chance'] < 100 and i18n.tooltips.pack_chance_to_contain_pack_leader or i18n.tooltips.pack_contains_pack_leader,
                }(tpl_args)
            end,
        },
    },
    -- Requirements
    {
        -- Talismans display their tier right above requirements
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'talisman_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'talisman_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.talisman_tier,
            },
        },
        -- Equipment requirements
        {
            show = true, -- Requires...
            func = function (tpl_args)
                local parts = {
                    {
                        key = 'required_level_final_html',
                        color = false, -- html already has color
                        inline = i18n.tooltips.level_inline,
                        hide_default = 1,
                        hide_default_key = 'required_level_final',
                    },
                }
                for _, attr in ipairs(m_game.constants.attribute_order) do
                    parts[#parts+1] = {
                        key = string.format('required_%s_html', attr),
                        color = false, -- html already has color
                        inline = '%s ' .. m_game.constants.attributes[attr].short_upper,
                        hide = function (tpl_args, value)
                            local min = m_game.constants.characters.minimum_attributes[m_game.constants.attributes[attr].short_lower]
                            return value.min <= min and value.max <= min
                        end,
                        hide_key = string.format('required_%s', attr),
                    }
                end
                return core.factory.infobox_line{
                    parts = parts,
                    sep = ', ',
                    fmt = i18n.tooltips.requires,
                }(tpl_args)
            end,
        },
        -- Tattoo requirements
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_min_adjacent'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_min_adjacent',
                        fmt = '%i',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.tattoo_min_adjacent,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_max_adjacent'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_max_adjacent',
                        fmt = '%i',
                        color = 'value',
                        inline = i18n.tooltips.tattoo_maximum .. ' %s',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.tattoo_max_adjacent,
            },
        },
        -- Heist gear requirements
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'heist_required_job', 'heist_required_job_level'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_job_level',
                    },
                    {
                        key = 'heist_required_job',
                    },
                },
                fmt = i18n.tooltips.heist_required_job,
            },
        },
    },
    -- Gem description
    {
        class = 'tc -gemdesc',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'gem_description'},
            },
            func = h.factory.display_raw_value('gem_description'),
        },
    },
    -- Gem stats
    {
        class = 'tc -mod',
        {
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.stat_text
            end,
            func = h.factory.display_raw_value('stat_text'),
        },
        {
            -- Gem quality selector widget
            -- Show in full infobox if gem has alternate quality
            -- Never show in hover infobox
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.quality_type1_stat_text and tpl_args._flags.is_alt_quality_gem and tpl_args._infobox_container == 'infobox'
            end,
            func = function (tpl_args)
                local html = mw.html.create()
                    :tag('br'):done()
                local widget = html:tag('span')
                    :addClass('gemqual-widget')
                    :wikitext(m_util.html.poe_color('value', string.format(i18n.tooltips.gem_quality_effect_bonus, '')))
                local qtypes = {}
                for k, quality_data in ipairs(tpl_args.skill_quality) do
                    qtypes[#qtypes+1] = m_game.constants.item.gem_quality_types[k].long_upper
                    local stats = widget:tag('span')
                        :addClass('gemqual-widget__stats')
                        :attr('data-qid', k)
                        :wikitext(quality_data.stat_text)
                    if k == 1 then
                        stats:addClass('is-selected')
                    end
                end
                widget:attr('data-qtypes', table.concat(qtypes, ','))
                return tostring(html)
            end,
        },
        {
            -- Superior quality bonus
            -- Show in full infobox if gem does not have alternate quality
            -- Always show in hover infobox
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.quality_type1_stat_text and (not tpl_args._flags.is_alt_quality_gem or tpl_args._infobox_container == 'inline')
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'quality_type1_stat_text',
                        color = 'mod',
                        inline = i18n.tooltips.gem_quality_effect_bonus,
                        inline_color = 'value',
                    },
                },
                fmt = ' <br> %s',
            },
        },
    },
    -- Implicit stats
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'implicit_stat_text'},
            },
            func = function (tpl_args)
                if tpl_args._infobox_container == 'inline' then
                    return h.strip_random_stats(tpl_args, tpl_args.implicit_stat_text)
                end
                return tpl_args.implicit_stat_text
            end,
        },
    },
    -- Explicit stats
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'explicit_stat_text'},
            },
            func = function (tpl_args)
                if tpl_args._infobox_container == 'inline' then
                    return h.strip_random_stats(tpl_args, tpl_args.explicit_stat_text)
                end
                return tpl_args.explicit_stat_text
            end,
        },
    },
    -- Experience
    --[[{
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'experience'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'experience',
                        fmt = '%i',
                    },
                },
            },
        },
    },]]--
    -- Harvest seeds (lower section)
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_consumed_wild_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.seed_consumed_wild_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_wild_lifeforce_percentage, m_util.html.poe_color('wild', m_game.seed_types.wild))
                end
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_consumed_vivid_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.seed_consumed_vivid_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_vivid_lifeforce_percentage, m_util.html.poe_color('vivid', m_game.seed_types.vivid))
                end
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_consumed_primal_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.seed_consumed_primal_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_primal_lifeforce_percentage, m_util.html.poe_color('primal', m_game.seed_types.primal))
                end
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_required_nearby_seed_amount',
                    },
                    {
                        key = 'seed_type_html',
                    },
                    {
                        key = 'seed_required_nearby_seed_tier',
                    },
                },
                fmt = i18n.tooltips.seed_required_seeds,
                color = 'mod',
            },
        },
    },
    {
        class = 'tc -crafted',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_effect'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('seed_effect'),
        },
    },
    -- Description
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'description'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('description'),
        },
        --[[{
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_additional_crafting_options'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_additional_crafting_options',
                    },
                },
                fmt = i18n.tooltips.plant_booster_additional_crafting_options,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_extra_chances'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_extra_chances',
                        fmt = '%s%%',
                    },
                },
                fmt = i18n.tooltips.plant_booster_extra_chances,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_lifeforce'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_lifeforce',
                        fmt = '%s%%',
                    },
                },
                fmt = i18n.tooltips.plant_booster_lifeforce,
            },
        },]]
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'monster_abilities'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('monster_abilities'),
        },
    },
    -- Variations (for hideout decorations)
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'variation_count'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.variation_count > 1 then
                    return string.format('%i %s', tpl_args.variation_count, i18n.tooltips.variations)
                end
                return nil
            end,
        },
    },
    -- Corrupted
    {
        class = 'tc -corrupted',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_corrupted'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_corrupted then
                    return i18n.tooltips.corrupted
                end
                return nil
            end,
        },
    },
    -- Mirrored
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_mirrored'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_mirrored then
                    return i18n.tooltips.mirrored
                end
                return nil
            end,
        },
    },
    -- Unmodifiable
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_unmodifiable'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_unmodifiable then
                    return i18n.tooltips.unmodifiable
                end
                return nil
            end,
        },
    },
    -- Flavour text
    {
        class = 'tc -flavour',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flavour_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('flavour_text'),
        },
    },
    -- Prophecy text
    {
        class = 'tc -value',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'prediction_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('prediction_text'),
        },
    },
    -- Can not be traded or modified
    {
        class = 'tc -canttradeormodify',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cannot_be_traded_or_modified'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.cannot_be_traded_or_modified then
                    return i18n.tooltips.cannot_be_traded_or_modified
                end
                return nil
            end,
        },
    },
    -- Help text
    {
        class = 'tc -help',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'help_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('help_text'),
        },
    },
    -- Account-bound
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_account_bound'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_account_bound then
                    return i18n.tooltips.account_bound
                end
                return nil
            end,
        },
    },
}

--
-- This is meant to show additional information about the item in a separate infobox
--
c.extra_display_groups = {
    {
        heading = i18n.tooltips.extra_info,
        class = '',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'atlas_connections'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                local fields = {
                    [false] = {
                        value = '✗',
                        sort = 0,
                        class = 'table-cell-xmark',
                    },
                    [true] = {
                        value = '✓',
                        sort = 1,
                        class = 'table-cell-checkmark',
                    },
                }
                
                local tbl = mw.html.create('table')
                tbl
                    :addClass('wikitable')
                    :attr('style', 'width:100%;')
                    :tag('tr')
                        :tag('th')
                            :attr('colspan', 6)
                            :attr('style', 'text-decoration: underline;')
                            :wikitext(i18n.tooltips.header_overall)
                            :done()
                        :done()
                    :tag('tr')
                        :tag('th')
                            :wikitext(i18n.tooltips.header_upgrades)
                            :done()
                        :tag('th')
                            :wikitext(0)
                            :done()
                        :tag('th')
                            :wikitext(1)
                            :done()
                        :tag('th')
                            :wikitext(2)
                            :done()
                        :tag('th')
                            :wikitext(3)
                            :done()
                        :tag('th')
                            :wikitext(4)
                            :done()
                        :done()
                    
                for _, vtype in ipairs({'tier', 'level'}) do
                    local tr = tbl:tag('tr')
                    tr
                        :tag('th')
                            :wikitext(i18n.tooltips['header_map_' .. vtype])
                            :done()
                    
                    for i=0,4 do
                        local value = tpl_args['atlas_map_tier' .. i]
                        if value == 0 then
                            value = fields[false].value
                        elseif vtype == 'level' then
                            value = value + 67
                        end
                        tr
                            :tag('td')
                                :wikitext(value)
                                :done()
                    end
                    tr:done()
                end
                
                tbl
                    :tag('tr')
                        :tag('th')
                            :attr('colspan', 6)
                            :attr('style', 'text-decoration: underline;')
                            :wikitext(i18n.tooltips.header_connections)
                            :done()
                        :done()
                
                -- sort alphabetically
                local sorted = {}
                for key, value in pairs(tpl_args.atlas_connections) do
                    sorted[#sorted+1] = key
                end
                table.sort(sorted)
                
                for _, key in ipairs(sorted) do
                    local tr = tbl:tag('tr')
                    tr
                        :tag('th')
                            :wikitext(key)
                            :done()
                    
                    for i=0,4 do
                        local field = fields[tpl_args.atlas_connections[key]['region' .. i]]
                        tr
                            :tag('td')
                                :attr('data-sort-value', field.sort)
                                :addClass(field.class)
                                :wikitext(field.value)
                                :done()
                    end
                    tr:done()
                end
                
                return tostring(tbl)
            end
        },
    },
    -- Acquisition
    {
        heading = i18n.tooltips.acquisition,
        {
            show = function (tpl_args)
                if tpl_args.is_in_game == false then
                    return true
                end
                return false
            end,
            func = function (tpl_args)
                local span = mw.html.create('span')
                span
                    :addClass('infobox-disabled-drop')
                    :wikitext(i18n.tooltips.not_in_game)
                    :done()
                return tostring(span)
            end,
        },
        {
            show = function (tpl_args)
                if tpl_args.drop_enabled == false and tpl_args.is_in_game ~= false then
                    return true
                end
                return false
            end,
            func = function (tpl_args)
                local span = mw.html.create('span')
                span
                    :addClass('infobox-disabled-drop')
                    :wikitext(i18n.tooltips.drop_disabled)
                    :done()
                return tostring(span)
            end,
        },
        {
            show = function (tpl_args)
                if tpl_args.is_drop_restricted == true and tpl_args.drop_enabled ~= false then
                    return true
                end
                return false
            end,
            func = function (tpl_args)
                local span = mw.html.create('span')
                span
                    :addClass('infobox-restricted-drop')
                    :wikitext(i18n.tooltips.drop_restricted)
                    :done()
                return tostring(span)
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'drop_level',
                        fmt = '%i',
                    },
                    {
                        key = 'drop_level_maximum',
                        fmt = '%i',
                        hide_default = 100,
                    },
                },
                sep = ' / ',
                fmt = i18n.tooltips.drop_level,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'acquisition_tags'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                local tags = {}
                for _, v in pairs(tpl_args.acquisition_tags) do
                    if v then
                        tags[#tags+1] = string.format('[[%s|%s]]', cfg.acquisition_tags[v].page, cfg.acquisition_tags[v].name)
                    end
                end
                return table.concat(tags, ' • ')
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_areas_html'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('drop_areas_html'),
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('drop_text'),
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seal_cost'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seal_cost',
                        fmt = function (tpl_args, value)
                            return string.format('%s %s', i18n.fmt.item_count, h.item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''})
                        end,
                        color = 'currency',
                    },
                },
                fmt = i18n.tooltips.seal_cost,
            },
        },
    },
    {
        -- Vendor prices
        heading = i18n.tooltips.purchase_costs,
        {
            show = function (tpl_args)
                for rarity, data in pairs(tpl_args.purchase_costs) do
                    if #data > 0 then
                        return true
                    end
                end
                return false
            end,
            func = function (tpl_args)
                local tbl = mw.html.create('table')
                tbl
                    --:addClass('wikitable')
                    :attr('style', 'width: 100%; margin-top: 0px;')
                    
                for _, rarity_id in ipairs(m_game.constants.rarity_order) do
                    local data = tpl_args.purchase_costs[rarity_id]
                    if #data > 0 then
                        local tr = tbl:tag('tr')
                        tr
                            :tag('td')
                                :wikitext(m_game.constants.rarities[rarity_id].long_upper)
                        local td = tr:tag('td')
                        for _, purchase_data in ipairs(data) do
                            td:wikitext(string.format('%dx [[%s]]<br />', purchase_data.amount, purchase_data.name))
                        end
                    end
                end
                
                return tostring(tbl)
            end,
        },
    },
    {
        -- Vendor offer
        heading = i18n.tooltips.sell_price,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sell_price_order'},
            },
            func = function (tpl_args)
                local out = {}
                if #tpl_args.sell_price_order > 0 then
                    for _, item_name in ipairs(tpl_args.sell_price_order) do
                        out[#out+1] = string.format('%dx [[%s]]', tpl_args.sell_prices[item_name], item_name)
                    end
                end
                return table.concat(out, '<br />')
            end,
        },
    },
    -- Damage per second
    {
        heading = i18n.tooltips.damage_per_second,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'physical_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'physical_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.physical_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'fire_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'fire_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.fire_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cold_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'cold_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.cold_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'lightning_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'lightning_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.lightning_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'chaos_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'chaos_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.chaos_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'elemental_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'elemental_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.elemental_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'poison_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'poison_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.poison_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.dps,
            },
        },
    },
    -- Metadata
    {
        heading = i18n.tooltips.metadata,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'class'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'class',
                    },
                },
                fmt = i18n.tooltips.item_class,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'metadata_id'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'metadata_id',
                            inline = m_util.html.abbr('%s', tpl_args.metadata_id),
                        },
                    },
                    fmt = tostring(
                        mw.html.create('span')
                            :addClass('u-truncate-line')
                            :wikitext(i18n.tooltips.metadata_id)
                    ),
                }(tpl_args)
            end,
        },
    },
}

-- ----------------------------------------------------------------------------
-- Subroutines
-- ----------------------------------------------------------------------------

local s = {}

-- Subroutines for p.item. These exist to declutter the main function. Each one of these is only called once.

function s.get_item_config(tpl_args)
    -- Returns primary item configuration, based on item class

    local config = {
        tables = {}, -- Table names that data may be stored to
        args = {}, -- Args to process early
        late_args = {}, -- Args to process late
        defaults = {}, -- Defaults based on item class
    }
    for _, v in ipairs(cfg.tables) do
        table.insert(config.tables, v)
    end
    for _, v in ipairs(cfg.default_args) do
        table.insert(config.args, v)
    end
    for _, v in ipairs(cfg.late_args) do
        table.insert(config.late_args, v)
    end

    -- Process class_id
    h.process_arguments(tpl_args, {'class_id'})

    local extend_keys = {'tables', 'args', 'late_args'} -- We will do defaults separately to preserve order of args
    for _, row in pairs(cfg.class_groups) do
        if row.keys[tpl_args.class_id] then
            for _, k in ipairs(extend_keys) do
                if row[k] then
                    for _, v in ipairs(row[k]) do
                        table.insert(config[k], v)
                    end
                end
            end
            if row['defaults'] then
                for k, v in pairs(row['defaults']) do
                    config['defaults'][k] = v
                end
            end
            break
        end
    end
    local class_specifics = cfg.class_specifics[tpl_args.class_id]
    if class_specifics then
        for _, k in ipairs(extend_keys) do
            if class_specifics[k] then
                for _, v in ipairs(class_specifics[k]) do
                    table.insert(config[k], v)
                end
            end
        end
        if class_specifics['defaults'] then
            for k, v in pairs(class_specifics['defaults']) do
                config['defaults'][k] = v
            end
        end
    end
    return config
end

function s.process_quest_rewards(tpl_args)
    local rid = 1
    local continue
    tpl_args.quest_rewards = {}
    tpl_args.vendor_rewards = {}
    repeat 
        continue = true
        local prefix = string.format('quest_reward%s_', rid)
        
        local input_args = {
            shared = {
                ['type'] = true, 
                ['quest'] = false, 
                ['quest_id'] = false, 
                ['act'] = true, 
                ['class_ids'] = false,
                },
            vendor = {
                ['npc'] = true,
            },
            quest = {
                ['sockets'] = false, 
                ['item_level'] = false, 
                ['rarity_id'] = false, 
                ['notes'] = false,
            },
        }
        
        local rdata = {}
        
        for key, is_required in pairs(input_args.shared) do
            rdata[key] = tpl_args[prefix .. key]
            if is_required then
                if rdata[key] == nil then
                    continue = false
                    break
                end
            end
        end
        
        if rdata.quest == nil or rdata.quest_id == nil then
            continue = false
        end
        
        if continue and rdata.type == 'vendor' or rdata.type == 'quest' then
            for key, is_required in pairs(input_args[rdata.type]) do
                rdata[key] = tpl_args[prefix .. key]
                if is_required then
                    if rdata[key] == nil then
                        continue = false
                        break
                    end
                end
            end
        else
            continue = false
        end
        
        if continue then
            rdata.classes = {}
            if rdata.class_ids ~= nil then
                rdata.class_ids = m_util.string.split(rdata.class_ids, ',%s*')
                for index, class_id in ipairs(rdata.class_ids) do
                    local class = m_game.constants.characters[class_id] 
                    if class == nil then
                        error(string.format('Class id %s is invalid', class_id))
                    else
                        rdata.class_ids[index] = class.str_id
                        rdata.classes[index] = class.name
                    end
                end
            end
            
            
            if rdata.item_level then
                rdata.item_level = m_util.cast.number(rdata.item_level)
            end
            
            if rdata.rarity_id then
                if m_game.constants.rarities[rdata.rarity_id] == nil then
                    error(string.format(i18n.errors.invalid_rarity_id, tostring(rdata.rarity_id)))
                end
            end
            
            rdata._table = rdata.type .. '_rewards'
            rdata.type = nil
            
            tpl_args[rdata._table] = rdata
            
            m_cargo.store(rdata)
            
            -- TODO: Verify quests and quest ids?
        end
        
        rid = rid + 1
    until continue == false
end

function s.process_base_item(tpl_args)
    if not tpl_args._flags.is_derived then
        if tpl_args.rarity_id ~= 'normal' then
            error(i18n.errors.missing_base_item)
        end
        return
    end
    m_item_util = m_item_util or require('Module:Item util')
    local qargs = {}
    qargs.tables = tpl_args._item_config.tables
    qargs.join = {}
    for _, tbl in ipairs(tpl_args._item_config.tables) do
        if tbl ~= 'items' then
            qargs.join[#qargs.join+1] = string.format('items._pageID=%s._pageID', tbl)
        end
    end
    qargs.join = #qargs.join > 0 and table.concat(qargs.join, ', ') or nil
    qargs.fields = {
        'items._pageName',
        'items.name',
        'items.metadata_id',
        'items.class_id',
        'items.rarity_id',
        'items.inventory_icon',
    }
    for _, k in ipairs(tpl_args._base_item_args) do
        local arg_def = core.map[k]
        if arg_def.field ~= nil then
            qargs.fields[#qargs.fields+1] = string.format('%s.%s', arg_def.table, arg_def.field)
        end
    end
    qargs.where = string.format('items.class_id = "%s"', tpl_args.class_id)
    local result = m_item_util.query_item({
        metadata_id = tpl_args.base_item_id,
        page = tpl_args.base_item_page,
        item_name_exact = tpl_args.base_item,
        debug = tpl_args.debug,
    }, qargs)
    if result.error then
        result.error:throw(true)
    end
    if result['items.rarity_id'] ~= 'normal' then
        error(i18n.errors.base_item_wrong_rarity)
    end

    tpl_args.base_item = result['items.name']
    tpl_args.base_item_page = result['items._pageName']
    tpl_args.base_item_id = result['items.metadata_id']
    h.process_arguments(tpl_args, {'base_item', 'base_item_page', 'base_item_id'})

    tpl_args.base_item_icon = result['items.inventory_icon']

    -- Copy values
    for _, k in ipairs(tpl_args._base_item_args) do
        local arg_def = core.map[k]
        if arg_def.func_fetch ~= nil then
            arg_def.func_fetch(tpl_args)
        elseif arg_def.field ~= nil then
            local value = result[string.format('%s.%s', arg_def.table, arg_def.field)]
            if value == nil then
                if tpl_args.debug then
                    mw.log(string.format(i18n.debug.base_item_field_not_found, arg_def.table, arg_def.field))
                end
            else
                local default = type(arg_def.default) == 'function' and arg_def.default(tpl_args) or arg_def.default
                -- Inherit value from base item if derived item value is not equal to the default value.
                -- This verbose comparison is needed since two empty tables are not considered equal to one another.
                if tpl_args[k] == arg_def.default or (type(tpl_args[k]) == 'table' and #tpl_args[k] == 0 and type(arg_def.default) == 'table' and #arg_def.default == 0) then
                    tpl_args[k] = value
                    if arg_def.func ~= nil then
                        tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
                    end
                    if arg_def.func_copy ~= nil then
                        arg_def.func_copy(tpl_args, tpl_args[k])
                    end
                elseif tpl_args.debug then
                    mw.log(string.format(i18n.debug.field_value_mismatch, k, tostring(tpl_args[k])))
                end
            end
        end
    end

    -- Fetch implicit mods from base item
    local mods = m_cargo.query(
        {'items' ,'item_mods'},
        {'item_mods.id', 'item_mods.is_random', 'item_mods.text'},
        {
            join = 'items._pageID=item_mods._pageID',
            where = string.format(
                'items._pageName="%s" AND item_mods.is_implicit=true',
                tpl_args.base_item_page
            ),
        }
    )
    tpl_args._base_implicit_mods = {}
    for _, row in ipairs(mods) do
        table.insert(tpl_args._base_implicit_mods, {
            id = row['item_mods.id'],
            stat_text = row['item_mods.text'],
            is_implicit = true,
            is_random = m_util.cast.boolean(row['item_mods.is_random']),
        })
    end
end

function s.process_mods(tpl_args)
    tpl_args._defined_implicit_mods = {}
    tpl_args._mods = {}

    local function parse_mod_arg(tpl_args, type, index)
        local prefix = type .. index
        local mod_data = {
            is_implicit = type == 'implicit',
            is_explicit = type == 'explicit',
            is_map_fragment_bonus = type == 'map_fragment_bonus',
            is_random = false,
        }
        local mods_table = mod_data.is_implicit and tpl_args._defined_implicit_mods or tpl_args._mods

        -- By mod id
        local value = tpl_args[prefix]
        if value ~= nil then
            mod_data.id = value
            mod_data.stat_text = tpl_args[prefix .. '_text']
            table.insert(mods_table, mod_data)
            return true
        end

        -- By list of possible mod ids
        value = tpl_args[prefix .. '_random_list']
        if value ~= nil then
            value = m_util.cast.table(value)
            for _, id in ipairs(value) do
                local mod_data_copy = {}
                for k, v in pairs(mod_data) do
                    mod_data_copy[k] = v
                end
                mod_data_copy.id = id
                mod_data_copy.is_random = true
                mod_data_copy.stat_text = tpl_args[prefix .. '_text'] or string.format(i18n.tooltips.random_mod, index)
                table.insert(mods_table, mod_data_copy)
            end
            tpl_args._flags.random_mods = true
            return true
        end

        -- By stat text
        value = tpl_args[prefix .. '_text']
        if value ~= nil then
            mod_data.result = false -- Not stored in Cargo table
            mod_data.stat_text = value
            table.insert(mods_table, mod_data)
            tpl_args._flags.text_modifier = true
            return true
        end

        return false
    end -- parse_mod_arg

    local types = {
        'implicit',
        'explicit',
        'map_fragment_bonus',
    }
    for _, t in ipairs(types) do
        local i = 1
        while parse_mod_arg(tpl_args, t, i) do
            i = i + 1
        end
    end

    -- If the item does not have its own implicit mods, fall back to the implicit mods on the base item.
    local implicit_mods = tpl_args._defined_implicit_mods or {}
    if #implicit_mods == 0 then
        implicit_mods = tpl_args._base_implicit_mods or {}
    end
    for _, v in ipairs(implicit_mods) do
        table.insert(tpl_args._mods, v)
    end
    if #tpl_args._mods > 0 then
        local mods = {}
        local mod_ids = {}
        local non_random_mod_ids = {}
        for _, mod_data in ipairs(tpl_args._mods) do
            if mod_data.result == nil then
                mods[mod_data.id] = mod_data
                table.insert(mod_ids, mod_data.id)
                if not mod_data.is_random then
                    table.insert(non_random_mod_ids, mod_data.id)
                end
            end
            table.insert(tpl_args._store_data, {
                _table = 'item_mods',
                id = mod_data.id,
                text = mod_data.stat_text,
                is_implicit = mod_data.is_implicit,
                is_explicit = mod_data.is_explicit,
                is_map_fragment_bonus = mod_data.is_map_fragment_bonus,
                is_random = mod_data.is_random,
            })
        end
        local results = m_cargo.query(
            {'mods'},
            {'mods._pageName', 'mods.id', 'mods.required_level', 'mods.stat_text'},
            {
                where = string.format(
                    'mods.id IN ("%s")',
                    table.concat(mod_ids, '","')
                )
            }
        )
        for _, row in ipairs(results) do
            local mod_data = mods[row['mods.id']]
            mod_data.result = row
            if mod_data.is_random == false then
                -- Modifiers contribute to level requirement
                -- Update base level requirement only if this is an implicit
                local args = {
                    'required_level_final',
                    mod_data.is_implicit and 'required_level' or nil,
                }
                for _, v in ipairs(args) do
                    local req = math.floor(tonumber(row['mods.required_level']) * cfg.item_required_level_modifier_contribution)
                    if req > tpl_args[v] then
                        tpl_args[v] = req
                    end
                end
            end
        end
        
        -- fetch stats
        results = m_cargo.query(
            {'mods', 'mod_stats'},
            {'mods.id', 'mod_stats.id', 'mod_stats.min', 'mod_stats.max'},
            {
                join = 'mods._pageID=mod_stats._pageID',
                where = string.format(
                    'mods.id IN ("%s") AND mod_stats.id IS NOT NULL',
                    table.concat(mod_ids, '","')
                ),
            }
        )
        for _, row in ipairs(results) do
            -- Stat data
            local mod_data = mods[row['mods.id']]
            mod_data.result.stats = mod_data.result.stats or {}
            table.insert(mod_data.result.stats, row)
            local stat_id = row['mod_stats.id']
            local value = {
                min = tonumber(row['mod_stats.min']),
                max = tonumber(row['mod_stats.max']),
            }
            local tbl = mod_data.is_random and '_random_stats' or '_stats'
            core.add_stat(tpl_args, stat_id, value, {tbl=tbl, mod=mod_data})
        end
        
        if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
            -- fetch sell prices
            results = m_cargo.query(
                {'mods', 'mod_sell_prices'},
                {'mods.id', 'mod_sell_prices.amount', 'mod_sell_prices.name'},
                {
                    join='mods._pageID=mod_sell_prices._pageID',
                    -- must be non random mods to avoid accumulating sell prices of randomized modifiers
                    where=string.format('mod_sell_prices.amount IS NOT NULL AND mods.id IN ("%s")', table.concat(non_random_mod_ids, '", "')),
                }
            )
            
            for _, data in ipairs(results) do
                local mod_data = mods[data['mods.id']]
                if not mod_data.is_implicit then
                    local values = {
                        name = data['mod_sell_prices.name'],
                        amount = tonumber(data['mod_sell_prices.amount']), 
                    }
                    -- sell_prices is defined in core.map.sell_prices_override
                    tpl_args.sell_prices[values.name] = (tpl_args.sell_prices[values.name] or 0) + values.amount
                end
            end
         end
    end
    if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
        local missing_sell_price = true
        for _, _ in pairs(tpl_args.sell_prices) do
            missing_sell_price = false
            break
        end
        
        if missing_sell_price then
            tpl_args.sell_prices[i18n.tooltips.default_vendor_offer] = 1
        end
        
        -- Set sell price on page
        for name, amount in pairs(tpl_args.sell_prices) do
            -- sell_price_order is defined in core.map.sell_prices_override
            tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
            tpl_args._store_data[#tpl_args._store_data+1] = {
                _table = 'item_sell_prices',
                amount = amount,
                name = name,
            }
        end
        table.sort(tpl_args.sell_price_order)
    end
end

function s.process_stats(tpl_args)
    tpl_args._stats = tpl_args._stats or {}

    -- Extra stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
    m_util.args.stats(tpl_args, {prefix='extra_'}) -- Populates tpl_args.extra_stats
    for _, stat in ipairs(tpl_args.extra_stats) do
        core.add_stat(tpl_args, stat.id, stat.value or stat)
    end
    
    -- Handle local item stat math - additions, increases, etc.
    for key, stat_def in pairs(core.stat_map) do
        local arg = stat_def.arg or key
        local value = {}
        if type(arg) == 'table' then
            value.min = tpl_args[arg.min]
            value.max = tpl_args[arg.max]
            value.base_min = tpl_args[arg.min]
            value.base_max = tpl_args[arg.max]
        else
            value.min = tpl_args[arg]
            value.max = tpl_args[arg]
            value.base = tpl_args[arg]
        end
        if value.min ~= nil and value.max ~= nil then
            -- Determine whether stat is overridden; if so, other calculations can be ignored
            local overridden = false
            if stat_def.stats_override then
                for id, v in pairs(stat_def.stats_override) do
                    if tpl_args._stats[id] then
                        -- If for some reason there is more than one of the same override stat, apply the final one.
                        local stat_value = tpl_args._stats[id][#tpl_args._stats[id]]
                        if stat_value then
                            if type(v) == 'table' then
                                value.min = v.min
                                value.max = v.max
                                overridden = true
                            elseif v then -- Use the stat value
                                value.min = stat_value.min
                                value.max = stat_value.max
                                overridden = true
                            end
                        end
                    end
                end
            end
            if not overridden then
                local operations = {'add', 'add_distance', 'increased', 'increased_inverse'}
                for _, o in ipairs(operations) do
                    local stat_ids = stat_def['stats_' .. o]
                    if stat_ids then
                        local total = {min=0, max=0}
                        for _, id in ipairs(stat_ids) do
                            if tpl_args._stats[id] then
                                for _, s in ipairs(tpl_args._stats[id]) do
                                    total.min = total.min + s.min
                                    total.max = total.max + s.max
                                end
                            end
                        end
                        h.stat[o](value, total)
                    end
                end
                if stat_def.minimum ~= nil then
                    for _, k in ipairs({'min', 'max'}) do
                        if value[k] < stat_def.minimum then
                            value[k] = stat_def.minimum 
                        end
                    end
                end
            end
            value.avg = (value.min + value.max) / 2

            for short_key, range_def in pairs(c.range_map) do
                tpl_args[stat_def.field .. range_def] = value[short_key]
            end
            
            -- process to HTML to use on list pages or other purposes
            h.handle_range_args(tpl_args, key, stat_def.field, value, stat_def.html_fmt_options)
        end
    end

    -- Transpose stats into cargo data
    for _, tbl in ipairs({'_stats', '_random_stats'}) do
        if tpl_args[tbl] then
            for stat_id, stats in pairs(tpl_args[tbl]) do
                for _, stat_data in ipairs(stats) do
                    table.insert(tpl_args._store_data, {
                        _table = 'item_stats',
                        id = stat_id,
                        min = stat_data.min,
                        max = stat_data.max,
                        avg = stat_data.avg,
                        mod_id = stat_data.mod and stat_data.mod.id or nil
                    })
                end
            end
        end
    end
end

function s.process_weapon_dps(tpl_args)
    for key, dps_def in pairs(core.dps_map) do
        local damage = {
            min = {},
            max = {},
        }
        for var_type, value in pairs(damage) do
            -- covers the min/max/avg range
            for short_key, range_def in pairs(c.range_map) do
                value[short_key] = 0
                for _, damage_key in ipairs(dps_def.damage_args) do
                    value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_def)] or 0)
                end
            end
        end
        local value = {}
        for short_key, range_def in pairs(c.range_map) do
            local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_def)]
            value[short_key] = result
            tpl_args[string.format('%s%s', dps_def.field, range_def)] = result
        end
        if value.avg > 0 then
            h.handle_range_args(tpl_args, key, dps_def.field, value, dps_def.html_fmt_options)
        end
    end
end

function s.process_gem_variants(tpl_args)
    if not tpl_args._flags.is_derived and tpl_args.metadata_id == nil then
        -- If this is a base item, then it needs a metadata ID in order to find its variants.
        return
    end
    local variants = {}
    local title = mw.title.getCurrentTitle()
    local current = {
        page = title.prefixedText,
        name = tpl_args.name,
        id = tpl_args.metadata_id,
        icon = tpl_args.inventory_icon,
        current = true,
    }
    local results
    local tables = {'items', 'skill_gems', 'skill'}
    local fields = {
        'items._pageName=page',
        'items.name=name',
        'items.metadata_id=id',
        'items.inventory_icon=icon'
    }
    local qargs = {
        join = 'items._pageID=skill_gems._pageID, items._pageID=skill._pageID',
        orderBy = 'skill.skill_id ASC',
    }

    if tpl_args.class_id == 'Active Skill Gem' then
        if tpl_args.is_vaal_skill_gem then
            variants.vaal = current
            
            -- Query base skill gem
            qargs.where = string.format(
                [[items.metadata_id IS NOT NULL
                  AND items.class_id = "Active Skill Gem"
                  AND skill_gems.vaal_variant_id = "%s"
                  AND skill_gems.is_vaal_skill_gem = false]],
                tpl_args.metadata_id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.base = results[1]
            end
        else
            -- Determine base skill gem
            if tpl_args._flags.is_derived then
                variants.base = {
                    page = tpl_args.base_item_page,
                    name = tpl_args.base_item,
                    id = tpl_args.base_item_id,
                    icon = tpl_args.base_item_icon,
                }
            else
                variants.base = current
            end

            if tpl_args.vaal_variant_id ~= nil then
                -- Query Vaal skill gem variant
                qargs.where = string.format(
                    [[items.metadata_id = "%s"
                      AND items.class_id = "Active Skill Gem"
                      AND skill_gems.is_vaal_skill_gem = true]],
                    tpl_args.vaal_variant_id
                )
                if title.namespace == 0 then
                    qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                end
                results = m_cargo.query(tables, fields, qargs)
                if #results > 0 then
                    variants.vaal = results[1]
                end
            end
        end
        if variants.base then
            -- Query transfigured skill gem variants
            qargs.where = string.format(
                [[items.metadata_id IS NULL
                  AND items.base_item_id = "%s"
                  AND items.class_id = "Active Skill Gem"]],
                variants.base.id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.transfigured = {}
                for _, row in ipairs(results) do
                    row.current = row.page == title.prefixedText
                    table.insert(variants.transfigured, row)
                end
            end
        end
    elseif tpl_args.class_id == 'Support Skill Gem' then
        if tpl_args.is_awakened_support_gem then
            variants.awakened = current
            
            -- Query base support gem
            qargs.where = string.format(
                [[items.metadata_id IS NOT NULL
                  AND items.class_id = "Support Skill Gem"
                  AND skill_gems.awakened_variant_id = "%s"
                  AND skill_gems.is_awakened_support_gem = false]],
                tpl_args.metadata_id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.base = results[1]
            end
        else
            variants.base = current

            if tpl_args.awakened_variant_id ~= nil then
                -- Query awakened support gem variant
                qargs.where = string.format(
                    [[items.metadata_id = "%s"
                      AND items.class_id = "Support Skill Gem"
                      AND skill_gems.is_awakened_support_gem = true]],
                    tpl_args.awakened_variant_id
                )
                if title.namespace == 0 then
                    qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                end
                results = m_cargo.query(tables, fields, qargs)
                if #results > 0 then
                    variants.awakened = results[1]
                end
            end
        end
    end
    tpl_args._variants = {}
    table.insert(tpl_args._variants, variants.base)
    if variants.transfigured then
        for _, v in ipairs(variants.transfigured) do
            table.insert(tpl_args._variants, v)
        end
    end
    table.insert(tpl_args._variants, variants.vaal)
    table.insert(tpl_args._variants, variants.awakened)
end

function s.get_categories(tpl_args)
    local cats = {}
    if tpl_args._flags.is_prophecy then
        table.insert(cats, i18n.categories.prophecies)
    elseif tpl_args._flags.is_blight_item then
        table.insert(cats, i18n.categories.oils)
    elseif tpl_args._flags.is_talisman then
        table.insert(cats, i18n.categories.talismans)
    elseif tpl_args._flags.is_essence then
        table.insert(cats, i18n.categories.essences)
    elseif tpl_args._flags.is_fossil then
        table.insert(cats, i18n.categories.fossils)
    elseif tpl_args._flags.is_scarab then
        table.insert(cats, i18n.categories.scarabs)
    elseif tpl_args._flags.is_tattoo then
        table.insert(cats, i18n.categories.tattoos)
    elseif tpl_args._flags.is_delirium_orb then
        table.insert(cats, i18n.categories.delirium_orbs)
    elseif tpl_args._flags.is_catalyst then
        table.insert(cats, i18n.categories.catalysts)
    elseif tpl_args.class_id == 'Map' and tpl_args.rarity_id == 'normal' then
        table.insert(cats, string.format(i18n.categories.maps_by_series, tpl_args.map_series))
    elseif tpl_args.class_id == 'Microtransaction' and tpl_args.cosmetic_type and m_game.constants.item.cosmetic_item_types[tpl_args.cosmetic_type].cats then
        for _, v in ipairs(m_game.constants.item.cosmetic_item_types[tpl_args.cosmetic_type].cats) do
            table.insert(cats, v)
        end
    elseif m_game.constants.item.classes[tpl_args.class_id].cats then
        for _, v in ipairs(m_game.constants.item.classes[tpl_args.class_id].cats) do
            if tpl_args.rarity_id == 'unique' then
                table.insert(cats, string.format(i18n.categories.unique_affix, v))
            else
                table.insert(cats, v)
            end
        end
    else
        table.insert(cats, tpl_args.class)
    end
    
    if tpl_args._flags.is_derived then
        table.insert(cats, i18n.categories.derived_items)
    else
        table.insert(cats, i18n.categories.base_items)
    end

    for _, tag in ipairs(tpl_args.acquisition_tags) do
        if cfg.acquisition_tags[tag] and cfg.acquisition_tags[tag].cat then
            table.insert(cats, cfg.acquisition_tags[tag].cat)
        end
    end
    
    for _, attr in ipairs(m_game.constants.attribute_order) do
        if tpl_args[attr .. '_percent'] then
            table.insert(cats, string.format('%s %s', m_game.constants.attributes[attr].long_upper, tpl_args.class))
        end
    end
    
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        for _, tag in ipairs(tpl_args.gem_tags) do
            table.insert(cats, string.format(i18n.categories.gem_tag_affix, tag))
        end
    end

    if tpl_args._flags.is_derived and #tpl_args._defined_implicit_mods > 0 then
        table.insert(cats, i18n.categories.implicit_modifier_override)
    end
    
    if #tpl_args.alternate_art_inventory_icons > 0 then
        table.insert(cats, i18n.categories.alternate_artwork)
    end

    if tpl_args._flags.has_legacy_drop_areas == true then
        mw.log('IDs of legacy map areas used in drop_areas:')
        mw.logObject(tpl_args._legacy_drop_areas)
        table.insert(cats, i18n.categories.legacy_drop_areas)
    end
    
    if tpl_args.release_version == nil then
        table.insert(cats, i18n.categories.missing_release_version)
    end
    
    if tpl_args._flags.text_modifier and not tpl_args.suppress_improper_modifiers_category then
        table.insert(cats, i18n.categories.improper_modifiers)
    end
    
    for _, k in ipairs({'invalid_recipe_parts', 'duplicate_recipes', 'duplicate_query_area_ids', 'sell_prices_override'}) do
        if tpl_args._flags[k] then
            table.insert(cats, i18n.categories[k])
        end
    end

    if tpl_args.disable_automatic_recipes == true then
        table.insert(cats, i18n.categories.automatic_recipes_disabled)
    end

    if tpl_args._flags.uses_deprecated_parameters == true then
        mw.log('Deprecated parameters used:')
        mw.logObject(tpl_args._deprecated_args)
        table.insert(cats, i18n.categories.deprecated_parameters)
    end

    if tpl_args._flags.has_deprecated_skill_parameters then
        table.insert(cats, i18n.categories.deprecated_skill_parameters)
    end
    return cats
end

-- ----------------------------------------------------------------------------
-- Main functions
-- ----------------------------------------------------------------------------

local function _main(tpl_args)
    local t = os.clock() -- Start time (for logging)
    tpl_args._flags = {}
    tpl_args._store_data = {}
    tpl_args._errors = {}
    
    -- Item configuration
    tpl_args._item_config = s.get_item_config(tpl_args)

    -- Add table names to core.map and append range fields.
    h.append_schema(tpl_args, tpl_args._item_config.tables)
    
    -- Using general purpose function to handle release and removal versions
    m_util.args.version(tpl_args)

    -- Assume this is meant to be a derived item if any base item parameters are set
    tpl_args._flags.is_derived = m_util.table.has_any_key(tpl_args, {'base_item_id', 'base_item_page', 'base_item'})
    
    -- Must validate some argument early. It is required for future things
    h.process_arguments(tpl_args, tpl_args._item_config.args)

    -- Base item
    s.process_base_item(tpl_args)

    -- Process arguments that require a particular flag to be set
    -- Used for subsets of item classes that have additional fields
    for k, v in pairs(cfg.flagged_args) do
        if tpl_args._flags[k] then
            h.process_arguments(tpl_args, v.args)
        end
    end
    
    -- Mods
    s.process_mods(tpl_args)

    -- Stats
    s.process_stats(tpl_args)

    -- Calculate and handle weapon dps
    if cfg.class_groups.weapons.keys[tpl_args.class_id] then
        s.process_weapon_dps(tpl_args)
    end

    -- Skill gems
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        h.process_skill_data(tpl_args)
    end
    
    -- Late argument processing
    h.process_arguments(tpl_args, tpl_args._item_config.late_args)
    
    -- Recipes
    h.process_recipes(tpl_args)
    
    -- Quest reward info
    s.process_quest_rewards(tpl_args)

    -- Gem variants
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        s.process_gem_variants(tpl_args)
    end
    
    -- ------------------------------------------------------------------------
    -- Infobox handling 
    -- ------------------------------------------------------------------------

    --
    -- Tabs
    --

    local tabs
    if type(tpl_args._variants) == 'table' and #tpl_args._variants > 1 then    
        tabs = mw.html.create('div')
            :addClass('itembox-tabs')
        for _, v in ipairs(tpl_args._variants) do
            local tab = tabs:tag('span')
            tab:addClass('itembox-tab')
            if v.current then
                tab:addClass('-selected')
            end
            if v.icon then
                tab:wikitext(string.format('[[%s|34x34px|link=%s|alt=%s]]', v.icon, v.page, v.name))
            else
                tab:wikitext(m_util.html.wikilink(v.page, v.name))
            end
        end
    end

    --
    -- Primary infobox
    --

    tpl_args._infobox_container = 'infobox'
    local infobox = h.make_main_infobox(tpl_args)
    if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then
        infobox:tag('span')
            :addClass('images')
            :wikitext(string.format(
                '[[%s|%sx%spx]]',
                tpl_args.inventory_icon,
                cfg.image_size_full * tpl_args.size_x,
                cfg.image_size_full * tpl_args.size_y
            ))
    end
    tpl_args.infobox_html = tostring(infobox)
    
    --
    -- Secondary infobox
    --
    
    local extra_infobox = mw.html.create('div')
        :addClass('item-box -' .. tpl_args.frame_type)
    h.add_to_infobox_from_map(tpl_args, extra_infobox, c.extra_display_groups)
    tpl_args.metabox_html = tostring(extra_infobox)
    
    -- 
    -- Output
    --
    
    local container = mw.html.create('div')
        :addClass('infobox-page-container')
    if tabs then
        container:node(tabs)
    end
    container
        :node(infobox)
        :node(extra_infobox)
        
    -- skill_screenshot is set in skill module
    if tpl_args.skill_screenshot then
        container:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
    end
    
    local out = tostring(container)
    
    local cats = s.get_categories(tpl_args)
    
    out = out .. m_util.misc.add_category(cats, {ignore_blacklist=tpl_args.debug})
    
    --
    --  Misc
    --
     
    -- Also show the infobox for areas right away for maps, since they're both on the same page
    local query_id
    if tpl_args.rarity_id == 'normal' and tpl_args.map_area_id ~= nil then
        query_id = tpl_args.map_area_id
    elseif tpl_args.rarity_id == 'unique' and tpl_args.unique_map_area_id ~= nil then
        query_id = tpl_args.unique_map_area_id
    end

    if query_id then
        out = out .. h.query_area_info{cats=true, where=string.format('areas.id="%s"', query_id)}
    end
    
    -- ------------------------------------------------------------------------
    -- Store cargo data
    -- ------------------------------------------------------------------------

    -- Store the infobox so it can be accessed with ease on other pages
    tpl_args._infobox_container = 'inline'
    tpl_args.html = tostring(h.make_main_infobox(tpl_args))

    -- Map argument values for cargo storage
    for _, table_name in ipairs(tpl_args._item_config.tables) do
        tpl_args._store_data[table_name] = {
            _table = table_name,
        }
    end
    for k, v in pairs(tpl_args) do
        local arg_def = core.map[k]
        if arg_def ~= nil then
            if arg_def.table ~= nil and arg_def.field ~= nil then
                if arg_def.type == 'Integer' then
                    v = tonumber(string.format("%.0f", v))
                    if v ~= tpl_args[k] then
                        mw.log(string.format('Float value "%s" for integer field "%s.%s"', tpl_args[k], arg_def.table, arg_def.field))
                    end
                end
                if tpl_args._store_data[arg_def.table] == nil then
                    error(string.format('Missing data for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
                end
                if type(tpl_args._store_data[arg_def.table]) ~= 'table' then
                    error(string.format('Unexpected format of data for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
                end
                tpl_args._store_data[arg_def.table][arg_def.field] = v
            elseif arg_def.table ~= nil and arg_def.field == nil then
                error(string.format('Missing field for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
            elseif arg_def.table == nil and arg_def.field ~= nil then
                mw.log(string.format('Possibly redundant argument "%s", value:\n "%s"', k, mw.dumpObject(v)))
            end
        end
    end
    
    -- Don't store cargo data in testing mode
    if not tpl_args.test then
        local attach = {}
        for _, data in pairs(tpl_args._store_data) do
            if attach[data._table] == nil then
                local i = 0 
                for _, _ in pairs(data) do
                    i = i + 1
                    -- Don't attach to tables we don't store data to. _table is always present so we need to check for 2 or more entries.
                    if i > 1 then
                        attach[data._table] = true
                        -- One of the purposes of attaching is to facilitate table recreation.
                        -- Unfortunately, the Cargo extension's table recreation tool is 
                        -- very slow and often fails to rebuild the entire table.
                        mw.getCurrentFrame():expandTemplate{
                            title = string.format(i18n.templates.cargo_attach, data._table),
                            args = {}
                        }
                        break
                    end
                end
            end
            m_cargo.store(data, {
                debug = tpl_args.debug,
                sep = {
                    name_list = '�',
                },
            })
        end
    end
    
    -- Show additional error messages in console to help fixing them
    if #tpl_args._errors > 0 then
        mw.log(table.concat(tpl_args._errors, '\n'))
    end
    
    if tpl_args.debug then
        mw.log(os.clock() - t)
        mw.log('Start logging tpl_args.')
        mw.logObject(tpl_args)
        mw.log('Stop logging tpl_args.')
        mw.log('Start logging core.map.')
        mw.logObject(core.map)
        mw.log('Stop logging core.map.')
    end
    if tpl_args.test then
        tpl_args.out = out
        return tpl_args
    end
    return out
end

-- ----------------------------------------------------------------------------
-- Exported functions
-- ----------------------------------------------------------------------------

local p = {}

--
-- Template:Item
--
p.main = m_util.misc.invoker_factory(_main, {
    parentFirst = true,
})

p.item = p.main

return p
Retrieved from "https://www.poewiki.net/index.php?title=Module:Item2&oldid=1435558"