Module:Item2/sandbox
Jump to navigation
Jump to search
This is the module sandbox page for Module:Item2 (diff).
See also the companion subpage for test cases (run).
This module is used on 12,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.
This module depends on the following other modules:
The item module provides functionality for various item-related templates.
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,
Item templates
Module:Item2
All templates defined in Module:Item2:
Module:Item table
All templates defined in Module:Item table:
- {{Item table}}
- {{Query base items}}
- {{Query unique items}}
- {{Item unique versions}}
- {{Area item drops}}
- {{Skill gem table}}
- {{Map item drops}}
- {{Prophecy description}}
- {{Simple item list}}
Module:Item link
All templates defined in Module:Item link:
- {{Item link}}
- {{Il}}
- {{Item icon link}}
Module:Item acquisition
- {{Item acquisition}}
The above documentation is transcluded from Module:Item2/doc.
Editors can experiment in this module's sandbox and testcases pages.
Please add categories to the /doc subpage. Subpages of this module.
Editors can experiment in this module's sandbox and testcases pages.
Please add categories to the /doc subpage. Subpages of this module.
-- SMW reworked item module
-- ----------------------------------------------------------------------------
-- TODO
-- ----------------------------------------------------------------------------
-- Items
-- -----
--
-- DROP restriction improvements:
-- drop location (area)
-- drop difficulty
-- drop monster type(s)
--
-- divination card support
--
-- unique items:
-- 3D art
-- supporter attribution
--
-- singular for weapon class in infoboxes
--
-- Maps:
-- Area level can be retrieved eventually
--
-- Essence:
-- type column
-- monster modifier info
-- ----------
-- Item table
-- ----------
-- Skills need proper range values in their tables
--
-- ----------
-- Item class
-- ----------
--
-- remove the ul if name_list is not provided
-- maybe smw
-- ----------------------------------------------------------------------------
-- Imports
-- ----------------------------------------------------------------------------
local xtable = require('Module:Table')
local util = require('Module:Util')
local getArgs = require('Module:Arguments').getArgs
local m_game = require('Module:Game')
local m_skill = require('Module:Skill')
local p = {}
local c = {}
c.image_size = 39
-- 9 doesn't hit the query limit
c.max_mod_params = 11
c.max_stat_params = 8
-- ----------------------------------------------------------------------------
-- Strings
-- ----------------------------------------------------------------------------
-- This section contains strings used by this module.
-- Add new strings here instead of in-code directly, this will help other
-- people to correct spelling mistakes easier and help with translation to
-- other PoE wikis.
--
-- TODO: Maybe move this out to a separate sub-page module
local i18n = {
range = '(%s to %s)',
inventory_icon = 'File:%s inventory icon.png',
status_icon = 'File:%s status icon.png',
skill_screenshot = 'File:%s skill screenshot.jpg',
skill_icon = 'File:%s skill icon.png',
divination_card_art = 'File:%s card art.png',
gem_tag_category = '[[:Category:%s (gem tag)|%s]]',
categories = {
-- maintenance cats
broken_item_links = '[[Category:Pages with broken item links]]',
improper_modifiers = 'Items with improper modifiers',
missing_release_version = 'Items without a release version',
-- regular cats
alternate_artwork = 'Items with alternate artwork',
-- misc
gem_tag_affix = '%s (gem tag)',
unique_affix = 'Unique %s',
},
stat_skip_patterns = {
maps = {
'%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',
},
jewels = {
'Limited to %d+ %(Hidden%)',
'Jewel has a radius of %d+ %(Hidden%)',
},
},
help_text_defaults = {
active_gem = 'Place into an item socket of the right colour to gain this skill. Right click to remove from a socket.',
support_gem = '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.',
hideout_doodad = 'Right click on this item then left click on a location on the ground to create the object.',
jewel = 'Place into an allocated Jewel Socket on the Passive Skill Tree. Right click to remove from the Socket.',
},
-- Used by the item table
item_table = {
item = 'Item',
skill_gem = 'Skill gem',
physical_dps = util.html.abbr('pDPS', 'physical damage per second'),
fire_dps = util.html.abbr('Fire DPS', 'fire damage per second'),
cold_dps = util.html.abbr('Cold DPS', 'cold damage per second'),
lightning_dps = util.html.abbr('Light. DPS', 'lightning damage per second'),
chaos_dps = util.html.abbr('Chaos DPS', 'chaos damage per second'),
elemental_dps = util.html.abbr('eDPS', 'elemental damage (i.e. fire/cold/lightning) per second'),
poison_dps = util.html.abbr('Poison DPS', 'poison damage (i.e. physical/chaos) per second'),
dps = util.html.abbr('DPS', 'total damage (i.e. physical/fire/cold/lightning/chaos) per second'),
base_item = 'Base Item',
item_class = 'Item Class',
essence_tier = 'Essence<br>Tier',
drop_level = 'Drop<br>Level',
stack_size = 'Stack<br>Size',
stack_size_currency_tab = util.html.abbr('Tab<br>Stack<br>Size', 'Stack size in the currency stash tab'),
armour = util.html.abbr('AR', 'Armour'),
evasion = util.html.abbr('EV', 'Evasion Rating'),
energy_shield = util.html.abbr('ES', 'Energy Shield'),
block = util.html.abbr('Block', 'Chance to Block'),
damage = util.html.abbr('Damage', 'Colour coded damage'),
attacks_per_second = util.html.abbr('APS', 'Attacks per second'),
local_critical_strike_chance = util.html.abbr('Crit', 'Local weapon critical strike chance'),
flask_life = util.html.abbr('Life', 'Life regenerated over the flask duration'),
flask_mana = util.html.abbr('Mana', 'Mana regenerated over the flask duration'),
flask_duration = 'Duration',
flask_charges_per_use = util.html.abbr('Usage', 'Number of charges consumed on use'),
flask_maximum_charges = util.html.abbr('Capacity', 'Maximum number of flask charges held'),
item_limit = 'Limit',
jewel_radius = 'Radius',
map_tier = 'Map<br>Tier',
map_level = 'Map<br>Level',
map_guild_character = util.html.abbr('Char', 'Character for the guild tag'),
buff_effects = 'Buff Effects',
stats = 'Stats',
effects = 'Effect(s)',
flavour_text = 'Flavour Text',
help_text = 'Help Text',
buff_icon = 'Buff<br>Icon',
-- Skills
support_gem_letter = util.html.abbr('L', 'Support gem letter.'),
skill_icon = 'Icon',
description = 'Description',
skill_critical_strike_chance = util.html.abbr('Crit', 'Critical Strike Chance'),
cast_time = util.html.abbr('Cast<br>Time', 'Casting time of the skill in seconds'),
damage_effectiveness = util.html.abbr('Dmg.<br>Eff.', 'Damage Effectiveness'),
mana_cost_multiplier = util.html.abbr('MCM', 'Mana cost multiplier - missing values indicate it changes on gem level'),
mana_cost = util.html.abbr('Mana', 'Mana cost'),
reserves_mana_suffix = util.html.abbr('R', 'reserves mana'),
vaal_souls_requirement = util.html.abbr('Souls', 'Vaal souls requirement in Normal/Cruel/Merciless difficulty'),
stored_uses = util.html.abbr('Uses', 'Maximum number of stored uses'),
primary_radius = util.html.abbr('R1', 'Primary radius'),
secondary_radius = util.html.abbr('R2', 'Secondary radius'),
tertiary_radius = util.html.abbr('R3', 'Tertiary radius'),
},
-- Used by the item info box
tooltips = {
corrupted = 'Corrupted',
support_icon = 'Icon: %s',
radius = 'Radius: %s',
mana_reserved = 'Mana Reserved: %s',
mana_cost = 'Mana Cost: %s',
mana_multiplier = 'Mana Multiplier: %s',
vaal_souls_per_use = 'Souls per use: %s',
stored_uses = 'Can store %s use(s)',
cooldown_time = 'Cooldown Time: %s',
cast_time = 'Cast Time: %s',
critical_strike_chance = 'Critical Strike Chance: %s',
damage_effectiveness = 'Damage Effectiveness: %s',
projectile_speed = 'Projectile Speed: %s',
quality = 'Quality: %s',
physical_damage = 'Physical Damage: %s',
elemental_damage = 'Elemental Damage:%s',
chaos_damage = 'Chaos Damage: %s',
attacks_per_second = 'Attacks per Second: %s',
weapon_range = 'Weapon Range: %s',
map_level = 'Map Level: %s',
map_tier = 'Map Tier: %s',
map_guild_character = util.html.abbr('Guild Character', 'When used in guild creation, this map can be used for the listed character') .. ': %s',
item_quantity = 'Item Quantity: %s',
item_rarity = 'Item Rarity: %s',
monster_pack_size = 'Monster Pack Size: %s',
limited_to = 'Limited to: %s',
flask_mana_recovery = 'Recovers %s Mana over %s seconds',
flask_life_recovery = 'Recovers %s Life over %s seconds',
flask_duration = 'Lasts %s Seconds',
flask_charges_per_use = 'Consumes %s of %s Charges on use',
chance_to_block = 'Chance to Block: %s',
armour = 'Armour: %s',
evasion = 'Evasion: %s',
energy_shield = 'Energy Shield: %s',
talisman_tier = 'Talisman Tier: %s',
stack_size = 'Stack Size: %s',
essence_tier = 'Essence Tier: %s',
requires = 'Requires %s',
level_inline = 'Level %s',
level = 'Level: %s',
gem_quality = 'Per 1% Quality:',
variation_singular = 'Variation',
variation_plural = 'Variations',
favour_cost = 'Favour cost: %s',
seal_cost = 'Seal cost: <br>%s',
-- secondary infobox
drop_restrictions = 'Acquisition',
league_restriction = util.html.abbr('League(s):', 'Item can be obtained in relation to these league(s)') .. ' %s',
drop_disabled = 'DROP DISABLED',
damage_per_second = 'Weapon DPS',
physical_dps = 'Physical',
fire_dps = 'Fire',
cold_dps = 'Cold',
lightning_dps = 'Lightning',
chaos_dps = 'Chaos',
elemental_dps = 'Elemental',
poison_dps = 'Phys+Chaos',
dps = 'Total',
},
item_class_infobox = {
page = '[[Item class]]',
info = 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'),
also_referred_to_as = 'Also referred to as:',
},
debug = {
base_item_property_not_found = 'Base item property not found: %s',
property_value_mismatch = 'Value for argument "%s" is set to something else then default: %s',
},
errors = {
missing_base_item = 'Rarity is set to above normal, but base item is not set. A base item for rarities above normal is required!',
missing_rarity = 'Base item parameter is set, but rarity is set to normal. A rarity above normal is required!',
duplicate_base_items = 'More then one result found for the specified base item. Consider using base_item_page or base_item_id to narrow down the results.',
smw_mod_count_duplicate_format = '%s (pages: %s)',
smw_mod_count_mismatch = 'Number of mods found does not match number of queried mods. Not found: "%s", duplicates: "%s"',
invalid_league = '%s is not a recognized league',
invalid_tag = '%s is not a valid tag',
item_link_invalid_args = 'page, item_name or item_name_exact must be specified',
item_link_no_results = 'No results found for search parameter "%s".',
item_link_too_many_results = 'Too many results for search parameter "%s". Consider using page parameter instead.',
item_link_alt_art_undefined = 'Image parameter was specified, but there is no alternate art defined on page "%s"',
item_link_alt_art_invalid_index = 'Alternate art with index/name "%s" not found on page "%s"',
generic_argument_parameter = 'Unrecognized %s parameter "%s"',
invalid_item_class = 'Invalid item class',
invalid_item_table_mode = 'Invalid mode for item table',
non_unique_relic = 'Only unique items can be be relics',
},
}
-- ----------------------------------------------------------------------------
-- Other stuff
-- ----------------------------------------------------------------------------
local h = {}
function h.debug(tpl_args, func)
if tpl_args.debug == nil then
return
end
func()
end
function h.na_or_val(tr, value, func)
if value == nil then
tr:wikitext(util.html.td.na())
else
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
-- helper to loop over the range variables easier
h.range_map = {
min = {
property = ' range minimum',
var = '_range_minimum',
},
max = {
property = ' range maximum',
var = '_range_maximum',
},
avg = {
property = ' range average',
var = '_range_average',
},
}
function h.handle_range_args(tpl_args, frame, argument_key, property, value, fmt_options)
fmt_options = mw.clone(fmt_options)
fmt_options.return_color = true
local html, colour = h.format_value(tpl_args, frame, value, fmt_options)
tpl_args[argument_key .. '_html'] = html
tpl_args._properties[property .. ' HTML'] = html
tpl_args._properties[property .. ' range colour'] = colour
fmt_options = mw.clone(fmt_options)
fmt_options.no_color = true
tpl_args._properties[property .. ' range text'] = h.format_value(tpl_args, frame, value, fmt_options)
end
function h.stats_update(tpl_args, id, value, modid, key)
if tpl_args[key][id] == nil then
tpl_args[key][id] = {
references = {modid},
min = value.min,
max = value.max,
avg = value.avg,
}
else
if modid ~= nil then
table.insert(tpl_args[key][id].references, modid)
end
tpl_args[key][id].min = tpl_args[key][id].min + value.min
tpl_args[key][id].max = tpl_args[key][id].max + value.max
tpl_args[key][id].avg = tpl_args[key][id].avg + value.avg
end
end
h.stat = {}
function h.stat.add (value, stat_cached)
value.min = value.min + stat_cached.min
value.max = value.max + stat_cached.max
end
function h.stat.more (value, stat_cached)
value.min = value.min * (1 + stat_cached.min / 100)
value.max = value.max * (1 + stat_cached.max / 100)
end
function h.stat.more_inverse (value, stat_cached)
value.min = value.min / (1 + stat_cached.min / 100)
value.max = value.max / (1 + stat_cached.max / 100)
end
h.tbl = {}
function h.tbl.range_properties(property)
return function()
local props = {}
for _, prop in ipairs({'maximum', 'text', 'colour'}) do
props[#props+1] = string.format('Has %s range %s', property, prop)
end
return props
end
end
h.tbl.display = {}
function h.tbl.display.na_or_val(tr, value, data)
return h.na_or_val(tr, value)
end
function h.tbl.display.seconds(tr, value, data)
return h.na_or_val(tr, value, function(value)
return string.format('%ss', value)
end)
end
function h.tbl.display.percent(tr, value, data)
return h.na_or_val(tr, value, function(value)
return string.format('%s%%', value)
end)
end
function h.tbl.display.wikilink(tr, value, data)
return h.na_or_val(tr, value, function(value)
return string.format('[[%s]]', value)
end)
end
h.tbl.display.factory = {}
function h.tbl.display.factory.value(args)
args.options = args.options or {}
return function(tr, data, properties)
values = {}
for index, prop in ipairs(properties) do
local value = data[prop]
if args.options[index] and args.options[index].fmt then
value = string.format(args.options[index].fmt, value)
end
values[#values+1] = value
end
local td = tr:tag('td')
td:attr('data-sort-value', table.concat(values, ', '))
td:wikitext(table.concat(values, ', '))
if args.colour then
td:attr('class', 'tc -' .. args.colour)
end
end
end
function h.tbl.display.factory.range(args)
-- args: table
-- property
return function (tr, data, properties)
tr
:tag('td')
:attr('data-sort-value', data[string.format('Has %s range maximum', args.property)] or '0')
:attr('class', 'tc -' .. (data[string.format('Has %s range colour', args.property)] or 'default'))
:wikitext(data[string.format('Has %s range text', args.property)])
:done()
end
end
function h.format_value(tpl_args, frame, value, options)
-- value: table
-- min:
-- max:
-- options: table
-- fmt: formatter to use for the value instead of valfmt
-- fmt_range: formatter to use for the range values. Default: (%s to %s)
-- inline: Use this format string to insert value
-- inline_color: colour to use for the inline value; false to disable colour
-- func: Function to adjust the value with before output
-- color: colour code for util.html.poe_color, overrides mod colour
-- no_color: set to true to ingore colour entirely
-- return_color: also return colour
if options.no_color == nil then
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
end
if options.func ~= nil then
value.min = options.func(tpl_args, frame, value.min)
value.max = options.func(tpl_args, frame, value.max)
end
if options.fmt == nil then
options.fmt = '%s'
elseif type(options.fmt) == 'function' then
options.fmt = options.fmt(tpl_args, frame)
end
if value.min == value.max then
value.out = string.format(options.fmt, value.min)
else
value.out = string.format(string.format(options.fmt_range or i18n.range, options.fmt, options.fmt), value.min, value.max)
end
if options.no_color == nil then
value.out = util.html.poe_color(value.color, value.out)
end
local return_color
if options.return_color ~= nil then
return_color = value.color
end
local text = options.inline
if type(text) == 'string' then
elseif type(text) == 'function' then
text = text(tpl_args, frame)
else
text = nil
end
if text and text ~= '' then
local color
if options.inline_color == nil then
color = 'default'
elseif options.inline_color ~= false then
color = color.inline_color
end
if color ~= nil then
text = util.html.poe_color(color, text)
end
return string.format(text, value.out), return_color
end
-- If we didn't return before, return here
return value.out, return_color
end
-- ----------------------------------------------------------------------------
-- core
-- ----------------------------------------------------------------------------
local core = {}
function core.validate_mod(tpl_args, frame, args)
-- args:
-- key - implict or explicit
-- i
-- value
local value = tpl_args[args.key .. args.i]
local out = {
result=nil,
modid=nil,
type=args.key,
}
if value ~= nil then
table.insert(tpl_args.mods, value)
table.insert(tpl_args[args.key .. '_mods'], value)
out.modid = value
--out.result = nil
table.insert(tpl_args._mods, out)
return true
else
value = tpl_args[args.key .. args.i .. '_text']
if value ~= nil then
tpl_args._flags.text_modifier = true
--table.insert(tpl_args._subobjects, {
-- ['Is mod number'] = args.i,
-- ['Has mod text'] = value,
--})
out.result = value
table.insert(tpl_args._mods, out)
return true
end
end
return false
end
function core.process_smw_mods(tpl_args, frame)
if #tpl_args.mods == 0 then
return
end
local mods = {}
for _, mod_data in ipairs(tpl_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(#tpl_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] = tpl_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, 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
for _, key in ipairs(keys) do
local req = math.floor(tonumber(row['Has level requirement']) * 0.8)
if req > tpl_args[key] then
tpl_args[key] = req
end
end
end
end
-- TODO: Can items have mods twice? I dont think so, if they do it would need to be accounted for here
if #results ~= #tpl_args.mods then
local missing = {}
for _, modid in ipairs(tpl_args.mods) do
if mods[modid].result == nil then
missing[#missing+1] = modid
end
end
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
local text = {}
for modid, pages in pairs(duplicates) do
if #pages <= 1 then
duplicates[modid] = nil
else
text[#text+1] = string.format(i18n.errors.smw_mod_count_duplicate_format, modid, table.concat(pages, ', '))
end
end
error(string.format(i18n.errors.smw_mod_count_mismatch, table.concat(missing, ', '), table.concat(text)))
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, 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
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(tpl_args, id, value, mod_data.result['Is mod'], '_stats')
if mod_data.type ~= 'implicit' then
h.stats_update(tpl_args, id, value, mod_data.result['Is mod'], '_explicit_stats')
end
end
end
end
function core.process_base_item(tpl_args, frame, args)
local query = {}
if tpl_args.base_item_id ~= nil then
query[#query+1] = string.format('[[Has metadata id::%s]]', tpl_args.base_item_id)
elseif tpl_args.base_item_page ~= nil then
query[#query+1] = string.format('[[%s]]', tpl_args.base_item_page)
elseif tpl_args.base_item ~= nil then
query[#query+1] = string.format('[[Has name::%s]]', tpl_args.base_item)
elseif tpl_args.rarity ~= 'Normal' then
error(util.html.error{msg=i18n.errors.missing_base_item})
else
return
end
if #query > 1 and tpl_args.rarity == 'Normal' then
error(util.html.error{msg=i18n.errors.missing_rarity})
end
query[#query] = query[#query] .. string.format('[[Has item class::%s]] [[Has rarity::Normal]]', tpl_args['class'])
query[#query+1] = '?Has implicit mod ids#'
query[#query+1] = '?Has metadata id'
query[#query+1] = '?Has name'
for _, k in ipairs(tpl_args._base_item_args) do
if core.map[k].property ~= nil then
query[#query+1] = string.format('?%s#', core.map[k].property)
end
end
local result = util.smw.query(query, frame)
if #result > 1 then
error(util.html.error{msg=i18n.errors.duplicate_base_items})
-- TODO be more explicit in the error?
end
result = result[1]
tpl_args.base_item_data = result
core.process_arguments(tpl_args, frame, {array={'base_item', 'base_item_page', 'base_item_id'}})
--Copy values..
for _, k in ipairs(tpl_args._base_item_args) do
local data = core.map[k]
if data.property then
local value = result[data.property]
-- I can just use data.default since it will be nil if not provided. Neat! ;)
if value ~= "" and tpl_args[k] == data.default then
tpl_args[k] = value
if data.property_func ~= nil then
data.property_func(tpl_args, frame)
elseif data.func ~= nil then
data.func(tpl_args, frame)
end
elseif value == "" then
h.debug(tpl_args, function ()
mw.logObject(string.format(i18n.debug.base_item_property_not_found, data.property))
end)
elseif tpl_args[k] ~= data.default then
h.debug(tpl_args, function ()
mw.logObject(string.format(i18n.debug.property_value_mismatch, k, tostring(tpl_args[k])))
end)
end
elseif data.property_func ~= nil then
-- property func is set, but not a property. Probably fetching subobjects here
data.property_func(tpl_args, frame)
end
end
end
function core.process_arguments(tpl_args, frame, args)
for _, k in ipairs(args.array) do
local data = core.map[k]
table.insert(tpl_args._total_args, k)
if data.no_copy == nil then
table.insert(tpl_args._base_item_args, k)
end
if data.func ~= nil then
data.func(tpl_args, frame)
--[[local status, err = pcall(data.func)
-- an error was raised, return the error string instead of the template
if not status then
return err
end
]]--
end
if data.default ~= nil and tpl_args[k] == nil then
tpl_args[k] = data.default
end
end
end
function core.process_mod_stats(tpl_args, args)
local lines = {}
local skip = core.class_specifics[tpl_args.class]
if skip then
skip = skip.skip_stat_lines
end
for _, modinfo in ipairs(tpl_args._mods) do
if modinfo.type == args.type then
if modinfo.modid == nil then
table.insert(lines, modinfo.result)
else
for _, line in ipairs(util.string.split(modinfo.result['Has stat text'], '<br>')) do
if line ~= '' then
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
end
end
if #lines == 0 then
return
else
return table.concat(lines, '<br>')
end
end
function core.process_upgraded_from(tpl_args, args)
return
-- TODO DISABLED
--[[
local sets = {}
local setid = 1
local set
repeat
local prefix = string.format('upgrade_from_set%s_', setid)
local groupid = 1
local group
set = {
groups = {},
optional = util.cast.boolean(tpl_args[prefix .. 'optional']),
text = tpl_args[prefix .. 'text'],
}
repeat
local group_prefix = string.format('%sgroup%s_', prefix, index)
group = {
item = tpl_args[group_prefix .. 'item'],
count = tonumber(tpl_args[group_prefix .. 'count']) or 1,
notes = tpl_args[group_prefix .. 'notes'],
}
if group.item == nil then
set.groups[#set.groups+1] = group
end
groupid = groupid + 1
until group.item == nil end
-- set was empty, can terminate safely
if #set.groups == 0 then
set = nil
else
setid = setid + 1
sets[#sets+1] = set
end
until set == nil end
if #sets == 0 then
return
end
tpl_args.upgrade_from_sets = sets
-- TODO: Semantic properties, validate items
]]--
end
--
-- function factory
--
core.factory = {}
function core.factory.display_value(args)
-- args:
-- type: Type of the keys (nil = regular, gem = skill gems, stat = stats)
-- options<Array>:
-- key: key to use
-- allow_zero: allow zero values
-- hide_default: hide the value if this is set
-- hide_default_key: key to use if it isn't equal to the key parameter
-- -- from h.format_value --
-- fmt: formatter to use for the value instead of valfmt
-- fmt_range: formatter to use for the range values. Default: (%s to %s)
-- insert: insert results into this object
-- func: Function to adjust the value with before output
-- color: colour code for util.html.poe_color, overrides mod colour
-- no_color: set to true to ingore colour entirely
for k, default in pairs({options = {}}) do
if args[k] == nil then
args[k] = default
end
end
return function (tpl_args, frame)
local base_values = {}
local temp_values = {}
if args.type == 'gem' then
if not core.class_groups.gems.keys[tpl_args.class] then
return
end
for i, data in ipairs(args.options) do
local value = tpl_args['static_' .. data.key]
if value ~= nil then
base_values[#base_values+1] = value
temp_values[#temp_values+1] = {value={min=value,max=value}, index=i}
else
value = {
min=tpl_args[string.format('level1_%s', data.key)],
max=tpl_args[string.format('level%s_%s', tpl_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
elseif args.type == 'stat' then
for i, data in ipairs(args.options) do
local value = tpl_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] = tpl_args[data.key]
local value = {}
if tpl_args[data.key .. '_range_minimum'] ~= nil then
value.min = tpl_args[data.key .. '_range_minimum']
value.max = tpl_args[data.key .. '_range_maximum']
elseif tpl_args[data.key] ~= nil then
value.min = tpl_args[data.key]
value.max = tpl_args[data.key]
end
if value.min == nil then
else
temp_values[#temp_values+1] = {value=value, index=i}
end
end
end
local final_values = {}
for i, data in ipairs(temp_values) do
local opt = args.options[data.index]
local insert = false
if opt.hide_default == nil then
insert = true
elseif opt.hide_default_key == nil then
local v = data.value
if opt.hide_default ~= v.min and opt.hide_default ~= v.max then
insert = true
end
else
local v = {
min = tpl_args[opt.hide_default_key .. '_range_minimum'],
max = tpl_args[opt.hide_default_key .. '_range_maximum'],
}
if v.min == nil or v.max == nil then
if opt.hide_default ~= tpl_args[opt.hide_default_key] then
insert = true
end
elseif opt.hide_default ~= v.min and opt.hide_default ~= v.max then
insert = true
end
end
if insert == true then
table.insert(final_values, data)
end
end
-- all zeros = dont display and return early
if #final_values == 0 then
return nil
end
local out = {}
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(tpl_args, frame, value, options)
end
if args.inline then
return util.html.poe_color('default', string.format(args.inline, unpack(out)))
else
return table.concat(out, '')
end
end
end
function core.factory.display_value_only(key)
return function(tpl_args, frame)
return tpl_args[key]
end
end
function core.factory.descriptor_value(args)
-- Arguments:
-- key
-- tbl
args = args or {}
return function (tpl_args, frame, value)
args.tbl = args.tbl or tpl_args
if args.tbl[args.key] then
value = util.html.abbr(value, args.tbl[args.key])
end
return value
end
end
function core.factory.damage_html(args)
return function(tpl_args, frame)
if args.key ~= 'physical' then
args.color = args.key
args.no_color = true
end
local keys = {
min=args.key .. '_damage_min',
max=args.key .. '_damage_max',
}
local value = {}
for ktype, key in pairs(keys) do
value[ktype] = core.factory.display_value{options={ [1] = {
key = key,
no_color = args.no_color,
hide_default = 0
}}}(tpl_args, frame)
end
if value.min and value.max then
value = value.min .. '–' .. value.max
if args.color ~= nil then
value = util.html.poe_color(args.color, value)
end
tpl_args[args.key .. '_damage_html'] = value
end
end
end
function core.factory.copy_stats(args)
return function(tpl_args, frame)
if tpl_args._stats[args.stat_key] then
if tpl_args._stats[args.stat_key].min ~= tpl_args._stats[args.stat_key].max then
error('TODO: Missing support for range item limits')
end
tpl_args[args.key] = tpl_args._stats[args.stat_key].min
end
end
end
core.display = {}
function core.display.add_to_container_from_map(tpl_args, frame, container, mapping)
local grpcont
local valid
local statcont = mw.html.create('span')
statcont
:attr('class', 'item-stats')
:done()
local count = 0
for _, group in ipairs(mapping) 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 tpl_args[key] == nil then
valid = false
break
end
end
elseif type(disp.args) == 'function' then
valid = disp.args(tpl_args, frame)
end
if valid then
grpcont[#grpcont+1] = disp.func(tpl_args, frame)
end
end
else
grpcont = group.func(tpl_args, frame)
end
if #grpcont > 0 then
count = count + 1
local header = ''
if group.header == nil then
elseif type(group.header) == 'function' then
header = group.header()
else
header = string.format('<em class="header">%s</em><br>', group.header)
end
statcont
:tag('span')
:attr('class', 'group ' .. (group.css_class or ''))
:wikitext(header .. table.concat(grpcont, '<br>'))
:done()
end
end
-- Don't add empty containers
if count > 0 then
container:node(statcont)
end
end
--
-- argument mapping
--
-- format:
-- tpl_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(tpl_args, frame)
tpl_args.implicit_stat_text = core.process_mod_stats(tpl_args, {type='implicit'})
end,
},
explicit_stat_text = {
property = 'Has explicit stat text',
func = function(tpl_args, frame)
tpl_args.explicit_stat_text = core.process_mod_stats(tpl_args, {type='explicit'})
if tpl_args.is_talisman or tpl_args.is_corrupted then
if tpl_args.explicit_stat_text == nil or tpl_args.explicit_stat_text == '' then
tpl_args.explicit_stat_text = util.html.poe_color('corrupted', i18n.tooltips.corrupted)
else
tpl_args.explicit_stat_text = (tpl_args.explicit_stat_text or '') .. '<br>' .. util.html.poe_color('corrupted', i18n.tooltips.corrupted)
end
end
end,
},
stat_text = {
property = 'Has stat text',
func = function(tpl_args, frame)
local sep = ''
if tpl_args.implicit_stat_text and tpl_args.explicit_stat_text then
sep = string.format('<span class="item-stat-separator -%s"></span>', tpl_args.frame_type)
end
local text = (tpl_args.implicit_stat_text or '') .. sep .. (tpl_args.explicit_stat_text or '')
if string.len(text) > 0 then
tpl_args.stat_text = text
end
end,
},
-- generic
class = {
no_copy = true,
property = 'Has item class',
func = util.cast.factory.table('class', {key='full', tbl=m_game.constants.item.class}),
},
rarity = {
no_copy = true,
property = 'Has rarity',
func = util.cast.factory.table('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 = util.cast.factory.number('size_x'),
},
size_y = {
property = 'Has inventory height',
func = util.cast.factory.number('size_y'),
},
drop_enabled = {
no_copy = true,
property = 'Is drop enabled',
func = util.cast.factory.boolean('drop_enabled'),
default = true,
},
drop_level = {
no_copy = true,
property = 'Has drop level',
func = util.cast.factory.number('drop_level'),
},
drop_level_maximum = {
no_copy = true,
property = 'Has maximum drop level',
func = util.cast.factory.number('drop_level_maximum'),
},
drop_leagues = {
no_copy = true,
property = 'Has league drop restrictions',
func = util.cast.factory.assoc_table('drop_leagues', {tbl=m_game.constants.leagues, errmsg=i18n.errors.invalid_league}),
},
required_level = {
property = 'Has base level requirement',
func = util.cast.factory.number('required_level'),
default = 1,
},
required_level_final = {
property = 'Has level requirement',
func = function(tpl_args, frame)
tpl_args.required_level_final = tpl_args.required_level
end,
default = 1,
},
required_dexterity = {
property = 'Has base dexterity requirement',
func = util.cast.factory.number('required_dexterity'),
default = 0,
},
required_strength = {
property = 'Has base strength requirement',
func = util.cast.factory.number('required_strength'),
default = 0,
},
required_intelligence = {
property = 'Has base intelligence requirement',
func = util.cast.factory.number('required_intelligence'),
default = 0,
},
inventory_icon = {
no_copy = true,
property = 'Has inventory icon',
func = function(tpl_args, frame)
tpl_args.inventory_icon_id = tpl_args.inventory_icon or tpl_args.name
tpl_args.inventory_icon = string.format(i18n.inventory_icon, tpl_args.inventory_icon_id)
end,
},
-- note: this must be called after inventory item to work correctly as it depends on tpl_args.inventory_icon_id being set
alternate_art_inventory_icons = {
no_copy = true,
property = 'Has alternate inventory icons',
func = function(tpl_args, frame)
local icons = {}
if tpl_args.alternate_art_inventory_icons ~= nil then
local names = util.string.split(tpl_args.alternate_art_inventory_icons, ', ')
for _, name in ipairs(names) do
icons[#icons+1] = string.format(i18n.inventory_icon, string.format('%s %s', tpl_args.inventory_icon_id, name))
end
end
tpl_args.alternate_art_inventory_icons = icons
end,
default = {},
},
buff_icon = {
property = 'Has buff icon',
func = function(tpl_args, frame)
tpl_args.buff_icon = string.format(i18n.status_icon, tpl_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(tpl_args, frame)
tpl_args.tags = util.string.split(tpl_args.tags, '<MANY>')
end,
func = util.cast.factory.assoc_table('tags', {
tbl = m_game.constants.tags,
errmsg = i18n.errors.invalid_tag,
}),
},
metadata_id = {
no_copy = true,
property = 'Has metadata id',
func = nil,
},
is_corrupted = {
no_copy = true,
property = 'Is corrupted',
func = util.cast.factory.boolean('is_corrupted'),
default = false,
},
is_relic = {
no_copy = true,
property = 'Is relic',
func = function(tpl_args, frame)
util.cast.factory.boolean('is_relic')(tpl_args, frame)
if tpl_args.is_relic == true and tpl_args.rarity ~= 'Unique' then
error(i18n.errors.non_unique_relic)
end
end,
default = false,
},
--
-- specific section
--
-- Most item classes
quality = {
no_copy = true,
property = 'Has quality',
-- Can be set manually, but default to Q20 for unique weapons/body armours
-- Also must copy to stat for the stat adjustments to work properly
func = function(tpl_args, frame)
local quality = tonumber(tpl_args.quality)
--
if quality == nil then
if tpl_args.rarity ~= 'Unique' then
quality = 0
elseif core.class_groups.weapons.keys[tpl_args.class] or core.class_groups.armor.keys[tpl_args.class] then
quality = 20
else
quality = 0
end
end
tpl_args.quality = quality
local stat = {
min = quality,
max = quality,
avg = quality,
}
h.stats_update(tpl_args, 'quality', stat, nil, '_stats')
if tpl_args.class == 'Utility Flasks' or tpl_args.class == 'Critical Utility Flasks' then
h.stats_update(tpl_args, 'quality_flask_duration', stat, nil, '_stats')
-- quality is added to quantity for maps
elseif tpl_args.class == 'Maps' then
h.stats_update(tpl_args, 'map_item_drop_quantity_+%', stat, nil, '_stats')
end
end
},
-- amulets
is_talisman = {
property = 'Is talisman',
func = util.cast.factory.boolean('is_talisman'),
default = false,
},
talisman_tier = {
property = 'Has talisman tier',
func = util.cast.factory.number('talisman_tier'),
},
-- flasks
charges_max = {
property = 'Has base maximum flask charges',
func = util.cast.factory.number('charges_max'),
},
charges_per_use = {
property = 'Has base flask charges per use',
func = util.cast.factory.number('charges_per_use'),
},
flask_mana = {
property = 'Has base flask mana recovery',
func = util.cast.factory.number('flask_mana'),
},
flask_life = {
property = 'Has base flask life recovery',
func = util.cast.factory.number('flask_life'),
},
flask_duration = {
property = 'Has base flask duration',
func = util.cast.factory.number('flask_duration'),
},
buff_id = {
property = 'Has buff id',
func = nil,
},
buff_values = {
property = nil,
property_func = function(tpl_args, frame)
local results = util.smw.query({
string.format('[[-Has subobject::%s]] [[Is number::+]] [[Has buff value::+]]', tpl_args.base_item_page),
'?Is number#',
'?Has buff value#',
}, frame)
local values = {}
for _, row in ipairs(results) do
local i = tonumber(row['Is number'])
local value = tonumber(row['Has buff value'])
values[i] = value
if i ~= nil then
local key = 'buff_value' .. i
tpl_args[key] = value
tpl_args._subobjects[key] = {
['Is number'] = i,
['Has buff value'] = value,
}
end
end
tpl_args.buff_values = values
end,
func = function(tpl_args, frame)
local values = {}
local i = 0
local value
local key
repeat
i = i + 1
key = 'buff_value' .. i
value = tonumber(tpl_args[key])
values[i] = value
tpl_args[key] = value
tpl_args._subobjects[key] = {
['Is number'] = i,
['Has buff value'] = value,
}
until values[i] == nil
tpl_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 = util.cast.factory.number('critical_strike_chance'),
},
-- weapons
attack_speed = {
property = 'Has base attack speed',
func = util.cast.factory.number('attack_speed'),
},
physical_damage_min = {
property = 'Has base minimum physical damage',
func = util.cast.factory.number('physical_damage_min'),
},
physical_damage_max = {
property = 'Has base maximum physical damage',
func = util.cast.factory.number('physical_damage_max'),
},
range = {
property = 'Has base weapon range',
func = util.cast.factory.number('range'),
},
-- armor-type stuff
armour = {
property = 'Has base armour',
func = util.cast.factory.number('armour'),
default = 0,
},
energy_shield = {
property = 'Has base energy shield',
func = util.cast.factory.number('energy_shield'),
default = 0,
},
evasion = {
property = 'Has base evasion',
func = util.cast.factory.number('evasion'),
default = 0,
},
-- shields
block = {
property = 'Has base block',
func = util.cast.factory.number('block'),
},
-- skill gem stuff
gem_description = {
property = 'Has description',
func = nil,
},
dexterity_percent = {
property = 'Has dexterity percentage',
func = util.cast.factory.percentage('dexterity_percent'),
},
strength_percent = {
property = 'Has strength percentage',
func = util.cast.factory.percentage('strength_percent'),
},
intelligence_percent = {
property = 'Has intelligence percentage',
func = util.cast.factory.percentage('intelligence_percent'),
},
primary_attribute = {
property = 'Has primary attribute',
func = function(tpl_args, frame)
for _, attr in ipairs(m_game.constants.attributes) do
local val = tpl_args[attr.long_lower .. '_percent']
if val and val >= 60 then
tpl_args['primary_attribute'] = attr.long_upper
return
end
end
tpl_args['primary_attribute'] = 'None'
end,
},
gem_tags = {
property = 'Has gem tags',
-- TODO: default rework
func = util.cast.factory.array_table('gem_tags', {
tbl = m_game.constants.item.gem_tags,
errmsg = i18n.errors.invalid_tag,
}),
default = {},
},
experience = {
property = 'Has maximum experience',
func = util.cast.factory.percentage('experience'),
},
skill_screenshot = {
property = 'Has skill screenshot',
func = function(tpl_args, frame)
tpl_args.skill_screenshot = string.format(i18n.skill_screenshot, tpl_args.name)
end,
},
-- Active gems only
gem_icon = {
property = 'Has skill gem icon',
func = function(tpl_args, frame)
-- TODO readd support if needed.
tpl_args.gem_icon = string.format(i18n.skill_icon, tpl_args.name)
end,
},
-- Support gems only
support_gem_letter_html = {
property = 'Has support gem letter HTML',
func = function(tpl_args, frame)
if tpl_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 tpl_args[k] and tpl_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(tpl_args.support_gem_letter)
:done()
tpl_args.support_gem_letter_html = tostring(container)
end
end,
},
-- Maps
map_tier = {
property = 'Has map tier',
func = util.cast.factory.number('tier'),
},
map_guild_character = {
no_copy = true,
property = 'Has map guild character',
func = nil,
},
map_area_id = {
no_copy = true,
property = 'Has map area id',
func = nil, -- TODO: Validate against a query?
},
map_area_level = {
no_copy = true,
property = 'Has map area level',
func = util.cast.factory.number('map_area_level'),
},
unique_map_guild_character = {
property = 'Has unique map guild character',
property_func = function(tpl_args, frame)
tpl_args.map_guild_character = tpl_args.unique_map_guild_character
tpl_args.unique_map_guild_character = nil
end,
func = nil,
},
unique_map_area_id = {
property = 'Has unique map area id',
func = nil, -- TODO: Validate against a query?
property_func = function(tpl_args, frame)
tpl_args.map_area_id = tpl_args.unique_map_area_id
tpl_args.unique_map_area_id = nil
end,
},
unique_map_area_level = {
property = 'Has unique map area level',
func = util.cast.factory.number('unique_map_area_level'),
property_func = function(tpl_args, frame)
tpl_args.map_area_level = tpl_args.unique_map_area_level
tpl_args.unique_map_area_level = nil
end,
},
--
-- Currency-like items
--
stack_size = {
property = 'Has stack size',
func = util.cast.factory.number('stack_size'),
},
stack_size_currency_tab = {
property = 'Has currency tab stack size',
func = util.cast.factory.number('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 = util.cast.factory.boolean('is_essence'),
default = false,
},
essence_level_restriction = {
property = 'Has essence level restriction',
func = util.cast.factory.number('essence_level_restriction'),
},
essence_tier = {
property = 'Has essence tier',
func = util.cast.factory.number('essence_tier'),
},
--
-- hideout doodads (HideoutDoodads.dat)
--
is_master_doodad = {
property = 'Is master doodad',
func = util.cast.factory.boolean('is_master_doodad'),
},
master = {
property = 'Is sold by master',
-- todo validate against list of master names
func = util.cast.factory.table('master', {key='full', tbl=m_game.constants.masters}),
},
master_level_requirement = {
property = 'Has master level requirement',
func = util.cast.factory.number('master_level_requirement'),
},
master_favour_cost = {
property = 'Has master favour cost',
func = util.cast.factory.number('master_favour_cost'),
},
variation_count = {
property = 'Has variation count',
func = util.cast.factory.number('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 = util.cast.factory.number('seal_cost_normal'),
},
seal_cost_cruel = {
property = 'Has prophecy seal cost in cruel difficulty',
func = util.cast.factory.number('seal_cost_cruel'),
},
seal_cost_merciless = {
property = 'Has prophecy seal cost in merciless difficulty',
func = util.cast.factory.number('seal_cost_merciless'),
},
-- Divination cards
card_art = {
proprety = 'Has divination card art',
func = function(tpl_args, frame)
tpl_args.card_art = string.format(i18n.divination_card_art, tpl_args.name)
end,
},
card_reward = {
property = 'Has divinication card reward',
func = nil,
},
-- ------------------------------------------------------------------------
-- derived stats
-- ------------------------------------------------------------------------
-- For rarity != normal, rarity already verified
base_item = {
no_copy = true,
property = 'Has base item',
func = function(tpl_args, frame)
tpl_args.base_item = tpl_args.base_item_data['Has name']
end,
},
base_item_id = {
no_copy = true,
property = 'Has base item metadata id',
func = function(tpl_args, frame)
tpl_args.base_item_id = tpl_args.base_item_data['Has metadata id']
end,
},
base_item_page = {
no_copy = true,
property = 'Has base item wiki page',
func = function(tpl_args, frame)
tpl_args.base_item_page = tpl_args.base_item_data[1]
end,
},
name_list = {
no_copy = true,
property = 'Has names',
func = function(tpl_args, frame)
if tpl_args.name_list ~= nil then
tpl_args.name_list = util.string.split(tpl_args.name_list, ', ')
tpl_args.name_list[#tpl_args.name_list+1] = tpl_args.name
else
tpl_args.name_list = {tpl_args.name}
end
end,
},
name_list_lower = {
no_copy = true,
property = 'Has lowercase names',
func = function(tpl_args, frame)
tpl_args.name_list_lower = {}
for index, value in ipairs(tpl_args.name_list) do
tpl_args.name_list_lower[index] = mw.ustring.lower(value)
end
end,
},
gem_tags_difference = {
no_copy = true,
property = 'Has gem tags difference',
func = function(tpl_args, frame)
if tpl_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(tpl_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
tpl_args.gem_tags_difference = {}
for key, value in pairs(gtags) do
tpl_args.gem_tags_difference[#tpl_args.gem_tags_difference+1] = key
end
end
end,
},
frame_type = {
no_copy = true,
property = nil,
func = function(tpl_args, frame)
if tpl_args.name == 'Prophecy' or tpl_args.base_item == 'Prophecy' then
tpl_args.frame_type = 'prophecy'
return
end
local var = core.class_specifics[tpl_args.class]
if var ~= nil and var.frame_type ~= nil then
tpl_args.frame_type = var.frame_type
return
end
if tpl_args.is_relic then
tpl_args.frame_type = 'relic'
return
end
tpl_args.frame_type = string.lower(tpl_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 (tpl_args)
tpl_args.implicit_mods = util.string.split(tpl_args.implicit_mods, '<MANY>')
for _, modid in ipairs(tpl_args.implicit_mods) do
tpl_args.mods[#tpl_args.mods+1] = modid
tpl_args._mods[#tpl_args._mods+1] = {
result=nil,
modid=modid,
type='implicit',
}
end
end,
default = {},
},
explicit_mods = {
no_copy = true,
property = 'Has explicit mod ids',
default = {},
},
physical_damage_html = {
no_copy = true,
property = nil,
func = core.factory.damage_html{key='physical'},
},
fire_damage_html = {
no_copy = true,
property = nil,
func = core.factory.damage_html{key='fire'},
},
cold_damage_html = {
no_copy = true,
property = nil,
func = core.factory.damage_html{key='cold'},
},
lightning_damage_html = {
no_copy = true,
property = nil,
func = core.factory.damage_html{key='lightning'},
},
chaos_damage_html = {
no_copy = true,
property = nil,
func = core.factory.damage_html{key='chaos'},
},
damage_avg = {
no_copy = true,
property = 'Has average damage',
func = function(tpl_args, frame)
local dmg = {min=0, max=0}
for key, _ in pairs(dmg) do
for _, data in ipairs(m_game.constants.damage_types) do
dmg[key] = dmg[key] + tpl_args[string.format('%s_damage_%s_range_average', data.short_lower, key)]
end
end
dmg = (dmg.min + dmg.max) / 2
tpl_args.damage_avg = dmg
end,
},
damage_html = {
no_copy = true,
property = 'Has damage HTML',
func = function(tpl_args, frame)
local text = {}
for _, data in ipairs(m_game.constants.damage_types) do
local value = tpl_args[data.short_lower .. '_damage_html']
if value ~= nil then
text[#text+1] = value
end
end
if #text > 0 then
tpl_args.damage_html = table.concat(text, '<br>')
end
end,
},
item_limit = {
no_copy = true,
property = 'Has item limit',
func = util.cast.factory.number('item_limit'),
},
jewel_radius = {
no_copy = true,
property = 'Has jewel radius',
func = core.factory.copy_stats{key='jewel_radius', stat_key='local_jewel_effect_base_radius'}
},
jewel_radius_html = {
no_copy = true,
property = 'Has jewel radius HTML',
func = function(tpl_args, frame)
if tpl_args.jewel_radius then
tpl_args.jewel_radius_html = string.format('%s (%i)', (m_game.constants.item.jewel_radius_to_size[tpl_args.jewel_radius] or '?'), tpl_args.jewel_radius)
end
end,
},
}
core.stat_map = {
required_level_final = {
property = 'Has level requirement',
stats_add = {
'local_level_requirement_+',
},
stats_override = {
['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=1, max=1},
},
minimum = 1,
html_fmt_options = {
fmt = '%i',
},
},
range = {
property = 'Has weapon range',
stats_add = {
'local_weapon_range_+',
},
minimum = 0,
html_fmt_options = {
fmt = '%i',
},
},
physical_damage_min = {
property = 'Has minimum physical damage',
stats_add = {
'local_minimum_added_physical_damage',
},
stats_increased = {
'local_physical_damage_+%',
'quality',
},
minimum = 0,
html_fmt_options = {
fmt = '%i',
},
},
physical_damage_max = {
property = 'Has maximum physical damage',
stats_add = {
'local_maximum_added_physical_damage',
},
stats_increased = {
'local_physical_damage_+%',
'quality',
},
minimum = 0,
html_fmt_options = {
fmt = '%i',
},
},
fire_damage_min = {
default = 0,
property = 'Has minimum fire damage',
stats_add = {
'local_minimum_added_fire_damage',
},
minimum = 0,
html_fmt_options = {
color = 'fire',
fmt = '%i',
},
},
fire_damage_max = {
default = 0,
property = 'Has maximum fire damage',
stats_add = {
'local_maximum_added_fire_damage',
},
minimum = 0,
html_fmt_options = {
color = 'fire',
fmt = '%i',
},
},
cold_damage_min = {
default = 0,
property = 'Has minimum cold damage',
stats_add = {
'local_minimum_added_cold_damage',
},
minimum = 0,
html_fmt_options = {
color = 'cold',
fmt = '%i',
},
},
cold_damage_max = {
default = 0,
property = 'Has maximum cold damage',
stats_add = {
'local_maximum_added_cold_damage',
},
minimum = 0,
html_fmt_options = {
color = 'cold',
fmt = '%i',
},
},
lightning_damage_min = {
default = 0,
property = 'Has minimum lightning damage',
stats_add = {
'local_minimum_added_lightning_damage',
},
minimum = 0,
html_fmt_options = {
color = 'lightning',
fmt = '%i',
},
},
lightning_damage_max = {
default = 0,
property = 'Has maximum lightning damage',
stats_add = {
'local_maximum_added_lightning_damage',
},
minimum = 0,
html_fmt_options = {
color = 'lightning',
fmt = '%i',
},
},
chaos_damage_min = {
default = 0,
property = 'Has minimum chaos damage',
stats_add = {
'local_minimum_added_chaos_damage',
},
minimum = 0,
html_fmt_options = {
color = 'chaos',
fmt = '%i',
},
},
chaos_damage_max = {
default = 0,
property = 'Has maximum chaos damage',
stats_add = {
'local_maximum_added_chaos_damage',
},
minimum = 0,
html_fmt_options = {
color = 'chaos',
fmt = '%i',
},
},
critical_strike_chance = {
property = 'Has critical strike chance',
stats_add = {
'local_critical_strike_chance',
},
stats_increased = {
'local_critical_strike_chance_+%',
},
stats_override = {
['local_weapon_always_crit'] = {min=100, max=100},
},
minimum = 0,
html_fmt_options = {
fmt = '%.2f%%',
},
},
attack_speed = {
property = 'Has attack speed',
stats_increased = {
'local_attack_speed_+%',
},
minimum = 0,
html_fmt_options = {
fmt = '%.2f',
},
},
flask_life = {
property = 'Has flask life recovery',
stats_add = {
'local_flask_life_to_recover',
},
stats_increased = {
'local_flask_life_to_recover_+%',
'local_flask_amount_to_recover_+%',
'quality',
},
html_fmt_options = {
fmt = '%i',
},
},
flask_mana = {
property = 'Has flask mana recovery',
stats_add = {
'local_flask_mana_to_recover',
},
stats_increased = {
'local_flask_mana_to_recover_+%',
'local_flask_amount_to_recover_+%',
'quality',
},
},
flask_duration = {
property = 'Has flask duration',
stats_increased = {
'local_flask_duration_+%',
-- regular quality isn't used here because it doesn't increase duration of life/mana/hybrid flasks
'quality_flask_duration',
},
stats_increased_inverse = {
'local_flask_recovery_speed_+%',
},
minimum = 0,
html_fmt_options = {
fmt = '%.2f',
},
},
charges_per_use = {
property = 'Has flask charges per use',
stats_increased = {
'local_charges_used_+%',
},
minimum = 0,
html_fmt_options = {
fmt = '%i',
},
},
charges_max = {
property = 'Has maximum flask charges',
stats_add = {
'local_extra_max_charges',
},
stats_increased = {
'local_max_charges_+%',
},
minimum = 0,
html_fmt_options = {
fmt = '%i',
},
},
block = {
property = 'Has block',
stats_add = {
'local_additional_block_chance_%',
},
minimum = 0,
html_fmt_options = {
fmt = '%i%%',
},
},
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_+%',
'quality',
},
minimum = 0,
html_fmt_options = {
fmt = '%i',
},
},
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_+%',
'quality',
},
minimum = 0,
html_fmt_options = {
fmt = '%i',
},
},
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_+%',
'quality',
},
stats_override = {
['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
},
minimum = 0,
html_fmt_options = {
fmt = '%i',
},
},
required_dexterity = {
property = 'Has dexterity requirement',
stats_add = {
'local_dexterity_requirement_+'
},
stats_increased = {
'local_dexterity_requirement_+%',
'local_attribute_requirements_+%',
},
stats_override = {
['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
},
minimum = 0,
html_fmt_options = {
fmt = '%i',
},
},
required_intelligence = {
property = 'Has intelligence requirement',
stats_add = {
'local_intelligence_requirement_+'
},
stats_increased = {
'local_intelligence_requirement_+%',
'local_attribute_requirements_+%',
},
stats_override = {
['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
},
minimum = 0,
html_fmt_options = {
fmt = '%i',
},
},
required_strength = {
property = 'Has strength requirement',
stats_add = {
'local_strength_requirement_+'
},
stats_increased = {
'local_strength_requirement_+%',
'local_attribute_requirements_+%',
},
stats_override = {
['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
},
minimum = 0,
html_fmt_options = {
fmt = '%i',
},
},
map_area_level = {
property = 'Has map area level',
stats_override = {
['map_item_level_override'] = true,
},
},
}
core.dps_map = {
{
name = 'physical_dps',
property = 'physical damage per second',
damage_args = {'physical_damage', },
label = i18n.item_table.physical_dps,
label_infobox = i18n.tooltips.physical_dps,
html_fmt_options = {
color = 'value',
fmt = '%.1f',
},
},
{
name = 'fire_dps',
property = 'fire damage per second',
damage_args = {'fire_damage'},
label = i18n.item_table.fire_dps,
label_infobox = i18n.tooltips.fire_dps,
html_fmt_options = {
color = 'fire',
fmt = '%.1f',
},
},
{
name = 'cold_dps',
property = 'cold damage per second',
damage_args = {'cold_damage'},
label = i18n.item_table.cold_dps,
label_infobox = i18n.tooltips.cold_dps,
html_fmt_options = {
color = 'cold',
fmt = '%.1f',
},
},
{
name = 'lightning_dps',
property = 'lightning damage per second',
damage_args = {'lightning_damage'},
label = i18n.item_table.lightning_dps,
label_infobox = i18n.tooltips.lightning_dps,
html_fmt_options = {
color = 'lightning',
fmt = '%.1f',
},
},
{
name = 'chaos_dps',
property = 'chaos damage per second',
damage_args = {'chaos_damage'},
label = i18n.item_table.chaos_dps,
label_infobox = i18n.tooltips.chaos_dps,
html_fmt_options = {
color = 'chaos',
fmt = '%.1f',
},
},
{
name = 'elemental_dps',
property = 'elemental damage per second',
damage_args = {'fire_damage', 'cold_damage', 'lightning_damage'},
label = i18n.item_table.elemental_dps,
label_infobox = i18n.tooltips.elemental_dps,
html_fmt_options = {
color = 'value',
fmt = '%.1f',
},
},
{
name = 'poison_dps',
property = 'poison damage per second',
damage_args = {'physical_damage', 'chaos_damage'},
label = i18n.item_table.poison_dps,
label_infobox = i18n.tooltips.poison_dps,
html_fmt_options = {
color = 'value',
fmt = '%.1f',
},
},
{
name = 'dps',
property = 'damage per second',
damage_args = {'physical_damage', 'fire_damage', 'cold_damage', 'lightning_damage', 'chaos_damage'},
label = i18n.item_table.dps,
label_infobox = i18n.tooltips.dps,
html_fmt_options = {
color = 'value',
fmt = '%.1f',
},
},
}
-- TODO: Second pass for i18n item classes
-- base item is default, but will be validated later
-- Notes:
-- inventory_icon must always be before alternate_art_inventory_icons
-- is_relic after rarity
core.default_args = {'class', 'rarity', 'name', 'name_list', 'name_list_lower', 'size_x', 'size_y', 'drop_enabled', 'drop_level', 'drop_level_maximum', 'drop_leagues', 'required_level', 'required_level_final', 'inventory_icon', 'alternate_art_inventory_icons', 'flavour_text', 'help_text', 'tags', 'metadata_id', 'is_corrupted', 'is_relic', '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 = {'quality', '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 = {'quality', 'required_dexterity', 'required_intelligence', 'required_strength', 'critical_strike_chance', 'attack_speed', 'physical_damage_min', 'physical_damage_max', 'range'},
late_args = {'physical_damage_html', 'fire_damage_html', 'cold_damage_html', 'lightning_damage_html', 'chaos_damage_html', 'damage_avg', 'damage_html'},
},
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 = {'quality', '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', 'talisman_tier'},
},
['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 = i18n.help_text_defaults.active_gem,
size_x = 1,
size_y = 1,
},
frame_type = 'gem',
},
['Support Skill Gems'] = {
args = {'support_gem_letter_html'},
defaults = {
help_text = i18n.help_text_defaults.support_gem,
size_x = 1,
size_y = 1,
},
frame_type = 'gem',
},
['Shields'] = {
args = {'block'},
},
['Maps'] = {
args = {'quality', '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 = i18n.stat_skip_patterns.maps,
},
['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 = i18n.help_text_defaults.hideout_doodad,
},
frame_type = 'currency',
},
['Jewel'] = {
late_args = {'item_limit', 'jewel_radius', 'jewel_radius_html'},
defaults = {
help_text = i18n.help_text_defaults.jewel,
},
skip_stat_lines = i18n.stat_skip_patterns.jewels,
},
['Quest Items'] = {
frame_type = 'quest',
},
['Divination Card'] = {
args = {'card_art', 'card_reward'},
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 = {}
function core.build_item_classes()
for _, data in ipairs(m_game.constants.item.class) do
core.item_classes[data['full']] = {
args = xtable:new(),
late_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)
if row.late_args ~= nil then
core.item_classes[k].late_args:insertT(row.late_args)
end
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.late_args ~= nil then
core.item_classes[k].late_args:insertT(row.late_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
end
-- GroupTable -> RowTable -> formatter function
--
--
--
-- Contents here are meant to resemble the ingame infobox of items
--
core.item_display_groups = {
-- Tags, stats, level, etc
{
{
args = {'cosmetic_type'},
func = core.factory.display_value{
options = {
[1] = {
key = 'cosmetic_type',
fmt = '%s',
color = 'default'
},
},
},
},
{
args = function(tpl_args, frame)
if tpl_args.class == nil then
return false
end
return core.class_groups.weapons.keys[tpl_args.class] ~= nil
end,
func = core.factory.display_value{
options = {
[1] = {
key = 'class',
color = 'default',
},
},
},
},
{
args = {'gem_tags'},
func = function(tpl_args, frame)
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,
},
{
args = {'support_gem_letter_html'},
func = core.factory.display_value{
options = {
[1] = {
key = 'support_gem_letter_html',
inline = i18n.tooltips.support_icon,
},
},
},
},
{
args = {'radius'},
func = core.factory.display_value{
options = {
[1] = {
key = 'radius',
inline = i18n.tooltips.radius,
func = core.factory.descriptor_value{key='radius_description'},
},
[2] = {
key = 'radius_secondary',
inline = ' / %s',
func = core.factory.descriptor_value{key='radius_secondary_description'},
},
[3] = {
key = 'radius_tertiary',
inline = ' / %s',
func = core.factory.descriptor_value{key='radius_tertiary_description'},
},
},
},
},
-- TODO: gem level here. Maybe put max level here?
{
args = nil,
func = core.factory.display_value{
type='gem',
options = {
[1] = {
key = 'mana_cost',
hide_default = 100,
fmt = function (tpl_args, frame)
if tpl_args.has_percentage_mana_cost then
return '%i%%'
else
return '%i'
end
end,
inline = function (tpl_args, frame)
if tpl_args.has_reservation_mana_cost then
return i18n.tooltips.mana_reserved
else
return i18n.tooltips.mana_cost
end
end,
},
},
},
},
{
args = nil,
func = core.factory.display_value{
type='gem',
options = {
[1] = {
key = 'mana_multiplier',
hide_default = 100,
fmt = '%i%%',
inline = i18n.tooltips.mana_multiplier,
},
},
},
},
-- TODO: i18n
{
args = nil,
func = core.factory.display_value{
type='gem',
options = {
[1] = {
key = 'vaal_souls_requirement',
hide_default = 0,
fmt = '%i (N) / ',
inline = i18n.tooltips.vaal_souls_per_use,
},
[2] = {
key = 'vaal_souls_requirement',
hide_default = 0,
fmt = '%i (C) / ',
func = function (tpl_args, frame, value)
return value*1.5
end,
},
[3] = {
key = 'vaal_souls_requirement',
hide_default = 0,
fmt = '%i (M)',
func = function (tpl_args, frame, value)
return value*2
end,
},
},
},
},
{
args = nil,
func = core.factory.display_value{
type='gem',
options = {
[1] = {
key = 'vaal_stored_uses',
hide_default = 0,
fmt = '%i',
inline = i18n.tooltips.stored_uses,
},
},
},
},
{
args = nil,
func = core.factory.display_value{
type='gem',
options = {
[1] = {
key = 'stored_uses',
hide_default = 0,
fmt = '%i',
inline = i18n.tooltips.stored_uses,
},
},
},
},
{
args = nil,
func = core.factory.display_value{
type='gem',
options = {
[1] = {
key = 'cooldown',
hide_default = 0,
fmt = '%.2f sec',
inline = i18n.tooltips.cooldown_time,
},
},
},
},
{
args = {'cast_time'},
func = core.factory.display_value{
options = {
[1] = {
key = 'cast_time',
hide_default = 0,
fmt = '%.2f sec',
inline = i18n.tooltips.cast_time,
},
},
},
},
{
args = nil,
func = core.factory.display_value{
type='gem',
options = {
[1] = {
key = 'critical_strike_chance',
hide_default = 0,
fmt = '%.2f%%',
inline = i18n.tooltips.critical_strike_chance,
},
},
},
},
{
args = nil,
func = core.factory.display_value{
type='gem',
options = {
[1] = {
key = 'damage_effectiveness',
hide_default = 100,
fmt = '%i%%',
inline = i18n.tooltips.damage_effectiveness,
},
},
},
},
{
args = {'projectile_speed'},
func = core.factory.display_value{
options = {
[1] = {
key = 'projectile_speed',
inline = i18n.tooltips.projectile_speed,
},
},
},
},
-- Quality is before item stats, but after gem stuff and item class
{
args = {'quality'},
func = core.factory.display_value{
options = {
[1] = {
key = 'quality',
fmt = '+%i%%',
color = 'mod',
inline = i18n.tooltips.quality,
hide_default = 0,
},
},
},
},
-- Weapon only
{
args = {'physical_damage_html'},
func = core.factory.display_value{
options = {
[1] = {
key = 'physical_damage_html',
fmt = '%s',
inline = i18n.tooltips.physical_damage,
},
},
},
},
{
args = nil,
func = function(tpl_args, frame)
local text = ''
for _, dtype in ipairs({'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}) do
local value = tpl_args[dtype]
if value ~= nil then
text = text .. ' ' .. value
end
end
if text ~= '' then
return string.format(i18n.tooltips.elemental_damage, text)
else
return
end
end,
},
{
args = {'chaos_damage_html'},
func = core.factory.display_value{
options = {
[1] = {
key = 'chaos_damage_html',
fmt = '%s',
inline = i18n.tooltips.chaos_damage,
},
},
},
},
{
args = {'critical_strike_chance_html'},
func = core.factory.display_value{
options = {
[1] = {
key = 'critical_strike_chance_html',
fmt = '%s',
inline = i18n.tooltips.critical_strike_chance,
},
},
},
},
{
args = {'attack_speed_html'},
func = core.factory.display_value{
options = {
[1] = {
key = 'attack_speed_html',
fmt = '%s',
inline = i18n.tooltips.attacks_per_second,
},
},
},
},
{
args = {'range_html'},
func = core.factory.display_value{
options = {
[1] = {
key = 'range_html',
fmt = '%s',
inline = i18n.tooltips.weapon_range,
},
},
},
},
-- Map only
{
args = {'map_area_level'},
func = core.factory.display_value{
options = {
[1] = {
key = 'map_area_level',
fmt = '%i',
inline = i18n.tooltips.map_level,
},
},
},
},
{
args = {'map_tier'},
func = core.factory.display_value{
options = {
[1] = {
key = 'map_tier',
fmt = '%i',
inline = i18n.tooltips.map_tier,
},
},
},
},
{
args = function(tpl_args, frame)
return tpl_args.map_guild_character ~= nil and tpl_args.rarity == 'Normal'
end,
func = core.factory.display_value{
options = {
[1] = {
key = 'map_guild_character',
fmt = '%s',
inline = i18n.tooltips.map_guild_character,
},
},
},
},
{
args = function(tpl_args, frame)
return tpl_args.unique_map_guild_character ~= nil and tpl_args.rarity == 'Unique'
end,
func = core.factory.display_value{
options = {
[1] = {
key = 'unique_map_guild_character',
fmt = '%s',
inline = i18n.tooltips.map_guild_character,
},
},
},
},
{
args = nil,
func = core.factory.display_value{
type = 'stat',
options = {
[1] = {
key = 'map_item_drop_quantity_+%',
fmt = '+%i%%',
color = 'mod',
inline = i18n.tooltips.item_quantity,
hide_default = 0,
},
},
},
},
{
args = nil,
func = core.factory.display_value{
type = 'stat',
options = {
[1] = {
key = 'map_item_drop_rarity_+%',
fmt = '+%i%%',
color = 'mod',
inline = i18n.tooltips.item_rarity,
hide_default = 0,
},
},
},
},
{
args = nil,
func = core.factory.display_value{
type = 'stat',
options = {
[1] = {
key = 'map_pack_size_+%',
fmt = '+%i%%',
color = 'mod',
inline = i18n.tooltips.monster_pack_size,
hide_default = 0,
},
},
},
},
-- Jewel Only
{
args = nil,
func = core.factory.display_value{
options = {
[1] = {
key = 'item_limit',
fmt = '%i',
inline = i18n.tooltips.limited_to,
},
},
},
},
{
args = {'jewel_radius_html'},
func = core.factory.display_value{
options = {
[1] = {
key = 'jewel_radius_html',
fmt = '%s',
inline = i18n.tooltips.radius,
},
},
},
},
-- Flask only
{
args = {'flask_mana_html', 'flask_duration_html'},
--func = core.factory.display_flask('flask_mana'),
func = core.factory.display_value{
inline = i18n.tooltips.flask_mana_recovery,
options = {
[1] = {
key = 'flask_mana_html',
fmt = '%s',
},
[2] = {
key = 'flask_duration_html',
fmt = '%s',
},
}
},
},
{
args = {'flask_life_html', 'flask_duration_html'},
func = core.factory.display_value{
inline = i18n.tooltips.flask_life_recovery,
options = {
[1] = {
key = 'flask_life_html',
fmt = '%s',
},
[2] = {
key = 'flask_duration_html',
fmt = '%s',
},
}
},
},
{
-- don't display for mana/life flasks
args = function(tpl_args, frame)
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.display_value{
inline = i18n.tooltips.flask_duration,
options = {
[1] = {
key = 'flask_duration_html',
fmt = '%s',
},
},
},
},
{
args = {'charges_per_use_html', 'charges_max_html'},
func = core.factory.display_value{
inline = i18n.tooltips.flask_charges_per_use,
options = {
[1] = {
key = 'charges_per_use_html',
fmt = '%s',
},
[2] = {
key = 'charges_max_html',
fmt = '%s',
},
},
},
},
{
args = {'buff_stat_text'},
func = core.factory.display_value{
options = {
[1] = {
key = 'buff_stat_text',
color = 'mod',
},
},
},
},
-- armor
{
args = {'block_html'},
func = core.factory.display_value{
options = {
[1] = {
key = 'block_html',
inline = i18n.tooltips.chance_to_block,
fmt = '%s',
hide_default = 0,
hide_default_key = 'block',
},
},
},
},
{
args = {'armour_html'},
func = core.factory.display_value{
options = {
[1] = {
key = 'armour_html',
inline = i18n.tooltips.armour,
fmt = '%s',
hide_default = 0,
hide_default_key = 'armour',
},
},
},
},
{
args = {'evasion_html'},
func = core.factory.display_value{
options = {
[1] = {
key = 'evasion_html',
inline = i18n.tooltips.evasion,
fmt = '%s',
hide_default = 0,
hide_default_key = 'evasion',
},
},
},
},
{
args = {'energy_shield_html'},
func = core.factory.display_value{
options = {
[1] = {
key = 'energy_shield_html',
inline = i18n.tooltips.energy_shield,
fmt = '%s',
hide_default = 0,
hide_default_key = 'energy_shield',
},
},
},
},
-- Amulet only
{
args = {'talisman_tier'},
func = core.factory.display_value{
options = {
[1] = {
key = 'talisman_tier',
fmt = '%i',
inline = i18n.tooltips.talisman_tier,
},
},
},
},
-- Misc
{
args = {'stack_size'},
func = core.factory.display_value{
options = {
[1] = {
key = 'stack_size',
hide_default = 1,
fmt = '%i',
inline = i18n.tooltips.stack_size,
},
},
},
},
-- Essence stuff
{
args = {'essence_tier'},
func = core.factory.display_value{
options = {
[1] = {
key = 'essence_tier',
fmt = '%i',
inline = i18n.tooltips.essence_tier,
},
},
},
},
},
-- Requirements
{
-- TODO: i18n Master name?
{
args = {'master', 'master_level_requirement'},
func = function(tpl_args, frame)
-- masters have been validated before
local data
for i, rowdata in ipairs(m_game.constants.masters) do
if tpl_args.master == rowdata.full then
data = rowdata
break
end
end
return util.html.poe_color('default', i18n.tooltips.requires, string.format('[[%s|%s %s]]', data.full, data.short_upper, tpl_args.master_level_requirement))
end
},
-- Instead of item level, show drop level if any
{
args = nil,
func = function(tpl_args, frame)
local opt = {
[1] = {
key = 'required_level_final_html',
hide_default = 1,
hide_default_key = 'required_level_final',
inline = i18n.tooltips.level_inline,
inline_color = false,
},
}
for _, attr in ipairs(m_game.constants.attributes) do
opt[#opt+1] = {
key = string.format('required_%s_html', attr['long_lower']),
hide_default = 0,
hide_default_key = string.format('required_%s', attr['long_lower']),
inline = ', %s ' .. attr['short_upper'],
inline_color = false,
}
end
local requirements = core.factory.display_value{options = opt}(tpl_args, frame)
-- return early
if requirements == nil then
return
end
requirements = string.gsub(requirements, '^, ', '')
return util.html.poe_color('default', string.format(i18n.tooltips.requires, requirements))
end,
},
},
-- Gem description
{
css_class = '-textwrap tc -gemdesc',
{
args = {'gem_description'},
func = core.factory.display_value_only('gem_description'),
},
},
-- Gem Quality Stats
{
css_class = '-textwrap tc -mod',
{
args = {'quality_stat_text'},
func = function(tpl_args, frame)
lines = {}
lines[#lines+1] = util.html.poe_color('default', i18n.tooltips.gem_quality)
lines[#lines+1] = tpl_args.quality_stat_text
return table.concat(lines, '<br>')
end,
},
},
-- Gem Implicit Stats
{
css_class = '-textwrap tc -mod',
{
args = function(tpl_args, frame)
return core.class_groups.gems.keys[tpl_args.class] and tpl_args.stat_text
end,
func = function(tpl_args, frame)
lines = {}
lines[#lines+1] = tpl_args.stat_text
if tpl_args.gem_tags:contains('Vaal') then
lines[#lines+1] = util.html.poe_color('corrupted', i18n.tooltips.corrupted)
end
return table.concat(lines, '<br>')
end,
},
},
-- Implicit Stats
{
css_class = '-textwrap tc -mod',
func = function(tpl_args, frame)
if tpl_args.implicit_stat_text ~= '' then
return {tpl_args.implicit_stat_text}
else
return {}
end
end,
},
-- Stats
{
css_class = '-textwrap tc -mod',
func = function(tpl_args, frame)
if tpl_args.explicit_stat_text ~= '' then
return {tpl_args.explicit_stat_text}
else
return {}
end
end,
},
-- Experience
{
{
args = {'experience'},
func = core.factory.display_value{
key = 'experience',
options = {
[1] = {
fmt = '%i',
},
},
},
},
},
-- Description (currency, doodads)
{
css_class = '-textwrap tc -mod',
{
args = {'description'},
func = core.factory.display_value_only('description'),
},
},
-- Variations (for doodads)
{
css_class = 'tc -mod',
{
args = {'variation_count'},
func = function(tpl_args, frame)
local txt
if tpl_args.variation_count == 1 then
txt = i18n.tooltips.variation_singular
else
txt = i18n.tooltips.variation_plural
end
return string.format('%i %s', tpl_args.variation_count, txt)
end,
},
},
-- Flavour Text
{
css_class = '-textwrap tc -flavour',
{
args = {'flavour_text'},
func = core.factory.display_value_only('flavour_text'),
},
},
-- Prophecy text
{
css_class = '-textwrap tc -value',
{
args = {'prediction_text'},
func = core.factory.display_value_only('prediction_text'),
},
},
-- Help text
{
css_class = '-textwrap tc -help',
{
args = {'help_text'},
func = core.factory.display_value_only('help_text'),
},
},
-- Cost (i.e. vendor costs)
{
--css_class = '',
{
args = {'master_favour_cost'},
func = core.factory.display_value{
options = {
[1] = {
key = 'master_favour_cost',
inline = i18n.tooltips.favour_cost,
color = 'currency',
},
},
},
},
{
args = {'seal_cost_normal', 'seal_cost_cruel', 'seal_cost_merciless'},
func = core.factory.display_value{
options = {
[1] = {
key = 'seal_cost_normal',
inline = i18n.tooltips.seal_cost,
fmt = '%dx/',
color = 'currency',
},
[2] = {
key = 'seal_cost_cruel',
fmt = '%dx/',
color = 'currency',
},
[3] = {
key = 'seal_cost_merciless',
fmt = '%dx',
color = 'currency',
inline = function (tpl_args, frame)
return '%s' .. p.item_link{item_name_exact='Silver Coin'}
end,
},
},
},
},
},
}
--
-- This is meant to show additional information about the item in a seperate infobox
--
core.extra_display_groups = {
-- Drop info
{
header = i18n.tooltips.drop_restrictions,
{
args = {'drop_enabled'},
func = core.factory.display_value{
options = {
[1] = {
key = 'drop_level',
fmt = '%i',
inline = i18n.tooltips.level,
},
[2] = {
key = 'drop_level_maximum',
hide_default = 100,
fmt = '%i',
inline = ' / %s',
},
},
},
},
{
args = {'drop_leagues'},
func = function(tpl_args, frame)
return string.format(i18n.tooltips.league_restriction, util.html.poe_color('value', table.concat(tpl_args.drop_leagues, ', ')))
end
},
{
args = function(tpl_args, frame)
if tpl_args.drop_enabled == true then
return false
end
return true
end,
func = function(tpl_args, frame)
local span = mw.html.create('span')
span
:attr('class', 'infobox-disabled-drop')
:wikitext(i18n.tooltips.drop_disabled)
:done()
return tostring(span)
end,
},
},
-- Damage per second
{
header = i18n.tooltips.damage_per_second,
-- Autoinsert here from dps map
},
}
for i, data in ipairs(core.dps_map) do
table.insert(core.extra_display_groups[2], {
args = {data.name .. '_html'},
func = core.factory.display_value{
options = {
[1] = {
key = data.name .. '_html',
inline = data.label_infobox .. ': %s',
fmt = '%s',
-- the html already contains the colour
no_color = true,
},
},
},
})
if i == 5 then
table.insert(core.extra_display_groups[2], {
args = function (tpl_args, frame)
return tpl_args.elemental_dps_html ~= nil or tpl_args.poison_dps_html ~= nil
end,
func = function (tpl_args, frame)
return ''
end,
})
elseif i == 7 then
table.insert(core.extra_display_groups[2], {
args = {'dps_html'},
func = function (tpl_args, frame)
return ''
end,
})
end
end
core.item_link_params = {'name', 'inventory_icon', 'html'}
core.result = {}
-- for sort type see:
-- https://meta.wikimedia.org/wiki/Help:Sorting
core.result.generic_item = {
{
arg = 'base_item',
header = i18n.item_table.base_item,
properties = {'Has base item', 'Has base item wiki page'},
display = function(tr, data)
tr
:tag('td')
:attr('data-sort-value', data['Has base item'])
:wikitext(string.format('[[%s|%s]]', data['Has base item'], data['Has base item wiki page']))
end,
order = 1000,
sort_type = 'text',
},
{
arg = 'class',
header = i18n.item_table.item_class,
properties = {'Has item class'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='[[%s]]',
},
}},
order = 1001,
sort_type = 'text',
},
{
arg = 'essence',
header = i18n.item_table.essence_tier,
properties = {'Has essence tier'},
display = h.tbl.display.factory.value{},
order = 2000,
},
{
arg = 'drop_level',
header = i18n.item_table.drop_level,
properties = {'Has drop level'},
display = h.tbl.display.factory.value{},
order = 3000,
},
{
arg = 'stack_size',
header = i18n.item_table.stack_size,
properties = {'Has stack size'},
display = h.tbl.display.factory.value{},
order = 4000,
},
{
arg = 'stack_size_currency_tab',
header = i18n.item_table.stack_size_currency_tab,
properties = {'Has currency tab stack size'},
display = h.tbl.display.factory.value{},
order = 4001,
},
{
arg = 'level',
header = m_game.level_requirement.icon,
properties = h.tbl.range_properties('level requirement'),
display = h.tbl.display.factory.range{property='level requirement'},
order = 5000,
},
{
arg = 'ar',
header = i18n.item_table.armour,
properties = h.tbl.range_properties('armour'),
display = h.tbl.display.factory.range{property='armour'},
order = 6000,
},
{
arg = 'ev',
header =i18n.item_table.evasion,
properties = h.tbl.range_properties('evasion'),
display = h.tbl.display.factory.range{property='evasion'},
order = 6001,
},
{
arg = 'es',
header = i18n.item_table.energy_shield,
properties = h.tbl.range_properties('energy shield'),
display = h.tbl.display.factory.range{property='energy shield'},
order = 6002,
},
{
arg = 'block',
header = i18n.item_table.block,
properties = h.tbl.range_properties('block'),
display = h.tbl.display.factory.range{property='block'},
order = 6003,
},
--[[{
arg = 'physical_damage_min',
header = util.html.abbr('Min', 'Local minimum weapon damage'),
properties = h.tbl.range_properties('minimum physical damage'),
display = h.tbl.display.factory.range{property='minimum physical damage'},
order = 7000,
},
{
arg = 'physical_damage_max',
header = util.html.abbr('Max', 'Local maximum weapon damage'),
properties = h.tbl.range_properties('maximum physical damage'),
display = h.tbl.display.factory.range{property='maximum physical damage'},
order = 7001,
},]]--
{
arg = {'weapon', 'damage'},
header = i18n.item_table.damage,
properties = {'Has damage HTML', 'Has average damage'},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['Has average damage'])
:wikitext(data['Has damage HTML'])
end,
order = 8000,
},
{
arg = {'weapon', 'aps'},
header = i18n.item_table.attacks_per_second,
properties = h.tbl.range_properties('attack speed'),
display = h.tbl.display.factory.range{property='attack speed'},
order = 8001,
},
{
arg = {'weapon', 'crit'},
header = i18n.item_table.local_critical_strike_chance,
properties = h.tbl.range_properties('critical strike chance'),
display = h.tbl.display.factory.range{property='critical strike chance'},
order = 8002,
},
{
arg = 'flask_life',
header = i18n.item_table.flask_life,
properties = h.tbl.range_properties('flask life recovery'),
display = h.tbl.display.factory.range{property='flask life recovery'},
order = 9000,
},
{
arg = 'flask_mana',
header = i18n.item_table.flask_mana,
properties = h.tbl.range_properties('flask mana recovery'),
display = h.tbl.display.factory.range{property='flask mana recovery'},
order = 9001,
},
{
arg = 'flask',
header = i18n.item_table.flask_duration,
properties = h.tbl.range_properties('flask duration'),
display = h.tbl.display.factory.range{property='flask duration'},
order = 9002,
},
{
arg = 'flask',
header = i18n.item_table.flask_charges_per_use,
properties = h.tbl.range_properties('flask charges per use'),
display = h.tbl.display.factory.range{property='flask charges per use'},
order = 9003,
},
{
arg = 'flask',
header = i18n.item_table.flask_maximum_charges,
properties = h.tbl.range_properties('maximum flask charges'),
display = h.tbl.display.factory.range{property='maximum flask charges'},
order = 9004,
},
{
arg = 'item_limit',
header = i18n.item_table.item_limit,
properties = {'Has item limit'},
display = h.tbl.display.factory.value{},
order = 10000,
},
{
arg = 'jewel_radius',
header = i18n.item_table.jewel_radius,
properties = {'Has jewel radius', 'Has jewel radius HTML'},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['Has jewel radius'])
:wikitext(data['Has jewel radius HTML'])
end,
order = 10001,
},
{
arg = 'map_tier',
header = i18n.item_table.map_tier,
properties = {'Has map tier'},
display = h.tbl.display.factory.value{},
order = 11000,
},
{
arg = 'map_level',
header = i18n.item_table.map_level,
properties = {'Has map area level'},
display = h.tbl.display.factory.value{},
order = 11010,
},
{
arg = 'map_guild_character',
header = i18n.item_table.map_guild_character,
properties = {'Has map guild character'},
display = h.tbl.display.factory.value{colour='value'},
order = 11020,
sort_type = 'text',
},
{
arg = 'buff',
header = i18n.item_table.buff_effects,
properties = {'Has buff stat text'},
display = h.tbl.display.factory.value{colour='mod'},
order = 12000,
sort_type = 'text',
},
{
arg = 'stat',
header = i18n.item_table.stats,
properties = {'Has stat text'},
display = h.tbl.display.factory.value{colour='mod'},
order = 12001,
sort_type = 'text',
},
{
arg = 'description',
header = i18n.item_table.effects,
properties = {'Has description'},
display = h.tbl.display.factory.value{colour='mod'},
order = 12002,
sort_type = 'text',
},
{
arg = 'flavour_text',
header = i18n.item_table.flavour_text,
properties = {'Has flavour text'},
display = h.tbl.display.factory.value{colour='flavour'},
order = 12003,
sort_type = 'text',
},
{
arg = 'help_text',
header = i18n.item_table.help_text,
properties = {'Has help text'},
display = h.tbl.display.factory.value{colour='help'},
order = 12004,
sort_type = 'text',
},
{
arg = 'buff_icon',
header = i18n.item_table.buff_icon,
properties = {'Has buff icon'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='[[%s]]',
},
}},
order = 13000,
sort_type = 'text',
},
}
for i, data in ipairs(core.dps_map) do
table.insert(core.result.generic_item, {
arg = data.name,
header = data.label,
properties = h.tbl.range_properties(data.property),
display = h.tbl.display.factory.range{property=data.property},
order = 8100+i,
})
end
core.result.skill_gem_new = {
{
arg = 'icon',
header = i18n.item_table.support_gem_letter,
properties = {'Has support gem letter HTML'},
display = h.tbl.display.factory.value{},
order = 1000,
sort_type = 'text',
},
{
arg = 'skill_icon',
header = i18n.item_table.skill_icon,
properties = {'Has skill gem icon'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='[[%s]]',
},
}},
order = 1001,
sort_type = 'text',
},
{
arg = 'description',
header = i18n.item_table.description,
properties = {'Has description'},
display = h.tbl.display.factory.value{},
order = 2000,
sort_type = 'text',
},
{
arg = 'level',
header = m_game.level_requirement.icon,
properties = {'Has level requirement'},
display = h.tbl.display.factory.value{},
order = 3004,
},
{
arg = 'crit',
header = i18n.item_table.skill_critical_strike_chance,
properties = {'Has critical strike chance'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='%s%%',
},
}},
order = 4000,
},
{
arg = 'cast_time',
header = i18n.item_table.cast_time,
properties = {'Has cast time'},
display = h.tbl.display.factory.value{},
order = 4001,
},
{
arg = 'dmgeff',
header = i18n.item_table.damage_effectiveness,
properties = {'Has damage effectiveness'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='%s%%',
},
}},
order = 4002,
},
{
arg = 'mcm',
header = i18n.item_table.mana_cost_multiplier,
properties = {'Has mana multiplier'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='%s%%',
},
}},
order = 5000,
},
{
arg = 'mana',
header = i18n.item_table.mana_cost,
properties = {'Has mana cost', 'Has percentage mana cost', 'Has reservation mana cost'},
display = function (tr, data)
local appendix = ''
if util.cast.boolean(data['Has percentage mana cost']) then
appendix = appendix .. '%'
end
if util.cast.boolean(data['Has reservation mana cost']) then
appendix = appendix .. ' ' .. i18n.item_table.reserves_mana_suffix
end
tr
:tag('td')
:attr('data-sort-value', data['Has mana cost'])
:wikitext(string.format('%d', data['Has mana cost']) .. appendix)
end,
order = 5001,
},
{
arg = 'vaal',
header = i18n.item_table.vaal_souls_requirement,
properties = {'Has vaal souls requirement'},
display = function (tr, data)
local souls = tonumber(data['Has vaal souls requirement'])
tr
:tag('td')
:attr('data-sort-value', souls)
:wikitext(string.format('%d / %d / %d', souls, souls*1.5, souls*2))
end,
order = 6000,
},
{
arg = 'vaal',
header = i18n.item_table.stored_uses,
properties = {'Has vaal stored uses'},
display = h.tbl.display.factory.value{},
order = 6001,
},
{
arg = 'radius',
header = i18n.item_table.primary_radius,
properties = {'Has primary radius', 'Has primary radius description'},
options = {[2] = {optional = true}},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['Has primary radius'])
:wikitext(core.factory.descriptor_value{tbl=data, key='Has primary radius description'}(nil, nil, data['Has primary radius']))
end,
order = 7000,
},
{
arg = 'radius',
header = i18n.item_table.secondary_radius,
properties = {'Has secondary radius', 'Has secondary radius description'},
options = {[2] = {optional = true}},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['Has secondary radius'])
:wikitext(core.factory.descriptor_value{tbl=data, key='Has secondary radius description'}(nil, nil, data['Has secondary radius']))
end,
order = 7001,
},
{
arg = 'radius',
header = i18n.item_table.tertiary_radius,
properties = {'Has tertiary radius', 'Has tertiary radius description'},
options = {[2] = {optional = true}},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['Has tertiary radius'])
:wikitext(core.factory.descriptor_value{tbl=data, key='Has tertiary radius description'}(nil, nil, data['Has tertiary radius']))
end,
order = 7002,
},
}
for i, attr in ipairs(m_game.constants.attributes) do
table.insert(core.result.generic_item, 7, {
arg = attr.short_lower,
header = attr.icon,
properties = h.tbl.range_properties(string.format('%s requirement', attr.long_lower)),
display = h.tbl.display.factory.range{property=string.format('%s requirement', attr.long_lower)},
order = 5000+i,
})
table.insert(core.result.skill_gem_new, 1, {
arg = attr.short_lower,
header = attr.icon,
properties = {string.format('Has %s percentage', attr.long_lower)},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data[string.format('Has %s percentage', attr.long_lower)])
:wikitext('[[File:Yes.png|yes|link=]]')
end,
order = 3000+i,
})
end
-- ----------------------------------------------------------------------------
-- Page views
-- ----------------------------------------------------------------------------
--
-- Template:Item
--
function p.itembox (frame)
--
-- Args/Frame
--
local t = os.clock()
local tpl_args = getArgs(frame, {
parentFirst = true
})
frame = util.misc.get_frame(frame)
--
-- Shared args
--
core.build_item_classes()
tpl_args._flags = {}
tpl_args._total_args = {}
tpl_args._base_item_args = {}
tpl_args._mods = {}
tpl_args._stats = {}
tpl_args._explicit_stats = {}
tpl_args._subobjects = {}
tpl_args._properties = {}
-- Using general purpose function to handle release and removal versions
util.args.version(tpl_args, {frame=frame, set_properties=true})
-- Must validate some argument early. It is required for future things
core.process_arguments(tpl_args, frame, {array=core.default_args})
core.process_arguments(tpl_args, frame, {array=core.item_classes[tpl_args.class].args})
-- set defaults
for k, v in pairs(core.item_classes[tpl_args.class].defaults) do
if tpl_args[k] == nil then
tpl_args[k] = v
end
end
-- Base Item
core.process_base_item(tpl_args, frame)
-- Prophecy special snowflake
if tpl_args.base_item == 'Prophecy' then
err = core.process_arguments(tpl_args, frame, {array=core.prophecy_args})
if err then
return err
end
tpl_args.inventory_icon = string.format(i18n.inventory_icon, 'Prophecy')
end
-- Mods
for _, k in ipairs({'implicit', 'explicit'}) do
local success = true
local i = 1
while success do
success = core.validate_mod(tpl_args, frame, {key=k, i=i})
i = i + 1
end
end
core.process_smw_mods(tpl_args, frame)
-- Add stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
util.args.stats(tpl_args, {prefix='extra_'})
for _, stat in ipairs(tpl_args.extra_stats) do
if stat.value ~= nil then
stat.min = stat.value
stat.max = stat.value
stat.avg = stat.value
end
h.stats_update(tpl_args, stat.id, stat, nil, '_stats')
h.stats_update(tpl_args, stat.id, stat, nil, '_explicit_stats')
end
-- Transpose stats into subobjects
for id, data in pairs(tpl_args._stats) do
tpl_args._subobjects[id] = {
['Has stat id'] = id,
['Has minimum stat value'] = data.min,
['Has maximum stat value'] = data.max,
['Has average stat value'] = data.avg,
}
end
for id, data in pairs(tpl_args._explicit_stats) do
tpl_args._subobjects['explicit_' .. id] = {
['Has explicit stat id'] = id,
['Has minimum stat value'] = data.min,
['Has maximum stat value'] = data.max,
['Has average stat value'] = data.avg,
}
end
-- Handle extra stats (for gems)
if core.class_groups.gems.keys[tpl_args.class] then
m_skill.skill(frame, tpl_args)
end
--
-- Handle local stats increases/reductions/additions
--
local skip = {}
-- general stats
for k, data in pairs(core.stat_map) do
local value = tpl_args[k]
if value == nil and data.default ~= nil then
value = data.default
tpl_args[k] = data.default
end
if value ~= nil and skip[k] == nil then
value = {min=value, max=value, base=value}
-- If stats are overriden we scan save some CPU time here
local overridden = false
if data.stats_override ~= nil then
for stat_id, override_value in pairs(data.stats_override) do
local stat_value = tpl_args._stats[stat_id]
if stat_value ~= nil then
-- Use the value of stat
if override_value == true then
value.min = stat_value.min
value.max = stat_value.max
overridden = true
elseif stat_value ~= 0 then
value.min = override_value.min
value.max = override_value.max
overridden = true
end
end
end
end
if overridden == false then
-- The simple cases; this must be using ipairs as "add" must apply before
for _, operator in ipairs({'add', 'more'}) do
local st = data['stats_' .. operator]
if st ~= nil then
for _, statid in ipairs(st) do
if tpl_args._stats[statid] ~= nil then
h.stat[operator](value, tpl_args._stats[statid])
end
end
end
end
-- For increased stats we need to add them up first
for stat_key, stat_func in pairs({increased=h.stat.more, increased_inverse=h.stat.more_inverse}) do
local st = data['stats_' .. stat_key]
if st ~= nil then
local total_increase = {min=0, max=0}
for _, statid in ipairs(st) do
if tpl_args._stats[statid] ~= nil then
for var, current_value in pairs(total_increase) do
total_increase[var] = current_value + tpl_args._stats[statid][var]
end
end
end
stat_func(value, total_increase)
end
end
if data.minimum ~= nil then
for _, key in ipairs({'min', 'max'}) do
if value[key] < data.minimum then
value[key] = data.minimum
end
end
end
else
end
value.avg = (value.min + value.max) / 2
-- don't add the properties unless we need to
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
tpl_args._properties[data.property .. range_data.property] = value[short_key]
end
-- process to HTML to use on list pages or other purposes
h.handle_range_args(tpl_args, frame, k, data.property, value, data.html_fmt_options or {})
end
for short_key, range_data in pairs(h.range_map) do
tpl_args[k .. range_data.var] = value[short_key]
end
end
end
-- calculate and handle weapon dps
if core.class_groups.weapons.keys[tpl_args.class] then
for _, data in ipairs(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_data in pairs(h.range_map) do
value[short_key] = 0
for _, damage_key in ipairs(data.damage_args) do
value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_data.var)] or 0)
end
end
end
local value = {}
for short_key, range_data in pairs(h.range_map) do
local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_data.var)]
value[short_key] = result
tpl_args[string.format('%s%s', data.name, range_data.var)] = result
-- It will set the property, even if 0.
-- 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
tpl_args._properties[string.format('Has %s%s', data.property, range_data.property)] = result
end
if value.avg > 0 then
h.handle_range_args(tpl_args, frame, data.name, 'Has ' .. data.property, value, data.html_fmt_options or {})
end
end
end
-- late processing
core.process_arguments(tpl_args, frame, {array=core.late_args})
core.process_arguments(tpl_args, frame, {array=core.item_classes[tpl_args.class].late_args})
-- Handle upgrade from restrictions/info
core.process_upgraded_from(tpl_args, frame)
-- Setting semantic properties Part 1 (base values)
local val
for _, k in ipairs(tpl_args._total_args) do
local prop = core.map[k].property
val = tpl_args[k]
if val == nil then
elseif prop == nil then
--mw.logObject(k)
else
tpl_args._properties[prop] = val
end
end
util.smw.set(frame, tpl_args._properties)
-- Subobjects
local command
for key, properties in pairs(tpl_args._subobjects) do
command = ''
if type(key) ~= 'number' then
command = key
end
util.smw.subobject(frame, command, properties)
end
-- ------------------------------------------------------------------------
-- Infobox handling
-- ------------------------------------------------------------------------
tpl_args._properties = {}
local extra_class = ''
local container = mw.html.create('span')
:attr( 'class', 'item-box -' .. tpl_args.frame_type)
if tpl_args.class == 'Divination Card' then
--TODO div card code
container
:tag('span')
:attr( 'class', 'divicard-wrapper')
:tag('span')
:attr('class', 'divicard-art')
:wikitext( '[[File:' .. tpl_args.card_art .. '|link=|alt=]]' )
:done()
:tag('span')
:attr('class', 'divicard-frame')
:wikitext( '[[File:Divination card frame.png|link=|alt=]]' )
:done()
:tag('span')
:attr('class', 'divicard-header')
:wikitext(tpl_args.name)
:done()
:tag('span')
:attr('class', 'divicard-stack')
:wikitext(tpl_args.stack_size)
:done()
:tag('span')
:attr('class', 'divicard-reward')
:tag('span')
:wikitext(tpl_args.card_reward)
:done()
:done()
:tag('span')
:attr('class', 'divicard-flavour text-color -flavour')
:tag('span')
:wikitext(tpl_args.flavour_text)
:done()
:done()
:done()
--TODO Extras?
else
local header_css
if tpl_args.base_item and tpl_args.rarity ~= 'Normal' then
line_type = 'double'
else
line_type = 'single'
end
local name_line = tpl_args.name
if tpl_args.base_item and tpl_args.base_item ~= 'Prophecy' then
name_line = name_line .. '<br>' .. tpl_args.base_item
end
container
:tag('span')
:attr( 'class', 'header -' .. line_type )
:wikitext( name_line )
:done()
core.display.add_to_container_from_map(tpl_args, frame, container, core.item_display_groups)
end
frame:callParserFunction('#set:', tpl_args._properties)
if tpl_args.gem_icon ~= nil then
container:wikitext(string.format('[[%s]]', tpl_args.gem_icon))
end
-- Store the infobox so it can be accessed with ease on other pages
frame:callParserFunction('#set:', {['Has infobox HTML'] = tostring(container)})
if tpl_args.inventory_icon ~= nil then
container:wikitext(string.format('[[%s]]', tpl_args.inventory_icon))
end
--
-- Secondary infobox
--
local extra_infobox = mw.html.create('span')
:attr( 'class', 'item-box -' .. tpl_args.frame_type)
core.display.add_to_container_from_map(tpl_args, frame, extra_infobox, core.extra_display_groups)
--
-- Output
--
local infobox = mw.html.create('span')
infobox
:attr('class', 'infobox-page-container')
:node(container)
:node(extra_infobox)
if tpl_args.skill_screenshot then
infobox:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
end
local out = tostring(infobox)
-- ------------------------------------------------------------------------
-- Category handling
-- ------------------------------------------------------------------------
local cats = {}
if tpl_args.rarity == 'Unique' then
cats[#cats+1] = string.format(i18n.categories.unique_affix, tpl_args.class)
elseif tpl_args.base_item == 'Prophecy' then
cats[#cats+1] = 'Prophecies'
elseif tpl_args.is_talisman then
cats[#cats+1] = 'Talismans'
else
cats[#cats+1] = tpl_args.class
end
for _, attr in ipairs(m_game.constants.attributes) do
if tpl_args[attr.long_lower .. '_percent'] then
cats[#cats+1] = string.format('%s %s', attr.long_upper, tpl_args.class)
end
end
local affix
if tpl_args.class == 'Active Skill Gems' or tpl_args.class == 'Support Skill Gems' then
affix = i18n.categories.gem_tag_affix
end
if affix ~= nil then
for _, tag in ipairs(tpl_args.gem_tags) do
cats[#cats+1] = string.format(affix, tag)
end
end
if #tpl_args.alternate_art_inventory_icons > 0 then
cats[#cats+1] = i18n.categories.alternate_artwork
end
-- TODO: add maintenance categories
if tpl_args.release_version == nil then
cats[#cats+1] = i18n.categories.missing_release_version
end
if tpl_args._flags.text_modifier then
cats[#cats+1] = i18n.categories.improper_modifiers
end
out = out .. util.misc.add_category(cats, {ingore_blacklist=tpl_args.debug})
--
--
--
mw.logObject(os.clock() - t)
return out
end
--
-- Template:Item link & Template:Sl
--
function p.item_link (frame)
--
-- Args/Frame
--
local tpl_args = getArgs(frame, {
parentFirst = true,
removeBlanks = false,
})
frame = util.misc.get_frame(frame)
-- Backwards compability
tpl_args.item_name = tpl_args.item_name or tpl_args[1]
if tpl_args.item_name ~= nil then
tpl_args.item_name = mw.ustring.lower(tpl_args.item_name)
end
tpl_args.name = tpl_args.name or tpl_args[2]
if util.table.has_all_value(tpl_args, {'page', 'item_name', 'item_name_exact'}) then
error(i18n.errors.item_link_invalid_args)
end
tpl_args.large = util.cast.boolean(tpl_args.large)
local img
local result
if util.table.has_one_value(tpl_args, core.item_link_params, nil) or tpl_args.item_name ~= nil then
local query = {}
if tpl_args.page ~= nil then
-- TODO returns the result even if the + format is specified.
query[#query+1] = string.format('[[%s]]', tpl_args.page)
else
if tpl_args.item_name ~= nil then
query[#query+1] = string.format('[[Has lowercase names::%s]]', tpl_args.item_name)
elseif tpl_args.item_name_exact ~= nil then
query[#query+1] = string.format('[[Has name::%s]]', tpl_args.item_name_exact)
end
query[#query] = query[#query] .. ' [[Has inventory icon::+]] [[Has infobox HTML::+]]'
if tpl_args.link_type == 'skill' then
query[#query] = query[#query] .. ' [[Concept:Skill gems]]'
end
end
query[#query+1] = '?Has name'
query[#query+1] = '?Has inventory icon'
query[#query+1] = '?Has infobox HTML'
query[#query+1] = '?Has alternate inventory icons'
query[#query+1] = '?Has inventory width'
query[#query+1] = '?Has inventory height'
-- attributes
result = util.smw.query(query, frame)
local err
if #result == 0 then
err = util.misc.raise_error_or_return{raise_required=true, args=tpl_args, msg=string.format(
i18n.errors.item_link_no_results,
tpl_args.page or tpl_args.item_name or tpl_args.item_name_exact
)}
elseif #result > 1 then
err = util.misc.raise_error_or_return{raise_required=true, args=tpl_args, msg=string.format(
i18n.errors.item_link_too_many_results,
tpl_args.page or tpl_args.item_name or tpl_args.item_name_exact
)}
end
if err ~= nil then
return err .. i18n.categories.broken_item_links
end
result = result[1]
else
result = {tpl_args.page or tpl_args.item_name_exact}
end
for _, k in ipairs(core.item_link_params) do
local prop = core.map[k].property
if tpl_args[k] ~= nil then
result[prop] = tpl_args[k]
end
end
if tpl_args.image ~= nil then
if result['Has alternate inventory icons'] == '' then
return util.misc.raise_error_or_return{raise_required=true, args=tpl_args, msg=string.format(
i18n.errors.item_link_alt_art_undefined,
result[1]
) .. i18n.categories.broken_item_links}
end
result['Has alternate inventory icons'] = util.string.split(result['Has alternate inventory icons'], '<MANY>')
local index = tonumber(tpl_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
if string.sub(filename, prefix, -suffix) == tpl_args.image then
img = filename
break
end
end
end
if img == nil then
return util.misc.raise_error_or_return{raise_required=true, args=tpl_args, msg=string.format(
i18n.errors.item_link_alt_art_invalid_index,
tpl_args.image, result[1]
) .. i18n.categories.broken_item_links}
end
elseif result['Has inventory icon'] ~= '' then
img = result['Has inventory icon']
end
-- output
local container = mw.html.create('span')
container:attr('class', 'c-item-hoverbox inline-infobox-container')
local activator = mw.html.create('span')
activator:attr('class', 'c-item-hoverbox__activator')
if not tpl_args.large then
activator:wikitext(string.format('[[%s|link=%s]]', img, result[1]))
end
activator:wikitext(string.format('[[%s|%s]]', result[1], result['Has name'] or result[1]))
local display = mw.html.create('span')
display:attr('class', 'c-item-hoverbox__display inline-infobox-hover')
if result['Has infobox HTML'] ~= '' then
display
:wikitext(result['Has infobox HTML'])
:wikitext(string.format('[[%s|link=%s]]', img, result[1]))
:done()
end
if tpl_args.large then
local width = tonumber(result['Has inventory width']) or tonumber(tpl_args.width)
local height = tonumber(result['Has inventory height']) or tonumber(tpl_args.height)
if width and height then
img = string.format('[[%s|%sx%spx|link=%s]]', img, width*c.image_size, height*c.image_size, result[1])
elseif width then
img = string.format('[[%s|%spx|link=%s]]', img, width*c.image_size, result[1])
elseif height then
img = string.format('[[%s|x%spx|link=%s]]', img, height*c.image_size, result[1])
else
img = string.format('[[%s|link=%s]]', img, result[1])
end
activator:wikitext(img)
end
container
:node(activator)
:node(display)
:done()
return tostring(container)
end
--
-- Template:Il
--
function p.item_link_compability (frame)
if util.misc.is_frame(frame) then
frame.args.raise = true
else
frame.raise = true
end
local result
local status, err = pcall(function ()
result = p.item_link(frame)
end)
mw.logObject(err)
if status then
return result
elseif string.match(err, ".*Too many results.*") then
return err .. i18n.categories.broken_item_links
else
return require('Module:Item').itemLink(frame)
end
end
-- ----------------------------------------------------------------------------
-- Result formatting templates for SMW queries
-- ----------------------------------------------------------------------------
--
-- Template:
--
function p.simple_item_list_row(frame)
-- Args
local tpl_args = getArgs(frame, {
parentFirst = true
})
frame = util.misc.get_frame(frame)
--
local args = util.string.split_args(tpl_args.userparam, {sep=', '})
tpl_args.userparam = args
local link = p.item_link{page=tpl_args[1], name=tpl_args['?Has name'], inventory_icon=tpl_args['?Has inventory icon'] or '', html=tpl_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(i18n.errors.generic_argument_parameter, 'format', args.format))
end
end
-- ----------------------------------------------------------------------------
-- Reponsibile for subtemplates of Template:SMW item table
--
-- =p.item_table{mode='item', stat_column1_format='%s%%', conditions='[[Has item class::+]] [[Has subobject.Has stat id::~additional_*dexterity*]] [[Has rarity::Unique]]', stat_column1_header='Dexterity', stat_column1_stat_format='add', stat_column1_format='Test %s', stat_column1_stat1_id='additional_dexterity', stat_column1_stat2_id='additional_strength_and_dexterity'}
-- =p.item_table{mode='skill'}
function p.item_table(frame)
-- args
local tpl_args = getArgs(frame, {
parentFirst = true
})
frame = util.misc.get_frame(frame)
local modes = {
skill = {
data = core.result.skill_gem_new,
header = i18n.item_table.skill_gem,
},
item = {
data = core.result.generic_item,
header = i18n.item_table.item,
},
}
if tpl_args.mode == nil then
tpl_args.mode = 'item'
end
if modes[tpl_args.mode] == nil then
error(i18n.errors.invalid_item_table_mode)
end
local row_infos = {}
for _, row_info in ipairs(modes[tpl_args.mode].data) do
local enabled = false
if row_info.arg == nil then
enabled = true
elseif type(row_info.arg) == 'string' and util.cast.boolean(tpl_args[row_info.arg]) then
enabled = true
elseif type(row_info.arg) == 'table' then
for _, argument in ipairs(row_info.arg) do
if util.cast.boolean(tpl_args[argument]) then
enabled = true
break
end
end
end
if enabled then
row_info.options = row_info.options or {}
row_infos[#row_infos+1] = row_info
end
end
-- Parse stat arguments
local stat_columns = {}
local query_stats = {}
local stat_results = {}
local i = 0
repeat
i = i + 1
local prefix = string.format('stat_column%s_', i)
local col_info = {
header = tpl_args[prefix .. 'header'] or tostring(i),
format = tpl_args[prefix .. 'format'],
stat_format = tpl_args[prefix .. 'stat_format'] or 'separate',
order = tonumber(tpl_args[prefix .. 'order']) or (10000000 + i),
stats = {},
options = {},
}
local j = 0
repeat
j = j +1
local stat_info = {
id = tpl_args[string.format('%sstat%s_id', prefix, j)],
}
if stat_info.id then
col_info.stats[#col_info.stats+1] = stat_info
query_stats[stat_info.id] = {}
else
-- Stop iteration entirely if this was the first index but no stat was supplied. We assume that we stop in this case.
if j == 1 then
i = nil
end
-- stop iteration
j = nil
end
until j == nil
-- Don't add this column if no stats were provided.
if #col_info.stats > 0 then
stat_columns[#stat_columns+1] = col_info
end
until i == nil
for _, col_info in ipairs(stat_columns) do
local row_info = {
--arg
header = col_info.header,
properties = {},
display = function(tr, data, properties)
if col_info.stat_format == 'separate' then
local stat_texts = {}
local num_stats = 0
local vmax = 0
for _, stat_info in ipairs(col_info.stats) do
num_stats = num_stats + 1
-- stat results from outside body
local stat = (stat_results[data[1]] or {})[stat_info.id]
if stat ~= nil then
stat_texts[#stat_texts+1] = h.format_value(tpl_args, frame, stat, {no_color=true})
vmax = vmax + stat.max
end
end
if num_stats ~= #stat_texts then
tr:wikitext(util.html.td.na())
else
local text
if col_info.format then
text = string.format(col_info.format, unpack(stat_texts))
else
text = table.concat(stat_texts, ', ')
end
tr:tag('td')
:attr('data-sort-value', vmax)
:attr('class', 'tc -mod')
:wikitext(text)
end
elseif col_info.stat_format == 'add' then
local total_stat = {
min = 0,
max = 0,
avg = 0,
}
for _, stat_info in ipairs(col_info.stats) do
local stat = (stat_results[data[1]] or {})[stat_info.id]
if stat ~= nil then
for k, v in pairs(total_stat) do
total_stat[k] = v + stat[k]
end
end
end
if col_info.format == nil then
col_info.format = '%s'
end
tr:tag('td')
:attr('data-sort-value', total_stat.max)
:attr('class', 'tc -mod')
:wikitext(string.format(col_info.format, h.format_value(tpl_args, frame, total_stat, {no_color=true})))
else
error(string.format(i18n.errors.generic_argument_parameter, 'stat_format', col_info.stat_format))
end
end,
order = col_info.order,
}
table.insert(row_infos, row_info)
end
-- sort the rows
table.sort(row_infos, function (a, b)
return (a.order or 0) < (b.order or 0)
end)
-- Parse query arguments
local query = {tpl_args.conditions}
for key, value in pairs(tpl_args) do
if string.sub(key, 0, 2) == 'q_' then
query[string.sub(key, 3)] = value
end
end
--Override and set defaults
query.limit = 1000
-- Set required fields
query[#query+1] = '?Has name#'
query[#query+1] = '?Has iventory icon#'
query[#query+1] = '?Has infobox HTML#'
query[#query+1] = '?Has inventory width#'
query[#query+1] = '?Has inventory height#'
for _, rowinfo in ipairs(row_infos) do
if type(rowinfo.properties) == 'function' then
rowinfo.properties = rowinfo.properties()
end
for index, property in ipairs(rowinfo.properties) do
rowinfo.options[index] = rowinfo.options[index] or {}
query[#query+1] = '?' .. property .. '#'
end
end
local results = util.smw.query(query, frame)
if #results == 0 and tpl_args.default ~= nil then
return tpl_args.default
end
if #stat_columns > 0 then
local continue = true
local offset = 0
while continue do
query = {string.format('[[-Has subobject::<q>%s</q>]] [[Has stat id::+]]', tpl_args.conditions)}
query[#query+1] = '?Has average stat value#'
query[#query+1] = '?Has maximum stat value#'
query[#query+1] = '?Has minimum stat value#'
query[#query+1] = '?Has stat id#'
query.limit = 1000
query.offset = 0
local temp = util.smw.query(query, frame)
for _, row in ipairs(temp) do
if query_stats[row['Has stat id']] ~= nil then
local stat = {
min = tonumber(row['Has minimum stat value']),
max = tonumber(row['Has maximum stat value']),
avg = tonumber(row['Has average stat value']),
}
local page = util.string.split(row[1], '#')[1]
if stat_results[page] == nil then
stat_results[page] = {[row['Has stat id']] = stat}
else
stat_results[page][row['Has stat id']] = stat
end
end
end
-- stop iteration if we didn't hit the query limit
if #temp == 1000 then
offset = offset + 1000
else
continue = false
end
end
end
local tbl = mw.html.create('table')
tbl:attr('class', 'wikitable sortable item-table')
-- Header
local tr = tbl:tag('tr')
tr
:tag('th')
:wikitext(modes[tpl_args.mode].header)
:done()
for _, row_info in ipairs(row_infos) do
tr
:tag('th')
:attr('data-sort-type', row_info.sort_type or 'number')
:wikitext(row_info.header)
:done()
end
for _, row in ipairs(results) do
tr = tbl:tag('tr')
local il_args = {
page=row[1],
name=row['Has name'],
inventory_icon=row['Has inventory icon'],
html=row['Has infobox HTML'],
width=row['Has inventory width'],
height=row['Has inventory height'],
}
if tpl_args.large then
il_args.large = tpl_args.large
end
tr
:tag('td')
:wikitext(p.item_link(il_args))
:done()
for _, rowinfo in ipairs(row_infos) do
-- this has been cast from a function in an earlier step
local display = true
for index, property in ipairs(rowinfo.properties) do
-- this will bet set to an empty value not nil confusingly
if row[property] == '' then
if rowinfo.options[index].optional ~= true then
display = false
break
else
row[property] = nil
end
end
end
if display then
rowinfo.display(tr, row, rowinfo.properties)
else
tr:wikitext(util.html.td.na())
end
end
end
return tostring(tbl)
end
item_table_factory = {}
function item_table_factory.intro(args)
-- args:
-- data_array
-- header
return function (frame)
-- Args
local tpl_args = getArgs(frame, {
parentFirst = true
})
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
return '<table class="wikitable sortable item-table">' .. tostring(tr)
end
end
-- ----------------------------------------------------------------------------
-- Item lists
-- ----------------------------------------------------------------------------
function p.skill_gem_list_by_gem_tag(frame)
-- Args
local tpl_args = getArgs(frame, {
parentFirst = true
})
frame = util.misc.get_frame(frame)
if tpl_args.class == 'Support Skill Gems' then
elseif tpl_args.class == 'Active Skill Gems' then
else
error(i18n.errors.invalid_item_class)
end
local query = {}
query[#query+1] = string.format('[[Has item class::%s]]', tpl_args.class)
query[#query+1] = '?Has gem tags'
query[#query+1] = '?Has name'
query[#query+1] = '?Has inventory icon'
--query[#query+1] = '?Has infobox HTML'
query.limit = 5000
query.sort = 'Has name'
local results = util.smw.query(query, frame)
local tags = {}
for _, row in ipairs(results) do
row['Has gem tags'] = util.string.split(row['Has gem tags'], '<MANY>')
for _, tag in ipairs(row['Has gem tags']) do
if tags[tag] == nil then
tags[tag] = {}
end
table.insert(tags[tag], row)
end
end
local tags_sorted = {}
for tag, _ in pairs(tags) do
table.insert(tags_sorted, tag)
end
table.sort(tags_sorted)
local tbl = mw.html.create('table')
tbl
:attr('class', 'wikitable sortable')
:tag('tr')
:tag('th')
:wikitext('Tag')
:done()
:tag('th')
:wikitext('Skills')
:done()
:done()
for _, tag in ipairs(tags_sorted) do
local rows = tags[tag]
local tr = tbl:tag('tr')
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
return tostring(tbl)
end
-- ----------------------------------------------------------------------------
-- Misc. Item templates
-- ----------------------------------------------------------------------------
--
-- Template:Item class
--
function p.item_class (frame)
-- Get args
local tpl_args = getArgs(frame, {
parentFirst = true
})
frame = util.misc.get_frame(frame)
if not doInfoCard then
doInfoCard = require('Module:Infocard')._main
end
util.cast.factory.table('name', {key='full', tbl=m_game.constants.item.class})(tpl_args, frame)
if tpl_args.name_list ~= nil then
tpl_args.name_list = util.string.split(tpl_args.name_list, ', ')
else
tpl_args.name_list = {}
end
--
local ul = mw.html.create('ul')
for _, item in ipairs(tpl_args.name_list) do
ul
:tag('li')
:wikitext(item)
:done()
end
-- Output Infocard
local tplargs = {
['header'] = tpl_args.name,
['subheader'] = i18n.item_class_infobox.page .. i18n.item_class_infobox.info,
[1] = i18n.item_class_infobox.also_referred_to_as .. tostring(ul),
}
-- cats
local cats = {
'Item classes',
tpl_args.name,
}
-- Done
return doInfoCard(tplargs) .. util.misc.add_category(cats, {ingore_blacklist=tpl_args.debug})
end
-- ----------------------------------------------------------------------------
-- Debug stuff
-- ----------------------------------------------------------------------------
p.debug = {}
function p.debug.show_range_vars ()
for _, prop in ipairs({'HTML', 'range text', 'range colour'}) do
for var, data in pairs(core.stat_map) do
mw.logObject(string.format('%s %s', data.property, prop))
end
for _, data in ipairs(core.dps_map) do
mw.logObject(string.format('Has %s %s', data.property, prop))
end
end
end
function p.debug._tbl_data(tbl)
keys = {}
for _, data in ipairs(core.result.generic_item) do
if type(data.arg) == 'string' then
keys[data.arg] = 1
elseif type(data.arg) == 'table' then
for _, arg in ipairs(data.arg) do
keys[arg] = 1
end
end
end
local out = {}
for key, _ in pairs(keys) do
out[#out+1] = string.format("['%s'] = '1'", key)
end
return table.concat(out, ', ')
end
function p.debug.generic_item_all()
return p.debug._tbl_data(core.result.generic_item)
end
function p.debug.skill_gem_all()
return p.debug._tbl_data(core.result.skill_gem_new)
end
return p