Space Station 14 Вики

Модуль:Prototypes/Хранилище/Предмет: различия между версиями

Интерактивная навигация по истории
← Предыдущая правка
мНет описания правки
мНет описания правки
 
(не показано 69 промежуточных версий этого же участника)
Строка 1: Строка 1:
local p = {}
---------------------------------------------------------------------
-- Функция поиска данных по ID
local function findDataById(data, id)
    if not data then
        return nil
    end


-- Кэш данных
    if data[id] then
local dataCache = {}
        return data[id]
local indexCache = {}
    end


-- Функция processRolls для преобразования диапазона
    if type(data) == "table" then
local processRolls = function(rolls)
        -- Если таблица массивная, то перебираем по порядку, иначе по парам
    if not rolls then return 'Не указан параметр rolls.' end
        local iterFunc = (#data > 0) and ipairs or pairs
    if rolls.range then
         for _, item in iterFunc(data) do
         local min, max = rolls.range:match("(%d+),%s*(%d+)")
            if type(item) == "table" and item.id == id then
        if min and max then
                return item
             return string.format('от %d до %d.', min + 1, max + 1)
             end
         end
         end
        return 'Некорректный формат для range.'
    elseif rolls.value then
        return string.format('Будет сгенерировано %d предметов.', rolls.value)
     end
     end
     return 'Не указан параметр rolls.'
     return nil
end
end


-- Локальные функции
---------------------------------------------------------------------
local loadData, findDataById, formatContent, getContentsOutput, processNestedSelectors, getTableOutput, getContainedOutput, getChemOutput, handleGroupSelector, handleAllSelector, handleNestedSelector
-- Форматирование содержимого
local function formatContent(content)
    if type(content) == "table" and not content.id then
        return "Ошибка: отсутствует id у элемента."
    end
 
    local id = content.id or content
    local amountNumber = 1


-- Функция для загрузки данных с кэшированием
     if content.amount then
loadData = function(filePath)
         if type(content.amount) == "table" then
     if not dataCache[filePath] then
            amountNumber = content.amount.value or 1
         local page = mw.title.new(filePath)
         else
        local content = page:getContent()
             amountNumber = content.amount
        dataCache[filePath] = content and mw.text.jsonDecode(content) or {}
        indexCache[filePath] = {}
         for _, item in ipairs(dataCache[filePath]) do
             indexCache[filePath][item.id] = item
         end
         end
     end
     end
     return dataCache[filePath], indexCache[filePath]
     local amount = (amountNumber and amountNumber ~= 1) and string.format(" [%d]", amountNumber) or ""
end


-- Поиск данных по ID через кэшированный индекс
    local prob = ""
findDataById = function(dataIndex, id)
    local probValue = nil
     return dataIndex[id]
    if content.prob then
end
        probValue = content.prob * 100 -- перевод в проценты
    elseif content.weight then
        probValue = content.weight
    end
    if probValue then
        prob = string.format("%s%%", (probValue >= 1) and math.floor(probValue) or probValue)
     end


-- Форматирование содержимого
-- Имитирует "string.format('{{#invoke:Предмет|main|%s|%s<span>%s</span>|repository=1|wrapper=1}}', id, amount, prob)", но работает быстрее, поэтому так
formatContent = function(content)
     return "{{LinkCard|название={{#invoke:Entity Lookup|getname|" .. id .. "}} {{#invoke:Prototypes/Хранилище/Предмет|main|framing|stack|" .. id .. "}} ".. amount .." <span>" .. prob .. "</span>|пин={{#invoke:Prototypes/Хранилище/Предмет|main|framing|contained|" .. id .. "}} {{#invoke:Prototypes/Хранилище/Предмет|main|framing|slot|" .. id .. "}} {{#invoke:Prototypes/Хранилище/Предмет|main|framing|chem|" .. id .. "}}|изображение=[[Файл:" .. id .. ".png|32px]]|горизонт_стиль=1}}"
    if not content.id then return "Ошибка: отсутствует id у элемента." end
   
    local name = string.format('{{#invoke:Entity Lookup|getname|%s}}', content.id)
     local image = content.id .. ".png"
    local amount = content.amount and string.format(" [%d]", content.amount) or ""
    local prob = content.weight and string.format(" <div>%.0f%%</div>", (content.weight / 100) * 100) or ""
   
    return string.format(
        '{{LinkСard|SideStyle=1|background-color=#cbcbff0b|image=%s|name=%s%s%s {{#invoke:Prototypes/Хранилище/Предмет|main|framing|contained|%s}} }}',
        image, name, amount, prob, content.id
    )
end
end


-- Получение содержимого через таблицу
---------------------------------------------------------------------
getContentsOutput = function(contents)
-- Обработка списка элементов (не таблицы, а прямой список содержимого)
local function getContentsOutput(contents)
     local result = {}
     local result = {}
     for _, content in ipairs(contents) do
     for _, content in ipairs(contents) do
Строка 66: Строка 66:
end
end


-- Обработка вложенных таблиц
---------------------------------------------------------------------
processNestedSelectors = function(children)
-- Универсальная функция обхода детей с учётом рекурсии и кеширования (visited)
     if not children or #children == 0 then return "" end
local function processChildren(children, visited)
     local results = {}
    visited = visited or {}
     if not children then return "" end
 
     local result = {}
     for _, child in ipairs(children) do
     for _, child in ipairs(children) do
         results[#results + 1] = child.id and formatContent(child) or ""
         if child.id then
            if not visited[child.id] then
                result[#result + 1] = formatContent(child)
            end
        elseif child["!type"] == "NestedSelector" then
            result[#result + 1] = handleNestedSelector(child, true, visited)
        elseif child["!type"] == "GroupSelector" then
            result[#result + 1] = handleGroupSelector(child, visited)
        elseif child["!type"] == "AllSelector" then
            result[#result + 1] = handleAllSelector(child)
        end
     end
     end
     return table.concat(results)
     return table.concat(result)
end
end


-- Обработка таблиц
---------------------------------------------------------------------
getTableOutput = function(tableId)
-- Получение содержимого таблицы по tableId с кешированием
    local allSelectors, allSelectorsIndex = loadData('User:IanComradeBot/prototypes/AllSelector.json')
local function getTableOutput(tableId, visited)
     local tableData = findDataById(allSelectorsIndex, tableId)
local tableData = mw.loadData("Модуль:IanComradeBot/prototypes/table.json/data")
     return tableData and processNestedSelectors(tableData.children or {}) or 'Таблица не найдена.'
    visited = visited or {}
    if visited[tableId] then return "" end
    visited[tableId] = true
 
     local tableDataIndex = findDataById(tableData, tableId)
     if not tableDataIndex then
        return 'Таблица не найдена.'
    end
 
    if tableDataIndex['!type:GroupSelector'] then
        return handleGroupSelector(tableDataIndex['!type:GroupSelector'], visited)
    elseif tableDataIndex['!type:AllSelector'] then
        return processChildren(tableDataIndex['!type:AllSelector'].children, visited)
    end
 
    return 'Таблица не содержит элементов.'
end
end


-- Формирование списка содержащихся предметов
---------------------------------------------------------------------
getContainedOutput = function(dataIndex, id)
-- Универсальная функция обработки детей контейнеров
     local item = findDataById(dataIndex, id)
local function processContainerChildren(children, visited)
     if not item then return '' end
     local result = {}
     return item.StorageFill and getContentsOutput(item.StorageFill.contents) or ''
    if children then
        for _, child in ipairs(children) do
            if child.id then
                result[#result + 1] = formatContent(child)
            elseif child["!type"] == "GroupSelector" then
                result[#result + 1] = handleGroupSelector(child, visited)
            elseif child["!type"] == "AllSelector" then
                result[#result + 1] = processChildren(child.children, visited)
            end
        end
     end
     return table.concat(result)
end
end


---------------------------------------------------------------------
-- Формирование списка содержащихся предметов или таблиц
local function getContainedOutput(itemData, id, visited)
    visited = visited or {}
    if visited[id] then return "" end
    visited[id] = true
    local item = findDataById(itemData, id)
    if not item then
        return ""
    end
    local result = {}
    if item.StorageFill and item.StorageFill.contents then
        result[#result + 1] = getContentsOutput(item.StorageFill.contents)
    elseif item.EntityTableContainerFill and item.EntityTableContainerFill.containers then
        local containers = item.EntityTableContainerFill.containers
        if containers.entity_storage then
            result[#result + 1] = processContainerChildren(containers.entity_storage.children, visited)
            if containers.entity_storage.tableId then
                result[#result + 1] = getTableOutput(containers.entity_storage.tableId, visited)
            end
        end
        if containers.storagebase then
            result[#result + 1] = processContainerChildren(containers.storagebase.children, visited)
            if containers.storagebase.tableId then
                result[#result + 1] = getTableOutput(containers.storagebase.tableId, visited)
            end
        end
    end
    return table.concat(result)
end
---------------------------------------------------------------------
-- Обработка AllSelector
-- Обработка AllSelector
handleAllSelector = function(allSelector)
function handleAllSelector(allSelector)
     return allSelector.children and processNestedSelectors(allSelector.children) or ''
     if not allSelector.children then return "" end
    return processChildren(allSelector.children)
end
end


---------------------------------------------------------------------
-- Обработка GroupSelector
-- Обработка GroupSelector
handleGroupSelector = function(groupSelector)
function handleGroupSelector(groupSelector, visited)
     if not groupSelector.children then return '' end
    visited = visited or {}
     if not groupSelector.children then return "" end
 
     local result = {}
     local result = {}
    local wrapperStart, wrapperEnd = "", ""
    if groupSelector.weight and groupSelector.weight ~= "default" then
        wrapperStart = string.format('{{LinkCard/Сollapsible|название=Группа предметов %s%%|содержание=', groupSelector.weight)
        wrapperEnd = "}}"
    elseif groupSelector["!type"] == "GroupSelector" and not groupSelector.weight then
        wrapperStart = '{{LinkCard/Сollapsible|название=Может выпасть лишь один из:|содержание='
        wrapperEnd = "}}"
    end
     for _, child in ipairs(groupSelector.children) do
     for _, child in ipairs(groupSelector.children) do
         result[#result + 1] = child.id and formatContent(child) or ""
         if child["!type"] == "GroupSelector" then
            result[#result + 1] = handleGroupSelector(child, visited)
        elseif child["!type"] == "AllSelector" then
            result[#result + 1] = string.format('{{LinkCard/Сollapsible|название=Выпадают только вместе:|содержание=%s}}', handleAllSelector(child))
        elseif child.id then
            result[#result + 1] = formatContent(child)
        else
            result[#result + 1] = "<div>Ошибка: отсутствует id у элемента.</div>"
        end
    end
 
    return wrapperStart .. table.concat(result) .. wrapperEnd
end
 
---------------------------------------------------------------------
-- Обработка NestedSelector
function handleNestedSelector(nestedSelector, wrapped, visited)
    visited = visited or {}
    if not nestedSelector.tableId then return "" end
 
    local result = {}
    local classesRolls, classesProb = "", ""
    if wrapped then
        if nestedSelector.rolls and nestedSelector.rolls.range then
            local rollsResult = processRolls(nestedSelector.rolls)
            if rollsResult and #rollsResult > 0 then
                classesRolls = ', максимум может выпасть: ' .. rollsResult
            end
        end
        if nestedSelector.prob then
            classesProb = string.format(" <div>%s%%</div>", (nestedSelector.prob * 100 >= 1) and math.floor(nestedSelector.prob * 100) or nestedSelector.prob * 100)
        end
    end
 
    if wrapped and (classesRolls ~= "" or classesProb ~= "") then
        result[#result + 1] = string.format('{{LinkCard/Сollapsible|название=Группа предметов%s%s|содержание=', classesRolls, classesProb)
    end
 
    result[#result + 1] = getTableOutput(nestedSelector.tableId, visited)
 
    if wrapped and (classesRolls ~= "" or classesProb ~= "") then
        result[#result + 1] = "}}"
     end
     end
     return table.concat(result)
     return table.concat(result)
end
end


-- Обработка NestedSelector
---------------------------------------------------------------------
handleNestedSelector = function(nestedSelector, wrapped)
-- Функция для преобразования диапазона (rolls)
     return nestedSelector.tableId and getTableOutput(nestedSelector.tableId) or ''
function processRolls(rolls)
    if rolls and rolls.range then
        local min, max = rolls.range:match("(%d+),%s*(%d+)")
        min, max = tonumber(min), tonumber(max)
        if min and max then
            return string.format('[%d-%d]', min + 1, max + 1)
        else
            return 'Некорректный формат для range.'
        end
     elseif rolls and rolls.value then
        return string.format('[%d]', rolls.value)
    else
        return 'Не указан параметр rolls.'
    end
end
end


---------------------------------------------------------------------
-- Формирование списка химии
-- Формирование списка химии
getChemOutput = function(dataIndex, id)
function getChemOutput(id)
     local item = findDataById(dataIndex, id)
local chemTranslateData = mw.loadData("Модуль:IanComradeBot/chem prototypes.json/data")
    if not item or not item.SolutionContainerManager or not item.SolutionContainerManager.solutions then return '' end
 
    local function loadSolutionData(solutionType)
        local modulePath = string.format("Модуль:IanComradeBot/prototypes/fills/chem/%s.json/data", solutionType)
        return mw.loadData(modulePath)
     end
 
    local function processSolution(solutionType)
        local solutionModule = loadSolutionData(solutionType)
        if not solutionModule then return "" end
 
        local item = findDataById(solutionModule, id)
        if not item then return "" end
 
        local solutionData = item[solutionType] or item
        if not solutionData or not solutionData.reagents then return "" end
 
        local output = {}
        for _, reagent in ipairs(solutionData.reagents) do
            local chemInfo = chemTranslateData[reagent.ReagentId]
            local displayName = chemInfo and chemInfo.name or reagent.ReagentId
            output[#output + 1] = string.format('<li>[[Химия#chem_%s|%s]] (%d ед.)</li>', reagent.ReagentId, displayName, reagent.Quantity)
        end
        return table.concat(output)
    end
 
     local result = {}
     local result = {}
     for _, solution in pairs(item.SolutionContainerManager.solutions) do
     local solutionTypes = {"drink", "beaker", "injector", "pen"}
        for _, reagent in ipairs(solution.reagents) do
    for _, solutionType in ipairs(solutionTypes) do
            result[#result + 1] = string.format('<li>[[Химия#chem_%s|%s]] (%d ед.)</li>', reagent.ReagentId, reagent.ReagentId, reagent.Quantity)
        result[#result + 1] = processSolution(solutionType)
         end
    end
    local combined = table.concat(result)
    return (combined ~= "") and string.format('<ul><b>%s</b></ul>', combined) or ""
end
 
---------------------------------------------------------------------
-- Функция для получения count из itemStackData
function getStackCount(id)
    local item = findDataById(itemStackData, id)
    if item and item.Stack and item.Stack.count then
         return item.Stack.count
     end
     end
     return string.format('<ul class="1">%s</ul>', table.concat(result))
     return nil
end
end


---------------------------------------------------------------------
local p = {}
---------------------------------------------------------------------
-- Основная функция модуля
-- Основная функция модуля
function p.main(frame)
function p.main(frame)
     local mode, id = frame.args[1], frame.args[2]
     local mode = frame.args[1]
     if not id then return 'Не указан ID.' end
    local id  = frame.args[2]
   
 
     local data, dataIndex = loadData('User:IanComradeBot/prototypes/fills/Item.json')
     if not id then
    if not data then return 'Не удалось загрузить данные.' end
        return 'Не указан ID.'
     end


     if mode == 'framing' then
     if mode == 'framing' then
         local subMode, subId = frame.args[2], frame.args[3]
         local subMode   = frame.args[2]
         if not subId then return 'Не указан ID для режима framing.' end
        local idFraming = frame.args[3]
         return frame:preprocess(subMode == 'chem' and ('{{СollapsibleMenu|' .. getChemOutput(dataIndex, subId) .. '}}')
         if not idFraming then
            or subMode == 'contained' and ('{{СollapsibleMenu|' .. getContainedOutput(dataIndex, subId) .. '}}')
            return 'Не указан ID для режима framing.'
             or 'Неизвестный подрежим для framing: ' .. subMode)
        end
 
         if subMode == 'chem' then
            local chemTranslateData = mw.loadData("Модуль:IanComradeBot/chem prototypes.json/data")
            return frame:preprocess('{{СollapsibleMenu|color=#3e7c82|' .. getChemOutput(idFraming, chemTranslateData) .. '}}')
 
        elseif subMode == 'contained' then
            local itemData = mw.loadData("Модуль:IanComradeBot/prototypes/fills/Item.json/data")
            return frame:preprocess('{{СollapsibleMenu|' .. getContainedOutput(itemData, idFraming) .. '}}')
 
        elseif subMode == "slot" then
            local itemSlotsData = mw.loadData("Модуль:IanComradeBot/prototypes/ItemSlots.json/data")
            local entry = findDataById(itemSlotsData, idFraming)
             if not entry then return "" end
            local startingItem
            if entry.ItemSlots and entry.ItemSlots.slots then
                for _, slot in ipairs(entry.ItemSlots.slots) do
                    if slot.startingItem and slot.startingItem ~= "" then
                        startingItem = slot.startingItem
                        break
                    end
                end
            end
            if not startingItem then return "" end
            return frame:preprocess('{{СollapsibleMenu|color=#71702a|' .. formatContent(startingItem) .. '}}')
 
        elseif subMode == "stack" then
            local itemStackData = mw.loadData("Модуль:IanComradeBot/prototypes/fills/stack.json/data")
            local count = getStackCount(idFraming, itemStackData)
            return count and ('(' .. count .. ')') or ""
 
        else
            return 'Неизвестный подрежим для framing: ' .. subMode
        end
 
    elseif mode == 'stack' then
        local itemStackData = mw.loadData("Модуль:IanComradeBot/prototypes/fills/stack.json/data")
        local count = getStackCount(id, itemStackData)
        return count or ""
 
     elseif mode == 'chem' then
     elseif mode == 'chem' then
         return frame:preprocess(getChemOutput(dataIndex, id))
        local chemTranslateData = mw.loadData("Модуль:IanComradeBot/chem prototypes.json/data")
         return getChemOutput(id, chemTranslateData)
 
     elseif mode == 'contained' then
     elseif mode == 'contained' then
         return frame:preprocess(getContainedOutput(dataIndex, id))
        local itemData = mw.loadData("Модуль:IanComradeBot/prototypes/fills/Item.json/data")
         return frame:preprocess(getContainedOutput(itemData, id))
 
    elseif mode == "slot" then
        local itemSlotsData = mw.loadData("Модуль:IanComradeBot/prototypes/ItemSlots.json/data")
        local entry = findDataById(itemSlotsData, id)
        if not entry then return "" end
        local startingItem
        if entry.ItemSlots and entry.ItemSlots.slots then
            for _, slot in ipairs(entry.ItemSlots.slots) do
                if slot.startingItem and slot.startingItem ~= "" then
                    startingItem = slot.startingItem
                    break
                end
            end
        end
        if not startingItem then return "" end
        return frame:preprocess(formatContent(startingItem))
 
     elseif mode == 'rolls' then
     elseif mode == 'rolls' then
         local entity = findDataById(dataIndex, id)
        local itemData = mw.loadData("Модуль:IanComradeBot/prototypes/fills/Item.json/data")
         return entity and entity.EntityTableContainerFill and entity.EntityTableContainerFill.containers
         local entity = findDataById(itemData, id)
             and entity.EntityTableContainerFill.containers.entity_storage and entity.EntityTableContainerFill.containers.entity_storage.rolls
         if not entity then
            and processRolls(entity.EntityTableContainerFill.containers.entity_storage.rolls) or 'Режим rolls не найден для этого ID.'
            return 'ID не найден в данных.'
        end
        if entity.EntityTableContainerFill then
            local containers = entity.EntityTableContainerFill.containers
             if containers.entity_storage and containers.entity_storage.rolls then
                return processRolls(containers.entity_storage.rolls)
            end
        end
        return ''
 
    else
        return 'Неизвестный режим: ' .. mode
     end
     end
    return 'Неизвестный режим: ' .. mode
end
end


return p
return p
Источник — https://station14.ru/wiki/Модуль:Prototypes/Хранилище/Предмет