5reactors+

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 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 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 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 assignUi = {reactors = {}, gates = {}, gateAddrs = {}, reactorAddrs = {}, gateUse = {}, selectedAdr = nil, back = {x=nil,y=nil,w=0}}

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}
local autoStopped = {}
local autoWaitTempByAdr = {}
local chargeRequestByAdr = {}
local autoStoppedCord = {x=nil,y=nil}
local chargeHintDismissed = false
local chargeHint = {x=nil,y=nil,w=0,visible=false}

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 isComponentAlive(addr)
if not addr then
return false
end
return com.get(addr) ~= nil
end

local function ensureFlowInit(r, force)
if not r or (r.flowInit and not force) then
return
end
pcall(r.upgate.setSignalLowFlow, r.upgate, CHARGE_FLOW)
r.flowInit = true
flowInitByAdr[r.reactorAdr] = true
if reactors[activeIndex] and reactors[activeIndex].reactorAdr == r.reactorAdr then
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))
end
end
end

local function canChargeStatus(status)
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 "ВКЛ"
elseif status == "offline" then
return "ВЫК"
elseif status == "charging" then
return "ЗАР"
elseif status == "charged" then
return "ГОТ"
elseif status == "stopping" then
return "СТП"
elseif status == "cold" then
return "ХОЛ"
elseif status == "cooling" then
return "ОСТ"
elseif status == "warming_up" 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
button.start.visible = false
button.stop.visible = false
button.charge.visible = false
if canChargeStatus(infcord.status.value) then
guiWrite(button.charge.x,button.charge.y,color.skyblue,color.black,"%s",button.charge.name)
button.charge.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
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 == "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
end
end
end
-- Инициализация программы, анализ и настройка всей технической белеберды
local function screenStart()
handleMain = false
handleOptions = false
handleStart = true
local x = drawHeader("HiTech Classic is the best   (Preparation)")
if not firstStartCompleted then
printf("Эта страница для настройки программы при первом запуске или после сбоя")
end
drawSeparator(x)
term.setCursor(1,screenH - 2)
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)
local hadFile = readReactorsFile() ~= nil
while true do
if not ops then return end
reactors = buildReactors()
if reactors and #reactors > 0 then
setActive(1)
firstStartCompleted = true
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 {}
firstStartCompleted = true
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

local saveAssignedGates

local function getChatBox()
if chatBox then
return chatBox
end
if com.isAvailable("chat_box") then
chatBox = com.chat_box
end
return chatBox
end

local function chatSay(message, color_code)
local box = getChatBox()
if not box or not message then
return false
end
if box.say and pcall(function() box.say(message) end) then
return true
end
if box.sendMessage and pcall(function() box.sendMessage(message) end) then
return true
end
if box.sendMessage and pcall(function() box.sendMessage(message, color_code or 64) end) then
return true
end
return false
end

local function maybeChatSay(step, message, color_code)
if step and easyAssign.lastChatStep ~= step then
easyAssign.lastChatStep = step
easyAssign.lastChatMessage = nil
end
if message and easyAssign.lastChatMessage ~= message then
easyAssign.lastChatMessage = message
chatSay(message, color_code)
end
end

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

local function initEasyKnown()
easyAssign.known = {draconic_reactor = {}, flux_gate = {}}
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
end
end

local function findNewComponent(typeName)
if not easyAssign.known or not easyAssign.known[typeName] then
initEasyKnown()
end
for addr in com.list(typeName) do
if not easyAssign.known[typeName][addr] then
easyAssign.known[typeName][addr] = true
return addr
end
end
return nil
end

local function isAddressUsed(addr)
if not addr then
return false
end
local entries = readReactorsFile() or {}
for i=1,#entries do
if entries[i].reactorAdr == addr or entries[i].upAdr == addr or entries[i].downAdr == addr then
return true
end
end
return false
end

local function clearAssignedByAdr(reactorAdr)
if not reactorAdr then
return false
end
local entries = readReactorsFile() or {}
local newEntries = {}
local removed = false
for i=1,#entries do
if entries[i].reactorAdr ~= reactorAdr then
newEntries[#newEntries+1] = entries[i]
else
removed = true
end
end
if removed then
writeReactorsFile(newEntries)
end
return removed
end

local function startEasyAssign()
local entries = readReactorsFile() or {}
if #entries >= MAX_REACTORS then
easyAssign.active = false
easyAssign.message = "Достигнут лимит реакторов."
return
end
if not getChatBox() then
easyAssign.active = false
easyAssign.message = "Ошибка: для работы нужен chat_box."
return
end
easyAssign.active = true
easyAssign.step = "reactor"
easyAssign.core = nil
easyAssign.shield = nil
easyAssign.output = nil
easyAssign.saved = false
easyAssign.message = nil
easyAssign.index = #entries + 1
easyAssign.lastChatStep = nil
easyAssign.lastChatMessage = nil
initEasyKnown()
maybeChatSay("intro", "Легкий режим: подключите адаптер к реактору #" .. tostring(easyAssign.index) .. " и смотрите монитор.")
end

local function screenAssignChoice()
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)
gpu.setForeground(color.white)
term.setCursor(2,5)
printf("Выберите способ добавления гейтов:")
local heavyLabel = " Тяжелый способ (анализатор) "
local easyLabel = " Легкий способ (подключение) "
local heavyX, heavyY = 2, 7
local easyX, easyY = 2, 9
easyAssign.heavyBtn = {x=heavyX,y=heavyY,w=textWidth(heavyLabel)}
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)
end
end

local function screenAssignEasy()
handleMain = false
handleStart = false
handleOptions = false
handleOverview = false
handleAssign = true
local x = drawHeader("HiTech Classic is the best   (Гейты - Легкий)")
drawSeparator(x)
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()
easyAssign.backBtn = {x=menuItem.back.x,y=menuItem.back.y,w=textWidth(menuItem.back.name)}
gpu.setForeground(color.blue)
printf(menuItem.back.name)
menuItem.back.w = textWidth(menuItem.back.name)
gpu.setForeground(color.white)
term.setCursor(2,5)
printf("РЕАКТОР #%d", easyAssign.index or 1)
term.setCursor(2,7)
if easyAssign.step == "reactor" then
guiWrite(2,7,color.green,-1,"Подключите адаптер к ядру реактора.")
maybeChatSay("reactor", "Подключите адаптер к ядру реактора.", 255)
elseif easyAssign.step == "shield" then
guiWrite(2,7,color.green,-1,"Подключите адаптер к гейту ЩИТОВ.")
maybeChatSay("shield", "Подключите адаптер к гейту ЩИТОВ.", 4096)
elseif easyAssign.step == "output" then
guiWrite(2,7,color.green,-1,"Подключите адаптер к гейту ВЫВОДА.")
maybeChatSay("output", "Подключите адаптер к гейту ВЫВОДА.", 16711680)
elseif easyAssign.step == "done" then
guiWrite(2,7,color.green,-1,"Реактор добавлен.")
maybeChatSay("done", "Реактор добавлен. Смотрите монитор.", 65280)
end
term.setCursor(2,9)
printf("Ожидаю компонент...")
local infoY = 11
local coreLine = "Ядро: " .. (easyAssign.core or "-")
local shieldLine = "Щиты: " .. (easyAssign.shield or "-")
local outputLine = "Вывод: " .. (easyAssign.output or "-")
local coreColor = (easyAssign.step == "reactor") and color.blue or (easyAssign.core and color.green or color.white)
local shieldColor = (easyAssign.step == "shield") and color.blue or (easyAssign.shield and color.green or color.white)
local outputColor = (easyAssign.step == "output") and color.blue or (easyAssign.output and color.green or color.white)
guiWrite(2,infoY,coreColor,-1,"%s",coreLine)
guiWrite(2,infoY + 1,shieldColor,-1,"%s",shieldLine)
guiWrite(2,infoY + 2,outputColor,-1,"%s",outputLine)
if easyAssign.message then
guiWrite(2,infoY + 4,color.yellow,-1,"%s",easyAssign.message)
end
if easyAssign.step == "done" then
local contLabel = " [Продолжить] "
local finLabel = " [Завершить] "
local contX, contY = 2, infoY + 6
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)
end
end

local function screenAssignManual()
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)
gpu.setForeground(color.white)
term.setCursor(2,4)
printf("Выберите реактор")
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,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 screenAssign()
if assignMode == "manual" then
screenAssignManual()
elseif assignMode == "easy" then
screenAssignEasy()
else
screenAssignChoice()
end
end

local function acceptEasyComponent(address, componentType)
if easyAssign.step == "reactor" then
if componentType ~= "draconic_reactor" then
easyAssign.message = "Нужен draconic_reactor."
screenAssignEasy()
return
end
if isAddressUsed(address) then
easyAssign.message = "Адрес уже используется."
screenAssignEasy()
return
end
easyAssign.core = address
easyAssign.step = "shield"
easyAssign.message = "Реактор принят."
maybeChatSay("accepted", "Реактор принят. Смотри монитор.")
screenAssignEasy()
return
end
if easyAssign.step == "shield" then
if componentType ~= "flux_gate" then
easyAssign.message = "Нужен flux_gate."
screenAssignEasy()
return
end
if isAddressUsed(address) then
easyAssign.message = "Адрес уже используется."
screenAssignEasy()
return
end
easyAssign.shield = address
easyAssign.step = "output"
easyAssign.message = "Гейт щитов принят."
maybeChatSay("accepted", "Гейт щитов принят. Смотри монитор.")
screenAssignEasy()
return
end
if easyAssign.step == "output" then
if componentType ~= "flux_gate" then
easyAssign.message = "Нужен flux_gate."
screenAssignEasy()
return
end
if isAddressUsed(address) or address == easyAssign.shield then
easyAssign.message = "Нужны два разных гейта."
screenAssignEasy()
return
end
easyAssign.output = address
local saved = saveAssignedGates(easyAssign.core, easyAssign.shield, easyAssign.output)
if not saved then
easyAssign.message = "Не удалось сохранить."
screenAssignEasy()
return
end
easyAssign.saved = true
easyAssign.step = "done"
easyAssign.message = "Успешно сохранено."
maybeChatSay("accepted", "Успешно сохранено. Смотри монитор.")
screenAssignEasy()
return
end
end

local function handleComponentAdded(_, address, componentType)
if not handleAssign or assignMode ~= "easy" or not easyAssign.active then
return
end
acceptEasyComponent(address, componentType)
end

local function pollEasyAssign()
if not handleAssign or assignMode ~= "easy" or not easyAssign.active then
return
end
if easyAssign.step == "reactor" then
local addr = findNewComponent("draconic_reactor")
if addr then
acceptEasyComponent(addr, "draconic_reactor")
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

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.reactorAdr = nil
assignState.shieldGateIdx = nil
assignState.shieldGateAdr = nil
assignState.outGateIdx = nil
assignState.outGateAdr = nil
assignState.step = "reactor"
end

saveAssignedGates = function(reactorAdr, shieldAdr, outAdr)
if not reactorAdr or not shieldAdr or not outAdr then
return false
end
local entries = readReactorsFile() or {}
local updated = false
for i=1,#entries do
if entries[i].reactorAdr == reactorAdr then
entries[i].upAdr = outAdr
entries[i].downAdr = shieldAdr
updated = true
break
end
end
if not updated then
entries[#entries+1] = {
reactorAdr = reactorAdr,
upAdr = outAdr,
downAdr = shieldAdr
}
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 = reactorAdr
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
if reactors[activeIndex] and (not isComponentAlive(reactors[activeIndex].reactorAdr) or not isComponentAlive(reactors[activeIndex].upAdr) or not isComponentAlive(reactors[activeIndex].downAdr)) then
refreshReactors(false)
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
if reactors[activeIndex] and (not isComponentAlive(reactors[activeIndex].reactorAdr) or not isComponentAlive(reactors[activeIndex].upAdr) or not isComponentAlive(reactors[activeIndex].downAdr)) 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 = getGateFlow(upgate)
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 - getGateFlow(downgate)))
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(getGateFlow(downgate)))

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)
local controlsY = button.stop.y + 3
if not chargeHintDismissed then
	local hint1 = "Перед первым запуском поставь поток на 535 000."
	local hint2 = "Потом включай."
	chargeHint.x = 1
	chargeHint.y = math.max(1, screenH - 1)
	local hintY2 = math.min(screenH, chargeHint.y + 1)
	local prevFg = gpu.getForeground()
	local prevBg = gpu.getBackground()
	gpu.setForeground(color.green)
	gpu.setBackground(color.grey)
	gpu.set(chargeHint.x, chargeHint.y, hint1)
	if hintY2 ~= chargeHint.y then
		gpu.set(chargeHint.x, hintY2, hint2)
	end
	gpu.setForeground(prevFg)
	gpu.setBackground(prevBg)
	chargeHint.w = math.max(textWidth(hint1), textWidth(hint2))
	chargeHint.visible = true
else
	chargeHint.visible = false
end
term.setCursor(button.stop.x, controlsY)
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
end
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 = 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)))
infcord.drain.value = inf.fieldDrainRate
guiWrite(infcord.drain.x,infcord.drain.y,-1,-1,"%s\n",numformat(getGateFlow(downgate)))
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(true)
r.downgate.setFlowOverride(downflow)
return
end
if inf.status == "charging" then
local downflow = 900000
r.downgate.setOverrideEnabled(true)
r.downgate.setFlowOverride(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
if inf.status == "charging" then
r.downgate.setOverrideEnabled(true)
r.downgate.setFlowOverride(downflow)
else
r.downgate.setOverrideEnabled(false)
r.downgate.setSignalHighFlow(downflow)
r.downgate.setSignalLowFlow(downflow)
end
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 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()
screenAssign()
return
end
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
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
local usedNativeCharge = false
if reactor and reactor.chargeReactor then
local ok = pcall(reactor.chargeReactor)
if ok then
usedNativeCharge = true
end
end
if not usedNativeCharge then
ensureFlowInit(reactors[activeIndex], true)
if upgate then
upgate.setSignalLowFlow(CHARGE_FLOW)
end
infcord.flow.value = CHARGE_FLOW
if infcord.flow.x then
guiWrite(infcord.flow.x,infcord.flow.y,color.red,color.grey,"%s",numformat(infcord.flow.value))
end
end
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
chargeHintDismissed = true
end
guiWrite(button.charge.x,button.charge.y,-1,color.grey,"                 ",button.charge.name)
button.charge.visible = false
if not usedNativeCharge then
	local currentReactor = reactors[activeIndex]
	if currentReactor and currentReactor.reactorAdr then
		local chargeUntil = computer.uptime() + CHARGE_DURATION
		currentReactor.chargeRequested = chargeUntil
		chargeRequestByAdr[currentReactor.reactorAdr] = chargeUntil
	end
end
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 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
assignMode = nil
easyAssign.active = false
screenOverview()
return
end
if easyAssign.heavyBtn.x and x >= easyAssign.heavyBtn.x and x <= easyAssign.heavyBtn.x + easyAssign.heavyBtn.w - 1 and y == easyAssign.heavyBtn.y then
assignMode = "manual"
resetAssignState()
screenAssignManual()
return
end
if easyAssign.easyBtn.x and x >= easyAssign.easyBtn.x and x <= easyAssign.easyBtn.x + easyAssign.easyBtn.w - 1 and y == easyAssign.easyBtn.y then
assignMode = "easy"
startEasyAssign()
if not easyAssign.active then
assignMode = nil
screenAssignChoice()
else
screenAssignEasy()
end
return
end
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
if easyAssign.saved and easyAssign.core then
clearAssignedByAdr(easyAssign.core)
end
easyAssign.active = false
easyAssign.step = "reactor"
easyAssign.core = nil
easyAssign.shield = nil
easyAssign.output = nil
easyAssign.saved = false
easyAssign.message = nil
assignMode = nil
screenAssignChoice()
return
end
if easyAssign.step == "done" 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
startEasyAssign()
screenAssignEasy()
return
end
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
assignMode = nil
refreshReactors(false)
screenOverview()
return
end
end
return
end
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()
assignMode = nil
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.reactorAdr = assignUi.reactorAddrs[i]
assignState.shieldGateIdx = nil
assignState.shieldGateAdr = nil
assignState.outGateIdx = nil
assignState.outGateAdr = 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.shieldGateAdr = gateAdr
assignState.step = "output"
screenAssign()
return
elseif assignState.step == "output" then
if assignState.shieldGateAdr and assignState.shieldGateAdr == gateAdr then
assignState.message = "Нужны два разных гейта!"
screenAssign()
return
end
assignState.outGateIdx = i
assignState.outGateAdr = gateAdr
if not assignState.reactorAdr and assignState.reactorIndex then
assignState.reactorAdr = assignUi.reactorAddrs[assignState.reactorIndex]
end
if not assignState.shieldGateAdr and assignState.shieldGateIdx then
assignState.shieldGateAdr = assignUi.gateAddrs[assignState.shieldGateIdx]
end
local saved = saveAssignedGates(assignState.reactorAdr, assignState.shieldGateAdr, assignState.outGateAdr)
if not saved then
assignState.message = "Не удалось сохранить гейты!"
screenAssign()
return
end
local targetAdr = assignState.reactorAdr
resetAssignState()
assignMode = nil
handleAssign = false
handleMain = true
handleOverview = false
reactors = buildReactors() or reactors
local idx = 1
if targetAdr then
for j=1,#reactors do
if reactors[j].reactorAdr == targetAdr then
idx = j
break
end
end
end
setActive(idx)
if not reactors or #reactors == 0 or not reactor or not upgate or not downgate 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)
event.listen("component_added", handleComponentAdded)
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
pollEasyAssign()
os.sleep(0)
end
gpu.setBackground(rback)
gpu.setForeground(rfore)
gpu.setResolution(xz,yz)
term.clear()