Space Station 14 Вики

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

Интерактивная навигация по истории
← Предыдущая правка
мНет описания правки
мНет описания правки
 
(не показаны 74 промежуточные версии этого же участника)
Строка 1: Строка 1:
local p = {}
---------------------------------------------------------------------
 
-- Функция поиска данных по ID
-- Кэш данных
local function findDataById(data, id)
local dataCache = {}
     if not data then  
local indexCache = {}
         return nil
local tableCache = {}
local containedCache = {}
local chemCache = {}
local processRollsCache = {}
 
-- Функция processRolls для преобразования диапазона с кэшированием
local processRolls = function(rolls)
     if processRollsCache[rolls] then return processRollsCache[rolls] end
   
    local result = {}
    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
            result[#result + 1] = string.format('от %d до %d.', min + 1, max + 1)
        else
            result[#result + 1] = 'Некорректный формат для range.'
        end
    elseif rolls and rolls.value then
        result[#result + 1] = string.format('Будет сгенерировано %d предметов.', rolls.value)
    else
        result[#result + 1] = 'Не указан параметр rolls.'
     end
     end
   
    processRollsCache[rolls] = table.concat(result)
    return processRollsCache[rolls]
end


-- Локальные функции
     if data[id] then
local loadData, findDataById, formatContent, getContentsOutput, processNestedSelectors, getTableOutput, getContainedOutput, getChemOutput, handleGroupSelector, handleAllSelector, handleNestedSelector
         return data[id]
 
-- Функция для загрузки данных с кэшированием
loadData = function(filePath)
     if not dataCache[filePath] then
         local page = mw.title.new(filePath)
        local content = page:getContent()
        dataCache[filePath] = content and mw.text.jsonDecode(content) or nil
     end
     end
    return dataCache[filePath]
end


-- Создание хэш-таблицы для быстрого поиска по ID
    if type(data) == "table" then
local function buildIndex(data)
        -- Если таблица массивная, то перебираем по порядку, иначе по парам
    if indexCache[data] then return indexCache[data] end
        local iterFunc = (#data > 0) and ipairs or pairs
    if not data then return {} end
        for _, item in iterFunc(data) do
    local index = {}
            if type(item) == "table" and item.id == id then
    for _, item in ipairs(data) do
                return item
        index[item.id] = item
            end
        end
     end
     end
    indexCache[data] = index
     return nil
     return index
end
 
-- Поиск данных по ID через хэш-таблицу
findDataById = function(dataIndex, id)
    return dataIndex and dataIndex[id] or nil
end
end


---------------------------------------------------------------------
-- Форматирование содержимого
-- Форматирование содержимого
formatContent = function(content)
local function formatContent(content)
     if not content.id then
     if type(content) == "table" and not content.id then
         return "Ошибка: отсутствует id у элемента."
         return "Ошибка: отсутствует id у элемента."
     end
     end


     local name = string.format('{{#invoke:Entity Lookup|getname|%s}}', content.id)
     local id = content.id or content
    local image = string.format('%s.png', content.id)
     local amountNumber = 1
    local amount = content.amount and string.format(" [%d]", content.amount) or ""
     local prob = ""


     if content.weight then
     if content.amount then
         content.prob = content.weight / 100
         if type(content.amount) == "table" then
            amountNumber = content.amount.value or 1
        else
            amountNumber = content.amount
        end
     end
     end
    local amount = (amountNumber and amountNumber ~= 1) and string.format(" [%d]", amountNumber) or ""


    local prob = ""
    local probValue = nil
     if content.prob then
     if content.prob then
         prob = string.format(" <div>%s%%</div>", content.prob * 100 >= 1 and math.floor(content.prob * 100) or content.prob * 100)
        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
     end


    return string.format(
-- Имитирует "string.format('{{#invoke:Предмет|main|%s|%s<span>%s</span>|repository=1|wrapper=1}}', id, amount, prob)", но работает быстрее, поэтому так
        '{{LinkСard|SideStyle=1|background-color=#cbcbff0b|image=%s|name=%s%s%s {{#invoke:Prototypes/Хранилище/Предмет|main|framing|contained|%s}} }}',
    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}}"
        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
         result[#result + 1] = tostring(formatContent(content))
         result[#result + 1] = formatContent(content)
     end
     end
      
     return table.concat(result)
    local cacheKey = table.concat(result, ",")
    if containedCache[cacheKey] then return containedCache[cacheKey] end
   
    containedCache[cacheKey] = table.concat(result)
    return containedCache[cacheKey]
end
end


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


    local result = {}
     for _, child in ipairs(children) do
     for _, child in ipairs(children) do
         if child.id then
         if child.id then
             results[#results + 1] = formatContent(child)
             if not visited[child.id] then
                result[#result + 1] = formatContent(child)
            end
         elseif child["!type"] == "NestedSelector" then
         elseif child["!type"] == "NestedSelector" then
             -- Кэшируем результат вызова handleNestedSelector
             result[#result + 1] = handleNestedSelector(child, true, visited)
            if not nestedCache[child.tableId] then
                nestedCache[child.tableId] = handleNestedSelector(child, true)
            end
            results[#results + 1] = nestedCache[child.tableId]
         elseif child["!type"] == "GroupSelector" then
         elseif child["!type"] == "GroupSelector" then
             results[#results + 1] = handleGroupSelector(child)
             result[#result + 1] = handleGroupSelector(child, visited)
        elseif child["!type"] == "AllSelector" then
            result[#result + 1] = handleAllSelector(child)
         end
         end
     end
     end
    return table.concat(result)
end


     return table.concat(results)
---------------------------------------------------------------------
end
-- Получение содержимого таблицы по tableId с кешированием
local function getTableOutput(tableId, visited)
local tableData = mw.loadData("Модуль:IanComradeBot/prototypes/table.json/data")
    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
getTableOutput = function(tableId)
        return handleGroupSelector(tableDataIndex['!type:GroupSelector'], visited)
     if tableCache[tableId] then return tableCache[tableId] end
     elseif tableDataIndex['!type:AllSelector'] then
   
         return processChildren(tableDataIndex['!type:AllSelector'].children, visited)
    local allSelectors = loadData('User:IanComradeBot/prototypes/AllSelector.json')
    local tableData = findDataById(buildIndex(allSelectors), tableId)
      
    if not tableData then
        tableCache[tableId] = 'Таблица не найдена.'
         return tableCache[tableId]
     end
     end


     if tableData['!type:GroupSelector'] then
     return 'Таблица не содержит элементов.'
         tableCache[tableId] = handleGroupSelector(tableData['!type:GroupSelector'])
end
    elseif tableData['!type:AllSelector'] then
 
        tableCache[tableId] = processNestedSelectors(tableData['!type:AllSelector'].children)
---------------------------------------------------------------------
    else
-- Универсальная функция обработки детей контейнеров
         tableCache[tableId] = 'Таблица не содержит элементов.'
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
     end
   
     return table.concat(result)
     return tableCache[tableId]
end
end


---------------------------------------------------------------------
-- Формирование списка содержащихся предметов или таблиц
-- Формирование списка содержащихся предметов или таблиц
getContainedOutput = function(data, id)
local function getContainedOutput(itemData, id, visited)
     local item = findDataById(data, id)
    visited = visited or {}
     if not item then return '' end
    if visited[id] then return "" end
    visited[id] = true
 
     local item = findDataById(itemData, id)
     if not item then  
        return ""
    end


     local result = {}
     local result = {}


    -- Обработка StorageFill
     if item.StorageFill and item.StorageFill.contents then
     if item.StorageFill and item.StorageFill.contents then
         result[#result + 1] = getContentsOutput(item.StorageFill.contents)
         result[#result + 1] = getContentsOutput(item.StorageFill.contents)
    -- Обработка EntityTableContainerFill
     elseif item.EntityTableContainerFill and item.EntityTableContainerFill.containers then
     elseif item.EntityTableContainerFill and item.EntityTableContainerFill.containers then
         local containers = item.EntityTableContainerFill.containers
         local containers = item.EntityTableContainerFill.containers
        -- Обработка entity_storage
         if containers.entity_storage then
         if containers.entity_storage then
             if containers.entity_storage.children then
             result[#result + 1] = processContainerChildren(containers.entity_storage.children, visited)
                result[#result + 1] = processNestedSelectors(containers.entity_storage.children)
            end
 
             if containers.entity_storage.tableId then
             if containers.entity_storage.tableId then
                 result[#result + 1] = getTableOutput(containers.entity_storage.tableId)
                 result[#result + 1] = getTableOutput(containers.entity_storage.tableId, visited)
             end
             end
         end
         end
 
         if containers.storagebase then
         -- Обработка storagebase
            result[#result + 1] = processContainerChildren(containers.storagebase.children, visited)
        if containers.storagebase and containers.storagebase.tableId then
            if containers.storagebase.tableId then
            result[#result + 1] = getTableOutput(containers.storagebase.tableId)
                result[#result + 1] = getTableOutput(containers.storagebase.tableId, visited)
            end
         end
         end
     end
     end
     return table.concat(result)
     return table.concat(result)
end
end


---------------------------------------------------------------------
-- Обработка AllSelector
-- Обработка AllSelector
handleAllSelector = function(allSelector)
function handleAllSelector(allSelector)
     if not allSelector.children then return '' end
     if not allSelector.children then return "" end
     return processNestedSelectors(allSelector.children)
     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 = "", ""
     local wrapperStart, wrapperEnd = "", ""
    -- Проверка для контейнера EntityTableContainerFill
     if groupSelector.weight and groupSelector.weight ~= "default" then
     if groupSelector.weight and groupSelector.weight ~= "default" then
         wrapperStart = string.format('<div class="together" id="%s">', groupSelector.weight)
         wrapperStart = string.format('{{LinkCard/Сollapsible|название=Группа предметов %s%%|содержание=', groupSelector.weight)
         wrapperEnd = "</div>"
         wrapperEnd = "}}"
     elseif groupSelector["!type"] == "GroupSelector" and not groupSelector.weight then
     elseif groupSelector["!type"] == "GroupSelector" and not groupSelector.weight then
         wrapperStart = '<div class="EntityFill">'
         wrapperStart = '{{LinkCard/Сollapsible|название=Может выпасть лишь один из:|содержание='
         wrapperEnd = "</div>"
         wrapperEnd = "}}"
     end
     end


     for _, child in ipairs(groupSelector.children) do
     for _, child in ipairs(groupSelector.children) do
         if child["!type"] == "GroupSelector" then
         if child["!type"] == "GroupSelector" then
             result[#result + 1] = handleGroupSelector(child)
             result[#result + 1] = handleGroupSelector(child, visited)
         elseif child["!type"] == "AllSelector" then
         elseif child["!type"] == "AllSelector" then
             result[#result + 1] = string.format('<div class="AllSelector">%s</div>', handleAllSelector(child))
             result[#result + 1] = string.format('{{LinkCard/Сollapsible|название=Выпадают только вместе:|содержание=%s}}', handleAllSelector(child))
         elseif child.id then
         elseif child.id then
             result[#result + 1] = formatContent(child)
             result[#result + 1] = formatContent(child)
Строка 219: Строка 201:
end
end


---------------------------------------------------------------------
-- Обработка NestedSelector
-- Обработка NestedSelector
handleNestedSelector = function(nestedSelector, wrapped)
function handleNestedSelector(nestedSelector, wrapped, visited)
     if not nestedSelector.tableId then return '' end
    visited = visited or {}
     if not nestedSelector.tableId then return "" end


     local result = {}
     local result = {}
     local classes = {}
     local classesRolls, classesProb = "", ""
 
     if wrapped then
     if wrapped then
         if nestedSelector.rolls and nestedSelector.rolls.range then
         if nestedSelector.rolls and nestedSelector.rolls.range then
             classes[#classes + 1] = 'rolls-' .. processRolls(nestedSelector.rolls)
             local rollsResult = processRolls(nestedSelector.rolls)
            if rollsResult and #rollsResult > 0 then
                classesRolls = ', максимум может выпасть: ' .. rollsResult
            end
         end
         end
         if nestedSelector.prob then
         if nestedSelector.prob then
             classes[#classes + 1] = 'prob-' .. tostring(math.floor(nestedSelector.prob * 100)) .. 'p'
             classesProb = string.format(" <div>%s%%</div>", (nestedSelector.prob * 100 >= 1) and math.floor(nestedSelector.prob * 100) or nestedSelector.prob * 100)
         end
         end
     end
     end


     if wrapped and #classes > 0 then
     if wrapped and (classesRolls ~= "" or classesProb ~= "") then
         result[#result + 1] = string.format('<div class="%s">', table.concat(classes, ' '))
         result[#result + 1] = string.format('{{LinkCard/Сollapsible|название=Группа предметов%s%s|содержание=', classesRolls, classesProb)
     end
     end


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


     if wrapped and #classes > 0 then
     if wrapped and (classesRolls ~= "" or classesProb ~= "") then
         result[#result + 1] = "</div>"
         result[#result + 1] = "}}"
     end
     end


Строка 248: Строка 234:
end
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
---------------------------------------------------------------------
-- Формирование списка химии
-- Формирование списка химии
getChemOutput = function(data, id)
function getChemOutput(id)
     if chemCache[id] then return chemCache[id] end
local chemTranslateData = mw.loadData("Модуль:IanComradeBot/chem prototypes.json/data")
   
 
    local item = findDataById(data, id)
    local function loadSolutionData(solutionType)
    if not item or not item.SolutionContainerManager or not item.SolutionContainerManager.solutions then  
        local modulePath = string.format("Модуль:IanComradeBot/prototypes/fills/chem/%s.json/data", solutionType)
         chemCache[id] = ''
        return mw.loadData(modulePath)
         return ''
     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
     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 nil
    chemCache[id] = string.format('<ul class="1">%s</ul>', table.concat(result))
     return chemCache[id]
end
end


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


     if not id then return 'Не указан ID.' end
     if not id then
 
        return 'Не указан ID.'
    local data = loadData('User:IanComradeBot/prototypes/fills/Item.json')
     end
     local dataIndex = buildIndex(data)
 
    if not data then return 'Не удалось загрузить данные.' end


     if mode == 'framing' then
     if mode == 'framing' then
         local subMode = frame.args[2]
         local subMode   = frame.args[2]
         local id = frame.args[3]
         local idFraming = frame.args[3]
 
         if not idFraming then
         if not id then
             return 'Не указан ID для режима framing.'
             return 'Не указан ID для режима framing.'
         end
         end


         if subMode == 'chem' then
         if subMode == 'chem' then
             return frame:preprocess('{{СollapsibleMenu|' .. getChemOutput(dataIndex, id) .. '}}')
            local chemTranslateData = mw.loadData("Модуль:IanComradeBot/chem prototypes.json/data")
             return frame:preprocess('{{СollapsibleMenu|color=#3e7c82|' .. getChemOutput(idFraming, chemTranslateData) .. '}}')
 
         elseif subMode == 'contained' then
         elseif subMode == 'contained' then
             return frame:preprocess('{{СollapsibleMenu|' .. getContainedOutput(dataIndex, id) .. '}}')
            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
         else
             return 'Неизвестный подрежим для framing: ' .. subMode
             return 'Неизвестный подрежим для framing: ' .. subMode
         end
         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")
         if not entity then return 'ID не найден в данных.' end
         local entity = findDataById(itemData, id)
 
         if not entity then
            return 'ID не найден в данных.'
        end
         if entity.EntityTableContainerFill then
         if entity.EntityTableContainerFill then
             local containers = entity.EntityTableContainerFill.containers
             local containers = entity.EntityTableContainerFill.containers
Строка 310: Строка 394:
             end
             end
         end
         end
        return ''


        return 'Режим rolls не найден для этого ID.'
     else
     else
         return 'Неизвестный режим: ' .. mode
         return 'Неизвестный режим: ' .. mode
Источник — https://station14.ru/wiki/Модуль:Prototypes/Хранилище/Предмет