Module:Mod: Difference between revisions
Jump to navigation
Jump to search
>OmegaK2 (Fix max domain range) |
>OmegaK2 m (Modifier table has been split off into Module:Modifier table, switched util to m_util for consistency) |
||
| Line 3: | Line 3: | ||
-- | -- | ||
local | local m_util = require('Module:Util') | ||
local getArgs = require('Module:Arguments').getArgs | local getArgs = require('Module:Arguments').getArgs | ||
local game = require('Module:Game') | local game = require('Module:Game') | ||
local f_item_link = require('Module:Item link').item_link | local f_item_link = require('Module:Item link').item_link | ||
local cargo = mw.ext.cargo | |||
local p = {} | local p = {} | ||
| Line 19: | Line 21: | ||
local i18n = { | local i18n = { | ||
args = { | args = { | ||
-- | -- | ||
| Line 62: | Line 56: | ||
-- ---------------------------------------------------------------------------- | -- ---------------------------------------------------------------------------- | ||
-- | -- m_utility / Helper functions | ||
-- ---------------------------------------------------------------------------- | -- ---------------------------------------------------------------------------- | ||
| Line 81: | Line 75: | ||
function h.validate.number (args) | function h.validate.number (args) | ||
return function (tpl_args, frame, value) | return function (tpl_args, frame, value) | ||
return | return m_util.cast.number(value, args) | ||
end | end | ||
end | end | ||
| Line 134: | Line 128: | ||
:done() | :done() | ||
end | end | ||
-- ---------------------------------------------------------------------------- | -- ---------------------------------------------------------------------------- | ||
| Line 245: | Line 238: | ||
return {} | return {} | ||
else | else | ||
return | return m_util.string.split(value, ', ') | ||
end | end | ||
end, | end, | ||
| Line 280: | Line 273: | ||
} | } | ||
p.table_main = | p.table_main = m_util.cargo.declare_factory{data=mod_map.main} | ||
p.table_mod_sell_prices = | p.table_mod_sell_prices = m_util.cargo.declare_factory{data=mod_map.mod_sell_prices} | ||
function p.table_mod_stats(frame) | function p.table_mod_stats(frame) | ||
m_util.cargo.declare(frame, { | |||
_table = 'mod_stats', | _table = 'mod_stats', | ||
id = 'String', | id = 'String', | ||
| Line 299: | Line 292: | ||
parentFirst = true | parentFirst = true | ||
}) | }) | ||
frame = | frame = m_util.misc.get_frame(frame) | ||
-- | -- | ||
| Line 341: | Line 334: | ||
properties['+sep'] = ';' | properties['+sep'] = ';' | ||
m_util.smw.set(frame, properties) | |||
m_util.cargo.store(frame, cargo_data) | |||
-- Validate % set the stat subobjects | -- Validate % set the stat subobjects | ||
m_util.args.stats(tpl_args, {frame=frame}) | |||
for _, stat_data in pairs(tpl_args.stats) do | for _, stat_data in pairs(tpl_args.stats) do | ||
m_util.cargo.store(frame, { | |||
_table = 'mod_stats', | _table = 'mod_stats', | ||
id = stat_data.id, | id = stat_data.id, | ||
| Line 356: | Line 349: | ||
-- Validate & set spawn weight subobjects | -- Validate & set spawn weight subobjects | ||
m_util.args.spawn_weight_list(tpl_args, { | |||
frame=frame, | frame=frame, | ||
}) | }) | ||
-- Validate & set generation weight subobjects | -- Validate & set generation weight subobjects | ||
m_util.args.generation_weight_list(tpl_args, { | |||
frame=frame, | frame=frame, | ||
}) | }) | ||
| Line 392: | Line 385: | ||
properties['Has sell price amount'] = value.amount | properties['Has sell price amount'] = value.amount | ||
m_util.smw.subobject(frame, 'sell price ' .. value.name, properties) | |||
local cargo_data = {} | local cargo_data = {} | ||
| Line 398: | Line 391: | ||
cargo_data[data.field] = value[key] | cargo_data[data.field] = value[key] | ||
end | end | ||
m_util.cargo.store(frame, cargo_data) | |||
sell_prices[#sell_prices+1] = value | sell_prices[#sell_prices+1] = value | ||
| Line 659: | Line 652: | ||
-- Done -> output | -- Done -> output | ||
return tostring(container) .. | return tostring(container) .. m_util.misc.add_category(cats) .. '\n' .. table.concat(out) | ||
end | end | ||
| Line 671: | Line 664: | ||
parentFirst = true | parentFirst = true | ||
}) | }) | ||
g_frame = | g_frame = m_util.misc.get_frame(frame) | ||
g_args.colspan = 4 | g_args.colspan = 4 | ||
| Line 726: | Line 719: | ||
-- this works because lua only considers nil to be false >_> | -- this works because lua only considers nil to be false >_> | ||
while query.offset do | while query.offset do | ||
results = | results = m_util.smw.query(query, g_frame) | ||
query.offset = query.offset + #results | query.offset = query.offset + #results | ||
-- terminates the while if enough reuslts have been fetched | -- terminates the while if enough reuslts have been fetched | ||
| Line 764: | Line 757: | ||
end | end | ||
results = | results = m_util.smw.query(query, g_frame) | ||
local last = '' | local last = '' | ||
| Line 785: | Line 778: | ||
return table.concat(out, '') | return table.concat(out, '') | ||
end | end | ||
| Line 936: | Line 795: | ||
parentFirst = true | parentFirst = true | ||
}) | }) | ||
g_frame = | g_frame = m_util.misc.get_frame(frame) | ||
-- | -- | ||
local args = | local args = m_util.string.split_args(g_args.userparam, {sep=', '}) | ||
g_args.userparam = args | g_args.userparam = args | ||
| Line 946: | Line 805: | ||
args.show_tags = true | args.show_tags = true | ||
else | else | ||
args.show_tags = | args.show_tags = m_util.cast.boolean(args.show_tags) | ||
end | end | ||
args.effect_rowid = (tonumber(args.effect_rowid) or 0) + 1 | args.effect_rowid = (tonumber(args.effect_rowid) or 0) + 1 | ||
| Line 1,012: | Line 871: | ||
} | } | ||
result = | result = m_util.smw.query(query, g_frame) | ||
local stat_map = { | local stat_map = { | ||
| Line 1,055: | Line 914: | ||
tags = {} | tags = {} | ||
result = | result = m_util.smw.query(query, g_frame) | ||
end | end | ||
| Line 1,136: | Line 995: | ||
parentFirst = true | parentFirst = true | ||
}) | }) | ||
local g_frame = | local g_frame = m_util.misc.get_frame(frame) | ||
-- Only the explicit modifiers are counted when vendors calculates the price. | -- Only the explicit modifiers are counted when vendors calculates the price. | ||
| Line 1,145: | Line 1,004: | ||
'?Has rarity', | '?Has rarity', | ||
} | } | ||
local results_query_item_mods = | local results_query_item_mods = m_util.smw.query(query_item_mods, g_frame) | ||
local item_mods = | local item_mods = m_util.string.split(results_query_item_mods[1]['Has explicit mod ids'], '<MANY>') | ||
-- If the item has a Normal rarity then the sell price would be a fixed price. | -- If the item has a Normal rarity then the sell price would be a fixed price. | ||
| Line 1,162: | Line 1,021: | ||
string.format('[[Is mod::%s]]', modid), | string.format('[[Is mod::%s]]', modid), | ||
} | } | ||
local mod_page = | local mod_page = m_util.smw.query(query_mod_page, g_frame) | ||
local query_mod_sell_price = { | local query_mod_sell_price = { | ||
| Line 1,169: | Line 1,028: | ||
'?Has sell price item name', | '?Has sell price item name', | ||
} | } | ||
local results = | local results = m_util.smw.query(query_mod_sell_price, g_frame) | ||
for _, k in ipairs(results) do | for _, k in ipairs(results) do | ||
| Line 1,218: | Line 1,077: | ||
parentFirst = true | parentFirst = true | ||
}) | }) | ||
local g_frame = | local g_frame = m_util.misc.get_frame(frame) | ||
local item_name = g_args[1] | local item_name = g_args[1] | ||
| Line 1,230: | Line 1,089: | ||
'?Has item class' | '?Has item class' | ||
} | } | ||
local results = | local results = m_util.smw.query(query, g_frame) | ||
for i,_ in ipairs(results) do | for i,_ in ipairs(results) do | ||
| Line 1,244: | Line 1,103: | ||
-- This function replace specific numbers with a generic #. | -- This function replace specific numbers with a generic #. | ||
local s = table.concat( | local s = table.concat(m_util.string.split(str, '%(%d+%.*%d*%-%d+%.*%d*%)'), '#') | ||
s = table.concat( | s = table.concat(m_util.string.split(s, '%d+%.*%d*'), '#') | ||
s = table.concat( | s = table.concat(m_util.string.split(s, '<br>'), ', ') | ||
return s | return s | ||
| Line 1,258: | Line 1,117: | ||
parentFirst = true | parentFirst = true | ||
}) | }) | ||
local g_frame = | local g_frame = m_util.misc.get_frame(frame) | ||
local tbl = g_args['tbl'] | local tbl = g_args['tbl'] | ||
| Line 1,313: | Line 1,172: | ||
parentFirst = true | parentFirst = true | ||
}) | }) | ||
local g_frame = | local g_frame = m_util.misc.get_frame(frame) | ||
local get_item_tags = p.get_item_tags{g_args.item}[1] | local get_item_tags = p.get_item_tags{g_args.item}[1] | ||
local item_tags = {} | local item_tags = {} | ||
if g_args.item_tags ~= nil then | if g_args.item_tags ~= nil then | ||
item_tags = | item_tags = m_util.string.split(g_args.item_tags, ', ') | ||
else | else | ||
item_tags = | item_tags = m_util.string.split(get_item_tags['Has tags'], ', ') | ||
end | end | ||
| Line 1,346: | Line 1,205: | ||
local extra_properties = {} | local extra_properties = {} | ||
if g_args.extra_properties ~= nil then | if g_args.extra_properties ~= nil then | ||
extra_properties = | extra_properties = m_util.string.split(g_args.extra_properties, ', ') | ||
local a = #all_fields | local a = #all_fields | ||
for _,v in ipairs(extra_properties) do | for _,v in ipairs(extra_properties) do | ||
| Line 1,425: | Line 1,284: | ||
-- Query the mods in the concept page, if there are too many results then repeat and add the remaining values: | -- Query the mods in the concept page, if there are too many results then repeat and add the remaining values: | ||
repeat | repeat | ||
local result = | local result = m_util.smw.query(query, g_frame) | ||
query.offset = query.offset + #result -- Possible error source if only one mod is missing. | query.offset = query.offset + #result -- Possible error source if only one mod is missing. | ||
| Line 1,452: | Line 1,311: | ||
-- Query the subobjects in each mod page for the mod tags, if there are too many results then repeat and add the remaining values: | -- Query the subobjects in each mod page for the mod tags, if there are too many results then repeat and add the remaining values: | ||
repeat | repeat | ||
local results_mod_tags = | local results_mod_tags = m_util.smw.query(query_mod_tags, g_frame) | ||
query_mod_tags.offset = query_mod_tags.offset + #results_mod_tags | query_mod_tags.offset = query_mod_tags.offset + #results_mod_tags | ||
for _,v in ipairs(results_mod_tags) do | for _,v in ipairs(results_mod_tags) do | ||
local pagename = | local pagename = m_util.string.split(v[1], '#')[1] | ||
if mod_data_subobject[pagename] == nil then | if mod_data_subobject[pagename] == nil then | ||
mod_data_subobject[pagename] = {} | mod_data_subobject[pagename] = {} | ||
| Line 1,485: | Line 1,344: | ||
local query_mod_tags_missed = query_mod_tags | local query_mod_tags_missed = query_mod_tags | ||
query_mod_tags_missed[1] = string.format('[[-Has subobject::<q>%s [[%s]]</q>]]', table.concat(conditions, ' '), pagename) | query_mod_tags_missed[1] = string.format('[[-Has subobject::<q>%s [[%s]]</q>]]', table.concat(conditions, ' '), pagename) | ||
local results_mod_tags = | local results_mod_tags = m_util.smw.query(query_mod_tags, g_frame) | ||
for _,v in ipairs(results_mod_tags) do | for _,v in ipairs(results_mod_tags) do | ||
| Line 1,588: | Line 1,447: | ||
-- If there are multiple unique mod types with the same mod group then change the style of the drop down list to indicate it: | -- If there are multiple unique mod types with the same mod group then change the style of the drop down list to indicate it: | ||
if number_of_mod_types > 1 then | if number_of_mod_types > 1 then | ||
tbl_caption = string.format('%s', | tbl_caption = string.format('%s', m_util.html.poe_color('mod', 'Mod group: ' .. mod_properties['Has mod group'])) | ||
else | else | ||
tbl_caption = string.format('%s (%s)', | tbl_caption = string.format('%s (%s)', m_util.html.poe_color('mod', p.header(mod_properties['Has stat text'])), mod_properties['Has mod scope']) | ||
end | end | ||
| Line 1,640: | Line 1,499: | ||
:tag('td') | :tag('td') | ||
:attr('width', '*') | :attr('width', '*') | ||
:wikitext(string.format('%s', | :wikitext(string.format('%s', m_util.html.poe_color('mod', mod_properties['Has stat text']:gsub('<br>', ', ')) )) | ||
:done() | :done() | ||
:node(td) | :node(td) | ||
Revision as of 12:56, 14 December 2017
This module is used on 34,000+ pages.
To avoid major disruption and server load, do not make unnecessary edits to this module. Test changes to this module first using its /sandbox and /testcases subpages . All of the changes can then be applied to this module in a single edit.
Consider discussing changes on the talk page or on Discord before implementing them.
This module depends on the following other modules:
Module for handling for modifiers with Cargo support.
List of currently implemented templates
The above documentation is transcluded from Module:Mod/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 for mod related templates
--
local m_util = require('Module:Util')
local getArgs = require('Module:Arguments').getArgs
local game = require('Module:Game')
local f_item_link = require('Module:Item link').item_link
local cargo = mw.ext.cargo
local p = {}
-- ----------------------------------------------------------------------------
-- Strings
-- ----------------------------------------------------------------------------
-- This section contains strings used by this module.
-- Add new strings here instead of in-code directly, this will help other
-- people to correct spelling mistakes easier and help with translation to
-- other PoE wikis.
local i18n = {
args = {
--
-- Mod template
--
-- main
id = 'id',
name = 'name',
mod_group = 'mod_group',
mod_type = 'mod_type',
domain = 'domain',
generation_type = 'generation_type',
required_level = 'required_level',
stat_text = 'stat_text',
granted_buff_id = 'granted_buff_id',
granted_buff_value = 'granted_buff_value',
granted_skill = 'granted_skill',
tags = 'tags',
-- sell price
sell_price_prefix = 'sell_price',
item_name = 'name',
amount = 'amount',
},
errors = {
--
-- Mod template
--
sell_price_duplicate_name = 'Do not specify a sell price item name multiple times. Adjust the amount instead.',
sell_price_missing_argument = 'Both %s and %s must be specified',
},
}
-- ----------------------------------------------------------------------------
-- m_utility / Helper functions
-- ----------------------------------------------------------------------------
local h = {}
-- Validate single value properties and set them
h.validate = {}
function h.validate.not_nil (args)
return function (arg)
if g_args[arg] == nil then
error(string.format('%s must not be nil', arg))
end
end
end
function h.validate.number (args)
return function (tpl_args, frame, value)
return m_util.cast.number(value, args)
end
end
function h.create_header(row)
local stat = mw.html.create('span')
local text, nsub = mw.ustring.gsub(row['Has stat text'], '%d+', '?')
stat
:attr('class', 'mod-table-header-stat')
:wikitext(text)
:done()
local mgroup = mw.html.create('span')
mgroup
:attr('class', 'mod-table-header-modgroup')
:wikitext(row['Has mod group'])
:done()
local tbl = mw.html.create('table')
tbl
:attr('class', 'wikitable mw-collapsible mw-collapsed mod-table')
:tag('tr')
:tag('th')
:attr('class', 'mod-table-header')
:attr('colspan', g_args.colspan)
:tag('span')
:attr('class', 'mod-table-header-container')
:wikitext(tostring(stat) .. tostring(mgroup))
:done()
:done()
return tbl
end
function h.format_mod(tbl, row, tags)
local tr = tbl:tag('tr')
tr
:tag('td')
:wikitext(string.format('[[%s|%s]]', row[1], row['Has name']))
:attr('class', 'mod-table-cell-name')
:done()
:tag('td')
:wikitext(row['Has level requirement'])
:attr('class', 'mod-table-cell-level')
:done()
:tag('td')
:wikitext(row['Has stat text'])
:attr('class', 'mod-table-cell-stat')
:done()
:tag('td')
:wikitext(table.concat(tags, ', '))
:attr('class', 'mod-table-cell-tags')
:done()
end
-- ----------------------------------------------------------------------------
-- Templates
-- ----------------------------------------------------------------------------
--
-- Template: Mod
--
local mod_map = {
main = {
table = 'mods',
order = {'id', 'name', 'mod_group', 'mod_type', 'domain', 'generation_type', 'required_level', 'stat_text', 'granted_buff_id', 'granted_buff_value', 'granted_skill', 'tags'},
fields = {
id = {
name = i18n.args.id,
field = i18n.args.id,
type = 'String',
property = 'Is mod',
wikitext = 'Mod Id',
},
name = {
name = i18n.args.name,
field = i18n.args.name,
type = 'String',
property = 'Has name',
wikitext = 'Name',
},
mod_group = {
name = i18n.args.mod_group,
field = i18n.args.mod_group,
type = 'String',
property = 'Has mod group',
wikitext = 'Group',
},
mod_type = {
name = i18n.args.mod_type,
field = i18n.args.mod_type,
type = 'String',
property = 'Has mod type',
wikitext = 'Mod type',
},
domain = {
name = i18n.args.domain,
field = i18n.args.domain,
type = 'Integer',
property = 'Has mod domain',
func = h.validate.number{min=1, max=15},
wikitext = 'Mod domain',
display = function (value)
return game.constants.mod.domains[value]['short_upper'] .. ' (Id: ' .. value .. ')'
end,
},
generation_type = {
name = i18n.args.generation_type,
field = i18n.args.generation_type,
type = 'Integer',
property = 'Has mod generation type',
func = h.validate.number{min=1, max=12},
wikitext = 'Generation type',
display = function (value)
return game.constants.mod.generation_types[value]['short_upper'] .. ' (Id: ' .. value .. ')'
end,
},
required_level = {
name = i18n.args.required_level,
field = i18n.args.required_level,
type = 'Integer',
property = 'Has level requirement',
func = h.validate.number{min=0, max=100},
wikitext = 'Req. level',
},
stat_text = {
name = i18n.args.stat_text,
field = i18n.args.stat_text,
type = 'Text',
property = 'Has stat text',
wikitext = 'Effect',
},
granted_buff_id = {
name = i18n.args.granted_buff_id,
field = i18n.args.granted_buff_id,
type = 'String',
property = 'Has granted buff id',
wikitext = 'Granted Buff Id',
},
granted_buff_value = {
name = i18n.args.granted_buff_value,
field = i18n.args.granted_buff_value,
type = 'Integer',
property = 'Has granted buff value',
wikitext = 'Granted Buff Value',
},
granted_skill = {
name = i18n.args.granted_skill,
field = i18n.args.granted_skill,
type = 'String',
property = 'Has granted skill id',
wikitext = 'Granted Skill',
},
tags = {
name = i18n.args.tags,
field = i18n.args.tags,
type = 'List (,) of String',
property = 'Has tags',
wikitext = 'Tags',
func = function (tpl_args, frame, value)
if value == nil then
return {}
else
return m_util.string.split(value, ', ')
end
end,
func_smw = function(tpl_args, frame)
return table.concat(tpl_args.tags, ';')
end,
func_cargo = function(tpl_args, frame)
return table.concat(tpl_args.tags, ',')
end,
display = function(value)
return table.concat(value, ', ')
end,
},
},
},
mod_sell_prices = {
table = 'mod_sell_prices',
order = {'name', 'amount'},
fields = {
name = {
name = i18n.args.item_name,
field = i18n.args.item_name,
type = 'String',
func = function (value) return value end,
},
amount = {
name = i18n.args.amount,
field = i18n.args.amount,
type = 'Integer',
func = tonumber,
},
},
},
}
p.table_main = m_util.cargo.declare_factory{data=mod_map.main}
p.table_mod_sell_prices = m_util.cargo.declare_factory{data=mod_map.mod_sell_prices}
function p.table_mod_stats(frame)
m_util.cargo.declare(frame, {
_table = 'mod_stats',
id = 'String',
min = 'Integer',
max = 'Integer',
})
end
-- p.mod{id = "LocalIncreasedPhysicalDamagePercentUniqueOneHandSword2", name = "", mod_group = "LocalPhysicalDamagePercent", domain = "1", generation_type = "3", required_level = "1", mod_type = "LocalPhysicalDamagePercent", stat_text = "150% increased Physical Damage", stat1_id = "local_physical_damage_+%", stat1_min = "150", stat1_max = "150"}
function p.mod(frame)
-- Get args
tpl_args = getArgs(frame, {
parentFirst = true
})
frame = m_util.misc.get_frame(frame)
--
-- Validation & semantic properties
--
-- Validate single value properties and set them
local properties = {}
local cargo_data = {
_table = mod_map.main.table,
}
for key, data in pairs(mod_map.main.fields) do
local value
if data.func ~= nil then
value = data.func(tpl_args, frame, tpl_args[data.name])
else
value = tpl_args[data.name]
end
tpl_args[key] = value
if data.property ~= nil then
if data.func_smw then
else
properties[data.property] = value
end
end
if data.field ~= nil then
if data.func_cargo then
cargo_data[data.field] = data.func_cargo(tpl_args, frame)
else
cargo_data[data.field] = value
end
end
end
properties['+sep'] = ';'
m_util.smw.set(frame, properties)
m_util.cargo.store(frame, cargo_data)
-- Validate % set the stat subobjects
m_util.args.stats(tpl_args, {frame=frame})
for _, stat_data in pairs(tpl_args.stats) do
m_util.cargo.store(frame, {
_table = 'mod_stats',
id = stat_data.id,
min = stat_data.min,
max = stat_data.max,
})
end
-- Validate & set spawn weight subobjects
m_util.args.spawn_weight_list(tpl_args, {
frame=frame,
})
-- Validate & set generation weight subobjects
m_util.args.generation_weight_list(tpl_args, {
frame=frame,
})
-- Validate & set mod sell values
i = 0
local names = {}
local sell_prices = {}
repeat
i = i + 1
local id = {}
value = {}
for key, data in pairs(mod_map.mod_sell_prices.fields) do
id[key] = string.format('%s%s_%s', i18n.args.sell_price_prefix, i, data.name)
value[key] = data.func(tpl_args[id[key]])
end
if value.name == nil and value.amount == nil then
value = nil
elseif value.name ~= nil and value.amount ~= nil then
if names[value.name] then
error(i18n.errors.sell_price_duplicate_name)
else
names[value.name] = true
end
local properties = {}
properties['Has sell price item name'] = value.name
properties['Has sell price amount'] = value.amount
m_util.smw.subobject(frame, 'sell price ' .. value.name, properties)
local cargo_data = {}
for key, data in pairs(mod_map.mod_sell_prices.fields) do
cargo_data[data.field] = value[key]
end
m_util.cargo.store(frame, cargo_data)
sell_prices[#sell_prices+1] = value
else
error (string.format(i18n.errors.sell_price_missing_arguments, id.name, id.amount))
end
until value == nil
--
-- Display
--
local container = mw.html.create('div')
container
:attr('class', 'modbox')
-- core stats
local tbl = container:tag('table')
tbl
:attr('class', 'wikitable')
for _, key in ipairs(mod_map.main.order) do
local data = mod_map.main.fields[key]
local text
if data.display == nil then
text = tpl_args[key]
else
text = data.display(tpl_args[key])
end
tbl
:tag('tr')
:tag('th')
:wikitext(string.format('[[Property:%s|%s]]', data.property, data.wikitext))
:done()
:tag('td')
:wikitext(text)
:done()
:done()
:done()
end
tbl
:tag('tr')
:tag('th')
:wikitext('[[Property:Has tag|Tags]]')
:done()
:tag('td')
:wikitext(table.concat(tpl_args['tags'], ', '))
:done()
:done()
:done()
-- stat table
tbl = container:tag('table')
tbl
:attr('class', 'wikitable sortable')
:tag('tr')
:tag('th')
:attr('colspan', 4)
:wikitext('Stats')
:done()
:done()
:tag('tr')
:tag('th')
:wikitext('[[Property:Is stat number|#]]')
:done()
:tag('th')
:wikitext('[[Property:Has stat id|Stat Id]]')
:done()
:tag('th')
:wikitext('[[Property:Has minimum stat value|Minimum]]')
:done()
:tag('th')
:wikitext('[[Property:Has maximum stat value|Maximum]]')
:done()
:done()
:done()
for i=1, #tpl_args.stats do
local value = {
id = tpl_args['stat' .. i .. '_id'],
min = tpl_args['stat' .. i .. '_min'],
max = tpl_args['stat' .. i .. '_max'],
}
if value.id then
tbl
:tag('tr')
:tag('td')
:wikitext(i)
:done()
:tag('td')
:wikitext(value.id)
:done()
:tag('td')
:wikitext(value.min)
:done()
:tag('td')
:wikitext(value.max)
:done()
:done()
:done()
end
end
-- spawn weight table
tbl = container:tag('table')
tbl
:attr('class', 'wikitable sortable')
:tag('tr')
:tag('th')
:attr('colspan', 3)
:wikitext('Spawn Weights')
:done()
:done()
:tag('tr')
:tag('th')
:wikitext('[[Property:Is tag number|#]]')
:done()
:tag('th')
:wikitext('[[Property:Has tag|Tag]]')
:done()
:tag('th')
:wikitext('[[Property:Has spawn weight|Weight]]')
:done()
:done()
:done()
i = 0
value = nil
repeat
i = i + 1
value = {
tag = tpl_args[string.format('spawn_weight%s_tag', i)],
value = tpl_args[string.format('spawn_weight%s_value', i)],
}
if value.tag then
tbl
:tag('tr')
:tag('td')
:wikitext(i)
:done()
:tag('td')
:wikitext(value.tag)
:done()
:tag('td')
:wikitext(value.value)
:done()
:done()
:done()
end
until value.tag == nil
-- generation weight table
tbl = container:tag('table')
tbl
:attr('class', 'wikitable sortable')
:tag('tr')
:tag('th')
:attr('colspan', 3)
:wikitext('Generation Weights')
:done()
:done()
:tag('tr')
:tag('th')
:wikitext('[[Property:Is tag number|#]]')
:done()
:tag('th')
:wikitext('[[Property:Has tag|Tag]]')
:done()
:tag('th')
:wikitext('[[Property:Has generation weight|Weight]]')
:done()
:done()
:done()
i = 0
value = nil
repeat
i = i + 1
value = {
tag = tpl_args[string.format('generation_weight%s_tag', i)],
value = tpl_args[string.format('generation_weight%s_value', i)],
}
if value.tag then
tbl
:tag('tr')
:tag('td')
:wikitext(i)
:done()
:tag('td')
:wikitext(value.tag)
:done()
:tag('td')
:wikitext(value.value)
:done()
:done()
:done()
end
until value.tag == nil
-- Sell prices
tbl = container:tag('table')
tbl
:attr('class', 'wikitable sortable')
:tag('tr')
:tag('th')
:attr('colspan', 2)
:wikitext('Modifier sell price')
:done()
:done()
:tag('tr')
:tag('th')
:wikitext('[[Property:Has sell price amount|#]]')
:done()
:tag('th')
:wikitext('[[Property:Has sell price item name|Item]]')
:done()
:done()
:done()
for i, value in ipairs(sell_prices) do
tbl
:tag('tr')
:tag('td')
:wikitext(value.amount)
:done()
:tag('td')
:wikitext(f_item_link{item_name_exact=value.name})
:done()
:done()
end
-- Generic messages on the page
out = {}
if mw.ustring.find(tpl_args['id'], '_') then
out[#out+1] = frame:expandTemplate{ title = 'Incorrect title', args = { title=tpl_args['id'] } } .. '\n\n\n'
end
if tpl_args['name'] then
out[#out+1] = string.format("'''%s''' is the internal id of modifier '''%s'''.\n", tpl_args['id'], tpl_args['name'])
else
out[#out+1] = string.format("'''%s''' is the internal id of an unnamed modifier.\n", tpl_args['id'], tpl_args['name'])
end
-- Categories
cats = {'Mods'}
-- Done -> output
return tostring(container) .. m_util.misc.add_category(cats) .. '\n' .. table.concat(out)
end
--
-- Template: SMW query mods
--
function p.query_mods(frame)
-- Args
g_args = getArgs(frame, {
parentFirst = true
})
g_frame = m_util.misc.get_frame(frame)
g_args.colspan = 4
local conditions = {}
conditions[#conditions+1] = 'concept'
if g_args.tag then
conditions[#conditions+1] = string.format('[[Has subobject::<q>[[-Has subobject::+]] [[Has spawn weight::>>0]] [[Has tag::%s]]</q>]]', g_args.tag)
end
g_args.header_level = g_args.header_level or 2
-- Fields
local fields = {}
fields[#fields+1] = '?Is mod'
fields[#fields+1] = '?Has name'
fields[#fields+1] = '?Has level requirement'
fields[#fields+1] = '?Has mod group'
fields[#fields+1] = '?Has stat text'
-- parameters
local parameters = {}
parameters.sort = 'Has mod group, '
parameters.limit = 1000 -- lets see
local data = {}
data.header = {
prefix = 'Prefix',
suffix = 'Suffix',
}
local out = {}
for _, v in ipairs({'prefix', 'suffix'}) do
out[#out+1] = string.format('<h%i>%s</h%i>', g_args.header_level, data.header[v], g_args.header_level)
conditions[1] = string.format('[[Concept:Spawnable named %s item mods]]', v)
local query
local results
--
-- Query tags
--
query = {}
query[#query+1] = string.format('[[-Has subobject::<q>%s</q>]]', table.concat(conditions, ' '))
query[#query+1] = '[[Has tag::+]]'
query[#query+1] = '[[Has spawn weight::+]]'
--query[#query+1] = '[[Has spawn weight::>>0]]'
query[#query+1] = '?Has tag'
query[#query+1] = '?Has spawn weight#' -- need native number
query.limit = 1000
query.offset = 0
-- Tag order is very important
query.sort = ', Is tag number'
local tags = {}
-- this works because lua only considers nil to be false >_>
while query.offset do
results = m_util.smw.query(query, g_frame)
query.offset = query.offset + #results
-- terminates the while if enough reuslts have been fetched
if query.offset % 1000 ~= 0 then
query.offset = nil
end
for _, row in ipairs(results) do
local page, _ = string.gsub(row[1], '#_[%x]+', '')
if tags[page] == nil then
tags[page] = {}
end
local text
if tonumber(row['Has spawn weight']) > 0 then
text = '[[File:Yes.png|yes|link=]]'
else
text = '[[File:No.png|no|link=]]'
end
tags[page][#tags[page]+1] = string.format('%s %s', row['Has tag'], text)
end
end
--
-- Query mods
--
query = {}
for _, v in ipairs(conditions) do
query[#query+1] = v
end
for _, v in ipairs(fields) do
query[#query+1] = v
end
for k, v in pairs(parameters) do
query[k] = v
end
results = m_util.smw.query(query, g_frame)
local last = ''
local tbl = ''
for _, row in ipairs(results) do
local current = string.gsub(row['Is mod'], '%d+.*', '%%d.*')
if string.match(last, current) then
h.format_mod(tbl, row, tags[row[1]])
else
out[#out+1] = tostring(tbl)
tbl = h.create_header(row)
h.format_mod(tbl, row, tags[row[1]])
end
last = row['Is mod']
end
-- add the last table
out[#out+1] = tostring(tbl)
end
return table.concat(out, '')
end
--
-- Template: SMW mod table
--
-- =p.mod_list{'Strength1', 'shitty name', 'test', 'test2', userparam='extra_rows=2, show_jewels=1'}
-- =p.mod_list{'ColdCritMultiplier', 'shitty name', 'test', 'test2', userparam='extra_rows=2, show_jewels=1'}
-- =p.mod_list{'MapMultipleExilesMap2Tier', 'asdasda', 'Area yields 15% more Items<br>8% increased Rarity of Items found in this Area<br>Area is inhabited by 2 additional Rogue Exiles<br>Extra monsters ignore rarity bias (Hidden)<br>+14% Monster pack size', userparam='extra_rows=1, type=map, effect_rowid=2'}
function p.mod_list(frame)
local types = {'map', 'jewel'}
-- Args
g_args = getArgs(frame, {
parentFirst = true
})
g_frame = m_util.misc.get_frame(frame)
--
local args = m_util.string.split_args(g_args.userparam, {sep=', '})
g_args.userparam = args
args.extra_rows = (tonumber(args.extra_rows) or 0)
if args.show_tags == nil then
args.show_tags = true
else
args.show_tags = m_util.cast.boolean(args.show_tags)
end
args.effect_rowid = (tonumber(args.effect_rowid) or 0) + 1
tr = mw.html.create('tr')
tr
:tag('td')
:attr('data-sort-value', g_args[2] or g_args[1])
:wikitext(string.format('[[%s|%s]]', g_args[1], g_args[2] or g_args[1]))
:done()
local i = 2
local row_max = i + args.extra_rows
local text
while i < row_max do
i = i + 1
text = g_args[i] or ''
text = table.concat(mw.text.split(text, ';', true), '<br>')
if args.type == 'map' and i == args.effect_rowid then
text = mw.text.split(text, '<br>', true)
local map = {
'%d+%% increased Quantity of Items found in this Area',
'%d+%% increased Rarity of Items found in this Area',
'%+%d+%% Monster pack size',
}
out = {}
local valid
for k, v in pairs(text) do
valid = true
for _, pattern in ipairs(map) do
if mw.ustring.find(v, pattern) ~= nil then
valid = false
break
end
end
if valid then
table.insert(out, v)
end
end
text = table.concat(out, '<br>')
end
tr
:tag('td')
:wikitext(text)
:done()
end
local query
local result
if args.type == 'map' then
query = {
string.format('[[-Has subobject::%s]]', g_args[1]),
'[[Has stat id::+]]',
'?Has stat id',
'?Has minimum stat value',
'?Has maximum stat value',
}
result = m_util.smw.query(query, g_frame)
local stat_map = {
['map_item_drop_quantity_+%'] = {disp=0, sort=0},
['map_item_drop_rarity_+%'] = {disp=0, sort=0},
['map_pack_size_+%'] = {disp=0, sort=0},
}
local stat
for _, row in ipairs(result) do
stat = stat_map[row['Has stat id']]
if stat ~= nil then
stat.sort = (row['Has minimum stat value'] + row['Has maximum stat value']) / 2
if row['Has minimum stat value'] ~= row['Has minimum stat value'] then
stat.disp = string.format('(%s%-%s)', row['Has minimum stat value'], row['Has maximum stat value'])
else
stat.disp = row['Has minimum stat value']
end
end
end
for _, k in ipairs({'map_item_drop_quantity_+%', 'map_item_drop_rarity_+%', 'map_pack_size_+%'}) do
stat = stat_map[k]
tr
:tag('td')
:attr('data-sort-value', stat.sort)
:wikitext(stat.disp)
:done()
:done()
end
end
local tags
if args.show_tags or args.type == 'jewel' then
query = {
string.format('[[-Has subobject::%s]]', g_args[1]),
'[[Has tag::+]]',
'?Has tag',
'?Has spawn weight',
sort='Is tag number',
}
tags = {}
result = m_util.smw.query(query, g_frame)
end
if args.type == 'jewel' then
local jewels = {
dex=0,
str=0,
int=0,
pris=0,
}
local cast_tbl = {
not_dex={'str', 'int'},
not_int={'str', 'dex'},
not_str={'int', 'dex'},
default={'str','int','dex','pris'},
}
local i = #result
local row
local cast
while i > 0 do
row = result[i]
cast = cast_tbl[row['Has tag']]
if cast ~= nil then
for _, k in ipairs(cast) do
jewels[k] = row['Has spawn weight']
end
end
i = i - 1
end
tr
:tag('td')
:attr('class', 'table-cell-dex')
:wikitext(jewels.dex)
:done()
:tag('td')
:attr('class', 'table-cell-int')
:wikitext(jewels.int)
:done()
:tag('td')
:attr('class', 'table-cell-str')
:wikitext(jewels.str)
:done()
:tag('td')
:attr('class', 'table-cell-prismatic')
:wikitext(jewels.pris)
:done()
:done()
end
if args.show_tags then
for _, row in ipairs(result) do
tags[#tags+1] = string.format('%s %s', row['Has tag'], row['Has spawn weight'])
end
tr
:tag('td')
:wikitext(table.concat(tags, '<br>'))
:done()
:done()
end
return tostring(tr)
end
function p.item_sell_price(frame)
-- Query and sum the vendor prices for an item.
-- Unidentified items won't currently show the correct vendor price. Not sure how that is specified, nor is it used at all.
-- Expanding {{il}} seems to give a nil /n the first time a new command is run. Doesn't always happen.
-- = p.item_sell_price{page="Voideye"}
-- = p.item_sell_price{page="Pyre"}
-- = p.item_sell_price{page="Vessel of Vinktar (Lightning Penetration)"}
-- Args
local g_args = getArgs(frame, {
parentFirst = true
})
local g_frame = m_util.misc.get_frame(frame)
-- Only the explicit modifiers are counted when vendors calculates the price.
local condition = string.format('[[%s]]', g_args['page'])
local query_item_mods = {
condition,
'?Has explicit mod ids',
'?Has rarity',
}
local results_query_item_mods = m_util.smw.query(query_item_mods, g_frame)
local item_mods = m_util.string.split(results_query_item_mods[1]['Has explicit mod ids'], '<MANY>')
-- If the item has a Normal rarity then the sell price would be a fixed price.
if results_query_item_mods[1]['Has rarity'] == 'Normal' then
local amount_normal = 1
local currency_normal = 'Scroll Fragment'
return string.format('%s %s', amount_normal, g_frame:expandTemplate{title = 'il', args = {currency_normal, currency_normal .. 's'}})
-- return string.format('%s %s', amount_normal, currency_normal)
end
local mods_sell_price = {}
for _, modid in ipairs(item_mods) do
local query_mod_page = {
string.format('[[Is mod::%s]]', modid),
}
local mod_page = m_util.smw.query(query_mod_page, g_frame)
local query_mod_sell_price = {
string.format('[[-Has subobject::%s]]', mod_page[1][1]),
'?Has sell price amount#',
'?Has sell price item name',
}
local results = m_util.smw.query(query_mod_sell_price, g_frame)
for _, k in ipairs(results) do
if k['Has sell price amount'] ~= '' then
if mods_sell_price[k['Has sell price item name']] == nil then
mods_sell_price[k['Has sell price item name']] = k['Has sell price amount']
else
mods_sell_price[k['Has sell price item name']] = k['Has sell price amount'] + mods_sell_price[k['Has sell price item name']]
end
end
end
end
local out = {}
for currency, amount in pairs(mods_sell_price) do
out[#out+1] = string.format('%s %s', amount, g_frame:expandTemplate{title = 'il', args = {currency, currency .. 's'}})
end
return table.concat(out, ', ')
end
function p.find_mod_domain(input)
-- Find the mod domain based on the item class.
local out = input
local mod_domains = game.constants.mod.domains
for i,_ in ipairs(out) do
out[i]['Has mod domain'] = 1
for j, row in pairs(mod_domains) do
if out[i]['Has item class']:gsub('Map', 'Area'):match(mod_domains[j]['short_upper']) then -- This may need updating if an area item class doesn't have 'Map' in the string, or if the mod domain descriptions doesn't match the item class.
out[i]['Has mod domain'] = j
end
end
out[i]['Has mod domain text'] = mod_domains[out[i]['Has mod domain']]['short_lower']
end
return out
end
function p.get_item_tags(frame)
-- This function queries for the tags of a specific item.
-- Args
local g_args = getArgs(frame, {
parentFirst = true
})
local g_frame = m_util.misc.get_frame(frame)
local item_name = g_args[1]
local query = {
string.format('[[Has name::%s]]', item_name),
'?Has tags',
'?Has base strength requirement',
'?Has base intelligence requirement',
'?Has base dexterity requirement',
'?Has item class'
}
local results = m_util.smw.query(query, g_frame)
for i,_ in ipairs(results) do
results[i]['Has tags'] = results[i]['Has tags']:gsub('(<MANY>)', ', ') -- Remove unnecessary symbols.
end
results = p.find_mod_domain(results)
return results
end
function p.header(str)
-- This function replace specific numbers with a generic #.
local s = table.concat(m_util.string.split(str, '%(%d+%.*%d*%-%d+%.*%d*%)'), '#')
s = table.concat(m_util.string.split(s, '%d+%.*%d*'), '#')
s = table.concat(m_util.string.split(s, '<br>'), ', ')
return s
end
function p.get_spawn_chance(frame)
-- Calculates the spawn chance of a set of mods that all have a spawn weight.
-- Args
local g_args = getArgs(frame, {
parentFirst = true
})
local g_frame = m_util.misc.get_frame(frame)
local tbl = g_args['tbl']
local chance_multiplier = tonumber(g_args['chance_multiplier']) or 1 -- Probabillities affecting the result besides the spawn weight.
local N = 0
for i,_ in ipairs(tbl) do
N = N + tbl[i]['Has spawn weight'] -- Total number of outcomes.
end
for i,_ in ipairs(tbl) do
local n = tbl[i]['Has spawn weight'] -- Number of ways it can happen.
tbl[i]['Has spawn chance'] = string.format("%0.2f%%", n/N * chance_multiplier*100) -- Truncated value.
end
return tbl
end
function p.drop_down_table(frame)
-- This function queries mods in concept pages, queries the subobjects in each mod page for the mod tags. Then compares the tags on the item with the mod tags. If there's a match and the spawn weighting is larger than zero, then that mod is added to a drop down list.
-- Misses forsaken masters currently.
-- Add a proper expand/collapse toggle for the entire header row so it reacts together with mw-collapsible.
-- Show Mod group in a better way perhaps:
-- Mod group (expanded)
-- # to Damage (Collapsed)
-- 3 to Damage
-- 5 to Damage
-- Add a better solution for properties inside subobjects, for extra_properties. Note that properties already queried for should not be added with this solution.
-- Weapons
-- p.drop_down_table{item = 'Rusted Hatchet', header = 'One Handed Axes'}
-- p.drop_down_table{item = 'Stone Axe', header = 'Two Handed Axes'}
-- Accessories
-- p.drop_down_table{item = 'Amber Amulet', header = 'Amulets'}
-- Jewels
-- p.drop_down_table{item = 'Cobalt Jewel', header = 'Jewels'}
-- Armour
-- p.drop_down_table{item = 'Plate Vest', header = 'Armour body armours'}
-- p.drop_down_table{item = 'Iron Greaves', header = 'Armour boots'}
-- p.drop_down_table{item = 'Iron Gauntlets', header = 'Armour gloves'}
-- p.drop_down_table{item = 'Iron Hat', header = 'Armour helmets'}
-- p.drop_down_table{item = 'Splintered Tower Shield', header = 'Armour shields'}
-- p.drop_down_table{item = 'Fishing Rod', header = 'FISH PLEASE', item_tags = 'fishing_rod', extra_properties = 'Has spawn weight, Has spawn chance'}
-- Args
local g_args = getArgs(frame, {
parentFirst = true
})
local g_frame = m_util.misc.get_frame(frame)
local get_item_tags = p.get_item_tags{g_args.item}[1]
local item_tags = {}
if g_args.item_tags ~= nil then
item_tags = m_util.string.split(g_args.item_tags, ', ')
else
item_tags = m_util.string.split(get_item_tags['Has tags'], ', ')
end
local header = g_args['header']
if header == nil then
header = table.concat(item_tags, ', ')
end
-- Conditions
local conditions = {}
conditions[1] = 'concept' -- Reserve for Concepts.
conditions[#conditions+1] = string.format('[[Has subobject::<q> [[Has tag::%s]] </q>]]', table.concat(item_tags, ' || '))
-- Fields
local all_fields = {
1,
'Is mod',
'Has name',
'Has level requirement',
'Has mod group',
'Has mod type',
'Has stat text',
}
local extra_properties = {}
if g_args.extra_properties ~= nil then
extra_properties = m_util.string.split(g_args.extra_properties, ', ')
local a = #all_fields
for _,v in ipairs(extra_properties) do
table.insert(all_fields, a+1, v)
end
end
local fields = {}
for _,v in ipairs(all_fields) do
fields[#fields+1] = string.format('?%s', v)
end
-- Parameters
local parameters = {
sort = 'Has mod group, Has mod type, Has level requirement',
-- limit = 1000, -- lets see
offset = 0,
}
-- Create drop down lists in these sections and look in these concept pages for the modifiers:
local section = {}
section = {
[1] = {
header = 'Prefix',
generation_type = 'prefix',
condition = string.format('[[Concept:Spawnable named prefix %s mods]]', get_item_tags['Has mod domain text']),
},
[2] = {
header = 'Suffix',
generation_type = 'suffix',
condition = string.format('[[Concept:Spawnable named suffix %s mods]]', get_item_tags['Has mod domain text']),
},
[3] = {
header = 'Corrupted',
generation_type = 'corrupted',
condition = string.format('[[Concept:Spawnable corrupted %s mods]]', get_item_tags['Has mod domain text']),
chance_multiplier = 1/4, -- See Vaal orb, for the 4 possible events.
},
-- [4] = {
-- header = 'Forsaken masters',
-- generation_type = 'master',
-- condition = '[[Concept:AAAAAAAAAAAAAAAAAAAA]]',
-- },
}
local out = {}
-- Introductory text:
out[#out+1] = string.format('==%s== \n', header)
out[#out+1] = '<div style="float: right; text-align:center"><div class="mw-collapsible-collapse-all" style="cursor:pointer;">[Collapse All]</div><hr><div class="mw-collapsible-expand-all" style="cursor:pointer;">[Expand All]</div></div>'
out[#out+1] = string.format('The table below displays the available [[modifiers]] for [[item]]s such as %s.<br><br><br>', f_item_link{get_item_tags[1]})
local results = {}
local item_mods = {}
local tableIndex = -1
-- Loop through all the sections and query the mods in the concept pages:
for i_type,_ in ipairs(section) do
local generation_type = section[i_type]['generation_type']
local query = {}
conditions[1] = section[i_type]['condition']
query[#query+1] = table.concat(conditions, ' ')
for _, v in ipairs(fields) do
query[#query+1] = v
end
for k, v in pairs(parameters) do
query[k] = v
end
if results[generation_type] == nil then
results[generation_type] = {}
end
-- Query the mods in the concept page, if there are too many results then repeat and add the remaining values:
repeat
local result = m_util.smw.query(query, g_frame)
query.offset = query.offset + #result -- Possible error source if only one mod is missing.
for _,v in ipairs(result) do
results[generation_type][#results[generation_type]+1] = v
end
until #result < 1000
item_mods[generation_type] = {}
local container = mw.html.create('div')
:attr('style', 'vertical-align:top; display:inline-block;')
if #results[generation_type] > 0 then
query_mod_tags = {
string.format('[[-Has subobject::<q>%s</q>]]', table.concat(conditions, ' ')),
'?Has tag#',
'?Has spawn weight#',
'?Is tag number#',
offset = 0,
}
local mod_data_subobject = {}
-- Query the subobjects in each mod page for the mod tags, if there are too many results then repeat and add the remaining values:
repeat
local results_mod_tags = m_util.smw.query(query_mod_tags, g_frame)
query_mod_tags.offset = query_mod_tags.offset + #results_mod_tags
for _,v in ipairs(results_mod_tags) do
local pagename = m_util.string.split(v[1], '#')[1]
if mod_data_subobject[pagename] == nil then
mod_data_subobject[pagename] = {}
end
local subobjectname = v[1]
mod_data_subobject[pagename][subobjectname] = v
end
until #results_mod_tags < 1000
-- Loop through all the modifiers from the concept pages:
local last
for i, v in ipairs(results[generation_type]) do
local pagename = results[generation_type][i][1]
-- Loop through all the modifier tags until they match the item tags:
local j = 0
local tag_match_stop
repeat
j = j+1
local subobjectname = string.format('%s#%s_%s', pagename, 'spawn_weight', j)
-- We know that the mod query found subobjects with tags. If the subobject missed any subobject for some reason make sure to catch that potential error and requery only for that particular mod page:
local j2 = 0
while not pcall(function () return mod_data_subobject[pagename][subobjectname]['Has tag'] end) do
j2 = j2+1
local query_mod_tags_missed = query_mod_tags
query_mod_tags_missed[1] = string.format('[[-Has subobject::<q>%s [[%s]]</q>]]', table.concat(conditions, ' '), pagename)
local results_mod_tags = m_util.smw.query(query_mod_tags, g_frame)
for _,v in ipairs(results_mod_tags) do
if mod_data_subobject[pagename] == nil then
mod_data_subobject[pagename] = {}
end
mod_data_subobject[pagename][v[1]] = v
end
if (not pcall(function () return mod_data_subobject[pagename][subobjectname]['Has tag'] end)) and j2 == 3 then
error(string.format('mod_data_subobject doesnt have tags: pagename = %s, subobjectname = %s ? Queried %s times. Try to null edit the mod page and the mod list page.', pagename, subobjectname, j2))
end
end
local mod_tag = mod_data_subobject[pagename][subobjectname]['Has tag']
local mod_tag_weight = tonumber(mod_data_subobject[pagename][subobjectname]['Has spawn weight'])
-- Loop through the item tags until it matches the mod tag and the mod tag has a value larger than zero:
local y = 0
local tag_match_add
repeat
y = y+1
tag_match_stop = ((mod_tag == item_tags[y]) and ((mod_tag_weight or -1) >= 0)) or (mod_data_subobject[pagename][subobjectname] == nil)
tag_match_add = (mod_tag == item_tags[y]) and ((mod_tag_weight or -1) > 0)
until tag_match_stop or y == #item_tags
-- If there's a match then save that mod and other interesting information:
if tag_match_add then
-- Assume that the mod is global then go through all the subobjects and check if any of the stats are local:
local mod_scope = 'Global'
for subobject, subobject_val in pairs(mod_data_subobject[pagename]) do
-- If at least one stat is local then change the scope of the mod to local:
if subobject:find('stat.*local') ~= nil then
mod_scope = 'Local'
end
-- Complement with the properties the matching subobject has:
if subobject == subobjectname then
for property,w in pairs(subobject_val) do
if results[generation_type][i][property] == nil then
results[generation_type][i][property] = {}
end
results[generation_type][i][property] = w
end
end
end
-- Save the matching modifier and all other interesting properties:
local a = #item_mods[generation_type]
item_mods[generation_type][a+1] = {}
for _,property in ipairs(all_fields) do
item_mods[generation_type][a+1][property] = results[generation_type][i][property]
end
item_mods[generation_type][a+1]['Has mod scope'] = mod_scope
end
until tag_match_stop
end
-- If the user wants to see the spawn chance then do the calculations and save that result as well:
for _,v in ipairs(extra_properties) do
if v == 'Has spawn chance' then
item_mods[generation_type] = p.get_spawn_chance{tbl = item_mods[generation_type], chance_multiplier = section[i_type]['chance_multiplier']}
break
end
end
-- Create the drop down table with <table></table>:
local headers = container
headers
:tag('h3')
:wikitext(string.format('%s', section[i_type]['header']))
:done()
:done()
-- Loop through and add all matching mods to the <table>.
local tbl, last
for _, mod_properties in ipairs(item_mods[generation_type]) do
-- If the last mod group is different to the current mod group then assume the mod isn't related and start a new drop down list:
if mod_properties['Has mod group'] ~= last then
-- Check through all the mods and see if there are multiple mod types within the same mod group:
local count = {}
for _, n in ipairs(item_mods[generation_type]) do
-- If the mod has the same mod group, then add the mod type to the counter. Only unique mod types matter so the number is just a dummy value:
if n['Has mod group'] == mod_properties['Has mod group'] then
count[n['Has mod type']] = 1
end
end
-- Calculate how many unique mod types with the same mod group there are:
local number_of_mod_types = 0
for _ in pairs(count) do
number_of_mod_types = number_of_mod_types + 1
end
-- If there are multiple unique mod types with the same mod group then change the style of the drop down list to indicate it:
if number_of_mod_types > 1 then
tbl_caption = string.format('%s', m_util.html.poe_color('mod', 'Mod group: ' .. mod_properties['Has mod group']))
else
tbl_caption = string.format('%s (%s)', m_util.html.poe_color('mod', p.header(mod_properties['Has stat text'])), mod_properties['Has mod scope'])
end
-- Add class and style to the <table>:
tableIndex = tableIndex+1
tbl = container:tag('table')
tbl
:attr('class', 'mw-collapsible mw-collapsed')
:attr('style', 'text-align:left; line-height:1.60em; width:810px;')
:tag('th')
:attr('class', string.format('mw-customtoggle-%s', tableIndex))
:attr('style', 'text-align:left; line-height:1.40em; border-bottom:1pt solid dimgrey;')
:attr('colspan', '3' .. #extra_properties)
:wikitext(tbl_caption)
:done()
:done()
end
-- If the mod has no name then use the mod id:
local mod_name = mod_properties['Has name']
if mod_name == '' then
mod_name = mod_properties['Is mod']
end
-- Check if there are any extra properties to show in the drop down list and then add a cell for that, add this node at the end of the table row:
local td = mw.html.create('td')
if extra_properties ~= nil then
for _, extra_property in ipairs(extra_properties) do
td
:attr('width', '*')
:wikitext(string.format('%s: %s ', extra_property, mod_properties[extra_property]))
:done()
end
end
-- Add a table row with the interesting properties that modifier has:
tbl
:tag('tr')
:attr('class', 'mw-collapsible mw-collapsed')
:attr('id', string.format('mw-customcollapsible-%s', tableIndex))
:tag('td')
:attr('width', '160')
:wikitext(string.format(' [[%s|%s]]', mod_properties[1], mod_name:gsub('%s', ' ')))
:done()
:tag('td')
:attr('width', '1')
:wikitext(string.format('%s %s',game.level_requirement['short_upper']:gsub('%s', ' '), mod_properties['Has level requirement']))
:done()
:tag('td')
:attr('width', '*')
:wikitext(string.format('%s', m_util.html.poe_color('mod', mod_properties['Has stat text']:gsub('<br>', ', ')) ))
:done()
:node(td)
:done()
:done()
-- Save the last mod group for later comparison:
last = mod_properties['Has mod group']
end
end
out[#out+1] = tostring(container)
end
return table.concat(out,'')
end
return p