Module:Item table: Difference between revisions
Jump to navigation
Jump to search
(Check for redirects when |page= is used) |
m (126 revisions imported) |
||
(27 intermediate revisions by 3 users not shown) | |||
Line 4: | Line 4: | ||
-- | -- | ||
-- This module implements Template:Item table and other templates that query | -- This module implements Template:Item table and other templates that query | ||
-- and display lists of items. | -- and display tables or lists of items. | ||
------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ||
require('Module:No globals') | require('Module:No globals') | ||
local m_util = require('Module:Util') | local m_util = require('Module:Util') | ||
local m_cargo = require('Module:Cargo') | local m_cargo = require('Module:Cargo') | ||
-- Should we use the sandbox version of our submodules? | -- Should we use the sandbox version of our submodules? | ||
local use_sandbox = m_util.misc.maybe_sandbox('Item table') | local use_sandbox = m_util.misc.maybe_sandbox('Item table') | ||
local m_game = use_sandbox and mw.loadData('Module:Game/sandbox') or mw.loadData('Module:Game') | |||
-- Lazy loading | -- Lazy loading | ||
local m_item_util -- require('Module:Item util') | |||
local f_item_link -- require('Module:Item link').item_link | local f_item_link -- require('Module:Item link').item_link | ||
local f_skill_link -- require('Module:Skill link').skill_link | local f_skill_link -- require('Module:Skill link').skill_link | ||
Line 173: | Line 164: | ||
base=data[field], | base=data[field], | ||
} | } | ||
if sdata then | if sdata then --For skill data | ||
-- Use the fixed value, or the first-level value. | |||
value.min = value.min or sdata['0'][field] or sdata['1'][field] | value.min = value.min or sdata['0'][field] or sdata['1'][field] | ||
-- Fall back to the fixed value, and then the max level value. | |||
value.max = value.max or sdata['0'][field] or sdata[data['skill.max_level']][field] | value.max = value.max or sdata['0'][field] or sdata[data['skill.max_level']][field] | ||
end | end | ||
Line 184: | Line 177: | ||
opts.no_color = true | opts.no_color = true | ||
end | end | ||
fmt_values[#fmt_values+1] = m_util.html.format_value( | fmt_values[#fmt_values+1] = m_util.html.format_value(nil, value, opts) | ||
end | end | ||
end | end | ||
Line 270: | Line 263: | ||
-- tbl | -- tbl | ||
args = args or {} | args = args or {} | ||
return function ( | return function (value) | ||
if args.tbl[args.key] then | if args.tbl[args.key] then | ||
value = m_util.html.abbr(value, args.tbl[args.key]) | value = m_util.html.abbr(value, args.tbl[args.key]) | ||
Line 359: | Line 351: | ||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{}, | ||
order = 1004, | order = 1004, | ||
}, | |||
{ | |||
arg = {'size'}, | |||
header = i18n.item_table.inventory_size, | |||
fields = {'items.size_x', 'items.size_y'}, | |||
display = function (tr, data) | |||
tr | |||
:tag('td') | |||
:attr('data-sort-value', data['items.size_x'] * data['items.size_y']) | |||
:wikitext(string.format('%s×%s', data['items.size_x'], data['items.size_y'])) | |||
end, | |||
order = 1005, | |||
}, | }, | ||
{ | { | ||
Line 365: | Line 369: | ||
fields = {'essences.level'}, | fields = {'essences.level'}, | ||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{}, | ||
order = | order = 1100, | ||
}, | }, | ||
{ | { | ||
Line 372: | Line 376: | ||
fields = {'items.drop_level'}, | fields = {'items.drop_level'}, | ||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{}, | ||
order = | order = 1200, | ||
}, | |||
{ | |||
arg = {'drop_level_maximum'}, | |||
header = i18n.item_table.drop_level_maximum, | |||
fields = {'items.drop_level_maximum'}, | |||
display = h.tbl.display.factory.value{}, | |||
order = 1201, | |||
}, | }, | ||
{ | { | ||
Line 379: | Line 390: | ||
fields = {'stackables.stack_size'}, | fields = {'stackables.stack_size'}, | ||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{}, | ||
order = | order = 1300, | ||
}, | }, | ||
{ | { | ||
Line 386: | Line 397: | ||
fields = {'stackables.stack_size_currency_tab'}, | fields = {'stackables.stack_size_currency_tab'}, | ||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{}, | ||
order = | order = 1301, | ||
}, | }, | ||
-- Requirements | |||
{ | { | ||
arg = 'level', | arg = 'level', | ||
Line 393: | Line 405: | ||
fields = h.tbl.range_fields{field='items.required_level'}, | fields = h.tbl.range_fields{field='items.required_level'}, | ||
display = h.tbl.display.factory.range{field='items.required_level'}, | display = h.tbl.display.factory.range{field='items.required_level'}, | ||
order = | order = 1400, | ||
}, | |||
{ | |||
arg = 'str', | |||
header = '[[File:StrengthIcon small.png|link=|alt=Required strength]]', | |||
fields = h.tbl.range_fields{field='items.required_strength'}, | |||
display = h.tbl.display.factory.range{field='items.required_strength'}, | |||
order = 1401, | |||
}, | |||
{ | |||
arg = 'dex', | |||
header = '[[File:DexterityIcon small.png|link=|alt=Required dexterity]]', | |||
fields = h.tbl.range_fields{field='items.required_dexterity'}, | |||
display = h.tbl.display.factory.range{field='items.required_dexterity'}, | |||
order = 1402, | |||
}, | |||
{ | |||
arg = 'int', | |||
header = '[[File:IntelligenceIcon small.png|link=|alt=Required intelligence]]', | |||
fields = h.tbl.range_fields{field='items.required_intelligence'}, | |||
display = h.tbl.display.factory.range{field='items.required_intelligence'}, | |||
order = 1403, | |||
}, | }, | ||
-- Armour 15xx | |||
{ | { | ||
arg = 'ar', | arg = 'ar', | ||
Line 400: | Line 434: | ||
fields = h.tbl.range_fields{field='armours.armour'}, | fields = h.tbl.range_fields{field='armours.armour'}, | ||
display = h.tbl.display.factory.range{field='armours.armour'}, | display = h.tbl.display.factory.range{field='armours.armour'}, | ||
order = | order = 1500, | ||
}, | }, | ||
{ | { | ||
Line 407: | Line 441: | ||
fields = h.tbl.range_fields{field='armours.evasion'}, | fields = h.tbl.range_fields{field='armours.evasion'}, | ||
display = h.tbl.display.factory.range{field='armours.evasion'}, | display = h.tbl.display.factory.range{field='armours.evasion'}, | ||
order = | order = 1501, | ||
}, | }, | ||
{ | { | ||
Line 414: | Line 448: | ||
fields = h.tbl.range_fields{field='armours.energy_shield'}, | fields = h.tbl.range_fields{field='armours.energy_shield'}, | ||
display = h.tbl.display.factory.range{field='armours.energy_shield'}, | display = h.tbl.display.factory.range{field='armours.energy_shield'}, | ||
order = | order = 1502, | ||
}, | }, | ||
{ | { | ||
Line 421: | Line 455: | ||
fields = h.tbl.range_fields{field='armours.ward'}, | fields = h.tbl.range_fields{field='armours.ward'}, | ||
display = h.tbl.display.factory.range{field='armours.ward'}, | display = h.tbl.display.factory.range{field='armours.ward'}, | ||
order = | order = 1503, | ||
}, | }, | ||
{ | { | ||
Line 428: | Line 462: | ||
fields = h.tbl.range_fields{field='shields.block'}, | fields = h.tbl.range_fields{field='shields.block'}, | ||
display = h.tbl.display.factory.range{field='shields.block'}, | display = h.tbl.display.factory.range{field='shields.block'}, | ||
order = | order = 1504, | ||
}, | }, | ||
--[[{ | --[[{ | ||
Line 445: | Line 479: | ||
},]]-- | },]]-- | ||
-- Weapons 16xx | |||
{ | { | ||
arg = {'weapon', 'damage'}, | arg = {'weapon', 'damage'}, | ||
Line 455: | Line 490: | ||
:wikitext(data['weapons.damage_html']) | :wikitext(data['weapons.damage_html']) | ||
end, | end, | ||
order = | order = 1600, | ||
}, | }, | ||
{ | { | ||
Line 462: | Line 497: | ||
fields = h.tbl.range_fields{field='weapons.attack_speed'}, | fields = h.tbl.range_fields{field='weapons.attack_speed'}, | ||
display = h.tbl.display.factory.range{field='weapons.attack_speed'}, | display = h.tbl.display.factory.range{field='weapons.attack_speed'}, | ||
order = | order = 1601, | ||
}, | }, | ||
{ | { | ||
Line 469: | Line 504: | ||
fields = h.tbl.range_fields{field='weapons.critical_strike_chance'}, | fields = h.tbl.range_fields{field='weapons.critical_strike_chance'}, | ||
display = h.tbl.display.factory.range{field='weapons.critical_strike_chance'}, | display = h.tbl.display.factory.range{field='weapons.critical_strike_chance'}, | ||
order = | order = 1602, | ||
}, | }, | ||
{ | { | ||
Line 476: | Line 511: | ||
fields = h.tbl.range_fields{field='weapons.physical_dps'}, | fields = h.tbl.range_fields{field='weapons.physical_dps'}, | ||
display = h.tbl.display.factory.range{field='weapons.physical_dps'}, | display = h.tbl.display.factory.range{field='weapons.physical_dps'}, | ||
order = | order = 1603, | ||
}, | }, | ||
{ | { | ||
Line 483: | Line 518: | ||
fields = h.tbl.range_fields{field='weapons.lightning_dps'}, | fields = h.tbl.range_fields{field='weapons.lightning_dps'}, | ||
display = h.tbl.display.factory.range{field='weapons.lightning_dps'}, | display = h.tbl.display.factory.range{field='weapons.lightning_dps'}, | ||
order = | order = 1604, | ||
}, | }, | ||
{ | { | ||
Line 490: | Line 525: | ||
fields = h.tbl.range_fields{field='weapons.cold_dps'}, | fields = h.tbl.range_fields{field='weapons.cold_dps'}, | ||
display = h.tbl.display.factory.range{field='weapons.cold_dps'}, | display = h.tbl.display.factory.range{field='weapons.cold_dps'}, | ||
order = | order = 1605, | ||
}, | }, | ||
{ | { | ||
Line 497: | Line 532: | ||
fields = h.tbl.range_fields{field='weapons.fire_dps'}, | fields = h.tbl.range_fields{field='weapons.fire_dps'}, | ||
display = h.tbl.display.factory.range{field='weapons.fire_dps'}, | display = h.tbl.display.factory.range{field='weapons.fire_dps'}, | ||
order = | order = 1606, | ||
}, | }, | ||
{ | { | ||
Line 504: | Line 539: | ||
fields = h.tbl.range_fields{field='weapons.chaos_dps'}, | fields = h.tbl.range_fields{field='weapons.chaos_dps'}, | ||
display = h.tbl.display.factory.range{field='weapons.chaos_dps'}, | display = h.tbl.display.factory.range{field='weapons.chaos_dps'}, | ||
order = | order = 1607, | ||
}, | }, | ||
{ | { | ||
Line 511: | Line 546: | ||
fields = h.tbl.range_fields{field='weapons.elemental_dps'}, | fields = h.tbl.range_fields{field='weapons.elemental_dps'}, | ||
display = h.tbl.display.factory.range{field='weapons.elemental_dps'}, | display = h.tbl.display.factory.range{field='weapons.elemental_dps'}, | ||
order = | order = 1608, | ||
}, | }, | ||
{ | { | ||
Line 518: | Line 553: | ||
fields = h.tbl.range_fields{field='weapons.poison_dps'}, | fields = h.tbl.range_fields{field='weapons.poison_dps'}, | ||
display = h.tbl.display.factory.range{field='weapons.poison_dps'}, | display = h.tbl.display.factory.range{field='weapons.poison_dps'}, | ||
order = | order = 1609, | ||
}, | }, | ||
{ | { | ||
Line 525: | Line 560: | ||
fields = h.tbl.range_fields{field='weapons.dps'}, | fields = h.tbl.range_fields{field='weapons.dps'}, | ||
display = h.tbl.display.factory.range{field='weapons.dps'}, | display = h.tbl.display.factory.range{field='weapons.dps'}, | ||
order = | order = 1610, | ||
}, | }, | ||
-- Flasks 17xx | |||
{ | { | ||
arg = 'flask_life', | arg = 'flask_life', | ||
Line 532: | Line 568: | ||
fields = h.tbl.range_fields{field='flasks.life'}, | fields = h.tbl.range_fields{field='flasks.life'}, | ||
display = h.tbl.display.factory.range{field='flasks.life'}, | display = h.tbl.display.factory.range{field='flasks.life'}, | ||
order = | order = 1700, | ||
}, | }, | ||
{ | { | ||
Line 539: | Line 575: | ||
fields = h.tbl.range_fields{field={'flasks.life', 'flasks.duration'}, full=true}, | fields = h.tbl.range_fields{field={'flasks.life', 'flasks.duration'}, full=true}, | ||
display = h.tbl.display.factory.range_composite{field1='flasks.life', field2='flasks.duration'}, | display = h.tbl.display.factory.range_composite{field1='flasks.life', field2='flasks.duration'}, | ||
order = | order = 1701, | ||
}, | }, | ||
{ | { | ||
Line 546: | Line 582: | ||
fields = h.tbl.range_fields{field={'flasks.life', 'flasks.charges_per_use'}, full=true}, | fields = h.tbl.range_fields{field={'flasks.life', 'flasks.charges_per_use'}, full=true}, | ||
display = h.tbl.display.factory.range_composite{field1='flasks.life', field2='flasks.charges_per_use'}, | display = h.tbl.display.factory.range_composite{field1='flasks.life', field2='flasks.charges_per_use'}, | ||
order = | order = 1702, | ||
}, | }, | ||
{ | { | ||
Line 553: | Line 589: | ||
fields = h.tbl.range_fields{field='flasks.mana'}, | fields = h.tbl.range_fields{field='flasks.mana'}, | ||
display = h.tbl.display.factory.range{field='flasks.mana'}, | display = h.tbl.display.factory.range{field='flasks.mana'}, | ||
order = | order = 1703, | ||
}, | }, | ||
{ | { | ||
Line 560: | Line 596: | ||
fields = h.tbl.range_fields{field={'flasks.mana', 'flasks.duration'}, full=true}, | fields = h.tbl.range_fields{field={'flasks.mana', 'flasks.duration'}, full=true}, | ||
display = h.tbl.display.factory.range_composite{field1='flasks.mana', field2='flasks.duration'}, | display = h.tbl.display.factory.range_composite{field1='flasks.mana', field2='flasks.duration'}, | ||
order = | order = 1704, | ||
}, | }, | ||
{ | { | ||
Line 567: | Line 603: | ||
fields = h.tbl.range_fields{field={'flasks.mana', 'flasks.charges_per_use'}, full=true}, | fields = h.tbl.range_fields{field={'flasks.mana', 'flasks.charges_per_use'}, full=true}, | ||
display = h.tbl.display.factory.range_composite{field1='flasks.mana', field2='flasks.charges_per_use'}, | display = h.tbl.display.factory.range_composite{field1='flasks.mana', field2='flasks.charges_per_use'}, | ||
order = | order = 1705, | ||
}, | }, | ||
{ | { | ||
Line 574: | Line 610: | ||
fields = h.tbl.range_fields{field='flasks.duration'}, | fields = h.tbl.range_fields{field='flasks.duration'}, | ||
display = h.tbl.display.factory.range{field='flasks.duration'}, | display = h.tbl.display.factory.range{field='flasks.duration'}, | ||
order = | order = 1706, | ||
}, | }, | ||
{ | { | ||
Line 581: | Line 617: | ||
fields = h.tbl.range_fields{field='flasks.charges_per_use'}, | fields = h.tbl.range_fields{field='flasks.charges_per_use'}, | ||
display = h.tbl.display.factory.range{field='flasks.charges_per_use'}, | display = h.tbl.display.factory.range{field='flasks.charges_per_use'}, | ||
order = | order = 1707, | ||
}, | }, | ||
{ | { | ||
Line 588: | Line 624: | ||
fields = h.tbl.range_fields{field='flasks.charges_max'}, | fields = h.tbl.range_fields{field='flasks.charges_max'}, | ||
display = h.tbl.display.factory.range{field='flasks.charges_max'}, | display = h.tbl.display.factory.range{field='flasks.charges_max'}, | ||
order = | order = 1708, | ||
}, | |||
-- Jewels 18xx | |||
{ | |||
arg = 'jewel_limit', | |||
header = i18n.item_table.jewel_limit, | |||
fields = {'jewels.jewel_limit'}, | |||
display = h.tbl.display.factory.value{}, | |||
order = 1800, | |||
}, | }, | ||
{ | { | ||
arg = | arg = 'jewel_radius', | ||
header = i18n.item_table. | header = i18n.item_table.jewel_radius, | ||
fields = {' | fields = {'jewels.radius_html'}, | ||
display = function (tr, data) | display = function (tr, data) | ||
tr | tr | ||
:tag('td') | :tag('td') | ||
:wikitext(data['jewels.radius_html']) | |||
:wikitext(data[' | |||
end, | end, | ||
order = | order = 1801, | ||
}, | }, | ||
-- Maps 19xx | |||
{ | { | ||
arg = | arg = 'map_tier', | ||
header = i18n.item_table. | header = i18n.item_table.map_tier, | ||
fields = {' | fields = {'maps.tier'}, | ||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{}, | ||
order = | order = 1900, | ||
}, | }, | ||
{ | { | ||
arg = | arg = 'map_level', | ||
header = i18n.item_table. | header = i18n.item_table.map_level, | ||
fields = {' | fields = {'maps.area_level'}, | ||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{}, | ||
order = | order = 1901, | ||
}, | }, | ||
{ | { | ||
arg = | arg = 'map_guild_character', | ||
header = i18n.item_table. | header = i18n.item_table.map_guild_character, | ||
fields = {' | fields = {'maps.guild_character'}, | ||
display = h.tbl.display.factory.value{ | display = h.tbl.display.factory.value{}, | ||
order = | order = 1902, | ||
sort_type = 'text', | |||
}, | }, | ||
{ | { | ||
arg = | arg = 'map_series', | ||
header = i18n.item_table. | header = i18n.item_table.map_series, | ||
fields = {' | fields = {'maps.series'}, | ||
display = h.tbl.display.factory.value{ | display = h.tbl.display.factory.value{}, | ||
order = | order = 1903, | ||
}, | }, | ||
{ | { | ||
arg = | arg = 'atlas_tier', | ||
header = i18n.item_table. | header = i18n.item_table.atlas_tier, | ||
fields = {' | colspan = 5, | ||
display = h.tbl.display.factory. | fields = {'atlas_maps.map_tier0', 'atlas_maps.map_tier1', 'atlas_maps.map_tier2', 'atlas_maps.map_tier3', 'atlas_maps.map_tier4'}, | ||
order = | display = h.tbl.display.factory.atlas_tier{is_level=false}, | ||
order = 1904, | |||
}, | }, | ||
{ | { | ||
arg = | arg = 'atlas_level', | ||
header = i18n.item_table. | header = i18n.item_table.atlas_level, | ||
fields = {' | colspan = 5, | ||
display = h.tbl.display.factory. | fields = {'atlas_maps.map_tier0', 'atlas_maps.map_tier1', 'atlas_maps.map_tier2', 'atlas_maps.map_tier3', 'atlas_maps.map_tier4'}, | ||
order = | display = h.tbl.display.factory.atlas_tier{is_level=true}, | ||
order = 1905, | |||
}, | }, | ||
-- Map fragments 20xx | |||
{ | { | ||
arg = {' | arg = {'map_fragment', 'map_fragment_limit'}, | ||
header = i18n.item_table. | header = i18n.item_table.map_fragment_limit, | ||
fields = {' | fields = {'map_fragments.map_fragment_limit'}, | ||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{}, | ||
order = | order = 2000, | ||
}, | }, | ||
-- | -- Hideout decorations 21xx | ||
{ | { | ||
arg = ' | arg = {'doodad', 'variation_count'}, | ||
header = i18n.item_table. | header = i18n.item_table.variation_count, | ||
fields = {' | fields = {'hideout_doodads.variation_count'}, | ||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{colour='mod'}, | ||
order = | order = 2100, | ||
}, | }, | ||
-- Corpse items 22xx | |||
{ | { | ||
arg = ' | arg = {'corpse', 'monster_category'}, | ||
header = i18n.item_table. | header = i18n.item_table.monster_category, | ||
fields = {' | fields = {'corpse_items.monster_category', 'corpse_items.monster_category_html'}, | ||
display = function (tr, data) | display = function (tr, data) | ||
tr | tr | ||
:tag('td') | :tag('td') | ||
:wikitext(data[' | :attr('data-sort-value', m_game.constants.monster.categories[data['corpse_items.monster_category']].id) | ||
:wikitext(data['corpse_items.monster_category_html']) | |||
end, | end, | ||
order = | order = 2200, | ||
}, | }, | ||
{ | { | ||
arg = ' | arg = {'corpse', 'monster_abilities'}, | ||
header = i18n.item_table. | header = i18n.item_table.monster_abilities, | ||
fields = {' | fields = {'corpse_items.monster_abilities'}, | ||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{colour='mod'}, | ||
order = | order = 2201, | ||
sort_type = 'text', | |||
}, | }, | ||
-- Tinctures 23xx | |||
{ | { | ||
arg = ' | arg = {'tincture'}, | ||
header = i18n.item_table. | header = i18n.item_table.tincture_debuff_interval, | ||
fields = {' | fields = h.tbl.range_fields{field='tinctures.debuff_interval'}, | ||
display = h.tbl.display.factory. | display = h.tbl.display.factory.range{field='tinctures.debuff_interval'}, | ||
order = | order = 2300, | ||
}, | }, | ||
{ | { | ||
arg = ' | arg = {'tincture'}, | ||
header = i18n.item_table. | header = i18n.item_table.tincture_cooldown, | ||
fields = {' | fields = h.tbl.range_fields{field='tinctures.cooldown'}, | ||
display = h.tbl.display.factory. | display = h.tbl.display.factory.range{field='tinctures.cooldown'}, | ||
order = | order = 2301, | ||
}, | }, | ||
-- Seed data 91xx, | |||
{ | { | ||
arg = ' | arg = {'seed', 'seed_type'}, | ||
header = i18n.item_table. | header = i18n.item_table.seed_type, | ||
fields = {'harvest_seeds.type', 'harvest_seeds.type_id'}, | |||
fields = {' | display = function (tr, data) | ||
tr | |||
order = | :tag('td') | ||
:attr('table-sort-value', data['harvest_seeds.type']) | |||
:attr('class', 'tc -' .. data['harvest_seeds.type_id']) | |||
:wikitext(data['harvest_seeds.type']) | |||
end, | |||
order = 9100, | |||
}, | }, | ||
{ | { | ||
arg = {'seed', 'seed_tier'}, | |||
header = i18n.item_table.seed_tier, | |||
fields = {'harvest_seeds.tier'}, | |||
arg = {' | |||
header = i18n.item_table. | |||
fields = {' | |||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{}, | ||
order = | order = 9101, | ||
}, | }, | ||
{ | { | ||
arg = {' | arg = {'seed', 'seed_growth_cycles'}, | ||
header = i18n.item_table. | header = i18n.item_table.seed_growth_cycles, | ||
fields = {' | fields = {'harvest_seeds.growth_cycles'}, | ||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{}, | ||
order = | order = 9102, | ||
}, | }, | ||
{ | { | ||
arg = {' | arg = {'seed', 'seed_cosumed_lifeforce', 'seed_consumed_lifeforce_percentage', 'seed_consumed_primal_lifeforce_percentage'}, | ||
header = i18n.item_table. | header = i18n.item_table.seed_consumed_primal_lifeforce_percentage, | ||
fields = {' | fields = {'harvest_seeds.consumed_primal_lifeforce_percentage'}, | ||
display = h.tbl.display.factory.value{ | display = h.tbl.display.factory.value{color='primal'}, | ||
order = | order = 9110, | ||
}, | }, | ||
{ | { | ||
arg = {' | arg = {'seed', 'seed_cosumed_lifeforce', 'seed_consumed_lifeforce_percentage', 'seed_consumed_vivid_lifeforce_percentage'}, | ||
header = i18n.item_table. | header = i18n.item_table.seed_consumed_vivid_lifeforce_percentage, | ||
fields = {' | fields = {'harvest_seeds.consumed_vivid_lifeforce_percentage'}, | ||
display = h.tbl.display.factory.value{ | display = h.tbl.display.factory.value{color='vivid'}, | ||
order = | order = 9110, | ||
}, | |||
{ | |||
arg = {'seed', 'seed_cosumed_lifeforce', 'seed_consumed_lifeforce_percentage', 'seed_consumed_wild_lifeforce_percentage'}, | |||
header = i18n.item_table.seed_consumed_wild_lifeforce_percentage, | |||
fields = {'harvest_seeds.consumed_wild_lifeforce_percentage'}, | |||
display = h.tbl.display.factory.value{color='wild'}, | |||
order = 9110, | |||
}, | |||
{ | |||
arg = {'seed', 'seed_required_nearby_seeds', 'seed_required_nearby_seed_amount'}, | |||
header = i18n.item_table.seed_required_nearby_seed_amount, | |||
fields = {'harvest_seeds.required_nearby_seed_amount'}, | |||
display = h.tbl.display.factory.value{}, | |||
order = 9113, | |||
}, | |||
{ | |||
arg = {'seed', 'seed_required_nearby_seeds', 'seed_required_nearby_seed_tier'}, | |||
header = i18n.item_table.seed_required_nearby_seed_tier, | |||
fields = {'harvest_seeds.required_nearby_seed_tier'}, | |||
display = h.tbl.display.factory.value{}, | |||
order = 9114, | |||
}, | }, | ||
{ | { | ||
arg = 'buff', | arg = 'buff', | ||
Line 757: | Line 826: | ||
{ | { | ||
arg = 'description', | arg = 'description', | ||
header = i18n.item_table. | header = i18n.item_table.description, | ||
fields = {'items.description'}, | fields = {'items.description'}, | ||
display = h.tbl.display.factory.value{colour='mod'}, | display = h.tbl.display.factory.value{colour='mod'}, | ||
Line 765: | Line 834: | ||
{ | { | ||
arg = {'seed', 'seed_effect'}, | arg = {'seed', 'seed_effect'}, | ||
header = i18n.item_table. | header = i18n.item_table.seed_effects, | ||
fields = {'harvest_seeds.effect'}, | fields = {'harvest_seeds.effect'}, | ||
display = h.tbl.display.factory.value{colour='crafted'}, | display = h.tbl.display.factory.value{colour='crafted'}, | ||
order = 12003, | order = 12003, | ||
sort_type = 'text', | sort_type = 'text', | ||
}, | }, | ||
Line 876: | Line 937: | ||
display = h.tbl.display.factory.value{}, | display = h.tbl.display.factory.value{}, | ||
order = 15002, | order = 15002, | ||
}, | }, | ||
{ | { | ||
Line 1,475: | Line 1,520: | ||
} | } | ||
data_map. | data_map.skill_gem = { | ||
{ | { | ||
arg = 'icon', | arg = 'icon', | ||
Line 1,525: | Line 1,570: | ||
fields = h.tbl.range_fields{field='items.required_level'}, | fields = h.tbl.range_fields{field='items.required_level'}, | ||
display = h.tbl.display.factory.range{field='items.required_level'}, | display = h.tbl.display.factory.range{field='items.required_level'}, | ||
order = | order = 3000, | ||
}, | |||
{ | |||
arg = 'str', | |||
header = '[[File:StrengthIcon small.png|link=|alt=Gem has strength requirement]]', | |||
fields = {'skill_gems.strength_percent'}, | |||
display = function (tr, data) | |||
tr | |||
:tag('td') | |||
:attr('data-sort-value', data['skill_gems.strength_percent']) | |||
:wikitext('[[File:Yes.png|yes|link=]]') | |||
end, | |||
order = 3001, | |||
}, | }, | ||
{ | { | ||
arg = 'crit', | arg = 'dex', | ||
header = i18n.item_table.skill_critical_strike_chance, | header = '[[File:DexterityIcon small.png|link=|alt=Gem has dexterity requirement]]', | ||
fields = {'skill_levels.critical_strike_chance'}, | fields = {'skill_gems.dexterity_percent'}, | ||
display = h.tbl.display.factory.value{options = { | display = function (tr, data) | ||
[1] = { | tr | ||
fmt='%s%%', | :tag('td') | ||
skill_levels = true, | :attr('data-sort-value', data['skill_gems.dexterity_percent']) | ||
}, | :wikitext('[[File:Yes.png|yes|link=]]') | ||
}}, | end, | ||
order = 3002, | |||
}, | |||
{ | |||
arg = 'int', | |||
header = '[[File:IntelligenceIcon small.png|link=|alt=Gem has intelligence requirement]]', | |||
fields = {'skill_gems.intelligence_percent'}, | |||
display = function (tr, data) | |||
tr | |||
:tag('td') | |||
:attr('data-sort-value', data['skill_gems.intelligence_percent']) | |||
:wikitext('[[File:Yes.png|yes|link=]]') | |||
end, | |||
order = 3003, | |||
}, | |||
{ | |||
arg = 'crit', | |||
header = i18n.item_table.skill_critical_strike_chance, | |||
fields = {'skill_levels.critical_strike_chance'}, | |||
display = h.tbl.display.factory.value{options = { | |||
[1] = { | |||
fmt='%s%%', | |||
skill_levels = true, | |||
}, | |||
}}, | |||
order = 4000, | order = 4000, | ||
options = { | options = { | ||
Line 1,589: | Line 1,670: | ||
}, | }, | ||
{ | { | ||
arg = 'mcm', | arg = {'mcm', 'cost_multiplier'}, | ||
header = i18n.item_table. | header = i18n.item_table.cost_multiplier, | ||
fields = {'skill_levels. | fields = {'skill_levels.cost_multiplier'}, | ||
display = h.tbl.display.factory.value{options = { | display = h.tbl.display.factory.value{options = { | ||
[1] = { | [1] = { | ||
Line 1,608: | Line 1,689: | ||
arg = 'mana', | arg = 'mana', | ||
header = i18n.item_table.mana_cost, | header = i18n.item_table.mana_cost, | ||
fields = {'skill_levels. | fields = {'skill_levels.cost_amounts', 'skill_levels.mana_reservation_percent', 'skill_levels.mana_reservation_flat'}, | ||
display = function (tr, data, fields, data2) | display = function (tr, data, fields, data2) | ||
local appendix = '' | local appendix = '' | ||
if | local cost_field = '' | ||
local sdata = data2.skill_levels[data['items._pageName']] | |||
-- Percentage Mana reservation is in level 0 of most of the skill_levels at this point, but spellslinger and awakened blasphemy change it per-level | |||
-- Flat Mana resservation is in real gem levels, but maybe there will be fixed flat mana reservations in the future. | |||
-- Per-use mana costs are stored in the real gem levels if they change, or in 0 if it's fixed. | |||
if(sdata['1']['skill_levels.mana_reservation_percent'] ~= nil or sdata['0']['skill_levels.mana_reservation_percent'] ~= nil) then | |||
cost_field = 'skill_levels.mana_reservation_percent' | |||
appendix = appendix .. '%%' | appendix = appendix .. '%%' | ||
elseif(sdata['1']['skill_levels.mana_reservation_flat'] ~= nil or sdata['0']['skill_levels.mana_reservation_flat'] ~= nil) then | |||
cost_field = 'skill_levels.mana_reservation_flat' | |||
appendix = appendix .. ' ' .. i18n.item_table.reserves_mana_suffix | appendix = appendix .. ' ' .. i18n.item_table.reserves_mana_suffix | ||
elseif(sdata['1']['skill_levels.cost_amounts'] ~= nil or sdata['0']['skill_levels.cost_amounts'] ~= nil) then | |||
cost_field = 'skill_levels.cost_amounts' | |||
end | end | ||
Line 1,623: | Line 1,712: | ||
skill_levels = true, | skill_levels = true, | ||
}, | }, | ||
}}(tr, data, { | }}(tr, data, {cost_field}, data2) | ||
end, | end, | ||
order = 5001, | order = 5001, | ||
-- Need one set of options per field. | |||
options = { | options = { | ||
[1] = { | [1] = { | ||
skill_levels = true, | |||
}, | |||
[2] = { | |||
skill_levels = true, | |||
}, | |||
[3] = { | |||
skill_levels = true, | skill_levels = true, | ||
}, | }, | ||
Line 1,673: | Line 1,769: | ||
:tag('td') | :tag('td') | ||
:attr('data-sort-value', data['skill.radius']) | :attr('data-sort-value', data['skill.radius']) | ||
:wikitext(h.tbl.display.factory.descriptor_value{tbl=data, key='skill.radius_description'}( | :wikitext(h.tbl.display.factory.descriptor_value{tbl=data, key='skill.radius_description'}(data['skill.radius'])) | ||
end, | end, | ||
order = 7000, | order = 7000, | ||
Line 1,686: | Line 1,782: | ||
:tag('td') | :tag('td') | ||
:attr('data-sort-value', data['skill.radius_secondary']) | :attr('data-sort-value', data['skill.radius_secondary']) | ||
:wikitext(h.tbl.display.factory.descriptor_value{tbl=data, key='skill.radius_secondary_description'}( | :wikitext(h.tbl.display.factory.descriptor_value{tbl=data, key='skill.radius_secondary_description'}(data['skill.radius_secondary'])) | ||
end, | end, | ||
order = 7001, | order = 7001, | ||
Line 1,699: | Line 1,795: | ||
:tag('td') | :tag('td') | ||
:attr('data-sort-value', data['skill.radius_tertiary']) | :attr('data-sort-value', data['skill.radius_tertiary']) | ||
:wikitext(h.tbl.display.factory.descriptor_value{tbl=data, key='skill.radius_tertiary_description'}( | :wikitext(h.tbl.display.factory.descriptor_value{tbl=data, key='skill.radius_tertiary_description'}(data['skill.radius_tertiary'])) | ||
end, | end, | ||
order = 7002, | order = 7002, | ||
Line 1,705: | Line 1,801: | ||
} | } | ||
-- ---------------------------------------------------------------------------- | |||
-- Main functions | |||
-- ---------------------------------------------------------------------------- | |||
local function _item_table(args) | |||
-- ---------------------------------------------------------------------------- | |||
-- | |||
-- ---------------------------------------------------------------------------- | |||
local | |||
function | |||
--[[ | --[[ | ||
Creates a generic table for items. | Creates a generic table for items. | ||
Line 1,752: | Line 1,818: | ||
} | } | ||
]] | ]] | ||
m_item_util = m_item_util or require('Module:Item util') | |||
local t = os.clock() | local t = os.clock() | ||
args.mode = args.mode or 'item' | |||
local modes = { | local modes = { | ||
skill = { | skill = { | ||
data = data_map. | data = data_map.skill_gem, | ||
header = i18n.item_table.skill_gem, | header = i18n.item_table.skill_gem, | ||
}, | }, | ||
Line 1,772: | Line 1,834: | ||
}, | }, | ||
} | } | ||
if modes[args.mode] == nil then | |||
if modes[ | |||
error(i18n.errors.invalid_item_table_mode) | error(i18n.errors.invalid_item_table_mode) | ||
end | end | ||
Line 1,788: | Line 1,845: | ||
local row_infos = {} | local row_infos = {} | ||
for _, row_info in ipairs(modes[ | for _, row_info in ipairs(modes[args.mode].data) do | ||
local enabled = false | local enabled = false | ||
if row_info.arg == nil then | if row_info.arg == nil then | ||
enabled = true | enabled = true | ||
elseif type(row_info.arg) == 'string' and m_util.cast.boolean( | elseif type(row_info.arg) == 'string' and m_util.cast.boolean(args[row_info.arg]) then | ||
enabled = true | enabled = true | ||
elseif type(row_info.arg) == 'table' then | elseif type(row_info.arg) == 'table' then | ||
for _, argument in ipairs(row_info.arg) do | for _, argument in ipairs(row_info.arg) do | ||
if m_util.cast.boolean( | if m_util.cast.boolean(args[argument]) then | ||
enabled = true | enabled = true | ||
break | break | ||
Line 1,812: | Line 1,869: | ||
local stat_columns = {} | local stat_columns = {} | ||
local query_stats = {} | local query_stats = {} | ||
for i=1, math.huge do -- repeat until no more columns are found | |||
local prefix = string.format('stat_column%s_', i) | local prefix = string.format('stat_column%s_', i) | ||
if args[prefix .. 'stat1_id'] == nil then | |||
-- Each column requires at least one stat id | |||
break | |||
end | |||
local col_info = { | local col_info = { | ||
header = | header = args[prefix .. 'header'] or tostring(i), | ||
format = | format = args[prefix .. 'format'], | ||
stat_format = | stat_format = args[prefix .. 'stat_format'] or 'separate', | ||
order = tonumber( | order = tonumber(args[prefix .. 'order']) or (10000000 + i), | ||
stats = {}, | stats = {}, | ||
} | } | ||
for j=1, math.huge do | |||
local stat_id = args[string.format('%sstat%s_id', prefix, j)] | |||
if stat_id == nil then | |||
break | |||
local | |||
end | end | ||
table.insert(col_info.stats, {id=stat_id}) | |||
query_stats[stat_id] = true | |||
end | end | ||
table.insert(stat_columns, col_info) | |||
end | |||
for _, col_info in ipairs(stat_columns) do | for _, col_info in ipairs(stat_columns) do | ||
Line 1,868: | Line 1,908: | ||
local stat = (results2.stats[data['items._pageName']] or {})[stat_info.id] | local stat = (results2.stats[data['items._pageName']] or {})[stat_info.id] | ||
if stat ~= nil then | if stat ~= nil then | ||
stat_texts[#stat_texts+1] = m_util.html.format_value( | stat_texts[#stat_texts+1] = m_util.html.format_value(args, stat, {no_color=true}) | ||
vmax = vmax + stat.max | vmax = vmax + stat.max | ||
end | end | ||
Line 1,910: | Line 1,950: | ||
:attr('data-sort-value', total_stat.max) | :attr('data-sort-value', total_stat.max) | ||
:attr('class', 'tc -mod') | :attr('class', 'tc -mod') | ||
:wikitext(string.format(col_info.format, m_util.html.format_value( | :wikitext(string.format(col_info.format, m_util.html.format_value(args, total_stat, {no_color=true}))) | ||
else | else | ||
error(string.format(i18n.errors.generic_argument_parameter, 'stat_format', col_info.stat_format)) | error(string.format(i18n.errors.generic_argument_parameter, 'stat_format', col_info.stat_format)) | ||
Line 1,944: | Line 1,984: | ||
local query = {} | local query = {} | ||
for key, value in pairs( | for key, value in pairs(args) do | ||
if string.sub(key, 0, 2) == 'q_' then | if string.sub(key, 0, 2) == 'q_' then | ||
if prepend[key] then | if prepend[key] then | ||
Line 1,957: | Line 1,997: | ||
-- This is mainly to prevent items from user pages or other testing pages | -- This is mainly to prevent items from user pages or other testing pages | ||
-- from being returned in the query results. | -- from being returned in the query results. | ||
if | if args.namespaces ~= 'any' then | ||
local namespaces = | local namespaces = m_util.cast.table(args.namespaces, {callback=m_util.cast.number}) | ||
query.where = string.format('%s AND items._pageNamespace IN (%s)', query.where, namespaces) | if #namespaces > 0 then | ||
namespaces = table.concat(namespaces, ',') | |||
else | |||
namespaces = m_item_util.get_item_namespaces{format = 'list'} | |||
end | |||
query.where = string.format('(%s) AND items._pageNamespace IN (%s)', query.where, namespaces) | |||
end | end | ||
Line 1,981: | Line 2,026: | ||
fields[#fields+1] = 'skill.max_level' | fields[#fields+1] = 'skill.max_level' | ||
tables_assoc.skill = true | tables_assoc.skill = true | ||
end | end | ||
Line 2,019: | Line 2,063: | ||
local results = m_cargo.query(query.tables, query.fields, query) | local results = m_cargo.query(query.tables, query.fields, query) | ||
if #results == 0 and | if #results == 0 and args.default ~= nil then | ||
return | return args.default | ||
end | end | ||
Line 2,056: | Line 2,100: | ||
if #stat_columns > 0 then | if #stat_columns > 0 then | ||
local | local stat_results = m_cargo.query( | ||
{'items', 'item_stats'}, | {'items', 'item_stats'}, | ||
{'item_stats._pageName', 'item_stats.id', 'item_stats.min', 'item_stats.max', 'item_stats.avg'}, | {'item_stats._pageName', 'item_stats.id', 'item_stats.min', 'item_stats.max', 'item_stats.avg'}, | ||
{ | { | ||
where=string.format('item_stats. | join = 'items._pageID=item_stats._pageID', | ||
where = string.format( | |||
'item_stats._pageID IN (%s) AND item_stats.id IN ("%s")', | |||
groupBy='items._pageID, item_stats.id', | table.concat(m_util.table.column(results, 'items._pageID'), ','), | ||
table.concat(m_util.table.keys(query_stats), '","') | |||
), | |||
groupBy = 'items._pageID, item_stats.id', | |||
} | } | ||
) | ) | ||
for _, row in ipairs(stat_results) do | |||
for _, row in ipairs( | |||
local stat = { | local stat = { | ||
min = tonumber(row['item_stats.min']), | min = tonumber(row['item_stats.min']), | ||
Line 2,106: | Line 2,136: | ||
local tbl = mw.html.create('table') | local tbl = mw.html.create('table') | ||
tbl:attr('class', 'wikitable sortable item-table') | tbl:attr('class', 'wikitable sortable item-table') | ||
if m_util.cast.boolean(args.responsive) then | |||
tbl:addClass('responsive-table') | |||
end | |||
-- Headers: | -- Headers: | ||
Line 2,111: | Line 2,144: | ||
tr | tr | ||
:tag('th') | :tag('th') | ||
:wikitext(modes[ | :wikitext(modes[args.mode].header) | ||
:done() | :done() | ||
for _, row_info in ipairs(row_infos) do | for _, row_info in ipairs(row_infos) do | ||
Line 2,138: | Line 2,171: | ||
} | } | ||
if | if args.no_html == nil then | ||
il_args.html = row['items.html'] | il_args.html = row['items.html'] | ||
end | end | ||
if | if args.large then | ||
il_args.large = | il_args.large = args.large | ||
end | end | ||
Line 2,154: | Line 2,187: | ||
-- this has been cast from a function in an earlier step | -- this has been cast from a function in an earlier step | ||
local display = true | local display = true | ||
for index, field in ipairs(rowinfo.fields) do | for index, field in ipairs(rowinfo.fields) do | ||
-- this will bet set to an empty value not nil confusingly | -- this will bet set to an empty value not nil confusingly | ||
Line 2,185: | Line 2,219: | ||
mw.logObject({os.clock() - t, query}) | mw.logObject({os.clock() - t, query}) | ||
return tostring(tbl) .. m_util.misc.add_category(cats, {ignore_blacklist= | return tostring(tbl) .. m_util.misc.add_category(cats, {ignore_blacklist=args.debug}) | ||
end | end | ||
Line 2,193: | Line 2,227: | ||
------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ||
function | local function _map_item_drops(args) | ||
--[[ | --[[ | ||
Gets the area id from the map item and activates | Gets the area id from the map item and activates | ||
Line 2,201: | Line 2,235: | ||
= p.map_item_drops{page='Underground River Map (War for the Atlas)'} | = p.map_item_drops{page='Underground River Map (War for the Atlas)'} | ||
]] | ]] | ||
local tables = {'maps'} | local tables = {'maps'} | ||
Line 2,216: | Line 2,244: | ||
groupBy = 'maps._pageName', | groupBy = 'maps._pageName', | ||
} | } | ||
if | if args.page then | ||
-- Join with _pageData in order to check for page redirect | -- Join with _pageData in order to check for page redirect | ||
tables[#tables+1] = '_pageData' | tables[#tables+1] = '_pageData' | ||
Line 2,222: | Line 2,250: | ||
query.where = string.format( | query.where = string.format( | ||
'_pageData._pageName="%s"', | '_pageData._pageName="%s"', | ||
args.page | |||
) | ) | ||
query.join = 'maps._pageName = _pageData._pageNameOrRedirect' | query.join = 'maps._pageName = _pageData._pageNameOrRedirect' | ||
Line 2,237: | Line 2,265: | ||
id = results[1]['maps.area_id'] | id = results[1]['maps.area_id'] | ||
end | end | ||
return | return mw.getCurrentFrame():expandTemplate{ title = 'Area item drops', args = {area_id=id} } | ||
end | end | ||
Line 2,244: | Line 2,272: | ||
------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | ||
function | local function _prophecy_description(args) | ||
args.page = args.page or tostring(mw.title.getCurrentTitle()) | |||
local results = m_cargo.query( | local results = m_cargo.query( | ||
Line 2,257: | Line 2,279: | ||
{'prophecies.objective', 'prophecies.reward'}, | {'prophecies.objective', 'prophecies.reward'}, | ||
{ | { | ||
where=string.format('prophecies._pageName="%s"', | where=string.format('prophecies._pageName="%s"', args.page), | ||
-- Only need each page name once | -- Only need each page name once | ||
groupBy='prophecies._pageName', | groupBy='prophecies._pageName', | ||
Line 2,280: | Line 2,302: | ||
end | end | ||
-- | local function _simple_item_list(args) | ||
--[[ | |||
Creates a simple list of items. | |||
Examples | |||
-------- | |||
= p.simple_item_list{ | |||
q_tables='maps', | |||
q_join='items._pageID=maps._pageID', | |||
q_where='maps.tier=1 AND items.drop_enabled=1 AND items.rarity_id="normal"', | |||
no_html=1, | |||
link_from_name=1, | |||
} | } | ||
]] | |||
local query = {} | |||
for key, value in pairs(args) do | |||
if string.sub(key, 0, 2) == 'q_' then | |||
query[string.sub(key, 3)] = value | |||
local | |||
end | end | ||
end | |||
local fields = { | |||
'items._pageName', | |||
'items.name', | |||
'items.class', | |||
} | |||
if args.no_icon == nil then | |||
fields[#fields+1] = 'items.inventory_icon' | |||
end | |||
if args.no_html == nil then | |||
fields[#fields+1] = 'items.html' | |||
end | |||
local tables = m_util.cast.table(args.q_tables) | |||
table.insert(tables, 1, 'items') | |||
query.groupBy = query.groupBy or 'items._pageID' | |||
local results = m_cargo.query( | |||
tables, | |||
fields, | |||
query | |||
) | |||
local out = {} | |||
for _, row in ipairs(results) do | |||
local page | |||
if args.use_name_as_link ~= nil then | |||
page = row['items.name'] | |||
else | |||
page = row['items._pageName'] | |||
end | |||
local link = h.item_link{ | |||
page=page, | |||
name=row['items.name'], | |||
inventory_icon=row['items.inventory_icon'] or '', | |||
html=row['items.html'] or '', | |||
skip_query=true | |||
} | |||
if args.format == nil then | |||
out[#out+1] = string.format('* %s', link) | |||
elseif args.format == 'none' then | |||
out[#out+1] = link | |||
elseif args.format == 'li' then | |||
out[#out+1] = string.format('<li>%s</li>', link) | |||
else | |||
error(string.format(i18n.errors.generic_argument_parameter, 'format', args.format)) | |||
end | |||
end | |||
if args.format == nil then | |||
return table.concat(out, '\n') | |||
elseif args.format == 'none' then | |||
return table.concat(out, '\n') | |||
elseif args.format == 'li' then | |||
return table.concat(out) | |||
end | |||
end | |||
-- ---------------------------------------------------------------------------- | |||
-- Exported functions | |||
-- ---------------------------------------------------------------------------- | |||
local p = {} | |||
-- | |||
-- Template:Item table | |||
-- | |||
p.item_table = m_util.misc.invoker_factory(_item_table) | |||
-- | |||
-- Template:Map item drops | |||
-- | |||
p.map_item_drops = m_util.misc.invoker_factory(_map_item_drops, { | |||
wrappers = cfg.wrappers.map_item_drops, | |||
}) | |||
-- | |||
-- Template:Prophecy description | |||
-- | |||
p.prophecy_description = m_util.misc.invoker_factory(_prophecy_description, { | |||
wrappers = cfg.wrappers.prophecy_description, | |||
}) | |||
-- | |||
-- Template:Simple item list | |||
-- | |||
p.simple_item_list = m_util.misc.invoker_factory(_simple_item_list, { | |||
wrappers = cfg.wrappers.simple_item_list, | |||
}) | |||
-- ---------------------------------------------------------------------------- | -- ---------------------------------------------------------------------------- | ||
-- Debug | -- Debug | ||
-- ---------------------------------------------------------------------------- | -- ---------------------------------------------------------------------------- | ||
p.debug = {} | p.debug = {} | ||
Line 2,583: | Line 2,449: | ||
function p.debug.skill_gem_all() | function p.debug.skill_gem_all() | ||
return p.debug._tbl_data(data_map. | return p.debug._tbl_data(data_map.skill_gem) | ||
end | end | ||
return p | return p |
Latest revision as of 03:34, 30 September 2024
This module is used on 4000+ 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 or your user space. 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.
The item module provides functionality for creating item tables.
Implemented templates
This module implements the following templates:
The above documentation is transcluded from Module:Item table/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.
-------------------------------------------------------------------------------
--
-- Module:Item table
--
-- This module implements Template:Item table and other templates that query
-- and display tables or lists of items.
-------------------------------------------------------------------------------
require('Module:No globals')
local m_util = require('Module:Util')
local m_cargo = require('Module:Cargo')
-- Should we use the sandbox version of our submodules?
local use_sandbox = m_util.misc.maybe_sandbox('Item table')
local m_game = use_sandbox and mw.loadData('Module:Game/sandbox') or mw.loadData('Module:Game')
-- Lazy loading
local m_item_util -- require('Module:Item util')
local f_item_link -- require('Module:Item link').item_link
local f_skill_link -- require('Module:Skill link').skill_link
-- The cfg table contains all localisable strings and configuration, to make it
-- easier to port this module to another wiki.
local cfg = use_sandbox and mw.loadData('Module:Item table/config/sandbox') or mw.loadData('Module:Item table/config')
local i18n = cfg.i18n
-- ----------------------------------------------------------------------------
-- Helper functions
-- ----------------------------------------------------------------------------
local h = {}
h.string = {}
function h.string.format(str, vars)
--[[
Allow string replacement using named arguments.
TODO:
* Support %d ?
* Support 0.2f ?
Parameters
----------
str : String to replace.
vars : Table of arguments.
Examples
--------
= h.string.format('{foo} is {bar}.', {foo='Dinner', bar='nice'})
References
----------
http://lua-users.org/wiki/StringInterpolation
]]
if not vars then
vars = str
str = vars[1]
end
return (string.gsub(str, "({([^}]+)})",
function(whole, i)
return vars[i] or whole
end))
end
-- Lazy loading for Module:Item link
function h.item_link(args)
if not f_item_link then
f_item_link = require('Module:Item link').item_link
end
return f_item_link(args)
end
-- Lazy loading for Module:Skill link
function h.skill_link(args)
if not f_skill_link then
f_skill_link = require('Module:Skill link').skill_link
end
return f_skill_link(args)
end
function h.na_or_val(tr, value, func)
if value == nil or value == '' then
tr:wikitext(m_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
h.tbl = {}
function h.tbl.range_fields(args)
local suffixes = {'maximum', 'text', 'colour'}
if args.full then
suffixes[#suffixes+1] = 'minimum'
end
return function()
local fields = {}
local inner = function (field)
for _, partial_field in ipairs(suffixes) do
fields[#fields+1] = string.format('%s_range_%s', field, partial_field)
end
end
if type(args.field) == 'table' then
for _, field in ipairs(args.field) do
inner(field)
end
else
inner(args.field)
end
return fields
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, fields, data2)
local values = {}
local fmt_values = {}
local sdata = data2.skill_levels[data['items._pageName']]
for index, field in ipairs(fields) do
local value = {
min=data[field],
max=data[field],
base=data[field],
}
if sdata then --For skill data
-- Use the fixed value, or the first-level value.
value.min = value.min or sdata['0'][field] or sdata['1'][field]
-- Fall back to the fixed value, and then the max level value.
value.max = value.max or sdata['0'][field] or sdata[data['skill.max_level']][field]
end
if value.min then
values[#values+1] = value.max
local opts = args.options[index] or {}
-- global colour is set, no overrides
if args.colour ~= nil then
opts.no_color = true
end
fmt_values[#fmt_values+1] = m_util.html.format_value(nil, value, opts)
end
end
if #values == 0 then
tr:wikitext(m_util.html.td.na())
else
local td = tr:tag('td')
td:attr('data-sort-value', table.concat(values, ', '))
td:wikitext(table.concat(fmt_values, ', '))
if args.colour then
td:attr('class', 'tc -' .. args.colour)
end
end
end
end
function h.tbl.display.factory.range(args)
-- args: table
-- property
return function (tr, data, fields)
tr
:tag('td')
:attr('data-sort-value', data[string.format('%s_range_maximum', args.field)] or '0')
:attr('class', 'tc -' .. (data[string.format('%s_range_colour', args.field)] or 'default'))
:wikitext(data[string.format('%s_range_text', args.field)])
:done()
end
end
function h.tbl.display.factory.range_composite(args)
-- division by default
if args.func == nil then
args.func = function (a, b)
if b == 0 then
return 'fail'
end
return a / b
end
end
return function(tr, data, fields)
local field = {}
for i=1, 2 do
local fieldn = args['field' .. i]
field[i] = {
min = tonumber(data[string.format('%s_range_minimum', fieldn)]) or 0,
max = tonumber(data[string.format('%s_range_maximum', fieldn)]) or 0,
color = data[string.format('%s_range_colour', fieldn)] or 'default',
}
end
field.min = args.func(field[1].min, field[2].min)
field.max = args.func(field[1].max, field[2].max)
if field.min == 'fail' or field.max == 'fail' then
field.text = ''
field.color = 'default'
else
for i=1, 2 do
if field[i].color ~= 'default' then
field.color = field[i].color
break
end
end
if field.min == field.max then
field.text = string.format('%.2f', field.min)
else
field.text = string.format('(%.2f-%.2f)', field.min, field.max)
end
end
tr
:tag('td')
:attr('data-sort-value', field.max)
:attr('class', 'tc -' .. field.color)
:wikitext(field.text)
:done()
end
end
function h.tbl.display.factory.descriptor_value(args)
-- Arguments:
-- key
-- tbl
args = args or {}
return function (value)
if args.tbl[args.key] then
value = m_util.html.abbr(value, args.tbl[args.key])
end
return value
end
end
function h.tbl.display.factory.atlas_tier(args)
args = args or {}
return function (tr, data)
for i=0,4 do
local t = tonumber(data['atlas_maps.map_tier' .. i])
if t == 0 then
tr
:tag('td')
:attr('table-sort-value', 0)
:attr('class', 'table-cell-xmark')
:wikitext('✗')
else
if args.is_level then
t = t + 67
end
tr
:tag('td')
:attr('class', 'tc -value')
:wikitext(t)
:done()
end
end
end
end
-- ----------------------------------------------------------------------------
-- Data mappings
-- ----------------------------------------------------------------------------
local data_map = {}
-- for sort type see:
-- https://meta.wikimedia.org/wiki/Help:Sorting
data_map.generic_item = {
{
arg = 'base_item',
header = i18n.item_table.base_item,
fields = {'items.base_item', 'items.base_item_page'},
display = function(tr, data)
tr
:tag('td')
:attr('data-sort-value', data['items.base_item'])
:wikitext(string.format('[[%s|%s]]', data['items.base_item_page'], data['items.base_item']))
end,
order = 1000,
sort_type = 'text',
},
{
arg = 'class',
header = i18n.item_table.item_class,
fields = {'items.class'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='[[%s]]',
},
}},
order = 1001,
sort_type = 'text',
},
{
arg = 'rarity',
header = i18n.item_table.rarity,
fields = {'items.rarity'},
display = h.tbl.display.factory.value{},
order = 1002,
},
{
arg = 'rarity_id',
header = i18n.item_table.rarity_id,
fields = {'items.rarity_id'},
display = h.tbl.display.factory.value{},
order = 1003,
},
{
arg = 'metadata_id',
header = i18n.item_table.metadata_id,
fields = {'items.metadata_id'},
display = h.tbl.display.factory.value{},
order = 1004,
},
{
arg = {'size'},
header = i18n.item_table.inventory_size,
fields = {'items.size_x', 'items.size_y'},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['items.size_x'] * data['items.size_y'])
:wikitext(string.format('%s×%s', data['items.size_x'], data['items.size_y']))
end,
order = 1005,
},
{
arg = 'essence',
header = i18n.item_table.essence_level,
fields = {'essences.level'},
display = h.tbl.display.factory.value{},
order = 1100,
},
{
arg = {'drop', 'drop_level'},
header = i18n.item_table.drop_level,
fields = {'items.drop_level'},
display = h.tbl.display.factory.value{},
order = 1200,
},
{
arg = {'drop_level_maximum'},
header = i18n.item_table.drop_level_maximum,
fields = {'items.drop_level_maximum'},
display = h.tbl.display.factory.value{},
order = 1201,
},
{
arg = 'stack_size',
header = i18n.item_table.stack_size,
fields = {'stackables.stack_size'},
display = h.tbl.display.factory.value{},
order = 1300,
},
{
arg = 'stack_size_currency_tab',
header = i18n.item_table.stack_size_currency_tab,
fields = {'stackables.stack_size_currency_tab'},
display = h.tbl.display.factory.value{},
order = 1301,
},
-- Requirements
{
arg = 'level',
header = m_game.level_requirement.icon,
fields = h.tbl.range_fields{field='items.required_level'},
display = h.tbl.display.factory.range{field='items.required_level'},
order = 1400,
},
{
arg = 'str',
header = '[[File:StrengthIcon small.png|link=|alt=Required strength]]',
fields = h.tbl.range_fields{field='items.required_strength'},
display = h.tbl.display.factory.range{field='items.required_strength'},
order = 1401,
},
{
arg = 'dex',
header = '[[File:DexterityIcon small.png|link=|alt=Required dexterity]]',
fields = h.tbl.range_fields{field='items.required_dexterity'},
display = h.tbl.display.factory.range{field='items.required_dexterity'},
order = 1402,
},
{
arg = 'int',
header = '[[File:IntelligenceIcon small.png|link=|alt=Required intelligence]]',
fields = h.tbl.range_fields{field='items.required_intelligence'},
display = h.tbl.display.factory.range{field='items.required_intelligence'},
order = 1403,
},
-- Armour 15xx
{
arg = 'ar',
header = i18n.item_table.armour,
fields = h.tbl.range_fields{field='armours.armour'},
display = h.tbl.display.factory.range{field='armours.armour'},
order = 1500,
},
{
arg = 'ev',
header =i18n.item_table.evasion,
fields = h.tbl.range_fields{field='armours.evasion'},
display = h.tbl.display.factory.range{field='armours.evasion'},
order = 1501,
},
{
arg = 'es',
header = i18n.item_table.energy_shield,
fields = h.tbl.range_fields{field='armours.energy_shield'},
display = h.tbl.display.factory.range{field='armours.energy_shield'},
order = 1502,
},
{
arg = 'wd',
header = i18n.item_table.ward,
fields = h.tbl.range_fields{field='armours.ward'},
display = h.tbl.display.factory.range{field='armours.ward'},
order = 1503,
},
{
arg = 'block',
header = i18n.item_table.block,
fields = h.tbl.range_fields{field='shields.block'},
display = h.tbl.display.factory.range{field='shields.block'},
order = 1504,
},
--[[{
arg = 'physical_damage_min',
header = m_util.html.abbr('Min', 'Local minimum weapon damage'),
fields = h.tbl.range_fields('minimum physical damage'),
display = h.tbl.display.factory.range{field='minimum physical damage'},
order = 7000,
},
{
arg = 'physical_damage_max',
header = m_util.html.abbr('Max', 'Local maximum weapon damage'),
fields = h.tbl.range_fields('maximum physical damage'),
display = h.tbl.display.factory.range{field='maximum physical damage'},
order = 7001,
},]]--
-- Weapons 16xx
{
arg = {'weapon', 'damage'},
header = i18n.item_table.damage,
fields = {'weapons.damage_html', 'weapons.damage_avg'},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['weapons.damage_avg'])
:wikitext(data['weapons.damage_html'])
end,
order = 1600,
},
{
arg = {'weapon', 'aps'},
header = i18n.item_table.attacks_per_second,
fields = h.tbl.range_fields{field='weapons.attack_speed'},
display = h.tbl.display.factory.range{field='weapons.attack_speed'},
order = 1601,
},
{
arg = {'weapon', 'crit'},
header = i18n.item_table.local_critical_strike_chance,
fields = h.tbl.range_fields{field='weapons.critical_strike_chance'},
display = h.tbl.display.factory.range{field='weapons.critical_strike_chance'},
order = 1602,
},
{
arg = {'physical_dps'},
header = i18n.item_table.physical_dps,
fields = h.tbl.range_fields{field='weapons.physical_dps'},
display = h.tbl.display.factory.range{field='weapons.physical_dps'},
order = 1603,
},
{
arg = {'lightning_dps'},
header = i18n.item_table.lightning_dps,
fields = h.tbl.range_fields{field='weapons.lightning_dps'},
display = h.tbl.display.factory.range{field='weapons.lightning_dps'},
order = 1604,
},
{
arg = {'cold_dps'},
header = i18n.item_table.cold_dps,
fields = h.tbl.range_fields{field='weapons.cold_dps'},
display = h.tbl.display.factory.range{field='weapons.cold_dps'},
order = 1605,
},
{
arg = {'fire_dps'},
header = i18n.item_table.fire_dps,
fields = h.tbl.range_fields{field='weapons.fire_dps'},
display = h.tbl.display.factory.range{field='weapons.fire_dps'},
order = 1606,
},
{
arg = {'chaos_dps'},
header = i18n.item_table.chaos_dps,
fields = h.tbl.range_fields{field='weapons.chaos_dps'},
display = h.tbl.display.factory.range{field='weapons.chaos_dps'},
order = 1607,
},
{
arg = {'elemental_dps'},
header = i18n.item_table.elemental_dps,
fields = h.tbl.range_fields{field='weapons.elemental_dps'},
display = h.tbl.display.factory.range{field='weapons.elemental_dps'},
order = 1608,
},
{
arg = {'poison_dps'},
header = i18n.item_table.poison_dps,
fields = h.tbl.range_fields{field='weapons.poison_dps'},
display = h.tbl.display.factory.range{field='weapons.poison_dps'},
order = 1609,
},
{
arg = {'dps'},
header = i18n.item_table.dps,
fields = h.tbl.range_fields{field='weapons.dps'},
display = h.tbl.display.factory.range{field='weapons.dps'},
order = 1610,
},
-- Flasks 17xx
{
arg = 'flask_life',
header = i18n.item_table.flask_life,
fields = h.tbl.range_fields{field='flasks.life'},
display = h.tbl.display.factory.range{field='flasks.life'},
order = 1700,
},
{
arg = 'flask_life_per_second',
header = i18n.item_table.flask_life_per_second,
fields = h.tbl.range_fields{field={'flasks.life', 'flasks.duration'}, full=true},
display = h.tbl.display.factory.range_composite{field1='flasks.life', field2='flasks.duration'},
order = 1701,
},
{
arg = 'flask_life_per_charge',
header = i18n.item_table.flask_life_per_charge,
fields = h.tbl.range_fields{field={'flasks.life', 'flasks.charges_per_use'}, full=true},
display = h.tbl.display.factory.range_composite{field1='flasks.life', field2='flasks.charges_per_use'},
order = 1702,
},
{
arg = 'flask_mana',
header = i18n.item_table.flask_mana,
fields = h.tbl.range_fields{field='flasks.mana'},
display = h.tbl.display.factory.range{field='flasks.mana'},
order = 1703,
},
{
arg = 'flask_mana_per_second',
header = i18n.item_table.flask_mana_per_second,
fields = h.tbl.range_fields{field={'flasks.mana', 'flasks.duration'}, full=true},
display = h.tbl.display.factory.range_composite{field1='flasks.mana', field2='flasks.duration'},
order = 1704,
},
{
arg = 'flask_mana_per_charge',
header = i18n.item_table.flask_mana_per_charge,
fields = h.tbl.range_fields{field={'flasks.mana', 'flasks.charges_per_use'}, full=true},
display = h.tbl.display.factory.range_composite{field1='flasks.mana', field2='flasks.charges_per_use'},
order = 1705,
},
{
arg = 'flask',
header = i18n.item_table.flask_duration,
fields = h.tbl.range_fields{field='flasks.duration'},
display = h.tbl.display.factory.range{field='flasks.duration'},
order = 1706,
},
{
arg = 'flask',
header = i18n.item_table.flask_charges_per_use,
fields = h.tbl.range_fields{field='flasks.charges_per_use'},
display = h.tbl.display.factory.range{field='flasks.charges_per_use'},
order = 1707,
},
{
arg = 'flask',
header = i18n.item_table.flask_maximum_charges,
fields = h.tbl.range_fields{field='flasks.charges_max'},
display = h.tbl.display.factory.range{field='flasks.charges_max'},
order = 1708,
},
-- Jewels 18xx
{
arg = 'jewel_limit',
header = i18n.item_table.jewel_limit,
fields = {'jewels.jewel_limit'},
display = h.tbl.display.factory.value{},
order = 1800,
},
{
arg = 'jewel_radius',
header = i18n.item_table.jewel_radius,
fields = {'jewels.radius_html'},
display = function (tr, data)
tr
:tag('td')
:wikitext(data['jewels.radius_html'])
end,
order = 1801,
},
-- Maps 19xx
{
arg = 'map_tier',
header = i18n.item_table.map_tier,
fields = {'maps.tier'},
display = h.tbl.display.factory.value{},
order = 1900,
},
{
arg = 'map_level',
header = i18n.item_table.map_level,
fields = {'maps.area_level'},
display = h.tbl.display.factory.value{},
order = 1901,
},
{
arg = 'map_guild_character',
header = i18n.item_table.map_guild_character,
fields = {'maps.guild_character'},
display = h.tbl.display.factory.value{},
order = 1902,
sort_type = 'text',
},
{
arg = 'map_series',
header = i18n.item_table.map_series,
fields = {'maps.series'},
display = h.tbl.display.factory.value{},
order = 1903,
},
{
arg = 'atlas_tier',
header = i18n.item_table.atlas_tier,
colspan = 5,
fields = {'atlas_maps.map_tier0', 'atlas_maps.map_tier1', 'atlas_maps.map_tier2', 'atlas_maps.map_tier3', 'atlas_maps.map_tier4'},
display = h.tbl.display.factory.atlas_tier{is_level=false},
order = 1904,
},
{
arg = 'atlas_level',
header = i18n.item_table.atlas_level,
colspan = 5,
fields = {'atlas_maps.map_tier0', 'atlas_maps.map_tier1', 'atlas_maps.map_tier2', 'atlas_maps.map_tier3', 'atlas_maps.map_tier4'},
display = h.tbl.display.factory.atlas_tier{is_level=true},
order = 1905,
},
-- Map fragments 20xx
{
arg = {'map_fragment', 'map_fragment_limit'},
header = i18n.item_table.map_fragment_limit,
fields = {'map_fragments.map_fragment_limit'},
display = h.tbl.display.factory.value{},
order = 2000,
},
-- Hideout decorations 21xx
{
arg = {'doodad', 'variation_count'},
header = i18n.item_table.variation_count,
fields = {'hideout_doodads.variation_count'},
display = h.tbl.display.factory.value{colour='mod'},
order = 2100,
},
-- Corpse items 22xx
{
arg = {'corpse', 'monster_category'},
header = i18n.item_table.monster_category,
fields = {'corpse_items.monster_category', 'corpse_items.monster_category_html'},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', m_game.constants.monster.categories[data['corpse_items.monster_category']].id)
:wikitext(data['corpse_items.monster_category_html'])
end,
order = 2200,
},
{
arg = {'corpse', 'monster_abilities'},
header = i18n.item_table.monster_abilities,
fields = {'corpse_items.monster_abilities'},
display = h.tbl.display.factory.value{colour='mod'},
order = 2201,
sort_type = 'text',
},
-- Tinctures 23xx
{
arg = {'tincture'},
header = i18n.item_table.tincture_debuff_interval,
fields = h.tbl.range_fields{field='tinctures.debuff_interval'},
display = h.tbl.display.factory.range{field='tinctures.debuff_interval'},
order = 2300,
},
{
arg = {'tincture'},
header = i18n.item_table.tincture_cooldown,
fields = h.tbl.range_fields{field='tinctures.cooldown'},
display = h.tbl.display.factory.range{field='tinctures.cooldown'},
order = 2301,
},
-- Seed data 91xx,
{
arg = {'seed', 'seed_type'},
header = i18n.item_table.seed_type,
fields = {'harvest_seeds.type', 'harvest_seeds.type_id'},
display = function (tr, data)
tr
:tag('td')
:attr('table-sort-value', data['harvest_seeds.type'])
:attr('class', 'tc -' .. data['harvest_seeds.type_id'])
:wikitext(data['harvest_seeds.type'])
end,
order = 9100,
},
{
arg = {'seed', 'seed_tier'},
header = i18n.item_table.seed_tier,
fields = {'harvest_seeds.tier'},
display = h.tbl.display.factory.value{},
order = 9101,
},
{
arg = {'seed', 'seed_growth_cycles'},
header = i18n.item_table.seed_growth_cycles,
fields = {'harvest_seeds.growth_cycles'},
display = h.tbl.display.factory.value{},
order = 9102,
},
{
arg = {'seed', 'seed_cosumed_lifeforce', 'seed_consumed_lifeforce_percentage', 'seed_consumed_primal_lifeforce_percentage'},
header = i18n.item_table.seed_consumed_primal_lifeforce_percentage,
fields = {'harvest_seeds.consumed_primal_lifeforce_percentage'},
display = h.tbl.display.factory.value{color='primal'},
order = 9110,
},
{
arg = {'seed', 'seed_cosumed_lifeforce', 'seed_consumed_lifeforce_percentage', 'seed_consumed_vivid_lifeforce_percentage'},
header = i18n.item_table.seed_consumed_vivid_lifeforce_percentage,
fields = {'harvest_seeds.consumed_vivid_lifeforce_percentage'},
display = h.tbl.display.factory.value{color='vivid'},
order = 9110,
},
{
arg = {'seed', 'seed_cosumed_lifeforce', 'seed_consumed_lifeforce_percentage', 'seed_consumed_wild_lifeforce_percentage'},
header = i18n.item_table.seed_consumed_wild_lifeforce_percentage,
fields = {'harvest_seeds.consumed_wild_lifeforce_percentage'},
display = h.tbl.display.factory.value{color='wild'},
order = 9110,
},
{
arg = {'seed', 'seed_required_nearby_seeds', 'seed_required_nearby_seed_amount'},
header = i18n.item_table.seed_required_nearby_seed_amount,
fields = {'harvest_seeds.required_nearby_seed_amount'},
display = h.tbl.display.factory.value{},
order = 9113,
},
{
arg = {'seed', 'seed_required_nearby_seeds', 'seed_required_nearby_seed_tier'},
header = i18n.item_table.seed_required_nearby_seed_tier,
fields = {'harvest_seeds.required_nearby_seed_tier'},
display = h.tbl.display.factory.value{},
order = 9114,
},
{
arg = 'buff',
header = i18n.item_table.buff_effects,
fields = {'item_buffs.stat_text'},
display = h.tbl.display.factory.value{colour='mod'},
order = 12000,
sort_type = 'text',
},
{
arg = 'stat',
header = i18n.item_table.stats,
fields = {'items.stat_text'},
display = h.tbl.display.factory.value{colour='mod'},
order = 12001,
sort_type = 'text',
},
{
arg = 'description',
header = i18n.item_table.description,
fields = {'items.description'},
display = h.tbl.display.factory.value{colour='mod'},
order = 12002,
sort_type = 'text',
},
{
arg = {'seed', 'seed_effect'},
header = i18n.item_table.seed_effects,
fields = {'harvest_seeds.effect'},
display = h.tbl.display.factory.value{colour='crafted'},
order = 12003,
sort_type = 'text',
},
{
arg = 'flavour_text',
header = i18n.item_table.flavour_text,
fields = {'items.flavour_text'},
display = h.tbl.display.factory.value{colour='flavour'},
order = 12006,
sort_type = 'text',
},
{
arg = 'help_text',
header = i18n.item_table.help_text,
fields = {'items.help_text'},
display = h.tbl.display.factory.value{colour='help'},
order = 12008,
sort_type = 'text',
},
{
arg = {'prophecy', 'objective'},
header = i18n.item_table.objective,
fields = {'prophecies.objective'},
display = h.tbl.display.factory.value{},
order = 13002,
},
{
arg = {'prophecy', 'reward'},
header = i18n.item_table.reward,
fields = {'prophecies.reward'},
display = h.tbl.display.factory.value{},
order = 13001,
},
{
arg = {'prophecy', 'seal_cost'},
header = i18n.item_table.seal_cost,
fields = {'prophecies.seal_cost'},
display = h.tbl.display.factory.value{colour='currency'},
order = 13002,
},
{
arg = {'prediction_text'},
header = i18n.item_table.prediction_text,
fields = {'prophecies.prediction_text'},
display = h.tbl.display.factory.value{colour='value'},
order = 12004,
sort_type = 'text',
},
{
arg = 'buff_icon',
header = i18n.item_table.buff_icon,
fields = {'item_buffs.icon'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='[[%s]]',
},
}},
order = 14000,
sort_type = 'text',
},
{
arg = {'version', 'release_version'},
header = i18n.item_table.release_version,
fields = {'items.release_version'},
display = function(tr, data)
tr
:tag('td')
:wikitext(
string.format(
i18n.item_table.version_link,
data['items.release_version'],
data['items.release_version']
)
)
end,
order = 15000,
},
{
arg = {'version', 'removal_version'},
header = i18n.item_table.removal_version,
fields = {'items.removal_version'},
display = function(tr, data)
tr
:tag('td')
:wikitext(
string.format(
i18n.item_table.version_link,
data['items.removal_version'],
data['items.removal_version']
)
)
end,
order = 15001,
},
{
arg = {'drop', 'drop_enabled'},
header = i18n.item_table.drop_enabled,
fields = {'items.drop_enabled'},
display = h.tbl.display.factory.value{},
order = 15002,
},
{
arg = {'drop', 'drop_areas'},
header = i18n.item_table.drop_areas,
fields = {'items.drop_areas_html'},
display = h.tbl.display.factory.value{},
order = 15004,
sort_type = 'text',
},
{
arg = {'drop', 'drop_monsters'},
header = i18n.item_table.drop_monsters,
fields = {'items.drop_monsters'},
display = function(tr, data, na, results2)
if results2['drop_monsters_query'] == nil then
results2['drop_monsters_query'] = m_cargo.query(
{'items', 'monsters', 'main_pages'},
{
'items._pageName',
'monsters._pageName',
'monsters.name',
'main_pages._pageName',
},
{
join=[[
items.drop_monsters HOLDS monsters.metadata_id,
monsters.metadata_id=main_pages.id
]],
where=string.format([[
items._pageID IN (%s)
AND monsters.metadata_id IS NOT NULL
]],
table.concat(results2.pageIDs, ', ')
),
orderBy='items.drop_monsters',
}
)
results2['drop_monsters_query'] = m_cargo.map_results_to_id{
results=results2['drop_monsters_query'],
field='items._pageName',
}
end
local results = results2['drop_monsters_query'][data['items._pageName']] or {}
local tbl = {}
for _,v in ipairs(results) do
local page = v['main_pages._pageName'] or v['monsters._pageName'] or ''
local name = v['monsters.name'] or v['items.drop_monsters'] or ''
tbl[#tbl+1] = string.format('[[%s|%s]]', page, name)
end
h.na_or_val(tr, table.concat(tbl, '<br>'))
end,
order = 15005,
sort_type = 'text',
},
{
arg = {'drop', 'drop_text'},
header = i18n.item_table.drop_text,
fields = {'items.drop_text'},
display = h.tbl.display.factory.value{},
order = 15006,
sort_type = 'text',
},
{
arg = {'quest'},
header = i18n.item_table.quest_rewards,
fields = {'items._pageName'},
display = function(tr, data, na, results2)
if results2['quest_query'] == nil then
results2['quest_query'] = m_cargo.query(
{'items', 'quest_rewards'},
{
'quest_rewards._pageName',
'quest_rewards.classes',
'quest_rewards.act',
'quest_rewards.quest'
},
{
join='items._pageName=quest_rewards._pageName',
where=string.format(
'items._pageID IN (%s) AND quest_rewards._pageName IS NOT NULL',
table.concat(results2.pageIDs, ', ')
),
orderBy='quest_rewards.act, quest_rewards.quest',
}
)
results2['quest_query'] = m_cargo.map_results_to_id{
results=results2['quest_query'],
field='quest_rewards._pageName',
}
end
local results = results2['quest_query'][data['items._pageName']] or {}
local tbl = {}
for _, v in ipairs(results) do
local classes = table.concat(m_util.string.split(v['quest_rewards.classes'] or '', ',%s*'), ', ')
if classes == '' or classes == nil then
classes = i18n.item_table.quest_rewards_any_classes
end
tbl[#tbl+1] = string.format(
i18n.item_table.quest_rewards_row_format,
v['quest_rewards.act'],
v['quest_rewards.quest'],
classes
)
end
local value = table.concat(tbl, '<br>')
if value == nil or value == '' then
tr:wikitext(m_util.html.td.na())
else
tr
:tag('td')
:attr('style', 'text-align:left')
:wikitext(value)
end
end,
order = 16001,
sort_type = 'text',
},
{
arg = {'vendor'},
header = i18n.item_table.vendor_rewards,
fields = {'items._pageName'},
display = function(tr, data, na, results2)
if results2['vendor_query'] == nil then
results2['vendor_query'] = m_cargo.query(
{'items', 'vendor_rewards'},
{
'vendor_rewards._pageName',
'vendor_rewards.classes',
'vendor_rewards.act',
'vendor_rewards.npc',
'vendor_rewards.quest',
},
{
join='items._pageName=vendor_rewards._pageName',
where=string.format(
'items._pageID IN (%s) AND vendor_rewards._pageName IS NOT NULL',
table.concat(results2.pageIDs, ', ')
),
orderBy='vendor_rewards.act, vendor_rewards.quest',
}
)
results2['vendor_query'] = m_cargo.map_results_to_id{
results=results2['vendor_query'],
field='vendor_rewards._pageName',
}
end
local results = results2['vendor_query'][data['items._pageName']] or {}
local tbl = {}
for _, v in ipairs(results) do
local classes = table.concat(m_util.string.split(v['vendor_rewards.classes'] or '', ',%s*'), ', ')
if classes == '' or classes == nil then
classes = i18n.item_table.vendor_rewards_any_classes
end
tbl[#tbl+1] = string.format(
i18n.item_table.vendor_rewards_row_format,
v['vendor_rewards.act'],
v['vendor_rewards.quest'],
v['vendor_rewards.npc'],
classes
)
end
local value = table.concat(tbl, '<br>')
if value == nil or value == '' then
tr:wikitext(m_util.html.td.na())
else
tr
:tag('td')
:attr('style', 'text-align:left')
:wikitext(value)
end
end,
order = 17001,
sort_type = 'text',
},
{
arg = {'price', 'purchase_cost'},
header = i18n.item_table.purchase_costs,
fields = {'item_purchase_costs.name', 'item_purchase_costs.amount'},
display = function (tr, data)
-- Can purchase costs have multiple currencies and rows?
-- Just switch to the same method as in sell_price then.
local tbl = {}
if data['item_purchase_costs.name'] ~= nil then
tbl[#tbl+1] = string.format(
'%sx %s',
data['item_purchase_costs.amount'],
h.item_link{data['item_purchase_costs.name']}
)
end
h.na_or_val(tr, table.concat(tbl, '<br>'))
end,
order = 18001,
sort_type = 'text',
},
{
arg = {'price', 'sell_price'},
header = i18n.item_table.sell_price,
fields = {'item_sell_prices.name', 'item_sell_prices.amount'},
display = function(tr, data, na, results2)
if results2['sell_price_query'] == nil then
results2['sell_price_query'] = m_cargo.query(
{'items', 'item_sell_prices'},
{
'item_sell_prices.name',
'item_sell_prices.amount',
'item_sell_prices._pageID'
},
{
join='items._pageID=item_sell_prices._pageID',
where=string.format(
'items._pageID IN (%s) AND item_sell_prices._pageID IS NOT NULL',
table.concat(results2.pageIDs, ', ')
),
orderBy='item_sell_prices.name',
}
)
results2['sell_price_query'] = m_cargo.map_results_to_id{
results=results2['sell_price_query'],
field='item_sell_prices._pageID',
}
end
local results = results2['sell_price_query'][data['items._pageID']] or {}
local tbl = {}
for _,v in ipairs(results) do
tbl[#tbl+1] = string.format(
'%sx %s',
v['item_sell_prices.amount'],
h.item_link{v['item_sell_prices.name']}
)
end
h.na_or_val(tr, table.concat(tbl, '<br>'))
end,
order = 18002,
sort_type = 'text',
},
{
arg = {'boss', 'boss_name'},
header = i18n.item_table.boss_name,
fields = {'maps.area_id'},
display = function(tr, data, na, results2)
if results2['boss_query'] == nil then
results2['boss_query'] = m_cargo.query(
{'items', 'maps', 'areas', 'monsters', 'main_pages'},
{
'items._pageName',
'maps.area_id',
'areas.id',
'areas.boss_monster_ids',
'monsters._pageName',
'monsters.name',
'main_pages._pageName',
},
{
join=[[
items._pageID=maps._pageID,
maps.area_id=areas.id,
areas.boss_monster_ids HOLDS monsters.metadata_id,
monsters.metadata_id=main_pages.id
]],
where=string.format([[
items._pageID IN (%s)
AND maps.area_id IS NOT NULL
AND areas.boss_monster_ids HOLDS LIKE "%%"
]],
table.concat(results2.pageIDs, ', ')
),
orderBy='areas.boss_monster_ids',
}
)
results2['boss_query'] = m_cargo.map_results_to_id{
results=results2['boss_query'],
field='items._pageName',
}
end
local results = results2['boss_query'][data['items._pageName']] or {}
local tbl = {}
for _,v in ipairs(results) do
local page = v['main_pages._pageName'] or v['monsters._pageName'] or ''
local name = v['monsters.name'] or v['areas.boss_monster_ids'] or ''
tbl[#tbl+1] = string.format('[[%s|%s]]', page, name)
end
h.na_or_val(tr, table.concat(tbl, '<br>'))
end,
order = 19001,
sort_type = 'text',
},
{
arg = {'boss', 'boss_number'},
header = i18n.item_table.boss_number,
fields = {'maps.area_id'},
display = function(tr, data, na, results2)
if results2['boss_query'] == nil then
results2['boss_query'] = m_cargo.query(
{'items', 'maps', 'areas', 'monsters', 'main_pages'},
{
'items._pageName',
'maps.area_id',
'areas.id',
'areas.boss_monster_ids',
'monsters._pageName',
'monsters.name',
'main_pages._pageName',
},
{
join=[[
items._pageID=maps._pageID,
maps.area_id=areas.id,
areas.boss_monster_ids HOLDS monsters.metadata_id,
monsters.metadata_id=main_pages.id
]],
where=string.format([[
items._pageID IN (%s)
AND maps.area_id IS NOT NULL
AND areas.boss_monster_ids HOLDS LIKE "%%"
]],
table.concat(results2.pageIDs, ', ')
),
orderBy='areas.boss_monster_ids',
}
)
results2['boss_query'] = m_cargo.map_results_to_id{
results=results2['boss_query'],
field='items._pageName',
}
end
local results = results2['boss_query'][data['items._pageName']] or {}
local tbl = {}
for _,v in ipairs(results) do
tbl[#tbl+1] = v['areas.boss_monster_ids']
end
h.na_or_val(tr, #tbl)
end,
order = 19002,
},
{
arg = {'legacy'},
header = i18n.item_table.legacy,
fields = {'items.name'},
display = function(tr, data, na, results2)
if results2['legacy_query'] == nil then
results2['legacy_query'] = m_cargo.query(
{'items', 'legacy_variants'},
{
'items._pageID',
'items._pageName',
'items.frame_type',
'legacy_variants.removal_version',
'legacy_variants.implicit_stat_text',
'legacy_variants.explicit_stat_text',
'legacy_variants.stat_text',
'legacy_variants.base_item',
'legacy_variants.required_level'
},
{
join='items._pageID=legacy_variants._pageID',
where='legacy_variants.removal_version IS NOT NULL',
where=string.format(
'items._pageID IN (%s) AND legacy_variants.removal_version IS NOT NULL',
table.concat(results2.pageIDs, ', ')
),
orderBy='items._pageName',
}
)
results2['legacy_query'] = m_cargo.map_results_to_id{
results=results2['legacy_query'],
field='items._pageName',
}
end
local results = results2['legacy_query'][data['items._pageName']] or {}
local tbl = mw.html.create('table')
:attr('width', '100%')
for _, v in ipairs(results) do
local cell = {}
local l = {
'legacy_variants.base_item',
'legacy_variants.stat_text'
}
-- Clean up data:
for _, k in ipairs(l) do
if v[k] ~= nil then
local s = m_util.string.split(v[k], '*')
local s_flt = {}
for _, sss in ipairs(s) do
if sss ~= nil and sss ~= '' then
s_flt[#s_flt+1] = string.gsub(sss, '\n', '')
end
end
cell[#cell+1] = table.concat(s_flt, '<br>')
end
end
local sep = string.format(
'<span class="item-stat-separator -%s"></span>',
v['items.frame_type']
)
tbl
:tag('tr')
:attr('class', 'upgraded-from-set')
:tag('td')
:wikitext(
v['legacy_variants.removal_version']
)
:done()
:tag('td')
:attr('class', 'group legacy-stats plainlist')
:wikitext(table.concat(cell, sep))
:done()
:done()
end
tr
:tag('td')
:node(tbl)
end,
order = 21001,
sort_type = 'text',
},
{
arg = {'granted_skills'},
header = i18n.item_table.granted_skills,
fields = {'items.name'},
display = function(tr, data, na, results2)
if results2['granted_skills_query'] == nil then
results2['granted_skills_query'] = m_cargo.query(
{'items', 'item_mods', 'mods', 'skill', 'items=items2'},
{
'items._pageName',
'items.name',
'item_mods.id',
'mods._pageName',
'mods.id',
'mods.granted_skill',
'mods.stat_text_raw',
'skill._pageName',
'skill.skill_id',
'skill.active_skill_name',
'skill.skill_icon',
'skill.stat_text',
'items2.class',
'items2.name',
'items2.inventory_icon',
'items2.size_x',
'items2.size_y',
'items2.html',
},
{
join='items._pageID=item_mods._pageID, item_mods.id=mods.id, mods.granted_skill=skill.skill_id, skill._pageID=items2._pageID',
where=string.format(
'items._pageID IN (%s) AND mods.granted_skill IS NOT NULL',
table.concat(results2.pageIDs, ', ')
),
}
)
results2['granted_skills_query'] = m_cargo.map_results_to_id{
results=results2['granted_skills_query'],
field='items._pageName',
}
end
local results = results2['granted_skills_query'][data['items._pageName']] or {}
local tbl = {}
for _, v in ipairs(results) do
-- Check if a level for the skill is specified in the
-- mod stat text.
-- Stat ids have unreliable naming convention so using
-- the mod stat text instead.
local level = ''
local stat_text = v['mods.stat_text_raw'] or ''
local level_number = string.match(
stat_text:lower(),
h.string.format(
i18n.item_table.granted_skills_level_pattern,
{
granted_skills_level_label = i18n.item_table.granted_skills_level_label:lower()
}
)
)
-- If a level number was specified in the stat text
-- then add it to the cell:
if level_number then
level = h.string.format(
i18n.item_table.granted_skills_level_format,
{
granted_skills_level_label = i18n.item_table.granted_skills_level_label,
level_number = level_number,
}
)
end
-- Use different formats depending on if it's a gem or
-- not:
if v['items2.class'] == nil then
tbl[#tbl+1] = h.string.format(
i18n.item_table.granted_skills_skill_output_format,
{
level = level,
sl = h.skill_link{
skip_query=true,
page = v['skill.active_skill_name']
or v['skill._pageName']
or v['mods._pageName']
or '',
name = v['skill.active_skill_name']
or v['skill.stat_text']
or v['mods.granted_skill'],
icon = v['skill.skill_icon'],
},
}
)
else
local il_args = {
skip_query=true,
page=v['items2._pageName'],
name=v['items2.name'],
inventory_icon=v['items2.inventory_icon'],
width=v['items2.size_x'],
height=v['items2.size_y'],
}
-- TODO: add in tpl_args.
if no_html == nil then
il_args.html = v['items2.html']
end
tbl[#tbl+1] = h.string.format(
i18n.item_table.granted_skills_gem_output_format,
{
level = level,
il = h.item_link(il_args),
}
)
end
end
h.na_or_val(tr, table.concat(tbl, '<br>'))
end,
order = 22001,
sort_type = 'text',
},
{
arg = 'alternate_art',
header = i18n.item_table.alternate_art,
fields = {'items.alternate_art_inventory_icons'},
display = function (tr, data)
local alt_art = m_util.string.split(
data['items.alternate_art_inventory_icons'],
','
)
-- TODO: Use il instead to handle size?
-- local size = 39
local out = {}
for i,v in ipairs(alt_art) do
out[#out+1] = string.format(
'[[%s|link=|%s]]',
v,
v
)
end
tr
:tag('td')
:wikitext(table.concat(out, ''))
end,
order = 23000,
sort_type = 'text',
},
}
data_map.skill_gem = {
{
arg = 'icon',
header = i18n.item_table.support_gem_letter,
fields = {'skill_gems.support_gem_letter_html'},
display = h.tbl.display.factory.value{},
order = 1000,
sort_type = 'text',
},
{
arg = 'skill_icon',
header = i18n.item_table.skill_icon,
fields = {'skill.skill_icon'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='[[%s]]',
},
}},
order = 1001,
sort_type = 'text',
},
{
arg = {'stat', 'stat_text'},
header = i18n.item_table.stats,
fields = {'skill.stat_text'},
display = h.tbl.display.factory.value{},
order = 2000,
sort_type = 'text',
},
{
arg = {'quality', 'quality_stat_text'},
header = i18n.item_table.quality_stats,
fields = {'skill.quality_stat_text'},
display = h.tbl.display.factory.value{},
order = 2001,
sort_type = 'text',
},
{
arg = 'description',
header = i18n.item_table.description,
fields = {'skill.description'},
display = h.tbl.display.factory.value{},
order = 2100,
sort_type = 'text',
},
{
arg = 'level',
header = m_game.level_requirement.icon,
fields = h.tbl.range_fields{field='items.required_level'},
display = h.tbl.display.factory.range{field='items.required_level'},
order = 3000,
},
{
arg = 'str',
header = '[[File:StrengthIcon small.png|link=|alt=Gem has strength requirement]]',
fields = {'skill_gems.strength_percent'},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['skill_gems.strength_percent'])
:wikitext('[[File:Yes.png|yes|link=]]')
end,
order = 3001,
},
{
arg = 'dex',
header = '[[File:DexterityIcon small.png|link=|alt=Gem has dexterity requirement]]',
fields = {'skill_gems.dexterity_percent'},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['skill_gems.dexterity_percent'])
:wikitext('[[File:Yes.png|yes|link=]]')
end,
order = 3002,
},
{
arg = 'int',
header = '[[File:IntelligenceIcon small.png|link=|alt=Gem has intelligence requirement]]',
fields = {'skill_gems.intelligence_percent'},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['skill_gems.intelligence_percent'])
:wikitext('[[File:Yes.png|yes|link=]]')
end,
order = 3003,
},
{
arg = 'crit',
header = i18n.item_table.skill_critical_strike_chance,
fields = {'skill_levels.critical_strike_chance'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='%s%%',
skill_levels = true,
},
}},
order = 4000,
options = {
[1] = {
skill_levels = true,
},
},
},
{
arg = 'cast_time',
header = i18n.item_table.cast_time,
fields = {'skill.cast_time'},
display = h.tbl.display.factory.value{options = {
}},
order = 4001,
options = {
},
},
{
arg = {'aspd', 'attack_speed', 'attack_speed_multiplier'},
header = i18n.item_table.attack_speed_multiplier,
fields = {'skill_levels.attack_speed_multiplier'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='%s%%',
skill_levels = true,
},
}},
order = 4002,
options = {
[1] = {
skill_levels = true,
},
},
},
{
arg = 'dmgeff',
header = i18n.item_table.damage_effectiveness,
fields = {'skill_levels.damage_effectiveness'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='%s%%',
skill_levels = true,
},
}},
order = 4003,
options = {
[1] = {
skill_levels = true,
},
},
},
{
arg = {'mcm', 'cost_multiplier'},
header = i18n.item_table.cost_multiplier,
fields = {'skill_levels.cost_multiplier'},
display = h.tbl.display.factory.value{options = {
[1] = {
fmt='%s%%',
skill_levels = true,
},
}},
order = 5000,
options = {
[1] = {
skill_levels = true,
},
},
},
{
arg = 'mana',
header = i18n.item_table.mana_cost,
fields = {'skill_levels.cost_amounts', 'skill_levels.mana_reservation_percent', 'skill_levels.mana_reservation_flat'},
display = function (tr, data, fields, data2)
local appendix = ''
local cost_field = ''
local sdata = data2.skill_levels[data['items._pageName']]
-- Percentage Mana reservation is in level 0 of most of the skill_levels at this point, but spellslinger and awakened blasphemy change it per-level
-- Flat Mana resservation is in real gem levels, but maybe there will be fixed flat mana reservations in the future.
-- Per-use mana costs are stored in the real gem levels if they change, or in 0 if it's fixed.
if(sdata['1']['skill_levels.mana_reservation_percent'] ~= nil or sdata['0']['skill_levels.mana_reservation_percent'] ~= nil) then
cost_field = 'skill_levels.mana_reservation_percent'
appendix = appendix .. '%%'
elseif(sdata['1']['skill_levels.mana_reservation_flat'] ~= nil or sdata['0']['skill_levels.mana_reservation_flat'] ~= nil) then
cost_field = 'skill_levels.mana_reservation_flat'
appendix = appendix .. ' ' .. i18n.item_table.reserves_mana_suffix
elseif(sdata['1']['skill_levels.cost_amounts'] ~= nil or sdata['0']['skill_levels.cost_amounts'] ~= nil) then
cost_field = 'skill_levels.cost_amounts'
end
h.tbl.display.factory.value{options = {
[1] = {
fmt='%d' .. appendix,
skill_levels = true,
},
}}(tr, data, {cost_field}, data2)
end,
order = 5001,
-- Need one set of options per field.
options = {
[1] = {
skill_levels = true,
},
[2] = {
skill_levels = true,
},
[3] = {
skill_levels = true,
},
},
},
{
arg = 'vaal',
header = i18n.item_table.vaal_souls_requirement,
fields = {'skill_levels.vaal_souls_requirement'},
display = h.tbl.display.factory.value{options = {
[1] = {
skill_levels = true,
},
}},
order = 6000,
options = {
[1] = {
skill_levels = true,
},
},
},
{
arg = 'vaal',
header = i18n.item_table.stored_uses,
fields = {'skill_levels.vaal_stored_uses'},
display = h.tbl.display.factory.value{options = {
[1] = {
skill_levels = true,
},
}},
order = 6001,
options = {
[1] = {
skill_levels = true,
},
},
},
{
arg = 'radius',
header = i18n.item_table.primary_radius,
fields = {'skill.radius', 'skill.radius_description'},
options = {[2] = {optional = true}},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['skill.radius'])
:wikitext(h.tbl.display.factory.descriptor_value{tbl=data, key='skill.radius_description'}(data['skill.radius']))
end,
order = 7000,
},
{
arg = 'radius',
header = i18n.item_table.secondary_radius,
fields = {'skill.radius_secondary', 'skill.radius_secondary_description'},
options = {[2] = {optional = true}},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['skill.radius_secondary'])
:wikitext(h.tbl.display.factory.descriptor_value{tbl=data, key='skill.radius_secondary_description'}(data['skill.radius_secondary']))
end,
order = 7001,
},
{
arg = 'radius',
header = i18n.item_table.tertiary_radius,
fields = {'skill.radius_tertiary', 'skill.radius_tertiary_description'},
options = {[2] = {optional = true}},
display = function (tr, data)
tr
:tag('td')
:attr('data-sort-value', data['skill.radius_tertiary'])
:wikitext(h.tbl.display.factory.descriptor_value{tbl=data, key='skill.radius_tertiary_description'}(data['skill.radius_tertiary']))
end,
order = 7002,
},
}
-- ----------------------------------------------------------------------------
-- Main functions
-- ----------------------------------------------------------------------------
local function _item_table(args)
--[[
Creates a generic table for items.
Examples
--------
= p.item_table{
q_tables='vendor_rewards, quest_rewards, skill_gems',
q_join='items._pageID=vendor_rewards._pageID, items._pageID=quest_rewards._pageID, items._pageID=skill_gems._pageID',
q_where='(items.class="Active Skill Gems" OR items.class = "Support Skill Gems") AND (vendor_rewards.quest_id IS NOT NULL OR quest_rewards.quest_id IS NOT NULL)',
vendor=1,
}
]]
m_item_util = m_item_util or require('Module:Item util')
local t = os.clock()
args.mode = args.mode or 'item'
local modes = {
skill = {
data = data_map.skill_gem,
header = i18n.item_table.skill_gem,
},
item = {
data = data_map.generic_item,
header = i18n.item_table.item,
},
}
if modes[args.mode] == nil then
error(i18n.errors.invalid_item_table_mode)
end
local results2 = {
stats = {},
skill_levels = {},
pageIDs = {},
}
local row_infos = {}
for _, row_info in ipairs(modes[args.mode].data) do
local enabled = false
if row_info.arg == nil then
enabled = true
elseif type(row_info.arg) == 'string' and m_util.cast.boolean(args[row_info.arg]) then
enabled = true
elseif type(row_info.arg) == 'table' then
for _, argument in ipairs(row_info.arg) do
if m_util.cast.boolean(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 = {}
for i=1, math.huge do -- repeat until no more columns are found
local prefix = string.format('stat_column%s_', i)
if args[prefix .. 'stat1_id'] == nil then
-- Each column requires at least one stat id
break
end
local col_info = {
header = args[prefix .. 'header'] or tostring(i),
format = args[prefix .. 'format'],
stat_format = args[prefix .. 'stat_format'] or 'separate',
order = tonumber(args[prefix .. 'order']) or (10000000 + i),
stats = {},
}
for j=1, math.huge do
local stat_id = args[string.format('%sstat%s_id', prefix, j)]
if stat_id == nil then
break
end
table.insert(col_info.stats, {id=stat_id})
query_stats[stat_id] = true
end
table.insert(stat_columns, col_info)
end
for _, col_info in ipairs(stat_columns) do
local row_info = {
--arg
header = col_info.header,
fields = {},
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 = (results2.stats[data['items._pageName']] or {})[stat_info.id]
if stat ~= nil then
stat_texts[#stat_texts+1] = m_util.html.format_value(args, stat, {no_color=true})
vmax = vmax + stat.max
end
end
if num_stats ~= #stat_texts then
tr:wikitext(m_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 = (results2.stats[data['items._pageName']] 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, m_util.html.format_value(args, 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 tables_assoc = {items=true}
local fields = {
'items._pageID',
'items._pageName',
'items.name',
'items.inventory_icon',
'items.html',
'items.size_x',
'items.size_y',
}
--
local prepend = {
q_groupBy=true,
q_tables=true,
}
local query = {}
for key, value in pairs(args) do
if string.sub(key, 0, 2) == 'q_' then
if prepend[key] then
value = ',' .. value
end
query[string.sub(key, 3)] = value
end
end
-- Namespace condition
-- This is mainly to prevent items from user pages or other testing pages
-- from being returned in the query results.
if args.namespaces ~= 'any' then
local namespaces = m_util.cast.table(args.namespaces, {callback=m_util.cast.number})
if #namespaces > 0 then
namespaces = table.concat(namespaces, ',')
else
namespaces = m_item_util.get_item_namespaces{format = 'list'}
end
query.where = string.format('(%s) AND items._pageNamespace IN (%s)', query.where, namespaces)
end
local skill_levels = {}
for _, rowinfo in ipairs(row_infos) do
if type(rowinfo.fields) == 'function' then
rowinfo.fields = rowinfo.fields()
end
for index, field in ipairs(rowinfo.fields) do
rowinfo.options[index] = rowinfo.options[index] or {}
if rowinfo.options[index].skill_levels then
skill_levels[#skill_levels+1] = field
else
fields[#fields+1] = field
tables_assoc[m_util.string.split(field, '%.')[1]] = true
end
end
end
if #skill_levels > 0 then
fields[#fields+1] = 'skill.max_level'
tables_assoc.skill = true
end
-- Reformat the tables and fields so they can be retrieved correctly:
local tables = {}
for table_name,_ in pairs(tables_assoc) do
tables[#tables+1] = table_name
end
local tbls = table.concat(tables,',') .. (query.tables or '')
query.tables = m_util.string.split(tbls, ',')
for index, field in ipairs(fields) do
fields[index] = string.format('%s=%s', field, field)
end
query.fields = fields
-- Take care of the minimum required joins, joins from templates
-- must still be userdefined:
local joins = {}
for index, table_name in ipairs(tables) do
if table_name ~= 'items' then
joins[#joins+1] = string.format('items._pageID=%s._pageID', table_name)
end
end
if #joins > 0 and query.join then
query.join = table.concat(joins, ',') .. ',' .. query.join
elseif #joins > 0 and not query.join then
query.join = table.concat(joins, ',')
elseif #joins == 0 and query.join then
-- leave query.join as is
end
-- Needed to eliminate duplicates supplied via table joins:
query.groupBy = 'items._pageID' .. (query.groupBy or '')
-- Query results:
local results = m_cargo.query(query.tables, query.fields, query)
if #results == 0 and args.default ~= nil then
return args.default
end
if #results > 0 then
-- Create a list of found pageIDs for column specific queries:
for _,v in ipairs(results) do
results2.pageIDs[#results2.pageIDs+1] = v['items._pageID']
end
-- fetch skill level information
if #skill_levels > 0 then
skill_levels[#skill_levels+1] = 'skill_levels._pageName'
skill_levels[#skill_levels+1] = 'skill_levels.level'
local pages = {}
for _, row in ipairs(results) do
pages[#pages+1] = string.format('(skill_levels._pageID="%s" AND skill_levels.level IN (0, 1, %s))', row['items._pageID'], row['skill.max_level'])
end
local temp = m_cargo.query(
{'skill_levels'},
skill_levels,
{
where=table.concat(pages, ' OR '),
groupBy='skill_levels._pageID, skill_levels.level',
}
)
-- map to results
for _, row in ipairs(temp) do
if results2.skill_levels[row['skill_levels._pageName']] == nil then
results2.skill_levels[row['skill_levels._pageName']] = {}
end
-- TODO: convert to int?
results2.skill_levels[row['skill_levels._pageName']][row['skill_levels.level']] = row
end
end
if #stat_columns > 0 then
local stat_results = m_cargo.query(
{'items', 'item_stats'},
{'item_stats._pageName', 'item_stats.id', 'item_stats.min', 'item_stats.max', 'item_stats.avg'},
{
join = 'items._pageID=item_stats._pageID',
where = string.format(
'item_stats._pageID IN (%s) AND item_stats.id IN ("%s")',
table.concat(m_util.table.column(results, 'items._pageID'), ','),
table.concat(m_util.table.keys(query_stats), '","')
),
groupBy = 'items._pageID, item_stats.id',
}
)
for _, row in ipairs(stat_results) do
local stat = {
min = tonumber(row['item_stats.min']),
max = tonumber(row['item_stats.max']),
avg = tonumber(row['item_stats.avg']),
}
if results2.stats[row['item_stats._pageName']] == nil then
results2.stats[row['item_stats._pageName']] = {[row['item_stats.id']] = stat}
else
results2.stats[row['item_stats._pageName']][row['item_stats.id']] = stat
end
end
end
end
--
-- Display the table
--
local tbl = mw.html.create('table')
tbl:attr('class', 'wikitable sortable item-table')
if m_util.cast.boolean(args.responsive) then
tbl:addClass('responsive-table')
end
-- Headers:
local tr = tbl:tag('tr')
tr
:tag('th')
:wikitext(modes[args.mode].header)
:done()
for _, row_info in ipairs(row_infos) do
local th = tr:tag('th')
if row_info.colspan then
th:attr('colspan', row_info.colspan)
end
th
:attr('data-sort-type', row_info.sort_type or 'number')
:wikitext(row_info.header)
end
-- Rows:
for _, row in ipairs(results) do
tr = tbl:tag('tr')
local il_args = {
skip_query=true,
page=row['items._pageName'],
name=row['items.name'],
inventory_icon=row['items.inventory_icon'],
width=row['items.size_x'],
height=row['items.size_y'],
}
if args.no_html == nil then
il_args.html = row['items.html']
end
if args.large then
il_args.large = args.large
end
tr
:tag('td')
:wikitext(h.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, field in ipairs(rowinfo.fields) do
-- this will bet set to an empty value not nil confusingly
if row[field] == nil or row[field] == '' then
local opts = rowinfo.options[index]
if opts.optional ~= true and opts.skill_levels ~= true then
display = false
break
else
row[field] = nil
end
end
end
if display then
rowinfo.display(tr, row, rowinfo.fields, results2)
else
tr:wikitext(m_util.html.td.na())
end
end
end
local cats = {}
if #results == query.limit then
cats[#cats+1] = i18n.categories.query_limit
end
if #results == 0 then
cats[#cats+1] = i18n.categories.no_results
end
mw.logObject({os.clock() - t, query})
return tostring(tbl) .. m_util.misc.add_category(cats, {ignore_blacklist=args.debug})
end
-------------------------------------------------------------------------------
-- Map item drops
-------------------------------------------------------------------------------
local function _map_item_drops(args)
--[[
Gets the area id from the map item and activates
Template:Area_item_drops.
Examples:
= p.map_item_drops{page='Underground River Map (War for the Atlas)'}
]]
local tables = {'maps'}
local fields = {
'maps.area_id',
}
local query = {
-- Only need each page name once
groupBy = 'maps._pageName',
}
if args.page then
-- Join with _pageData in order to check for page redirect
tables[#tables+1] = '_pageData'
fields[#fields+1] = '_pageData._pageNameOrRedirect'
query.where = string.format(
'_pageData._pageName="%s"',
args.page
)
query.join = 'maps._pageName = _pageData._pageNameOrRedirect'
else
query.where = string.format(
'maps._pageName="%s"',
tostring(mw.title.getCurrentTitle())
)
end
query.where = query.where .. ' AND maps.area_id > ""' -- area_id must not be empty or null
local results = m_cargo.query(tables, fields, query)
local id = ''
if #results > 0 then
id = results[1]['maps.area_id']
end
return mw.getCurrentFrame():expandTemplate{ title = 'Area item drops', args = {area_id=id} }
end
-------------------------------------------------------------------------------
-- Prophecy description
-------------------------------------------------------------------------------
local function _prophecy_description(args)
args.page = args.page or tostring(mw.title.getCurrentTitle())
local results = m_cargo.query(
{'prophecies'},
{'prophecies.objective', 'prophecies.reward'},
{
where=string.format('prophecies._pageName="%s"', args.page),
-- Only need each page name once
groupBy='prophecies._pageName',
}
)
results = results[1]
local out = {}
if results['prophecies.objective'] then
out[#out+1] = string.format('<h2>%s</h2>', i18n.prophecy_description.objective)
out[#out+1] = results['prophecies.objective']
end
if results['prophecies.reward'] then
out[#out+1] = string.format('<h2>%s</h2>', i18n.prophecy_description.reward)
out[#out+1] = results['prophecies.reward']
end
return table.concat(out, '\n')
end
local function _simple_item_list(args)
--[[
Creates a simple list of items.
Examples
--------
= p.simple_item_list{
q_tables='maps',
q_join='items._pageID=maps._pageID',
q_where='maps.tier=1 AND items.drop_enabled=1 AND items.rarity_id="normal"',
no_html=1,
link_from_name=1,
}
]]
local query = {}
for key, value in pairs(args) do
if string.sub(key, 0, 2) == 'q_' then
query[string.sub(key, 3)] = value
end
end
local fields = {
'items._pageName',
'items.name',
'items.class',
}
if args.no_icon == nil then
fields[#fields+1] = 'items.inventory_icon'
end
if args.no_html == nil then
fields[#fields+1] = 'items.html'
end
local tables = m_util.cast.table(args.q_tables)
table.insert(tables, 1, 'items')
query.groupBy = query.groupBy or 'items._pageID'
local results = m_cargo.query(
tables,
fields,
query
)
local out = {}
for _, row in ipairs(results) do
local page
if args.use_name_as_link ~= nil then
page = row['items.name']
else
page = row['items._pageName']
end
local link = h.item_link{
page=page,
name=row['items.name'],
inventory_icon=row['items.inventory_icon'] or '',
html=row['items.html'] or '',
skip_query=true
}
if args.format == nil then
out[#out+1] = string.format('* %s', link)
elseif args.format == 'none' then
out[#out+1] = link
elseif args.format == 'li' then
out[#out+1] = string.format('<li>%s</li>', link)
else
error(string.format(i18n.errors.generic_argument_parameter, 'format', args.format))
end
end
if args.format == nil then
return table.concat(out, '\n')
elseif args.format == 'none' then
return table.concat(out, '\n')
elseif args.format == 'li' then
return table.concat(out)
end
end
-- ----------------------------------------------------------------------------
-- Exported functions
-- ----------------------------------------------------------------------------
local p = {}
--
-- Template:Item table
--
p.item_table = m_util.misc.invoker_factory(_item_table)
--
-- Template:Map item drops
--
p.map_item_drops = m_util.misc.invoker_factory(_map_item_drops, {
wrappers = cfg.wrappers.map_item_drops,
})
--
-- Template:Prophecy description
--
p.prophecy_description = m_util.misc.invoker_factory(_prophecy_description, {
wrappers = cfg.wrappers.prophecy_description,
})
--
-- Template:Simple item list
--
p.simple_item_list = m_util.misc.invoker_factory(_simple_item_list, {
wrappers = cfg.wrappers.simple_item_list,
})
-- ----------------------------------------------------------------------------
-- Debug
-- ----------------------------------------------------------------------------
p.debug = {}
function p.debug._tbl_data(tbl)
keys = {}
for _, data in ipairs(tbl) 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(data_map.generic_item)
end
function p.debug.skill_gem_all()
return p.debug._tbl_data(data_map.skill_gem)
end
return p