reactor_5

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 autostateByAdr = {}
local flowInitByAdr = {}
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 function parseNum(str)
local n = ""
for i=1,#str do
local ch = str:byte(i,i)
if ch >= 48 and ch <= 57 or ch == 46 then
n = n..string.char(ch)
end
end
if n ~= "" then
return tonumber(n)
else return n
end
end

local cfg = {}
local confnames =
{
[1] = "default_interval",
[2] = "ctrl_interval",
[3] = "shift_interval",
[4] = "ctrlShift_interval",
[5] = "shield",
[6] = "tempCriticalEdge",
[7] = "forceModeTempLowEdge",
[8] = "forceModeStepCase",
[9] = "forceModeStep",
[10] = "safeModeTempWaitEdge",
[11] = "safeModeTempToWaitEdge",
[12] = "safeModeStepCase",
[13] = "safemodeStep",
[14] = "autoProtectTempEdge",
[15] = "screen_w",
[16] = "screen_h",
[17] = "fuelStopPct"
}

local function readConfig(name)
local file = io.open(name,"r")
if not file then
return nil
end
local tab = {}
for line in file:lines() do
local key, val = line:match("^%s*([%w_]+)%s*=%s*([%d%.]+)")
if key and val then
tab[key] = tonumber(val)
end
end
file:close()
return tab
end

local function hasConfigKeys(parsed)
if not parsed then
return false
end
for i=1,#confnames do
if parsed[confnames[i]] == nil then
return false
end
end
return true
end

local function readParse(name)
local file = io.open(name,"r")
if file then
local tab = {}
local i = 1
while true do
local str = file:read("*l")
if str == nil then
break
end
if parseNum(str) ~= "" then
tab[i] = parseNum(str)
i=i+1
end
end
file:close()
return tab
else
return false
end
end

local function writeText(name,text)
local file = io.open(name,"w")
file:write(text)
file:close()
end

local function configWrite(name)
local parsed = readConfig(name)
if not parsed or not hasConfigKeys(parsed) then
writeText(name,DEFAULT_CONFIG)
elseif cfg.default_interval ~= nil and
cfg.ctrl_interval ~= nil and
cfg.shift_interval ~= nil and
cfg.ctrlShift_interval ~= nil and
cfg.shield ~= nil and
cfg.tempCriticalEdge ~= nil and
cfg.forceModeTempLowEdge ~= nil and
cfg.forceModeStepCase ~= nil and
cfg.forceModeStep ~= nil and
cfg.safeModeTempWaitEdge ~= nil and
cfg.safeModeTempToWaitEdge ~= nil and
cfg.safeModeStepCase ~= nil and
cfg.safemodeStep ~= nil and
cfg.autoProtectTempEdge ~= nil and
cfg.screen_w ~= nil and
cfg.screen_h ~= nil and
cfg.fuelStopPct ~= nil then

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.ctrl_interval,
cfg.shift_interval,
cfg.ctrlShift_interval,
cfg.shield,
cfg.tempCriticalEdge,
cfg.forceModeTempLowEdge,
cfg.forceModeStepCase,
cfg.forceModeStep,
cfg.safeModeTempWaitEdge,
cfg.safeModeTempToWaitEdge,
cfg.safeModeStepCase,
cfg.safemodeStep,
cfg.autoProtectTempEdge,
cfg.screen_w,
cfg.screen_h,
cfg.fuelStopPct
))
end
end

local function makeConfig(tab,tab2)
local config = {}
for i=1,#tab do
config[tostring(tab[i])] = tab2[i]
end
return config
end

local function listAddresses(typeName)
local list = {}
for adr in com.list(typeName) do
list[#list+1] = adr
end
return list
end

local function readReactorsFile()
local file = io.open(reactorsFile,"r")
if not file then
return nil
end
local list = {}
for line in file:lines() do
local r,u,d = line:match("(%S+)%s+(%S+)%s+(%S+)")
if r and u and d then
list[#list+1] = {reactorAdr = r, upAdr = u, downAdr = d}
end
end
file:close()
if #list == 0 then
return nil
end
return list
end

local function writeReactorsFile(list)
local file = io.open(reactorsFile,"w")
for i=1,#list do
file:write(string.format("%s %s %s\n",list[i].reactorAdr,list[i].upAdr,list[i].downAdr))
end
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
end

local function mergeEntries(entries)
local usedReactors = {}
local usedGates = {}
for i=1,#entries do
usedReactors[entries[i].reactorAdr] = true
usedGates[entries[i].upAdr] = true
usedGates[entries[i].downAdr] = true
end
local reactorsList = listAddresses("draconic_reactor")
local gates = listAddresses("flux_gate")
local freeReactors = {}
local freeGates = {}
for i=1,#reactorsList do
if not usedReactors[reactorsList[i]] then
freeReactors[#freeReactors+1] = reactorsList[i]
end
end
for i=1,#gates do
if not usedGates[gates[i]] then
freeGates[#freeGates+1] = gates[i]
end
end
local addCount = math.min(#freeReactors, math.floor(#freeGates/2), MAX_REACTORS - #entries)
for i=1,addCount do
entries[#entries+1] = {
reactorAdr = freeReactors[i],
upAdr = freeGates[(i-1)*2+1],
downAdr = freeGates[(i-1)*2+2]
}
end
return entries
end

local function buildReactors()
newEntriesAdded = false
lastAddedReactorAdr = nil
local entries = readReactorsFile()
local currentReactors = reactors or {}
if entries then
local valid = {}
for i=1,#entries do
if validEntry(entries[i]) then
valid[#valid+1] = entries[i]
end
end
if #valid > 0 then
entries = valid
end
end
if entries and #entries > 0 then
local reactorsList = listAddresses("draconic_reactor")
if #reactorsList > #entries then
newEntriesAdded = true
end
end
if not entries or #entries == 0 then
return nil
end
local oldByAdr = {}
for i=1,#currentReactors do
oldByAdr[currentReactors[i].reactorAdr] = currentReactors[i]
end
local reactors = {}
for i=1,#entries do
local e = entries[i]
local old = oldByAdr[e.reactorAdr]
local savedAuto = autostateByAdr[e.reactorAdr]
local savedFlowInit = flowInitByAdr[e.reactorAdr]
local savedCharge = chargeRequestByAdr[e.reactorAdr]
reactors[i] = {
index = i,
reactorAdr = e.reactorAdr,
upAdr = e.upAdr,
downAdr = e.downAdr,
reactor = com.proxy(com.get(e.reactorAdr)),
upgate = com.proxy(com.get(e.upAdr)),
downgate = com.proxy(com.get(e.downAdr)),
maxGenerationRate = old and old.maxGenerationRate or 0,
autostate = old and old.autostate or (savedAuto ~= nil and savedAuto or false),
temprise = old and old.temprise or false,
flowInit = old and old.flowInit or (savedFlowInit ~= nil and savedFlowInit or false),
chargeRequested = old and old.chargeRequested or (savedCharge or 0),
lastTemp = nil,
row = {},
powerBtn = {},
tab = {}
}
if not old then
lastAddedReactorAdr = e.reactorAdr
end
end
return reactors
end

configWrite(cfgName)
cfg = readConfig(cfgName)
if not cfg then
cfg = makeConfig(confnames,readParse(cfgName))
end

local reactors = {}
local activeIndex = 1
local summaryProfitCord = {x=nil,y=nil}
local summaryEuCord = {x=nil,y=nil}
local summaryShieldCord = {x=nil,y=nil}
local summaryGenCord = {x=nil,y=nil}
local summaryMaxProfitCord = {x=nil,y=nil}
local maxSummaryProfit = 0
local newEntriesAdded = false
local pendingActiveReactorAdr = nil
autostateByAdr = {}
flowInitByAdr = {}

local color = { }
color["red"]   = 0xFF0000
color["green"] = 0x00FF00
color["yellow"] = 0xFFD166
color["skyblue"] = 0x4FC3F7
color["black"]   = 0x0F1115
color["grey"]   = 0x0F1115
color["panel"]  = 0x1A1F27
color["blue"]   = 0x4FC3F7
color["orange"] = 0xFF9800
color["white"] = 0xE6EDF3
color["dark"]  = 0x242B36
color["dim"]   = 0x7A8599

local rback = gpu.getBackground()
local rfore = gpu.getForeground()

local handleMain
local handleOptions
local handleStart
local handleOverview
local handleAssign
local screenAssign
local screenOverview
local assignState = {reactorIndex = nil, shieldGateIdx = nil, outGateIdx = nil, step = "reactor", message = nil}
local assignUi = {reactors = {}, gates = {}, back = {x=nil,y=nil,w=0}}
local autoStopped = {}
local autoWaitTempByAdr = {}
local chargeRequestByAdr = {}
local autoStoppedCord = {x=nil,y=nil}

local menuItem = {}
menuItem["options"] =
{
["name"] ="Настройки |",
["x"] = 1,
["y"] = 2
}
menuItem["save"] =
{
["name"] ="Сохранить |",
["x"] = 1,
["y"] = 2
}
menuItem["cancel"] =
{
["name"] =" Отменить  |",
["x"] = 12,
["y"] = 2
}
menuItem["overview"] =
{
["name"] ="Главный |",
["x"] = 1,
["y"] = 2
}
menuItem["refresh"] =
{
["name"] ="Обновить |",
["x"] = 1,
["y"] = 2
}
menuItem["gates"] =
{
["name"] ="Гейты |",
["x"] = 1,
["y"] = 2
}
menuItem["back"] =
{
["name"] ="Назад |",
["x"] = 1,
["y"] = 2
}
menuItem["reset"] =
{
["name"] ="Сброс |",
["x"] = 1,
["y"] = 2
}
menuItem["optionsBack"] =
{
["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)
gpu.setResolution(screenW,screenH)

gpu.setBackground(color.grey)
gpu.setForeground(color.white)

local prog = true
local OptionDefault = {}
local OptionCtrl = {}
local OptionShift = {}
local OptionCtrlShift = {}
local OptionShield = {}
local OptionFuelStop = {}
OptionDefault["value"] = cfg.default_interval
OptionCtrl["value"] = cfg.ctrl_interval
OptionShift["value"] = cfg.shift_interval
OptionCtrlShift["value"] = cfg.ctrlShift_interval
OptionShield["value"] = cfg.shield
OptionFuelStop["value"] = cfg.fuelStopPct or 98

local infcord =
{
["status"] =
	{
	["value"] = nil,
	["x"] = nil,
	["y"] = nil
	},
["temp"] =
	{
	["value"] = nil,
	["x"] = nil,
	["y"] = nil
	},
["generation"] =
	{
	["value"] = nil,
	["x"] = nil,
	["y"] = nil
	},
["maxgen"] =
	{
	["value"] = nil,
	["x"] = nil,
	["y"] = nil
	},
["flow"] =
	{
	["value"] = nil,
	["x"] = nil,
	["y"] = nil
	},
["puregen"] =
	{
	["value"] = nil,
	["x"] = nil,
	["y"] = nil
	},
["drain"] =
	{
	["value"] = nil,
	["x"] = nil,
	["y"] = nil
	},
["fstrth"] =
	{
	["value"] = nil,
	["x"] = nil,
	["y"] = nil
	},
["esturn"] =
	{
	["value"] = nil,
	["x"] = nil,
	["y"] = nil
	},
["fuel"] =
	{
	["value"] = nil,
	["x"] = nil,
	["y"] = nil
	},
["fuelconv"] =
	{
	["value"] = nil,
	["x"] = nil,
	["y"] = nil
	},
["core"] =
	{
	["value"] = nil,
	["x"] = nil,
	["y"] = nil
	}
}

local button =
{
["continue"] =
	{
	["name"] = "Продолжить",
	["x"] = nil,
	["y"] = nil
	},
["change"] =
	{
	["name"] = "Изменить",
	["x"] = nil,
	["y"] = nil
	},
["add"] =
	{
	["name"] = " + ",
	["x"] = nil,
	["y"] = nil
	},
["sub"] =
	{
	["name"] = " - ",
	["x"] = nil,
	["y"] = nil
	},
["start"] =
	{
	["name"] = " [PWR] ЗАПУСК ",
	["x"] = nil,
	["y"] = nil,
	["visible"] = nil
	},
["stop"] =
	{
	["name"] = " [PWR] СТОП ",
	["x"] = nil,
	["y"] = nil,
	["visible"] = nil
	},
["charge"] =
	{
	["name"] = "Зарядить реактор ",
	["x"] = nil,
	["y"] = nil,
	["visible"] = nil
	},
["autoon"] =
	{
	["name"] = "[ON] ",
	["x"] = nil,
	["y"] = nil,
	},
["autooff"] =
	{
	["name"] = "[OFF]",
	["x"] = nil,
	["y"] = nil,
	}
}

local ops = true
local canedit = true
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

local function textWidth(s)
local ok, len = pcall(unicode.len, s)
if ok and len then
return len
end
return #s
end

local function guiWrite(x,y,cf,cb,s,...)
term.setCursor(x,y)
if cf >=0 and cb >=0 then
local fg = gpu.getForeground()
local bg = gpu.getBackground()
gpu.setForeground(cf)
gpu.setBackground(cb)
printf(s,...)
gpu.setForeground(fg)
gpu.setBackground(bg)
elseif cb <0 and cf>=0 then
local fg = gpu.getForeground()
gpu.setForeground(cf)
printf(s,...)
gpu.setForeground(fg)
elseif cf < 0 and cb >= 0 then
local bg = gpu.getBackground()
printf(s,...)
gpu.setBackground(bg)
else
local fg = gpu.getForeground()
gpu.setForeground(color.white)
printf(s,...)
gpu.setForeground(fg)
end
end

local function getCord(param)
param.x,param.y = term.getCursor()
return param.x,param.y
end

local function guiClear(y)
local fg = gpu.getForeground()
local bg = gpu.getBackground()
gpu.setForeground(color.white)
gpu.setBackground(color.grey)
for i=y+3,3,-1 do
term.setCursor(1,i)
term.clearLine()
end
gpu.setForeground(fg)
gpu.setBackground(bg)
end

local function setActive(index)
if not reactors[index] then
return
end
activeIndex = index
reactor = reactors[index].reactor
upgate = reactors[index].upgate
downgate = reactors[index].downgate
autostate = reactors[index].autostate
temprise = reactors[index].temprise
maxGenerationRate = reactors[index].maxGenerationRate
end

local function syncActive()
if not reactors[activeIndex] then
return
end
reactors[activeIndex].autostate = autostate
reactors[activeIndex].temprise = temprise
reactors[activeIndex].maxGenerationRate = maxGenerationRate
end

local function drawHeader(title)
local x = gpu.getResolution()
gpu.setBackground(color.grey)
gpu.setForeground(color.white)
term.clear()
gpu.setBackground(color.panel)
gpu.setForeground(color.white)
term.clearLine()
printf(" %s",title)
gpu.setForeground(color.green)
printf(" | Разработал : GintaRus")
gpu.setForeground(color.white)
printf("\n")
gpu.setBackground(color.grey)
gpu.setForeground(color.white)
term.clearLine()
gpu.setBackground(0xFF0000)
gpu.set(x-2,1," X ")
gpu.setBackground(color.grey)
gpu.setForeground(color.white)
return x
end

local function drawSeparator(x)
gpu.setBackground(color.grey)
gpu.setForeground(color.dim)
gpu.fill(1,3,x,1,"-")
gpu.setBackground(color.grey)
gpu.setForeground(color.white)
term.setCursor(1,4)
end

local function makeButton(x,y,text)
term.setCursor(x,y)
local fg = gpu.getForeground()
local bg = gpu.getBackground()
gpu.setBackground(color.blue)
gpu.setForeground(color.white)
printf(text)
gpu.setBackground(bg)
gpu.setForeground(fg)

end

local function makePowerButton(x,y,text,bg,fg)
term.setCursor(x,y)
local rfg = gpu.getForeground()
local rbg = gpu.getBackground()
gpu.setBackground(bg)
gpu.setForeground(fg)
printf(text)
gpu.setBackground(rbg)
gpu.setForeground(rfg)
end

local function getGateFlow(gate)
if not gate then
return 0
end
local ok, value = pcall(gate.getSignalLowFlow)
if ok and type(value) == "number" then
return value
end
local ok2, value2 = pcall(gate.getFlow)
if ok2 and type(value2) == "number" then
return value2
end
return 0
end

local function ensureFlowInit(r, force)
if not r or (r.flowInit and not force) then
return
end
pcall(r.upgate.setSignalLowFlow, r.upgate, 535000)
r.flowInit = true
flowInitByAdr[r.reactorAdr] = true
if reactors[activeIndex] and reactors[activeIndex].reactorAdr == r.reactorAdr then
infcord.flow.value = 535000
if handleMain and infcord.flow.x then
guiWrite(infcord.flow.x,infcord.flow.y,color.red,color.grey,"%s",numformat(infcord.flow.value))
end
end
end

local function statusText(status)
if status == "online" then
return "ВКЛ"
elseif status == "offline" then
return "ВЫК"
elseif status == "charging" then
return "ЗАР"
elseif status == "charged" then
return "ГОТ"
elseif status == "stopping" then
return "СТП"
end
return status
end

local function show(fc,bc,param)
local fg = gpu.getForeground()
local bg = gpu.getBackground()
term.setCursor(param.x,param.y)
gpu.setForeground(fc)
gpu.setBackground(bc)
local st = " "
for i = 0,#tostring(param.value) do
st=st.." "
end
gpu.set(param.x,param.y,st)
printf("%d",param.value)
gpu.setForeground(fg)
gpu.setBackground(bg)
end

local function numformat(n)
local s = tostring(n)
if n >= 1000 and n < 1000000 then
local t = s:sub(1,#s-3)
local e = s:sub(#s-2)
s = t.." "..e.."  "
return s
elseif n >= 1000000 then
local m = s:sub(1,#s-6)
local t = s:sub(#s-5,#s-3)
local e = s:sub(#s-2)
s = m.." "..t.." "..e.."  "
return s
else
s=s.."  "
return s
end
end

local function overviewCols(x)
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}
end
local ctrl = cols.flow + 12
if ctrl < 65 then
ctrl = 65
end
if ctrl + 16 > x then
ctrl = math.max(65, x - 16)
end
cols.ctrl = ctrl
return cols
end

local function coreformat()
local num = com.draconic_rf_storage.getEnergyStored()
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)
elseif num > 10^6 then
return string.format(" Накоплено в ядре: %0.3f M   \n",num/10^6)
elseif num > 10^3 then
return string.format(" Накоплено в ядре: %0.3f K   \n",num/10^3)
else
return string.format(" Накоплено в ядре: %d   \n",num)
end
end

-- Анализ и корректировка запомненных адресов
local function checkButtons()
local ok, inf = pcall(reactor.getReactorInfo)
if not ok or type(inf) ~= "table" then
return
end
infcord.status.value = inf.status
if infcord.status.value == "offline" then
guiWrite(button.charge.x,button.charge.y,color.skyblue,color.black,"%s",button.charge.name)
button.charge.visible = true
elseif infcord.status.value == "stopping" then
if (inf.energySaturation/inf.maxEnergySaturation)*100 >=50 and (inf.fieldStrength/inf.maxFieldStrength)*100 >= 50 and inf.temperature > 2000 then
guiWrite(button.start.x,button.start.y,color.green,color.black,"%s",button.start.name)
button.start.visible = true
elseif infcord.status.value ~= "charging" then
guiWrite(button.charge.x,button.charge.y,color.skyblue,color.black,"%s",button.charge.name)
button.charge.visible = true
end
elseif infcord.status.value == "online" or infcord.status.value == "charging" then
guiWrite(button.stop.x,button.stop.y,color.red,color.black,"%s",button.stop.name)
button.stop.visible = true
elseif infcord.status.value == "charged" then
guiWrite(button.start.x,button.start.y,color.green,color.black,"%s",button.start.name)
button.start.visible = true
guiWrite(button.stop.x,button.stop.y,color.red,color.black,"%s",button.stop.name)
button.stop.visible = true
end
end
-- Инициализация программы, анализ и настройка всей технической белеберды
local function screenStart()
handleMain = false
handleOptions = false
handleStart = true
local x = drawHeader("HiTech Classic is the best   (Preparation)")
printf("Это страница для настройки программы при первом запуске или после сбоя")
drawSeparator(x)
local hadFile = readReactorsFile() ~= nil
while true do
if not ops then return end
reactors = buildReactors()
if reactors and #reactors > 0 then
setActive(1)
if not hadFile then
screenAssign()
return
end
break
end
if not hadFile then
local reactorsList = listAddresses("draconic_reactor")
local gates = listAddresses("flux_gate")
if #reactorsList > 0 and #gates >= 2 then
reactors = reactors or {}
screenOverview()
return
end
end
guiClear(2)
printf("Подключите реакторы и флюкс-гейты (2 гейта на каждый реактор)\n")
printf("Максимум: %d реакторов. Адреса можно сохранить в %s\n",MAX_REACTORS,reactorsFile)
os.sleep(1)
end
end
-- Экран настроек
local function screenOptions()
handleMain = false
handleStart = false
handleOptions = true
handleOverview = false
handleAssign = false
canedit = true
canclose = true
local x = drawHeader("HiTech Classic is the best   (Options)")
menuItem.save.x,menuItem.save.y =term.getCursor()
gpu.setForeground(color.blue)
printf(menuItem.save.name)
menuItem.save.w = textWidth(menuItem.save.name)
menuItem.cancel.x,menuItem.cancel.y =term.getCursor()
printf(menuItem.cancel.name)
menuItem.cancel.w = textWidth(menuItem.cancel.name)
menuItem.optionsBack.x,menuItem.optionsBack.y =term.getCursor()
printf(menuItem.optionsBack.name)
menuItem.optionsBack.w = textWidth(menuItem.optionsBack.name)
gpu.setForeground(color.white)
drawSeparator(x)
printf(" Интервал для щелчка: ")
OptionDefault["x"],OptionDefault["y"] = term.getCursor()
printf("%d\n",OptionDefault.value)
printf(" Интервал для CTRL: ")
OptionCtrl["x"],OptionCtrl["y"] = term.getCursor()
printf("%d\n",OptionCtrl.value)
printf(" Интервал для SHIFT: ")
OptionShift["x"],OptionShift["y"] = term.getCursor()
printf("%d\n",OptionShift.value)
printf(" Интервал для CTRL+SHIFT: ")
OptionCtrlShift["x"],OptionCtrlShift["y"] = term.getCursor()
printf("%d\n",OptionCtrlShift.value)
printf(" Уровень щитов: ")
OptionShield["x"],OptionShield["y"] = term.getCursor()
printf("%d\n",OptionShield.value)
printf(" Отключение по топливу (%%): ")
OptionFuelStop["x"],OptionFuelStop["y"] = term.getCursor()
printf("%d\n",OptionFuelStop.value)
end
-- Назначение гейтов
local function clearPromptLine()
local _, y = term.getCursor()
if y > 1 then
term.setCursor(1, y - 1)
term.clearLine()
term.setCursor(1, y - 1)
end
end

local function readIndex(prompt,max,used)
while true do
printf("%s",prompt)
local input = term.read(false,false) or ""
clearPromptLine()
local num = tonumber(input:match("%d+"))
if num and num >= 1 and num <= max and not used[num] then
return num
end
printf("Неверный выбор, попробуйте снова.\n")
end
end

local function readIndexAllowZero(prompt,max)
while true do
printf("%s",prompt)
local input = term.read(false,false) or ""
clearPromptLine()
local lower = input:lower()
if lower:find("назад") or lower:find("back") or lower:match("^b%s*$") then
return -1
end
local num = tonumber(input:match("%d+"))
if num and num >= 0 and num <= max then
return num
end
printf("Неверный выбор, попробуйте снова.\n")
end
end

function screenAssign()
handleMain = false
handleStart = false
handleOptions = false
handleOverview = false
handleAssign = true
local x = drawHeader("HiTech Classic is the best   (Гейты)")
drawSeparator(x)
assignUi.reactors = {}
assignUi.gates = {}
assignUi.gateAddrs = {}
assignUi.reactorAddrs = {}
assignUi.gateUse = {}
assignUi.selectedAdr = nil
gpu.setBackground(color.grey)
gpu.setForeground(color.white)
gpu.fill(1,4,x,21," ")
term.setCursor(1,2)
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)
gpu.setForeground(color.blue)
printf(menuItem.back.name)
menuItem.back.w = textWidth(menuItem.back.name)
menuItem.reset.x,menuItem.reset.y = term.getCursor()
assignUi.reset = {x=menuItem.reset.x,y=menuItem.reset.y,w=textWidth(menuItem.reset.name)}
if assignState.reactorIndex then
gpu.setForeground(color.blue)
else
gpu.setForeground(color.dim)
end
printf(menuItem.reset.name)
menuItem.reset.w = textWidth(menuItem.reset.name)
gpu.setForeground(color.white)
local reactorsList = listAddresses("draconic_reactor")
local gates = listAddresses("flux_gate")
assignUi.gateAddrs = gates
assignUi.reactorAddrs = reactorsList
if #reactorsList == 0 or #gates < 2 then
printf("Недостаточно реакторов или флюкс-гейтов.\n")
os.sleep(1)
screenOverview()
return
end
local count = math.min(#reactorsList, MAX_REACTORS)
term.setCursor(2,4)
if assignState.step == "reactor" then
printf("Выберите реактор")
elseif assignState.step == "shield" then
printf("Выберите гейт ЩИТЫ для R%d",assignState.reactorIndex or 0)
else
printf("Выберите гейт ВЫВОД для R%d",assignState.reactorIndex or 0)
end
if assignState.message then
term.setCursor(2,3)
guiWrite(2,3,color.red,-1,"%s",assignState.message)
assignState.message = nil
end

term.setCursor(2,5)
printf("Реакторы:")
local rowY = 6
for i=1,count do
term.setCursor(2,rowY)
local label = string.format("%d) %s",i,reactorsList[i])
if assignState.reactorIndex == i then
guiWrite(2,rowY,color.black,color.blue,"%s",label)
else
guiWrite(2,rowY,color.white,-1,"%s",label)
end
assignUi.reactors[i] = {x=2,y=rowY,w=textWidth(label)}
rowY = rowY + 1
end

local entries = readReactorsFile() or {}
local gateUse = {}
for i=1,#entries do
gateUse[entries[i].upAdr] = entries[i].reactorAdr
gateUse[entries[i].downAdr] = entries[i].reactorAdr
end
assignUi.gateUse = gateUse
local selectedAdr = assignState.reactorIndex and reactorsList[assignState.reactorIndex] or nil
assignUi.selectedAdr = selectedAdr
local selectedEntry = nil
if selectedAdr then
for i=1,#entries do
if entries[i].reactorAdr == selectedAdr then
selectedEntry = entries[i]
break
end
end
end
assignUi.selectedEntry = selectedEntry

term.setCursor(40,5)
printf("Гейты:")
local gateY = 6
for i=1,#gates do
if gateY > 24 then
break
end
term.setCursor(40,gateY)
local label = string.format("%d) %s",i,gates[i])
local colorGate = color.dim
if selectedAdr then
if selectedEntry and (gates[i] == selectedEntry.upAdr or gates[i] == selectedEntry.downAdr) then
colorGate = color.green
elseif assignState.shieldGateIdx == i or assignState.outGateIdx == i then
colorGate = color.green
elseif gateUse[gates[i]] and gateUse[gates[i]] ~= selectedAdr then
colorGate = color.red
else
colorGate = color.dim
end
end
guiWrite(40,gateY,colorGate,-1,"%s",label)
assignUi.gates[i] = {x=40,y=gateY,w=textWidth(label)}
gateY = gateY + 1
end
end

local function refreshReactors(openAssign)
autostateByAdr = {}
flowInitByAdr = {}
autoWaitTempByAdr = {}
chargeRequestByAdr = {}
for i=1,#reactors do
local r = reactors[i]
autostateByAdr[r.reactorAdr] = r.autostate
flowInitByAdr[r.reactorAdr] = r.flowInit
chargeRequestByAdr[r.reactorAdr] = r.chargeRequested
end
syncActive()
local prevAdr = reactors[activeIndex] and reactors[activeIndex].reactorAdr
reactors = buildReactors() or reactors
local idx = 1
if pendingActiveReactorAdr then
for i=1,#reactors do
if reactors[i].reactorAdr == pendingActiveReactorAdr then
idx = i
break
end
end
pendingActiveReactorAdr = nil
elseif lastAddedReactorAdr then
for i=1,#reactors do
if reactors[i].reactorAdr == lastAddedReactorAdr then
idx = i
break
end
end
lastAddedReactorAdr = nil
elseif prevAdr then
for i=1,#reactors do
if reactors[i].reactorAdr == prevAdr then
idx = i
break
end
end
end
setActive(idx)
if openAssign and newEntriesAdded then
resetAssignState()
screenAssign()
return
end
if handleMain then
screenMain()
else
screenOverview()
end
end

local function resetAssignState()
assignState.reactorIndex = nil
assignState.shieldGateIdx = nil
assignState.outGateIdx = nil
assignState.step = "reactor"
end

local function saveAssignedGates(reactorIndex, shieldIdx, outIdx)
local reactorsList = listAddresses("draconic_reactor")
local gates = listAddresses("flux_gate")
if not reactorsList[reactorIndex] or not gates[shieldIdx] or not gates[outIdx] then
return false
end
local entries = readReactorsFile() or {}
local updated = false
for i=1,#entries do
if entries[i].reactorAdr == reactorsList[reactorIndex] then
entries[i].upAdr = gates[outIdx]
entries[i].downAdr = gates[shieldIdx]
updated = true
break
end
end
if not updated then
entries[#entries+1] = {
reactorAdr = reactorsList[reactorIndex],
upAdr = gates[outIdx],
downAdr = gates[shieldIdx]
}
end
if #entries > MAX_REACTORS then
local trimmed = {}
for i=1,MAX_REACTORS do
trimmed[i] = entries[i]
end
entries = trimmed
end
writeReactorsFile(entries)
pendingActiveReactorAdr = reactorsList[reactorIndex]
return true
end

local function clearAssignedGates(reactorIndex)
local reactorsList = listAddresses("draconic_reactor")
if not reactorsList[reactorIndex] then
return false
end
local entries = readReactorsFile() or {}
local newEntries = {}
for i=1,#entries do
if entries[i].reactorAdr ~= reactorsList[reactorIndex] then
newEntries[#newEntries+1] = entries[i]
end
end
writeReactorsFile(newEntries)
return true
end
-- Экран обзора реакторов
screenOverview = function()
handleMain = false
handleStart = false
handleOptions = false
handleOverview = true
handleAssign = false
local x = drawHeader("HiTech Classic is the best")
reactors = reactors or {}
local cols = overviewCols(x)
term.setCursor(1,2)
menuItem.options.x,menuItem.options.y = term.getCursor()
gpu.setForeground(color.blue)
printf(menuItem.options.name)
menuItem.options.w = textWidth(menuItem.options.name)
gpu.setForeground(color.white)
menuItem.overview.x,menuItem.overview.y = term.getCursor()
gpu.setForeground(color.blue)
printf(menuItem.overview.name)
menuItem.overview.w = textWidth(menuItem.overview.name)
gpu.setForeground(color.white)
menuItem.refresh.x,menuItem.refresh.y = term.getCursor()
gpu.setForeground(color.blue)
printf(menuItem.refresh.name)
menuItem.refresh.w = textWidth(menuItem.refresh.name)
gpu.setForeground(color.white)
menuItem.gates.x,menuItem.gates.y = term.getCursor()
gpu.setForeground(color.blue)
printf(menuItem.gates.name)
menuItem.gates.w = textWidth(menuItem.gates.name)
gpu.setForeground(color.white)
for i=1,#reactors do
local label = string.format("[R%d]",i)
reactors[i].tab.x,reactors[i].tab.y = term.getCursor()
reactors[i].tab.w = textWidth(label)
if i == activeIndex then
guiWrite(reactors[i].tab.x,reactors[i].tab.y,color.black,color.orange,"%s",label)
else
guiWrite(reactors[i].tab.x,reactors[i].tab.y,color.blue,color.white,"%s",label)
end
printf(" ")
end
drawSeparator(x)
gpu.setBackground(color.grey)
gpu.setForeground(color.white)
gpu.fill(1,4,x,21," ")
if #reactors == 0 then
term.setCursor(2,5)
printf("Нет настроенных реакторов.")
term.setCursor(2,6)
printf("Откройте \"Гейты\" и назначьте гейты.")
return
end

gpu.setBackground(color.panel)
gpu.setForeground(color.white)
gpu.fill(2,4,x-2,6," ")
term.setCursor(3,4)
printf("Сводка")
term.setCursor(3,5)
printf("Суммарная прибыль:")
term.setCursor(28,5)
getCord(summaryProfitCord)
term.setCursor(3,6)
printf("Суммарная EU:")
term.setCursor(28,6)
getCord(summaryEuCord)
term.setCursor(3,7)
printf("Тратим на щиты RF:")
term.setCursor(28,7)
getCord(summaryShieldCord)
term.setCursor(3,8)
printf("Суммарная выработка:")
term.setCursor(28,8)
getCord(summaryGenCord)
term.setCursor(3,9)
printf("Максимум прибыли RF/EU:")
term.setCursor(28,9)
getCord(summaryMaxProfitCord)
local autoX = math.max(40, x - 33)
term.setCursor(autoX,4)
printf("Выключены автоматически:")
term.setCursor(autoX,5)
getCord(autoStoppedCord)

gpu.setBackground(color.dark)
gpu.setForeground(color.white)
gpu.fill(2,11,x-2,1," ")
term.setCursor(2,11)
printf("#")
term.setCursor(cols.status,11)
printf("СТАТУС")
term.setCursor(cols.temp,11)
printf(" ТЕМП")
term.setCursor(cols.fuel,11)
printf("ТОПЛИВО")
term.setCursor(cols.profit,11)
printf("ПРИБЫЛЬ")
term.setCursor(cols.gen,11)
printf("ГЕН")
term.setCursor(cols.flow,11)
printf("ПОТОК")
term.setCursor(cols.ctrl,11)
printf("УПР")
gpu.setForeground(color.dim)
gpu.fill(2,12,x-2,1,"-")
gpu.setForeground(color.white)
gpu.setBackground(color.grey)
local rowY = 13
for i=1,#reactors do
local r = reactors[i]
term.setCursor(2,rowY)
printf("#%d",i)
term.setCursor(cols.status,rowY)
r.row.status = {x=cols.status,y=rowY}
term.setCursor(cols.temp,rowY)
r.row.temp = {x=cols.temp,y=rowY}
term.setCursor(cols.fuel,rowY)
r.row.fuel = {x=cols.fuel,y=rowY}
term.setCursor(cols.profit,rowY)
r.row.profit = {x=cols.profit,y=rowY}
term.setCursor(cols.gen,rowY)
r.row.gen = {x=cols.gen,y=rowY}
term.setCursor(cols.flow,rowY)
r.row.flow = {x=cols.flow,y=rowY}
term.setCursor(cols.ctrl,rowY)
r.control = r.control or {}
r.control.dec = {x=cols.ctrl,y=rowY,w=3}
term.setCursor(cols.ctrl + 4,rowY)
r.control.inc = {x=cols.ctrl + 4,y=rowY,w=3}
term.setCursor(cols.ctrl + 8,rowY)
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
end
end
-- Инициализация главного экрана
local function screenMain()
handleOptions = false
handleStart = false
handleMain = true
handleOverview = false
handleAssign = false
if not reactor or not upgate or not downgate then
screenOverview()
return
end
local x = drawHeader("HiTech Classic is the best")
local ok, inf = pcall(reactor.getReactorInfo)
if not ok or type(inf) ~= "table" then
refreshReactors(false)
screenOverview()
return
end
infcord.status.value = inf.status
menuItem.options.x,menuItem.options.y =term.getCursor()
gpu.setForeground(color.blue)
printf(menuItem.options.name)
menuItem.options.w = textWidth(menuItem.options.name)
gpu.setForeground(color.white)
menuItem.overview.x,menuItem.overview.y = term.getCursor()
gpu.setForeground(color.blue)
printf(menuItem.overview.name)
menuItem.overview.w = textWidth(menuItem.overview.name)
gpu.setForeground(color.white)
menuItem.refresh.x,menuItem.refresh.y = term.getCursor()
gpu.setForeground(color.blue)
printf(menuItem.refresh.name)
menuItem.refresh.w = textWidth(menuItem.refresh.name)
gpu.setForeground(color.white)
menuItem.gates.x,menuItem.gates.y = term.getCursor()
gpu.setForeground(color.blue)
printf(menuItem.gates.name)
menuItem.gates.w = textWidth(menuItem.gates.name)
gpu.setForeground(color.white)
for i=1,#reactors do
local label = string.format("[R%d]",i)
reactors[i].tab.x,reactors[i].tab.y = term.getCursor()
reactors[i].tab.w = textWidth(label)
if i == activeIndex then
guiWrite(reactors[i].tab.x,reactors[i].tab.y,color.black,color.orange,"%s",label)
else
guiWrite(reactors[i].tab.x,reactors[i].tab.y,color.blue,color.white,"%s",label)
end
printf(" ")
end
guiWrite(x-25,1,color.yellow,color.panel,"Макс. выраб.: ")
getCord(infcord.maxgen)
if inf.generationRate > maxGenerationRate then
maxGenerationRate = inf.generationRate
end
guiWrite(infcord.maxgen.x,infcord.maxgen.y,color.green,color.panel,"%s",numformat(maxGenerationRate))
drawSeparator(x)
gpu.setBackground(color.panel)
gpu.setForeground(color.blue)
printf(" ПАРАМЕТРЫ ")
term.setCursor(30,4)
printf(" УПРАВЛЕНИЕ ")
gpu.setBackground(color.grey)
gpu.setForeground(color.white)
term.setCursor(1,6)
gpu.setBackground(color.panel)
printf(" Температура:     ")
gpu.setBackground(color.grey)
printf(" ")
getCord(infcord.temp)
guiWrite(infcord.temp.x,infcord.temp.y,-1,-1,"%0.2f\n",inf.temperature)
printf(" Вырабатывает:     ")
getCord(infcord.generation)
guiWrite(infcord.generation.x,infcord.generation.y,-1,-1,"%s  \n",numformat(inf.generationRate))
gpu.setBackground(color.panel)
printf (" Поток:           ")
gpu.setBackground(color.grey)
printf(" ")
getCord(infcord.flow)
infcord.flow.value = upgate.getFlow()
guiWrite(infcord.flow.x,infcord.flow.y,-1,-1,"%s  ",numformat(infcord.flow.value))
getCord(button.add)
makeButton(button.add.x + 4, button.add.y ,button.add.name)
getCord(button.sub)
makeButton(button.sub.x+2,button.sub.y,button.sub.name)

printf("\n")
printf (" Итоговая мосч:    ")
getCord(infcord.puregen)
guiWrite(infcord.puregen.x,infcord.puregen.y,-1,-1,"%s  \n",numformat(inf.generationRate - downgate.getFlow()))
gpu.setBackground(color.panel)
printf (" Поглощает:       ")
gpu.setBackground(color.grey)
printf(" ")
getCord(infcord.drain)
guiWrite(infcord.drain.x,infcord.drain.y,-1,-1,"%s  \n",numformat(downgate.getFlow()))

printf (" Мощность поля:    ")
getCord(infcord.fstrth)
if inf.maxFieldStrength > 0 then
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)
else
guiWrite(infcord.fstrth.x,infcord.fstrth.y,-1,-1,"0 / 0 (0 %%) \n")
end
gpu.setBackground(color.panel)
printf (" Насыщенность:    ")
gpu.setBackground(color.grey)
printf(" ")
getCord(infcord.esturn)
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)
else
guiWrite(infcord.esturn.x,infcord.esturn.y,-1,-1,"0 / 0 (0 %%) \n")
end
printf (" Топливо:          ")
getCord(infcord.fuel)

if inf.fuelConversion/inf.maxFuelConversion < 0.78 then
guiWrite(infcord.fuel.x,infcord.fuel.y,-1,-1,"%d / %d (%0.2f %%)                           \n",inf.fuelConversion,inf.maxFuelConversion,(inf.fuelConversion/inf.maxFuelConversion)*100)
else
if inf.maxFuelConversion > 0 then
if inf.status == "online" or inf.status == "charging" or inf.status == "charged" then
guiWrite(infcord.fuel.x,infcord.fuel.y,color.red,-1,"%d / %d (%0.2f %%) Критический уровень топлива\n",inf.fuelConversion,inf.maxFuelConversion,(inf.fuelConversion/inf.maxFuelConversion)*100)
else
guiWrite(infcord.fuel.x,infcord.fuel.y,-1,-1,"%d / %d (%0.2f %%) Критический уровень топлива\n",inf.fuelConversion,inf.maxFuelConversion,(inf.fuelConversion/inf.maxFuelConversion)*100)
end
else
guiWrite(infcord.fuel.x,infcord.fuel.y,-1,-1,"0 / 0 (0 %%)                           \n")
end
end
gpu.setBackground(color.panel)
printf (" Расход топлива:  ")
gpu.setBackground(color.grey)
printf(" ")
getCord(infcord.fuelconv)
guiWrite(infcord.fuelconv.x,infcord.fuelconv.y,-1,-1,"%d\n",inf.fuelConversionRate)

getCord(infcord.core)
if com.isAvailable("draconic_rf_storage") then
guiWrite(infcord.core.x,infcord.core.y,-1,-1,coreformat())
end
printf("\n")
button.stop.x,button.stop.y = term.getCursor()
button.start.x,button.start.y = button.stop.x,button.stop.y + 1
button.charge.x,button.charge.y = button.stop.x,button.stop.y + 2
button.stop.w = textWidth(button.stop.name)
button.start.w = textWidth(button.start.name)
button.charge.w = textWidth(button.charge.name)
term.setCursor(button.stop.x, button.stop.y + 3)
printf("                   Автономный режим: ")
getCord(button.autoon)
getCord(button.autooff)
if not autostate then
guiWrite(button.autooff.x,button.autooff.y,color.red,color.black,"%s\n",button.autooff.name)
else
guiWrite(button.autoon.x,button.autoon.y,color.green,color.black,"%s\n",button.autoon.name)
end
checkButtons()

end
-- Обновление обзора реакторов
local function refreshOverview()
if not handleOverview then
return
end
if not reactors or #reactors == 0 then
return
end
gpu.setForeground(color.white)
local stopPct = cfg.fuelStopPct or 98
local totalGen = 0
local totalProfit = 0
local totalShield = 0
local maxProfit = 0
gpu.setBackground(color.grey)
for i=1,#reactors do
local r = reactors[i]
local ok, inf = pcall(r.reactor.getReactorInfo)
if not ok or type(inf) ~= "table" then
guiWrite(r.row.status.x,r.row.status.y,color.red,-1,"ERR")
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.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,"----")
else
totalGen = totalGen + inf.generationRate
guiWrite(r.row.gen.x,r.row.gen.y,-1,-1,"%s",numformat(inf.generationRate))
local flow = getGateFlow(r.upgate)
guiWrite(r.row.flow.x,r.row.flow.y,-1,-1,"%s",numformat(flow))
local shieldFlow = getGateFlow(r.downgate)
totalShield = totalShield + shieldFlow
local profit = inf.generationRate - shieldFlow
totalProfit = totalProfit + profit
if profit > maxProfit then
maxProfit = profit
end
guiWrite(r.row.profit.x,r.row.profit.y,-1,-1,"%s",numformat(profit))
local tempColor = color.white
if inf.temperature >= cfg.tempCriticalEdge then
tempColor = color.red
elseif inf.temperature >= cfg.safeModeTempWaitEdge then
tempColor = color.yellow
end
guiWrite(r.row.temp.x,r.row.temp.y,tempColor,-1,"%4.0fC",inf.temperature)
local fuelPct = 0
if inf.maxFuelConversion > 0 then
fuelPct = (inf.fuelConversion/inf.maxFuelConversion)*100
end
if autoStopped[r.reactorAdr] and (inf.status == "online" or inf.status == "charging" or inf.status == "charged") then
autoStopped[r.reactorAdr] = nil
end
if fuelPct >= stopPct and (inf.status == "online" or inf.status == "charging" or inf.status == "charged") then
if not autoStopped[r.reactorAdr] then
r.reactor.stopReactor()
autoStopped[r.reactorAdr] = true
end
end
local fuelColor = color.white
if fuelPct >= 80 then
fuelColor = color.red
end
guiWrite(r.row.fuel.x,r.row.fuel.y,fuelColor,-1,"%5.1f%%",fuelPct)
local stColor = color.white
if inf.status == "online" or inf.status == "charging" or inf.status == "charged" then
stColor = color.green
elseif inf.status == "offline" or inf.status == "stopping" then
stColor = color.red
end
guiWrite(r.row.status.x,r.row.status.y,stColor,-1,"%s",statusText(inf.status))
makePowerButton(r.control.dec.x,r.control.dec.y,"[-]",color.dim,color.white)
makePowerButton(r.control.inc.x,r.control.inc.y,"[+]",color.dim,color.white)
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
r.powerBtn.action = "stop"
makePowerButton(r.powerBtn.x,r.powerBtn.y,"PWR",color.red,color.white)
else
r.powerBtn.action = "start"
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))
guiWrite(summaryEuCord.x,summaryEuCord.y,color.white,color.panel,"%s",numformat(math.floor(totalProfit/8)))
guiWrite(summaryShieldCord.x,summaryShieldCord.y,color.white,color.panel,"%s",numformat(totalShield))
guiWrite(summaryGenCord.x,summaryGenCord.y,color.white,color.panel,"%s",numformat(totalGen))
guiWrite(summaryMaxProfitCord.x,summaryMaxProfitCord.y,color.white,color.panel,"%s / %s",numformat(maxSummaryProfit),numformat(math.floor(maxSummaryProfit/8)))
local autoList = {}
for i=1,#reactors do
if autoStopped[reactors[i].reactorAdr] then
autoList[#autoList+1] = "R"..i
end
end
local autoText = "нет"
if #autoList > 0 then
autoText = table.concat(autoList, ", ")
end
guiWrite(autoStoppedCord.x,autoStoppedCord.y,color.red,-1,"%s",autoText)
end
local screen = {}
screen["overview"] = screenOverview
screen["detail"] = screenMain
screen["options"] = screenOptions

local function editOption(param)
local rd = true
while rd do
gpu.fill(param.x, param.y, #tostring(param.value), 1, " ")
term.setCursor(param.x,param.y)

param.value = term.read(false,false)
local val = tonumber(param.value)
if val then
param.value = val
show(color.black,color.grey,param)
rd = false
end
end
canedit = true
canclose = true
screen.options()
end

local function add(n,i)
n.value=n.value+i
upgate.setSignalLowFlow(n.value)
return n.value
end

local function sub(n,i)
term.setCursor(n.x,n.y)
n.value=n.value-i
return n.value
end
-- Обновление информации на экране + анализ поведения температуры
local function refreshInfo()
local ok, inf = pcall(reactor.getReactorInfo)
if not ok or type(inf) ~= "table" then
refreshReactors(false)
screenOverview()
return
end
infcord.status.value = inf.status
gpu.setForeground(color.white)
local tbuf1 = inf.temperature
os.sleep(0.1)
local ok2, inf2 = pcall(reactor.getReactorInfo)
local tbuf2 = ok2 and type(inf2) == "table" and inf2.temperature or tbuf1
if handleMain then
local stopPct = cfg.fuelStopPct or 98
if cfg.autoProtectTempEdge and inf.temperature >= cfg.autoProtectTempEdge and not autostate then
autostate = true
guiWrite(button.autoon.x,button.autoon.y,color.green,color.black,"%s\n",button.autoon.name)
end
syncActive()
local fuelPct = 0
if inf.maxFuelConversion > 0 then
fuelPct = (inf.fuelConversion/inf.maxFuelConversion)*100
end
if autoStopped[reactors[activeIndex].reactorAdr] and (inf.status == "online" or inf.status == "charging" or inf.status == "charged") then
autoStopped[reactors[activeIndex].reactorAdr] = nil
end
if fuelPct >= stopPct and (inf.status == "online" or inf.status == "charging" or inf.status == "charged") then
if not autoStopped[reactors[activeIndex].reactorAdr] then
reactor.stopReactor()
autoStopped[reactors[activeIndex].reactorAdr] = true
end
end
if tbuf2>tbuf1 then
guiWrite(infcord.temp.x,infcord.temp.y,color.red,-1,"%0.2f \n",inf.temperature)
temprise = true
elseif tbuf2<tbuf1 then
guiWrite(infcord.temp.x,infcord.temp.y,color.blue,-1,"%0.2f \n",inf.temperature)
temprise = false
else
if inf.temperature == 2000 then
guiWrite(infcord.temp.x,infcord.temp.y,-1,-1,"%0.2f \n",inf.temperature)
end
end
guiWrite(infcord.generation.x,infcord.generation.y,-1,-1,"%s\n",numformat(inf.generationRate))
if inf.generationRate > maxGenerationRate then
maxGenerationRate = inf.generationRate
end
guiWrite(infcord.maxgen.x,infcord.maxgen.y,color.green,color.panel,"%s",numformat(maxGenerationRate))
infcord.flow.value = upgate.getFlow()
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 - downgate.getFlow()))
infcord.drain.value = inf.fieldDrainRate
guiWrite(infcord.drain.x,infcord.drain.y,-1,-1,"%s\n",numformat(downgate.getFlow()))
if inf.maxFieldStrength > 0 then
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)
else
guiWrite(infcord.fstrth.x,infcord.fstrth.y,-1,-1,"0 / 0 (0 %%) \n")
end
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)
else
guiWrite(infcord.esturn.x,infcord.esturn.y,-1,-1,"0 / 0 (0 %%) \n")
end
if inf.fuelConversion/inf.maxFuelConversion < 0.78 then
guiWrite(infcord.fuel.x,infcord.fuel.y,-1,-1,"%d / %d (%0.2f %%) \n",inf.fuelConversion,inf.maxFuelConversion,(inf.fuelConversion/inf.maxFuelConversion)*100)
else
if inf.maxFuelConversion > 0 then
if inf.status == "online" or inf.status == "charging" or inf.status == "charged" then
guiWrite(infcord.fuel.x,infcord.fuel.y,color.red,-1,"%d / %d (%0.2f %%) Критический уровень топлива\n",inf.fuelConversion,inf.maxFuelConversion,(inf.fuelConversion/inf.maxFuelConversion)*100)
else
guiWrite(infcord.fuel.x,infcord.fuel.y,-1,-1,"%d / %d (%0.2f %%) Критический уровень топлива\n",inf.fuelConversion,inf.maxFuelConversion,(inf.fuelConversion/inf.maxFuelConversion)*100)
end
else
guiWrite(infcord.fuel.x,infcord.fuel.y,-1,-1,"0 / 0 (0 %%)\n")
end
end
guiWrite(infcord.fuelconv.x,infcord.fuelconv.y,-1,-1,"%d\n",inf.fuelConversionRate)
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()
end
elseif button.stop.y ~= infcord.fuelconv.y + 2 then
screenMain()
end
checkButtons()
syncActive()
end
end
-- Алгоритм автономного режима
local function autoForReactor(r, state)
if not r or not r.reactor or not r.upgate or not r.downgate then
return
end
local ok, inf = pcall(r.reactor.getReactorInfo)
if not ok or type(inf) ~= "table" then
return
end
local now = computer.uptime()
if r.chargeRequested and now <= r.chargeRequested then
local downflow = 900000
r.downgate.setOverrideEnabled(false)
r.downgate.setSignalHighFlow(downflow)
r.downgate.setSignalLowFlow(downflow)
return
end
local isActive = reactors[activeIndex] and reactors[activeIndex].reactorAdr == r.reactorAdr
if cfg.autoProtectTempEdge and inf.temperature >= cfg.autoProtectTempEdge and not r.autostate then
r.autostate = true
if isActive then
autostate = true
if handleMain and button.autoon.x then
guiWrite(button.autoon.x,button.autoon.y,color.green,color.black,"%s\n",button.autoon.name)
end
end
end
local shieldPct = cfg.shield or 25
local flow = getGateFlow(r.upgate)
if type(flow) ~= "number" then
flow = 0
end
local drain = inf.fieldDrainRate
if state then
local forceEdge = cfg.forceModeTempLowEdge or 7600
if forceEdge < 7600 then
forceEdge = 7600
end
local waittemp = autoWaitTempByAdr[r.reactorAdr]
local tempRise = false
if r.lastTemp then
if inf.temperature > r.lastTemp then
tempRise = true
elseif inf.temperature < r.lastTemp then
tempRise = false
else
tempRise = r.temprise or false
end
end
r.lastTemp = inf.temperature
r.temprise = tempRise
local downflow = drain / (1 - (shieldPct/100))
r.downgate.setOverrideEnabled(true)
r.downgate.setFlowOverride(downflow)
if inf.temperature <= forceEdge then
if flow - inf.generationRate <= cfg.forceModeStepCase then
flow = flow + cfg.forceModeStep
r.upgate.setSignalLowFlow(flow)
end
elseif flow - inf.generationRate <= cfg.safeModeStepCase and inf.temperature >= forceEdge then
if not waittemp then
flow = getGateFlow(r.upgate) + cfg.safemodeStep
r.upgate.setSignalLowFlow(flow)
elseif inf.temperature < cfg.safeModeTempToWaitEdge then
waittemp = false
end
elseif tempRise and inf.temperature >= cfg.safeModeTempWaitEdge then
if inf.temperature > cfg.safeModeTempWaitEdge then
waittemp = true
end
if inf.temperature > cfg.tempCriticalEdge then
flow = inf.generationRate - 1000
r.upgate.setSignalLowFlow(flow)
end
end
autoWaitTempByAdr[r.reactorAdr] = waittemp
if isActive and handleMain and infcord.flow.x then
infcord.flow.value = flow
guiWrite(infcord.flow.x,infcord.flow.y,color.red,color.grey,"%s",numformat(flow))
end
else
local downflow
if inf.status == "charging" then
downflow = 900000
else
downflow = drain / (1 - (shieldPct/100))
end
r.downgate.setOverrideEnabled(false)
r.downgate.setSignalHighFlow(downflow)
r.downgate.setSignalLowFlow(downflow)
end
end
-- Обработчик событий
local function tcall(type,scrnAdr,x,y,btn,player)
local rx,ry = gpu.getResolution()
--выход
if x >= rx-2 and x<=rx and y == 1 then
event.ignore("touch",tcall)
prog = false
ops = false
end
-- Главный экран
if handleMain then
-- Увеличение
if x >= button.add.x+4 and x <= button.add.x+3+#button.add.name and y == button.add.y then
if keyb.isShiftDown() then
if keyb.isControlDown() then
upgate.setSignalLowFlow(add(infcord.flow,cfg.ctrlShift_interval))
else
upgate.setSignalLowFlow(add(infcord.flow,cfg.shift_interval))
end
else
if keyb.isControlDown() then
upgate.setSignalLowFlow(add(infcord.flow,cfg.ctrl_interval))
else
upgate.setSignalLowFlow(add(infcord.flow,cfg.default_interval))
end
end
guiWrite(infcord.flow.x,infcord.flow.y,color.red,color.grey,"%s",numformat(infcord.flow.value))
end
--Уменьшение
if x >= button.sub.x+2 and x <= button.sub.x+1+#button.sub.name and y == button.sub.y then
if keyb.isShiftDown() then
if keyb.isControlDown() then
upgate.setSignalLowFlow(sub(infcord.flow,cfg.ctrlShift_interval))
else
upgate.setSignalLowFlow(sub(infcord.flow,cfg.shift_interval))
end
else
if keyb.isControlDown() then
upgate.setSignalLowFlow(sub(infcord.flow,cfg.ctrl_interval))
else
upgate.setSignalLowFlow(sub(infcord.flow,cfg.default_interval))
end
end
guiWrite(infcord.flow.x,infcord.flow.y,color.blue,color.grey,"%s",numformat(infcord.flow.value))
end

if not autostate then
if x >= button.autooff.x and x <= button.autooff.x + textWidth(button.autooff.name) - 1 and y == button.autooff.y then
gpu.set(button.autooff.x, button.autooff.y,"        ")
autostate = true
guiWrite(button.autoon.x,button.autoon.y,color.green,color.black,"%s\n",button.autoon.name)
end
else
if x >= button.autoon.x and x <= button.autoon.x + textWidth(button.autoon.name) - 1 and y == button.autoon.y then
gpu.set(button.autoon.x, button.autoon.y,"       ")
autostate = false
guiWrite(button.autooff.x,button.autooff.y,color.red,color.black,"%s\n",button.autooff.name)
end
end
if button.charge.visible then
local w = button.charge.w or textWidth(button.charge.name)
if x >= button.charge.x and x <= button.charge.x + w - 1 and y == button.charge.y then
ensureFlowInit(reactors[activeIndex], true)
if reactors[activeIndex] and reactors[activeIndex].downgate then
pcall(reactors[activeIndex].downgate.setSignalHighFlow, reactors[activeIndex].downgate, 900000)
pcall(reactors[activeIndex].downgate.setSignalLowFlow, reactors[activeIndex].downgate, 900000)
pcall(reactors[activeIndex].downgate.setOverrideEnabled, reactors[activeIndex].downgate, false)
end
if reactors[activeIndex] then
reactors[activeIndex].chargeRequested = computer.uptime() + 2
chargeRequestByAdr[reactors[activeIndex].reactorAdr] = reactors[activeIndex].chargeRequested
end
reactor.chargeReactor()
guiWrite(button.charge.x,button.charge.y,-1,color.grey,"                 ",button.charge.name)
button.charge.visible = false
end
end
if button.start.visible then
local w = button.start.w or textWidth(button.start.name)
if x >= button.start.x and x <= button.start.x + w - 1 and y == button.start.y then
ensureFlowInit(reactors[activeIndex])
reactor.activateReactor()
if reactors[activeIndex] then
autoStopped[reactors[activeIndex].reactorAdr] = nil
end
guiWrite(button.start.x,button.start.y,-1,color.grey,"                 ",button.start.name)
button.start.visible = false
end
end
if button.stop.visible then
local w = button.stop.w or textWidth(button.stop.name)
if x >= button.stop.x and x <= button.stop.x + w - 1 and y == button.stop.y then
reactor.stopReactor()
guiWrite(button.stop.x,button.stop.y,-1,color.grey,"                 ",button.stop.name)
button.stop.visible = false
end
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
screenOptions()
return
end
if x>= menuItem.overview.x and x <= (menuItem.overview.x + (menuItem.overview.w or #menuItem.overview.name) - 1) and y == menuItem.overview.y then
syncActive()
screenOverview()
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
refreshReactors(true)
return
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
resetAssignState()
screenAssign()
return
end
for i=1,#reactors do
local tab = reactors[i].tab
if tab.x and x >= tab.x and x <= tab.x + tab.w - 1 and y == tab.y then
syncActive()
setActive(i)
screenMain()
return
end
end
if x == 1 and y == 1 then
event.ignore("touch",tcall)
prog = false
end
end
-- Экран обзора
if handleOverview 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()
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
refreshReactors(true)
return
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
resetAssignState()
screenAssign()
return
end
for i=1,#reactors do
local tab = reactors[i].tab
if tab.x and x >= tab.x and x <= tab.x + tab.w - 1 and y == tab.y then
syncActive()
setActive(i)
screenMain()
return
end
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)
return
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
local flow = getGateFlow(reactors[i].upgate)
reactors[i].upgate.setSignalLowFlow(flow + cfg.default_interval)
return
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
reactors[i].autostate = not reactors[i].autostate
if i == activeIndex then
autostate = reactors[i].autostate
end
refreshOverview()
return
end
local btn = reactors[i].powerBtn
if btn.x and x >= btn.x and x <= btn.x + btn.w - 1 and y == btn.y then
if btn.action == "start" then
ensureFlowInit(reactors[i])
reactors[i].reactor.activateReactor()
autoStopped[reactors[i].reactorAdr] = nil
else
reactors[i].reactor.stopReactor()
end
return
end
end
if x == 1 and y == 1 then
event.ignore("touch",tcall)
prog = false
end
end
-- Экран настроек
if handleOptions then
-- Работа со значениями
if canedit then
if x >= OptionDefault.x and x <= OptionDefault.x + #tostring(OptionDefault.value)-1 and y == OptionDefault.y then
canclose = false
canedit = false
editOption(OptionDefault)
end
if x >= OptionCtrl.x and x <= OptionCtrl.x + #tostring(OptionCtrl.value)-1 and y == OptionCtrl.y then
canclose = false
canedit = false
editOption(OptionCtrl)
end
if x >= OptionShift.x and x <= OptionShift.x + #tostring(OptionShift.value)-1 and y == OptionShift.y then
canclose = false
canedit = false
editOption(OptionShift)
end
if x >= OptionCtrlShift.x and x <= OptionCtrlShift.x + #tostring(OptionCtrlShift.value)-1 and y == OptionCtrlShift.y then
canclose = false
canedit = false
editOption(OptionCtrlShift)
end
if x >= OptionShield.x and x <= OptionShield.x + #tostring(OptionShield.value)-1 and y == OptionShield.y then
canclose = false
canedit = false
editOption(OptionShield)
end
if x >= OptionFuelStop.x and x <= OptionFuelStop.x + #tostring(OptionFuelStop.value)-1 and y == OptionFuelStop.y then
canclose = false
canedit = false
editOption(OptionFuelStop)
end
end
-- меню
if canclose 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
screenOverview()
return
end
if x>= menuItem.save.x and x <= (menuItem.save.x + (menuItem.save.w or #menuItem.save.name) - 1) and y == menuItem.save.y then
cfg.default_interval = OptionDefault.value
cfg.ctrl_interval = OptionCtrl.value
cfg.shift_interval = OptionShift.value
cfg.ctrlShift_interval = OptionCtrlShift.value
cfg.shield = OptionShield.value
cfg.fuelStopPct = OptionFuelStop.value
configWrite(cfgName)
screenOverview()
return
end
if x>= menuItem.cancel.x and x <= (menuItem.cancel.x + (menuItem.cancel.w or #menuItem.cancel.name) - 1) and y == menuItem.cancel.y then
OptionDefault.value = cfg.default_interval
OptionCtrl.value = cfg.ctrl_interval
OptionShift.value = cfg.shift_interval
OptionCtrlShift.value = cfg.ctrlShift_interval
OptionShield.value = cfg.shield
OptionFuelStop.value = cfg.fuelStopPct or 98
screenOverview()
return
end
end
end
-- Экран гейтов
-- gates screen
if handleAssign then
if x>= menuItem.back.x and x <= (menuItem.back.x + (menuItem.back.w or #menuItem.back.name) - 1) and y == menuItem.back.y then
if not assignState.reactorIndex and not assignState.shieldGateIdx and not assignState.outGateIdx then
resetAssignState()
screenOverview()
return
end
assignState.message = "Выбери гейты!"
screenAssign()
return
end
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
clearAssignedGates(assignState.reactorIndex)
reactors = buildReactors() or reactors
resetAssignState()
screenAssign()
end
return
end
for i=1,#assignUi.reactors do
local btn = assignUi.reactors[i]
if btn and x >= btn.x and x <= btn.x + btn.w - 1 and y == btn.y then
assignState.reactorIndex = i
assignState.shieldGateIdx = nil
assignState.outGateIdx = nil
assignState.step = "shield"
screenAssign()
return
end
end
for i=1,#assignUi.gates do
local btn = assignUi.gates[i]
if btn and x >= btn.x and x <= btn.x + btn.w - 1 and y == btn.y then
local gateAdr = assignUi.gateAddrs[i]
if assignState.step == "reactor" then
return
end
if gateAdr and assignUi.gateUse[gateAdr] and assignUi.gateUse[gateAdr] ~= assignUi.selectedAdr then
return
end
local selectedEntry = assignUi.selectedEntry
if not assignState.reactorIndex then
assignState.step = "reactor"
screenAssign()
return
end
if assignState.step == "shield" then
assignState.shieldGateIdx = i
assignState.step = "output"
screenAssign()
return
elseif assignState.step == "output" then
if assignState.shieldGateIdx and assignUi.gateAddrs[assignState.shieldGateIdx] == gateAdr then
assignState.message = "Нужны два разных гейта!"
screenAssign()
return
end
assignState.outGateIdx = i
local idx = assignState.reactorIndex
local saved = saveAssignedGates(assignState.reactorIndex, assignState.shieldGateIdx, assignState.outGateIdx)
resetAssignState()
refreshReactors(false)
if not saved or not reactors or #reactors == 0 then
screenOverview()
return
end
screenMain()
return
end
end
end
if x == 1 and y == 1 then
event.ignore("touch",tcall)
prog = false
end
end
end

event.listen("touch",tcall)
screenStart()
if upgate ~= nil and downgate ~= nil then
screen.overview()
end
while prog do
local now = computer.uptime()
if handleMain and now - lastDetailUpdate >= 0.2 then
lastDetailUpdate = now
if not pcall(refreshInfo) then
autostate = false
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
os.sleep(0)
end
gpu.setBackground(rback)
gpu.setForeground(rfore)
gpu.setResolution(xz,yz)
term.clear()