Module:Item2
This module is used on 13,000+ pages.
To avoid major disruption and server load, do not make unnecessary edits to this module. Test changes to this module first using its /sandbox and /testcases subpages . All of the changes can then be applied to this module in a single edit.
Consider discussing changes on the talk page or on Discord before implementing them.
This module depends on the following other modules:
The module implements {{item}}.
Overview
This module is responsible for creating item boxes, various item lists, item links and other item-related tasks. In the process a lot of the input data is verified and also added as semantic property to pages; as such, any templates deriving from this module should not be used on user pages other then for temporary testing purposes.
This template is also backed by an export script in PyPoE which can be used to export item data from the game files which then can be used on the wiki. Use the export when possible. de:Modul:Item2 ru:Модуль:Item2
The above documentation is transcluded from Module:Item2/doc.
Editors can experiment in this module's sandbox and testcases pages.
Subpages of this module.
Editors can experiment in this module's sandbox and testcases pages.
Subpages of this module.
-- SMW reworked item module
-- TODO:
-- included mods and base items should override the internal values and then set them as semantic properties so items can be queried for
-- > subobjects/property in display code
-- drop location (+drop difficulty) support
-- divinatation card support
--
-- TODO: description, stack_size_currency_tab, cosmetic_type
--
-- ----------------------------------------------------------------------------
-- Imports
-- ----------------------------------------------------------------------------
local xtable = require('Module:Table')
local util = require('Module:Util')
local getArgs = require('Module:Arguments').getArgs
local game = require('Module:Game')
local m_skill = require('Module:Skill')
local p = {}
local v = {}
local g_frame, g_args
-- ----------------------------------------------------------------------------
-- Other stuff
-- ----------------------------------------------------------------------------
local h = {}
function h.new_color(label, text)
if text == nil or text == '' then
return nil
end
return tostring(mw.html.create('span')
:attr('class', 'text-' .. label)
:wikitext(text))
end
-- ----------------------------------------------------------------------------
-- core
-- ----------------------------------------------------------------------------
local core = {}
function core.validate_mod(args)
local value = g_args[args.key .. args.i]
local out = {
result=nil,
type=args.key,
is_text=false,
}
if value ~= nil then
--semantic search
local query = {
string.format('[[Is mod::%s]]', value),
'?#=Page',
'?Is Mod#',
'?Has mod group#',
'?Has mod type#',
'?Has stat text#',
}
out.result = util.smw.query(query, g_frame)
if out.result == nil or #out.result == 0 then
error(string.format('Mod "%s" found', value))
end
out.result = out.result[1]
query = {
string.format('[[-Has subobject::%s]]', out.result[1]),
'?Is stat number#',
'?Has stat id#',
'?Has minimum stat value#',
'?Has maximum stat value#',
}
out.result.stats = util.smw.query(query, g_frame)
table.insert(g_args._subobjects, {
['Is mod number'] = args.i,
['Has mod id'] = g_args[value],
})
-- process and cache stats
local id, min, max
for _, stat in ipairs(out.result.stats) do
id = stat['Has stat id']
min = tonumber(stat['Has minimum stat value'])
max = tonumber(stat['Has maximum stat value'])
if g_args._stats[id] == nil then
g_args._stats[id] = {
references = #out+1,
min = min,
max = max,
}
else
table.insert(g_args._stats[id].references, #out+1)
g_args._stats[id].min = g_args._stats[id].min + min
g_args._stats[id].max = g_args._stats[id].max + max
end
end
else
value = g_args[args.key .. args.i .. '_text']
if value ~= nil then
table.insert(g_args._subobjects, {
['Is mod number'] = args.i,
['Has mod text'] = value,
})
out.is_text = true
out.result = value
end
end
if out.result ~= nil then
table.insert(g_args._mods, out)
return true
else
return false
end
end
function core.err(args)
local err = mw.html.create('div')
err
:attr('style', 'font-color: red; font-weight: bold;')
:wikitext(args.msg or ('Argument ' .. args.key .. ' to item template is invalid. Please check the documention for acceptable values.'))
:done()
return tostring(err)
end
--
-- function factory
--
core.factory = {}
function core.factory.array_table_cast(k, args)
-- Arguments:
--
-- tbl
-- errmsg
return function ()
local elements
if g_args[k] ~= nil then
elements = util.string.split(g_args[k], ', ')
for _, element in ipairs(elements) do
local r = util.table.find_in_nested_array{value=element, tbl=args.tbl, key='full'}
if r == nil then
error(core.err{msg=string.format(args.errmsg, element)})
end
end
g_args[k] = xtable:new(elements)
end
end
end
function core.factory.table_cast(k, args)
return function ()
args.value = g_args[k]
g_args[k] = util.table.find_in_nested_array(args)
if g_args[k] == nil then
error(core.err{key=k})
end
end
end
function core.factory.number_cast(k, default)
return function ()
g_args[k] = tonumber(g_args[k]) or default
end
end
function core.factory.boolean_cast(k, default)
return function()
if g_args[k] == nil then
g_args[k] = default
else
g_args[k] = util.cast.boolean(g_args[k])
end
end
end
function core.factory.percentage(k)
return function ()
local v = tonumber(g_args[k])
if v == nil then
return core.err{key=k}
end
if v < 0 or v > 100 then
return core.err{msg=k .. ' must be in range 0-100.'}
end
g_args[k] = v
end
end
function core.factory.display_mods(args)
return function ()
lines = {}
for _, modinfo in ipairs(g_args._mods) do
if modinfo.type == args.type then
if modinfo.is_text then
table.insert(lines, modinfo.result)
else
table.insert(lines, modinfo.result['Has stat text'])
end
end
end
if #lines > 0 and args.type == 'quality' then
table.insert(lines, h.new_color('default', 'Per 1% Quality:'), 1)
end
return lines
end
end
function core.factory.display_value(args)
-- TODO: sane defaults for the prepend string "before" & after arguments
--
-- args:
-- args<Array>: Array of arguments to use for displaying
-- values<Array>: Array of base values to use for displaying; useful if no args are present
-- options<Array>:
-- fmt: formatter to use for the value instead of valfmt
-- allow_zero: allow zero values
-- before: add this string before the coloured string with colour gray
-- after: add this string after the coloured string with colour gray
-- stats_add: Array of stats to add
-- stats_multiplay: Array of stats to multiply
-- func: Function to adjust the value with before output
-- gem_hide_static: function to hide a static value for gem display type
local _map = {
add = function (value, stat_cached)
value.min = value.min + stat_cached.min
value.max = value.max + stat_cached.max
end,
multiply = function (value, stat_cached)
value.min = value.min * stat_cached.min / 100
value.max = value.max * stat_cached.max / 100
end,
}
for k, default in pairs({stats = {}, options = {}}) do
if args[k] == nil then
args[k] = default
end
end
local size
if args.keys ~= nil then
size = #args.keys
elseif args.values ~= nil then
size = #args.values
end
if size then
for i=1, size do
if args.options[i] == nil then
args.options[i] = {}
end
end
else
error('invalid data')
end
return function ()
local values = {}
local final_values = {}
if args.type == 'gem' then
if not core.class_groups.gems.keys:contains(g_args.class) then
return
end
for i, k in ipairs(args.keys) do
local value = g_args['static_' .. k]
if value ~= nil then
if args.options[i].gem_hide_static ~= nil and args.options[i].gem_hide_static(value) then
return
end
values[#values+1] = value
final_values[#final_values+1] = {value={min=value,max=value}, index=#values}
else
value = {
min=g_args[string.format('level1_%s', k)],
max=g_args[string.format('level%s_%s', g_args.max_level, k)],
}
if value.min ~= nil and value.max ~= nil then
values[#values+1] = value.min
final_values[#final_values+1] = {value=value, index=#values}
end
end
end
else
if args.values == nil then
values = {}
for i, k in ipairs(args.keys) do
local value = g_args[k]
if g_args.base_item then
value = tonumber(g_args.base_item[core.map[k].property]) or value
end
values[i] = value
end
else
values = args.values
end
final_values = {}
for i, base_value in ipairs(values) do
local value = {min=base_value, max=base_value}
for _, operator in ipairs({'add', 'multiply'}) do
local st = args.options[i]['stats_' .. operator]
if st ~= nil then
for _, statid in ipairs(st) do
if g_args._stats[statid] ~= nil then
_map[operator](value, g_args._stats[statid])
end
end
end
end
local prop = args.options[i].property
if prop ~= nil and not (value.min == 0 and value.max == 0) then
g_args._properties[prop .. ' range minimum'] = value.min
g_args._properties[prop .. ' range maximum'] = value.max
g_args._properties[prop .. ' range avarage'] = (value.min + value.max) / 2
end
if not (value.min == 0 and value.max == 0 and args.options[i].allow_zero == nil) then
table.insert(final_values, {value=value, index=i})
end
end
end
-- all zeros = dont display and return early
if #final_values == 0 then
return nil
end
local out = {}
if args.before then
out[#out+1] = h.new_color('default', args.before)
end
for i, data in ipairs(final_values) do
local value = data.value
local base_value = values[data.index]
local fmt = args.options[data.index]
if not args.type == 'gem' and (base_value ~= value.min or base_value ~= value.max) then
value.color = 'mod'
else
value.color = 'value'
end
if fmt.func ~= nil then
value.min = fmt.func(value.min)
value.max = fmt.func(value.max)
end
if fmt.fmt == nil then
fmt.fmt = '%s'
elseif type(fmt.fmt) == 'function' then
fmt.fmt = fmt.fmt()
end
if value.min == value.max then
value.out = string.format(fmt.fmt, value.min)
else
value.out = string.format(string.format("(%s to %s)", fmt.fmt, fmt.fmt), value.min, value.max)
end
value.out = h.new_color(value.color, value.out)
local before = ''
if type(fmt.before) == 'string' then
before = h.new_color('default', fmt.before)
elseif type(fmt.before) == 'function' then
before = h.new_color('default', fmt.before())
end
local after = ''
if type(fmt.after) == 'string' then
after = h.new_color('default', fmt.after)
elseif type(fmt.after) == 'function' then
after = h.new_color('default', fmt.after())
end
out[#out+1] = before .. value.out .. after
end
if args.after then
out[#out+1] = h.new_color('default', args.after)
end
return table.concat(out, ' ')
end
end
function core.factory.display_value_only(key)
return function()
return g_args[key]
end
end
--
-- argument mapping
--
core.map = {
-- special params
html = {
property = 'Has infobox HTML',
func = nil,
},
-- generic
class = {
property = 'Has item class',
func = core.factory.table_cast('class', {key='full', tbl=game.constants.item.class}),
},
rarity = {
property = 'Has rarity',
func = core.factory.table_cast('rarity', {key={'full', 'long_lower'}, tbl=game.constants.item.rarity, rtrkey='full'}),
},
name = {
property = 'Has name',
func = nil,
},
size_x = {
property = 'Has inventory width',
func = core.factory.number_cast('size_x'),
},
size_y = {
property = 'Has inventory height',
func = core.factory.number_cast('size_y'),
},
drop_enabled = {
property = 'Is drop enabled',
func = core.factory.boolean_cast('drop_enabled', true),
},
drop_level = {
property = 'Has drop level',
func = core.factory.number_cast('drop_level'),
},
required_level = {
property = 'Has level requirement',
func = core.factory.number_cast('required_level'),
},
required_dexterity = {
property = 'Has base dexterity requirement',
func = core.factory.number_cast('required_dexterity'),
},
required_strength = {
property = 'Has base strength requirement',
func = core.factory.number_cast('required_strength'),
},
required_intelligence = {
property = 'Has base intelligence requirement',
func = core.factory.number_cast('required_intelligence'),
},
inventory_icon = {
property = 'Has inventory icon',
func = function ()
-- TODO readd support if needed.
g_args['inventory_icon'] = string.format('File:%s inventory icon.png', g_args.name)
end,
},
help_text = {
property = 'Has help text',
func = nil,
},
flavour_text = {
property = 'Has flavour text',
func = nil,
},
tags = {
property = 'Has tags',
func = core.factory.array_table_cast('tags', {
tbl = game.constants.tags,
errmsg = '%s is not a valid tag',
}),
},
metadata_id = {
property = 'Has metadata id',
func = nil,
},
-- For rarity != normal, rarity already verified
base_item = {
property = 'Has base item',
func = function ()
if g_args['rarity'] ~= 'Normal' then
local query = {
string.format('[[Has name::%s]]', g_args['base_item']),
string.format('[[Has item class::%s]]', g_args['class']),
'[[Has rarity::normal]]',
}
for _, k in ipairs(g_args['total_args']) do
query[#query+1] = string.format('?%s#', core.map[k].property)
end
local result = util.smw.query(query, g_frame)
if #result > 1 then
error(core.err{msg='More then one result found for the specified base item.'})
-- TODO be more explicit in the error?
end
g_args['base_item'] = result
-- TODO Semantic search - verify ?
elseif g_args['base_item'] ~= nil then
error(core.err{msg='Base item requries item with rarity above normal.'})
end
end,
},
--
-- specific section
--
-- flasks
charges_max = {
property = 'Has base maximum flask charges',
func = core.factory.number_cast('charges_max'),
},
charges_per_use = {
property = 'Has base flask charges per use',
func = core.factory.number_cast('changes_per_use'),
},
flask_mana = {
property = 'Has base flask mana recovery',
func = core.factory.number_cast('flask_mana'),
},
flask_life = {
property = 'Has base flask life recovery',
func = core.factory.number_cast('flask_life'),
},
flask_duration = {
property = 'Has base flask duration',
func = core.factory.number_cast('flask_duration'),
},
-- weapons & active skills
critical_strike_chance = {
property = 'Has base critical strike chance',
func = core.factory.number_cast('critical_strike_chance'),
},
-- weapons
attack_speed = {
property = 'Has base attack speed',
func = core.factory.number_cast('attack_speed'),
},
damage_min = {
property = 'Has base minimum damage',
func = core.factory.number_cast('damage_min'),
},
damage_max = {
property = 'Has base maximum damage',
func = core.factory.number_cast('damage_max'),
},
range = {
property = 'Has base weapon range',
func = core.factory.number_cast('range'),
},
-- armor-type stuff
armour = {
property = 'Has base armour',
func = core.factory.number_cast('armour', 0),
},
energy_shield = {
property = 'Has base energy shield',
func = core.factory.number_cast('energy shield', 0),
},
evasion = {
property = 'Has base evasion',
func = core.factory.number_cast('evasion', 0),
},
-- shields
block = {
property = 'Has base block chance',
func = core.factory.number_cast('block'),
},
-- skill gem stuff
gem_description = {
property = 'Has description',
func = nil,
},
dexterity_percent = {
property = 'Has dexterity percentage',
func = core.factory.percentage('dexterity_percent'),
},
strength_percent = {
property = 'Has strength percentage',
func = core.factory.percentage('strength_percent'),
},
intelligence_percent = {
property = 'Has intelligence percentage',
func = core.factory.percentage('intelligence_percent'),
},
gem_tags = {
property = 'Has gem tag',
func = core.factory.array_table_cast('gem_tags', {
tbl = game.constants.item.gem_tags,
errmsg = '%s is not a valid tag',
}),
},
experience = {
property = 'Has maximum experience',
func = core.factory.percentage('experience'),
},
skill_screenshot = {
property = 'Has skill screenshot',
func = function ()
g_args.skill_screenshot = string.format('File:%s skill screenshot.jpg', g_args.name)
end,
},
-- Active gems only
gem_icon = {
property = 'Has skill gem icon',
func = function ()
-- TODO readd support if needed.
g_args.gem_icon = string.format('File:%s skill icon.png', g_args.name)
end,
},
-- Support gems only
support_gem_letter_html = {
property = 'Has support gem letter HTML',
func = function ()
if g_args.support_gem_letter == nil then
return
end
-- TODO replace this with a loop possibly
local css_map = {
strength = 'red',
intelligence = 'blue',
dexterity = 'green',
}
local id
for k, v in pairs(css_map) do
k = string.format('%s_percent', k)
if g_args[k] and g_args[k] > 50 then
id = v
break
end
end
if id ~= nil then
local container = mw.html.create('span')
container
:attr('class', string.format('support-gem-id-%s', id))
:wikitext(g_args.support_gem_letter)
:done()
g_args.support_gem_letter_html = tostring(container)
end
end,
},
-- Maps
map_level = {
property = 'Has map level',
func = core.factory.number_cast('map_level'),
},
-- TODO: aren't these given by mods ... removeable?
map_item_quantity = {
property = 'Has base map item quantity',
func = core.factory.number_cast('map_item_quantity'),
},
map_item_rarity = {
property = 'Has base map item rarity',
func = core.factory.number_cast('map_item_rarity'),
},
map_pack_size = {
property = 'Has base map pack size',
func = core.factory.number_cast('map_pack_size'),
},
-- Currency-like items
stack_size = {
property = 'Has stack size',
func = core.factory.number_cast('stack_size'),
},
stack_size_currency_tab = {
property = 'Has currency tab stack size',
func = core.factory.number_cast('stack_size_currency_tab'),
},
description = {
property = 'Has description',
func = nil,
},
cosmetic_type = {
property = 'Has cosmetic type',
func = nil,
},
}
-- base item is default, but will be validated later
core.default_args = {'class', 'rarity', 'name', 'size_x', 'size_y', 'drop_enabled', 'drop_level', 'required_level', 'required_dexterity', 'required_intelligence', 'required_strength', 'inventory_icon', 'flavour_text', 'help_text', 'tags', 'metadata_id'}
core.class_groups = {
flasks = {
keys = xtable:new({'Life Flasks', 'Mana Flasks', 'Hybrid Flasks', 'Utility Flasks', 'Critical Utility Flasks'}),
args = {'flask_duration', 'charges_max', 'charges_per_use'},
},
weapons = {
keys = xtable:new({'Claws', 'Daggers', 'Wands', 'One Hand Swords', 'Thrusting One Hand Swords', 'One Hand Axes', 'One Hand Maces', 'Bows', 'Staves', 'Two Hand Swords', 'Two Hand Axes', 'Two Hand Maces', 'Sceptres'}),
args = {'critical_strike_chance', 'attack_speed', 'damage_min', 'damage_max', 'range'},
},
gems = {
keys = xtable:new({'Active Skill Gems', 'Support Skill Gems'}),
args = {'dexterity_percent', 'strength_percent', 'intelligence_percent', 'gem_tags'},
},
armor = {
keys = xtable:new({'Gloves', 'Boots', 'Body Armours', 'Helmets', 'Shields'}),
args = {'armour', 'energy_shield', 'evasion'},
},
stackable = {
keys = xtable:new({'Currency', 'Stackable Currency', 'Hideout Doodads', 'Microtransactions', 'Divination Card'}),
args = {'stack_size', 'stack_size_currency_tab', 'description', 'cosmetic_type'},
},
}
core.class_specifics = {
['Life Flasks'] = {
args = {'flask_life'},
},
['Mana Flasks'] = {
args = {'flask_mana'},
},
['Hybrid Flasks'] = {
args = {'flask_life', 'flask_mana'},
},
['Active Skill Gems'] = {
args = {'skill_screenshot', 'gem_icon'},
defaults = {
help_text = 'Place into an item socket of the right colour to gain this skill. Right click to remove from a socket.',
size_x = 1,
size_y = 1,
},
},
['Support Skill Gems'] = {
args = {'support_gem_letter_html'},
defaults = {
help_text = 'This is a Support Gem. It does not grant a bonus to your character, but skills in sockets connected to it. Place into an item socket connected to a socket containing the Active Skill Gem you wish to augment. Right click to remove from a socket.',
size_x = 1,
size_y = 1,
},
},
['Shields'] = {
args = {'block'},
},
['Hideout Doodads'] = {
defaults = {
help_text = 'Right click on this item then left click on a location on the ground to create the object.',
},
},
['Jewel'] = {
defaults = {
help_text = 'Place into an allocated Jewel Socket on the Passive Skill Tree. Right click to remove from the Socket.',
},
},
}
-- add defaults from class specifics and class groups
core.item_classes = {}
for _, data in ipairs(game.constants.item.class) do
core.item_classes[data['full']] = {
args = xtable:new(),
defaults = {},
}
end
for _, row in pairs(core.class_groups) do
for _, k in ipairs(row.keys) do
core.item_classes[k].args:insertT(row.args)
end
end
for k, row in pairs(core.class_specifics) do
if row.args ~= nil then
core.item_classes[k].args:insertT(row.args)
end
if row.defaults ~= nil then
for key, value in pairs(row.defaults) do
core.item_classes[k].defaults[key] = value
end
end
end
-- GroupTable -> RowTable -> formatter function
--
--
core.display_groups = {
-- Tags, stats, level, etc
{
{
args = {'gem_tags'},
func = function ()
local out = {}
for i, tag in ipairs(g_args.gem_tags) do
out[#out+1] = string.format('[[:Category:%s (gem tag)|%s]]', tag, tag)
end
return table.concat(out, ', ')
end,
},
{
args = {'support_gem_letter_html'},
func = core.factory.display_value{
keys={'support_gem_letter_html'},
options = {
[1] = {
--property = 'Has support gem letter HTML',
before = 'Icon: ',
},
},
},
},
{
args = {'radius'},
func = core.factory.display_value{
keys={'radius'},
options = {
[1] = {
--property = 'Has radius',
before = 'Radius: ',
},
},
},
},
-- TODO: gem level here. Maybe put max level here?
{
args = nil,
func = core.factory.display_value{
keys={'mana_cost'},
type='gem',
options = {
[1] = {
--property = 'Has mana cost',
fmt = function ()
if g_args.has_percentage_mana_cost then
return '%i%%'
else
return '%i'
end
end,
before = function ()
if g_args.has_reservation_mana_cost then
return 'Mana Reserved: '
else
return 'Mana Cost: '
end
end,
},
},
},
},
{
args = nil,
func = core.factory.display_value{
keys={'mana_multiplier'},
type='gem',
options = {
[1] = {
--property = 'Has mana multiplier',
fmt = '%i%%',
before = 'Mana Multiplier: ',
gem_hide_static=function (value)
if value == 100 then
return true
end
return false
end,
},
},
},
},
{
args = nil,
func = core.factory.display_value{
keys={'vaal_souls_requirement', 'vaal_souls_requirement', 'vaal_souls_requirement'},
type='gem',
options = {
[1] = {
--property = 'Has normal souls requirement',
fmt = '%i (N) / ',
before = 'Souls per use: ',
},
[2] = {
fmt = '%i (C) / ',
func = function (value)
return value*1.5
end,
},
[3] = {
fmt = '%i (M)',
func = function (value)
return value*2
end,
},
},
},
},
{
args = nil,
func = core.factory.display_value{
keys={'vaal_stored_uses'},
type='gem',
options = {
[1] = {
--property = 'Has stored uses',
fmt = '%i',
before = 'Can store ',
after = ' use(s)',
},
},
},
},
{
args = nil,
func = core.factory.display_value{
keys={'stored_uses'},
type='gem',
options = {
[1] = {
--property = 'Has stored uses',
fmt = '%i',
before = 'Can store ',
after = ' use(s)',
},
},
},
},
{
args = nil,
func = core.factory.display_value{
keys={'cooldown'},
type='gem',
options = {
[1] = {
--property = 'Has cooldown time',
fmt = '%.2f sec',
before = 'Cooldown Time: ',
},
},
},
},
{
args = {'cast_time'},
func = core.factory.display_value{
keys={'cast_time'},
options = {
[1] = {
--property = 'Has cast time',
fmt = '%.2f sec',
before = 'Cast Time: ',
},
},
},
},
{
args = nil,
func = core.factory.display_value{
keys={'critical_strike_chance'},
type='gem',
options = {
[1] = {
property = 'Has critical strike chance',
fmt = '%.2f%%',
before = 'Critical Strike Chance: ',
},
},
},
},
{
args = nil,
func = core.factory.display_value{
type='gem',
keys={'damage_effectiveness'},
options = {
[1] = {
--property = 'Has damage effectiveness',
fmt = '%i%%',
before = 'Damage Effectiveness: ',
},
},
},
},
-- Weapon only
{
args = {'damage_min', 'damage_max'},
func = core.factory.display_value{
keys={'damage_min', 'damage_max'},
options = {
[1] = {
property = 'Has minimum physical damage',
fmt = '%i–',
stats_add = {
'local_minimum_added_physical_damage',
},
stats_multiply = {
'local_physical_damage_+%',
},
before = 'Physical Damage: '
},
[2] = {
property = 'Has maximum physical damage',
fmt = '%i',
stats_add = {
'local_maximum_added_physical_damage',
},
stats_multiply = {
'local_physical_damage_+%',
},
},
},
},
},
{
args = nil,
func = core.factory.display_value{
before='Elemental Damage: ',
values={0, 0, 0, 0, 0, 0},
options = {
[1] = {
property = 'Has minimum fire damage',
fmt = '%i',
before = '<span class="text-fire">',
stats_add = {
'local_minimum_added_fire_damage',
},
},
[2] = {
property = 'Has maximum fire damage',
fmt = '%i',
after = '</span>',
stats_add = {
'local_maximum_added_fire_damage',
},
},
[3] = {
property = 'Has minimum cold damage',
fmt = '%i',
before = '<span class="text-cold">',
stats_add = {
'local_minimum_added_cold_damage',
},
},
[4] = {
property = 'Has maximum cold damage',
fmt = '%i',
after = '</span>',
stats_add = {
'local_maximum_added_cold_damage',
},
},
[5] = {
property = 'Has minimum lightning damage',
fmt = '%i',
before = '<span class="text-lightning">',
stats_add = {
'local_minimum_added_lightning_damage',
},
},
[6] = {
property = 'Has maximum lightning damage',
fmt = '%i',
after = '</span>',
stats_add = {
'local_maximum_added_lightning_damage',
},
},
},
},
},
{
args = nil,
func = core.factory.display_value{
before='Chaos Damage: ',
values={0,0},
options = {
[1] = {
property = 'Has minimum chaos damage',
fmt = '%i',
stats_add = {
'local_minimum_added_chaos_damage',
},
},
[2] = {
property = 'Has maximum chaos damage',
fmt='%i',
stats_add = {
'local_maximum_added_chaos_damage',
},
},
},
},
},
{
args = {'critical_strike_chance'},
func = core.factory.display_value{
keys={'critical_strike_chance'},
options = {
[1] = {
property = 'Has critical strike chance',
fmt = '%.2f%%',
before = 'Critical Strike Chance: ',
stats_add = {
'local_critical_strike_chance',
},
stats_multiply = {
'local_critical_strike_chance_+%',
},
},
},
},
},
{
args = {'attack_speed'},
func = core.factory.display_value{
keys={'attack_speed'},
options = {
[1] = {
property = 'Has attack speed',
fmt = '%.2f',
before = 'Attacks per Second: ',
stats_multiply = {
'local_attack_speed_+%',
},
},
},
},
},
-- Map only
{
args = {'map_level'},
func = core.factory.display_value{
keys={'map_level'},
options = {
[1] = {
--property = 'Has map level',
fmt = '%i',
before = 'Map Level: ',
},
},
},
},
{
args = {'map_item_quantity'},
func = core.factory.display_value{
keys={'map_item_quantity'},
options = {
[1] = {
property = 'Has map item quantity',
fmt = '%i',
before = 'Item Quantity: ',
stats_add = {
'map_item_drop_quantity_+%',
},
},
},
},
},
{
args = {'map_item_rarity'},
func = core.factory.display_value{
keys={'map_item_rarity'},
options = {
[1] = {
property = 'Has map item rarity',
fmt = '%i',
before = 'Item Rarity: ',
stats_add = {
'map_item_drop_rarity_+%',
},
},
},
},
},
{
args = {'map_pack_size'},
func = core.factory.display_value{
keys={'map_pack_size'},
options = {
[1] = {
property = 'Has map pack size',
fmt = '%i',
before = 'Pack Size: ',
stats_add = {
'map_pack_size_+%',
},
},
},
},
},
-- Jewel Only
{
args = {'limit'},
func = core.factory.display_value{
keys={'limit'},
options = {
[1] = {
--property = 'Has limit',
fmt = '%i',
before = 'Limit: ',
},
},
},
},
{
args = {'jewel_radius'},
func = core.factory.display_value{
keys={'jewel_radius'},
options = {
[1] = {
--property = 'Has jewel radius',
fmt = '%i',
before = 'Radius: ',
},
},
},
},
-- Flask only
{
args = {'flask_mana', 'flask_duration'},
--func = core.factory.display_flask('flask_mana'),
func = core.factory.display_value{
keys = {'flask_mana', 'flask_duration'},
options = {
[1] = {
property = 'Has flask mana recovery',
fmt = '%i Mana',
before = 'Recovers',
stats_add = {
'local_flask_mana_to_recover',
},
stats_multiply = {
'local_flask_mana_to_recover_+%',
},
},
[2] = {
property = 'Has flask duration',
fmt = '%.2f',
before = ' over ',
after = ' seconds',
stats_multiply = {
'local_flask_recovery_speed_+%',
},
},
}
},
},
{
args = {'flask_life', 'flask_duration'},
func = core.factory.display_value{
keys = {'flask_life', 'flask_duration'},
options = {
[1] = {
property = 'Has flask mana recovery',
fmt = '%i Life',
before = 'Recovers',
stats_add = {
'local_flask_life_to_recover',
},
stats_multiply = {
'local_flask_life_to_recover_+%',
},
},
[2] = {
property = 'Has flask duration',
fmt = '%.2f',
before = ' over ',
after = ' seconds',
stats_multiply = {
'local_flask_recovery_speed_+%',
},
},
}
},
},
{
-- don't display for mana/life flasks
args = function ()
for _, k in ipairs({'flask_life', 'flask_mana'}) do
if g_args[k] ~= nil then
return false
end
end
return g_args['flask_duration'] ~= nil
end,
func = core.factory.display_value{
keys = {'flask_duration'},
options = {
[1] = {
property = 'Has flask duration',
before = 'Lasts ',
after = ' Seconds',
fmt = '%.2f',
stats_multiply = {
'local_flask_recovery_speed_+%',
},
},
},
},
},
{
args = {'charges_per_use', 'charges_cap'},
func = core.factory.display_value{
keys = {'charges_per_use', 'charges_cap'},
options = {
[1] = {
property = 'Has flask charges per use',
before = 'Consumes ',
fmt = '%i',
stats_multiply = {
'local_charges_used_+%',
},
},
[2] = {
property = 'Has flask maximum charges',
before = ' of ',
after = ' Charges on use',
fmt = '%i',
stats_add = {
'local_extra_max_charges',
},
stats_multiply = {
'local_max_charges_+%',
'local_charges_added_+%',
},
},
},
},
},
-- armor
{
args = {'block'},
func = core.factory.display_value{
keys={'block'},
options = {
[1] = {
property = 'Has block',
fmt = '%i',
stats_add = {
'local_additional_block_chance_%',
},
},
},
},
},
{
args = {'armour'},
func = core.factory.display_value{
keys={'armour'},
options = {
[1] = {
property = 'Has armour',
fmt = '%i',
stats_add = {
'local_base_physical_damage_reduction_rating',
},
stats_multiply = {
'local_physical_damage_reduction_rating_+%',
'local_armour_and_energy_shield_+%',
'local_armour_and_evasion_+%',
'local_armour_and_evasion_and_energy_shield_+%',
},
},
},
},
},
{
args = {'evasion'},
func = core.factory.display_value{
keys={'evasion'},
options = {
[1] = {
property = 'Has evasion',
fmt = '%i',
stats_add = {
'local_base_evasion_rating',
},
stats_multiply = {
'local_evasion_rating_+%',
'local_evasion_and_energy_shield_+%',
'local_armour_and_evasion_+%',
'local_armour_and_evasion_and_energy_shield_+%',
},
},
},
},
},
{
args = {'energy_shield'},
func = core.factory.display_value{
keys={'energy_shield'},
options = {
[1] = {
property = 'Has energy shield',
fmt = '%i',
stats_add = {
'local_energy_shield'
},
stats_multiply = {
'local_energy_shield_+%',
'local_armour_and_energy_shield_+%',
'local_evasion_and_energy_shield_+%',
'local_armour_and_evasion_and_energy_shield_+%',
},
},
},
},
},
-- Misc
{
args = {'stack_size'},
func = core.factory.display_value{
keys={'stack_size'},
options = {
[1] = {
--property = 'Has stack size',
fmt = '%i',
before = 'Stack Size: ',
},
},
},
},
},
-- Requirements
{
{
args = function ()
if g_args.drop_enabled == true then
return false
end
return true
end,
func = function()
local span = mw.html.create('span')
span
:attr('class', 'infobox-disabled-drop')
:wikitext('DROP DISABLED')
:done()
return tostring(span)
end,
},
-- Instead of item level, show drop level if any
{
args = function ()
if g_args.drop_enabled == false then
return false
end
return g_args.drop_level ~= nil
end,
func = core.factory.display_value{
keys={'drop_level'},
options = {
[1] = {
fmt = '%i',
before = 'Drop Level: ',
},
},
},
},
{
args = nil,
func = function ()
local requirements = {}
local attr_label
local use_short_label
if g_args.required_level then
table.insert( requirements, 'Level ' .. tostring( h.new_color('value', g_args.required_level) ) )
end
for _, attr in ipairs(game.constants.attributes) do
local val = g_args['required_' .. attr['long_lower']]
if val then
use_short_label = false or g_args.required_level
for _, attr2 in ipairs(game.constants.attributes) do
if attr ~= attr2 then
use_short_label = use_short_label or g_args[attr2['long_lower']]
end
end
if use_short_label then
attr_label = attr['short_upper']
else
attr_label = attr['long_upper']
end
table.insert( requirements, h.new_color('value', val) .. ' ' .. attr_label )
end
end
-- return early
if #requirements == 0 then
return
end
return h.new_color('default', 'Requires ') .. table.concat(requirements, ', ')
end,
},
},
-- Gem description
{
css_class = 'textwrap text-gemdesc',
{
args = {'gem_description'},
func = core.factory.display_value_only('gem_description'),
},
},
-- Gem Quality Stats
{
css_class = 'textwrap text-mod',
{
args = {'quality_stat_text'},
func = function ()
lines = {}
lines[#lines+1] = h.new_color('default', 'Per 1% Quality:')
lines[#lines+1] = g_args.quality_stat_text
return table.concat(lines, '<br>')
end,
},
},
-- Gem Implicit Stats
{
css_class = 'textwrap text-mod',
{
args = {'stat_text'},
func = function ()
lines = {}
lines[#lines+1] = g_args.stat_text
if g_args.gem_tags:contains('Vaal') then
lines[#lines+1] = h.new_color('corrupted', 'Corrupted')
end
return table.concat(lines, '<br>')
end,
},
},
-- Quality Stats
{
css_class = 'text-mod',
func = core.factory.display_mods{type='quality'},
},
-- Implicit Stats
{
css_class = 'text-mod',
func = core.factory.display_mods{type='implicit'},
},
-- Stats
{
css_class = 'text-mod',
func = core.factory.display_mods{type='mod'},
},
-- Experience
{
{
args = {'experience'},
func = core.factory.display_value{
keys={'experience'},
options = {
[1] = {
fmt = '%i',
},
},
},
},
},
-- Flavour Text
{
css_class = 'textwrap text-flavour',
{
args = {'flavour_text'},
func = core.factory.display_value_only('flavour_text'),
},
},
-- Help text
{
css_class = 'textwrap text-help',
{
args = {'help_text'},
func = core.factory.display_value_only('help_text'),
},
},
-- Cost (i.e. vendor costs)
{
},
}
core.item_link_params = {'name', 'inventory_icon', 'html'}
core.item_link_broken_cat = '[[Category:Pages with broken item links]]'
-- ----------------------------------------------------------------------------
-- Page views
-- ----------------------------------------------------------------------------
--
-- Frame args:
-- class
-- rarity
function p.itembox (frame)
--
-- Args/Frame
--
local t = os.clock()
g_args = getArgs(frame, {
parentFirst = true
})
g_frame = util.misc.get_frame(frame)
--
-- Shared args
--
g_args._total_args = {}
local properties = {}
-- Must validate some argument early. It is required for future things
for _, k in ipairs(core.default_args) do
table.insert(g_args._total_args, k)
local data = core.map[k]
if data.func ~= nil then
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
end
for _, k in ipairs(core.item_classes[g_args.class].args) do
table.insert(g_args._total_args, k)
local data = core.map[k]
if data.func ~= nil then
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
end
-- set defaults
for k, v in pairs(core.item_classes[g_args.class].defaults) do
if g_args[k] == nil then
g_args[k] = v
end
end
-- Mods
g_args._mods = {}
g_args._stats = {}
g_args._subobjects = {}
for _, k in ipairs({'implicit', 'mod', 'quality'}) do
local success = true
local i = 1
while success do
success = core.validate_mod{key=k, i=i}
i = i + 1
end
end
-- Handle extra stats (for gems)
if core.class_groups.gems.keys:contains(g_args.class) then
m_skill.skill(g_frame, g_args)
end
-- base_item
core.map.base_item.func()
table.insert(g_args._total_args, 'base_item')
-- Setting semantic properties Part 1 (base values)
local val
for _, k in ipairs(g_args._total_args) do
local prop = core.map[k].property
val = g_args[k]
if val == nil then
elseif type(val) == 'table' then
-- unfortunatly, it seems like +sep=; is broken
for _, val in ipairs(g_args[k]) do
g_frame:callParserFunction('#set:', {[prop] = val})
end
else
properties[prop] = val
end
end
g_frame:callParserFunction('#set:', properties)
-- Subobjects
for _, properties in ipairs(g_args._subobjects) do
g_frame:callParserFunction('#subobject:', properties)
end
--
-- Validate arguments
--
local x = v.itembox()
mw.logObject(os.clock() - t)
return x
end
function p.item_link (frame)
--
-- Args/Frame
--
g_args = getArgs(frame, {
parentFirst = true,
removeBlanks = false,
})
g_frame = util.misc.get_frame(frame)
-- Backwards compability
g_args.item_name = g_args.item_name or g_args[1]
g_args.name = g_args.name or g_args[2]
if util.table.has_all_value(g_args, {'page', 'item_name'}) then
error('page or item name must be specified')
end
local img
local result
if util.table.has_one_value(g_args, core.item_link_params, nil) then
local query = {}
if g_args.page ~= nil then
-- TODO returns the result even if the + format is specified.
query[#query+1] = string.format('[[%s]]', g_args.page)
elseif g_args.item_name ~= nil then
query[#query+1] = string.format('[[Has name::%s]] [[Has inventory icon::+]] [[Has infobox HTML::+]]', g_args.item_name)
end
query[#query+1] = '?Has name'
query[#query+1] = '?Has inventory icon'
query[#query+1] = '?Has infobox HTML'
-- attributes
result = util.smw.query(query, g_frame)
if #result == 0 then
return util.html.error{msg=string.format('No results found.')} .. core.item_link_broken_cat
elseif #result > 1 then
return util.html.error{msg=string.format('Too many results. Consider using page parameter instead.')} .. core.item_link_broken_cat
end
result = result[1]
else
result = {g_args.page or g_args.item_name}
end
for _, k in ipairs(core.item_link_params) do
local prop = core.map[k].property
if g_args[k] ~= nil then
result[prop] = g_args[k]
end
end
if result['Has inventory icon'] ~= '' then
img = string.format('[[%s]]', result['Has inventory icon'])
end
-- output
local container = mw.html.create('span')
container
:attr('class', 'inline-infobox-container')
:wikitext(img)
:wikitext(string.format('[[%s|%s]]', result[1], result['Has name'] or result[1]))
if result['Has infobox HTML'] ~= '' then
container
:tag('span')
:attr('class', 'inline-infobox-hover')
:wikitext(result['Has infobox HTML'])
:done()
end
return tostring(container)
end
-- ----------------------------------------------------------------------------
-- Result formatting templates for SMW queries
-- ----------------------------------------------------------------------------
--
-- Template:
--
function p.simple_item_list_row(frame)
-- Args
g_args = getArgs(frame, {
parentFirst = true
})
g_frame = util.misc.get_frame(frame)
--
local args = util.string.split_args(g_args.userparam, {sep=', '})
g_args.userparam = args
local link = p.item_link{page=g_args[1], name=g_args['?Has name'], inventory_icon=g_args['?Has inventory icon'] or '', html=g_args['?Has infobox HTML'] or ''}
if args.format == nil then
return '* ' .. link
elseif args.format == 'none' then
return link
elseif args.format == 'li' then
return string.format('<li>%s</li>', link)
else
error(string.format('Unrecognized format parameter "%s"', args.format))
end
end
-- ----------------------------------------------------------------------------
-- Property views..
-- ----------------------------------------------------------------------------
function v.itembox ()
--todo: remove g_args.frame ?
local container = v._itembox_core()
for _, k in ipairs({'inventory_icon', 'gem_icon'}) do
if g_args[k] ~= nil then
container:wikitext(string.format('[[%s]]', g_args[k]))
end
end
local infobox = tostring(container)
-- Store the infobox so it can be accessed with ease on other pages
g_frame:callParserFunction('#set:', {['Has infobox HTML'] = infobox})
local div = mw.html.create('div')
div
:attr('class', 'infobox-page-container')
:wikitext(infobox)
if g_args.skill_screenshot then
div:wikitext(string.format('<br>[[%s|300px]]', g_args.skill_screenshot))
end
return tostring(div) .. v._itembox_categories()
end
function v._itembox_core()
-- needed later for setting caculated properties
g_args._properties = {}
local frame_css = {
['Currency'] = 'currency',
['Microtransactions'] = 'currency',
['Active Skill Gems'] = 'gem',
['Support Skill Gems'] = 'gem',
['Quest'] = 'quest',
['Divination Card'] = 'divicard'
}
local container = mw.html.create('div')
:attr( 'class', 'itembox-' .. ( string.lower(g_args.frame or frame_css[g_args.class] or g_args.rarity) .. ' ' .. g_args.class))
if g_args.class == 'Divination Card' then
--TODO div card code
else
container
:tag('span')
:attr( 'class', 'itemboxheader-' .. (g_args.base_item and 'double' or 'single') )
:tag('span')
:attr('class', 'itemboxheaderleft')
:done()
:tag('span')
:attr('class', 'itemboxheaderright')
:done()
:tag('span')
:attr('class', 'itemboxheadertext')
:wikitext( g_args.name .. (g_args.base_item and '<br>' .. g_args.base_item or '') )
:done()
:done()
local grpcont
local valid
local statcont = container:tag('span')
statcont
:attr('class', 'itemboxstats')
:done()
for _, group in ipairs(core.display_groups) do
grpcont = {}
if group.func == nil then
for _, disp in ipairs(group) do
valid = true
-- No args to verify which means always valid
if disp.args == nil then
elseif type(disp.args) == 'table' then
for _, key in ipairs(disp.args) do
if g_args[key] == nil then
valid = false
break
end
end
elseif type(disp.args) == 'function' then
valid = disp.args()
end
if valid then
grpcont[#grpcont+1] = disp.func()
end
end
else
grpcont = group.func()
end
if #grpcont > 0 then
statcont
:tag('span')
:attr('class', 'itemboxstatsgroup ' .. (group.css_class or ''))
:wikitext(table.concat(grpcont, '<br>'))
:done()
end
end
end
g_frame:callParserFunction('#set:', g_args._properties)
return container
end
function v._itembox_categories()
cats = {}
cats[#cats+1] = g_args.class
if g_args.rarity == 'Unique' then
cats[#cats+1] = 'Unique ' .. g_args.class
end
for _, attr in ipairs(game.constants.attributes) do
if g_args[attr.long_lower .. '_percent'] then
cats[#cats+1] = string.format('%s %s', attr.long_upper, g_args.class)
end
end
local suffix
if g_args.class == 'Active Skill Gems' or g_args.class == 'Support Skill Gems' then
suffix = ' (gem tag)'
end
if suffix ~= nil then
for _, tag in ipairs(g_args.gem_tags) do
cats[#cats+1] = tag .. suffix
end
end
-- TODO: add maintenance categories
--
-- Output formatting
--
return util.misc.add_category(cats)
end
return p