Module:ProfessionList: Difference between revisions

Inline

Latest revision as of 10:07, 19 December 2024

Module documentation

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

Module:ProfessionList requires Module:Currency.

Module:ProfessionList requires Module:RecipeTreeSearch.

Module:ProfessionList is required by .

This module is a helper module to be used by other modules; it may not designed to be invoked directly. See Brighter Shores:Lua/Helper modules for a full list and more information. For a full list of modules using this helper click here

Function	Type	Use
`currency_cell(amount)`	`amount`: number, or nil	Returns the HTML to create a table currency cell using `module:currency._cell`. If instead it is supplied with nil then a 10x1 cell is created with the text "unknown". Use within :node()
`unknown_value_cell(size)`	`size`: integer	Returns the HTML to create a `size`x1 cell with the text "unknown". Use within :node()
`unknown_value_edit_cell(page,size)`	`page`: string, name of page `size`: integer	Returns the HTML to create a `size`x1 cell with a link to edit the specified page. Use within :node()
`generate_recipe_table(queryString)`	`queryString`: string, SMW query `screenFunction`: function, `table > boolean`	Generates a table of recipes and activities from a Semantic MediaWiki query string and a screening function. `queryString` is an SMW query, but it only needs to be the selection of pages. Parameters to be returned are chosen by the function. `screenFunction` is a function which takes one recipe from the search and returns true if that recipe is to be kept, or false if it is to be discarded. Parameters available to the screening function are those present in the Recipe JSON or Activity JSON, as well as the name and image of the page that held the JSON. Pages with multiple recipes or activities will make one entry into the results table for each JSON. The results table entries are the decoded recipe/activity JSONs, parsed through `Module:RecipeTreeSearch`
`one_column_image_text(sort,materials)`	`sort`: string, to sort the multicolumn cell by `materials`: table, each entry is a name/quantity pair for an item to display	Produces 1 cells with multiple lines of text in a standard format to display a list of materials for a recipe. Includes the quantity of each material. Requires that the image of each item is exactly the same as the item name itself. For example: the reagents and bottle to produce a potion.
`two_column_image_text(sort,image,text,link)`	`sort`: string, to sort the multicolumn cell by `image`: string, image name to use, including File: and .png `text`: string, text to display `link`: string, page to link the image and text to	Produces 2 cells in a standard format to display an image and some text, which link to the same page. For example: the image and name of a skill node, but linking to the item they make.
`three_column_image_text(sort,quantity,image,text,link)`	`sort`: string, to sort the multicolumn cell by `quantity`: number, will be displayed with "×" after it `image`: string, image name to use, including File: and .png `text`: string, text to display `link`: string, page to link the image and text to	Produces 3 cells in a standard format to display a quantity, an image, and some text, which link to the same page. For example: the quantity, image, and name of a recipe product.

local currency = require('Module:Currency')
local search = require('Module:RecipeTreeSearch')

local p = {}

-- this module provides functions that are commonly used among all of the modules to greate tables of profession activities
-- such as AlchemistList, DetectivePassiveList, BlacksmithSmeltingList, and so on

-- creates the html directly for a currency cell of a table
-- will always be 10 cells wide, for currency alignment
-- if not supplied with an amount, displays "unknown"
-- use within :node()
function p.currency_cell(amount)
	if not amount then
		return mw.html.create('td')
			:addClass('table-bg-gray')
			:css{ ['text-align'] = 'center' }
			:attr{ colspan = '10' }
			:wikitext("''unknown''")
		:done()
	end
	return currency._cell(amount, { html = 'yes' })
end

-- creates the html for an unknown value cell
-- use within :node()
function p.unknown_value_cell(N)
	return mw.html.create('td')
		:addClass('table-bg-gray')
		:css{ ['text-align'] = 'center' }
		:attr{ colspan = tostring(N) }
		:wikitext("''unknown''")
	:done()
end

-- creates the html for an unknown value cell, with a link to edit the page that has the unknown parameter
-- use within :node()
function p.unknown_value_edit_cell(page,N)
	local url = tostring(mw.uri.fullUrl(page,'action=edit'))
	return mw.html.create('td')
		:addClass('table-bg-gray')
		:css{ ['text-align'] = 'center' }
		:attr{ colspan = tostring(N) }
		:wikitext('['..url.." '''?''' (edit)]")
	:done()
end

-- generates a table of recipes and activities from a Semantic MediaWiki query string
-- the queryString is just a selection of pages, from any combination of SMW properties and categories
-- for pages with multiple recipes or activities, will make on entry into the results table for each 
-- screenFunction takes a decoded recipe/activity JSON and returns true if it is to be kept
function p.generate_recipe_table(queryString,screenFunction)
	
	-- first formulate the query to get the list of pages
	local query = {
		queryString,
		'? #- = pageName',
		'?Image #- = pageImage',
		'?Activity JSON = activityJSON',
		'?Recipe JSON = recipeJSON',
		'limit = 500'
	}
	local pages = mw.smw.ask(query)
	
	-- if no pages were found, skip the rest of this function
	if pages == nil then
		return nil
	end
	
	-- collate structure
	local recipes = {}
	
	-- iterate through pages found
	for _, page in ipairs(pages) do
		
		-- first iterate through activities
		if page.activityJSON ~= nil then
			if type(page.activityJSON)=='string' then
				page.activityJSON = { page.activityJSON }
			end
			for _, JSON in ipairs(page.activityJSON) do
				local item = mw.text.jsonDecode(JSON)
				item.pageName = page.pageName
				item.pageImage = page.pageImage
				item.type = 'activity'
				table.insert(recipes,item)
			end
		end
		
		-- same iteration through recipes
		if page.recipeJSON ~= nil then
			if type(page.recipeJSON)=='string' then
				page.recipeJSON = { page.recipeJSON }
			end
			for _, JSON in ipairs(page.recipeJSON) do
				local item = mw.text.jsonDecode(JSON)
				item.pageName = page.pageName
				item.pageImage = page.pageImage
				item.type = 'recipe'
				table.insert(recipes,item)
			end
		end
		
	end
	
	-- if none of the pages had recipes of activities, skip the rest of this function
	if recipes == nil or recipes[1] == nil then
		return nil
	end
	
	-- output structure
	local output = {}
	
	-- screen using screenFunction
	for _, item in ipairs(recipes) do
		if screenFunction(item) then
			table.insert(output,item)
		end
	end
	
	-- if all of the results were screened, skip the rest of this function
	if output == nil or output[1] == nil then
		return nil
	end

	-- sort the output by the .level parameter
	table.sort(output, function(item1, item2)
		 -- if one of the two has no leve
		if (item1.level == nil) ~= (item2.level == nil) then
			-- true if lvl2 is nil but not lvl1, false if lvl1 is nil but not lvl2
			return item2.level == nil 
		end
		if item1.level == nil then
			-- if both are empty, treat as equivalent
			return false
		end
		 -- normal comparison
		return item1.level < item2.level
	end)
	
	-- perform a number of useful calculations on the data that are widely useful
	-- like cost of materials, profit of products, recipe tree search
	for _,item in ipairs(output) do
		
		item.product = item.output[1].name or ''
		
		-- perform the full recipe tree search on the product
		local fullRecipe = search.main(item.product)
		-- overwrite any parameters from the original recipe with their counterparts from the full recipe
		-- when product is nil, no data is overwritten
		for key,value in pairs(fullRecipe) do
			item[key] = value
		end
		
		-- include the price of selling the product
		local sell = search.getShopSellPrice(item.product)
		local qty = item.output[1].quantity
		item.sellPrice = sell and qty and sell * qty
		item.profit = item.buyPrice and item.sellPrice and item.sellPrice - item.buyPrice
		item.profitPerXP = item.profit and item.xp and item.profit / item.xp
		
		
	end
	
	return output
	
end

function p.one_column_image_text(sort,materials)
	
		local materialCell  = mw.html.create('td')

		for _, mat in ipairs(item.materials) do
			materialCell:wikitext(mat.quantity .. ' &times; [[File:' .. mat.name .. '.png|18px|link=' .. mat.name .. ']] [[' .. mat.name .. ']]<br>')
		end
		
		return materialCell 
	
end

function p.two_column_image_text(sort,image,text,link)
	
	return mw.html.create('td')
		:css{ ['border-right'] = '0', ['text-align'] = 'right', ['max-width'] = '100px' }
		:attr{ ['data-sort-value'] = sort }
		:wikitext(' [[' .. image .. '|link=' .. link .. '|30x30px]]')
	:done()
	:tag('td')
		:addClass('plinkt-link no-border')
		:wikitext('[[' .. link .. '|'  .. text ..']]')
	:done()
	
end

function p.three_column_image_text(sort,quantity,image,text,link)
	
	return mw.html.create('td')
		:css{ ['border-right'] = '0', ['padding-right'] = '0', ['text-align'] = 'right' }
		:attr{ ['data-sort-value'] = sort }
		:wikitext(quantity .. ' &times;')
	:done()
	:tag('td')
		:addClass('plinkt-image no-border')
		:css{ ['border-left'] = '0', ['padding-left'] = '0' }
		:wikitext('[[' .. image .. '|link=' .. link .. '|30px]]')
	:done()
	:tag('td')
		:addClass('plinkt-link no-border')
		:wikitext('[[' .. link .. '|' .. text .. ']]')
	:done()
	
end

return p