View difference between Paste ID: v6vzj1Ez and GxgdUYWf

 local event = require("event")
 local term = require("term")
 local os = require("os")
 local computer = require("computer")
 local com = require("component")
 local unicode = require("unicode")
 local keyb = require("keyboard")
 local gpu = com.gpu
 
 local reactorsFile = "/home/reactors.txt"
 local cfgName = "/home/DracReactorConfig.cfg"
 local MAX_REACTORS = 5
 local CHARGE_FLOW = 535000
-local CHARGE_DURATION = 12 -- seconds to keep the charge override active
+local CHARGE_DURATION = 12
 local autostateByAdr = {}
 local flowInitByAdr = {}
 local chargeRequestByAdr = {}
 
 local DEFAULT_CONFIG = [[
 -- Интервалы для кнопок +/-
 default_interval = 1000
 ctrl_interval = 5000
 shift_interval = 10000
 ctrlShift_interval = 20000
 -- Автономный режим:
 -- Основные константы
 shield = 25 - Щиты будут автоматически поддерживаться на этом уровне ( в %)
 tempCriticalEdge = 8100 -- Если температура превысит это значение, программа экстренно понизит поток вывода;
 -- Форсированный режим
 forceModeTempLowEdge = 7500 -- Пока температура не превысит это значение, программа будет работать в форсированном режиме, иначе - перейдет в безопасный режим;
 forceModeStepCase = 5000  -- Если разница между текущей выработкой энергии и выставленным потоком превысит это значение, то к потоку добавится
 forceModeStep = 20000 -- это значение
 -- безопасный режим
 safeModeTempWaitEdge = 8000 -- Если температура превысит это значение, программа будет ожидать,
 safeModeTempToWaitEdge = 7850 -- пока температура не понизится до этого значения;
 safeModeStepCase = 0 -- Если разница между текущей выработкой энергии и выставленным потоком превысит это значение, то к потоку добавится
 safemodeStep = 8000 -- это значение
 autoProtectTempEdge = 8300 -- При достижении этой температуры включается автономный режим
 screen_w = 80 -- Ширина экрана
 screen_h = 25 -- Высота экрана
 fuelStopPct = 98 -- % топлива, при котором реактор выключается]]
 
-local n = ""
+
-for i=1,#str do
+    local n = ""
-local ch = str:byte(i,i)
+    for i = 1, #str do
-if ch >= 48 and ch <= 57 or ch == 46 then
+        local ch = str:byte(i, i)
-n = n..string.char(ch)
+        if ch >= 48 and ch <= 57 or ch == 46 then
             n = n .. string.char(ch)
         end
-if n ~= "" then
+    end
-return tonumber(n)
+    if n ~= "" then
-else return n
+        return tonumber(n)
     else
         return n
     end
 end
-local confnames =
+
-{
+
-[1] = "default_interval",
+local confnames = {
-[2] = "ctrl_interval",
+    [1]  = "default_interval",
-[3] = "shift_interval",
+    [2]  = "ctrl_interval",
-[4] = "ctrlShift_interval",
+    [3]  = "shift_interval",
-[5] = "shield",
+    [4]  = "ctrlShift_interval",
-[6] = "tempCriticalEdge",
+    [5]  = "shield",
-[7] = "forceModeTempLowEdge",
+    [6]  = "tempCriticalEdge",
-[8] = "forceModeStepCase",
+    [7]  = "forceModeTempLowEdge",
-[9] = "forceModeStep",
+    [8]  = "forceModeStepCase",
-[10] = "safeModeTempWaitEdge",
+    [9]  = "forceModeStep",
-[11] = "safeModeTempToWaitEdge",
+    [10] = "safeModeTempWaitEdge",
-[12] = "safeModeStepCase",
+    [11] = "safeModeTempToWaitEdge",
-[13] = "safemodeStep",
+    [12] = "safeModeStepCase",
-[14] = "autoProtectTempEdge",
+    [13] = "safemodeStep",
-[15] = "screen_w",
+    [14] = "autoProtectTempEdge",
-[16] = "screen_h",
+    [15] = "screen_w",
-[17] = "fuelStopPct"
+    [16] = "screen_h",
     [17] = "fuelStopPct"
 }
 
-local file = io.open(name,"r")
+
-if not file then
+    local file = io.open(name, "r")
-return nil
+    if not file then
         return nil
-local tab = {}
+    end
-for line in file:lines() do
+    local tab = {}
-local key, val = line:match("^%s*([%w_]+)%s*=%s*([%d%.]+)")
+    for line in file:lines() do
-if key and val then
+        local key, val = line:match("^%s*([%w_]+)%s*=%s*([%d%.]+)")
-tab[key] = tonumber(val)
+        if key and val then
             tab[key] = tonumber(val)
         end
-file:close()
+    end
-return tab
+    file:close()
     return tab
 end
 
-if not parsed then
+
-return false
+    if not parsed then
         return false
-for i=1,#confnames do
+    end
-if parsed[confnames[i]] == nil then
+    for i = 1, #confnames do
-return false
+        if parsed[confnames[i]] == nil then
             return false
         end
-return true
+    end
     return true
 end
 
-local file = io.open(name,"r")
+
-if file then
+    local file = io.open(name, "r")
-local tab = {}
+    if file then
-local i = 1
+        local tab = {}
-while true do
+        local i = 1
-local str = file:read("*l")
+        while true do
-if str == nil then
+            local str = file:read("*l")
-break
+            if str == nil then
                 break
-if parseNum(str) ~= "" then
+            end
-tab[i] = parseNum(str)
+            if parseNum(str) ~= "" then
-i=i+1
+                tab[i] = parseNum(str)
                 i = i + 1
             end
-file:close()
+        end
-return tab
+        file:close()
-else
+        return tab
-return false
+    else
         return false
     end
 end
-local function writeText(name,text)
+
-local file = io.open(name,"w")
+local function writeText(name, text)
-file:write(text)
+    local file = io.open(name, "w")
-file:close()
+    file:write(text)
     file:close()
 end
 
-local parsed = readConfig(name)
+
-if not parsed or not hasConfigKeys(parsed) then
+    local parsed = readConfig(name)
-writeText(name,DEFAULT_CONFIG)
+    if not parsed or not hasConfigKeys(parsed) then
-elseif cfg.default_interval ~= nil and
+        writeText(name, DEFAULT_CONFIG)
-cfg.ctrl_interval ~= nil and
+    elseif cfg.default_interval ~= nil and
-cfg.shift_interval ~= nil and
+        cfg.ctrl_interval ~= nil and
-cfg.ctrlShift_interval ~= nil and
+        cfg.shift_interval ~= nil and
-cfg.shield ~= nil and
+        cfg.ctrlShift_interval ~= nil and
-cfg.tempCriticalEdge ~= nil and
+        cfg.shield ~= nil and
-cfg.forceModeTempLowEdge ~= nil and
+        cfg.tempCriticalEdge ~= nil and
-cfg.forceModeStepCase ~= nil and
+        cfg.forceModeTempLowEdge ~= nil and
-cfg.forceModeStep ~= nil and
+        cfg.forceModeStepCase ~= nil and
-cfg.safeModeTempWaitEdge ~= nil and
+        cfg.forceModeStep ~= nil and
-cfg.safeModeTempToWaitEdge ~= nil and
+        cfg.safeModeTempWaitEdge ~= nil and
-cfg.safeModeStepCase ~= nil and
+        cfg.safeModeTempToWaitEdge ~= nil and
-cfg.safemodeStep ~= nil and
+        cfg.safeModeStepCase ~= nil and
-cfg.autoProtectTempEdge ~= nil and
+        cfg.safemodeStep ~= nil and
-cfg.screen_w ~= nil and
+        cfg.autoProtectTempEdge ~= nil and
-cfg.screen_h ~= nil and
+        cfg.screen_w ~= nil and
-cfg.fuelStopPct ~= nil then
+        cfg.screen_h ~= nil and
         cfg.fuelStopPct ~= nil then
-writeText(name,string.format(
+
-[[
+        writeText(name, string.format([[
 -- Интервалы для кнопок +/-
 default_interval = %d
 ctrl_interval = %d
 shift_interval = %d
 ctrlShift_interval = %d
 -- Автономный режим:
 -- Основные константы
 shield = %0.2f - Щиты будут автоматически поддерживаться на этом уровне ( в %)
 tempCriticalEdge = %d -- Если температура превысит это значение, программа экстренно понизит поток вывода;
 -- Форсированный режим
 forceModeTempLowEdge = %d -- Пока температура не превысит это значение, программа будет работать в форсированном режиме, иначе - перейдет в безопасный режим;
 forceModeStepCase = %d -- Если разница между текущей выработкой энергии и выставленным потоком превысит это значение, то к потоку добавится
 forceModeStep = %d -- это значение
 -- Безопасный режим
 safeModeTempWaitEdge = %d -- Если температура превысит это значение, программа будет ожидать,
 safeModeTempToWaitEdge = %d -- пока температура не понизится до этого значения;
 safeModeStepCase = %d -- Если разница между текущей выработкой энергии и выставленным потоком превысит это значение, то к потоку добавится
 safemodeStep = %d -- это значение
 autoProtectTempEdge = %d -- При достижении этой температуры включается автономный режим
 screen_w = %d -- Ширина экрана
 screen_h = %d -- Высота экрана
 fuelStopPct = %d -- % топлива, при котором реактор выключается]],
-cfg.default_interval,
+            cfg.default_interval,
-cfg.ctrl_interval,
+            cfg.ctrl_interval,
-cfg.shift_interval,
+            cfg.shift_interval,
-cfg.ctrlShift_interval,
+            cfg.ctrlShift_interval,
-cfg.shield,
+            cfg.shield,
-cfg.tempCriticalEdge,
+            cfg.tempCriticalEdge,
-cfg.forceModeTempLowEdge,
+            cfg.forceModeTempLowEdge,
-cfg.forceModeStepCase,
+            cfg.forceModeStepCase,
-cfg.forceModeStep,
+            cfg.forceModeStep,
-cfg.safeModeTempWaitEdge,
+            cfg.safeModeTempWaitEdge,
-cfg.safeModeTempToWaitEdge,
+            cfg.safeModeTempToWaitEdge,
-cfg.safeModeStepCase,
+            cfg.safeModeStepCase,
-cfg.safemodeStep,
+            cfg.safemodeStep,
-cfg.autoProtectTempEdge,
+            cfg.autoProtectTempEdge,
-cfg.screen_w,
+            cfg.screen_w,
-cfg.screen_h,
+            cfg.screen_h,
-cfg.fuelStopPct
+            cfg.fuelStopPct
-))
+        ))
     end
 end
 
-local function makeConfig(tab,tab2)
+local function makeConfig(tab, tab2)
-local config = {}
+    local config = {}
-for i=1,#tab do
+    for i = 1, #tab do
-config[tostring(tab[i])] = tab2[i]
+        config[tostring(tab[i])] = tab2[i]
     end
-return config
+    return config
 end
 
 local function listAddresses(typeName)
-local list = {}
+    local list = {}
-for adr in com.list(typeName) do
+    for adr in com.list(typeName) do
-list[#list+1] = adr
+        list[#list + 1] = adr
     end
-return list
+    return list
 end
 
 local function readReactorsFile()
-local file = io.open(reactorsFile,"r")
+    local file = io.open(reactorsFile, "r")
-if not file then
+    if not file then
-return nil
+        return nil
     end
-local list = {}
+    local list = {}
-for line in file:lines() do
+    for line in file:lines() do
-local r,u,d = line:match("(%S+)%s+(%S+)%s+(%S+)")
+        local r, u, d = line:match("(%S+)%s+(%S+)%s+(%S+)")
-if r and u and d then
+        if r and u and d then
-list[#list+1] = {reactorAdr = r, upAdr = u, downAdr = d}
+            list[#list + 1] = {reactorAdr = r, upAdr = u, downAdr = d}
         end
     end
-file:close()
+    file:close()
-if #list == 0 then
+    if #list == 0 then
-return nil
+        return nil
     end
-return list
+    return list
 end
 
 local function writeReactorsFile(list)
-local file = io.open(reactorsFile,"w")
+    local file = io.open(reactorsFile, "w")
-for i=1,#list do
+    for i = 1, #list do
-file:write(string.format("%s %s %s\n",list[i].reactorAdr,list[i].upAdr,list[i].downAdr))
+        file:write(string.format("%s %s %s\n", list[i].reactorAdr, list[i].upAdr, list[i].downAdr))
     end
-file:close()
+    file:close()
 end
 
 local function validEntry(entry)
-return com.get(entry.reactorAdr) ~= nil and com.get(entry.upAdr) ~= nil and com.get(entry.downAdr) ~= nil
+    return com.get(entry.reactorAdr) ~= nil and com.get(entry.upAdr) ~= nil and com.get(entry.downAdr) ~= nil
 end
 
 local function mergeEntries(entries)
-local usedReactors = {}
+    local usedReactors = {}
-local usedGates = {}
+    local usedGates = {}
-for i=1,#entries do
+    for i = 1, #entries do
-usedReactors[entries[i].reactorAdr] = true
+        usedReactors[entries[i].reactorAdr] = true
-usedGates[entries[i].upAdr] = true
+        usedGates[entries[i].upAdr] = true
-usedGates[entries[i].downAdr] = true
+        usedGates[entries[i].downAdr] = true
     end
-local reactorsList = listAddresses("draconic_reactor")
+    local reactorsList = listAddresses("draconic_reactor")
-local gates = listAddresses("flux_gate")
+    local gates = listAddresses("flux_gate")
-local freeReactors = {}
+    local freeReactors = {}
-local freeGates = {}
+    local freeGates = {}
-for i=1,#reactorsList do
+    for i = 1, #reactorsList do
-if not usedReactors[reactorsList[i]] then
+        if not usedReactors[reactorsList[i]] then
-freeReactors[#freeReactors+1] = reactorsList[i]
+            freeReactors[#freeReactors + 1] = reactorsList[i]
         end
     end
-for i=1,#gates do
+    for i = 1, #gates do
-if not usedGates[gates[i]] then
+        if not usedGates[gates[i]] then
-freeGates[#freeGates+1] = gates[i]
+            freeGates[#freeGates + 1] = gates[i]
         end
     end
-local addCount = math.min(#freeReactors, math.floor(#freeGates/2), MAX_REACTORS - #entries)
+    local addCount = math.min(#freeReactors, math.floor(#freeGates / 2), MAX_REACTORS - #entries)
-for i=1,addCount do
+    for i = 1, addCount do
-entries[#entries+1] = {
+        entries[#entries + 1] = {
-reactorAdr = freeReactors[i],
+            reactorAdr = freeReactors[i],
-upAdr = freeGates[(i-1)*2+1],
+            upAdr = freeGates[(i - 1) * 2 + 1],
-downAdr = freeGates[(i-1)*2+2]
+            downAdr = freeGates[(i - 1) * 2 + 2]
         }
     end
-return entries
+    return entries
 end
 
 local function buildReactors()
-newEntriesAdded = false
+    newEntriesAdded = false
-lastAddedReactorAdr = nil
+    lastAddedReactorAdr = nil
-local entries = readReactorsFile()
+    local entries = readReactorsFile()
-local currentReactors = reactors or {}
+    local currentReactors = reactors or {}
-if entries then
+    if entries then
-local valid = {}
+        local valid = {}
-for i=1,#entries do
+        for i = 1, #entries do
-if validEntry(entries[i]) then
+            if validEntry(entries[i]) then
-valid[#valid+1] = entries[i]
+                valid[#valid + 1] = entries[i]
             end
         end
-if #valid > 0 then
+        if #valid > 0 then
-entries = valid
+            entries = valid
         end
     end
-if entries and #entries > 0 then
+    if entries and #entries > 0 then
-local reactorsList = listAddresses("draconic_reactor")
+        local reactorsList = listAddresses("draconic_reactor")
-if #reactorsList > #entries then
+        if #reactorsList > #entries then
-newEntriesAdded = true
+            newEntriesAdded = true
         end
     end
-if not entries or #entries == 0 then
+    if not entries or #entries == 0 then
-return nil
+        return nil
     end
-local oldByAdr = {}
+    local oldByAdr = {}
-for i=1,#currentReactors do
+    for i = 1, #currentReactors do
-oldByAdr[currentReactors[i].reactorAdr] = currentReactors[i]
+        oldByAdr[currentReactors[i].reactorAdr] = currentReactors[i]
     end
     local reactors = {}
-for i=1,#entries do
+    for i = 1, #entries do
-local e = entries[i]
+        local e = entries[i]
-local old = oldByAdr[e.reactorAdr]
+        local old = oldByAdr[e.reactorAdr]
-local savedAuto = autostateByAdr[e.reactorAdr]
+        local savedAuto = autostateByAdr[e.reactorAdr]
-local savedFlowInit = flowInitByAdr[e.reactorAdr]
+        local savedFlowInit = flowInitByAdr[e.reactorAdr]
-local savedCharge = chargeRequestByAdr[e.reactorAdr]
+        local savedCharge = chargeRequestByAdr[e.reactorAdr]
-reactors[i] = {
+        reactors[i] = {
-index = i,
+            index = i,
-reactorAdr = e.reactorAdr,
+            reactorAdr = e.reactorAdr,
-upAdr = e.upAdr,
+            upAdr = e.upAdr,
-downAdr = e.downAdr,
+            downAdr = e.downAdr,
-reactor = com.proxy(com.get(e.reactorAdr)),
+            reactor = com.proxy(com.get(e.reactorAdr)),
-upgate = com.proxy(com.get(e.upAdr)),
+            upgate = com.proxy(com.get(e.upAdr)),
-downgate = com.proxy(com.get(e.downAdr)),
+            downgate = com.proxy(com.get(e.downAdr)),
-maxGenerationRate = old and old.maxGenerationRate or 0,
+            maxGenerationRate = old and old.maxGenerationRate or 0,
-autostate = old and old.autostate or (savedAuto ~= nil and savedAuto or false),
+            autostate = old and old.autostate or (savedAuto ~= nil and savedAuto or false),
-temprise = old and old.temprise or false,
+            temprise = old and old.temprise or false,
-flowInit = old and old.flowInit or (savedFlowInit ~= nil and savedFlowInit or false),
+            flowInit = old and old.flowInit or (savedFlowInit ~= nil and savedFlowInit or false),
-chargeRequested = old and old.chargeRequested or (savedCharge or 0),
+            chargeRequested = old and old.chargeRequested or (savedCharge or 0),
-lastTemp = nil,
+            lastTemp = nil,
-row = {},
+            row = {},
-powerBtn = {},
+            powerBtn = {},
-tab = {}
+            tab = {}
         }
-if not old then
+        if not old then
-lastAddedReactorAdr = e.reactorAdr
+            lastAddedReactorAdr = e.reactorAdr
         end
     end
-return reactors
+    return reactors
 end
 
 configWrite(cfgName)
 cfg = readConfig(cfgName)
 if not cfg then
-cfg = makeConfig(confnames,readParse(cfgName))
+    cfg = makeConfig(confnames, readParse(cfgName))
 end
 
 local reactors = {}
 local activeIndex = 1
-local summaryProfitCord = {x=nil,y=nil}
+local summaryProfitCord = {x = nil, y = nil}
-local summaryEuCord = {x=nil,y=nil}
+local summaryEuCord = {x = nil, y = nil}
-local summaryShieldCord = {x=nil,y=nil}
+local summaryShieldCord = {x = nil, y = nil}
-local summaryGenCord = {x=nil,y=nil}
+local summaryGenCord = {x = nil, y = nil}
-local summaryMaxProfitCord = {x=nil,y=nil}
+local summaryMaxProfitCord = {x = nil, y = nil}
 local maxSummaryProfit = 0
 local newEntriesAdded = false
 local pendingActiveReactorAdr = nil
 autostateByAdr = {}
 flowInitByAdr = {}
 
-local color = { }
+local color = {}
-color["red"]   = 0xFF0000
+color["red"]    = 0xFF0000
-color["green"] = 0x00FF00
+color["green"]  = 0x00FF00
 color["yellow"] = 0xFFD166
 color["skyblue"] = 0x4FC3F7
-color["black"]   = 0x0F1115
+color["black"]  = 0x0F1115
 color["grey"]   = 0x0F1115
 color["panel"]  = 0x1A1F27
 color["blue"]   = 0x4FC3F7
 color["orange"] = 0xFF9800
-color["white"] = 0xE6EDF3
+color["white"]  = 0xE6EDF3
-color["dark"]  = 0x242B36
+color["dark"]   = 0x242B36
-color["dim"]   = 0x7A8599
+color["dim"]    = 0x7A8599
 
 local rback = gpu.getBackground()
 local rfore = gpu.getForeground()
 local chatBox = nil
 
 local handleMain
 local handleOptions
 local handleStart
 local screenAssign
 local screenOverview
 local assignMode = nil
 local firstStartCompleted = false
-local assignState = {reactorIndex = nil, reactorAdr = nil, shieldGateIdx = nil, shieldGateAdr = nil, outGateIdx = nil, outGateAdr = nil, step = "reactor", message = nil}
+local assignState = {
-local assignUi = {reactors = {}, gates = {}, gateAddrs = {}, reactorAddrs = {}, gateUse = {}, selectedAdr = nil, back = {x=nil,y=nil,w=0}}
+    reactorIndex = nil,
     reactorAdr = nil,
-local easyAssign = {active=false, step="reactor", index=1, core=nil, shield=nil, output=nil, saved=false, message=nil, heavyBtn={}, easyBtn={}, continueBtn={}, finishBtn={}, backBtn={}, known={}, lastChatStep=nil, lastChatMessage=nil}
+    shieldGateIdx = nil,
     shieldGateAdr = nil,
     outGateIdx = nil,
     outGateAdr = nil,
-local autoStoppedCord = {x=nil,y=nil}
+    step = "reactor",
     message = nil
-local chargeHint = {x=nil,y=nil,w=0,visible=false}
+
 local assignUi = {
     reactors = {},
-menuItem["options"] =
+    gates = {},
-{
+    gateAddrs = {},
-["name"] ="Настройки |",
+    reactorAddrs = {},
-["x"] = 1,
+    gateUse = {},
-["y"] = 2
+    selectedAdr = nil,
     back = {x = nil, y = nil, w = 0}
-menuItem["save"] =
+
-{
+
-["name"] ="Сохранить |",
+local easyAssign = {
-["x"] = 1,
+    active = false,
-["y"] = 2
+    step = "reactor",
     index = 1,
-menuItem["cancel"] =
+    core = nil,
-{
+    shield = nil,
-["name"] =" Отменить  |",
+    output = nil,
-["x"] = 12,
+    saved = false,
-["y"] = 2
+    message = nil,
     heavyBtn = {},
-menuItem["overview"] =
+    easyBtn = {},
-{
+    continueBtn = {},
-["name"] ="Главный |",
+    finishBtn = {},
-["x"] = 1,
+    backBtn = {},
-["y"] = 2
+    known = {},
     lastChatStep = nil,
-menuItem["refresh"] =
+    lastChatMessage = nil
-{
+
-["name"] ="Обновить |",
+
-["x"] = 1,
+
-["y"] = 2
+
 local autoStoppedCord = {x = nil, y = nil}
-menuItem["gates"] =
+
-{
+local chargeHint = {x = nil, y = nil, w = 0, visible = false}
-["name"] ="Гейты |",
+
-["x"] = 1,
+
-["y"] = 2
+menuItem["options"] = {
     ["name"] = "Настройки |",
-menuItem["back"] =
+    ["x"] = 1,
-{
+    ["y"] = 2
-["name"] ="Назад |",
+
-["x"] = 1,
+menuItem["save"] = {
-["y"] = 2
+    ["name"] = "Сохранить |",
     ["x"] = 1,
-menuItem["reset"] =
+    ["y"] = 2
-{
+
-["name"] ="Сброс |",
+menuItem["cancel"] = {
-["x"] = 1,
+    ["name"] = " Отменить  |",
-["y"] = 2
+    ["x"] = 12,
     ["y"] = 2
-menuItem["optionsBack"] =
+
-{
+menuItem["overview"] = {
-["name"] =" Назад |",
+    ["name"] = "Главный |",
-["x"] = 1,
+    ["x"] = 1,
-["y"] = 2
+    ["y"] = 2
 }
-menuItem["optionsBack"] =
+menuItem["refresh"] = {
-{
+    ["name"] = "Обновить |",
-["name"] =" Назад |",
+    ["x"] = 1,
-["x"] = 1,
+    ["y"] = 2
-["y"] = 2
+
 menuItem["gates"] = {
     ["name"] = "Гейты |",
-local xz,yz = gpu.maxResolution()
+    ["x"] = 1,
     ["y"] = 2
 }
-gpu.setResolution(screenW,screenH)
+menuItem["back"] = {
     ["name"] = "Назад |",
     ["x"] = 1,
     ["y"] = 2
 }
 menuItem["reset"] = {
     ["name"] = "Сброс |",
     ["x"] = 1,
     ["y"] = 2
 }
 menuItem["optionsBack"] = {
     ["name"] = " Назад |",
     ["x"] = 1,
     ["y"] = 2
 }
 
 local xz, yz = gpu.maxResolution()
 local screenW = math.min(120, xz)
 local screenH = math.min(40, yz)
-local infcord =
+gpu.setResolution(screenW, screenH)
-{
+
-["status"] =
+
-	{
+
-	["value"] = nil,
+
-	["x"] = nil,
+
-	["y"] = nil
+
-	},
+
-["temp"] =
+
-	{
+
-	["value"] = nil,
+
-	["x"] = nil,
+
-	["y"] = nil
+
-	},
+
-["generation"] =
+
-	{
+
-	["value"] = nil,
+
-	["x"] = nil,
+
-	["y"] = nil
+
-	},
+local infcord = {
-["maxgen"] =
+    ["status"] = {
-	{
+        ["value"] = nil,
-	["value"] = nil,
+        ["x"] = nil,
-	["x"] = nil,
+        ["y"] = nil
-	["y"] = nil
+    },
-	},
+    ["temp"] = {
-["flow"] =
+        ["value"] = nil,
-	{
+        ["x"] = nil,
-	["value"] = nil,
+        ["y"] = nil
-	["x"] = nil,
+    },
-	["y"] = nil
+    ["generation"] = {
-	},
+        ["value"] = nil,
-["puregen"] =
+        ["x"] = nil,
-	{
+        ["y"] = nil
-	["value"] = nil,
+    },
-	["x"] = nil,
+    ["maxgen"] = {
-	["y"] = nil
+        ["value"] = nil,
-	},
+        ["x"] = nil,
-["drain"] =
+        ["y"] = nil
-	{
+    },
-	["value"] = nil,
+    ["flow"] = {
-	["x"] = nil,
+        ["value"] = nil,
-	["y"] = nil
+        ["x"] = nil,
-	},
+        ["y"] = nil
-["fstrth"] =
+    },
-	{
+    ["puregen"] = {
-	["value"] = nil,
+        ["value"] = nil,
-	["x"] = nil,
+        ["x"] = nil,
-	["y"] = nil
+        ["y"] = nil
-	},
+    },
-["esturn"] =
+    ["drain"] = {
-	{
+        ["value"] = nil,
-	["value"] = nil,
+        ["x"] = nil,
-	["x"] = nil,
+        ["y"] = nil
-	["y"] = nil
+    },
-	},
+    ["fstrth"] = {
-["fuel"] =
+        ["value"] = nil,
-	{
+        ["x"] = nil,
-	["value"] = nil,
+        ["y"] = nil
-	["x"] = nil,
+    },
-	["y"] = nil
+    ["esturn"] = {
-	},
+        ["value"] = nil,
-["fuelconv"] =
+        ["x"] = nil,
-	{
+        ["y"] = nil
-	["value"] = nil,
+    },
-	["x"] = nil,
+    ["fuel"] = {
-	["y"] = nil
+        ["value"] = nil,
-	},
+        ["x"] = nil,
-["core"] =
+        ["y"] = nil
-	{
+    },
-	["value"] = nil,
+    ["fuelconv"] = {
-	["x"] = nil,
+        ["value"] = nil,
-	["y"] = nil
+        ["x"] = nil,
-	}
+        ["y"] = nil
     },
     ["core"] = {
-local button =
+        ["value"] = nil,
-{
+        ["x"] = nil,
-["continue"] =
+        ["y"] = nil
-	{
+    }
-	["name"] = "Продолжить",
+
-	["x"] = nil,
+
-	["y"] = nil
+local button = {
-	},
+    ["continue"] = {
-["change"] =
+        ["name"] = "Продолжить",
-	{
+        ["x"] = nil,
-	["name"] = "Изменить",
+        ["y"] = nil
-	["x"] = nil,
+    },
-	["y"] = nil
+    ["change"] = {
-	},
+        ["name"] = "Изменить",
-["add"] =
+        ["x"] = nil,
-	{
+        ["y"] = nil
-	["name"] = " + ",
+    },
-	["x"] = nil,
+    ["add"] = {
-	["y"] = nil
+        ["name"] = " + ",
-	},
+        ["x"] = nil,
-["sub"] =
+        ["y"] = nil
-	{
+    },
-	["name"] = " - ",
+    ["sub"] = {
-	["x"] = nil,
+        ["name"] = " - ",
-	["y"] = nil
+        ["x"] = nil,
-	},
+        ["y"] = nil
-["start"] =
+    },
-	{
+    ["start"] = {
-	["name"] = " [PWR] ЗАПУСК ",
+        ["name"] = " [PWR] ЗАПУСК ",
-	["x"] = nil,
+        ["x"] = nil,
-	["y"] = nil,
+        ["y"] = nil,
-	["visible"] = nil
+        ["visible"] = nil
-	},
+    },
-["stop"] =
+    ["stop"] = {
-	{
+        ["name"] = " [PWR] СТОП ",
-	["name"] = " [PWR] СТОП ",
+        ["x"] = nil,
-	["x"] = nil,
+        ["y"] = nil,
-	["y"] = nil,
+        ["visible"] = nil
-	["visible"] = nil
+    },
-	},
+    ["charge"] = {
-["charge"] =
+        ["name"] = "Зарядить реактор ",
-	{
+        ["x"] = nil,
-	["name"] = "Зарядить реактор ",
+        ["y"] = nil,
-	["x"] = nil,
+        ["visible"] = nil
-	["y"] = nil,
+    },
-	["visible"] = nil
+    ["autoon"] = {
-	},
+        ["name"] = "[ON] ",
-["autoon"] =
+        ["x"] = nil,
-	{
+        ["y"] = nil,
-	["name"] = "[ON] ",
+    },
-	["x"] = nil,
+    ["autooff"] = {
-	["y"] = nil,
+        ["name"] = "[OFF]",
-	},
+        ["x"] = nil,
-["autooff"] =
+        ["y"] = nil,
-	{
+    }
-	["name"] = "[OFF]",
+
-	["x"] = nil,
+
-	["y"] = nil,
+
-	}
+
 local canclose = true
 local temprise
 local autostate = false
 local maxGenerationRate = 0
 local lastDetailUpdate = 0
 local lastOverviewUpdate = 0
 
 printf = function(s, ...)
     return io.write(s:format(...))
 end
 
-printf = function (s,...)
+
-return io.write(s:format(...))
+    local ok, len = pcall(unicode.len, s)
     if ok and len then
         return len
     end
-local ok, len = pcall(unicode.len, s)
+    return #s
-if ok and len then
+
-return len
+
 local function guiWrite(x, y, cf, cb, s, ...)
-return #s
+    term.setCursor(x, y)
     if cf >= 0 and cb >= 0 then
         local fg = gpu.getForeground()
-local function guiWrite(x,y,cf,cb,s,...)
+        local bg = gpu.getBackground()
-term.setCursor(x,y)
+        gpu.setForeground(cf)
-if cf >=0 and cb >=0 then
+        gpu.setBackground(cb)
-local fg = gpu.getForeground()
+        printf(s, ...)
-local bg = gpu.getBackground()
+        gpu.setForeground(fg)
-gpu.setForeground(cf)
+        gpu.setBackground(bg)
-gpu.setBackground(cb)
+    elseif cb < 0 and cf >= 0 then
-printf(s,...)
+        local fg = gpu.getForeground()
-gpu.setForeground(fg)
+        gpu.setForeground(cf)
-gpu.setBackground(bg)
+        printf(s, ...)
-elseif cb <0 and cf>=0 then
+        gpu.setForeground(fg)
-local fg = gpu.getForeground()
+    elseif cf < 0 and cb >= 0 then
-gpu.setForeground(cf)
+        local bg = gpu.getBackground()
-printf(s,...)
+        printf(s, ...)
-gpu.setForeground(fg)
+        gpu.setBackground(bg)
-elseif cf < 0 and cb >= 0 then
+    else
-local bg = gpu.getBackground()
+        local fg = gpu.getForeground()
-printf(s,...)
+        gpu.setForeground(color.white)
-gpu.setBackground(bg)
+        printf(s, ...)
-else
+        gpu.setForeground(fg)
-local fg = gpu.getForeground()
+    end
 end
-printf(s,...)
+
-gpu.setForeground(fg)
+
     param.x, param.y = term.getCursor()
     return param.x, param.y
 end
 
-param.x,param.y = term.getCursor()
+
-return param.x,param.y
+    local fg = gpu.getForeground()
     local bg = gpu.getBackground()
     gpu.setForeground(color.white)
     gpu.setBackground(color.grey)
-local fg = gpu.getForeground()
+    for i = y + 3, 3, -1 do
-local bg = gpu.getBackground()
+        term.setCursor(1, i)
         term.clearLine()
     end
-for i=y+3,3,-1 do
+    gpu.setForeground(fg)
-term.setCursor(1,i)
+    gpu.setBackground(bg)
-term.clearLine()
+
 
-gpu.setForeground(fg)
+
-gpu.setBackground(bg)
+    if not reactors[index] then
         return
     end
     activeIndex = index
-if not reactors[index] then
+    reactor = reactors[index].reactor
-return
+    upgate = reactors[index].upgate
     downgate = reactors[index].downgate
-activeIndex = index
+    autostate = reactors[index].autostate
-reactor = reactors[index].reactor
+    temprise = reactors[index].temprise
-upgate = reactors[index].upgate
+    maxGenerationRate = reactors[index].maxGenerationRate
-downgate = reactors[index].downgate
+
-autostate = reactors[index].autostate
+
-temprise = reactors[index].temprise
+
-maxGenerationRate = reactors[index].maxGenerationRate
+    if not reactors[activeIndex] then
         return
     end
     reactors[activeIndex].autostate = autostate
-if not reactors[activeIndex] then
+    reactors[activeIndex].temprise = temprise
-return
+    reactors[activeIndex].maxGenerationRate = maxGenerationRate
 end
-reactors[activeIndex].autostate = autostate
+
-reactors[activeIndex].temprise = temprise
+
-reactors[activeIndex].maxGenerationRate = maxGenerationRate
+    local x = gpu.getResolution()
     gpu.setBackground(color.grey)
     gpu.setForeground(color.white)
     term.clear()
-local x = gpu.getResolution()
+    gpu.setBackground(color.panel)
     gpu.setForeground(color.white)
     term.clearLine()
     printf(" %s", title)
-gpu.setBackground(color.panel)
+    gpu.setForeground(color.green)
     printf(" | Разработал : GintaRus")
-term.clearLine()
+    gpu.setForeground(color.white)
-printf(" %s",title)
+    printf("\n")
-gpu.setForeground(color.green)
+    gpu.setBackground(color.grey)
-printf(" | Разработал : GintaRus")
+    gpu.setForeground(color.white)
     term.clearLine()
-printf("\n")
+    gpu.setBackground(0xFF0000)
     gpu.set(x - 2, 1, " X ")
     gpu.setBackground(color.grey)
-term.clearLine()
+    gpu.setForeground(color.white)
-gpu.setBackground(0xFF0000)
+    return x
-gpu.set(x-2,1," X ")
+
 
 local function drawSeparator(x)
-return x
+    gpu.setBackground(color.grey)
     gpu.setForeground(color.dim)
     gpu.fill(1, 3, x, 1, "-")
     gpu.setBackground(color.grey)
     gpu.setForeground(color.white)
-gpu.setForeground(color.dim)
+    term.setCursor(1, 4)
-gpu.fill(1,3,x,1,"-")
+
 
 local function makeButton(x, y, text)
-term.setCursor(1,4)
+    term.setCursor(x, y)
     local fg = gpu.getForeground()
     local bg = gpu.getBackground()
-local function makeButton(x,y,text)
+    gpu.setBackground(color.blue)
-term.setCursor(x,y)
+    gpu.setForeground(color.white)
-local fg = gpu.getForeground()
+    printf(text)
-local bg = gpu.getBackground()
+    gpu.setBackground(bg)
-gpu.setBackground(color.blue)
+    gpu.setForeground(fg)
 end
-printf(text)
+
-gpu.setBackground(bg)
+local function makePowerButton(x, y, text, bg, fg)
-gpu.setForeground(fg)
+    term.setCursor(x, y)
     local rfg = gpu.getForeground()
     local rbg = gpu.getBackground()
     gpu.setBackground(bg)
-local function makePowerButton(x,y,text,bg,fg)
+    gpu.setForeground(fg)
-term.setCursor(x,y)
+    printf(text)
-local rfg = gpu.getForeground()
+    gpu.setBackground(rbg)
-local rbg = gpu.getBackground()
+    gpu.setForeground(rfg)
-gpu.setBackground(bg)
+
-gpu.setForeground(fg)
+
-printf(text)
+
-gpu.setBackground(rbg)
+    if not gate then
-gpu.setForeground(rfg)
+        return 0
     end
     local ok, value = pcall(gate.getSignalLowFlow)
     if ok and type(value) == "number" then
-if not gate then
+        return value
-return 0
+    end
     local ok2, value2 = pcall(gate.getFlow)
-local ok, value = pcall(gate.getSignalLowFlow)
+    if ok2 and type(value2) == "number" then
-if ok and type(value) == "number" then
+        return value2
-return value
+    end
     return 0
-local ok2, value2 = pcall(gate.getFlow)
+
-if ok2 and type(value2) == "number" then
+
-return value2
+
     if not addr then
-return 0
+        return false
     end
     return com.get(addr) ~= nil
 end
-if not addr then
+
-return false
+
     if not r or (r.flowInit and not force) then
-return com.get(addr) ~= nil
+        return
     end
     pcall(r.upgate.setSignalLowFlow, r.upgate, CHARGE_FLOW)
     r.flowInit = true
-if not r or (r.flowInit and not force) then
+    flowInitByAdr[r.reactorAdr] = true
-return
+    if reactors[activeIndex] and reactors[activeIndex].reactorAdr == r.reactorAdr then
         infcord.flow.value = CHARGE_FLOW
-pcall(r.upgate.setSignalLowFlow, r.upgate, CHARGE_FLOW)
+        if handleMain and infcord.flow.x then
-r.flowInit = true
+            guiWrite(infcord.flow.x, infcord.flow.y, color.red, color.grey, "%s", numformat(infcord.flow.value))
-flowInitByAdr[r.reactorAdr] = true
+        end
-if reactors[activeIndex] and reactors[activeIndex].reactorAdr == r.reactorAdr then
+    end
-infcord.flow.value = CHARGE_FLOW
+
-if handleMain and infcord.flow.x then
+
-guiWrite(infcord.flow.x,infcord.flow.y,color.red,color.grey,"%s",numformat(infcord.flow.value))
+
     return status == "offline" or status == "stopping" or status == "cold" or status == "cooling" or status == "warming_up"
 end
 
 local function statusText(status)
     if status == "online" then
-return status == "offline" or status == "stopping" or status == "cold" or status == "cooling" or status == "warming_up"
+        return "ВКЛ"
     elseif status == "offline" then
         return "ВЫК"
     elseif status == "charging" then
-if status == "online" then
+        return "ЗАР"
-return "ВКЛ"
+    elseif status == "charged" then
-elseif status == "offline" then
+        return "ГОТ"
-return "ВЫК"
+    elseif status == "stopping" then
-elseif status == "charging" then
+        return "СТП"
-return "ЗАР"
+    elseif status == "cold" then
-elseif status == "charged" then
+        return "ХОЛ"
-return "ГОТ"
+    elseif status == "cooling" then
-elseif status == "stopping" then
+        return "ОСТ"
-return "СТП"
+    elseif status == "warming_up" then
-elseif status == "cold" then
+        return "РАЗ"
-return "ХОЛ"
+    end
-elseif status == "cooling" then
+    return status
-return "ОСТ"
+
-elseif status == "warming_up" then
+
-return "РАЗ"
+local function show(fc, bc, param)
     local fg = gpu.getForeground()
-return status
+    local bg = gpu.getBackground()
     term.setCursor(param.x, param.y)
     gpu.setForeground(fc)
-local function show(fc,bc,param)
+    gpu.setBackground(bc)
-local fg = gpu.getForeground()
+    local st = " "
-local bg = gpu.getBackground()
+    for i = 0, #tostring(param.value) do
-term.setCursor(param.x,param.y)
+        st = st .. " "
-gpu.setForeground(fc)
+    end
-gpu.setBackground(bc)
+    gpu.set(param.x, param.y, st)
-local st = " "
+    printf("%d", param.value)
-for i = 0,#tostring(param.value) do
+    gpu.setForeground(fg)
-st=st.." "
+    gpu.setBackground(bg)
 end
-gpu.set(param.x,param.y,st)
+
-printf("%d",param.value)
+
-gpu.setForeground(fg)
+    local s = tostring(n)
-gpu.setBackground(bg)
+    if n >= 1000 and n < 1000000 then
         local t = s:sub(1, #s - 3)
         local e = s:sub(#s - 2)
         s = t .. " " .. e .. "  "
-local s = tostring(n)
+        return s
-if n >= 1000 and n < 1000000 then
+    elseif n >= 1000000 then
-local t = s:sub(1,#s-3)
+        local m = s:sub(1, #s - 6)
-local e = s:sub(#s-2)
+        local t = s:sub(#s - 5, #s - 3)
-s = t.." "..e.."  "
+        local e = s:sub(#s - 2)
-return s
+        s = m .. " " .. t .. " " .. e .. "  "
-elseif n >= 1000000 then
+        return s
-local m = s:sub(1,#s-6)
+    else
-local t = s:sub(#s-5,#s-3)
+        s = s .. "  "
-local e = s:sub(#s-2)
+        return s
-s = m.." "..t.." "..e.."  "
+    end
-return s
+
-else
+
-s=s.."  "
+
-return s
+    local cols
     if x >= 120 then
         cols = {status = 6, temp = 15, fuel = 27, profit = 43, gen = 60, flow = 77}
     else
         cols = {status = 5, temp = 11, fuel = 20, profit = 33, gen = 48, flow = 63}
-local cols
+    end
-if x >= 120 then
+    local ctrl = cols.flow + 12
-cols = {status=6,temp=15,fuel=27,profit=43,gen=60,flow=77}
+    if ctrl < 65 then
-else
+        ctrl = 65
-cols = {status=5,temp=11,fuel=20,profit=33,gen=48,flow=63}
+    end
     if ctrl + 16 > x then
-local ctrl = cols.flow + 12
+        ctrl = math.max(65, x - 16)
-if ctrl < 65 then
+    end
-ctrl = 65
+    cols.ctrl = ctrl
     return cols
-if ctrl + 16 > x then
+
-ctrl = math.max(65, x - 16)
+
 local function coreformat()
-cols.ctrl = ctrl
+    local num = com.draconic_rf_storage.getEnergyStored()
-return cols
+    if num > 10 ^ 12 then
         return string.format(" Накоплено в ядре: %0.3f T   \n", num / 10 ^ 12)
     elseif num > 10 ^ 9 then
         return string.format(" Накоплено в ядре: %0.3f B   \n", num / 10 ^ 9)
-local num = com.draconic_rf_storage.getEnergyStored()
+    elseif num > 10 ^ 6 then
-if num > 10^12 then
+        return string.format(" Накоплено в ядре: %0.3f M   \n", num / 10 ^ 6)
-return string.format(" Накоплено в ядре: %0.3f T   \n",num/10^12)
+    elseif num > 10 ^ 3 then
-elseif num > 10^9 then
+        return string.format(" Накоплено в ядре: %0.3f K   \n", num / 10 ^ 3)
-return string.format(" Накоплено в ядре: %0.3f B   \n",num/10^9)
+    else
-elseif num > 10^6 then
+        return string.format(" Накоплено в ядре: %d   \n", num)
-return string.format(" Накоплено в ядре: %0.3f M   \n",num/10^6)
+    end
-elseif num > 10^3 then
+
-return string.format(" Накоплено в ядре: %0.3f K   \n",num/10^3)
+
-else
+
-return string.format(" Накоплено в ядре: %d   \n",num)
+    local ok, inf = pcall(reactor.getReactorInfo)
     if not ok or type(inf) ~= "table" then
         return
     end
--- Анализ и корректировка запомненных адресов
+    infcord.status.value = inf.status
     button.start.visible = false
-local ok, inf = pcall(reactor.getReactorInfo)
+    button.stop.visible = false
-if not ok or type(inf) ~= "table" then
+    button.charge.visible = false
-return
+    if canChargeStatus(infcord.status.value) then
         guiWrite(button.charge.x, button.charge.y, color.skyblue, color.black, "%s", button.charge.name)
-infcord.status.value = inf.status
+        button.charge.visible = true
-button.start.visible = false
+    elseif infcord.status.value == "charged" then
-button.stop.visible = false
+        guiWrite(button.start.x, button.start.y, color.green, color.black, "%s", button.start.name)
-button.charge.visible = false
+        button.start.visible = true
-if canChargeStatus(infcord.status.value) then
+        guiWrite(button.stop.x, button.stop.y, color.red, color.black, "%s", button.stop.name)
-guiWrite(button.charge.x,button.charge.y,color.skyblue,color.black,"%s",button.charge.name)
+        button.stop.visible = true
-button.charge.visible = true
+    elseif infcord.status.value == "online" or infcord.status.value == "charging" then
-elseif infcord.status.value == "charged" then
+        guiWrite(button.stop.x, button.stop.y, color.red, color.black, "%s", button.stop.name)
-guiWrite(button.start.x,button.start.y,color.green,color.black,"%s",button.start.name)
+        button.stop.visible = true
-button.start.visible = true
+    elseif infcord.status.value == "stopping" then
-guiWrite(button.stop.x,button.stop.y,color.red,color.black,"%s",button.stop.name)
+        if (inf.energySaturation / inf.maxEnergySaturation) * 100 >= 50 and
-button.stop.visible = true
+            (inf.fieldStrength / inf.maxFieldStrength) * 100 >= 50 and
-elseif infcord.status.value == "online" or infcord.status.value == "charging" then
+            inf.temperature > 2000 then
-guiWrite(button.stop.x,button.stop.y,color.red,color.black,"%s",button.stop.name)
+            guiWrite(button.start.x, button.start.y, color.green, color.black, "%s", button.start.name)
-button.stop.visible = true
+            button.start.visible = true
-elseif infcord.status.value == "stopping" then
+        end
-if (inf.energySaturation/inf.maxEnergySaturation)*100 >=50 and (inf.fieldStrength/inf.maxFieldStrength)*100 >= 50 and inf.temperature > 2000 then
+    end
-guiWrite(button.start.x,button.start.y,color.green,color.black,"%s",button.start.name)
+
-button.start.visible = true
+
 local function screenStart()
     handleMain = false
     handleOptions = false
--- Инициализация программы, анализ и настройка всей технической белеберды
+    handleStart = true
     local x = drawHeader("HiTech Classic is the best   (Preparation)")
-handleMain = false
+    if not firstStartCompleted then
-handleOptions = false
+        printf("Эта страница для настройки программы при первом запуске или после сбоя")
-handleStart = true
+    end
-local x = drawHeader("HiTech Classic is the best   (Preparation)")
+    drawSeparator(x)
-if not firstStartCompleted then
+    term.setCursor(1, screenH - 2)
-printf("Эта страница для настройки программы при первом запуске или после сбоя")
+    menuItem.gates.x, menuItem.gates.y = term.getCursor()
     gpu.setForeground(color.blue)
-drawSeparator(x)
+    printf(menuItem.gates.name)
-term.setCursor(1,screenH - 2)
+    menuItem.gates.w = textWidth(menuItem.gates.name)
-menuItem.gates.x,menuItem.gates.y = term.getCursor()
+    gpu.setForeground(color.white)
-gpu.setForeground(color.blue)
+    local hadFile = readReactorsFile() ~= nil
-printf(menuItem.gates.name)
+    while true do
-menuItem.gates.w = textWidth(menuItem.gates.name)
+        if not ops then
             return
-local hadFile = readReactorsFile() ~= nil
+        end
-while true do
+        reactors = buildReactors()
-if not ops then return end
+        if reactors and #reactors > 0 then
-reactors = buildReactors()
+            setActive(1)
-if reactors and #reactors > 0 then
+            firstStartCompleted = true
-setActive(1)
+            if not hadFile then
-firstStartCompleted = true
+                screenAssign()
-if not hadFile then
+                return
-screenAssign()
+            end
-return
+            break
         end
-break
+        if not hadFile then
             local reactorsList = listAddresses("draconic_reactor")
-if not hadFile then
+            local gates = listAddresses("flux_gate")
-local reactorsList = listAddresses("draconic_reactor")
+            if #reactorsList > 0 and #gates >= 2 then
-local gates = listAddresses("flux_gate")
+                reactors = reactors or {}
-if #reactorsList > 0 and #gates >= 2 then
+                firstStartCompleted = true
-reactors = reactors or {}
+                screenOverview()
-firstStartCompleted = true
+                return
-screenOverview()
+            end
-return
+        end
         guiClear(2)
         printf("Подключите реакторы и флюкс-гейты (2 гейта на каждый реактор)\n")
-guiClear(2)
+        printf("Максимум: %d реакторов. Адреса можно сохранить в %s\n", MAX_REACTORS, reactorsFile)
-printf("Подключите реакторы и флюкс-гейты (2 гейта на каждый реактор)\n")
+        os.sleep(1)
-printf("Максимум: %d реакторов. Адреса можно сохранить в %s\n",MAX_REACTORS,reactorsFile)
+    end
-os.sleep(1)
+
 
 local function screenOptions()
--- Экран настроек
+    handleMain = false
     handleStart = false
-handleMain = false
+    handleOptions = true
-handleStart = false
+    handleOverview = false
-handleOptions = true
+    handleAssign = false
-handleOverview = false
+    canedit = true
-handleAssign = false
+    canclose = true
-canedit = true
+    local x = drawHeader("HiTech Classic is the best   (Options)")
-canclose = true
+    menuItem.save.x, menuItem.save.y = term.getCursor()
-local x = drawHeader("HiTech Classic is the best   (Options)")
+    gpu.setForeground(color.blue)
-menuItem.save.x,menuItem.save.y =term.getCursor()
+    printf(menuItem.save.name)
-gpu.setForeground(color.blue)
+    menuItem.save.w = textWidth(menuItem.save.name)
-printf(menuItem.save.name)
+    menuItem.cancel.x, menuItem.cancel.y = term.getCursor()
-menuItem.save.w = textWidth(menuItem.save.name)
+    printf(menuItem.cancel.name)
-menuItem.cancel.x,menuItem.cancel.y =term.getCursor()
+    menuItem.cancel.w = textWidth(menuItem.cancel.name)
-printf(menuItem.cancel.name)
+    menuItem.optionsBack.x, menuItem.optionsBack.y = term.getCursor()
-menuItem.cancel.w = textWidth(menuItem.cancel.name)
+    printf(menuItem.optionsBack.name)
-menuItem.optionsBack.x,menuItem.optionsBack.y =term.getCursor()
+    menuItem.optionsBack.w = textWidth(menuItem.optionsBack.name)
-printf(menuItem.optionsBack.name)
+    gpu.setForeground(color.white)
-menuItem.optionsBack.w = textWidth(menuItem.optionsBack.name)
+    drawSeparator(x)
     printf(" Интервал для щелчка: ")
-drawSeparator(x)
+    OptionDefault["x"], OptionDefault["y"] = term.getCursor()
-printf(" Интервал для щелчка: ")
+    printf("%d\n", OptionDefault.value)
-OptionDefault["x"],OptionDefault["y"] = term.getCursor()
+    printf(" Интервал для CTRL: ")
-printf("%d\n",OptionDefault.value)
+    OptionCtrl["x"], OptionCtrl["y"] = term.getCursor()
-printf(" Интервал для CTRL: ")
+    printf("%d\n", OptionCtrl.value)
-OptionCtrl["x"],OptionCtrl["y"] = term.getCursor()
+    printf(" Интервал для SHIFT: ")
-printf("%d\n",OptionCtrl.value)
+    OptionShift["x"], OptionShift["y"] = term.getCursor()
-printf(" Интервал для SHIFT: ")
+    printf("%d\n", OptionShift.value)
-OptionShift["x"],OptionShift["y"] = term.getCursor()
+    printf(" Интервал для CTRL+SHIFT: ")
-printf("%d\n",OptionShift.value)
+    OptionCtrlShift["x"], OptionCtrlShift["y"] = term.getCursor()
-printf(" Интервал для CTRL+SHIFT: ")
+    printf("%d\n", OptionCtrlShift.value)
-OptionCtrlShift["x"],OptionCtrlShift["y"] = term.getCursor()
+    printf(" Уровень щитов: ")
-printf("%d\n",OptionCtrlShift.value)
+    OptionShield["x"], OptionShield["y"] = term.getCursor()
-printf(" Уровень щитов: ")
+    printf("%d\n", OptionShield.value)
-OptionShield["x"],OptionShield["y"] = term.getCursor()
+    printf(" Отключение по топливу (%%): ")
-printf("%d\n",OptionShield.value)
+    OptionFuelStop["x"], OptionFuelStop["y"] = term.getCursor()
-printf(" Отключение по топливу (%%): ")
+    printf("%d\n", OptionFuelStop.value)
-OptionFuelStop["x"],OptionFuelStop["y"] = term.getCursor()
+
-printf("%d\n",OptionFuelStop.value)
+
 local function clearPromptLine()
--- Назначение гейтов
+    local _, y = term.getCursor()
     if y > 1 then
-local _, y = term.getCursor()
+        term.setCursor(1, y - 1)
-if y > 1 then
+        term.clearLine()
-term.setCursor(1, y - 1)
+        term.setCursor(1, y - 1)
-term.clearLine()
+    end
-term.setCursor(1, y - 1)
+
 
 local function readIndex(prompt, max, used)
     while true do
-local function readIndex(prompt,max,used)
+        printf("%s", prompt)
-while true do
+        local input = term.read(false, false) or ""
-printf("%s",prompt)
+        clearPromptLine()
-local input = term.read(false,false) or ""
+        local num = tonumber(input:match("%d+"))
-clearPromptLine()
+        if num and num >= 1 and num <= max and not used[num] then
-local num = tonumber(input:match("%d+"))
+            return num
-if num and num >= 1 and num <= max and not used[num] then
+        end
-return num
+        printf("Неверный выбор, попробуйте снова.\n")
     end
-printf("Неверный выбор, попробуйте снова.\n")
+
 
 local function readIndexAllowZero(prompt, max)
     while true do
-local function readIndexAllowZero(prompt,max)
+        printf("%s", prompt)
-while true do
+        local input = term.read(false, false) or ""
-printf("%s",prompt)
+        clearPromptLine()
-local input = term.read(false,false) or ""
+        local lower = input:lower()
-clearPromptLine()
+        if lower:find("назад") or lower:find("back") or lower:match("^b%s*$") then
-local lower = input:lower()
+            return -1
-if lower:find("назад") or lower:find("back") or lower:match("^b%s*$") then
+        end
-return -1
+        local num = tonumber(input:match("%d+"))
         if num and num >= 0 and num <= max then
-local num = tonumber(input:match("%d+"))
+            return num
-if num and num >= 0 and num <= max then
+        end
-return num
+        printf("Неверный выбор, попробуйте снова.\n")
     end
-printf("Неверный выбор, попробуйте снова.\n")
+
 
 local saveAssignedGates
 
 local function getChatBox()
     if chatBox then
         return chatBox
-if chatBox then
+    end
-return chatBox
+    if com.isAvailable("chat_box") then
         chatBox = com.chat_box
-if com.isAvailable("chat_box") then
+    end
-chatBox = com.chat_box
+    return chatBox
 end
-return chatBox
+
 local function chatSay(message, color_code)
     local box = getChatBox()
     if not box or not message then
-local box = getChatBox()
+        return false
-if not box or not message then
+    end
-return false
+    if box.say and pcall(function()
         box.say(message)
-if box.say and pcall(function() box.say(message) end) then
+    end) then
-return true
+        return true
     end
-if box.sendMessage and pcall(function() box.sendMessage(message) end) then
+    if box.sendMessage and pcall(function()
-return true
+        box.sendMessage(message)
     end) then
-if box.sendMessage and pcall(function() box.sendMessage(message, color_code or 64) end) then
+        return true
-return true
+    end
     if box.sendMessage and pcall(function()
-return false
+        box.sendMessage(message, color_code or 64)
     end) then
         return true
     end
-if step and easyAssign.lastChatStep ~= step then
+    return false
-easyAssign.lastChatStep = step
+
-easyAssign.lastChatMessage = nil
+
 local function maybeChatSay(step, message, color_code)
-if message and easyAssign.lastChatMessage ~= message then
+    if step and easyAssign.lastChatStep ~= step then
-easyAssign.lastChatMessage = message
+        easyAssign.lastChatStep = step
-chatSay(message, color_code)
+        easyAssign.lastChatMessage = nil
     end
     if message and easyAssign.lastChatMessage ~= message then
         easyAssign.lastChatMessage = message
         chatSay(message, color_code)
-local list = {}
+    end
-for adr in com.list(typeName) do
+
-list[#list+1] = adr
+
 local function snapshotComponents(typeName)
-return list
+    local list = {}
     for adr in com.list(typeName) do
         list[#list + 1] = adr
     end
-easyAssign.known = {draconic_reactor = {}, flux_gate = {}}
+    return list
-for _, addr in ipairs(snapshotComponents("draconic_reactor")) do
+
-easyAssign.known.draconic_reactor[addr] = true
+
 local function initEasyKnown()
-for _, addr in ipairs(snapshotComponents("flux_gate")) do
+    easyAssign.known = {draconic_reactor = {}, flux_gate = {}}
-easyAssign.known.flux_gate[addr] = true
+    for _, addr in ipairs(snapshotComponents("draconic_reactor")) do
         easyAssign.known.draconic_reactor[addr] = true
     end
     for _, addr in ipairs(snapshotComponents("flux_gate")) do
         easyAssign.known.flux_gate[addr] = true
-if not easyAssign.known or not easyAssign.known[typeName] then
+    end
-initEasyKnown()
+
 
-for addr in com.list(typeName) do
+
-if not easyAssign.known[typeName][addr] then
+    if not easyAssign.known or not easyAssign.known[typeName] then
-easyAssign.known[typeName][addr] = true
+        initEasyKnown()
-return addr
+    end
     for addr in com.list(typeName) do
         if not easyAssign.known[typeName][addr] then
-return nil
+            easyAssign.known[typeName][addr] = true
             return addr
         end
     end
-if not addr then
+    return nil
-return false
+
 
-local entries = readReactorsFile() or {}
+
-for i=1,#entries do
+    if not addr then
-if entries[i].reactorAdr == addr or entries[i].upAdr == addr or entries[i].downAdr == addr then
+        return false
-return true
+    end
     local entries = readReactorsFile() or {}
     for i = 1, #entries do
-return false
+        if entries[i].reactorAdr == addr or entries[i].upAdr == addr or entries[i].downAdr == addr then
             return true
         end
     end
-if not reactorAdr then
+    return false
-return false
+
 
-local entries = readReactorsFile() or {}
+
-local newEntries = {}
+    if not reactorAdr then
-local removed = false
+        return false
-for i=1,#entries do
+    end
-if entries[i].reactorAdr ~= reactorAdr then
+    local entries = readReactorsFile() or {}
-newEntries[#newEntries+1] = entries[i]
+    local newEntries = {}
-else
+    local removed = false
-removed = true
+    for i = 1, #entries do
         if entries[i].reactorAdr ~= reactorAdr then
             newEntries[#newEntries + 1] = entries[i]
-if removed then
+        else
-writeReactorsFile(newEntries)
+            removed = true
         end
-return removed
+    end
     if removed then
         writeReactorsFile(newEntries)
     end
-local entries = readReactorsFile() or {}
+    return removed
-if #entries >= MAX_REACTORS then
+
-easyAssign.active = false
+
-easyAssign.message = "Достигнут лимит реакторов."
+
-return
+    local entries = readReactorsFile() or {}
     if #entries >= MAX_REACTORS then
-if not getChatBox() then
+        easyAssign.active = false
-easyAssign.active = false
+        easyAssign.message = "Достигнут лимит реакторов."
-easyAssign.message = "Ошибка: для работы нужен chat_box."
+        return
-return
+    end
     if not getChatBox() then
-easyAssign.active = true
+        easyAssign.active = false
-easyAssign.step = "reactor"
+        easyAssign.message = "Ошибка: для работы нужен chat_box."
-easyAssign.core = nil
+        return
-easyAssign.shield = nil
+    end
-easyAssign.output = nil
+    easyAssign.active = true
-easyAssign.saved = false
+    easyAssign.step = "reactor"
-easyAssign.message = nil
+    easyAssign.core = nil
-easyAssign.index = #entries + 1
+    easyAssign.shield = nil
-easyAssign.lastChatStep = nil
+    easyAssign.output = nil
-easyAssign.lastChatMessage = nil
+    easyAssign.saved = false
-initEasyKnown()
+    easyAssign.message = nil
-maybeChatSay("intro", "Легкий режим: подключите адаптер к реактору #" .. tostring(easyAssign.index) .. " и смотрите монитор.")
+    easyAssign.index = #entries + 1
     easyAssign.lastChatStep = nil
     easyAssign.lastChatMessage = nil
     initEasyKnown()
-handleMain = false
+    maybeChatSay("intro", "Легкий режим: подключите адаптер к реактору #" .. tostring(easyAssign.index) .. " и смотрите монитор.")
-handleStart = false
+
-handleOptions = false
+
-handleOverview = false
+
-handleAssign = true
+    handleMain = false
-local x = drawHeader("HiTech Classic is the best   (Гейты)")
+    handleStart = false
-drawSeparator(x)
+    handleOptions = false
-assignUi.reactors = {}
+    handleOverview = false
-assignUi.gates = {}
+    handleAssign = true
-assignUi.gateAddrs = {}
+    local x = drawHeader("HiTech Classic is the best   (Гейты)")
-assignUi.reactorAddrs = {}
+    drawSeparator(x)
-assignUi.gateUse = {}
+    assignUi.reactors = {}
-assignUi.selectedAdr = nil
+    assignUi.gates = {}
     assignUi.gateAddrs = {}
     assignUi.reactorAddrs = {}
-gpu.fill(1,4,x,21," ")
+    assignUi.gateUse = {}
-term.setCursor(1,2)
+    assignUi.selectedAdr = nil
-menuItem.back.x,menuItem.back.y = term.getCursor()
+    gpu.setBackground(color.grey)
-assignUi.back.x,assignUi.back.y,assignUi.back.w = menuItem.back.x,menuItem.back.y,textWidth(menuItem.back.name)
+    gpu.setForeground(color.white)
-gpu.setForeground(color.blue)
+    gpu.fill(1, 4, x, 21, " ")
-printf(menuItem.back.name)
+    term.setCursor(1, 2)
-menuItem.back.w = textWidth(menuItem.back.name)
+    menuItem.back.x, menuItem.back.y = term.getCursor()
     assignUi.back.x, assignUi.back.y, assignUi.back.w = menuItem.back.x, menuItem.back.y, textWidth(menuItem.back.name)
-term.setCursor(2,5)
+    gpu.setForeground(color.blue)
-printf("Выберите способ добавления гейтов:")
+    printf(menuItem.back.name)
-local heavyLabel = " Тяжелый способ (анализатор) "
+    menuItem.back.w = textWidth(menuItem.back.name)
-local easyLabel = " Легкий способ (подключение) "
+    gpu.setForeground(color.white)
-local heavyX, heavyY = 2, 7
+    term.setCursor(2, 5)
-local easyX, easyY = 2, 9
+    printf("Выберите способ добавления гейтов:")
-easyAssign.heavyBtn = {x=heavyX,y=heavyY,w=textWidth(heavyLabel)}
+    local heavyLabel = " Тяжелый способ (анализатор) "
-easyAssign.easyBtn = {x=easyX,y=easyY,w=textWidth(easyLabel)}
+    local easyLabel = " Легкий способ (подключение) "
-guiWrite(heavyX,heavyY,color.white,color.red,"%s",heavyLabel)
+    local heavyX, heavyY = 2, 7
-guiWrite(easyX,easyY,color.white,color.green,"%s",easyLabel)
+    local easyX, easyY = 2, 9
-if easyAssign.message then
+    easyAssign.heavyBtn = {x = heavyX, y = heavyY, w = textWidth(heavyLabel)}
-guiWrite(2,12,color.yellow,-1,"%s",easyAssign.message)
+    easyAssign.easyBtn = {x = easyX, y = easyY, w = textWidth(easyLabel)}
     guiWrite(heavyX, heavyY, color.white, color.red, "%s", heavyLabel)
     guiWrite(easyX, easyY, color.white, color.green, "%s", easyLabel)
     if easyAssign.message then
         guiWrite(2, 12, color.yellow, -1, "%s", easyAssign.message)
-handleMain = false
+    end
-handleStart = false
+
-handleOptions = false
+
-handleOverview = false
+
-handleAssign = true
+    handleMain = false
-local x = drawHeader("HiTech Classic is the best   (Гейты - Легкий)")
+    handleStart = false
-drawSeparator(x)
+    handleOptions = false
     handleOverview = false
     handleAssign = true
-gpu.fill(1,4,x,21," ")
+    local x = drawHeader("HiTech Classic is the best   (Гейты - Легкий)")
-term.setCursor(1,2)
+    drawSeparator(x)
-menuItem.back.x,menuItem.back.y = term.getCursor()
+    gpu.setBackground(color.grey)
-easyAssign.backBtn = {x=menuItem.back.x,y=menuItem.back.y,w=textWidth(menuItem.back.name)}
+    gpu.setForeground(color.white)
-gpu.setForeground(color.blue)
+    gpu.fill(1, 4, x, 21, " ")
-printf(menuItem.back.name)
+    term.setCursor(1, 2)
-menuItem.back.w = textWidth(menuItem.back.name)
+    menuItem.back.x, menuItem.back.y = term.getCursor()
     easyAssign.backBtn = {x = menuItem.back.x, y = menuItem.back.y, w = textWidth(menuItem.back.name)}
-term.setCursor(2,5)
+    gpu.setForeground(color.blue)
-printf("РЕАКТОР #%d", easyAssign.index or 1)
+    printf(menuItem.back.name)
-term.setCursor(2,7)
+    menuItem.back.w = textWidth(menuItem.back.name)
-if easyAssign.step == "reactor" then
+    gpu.setForeground(color.white)
-guiWrite(2,7,color.green,-1,"Подключите адаптер к ядру реактора.")
+    term.setCursor(2, 5)
-maybeChatSay("reactor", "Подключите адаптер к ядру реактора.", 255)
+    printf("РЕАКТОР #%d", easyAssign.index or 1)
-elseif easyAssign.step == "shield" then
+    term.setCursor(2, 7)
-guiWrite(2,7,color.green,-1,"Подключите адаптер к гейту ЩИТОВ.")
+    if easyAssign.step == "reactor" then
-maybeChatSay("shield", "Подключите адаптер к гейту ЩИТОВ.", 4096)
+        guiWrite(2, 7, color.green, -1, "Подключите адаптер к ядру реактора.")
-elseif easyAssign.step == "output" then
+        maybeChatSay("reactor", "Подключите адаптер к ядру реактора.", 255)
-guiWrite(2,7,color.green,-1,"Подключите адаптер к гейту ВЫВОДА.")
+    elseif easyAssign.step == "shield" then
-maybeChatSay("output", "Подключите адаптер к гейту ВЫВОДА.", 16711680)
+        guiWrite(2, 7, color.green, -1, "Подключите адаптер к гейту ЩИТОВ.")
-elseif easyAssign.step == "done" then
+        maybeChatSay("shield", "Подключите адаптер к гейту ЩИТОВ.", 4096)
-guiWrite(2,7,color.green,-1,"Реактор добавлен.")
+    elseif easyAssign.step == "output" then
-maybeChatSay("done", "Реактор добавлен. Смотрите монитор.", 65280)
+        guiWrite(2, 7, color.green, -1, "Подключите адаптер к гейту ВЫВОДА.")
         maybeChatSay("output", "Подключите адаптер к гейту ВЫВОДА.", 16711680)
-term.setCursor(2,9)
+    elseif easyAssign.step == "done" then
-printf("Ожидаю компонент...")
+        guiWrite(2, 7, color.green, -1, "Реактор добавлен.")
-local infoY = 11
+        maybeChatSay("done", "Реактор добавлен. Смотрите монитор.", 65280)
-local coreLine = "Ядро: " .. (easyAssign.core or "-")
+    end
-local shieldLine = "Щиты: " .. (easyAssign.shield or "-")
+    term.setCursor(2, 9)
-local outputLine = "Вывод: " .. (easyAssign.output or "-")
+    printf("Ожидаю компонент...")
-local coreColor = (easyAssign.step == "reactor") and color.blue or (easyAssign.core and color.green or color.white)
+    local infoY = 11
-local shieldColor = (easyAssign.step == "shield") and color.blue or (easyAssign.shield and color.green or color.white)
+    local coreLine = "Ядро: " .. (easyAssign.core or "-")
-local outputColor = (easyAssign.step == "output") and color.blue or (easyAssign.output and color.green or color.white)
+    local shieldLine = "Щиты: " .. (easyAssign.shield or "-")
-guiWrite(2,infoY,coreColor,-1,"%s",coreLine)
+    local outputLine = "Вывод: " .. (easyAssign.output or "-")
-guiWrite(2,infoY + 1,shieldColor,-1,"%s",shieldLine)
+    local coreColor = (easyAssign.step == "reactor") and color.blue or (easyAssign.core and color.green or color.white)
-guiWrite(2,infoY + 2,outputColor,-1,"%s",outputLine)
+    local shieldColor = (easyAssign.step == "shield") and color.blue or (easyAssign.shield and color.green or color.white)
-if easyAssign.message then
+    local outputColor = (easyAssign.step == "output") and color.blue or (easyAssign.output and color.green or color.white)
-guiWrite(2,infoY + 4,color.yellow,-1,"%s",easyAssign.message)
+    guiWrite(2, infoY, coreColor, -1, "%s", coreLine)
     guiWrite(2, infoY + 1, shieldColor, -1, "%s", shieldLine)
-if easyAssign.step == "done" then
+    guiWrite(2, infoY + 2, outputColor, -1, "%s", outputLine)
-local contLabel = " [Продолжить] "
+    if easyAssign.message then
-local finLabel = " [Завершить] "
+        guiWrite(2, infoY + 4, color.yellow, -1, "%s", easyAssign.message)
-local contX, contY = 2, infoY + 6
+    end
-local finX, finY = 2 + textWidth(contLabel) + 2, infoY + 6
+    if easyAssign.step == "done" then
-easyAssign.continueBtn = {x=contX,y=contY,w=textWidth(contLabel)}
+        local contLabel = " [Продолжить] "
-easyAssign.finishBtn = {x=finX,y=finY,w=textWidth(finLabel)}
+        local finLabel = " [Завершить] "
-guiWrite(contX,contY,color.white,color.green,"%s",contLabel)
+        local contX, contY = 2, infoY + 6
-guiWrite(finX,finY,color.white,color.red,"%s",finLabel)
+        local finX, finY = 2 + textWidth(contLabel) + 2, infoY + 6
         easyAssign.continueBtn = {x = contX, y = contY, w = textWidth(contLabel)}
         easyAssign.finishBtn = {x = finX, y = finY, w = textWidth(finLabel)}
         guiWrite(contX, contY, color.white, color.green, "%s", contLabel)
         guiWrite(finX, finY, color.white, color.red, "%s", finLabel)
-handleMain = false
+    end
-handleStart = false
+
-handleOptions = false
+
-handleOverview = false
+
-handleAssign = true
+    handleMain = false
-local x = drawHeader("HiTech Classic is the best   (Гейты)")
+    handleStart = false
-drawSeparator(x)
+    handleOptions = false
-assignUi.reactors = {}
+    handleOverview = false
-assignUi.gates = {}
+    handleAssign = true
-assignUi.gateAddrs = {}
+    local x = drawHeader("HiTech Classic is the best   (Гейты)")
-assignUi.reactorAddrs = {}
+    drawSeparator(x)
-assignUi.gateUse = {}
+    assignUi.reactors = {}
-assignUi.selectedAdr = nil
+    assignUi.gates = {}
     assignUi.gateAddrs = {}
     assignUi.reactorAddrs = {}
-gpu.fill(1,4,x,21," ")
+    assignUi.gateUse = {}
-term.setCursor(1,2)
+    assignUi.selectedAdr = nil
-menuItem.back.x,menuItem.back.y = term.getCursor()
+    gpu.setBackground(color.grey)
-assignUi.back.x,assignUi.back.y,assignUi.back.w = menuItem.back.x,menuItem.back.y,textWidth(menuItem.back.name)
+    gpu.setForeground(color.white)
-gpu.setForeground(color.blue)
+    gpu.fill(1, 4, x, 21, " ")
-printf(menuItem.back.name)
+    term.setCursor(1, 2)
-menuItem.back.w = textWidth(menuItem.back.name)
+    menuItem.back.x, menuItem.back.y = term.getCursor()
     assignUi.back.x, assignUi.back.y, assignUi.back.w = menuItem.back.x, menuItem.back.y, textWidth(menuItem.back.name)
-term.setCursor(2,4)
+    gpu.setForeground(color.blue)
-printf("Выберите реактор")
+    printf(menuItem.back.name)
-local reactorsList = listAddresses("draconic_reactor")
+    menuItem.back.w = textWidth(menuItem.back.name)
-local gates = listAddresses("flux_gate")
+    gpu.setForeground(color.white)
-assignUi.gateAddrs = gates
+    term.setCursor(2, 4)
-assignUi.reactorAddrs = reactorsList
+    printf("Выберите реактор")
-if #reactorsList == 0 or #gates < 2 then
+    local reactorsList = listAddresses("draconic_reactor")
-printf("Недостаточно реакторов или флюкс-гейтов.\n")
+    local gates = listAddresses("flux_gate")
-os.sleep(1)
+    assignUi.gateAddrs = gates
-screenOverview()
+    assignUi.reactorAddrs = reactorsList
-return
+    if #reactorsList == 0 or #gates < 2 then
         printf("Недостаточно реакторов или флюкс-гейтов.\n")
-local count = math.min(#reactorsList, MAX_REACTORS)
+        os.sleep(1)
-term.setCursor(2,5)
+        screenOverview()
-printf("Реакторы:")
+        return
-local rowY = 6
+    end
-for i=1,count do
+    local count = math.min(#reactorsList, MAX_REACTORS)
-term.setCursor(2,rowY)
+    term.setCursor(2, 5)
-local label = string.format("%d) %s",i,reactorsList[i])
+    printf("Реакторы:")
-if assignState.reactorIndex == i then
+    local rowY = 6
-guiWrite(2,rowY,color.black,color.blue,"%s",label)
+    for i = 1, count do
-else
+        term.setCursor(2, rowY)
-guiWrite(2,rowY,color.white,-1,"%s",label)
+        local label = string.format("%d) %s", i, reactorsList[i])
         if assignState.reactorIndex == i then
-assignUi.reactors[i] = {x=2,y=rowY,w=textWidth(label)}
+            guiWrite(2, rowY, color.black, color.blue, "%s", label)
-rowY = rowY + 1
+        else
             guiWrite(2, rowY, color.white, -1, "%s", label)
         end
-local entries = readReactorsFile() or {}
+        assignUi.reactors[i] = {x = 2, y = rowY, w = textWidth(label)}
-local gateUse = {}
+        rowY = rowY + 1
-for i=1,#entries do
+    end
-gateUse[entries[i].upAdr] = entries[i].reactorAdr
+
-gateUse[entries[i].downAdr] = entries[i].reactorAdr
+    local entries = readReactorsFile() or {}
     local gateUse = {}
-assignUi.gateUse = gateUse
+    for i = 1, #entries do
-local selectedAdr = assignState.reactorIndex and reactorsList[assignState.reactorIndex] or nil
+        gateUse[entries[i].upAdr] = entries[i].reactorAdr
-assignUi.selectedAdr = selectedAdr
+        gateUse[entries[i].downAdr] = entries[i].reactorAdr
-local selectedEntry = nil
+    end
-if selectedAdr then
+    assignUi.gateUse = gateUse
-for i=1,#entries do
+    local selectedAdr = assignState.reactorIndex and reactorsList[assignState.reactorIndex] or nil
-if entries[i].reactorAdr == selectedAdr then
+    assignUi.selectedAdr = selectedAdr
-selectedEntry = entries[i]
+    local selectedEntry = nil
-break
+    if selectedAdr then
         for i = 1, #entries do
             if entries[i].reactorAdr == selectedAdr then
                 selectedEntry = entries[i]
-assignUi.selectedEntry = selectedEntry
+                break
             end
-term.setCursor(40,5)
+        end
-printf("Гейты:")
+    end
-local gateY = 6
+    assignUi.selectedEntry = selectedEntry
-for i=1,#gates do
+
-if gateY > 24 then
+    term.setCursor(40, 5)
-break
+    printf("Гейты:")
     local gateY = 6
-term.setCursor(40,gateY)
+    for i = 1, #gates do
-local label = string.format("%d) %s",i,gates[i])
+        if gateY > 24 then
-local colorGate = color.dim
+            break
-if selectedAdr then
+        end
-if selectedEntry and (gates[i] == selectedEntry.upAdr or gates[i] == selectedEntry.downAdr) then
+        term.setCursor(40, gateY)
-colorGate = color.green
+        local label = string.format("%d) %s", i, gates[i])
-elseif assignState.shieldGateIdx == i or assignState.outGateIdx == i then
+        local colorGate = color.dim
-colorGate = color.green
+        if selectedAdr then
-elseif gateUse[gates[i]] and gateUse[gates[i]] ~= selectedAdr then
+            if selectedEntry and (gates[i] == selectedEntry.upAdr or gates[i] == selectedEntry.downAdr) then
-colorGate = color.red
+                colorGate = color.green
-else
+            elseif assignState.shieldGateIdx == i or assignState.outGateIdx == i then
-colorGate = color.dim
+                colorGate = color.green
             elseif gateUse[gates[i]] and gateUse[gates[i]] ~= selectedAdr then
                 colorGate = color.red
-guiWrite(40,gateY,colorGate,-1,"%s",label)
+            else
-assignUi.gates[i] = {x=40,y=gateY,w=textWidth(label)}
+                colorGate = color.dim
-gateY = gateY + 1
+            end
         end
         guiWrite(40, gateY, colorGate, -1, "%s", label)
         assignUi.gates[i] = {x = 40, y = gateY, w = textWidth(label)}
         gateY = gateY + 1
-if assignMode == "manual" then
+    end
-screenAssignManual()
+
-elseif assignMode == "easy" then
+
-screenAssignEasy()
+
-else
+    if assignMode == "manual" then
-screenAssignChoice()
+        screenAssignManual()
     elseif assignMode == "easy" then
         screenAssignEasy()
     else
         screenAssignChoice()
-if easyAssign.step == "reactor" then
+    end
-if componentType ~= "draconic_reactor" then
+
-easyAssign.message = "Нужен draconic_reactor."
+
-screenAssignEasy()
+
-return
+    if easyAssign.step == "reactor" then
         if componentType ~= "draconic_reactor" then
-if isAddressUsed(address) then
+            easyAssign.message = "Нужен draconic_reactor."
-easyAssign.message = "Адрес уже используется."
+            screenAssignEasy()
-screenAssignEasy()
+            return
-return
+        end
         if isAddressUsed(address) then
-easyAssign.core = address
+            easyAssign.message = "Адрес уже используется."
-easyAssign.step = "shield"
+            screenAssignEasy()
-easyAssign.message = "Реактор принят."
+            return
-maybeChatSay("accepted", "Реактор принят. Смотри монитор.")
+        end
-screenAssignEasy()
+        easyAssign.core = address
-return
+        easyAssign.step = "shield"
         easyAssign.message = "Реактор принят."
-if easyAssign.step == "shield" then
+        maybeChatSay("accepted", "Реактор принят. Смотри монитор.")
-if componentType ~= "flux_gate" then
+        screenAssignEasy()
-easyAssign.message = "Нужен flux_gate."
+        return
-screenAssignEasy()
+    end
-return
+    if easyAssign.step == "shield" then
         if componentType ~= "flux_gate" then
-if isAddressUsed(address) then
+            easyAssign.message = "Нужен flux_gate."
-easyAssign.message = "Адрес уже используется."
+            screenAssignEasy()
-screenAssignEasy()
+            return
-return
+        end
         if isAddressUsed(address) then
-easyAssign.shield = address
+            easyAssign.message = "Адрес уже используется."
-easyAssign.step = "output"
+            screenAssignEasy()
-easyAssign.message = "Гейт щитов принят."
+            return
-maybeChatSay("accepted", "Гейт щитов принят. Смотри монитор.")
+        end
-screenAssignEasy()
+        easyAssign.shield = address
-return
+        easyAssign.step = "output"
         easyAssign.message = "Гейт щитов принят."
-if easyAssign.step == "output" then
+        maybeChatSay("accepted", "Гейт щитов принят. Смотри монитор.")
-if componentType ~= "flux_gate" then
+        screenAssignEasy()
-easyAssign.message = "Нужен flux_gate."
+        return
-screenAssignEasy()
+    end
-return
+    if easyAssign.step == "output" then
         if componentType ~= "flux_gate" then
-if isAddressUsed(address) or address == easyAssign.shield then
+            easyAssign.message = "Нужен flux_gate."
-easyAssign.message = "Нужны два разных гейта."
+            screenAssignEasy()
-screenAssignEasy()
+            return
-return
+        end
         if isAddressUsed(address) or address == easyAssign.shield then
-easyAssign.output = address
+            easyAssign.message = "Нужны два разных гейта."
-local saved = saveAssignedGates(easyAssign.core, easyAssign.shield, easyAssign.output)
+            screenAssignEasy()
-if not saved then
+            return
-easyAssign.message = "Не удалось сохранить."
+        end
-screenAssignEasy()
+        easyAssign.output = address
-return
+        local saved = saveAssignedGates(easyAssign.core, easyAssign.shield, easyAssign.output)
         if not saved then
-easyAssign.saved = true
+            easyAssign.message = "Не удалось сохранить."
-easyAssign.step = "done"
+            screenAssignEasy()
-easyAssign.message = "Успешно сохранено."
+            return
-maybeChatSay("accepted", "Успешно сохранено. Смотри монитор.")
+        end
-screenAssignEasy()
+        easyAssign.saved = true
-return
+        easyAssign.step = "done"
         easyAssign.message = "Успешно сохранено."
         maybeChatSay("accepted", "Успешно сохранено. Смотри монитор.")
         screenAssignEasy()
         return
-if not handleAssign or assignMode ~= "easy" or not easyAssign.active then
+    end
-return
+
 
-acceptEasyComponent(address, componentType)
+
     if not handleAssign or assignMode ~= "easy" or not easyAssign.active then
         return
     end
-if not handleAssign or assignMode ~= "easy" or not easyAssign.active then
+    acceptEasyComponent(address, componentType)
-return
+
 
-if easyAssign.step == "reactor" then
+
-local addr = findNewComponent("draconic_reactor")
+    if not handleAssign or assignMode ~= "easy" or not easyAssign.active then
-if addr then
+        return
-acceptEasyComponent(addr, "draconic_reactor")
+    end
     if easyAssign.step == "reactor" then
-elseif easyAssign.step == "shield" or easyAssign.step == "output" then
+        local addr = findNewComponent("draconic_reactor")
-local addr = findNewComponent("flux_gate")
+        if addr then
-if addr then
+            acceptEasyComponent(addr, "draconic_reactor")
-acceptEasyComponent(addr, "flux_gate")
+        end
     elseif easyAssign.step == "shield" or easyAssign.step == "output" then
         local addr = findNewComponent("flux_gate")
         if addr then
             acceptEasyComponent(addr, "flux_gate")
         end
     end
 end
-autoWaitTempByAdr = {}
+
-chargeRequestByAdr = {}
+
-for i=1,#reactors do
+    autostateByAdr = {}
-local r = reactors[i]
+    flowInitByAdr = {}
-autostateByAdr[r.reactorAdr] = r.autostate
+    autoWaitTempByAdr = {}
-flowInitByAdr[r.reactorAdr] = r.flowInit
+    chargeRequestByAdr = {}
-chargeRequestByAdr[r.reactorAdr] = r.chargeRequested
+    for i = 1, #reactors do
         local r = reactors[i]
-syncActive()
+        autostateByAdr[r.reactorAdr] = r.autostate
-local prevAdr = reactors[activeIndex] and reactors[activeIndex].reactorAdr
+        flowInitByAdr[r.reactorAdr] = r.flowInit
-reactors = buildReactors() or reactors
+        chargeRequestByAdr[r.reactorAdr] = r.chargeRequested
-local idx = 1
+    end
-if pendingActiveReactorAdr then
+    syncActive()
-for i=1,#reactors do
+    local prevAdr = reactors[activeIndex] and reactors[activeIndex].reactorAdr
-if reactors[i].reactorAdr == pendingActiveReactorAdr then
+    reactors = buildReactors() or reactors
-idx = i
+    local idx = 1
-break
+    if pendingActiveReactorAdr then
         for i = 1, #reactors do
             if reactors[i].reactorAdr == pendingActiveReactorAdr then
-pendingActiveReactorAdr = nil
+                idx = i
-elseif lastAddedReactorAdr then
+                break
-for i=1,#reactors do
+            end
-if reactors[i].reactorAdr == lastAddedReactorAdr then
+        end
-idx = i
+        pendingActiveReactorAdr = nil
-break
+    elseif lastAddedReactorAdr then
         for i = 1, #reactors do
             if reactors[i].reactorAdr == lastAddedReactorAdr then
-lastAddedReactorAdr = nil
+                idx = i
-elseif prevAdr then
+                break
-for i=1,#reactors do
+            end
-if reactors[i].reactorAdr == prevAdr then
+        end
-idx = i
+        lastAddedReactorAdr = nil
-break
+    elseif prevAdr then
         for i = 1, #reactors do
             if reactors[i].reactorAdr == prevAdr then
                 idx = i
-setActive(idx)
+                break
-if openAssign and newEntriesAdded then
+            end
-resetAssignState()
+        end
-screenAssign()
+    end
-return
+    setActive(idx)
     if openAssign and newEntriesAdded then
-if handleMain then
+        resetAssignState()
-screenMain()
+        screenAssign()
-else
+        return
-screenOverview()
+    end
     if handleMain then
         screenMain()
     else
         screenOverview()
-assignState.reactorIndex = nil
+    end
-assignState.reactorAdr = nil
+
-assignState.shieldGateIdx = nil
+
-assignState.shieldGateAdr = nil
+
-assignState.outGateIdx = nil
+    assignState.reactorIndex = nil
-assignState.outGateAdr = nil
+    assignState.reactorAdr = nil
-assignState.step = "reactor"
+    assignState.shieldGateIdx = nil
     assignState.shieldGateAdr = nil
     assignState.outGateIdx = nil
     assignState.outGateAdr = nil
-if not reactorAdr or not shieldAdr or not outAdr then
+    assignState.step = "reactor"
-return false
+
 
-local entries = readReactorsFile() or {}
+
-local updated = false
+    if not reactorAdr or not shieldAdr or not outAdr then
-for i=1,#entries do
+        return false
-if entries[i].reactorAdr == reactorAdr then
+    end
-entries[i].upAdr = outAdr
+    local entries = readReactorsFile() or {}
-entries[i].downAdr = shieldAdr
+    local updated = false
-updated = true
+    for i = 1, #entries do
-break
+        if entries[i].reactorAdr == reactorAdr then
             entries[i].upAdr = outAdr
             entries[i].downAdr = shieldAdr
-if not updated then
+            updated = true
-entries[#entries+1] = {
+            break
-reactorAdr = reactorAdr,
+        end
-upAdr = outAdr,
+    end
-downAdr = shieldAdr
+    if not updated then
         entries[#entries + 1] = {
             reactorAdr = reactorAdr,
-if #entries > MAX_REACTORS then
+            upAdr = outAdr,
-local trimmed = {}
+            downAdr = shieldAdr
-for i=1,MAX_REACTORS do
+        }
-trimmed[i] = entries[i]
+    end
     if #entries > MAX_REACTORS then
-entries = trimmed
+        local trimmed = {}
         for i = 1, MAX_REACTORS do
-writeReactorsFile(entries)
+            trimmed[i] = entries[i]
-pendingActiveReactorAdr = reactorAdr
+        end
-return true
+        entries = trimmed
     end
     writeReactorsFile(entries)
     pendingActiveReactorAdr = reactorAdr
-local reactorsList = listAddresses("draconic_reactor")
+    return true
-if not reactorsList[reactorIndex] then
+
-return false
+
 local function clearAssignedGates(reactorIndex)
-local entries = readReactorsFile() or {}
+    local reactorsList = listAddresses("draconic_reactor")
-local newEntries = {}
+    if not reactorsList[reactorIndex] then
-for i=1,#entries do
+        return false
-if entries[i].reactorAdr ~= reactorsList[reactorIndex] then
+    end
-newEntries[#newEntries+1] = entries[i]
+    local entries = readReactorsFile() or {}
     local newEntries = {}
     for i = 1, #entries do
-writeReactorsFile(newEntries)
+        if entries[i].reactorAdr ~= reactorsList[reactorIndex] then
-return true
+            newEntries[#newEntries + 1] = entries[i]
         end
--- Экран обзора реакторов
+    end
     writeReactorsFile(newEntries)
-handleMain = false
+    return true
-handleStart = false
+
-handleOptions = false
+
-handleOverview = true
+
-handleAssign = false
+    handleMain = false
-local x = drawHeader("HiTech Classic is the best")
+    handleStart = false
-reactors = reactors or {}
+    handleOptions = false
-local cols = overviewCols(x)
+    handleOverview = true
-term.setCursor(1,2)
+    handleAssign = false
-menuItem.options.x,menuItem.options.y = term.getCursor()
+    local x = drawHeader("HiTech Classic is the best")
-gpu.setForeground(color.blue)
+    reactors = reactors or {}
-printf(menuItem.options.name)
+    local cols = overviewCols(x)
-menuItem.options.w = textWidth(menuItem.options.name)
+    term.setCursor(1, 2)
     menuItem.options.x, menuItem.options.y = term.getCursor()
-menuItem.overview.x,menuItem.overview.y = term.getCursor()
+    gpu.setForeground(color.blue)
-gpu.setForeground(color.blue)
+    printf(menuItem.options.name)
-printf(menuItem.overview.name)
+    menuItem.options.w = textWidth(menuItem.options.name)
-menuItem.overview.w = textWidth(menuItem.overview.name)
+    gpu.setForeground(color.white)
     menuItem.overview.x, menuItem.overview.y = term.getCursor()
-menuItem.refresh.x,menuItem.refresh.y = term.getCursor()
+    gpu.setForeground(color.blue)
-gpu.setForeground(color.blue)
+    printf(menuItem.overview.name)
-printf(menuItem.refresh.name)
+    menuItem.overview.w = textWidth(menuItem.overview.name)
-menuItem.refresh.w = textWidth(menuItem.refresh.name)
+    gpu.setForeground(color.white)
     menuItem.refresh.x, menuItem.refresh.y = term.getCursor()
-menuItem.gates.x,menuItem.gates.y = term.getCursor()
+    gpu.setForeground(color.blue)
-gpu.setForeground(color.blue)
+    printf(menuItem.refresh.name)
-printf(menuItem.gates.name)
+    menuItem.refresh.w = textWidth(menuItem.refresh.name)
-menuItem.gates.w = textWidth(menuItem.gates.name)
+    gpu.setForeground(color.white)
     menuItem.gates.x, menuItem.gates.y = term.getCursor()
-for i=1,#reactors do
+    gpu.setForeground(color.blue)
-local label = string.format("[R%d]",i)
+    printf(menuItem.gates.name)
-reactors[i].tab.x,reactors[i].tab.y = term.getCursor()
+    menuItem.gates.w = textWidth(menuItem.gates.name)
-reactors[i].tab.w = textWidth(label)
+    gpu.setForeground(color.white)
-if i == activeIndex then
+    for i = 1, #reactors do
-guiWrite(reactors[i].tab.x,reactors[i].tab.y,color.black,color.orange,"%s",label)
+        local label = string.format("[R%d]", i)
-else
+        reactors[i].tab.x, reactors[i].tab.y = term.getCursor()
-guiWrite(reactors[i].tab.x,reactors[i].tab.y,color.blue,color.white,"%s",label)
+        reactors[i].tab.w = textWidth(label)
         if i == activeIndex then
-printf(" ")
+            guiWrite(reactors[i].tab.x, reactors[i].tab.y, color.black, color.orange, "%s", label)
         else
-drawSeparator(x)
+            guiWrite(reactors[i].tab.x, reactors[i].tab.y, color.blue, color.white, "%s", label)
         end
         printf(" ")
-gpu.fill(1,4,x,21," ")
+    end
-if #reactors == 0 then
+    drawSeparator(x)
-term.setCursor(2,5)
+    gpu.setBackground(color.grey)
-printf("Нет настроенных реакторов.")
+    gpu.setForeground(color.white)
-term.setCursor(2,6)
+    gpu.fill(1, 4, x, 21, " ")
-printf("Откройте \"Гейты\" и назначьте гейты.")
+    if #reactors == 0 then
-return
+        term.setCursor(2, 5)
         printf("Нет настроенных реакторов.")
         term.setCursor(2, 6)
-gpu.setBackground(color.panel)
+        printf("Откройте \"Гейты\" и назначьте гейты.")
         return
-gpu.fill(2,4,x-2,6," ")
+    end
-term.setCursor(3,4)
+
-printf("Сводка")
+    gpu.setBackground(color.panel)
-term.setCursor(3,5)
+    gpu.setForeground(color.white)
-printf("Суммарная прибыль:")
+    gpu.fill(2, 4, x - 2, 6, " ")
-term.setCursor(28,5)
+    term.setCursor(3, 4)
-getCord(summaryProfitCord)
+    printf("Сводка")
-term.setCursor(3,6)
+    term.setCursor(3, 5)
-printf("Суммарная EU:")
+    printf("Суммарная прибыль:")
-term.setCursor(28,6)
+    term.setCursor(28, 5)
-getCord(summaryEuCord)
+    getCord(summaryProfitCord)
-term.setCursor(3,7)
+    term.setCursor(3, 6)
-printf("Тратим на щиты RF:")
+    printf("Суммарная EU:")
-term.setCursor(28,7)
+    term.setCursor(28, 6)
-getCord(summaryShieldCord)
+    getCord(summaryEuCord)
-term.setCursor(3,8)
+    term.setCursor(3, 7)
-printf("Суммарная выработка:")
+    printf("Тратим на щиты RF:")
-term.setCursor(28,8)
+    term.setCursor(28, 7)
-getCord(summaryGenCord)
+    getCord(summaryShieldCord)
-term.setCursor(3,9)
+    term.setCursor(3, 8)
-printf("Максимум прибыли RF/EU:")
+    printf("Суммарная выработка:")
-term.setCursor(28,9)
+    term.setCursor(28, 8)
-getCord(summaryMaxProfitCord)
+    getCord(summaryGenCord)
-local autoX = math.max(40, x - 33)
+    term.setCursor(3, 9)
-term.setCursor(autoX,4)
+    printf("Максимум прибыли RF/EU:")
-printf("Выключены автоматически:")
+    term.setCursor(28, 9)
-term.setCursor(autoX,5)
+    getCord(summaryMaxProfitCord)
-getCord(autoStoppedCord)
+    local autoX = math.max(40, x - 33)
     term.setCursor(autoX, 4)
-gpu.setBackground(color.dark)
+    printf("Выключены автоматически:")
     term.setCursor(autoX, 5)
-gpu.fill(2,11,x-2,1," ")
+    getCord(autoStoppedCord)
-term.setCursor(2,11)
+
-printf("#")
+    gpu.setBackground(color.dark)
-term.setCursor(cols.status,11)
+    gpu.setForeground(color.white)
-printf("СТАТУС")
+    gpu.fill(2, 11, x - 2, 1, " ")
-term.setCursor(cols.temp,11)
+    term.setCursor(2, 11)
-printf(" ТЕМП")
+    printf("#")
-term.setCursor(cols.fuel,11)
+    term.setCursor(cols.status, 11)
-printf("ТОПЛИВО")
+    printf("СТАТУС")
-term.setCursor(cols.profit,11)
+    term.setCursor(cols.temp, 11)
-printf("ПРИБЫЛЬ")
+    printf(" ТЕМП")
-term.setCursor(cols.gen,11)
+    term.setCursor(cols.fuel, 11)
-printf("ГЕН")
+    printf("ТОПЛИВО")
-term.setCursor(cols.flow,11)
+    term.setCursor(cols.profit, 11)
-printf("ПОТОК")
+    printf("ПРИБЫЛЬ")
-term.setCursor(cols.ctrl,11)
+    term.setCursor(cols.gen, 11)
-printf("УПР")
+    printf("ГЕН")
-gpu.setForeground(color.dim)
+    term.setCursor(cols.flow, 11)
-gpu.fill(2,12,x-2,1,"-")
+    printf("ПОТОК")
     term.setCursor(cols.ctrl, 11)
     printf("УПР")
-local rowY = 13
+    gpu.setForeground(color.dim)
-for i=1,#reactors do
+    gpu.fill(2, 12, x - 2, 1, "-")
-local r = reactors[i]
+    gpu.setForeground(color.white)
-term.setCursor(2,rowY)
+    gpu.setBackground(color.grey)
-printf("#%d",i)
+    local rowY = 13
-term.setCursor(cols.status,rowY)
+    for i = 1, #reactors do
-r.row.status = {x=cols.status,y=rowY}
+        local r = reactors[i]
-term.setCursor(cols.temp,rowY)
+        term.setCursor(2, rowY)
-r.row.temp = {x=cols.temp,y=rowY}
+        printf("#%d", i)
-term.setCursor(cols.fuel,rowY)
+        term.setCursor(cols.status, rowY)
-r.row.fuel = {x=cols.fuel,y=rowY}
+        r.row.status = {x = cols.status, y = rowY}
-term.setCursor(cols.profit,rowY)
+        term.setCursor(cols.temp, rowY)
-r.row.profit = {x=cols.profit,y=rowY}
+        r.row.temp = {x = cols.temp, y = rowY}
-term.setCursor(cols.gen,rowY)
+        term.setCursor(cols.fuel, rowY)
-r.row.gen = {x=cols.gen,y=rowY}
+        r.row.fuel = {x = cols.fuel, y = rowY}
-term.setCursor(cols.flow,rowY)
+        term.setCursor(cols.profit, rowY)
-r.row.flow = {x=cols.flow,y=rowY}
+        r.row.profit = {x = cols.profit, y = rowY}
-term.setCursor(cols.ctrl,rowY)
+        term.setCursor(cols.gen, rowY)
-r.control = r.control or {}
+        r.row.gen = {x = cols.gen, y = rowY}
-r.control.dec = {x=cols.ctrl,y=rowY,w=3}
+        term.setCursor(cols.flow, rowY)
-term.setCursor(cols.ctrl + 4,rowY)
+        r.row.flow = {x = cols.flow, y = rowY}
-r.control.inc = {x=cols.ctrl + 4,y=rowY,w=3}
+        term.setCursor(cols.ctrl, rowY)
-term.setCursor(cols.ctrl + 8,rowY)
+        r.control = r.control or {}
-r.control.auto = {x=cols.ctrl + 8,y=rowY,w=4}
+        r.control.dec = {x = cols.ctrl, y = rowY, w = 3}
-term.setCursor(cols.ctrl + 13,rowY)
+        term.setCursor(cols.ctrl + 4, rowY)
-r.powerBtn.x,r.powerBtn.y = term.getCursor()
+        r.control.inc = {x = cols.ctrl + 4, y = rowY, w = 3}
-r.powerBtn.w = 3
+        term.setCursor(cols.ctrl + 8, rowY)
-rowY = rowY + 1
+        r.control.auto = {x = cols.ctrl + 8, y = rowY, w = 4}
         term.setCursor(cols.ctrl + 13, rowY)
         r.powerBtn.x, r.powerBtn.y = term.getCursor()
--- Инициализация главного экрана
+        r.powerBtn.w = 3
         rowY = rowY + 1
-handleOptions = false
+    end
-handleStart = false
+
-handleMain = true
+
-handleOverview = false
+
-handleAssign = false
+    handleOptions = false
-if not reactor or not upgate or not downgate then
+    handleStart = false
-screenOverview()
+    handleMain = true
-return
+    handleOverview = false
     handleAssign = false
-if reactors[activeIndex] and (not isComponentAlive(reactors[activeIndex].reactorAdr) or not isComponentAlive(reactors[activeIndex].upAdr) or not isComponentAlive(reactors[activeIndex].downAdr)) then
+    if not reactor or not upgate or not downgate then
-refreshReactors(false)
+        screenOverview()
-screenOverview()
+        return
-return
+    end
     if reactors[activeIndex] and (not isComponentAlive(reactors[activeIndex].reactorAdr) or
-local x = drawHeader("HiTech Classic is the best")
+        not isComponentAlive(reactors[activeIndex].upAdr) or
-local ok, inf = pcall(reactor.getReactorInfo)
+        not isComponentAlive(reactors[activeIndex].downAdr)) then
-if not ok or type(inf) ~= "table" then
+        refreshReactors(false)
-refreshReactors(false)
+        screenOverview()
-screenOverview()
+        return
-return
+    end
     local x = drawHeader("HiTech Classic is the best")
-if reactors[activeIndex] and (not isComponentAlive(reactors[activeIndex].reactorAdr) or not isComponentAlive(reactors[activeIndex].upAdr) or not isComponentAlive(reactors[activeIndex].downAdr)) then
+    local ok, inf = pcall(reactor.getReactorInfo)
-refreshReactors(false)
+    if not ok or type(inf) ~= "table" then
-screenOverview()
+        refreshReactors(false)
-return
+        screenOverview()
         return
-infcord.status.value = inf.status
+    end
-menuItem.options.x,menuItem.options.y =term.getCursor()
+    if reactors[activeIndex] and (not isComponentAlive(reactors[activeIndex].reactorAdr) or
-gpu.setForeground(color.blue)
+        not isComponentAlive(reactors[activeIndex].upAdr) or
-printf(menuItem.options.name)
+        not isComponentAlive(reactors[activeIndex].downAdr)) then
-menuItem.options.w = textWidth(menuItem.options.name)
+        refreshReactors(false)
         screenOverview()
-menuItem.overview.x,menuItem.overview.y = term.getCursor()
+        return
-gpu.setForeground(color.blue)
+    end
-printf(menuItem.overview.name)
+    infcord.status.value = inf.status
-menuItem.overview.w = textWidth(menuItem.overview.name)
+    menuItem.options.x, menuItem.options.y = term.getCursor()
     gpu.setForeground(color.blue)
-menuItem.refresh.x,menuItem.refresh.y = term.getCursor()
+    printf(menuItem.options.name)
-gpu.setForeground(color.blue)
+    menuItem.options.w = textWidth(menuItem.options.name)
-printf(menuItem.refresh.name)
+    gpu.setForeground(color.white)
-menuItem.refresh.w = textWidth(menuItem.refresh.name)
+    menuItem.overview.x, menuItem.overview.y = term.getCursor()
     gpu.setForeground(color.blue)
-menuItem.gates.x,menuItem.gates.y = term.getCursor()
+    printf(menuItem.overview.name)
-gpu.setForeground(color.blue)
+    menuItem.overview.w = textWidth(menuItem.overview.name)
-printf(menuItem.gates.name)
+    gpu.setForeground(color.white)
-menuItem.gates.w = textWidth(menuItem.gates.name)
+    menuItem.refresh.x, menuItem.refresh.y = term.getCursor()
     gpu.setForeground(color.blue)
-for i=1,#reactors do
+    printf(menuItem.refresh.name)
-local label = string.format("[R%d]",i)
+    menuItem.refresh.w = textWidth(menuItem.refresh.name)
-reactors[i].tab.x,reactors[i].tab.y = term.getCursor()
+    gpu.setForeground(color.white)
-reactors[i].tab.w = textWidth(label)
+    menuItem.gates.x, menuItem.gates.y = term.getCursor()
-if i == activeIndex then
+    gpu.setForeground(color.blue)
-guiWrite(reactors[i].tab.x,reactors[i].tab.y,color.black,color.orange,"%s",label)
+    printf(menuItem.gates.name)
-else
+    menuItem.gates.w = textWidth(menuItem.gates.name)
-guiWrite(reactors[i].tab.x,reactors[i].tab.y,color.blue,color.white,"%s",label)
+    gpu.setForeground(color.white)
     for i = 1, #reactors do
-printf(" ")
+        local label = string.format("[R%d]", i)
         reactors[i].tab.x, reactors[i].tab.y = term.getCursor()
-guiWrite(x-25,1,color.yellow,color.panel,"Макс. выраб.: ")
+        reactors[i].tab.w = textWidth(label)
-getCord(infcord.maxgen)
+        if i == activeIndex then
-if inf.generationRate > maxGenerationRate then
+            guiWrite(reactors[i].tab.x, reactors[i].tab.y, color.black, color.orange, "%s", label)
-maxGenerationRate = inf.generationRate
+        else
             guiWrite(reactors[i].tab.x, reactors[i].tab.y, color.blue, color.white, "%s", label)
-guiWrite(infcord.maxgen.x,infcord.maxgen.y,color.green,color.panel,"%s",numformat(maxGenerationRate))
+        end
-drawSeparator(x)
+        printf(" ")
-gpu.setBackground(color.panel)
+    end
-gpu.setForeground(color.blue)
+    guiWrite(x - 25, 1, color.yellow, color.panel, "Макс. выраб.: ")
-printf(" ПАРАМЕТРЫ ")
+    getCord(infcord.maxgen)
-term.setCursor(30,4)
+    if inf.generationRate > maxGenerationRate then
-printf(" УПРАВЛЕНИЕ ")
+        maxGenerationRate = inf.generationRate
     end
     guiWrite(infcord.maxgen.x, infcord.maxgen.y, color.green, color.panel, "%s", numformat(maxGenerationRate))
-term.setCursor(1,6)
+    drawSeparator(x)
-gpu.setBackground(color.panel)
+    gpu.setBackground(color.panel)
-printf(" Температура:     ")
+    gpu.setForeground(color.blue)
     printf(" ПАРАМЕТРЫ ")
-printf(" ")
+    term.setCursor(30, 4)
-getCord(infcord.temp)
+    printf(" УПРАВЛЕНИЕ ")
-guiWrite(infcord.temp.x,infcord.temp.y,-1,-1,"%0.2f\n",inf.temperature)
+    gpu.setBackground(color.grey)
-printf(" Вырабатывает:     ")
+    gpu.setForeground(color.white)
-getCord(infcord.generation)
+    term.setCursor(1, 6)
-guiWrite(infcord.generation.x,infcord.generation.y,-1,-1,"%s  \n",numformat(inf.generationRate))
+    gpu.setBackground(color.panel)
-gpu.setBackground(color.panel)
+    printf(" Температура:     ")
-printf (" Поток:           ")
+    gpu.setBackground(color.grey)
     printf(" ")
-printf(" ")
+    getCord(infcord.temp)
-getCord(infcord.flow)
+    guiWrite(infcord.temp.x, infcord.temp.y, -1, -1, "%0.2f\n", inf.temperature)
-infcord.flow.value = getGateFlow(upgate)
+    printf(" Вырабатывает:     ")
-guiWrite(infcord.flow.x,infcord.flow.y,-1,-1,"%s  ",numformat(infcord.flow.value))
+    getCord(infcord.generation)
-getCord(button.add)
+    guiWrite(infcord.generation.x, infcord.generation.y, -1, -1, "%s  \n", numformat(inf.generationRate))
-makeButton(button.add.x + 4, button.add.y ,button.add.name)
+    gpu.setBackground(color.panel)
-getCord(button.sub)
+    printf(" Поток:           ")
-makeButton(button.sub.x+2,button.sub.y,button.sub.name)
+    gpu.setBackground(color.grey)
     printf(" ")
-printf("\n")
+    getCord(infcord.flow)
-printf (" Итоговая мосч:    ")
+    infcord.flow.value = getGateFlow(upgate)
-getCord(infcord.puregen)
+    guiWrite(infcord.flow.x, infcord.flow.y, -1, -1, "%s  ", numformat(infcord.flow.value))
-guiWrite(infcord.puregen.x,infcord.puregen.y,-1,-1,"%s  \n",numformat(inf.generationRate - getGateFlow(downgate)))
+    getCord(button.add)
-gpu.setBackground(color.panel)
+    makeButton(button.add.x + 4, button.add.y, button.add.name)
-printf (" Поглощает:       ")
+    getCord(button.sub)
     makeButton(button.sub.x + 2, button.sub.y, button.sub.name)
-printf(" ")
+
-getCord(infcord.drain)
+    printf("\n")
-guiWrite(infcord.drain.x,infcord.drain.y,-1,-1,"%s  \n",numformat(getGateFlow(downgate)))
+    printf(" Итоговая мосч:    ")
     getCord(infcord.puregen)
-printf (" Мощность поля:    ")
+    guiWrite(infcord.puregen.x, infcord.puregen.y, -1, -1, "%s  \n", numformat(inf.generationRate - getGateFlow(downgate)))
-getCord(infcord.fstrth)
+    gpu.setBackground(color.panel)
-if inf.maxFieldStrength > 0 then
+    printf(" Поглощает:       ")
-guiWrite(infcord.fstrth.x,infcord.fstrth.y,-1,-1,"%d / %d (%0.2f %%) \n",inf.fieldStrength -inf.fieldDrainRate,inf.maxFieldStrength,((inf.fieldStrength-inf.fieldDrainRate)/inf.maxFieldStrength)*100)
+    gpu.setBackground(color.grey)
-else
+    printf(" ")
-guiWrite(infcord.fstrth.x,infcord.fstrth.y,-1,-1,"0 / 0 (0 %%) \n")
+    getCord(infcord.drain)
     guiWrite(infcord.drain.x, infcord.drain.y, -1, -1, "%s  \n", numformat(getGateFlow(downgate)))
-gpu.setBackground(color.panel)
+
-printf (" Насыщенность:    ")
+    printf(" Мощность поля:    ")
     getCord(infcord.fstrth)
-printf(" ")
+    if inf.maxFieldStrength > 0 then
-getCord(infcord.esturn)
+        guiWrite(infcord.fstrth.x, infcord.fstrth.y, -1, -1, "%d / %d (%0.2f %%) \n",
-if inf.maxEnergySaturation > 0 then
+            inf.fieldStrength - inf.fieldDrainRate,
-guiWrite(infcord.esturn.x,infcord.esturn.y,-1,-1,"%d / %d (%0.2f %%) \n",inf.energySaturation,inf.maxEnergySaturation,(inf.energySaturation/inf.maxEnergySaturation)*100)
+            inf.maxFieldStrength,
-else
+            ((inf.fieldStrength - inf.fieldDrainRate) / inf.maxFieldStrength) * 100)
-guiWrite(infcord.esturn.x,infcord.esturn.y,-1,-1,"0 / 0 (0 %%) \n")
+    else
         guiWrite(infcord.fstrth.x, infcord.fstrth.y, -1, -1, "0 / 0 (0 %%) \n")
-printf (" Топливо:          ")
+    end
-getCord(infcord.fuel)
+    gpu.setBackground(color.panel)
     printf(" Насыщенность:    ")
-if inf.fuelConversion/inf.maxFuelConversion < 0.78 then
+    gpu.setBackground(color.grey)
-guiWrite(infcord.fuel.x,infcord.fuel.y,-1,-1,"%d / %d (%0.2f %%)                           \n",inf.fuelConversion,inf.maxFuelConversion,(inf.fuelConversion/inf.maxFuelConversion)*100)
+    printf(" ")
-else
+    getCord(infcord.esturn)
-if inf.maxFuelConversion > 0 then
+    if inf.maxEnergySaturation > 0 then
-if inf.status == "online" or inf.status == "charging" or inf.status == "charged" then
+        guiWrite(infcord.esturn.x, infcord.esturn.y, -1, -1, "%d / %d (%0.2f %%) \n",
-guiWrite(infcord.fuel.x,infcord.fuel.y,color.red,-1,"%d / %d (%0.2f %%) Критический уровень топлива\n",inf.fuelConversion,inf.maxFuelConversion,(inf.fuelConversion/inf.maxFuelConversion)*100)
+            inf.energySaturation,
-else
+            inf.maxEnergySaturation,
-guiWrite(infcord.fuel.x,infcord.fuel.y,-1,-1,"%d / %d (%0.2f %%) Критический уровень топлива\n",inf.fuelConversion,inf.maxFuelConversion,(inf.fuelConversion/inf.maxFuelConversion)*100)
+            (inf.energySaturation / inf.maxEnergySaturation) * 100)
     else
-else
+        guiWrite(infcord.esturn.x, infcord.esturn.y, -1, -1, "0 / 0 (0 %%) \n")
-guiWrite(infcord.fuel.x,infcord.fuel.y,-1,-1,"0 / 0 (0 %%)                           \n")
+    end
     printf(" Топливо:          ")
     getCord(infcord.fuel)
-gpu.setBackground(color.panel)
+
-printf (" Расход топлива:  ")
+    if inf.fuelConversion / inf.maxFuelConversion < 0.78 then
         guiWrite(infcord.fuel.x, infcord.fuel.y, -1, -1, "%d / %d (%0.2f %%)                           \n",
-printf(" ")
+            inf.fuelConversion,
-getCord(infcord.fuelconv)
+            inf.maxFuelConversion,
-guiWrite(infcord.fuelconv.x,infcord.fuelconv.y,-1,-1,"%d\n",inf.fuelConversionRate)
+            (inf.fuelConversion / inf.maxFuelConversion) * 100)
     else
-getCord(infcord.core)
+        if inf.maxFuelConversion > 0 then
-if com.isAvailable("draconic_rf_storage") then
+            if inf.status == "online" or inf.status == "charging" or inf.status == "charged" then
-guiWrite(infcord.core.x,infcord.core.y,-1,-1,coreformat())
+                guiWrite(infcord.fuel.x, infcord.fuel.y, color.red, -1, "%d / %d (%0.2f %%) Критический уровень топлива\n",
                     inf.fuelConversion,
-printf("\n")
+                    inf.maxFuelConversion,
-button.stop.x,button.stop.y = term.getCursor()
+                    (inf.fuelConversion / inf.maxFuelConversion) * 100)
-button.start.x,button.start.y = button.stop.x,button.stop.y + 1
+            else
-button.charge.x,button.charge.y = button.stop.x,button.stop.y + 2
+                guiWrite(infcord.fuel.x, infcord.fuel.y, -1, -1, "%d / %d (%0.2f %%) Критический уровень топлива\n",
-button.stop.w = textWidth(button.stop.name)
+                    inf.fuelConversion,
-button.start.w = textWidth(button.start.name)
+                    inf.maxFuelConversion,
-button.charge.w = textWidth(button.charge.name)
+                    (inf.fuelConversion / inf.maxFuelConversion) * 100)
-local controlsY = button.stop.y + 3
+            end
-if not chargeHintDismissed then
+        else
-	local hint1 = "Перед первым запуском поставь поток на 535 000."
+            guiWrite(infcord.fuel.x, infcord.fuel.y, -1, -1, "0 / 0 (0 %%)                           \n")
-	local hint2 = "Потом включай."
+        end
-	chargeHint.x = 1
+    end
-	chargeHint.y = math.max(1, screenH - 1)
+    gpu.setBackground(color.panel)
-	local hintY2 = math.min(screenH, chargeHint.y + 1)
+    printf(" Расход топлива:  ")
-	local prevFg = gpu.getForeground()
+    gpu.setBackground(color.grey)
-	local prevBg = gpu.getBackground()
+    printf(" ")
-	gpu.setForeground(color.green)
+    getCord(infcord.fuelconv)
-	gpu.setBackground(color.grey)
+    guiWrite(infcord.fuelconv.x, infcord.fuelconv.y, -1, -1, "%d\n", inf.fuelConversionRate)
-	gpu.set(chargeHint.x, chargeHint.y, hint1)
+
-	if hintY2 ~= chargeHint.y then
+    getCord(infcord.core)
-		gpu.set(chargeHint.x, hintY2, hint2)
+    if com.isAvailable("draconic_rf_storage") then
-	end
+        guiWrite(infcord.core.x, infcord.core.y, -1, -1, coreformat())
-	gpu.setForeground(prevFg)
+    end
-	gpu.setBackground(prevBg)
+    printf("\n")
-	chargeHint.w = math.max(textWidth(hint1), textWidth(hint2))
+    button.stop.x, button.stop.y = term.getCursor()
-	chargeHint.visible = true
+    button.start.x, button.start.y = button.stop.x, button.stop.y + 1
-else
+    button.charge.x, button.charge.y = button.stop.x, button.stop.y + 2
-	chargeHint.visible = false
+    button.stop.w = textWidth(button.stop.name)
     button.start.w = textWidth(button.start.name)
-term.setCursor(button.stop.x, controlsY)
+    button.charge.w = textWidth(button.charge.name)
-printf("                   Автономный режим: ")
+    local controlsY = button.stop.y + 3
-getCord(button.autoon)
+    if not chargeHintDismissed then
-getCord(button.autooff)
+        local hint1 = "Перед первым запуском поставь поток на 535 000."
-if not autostate then
+        local hint2 = "Потом включай."
-guiWrite(button.autooff.x,button.autooff.y,color.red,color.black,"%s\n",button.autooff.name)
+        chargeHint.x = 1
-else
+        chargeHint.y = math.max(1, screenH - 1)
-guiWrite(button.autoon.x,button.autoon.y,color.green,color.black,"%s\n",button.autoon.name)
+        local hintY2 = math.min(screenH, chargeHint.y + 1)
         local prevFg = gpu.getForeground()
-checkButtons()
+        local prevBg = gpu.getBackground()
         gpu.setForeground(color.green)
         gpu.setBackground(color.grey)
--- Обновление обзора реакторов
+        gpu.set(chargeHint.x, chargeHint.y, hint1)
         if hintY2 ~= chargeHint.y then
-if not handleOverview then
+            gpu.set(chargeHint.x, hintY2, hint2)
-return
+        end
         gpu.setForeground(prevFg)
-if not reactors or #reactors == 0 then
+        gpu.setBackground(prevBg)
-return
+        chargeHint.w = math.max(textWidth(hint1), textWidth(hint2))
         chargeHint.visible = true
     else
-local stopPct = cfg.fuelStopPct or 98
+        chargeHint.visible = false
-local totalGen = 0
+    end
-local totalProfit = 0
+    term.setCursor(button.stop.x, controlsY)
-local totalShield = 0
+    printf("                   Автономный режим: ")
-local maxProfit = 0
+    getCord(button.autoon)
     getCord(button.autooff)
-for i=1,#reactors do
+    if not autostate then
-local r = reactors[i]
+        guiWrite(button.autooff.x, button.autooff.y, color.red, color.black, "%s\n", button.autooff.name)
-local ok, inf = pcall(r.reactor.getReactorInfo)
+    else
-if not ok or type(inf) ~= "table" then
+        guiWrite(button.autoon.x, button.autoon.y, color.green, color.black, "%s\n", button.autoon.name)
-guiWrite(r.row.status.x,r.row.status.y,color.red,-1,"ERR")
+    end
-guiWrite(r.row.temp.x,r.row.temp.y,color.red,-1,"----")
+    checkButtons()
-guiWrite(r.row.fuel.x,r.row.fuel.y,color.red,-1,"----")
+
-guiWrite(r.row.profit.x,r.row.profit.y,color.red,-1,"----")
+
-guiWrite(r.row.gen.x,r.row.gen.y,color.red,-1,"----")
+
-guiWrite(r.row.flow.x,r.row.flow.y,color.red,-1,"----")
+    if not handleOverview then
-else
+        return
-totalGen = totalGen + inf.generationRate
+    end
-guiWrite(r.row.gen.x,r.row.gen.y,-1,-1,"%s",numformat(inf.generationRate))
+    if not reactors or #reactors == 0 then
-local flow = getGateFlow(r.upgate)
+        return
-guiWrite(r.row.flow.x,r.row.flow.y,-1,-1,"%s",numformat(flow))
+    end
-local shieldFlow = getGateFlow(r.downgate)
+    gpu.setForeground(color.white)
-totalShield = totalShield + shieldFlow
+    local stopPct = cfg.fuelStopPct or 98
-local profit = inf.generationRate - shieldFlow
+    local totalGen = 0
-totalProfit = totalProfit + profit
+    local totalProfit = 0
-if profit > maxProfit then
+    local totalShield = 0
-maxProfit = profit
+    local maxProfit = 0
     gpu.setBackground(color.grey)
-guiWrite(r.row.profit.x,r.row.profit.y,-1,-1,"%s",numformat(profit))
+    for i = 1, #reactors do
-local tempColor = color.white
+        local r = reactors[i]
-if inf.temperature >= cfg.tempCriticalEdge then
+        local ok, inf = pcall(r.reactor.getReactorInfo)
-tempColor = color.red
+        if not ok or type(inf) ~= "table" then
-elseif inf.temperature >= cfg.safeModeTempWaitEdge then
+            guiWrite(r.row.status.x, r.row.status.y, color.red, -1, "ERR")
-tempColor = color.yellow
+            guiWrite(r.row.temp.x, r.row.temp.y, color.red, -1, "----")
             guiWrite(r.row.fuel.x, r.row.fuel.y, color.red, -1, "----")
-guiWrite(r.row.temp.x,r.row.temp.y,tempColor,-1,"%4.0fC",inf.temperature)
+            guiWrite(r.row.profit.x, r.row.profit.y, color.red, -1, "----")
-local fuelPct = 0
+            guiWrite(r.row.gen.x, r.row.gen.y, color.red, -1, "----")
-if inf.maxFuelConversion > 0 then
+            guiWrite(r.row.flow.x, r.row.flow.y, color.red, -1, "----")
-fuelPct = (inf.fuelConversion/inf.maxFuelConversion)*100
+        else
             totalGen = totalGen + inf.generationRate
-if autoStopped[r.reactorAdr] and (inf.status == "online" or inf.status == "charging" or inf.status == "charged") then
+            guiWrite(r.row.gen.x, r.row.gen.y, -1, -1, "%s", numformat(inf.generationRate))
-autoStopped[r.reactorAdr] = nil
+            local flow = getGateFlow(r.upgate)
             guiWrite(r.row.flow.x, r.row.flow.y, -1, -1, "%s", numformat(flow))
-if fuelPct >= stopPct and (inf.status == "online" or inf.status == "charging" or inf.status == "charged") then
+            local shieldFlow = getGateFlow(r.downgate)
-if not autoStopped[r.reactorAdr] then
+            totalShield = totalShield + shieldFlow
-r.reactor.stopReactor()
+            local profit = inf.generationRate - shieldFlow
-autoStopped[r.reactorAdr] = true
+            totalProfit = totalProfit + profit
             if profit > maxProfit then
                 maxProfit = profit
-local fuelColor = color.white
+            end
-if fuelPct >= 80 then
+            guiWrite(r.row.profit.x, r.row.profit.y, -1, -1, "%s", numformat(profit))
-fuelColor = color.red
+            local tempColor = color.white
             if inf.temperature >= cfg.tempCriticalEdge then
-guiWrite(r.row.fuel.x,r.row.fuel.y,fuelColor,-1,"%5.1f%%",fuelPct)
+                tempColor = color.red
-local stColor = color.white
+            elseif inf.temperature >= cfg.safeModeTempWaitEdge then
-if inf.status == "online" or inf.status == "charging" or inf.status == "charged" then
+                tempColor = color.yellow
-stColor = color.green
+            end
-elseif inf.status == "offline" or inf.status == "stopping" then
+            guiWrite(r.row.temp.x, r.row.temp.y, tempColor, -1, "%4.0fC", inf.temperature)
-stColor = color.red
+            local fuelPct = 0
             if inf.maxFuelConversion > 0 then
-guiWrite(r.row.status.x,r.row.status.y,stColor,-1,"%s",statusText(inf.status))
+                fuelPct = (inf.fuelConversion / inf.maxFuelConversion) * 100
-makePowerButton(r.control.dec.x,r.control.dec.y,"[-]",color.dim,color.white)
+            end
-makePowerButton(r.control.inc.x,r.control.inc.y,"[+]",color.dim,color.white)
+            if autoStopped[r.reactorAdr] and (inf.status == "online" or inf.status == "charging" or inf.status == "charged") then
-local autoColor = r.autostate and color.green or color.red
+                autoStopped[r.reactorAdr] = nil
-makePowerButton(r.control.auto.x,r.control.auto.y,"AUTO",autoColor,color.white)
+            end
-if inf.status == "online" or inf.status == "charging" or inf.status == "charged" then
+            if fuelPct >= stopPct and (inf.status == "online" or inf.status == "charging" or inf.status == "charged") then
-r.powerBtn.action = "stop"
+                if not autoStopped[r.reactorAdr] then
-makePowerButton(r.powerBtn.x,r.powerBtn.y,"PWR",color.red,color.white)
+                    r.reactor.stopReactor()
-else
+                    autoStopped[r.reactorAdr] = true
-r.powerBtn.action = "start"
+                end
-makePowerButton(r.powerBtn.x,r.powerBtn.y,"PWR",color.green,color.white)
+            end
             local fuelColor = color.white
             if fuelPct >= 80 then
                 fuelColor = color.red
-if totalProfit > maxSummaryProfit then
+            end
-maxSummaryProfit = totalProfit
+            guiWrite(r.row.fuel.x, r.row.fuel.y, fuelColor, -1, "%5.1f%%", fuelPct)
             local stColor = color.white
-guiWrite(summaryProfitCord.x,summaryProfitCord.y,color.white,color.panel,"%s",numformat(totalProfit))
+            if inf.status == "online" or inf.status == "charging" or inf.status == "charged" then
-guiWrite(summaryEuCord.x,summaryEuCord.y,color.white,color.panel,"%s",numformat(math.floor(totalProfit/8)))
+                stColor = color.green
-guiWrite(summaryShieldCord.x,summaryShieldCord.y,color.white,color.panel,"%s",numformat(totalShield))
+            elseif inf.status == "offline" or inf.status == "stopping" then
-guiWrite(summaryGenCord.x,summaryGenCord.y,color.white,color.panel,"%s",numformat(totalGen))
+                stColor = color.red
-guiWrite(summaryMaxProfitCord.x,summaryMaxProfitCord.y,color.white,color.panel,"%s / %s",numformat(maxSummaryProfit),numformat(math.floor(maxSummaryProfit/8)))
+            end
-local autoList = {}
+            guiWrite(r.row.status.x, r.row.status.y, stColor, -1, "%s", statusText(inf.status))
-for i=1,#reactors do
+            makePowerButton(r.control.dec.x, r.control.dec.y, "[-]", color.dim, color.white)
-if autoStopped[reactors[i].reactorAdr] then
+            makePowerButton(r.control.inc.x, r.control.inc.y, "[+]", color.dim, color.white)
-autoList[#autoList+1] = "R"..i
+            local autoColor = r.autostate and color.green or color.red
             makePowerButton(r.control.auto.x, r.control.auto.y, "AUTO", autoColor, color.white)
             if inf.status == "online" or inf.status == "charging" or inf.status == "charged" then
-local autoText = "нет"
+                r.powerBtn.action = "stop"
-if #autoList > 0 then
+                makePowerButton(r.powerBtn.x, r.powerBtn.y, "PWR", color.red, color.white)
-autoText = table.concat(autoList, ", ")
+            else
                 r.powerBtn.action = "start"
-guiWrite(autoStoppedCord.x,autoStoppedCord.y,color.red,-1,"%s",autoText)
+                makePowerButton(r.powerBtn.x, r.powerBtn.y, "PWR", color.green, color.white)
             end
         end
     end
     if totalProfit > maxSummaryProfit then
         maxSummaryProfit = totalProfit
     end
     guiWrite(summaryProfitCord.x, summaryProfitCord.y, color.white, color.panel, "%s", numformat(totalProfit))
-local rd = true
+    guiWrite(summaryEuCord.x, summaryEuCord.y, color.white, color.panel, "%s", numformat(math.floor(totalProfit / 8)))
-while rd do
+    guiWrite(summaryShieldCord.x, summaryShieldCord.y, color.white, color.panel, "%s", numformat(totalShield))
-gpu.fill(param.x, param.y, #tostring(param.value), 1, " ")
+    guiWrite(summaryGenCord.x, summaryGenCord.y, color.white, color.panel, "%s", numformat(totalGen))
-term.setCursor(param.x,param.y)
+    guiWrite(summaryMaxProfitCord.x, summaryMaxProfitCord.y, color.white, color.panel, "%s / %s",
         numformat(maxSummaryProfit),
-param.value = term.read(false,false)
+        numformat(math.floor(maxSummaryProfit / 8)))
-local val = tonumber(param.value)
+    local autoList = {}
-if val then
+    for i = 1, #reactors do
-param.value = val
+        if autoStopped[reactors[i].reactorAdr] then
-show(color.black,color.grey,param)
+            autoList[#autoList + 1] = "R" .. i
-rd = false
+        end
     end
     local autoText = "нет"
-canedit = true
+    if #autoList > 0 then
-canclose = true
+        autoText = table.concat(autoList, ", ")
-screen.options()
+    end
     guiWrite(autoStoppedCord.x, autoStoppedCord.y, color.red, -1, "%s", autoText)
 end
-local function add(n,i)
+
-n.value=n.value+i
+
-upgate.setSignalLowFlow(n.value)
+
-return n.value
+
 screen["options"] = screenOptions
 
-local function sub(n,i)
+
-term.setCursor(n.x,n.y)
+    local rd = true
-n.value=n.value-i
+    while rd do
-return n.value
+        gpu.fill(param.x, param.y, #tostring(param.value), 1, " ")
         term.setCursor(param.x, param.y)
--- Обновление информации на экране + анализ поведения температуры
+
         param.value = term.read(false, false)
-local ok, inf = pcall(reactor.getReactorInfo)
+        local val = tonumber(param.value)
-if not ok or type(inf) ~= "table" then
+        if val then
-refreshReactors(false)
+            param.value = val
-screenOverview()
+            show(color.black, color.grey, param)
-return
+            rd = false
         end
-infcord.status.value = inf.status
+    end
     canedit = true
-local tbuf1 = inf.temperature
+    canclose = true
-os.sleep(0.1)
+    screen.options()
-local ok2, inf2 = pcall(reactor.getReactorInfo)
+
-local tbuf2 = ok2 and type(inf2) == "table" and inf2.temperature or tbuf1
+
-if handleMain then
+local function add(n, i)
-local stopPct = cfg.fuelStopPct or 98
+    n.value = n.value + i
-if cfg.autoProtectTempEdge and inf.temperature >= cfg.autoProtectTempEdge and not autostate then
+    upgate.setSignalLowFlow(n.value)
-autostate = true
+    return n.value
-guiWrite(button.autoon.x,button.autoon.y,color.green,color.black,"%s\n",button.autoon.name)
+
 
 local function sub(n, i)
-local fuelPct = 0
+    term.setCursor(n.x, n.y)
-if inf.maxFuelConversion >  0 then
+    n.value = n.value - i
-fuelPct = (inf.fuelConversion/inf.maxFuelConversion)*100
+    return n.value
 end
-if autoStopped[reactors[activeIndex].reactorAdr] and (inf.status == "online" or inf.status == "charging" or inf.status == "charged") then
+
-autoStopped[reactors[activeIndex].reactorAdr] = nil
+
     local ok, inf = pcall(reactor.getReactorInfo)
-if fuelPct >= stopPct and (inf.status == "online" or inf.status == "charging" or inf.status == "charged") then
+    if not ok or type(inf) ~= "table" then
-if not autoStopped[reactors[activeIndex].reactorAdr] then
+        refreshReactors(false)
-reactor.stopReactor()
+        screenOverview()
-autoStopped[reactors[activeIndex].reactorAdr] = true
+        return
     end
     infcord.status.value = inf.status
-if tbuf2>tbuf1 then
+    gpu.setForeground(color.white)
-guiWrite(infcord.temp.x,infcord.temp.y,color.red,-1,"%0.2f \n",inf.temperature)
+    local tbuf1 = inf.temperature
-temprise = true
+    os.sleep(0.1)
-elseif tbuf2<tbuf1 then
+    local ok2, inf2 = pcall(reactor.getReactorInfo)
-guiWrite(infcord.temp.x,infcord.temp.y,color.blue,-1,"%0.2f \n",inf.temperature)
+    local tbuf2 = ok2 and type(inf2) == "table" and inf2.temperature or tbuf1
-temprise = false
+    if handleMain then
-else
+        local stopPct = cfg.fuelStopPct or 98
-if inf.temperature == 2000 then
+        if cfg.autoProtectTempEdge and inf.temperature >= cfg.autoProtectTempEdge and not autostate then
-guiWrite(infcord.temp.x,infcord.temp.y,-1,-1,"%0.2f \n",inf.temperature)
+            autostate = true
             guiWrite(button.autoon.x, button.autoon.y, color.green, color.black, "%s\n", button.autoon.name)
         end
-guiWrite(infcord.generation.x,infcord.generation.y,-1,-1,"%s\n",numformat(inf.generationRate))
+    end
-if inf.generationRate > maxGenerationRate then
+    local fuelPct = 0
-maxGenerationRate = inf.generationRate
+    if inf.maxFuelConversion > 0 then
         fuelPct = (inf.fuelConversion / inf.maxFuelConversion) * 100
-guiWrite(infcord.maxgen.x,infcord.maxgen.y,color.green,color.panel,"%s",numformat(maxGenerationRate))
+    end
-infcord.flow.value = getGateFlow(upgate)
+    if autoStopped[reactors[activeIndex].reactorAdr] and (inf.status == "online" or inf.status == "charging" or inf.status == "charged") then
-guiWrite(infcord.flow.x,infcord.flow.y,-1,-1,"%s",numformat(infcord.flow.value))
+        autoStopped[reactors[activeIndex].reactorAdr] = nil
-guiWrite(infcord.puregen.x,infcord.puregen.y,-1,-1,"%s\n",numformat(inf.generationRate - getGateFlow(downgate)))
+    end
-infcord.drain.value = inf.fieldDrainRate
+    if fuelPct >= stopPct and (inf.status == "online" or inf.status == "charging" or inf.status == "charged") then
-guiWrite(infcord.drain.x,infcord.drain.y,-1,-1,"%s\n",numformat(getGateFlow(downgate)))
+        if not autoStopped[reactors[activeIndex].reactorAdr] then
-if inf.maxFieldStrength > 0 then
+            reactor.stopReactor()
-guiWrite(infcord.fstrth.x,infcord.fstrth.y,-1,-1,"%d / %d (%0.2f %%) \n",inf.fieldStrength-inf.fieldDrainRate,inf.maxFieldStrength,((inf.fieldStrength-inf.fieldDrainRate)/inf.maxFieldStrength)*100)
+            autoStopped[reactors[activeIndex].reactorAdr] = true
-else
+        end
-guiWrite(infcord.fstrth.x,infcord.fstrth.y,-1,-1,"0 / 0 (0 %%) \n")
+    end
     if tbuf2 > tbuf1 then
-if inf.maxEnergySaturation > 0 then
+        guiWrite(infcord.temp.x, infcord.temp.y, color.red, -1, "%0.2f \n", inf.temperature)
-guiWrite(infcord.esturn.x,infcord.esturn.y,-1,-1,"%d / %d (%0.2f %%) \n",inf.energySaturation,inf.maxEnergySaturation,(inf.energySaturation/inf.maxEnergySaturation)*100)
+        temprise = true
-else
+    elseif tbuf2 < tbuf1 then
-guiWrite(infcord.esturn.x,infcord.esturn.y,-1,-1,"0 / 0 (0 %%) \n")
+        guiWrite(infcord.temp.x, infcord.temp.y, color.blue, -1, "%0.2f \n", inf.temperature)
         temprise = false
-if inf.fuelConversion/inf.maxFuelConversion < 0.78 then
+    else
-guiWrite(infcord.fuel.x,infcord.fuel.y,-1,-1,"%d / %d (%0.2f %%) \n",inf.fuelConversion,inf.maxFuelConversion,(inf.fuelConversion/inf.maxFuelConversion)*100)
+        if inf.temperature == 2000 then
-else
+            guiWrite(infcord.temp.x, infcord.temp.y, -1, -1, "%0.2f \n", inf.temperature)
-if inf.maxFuelConversion > 0 then
+        end
-if inf.status == "online" or inf.status == "charging" or inf.status == "charged" then
+    end
-guiWrite(infcord.fuel.x,infcord.fuel.y,color.red,-1,"%d / %d (%0.2f %%) Критический уровень топлива\n",inf.fuelConversion,inf.maxFuelConversion,(inf.fuelConversion/inf.maxFuelConversion)*100)
+    guiWrite(infcord.generation.x, infcord.generation.y, -1, -1, "%s\n", numformat(inf.generationRate))
-else
+    if inf.generationRate > maxGenerationRate then
-guiWrite(infcord.fuel.x,infcord.fuel.y,-1,-1,"%d / %d (%0.2f %%) Критический уровень топлива\n",inf.fuelConversion,inf.maxFuelConversion,(inf.fuelConversion/inf.maxFuelConversion)*100)
+        maxGenerationRate = inf.generationRate
     end
-else
+    guiWrite(infcord.maxgen.x, infcord.maxgen.y, color.green, color.panel, "%s", numformat(maxGenerationRate))
-guiWrite(infcord.fuel.x,infcord.fuel.y,-1,-1,"0 / 0 (0 %%)\n")
+    infcord.flow.value = getGateFlow(upgate)
     guiWrite(infcord.flow.x, infcord.flow.y, -1, -1, "%s", numformat(infcord.flow.value))
     guiWrite(infcord.puregen.x, infcord.puregen.y, -1, -1, "%s\n", numformat(inf.generationRate - getGateFlow(downgate)))
-guiWrite(infcord.fuelconv.x,infcord.fuelconv.y,-1,-1,"%d\n",inf.fuelConversionRate)
+    infcord.drain.value = inf.fieldDrainRate
-if com.isAvailable("draconic_rf_storage") then
+    guiWrite(infcord.drain.x, infcord.drain.y, -1, -1, "%s\n", numformat(getGateFlow(downgate)))
-guiWrite(infcord.core.x,infcord.core.y,-1,-1,coreformat())
+    if inf.maxFieldStrength > 0 then
-if button.stop.y ~= infcord.core.y + 2 then
+        guiWrite(infcord.fstrth.x, infcord.fstrth.y, -1, -1, "%d / %d (%0.2f %%) \n",
-screenMain()
+            inf.fieldStrength - inf.fieldDrainRate,
             inf.maxFieldStrength,
-elseif button.stop.y ~= infcord.fuelconv.y + 2 then
+            ((inf.fieldStrength - inf.fieldDrainRate) / inf.maxFieldStrength) * 100)
-screenMain()
+    else
         guiWrite(infcord.fstrth.x, infcord.fstrth.y, -1, -1, "0 / 0 (0 %%) \n")
-checkButtons()
+    end
-syncActive()
+    if inf.maxEnergySaturation > 0 then
         guiWrite(infcord.esturn.x, infcord.esturn.y, -1, -1, "%d / %d (%0.2f %%) \n",
             inf.energySaturation,
--- Алгоритм автономного режима
+            inf.maxEnergySaturation,
             (inf.energySaturation / inf.maxEnergySaturation) * 100)
-if not r or not r.reactor or not r.upgate or not r.downgate then
+    else
-return
+        guiWrite(infcord.esturn.x, infcord.esturn.y, -1, -1, "0 / 0 (0 %%) \n")
     end
-local ok, inf = pcall(r.reactor.getReactorInfo)
+    if inf.fuelConversion / inf.maxFuelConversion < 0.78 then
-if not ok or type(inf) ~= "table" then
+        guiWrite(infcord.fuel.x, infcord.fuel.y, -1, -1, "%d / %d (%0.2f %%) \n",
-return
+            inf.fuelConversion,
             inf.maxFuelConversion,
-local now = computer.uptime()
+            (inf.fuelConversion / inf.maxFuelConversion) * 100)
-if r.chargeRequested and now <= r.chargeRequested then
+    else
-local downflow = 900000
+        if inf.maxFuelConversion > 0 then
-r.downgate.setOverrideEnabled(true)
+            if inf.status == "online" or inf.status == "charging" or inf.status == "charged" then
-r.downgate.setFlowOverride(downflow)
+                guiWrite(infcord.fuel.x, infcord.fuel.y, color.red, -1, "%d / %d (%0.2f %%) Критический уровень топлива\n",
-return
+                    inf.fuelConversion,
                     inf.maxFuelConversion,
-if inf.status == "charging" then
+                    (inf.fuelConversion / inf.maxFuelConversion) * 100)
-local downflow = 900000
+            else
-r.downgate.setOverrideEnabled(true)
+                guiWrite(infcord.fuel.x, infcord.fuel.y, -1, -1, "%d / %d (%0.2f %%) Критический уровень топлива\n",
-r.downgate.setFlowOverride(downflow)
+                    inf.fuelConversion,
-return
+                    inf.maxFuelConversion,
                     (inf.fuelConversion / inf.maxFuelConversion) * 100)
-local isActive = reactors[activeIndex] and reactors[activeIndex].reactorAdr == r.reactorAdr
+            end
-if cfg.autoProtectTempEdge and inf.temperature >= cfg.autoProtectTempEdge and not r.autostate then
+        else
-r.autostate = true
+            guiWrite(infcord.fuel.x, infcord.fuel.y, -1, -1, "0 / 0 (0 %%)\n")
-if isActive then
+        end
-autostate = true
+    end
-if handleMain and button.autoon.x then
+    guiWrite(infcord.fuelconv.x, infcord.fuelconv.y, -1, -1, "%d\n", inf.fuelConversionRate)
-guiWrite(button.autoon.x,button.autoon.y,color.green,color.black,"%s\n",button.autoon.name)
+    if com.isAvailable("draconic_rf_storage") then
         guiWrite(infcord.core.x, infcord.core.y, -1, -1, coreformat())
         if button.stop.y ~= infcord.core.y + 2 then
             screenMain()
-local shieldPct = cfg.shield or 25
+        end
-local flow = getGateFlow(r.upgate)
+    elseif button.stop.y ~= infcord.fuelconv.y + 2 then
-if type(flow) ~= "number" then
+        screenMain()
-flow = 0
+    end
     checkButtons()
-local drain = inf.fieldDrainRate
+    syncActive()
-if state then
+
-local forceEdge = cfg.forceModeTempLowEdge or 7600
+
-if forceEdge < 7600 then
+
-forceEdge = 7600
+    if not r or not r.reactor or not r.upgate or not r.downgate then
         return
-local waittemp = autoWaitTempByAdr[r.reactorAdr]
+    end
-local tempRise = false
+    local ok, inf = pcall(r.reactor.getReactorInfo)
-if r.lastTemp then
+    if not ok or type(inf) ~= "table" then
-if inf.temperature > r.lastTemp then
+        return
-tempRise = true
+    end
-elseif inf.temperature < r.lastTemp then
+    local now = computer.uptime()
-tempRise = false
+    if r.chargeRequested and now <= r.chargeRequested then
-else
+        local downflow = 900000
-tempRise = r.temprise or false
+        r.downgate.setOverrideEnabled(true)
         r.downgate.setFlowOverride(downflow)
         return
-r.lastTemp = inf.temperature
+    end
-r.temprise = tempRise
+    if inf.status == "charging" then
-local downflow = drain / (1 - (shieldPct/100))
+        local downflow = 900000
-r.downgate.setOverrideEnabled(true)
+        r.downgate.setOverrideEnabled(true)
-r.downgate.setFlowOverride(downflow)
+        r.downgate.setFlowOverride(downflow)
-if inf.temperature <= forceEdge then
+        return
-if flow - inf.generationRate <= cfg.forceModeStepCase then
+    end
-flow = flow + cfg.forceModeStep
+    local isActive = reactors[activeIndex] and reactors[activeIndex].reactorAdr == r.reactorAdr
-r.upgate.setSignalLowFlow(flow)
+    if cfg.autoProtectTempEdge and inf.temperature >= cfg.autoProtectTempEdge and not r.autostate then
         r.autostate = true
-elseif flow - inf.generationRate <= cfg.safeModeStepCase and inf.temperature >= forceEdge then
+        if isActive then
-if not waittemp then
+            autostate = true
-flow = getGateFlow(r.upgate) + cfg.safemodeStep
+            if handleMain and button.autoon.x then
-r.upgate.setSignalLowFlow(flow)
+                guiWrite(button.autoon.x, button.autoon.y, color.green, color.black, "%s\n", button.autoon.name)
-elseif inf.temperature < cfg.safeModeTempToWaitEdge then
+            end
-waittemp = false
+        end
     end
-elseif tempRise and inf.temperature >= cfg.safeModeTempWaitEdge then
+    local shieldPct = cfg.shield or 25
-if inf.temperature > cfg.safeModeTempWaitEdge then
+    local flow = getGateFlow(r.upgate)
-waittemp = true
+    if type(flow) ~= "number" then
         flow = 0
-if inf.temperature > cfg.tempCriticalEdge then
+    end
-flow = inf.generationRate - 1000
+    local drain = inf.fieldDrainRate
-r.upgate.setSignalLowFlow(flow)
+    if state then
         local forceEdge = cfg.forceModeTempLowEdge or 7600
         if forceEdge < 7600 then
-autoWaitTempByAdr[r.reactorAdr] = waittemp
+            forceEdge = 7600
-if isActive and handleMain and infcord.flow.x then
+        end
-infcord.flow.value = flow
+        local waittemp = autoWaitTempByAdr[r.reactorAdr]
-guiWrite(infcord.flow.x,infcord.flow.y,color.red,color.grey,"%s",numformat(flow))
+        local tempRise = false
         if r.lastTemp then
-else
+            if inf.temperature > r.lastTemp then
-local downflow
+                tempRise = true
-if inf.status == "charging" then
+            elseif inf.temperature < r.lastTemp then
-downflow = 900000
+                tempRise = false
-else
+            else
-downflow = drain / (1 - (shieldPct/100))
+                tempRise = r.temprise or false
             end
-if inf.status == "charging" then
+        end
-r.downgate.setOverrideEnabled(true)
+        r.lastTemp = inf.temperature
-r.downgate.setFlowOverride(downflow)
+        r.temprise = tempRise
-else
+        local downflow = drain / (1 - (shieldPct / 100))
-r.downgate.setOverrideEnabled(false)
+        r.downgate.setOverrideEnabled(true)
-r.downgate.setSignalHighFlow(downflow)
+        r.downgate.setFlowOverride(downflow)
-r.downgate.setSignalLowFlow(downflow)
+        if inf.temperature <= forceEdge then
             if flow - inf.generationRate <= cfg.forceModeStepCase then
                 flow = flow + cfg.forceModeStep
                 r.upgate.setSignalLowFlow(flow)
--- Обработчик событий
+            end
-local function tcall(type,scrnAdr,x,y,btn,player)
+        elseif flow - inf.generationRate <= cfg.safeModeStepCase and inf.temperature >= forceEdge then
-local rx,ry = gpu.getResolution()
+            if not waittemp then
---выход
+                flow = getGateFlow(r.upgate) + cfg.safemodeStep
-if x >= rx-2 and x<=rx and y == 1 then
+                r.upgate.setSignalLowFlow(flow)
-event.ignore("touch",tcall)
+            elseif inf.temperature < cfg.safeModeTempToWaitEdge then
-prog = false
+                waittemp = false
-ops = false
+            end
         elseif tempRise and inf.temperature >= cfg.safeModeTempWaitEdge then
-if handleStart then
+            if inf.temperature > cfg.safeModeTempWaitEdge then
-if menuItem.gates.x and x>= menuItem.gates.x and x <= (menuItem.gates.x + (menuItem.gates.w or #menuItem.gates.name) - 1) and y == menuItem.gates.y then
+                waittemp = true
-resetAssignState()
+            end
-screenAssign()
+            if inf.temperature > cfg.tempCriticalEdge then
-return
+                flow = inf.generationRate - 1000
                 r.upgate.setSignalLowFlow(flow)
             end
--- Главный экран
+        end
-if handleMain then
+        autoWaitTempByAdr[r.reactorAdr] = waittemp
--- Увеличение
+        if isActive and handleMain and infcord.flow.x then
-if x >= button.add.x+4 and x <= button.add.x+3+#button.add.name and y == button.add.y then
+            infcord.flow.value = flow
-if keyb.isShiftDown() then
+            guiWrite(infcord.flow.x, infcord.flow.y, color.red, color.grey, "%s", numformat(flow))
-if keyb.isControlDown() then
+        end
-upgate.setSignalLowFlow(add(infcord.flow,cfg.ctrlShift_interval))
+    else
-else
+        local downflow
-upgate.setSignalLowFlow(add(infcord.flow,cfg.shift_interval))
+        if inf.status == "charging" then
             downflow = 900000
-else
+        else
-if keyb.isControlDown() then
+            downflow = drain / (1 - (shieldPct / 100))
-upgate.setSignalLowFlow(add(infcord.flow,cfg.ctrl_interval))
+        end
-else
+        if inf.status == "charging" then
-upgate.setSignalLowFlow(add(infcord.flow,cfg.default_interval))
+            r.downgate.setOverrideEnabled(true)
             r.downgate.setFlowOverride(downflow)
         else
-guiWrite(infcord.flow.x,infcord.flow.y,color.red,color.grey,"%s",numformat(infcord.flow.value))
+            r.downgate.setOverrideEnabled(false)
             r.downgate.setSignalHighFlow(downflow)
---Уменьшение
+            r.downgate.setSignalLowFlow(downflow)
-if x >= button.sub.x+2 and x <= button.sub.x+1+#button.sub.name and y == button.sub.y then
+        end
-if keyb.isShiftDown() then
+    end
-if keyb.isControlDown() then
+
-upgate.setSignalLowFlow(sub(infcord.flow,cfg.ctrlShift_interval))
+
-else
+local function tcall(type, scrnAdr, x, y, btn, player)
-upgate.setSignalLowFlow(sub(infcord.flow,cfg.shift_interval))
+    local rx, ry = gpu.getResolution()
     if x >= rx - 2 and x <= rx and y == 1 then
-else
+        event.ignore("touch", tcall)
-if keyb.isControlDown() then
+        prog = false
-upgate.setSignalLowFlow(sub(infcord.flow,cfg.ctrl_interval))
+        ops = false
-else
+    end
-upgate.setSignalLowFlow(sub(infcord.flow,cfg.default_interval))
+    if handleStart then
         if menuItem.gates.x and x >= menuItem.gates.x and x <= (menuItem.gates.x + (menuItem.gates.w or #menuItem.gates.name) - 1) and y == menuItem.gates.y then
             resetAssignState()
-guiWrite(infcord.flow.x,infcord.flow.y,color.blue,color.grey,"%s",numformat(infcord.flow.value))
+            screenAssign()
             return
         end
-if not autostate then
+    end
-if x >= button.autooff.x and x <= button.autooff.x + textWidth(button.autooff.name) - 1 and y == button.autooff.y then
+    if handleMain then
-gpu.set(button.autooff.x, button.autooff.y,"        ")
+        if x >= button.add.x + 4 and x <= button.add.x + 3 + #button.add.name and y == button.add.y then
-autostate = true
+            if keyb.isShiftDown() then
-guiWrite(button.autoon.x,button.autoon.y,color.green,color.black,"%s\n",button.autoon.name)
+                if keyb.isControlDown() then
                     upgate.setSignalLowFlow(add(infcord.flow, cfg.ctrlShift_interval))
-else
+                else
-if x >= button.autoon.x and x <= button.autoon.x + textWidth(button.autoon.name) - 1 and y == button.autoon.y then
+                    upgate.setSignalLowFlow(add(infcord.flow, cfg.shift_interval))
-gpu.set(button.autoon.x, button.autoon.y,"       ")
+                end
-autostate = false
+            else
-guiWrite(button.autooff.x,button.autooff.y,color.red,color.black,"%s\n",button.autooff.name)
+                if keyb.isControlDown() then
                     upgate.setSignalLowFlow(add(infcord.flow, cfg.ctrl_interval))
                 else
-do
+                    upgate.setSignalLowFlow(add(infcord.flow, cfg.default_interval))
-local w = button.charge.w or textWidth(button.charge.name)
+                end
-if button.charge.x and button.charge.y and x >= button.charge.x and x <= button.charge.x + w - 1 and y == button.charge.y then
+            end
-local usedNativeCharge = false
+            guiWrite(infcord.flow.x, infcord.flow.y, color.red, color.grey, "%s", numformat(infcord.flow.value))
-if reactor and reactor.chargeReactor then
+        end
-local ok = pcall(reactor.chargeReactor)
+        if x >= button.sub.x + 2 and x <= button.sub.x + 1 + #button.sub.name and y == button.sub.y then
-if ok then
+            if keyb.isShiftDown() then
-usedNativeCharge = true
+                if keyb.isControlDown() then
                     upgate.setSignalLowFlow(sub(infcord.flow, cfg.ctrlShift_interval))
                 else
-if not usedNativeCharge then
+                    upgate.setSignalLowFlow(sub(infcord.flow, cfg.shift_interval))
-ensureFlowInit(reactors[activeIndex], true)
+                end
-if upgate then
+            else
-upgate.setSignalLowFlow(CHARGE_FLOW)
+                if keyb.isControlDown() then
                     upgate.setSignalLowFlow(sub(infcord.flow, cfg.ctrl_interval))
-infcord.flow.value = CHARGE_FLOW
+                else
-if infcord.flow.x then
+                    upgate.setSignalLowFlow(sub(infcord.flow, cfg.default_interval))
-guiWrite(infcord.flow.x,infcord.flow.y,color.red,color.grey,"%s",numformat(infcord.flow.value))
+                end
             end
             guiWrite(infcord.flow.x, infcord.flow.y, color.blue, color.grey, "%s", numformat(infcord.flow.value))
-if chargeHint.visible and chargeHint.x and chargeHint.y then
+        end
-guiWrite(chargeHint.x, chargeHint.y, color.white, color.grey, "%s", string.rep(" ", chargeHint.w))
+
-guiWrite(chargeHint.x, chargeHint.y + 1, color.white, color.grey, "%s", string.rep(" ", chargeHint.w))
+        if not autostate then
-chargeHint.visible = false
+            if x >= button.autooff.x and x <= button.autooff.x + textWidth(button.autooff.name) - 1 and y == button.autooff.y then
-chargeHintDismissed = true
+                gpu.set(button.autooff.x, button.autooff.y, "        ")
                 autostate = true
-guiWrite(button.charge.x,button.charge.y,-1,color.grey,"                 ",button.charge.name)
+                guiWrite(button.autoon.x, button.autoon.y, color.green, color.black, "%s\n", button.autoon.name)
-button.charge.visible = false
+            end
-if not usedNativeCharge then
+        else
-	local currentReactor = reactors[activeIndex]
+            if x >= button.autoon.x and x <= button.autoon.x + textWidth(button.autoon.name) - 1 and y == button.autoon.y then
-	if currentReactor and currentReactor.reactorAdr then
+                gpu.set(button.autoon.x, button.autoon.y, "       ")
-		local chargeUntil = computer.uptime() + CHARGE_DURATION
+                autostate = false
-		currentReactor.chargeRequested = chargeUntil
+                guiWrite(button.autooff.x, button.autooff.y, color.red, color.black, "%s\n", button.autooff.name)
-		chargeRequestByAdr[currentReactor.reactorAdr] = chargeUntil
+            end
-	end
+        end
         do
             local w = button.charge.w or textWidth(button.charge.name)
             if button.charge.x and button.charge.y and x >= button.charge.x and x <= button.charge.x + w - 1 and y == button.charge.y then
-if button.start.visible then
+                local usedNativeCharge = false
-local w = button.start.w or textWidth(button.start.name)
+                if reactor and reactor.chargeReactor then
-if x >= button.start.x and x <= button.start.x + w - 1 and y == button.start.y then
+                    local ok = pcall(reactor.chargeReactor)
-ensureFlowInit(reactors[activeIndex])
+                    if ok then
-reactor.activateReactor()
+                        usedNativeCharge = true
-if reactors[activeIndex] then
+                    end
-autoStopped[reactors[activeIndex].reactorAdr] = nil
+                end
                 if not usedNativeCharge then
-guiWrite(button.start.x,button.start.y,-1,color.grey,"                 ",button.start.name)
+                    ensureFlowInit(reactors[activeIndex], true)
-button.start.visible = false
+                    if upgate then
                         upgate.setSignalLowFlow(CHARGE_FLOW)
                     end
-if button.stop.visible then
+                    infcord.flow.value = CHARGE_FLOW
-local w = button.stop.w or textWidth(button.stop.name)
+                    if infcord.flow.x then
-if x >= button.stop.x and x <= button.stop.x + w - 1 and y == button.stop.y then
+                        guiWrite(infcord.flow.x, infcord.flow.y, color.red, color.grey, "%s", numformat(infcord.flow.value))
-reactor.stopReactor()
+                    end
-guiWrite(button.stop.x,button.stop.y,-1,color.grey,"                 ",button.stop.name)
+                end
-button.stop.visible = false
+                if chargeHint.visible and chargeHint.x and chargeHint.y then
                     guiWrite(chargeHint.x, chargeHint.y, color.white, color.grey, "%s", string.rep(" ", chargeHint.w))
                     guiWrite(chargeHint.x, chargeHint.y + 1, color.white, color.grey, "%s", string.rep(" ", chargeHint.w))
---меню
+                    chargeHint.visible = false
-if x>= menuItem.options.x and x <= (menuItem.options.x + (menuItem.options.w or #menuItem.options.name) - 1) and y == menuItem.options.y then
+                    chargeHintDismissed = true
-screenOptions()
+                end
-return
+                guiWrite(button.charge.x, button.charge.y, -1, color.grey, "                 ", button.charge.name)
                 button.charge.visible = false
-if x>= menuItem.overview.x and x <= (menuItem.overview.x + (menuItem.overview.w or #menuItem.overview.name) - 1) and y == menuItem.overview.y then
+                if not usedNativeCharge then
-syncActive()
+                    local currentReactor = reactors[activeIndex]
-screenOverview()
+                    if currentReactor and currentReactor.reactorAdr then
-return
+                        local chargeUntil = computer.uptime() + CHARGE_DURATION
                         currentReactor.chargeRequested = chargeUntil
-if x>= menuItem.refresh.x and x <= (menuItem.refresh.x + (menuItem.refresh.w or #menuItem.refresh.name) - 1) and y == menuItem.refresh.y then
+                        chargeRequestByAdr[currentReactor.reactorAdr] = chargeUntil
-refreshReactors(true)
+                    end
-return
+                end
             end
-if x>= menuItem.gates.x and x <= (menuItem.gates.x + (menuItem.gates.w or #menuItem.gates.name) - 1) and y == menuItem.gates.y then
+        end
-resetAssignState()
+        if button.start.visible then
-screenAssign()
+            local w = button.start.w or textWidth(button.start.name)
-return
+            if x >= button.start.x and x <= button.start.x + w - 1 and y == button.start.y then
                 ensureFlowInit(reactors[activeIndex])
-for i=1,#reactors do
+                reactor.activateReactor()
-local tab = reactors[i].tab
+                if reactors[activeIndex] then
-if tab.x and x >= tab.x and x <= tab.x + tab.w - 1 and y == tab.y then
+                    autoStopped[reactors[activeIndex].reactorAdr] = nil
-syncActive()
+                end
-setActive(i)
+                guiWrite(button.start.x, button.start.y, -1, color.grey, "                 ", button.start.name)
-screenMain()
+                button.start.visible = false
-return
+            end
         end
         if button.stop.visible then
-if x == 1 and y == 1 then
+            local w = button.stop.w or textWidth(button.stop.name)
-event.ignore("touch",tcall)
+            if x >= button.stop.x and x <= button.stop.x + w - 1 and y == button.stop.y then
-prog = false
+                reactor.stopReactor()
                 guiWrite(button.stop.x, button.stop.y, -1, color.grey, "                 ", button.stop.name)
                 button.stop.visible = false
--- Экран обзора
+            end
-if handleOverview then
+        end
-if x>= menuItem.options.x and x <= (menuItem.options.x + (menuItem.options.w or #menuItem.options.name) - 1) and y == menuItem.options.y then
+        if x >= menuItem.options.x and x <= (menuItem.options.x + (menuItem.options.w or #menuItem.options.name) - 1) and y == menuItem.options.y then
-screenOptions()
+            screenOptions()
-return
+            return
         end
-if x>= menuItem.refresh.x and x <= (menuItem.refresh.x + (menuItem.refresh.w or #menuItem.refresh.name) - 1) and y == menuItem.refresh.y then
+        if x >= menuItem.overview.x and x <= (menuItem.overview.x + (menuItem.overview.w or #menuItem.overview.name) - 1) and y == menuItem.overview.y then
-refreshReactors(true)
+            syncActive()
-return
+            screenOverview()
             return
-if x>= menuItem.gates.x and x <= (menuItem.gates.x + (menuItem.gates.w or #menuItem.gates.name) - 1) and y == menuItem.gates.y then
+        end
-resetAssignState()
+        if x >= menuItem.refresh.x and x <= (menuItem.refresh.x + (menuItem.refresh.w or #menuItem.refresh.name) - 1) and y == menuItem.refresh.y then
-screenAssign()
+            refreshReactors(true)
-return
+            return
         end
-for i=1,#reactors do
+        if x >= menuItem.gates.x and x <= (menuItem.gates.x + (menuItem.gates.w or #menuItem.gates.name) - 1) and y == menuItem.gates.y then
-local tab = reactors[i].tab
+            resetAssignState()
-if tab.x and x >= tab.x and x <= tab.x + tab.w - 1 and y == tab.y then
+            screenAssign()
-syncActive()
+            return
-setActive(i)
+        end
-screenMain()
+        for i = 1, #reactors do
-return
+            local tab = reactors[i].tab
             if tab.x and x >= tab.x and x <= tab.x + tab.w - 1 and y == tab.y then
-local ctrl = reactors[i].control
+                syncActive()
-if ctrl and ctrl.dec and x >= ctrl.dec.x and x <= ctrl.dec.x + ctrl.dec.w - 1 and y == ctrl.dec.y then
+                setActive(i)
-local flow = getGateFlow(reactors[i].upgate)
+                screenMain()
-reactors[i].upgate.setSignalLowFlow(flow - cfg.default_interval)
+                return
-return
+            end
         end
-if ctrl and ctrl.inc and x >= ctrl.inc.x and x <= ctrl.inc.x + ctrl.inc.w - 1 and y == ctrl.inc.y then
+        if x == 1 and y == 1 then
-local flow = getGateFlow(reactors[i].upgate)
+            event.ignore("touch", tcall)
-reactors[i].upgate.setSignalLowFlow(flow + cfg.default_interval)
+            prog = false
-return
+        end
     end
-if ctrl and ctrl.auto and x >= ctrl.auto.x and x <= ctrl.auto.x + ctrl.auto.w - 1 and y == ctrl.auto.y then
+    if handleOverview then
-reactors[i].autostate = not reactors[i].autostate
+        if x >= menuItem.options.x and x <= (menuItem.options.x + (menuItem.options.w or #menuItem.options.name) - 1) and y == menuItem.options.y then
-if i == activeIndex then
+            screenOptions()
-autostate = reactors[i].autostate
+            return
         end
-refreshOverview()
+        if x >= menuItem.refresh.x and x <= (menuItem.refresh.x + (menuItem.refresh.w or #menuItem.refresh.name) - 1) and y == menuItem.refresh.y then
-return
+            refreshReactors(true)
             return
-local btn = reactors[i].powerBtn
+        end
-if btn.x and x >= btn.x and x <= btn.x + btn.w - 1 and y == btn.y then
+        if x >= menuItem.gates.x and x <= (menuItem.gates.x + (menuItem.gates.w or #menuItem.gates.name) - 1) and y == menuItem.gates.y then
-if btn.action == "start" then
+            resetAssignState()
-ensureFlowInit(reactors[i])
+            screenAssign()
-reactors[i].reactor.activateReactor()
+            return
-autoStopped[reactors[i].reactorAdr] = nil
+        end
-else
+        for i = 1, #reactors do
-reactors[i].reactor.stopReactor()
+            local tab = reactors[i].tab
             if tab.x and x >= tab.x and x <= tab.x + tab.w - 1 and y == tab.y then
-return
+                syncActive()
                 setActive(i)
                 screenMain()
-if x == 1 and y == 1 then
+                return
-event.ignore("touch",tcall)
+            end
-prog = false
+            local ctrl = reactors[i].control
             if ctrl and ctrl.dec and x >= ctrl.dec.x and x <= ctrl.dec.x + ctrl.dec.w - 1 and y == ctrl.dec.y then
                 local flow = getGateFlow(reactors[i].upgate)
--- Экран настроек
+                reactors[i].upgate.setSignalLowFlow(flow - cfg.default_interval)
-if handleOptions then
+                return
--- Работа со значениями
+            end
-if canedit then
+            if ctrl and ctrl.inc and x >= ctrl.inc.x and x <= ctrl.inc.x + ctrl.inc.w - 1 and y == ctrl.inc.y then
-if x >= OptionDefault.x and x <= OptionDefault.x + #tostring(OptionDefault.value)-1 and y == OptionDefault.y then
+                local flow = getGateFlow(reactors[i].upgate)
-canclose = false
+                reactors[i].upgate.setSignalLowFlow(flow + cfg.default_interval)
-canedit = false
+                return
-editOption(OptionDefault)
+            end
             if ctrl and ctrl.auto and x >= ctrl.auto.x and x <= ctrl.auto.x + ctrl.auto.w - 1 and y == ctrl.auto.y then
-if x >= OptionCtrl.x and x <= OptionCtrl.x + #tostring(OptionCtrl.value)-1 and y == OptionCtrl.y then
+                reactors[i].autostate = not reactors[i].autostate
-canclose = false
+                if i == activeIndex then
-canedit = false
+                    autostate = reactors[i].autostate
-editOption(OptionCtrl)
+                end
                 refreshOverview()
-if x >= OptionShift.x and x <= OptionShift.x + #tostring(OptionShift.value)-1 and y == OptionShift.y then
+                return
-canclose = false
+            end
-canedit = false
+            local btn = reactors[i].powerBtn
-editOption(OptionShift)
+            if btn.x and x >= btn.x and x <= btn.x + btn.w - 1 and y == btn.y then
                 if btn.action == "start" then
-if x >= OptionCtrlShift.x and x <= OptionCtrlShift.x + #tostring(OptionCtrlShift.value)-1 and y == OptionCtrlShift.y then
+                    ensureFlowInit(reactors[i])
-canclose = false
+                    reactors[i].reactor.activateReactor()
-canedit = false
+                    autoStopped[reactors[i].reactorAdr] = nil
-editOption(OptionCtrlShift)
+                else
                     reactors[i].reactor.stopReactor()
-if x >= OptionShield.x and x <= OptionShield.x + #tostring(OptionShield.value)-1 and y == OptionShield.y then
+                end
-canclose = false
+                return
-canedit = false
+            end
-editOption(OptionShield)
+        end
         if x == 1 and y == 1 then
-if x >= OptionFuelStop.x and x <= OptionFuelStop.x + #tostring(OptionFuelStop.value)-1 and y == OptionFuelStop.y then
+            event.ignore("touch", tcall)
-canclose = false
+            prog = false
-canedit = false
+        end
-editOption(OptionFuelStop)
+    end
     if handleOptions then
         if canedit then
--- меню
+            if x >= OptionDefault.x and x <= OptionDefault.x + #tostring(OptionDefault.value) - 1 and y == OptionDefault.y then
-if canclose then
+                canclose = false
-if x>= menuItem.optionsBack.x and x <= (menuItem.optionsBack.x + (menuItem.optionsBack.w or #menuItem.optionsBack.name) - 1) and y == menuItem.optionsBack.y then
+                canedit = false
-screenOverview()
+                editOption(OptionDefault)
-return
+            end
             if x >= OptionCtrl.x and x <= OptionCtrl.x + #tostring(OptionCtrl.value) - 1 and y == OptionCtrl.y then
-if x>= menuItem.save.x and x <= (menuItem.save.x + (menuItem.save.w or #menuItem.save.name) - 1) and y == menuItem.save.y then
+                canclose = false
-cfg.default_interval = OptionDefault.value
+                canedit = false
-cfg.ctrl_interval = OptionCtrl.value
+                editOption(OptionCtrl)
-cfg.shift_interval = OptionShift.value
+            end
-cfg.ctrlShift_interval = OptionCtrlShift.value
+            if x >= OptionShift.x and x <= OptionShift.x + #tostring(OptionShift.value) - 1 and y == OptionShift.y then
-cfg.shield = OptionShield.value
+                canclose = false
-cfg.fuelStopPct = OptionFuelStop.value
+                canedit = false
                 editOption(OptionShift)
-screenOverview()
+            end
-return
+            if x >= OptionCtrlShift.x and x <= OptionCtrlShift.x + #tostring(OptionCtrlShift.value) - 1 and y == OptionCtrlShift.y then
                 canclose = false
-if x>= menuItem.cancel.x and x <= (menuItem.cancel.x + (menuItem.cancel.w or #menuItem.cancel.name) - 1) and y == menuItem.cancel.y then
+                canedit = false
-OptionDefault.value = cfg.default_interval
+                editOption(OptionCtrlShift)
-OptionCtrl.value = cfg.ctrl_interval
+            end
-OptionShift.value = cfg.shift_interval
+            if x >= OptionShield.x and x <= OptionShield.x + #tostring(OptionShield.value) - 1 and y == OptionShield.y then
-OptionCtrlShift.value = cfg.ctrlShift_interval
+                canclose = false
-OptionShield.value = cfg.shield
+                canedit = false
-OptionFuelStop.value = cfg.fuelStopPct or 98
+                editOption(OptionShield)
-screenOverview()
+            end
-return
+            if x >= OptionFuelStop.x and x <= OptionFuelStop.x + #tostring(OptionFuelStop.value) - 1 and y == OptionFuelStop.y then
                 canclose = false
                 canedit = false
                 editOption(OptionFuelStop)
--- Экран гейтов
+            end
--- gates screen
+        end
-if handleAssign then
+        if canclose then
-if assignMode ~= "manual" and assignMode ~= "easy" then
+            if x >= menuItem.optionsBack.x and x <= (menuItem.optionsBack.x + (menuItem.optionsBack.w or #menuItem.optionsBack.name) - 1) and y == menuItem.optionsBack.y then
-if easyAssign.backBtn.x and x>= easyAssign.backBtn.x and x <= easyAssign.backBtn.x + easyAssign.backBtn.w - 1 and y == easyAssign.backBtn.y then
+                screenOverview()
-assignMode = nil
+                return
-easyAssign.active = false
+            end
-screenOverview()
+            if x >= menuItem.save.x and x <= (menuItem.save.x + (menuItem.save.w or #menuItem.save.name) - 1) and y == menuItem.save.y then
-return
+                cfg.default_interval = OptionDefault.value
                 cfg.ctrl_interval = OptionCtrl.value
-if easyAssign.heavyBtn.x and x >= easyAssign.heavyBtn.x and x <= easyAssign.heavyBtn.x + easyAssign.heavyBtn.w - 1 and y == easyAssign.heavyBtn.y then
+                cfg.shift_interval = OptionShift.value
-assignMode = "manual"
+                cfg.ctrlShift_interval = OptionCtrlShift.value
-resetAssignState()
+                cfg.shield = OptionShield.value
-screenAssignManual()
+                cfg.fuelStopPct = OptionFuelStop.value
-return
+                configWrite(cfgName)
                 screenOverview()
-if easyAssign.easyBtn.x and x >= easyAssign.easyBtn.x and x <= easyAssign.easyBtn.x + easyAssign.easyBtn.w - 1 and y == easyAssign.easyBtn.y then
+                return
-assignMode = "easy"
+            end
-startEasyAssign()
+            if x >= menuItem.cancel.x and x <= (menuItem.cancel.x + (menuItem.cancel.w or #menuItem.cancel.name) - 1) and y == menuItem.cancel.y then
-if not easyAssign.active then
+                OptionDefault.value = cfg.default_interval
-assignMode = nil
+                OptionCtrl.value = cfg.ctrl_interval
-screenAssignChoice()
+                OptionShift.value = cfg.shift_interval
-else
+                OptionCtrlShift.value = cfg.ctrlShift_interval
-screenAssignEasy()
+                OptionShield.value = cfg.shield
                 OptionFuelStop.value = cfg.fuelStopPct or 98
-return
+                screenOverview()
                 return
-return
+            end
-elseif assignMode == "easy" then
+        end
-if easyAssign.backBtn.x and x>= easyAssign.backBtn.x and x <= easyAssign.backBtn.x + easyAssign.backBtn.w - 1 and y == easyAssign.backBtn.y then
+    end
-if easyAssign.saved and easyAssign.core then
+    if handleAssign then
-clearAssignedByAdr(easyAssign.core)
+        if assignMode ~= "manual" and assignMode ~= "easy" then
             if easyAssign.backBtn.x and x >= easyAssign.backBtn.x and x <= easyAssign.backBtn.x + easyAssign.backBtn.w - 1 and y == easyAssign.backBtn.y then
-easyAssign.active = false
+                assignMode = nil
-easyAssign.step = "reactor"
+                easyAssign.active = false
-easyAssign.core = nil
+                screenOverview()
-easyAssign.shield = nil
+                return
-easyAssign.output = nil
+            end
-easyAssign.saved = false
+            if easyAssign.heavyBtn.x and x >= easyAssign.heavyBtn.x and x <= easyAssign.heavyBtn.x + easyAssign.heavyBtn.w - 1 and y == easyAssign.heavyBtn.y then
-easyAssign.message = nil
+                assignMode = "manual"
-assignMode = nil
+                resetAssignState()
-screenAssignChoice()
+                screenAssignManual()
-return
+                return
             end
-if easyAssign.step == "done" then
+            if easyAssign.easyBtn.x and x >= easyAssign.easyBtn.x and x <= easyAssign.easyBtn.x + easyAssign.easyBtn.w - 1 and y == easyAssign.easyBtn.y then
-if easyAssign.continueBtn.x and x >= easyAssign.continueBtn.x and x <= easyAssign.continueBtn.x + easyAssign.continueBtn.w - 1 and y == easyAssign.continueBtn.y then
+                assignMode = "easy"
-startEasyAssign()
+                startEasyAssign()
-screenAssignEasy()
+                if not easyAssign.active then
-return
+                    assignMode = nil
                     screenAssignChoice()
-if easyAssign.finishBtn.x and x >= easyAssign.finishBtn.x and x <= easyAssign.finishBtn.x + easyAssign.finishBtn.w - 1 and y == easyAssign.finishBtn.y then
+                else
-easyAssign.active = false
+                    screenAssignEasy()
-assignMode = nil
+                end
-refreshReactors(false)
+                return
-screenOverview()
+            end
-return
+            return
         elseif assignMode == "easy" then
             if easyAssign.backBtn.x and x >= easyAssign.backBtn.x and x <= easyAssign.backBtn.x + easyAssign.backBtn.w - 1 and y == easyAssign.backBtn.y then
-return
+                if easyAssign.saved and easyAssign.core then
                     clearAssignedByAdr(easyAssign.core)
-if x>= menuItem.back.x and x <= (menuItem.back.x + (menuItem.back.w or #menuItem.back.name) - 1) and y == menuItem.back.y then
+                end
-if not assignState.reactorIndex and not assignState.shieldGateIdx and not assignState.outGateIdx then
+                easyAssign.active = false
-resetAssignState()
+                easyAssign.step = "reactor"
-assignMode = nil
+                easyAssign.core = nil
-screenOverview()
+                easyAssign.shield = nil
-return
+                easyAssign.output = nil
                 easyAssign.saved = false
-assignState.message = "Выбери гейты!"
+                easyAssign.message = nil
-screenAssign()
+                assignMode = nil
-return
+                screenAssignChoice()
                 return
-if assignUi.reset and x>= assignUi.reset.x and x <= assignUi.reset.x + assignUi.reset.w - 1 and y == assignUi.reset.y then
+            end
-if assignState.reactorIndex then
+            if easyAssign.step == "done" then
-clearAssignedGates(assignState.reactorIndex)
+                if easyAssign.continueBtn.x and x >= easyAssign.continueBtn.x and x <= easyAssign.continueBtn.x + easyAssign.continueBtn.w - 1 and y == easyAssign.continueBtn.y then
-reactors = buildReactors() or reactors
+                    startEasyAssign()
-resetAssignState()
+                    screenAssignEasy()
-screenAssign()
+                    return
                 end
-return
+                if easyAssign.finishBtn.x and x >= easyAssign.finishBtn.x and x <= easyAssign.finishBtn.x + easyAssign.finishBtn.w - 1 and y == easyAssign.finishBtn.y then
                     easyAssign.active = false
-for i=1,#assignUi.reactors do
+                    assignMode = nil
-local btn = assignUi.reactors[i]
+                    refreshReactors(false)
-if btn and x >= btn.x and x <= btn.x + btn.w - 1 and y == btn.y then
+                    screenOverview()
-assignState.reactorIndex = i
+                    return
-assignState.reactorAdr = assignUi.reactorAddrs[i]
+                end
-assignState.shieldGateIdx = nil
+            end
-assignState.shieldGateAdr = nil
+            return
-assignState.outGateIdx = nil
+        end
-assignState.outGateAdr = nil
+        if x >= menuItem.back.x and x <= (menuItem.back.x + (menuItem.back.w or #menuItem.back.name) - 1) and y == menuItem.back.y then
-assignState.step = "shield"
+            if not assignState.reactorIndex and not assignState.shieldGateIdx and not assignState.outGateIdx then
-screenAssign()
+                resetAssignState()
-return
+                assignMode = nil
                 screenOverview()
                 return
-for i=1,#assignUi.gates do
+            end
-local btn = assignUi.gates[i]
+            assignState.message = "Выбери гейты!"
-if btn and x >= btn.x and x <= btn.x + btn.w - 1 and y == btn.y then
+            screenAssign()
-local gateAdr = assignUi.gateAddrs[i]
+            return
-if assignState.step == "reactor" then
+        end
-return
+        if assignUi.reset and x >= assignUi.reset.x and x <= assignUi.reset.x + assignUi.reset.w - 1 and y == assignUi.reset.y then
             if assignState.reactorIndex then
-if gateAdr and assignUi.gateUse[gateAdr] and assignUi.gateUse[gateAdr] ~= assignUi.selectedAdr then
+                clearAssignedGates(assignState.reactorIndex)
-return
+                reactors = buildReactors() or reactors
                 resetAssignState()
-local selectedEntry = assignUi.selectedEntry
+                screenAssign()
-if not assignState.reactorIndex then
+            end
-assignState.step = "reactor"
+            return
-screenAssign()
+        end
-return
+        for i = 1, #assignUi.reactors do
             local btn = assignUi.reactors[i]
-if assignState.step == "shield" then
+            if btn and x >= btn.x and x <= btn.x + btn.w - 1 and y == btn.y then
-assignState.shieldGateIdx = i
+                assignState.reactorIndex = i
-assignState.shieldGateAdr = gateAdr
+                assignState.reactorAdr = assignUi.reactorAddrs[i]
-assignState.step = "output"
+                assignState.shieldGateIdx = nil
-screenAssign()
+                assignState.shieldGateAdr = nil
-return
+                assignState.outGateIdx = nil
-elseif assignState.step == "output" then
+                assignState.outGateAdr = nil
-if assignState.shieldGateAdr and assignState.shieldGateAdr == gateAdr then
+                assignState.step = "shield"
-assignState.message = "Нужны два разных гейта!"
+                screenAssign()
-screenAssign()
+                return
-return
+            end
         end
-assignState.outGateIdx = i
+        for i = 1, #assignUi.gates do
-assignState.outGateAdr = gateAdr
+            local btn = assignUi.gates[i]
-if not assignState.reactorAdr and assignState.reactorIndex then
+            if btn and x >= btn.x and x <= btn.x + btn.w - 1 and y == btn.y then
-assignState.reactorAdr = assignUi.reactorAddrs[assignState.reactorIndex]
+                local gateAdr = assignUi.gateAddrs[i]
                 if assignState.step == "reactor" then
-if not assignState.shieldGateAdr and assignState.shieldGateIdx then
+                    return
-assignState.shieldGateAdr = assignUi.gateAddrs[assignState.shieldGateIdx]
+                end
                 if gateAdr and assignUi.gateUse[gateAdr] and assignUi.gateUse[gateAdr] ~= assignUi.selectedAdr then
-local saved = saveAssignedGates(assignState.reactorAdr, assignState.shieldGateAdr, assignState.outGateAdr)
+                    return
-if not saved then
+                end
-assignState.message = "Не удалось сохранить гейты!"
+                local selectedEntry = assignUi.selectedEntry
-screenAssign()
+                if not assignState.reactorIndex then
-return
+                    assignState.step = "reactor"
                     screenAssign()
-local targetAdr = assignState.reactorAdr
+                    return
-resetAssignState()
+                end
-assignMode = nil
+                if assignState.step == "shield" then
-handleAssign = false
+                    assignState.shieldGateIdx = i
-handleMain = true
+                    assignState.shieldGateAdr = gateAdr
-handleOverview = false
+                    assignState.step = "output"
-reactors = buildReactors() or reactors
+                    screenAssign()
-local idx = 1
+                    return
-if targetAdr then
+                elseif assignState.step == "output" then
-for j=1,#reactors do
+                    if assignState.shieldGateAdr and assignState.shieldGateAdr == gateAdr then
-if reactors[j].reactorAdr == targetAdr then
+                        assignState.message = "Нужны два разных гейта!"
-idx = j
+                        screenAssign()
-break
+                        return
                     end
                     assignState.outGateIdx = i
                     assignState.outGateAdr = gateAdr
-setActive(idx)
+                    if not assignState.reactorAdr and assignState.reactorIndex then
-if not reactors or #reactors == 0 or not reactor or not upgate or not downgate then
+                        assignState.reactorAdr = assignUi.reactorAddrs[assignState.reactorIndex]
-screenOverview()
+                    end
-return
+                    if not assignState.shieldGateAdr and assignState.shieldGateIdx then
                         assignState.shieldGateAdr = assignUi.gateAddrs[assignState.shieldGateIdx]
-screenMain()
+                    end
-return
+                    local saved = saveAssignedGates(assignState.reactorAdr, assignState.shieldGateAdr, assignState.outGateAdr)
                     if not saved then
                         assignState.message = "Не удалось сохранить гейты!"
                         screenAssign()
-if x == 1 and y == 1 then
+                        return
-event.ignore("touch",tcall)
+                    end
-prog = false
+                    local targetAdr = assignState.reactorAdr
                     resetAssignState()
                     assignMode = nil
                     handleAssign = false
                     handleMain = true
-event.listen("touch",tcall)
+                    handleOverview = false
                     reactors = buildReactors() or reactors
                     local idx = 1
                     if targetAdr then
-screen.overview()
+                        for j = 1, #reactors do
                             if reactors[j].reactorAdr == targetAdr then
                                 idx = j
-local now = computer.uptime()
+                                break
-if handleMain and now - lastDetailUpdate >= 0.2 then
+                            end
-lastDetailUpdate = now
+                        end
-if not pcall(refreshInfo) then
+                    end
-autostate = false
+                    setActive(idx)
-if not pcall(screenStart) then
+                    if not reactors or #reactors == 0 or not reactor or not upgate or not downgate then
-break
+                        screenOverview()
                         return
-if not pcall(screenMain) then
+                    end
                     screenMain()
-if not pcall(screenMain) then
+                    return
-break
+                end
             end
         end
         if x == 1 and y == 1 then
-elseif handleOverview and now - lastOverviewUpdate >= 0.5 then
+            event.ignore("touch", tcall)
-lastOverviewUpdate = now
+            prog = false
-if not pcall(refreshOverview) then
+        end
-if not pcall(screenOverview) then
+    end
-break
+
 
 event.listen("touch", tcall)
 event.listen("component_added", handleComponentAdded)
-if reactors and #reactors > 0 then
+
-for i=1,#reactors do
+
-autoForReactor(reactors[i], reactors[i].autostate)
+    screen.overview()
 end
 while prog do
-pollEasyAssign()
+    local now = computer.uptime()
-os.sleep(0)
+    if handleMain and now - lastDetailUpdate >= 0.2 then
         lastDetailUpdate = now
         if not pcall(refreshInfo) then
             autostate = false
-gpu.setResolution(xz,yz)
+            if not pcall(screenStart) then
                 break
             end
             if not pcall(screenMain) then
                 screenStart()
                 if not pcall(screenMain) then
                     break
                 end
             end
         end
     elseif handleOverview and now - lastOverviewUpdate >= 0.5 then
         lastOverviewUpdate = now
         if not pcall(refreshOverview) then
             if not pcall(screenOverview) then
                 break
             end
         end
     end
     if reactors and #reactors > 0 then
         for i = 1, #reactors do
             autoForReactor(reactors[i], reactors[i].autostate)
         end
     end
     pollEasyAssign()
     os.sleep(0)
 end
 gpu.setBackground(rback)
 gpu.setForeground(rfore)
 gpu.setResolution(xz, yz)
 term.clear()