Space Station 14 Вики

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

Интерактивная навигация по истории
← Предыдущая правкаСледующая правка →
мНет описания правки
мНет описания правки
Строка 1: Строка 1:
local findDataById, formatContent, getContentsOutput, processNestedSelectors, getTableOutput, getContainedOutput, getChemOutput, handleGroupSelector, handleAllSelector, handleNestedSelector, processRolls, getStackCount
---------------------------------------------------------------------
---------------------------------------------------------------------
-- Загрузка данных
-- Предварительная загрузка данных
local itemData          = mw.loadData("Модуль:IanComradeBot/prototypes/fills/Item.json/data")
local itemData          = mw.loadData("Модуль:IanComradeBot/prototypes/fills/Item.json/data")
local itemSlotsData    = mw.loadData("Модуль:IanComradeBot/prototypes/ItemSlots.json/data")
local itemSlotsData    = mw.loadData("Модуль:IanComradeBot/prototypes/ItemSlots.json/data")
local itemStackData    = mw.loadData("Модуль:IanComradeBot/prototypes/fills/stack.json/data")
local itemStackData    = mw.loadData("Модуль:IanComradeBot/prototypes/fills/stack.json/data")
local chemTranslateData = mw.loadData("Модуль:IanComradeBot/chem prototypes.json/data")
local chemTranslateData = mw.loadData("Модуль:IanComradeBot/chem prototypes.json/data")
local tableData        = mw.loadData("Модуль:IanComradeBot/prototypes/table.json/data")


---------------------------------------------------------------------
---------------------------------------------------------------------
-- Функция поиска данных по ID
-- Функция поиска данных по ID
findDataById = function(data, id)
local function findDataById(data, id)
     if not data then  
     if not data then  
         return nil  
         return nil  
Строка 20: Строка 19:


     if type(data) == "table" then
     if type(data) == "table" then
         if #data > 0 then
         -- Если таблица массивная, то перебираем по порядку, иначе по парам
            for _, item in ipairs(data) do
        local iterFunc = (#data > 0) and ipairs or pairs
                if type(item) == "table" and item.id == id then
         for _, item in iterFunc(data) do
                    return item
            if type(item) == "table" and item.id == id then
                end
                return item
            end
         else
            for _, item in pairs(data) do
                if type(item) == "table" and item.id == id then
                    return item
                end
             end
             end
         end
         end
Строка 39: Строка 32:
---------------------------------------------------------------------
---------------------------------------------------------------------
-- Форматирование содержимого
-- Форматирование содержимого
formatContent = function(content)
local function formatContent(content)
     if type(content) == "table" and not content.id then
     if type(content) == "table" and not content.id then
         return "Ошибка: отсутствует id у элемента."
         return "Ошибка: отсутствует id у элемента."
Строка 45: Строка 38:


     local id = content.id or content
     local id = content.id or content
   
     local amountNumber = 1
     local amountNumber = 1
     if content.amount then
     if content.amount then
         if type(content.amount) == "table" then
         if type(content.amount) == "table" then
Строка 55: Строка 48:
     end
     end
     local amount = (amountNumber and amountNumber ~= 1) and string.format(" [%d]", amountNumber) or ""
     local amount = (amountNumber and amountNumber ~= 1) and string.format(" [%d]", amountNumber) or ""
   
local prob = ""
local probValue = nil
if content.prob then
    -- Если значение вероятности указано в формате десятичной дроби (например, 0.5)
    probValue = content.prob * 100  -- перевод в проценты
elseif content.weight then
    probValue = content.weight
end
if probValue then
    prob = string.format(" <div>%s%%</div>", probValue >= 1 and math.floor(probValue) or probValue)
end


     return string.format(
     local prob = ""
    -- <span></span> - костыль, без него ломается все почему-то
    local probValue = nil
        '{{#invoke:Предмет|main|%s|%s<span>%s</span>|repository=1|wrapper=1}}',
    if content.prob then
        id, amount, prob
        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
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 .. formatContent(content)
         result[#result + 1] = formatContent(content)
     end
     end
     return result
     return table.concat(result)
end
end


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


     local result = ""
     local result = {}
     for _, child in ipairs(children) do
     for _, child in ipairs(children) do
         if child.id then
         if child.id then
             if not visited[child.id] then
             if not visited[child.id] then
                 result = result .. formatContent(child)
                 result[#result + 1] = formatContent(child)
             end
             end
         elseif child["!type"] == "NestedSelector" then
         elseif child["!type"] == "NestedSelector" then
             result = result .. handleNestedSelector(child, true, visited)
             result[#result + 1] = handleNestedSelector(child, true, visited)
         elseif child["!type"] == "GroupSelector" then
         elseif child["!type"] == "GroupSelector" then
             result = result .. handleGroupSelector(child, visited)
             result[#result + 1] = handleGroupSelector(child, visited)
        elseif child["!type"] == "AllSelector" then
            result[#result + 1] = handleAllSelector(child)
         end
         end
     end
     end
 
     return table.concat(result)
     return result
end
end


---------------------------------------------------------------------
---------------------------------------------------------------------
-- Обработка таблиц
-- Получение содержимого таблицы по tableId с кешированием
getTableOutput = function(tableId, visited)
local function getTableOutput(tableId, visited)
     visited = visited or {}
     visited = visited or {}
 
     if visited[tableId] then return "" end
     if visited[tableId] then
        return ''
    end
 
     visited[tableId] = true
     visited[tableId] = true


    local tableData = mw.loadData("Модуль:IanComradeBot/prototypes/table.json/data")
     local tableDataIndex = findDataById(tableData, tableId)
     local tableDataIndex = findDataById(tableData, tableId)
     if not tableDataIndex then  
     if not tableDataIndex then  
         return 'Таблица не найдена.'  
         return 'Таблица не найдена.'  
Строка 129: Строка 111:
         return handleGroupSelector(tableDataIndex['!type:GroupSelector'], visited)
         return handleGroupSelector(tableDataIndex['!type:GroupSelector'], visited)
     elseif tableDataIndex['!type:AllSelector'] then
     elseif tableDataIndex['!type:AllSelector'] then
         return processNestedSelectors(tableDataIndex['!type:AllSelector'].children, visited)
         return processChildren(tableDataIndex['!type:AllSelector'].children, visited)
     end
     end


Строка 136: Строка 118:


---------------------------------------------------------------------
---------------------------------------------------------------------
-- Формирование списка содержащихся предметов или таблиц
-- Универсальная функция обработки детей контейнеров
getContainedOutput = function(itemData, id, visited)
local function processContainerChildren(children, visited)
     visited = visited or {}  
     local result = {}
 
    if children then
    if visited[id] then
        for _, child in ipairs(children) do
         return ''
            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)
end


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


     local item = findDataById(itemData, id)
     local item = findDataById(itemData, id)
     if not item then  
     if not item then  
         return ''
         return ""
     end
     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)
                for _, child in ipairs(containers.entity_storage.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] = processNestedSelectors(child.children, visited)
                    end
                end
            end
 
             if containers.entity_storage.tableId then
             if containers.entity_storage.tableId then
                 result[#result + 1] = getTableOutput(containers.entity_storage.tableId, visited)
                 result[#result + 1] = getTableOutput(containers.entity_storage.tableId, visited)
             end
             end
         end
         end
        -- Обработка storagebase (аналогично entity_storage)
         if containers.storagebase then
         if containers.storagebase then
             if containers.storagebase.children then
             result[#result + 1] = processContainerChildren(containers.storagebase.children, visited)
                for _, child in ipairs(containers.storagebase.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] = processNestedSelectors(child.children, visited)
                    end
                end
            end
 
             if containers.storagebase.tableId then
             if containers.storagebase.tableId then
                 result[#result + 1] = getTableOutput(containers.storagebase.tableId, visited)
                 result[#result + 1] = getTableOutput(containers.storagebase.tableId, visited)
Строка 199: Строка 166:
         end
         end
     end
     end
     return table.concat(result)
     return table.concat(result)
end
end
Строка 205: Строка 171:
---------------------------------------------------------------------
---------------------------------------------------------------------
-- Обработка 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, visited)
function handleGroupSelector(groupSelector, visited)
     if not groupSelector.children then return '' end
    visited = visited or {}
     local result = ""
     if not groupSelector.children then return "" end
 
     local result = {}
     local wrapperStart, wrapperEnd = "", ""
     local wrapperStart, wrapperEnd = "", ""
     if groupSelector.weight and groupSelector.weight ~= "default" then
     if groupSelector.weight and groupSelector.weight ~= "default" then
         wrapperStart = string.format('{{LinkСard/Сollapsible|name=Группа предметов %s%%|content=', groupSelector.weight)
         wrapperStart = string.format('{{LinkСard/Сollapsible|name=Группа предметов %s%%|content=', groupSelector.weight)
Строка 227: Строка 194:
     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 .. handleGroupSelector(child, visited)
             result[#result + 1] = handleGroupSelector(child, visited)
         elseif child["!type"] == "AllSelector" then
         elseif child["!type"] == "AllSelector" then
             result = result .. string.format('{{LinkСard/Сollapsible|name=Выпадают только вместе:|content=%s}}', handleAllSelector(child))
             result[#result + 1] = string.format('{{LinkСard/Сollapsible|name=Выпадают только вместе:|content=%s}}', handleAllSelector(child))
         elseif child.id then
         elseif child.id then
             result = result .. formatContent(child)
             result[#result + 1] = formatContent(child)
         else
         else
             result = result .. "<div>Ошибка: отсутствует id у элемента.</div>"
             result[#result + 1] = "<div>Ошибка: отсутствует id у элемента.</div>"
         end
         end
     end
     end


     return wrapperStart .. result .. wrapperEnd
     return wrapperStart .. table.concat(result) .. wrapperEnd
end
end


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


    local result = {}
    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
Строка 257: Строка 223:
         end
         end
         if nestedSelector.prob then
         if nestedSelector.prob then
             classesProb = string.format(" <div>%s%%</div>", nestedSelector.prob * 100 >= 1 and math.floor(nestedSelector.prob * 100) or nestedSelector.prob * 100)
             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 (classesRolls or classesProb) then
     if wrapped and (classesRolls ~= "" or classesProb ~= "") then
         result = result .. string.format('{{LinkСard/Сollapsible|name=Группа предметов%s%s|content=', classesRolls or "", classesProb or "")
         result[#result + 1] = string.format('{{LinkСard/Сollapsible|name=Группа предметов%s%s|content=', classesRolls, classesProb)
     end
     end


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


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


     return result
     return table.concat(result)
end
end


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


---------------------------------------------------------------------
---------------------------------------------------------------------
-- Формирование списка химии
-- Формирование списка химии
getChemOutput = function(id)
function getChemOutput(id)
     local function loadSolutionData(solutionType)
     local function loadSolutionData(solutionType)
         local modulePath = string.format("Модуль:IanComradeBot/prototypes/fills/chem/%s.json/data", solutionType)
         local modulePath = string.format("Модуль:IanComradeBot/prototypes/fills/chem/%s.json/data", solutionType)
Строка 304: Строка 268:
     local function processSolution(solutionType)
     local function processSolution(solutionType)
         local solutionModule = loadSolutionData(solutionType)
         local solutionModule = loadSolutionData(solutionType)
         if not solutionModule then
         if not solutionModule then return "" end
            return ""
        end


         local item = findDataById(solutionModule, id)
         local item = findDataById(solutionModule, id)
         if not item then  
         if not item then return "" end
            return ""
        end


         local solutionData = item[solutionType] or item
         local solutionData = item[solutionType] or item
         if not solutionData or not solutionData.reagents then
         if not solutionData or not solutionData.reagents then return "" end
            return ""
        end


         local output = ""
         local output = {}
         for _, reagent in ipairs(solutionData.reagents) do
         for _, reagent in ipairs(solutionData.reagents) do
             local chemInfo = chemTranslateData[reagent.ReagentId]
             local chemInfo = chemTranslateData[reagent.ReagentId]
             local displayName = chemInfo and chemInfo.name or reagent.ReagentId
             local displayName = chemInfo and chemInfo.name or reagent.ReagentId
             output = output .. string.format(
             output[#output + 1] = string.format('<li>[[Химия#chem_%s|%s]] (%d ед.)</li>', reagent.ReagentId, displayName, reagent.Quantity)
                '<li>[[Химия#chem_%s|%s]] (%d ед.)</li>',
                reagent.ReagentId, displayName, reagent.Quantity
            )
         end
         end
         return output
         return table.concat(output)
     end
     end


     local result = ""
     local result = {}
     local solutionTypes = {"drink", "beaker", "injector", "pen"}
     local solutionTypes = {"drink", "beaker", "injector", "pen"}
     for _, solutionType in ipairs(solutionTypes) do
     for _, solutionType in ipairs(solutionTypes) do
         result = result .. processSolution(solutionType)
         result[#result + 1] = processSolution(solutionType)
     end
     end
 
    local combined = table.concat(result)
     return result ~= "" and string.format('<ul><b>%s</b></ul>', result) or ''
     return (combined ~= "") and string.format('<ul><b>%s</b></ul>', combined) or ""
end
end


---------------------------------------------------------------------
---------------------------------------------------------------------
-- Функция поиска count в itemStackData
-- Функция для получения count из itemStackData
getStackCount = function(id)
function getStackCount(id)
     local item = findDataById(itemStackData, id)
     local item = findDataById(itemStackData, id)
     if item and item.Stack and item.Stack.count then
     if item and item.Stack and item.Stack.count then
Строка 349: Строка 304:
end
end


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


Строка 360: Строка 316:
         return 'Не указан ID.'  
         return 'Не указан ID.'  
     end
     end
   
 
    local itemDataIndex = itemData
   
     if not itemData then  
     if not itemData then  
         return 'Не удалось загрузить данные.'  
         return 'Не удалось загрузить данные.'  
Строка 369: Строка 323:
     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|color=#3e7c82|' .. getChemOutput(id) .. '}}')
             return frame:preprocess('{{СollapsibleMenu|color=#3e7c82|' .. getChemOutput(idFraming) .. '}}')
         elseif subMode == 'contained' then
         elseif subMode == 'contained' then
             return frame:preprocess('{{СollapsibleMenu|' .. getContainedOutput(itemDataIndex, id) .. '}}')
             return frame:preprocess('{{СollapsibleMenu|' .. getContainedOutput(itemData, idFraming) .. '}}')
         elseif subMode == "slot" then
         elseif subMode == "slot" then
local itemDataEntry = findDataById(itemSlotsData, id)
            local itemDataEntry = findDataById(itemSlotsData, idFraming)
if not itemDataEntry then return "" end
            if not itemDataEntry then return "" end
local startingItem = nil
            local startingItem = nil
if itemDataEntry.ItemSlots and itemDataEntry.ItemSlots.slots then
            if itemDataEntry.ItemSlots and itemDataEntry.ItemSlots.slots then
    for _, slot in pairs(itemDataEntry.ItemSlots.slots) do
                for _, slot in ipairs(itemDataEntry.ItemSlots.slots) do
        if slot.startingItem and slot.startingItem ~= "" then
                    if slot.startingItem and slot.startingItem ~= "" then
            startingItem = slot.startingItem
                        startingItem = slot.startingItem
            break
                        break
        end
                    end
    end
                end
end
            end
if not startingItem then return "" end
            if not startingItem then return "" end
return frame:preprocess('{{СollapsibleMenu|color=#71702a|' .. formatContent(startingItem) .. '}}')
            return frame:preprocess('{{СollapsibleMenu|color=#71702a|' .. formatContent(startingItem) .. '}}')
         elseif subMode == "stack" then
         elseif subMode == "stack" then
             local count = getStackCount(id)
             local count = getStackCount(idFraming)
             return count and '(' .. count .. ')' or ""
             return count and '(' .. count .. ')' or ""
         else
         else
Строка 405: Строка 357:
         return getChemOutput(id)
         return getChemOutput(id)
     elseif mode == 'contained' then
     elseif mode == 'contained' then
         return frame:preprocess(getContainedOutput(itemDataIndex, id))
         return frame:preprocess(getContainedOutput(itemData, id))
     elseif mode == "slot" then
     elseif mode == "slot" then
         local itemDataEntry = findDataById(itemSlotsData, id)
         local itemDataEntry = findDataById(itemSlotsData, id)
Строка 421: Строка 373:
         return frame:preprocess(formatContent(startingItem))
         return frame:preprocess(formatContent(startingItem))
     elseif mode == 'rolls' then
     elseif mode == 'rolls' then
         local entity = findDataById(itemDataIndex, id)
         local entity = findDataById(itemData, id)
         if not entity then  
         if not entity then  
             return 'ID не найден в данных.'  
             return 'ID не найден в данных.'  
Источник — https://station14.ru/wiki/Модуль:Prototypes/Хранилище/Предмет