View source for Module:GameData

local funcs = {}
local protosets = mw.loadJsonData('Module:GameData/protosets.json')
local machines = {
	Smelt='Smelter',
	Assemble='Assembling Machine',
	Refine='Oil Refinery',
	Chemical='Chemical Plant',
	Exchange='Energy Exchanger',
	Particle='Miniature Particle Collider',
	PhotonStore='Ray Receiver',
	Fractionate='Fractionator',
	Research='Matrix Lab',
	Mine='Mining Machine',
	Gas='Orbital Collector',
	Ocean='Water Pump',
	Oil='Oil Extractor',
}
local OilSeepID = 7

-- exported functions

-- recipesMaking
-- print out table rows of all recipes making an item with full information
-- the recipe, the building, technology to unlock it, etc.

function funcs.recipesMaking(frame)
	return recipesMakingName(frame:getParent().args[1], frame)
end

function funcs.recipesMakingDirect(frame)
	return recipesMakingName(frame.args[1], frame)
end

function recipesMakingName(name, frame)
	local rtable = {
		frame:expandTemplate{title='ProductionChainTable/head', args={}},
	}
	local item = itemByName(name)
	for _, recipe in ipairs(recipesMakingByID(item.ID)) do
		table.insert(rtable, recipeRow(recipe, frame))
	end
	local vein = veinMakingByID(item.ID)
	if vein ~= nil then
		table.insert(rtable, veinRow(item, vein, frame))
	end
	for _, giant in ipairs(deduplicateGiants(gasGiantsMakingByID(item.ID))) do
		table.insert(rtable, gasGiantRow(item, giant, frame))
	end
	if isItemOcean(item.ID) then
		table.insert(rtable, oceanRow(item, frame))
	end
	table.insert(rtable, '|}')
	return table.concat(rtable, '\n')
end

-- recipesUsing
-- print out table rows of all recipes using an item with full information, like recipesMaking
-- split output into components and buildings

function funcs.recipesUsing(frame)
	return recipesUsingName(frame:getParent().args[1], frame)
end

function funcs.recipesUsingDirect(frame)
	return recipesUsingName(frame.args[1], frame)
end

function recipesUsingName(name, frame)
	local output = {}
	local header = frame:expandTemplate{title='ProductionChainTable/head', args={}}
	local item = itemByName(name)
	local components = {}
	local buildings = {}
	for _, r in ipairs(recipesUsingByID(item.ID)) do
		if r.GridIndex >= 2000 then
			table.insert(buildings, r)
		else
			table.insert(components, r)
		end
	end
	if next(components) then
		if next(buildings) then
			table.insert(output, '=== Components ===')
		end
		table.insert(output, header)
		for _, recipe in ipairs(components) do
			table.insert(output, recipeRow(recipe, frame))
		end
		table.insert(output, '|}')
	end
	if next(buildings) then
		if next(components) then
			table.insert(output, '=== Buildings ===')
		end
		table.insert(output, header)
		for _, recipe in ipairs(buildings) do
			table.insert(output, recipeRow(recipe, frame))
		end
		table.insert(output, '|}')
	end
	return table.concat(output, '\n')
end

-- itemRecipes
-- print out just recipe information on how to make an item
-- intended for use in ItemInfo boxes

function funcs.itemRecipes(frame)
	return itemRecipesForName(frame:getParent().args[1], frame)
end
function funcs.itemRecipesDirect(frame)
	return itemRecipesForName(frame.args[1], frame)
end

function itemRecipesForName(name, frame)
	local item = itemByName(name)
	local output = {}
	for _, r in ipairs(recipesMakingByID(item.ID)) do
		table.insert(output, itemRecipe(r, frame))
	end
	local vein = veinMakingByID(item.ID)
	if vein then
		table.insert(output, veinRecipe(item, vein, frame))
	end
	for _, giant in ipairs(deduplicateGiants(gasGiantsMakingByID(item.ID))) do
		table.insert(output, gasGiantRecipe(giant, frame))
	end
	if isItemOcean(item.ID) then
		table.insert(output, oceanRecipe(item, frame))
	end
	return table.concat(output, '\n')
end

-- itemField
-- print a field from an item
-- used to extract details about an item

function funcs.itemField(frame)
	return itemFieldByName(frame:getParent().args[1], frame:getParent().args[2])
end
function funcs.itemFieldDirect(frame)
	return itemFieldByName(frame.args[1], frame.args[2])
end

function itemFieldByName(itemname, fieldname)
	local item = itemByName(itemname)
	return item[fieldname]
end

-- make full rows and recipe data for tables

function recipeRow(recipe, frame)
	local rdata = {
		Building = titleCase(machines[recipe.Type]),
	}
	if recipe.Type == 'Fractionate' then
		rdata.Recipe = fractionateRecipe(recipe, frame)
	else
		rdata.Recipe = itemRecipe(recipe, frame)
	end
	if recipe.Handcraft then
		rdata.Replicator = 'Yes'
	else
		rdata.Replicator = 'No'
	end
	local tech = technologyForRecipeID(recipe.ID)
	if tech ~= nil then
		rdata.Technology = titleCase(tech.Name)
	else
		rdata.Technology = ''
	end
	local productive = not recipe.NonProductive
	for i, itemid in ipairs(recipe.Items) do
		productive = productive and itemByID(itemid).Productive
	end
	if productive then
		rdata.Proliferator = 'Yes'
	else
		rdata.Proliferator = 'Speed'
	end
	return '|-\n| ' .. frame:expandTemplate{title='ProductionChain', args=rdata}
end

function itemRecipe(recipe, frame)
	local rdata = {
		CraftTime = string.format('%s s', tostring(recipe.TimeSpend/60)),
	}
	for i, itemid in ipairs(recipe.Results) do
		rdata[string.format('Out%d', i)] = titleCase(itemByID(itemid).Name)
		rdata[string.format('Out%dQty', i)] = tostring(recipe.ResultCounts[i])
	end
	for i, itemid in ipairs(recipe.Items) do
		rdata[string.format('In%d', i)] = titleCase(itemByID(itemid).Name)
		rdata[string.format('In%dQty', i)] = tostring(recipe.ItemCounts[i])
	end
	return frame:expandTemplate{title='ItemRecipe', args=rdata}
end

function fractionateRecipe(recipe, frame)
	local ratio = 100 * recipe.ResultCounts[1] / recipe.ItemCounts[1]
	local rdata = {
		CraftTime = tostring(ratio) .. '%',
	}
	for i, itemid in ipairs(recipe.Results) do
		rdata[string.format('Out%d', i)] = titleCase(itemByID(itemid).Name)
		rdata[string.format('Out%dQty', i)] = '1'
	end
	for i, itemid in ipairs(recipe.Items) do
		rdata[string.format('In%d', i)] = titleCase(itemByID(itemid).Name)
		rdata[string.format('In%dQty', i)] = '1'
	end
	return frame:expandTemplate{title='ItemRecipe', args=rdata}
end

function veinRow(item, vein, frame)
	if vein.ID == OilSeepID then -- I don't have a better test for oil right now
		local extractor = itemByName(machines.Oil)
		local extractorTech = technologyForRecipeID(recipesMakingByID(extractor.ID)[1].ID)
		local oildata = {
			Building = titleCase(extractor.Name),
			Replicator = 'No',
			Technology = titleCase(extractorTech.Name),
			Recipe = oilRecipe(item, vein, frame),
			Proliferator='No',
		}
		return '|-\n| ' .. frame:expandTemplate{title='ProductionChain', args=oildata}
	else
		local miner = itemByName(machines.Mine)
		local minerTech = technologyForRecipeID(recipesMakingByID(miner.ID)[1].ID)
		local veindata = {
			Building = titleCase(miner.Name),
			Replicator = 'Mine',
			Technology = titleCase(minerTech.Name),
			Recipe = veinRecipe(item, vein, frame),
			Proliferator='No',
		}
		return '|-\n| ' .. frame:expandTemplate{title='ProductionChain', args=veindata}
	end
end

function veinRecipe(item, vein, frame)
	local vname = string.gsub(vein.Name, '%sVeins$', ' Vein')
	local idata = {
		In1 = titleCase(vname),
		In1Qty = '1',
		Out1 = titleCase(item.Name),
		Out1Qty = '1',
		CraftTime = '2 s',
	}
	return frame:expandTemplate{title='ItemRecipe', args=idata}
end

function oilRecipe(item, vein, frame)
	local odata = {
		In1 = titleCase(vein.Name),
		In1Qty = '',
		Out1 = titleCase(item.Name),
		Out1Qty = '1',
		CraftTime = '?',
	}
	return frame:expandTemplate{title='ItemRecipe', args=odata}
end

function gasGiantRow(item, giant, frame)
	local collector = itemByName(machines.Gas)
	local collectorTech = technologyForRecipeID(recipesMakingByID(collector.ID)[1].ID)
	local giantdata = {
		Building = titleCase(collector.Name),
		Replicator = 'Mine',
		Technology = titleCase(collectorTech.Name),
		Recipe = gasGiantRecipe(giant, frame),
		Proliferator='No',
	}
	return '|-\n| ' .. frame:expandTemplate{title='ProductionChain', args=giantdata}
end

function gasGiantRecipe(gas, frame)
	local gdata = {
		CraftTime = '?',
		In1 = titleCase(gas.DisplayName),
		In1Qty = '',
	}
	for i, productID in ipairs(gas.GasItems) do
		local product = itemByID(productID)
		gdata[string.format('Out%d', i)] = titleCase(product.Name)
		gdata[string.format('Out%dQty', i)] = '1'
	end
	return frame:expandTemplate{title='ItemRecipe', args=gdata}
end

function oceanRow(item, frame)
	local pump = itemByName(machines.Ocean)
	local pumpTech = technologyForRecipeID(recipesMakingByID(pump.ID)[1].ID)
	local oceandata = {
		Building = titleCase(pump.Name),
		Replicator = 'No',
		Technology = titleCase(pumpTech.Name),
		Recipe = oceanRecipe(item, frame),
		Proliferator='No',
	}
	return '|-\n| ' .. frame:expandTemplate{title='ProductionChain', args=oceandata}
end

function oceanRecipe(item, frame)
	local odata = {
		CraftTime = '1.2 s',
		Out1 = titleCase(item.Name),
		Out1Qty = 1,
		In1 = titleCase(item.MiningFrom),
		In1Qty = '',
	}
	return frame:expandTemplate{title='ItemRecipe', args=odata}
end

-- get data from protosets

function itemByName(name)
	local lame = string.lower(name)
	for _, item in ipairs(protosets.ItemProtoSet.dataArray) do
		if string.lower(item.Name) == lame then
			return item
		end
	end
	error('No item named ' .. name)
end
function itemByID(id)
	for _, item in ipairs(protosets.ItemProtoSet.dataArray) do
		if item.ID == id then
			return item
		end
	end
	error('No item with ID ' .. id)
end

function recipesMakingByID(id)
	local result = {}
	for _, recipe in ipairs(protosets.RecipeProtoSet.dataArray) do
		for _, itemid in ipairs(recipe.Results) do
			if itemid == id then
				table.insert(result, recipe)
				break
			end
		end
	end
	return result
end
function recipesUsingByID(id)
	local recipes = {}
	for _, recipe in ipairs(protosets.RecipeProtoSet.dataArray) do
		for _, itemid in ipairs(recipe.Items) do
			if itemid == id then
				table.insert(recipes, recipe)
				break
			end
		end
	end
	return recipes
end

function technologyForRecipeID(id)
	for _, tech in ipairs(protosets.TechProtoSet.dataArray) do
		for _, recipeid in ipairs(tech.UnlockRecipes) do
			if recipeid == id then
				return tech
			end
		end
	end
	return nil
end

function veinMakingByID(id)
	for _, vein in ipairs(protosets.VeinProtoSet.dataArray) do
		if vein.MiningItem == id then
			return vein
		end
	end
	return nil
end

function gasGiantsMakingByID(id)
	local giants = {}
	for _, planet in ipairs(protosets.ThemeProtoSet.dataArray) do
		for _, item in ipairs(planet.GasItems) do
			if item == id then
				table.insert(giants, planet)
				break
			end
		end
	end
	return giants
end

function isItemOcean(id)
	for _, planet in ipairs(protosets.ThemeProtoSet.dataArray) do
		if id == planet.WaterItemId then
			return true
		end
	end
	return false
end

-- sorting/deduplication

function deduplicateGiants(giants)
	local dedup = {}
	for _, planet in ipairs(giants) do
		new = true
		for _, exist in ipairs(dedup) do
			if string.lower(planet.DisplayName) == string.lower(exist.DisplayName) then
				new = false
				break
			end
		end
		if new then table.insert(dedup, planet) end
	end
	return dedup
end

-- display formatting

function titleCase(str)
	local start = string.gsub(str, '^%l', string.upper)
	local title = string.gsub(start, '[-%s]%l', string.upper)
	local mk = string.gsub(title, 'MK.I', 'Mk.I')
	return mk
end

return funcs
Description	What you type	What you get
Italic	''Italic text''	Italic text
Bold	'''Bold text'''	Bold text
Bold & italic	'''''Bold & italic text'''''	*Bold & italic text*