Module:Sandbox: Difference between revisions

From Path of Exile 2 Wiki
Jump to navigation Jump to search
No edit summary
m (257 revisions imported)
 
(169 intermediate revisions by 6 users not shown)
Line 1: Line 1:
local p = {}
-- This is not an actual module. Do not add code.
local views = {}
local getArgs
local doConcat
 
---------------------------------------------------------------------
-- Argument processing
---------------------------------------------------------------------
local function makeInvokeFunc(funcName)
return function (frame)
if not getArgs then
getArgs = require('Module:Arguments').getArgs
end
local args = getArgs(frame)
return p[funcName](args)
end
end
 
---------------------------------------------------------------------
-- Implements {{item}}
---------------------------------------------------------------------
p.item = makeInvokeFunc('_item')
function p._item(args)
local cleanArgs = {}
cleanArgs.view = args.view or args.View or 'full'
cleanArgs.format = args.format or args.Format
cleanArgs.name = args.name or args.Name
cleanArgs.sortKey = args.sortKey or args.SortKey or cleanArgs.name
cleanArgs.pageName = args.pageName or args.PageName or cleanArgs.name
cleanArgs.image = args.image or args.Image or cleanArgs.pageName .. '.png'
cleanArgs.size = args.size or args.Size or '2x_'
cleanArgs.rarity = args.rarity or args.Rarity or 'Normal'
cleanArgs.type = args.type or args.Type
cleanArgs.subtype = args.subtype or args.Subtype
cleanArgs.baseItem = args.baseItem or args.BaseItem
cleanArgs.baseItemPage = args.baseItemPage or args.BaseItemPage or cleanArgs.baseItem
cleanArgs.level = args.level or args.RequiredLevel
cleanArgs.strength = args.strength or args.RequiredStrength
cleanArgs.dexterity = args.dexterity or args.RequiredDexterity
cleanArgs.intelligence = args.intelligence or args.RequiredIntelligence
cleanArgs.physical = args.physicalDamage or args.PhysicalDamage
cleanArgs.fire = args.fire or args.FireDamage
cleanArgs.cold = args.cold or args.ColdDamage
cleanArgs.lightning = args.lightning or args.LightningDamage
cleanArgs.chaos = args.chaos or args.ChaosDamage
cleanArgs.averageDamage = args.averageDamage or args.AverageDamage
cleanArgs.critChance = args.critChance or args.CriticalStrikeChance
cleanArgs.attacksPerSecond = args.attacksPerSecond or args.AttacksPerSecond
cleanArgs.blockChance = args.blockChance or args.Block
cleanArgs.armour = args.armour or args.Armour
cleanArgs.evasion = args.evasion or args.Evasion
cleanArgs.energyShield = args.energyShield or args.EnergyShield
cleanArgs.mapLevel = args.mapLevel or args.MapLevel
cleanArgs.itemQuantity = args.itemQuantity or args.itemQuantity
cleanArgs.radius = args.radius or args.Radius
cleanArgs.stackSize = args.stackSize or args.StackSize
cleanArgs.effect = args.effect or args.Effect
cleanArgs.life = args.life or args.FlaskLife
cleanArgs.mana = args.mana or args.FlaskMana
cleanArgs.duration = args.duration or args.FlaskDuration
cleanArgs.chargeCap = args.chargeCap or args.FlaskCharges
cleanArgs.chargeUse = args.chargeUse or args.ChargesUsed
cleanArgs.implicitMods = args.implicitMods or args.ImplicitMods
cleanArgs.randomMods = args.randomMods or args.RandomMods
cleanArgs.cosmeticMods = args.cosmeticMods or args.CosmeticMods
cleanArgs.helpText = args.helpText or args.HelpText
cleanArgs.flavourText = args.flavourText or args.FlavourText
return views[cleanArgs.view](cleanArgs)
end
 
---------------------------------------------------------------------
-- Views
---------------------------------------------------------------------
function views.full(args)
args.stats = p._statsBuilder(args)
args.class = 'itembox-full'
args.name = '[[' .. args.pageName .. '|' .. args.name .. ']]'
args.baseItem = args.baseItem and ('[[' .. args.baseItemPage .. '|' .. args.baseItem .. ']]') or nil
args.belowStats = mw.html.create('div')
:attr('class', 'itemboximage')
:wikitext( '[[File:' .. args.image .. '|' .. p._itemsize({args.size}) .. '|]]' )
local category
local types = {
['Weapon'] = {
['Bow'] = 'Bows',
['Claw'] = 'Claws',
['Dagger'] = 'Daggers',
['Wand'] = 'Wands',
['Fishing Rod'] = 'Fishing rods',
['Staff'] = 'Staves',
['One Handed Axe'] = 'One-handed axes',
['Two Handed Axe'] = 'Two-handed axes',
['One Handed Mace'] = 'One-handed maces',
['Two Handed Mace'] = 'Two-handed maces',
['One Handed Sword'] = 'One-handed swords',
['Two Handed Sword'] = 'Two-handed swords'
},
['Armour'] = {
['Body Armour'] = 'Body armours',
['Helmet'] = 'Helmets',
['Shield'] = 'Shields',
['Boots'] = 'Boots',
['Gloves'] = 'Gloves'
},
['Accessory'] = {
['Amulet'] = 'Amulets',
['Belt'] = 'Belts',
['Quiver'] = 'Quivers',
['Ring'] = 'Rings'
},
['Flask'] = {
['Life'] = 'Life flasks',
['Mana'] = 'Mana flasks',
['Hybrid'] = 'Hybrid flasks',
['Utility'] = 'Utility flasks'
},
['Map'] = {
['Fragment'] = 'Map fragments',
['_default'] = 'Maps'
},
['Jewel'] = 'Jewels',
['Currency'] = 'Currency items',
['Quest'] = 'Quest items',
['Microtrans'] = 'Microtransaction features'
}
category = types[args.type]
if type(category) == 'table' then
category = types[args.type][args.subtype or '_default']
end
if category then
if args.rarity == 'Unique' then
category = 'Unique ' .. string.lower(category)
end
else
category = 'Items with invalid types'
end
return tostring( p._itembox(args) ) .. '[[Category:' .. category .. ']]'
end
 
function views.standard(args)
args.stats = p._statsBuilder(args)
args.name = '[[' .. args.pageName .. '|' .. args.name .. ']]'
args.baseItem = args.baseItem and ('[[' .. args.baseItemPage .. '|' .. args.baseItem .. ']]') or nil
return tostring( p._itembox(args) )
end
 
function views.inline(args)
args.stats = p._statsBuilder(args)
args.class = 'itemboxhover itemboxhoverhide itemboxhovernojs'
args.isHover = true
local text = 'asdf'
local container = mw.html.create('span')
:tag('span')
:attr('class', 'itemhover')
:done()
:node( p.itembox(args) )
:tag('span')
:attr('class', 'itemboxhovericon itemboxhoverhide itemboxhovernojs')
:done()
return tostring(container)
end
 
---------------------------------------------------------------------
-- Stats builder
---------------------------------------------------------------------
function p._statsBuilder(args)
local container = mw.html.create('span')
local group
local function newGroup(class)
return mw.html.create('span')
:attr( 'class', 'itemboxstatsgroup ' .. (class or '') )
end
local function newColor(label, text)
if text == nil or text == '' then
return nil
end
return mw.html.create('span')
:attr('class', 'text-' .. label)
:wikitext(text)
end
if args.type == 'Weapon' then
group = newGroup()
:wikitext(args.subtype)
:tag('br'):done()
if args.physical then
group
:wikitext('Physical Damage: ')
:node( newColor('value', args.physical) )
:tag('br'):done()
end
if args.fire or args.cold or args.lightning then
local elementalDamage = {}
if args.fire then
table.insert( elementalDamage, tostring( newColor('fire', args.fire) ) )
end
if args.cold then
table.insert( elementalDamage, tostring( newColor('cold', args.cold) ) )
end
if args.lightning then
table.insert( elementalDamage, tostring( newColor('lightning', args.lightning) ) )
end
group
:wikitext('Elemental Damage: ')
:wikitext( table.concat(elementalDamage, ', ') )
:tag('br'):done()
end
if args.chaos then
group
:wikitext('Chaos Damage: ')
:node( newColor('chaos', args.chaos) )
:tag('br'):done()
end
group
:wikitext('Critical Strike Chance: ')
:node( newColor('value', args.critChance) )
:tag('br'):done()
:wikitext('Attacks per Second: ')
:node( newColor('value', args.attacksPerSecond) )
container:node(group)
elseif args.type == 'Armour' then
if args.blockChance or args.armour or args.evasion or args.energyShield then
group = newGroup()
if args.blockChance then
group
:wikitext('Chance to Block: ')
:node( newColor('value', args.blockChance) )
:tag('br'):done()
end
if args.armour then
group
:wikitext('Armour: ')
:node( newColor('value', args.armour) )
:tag('br'):done()
end
if args.evasion then
group
:wikitext('Evasion: ')
:node( newColor('value', args.evasion) )
:tag('br'):done()
end
if args.energyShield then
group
:wikitext('Energy Shield: ')
:node( newColor('value', args.energyShield) )
end
container:node(group)
end
elseif args.type == 'Map' then
if args.mapLevel then
group = newGroup()
:wikitext('Map Level: ')
:node( newColor('value', args.mapLevel) )
:tag('br'):done()
if args.itemQuantity then
group
:wikitext('Item Quantity: ')
:node( newColor('value', args.itemQuantity) )
end
container:node(group)
end
elseif args.type == 'Jewel' then
if args.radius then
group = newGroup()
:wikitext('Radius: ')
:node( newColor('value', args.radius) )
container:node(group)
end
elseif args.type == 'Currency' then
group = newGroup()
:wikitext('Stack Size: ')
:node( newColor('value', args.stackSize) )
container:node(group)
if args.effect then
group = newGroup('textwrap text-mod')
:wikitext(args.effect)
container:node(group)
end
elseif args.type == 'Flask' then
group = newGroup()
if args.life then
group
:wikitext('Recovers ')
:node( newColor('value', args.life) )
:wikitext(' Life over ')
:node( newColor('value', args.duration) )
:wikitext(' Seconds')
:tag('br'):done()
end
if args.mana then
group
:wikitext('Recovers ')
:node( newColor('value', args.mana) )
:wikitext(' Mana over ')
:node( newColor('value', args.duration) )
:wikitext(' Seconds')
:tag('br'):done()
end
if args.effect then
group
:wikitext('Lasts ')
:node( newColor('value', args.duration) )
:wikitext(' Seconds')
:tag('br'):done()
end
group
:wikitext('Consumes ')
:node( newColor('value', args.chargeUse) )
:wikitext(' of ')
:node( newColor('value', args.chargeCap) )
:wikitext(' Charges on use')
:tag('br'):done()
if args.effect then
group
:wikitext(args.effect)
end
container:node(group)
elseif args.type == 'Microtrans' then
group = newGroup()
if args.subtype or args.stackSize then
group
:wikitext(args.subtype)
:tag('br'):done()
if args.stackSize then
group
:wikitext('Stack Size: ')
:node( newColor('value', args.stackSize) )
end
container:node(group)
end
group = newGroup('textwrap text-mod')
:wikitext(args.effect)
container:node(group)
end
if args.level or args.strength or args.dexterity or args.intelligence then
local lvlReq
local strReq
local dexReq
local intReq
local reqTxt
if args.level then
lvlReq = 'Level ' .. tostring( newColor('value', args.level) )
end
if args.strength then
reqTxt = ' Strength'
if args.level or args.dexterity or args.intelligence then
reqTxt = ' Str'
end
strReq = tostring( newColor('value', args.strength) ) .. reqTxt
end
if args.dexterity then
reqTxt = ' Dexterity'
if args.level or args.strength or args.intelligence then
reqTxt = ' Dex'
end
dexReq = tostring( newColor('value', args.dexterity) ) .. reqTxt
end
if args.intelligence then
reqTxt = ' Intelligence'
if args.level or args.strength or args.dexterity then
reqTxt = ' Int'
end
intReq = tostring( newColor('value', args.intelligence) ) .. reqTxt
end
if not doConcat then
doConcat = require('Module:Concat')._main
end
group = newGroup()
:wikitext('Requires ')
:wikitext(
doConcat({lvlReq, strReq, dexReq, intReq})
)
container:node(group)
end
if args.implicitMods then
group = newGroup('text-mod')
:wikitext(args.implicitMods)
container:node(group)
end
if args.randomMods then
group = newGroup('text-mod')
:wikitext(args.randomMods)
container:node(group)
end
if args.cosmeticMods then
group = newGroup('text-cosmetic')
:wikitext(args.cosmeticMods)
container:node(group)
end
if args.flavourText then
group = newGroup('textwrap text-flavour')
:wikitext(args.flavourText)
container:node(group)
end
if args.helpText then
group = newGroup('textwrap text-help')
:wikitext(args.helpText)
container:node(group)
end
return container
end
 
---------------------------------------------------------------------
-- Implements {{itembox}}
---------------------------------------------------------------------
p.itembox = makeInvokeFunc('_itembox')
function p._itembox(args)
local frames = {
['Currency'] = 'currency',
['Microtrans'] = 'currency',
['Gem'] = 'gem',
['Quest'] = 'quest'
}
local container = mw.html.create(args.isHover and 'span' or 'div')
:attr( 'class', 'itembox-' .. ( string.lower(args.frame or frames[args.type] or args.rarity or 'normal') ) .. ' ' .. (args.class or '') )
:tag('span')
:attr( 'class', 'itemboxheader-' .. (args.baseItem and 'double' or 'single') )
:tag('span')
:attr('class', 'itemboxheaderleft')
:done()
:tag('span')
:attr('class', 'itemboxheaderright')
:done()
:tag('span')
:attr('class', 'itemboxheadertext')
:wikitext( args.name .. (args.baseItem and '<br>' .. args.baseItem or '') )
:done()
:done()
if type(args.aboveStats) == 'table' then
container:node(args.aboveStats)
elseif type(args.aboveStats) == 'string' then
container:wikitext(args.aboveStats)
end
local stats = mw.html.create('span')
:attr('class', 'itemboxstats')
if type(args.stats) == 'table' then
stats:node(args.stats)
elseif type(args.stats) == 'string' then
stats:wikitext(args.stats)
end
container:node(stats)
if type(args.belowStats) == 'table' then
container:node(args.belowStats)
elseif type(args.belowStats) == 'string' then
container:wikitext(args.belowStats)
end
return container
end
 
---------------------------------------------------------------------
-- Implements {{item range average}}
---------------------------------------------------------------------
p.itemRangeAverage = makeInvokeFunc('_itemRangeAverage')
function p._itemRangeAverage(args)
local prop = args[1]
return prop
end
 
---------------------------------------------------------------------
-- Implements {{itemsize}}
---------------------------------------------------------------------
p.itemsize = makeInvokeFunc('_itemsize')
function p._itemsize(args)
local size = args[1] or '1x_'
local grid = args[2] or 78
local dim = mw.text.split(size, 'x', true)
if dim[1] == '_' then
if dim[2] == '_' then
dim[1] = grid
else
dim[1] = ''
end
else
dim[1] = dim[1] * grid
end
if dim[2] == '_' then
dim[2] = ''
else
dim[2] = 'x' .. dim[2] * grid
end
return dim[1] .. dim[2] .. 'px'
end
 
return p

Latest revision as of 01:33, 23 September 2024

Module documentation[view] [edit] [history] [purge]


This page is not an actual Scribunto module. It exists to provide editors a place to create experimental modules.

Naming your modules

To keep things tidy, please use the following format to name your experimental modules: 

Module:Sandbox/Your username/Module name

Cleaning up unused modules

Experimental modules may be deleted by admins upon request or after a long period of inactivity.

List of modules in this area

For a list of the experimental modules under Module:Sandbox, see Special:PrefixIndex/Module:Sandbox/.

The above documentation is transcluded from Module:Sandbox/doc. (edit | history)
Editors can experiment in this module's sandbox (create | mirror) and testcases (create) pages.
Subpages of this module.

-- This is not an actual module. Do not add code.
Retrieved from "https://www.poe2wiki.net/index.php?title=Module:Sandbox&oldid=1665"