Module:Infobox Item/sandbox
Documentation for this module may be created at Module:Infobox Item/sandbox/doc
-- <nowiki>
-- Module for [[Template:Infobox Item]]
-- Test changes using [[Module:Infobox Item/sandbox]] [[Template:Infobox Item/sandbox]]
local p = {}
-- "imports"
local infobox = require('Module:Infobox')
local onmain = require('Module:Mainonly').on_main
local paramtest = require('Module:Paramtest')
local commas = require('Module:Addcommas')._add
local exchange = require('Module:Exchange')
local chart = require('Module:ExchangeData')._chart
local yesno = require('Module:Yesno')
local death_map = {
allowed = {
reclaimable = 'reclaimable',
never = 'never',
always = 'always',
alwaysinclwild = 'alwaysinclwild',
dropped = 'dropped',
safe = 'safe',
gemwdegrade = 'gemwdegrade'
},
strings = {
reclaimable = 'reclaimable', --extra processing so no nice string
never = 'Always lost',
always = 'Always kept outside [[Wilderness|Wild]]',
alwaysinclwild = 'Always kept',
dropped = 'Dropped on death',
safe = 'Always a safe death',
gemwdegrade = nil --intentional nil
}
}
-- location restriction
local restriction_map = {
surface = 'surface',
dungeoneering = 'dungeoneering',
dg = 'dungeoneering',
daemonheim = 'dungeoneering',
quest = 'quest',
minigame = 'minigame',
activity = 'minigame',
beta = 'removed',
gone = 'removed',
removed = 'removed',
limited = 'limited',
['time limited'] = 'limited',
th = 'microtransaction',
sof = 'microtransaction',
['treasure hunter'] = 'microtransaction',
['squeal of fortune'] = 'microtransaction',
cache = 'cache'
}
-- Main function called with invokes
function p.main(frame)
local args = frame:getParent().args
local ret = infobox.new(args)
-- Parameter definitions
ret:defineParams{
{ name = 'name', func = 'name' },
{ name = 'aka', func = 'has_content' },
{ name = 'image', func = 'image' },
{ name = 'vanchor', func = { name = 'has_content', params = { 'version' }, flag = 'p' } },
-- release and removal
-- removal only shown if it exists
{ name = 'release', func = 'release' },
{ name = 'removal', func = 'removal' },
{ name = 'removaldisp', func = { name = removaldisp, params = { 'removal' } }, dupes = true },
{ name = 'members', func = 'has_content' },
{ name = 'examine', func = 'has_content' },
{ name = 'quest', func = 'has_content' },
{ name = 'tradeable', func = tradeablearg },
{ name = 'tradeablesmw', func = { name = yesno, params = { 'tradeable', false }, flag = { 'd', 'r' } } },
{ name = 'equipable', func = 'has_content' },
-- bankable; only show if "No"; default to "Yes"
{ name = 'bankable', func = { name = 'has_content', params = { 'bankable', 'Yes'}, flag = { 'd', 'r' } } },
{ name = 'bankabledisp', func = { name = yesnodisp, params = { 'bankable', 'no' }, flag = { 'd', 'r' } }, dupes = true },
{ name = 'bankablesmw', func = { name = yesno, params = { 'bankable', false }, flag = { 'd', 'r' } }, dupes = true },
-- stacksinbank; only show if "No"; default to "Yes"
{ name = 'stacksinbank', func = { name = 'has_content', params = { 'stacksinbank', 'Yes'}, flag = { 'd', 'r' } } },
{ name = 'stacksinbankdisp', func = { name = yesnodisp, params = { 'stacksinbank', 'no' }, flag = { 'd', 'r' } }, dupes = true },
{ name = 'stacksinbanksmw', func = { name = yesno, params = { 'stacksinbank', false }, flag = { 'd', 'r' } }, dupes = true },
-- lendable; only show if "Yes"; default to "No"
{ name = 'lendable', func = { name = 'has_content', params = { 'lendable', 'No'}, flag = { 'd', 'r' } } },
{ name = 'lendabledisp', func = { name = yesnodisp, params = { 'lendable' } }, dupes = true },
{ name = 'lendablesmw', func = { name = yesno, params = { 'lendable', false }, flag = { 'd', 'r' } }, dupes = true },
{ name = 'stackable', func = 'has_content' },
{ name = 'stackablesmw', func = { name = yesno, params = { 'stackable', false }, flag = { 'd', 'r' } }, dupes = true },
{ name = 'disassembly', func = disassemblyarg },
{ name = 'disassemblysmw', func = { name = disassemblysmwarg, params = { 'disassembly' }, flag = 'p' } },
-- edible; only show if "Yes"; default to "No"
{ name = 'edible', func = { name = 'has_content', params = { 'edible', 'No'}, flag = { 'd', 'r' } } },
{ name = 'edibledisp', func = { name = yesnodisp, params = { 'edible' } }, dupes = true },
-- noteable; only show if "Yes"; default to "No"
{ name = 'noteable', func = { name = 'has_content', params = { 'noteable', 'No'}, flag = { 'd', 'r' } } },
{ name = 'noteabledisp', func = { name = yesnodisp, params = { 'noteable' } }, dupes = true },
{ name = 'noteablesmw', func = { name = yesno, params = { 'noteable', true }, flag = { 'd', 'r' }, dupes = true } },
{ name = 'destroy', func = 'has_content' },
{ name = 'store', func = storearg },
-- actions
{ name = 'actions', func = 'has_content' },
{ name = 'actionsdisp', func = { name = actionsdisparg, params = { 'actions', 'actions_ground', 'actions_equipped', 'actions_bank' }, flag = 'd' }, dupes = true },
{ name = 'actions_ground', func = 'has_content' },
{ name = 'actions_equipped', func = 'has_content' },
{ name = 'actions_bank', func = 'has_content' },
-- gemw prices
-- only displayed if they exist
--dupes must exist for individual prices to have them display properly
{ name = 'gemw', func = { name = gemwarg, params = { 'exchange', 'tradeable' }, flag = {'p', 'd'} } },
{ name = 'gemwname', func = { name = gemwnamearg, params = { 'name', 'gemwname' } } },
{ name = 'gemwprice', func = { name = gemwpricearg, params = { 'gemw', 'gemwname' } }, dupes = true },
{ name = 'gemwpage', func = { name = gemwpagearg, params = { 'gemwprice', 'gemwname' } } },
{ name = 'exchange', func = { name = exchangearg, params = { 'gemwprice', 'gemwname' } }, dupes = true },
{ name = 'graph', func = { name = gemwgrapharg, params = { 'gemwprice', 'gemwname' } }, dupes = true },
{ name = 'buylimit', func = { name = buylimitarg, params = { 'gemwprice', 'gemwname' } }, dupes = true },
{ name = 'buylimitsmw', func = { name = buylimitsmwarg, params = { 'buylimit' } }, dupes = true },
{ name = 'exgvalue', func = { name = exgvaluearg, params = { 'gemwprice', 'gemwname' } }, dupes = true },
{ name = 'val', func = { name = valraw, params = { 'value', 'exgvalue' }, flag = {'p', 'd'} }, dupes = true },
{ name = 'value', func = { name = valuearg, params = { 'val', 'convert' }, flag = { 'd', 'p' } } },
-- used for both exchange and graphs
{ name = 'gemwdisp', func = { name = gemwdisp, params = { 'gemwprice' } }, dupes = true },
{ name = 'deathstatus', func = { name = deathstatusarg, params = { 'kept' }, flag = 'p' } },
{ name = 'ikodvalue', func = { name = ikodarg, params = { 'deathstatus', 'ikod', 'val', 'gemwprice' }, flag = { 'd', 'p', 'd', 'd' } } },
{ name = 'reclaimvalue', func = { name = reclaimvaluearg, params = { 'ikodvalue', 'reclaim', }, flag = { 'd', 'p' } } },
{ name = 'sacrificevalue', func = { name = sacrificevaluearg, params = { 'reclaimvalue', 'sacrifice' }, flag = { 'd', 'p' } } },
{ name = 'kept', func = { name = keptondeatharg, params = { 'deathstatus', 'ikod', 'reclaimvalue', 'sacrificevalue' }, flag = {'d', 'p', 'd', 'd'} } },
-- alchemy
{ name = 'gemwalchable', func = { name = gemwalchablearg, params = { 'gemwprice', 'gemwname' } }, dupes = true },
{ name = 'gemwalchmultiplier', func = { name = gemwalchmultiplierarg, params = { 'gemwprice', 'gemwname' } }, dupes = true },
{ name = 'alchable', func = { name = alchablearg, params = { 'alchable', 'high', 'low', 'gemwalchable' }, flag = {'p', 'p', 'p', 'd' } }, dupes = true },
{ name = 'alchmultiplier', func = 'numbers' },
{ name = 'alchmultiplier_final', func = { name = multiplierarg, params = { 'alchmultiplier', 'gemwalchmultiplier' }, flag = {'p','d'} } },
{ name = 'highraw', func = { name = alchvaluesraw, params = { 'val', 'high', 'alchmultiplier_final', 1, 'alchable' }, flag = { 'd', 'p', 'd', 'r', 'd' } } },
{ name = 'lowraw', func = { name = alchvaluesraw, params = { 'val', 'low', 'alchmultiplier_final', 2/3, 'alchable' }, flag = { 'd', 'p', 'd', 'r', 'd' } } },
{ name = 'high', func = { name = alchvalues, params = { 'val', 'high', 'alchmultiplier_final', 1, 'alchable' }, flag = { 'd', 'p', 'd', 'r', 'd' } } },
{ name = 'low', func = { name = alchvalues, params = { 'val', 'low', 'alchmultiplier_final', 2/3, 'alchable' }, flag = { 'd', 'p', 'd', 'r', 'd' } } },
-- calcvalue (value for items not on the GE)
{ name = 'calcvalue', func = { name = calcvalParse, params = { 'calcvalue' }, flag = { 'p' } }, dupes = true },
{ name = 'calcvalue_smw', func = { name = calcvalSMW, params = { 'calcvalue' }, flag = { 'p' } }, dupes = true },
{ name = 'weight', func = weightarg },
{ name = 'weightraw', func = { name = weightargraw, params = { 'weight' }, flag = 'p' } },
{ name = 'restriction', func = restrictionarg },
{ name = 'restrictionsurface', func = { name = restrsurfarg , params = { 'restriction', 'restriction', 'quest' }, flag = { 'd', 'p', 'd' } } },
-- not used; only for categories
{ name = 'id', func = { name = iddisp, params = { 'id' }, flag = 'p' } },
{ name = 'id_smw', func = { name = idsmw, params = { 'id' }, flag = 'p' } },
{ name = 'chisel_links', func = { name = make_chisel_links, params = { 'id_smw', 'name' }, flag = 'd' } },
{ name = 'rscid', func = 'numbers' },
{ name = 'SMWarg', func = { name = SMWarg, params = {
'name', 'version', 'id', 'members', 'release', 'removal', 'examine', 'quest', 'destroy', 'restriction', -- strings
'deathstatus', 'ikodvalue', 'reclaimvalue', 'sacrificevalue', -- death
'tradeable', 'equipable', 'bankable', 'stacksinbank', 'lendable', 'stackable', 'disassembly', 'edible', 'noteable', --generally boolean or tri-lean
'val', 'high', 'low', 'weightraw', -- numbers
'gemw', 'gemwname', 'buylimit' -- gemw
}, flag = 'd' } }
}
ret:setMaxButtons(7)
ret:create()
ret:cleanParams()
ret:customButtonPlacement(true)
-- parameter linkings for hidden rows
ret:linkParams{
{ 'removal', 'removaldisp' },
{ 'exchange', 'gemwdisp' },
{ 'graph', 'gemwdisp' },
{ 'buylimit', 'gemwdisp' },
{ 'bankable', 'bankabledisp' },
{ 'stacksinbank', 'stacksinbankdisp' },
{ 'lendable', 'lendabledisp' },
{ 'noteable', 'noteabledisp' },
{ 'edible', 'edibledisp' },
}
ret:defineLinks({ links = {{ 'Template:%s/FAQ', 'FAQ' },
{ 'Template:%s/doc', 'doc' }}, colspan = 2 })
ret:useSMW({
id_smw = 'Item ID',
members = 'Is members only',
})
ret:useSMWElement({
buylimitsmw = 'Buy limit',
SMWarg = 'Item JSON',
})
--[[
Handled in categories currently so it only sets default value
ret:useSMWOne({
calcvalue_smw = 'Calculated value',
})
--]]
ret:useSMWSubobject({
id_smw = 'Item ID',
vanchor = 'Version anchor',
name = 'Item name',
examine = 'Examine',
val = 'Value',
highraw = 'High Alchemy value',
lowraw = 'Low Alchemy value',
weightraw = 'Weight',
members = 'Is members only',
tradeablesmw = 'Tradeable',
stackablesmw = 'Stackable',
bankablesmw = 'Bankable',
stacksinbanksmw = 'Stacksinbank',
lendablesmw = 'Lendable',
disassemblysmw = 'Disassembleable',
noteablesmw = 'Noteable',
gemwpage = 'Exchange page',
buylimitsmw = 'Buy limit',
restriction = 'Location restriction',
deathstatus = 'Kept on death',
release = 'Release date',
update = 'Release update',
calcvalue_smw = 'Calculated value',
--removal = 'Removal date',
removalupdate = 'Removal update',
})
if onmain() then
local a2 = ret:categoryData()
if not a2['restriction'].all_defined then
ret:useSMWSubobject({
restrictionsurface = 'Location restriction',
})
end
end
ret:addButtonsCaption()
ret:defineName('Infobox Item')
ret:addClass('infobox-item')
ret:addRow{
{ tag = 'argd', content = 'image', class = 'infobox-image inventory-image bordered-image', colspan = '2' }
}
:addRow{
{ tag = 'argh', content = 'name', class='infobox-header', colspan = '2' }
}
:addRow{
{ tag = 'th', content = 'Release' },
{ tag = 'argd', content = 'release' }
}
if ret:paramDefined('removal') then
ret:addRow{
{ tag = 'th', content = 'Removal' },
{ tag = 'argd', content = 'removal' }
}
end
if ret:paramDefined('aka') then
ret:addRow{
{ tag = 'th', content = '[[Slang dictionary|AKA]]' },
{ tag = 'argd', content = 'aka' }
}
end
ret:addRow{
{ tag = 'th', content = '[[Members]]' },
{ tag = 'argd', content = 'members' }
}
:addRow{
{ tag = 'th', content = '[[Quest items|Quest item]]' },
{ tag = 'argd', content = 'quest' }
}
:addRow{
{ tag = 'th', content = 'Properties', class = 'infobox-subheader', colspan = '2' }
}
:addRow{
{ tag = 'th', content = '[[Items#Tradeability|Tradeable]]' },
{ tag = 'argd', content = 'tradeable' }
}
if ret:paramGrep('bankable','no') then
ret:addRow{
{ tag = 'th', content = '[[Bank]]able' },
{ tag = 'argd', content = 'bankable' }
}
end
if ret:paramGrep('stacksinbank','no') then
ret:addRow{
{ tag = 'th', content = 'Stacks in bank' },
{ tag = 'argd', content = 'stacksinbank' }
}
end
if ret:paramGrep('lendable','yes') then
ret:addRow{
{ tag = 'th', content = '[[Item Lending|Lendable]]' },
{ tag = 'argd', content = 'lendable' }
}
end
ret:addRow{
{ tag = 'th', content = '[[Equipment|Equipable]]' },
{ tag = 'argd', content = 'equipable' }
}
:addRow{
{ tag = 'th', content = '[[Stackable items|Stackable]]' },
{ tag = 'argd', content = 'stackable' }
}
:addRow{
{ tag = 'th', content = '[[Disassemble|Disassembly]]' },
{ tag = 'argd', content = 'disassembly' }
}
if ret:paramGrep('noteable','yes') then
ret:addRow{
{ tag = 'th', content = '[[Note|Noteable]]' },
{ tag = 'argd', content = 'noteable' }
}
end
if ret:paramGrep('edible','yes') then
ret:addRow{
{ tag = 'th', content = '[[Food|Edible]]' },
{ tag = 'argd', content = 'edible' }
}
end
ret:addRow{
{ tag = 'th', content = '[[Destroy (action)|Destroy]]' },
{ tag = 'argd', content = 'destroy', css = { ['max-width'] = '200px' } }
}
if ret:paramGrep('actionsdisp', true) then
local actions_help = '<sup class="hover-text noprint" title="Excludes actions \'Examine\', \'Take\', and \'Use\'">[?]</sup>'
ret:addRow{
{ tag = 'th', content = 'Actions '..actions_help, class = 'infobox-subheader', colspan = '2' },
}
if yesno(ret:param('actions'), true) ~= false then
ret:addRow{
{ tag = 'th', content = '[[Inventory|Backpack]]'},
{ tag = 'argd', content = 'actions' }
}
end
if ret:paramDefined('actions_ground') then
ret:addRow{
{ tag = 'th', content = 'On ground'},
{ tag = 'argd', content = 'actions_ground' }
}
end
if ret:paramDefined('actions_equipped') then
ret:addRow{
{ tag = 'th', content = '[[Worn Equipment|Equipped]]'},
{ tag = 'argd', content = 'actions_equipped' }
}
end
if ret:paramDefined('actions_bank') then
ret:addRow{
{ tag = 'th', content = '[[Bank|In bank]]'},
{ tag = 'argd', content = 'actions_bank' }
}
end
end
ret:addRow{
{ tag = 'th', content = 'Values', class = 'infobox-subheader', colspan = '2' }
}
ret:addRow{
{ tag = 'th', content = '[[Value]]' },
{ tag = 'argd', content = 'value' }
}
-- If any are alchable, add both rows, otherwise add a single "no alch" row
local anyalchable = ret:paramGrep('alchable',true)
if anyalchable == true then
ret:addRow{
{ tag = 'th', content = '[[High Level Alchemy|High alch]]' },
{ tag = 'argd', content = 'high' }
}
:addRow{
{ tag = 'th', content = '[[Low Level Alchemy|Low alch]]' },
{ tag = 'argd', content = 'low' }
}
else
ret:addRow{
{ tag = 'th', content = '[[Alchemy]]' },
{ tag = 'td', content = 'Not alchemisable' }
}
end
ret:addRow{
{ tag = 'th', content = '[[Items Kept on Death|On death]]' },
{ tag = 'argd', content = 'kept' }
}
:addRow{
{ tag = 'th', content = '[[Weight]]' },
{ tag = 'argd', content = 'weight' }
}
:addRow{
{ tag = 'th', content = '[[Examine]]', class = 'infobox-subheader', colspan = '2' }
}
:addRow{
{ tag = 'argd', content = 'examine', colspan = '2', css = { ['max-width'] = '300px', ['text-align'] = 'center' } }
}
-- Include GE section if we have any exchange prices
local anygemw = ret:paramGrep('gemwprice', function(_arg) return _arg > 0 end)
if anygemw == true then
ret:addRow{
{ tag = 'th', content = '[[Grand Exchange]]', class = 'infobox-subheader', colspan = '2' }
}
:addRow{
{ tag = 'th', content = '[[RuneScape:Grand Exchange Market Watch|Exchange]]' },
{ tag = 'argd', content = 'exchange' }
}
:addRow{
{ tag = 'th', content = '[[Grand Exchange#Trade restrictions|Buy limit]]' },
{ tag = 'argd', content = 'buylimit' }
}
:addRow{
{ tag = 'argd', content = 'graph', colspan = '2', css = { ['text-align'] = 'center', ['padding'] = '0'} }
}
end
ret:addRow{
{ tag = 'th', content = 'Advanced data', class = 'infobox-subheader', colspan = '2' },
meta = {addClass = 'advanced-data'}
}
:addRow{
{ tag = 'th', content = 'Item ID' },
{ tag = 'argd', content = 'id' },
meta = {addClass = 'advanced-data'}
}
:addRow{
{ tag = 'th', content = 'Links' },
{ tag = 'argd', content = 'chisel_links' },
meta = {addClass = 'advanced-data'}
}
if ret:paramDefined('calcvalue') then
ret :addRow{
{ tag = 'th', content = 'Calcval parsed' },
{ tag = 'argd', content = 'calcvalue' },
meta = {addClass = 'advanced-data'}
}
:addRow{
{ tag = 'th', content = 'Calcval smw' },
{ tag = 'argd', content = 'calcvalue_smw' },
meta = {addClass = 'advanced-data'}
}
end
if onmain() then
local a1 = ret:param('all')
local a2 = ret:categoryData()
ret:wikitext(addcategories(ret, a1,a2))
end
return ret:tostring()
end
function actionsdisparg(actions, actions_ground, actions_equipped, actions_bank)
-- if actions="no" and other actions aren't defined or no actions defined, hide
if (yesno(actions, true) == false and not (infobox.isDefined(actions_ground) or infobox.isDefined(actions_equipped) or infobox.isDefined(actions_bank))) or not (infobox.isDefined(actions) or infobox.isDefined(actions_ground) or infobox.isDefined(actions_equipped) or infobox.isDefined(actions_bank)) then
return nil
end
-- else show
return true
end
-- Store price
function storearg(store, currency, seller)
-- remove any commas
store = string.gsub(store or '',',','')
-- no for not sold
if string.lower(store) == 'no' then
return 'Not sold'
else
store = tonumber(store,10)
end
if type(store) == 'number' then
return store
else
return nil
end
end
-- tradeable
-- tradeablearg(value)
function tradeablearg(v)
v = string.lower(v or '')
if v == 'yes' or v == 'no' then
v = mw.text.split(v,'')
v[1] = string.upper(v[1])
return table.concat(v,'')
elseif v == 'restricted' then
return '[[Restricted trade items|Restricted]]'
else
return nil
end
end
-- disassembly
-- disassemblyarg(yes/no)
local allowed_disassembly = {
yes = 'true',
no = 'false',
restricted = 'restricted',
na = 'N/A',
['n/a'] = 'N/A',
discontinued = 'N/A',
irrelevant = 'N/A'
}
function disassemblyarg(d)
d = string.lower(d or '')
d = allowed_disassembly[d]
if d == 'true' then
return '[[#DisassemblyT|Yes]]' -- Unique anchor ID created by {{Disassembly}}
elseif d == 'false' then
return 'No'
elseif d == 'restricted' then
return '[[:Category:Location restricted disassembly|Restricted]]'
elseif d == 'N/A' then
return 'N/A'
else
return nil
end
end
-- disassemblysmwarg(yes/no)
function disassemblysmwarg(d)
d = string.lower(d or '')
return allowed_disassembly[d]
end
-- value
-- separate number storage for operation
-- pulls the exchange value first, and prefers that if it exists
-- valraw(value, exchange value)
function valraw(v, ex)
if type(ex) == 'number' then
return ex
else
return tonumber(string.gsub(v or '', ',', ''), 10)
end
end
-- value
-- valuearg(value, convert)
-- actual value already parsed
function valuearg(v,c)
-- replace commas and turn into a number
if paramtest.has_content(c) then
c = string.gsub(c,',','')
c = tonumber(c,10)
else
c = nil
end
v = tonumber(v,10)
-- if both are defined, show both, value first
if v and c then
return string.format('%s<br/><b>Cash out:</b><br/>%s',plural('coin',v),plural('coin',c))
-- if only value is defined, show just that
elseif v and not c then
return plural('coin',v)
-- if only convert is defined, show just that
-- may need to change this so that value is requested
elseif c and not v then
return string.format('<b>Cash out:</b><br/>%s',plural('coin',c))
else
return nil
end
end
-- ge alchable boolean
-- gemwalchablearg(gemw price, name)
-- uses the already fetched ge price to operate
-- values less than 1 are used for parsing instructions
function gemwalchablearg(g,n)
if type(g) ~= 'number' then
g = tonumber(g,10) or 0
end
-- 0 for not sold an
-- -1 for error
-- call to hide the graph
if g == 0 or g == -1 then
return '-'
-- all other numbers
elseif g > 0 then
local ret = exchange._alchable(n)
if ret == nil then
return '-'
elseif ret == false then
return 'false' --not very good at handling false
else
return true
end
-- not a number = nil
-- shouldn't be used, but it's a fallback
else
return '-'
end
end
-- ge alch multiplier
-- gemwalchmultiplierarg(gemw price, name)
-- uses the already fetched ge price to operate
-- values less than 1 are used for parsing instructions
function gemwalchmultiplierarg(g,n)
if type(g) ~= 'number' then
g = tonumber(g,10) or 0
end
-- 0 for not sold an
-- -1 for error
-- call to hide the graph
if g == 0 or g == -1 then
return '-'
-- all other numbers
elseif g > 0 then
local ret = exchange._alchmultiplier(n)
if ret == nil then
return '-'
else
return ret
end
-- not a number = nil
-- shouldn't be used, but it's a fallback
else
return '-'
end
end
-- Alchables
-- alchablearg(alchable, high, low)
function alchablearg(a,h,l,ex)
if ex == true then
return true
elseif ex == 'false' then
return 'false'
end
-- not alchable if both are false, or if "alchable" is false
if string.lower(a or '') == 'no' then
return 'false'
elseif string.lower(h or '') == 'no' and string.lower(l or '') == 'no' then
return 'false'
else
return true
end
end
-- alch multiplier arg
-- only accepts numbers
-- defaults to .6
function multiplierarg(v, ex)
if type(ex) == 'number' then
return ex
end
return tonumber(v) or 0.6
end
-- high/low alch
-- alchvalues(value, override value, multiplier, alchable)
-- actual value already parsed
-- value, template param, alch multiplier, override multiplier, not alchable bool
function alchvalues(v,_p,a,m,n)
-- if you can't alch it, return this
-- used in the case of 1 version being alchable and the other not
if not infobox.isDefined(n) or n == 'false' then
return 'Not alchemisable'
end
-- remove commas and turn into a number
v = tonumber(v,10)
if paramtest.has_content(_p) then
_p = string.gsub(_p,',','')
_p = tonumber(_p,10)
else
_p = nil
end
-- return override always
if type(_p) == 'number' then
return plural('coin',_p)
end
-- otherwise try the value and multiply it
if v then
local r = math.floor(killRoundingError(v * m * a))
-- both high and low alch have a lower bound of one coin
r = math.max(r, 1)
return plural('coin',r)
end
return nil
end
-- alchvaluesraw(value, override value, multiplier, alchable)
-- actual value already parsed
-- value, template param, alch multiplier, override multiplier, not alchable bool
function alchvaluesraw(v,_p,a,m,n)
-- if you can't alch it, return nil
if not infobox.isDefined(n) or n == 'false' then
return nil
end
-- remove commas and turn into a number
v = tonumber(v,10)
if paramtest.has_content(_p) then
_p = string.gsub(_p,',','')
_p = tonumber(_p,10)
else
_p = nil
end
-- return override always
if type(_p) == 'number' then
return _p
end
-- otherwise try the value and multiply it
if v then
local r = math.floor(killRoundingError(v * m * a))
-- both high and low alch have a lower bound of one coin
r = math.max(r, 1)
return r
end
return nil
end
-- calcvalue (calculated value for items not sold on GE)
function calcvalSMW(calcval)
if tonumber(calcval) then
return calcval
end
local str = string.gsub( string.gsub(calcval, '{', '{{'), '}', '}}')
str = string.gsub(str, '¦', '|')
return str
end
function calcvalParse(calcval)
if tonumber(val) then
return val
end
local val = calcvalSMW(calcval)
if not infobox.isDefined(calcval) or not infobox.isDefined(val) then
return nil
end
val = mw.getCurrentFrame():preprocess(val)
if tonumber(val) then
val = math.floor(val * 100 + 0.5) / 100
end
return val
end
-- weight
-- weightarg(weight)
function weightarg(w)
if paramtest.has_content(w) then
-- replace all "kg" and spaces here
w = string.gsub(w or '','[kg ]','')
-- replace hyphen with minus sign
w = string.gsub(w,'-','−')
-- use non-breaking spaces and html entities for display
-- still necessary to convert the "kg" to html?
return string.format('%s kg',w)
end
return nil
end
-- weightargraw(weight)
function weightargraw(w)
if paramtest.has_content(w) then
-- replace all "kg" and spaces here
w = string.gsub(w or '','[kg ]','')
return tonumber(w)
end
return nil
end
-- on ge or not
-- only accepts "gemw"
-- gemwarg(exchange,tradeable)
function gemwarg(arg,arg2)
g = string.lower(arg or '')
return arg2 == 'Yes' and g == 'gemw'
end
-- gemw names
-- gemwnamearg(name, override name)
function gemwnamearg(n,a)
-- return override
if a and a:find('%S') then
return string.gsub(a,'</?span>','')
-- otherwise use the "name" parameter
elseif n and n:find('%S') then
return string.gsub(n,'</?span>','')
-- default to page name
else
return mw.title.getCurrentTitle().fullText
end
end
-- separate thing to hold all the prices as raw numbers
-- gemwpricearg(gemw, name)
function gemwpricearg(g,n)
if g == true then
-- return price if page is found
-- -1 for errors
if exchange._exists(n) then
return tonumber(exchange._price(n),10) or -1
else
return -1
end
-- 0 for no price
else
return 0
end
end
-- gemwpricearg(gemw price, name)
-- exchange page name for SMW
-- uses the already fetched ge price to operate
-- values less than 1 are used for parsing instructions
function gemwpagearg(g,n)
if type(g) ~= 'number' then
g = tonumber(g,10) or 0
end
if g < 1 then
return nil
else
return 'Exchange:'..n
end
end
-- exchange display
-- exchangearg(gemw price, name)
-- uses the already fetched ge price to operate
-- values less than 1 are used for parsing instructions
function exchangearg(g,n)
if type(g) ~= 'number' then
g = tonumber(g,10) or 0
end
-- 0 for not sold
if g == 0 then
return '<span class="infobox-quantity" data-val-each="0">Not sold</span>'
-- -1 for no page found
elseif g == -1 then
return badarg('exchange','was set to «gemw» but no page was found for «'..n..'».')
-- all other numbers
elseif g > 0 then
-- plural done in format because we need a span around the value
return string.format('<span class="infobox-quantity" data-val-each="%s"><span class="infobox-quantity-replace">%s</span> coin%s ([[Exchange:%s|info]])</span>',g,commas(g),g>1 and 's' or '',n)
-- not a number = nil
-- shouldn't be used, but it's a fallback
else
return 0
end
end
-- ge graphs
-- gemwgrapharg(gemw price, name)
-- uses the already fetched ge price to operate
-- values less than 1 are used for parsing instructions
function gemwgrapharg(g,n)
if type(g) ~= 'number' then
g = tonumber(g,10) or 0
end
-- 0 for not sold an
-- -1 for error
-- call to hide the graph
if g == 0 or g == -1 then
return 'No data to display'
-- all other numbers
elseif g > 0 then
return chart{n, size = 'small'}
-- not a number = nil
-- shouldn't be used, but it's a fallback
else
return nil
end
end
-- ge buy limits
-- buylimitarg(gemw price, name)
-- uses the already fetched ge price to operate
-- values less than 1 are used for parsing instructions
function buylimitarg(g,n)
if type(g) ~= 'number' then
g = tonumber(g,10) or 0
end
-- 0 for not sold an
-- -1 for error
-- call to hide the graph
if g == 0 or g == -1 then
return '-'
-- all other numbers
elseif g > 0 then
local ret = exchange._limit(n)
if ret == nil then
return '-'
else
return commas(ret)
end
-- not a number = nil
-- shouldn't be used, but it's a fallback
else
return nil
end
end
function buylimitsmwarg(b)
if type(b) == 'string' then
b = b:gsub(',', '')
end
if tonumber(b) then
return tonumber(b)
end
return infobox.donotsetsmw
end
-- ge value
-- exgvaluearg(gemw price, name)
-- uses the already fetched ge price to operate
-- values less than 1 are used for parsing instructions
function exgvaluearg(g,n)
if type(g) ~= 'number' then
g = tonumber(g,10) or 0
end
-- 0 for not sold an
-- -1 for error
-- call to hide the graph
if g == 0 or g == -1 then
return '-'
-- all other numbers
elseif g > 0 then
local ret = exchange._value(n)
if ret == nil then
return '-'
else
return ret
end
-- not a number = nil
-- shouldn't be used, but it's a fallback
else
return '-'
end
end
-- class names based on value
-- gemwdisp(price)
function gemwdisp(_p)
if _p == 0 then
return ''
else
return 'infobox-cell-shown'
end
end
-- Shows if the param matches the alt
-- alt defaults to yes
-- Everything else = hide
function yesnodisp(arg, alt)
arg = string.lower(arg or '')
alt = string.lower(alt or 'yes')
if arg == alt then
return 'infobox-cell-shown'
else
return ''
end
end
-- Shows if has a date
function removaldisp(arg)
if string.find(arg or '','%[%[') then
return 'infobox-cell-shown'
else
return ''
end
end
-- death
-- deathstatusarg(death)
function deathstatusarg(d)
d = string.lower(d or '')
return death_map.allowed[d]
end
-- ikodarg()
function ikodarg(d, _i, v, g)
if d == 'reclaimable' then
v = tonumber(v)
local i
-- replace commas and convert to number
if paramtest.has_content(_i) then
i = string.gsub(_i,',','')
i = tonumber(i,10)
else
i = nil
end
-- if i is defined, show that value
if i then
return i
-- test geprice next
elseif (tonumber(g,10) or 0) > 0 then
i = tonumber(g,10)
-- test value next
elseif v then
i = v
end
return i
end
return -1
end
-- reclaimvaluearg(ikodvalue, reclaim)
function reclaimvaluearg(i, _r)
i = tonumber(i or -1) or -1
if i > 0 then
local r
-- test for overridden reclaim
if paramtest.has_content(_r) then
_r = string.gsub(_r,',','')
r = tonumber(_r)
end
-- if no number, use formula
if not r then
-- less than 10,000: .15x
if i < 10000 then
r = math.floor(i * .15)
-- all items cost at least 1 coin, so round back up if 0
if r == 0 then
r = 1
end
--[[
Death formula
]]
-- 10,000 to 49,999: 500 + 0.1x
elseif i >= 10000 and i < 50000 then
r = 500 + i * 0.1
-- 50,000 to 249,999: 3000 + 0.05x
elseif i >= 50000 and i < 250000 then
r = 3000 + i * 0.05
-- 250,000 to 999,999: 10500 + 0.02x
elseif i >= 250000 and i < 1000000 then
r = 10500 + i * 0.02
-- 1,000,000 to 9,999,999: 20500 + 0.01x
elseif i >= 1000000 and i < 10000000 then
r = 20500 + i * 0.01
-- 10,000,000 and greater: 70,500 + 0.005x
elseif i >= 10000000 then
r = 70500 + i * 0.005
-- this shouldn't happen, but fallback to 1
else
r = 1
end
end
r = math.floor(killRoundingError(r))
return r
end
return -1
end
-- sacrificevaluearg(reclaimvalue, sacrifice)
function sacrificevaluearg(r, _s)
if r > 0 then
if paramtest.has_content(_s) then
_s = string.gsub(_s,',','')
_s = tonumber(_s,10)
end
-- if overridden, use _s for sacrifice
if tonumber(_s,10) then
s = _s
else
-- otherwise include sacrifice as 4r
s = r * 4
end
return s
end
return -1
end
-- keptondeatharg(deathstatus, ikod, reclaimvalue, sacrificevalue)
function keptondeatharg(d,_i,r,s)
if d == 'reclaimable' then
local ret = { 'Reclaimable' }
local i
-- replace commas and convert to number
if paramtest.has_content(_i) then
i = string.gsub(_i,',','')
i = tonumber(i,10)
else
i = nil
end
if i then
table.insert(ret,string.format('<b>Value:</b> %s',commas(i)))
end
table.insert(ret,string.format('<b>Reclaim:</b> %s',commas(r)))
table.insert(ret,string.format('<b>Sacrifice:</b> %s',commas(s)))
return table.concat(ret,'<br/>')
else
return death_map.strings[d]
end
end
-- red ERR span with title hover for explanation
function badarg(argname, argmessage)
return '<span '..
'title="The parameter «'..argname..'» '..argmessage..'" '..
'style="color:red; font-weight:bold; cursor:help; border-bottom:1px dotted red;">'..
'ERR</span>'
end
-- plural
-- returns number with the word
function plural(arg,n,alt)
local _n = commas(tonumber(n,10) or 1)
if tonumber(n,10) == 1 then
return string.format('%s %s',_n,arg)
elseif alt then
return string.format('%s %s',_n,alt)
else
return string.format('%s %ss',_n,arg)
end
end
-- Does exactly what's on the tin
function killRoundingError(n)
return math.floor(n*1000+0.0000099)/1000
end
function restrictionarg(arg)
if paramtest.is_empty(arg) then
return nil
end
return restriction_map[string.lower(arg)]
end
function restrsurfarg(cleaned, passed)
if infobox.isDefined(cleaned) then
return nil
end
return restriction_map.surface
end
function iddisp(id)
if infobox.isDefined(id) then
if id:lower() ~= 'no' then
local r = string.gsub(id, ', *', ', ')
return r
elseif id:lower() == 'no' then
return 'None'
end
end
return nil
end
function idsmw(id)
if infobox.isDefined(id) then
local r = string.gsub(id, ', *', infobox.splitpoint)
return r
end
return nil
end
function make_chisel_links(id, name)
local link1 = 'https://chisel.weirdgloop.org/gazproj/mrid'
local link2 = 'https://chisel.weirdgloop.org/gazproj/recipe/'
if infobox.isDefined(id) then
local ids = mw.text.split(id, infobox.splitpoint)
id1 = tonumber(ids[1])
if id1 then
if #ids == 1 then
link1 = string.format('%sid?%s#%s-%s', link1, id1, id1-15, id1+15)
link2 = link2 .. id1
else
for i,j in ipairs(ids) do
if i == 1 then
link1 = string.format('%sid?%s#%s', link1, j, j)
link2 = link2 .. j
else
link1 = link1 .. '@' .. j
end
end
end
else
link1 = string.format('%sid#%s', link1, ids[1])
link2 = link2 .. ids[1]
end
else
local _name = name:gsub(' ', '%%20')
link1 = string.format('%s#%s', link1, _name)
link2 = nil
end
if link2 then
return string.format('[%s MRID] • [%s recipe]', link1, link2)
else
return string.format('[%s MRID]', link1)
end
end
-- SMW JSON
function SMWarg(name, version, id, members, release, removal, examine, quest, destroy, restriction, deathstatus, ikodvalue, reclaimvalue, sacrificevalue, tradeable, equipable, bankable, stacksinbank, lendable, stackable, disassembly, edible, noteable, value, high, low, weight, gemw, gemwname, buylimit)
local toJSON = {
name = name,
version = version,
id = id,
members = string.lower(tostring(members) or ''),
examine = examine,
death = deathstatus,
destroy = destroy,
tradeable = string.lower(tostring(tradeable) or ''),
equipable = string.lower(tostring(equipable) or ''),
bankable = string.lower(tostring(bankable) or ''),
stacksinbank = string.lower(tostring(stacksinbank) or ''),
lendable = string.lower(tostring(lendable) or ''),
stackable = string.lower(tostring(stackable) or ''),
edible = string.lower(tostring(edible) or ''),
noteable = string.lower(tostring(noteable) or ''),
value = val,
weight = weight,
}
local w
if high == 'Not alchemisable' then
toJSON.highalch = false
else
w = high:gsub(',',''):gsub('coins?','')
toJSON.highalch = tonumber(w) or false
end
if low == 'Not alchemisable' then
toJSON.lowalch = false
else
w = low:gsub(',',''):gsub('coins?','')
toJSON.highalch = tonumber(w) or false
end
if toJSON.tradeable == 'yes' and gemw then
toJSON.gemw = { name = gemwname }
if buylimit ~= '-' then
w = buylimit:gsub(',','')
toJSON.gemw.limit = tonumber(w)
end
else
toJSON.gemw = false
end
if disassembly:find('[Yy]es') then
toJSON.disassembly = 'yes'
elseif disassembly:find('restricted') then
toJSON.disassembly = 'restricted'
else
toJSON.disassembly = string.lower(tostring(disassembly) or '')
end
if paramtest.is_empty(restriction) and tostring(restriction):find('action=edit') then
toJSON.restriction = restriction_map.surface
else
toJSON.restriction = restriction
end
local rel, upd, rem, updr
rel, upd = release:match('(.-) %(%[%[Update:(.-)|Update%]%]%)')
if rel == nil then
rel = release:match('(.-) %(Update unknown%)')
end
if rel then
toJSON.release_date = rel:gsub('%[',''):gsub('%]','')
if upd then
toJSON.release_update_post = upd
end
end
rem, updr = removal:match('(.-) %(%[%[Update:(.-)|Update%]%]%)')
if rem == nil then
rem = removal:match('(.-) %(Update unknown%)')
end
if rem then
toJSON.removal_date = rem:gsub('%[',''):gsub('%]','')
if updr then
toJSON.removal_update_post = updr
end
end
for k,v in pairs(toJSON) do
if v == '' or (type(v) == 'string' and string.find(v,'action=edit')) then
toJSON[k] = nil
end
end
return mw.text.killMarkers(mw.text.nowiki(mw.text.jsonEncode(toJSON)))
end
-- Categories
-- oman this is still blatant copy pasta
function addcategories(ibox, args, catargs)
local ret = { 'Items' }
local cat_map = {
-- Added if the parameter has content
defined = {
aka = 'Pages with AKA',
alchmultiplier = 'Has Alchemy Multiplier',
calcvalue = 'Items with an alternate value'
},
-- Added if the parameter has no content
notdefined = {
image = 'Needs image',
members = 'Needs members status',
release = 'Needs release date',
examine = 'Needs examine added',
level = 'Needs combat level',
weight = 'Needs weight added',
value = 'Items missing value',
quest = 'Items missing quest',
destroy = 'Missing destroy text',
kept = 'Items missing death info',
disassembly = 'Items missing disassembly info',
actions = 'Needs actions added',
},
-- Parameters that have text
-- map a category to a value
grep = {
members = { yes = 'Members\' items', no = 'Free-to-play items' },
stackable = { yes = 'Stackable items' },
lendable = { yes = 'Lendable items' },
equipable = { yes = 'Equipable items' },
gemw = { ['true'] = 'Grand Exchange items' },
exchange = { ['but no page was found for'] = 'Exchange page not found' },
tradeable = { yes = 'Tradeable items', no = 'Untradeable items', restricted = 'Restricted trade items' },
bankable = { no = 'Unbankable items' },
disassembly = { yes = 'Items that can be disassembled', no = 'Items that cannot be disassembled', restricted = 'Location restricted disassembly', ['n/a'] = 'Items with N/A disassembly' },
kept = { ['always lost'] = 'Items that are never kept on death', ['always kept outside'] = 'Items that are always kept outside the Wilderness on death', reclaimable = 'Items that are reclaimable on death' }
}
}
-- Run and add mapped categories
-- defined categories
for n, v in pairs(cat_map.defined) do
if catargs[n] and catargs[n].one_defined then
table.insert(ret,v)
end
end
-- undefined categories
for n, v in pairs(cat_map.notdefined) do
if catargs[n] and catargs[n].all_defined == false then
table.insert(ret,v)
end
end
-- searches
for n, v in pairs(cat_map.grep) do
for m, w in pairs(v) do
if args[n] then
if string.find(string.lower(tostring(args[n].d) or ''),m) then
table.insert(ret,w)
end
if args[n].switches then
for _, x in ipairs(args[n].switches) do
if string.find(string.lower(tostring(x)),m) then
table.insert(ret,w)
end
end
end
end
end
end
-- quest items
-- just look for a link
if args.quest.d:find('%[%[') then
table.insert(ret,'Quest items')
elseif args.quest.switches then
for _, v in ipairs(args.quest.switches) do
if v:find('%[%[') then
table.insert(ret,'Quest items')
break
end
end
end
-- extra func for death
-- searching for 'always kept' would match more than what we want
if args.kept.d == 'Always kept' then
table.insert(ret,'Items that are always kept on death')
elseif args.kept.switches then
for _, v in ipairs(args.kept.switches) do
if v == 'Always kept' then
table.insert(ret,'Items that are always kept on death')
break
end
end
end
-- ids
if not catargs.id.all_defined then
-- rsc ids have no id
if catargs.rscid.all_defined then
-- do nothing
else
table.insert(ret,'Needs ID')
end
end
-- store
if string.lower(args.store.d or '') ~= 'not sold' and not string.lower(args.store.d or 'edit'):find('edit') then
table.insert(ret,'Pages that use Store')
elseif args.store.switches then
for _, v in ipairs(args.store.switches) do
if string.lower(v or '') ~= 'not sold' and string.lower(v or '') ~= infobox.nil_param() and not string.lower(v or 'edit'):find('edit') then
table.insert(ret,'Pages that use Store')
end
end
end
-- alchemy
-- non alchable
if args.alchable.d ~= true then
table.insert(ret,'Items that cannot be alchemised')
elseif args.alchable.switches then
for _, v in ipairs(args.alchable.switches) do
if v ~= true then
table.insert(ret,'Items that cannot be alchemised')
break
end
end
end
-- gemw
-- if item is both (not untradeable) and (not GEMW) then add Non-GE items
if not args.gemw.d and string.lower(args.tradeable.d) ~= 'no' then
table.insert(ret, 'Non-GE items')
end
-- switches; if tradeable switches exist, if gemwX and tradeableX are as above, add Non-GE items
-- if no switches, gemwX and tradeable (default)
if args.gemw.switches then
if args.tradeable.switches then
for i, v in ipairs(args.gemw.switches) do
if not v and string.lower(args.tradeable.switches[i] or args.tradeable.d) ~= 'no' then
table.insert(ret, 'Non-GE items')
end
end
else
for i, v in ipairs(args.gemw.switches) do
if not v and string.lower(args.tradeable.d) ~= 'no' then
table.insert(ret, 'Non-GE items')
end
end
end
end
local limit = string.gsub(tostring(args.buylimit.d), ',', '')
if tonumber(limit) then
if tonumber(limit) < 1000 then
table.insert(ret, 'Low buy limit')
end
end
if args.buylimit.switches then
for i,v in ipairs(args.buylimit.switches) do
limit = string.gsub(tostring(args.buylimit.switches[i] or args.buylimit.d), ',', '')
if tonumber(limit) then
if tonumber(limit) < 1000 then
table.insert(ret, 'Low buy limit')
end
end
end
end
-- Calculated value, set default to base page
if args['calcvalue_smw'].d then
mw.smw.set({['Calculated value'] = args['calcvalue_smw'].d})
end
-- special addition for location restriction
-- if everything is the same then add to the base page as well
-- only matters if is a switchfo
if ibox.switchfo then
if not catargs.restriction.one_defined then
-- no restriction set == all of them are surface
mw.smw.set({['Location restriction'] = 'surface'})
else
if args.restriction.switches then
local val = args.restriction.switches[1] or args.restriction.d or restriction_map.surface
local all_the_same = true
for i,v in ipairs(args.restriction.switches) do
local curr = v or args.restriction.d or restriction_map.surface
if val ~= curr then
all_the_same = false
break
end
end
if all_the_same then
mw.smw.set({['Location restriction'] = val})
else
table.insert(ret, 'Items with mixed restrictions')
end
else
-- not a switchable param
-- set to d
mw.smw.set({['Location restriction'] = args.restriction.d or restriction_map.surface})
end
end
end
-- combine table and format category wikicode
for i, v in ipairs(ret) do
ret[i] = string.format('[[Category:%s]]',v)
end
return table.concat(ret,'')
end
return p
--</nowiki>