View difference between Paste ID: 1fN9bhUd and zdHPxvz7

 ---------------------------------------------------
 -- Mekanism Fission Reactor Monitoring Program   --
 -- Created for CC:Tweaked and Mekanism           --
 -- Originally created by InternetUnexplorer on   --
 -- GitHub. Modified for personal use, by         --
 -- iPlay_G on Minecraft, Derrick355 on GitHub.   --
 -- As the original program did not contain any   --
 -- license, this will not contain any license.   --
 -- However, this software is provided "AS-IS",   --
 -- with NO WARRANTY of ANY kind. There is no     --
 -- guarentee of fitness for a particular         --
 -- purpose.                                      --
 -- Feel free to use it, but I, nor the           --
 -- original author are responsible for any       --
 -- issues arising from the use of this program.  --
 --                    -=@=-                      --
 -- Thank you for downloading this program.       --
 ---------------------------------------------------
 
 
 --- NOTES ---
 -- If you see 'CRITICAL' on your monitor as the
 -- state, that is OK. Critical is what real
 -- reactors are considered when operating normally.
 
 -- It is generally recommended to edit settings
 -- in an IDE or text editor for ease of use.
 
 -- It is assumed you have a 6 wide, 4 tall monitor
 -- attached via a modem.
 
 -- References to an analog lever are common, since
 -- I used the Create mod, however if you don't
 -- have it, any way to input a variable-power
 -- redstone signal should work.
 
 -- Binary levers are just vanillia levers.
 
 -- I recommend putting this program on a disk,
 -- and having a startup script run this program.
 -- I have a second computer that I use to edit
 -- the program in-game so that the main one
 -- only runs this program, and nothing else.
 
 
 --- RECOMMENDED & ASSUMED COMPUTER I/O SETUP ---
 -- TOP: Binary lever, used to enable/disable manual burn rate control
 -- LEFT: Analog lever, used as coarse adjust on burn control
 -- RIGHT: Analog lever, used as fine adjust on burn control
 -- BOTTOM: Binary lever, used as reactor on/off control
 -- BACK: Modem to connect to reactor, turbine, and monitor
-burn_rate_coarse_multi = 75
+
 
 
 --- VARIABLE SETTINGS ---
-burn_rate_fine_multi = 5
+
 -- Default = 75
 burn_rate_coarse_multi = .1
 
-burn_rate_auto_max = 120
+
 -- Default = 5
 burn_rate_fine_multi = 1
 
 -- Maximum auto burn rate to establish
-min_turbine_power = 0.50
+
 burn_rate_auto_max = 15
 
 -- What turbine power percent value should burn rate be max at?
 -- For this value and all lower, burn rate will be at the max defined above.
-max_turbine_power = 0.75
+
 min_turbine_power = 0.8
--- What value should the alarm go off if turbine power falls below?
+
--- Default = 0.46
+
-turbine_min_power = 0.46
+
 -- Default = 0.75 (for 75%)
 max_turbine_power = 0.9
 
-monitor_name = "monitor_2"
+
 -- Default = monitor_0
 monitor_name = "monitor_0"
 
 -- Are you playing on a server with Advanced peripherals?
 -- This is used so that if a server is restarting the computer can
 -- shot down the reactor. Note, the server must issue some kind of
 -- restart warning beforehand.
 -- Default = true
 on_server = false
 
 -- If the above is true, you must configure this line.
 -- What message in chat should the program look for to see if the server
 -- is restarting?
 -- Default = "SCRAM"
 restart_message = "SCRAM"
 
-incoming_restart = false
+
 
 ------------------------------------------------
 
 local state, data, reactor, turbine, info_window, rules_window
 
 local STATES = {
-		if ok then
+
-			return rule_met, string.format("%s (%s)", name, value)
+
 	ESTOP = 3, -- Reactor is stopped due to rule(s) being violated
 	UNKNOWN = 4, -- Reactor or turbine peripherals are missing
 }
 
 ------------------------------------------------
 
 local function redstone_restart()
 	if fs.exists("disk/temp/notify_restart") then
 		redstone.setOutput("front", true)
 	else
 		redstone.setOutput("front", false)
 	end
 end
 
 redstone_restart()
 
-add_rule("REACTOR COOLANT LEVEL    >=    95%  ", function()
+local function check_for_restart_scram()
 	if fs.exists("disk/temp/scrammed") then
 		incoming_restart = true
 		fs.delete("disk/temp/scrammed")
 		fs.makeDir("disk/temp/notify_restart")
 		fs.makeDir("disk/temp/redstone_restart")
 	else
 		incoming_restart = false
 	end
 	return incoming_restart
 end
 
 incoming_restart = check_for_restart_scram()
 
 local function check_for_restart_notify()
-add_rule("INCOMING SERVER RESTART  ==  FALSE  ", function()
+	if fs.exists("disk/temp/notify_restart") then
-	return incoming_restart, incoming_restart
+		notify_restart = true
 		fs.delete("disk/temp/notify_restart")
 	else
 		notify_restart = false
 	end
 	return notify_restart
 end
 
 notify_restart = check_for_restart_notify()
 
 local function pollChatbox()
     while true do
         local box = peripheral.find('chatBox', function(_, chatbox) return chatbox.getOperationCooldown('chatMessage') == 0 end)
         if box then
             return box
         end
         sleep(0.1)
     end
 end
 
 ------------------------------------------------
 
 local rules = {}
 
 local function add_rule(name, fn)
 	table.insert(rules, function()
 		local ok, rule_met, value = pcall(fn)
 		if ok and value ~= false then
 			return rule_met, string.format("%s ( %s)", name, value)
 	elseif ok then
 		return rule_met, string.format("%s (%s)", name, value)
 		else
 			return false, name
 		end
 	end)
 end
 
 add_rule("REACTOR TEMPERATURE      <=  1100K  ", function()
 	local value = string.format("%3dK", math.ceil(data.reactor_temp))
 	return data.reactor_temp <= 1100, value
 end)
 
 add_rule("REACTOR DAMAGE           <=    10%  ", function()
 	local value = string.format("%3d%%", math.ceil(data.reactor_damage * 100))
 	return data.reactor_damage <= 0.10, value
 end)
 
 add_rule("COOLANT (COLD) LEVEL     >=    95%  ", function()
 	local value = string.format("%3d%%", math.floor(data.reactor_coolant * 100))
-	term.write(text)
+
 end)
 
 add_rule("COOLANT (HOT) LEVEL      >=    10%  ", function()
 	local value = string.format("%3d%%", math.floor(data.reactor_hot_coolant * 100))
 	return data.reactor_coolant >= 0.10, value
 end)
 
 add_rule("REACTOR WASTE LEVEL      <=    90%  ", function()
 	local value = string.format("%3d%%", math.ceil(data.reactor_waste * 100))
 	return data.reactor_waste <= 0.90, value
 end)
 
 add_rule("TURBINE ENERGY LEVEL     <=    95%  ", function()
 	local value = string.format("%3d%%", math.ceil(data.turbine_energy * 100))
 	return data.turbine_energy <= 0.95, value
 end)
 
 add_rule("REACTOR FUEL LEVEL       <=    10%  ", function()
 	local value = string.format("%3d%%", math.ceil(data.reactor_fuel * 100))
 	return data.turbine_energy <= .10, value
 end)
 
 if on_server then
 	add_rule("INCOMING SERVER RESTART  ==  FALSE  ", function()
 		return not incoming_restart, notify_restart
 	end)
 end
 
 local function all_rules_met()
 	for i, rule in ipairs(rules) do
 		if not rule() then
 			return false
 		end
 	end
 	-- Allow manual emergency stop with SCRAM button
 	return state ~= STATES.RUNNING or data.reactor_on
 end
 
 ------------------------------------------------
 
 local function update_data()
 	coarse_adjust = (tonumber(redstone.getAnalogInput("left")) * burn_rate_coarse_multi)
 	fine_adjust = (tonumber(redstone.getAnalogInput("right")) * burn_rate_fine_multi)
 	set_burn_rate = (coarse_adjust + fine_adjust)
 
 	data = {
 		lever_on = redstone.getInput("bottom"),
 		burn_rate_limit = set_burn_rate,
 		burn_rate_limited = redstone.getInput("top"),
 
 		reactor_on = reactor.getStatus(),
-		colored("READY - PULL LEVER TO STARTUP", colors.blue)
+
 		reactor_max_burn_rate = reactor.getMaxBurnRate(),
 		reactor_temp = reactor.getTemperature(),
 		reactor_damage = reactor.getDamagePercent(),
-		colored("SCRAM - SAFETY RULE VIOLATED", colors.red)
+
 		reactor_hot_coolant = reactor.getHeatedCoolantFilledPercentage(),
-		colored("SCRAM - TOGGLE LEVER TO RESET", colors.red)
+
 		reactor_fuel = reactor.getFuelFilledPercentage(),
 		reactor_max_fuel = reactor.getFuelCapacity(),
 		reactor_fuel_level = reactor.getFuel(),
 
 		turbine_energy = turbine.getEnergyFilledPercentage(),
 		turbine_power = turbine.getEnergy(),
 		max_turbine_power = turbine.getMaxEnergy()
 	}
 
 end
 ------------------------------------------------
 
-	colored(string.format("%5.2f", (data.turbine_energy*100)), colors.green)
+
 
 term.redirect(monitor)
 
 local function colored(text, fg, bg)
 	term.setTextColor(fg or colors.white)
 	term.setBackgroundColor(bg or colors.black)
 	term.write(string.upper(text))
 end
 
 local function make_section(name, x, y, w, h, color)
 	for row = 1, h do
 		term.setCursorPos(x, y + row - 1)
 		local char = (row == 1 or row == h) and "\127" or " "
 		colored("\127" .. string.rep(char, w - 2) .. "\127", color or colors.gray)
 	end
 
 	term.setCursorPos(x + 2, y)
 	colored(" " .. name .. " ")
 
 	return window.create(term.current(), x + 2, y + 2, w - 4, h - 4)
 end
 
 local function update_info()
 	local prev_term = term.redirect(info_window)
 
 	term.clear()
 	term.setCursorPos(1, 1)
 
 	if state == STATES.UNKNOWN then
 		colored("ERROR RETRIEVING DATA", colors.red)
 		return
 	end
 
 	colored("REACTOR: ")
 	colored(data.reactor_on and "CRITICAL" or "SHUTDOWN", data.reactor_on and colors.green or colors.red)
 	colored(" LEVER: ")
 	colored(data.lever_on and "POWERED" or "SECURED", data.lever_on and colors.green or colors.red)
 	colored(" BURN RATE: ")
 	if data.burn_rate_limited == false then
 		colored(string.format("%4.1f", data.reactor_burn_rate), colors.blue)
 	else
 		colored(string.format("%4.1f", data.reactor_burn_rate), colors.yellow)
 	end
 	colored("/", colors.lightGray)
 	colored(string.format("%4.0f", data.reactor_max_burn_rate), colors.blue)
 
 	term.setCursorPos(34, 2)
 	colored("SET LIMIT: ")
 	if data.burn_rate_limited then
 		colored(string.format("%4.1f", data.burn_rate_limit), colors.green)
 	else
 		colored(string.format("%4.1f", data.burn_rate_limit), colors.gray)
 	end
 
 	term.setCursorPos(1, 4)
 
 	colored("STATUS: ")
 	if state == STATES.READY then
 		colored("READY   - PULL LEVER TO STARTUP", colors.blue)
 	elseif state == STATES.RUNNING then
 		colored("RUNNING - PULL LEVER TO SHUTDOWN", colors.green)
 	elseif state == STATES.ESTOP and not all_rules_met() then
 		colored("SCRAM   - SAFETY RULE VIOLATED", colors.red)
 	elseif state == STATES.ESTOP then
 		colored("SCRAM   - TOGGLE LEVER TO RESET", colors.red)
 	end -- STATES.UNKNOWN cases handled above
 
 	term.setCursorPos(1, 6)
 
 	colored("STORED POWER: ")
 	colored(string.format("%4.0f", (data.turbine_power*4/1000000)), colors.green)
 	colored(" MFE", colors.green)
 	colored("/", colors.lightGray)
 
 	colored(string.format("%4.0f", (data.max_turbine_power*4/1000000)), colors.blue)
 	colored(" MFE", colors.blue)
 	colored(" (")
 	colored(string.format("%6.2f", (data.turbine_energy*100)), colors.green)
 	colored("%", colors.green)
 	colored(")")
 
 	term.setCursorPos(1, 7)
 
 	colored("STORED FUEL:  ")
 	colored(string.format("%4.0f", (data.reactor_fuel_level["amount"])), colors.green)
 	colored(" mB", colors.green)
 	colored("/", colors.lightGray)
 
 	colored(string.format("%4.0f", (data.reactor_max_fuel)), colors.blue)
 	colored(" mB", colors.blue)
 	colored("  (")
 	colored(string.format("%5.2f", (data.reactor_fuel*100)), colors.green)
 	colored("%", colors.green)
-	info_window = make_section("INFORMATION", 2, 2, width - 2, 10, window_color)
+
-	rules_window = make_section("SAFETY RULES", 2, 13, width - 2, 13, window_color)
+
 	term.setCursorPos(1, 8)
 	colored("FUEL TYPE:    ", colors.white)
 	fuel_name = data.reactor_fuel_level["name"]
 	fuel_name = fuel_name:match"^.-:(.+)"
 	fuel_name = fuel_name.gsub(fuel_name, "_", " ")
 	colored(fuel_name, colors.green)
 
 	term.redirect(prev_term)
 end
 
 
 local estop_reasons = {}
 
 local function update_rules()
-	if data.turbine_energy < turbine_min_power then --Sound an alarm that's attached to the front of the computer if turbine power falls below 45%.
+
-		redstone.setOutput("right", true)
+
 	term.clear()
-		redstone.setOutput("right", false)
+
 	if state ~= STATES.ESTOP then
 		estop_reasons = {}
 	end
 
 	for i, rule in ipairs(rules) do
 		local ok, text = rule()
 		term.setCursorPos(1, i)
 		if ok and not estop_reasons[i] then
 			colored("[ SAFE ] ", colors.green)
 			colored(text, colors.lightGray)
 		else
 			colored("[ FAIL ] ", colors.red)
 			colored(text, colors.red)
-local function shutdown_on_restart_warning()
+
 		end
 	end
-	--print("The 'chat' event was fired with the username " .. username .. " and the message " .. message)
+
-	chatBox.sendMessage("username: " .. username .. "message: ".. message)
+
-	if username == "sayCommand" and message == "SCRAM" then
+
 
-		chatBox.sendMessage("SCRAM aye")
+
 
 local function main_loop()
-parallel.waitForAny(main_loop, function()
+
-	os.pullEventRaw("terminate")
+
 		reactor = peripheral.find("fissionReactorLogicAdapter")
 		turbine = peripheral.find("turbineValve")
 	end
 
 	if not pcall(update_data) then
 		-- Error getting data (either reactor or turbine is nil?)
 		data = {}
 		state = STATES.UNKNOWN
 	elseif data.reactor_on == nil then
 		-- Reactor is not connected
 		state = STATES.UNKNOWN
 	elseif data.turbine_energy == nil then
 		-- Turbine is not connected
 		state = STATES.UNKNOWN
 	elseif not state then
 		-- Program just started, get current state from lever
 		state = data.lever_on and STATES.RUNNING or STATES.READY
 	elseif state == STATES.READY and data.lever_on then
 		-- READY -> RUNNING
 		state = STATES.RUNNING
 		-- Activate reactor
 		pcall(reactor.activate)
 		data.reactor_on = true
 	elseif state == STATES.RUNNING and not data.lever_on then
 		-- RUNNING -> READY
 		state = STATES.READY
 	elseif state == STATES.ESTOP and not data.lever_on then
 		-- ESTOP -> READY
 		state = STATES.READY
 	elseif state == STATES.UNKNOWN then
 		-- UNKNOWN -> ESTOP
 		state = data.lever_on and STATES.ESTOP or STATES.READY
 		estop_reasons = {}
 	end
 
 	-- Always enter ESTOP if safety rules are not met
 	if state ~= STATES.UNKNOWN and not all_rules_met() then
 		state = STATES.ESTOP
 	end
 
 	-- SCRAM reactor if not running
 	if state ~= STATES.RUNNING and reactor then
 		pcall(reactor.scram)
 	end
 
 	-- Make Windows
 	local width = term.getSize()
 	if state == STATES.ESTOP then
 		window_color = colors.red
 	elseif state == STATES.READY then
 		window_color = colors.green
 	else
 		window_color = colors.gray
 	end
 	info_window = make_section("STATUS", 2, 2, width - 2, 12, window_color)
 	rules_window = make_section("SAFETY RULES", 2, 15, width - 2, 11, window_color)
 
 	-- Update info and rules windows
 	pcall(update_info)
 	pcall(update_rules)
 
 	-- Update max burn rate to keep turbine below 75% energy.
 	if state ~= STATES.UNKNOWN and data.burn_rate_limited == false then
 
 		local tgt_burn_pct = math.min(math.max(0.0, 1 - (data.turbine_energy - min_turbine_power) / (max_turbine_power - min_turbine_power)), 1.0)
 		pcall(reactor.setBurnRate, tgt_burn_pct * burn_rate_auto_max)
 	elseif state ~= STATES.UNKNOWN and data.burn_rate_limited == true then
 		pcall(reactor.setBurnRate, data.burn_rate_limit) -- Let burn rate be limited by an analog lever
 	end
 
 	sleep() -- Other calls should already yield, this is just in case
 	return main_loop()
 end
 
 term.setPaletteColor(colors.black, 0x000000)
 term.setPaletteColor(colors.gray, 0x343434)
 term.setPaletteColor(colors.lightGray, 0xababab)
 term.setPaletteColor(colors.red, 0xdb2d20)
 term.setPaletteColor(colors.green, 0x01a252)
 term.setPaletteColor(colors.blue, 0x01a0e4)
 term.clear()
 
 
 function scram_on_restart()
 	chatBox = peripheral.find("chatBox")
 	local event, username, message, uuid, isHidden = os.pullEvent("chat")
 	pollChatbox().sendMessage("username: " .. username .. " message: `".. message .. "`")
 	if message == restart_message and username == "sayCommand" then
 		--fs.copy("/disk/temp/scram.lua", "/disk/temp/scrammed.lua")
 		fs.makeDir("/disk/temp/scrammed")
 		pollChatbox().sendMessage("SCRAM aye")
 	end
 end
 
 if on_server then
 	parallel.waitForAny(main_loop, scram_on_restart)
 else
 	parallel.waitForAny(main_loop, function()
 		os.pullEventRaw("terminate")
 	end)
 end
 
 os.reboot()