Модуль:Prototypes/Хранилище/Предмет

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

---------------------------------------------------------------------
-- Предварительная загрузка данных
local itemData          = mw.loadData("Модуль:IanComradeBot/prototypes/fills/Item.json/data")
local itemSlotsData     = mw.loadData("Модуль:IanComradeBot/prototypes/ItemSlots.json/data")
local itemStackData     = mw.loadData("Модуль:IanComradeBot/prototypes/fills/stack.json/data")
local chemTranslateData = mw.loadData("Модуль:IanComradeBot/chem prototypes.json/data")
local tableData         = mw.loadData("Модуль:IanComradeBot/prototypes/table.json/data")

---------------------------------------------------------------------
-- Функция поиска данных по ID
local function findDataById(data, id)
    if not data then 
        return nil 
    end

    if data[id] then
        return data[id]
    end

    if type(data) == "table" then
        -- Если таблица массивная, то перебираем по порядку, иначе по парам
        local iterFunc = (#data > 0) and ipairs or pairs
        for _, item in iterFunc(data) do
            if type(item) == "table" and item.id == id then
                return item
            end
        end
    end
    return nil
end

---------------------------------------------------------------------
-- Форматирование содержимого
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
        if type(content.amount) == "table" then
            amountNumber = content.amount.value or 1
        else
            amountNumber = content.amount
        end
    end
    local amount = (amountNumber and amountNumber ~= 1) and string.format(" [%d]", amountNumber) or ""

    local prob = ""
    local probValue = nil
    if content.prob then
        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

    return string.format('{{#invoke:Предмет|main|%s|%s<span>%s</span>|repository=1|wrapper=1}}', id, amount, prob)
end

---------------------------------------------------------------------
-- Обработка списка элементов (не таблицы, а прямой список содержимого)
local function getContentsOutput(contents)
    local result = {}
    for _, content in ipairs(contents) do
        result[#result + 1] = formatContent(content)
    end
    return table.concat(result)
end

---------------------------------------------------------------------
-- Универсальная функция обхода детей с учётом рекурсии и кеширования (visited)
local function processChildren(children, visited)
    visited = visited or {}
    if not children then return "" end

    local result = {}
    for _, child in ipairs(children) do
        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
    return table.concat(result)
end

---------------------------------------------------------------------
-- Получение содержимого таблицы по tableId с кешированием
local function getTableOutput(tableId, visited)
    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

---------------------------------------------------------------------
-- Универсальная функция обработки детей контейнеров
local function processContainerChildren(children, visited)
    local result = {}
    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

---------------------------------------------------------------------
-- Формирование списка содержащихся предметов или таблиц
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
function handleAllSelector(allSelector)
    if not allSelector.children then return "" end
    return processChildren(allSelector.children)
end

---------------------------------------------------------------------
-- Обработка GroupSelector
function handleGroupSelector(groupSelector, visited)
    visited = visited or {}
    if not groupSelector.children then return "" end

    local result = {}
    local wrapperStart, wrapperEnd = "", ""
    if groupSelector.weight and groupSelector.weight ~= "default" then
        wrapperStart = string.format('{{LinkСard/Сollapsible|name=Группа предметов %s%%|content=', groupSelector.weight)
        wrapperEnd = "}}"
    elseif groupSelector["!type"] == "GroupSelector" and not groupSelector.weight then
        wrapperStart = '{{LinkСard/Сollapsible|name=Может выпасть лишь один из:|content='
        wrapperEnd = "}}"
    end

    for _, child in ipairs(groupSelector.children) do
        if child["!type"] == "GroupSelector" then
            result[#result + 1] = handleGroupSelector(child, visited)
        elseif child["!type"] == "AllSelector" then
            result[#result + 1] = string.format('{{LinkСard/Сollapsible|name=Выпадают только вместе:|content=%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('{{LinkСard/Сollapsible|name=Группа предметов%s%s|content=', classesRolls, classesProb)
    end

    result[#result + 1] = getTableOutput(nestedSelector.tableId, visited)

    if wrapped and (classesRolls ~= "" or classesProb ~= "") then
        result[#result + 1] = "}}"
    end

    return table.concat(result)
end

---------------------------------------------------------------------
-- Функция для преобразования диапазона (rolls)
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

---------------------------------------------------------------------
-- Формирование списка химии
function getChemOutput(id)
    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 solutionTypes = {"drink", "beaker", "injector", "pen"}
    for _, solutionType in ipairs(solutionTypes) do
        result[#result + 1] = processSolution(solutionType)
    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
    return nil
end

---------------------------------------------------------------------
local p = {}

---------------------------------------------------------------------
-- Основная функция модуля
function p.main(frame)
    local mode = frame.args[1]
    local id = frame.args[2]

    if not id then 
        return 'Не указан ID.' 
    end

    if not itemData then 
        return 'Не удалось загрузить данные.' 
    end

    if mode == 'framing' then
        local subMode = frame.args[2]
        local idFraming = frame.args[3]
        if not idFraming then
            return 'Не указан ID для режима framing.'
        end
        if subMode == 'chem' then
            return frame:preprocess('{{СollapsibleMenu|color=#3e7c82|' .. getChemOutput(idFraming) .. '}}')
        elseif subMode == 'contained' then
            return frame:preprocess('{{СollapsibleMenu|' .. getContainedOutput(itemData, idFraming) .. '}}')
        elseif subMode == "slot" then
            local itemDataEntry = findDataById(itemSlotsData, idFraming)
            if not itemDataEntry then return "" end
            local startingItem = nil
            if itemDataEntry.ItemSlots and itemDataEntry.ItemSlots.slots then
                for _, slot in ipairs(itemDataEntry.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 count = getStackCount(idFraming)
            return count and '(' .. count .. ')' or ""
        else
            return 'Неизвестный подрежим для framing: ' .. subMode
        end
    elseif mode == 'stack' then
        local count = getStackCount(id)
        return count or ""
    elseif mode == 'chem' then
        return getChemOutput(id)
    elseif mode == 'contained' then
        return frame:preprocess(getContainedOutput(itemData, id))
    elseif mode == "slot" then
        local itemDataEntry = findDataById(itemSlotsData, id)
        if not itemDataEntry then return "" end
        local startingItem = nil
        if itemDataEntry.ItemSlots and itemDataEntry.ItemSlots.slots then
            for _, slot in ipairs(itemDataEntry.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
        local entity = findDataById(itemData, id)
        if not entity then 
            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 p