Module:Param Parse

Module documentation

This documentation is transcluded from Module:Param Parse/doc. [edit] [history] [purge]

Module:Param Parse requires Module:Currency.

Module:Param Parse requires Module:Edit button.

Module:Param Parse requires Module:Infobox.

Module:Param Parse requires strict.

Module:Param Parse is required by 25 modules

1. Module:Experience/Calculator
2. Module:Infobox Emote
3. Module:Infobox Episode
4. Module:Infobox Event
5. Module:Infobox Item
6. Module:Infobox Monster
7. Module:Infobox NPC
8. Module:Infobox Profession
9. Module:Infobox Quest
10. Module:Infobox Quest Item
11. Module:Infobox Recipe
12. Module:Infobox Room
13. Module:Infobox Scenery
14. Module:Infobox Shop
15. Module:Infobox Skill Node
16. Module:Infobox Spell
17. Module:Infobox Variant Category
18. Module:Infobox Venture
19. Module:Investigation info
20. Module:ItemSources
21. Module:Location Table
22. Module:Passive Combat
23. Module:Profession bounty
24. Module:Profession info
25. Module:Sandbox/User:The Gaffer/Modules/Infobox Recipe

.

These params and functions are used to validate and format information passed into an Infobox. See Module:Infobox for details and instructions on creating an Infobox. If the information is missing or not valid, the functions here should return nil.

Here is a summary of all the params:

param	explanation
parse.actions	Actions listed in the action menu
parse.name	Title
parse.description	Description of the entity in its card
parse.image	[[File:IMAGE.png]]. Use the class infobox-image in the table
parse.image_size300	[[File:IMAGE.png|300x300px]] by default unless overridden. Use the class infobox-image in the table
parse.single_episode	Episode name. The parameter read is "episode".
parse.episode	Two episode names. The parameters read are "episode" and "additional_episode"
parse.premium	Premium (Yes, No, N/A)
parse.release	Release Date in the format YYYY-MM-DD
parse.removal	Removal Date in the format YYYY-MM-DD
parse.value	Shows the value as a denomination of coins (or N/A)
parse.profession_bubble_a, parse.profession_bubble_b	Takes parameters profession_a + profession_a_level, or profession_b + profession_b_level
parse.variant	Which category the subject is a variant of
parse.name_with_variant_category	"name" parameter except the name of the variant category is put on a second line. Use "name_override" to change the default display of "variant_name<br>variant_category".
parse.name_with_variant_category_venture_icon	Same as above, but with the ventures icon before the variant category name.
parse.passive	Passiveness (Yes, No, N/A)
parse.duration	Number of hours to complete the venture
parse.aggressive	Aggressive (Yes, No, N/A)
parse.difficulty	Quest difficulty (0-5)
parse.quest	Quest name (or No)
parse.unlock	Level in a profession that something is unlocked at. Uses "unlock_level" and "unlock_profession" (defaulting to "profession_a") parameters
parse.knowledge	Knowledge
parse.bank	Bank

Here are some general use functions that can be used for custom or new params:

function name	explanation
has_content(arg)	Returns arg if any non-whitespace character is found in the string.
number(num)	Removes any commas and parses the string as a number
yes_no(text)	Only accepts "Yes", "No" and "N/A"
yes_no_smw(text)	Maps "Yes", "No" to true and false respectively

Creating New Params

Ideally, params should be defined here so that they can be reused between different Infoboxes. Here is how to create a new param:

parse.paramname = {
	name = <param>,
    func = <func>,
    empty = 'empty', -- optional
    category_never = 'category', -- optional
    category_partial = 'category', -- optional
    category_incomplete = 'category', -- optional
    category_complete = 'category', -- optional
    smw_property = 'Property', -- optional
    smw_func = <func>, -- optional
}

key	value
name	parameter name as used in the Template
func	A function in Module:Param Parse to validate and process the Template argument. You can also use a local function, but this is not recommended. If func is a function, will call func(Infobox.raw_param(name)): {name = <param>, func = <func>, ... }, If func is a table, it takes the following parameters: {name = <param>, func = { name = <func>, params = <func_params>}, ... }, name function in Module:Param Parse params a list of parameters to pass the the function, in the form of constants, or Infobox.raw_param(name), Infobox.param(name), Infobox.smw_param(name)
empty (optional)	text to display in the infobox if func returns nil; defaults to "? (edit)"
category_never (optional)	category to add if func returns nil for all versions
category_partial (optional)	category to add if func returns nil for some versions, but a value for other versions
category_incomplete (optional)	category to add if func returns nil for at least 1 version (i.e. category_never and category_partial combined)
category_complete (optional)	category to add if func returns a value for all versions
smw_property (optional)	if this string is defined, the parameter will be saved into SMW
smw_func (optional)	function to validate and process the Template argument to save into SMW. func is used by default if smw_func is not defined

---

--[=[
-- Standardized functions to parse Infobox params
--]=]
-- <nowiki>
require('strict')
local Infobox = require('Module:Infobox')
local currency = require('Module:Currency').parse
local editbutton = require('Module:Edit button')
local edit = editbutton("'''?''' (edit)")
local lang = mw.language.getContentLanguage()

local parse = {}

-- Generic functions --
-----------------------

-- Standardized "has content" function
function parse.has_content(arg)
	-- Return arg if any non-whitespace character is found
	return string.match(arg or '', '%S') and arg or nil
end

-- Standardized numbers
function parse.number_smw(num)
	return lang:parseFormattedNumber(num)
end

function parse.number(num)
	num = parse.number_smw(num)
	if num == nil then return nil end
	return lang:formatNum(num)
end

-- Standardized number range: Accepts '1' and '1-5'
function parse.number_or_number_range(prenum)
	if not prenum then return end
	local ret = ''
	local count = 0
	for out in string.gmatch(prenum, "[^-]+") do 
		if count == 1 then
			ret = ret .. "➨\n"
		elseif count == 3 then
			return nil
		end
		local num = parse.number_smw(out)
		if num == nil then
			return nil
		end
		ret = ret .. num
		count = count + 1
	end
	if count == 0 then
		return nil
	end
	return ret
end

function parse.number_or_number_range_low(prenum)
	if not prenum then return end
	local count = 0
	local value = nil
	for out in string.gmatch(prenum, "[^-]+") do
		out = parse.number_smw(out)
		if out == nil then
			return nil
		end
		count = count + 1
		if count == 1 then
			value = out
		end
		if count > 2 then
			return nil
		end
	end
	return value
end

function parse.number_or_number_range_high(prenum)
	if not prenum then return end
	local count = 0
	local value = nil
	for out in string.gmatch(prenum, "[^-]+") do
		out = parse.number_smw(out)
		if out == nil then
			return nil
		end
		count = count + 1
		if count == 2 then
			value = out
		end
		if count > 2 then
			return nil
		end
	end
	return value
end

-- Yes/No
local yes_no = {
	['Yes'] = 'true',
	['No'] = 'false',
	['N/A'] = 'NIL',
}
function parse.yes_no(text)
	if yes_no[text] ~= nil then
		return text
	end
	return nil
end
function parse.yes_no_smw(text)
	if text == 'N/A' then
		return nil
	end
	local bool = yes_no[text]
	if bool ~= nil then
		return bool
	end
	return nil
end

-- Premade Params --
--------------------

-- Standardized actions function
parse.actions = {
	name = 'actions',
	func = parse.has_content,
}

-- Standardized name function
function parse.get_parenthesis_style(name)
	if name == nil then
		return ''
	end
	local title = mw.title.getCurrentTitle().text
	name = name:gsub('&#39;', '\''):gsub('&#38;', '&')
	if name == title then
		-- Page title matches the given name, so parentheses should not be
		-- styled to be smaller
		return 'no-parenthesis-style'
	else
		return ''
	end
end
local name_parenthesis_style = {
	name = 'parenthesis_style',
	func = {name = parse.get_parenthesis_style, params = {Infobox.smw_param('name')}}
}

parse.name = {
	{
		name = 'name',
		func = parse.has_content,
		smw_property = 'Name',
		category_incomplete = 'Needs name',
	},
	name_parenthesis_style
}
local rarities = {'Common', 'Uncommon', 'Rare', 'Epic'}
function parse.get_rarity_func(name)
    for _, rarity in ipairs(rarities) do
        if name:sub(1, #rarity) == rarity then
            return rarity
        end
    end
    return nil
end
parse.rarity_from_name = {
	name = 'rarity_from_name',
	func = {name = parse.get_rarity_func, params = {Infobox.raw_param('name')}}
}

-- Standardized description function
parse.description = {
	name = 'description',
	func = parse.has_content,
	smw_property = 'Description',
	category_incomplete = 'Needs description',
}

-- Standardized image function
function parse.image_name(img)
	if img then
		return string.match(img, '%[%[(File:.+%.%w%w%w)|?%d*x?%d*p?x?%]%]')
	end
	return nil
end
function parse.image_height(img, default)
	if img then
		return string.match(img, '%[%[File:.+%.%w%w%w|%d*x(%d*)px%]%]') or default
	end
	return default
end
function parse.image_width(img, default)
	if img then
		return string.match(img, '%[%[File:.+%.%w%w%w|(%d*)x?%d*px%]%]') or default
	end
	return default
end
function parse.image_func(img, default_width, default_height)
	local name = parse.image_name(img)
	local width = parse.image_width(img, default_width)
	local height = parse.image_height(img, default_height)
	local size = ''
	if width and height then
		size = '|'..width..'x'..height..'px'
	elseif width then
		size = '|'..width..'px'
	elseif height then
		size = '|x'..height..'px'
	end
	local imagecheck = name and mw.smw.ask('[['..name..']]|?Modification date=data')
	imagecheck = imagecheck~=nil and imagecheck[1]~=nil and imagecheck[1].data~=nil
	if name and imagecheck then
		return '[['..name..size..']]'
	elseif name then
		return '[['..name..size..']][[Category:Needs image]]'
	end
	return nil
end
function parse.image_smw(img)
	return parse.image_name(img)
end

parse.image = {
	name = 'image',
	func = parse.image_func,
	smw_property = 'Image',
	smw_func = parse.image_smw,
	empty = '[[Special:Upload|Please upload an image!]]',
	category_incomplete = 'Needs image',
}
parse.image_size300 = {
	name = 'image',
	func = {name = parse.image_func, params = {Infobox.raw_param('image'), 300, 300}},
	smw_property = 'Image',
	smw_func = parse.image_smw,
	empty = '[[Special:Upload|Please upload an image!]]',
	category_incomplete = 'Needs image',
}


-- Episode
local valid_episodes = {
	['global'] = { -1, 'Global' },
	['none'] = { 0, 'None' },
	['hopeport'] = { 1, 'Hopeport' },
	['hopeforest'] = { 2, 'Hopeforest' },
	['mine of mantuban'] = { 3, 'Mine of Mantuban' },
	['crenopolis'] = { 4, 'Crenopolis' },
	['stonemaw hill'] = { 5, 'Stonemaw Hill' },
	['bleakholm crags'] = { 6, 'Bleakholm Crags' },
}
function parse.episode_func(episode)
	local valid_episode = valid_episodes[string.lower(episode or '')]
	if valid_episode then
		local sort = valid_episode[1]
		local name = valid_episode[2]
		local link = name
		local label = '[[' .. name .. ']]'
		if sort == 0 then
			name = 'Unknown'
			link = ''
			label = 'None'
		end
		return ('<span data-sort-value="%s">[[File:%s episode icon.png|18px|link=%s]] %s</span>'):format(sort, name, link, label)
	end
	return nil
end
function parse.episode_smw(episode)
	local valid_episode = valid_episodes[string.lower(episode or '')]
	if valid_episode then
		return valid_episode[2]
	end
	return nil
end
parse.single_episode = {
	name = 'episode',
	func = parse.episode_func,
	smw_property = 'Episode',
	smw_func = parse.episode_smw,
	category_incomplete = 'Needs episode',
}
parse.episode = {
	parse.single_episode,
	{
		name = 'additional_episode',
		func = parse.episode_func,
		smw_property = 'Additional Episode',
		smw_func = parse.episode_smw,
		category_complete = 'Infobox with two episodes',
	}
}

-- Premium
local premium_episodes = {
	['global'] = 'No',
	['none'] = 'No',
	['hopeport'] = 'No',
	['hopeforest'] = 'No',
	['mine of mantuban'] = 'Yes',
	['crenopolis'] = 'Yes',
	['stonemaw hill'] = 'Yes',
	['bleakholm crags'] = 'Yes'
}
function parse.premium_func(episode)
	local premium_episode = premium_episodes[string.lower(episode or '')]
	return premium_episode
end
function parse.premium_smw(is_premium)
	return parse.yes_no_smw(is_premium)
end
parse.premium = {
	name = 'premium',
	func = { name = parse.premium_func, params = { Infobox.raw_param('episode') } },
	smw_property = 'Premium',
	smw_func = { name = parse.premium_smw, params = { Infobox.param('premium') } }
}

-- Release
local function unix_time(date)
	-- Convert a time to unix time
	if date == nil then
		return nil
	end
	local year, month, day = string.match(date, '(%d+)-(%d+)-(%d+)')
	if year == nil or month == nil or day == nil then
		return nil
	end
	return os.time{year=year, month=month, day=day}
end
function parse.release_func(date)
	local time = unix_time(date)
	if time == nil then
		return nil
	end
	local formatted_date = os.date('[[%d %B]] [[%Y]]', time) -- [[01 January]] [[2024]]
	formatted_date = string.gsub(formatted_date, '%[%[0', '[[') -- Convert [[01 January]] [[2024]] to [[1 January]] [[2024]]
	local iso_date = os.date('%Y-%m-%d', time) -- 2024-01-01
	local update_string = formatted_date .. ' ([[Game updates/' .. iso_date .. '|Update]])'
	return update_string
end
function parse.release_smw(date)
	local time = unix_time(date)
	if time == nil then
		return nil
	end
	local formatted_date = os.date('%Y-%m-%d', time) -- 2024-01-01
	return formatted_date
end
parse.release = {
	name = 'release',
	func = parse.release_func,
	category_incomplete = 'Needs release date',
	smw_property = 'Release Date',
	smw_func = parse.release_smw,
}
parse.removal = {
	name = 'removal',
	func = parse.release_func,
	smw_property = 'Removal Date',
	smw_func = parse.release_smw,
}

-- Value
function parse.value_func(val)
	if val == '' or val == ' ' then
		return
	elseif val == 'N/A' then
		return 'N/A'
	end
	local status, val = pcall(currency, val)
	if status then
		return val
	end
end
parse.value = {
	name = 'value',
	func = parse.value_func,
	category_incomplete = 'Items needing value',
	smw_property = 'Value',
	smw_func = parse.number_smw
}

-- Profession
function parse.profession_bubble_func(profession, level)
	local profession_valid = parse.has_content(profession)
	local profession_valid_link = profession_valid
	local level_valid = parse.number_or_number_range(level)
	local category_error = false
	if not profession_valid and not level_valid then
		return nil
	end
	if not profession_valid and level_valid then
		-- Profession undefined but level defined, invalid, show an unknown profession
		profession_valid = 'Unknown episode'
		profession_valid_link = ''
		category_error = true
	end
	if profession_valid and not level_valid then
		-- Profession defined without level, invalid, show an unknown level
		level_valid = '?'
		category_error = true
	end
	return '[[File:'..profession_valid..' icon.png|x30px|link='..profession_valid_link..']] '..level_valid..(category_error and '[[Category:Invalid profession bubble]]' or '')
end
function parse.profession_bubble_smw(profession, level)
	local profession_valid = parse.has_content(profession)
	local level_valid = parse.number_smw(level)
	if not profession_valid then
		return nil
	end
	if not level_valid then
		return nil
	end
	return profession_valid..','..level_valid
end

parse.profession_bubble_a = {
	{
		name = 'profession_a',
		func = parse.has_content,
		smw_property = 'Profession A',
	},
	{
		name = 'profession_a_level',
		func = parse.number_or_number_range_low,
		smw_property = 'Profession Level A',
	},
	{
		name = 'profession_a_level_high',
		func = { name = parse.number_or_number_range_high, params = { Infobox.raw_param('profession_a_level') } },
		smw_property = 'Profession Level A High',
	},
	{
		name = 'profession_bubble_a',
		func = { name = parse.profession_bubble_func, params = { Infobox.raw_param('profession_a'), Infobox.raw_param('profession_a_level') } },
		smw_property = 'Profession Requirement A',
		smw_func = { name = parse.profession_bubble_smw, params = { Infobox.raw_param('profession_a'), Infobox.raw_param('profession_a_level') } },
	}
}
parse.profession_bubble_b = {
	{
		name = 'profession_b',
		func = parse.has_content,
		smw_property = 'Profession B',
	},
	{
		name = 'profession_b_level',
		func = parse.number_or_number_range_low,
		smw_property = 'Profession Level B',
	},
	{
		name = 'profession_b_level_high',
		func = {name = parse.number_or_number_range_high, params = {Infobox.raw_param('profession_b_level')}},
		smw_property = 'Profession Level B High',
	},
	{
		name = 'profession_bubble_b',
		func = {name = parse.profession_bubble_func, params = {Infobox.raw_param('profession_b'), Infobox.raw_param('profession_b_level')}},
		smw_property = 'Profession Requirement B',
		smw_func = {name = parse.profession_bubble_smw, params = {Infobox.raw_param('profession_b'), Infobox.raw_param('profession_b_level')}},
	}
}

-- Variant categories
local function strip_link(text)
	if text ~= nil then
		if text:sub(1, 2) == '[[' and text:sub(-2) == ']]' and not text:find('|') then
    		text = text:sub(3, -3)  -- Remove the [[]]
		end
	end
	return text
end
local variant_category_smw_cache = {}
local function variant_category_smw_lookup(v)
	v = strip_link(v)
	if not variant_category_smw_cache[v] then
		local smw_data = mw.smw.ask{
			'[[Category:Variant categories]][[' .. v .. ']]',
			'?Name',
			'?Name color',
			'?Name within variants'
		}
		if not smw_data then
			variant_category_smw_cache[v] = { name = v, name_for_removal = v, color = nil }
		else
			variant_category_smw_cache[v] = { name = smw_data[1].Name, name_for_removal = smw_data[1]['Name within variants'], color = smw_data[1]['Name color'] }
		end
	end
	return variant_category_smw_cache[v]
end
local function name_without_variant_category(name, variant_name)
	if variant_name and name:sub(-1-#variant_name) == ' '..variant_name then
		-- Ends with the variant name. Remove it
		name = name:sub(1, -2-#variant_name)
	end
	return name
end
function parse.name_with_variant_category_func(name, variant_data, passive, name_override, is_venture)
	passive = passive == 'true'

	local icon_prefix = ''
	if passive then
		icon_prefix = '[[File:Passive small icon.png|14px|link=Passive activity]] '
	elseif is_venture then
		icon_prefix = '[[File:Venture small icon.png|14px|link=Ventures]] '
	end

	if name_override or not variant_data or variant_data == 'N/A' then
		local result = mw.html.create('span')
			:wikitext(icon_prefix)
			:tag('span')
				:addClass('infobox-varianted-name-category')
				:wikitext(name_override or name)
			:done()
		return tostring(result)
	end

	local color_class = ''
	if variant_data.variant_color then
		color_class = ' name-color-' .. variant_data.variant_color
	end

	local result = mw.html.create('span')
		:addClass('infobox-varianted-name')
		:tag('span')
			:addClass('infobox-varianted-name-variant')
			:wikitext(variant_data.name_without_variant)
		:done()
		:tag('br'):done()
		:wikitext(icon_prefix)
		:tag('span')
			:addClass('infobox-varianted-name-category' .. color_class)
			:wikitext(variant_data.variant_name_for_removal or variant_data.variant_name)
		:done()
	return tostring(result)
end
function parse.name_with_variant_category_smw_func(name, variant_data, name_override)
	if name_override then
		return (name_override:gsub('<br>', ' '))
	end
	if not variant_data or variant_data == 'N/A' then
		return name
	end

	return ('%s %s'):format(variant_data.name_without_variant, variant_data.variant_name)
end

local _variant_data = {
	name = '_variant_data',  -- This parameter is only used by other parameters
	func = {
		name = function(v, name)
			v = parse.has_content(v)
			if v == nil then
				return nil
			elseif v == 'N/A' then
				return 'N/A'
			end
			v = strip_link(v)
			local smw_data = variant_category_smw_lookup(v)
			return {
				variant_link = v,
				variant_name = smw_data.name,
				variant_name_for_removal = smw_data.name_for_removal or smw_data.name,
				variant_color = smw_data.color,
				name_without_variant = name_without_variant_category(name, smw_data.name_for_removal or smw_data.name),
			}
		end,
		params = { Infobox.raw_param('variant'), Infobox.raw_param('name') }
	}
}

parse.variant = {
	_variant_data,
	{
		name = 'variant',
		func = { name = function(data)
			if not data then
				return nil
			end
			if data == 'N/A' then
				return 'N/A'
			end
			return ('[[%s|%s]]'):format(data.variant_link, data.variant_name)
		end, params = { Infobox.param('_variant_data') } },
		smw_func = { name = function(variant_data)
			if not variant_data or variant_data == 'N/A' then
				return nil
			end
			return variant_data.variant_link
		end, params = { Infobox.param('_variant_data') } },
		smw_property = 'Variant of',
		category_incomplete = 'Needs variant'
	},
	{
		name = 'variant_name',
		func = { name = function(variant_data)
			if variant_data and variant_data ~= 'N/A' then
				return variant_data.name_without_variant
			end
		end, params = { Infobox.param('_variant_data') }},
		smw_property = 'Variant name'
	}
}

parse.name_with_variant_category = {
	parse.variant,
	{
		name = 'name',
		func = { name = parse.name_with_variant_category_func, params = { Infobox.raw_param('name'), Infobox.param('_variant_data'), Infobox.smw_param('passive'), Infobox.raw_param('name_override'), false } },
		smw_func = { name = parse.name_with_variant_category_smw_func, params = { Infobox.raw_param('name'), Infobox.param('_variant_data'), Infobox.raw_param('name_override') } },
		smw_property = 'Name',
		category_incomplete = 'Needs name'
	},
	name_parenthesis_style
}

parse.name_with_variant_category_venture_icon = {
	parse.variant,
	{
		name = 'name',
		func = { name = parse.name_with_variant_category_func, params = { Infobox.raw_param('name'), Infobox.param('_variant_data'), 'false', Infobox.raw_param('name_override'), true } },
		smw_func = { name = parse.name_with_variant_category_smw_func, params = { Infobox.raw_param('name'), Infobox.param('_variant_data'), Infobox.raw_param('name_override') } },
		smw_property = 'Name',
		category_incomplete = 'Needs name'
	},
	name_parenthesis_style
}

-- Variant type
local valid_variant_types = {
	['item'] = 'Item',
	['monster'] = 'Monster',
	['skill node'] = 'Skill node',
	['venture'] = 'Venture',
	['bounty'] = 'Bounty'
}
function parse.variant_type_func(type)
	local valid_type = valid_variant_types[string.lower(type or '')]
	if valid_type then
		return valid_type..'[[Category:'..valid_type..' variants]]'
	else
		return edit..'[[Category:Invalid variant type]]'
	end
	return nil
end

parse.variant_type = {
	name = 'variant_type',
	func = parse.variant_type_func,
	smw_func = parse.has_content,
	smw_property = 'Variant type',
	category_incomplete = 'Needs variant type'
}

parse.passive = {
	name = 'passive',
	func = parse.yes_no,
	smw_property = 'Passive',
	smw_func = parse.yes_no_smw,
	category_incomplete = 'Needs passiveness'
}

function parse.duration_func(hours)
	hours = string.gsub(hours or '',',','')
	hours = tonumber(hours) or edit
	return (hours .. " Hours")
end

parse.duration = {
	name = 'duration',
	func = parse.duration_func,
	smw_property = 'Duration',
	category_incomplete = 'Needs duration',
}

parse.aggressive = {
	name = 'aggressive',
	func = parse.yes_no,
	smw_property = 'Aggressive',
	smw_func = parse.yes_no_smw,
	category_incomplete = 'Needs aggressiveness'
}

function parse.difficulty_func(val)
	if val == "0" then
		return "☆☆☆☆☆"	
	end
	if val == "1" then
		return "★☆☆☆☆"
	end
	if val == "2" then
		return "★★☆☆☆"
	end
	if val == "3" then
		return "★★★☆☆"
	end
	if val == "4" then
		return "★★★★☆"
	end
	if val == "5" then
		return "★★★★★"
	end
	return "N/A"
end
function parse.difficulty_smw(val)
	if val == 'N/A' then
		return -1
	end
	val = tonumber(val) -- Intentionally do not use parse.tonumber here
	if val == nil then
		return nil
	end
	if val >= 0 and val <= 5 and math.floor(val) == val then
		return val
	end
	return nil
end

-- Quest difficulty
parse.difficulty = {
	name = 'difficulty',
	func = parse.difficulty_func,
	smw_property = 'Difficulty',
	smw_func = parse.difficulty_smw,
	category_incomplete = 'Needs difficulty'
}

local valid_quest_types = {
	['main'] = 'Main',
	['side'] = 'Side'
}
function parse.quest_type_func(type)
	local valid_type = valid_quest_types[string.lower(type or '')]
	if valid_type then
		return valid_type
	else
		return 'None'
	end
	return nil
end
function parse.quest_type_smw(type)
	local valid_type = valid_quest_types[string.lower(type or '')]
	if valid_type then
		return valid_type
	end
	return nil
end

-- Quest type
parse.quest_type = {
	name = 'quest_type',
	func = parse.quest_type_func,
	smw_property = 'quest_type',
	smw_func = parse.quest_type_smw,
	category_incomplete = 'Needs quest_type'
}

-- Quest
function parse.quest_smw(quest)
	if quest == 'No' then
		return nil
	end
	return parse.has_content(quest)
end

parse.quest = {
	name = 'quest',
	func = parse.has_content,
	smw_property = 'Quest',
	smw_func = parse.quest_smw,
	category_incomplete = 'Needs quest'
}

-- Unlock Level
function parse.unlock_profession_func(unlock_profession, profession, level)
	if level == 'N/A' then
		return parse.has_content(unlock_profession or 'N/A')
	end
	return parse.has_content(unlock_profession or profession)
end

function parse.unlock_profession_func_smw(unlock_profession)
	if unlock_profession == 'N/A' then
		return nil
	end
	return unlock_profession
end

function parse.unlock_level_func(unlock_profession, level, raw_level)
	if raw_level == 'N/A' then
		return 'N/A'
	end
	if unlock_profession then
		local file = unlock_profession
		local link = unlock_profession
		if unlock_profession == 'N/A' then
			file = 'Unknown episode'
			link = ''
		end
		return ('[[File:%s icon.png|link=%s|width=18x18]] %s'):format(file, link, level or '?')
	end
end

function parse.unlock_level_smw(unlock_profession, level)
	level = parse.has_content(level)
	if unlock_profession == nil or level == 'N/A' then
		return nil
	end
	return parse.number_smw(level)
end

local unlock_profession = {
	name = 'unlock_profession',
	func = { name = parse.unlock_profession_func, params = { Infobox.raw_param('unlock_profession'), Infobox.raw_param('profession_a'), Infobox.raw_param('unlock_level') } },
	smw_property = 'Unlock profession',
	smw_func = { name = parse.unlock_profession_func_smw, params = { Infobox.param('unlock_profession') } },
}

local unlock_level = {
	name = 'unlock_level',
	func = { name = parse.unlock_level_func, params = { Infobox.param('unlock_profession'), Infobox.smw_param('unlock_level'), Infobox.raw_param('unlock_level') } },
	smw_property = 'Unlock level',
	smw_func = { name = parse.unlock_level_smw, params = { Infobox.param('unlock_profession'), Infobox.raw_param('unlock_level') } },
	category_incomplete = 'Needs unlock level',
}

parse.unlock = {
	unlock_profession, unlock_level
}

-- Knowledge
parse.knowledge = {
	name = 'knowledge',
	func = parse.number,
	smw_func = parse.number_smw,
	smw_property = 'Knowledge',
	category_incomplete = 'Needs knowledge',
}

parse.health = {
	name = 'health',
	func = parse.number,
	smw_func = parse.number_smw,
	smw_property = 'Health',
	category_incomplete = 'Needs health',
}

parse.experience = {
	name = 'experience',
	func = parse.number,
	smw_func = parse.number_smw,
	smw_property = 'Experience',
	category_incomplete = 'Needs experience',
}

local valid_attack_styles = {
    ['none'] = 'None',
    ['impact'] = 'Impact',
    ['cryonae'] = 'Cryonae',
    ['arborae'] = 'Arborae',
    ['tempestae'] = 'Tempestae',
    ['infernae'] = 'Infernae',
    ['necromae'] = 'Necromae',
}

local function attack_style_func(style)
    local attack_style = valid_attack_styles[string.lower(style or '')]
    if attack_style then
        if attack_style == 'None' then
            return 'None'
        else
            return string.format('[[File:%s damage icon.png|18px|link=%s]] [[%s]]', attack_style, attack_style, attack_style)
        end
    end
    return nil
end

local function attack_style_smw(style)
	local attack_style = valid_attack_styles[string.lower(style or '')]
	if attack_style then
		return attack_style
	else
		return nil
	end
end

parse.attack_style = {
	name = 'attack_style',
	func = attack_style_func,
	smw_property = 'Attack style',
	smw_func = attack_style_smw,
	category_incomplete = 'Needs attack style',
}

parse.immune_to = {
	name = 'immune_to',
	func = attack_style_func,
	smw_property = 'Immune to',
	smw_func = attack_style_smw,
	category_incomplete = 'Needs immune to',
}

parse.vulnerable_to = {
	name = 'vulnerable_to',
	func = attack_style_func,
	smw_property = 'Vulnerable to',
	smw_func = attack_style_smw,
	category_incomplete = 'Needs vulnerable to',
}

-- Bank
parse.bank = {
	name = 'bank',
	func = parse.has_content,
	smw_property = 'Bank',
	category_complete = 'Bankable items'
}

-- Transmog Event
parse.event = {
	name = 'event',
	func = parse.has_content,
	smw_property = 'Event',
}

-- Transmog Equipment Slot
parse.slot = {
	name = 'slot',
	func = parse.has_content,
	smw_property = 'Slot',
}

-- Event predecessor
parse.predecessor = {
	name = 'predecessor',
	func = parse.has_content
}

-- Event successor
parse.successor = {
	name = 'successor',
	func = parse.has_content
}

return parse
-- </nowiki>