Перейти к содержанию

Модуль:Обжиг: различия между версиями

Материал из LemonCraft Wiki
м 1 версия импортирована
м 1 версия импортирована
 
(не показана 1 промежуточная версия 1 участника)
Строка 1: Строка 1:
----------------------------------------------------------------------------------
--- Модуль для создания таблиц с рецептами для обжига и похожих методов обработки.
----------------------------------------------------------------------------------
local p = {}
local p = {}
function p.table( f )
 
--- Интернационализация и локализация
local i18n = {
-- Зависимости
moduleArgs = [[Модуль:ProcessArgs]],
moduleRecipe = [[Модуль:Таблица рецептов]],
moduleProcessing = [[Модуль:Обработка]],
moduleProcessingFunc = "interface",
moduleMods = [[Модуль:Модификации]],
-- Параметры процесса
type = "обжиг",
typeGenitive = "обжига",
}
 
-- Зависимости
local recipeTable = require(i18n.moduleRecipe).table
local modNames = mw.loadData(i18n.moduleMods)
 
-- Создание таблицы
function p.table(f)
local args = f
local args = f
if f == mw.getCurrentFrame() then
if f == mw.getCurrentFrame() then
args = f:getParent().args
args = require(i18n.moduleArgs).merge(true)
else
else
f = mw.getCurrentFrame()
f = mw.getCurrentFrame()
end
end
local getParts = require( 'Модуль:Инвентарный слот' ).makeFrame
-- Начинать таблицу при необходимости
-- Модификация и вид обработки
local multirow = f:callParserFunction( '#dplvar', 'recipetable-multirow' )
-- [[Модуль:Обработка]] не разбирает сокращения и не поддерживает параметр
if multirow == '' then
-- «мод» со строчной буквы, поэтому они обрабатываются явным образом.
multirow = nil
local mod = args["мод"] or args["Мод"]
end
local progress = args["Прогресс"]
local head = args["глава"] or '0'
if progress then
if tonumber(head) then
args["несколько обработок"] = 1
head = tonumber(head)
else
error("Параметр «глава» не является числом.")
end
if multirow then
head = 0
elseif head ~= 0 then
multirow = 1
f:callParserFunction( '#dplvar:set', 'recipetable-multirow', '1' )
else
head = 1
end
end
-- Заканчивать таблицу при необходимости
if mod then
local foot = args["подвал"] or ''
-- разбор сокращений
if multirow then
mod = modNames[mod] or mod
if foot ~= '' then
elseif progress then
multirow = nil
-- определение модификации по обозначению вида обработки
f:callParserFunction( '#dplvar:set', 'recipetable-multirow', '' )
-- для совместимости??!
end
if progress:find('gt4') then
else
foot = 1
end
local mod = args["Мод"]
if not mod and args["Прогресс"] then
if args['Прогресс']:find('gt4') then
mod = 'GregTech 4'
mod = 'GregTech 4'
elseif args['Прогресс']:find('gt') then
elseif progress:find('gt') then
mod = 'GregTech'
mod = 'GregTech'
elseif args['Прогресс']:find('ic2') then
elseif progress:find('ic2') then
mod = 'IndustrialCraft 2'
mod = 'IndustrialCraft 2'
end
end
end
end
local modNames = mw.loadData("Модуль:Модификации")
args["мод"] = mod
args["Мод"] = modNames[mod] or mod
args["Мод"] = mod
 
-- Сборка заголовка таблицы
-- Обработка аргументов интерфейса
local header = ''
local ingredientArgVals = {}
if head ~= 0 then
local outputArgVals = {}
local name = ''
local description = ''
-- Нежидкостные ресурсы
if args["показатьимя"] == '1' or multirow and args["показатьимя"] ~= '0' then
args["Ресурс1"] = args["Ресурс1"] or args["Ресурс"] or args[1]
name = '!! Результат'
if args["Ресурс1"] then
f:callParserFunction( '#dplvar:set', 'recipetable-name', '1' )
ingredientArgVals[1] = "Ресурс1"
end
if args["показатьописание"] == '1' then
description = ' !! class="unsortable" | Описание'
f:callParserFunction( '#dplvar:set', 'recipetable-description', '1' )
end
local class = args["класс"] or ''
if multirow then
class = 'sortable collapsible ' .. class
recipeClass = 'class="unsortable" |'
else
recipeClass = ''
end
if args["Прогресс"] then
process = ' Процесс'
else
process = ' [[Плавка|Процесс]]'
end
header = table.concat( {
' {| class="wikitable ' .. class .. '" data-description="Процесс"',
'! ' .. 'Ингредиенты !! ' .. recipeClass .. process .. name .. description,
'|-'}, '\n' )
end
end
-- Конвертор аргументов
if not args["Ресурс2"] then
args["Ресурс1"] = args["Ресурс1"] or args["Ресурс"] or args[1]
args["Ресурс2"] = args["Топливо"] or args["топливо"]
args["Ресурс2"] = args["Ресурс2"] or args["Топливо"] or args["топливо"]
else
args["Выход1"] = args["Выход1"] or args["Выход"] or args[2]
-- Если Ресурс2 на самом деле топливо, то этот параметр исключается из
args["РесурсЖ1"] = args["РесурсЖ1"] or args["РесурсЖ"]
-- списка аргументов, обрабатываемых Таблицей рецептов. То есть, на
args["ВыходЖ1"] = args["ВыходЖ1"] or args["ВыходЖ"]
-- топливо не будет ссылок в ячейке ингредиентов. Также оно не будет
-- учитываться системами отслеживания использования ингредиентов, если
-- и когда они будут реализованы для Обжига.
-- Но здесь не тот случай
table.insert(ingredientArgVals, "Ресурс2")
end
local input = {}
local n = 3
n = 1
while args["Ресурс" .. n] do
while args['Ресурс' .. n] do
table.insert(ingredientArgVals, "Ресурс" .. n)
table.insert( input , mw.text.trim( args['Ресурс' .. n] ))
n = n + 1
n = n + 1
end
end
-- Нежидкостные выходы
args["Выход1"] = args["Выход1"] or args["Выход"] or args[2]
n = 1
n = 1
while args['РесурсЖ' .. n] do
while args["Выход" .. n] do
table.insert( input , mw.text.trim( args['РесурсЖ' .. n] ))
table.insert(outputArgVals, "Выход" .. n)
n = n + 1
n = n + 1
end
end
local output = {}
-- Жидкостные входы
args["РесурсЖ1"] = args["РесурсЖ1"] or args["РесурсЖ"]
n = 1
n = 1
while args['Выход' .. n] do
while args["РесурсЖ" .. n] do
table.insert( output , mw.text.trim( args['Выход' .. n] ))
table.insert(ingredientArgVals, "РесурсЖ" .. n)
n = n + 1
n = n + 1
end
end
-- Жидкостные выходы
args["ВыходЖ1"] = args["ВыходЖ1"] or args["ВыходЖ"]
n = 1
n = 1
while args['ВыходЖ' .. n] do
while args["ВыходЖ" .. n] do
table.insert( output , mw.text.trim( args['ВыходЖ' .. n] ))
table.insert(outputArgVals, "ВыходЖ" .. n)
n = n + 1
n = n + 1
end
end
-- Ячейка с ингредиентами
-- Теперь можно использовать Таблицу рецептов
local ingredientsCell
local out = recipeTable(args, {
if args["ингредиенты"] or '' ~= '' then
["модуль интерфейса"] = i18n.moduleProcessing,
ingredientsCell = args["ингредиенты"]
["функция интерфейса"] = i18n.moduleProcessingFunc,
else
["тип"] = i18n.type,
ingredientsCell = {}
["типа"] = i18n.typeGenitive,
local ingredients = {}
["аргументы ингредиентов"] = ingredientArgVals,
local separator = ''
["аргументы выхода"] = outputArgVals
for k, v in ipairs ( input ) do
})
if k > 1 and next( ingredients ) then
return out
separator = '&nbsp;+<br>\n'
end
end
for item in mw.text.gsplit( v, '%s*;%s*' ) do
local parts = getParts( item, mod )
if parts.name ~= '' and not ingredients[parts.name] and ( k >= 1 and ( v ~= args['Топливо'] )) then
local link = ''
if separator == '' and next( ingredients ) then
separator = '&nbsp;или<br>\n'
end


if parts.mod then
link = parts.mod .. '/' .. parts.name .. '|'
end
if parts.name:find( '^Люб' ) then
if parts.mod then
link = parts.mod .. '/' .. mw.ustring.gsub( mw.ustring.sub( parts.name, 7 ), "^%l", mw.ustring.upper ) .. '|'
end
table.insert( ingredientsCell, separator .. mw.ustring.sub( parts.name, 0, 6 ) .. '[[' .. link .. mw.ustring.sub( parts.name, 6 ) .. ']]' )
else
table.insert( ingredientsCell, separator .. '[[' .. link .. parts.name .. ']]' )
end
separator = ''
ingredients[parts.name] = 1
end
end
end
ingredientsCell = table.concat( ingredientsCell )
end
-- Ячейка с рецептом
local recipeCell = require( 'Модуль:Обработка' ).interface( args )
-- Ячейка с продуктами
local nameCell
if args["название"] or '' ~= '' then
nameCell = args["название"]
elseif f:callParserFunction( '#dplvar', 'recipetable-name' ) == '1' then
nameCell = {}
local names = {}
for k, v in ipairs ( output ) do
local separator = ''
if k > 1 and next( names ) then
separator = '&nbsp;+<br>\n'
end
for item in mw.text.gsplit( v, '%s*;%s*' ) do
local parts = getParts( item, mod )
if parts.name ~= '' and not names[parts.name] and ( k >= 1 ) then
local link = ''
if separator == '' and next( names ) then
separator = '&nbsp;или<br>\n'
end
if parts.mod then
link = parts.mod .. '/' .. parts.name .. '|'
end
if parts.name:find( '^Люб' ) then
if parts.mod then
link = parts.mod .. '/' .. mw.ustring.gsub( mw.ustring.sub( parts.name, 7 ), "^%l", mw.ustring.upper ) .. '|'
end
table.insert( nameCell, separator .. mw.ustring.sub( parts.name, 0, 6 ) .. '[[' .. link .. mw.ustring.sub( parts.name, 6 ) .. ']]' )
else
table.insert( nameCell, separator .. '[[' .. link .. parts.name .. ']]' )
end
separator = ''
names[parts.name] = 1
end
end
end
nameCell = table.concat( nameCell )
end
if nameCell and args["запланированное"] then
nameCell = nameCell .. '<br>([[' .. args["запланированное"] .. ']])'
end
-- Сборка строки таблицы с интерфейсом
local row = {
'\n|' .. ingredientsCell,
'style="text-align:center"|' .. recipeCell
}
if nameCell then
table.insert( row, 'style="text-align:center;font-weight:bold"|' .. nameCell )
end
if f:callParserFunction( '#dplvar', 'recipetable-description' ) == '1' then
table.insert( row, args["описание"] or '' )
end
row = table.concat( row, '\n|' ) .. '\n|-'
-- Закрытие таблицы
local footer = ''
if foot ~= '' then
footer = '\n|}'
f:callParserFunction( '#dplvar:set', 'recipetable-name', '', 'recipetable-description', '' )
end
local category = ''
local title = mw.title.getCurrentTitle()
if args["запланированное"] and args["некат"] ~= '1' and title.namespace == 0 and not title.isSubpage then
category = '[[Категория:Запланированные материалы]]'
end
return header .. row .. footer .. category
end
return p
return p

Текущая версия от 00:33, 13 июня 2025

Для документации этого модуля может быть создана страница Модуль:Обжиг/doc

----------------------------------------------------------------------------------
--- Модуль для создания таблиц с рецептами для обжига и похожих методов обработки.
----------------------------------------------------------------------------------
local p = {}

--- Интернационализация и локализация
local i18n = {
	-- Зависимости
	moduleArgs = [[Модуль:ProcessArgs]],
	moduleRecipe = [[Модуль:Таблица рецептов]],
	moduleProcessing = [[Модуль:Обработка]],
	moduleProcessingFunc = "interface",
	moduleMods = [[Модуль:Модификации]],
	
	-- Параметры процесса
	type = "обжиг",
	typeGenitive = "обжига",
}

-- Зависимости
local recipeTable = require(i18n.moduleRecipe).table
local modNames = mw.loadData(i18n.moduleMods)

-- Создание таблицы
function p.table(f)
	local args = f
	if f == mw.getCurrentFrame() then
		args = require(i18n.moduleArgs).merge(true)
	else
		f = mw.getCurrentFrame()
	end
	
	-- Модификация и вид обработки
	-- [[Модуль:Обработка]] не разбирает сокращения и не поддерживает параметр
	-- «мод» со строчной буквы, поэтому они обрабатываются явным образом.
	local mod = args["мод"] or args["Мод"]
	local progress = args["Прогресс"]
	if progress then
		args["несколько обработок"] = 1
	end
	
	if mod then
		-- разбор сокращений
		mod = modNames[mod] or mod
	elseif progress then
		-- определение модификации по обозначению вида обработки
		-- для совместимости??!
		if progress:find('gt4') then
			mod = 'GregTech 4'
		elseif progress:find('gt') then
			mod = 'GregTech'
		elseif progress:find('ic2') then
			mod = 'IndustrialCraft 2'
		end
	end
	args["мод"] = mod
	args["Мод"] = mod
	
	-- Обработка аргументов интерфейса
	local ingredientArgVals = {}
	local outputArgVals = {}
	
	-- Нежидкостные ресурсы
	args["Ресурс1"] = args["Ресурс1"] or args["Ресурс"] or args[1]
	if args["Ресурс1"] then
		ingredientArgVals[1] = "Ресурс1"
	end
	
	if not args["Ресурс2"] then
		args["Ресурс2"] = args["Топливо"] or args["топливо"]
	else
		-- Если Ресурс2 на самом деле топливо, то этот параметр исключается из
		-- списка аргументов, обрабатываемых Таблицей рецептов. То есть, на
		-- топливо не будет ссылок в ячейке ингредиентов. Также оно не будет
		-- учитываться системами отслеживания использования ингредиентов, если
		-- и когда они будут реализованы для Обжига.
		
		-- Но здесь не тот случай
		table.insert(ingredientArgVals, "Ресурс2")
	end
	
	local n = 3
	while args["Ресурс" .. n] do
		table.insert(ingredientArgVals, "Ресурс" .. n)
		n = n + 1
	end
	
	-- Нежидкостные выходы
	args["Выход1"] = args["Выход1"] or args["Выход"] or args[2]
	n = 1
	while args["Выход" .. n] do
		table.insert(outputArgVals, "Выход" .. n)
		n = n + 1
	end
	
	-- Жидкостные входы
	args["РесурсЖ1"] = args["РесурсЖ1"] or args["РесурсЖ"]
	n = 1
	while args["РесурсЖ" .. n] do
		table.insert(ingredientArgVals, "РесурсЖ" .. n)
		n = n + 1
	end
	
	-- Жидкостные выходы
	args["ВыходЖ1"] = args["ВыходЖ1"] or args["ВыходЖ"]
	n = 1
	while args["ВыходЖ" .. n] do
		table.insert(outputArgVals, "ВыходЖ" .. n)
		n = n + 1
	end
	
	-- Теперь можно использовать Таблицу рецептов
	local out = recipeTable(args, {
		["модуль интерфейса"] = i18n.moduleProcessing,
		["функция интерфейса"] = i18n.moduleProcessingFunc,
		["тип"] = i18n.type,
		["типа"] = i18n.typeGenitive,
		["аргументы ингредиентов"] = ingredientArgVals,
		["аргументы выхода"] = outputArgVals
	})
	return out
end

return p