Module:Sandbox

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.

local p = {}
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 = {}
			table.insert( elementalDamage, tostring( newColor('fire', args.fire) ) )
			table.insert( elementalDamage, tostring( newColor('cold', args.cold) ) )
			table.insert( elementalDamage, tostring( newColor('lightning', args.lightning) ) )
			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