|
|
Строка 1: |
Строка 1: |
| local prototypes = mw.loadData("Module:Chemistry Lookup/data") | | local chem = "User:FireBot/chem_prototypes.json" |
| | local react = "User:FireBot/react_prototypes.json" |
| | local status = "User:FireBot/chem_status.json" |
| | local flavors = "User:FireBot/flavors.json" |
|
| |
|
| local p = {} | | -- Загружаем данные из JSON файлов |
| p.chem = prototypes.chem or {}
| | local chemData = mw.text.jsonDecode(mw.title.new(chem, "User"):getContent()) |
| p.react = prototypes.react or {}
| | local reactData = mw.text.jsonDecode(mw.title.new(react, "User"):getContent()) |
| p.status = prototypes.status or {}
| | local statusData = mw.text.jsonDecode(mw.title.new(status, "User"):getContent()) |
| p.groupDirection = prototypes.groupDirection or {}
| | local flavorData = mw.text.jsonDecode(mw.title.new(flavors, "User"):getContent()) |
|
| |
|
| -- ===== Хелперы ===== | | -- Функция для поиска рецептов химиката |
| local function tablelength(T) | | local function findRecipesForChem(chemName) |
| local count = 0 | | local recipes = {} |
| for _ in pairs(T or {}) do count = count + 1 end
| | for reactionId, reactionData in pairs(reactData) do |
| return count
| | if reactionData.products and reactionData.products[chemName] then |
| end
| | table.insert(recipes, reactionId) |
| | |
| local function hchangelist(l, frame)
| |
| local out = ""
| |
| local len = tablelength(l)
| |
| local i = 0
| |
| for k, v in pairs(l) do | |
| i = i + 1
| |
| if len == i and i ~= 1 then | |
| out = out .. ", and "
| |
| elseif i ~= 1 then
| |
| out = out .. ", "
| |
| end
| |
| out = out .. frame:expandTemplate{ title = "HealthModifier", args = { adj = v, kind = k } }
| |
| end
| |
| return out
| |
| end
| |
| | |
| function p.readscalar(frame)
| |
| local a, b = frame.args[1], frame.args[2]
| |
| if not (a and b) or not p.chem[a] then return "" end
| |
| local v = p.chem[a][b]
| |
| if v == nil then return "" end
| |
| return mw.text.nowiki(tostring(v))
| |
| end
| |
| | |
| function p.readscalarreact(frame)
| |
| local a, b = frame.args[1], frame.args[2]
| |
| if not (a and b) or not p.react[a] then return "" end
| |
| local v = p.react[a][b]
| |
| if v == nil then return "" end
| |
| return mw.text.nowiki(tostring(v))
| |
| end
| |
| | |
| function p.getcolor(frame)
| |
| local a = frame.args[1]
| |
| if not a or not p.chem[a] or not p.chem[a].color then return "" end
| |
| return mw.text.nowiki(p.chem[a].color:sub(1, 7))
| |
| end
| |
| | |
| function p.gettextcolor(frame)
| |
| local a = frame.args[1]
| |
| if not a or not p.chem[a] or not p.chem[a].color then return mw.text.nowiki("#000") end
| |
| local basecol = p.chem[a].color
| |
| local red = tonumber(basecol:sub(2, 3), 16) or 0
| |
| local grn = tonumber(basecol:sub(4, 5), 16) or 0
| |
| local blu = tonumber(basecol:sub(6, 7), 16) or 0
| |
| local luminance = math.sqrt(0.241*red*red + 0.691*grn*grn + 0.068*blu*blu)
| |
| if luminance > 100 then
| |
| return mw.text.nowiki("#000")
| |
| else
| |
| return mw.text.nowiki("#FFF")
| |
| end
| |
| end
| |
| | |
| function p.hasrecipe(frame)
| |
| local chem = frame.args[1]
| |
| if not chem or not p.chem[chem] then return "" end
| |
| return (p.chem[chem].recipes and p.chem[chem].recipes[1]) and "true" or ""
| |
| end
| |
| | |
| function p.buildboxes(frame)
| |
| local out = ""
| |
| local group = frame.args[1]
| |
| for k, v in pairs(p.chem) do
| |
| if type(v) == "table" then
| |
| if (group == nil) or (v.group == group) then
| |
| out = out .. frame:expandTemplate{ title = "Chembox", args = { prototype = k }}
| |
| end | |
| end
| |
| end
| |
| return out
| |
| end
| |
| | |
| function p.buildreactboxes(frame)
| |
| local out = ""
| |
| for k, v in pairs(p.react) do
| |
| if type(v) == "table" and v.effects and tablelength(v.effects) ~= 0 then
| |
| out = out .. frame:expandTemplate{ title = "Reactionbox", args = { reaction = k }}
| |
| end
| |
| end
| |
| return out
| |
| end
| |
| | |
| function p.buildrecipes(frame)
| |
| local chem = frame.args[1]
| |
| if not chem or not p.chem[chem] then return "" end
| |
| local out = ""
| |
| for _, recipe in pairs(p.chem[chem].recipes or {}) do
| |
| out = out .. p.buildreaction(frame, recipe)
| |
| end
| |
| return out
| |
| end
| |
| | |
| -- Версия для консоли отладки без frame
| |
| function p.buildrecipes_debug(chem)
| |
| if not chem or not p.chem[chem] then return "Химикат не найден" end
| |
| local out = "=== Рецепты для " .. chem .. " ===\n"
| |
| for i, recipe in ipairs(p.chem[chem].recipes or {}) do
| |
| out = out .. "Рецепт " .. i .. ": " .. recipe .. "\n"
| |
| if p.react[recipe] then
| |
| local data = p.react[recipe]
| |
| out = out .. " Реактанты:\n"
| |
| for k, v in pairs(data.reactants or {}) do
| |
| out = out .. " - " .. k .. ": " .. (v.amount or "?") .. "\n"
| |
| end
| |
| out = out .. " Продукты:\n"
| |
| for k, v in pairs(data.products or {}) do
| |
| out = out .. " - " .. k .. ": " .. tostring(v) .. "\n"
| |
| end
| |
| end
| |
| out = out .. "\n"
| |
| end
| |
| return out
| |
| end
| |
| | |
| function p.buildreactionext(frame)
| |
| local react = frame.args[1]
| |
| return p.buildreaction(frame, react)
| |
| end
| |
| | |
| function p.buildreaction(frame, react)
| |
| if not react or not p.react[react] then return "" end
| |
|
| |
| -- Проверка для консоли отладки
| |
| if not frame or not frame.expandTemplate then
| |
| return "Рецепт: " .. react .. " (для полного отображения используйте в MediaWiki)"
| |
| end
| |
|
| |
| local data = p.react[react]
| |
| local args = {}
| |
| | |
| -- Реактанты
| |
| local i = 0
| |
| for k, v in pairs(data.reactants or {}) do
| |
| i = i + 1
| |
| local dest = p.groupDirection[(p.chem[k] or {}).group] or "Chemistry"
| |
| args["component-" .. i] = frame:expandTemplate{
| |
| title = "Chem Recipe Component",
| |
| args = { reagent = k, amount = v.amount, dest = dest }
| |
| }
| |
| end
| |
| | |
| -- Продукты
| |
| i = 0
| |
| for k, v in pairs(data.products or {}) do
| |
| i = i + 1
| |
| local dest = p.groupDirection[(p.chem[k] or {}).group] or "Chemistry"
| |
| args["result-" .. i] = frame:expandTemplate{
| |
| title = "Chem Recipe Component",
| |
| args = { reagent = k, amount = v, dest = dest }
| |
| }
| |
| end
| |
| | |
| -- Эффекты реакции (не метаболизм)
| |
| if data.effects ~= nil then
| |
| args.effects = p.geneffectlist(data.effects, frame, 1)
| |
| end
| |
| | |
| return frame:expandTemplate{ title = "Chem Box Recipe", args = args }
| |
| end
| |
| | |
| local function scan_metab(chem)
| |
| local met = (p.chem[chem] or {}).metabolisms
| |
| if not met then return nil end
| |
| return met
| |
| end
| |
| | |
| function p.checksatiatesthirst(frame)
| |
| local chem = frame.args[1]
| |
| local met = scan_metab(chem)
| |
| if not met then return "" end
| |
| for _, v in pairs(met) do
| |
| for _, w in pairs(v.effects or {}) do
| |
| -- Исправляем проверку для JSON структуры
| |
| local effectName = (type(w.type) == "table" and w.type.name) or w.type or ""
| |
| if effectName == "SatiateThirst" then return "1" end
| |
| end | | end |
| end | | end |
| return "" | | return recipes |
| end | | end |
|
| |
|
| function p.checksatiateshunger(frame)
| | -- Обрабатываем данные химикатов |
| local chem = frame.args[1]
| | local processedChem = {} |
| local met = scan_metab(chem)
| | for chemId, chemInfo in pairs(chemData) do |
| if not met then return "" end
| | if type(chemInfo) == "table" and chemInfo.type == "reagent" then |
| for _, v in pairs(met) do
| | -- Копируем все данные химиката |
| for _, w in pairs(v.effects or {}) do
| | processedChem[chemId] = {} |
| -- Исправляем проверку для JSON структуры
| | for k, v in pairs(chemInfo) do |
| local effectName = (type(w.type) == "table" and w.type.name) or w.type or ""
| | processedChem[chemId][k] = v |
| if effectName == "SatiateHunger" then return "1" end | |
| end | | end |
| end
| |
| return ""
| |
| end
| |
|
| |
| function p.haseffects(frame)
| |
| local chem = frame.args[1]
| |
| local met = scan_metab(chem)
| |
| if not met then return "" end
| |
| for _, v in pairs(met) do
| |
| for _, w in pairs(v.effects or {}) do
| |
| -- Исправляем проверку для JSON структуры
| |
| local effectName = (type(w.type) == "table" and w.type.name) or w.type or ""
| |
| if effectName ~= "SatiateHunger" and effectName ~= "SatiateThirst" then
| |
| return "1"
| |
| end
| |
| end
| |
| end
| |
| return ""
| |
| end
| |
|
| |
| function p.geneffects(frame, chem)
| |
| if chem == nil then chem = frame.args[1] end
| |
| local met = scan_metab(chem)
| |
| if not met then return "" end
| |
| local out = ""
| |
| for k, v in pairs(met) do
| |
| -- Исправляем вывод rate - теперь используем правильное поле
| |
| local rate = v.rate or 1.0
| |
| | | |
| -- Получаем локализованное название группы метаболизма | | -- Исправляем структуру метаболизма - заменяем metabolismRate на rate |
| local groupName = k
| | if chemInfo.metabolisms then |
| if p.status and p.status[k] and p.status[k].name then | | processedChem[chemId].metabolisms = {} |
| groupName = p.status[k].name | | for metabType, metabData in pairs(chemInfo.metabolisms) do |
| end
| | processedChem[chemId].metabolisms[metabType] = {} |
|
| | |
| out = out .. "<b>" .. groupName .. "</b>\n"
| | -- Копируем все данные метаболизма |
|
| | for k, v in pairs(metabData) do |
| -- Генерируем эффекты для этой группы
| | if k == "metabolismRate" then |
| local effectsText = p.geneffectlist(v.effects or {}, frame, rate)
| | -- Переименовываем metabolismRate в rate |
| out = out .. effectsText
| | processedChem[chemId].metabolisms[metabType].rate = v |
| out = out .. "\n"
| | else |
| end
| | processedChem[chemId].metabolisms[metabType][k] = v |
| return out
| | end |
| end
| | end |
| | | |
| function p.geneffectlist(effects, frame, rate)
| | -- Если rate не был задан, устанавливаем значение по умолчанию |
| local out = ""
| | if not processedChem[chemId].metabolisms[metabType].rate then |
| for _, w in pairs(effects or {}) do
| | processedChem[chemId].metabolisms[metabType].rate = 1.0 |
| -- Исправляем получение ID эффекта для JSON структуры
| | end |
| local effectId = (type(w.type) == "table" and w.type.name) or w.type or w.id or ""
| |
|
| |
| -- Обрабатываем условия для всех эффектов
| |
| local conditionsText = ""
| |
| if w.conditions and #w.conditions > 0 then
| |
| conditionsText = " если " .. p.genconds(w.conditions, frame or {})
| |
| end
| |
|
| |
| -- Применяем factor ко всем эффектам
| |
| local factor = w.factor or 1
| |
| local effectText = ""
| |
|
| |
| if effectId == "SatiateThirst" then
| |
| local text = (type(w.type) == "table" and w.type.text) or "Утоляет жажду"
| |
| if factor ~= 1 then
| |
| effectText = text .. " на " .. tostring(factor) .. "x от обычного"
| |
| else
| |
| effectText = text | |
| end | | end |
| elseif effectId == "SatiateHunger" then
| |
| local text = (type(w.type) == "table" and w.type.text) or "Утоляет голод"
| |
| if factor ~= 1 then
| |
| effectText = text .. " на " .. tostring(factor) .. "x от обычного"
| |
| else
| |
| effectText = text
| |
| end
| |
| elseif effectId == "HealthChange" then
| |
| effectText = p.genhealthchange_simple(w, rate, factor)
| |
| elseif effectId == "AdjustReagent" then
| |
| effectText = p.genadjustreagent_simple(w, rate, factor)
| |
| -- Добавьте другие типы эффектов по необходимости
| |
| end | | end |
| | | |
| if effectText ~= "" then | | -- Добавляем рецепты |
| out = out .. effectText .. conditionsText .. "\n" | | local recipes = findRecipesForChem(chemId) |
| | if #recipes > 0 then |
| | processedChem[chemId].recipes = recipes |
| end | | end |
| end | | end |
| return out
| |
| end | | end |
|
| |
|
| -- Упрощенная функция для HealthChange без условий (условия обрабатываются отдельно)
| | return { |
| function p.genhealthchange_simple(h, rate, factor)
| | chem = processedChem, |
| local out = ""
| | react = reactData, |
| factor = factor or 1
| | status = statusData, |
|
| | flavors = flavorData, |
| if h.damage and h.damage.types then
| | groupDirection = { |
| for damageType, amount in pairs(h.damage.types) do
| | Drinks = "Drinks"; |
| local finalAmount = amount * factor
| | Foods = "Cooking"; |
| if finalAmount > 0 then
| |
| out = out .. "Наносит " .. tostring(finalAmount) .. " ед. " .. damageType .. "\n"
| |
| else
| |
| out = out .. "Лечит " .. tostring(-finalAmount) .. " ед. " .. damageType .. "\n"
| |
| end
| |
| end
| |
| end
| |
|
| |
| if h.damage and h.damage.groups then
| |
| for damageGroup, amount in pairs(h.damage.groups) do
| |
| local finalAmount = amount * factor
| |
| if finalAmount > 0 then
| |
| out = out .. "Наносит " .. tostring(finalAmount) .. " ед. " .. damageGroup .. "\n"
| |
| else
| |
| out = out .. "Лечит " .. tostring(-finalAmount) .. " ед. " .. damageGroup .. "\n"
| |
| end
| |
| end
| |
| end
| |
|
| |
| return out:gsub("\n$", "") -- убираем последний перенос строки
| |
| end
| |
| | |
| -- Упрощенная функция для AdjustReagent без условий
| |
| function p.genadjustreagent_simple(r, rate, factor)
| |
| factor = factor or 1
| |
| local amount = (r.amount or r.Amount or 0) * factor | |
| local reagent = r.reagent or r.Reagent or "неизвестный реагент"
| |
|
| |
| if amount > 0 then
| |
| return "Добавляет " .. tostring(amount) .. " ед. " .. reagent
| |
| else
| |
| return "Удаляет " .. tostring(-amount) .. " ед. " .. reagent
| |
| end
| |
| end
| |
| | |
| function p.gensmokeareareactioneffect(r, frame)
| |
| local conds = nil
| |
| if r.conditions ~= nil then | |
| conds = p.genconds(r.conditions, frame)
| |
| end
| |
| return frame:expandTemplate{ title = "SmokeAreaReactionEffect", args = { when = conds, prob = r.probability }} | |
| end
| |
| | |
| function p.genfoamareareactioneffect(r, frame)
| |
| local conds = nil
| |
| if r.conditions ~= nil then | |
| conds = p.genconds(r.conditions, frame)
| |
| end
| |
| return frame:expandTemplate{ title = "FoamAreaReactionEffect", args = { when = conds, prob = r.probability }} | |
| end
| |
| | |
| function p.genexplosionreactioneffect(r, frame)
| |
| local conds = nil
| |
| if r.conditions ~= nil then
| |
| conds = p.genconds(r.conditions, frame) | |
| end
| |
| return frame:expandTemplate{ title = "ExplosionReactionEffect", args = { when = conds, prob = r.probability }}
| |
| end
| |
| | |
| function p.gengenericstatuseffect(r, frame)
| |
| local conds = nil
| |
| if r.conditions ~= nil then
| |
| conds = p.genconds(r.conditions, frame)
| |
| end
| |
| return frame:expandTemplate{
| |
| title = "GenericStatusEffect", | |
| args = { key = r.Key or r.key, type = r.Type, time = r.Time or r.time, refresh = r.Refresh, when = conds, prob = r.probability }
| |
| } | | } |
| end
| | } |
| | |
| function p.genadjusttemperature(r, frame)
| |
| local conds = nil
| |
| if r.conditions ~= nil then
| |
| conds = p.genconds(r.conditions, frame)
| |
| end
| |
| return frame:expandTemplate{ title = "AdjustTemperature", args = { amount = r.Amount or r.amount, when = conds, prob = r.probability }}
| |
| end
| |
| | |
| function p.genflammablereaction(r, frame)
| |
| local conds = nil
| |
| if r.conditions ~= nil then
| |
| conds = p.genconds(r.conditions, frame)
| |
| end
| |
| return frame:expandTemplate{ title = "FlammableReaction", args = { multiplier = r.Multiplier, when = conds, prob = r.probability }}
| |
| end
| |
| | |
| function p.genadjustreagent(r, rate, frame)
| |
| local conds = nil
| |
| if r.conditions ~= nil then
| |
| conds = p.genconds(r.conditions, frame)
| |
| end
| |
| return frame:expandTemplate{ title = "AdjustReagent", args = { amount = r.Amount or r.amount, reagent = r.Reagent or r.reagent, when = conds, prob = r.probability }}
| |
| end
| |
| | |
| function p.genmodifybleedamount(r, frame)
| |
| local conds = nil
| |
| if r.conditions ~= nil then
| |
| conds = p.genconds(r.conditions, frame)
| |
| end
| |
| return frame:expandTemplate{ title = "ModifyBleedAmount", args = { amount = r.Amount or r.amount, when = conds, prob = r.probability }}
| |
| end
| |
| | |
| function p.genhealthchange(h, rate, frame)
| |
| local healst = {}
| |
| local dealst = {}
| |
| local r = 1.0 / (rate or 1)
| |
| | |
| if h.damage and h.damage.types then
| |
| for k, v in pairs(h.damage.types) do
| |
| if v < 0 then healst[k] = v * r else dealst[k] = v * r end
| |
| end
| |
| end
| |
| if h.damage and h.damage.groups then
| |
| for k, v in pairs(h.damage.groups) do
| |
| if v < 0 then healst[k] = v * r else dealst[k] = v * r end
| |
| end
| |
| end
| |
| | |
| local heals = hchangelist(healst, frame)
| |
| local deals = hchangelist(dealst, frame)
| |
| local conds = nil
| |
| if h.conditions ~= nil then
| |
| conds = p.genconds(h.conditions, frame)
| |
| end
| |
| return frame:expandTemplate{ title = "HealthChange", args = { heals = heals, deals = deals, when = conds, prob = h.probability }}
| |
| end
| |
| | |
| function p.genconds(conds, frame)
| |
| local out = ""
| |
| local len = tablelength(conds or {})
| |
| local i = 0
| |
| for _, c in pairs(conds or {}) do
| |
| i = i + 1
| |
| if len == i and i ~= 1 then
| |
| out = out .. ", and "
| |
| elseif i ~= 1 then
| |
| out = out .. ", "
| |
| end
| |
| out = out .. p.gencond(c, frame)
| |
| end
| |
| return out
| |
| end
| |
| | |
| function p.gencond(c, frame)
| |
| if not c or not c.type then return "" end
| |
| if c.type == "TotalDamage" then
| |
| -- Если нет frame, формируем текст напрямую
| |
| if not frame or not frame.expandTemplate then
| |
| local min = c.Min or c.min or "?"
| |
| local max = c.Max or c.max or "?"
| |
| return "общий урон между " .. tostring(min) .. " и " .. tostring(max)
| |
| end
| |
| return frame:expandTemplate{ title = "TotalDamage", args = { min = c.Min or c.min, max = c.Max or c.max } }
| |
| elseif c.type == "ReagentThreshold" then
| |
| -- Если нет frame, формируем текст напрямую
| |
| if not frame or not frame.expandTemplate then
| |
| local min = c.Min or c.min or 0
| |
| local max = c.Max or c.max or "∞"
| |
| local reagent = c.Reagent or c.reagent or "неизвестный реагент"
| |
| return reagent .. " между " .. tostring(min) .. " и " .. tostring(max) .. " единиц"
| |
| end
| |
| return frame:expandTemplate{ title = "ReagentThreshold", args = { min = c.Min or c.min, max = c.Max or c.max, reagent = c.Reagent or c.reagent } }
| |
| elseif c.type == "Temperature" then
| |
| -- Если нет frame, формируем текст напрямую
| |
| if not frame or not frame.expandTemplate then
| |
| local min = c.Min or c.min or "?"
| |
| local max = c.Max or c.max or "?"
| |
| return "температура между " .. tostring(min) .. " и " .. tostring(max)
| |
| end
| |
| return frame:expandTemplate{ title = "Temperature", args = { min = c.Min or c.min, max = c.Max or c.max } }
| |
| else
| |
| -- Новая логика: если type не является стандартным условием, то это тип органа
| |
| local organTypeName = c.type
| |
| local shouldHave = c.shouldHave
| |
| if shouldHave == nil then shouldHave = true end
| |
|
| |
| -- Получаем локализованное название типа органа из status данных
| |
| if p.status and p.status[organTypeName] and p.status[organTypeName].name then
| |
| organTypeName = p.status[organTypeName].name
| |
| end
| |
|
| |
| -- Формируем текст условия напрямую
| |
| if shouldHave then
| |
| return "метаболизирующий орган это " .. organTypeName .. " орган"
| |
| else
| |
| return "метаболизирующий орган не " .. organTypeName .. " орган"
| |
| end
| |
| end
| |
| return ""
| |
| end
| |
| | |
| -- Отладочная функция для проверки рецептов
| |
| function p.debugrecipes(frame)
| |
| local chem = frame.args[1]
| |
| if not chem then return "Не указан химикат" end
| |
|
| |
| local out = "=== Отладка рецептов для " .. chem .. " ===\n"
| |
|
| |
| -- Проверяем существует ли химикат
| |
| if not p.chem[chem] then
| |
| out = out .. "ОШИБКА: Химикат не найден в базе данных\n"
| |
| return out
| |
| end
| |
|
| |
| -- Проверяем есть ли рецепты
| |
| local recipes = p.chem[chem].recipes
| |
| if not recipes then
| |
| out = out .. "Рецепты не найдены (recipes = nil)\n"
| |
| -- Попробуем найти рецепты вручную
| |
| out = out .. "Поиск рецептов в реакциях:\n"
| |
| for reactId, reactData in pairs(p.react) do
| |
| if reactData.products and reactData.products[chem] then
| |
| out = out .. "- Найдена реакция: " .. reactId .. " (производит " .. tostring(reactData.products[chem]) .. ")\n"
| |
| end
| |
| end
| |
| else
| |
| -- Подсчитываем рецепты правильно
| |
| local recipeCount = 0
| |
| for _ in pairs(recipes) do
| |
| recipeCount = recipeCount + 1
| |
| end
| |
| out = out .. "Найдено рецептов: " .. recipeCount .. "\n"
| |
|
| |
| for i, recipe in ipairs(recipes) do
| |
| out = out .. "- Рецепт " .. i .. ": " .. recipe .. "\n"
| |
| if p.react[recipe] then
| |
| out = out .. " Реакция существует: да\n"
| |
| if p.react[recipe].products and p.react[recipe].products[chem] then
| |
| out = out .. " Производит " .. chem .. ": " .. tostring(p.react[recipe].products[chem]) .. "\n"
| |
| else
| |
| out = out .. " ОШИБКА: Не производит " .. chem .. "\n"
| |
| end
| |
| else
| |
| out = out .. " ОШИБКА: Реакция не существует\n"
| |
| end
| |
| end
| |
| end
| |
|
| |
| return out
| |
| end
| |
| | |
| return p
| |