Saereth

Untitled

May 3rd, 2015
302
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. --[[
  2. Program name: Lolmer's EZ-NUKE reactor control system
  3. Version: v0.3.16
  4. Programmer: Lolmer
  5. Great assistance by Mechaet
  6. Last update: 2015-03-25
  7. Pastebin: http://pastebin.com/fguScPBQ
  8. GitHub: https://github.com/sandalle/minecraft_bigreactor_control
  9.  
  10. Description:
  11. This program controls a Big Reactors nuclear reactor in Minecraft with a Computercraft computer, using Computercraft's own wired modem connected to the reactors computer control port.
  12.  
  13. This program was designed to work with the mods and versions installed on Never Stop Toasting (NST) Diet http://www.technicpack.net/modpack/details/never-stop-toasting-diet.254882 Endeavour: Never Stop Toasting: Diet official Minecraft server http://forums.somethingawful.com/showthread.php?threadid=3603757
  14.  
  15. To simplify the code and guesswork, I assume the following monitor layout, where each "monitor" listed below is a collection of three wide by two high Advanced Monitors:
  16. 1) One Advanced Monitor for overall status display plus
  17.     one or more Reactors plus
  18.     none or more Turbines.
  19. 2) One Advanced Monitor for overall status display plus (furthest monitor from computer by cable length)
  20.     one Advanced Monitor for each connected Reactor plus (subsequent found monitors)
  21.     one Advanced Monitor for each connected Turbine (last group of monitors found).
  22. If you enable debug mode, add one additional Advanced Monitor for #1 or #2.
  23.  
  24. Notes:
  25.     Only one reactor and one, two, and three turbines have been tested with the above, but IN THEORY any number is supported.
  26.     Devices are found in the reverse order they are plugged in, so monitor_10 will be found before monitor_9.
  27.     Two 15x15x14 Turbines can output 260K RF/t by just one 7^3 (four rods) reactor putting out 4k mB steam.
  28.  
  29. When using actively cooled reactors with turbines, keep the following in mind:
  30.     - 1 mB steam carries up to 10RF of potential energy to extract in a turbine.
  31.     - Actively cooled reactors produce steam, not power.
  32.     - You will need about 10 mB of water for each 1 mB of steam that you want to create in a 7^3 reactor.
  33.  
  34. Features:
  35.     Configurable min/max energy buffer and min/max temperature via ReactorOptions file.
  36.     ReactorOptions is read on start and then current values are saved every program cycle.
  37.     Rod Control value in ReactorOptions is only useful for initial start, after that the program saves the current Rod Control average over all Fuel Rods for next boot.
  38.     Auto-adjusts control rods per reactor to maintain temperature.
  39.     Will display reactor data to all attached monitors of correct dimensions.
  40.         For multiple monitors, the first monitor (often last plugged in) is the overall status monitor.
  41.     For multiple monitors, the first monitor (often last plugged in) is the overall status monitor.
  42.     A new cruise mode from mechaet, ONLINE will be "blue" when active, to keep your actively cooled reactors running smoothly.
  43.  
  44. GUI Usage:
  45.     The "<" and ">" buttons, when right-clicked with the mouse, will decrease and increase, respectively, the values assigned to the monitor:
  46.         "Rod (%)" will lower/raise the Reactor Control Rods for that Reactor
  47.         "mB/t" will lower/raise the Turbine Flow Rate maximum for that Turbine
  48.         "RPM" will lower/raise the target Turbine RPM for that Turbine
  49.     Right-clicking between the "<" and ">" (not on them) will disable auto-adjust of that value for attached device.
  50.         Right-clicking on the "Enabled" or "Disabled" text for auto-adjust will do the same.
  51.     Right-clicking on "ONLINE" or "OFFLINE" at the top-right will toggle the state of attached device.
  52.  
  53. Default values:
  54.     Rod Control: 90% (Let's start off safe and then power up as we can)
  55.     Minimum Energy Buffer: 15% (will power on below this value)
  56.     Maximum Energy Buffer: 85% (will power off above this value)
  57.     Minimum Passive Cooling Temperature: 950^C (will raise control rods below this value)
  58.     Maximum Passive Cooling Temperature: 1,400^C (will lower control rods above this value)
  59.     Minimum Active Cooling Temperature: 300^C (will raise the control rods below this value)
  60.     Maximum Active Cooling Temperature: 420^C (will lower control rods above this value)
  61.     Optimal Turbine RPM:  900, 1,800, or 2,700 (divisible by 900)
  62.     New user-controlled option for target speed of turbines, defaults to 2726RPM, which is high-optimal.
  63.  
  64. Requirements:
  65.     Advanced Monitor size is X: 29, Y: 12 with a 3x2 size
  66.     Computer or Advanced Computer
  67.     Modems (not wireless) connecting each of the Computer to both the Advanced Monitor and Reactor Computer Port.
  68.     Big Reactors (http://www.big-reactors.com/) 0.3.2A+
  69.     Computercraft (http://computercraft.info/) 1.58 or 1.63+
  70.     Reset the computer any time number of connected devices change.
  71.  
  72. Resources:
  73. This script is available from:
  74.     http://pastebin.com/fguScPBQ
  75.     https://github.com/sandalle/minecraft_bigreactor_control
  76. Start-up script is available from:
  77.     http://pastebin.com/ZTMzRLez
  78.     https://github.com/sandalle/minecraft_bigreactor_control
  79. Other reactor control program which I based my program on:
  80.     http://pastebin.com/aMAu4X5J (ScatmanJohn)
  81.     http://pastebin.com/HjUVNDau (version ScatmanJohn based his on)
  82. A simpler Big Reactor control program is available from:
  83.     http://pastebin.com/7S5xCvgL (IronClaymore only for passively cooled reactors)
  84.  
  85.     Reactor Computer Port API: http://wiki.technicpack.net/Reactor_Computer_Port
  86.     Computercraft API: http://computercraft.info/wiki/Category:APIs
  87.     Big Reactors Efficiency, Speculation and Questions! http://www.reddit.com/r/feedthebeast/comments/1vzds0/big_reactors_efficiency_speculation_and_questions/
  88.     Big Reactors API code: https://github.com/erogenousbeef/BigReactors/blob/master/erogenousbeef/bigreactors/common/multiblock/tileentity/TileEntityReactorComputerPort.java
  89.     Big Reactors API: http://big-reactors.com/cc_api.html
  90.     Big Reactor Simulator from http://reddit.com/r/feedthebeast : http://br.sidoh.org/
  91.  
  92. ChangeLog:
  93. - 0.3.16
  94.     - Add support for ComputerCraft 1.7 (thanks dkowis and jnyl42).
  95.     - Fix typo for unsupported OS (found from above)
  96.  
  97. - 0.3.15
  98.     - Add ability to override safe values for Issue #39.
  99.  
  100. - 0.3.14
  101.     - Fix Issue #5. EZ-Nuke should now work with ComputerCraft 1.58 or 1.63.
  102.  
  103. - 0.3.13
  104.     - Fix one reactor and one monitor incorrectly using status display instead of control display (Issue #35)
  105.     - Fix concatenating a string and boolean, see http://stackoverflow.com/questions/6615572/how-to-format-a-lua-string-with-a-boolean-variable
  106.     - Hopefully fix concatenating string and nul in printLog (Issue #3)
  107.  
  108. - 0.3.12
  109.     - Mechaet's changes:
  110.     - Redid some typing to correct a bug where the reactors always started with rod control disabled.
  111.  
  112. - 0.3.11
  113.     - Mechaet's changes:
  114.     - Cleaned up global variables list
  115.     - Added in per-device naming (displays a friendly name on the bottom of the monitor if configured in the device options file)
  116.     - Bigger bypasses of control routines when the control has been overridden
  117.     - Individual config files for turbines and reactors. Persistent between reboots, remembers your last saved settings.
  118.     - Cruise mode override bypass
  119.     - Changing flow rate no longer toggles flow rate override on and off. Changing the flow rate clearly indicates intent, so we put the override flag on and leave it there.
  120.     - Changed the rate at which the regular algorithm adjusts reactor rod control rates. Instead of being 1:1 we now move at 1:5 speed because there is a wide loophole where big adjustments can cause a swinging pendulum effect continually missing the target.
  121.  
  122. - 0.3.10
  123.     - Turbine algorithm pass by Mechaet.
  124.     - Updated turbine GUI.
  125.     - Fix single monitor (again) for Issue #22.
  126.  
  127. - 0.3.9
  128.     - Reactor algorithm pass by Mechaet.
  129.     - Additional user config options by Mechaet.
  130.     - Fix multiple reactors and none or more turbines with only one status monitor.
  131.     - Fix monitor scaling after one was used as debug (or in case of other modifications).
  132.     - Cruise mode implemented, defaults off but is saved between boots.
  133.     - Fix energy/% displays to match Big Reactors' GUI (Issue #9).
  134.     - Always write out found devices on computer terminal.
  135.     - Much improved round() function from mechaet (Issue #14).
  136.     - Refactoring pass/algorithm change on the reactor temperature control. Should now adjust in increments to achieve the desired temperature range quicker and more accurately.
  137.     - Optimal passive-cooled reactor temperature range changed from 850-900 to 950-1400.
  138.     - Fix display Issue #15.
  139.  
  140. - 0.3.8
  141.     - Update to ComputerCraft 1.6 API (only term.restore() -> term.native() required :)).
  142.  
  143. - 0.3.7
  144.     - Fix typo when initializing TurbineNames array.
  145.     - Fix Issue #1, turbine display is using the Reactor buffer size (10M RF) instead of the Turbine buffer size (1M RF).
  146.  
  147. - 0.3.6
  148.     - Fix multi-reactors displaying on the correct monitors (thanks HybridFusion).
  149.     - Fix rod auto-adjust text position.
  150.     - Reactors store 10M RF and Turbines store 1M RF in their buffer.
  151.     - Add more colour to displayAllStatus().
  152.     - Sleep for only two seconds instead of five.
  153.     - Fix getDeviceStoredEnergyBufferPercent() for Reactors storing 10M RF in buffer.
  154.     - Keep actively cooled reactors between 0-300^C (non-configurable for now).
  155.  
  156. - 0.3.5
  157.     - Do not discover connected devices every loop - nicer on servers. Reset computer anytime number of connected devices change.
  158.     - Fix multi-reactor setups to display the additional reactors on monitors, rather than the last one found.
  159.     - Fix passive reactor display having auto-adjust and energy buffer overwrite each other (removes rod count).
  160.  
  161. - 0.3.4
  162.     - Fix arithmetic for checking if we have enough monitors for the number of reactors.
  163.     - Turbines are optimal at 900, 1800, *and* 2700 RPM
  164.     - Increase loop timer from 1 to 5 to be nicer to servers
  165.  
  166. - 0.3.3
  167.     - Add Big Reactors Turbine support.
  168.     - First found monitor (appears to be last connected monitor) is used to display status of all found devices (if more than one valid monitor is found)
  169.     - Display monitor number on top left of each monitor as "M#" to help find which monitor is which.
  170.     - Enabling debug will use the last monitor found, if more than one, to print out debug info (also written to file)
  171.     - Only clear monitors when we're about to use them (e.g. turbine monitors no longer clear, then wait for all reactors to update)
  172.     - Fix getDeviceStoredEnergyBufferPercent(), was off by a decimal place
  173.     - Just use first Control Rod level for entire reactor, they are no longer treated individually in BR 0.3
  174.     - Allow for one monitor for n number of reactors and m number of turbines
  175.     - Auto-adjust turbine flow rate by 25 mB to keep rotor speed at 900 or 1,800 RPM.
  176.     - Clicks on monitors relate to what the monitor is showing (e.g. clicking on reactor 1's display won't modify turbine 1's nor reactor 2's values)
  177.     - Print monitor name and device (reactor|turbine) name in blue to monitor associated for easier design by users.
  178.     - Remove version number from monitors to free up space for monitor names.
  179.     - Add option of right-clicking on "Enabled"/"Disabled" of auto-adjust to toggle it.
  180.  
  181. - 0.3.2
  182.     - Allow for rod control to override (disable) auto-adjust via UI (Rhonyn)
  183.  
  184. - 0.3.1
  185.     - Add fuel consumption per tick to display
  186.  
  187. - 0.3.0
  188.     - Add multi-monitor support! Sends one reactor's data to all monitors.
  189.     - print function now takes table to support optional specified monitor
  190.     - Set "numRods" every cycle for some people (mechaet)
  191.     - Don't redirect terminal output with multiple monitor support
  192.     - Log troubleshooting data to reactorcontrol.log
  193.     - FC_API no longer used (copied and modified what I needed)
  194.     - Multi-reactor support is theoretically implemented, but it is UNTESTED!
  195.     - Updated for Big Reactor 0.3 (no longer works with 0.2)
  196.     - BR getFuelTemperature() now returns many significant digits, just use math.ceil()
  197.     - BR 0.3 removed individual rod temperatures, now it's only reactor-level temperature
  198.  
  199. - 0.2.4
  200.     - Simplify math, don't divide by a simple large number and then multiply by 100 (#/10000000*100)
  201.     - Fix direct-connected (no modem) devices. getDeviceSide -> FC_API.getDeviceSide (simple as that :))
  202.  
  203. - 0.2.3
  204.     - Check bounds on reactor.setRodControlLevel(#,#), Big Reactor doesn't check for us.
  205.  
  206. - 0.2.2
  207.     - Do not auto-start the reactor if it was manually powered off (autoStart=false)
  208.  
  209. - 0.2.1
  210.     - Lower/raise only the hottest/coldest Control Rod while trying to control the reactor temperature.
  211.     - "<" Rod Control buttons was off by one (to the left)
  212.  
  213. - 0.2.0 - Lolmer Edition :)
  214.     - Add min/max stored energy percentage (default is 15%/85%), configurable via ReactorOptions file.
  215.     - No reason to keep burning fuel if our power output is going nowhere. :)
  216.     - Use variables variable for the title and version.
  217.     - Try to keep the temperature between configured values (default is 850^C-950^C)
  218.     - Add Waste and number of Control/Fuel Rods to displayBards()
  219.  
  220. TODO:
  221. - Save parameters per reactor instead of one global set for all reactors.
  222. - Add min/max RF/t output and have it override temperature concerns (maybe?).
  223. - Add support for wireless modems, see http://computercraft.info/wiki/Modem_%28API%29, will not be secure (anyone can send/listen to your channels)!
  224. - Add support for any sized monitor (minimum 3x3), dynamic allocation/alignment.
  225. - Lookup using pcall for better error handling http://www.computercraft.info/forums2/index.php?/topic/10992-using-pcall/ .
  226. - Update cruise mode to work independently for each actively-cooled reactor.
  227.  
  228. ]]--
  229.  
  230.  
  231. -- Some global variables
  232. local progVer = "0.3.16"
  233. local progName = "COSHI-NUKE"
  234. local sideClick, xClick, yClick = nil, 0, 0
  235. local loopTime = 2
  236. local controlRodAdjustAmount = 1 -- Default Reactor Rod Control % adjustment amount
  237. local flowRateAdjustAmount = 25 -- Default Turbine Flow Rate in mB adjustment amount
  238. local debugMode = false
  239. -- End multi-reactor cleanup section
  240. local minStoredEnergyPercent = nil -- Max energy % to store before activate
  241. local maxStoredEnergyPercent = nil -- Max energy % to store before shutdown
  242. local monitorList = {} -- Empty monitor array
  243. local monitorNames = {} -- Empty array of monitor names
  244. local reactorList = {} -- Empty reactor array
  245. local reactorNames = {} -- Empty array of reactor names
  246. local turbineList = {} -- Empty turbine array
  247. local turbineNames = {} -- Empty array of turbine names
  248. local turbineMonitorOffset = 0 -- Turbines are assigned monitors after reactors
  249. local knowlinglyOverride = false -- Issue #39 Allow the user to override safe values, currently only enabled for actively cooled reactor min/max temperature
  250.  
  251. term.clear()
  252. term.setCursorPos(2,1)
  253. write("Initializing program...\n")
  254.  
  255.  
  256. -- File needs to exist for append "a" later and zero it out if it already exists
  257. -- Always initalize this file to avoid confusion with old files and the latest run
  258. local logFile = fs.open("reactorcontrol.log", "w")
  259. if logFile then
  260.     logFile.writeLine("Minecraft time: Day "..os.day().." at "..textutils.formatTime(os.time(),true))
  261.     logFile.close()
  262. else
  263.     error("Could not open file reactorcontrol.log for writing.")
  264. end
  265.  
  266.  
  267. -- Helper functions
  268.  
  269. local function termRestore()
  270.     local ccVersion = nil
  271.     ccVersion = os.version()
  272.  
  273.     if ccVersion == "CraftOS 1.6" or "CraftOS 1.7" then
  274.         term.native()
  275.     elseif ccVersion == "CraftOS 1.5" then
  276.         term.restore()
  277.     else -- Default to older term.restore
  278.         printLog("Unsupported CraftOS found. Reported version is \""..ccVersion.."\".")
  279.         term.restore()
  280.     end -- if ccVersion
  281. end -- function termRestore()
  282.  
  283. local function printLog(printStr)
  284.     if debugMode then
  285.         -- If multiple monitors, use the last monitor for debugging if debug is enabled
  286.         if #monitorList > 1 then
  287.             term.redirect(monitorList[#monitorList]) -- Redirect to last monitor for debugging
  288.             monitorList[#monitorList].setTextScale(0.5) -- Fit more logs on screen
  289.             write(printStr.."\n")   -- May need to use term.scroll(x) if we output too much, not sure
  290.             termRestore()
  291.         end -- if #monitorList > 1 then
  292.  
  293.         local logFile = fs.open("reactorcontrol.log", "a") -- See http://computercraft.info/wiki/Fs.open
  294.         if logFile then
  295.             logFile.writeLine(printStr)
  296.             logFile.close()
  297.         else
  298.             error("Cannot open file reactorcontrol.log for appending!")
  299.         end -- if logFile then
  300.     end -- if debugMode then
  301. end -- function printLog(printStr)
  302.  
  303. -- Trim a string
  304. function stringTrim(s)
  305.     assert(s ~= nil, "String can't be nil")
  306.     return(string.gsub(s, "^%s*(.-)%s*$", "%1"))
  307. end
  308.  
  309. config = {}
  310.  
  311. -- Save a table into a config file
  312. -- path: path of the file to write
  313. -- tab: table to save
  314. config.save = function(path, tab)
  315.     printLog("Save function called for config for "..path.." EOL")
  316.     assert(path ~= nil, "Path can't be nil")
  317.     assert(type(tab) == "table", "Second parameter must be a table")
  318.     local f = io.open(path, "w")
  319.     local i = 0
  320.     for key, value in pairs(tab) do
  321.         if i ~= 0 then
  322.             f:write("\n")
  323.         end
  324.         f:write("["..key.."]".."\n")
  325.         for key2, value2 in pairs(tab[key]) do
  326.             key2 = stringTrim(key2)
  327.             --doesn't like boolean values
  328.             if (type(value2) ~= "boolean") then
  329.             value2 = stringTrim(value2)
  330.             else
  331.             value2 = tostring(value2)
  332.             end
  333.             key2 = key2:gsub(";", "\\;")
  334.             key2 = key2:gsub("=", "\\=")
  335.             value2 = value2:gsub(";", "\\;")
  336.             value2 = value2:gsub("=", "\\=")   
  337.             f:write(key2.."="..value2.."\n")
  338.         end
  339.         i = i + 1
  340.     end
  341.     f:close()
  342. end --config.save = function(path, tab)
  343.  
  344. -- Load a config file
  345. -- path: path of the file to read
  346. config.load = function(path)
  347.     printLog("Load function called for config for "..path.." EOL")
  348.     assert(path ~= nil, "Path can't be nil")
  349.     local f = fs.open(path, "r")
  350.     if f ~= nil then
  351.         local tab = {}
  352.         local line = ""
  353.         local newLine
  354.         local i
  355.         local currentTag = nil
  356.         local found = false
  357.         local pos = 0
  358.         while line ~= nil do
  359.             found = false      
  360.             line = line:gsub("\\;", "#_!36!_#") -- to keep \;
  361.             line = line:gsub("\\=", "#_!71!_#") -- to keep \=
  362.             if line ~= "" then
  363.                 -- Delete comments
  364.                 newLine = line
  365.                 line = ""
  366.                 for i=1, string.len(newLine) do            
  367.                     if string.sub(newLine, i, i) ~= ";" then
  368.                         line = line..newLine:sub(i, i)                     
  369.                     else               
  370.                         break
  371.                     end
  372.                 end
  373.                 line = stringTrim(line)
  374.                 -- Find tag        
  375.                 if line:sub(1, 1) == "[" and line:sub(line:len(), line:len()) == "]" then
  376.                     currentTag = stringTrim(line:sub(2, line:len()-1))
  377.                     tab[currentTag] = {}
  378.                     found = true                           
  379.                 end
  380.                 -- Find key and values
  381.                 if not found and line ~= "" then               
  382.                     pos = line:find("=")               
  383.                     if pos == nil then
  384.                         error("Bad INI file structure")
  385.                     end
  386.                     line = line:gsub("#_!36!_#", ";")
  387.                     line = line:gsub("#_!71!_#", "=")
  388.                     tab[currentTag][stringTrim(line:sub(1, pos-1))] = stringTrim(line:sub(pos+1, line:len()))
  389.                     found = true           
  390.                 end        
  391.             end
  392.             line = f.readLine()
  393.         end
  394.        
  395.         f:close()
  396.        
  397.         return tab
  398.     else
  399.         return nil
  400.     end
  401. end --config.load = function(path)
  402.  
  403.  
  404.  
  405. -- round() function from mechaet
  406. local function round(num, places)
  407.     local mult = 10^places
  408.     local addon = nil
  409.     if ((num * mult) < 0) then
  410.         addon = -.5
  411.     else
  412.         addon = .5
  413.     end
  414.  
  415.     local integer, decimal = math.modf(num*mult+addon)
  416.     newNum = integer/mult
  417.     printLog("Called round(num="..num..",places="..places..") returns \""..newNum.."\".")
  418.     return newNum
  419. end -- function round(num, places)
  420.  
  421.  
  422. local function print(printParams)
  423.     -- Default to xPos=1, yPos=1, and first monitor
  424.     setmetatable(printParams,{__index={xPos=1, yPos=1, monitorIndex=1}})
  425.     local printString, xPos, yPos, monitorIndex =
  426.         printParams[1], -- Required parameter
  427.         printParams[2] or printParams.xPos,
  428.         printParams[3] or printParams.yPos,
  429.         printParams[4] or printParams.monitorIndex
  430.  
  431.     local monitor = nil
  432.     monitor = monitorList[monitorIndex]
  433.  
  434.     if not monitor then
  435.         printLog("monitor["..monitorIndex.."] in print() is NOT a valid monitor.")
  436.         return -- Invalid monitorIndex
  437.     end
  438.  
  439.     monitor.setCursorPos(xPos, yPos)
  440.     monitor.write(printString)
  441. end -- function print(printParams)
  442.  
  443.  
  444. -- Replaces the one from FC_API (http://pastebin.com/A9hcbZWe) and adding multi-monitor support
  445. local function printCentered(printString, yPos, monitorIndex)
  446.     local monitor = nil
  447.     monitor = monitorList[monitorIndex]
  448.  
  449.     if not monitor then
  450.         printLog("monitor["..monitorIndex.."] in printCentered() is NOT a valid monitor.")
  451.         return -- Invalid monitorIndex
  452.     end
  453.  
  454.     local width, height = monitor.getSize()
  455.     local monitorNameLength = 0
  456.  
  457.     -- Special changes for title bar
  458.     if yPos == 1 then
  459.         -- Add monitor name to first line
  460.         monitorNameLength = monitorNames[monitorIndex]:len()
  461.  
  462.         -- Leave room for "offline" and "online" on the right except for overall status display
  463.         if (#monitorList ~= 1) and (monitorIndex ~= 1) then
  464.             width = width - 7
  465.         end
  466.     end
  467.  
  468.     monitor.setCursorPos(math.floor(width/2) - math.ceil(printString:len()/2) +  monitorNameLength/2, yPos)
  469.     monitor.clearLine()
  470.     monitor.write(printString)
  471.  
  472.     monitor.setTextColor(colors.blue)
  473.     print{monitorNames[monitorIndex], 1, 1, monitorIndex}
  474.     monitor.setTextColor(colors.white)
  475. end -- function printCentered(printString, yPos, monitorIndex)
  476.  
  477.  
  478. -- Print text padded from the left side
  479. -- Clear the left side of the screen
  480. local function printLeft(printString, yPos, monitorIndex)
  481.     local monitor = nil
  482.     monitor = monitorList[monitorIndex]
  483.  
  484.     if not monitor then
  485.         printLog("monitor["..monitorIndex.."] in printLeft() is NOT a valid monitor.")
  486.         return -- Invalid monitorIndex
  487.     end
  488.  
  489.     local gap = 1
  490.     local width = monitor.getSize()
  491.  
  492.     -- Clear left-half of the monitor
  493.  
  494.     for curXPos = 1, (width / 2) do
  495.         monitor.setCursorPos(curXPos, yPos)
  496.         monitor.write(" ")
  497.     end
  498.  
  499.     -- Write our string left-aligned
  500.     monitor.setCursorPos(1+gap, yPos)
  501.     monitor.write(printString)
  502. end
  503.  
  504.  
  505. -- Print text padded from the right side
  506. -- Clear the right side of the screen
  507. local function printRight(printString, yPos, monitorIndex)
  508.     local monitor = nil
  509.     monitor = monitorList[monitorIndex]
  510.  
  511.     if not monitor then
  512.         printLog("monitor["..monitorIndex.."] in printRight() is NOT a valid monitor.")
  513.         return -- Invalid monitorIndex
  514.     end
  515.  
  516.     -- Make sure printString is a string
  517.     printString = tostring(printString)
  518.  
  519.     local gap = 1
  520.     local width = monitor.getSize()
  521.  
  522.     -- Clear right-half of the monitor
  523.     for curXPos = (width/2), width do
  524.         monitor.setCursorPos(curXPos, yPos)
  525.         monitor.write(" ")
  526.     end
  527.  
  528.     -- Write our string right-aligned
  529.     monitor.setCursorPos(math.floor(width) - math.ceil(printString:len()+gap), yPos)
  530.     monitor.write(printString)
  531. end
  532.  
  533.  
  534. -- Replaces the one from FC_API (http://pastebin.com/A9hcbZWe) and adding multi-monitor support
  535. local function clearMonitor(printString, monitorIndex)
  536.     local monitor = nil
  537.     monitor = monitorList[monitorIndex]
  538.  
  539.     printLog("Called as clearMonitor(printString="..printString..",monitorIndex="..monitorIndex..").")
  540.  
  541.     if not monitor then
  542.         printLog("monitor["..monitorIndex.."] in clearMonitor(printString="..printString..",monitorIndex="..monitorIndex..") is NOT a valid monitor.")
  543.         return -- Invalid monitorIndex
  544.     end
  545.  
  546.     local gap = 2
  547.     monitor.clear()
  548.     local width, height = monitor.getSize()
  549.     monitor.setTextScale(1.0) -- Make sure scale is correct
  550.  
  551.     printCentered(printString, 1, monitorIndex)
  552.     monitor.setTextColor(colors.blue)
  553.     print{monitorNames[monitorIndex], 1, 1, monitorIndex}
  554.     monitor.setTextColor(colors.white)
  555.  
  556.     for i=1, width do
  557.         monitor.setCursorPos(i, gap)
  558.         monitor.write("-")
  559.     end
  560.  
  561.     monitor.setCursorPos(1, gap+1)
  562. end -- function clearMonitor(printString, monitorIndex)
  563.  
  564.  
  565. -- Return a list of all connected (including via wired modems) devices of "deviceType"
  566. local function getDevices(deviceType)
  567.     printLog("Called as getDevices(deviceType="..deviceType..")")
  568.  
  569.     local deviceName = nil
  570.     local deviceIndex = 1
  571.     local deviceList, deviceNames = {}, {} -- Empty array, which grows as we need
  572.     local peripheralList = peripheral.getNames() -- Get table of connected peripherals
  573.  
  574.     deviceType = deviceType:lower() -- Make sure we're matching case here
  575.  
  576.     for peripheralIndex = 1, #peripheralList do
  577.         -- Log every device found
  578.         -- printLog("Found "..peripheral.getType(peripheralList[peripheralIndex]).."["..peripheralIndex.."] attached as \""..peripheralList[peripheralIndex].."\".")
  579.         if (string.lower(peripheral.getType(peripheralList[peripheralIndex])) == deviceType) then
  580.             -- Log devices found which match deviceType and which device index we give them
  581.             printLog("Found "..peripheral.getType(peripheralList[peripheralIndex]).."["..peripheralIndex.."] as index \"["..deviceIndex.."]\" attached as \""..peripheralList[peripheralIndex].."\".")
  582.             write("Found "..peripheral.getType(peripheralList[peripheralIndex]).."["..peripheralIndex.."] as index \"["..deviceIndex.."]\" attached as \""..peripheralList[peripheralIndex].."\".\n")
  583.             deviceNames[deviceIndex] = peripheralList[peripheralIndex]
  584.             deviceList[deviceIndex] = peripheral.wrap(peripheralList[peripheralIndex])
  585.             deviceIndex = deviceIndex + 1
  586.         end
  587.     end -- for peripheralIndex = 1, #peripheralList do
  588.  
  589.     return deviceList, deviceNames
  590. end -- function getDevices(deviceType)
  591.  
  592. -- Draw a line across the entire x-axis
  593. local function drawLine(yPos, monitorIndex)
  594.     local monitor = nil
  595.     monitor = monitorList[monitorIndex]
  596.  
  597.     if not monitor then
  598.         printLog("monitor["..monitorIndex.."] in drawLine() is NOT a valid monitor.")
  599.         return -- Invalid monitorIndex
  600.     end
  601.  
  602.     local width, height = monitor.getSize()
  603.  
  604.     for i=1, width do
  605.         monitor.setCursorPos(i, yPos)
  606.         monitor.write("-")
  607.     end
  608. end -- function drawLine(yPos,monitorIndex)
  609.  
  610.  
  611. -- Display a solid bar of specified color
  612. local function drawBar(startXPos, startYPos, endXPos, endYPos, color, monitorIndex)
  613.     local monitor = nil
  614.     monitor = monitorList[monitorIndex]
  615.  
  616.     if not monitor then
  617.         printLog("monitor["..monitorIndex.."] in drawBar() is NOT a valid monitor.")
  618.         return -- Invalid monitorIndex
  619.     end
  620.  
  621.     -- PaintUtils only outputs to term., not monitor.
  622.     -- See http://www.computercraft.info/forums2/index.php?/topic/15540-paintutils-on-a-monitor/
  623.     term.redirect(monitor)
  624.     paintutils.drawLine(startXPos, startYPos, endXPos, endYPos, color)
  625.     monitor.setBackgroundColor(colors.black) -- PaintUtils doesn't restore the color
  626.     termRestore()
  627. end -- function drawBar(startXPos, startYPos,endXPos,endYPos,color,monitorIndex)
  628.  
  629.  
  630. -- Display single pixel color
  631. local function drawPixel(xPos, yPos, color, monitorIndex)
  632.     local monitor = nil
  633.     monitor = monitorList[monitorIndex]
  634.  
  635.     if not monitor then
  636.         printLog("monitor["..monitorIndex.."] in drawPixel() is NOT a valid monitor.")
  637.         return -- Invalid monitorIndex
  638.     end
  639.  
  640.     -- PaintUtils only outputs to term., not monitor.
  641.     -- See http://www.computercraft.info/forums2/index.php?/topic/15540-paintutils-on-a-monitor/
  642.     term.redirect(monitor)
  643.     paintutils.drawPixel(xPos, yPos, color)
  644.     monitor.setBackgroundColor(colors.black) -- PaintUtils doesn't restore the color
  645.     termRestore()
  646. end -- function drawPixel(xPos, yPos, color, monitorIndex)
  647.  
  648.  
  649. -- End helper functions
  650.  
  651.  
  652. -- Then initialize the monitors
  653. local function findMonitors()
  654.     -- Empty out old list of monitors
  655.     monitorList = {}
  656.  
  657.     printLog("Finding monitors...")
  658.     monitorList, monitorNames = getDevices("monitor")
  659.  
  660.     if #monitorList == 0 then
  661.         printLog("No monitors found!")
  662.         error("Can't find any monitors!")
  663.     else
  664.         for monitorIndex = 1, #monitorList do
  665.             local monitor, monitorX, monitorY = nil, nil, nil
  666.             monitor = monitorList[monitorIndex]
  667.  
  668.             if not monitor then
  669.                 printLog("monitorList["..monitorIndex.."] in findMonitors() is NOT a valid monitor.")
  670.  
  671.                 table.remove(monitorList, monitorIndex) -- Remove invalid monitor from list
  672.                 if monitorIndex ~= #monitorList then    -- If we're not at the end, clean up
  673.                     monitorIndex = monitorIndex - 1 -- We just removed an element
  674.                 end -- if monitorIndex == #monitorList then
  675.                 break -- Invalid monitorIndex
  676.             else -- valid monitor
  677.                 monitorX, monitorY = monitor.getSize()
  678.                 if (monitorX == nil) or (monitorY == nil) then -- somehow a valid monitor, but non-existent sizes? Maybe fixes Issue #3
  679.                     printLog("monitorList["..monitorIndex.."] in findMonitors() is NOT a valid sized monitor.")
  680.  
  681.                     table.remove(monitorList, monitorIndex) -- Remove invalid monitor from list
  682.                     if monitorIndex ~= #monitorList then    -- If we're not at the end, clean up
  683.                         monitorIndex = monitorIndex - 1 -- We just removed an element
  684.                     end -- if monitorIndex == #monitorList then
  685.                     break -- Invalid monitorIndex
  686.  
  687.                 -- Check for minimum size to allow for monitor.setTextScale(0.5) to work for 3x2 debugging monitor, changes getSize()
  688.                 elseif monitorX < 29 or monitorY < 12 then
  689.                     term.redirect(monitor)
  690.                     monitor.clear()
  691.                     printLog("Removing monitor "..monitorIndex.." for being too small.")
  692.                     monitor.setCursorPos(1,2)
  693.                     write("Monitor is the wrong size!\n")
  694.                     write("Needs to be at least 3x2.")
  695.                     termRestore()
  696.  
  697.                     table.remove(monitorList, monitorIndex) -- Remove invalid monitor from list
  698.                     if monitorIndex == #monitorList then    -- If we're at the end already, break from loop
  699.                         break
  700.                     else
  701.                         monitorIndex = monitorIndex - 1 -- We just removed an element
  702.                     end -- if monitorIndex == #monitorList then
  703.  
  704.                 end -- if monitorX < 29 or monitorY < 12 then
  705.             end -- if not monitor then
  706.  
  707.             printLog("Monitor["..monitorIndex.."] named \""..monitorNames[monitorIndex].."\" is a valid monitor of size x:"..monitorX.." by y:"..monitorY..".")
  708.         end -- for monitorIndex = 1, #monitorList do
  709.     end -- if #monitorList == 0 then
  710.  
  711.     printLog("Found "..#monitorList.." monitor(s) in findMonitors().")
  712. end -- local function findMonitors()
  713.  
  714.  
  715. -- Initialize all Big Reactors - Reactors
  716. local function findReactors()
  717.     -- Empty out old list of reactors
  718.     newReactorList = {}
  719.     printLog("Finding reactors...")
  720.     newReactorList, reactorNames = getDevices("BigReactors-Reactor")
  721.  
  722.     if #newReactorList == 0 then
  723.         printLog("No reactors found!")
  724.         error("Can't find any reactors!")
  725.     else  -- Placeholder
  726.         for reactorIndex = 1, #newReactorList do
  727.             local reactor = nil
  728.             reactor = newReactorList[reactorIndex]
  729.  
  730.             if not reactor then
  731.                 printLog("reactorList["..reactorIndex.."] in findReactors() is NOT a valid Big Reactor.")
  732.  
  733.                 table.remove(newReactorList, reactorIndex) -- Remove invalid reactor from list
  734.                 if reactorIndex ~= #newReactorList then    -- If we're not at the end, clean up
  735.                     reactorIndex = reactorIndex - 1 -- We just removed an element
  736.                 end -- reactorIndex ~= #newReactorList then
  737.                 return -- Invalid reactorIndex
  738.             else
  739.                 printLog("reactor["..reactorIndex.."] in findReactors() is a valid Big Reactor.")
  740.                 --initialize the default table
  741.                 _G[reactorNames[reactorIndex]] = {}
  742.                 _G[reactorNames[reactorIndex]]["ReactorOptions"] = {}
  743.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"] = 80
  744.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"] = 0
  745.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = true
  746.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["activeCooled"] = true
  747.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"] = 1400 --set for passive-cooled, the active-cooled subroutine will correct it
  748.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"] = 1000
  749.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] = false
  750.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorName"] = reactorNames[reactorIndex]
  751.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = false
  752.                 if reactor.getConnected() then
  753.                     printLog("reactor["..reactorIndex.."] in findReactors() is connected.")
  754.                 else
  755.                     printLog("reactor["..reactorIndex.."] in findReactors() is NOT connected.")
  756.                     return -- Disconnected reactor
  757.                 end
  758.             end
  759.            
  760.             --failsafe
  761.             local tempTable = _G[reactorNames[reactorIndex]]
  762.            
  763.             --check to make sure we get a valid config
  764.             if (config.load(reactorNames[reactorIndex]..".options")) ~= nil then
  765.                 tempTable = config.load(reactorNames[reactorIndex]..".options")
  766.             else
  767.                 --if we don't have a valid config from disk, make a valid config
  768.                 config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
  769.             end
  770.            
  771.             --load values from tempTable, checking for nil values along the way
  772.             if tempTable["ReactorOptions"]["baseControlRodLevel"] ~= nil then
  773.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"] = tempTable["ReactorOptions"]["baseControlRodLevel"]
  774.             end
  775.            
  776.             if tempTable["ReactorOptions"]["lastTempPoll"] ~= nil then
  777.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"] = tempTable["ReactorOptions"]["lastTempPoll"]
  778.             end
  779.            
  780.             if tempTable["ReactorOptions"]["autoStart"] ~= nil then
  781.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = tempTable["ReactorOptions"]["autoStart"]
  782.             end
  783.            
  784.             if tempTable["ReactorOptions"]["activeCooled"] ~= nil then
  785.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["activeCooled"] = tempTable["ReactorOptions"]["activeCooled"]
  786.             end
  787.            
  788.             if tempTable["ReactorOptions"]["reactorMaxTemp"] ~= nil then
  789.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"] = tempTable["ReactorOptions"]["reactorMaxTemp"]
  790.             end
  791.            
  792.             if tempTable["ReactorOptions"]["reactorMinTemp"] ~= nil then
  793.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"] = tempTable["ReactorOptions"]["reactorMinTemp"]
  794.             end
  795.            
  796.             if tempTable["ReactorOptions"]["rodOverride"] ~= nil then
  797.                 printLog("Got value from config file for Rod Override, the value is: "..tostring(tempTable["ReactorOptions"]["rodOverride"]).." EOL")
  798.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] = tempTable["ReactorOptions"]["rodOverride"]
  799.             end
  800.            
  801.             if tempTable["ReactorOptions"]["reactorName"] ~= nil then
  802.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorName"] = tempTable["ReactorOptions"]["reactorName"]
  803.             end
  804.            
  805.             if tempTable["ReactorOptions"]["reactorCruising"] ~= nil then
  806.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = tempTable["ReactorOptions"]["reactorCruising"]
  807.             end
  808.            
  809.             --stricter typing, let's set these puppies up with the right type of value.
  810.             _G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"] = tonumber(_G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"])
  811.            
  812.             _G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"] = tonumber(_G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"])
  813.            
  814.             if (tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"]) == "true") then
  815.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = true
  816.             else
  817.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = false
  818.             end
  819.            
  820.             if (tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["activeCooled"]) == "true") then
  821.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["activeCooled"] = true
  822.             else
  823.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["activeCooled"] = false
  824.             end
  825.            
  826.             _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"] = tonumber(_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"])
  827.            
  828.             _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"] = tonumber(_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"])
  829.            
  830.             if (tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]) == "true") then
  831.                 printLog("Setting Rod Override for  "..reactorNames[reactorIndex].." to true because value was "..tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]).." EOL")
  832.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] = true
  833.             else
  834.                 printLog("Setting Rod Override for  "..reactorNames[reactorIndex].." to false because value was "..tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]).." EOL")
  835.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] = false
  836.             end
  837.            
  838.             if (tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"]) == "true") then
  839.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = true
  840.             else
  841.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = false
  842.             end
  843.                        
  844.             --save one more time, in case we didn't have a complete config file before
  845.             config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
  846.         end -- for reactorIndex = 1, #newReactorList do
  847.     end -- if #newReactorList == 0 then
  848.  
  849.     -- Overwrite old reactor list with the now updated list
  850.     reactorList = newReactorList
  851.  
  852.     -- Start turbine monitor offset after reactors get monitors
  853.     -- This assumes that there is a monitor for each turbine and reactor, plus the overall monitor display
  854.     turbineMonitorOffset = #reactorList + 1 -- #turbineList will start at "1" if turbines found and move us just beyond #reactorList and status monitor range
  855.  
  856.     printLog("Found "..#reactorList.." reactor(s) in findReactors().")
  857.     printLog("Set turbineMonitorOffset to "..turbineMonitorOffset.." in findReactors().")
  858. end -- function findReactors()
  859.  
  860.  
  861. -- Initialize all Big Reactors - Turbines
  862. local function findTurbines()
  863.     -- Empty out old list of turbines
  864.     newTurbineList = {}
  865.  
  866.     printLog("Finding turbines...")
  867.     newTurbineList, turbineNames = getDevices("BigReactors-Turbine")
  868.  
  869.     if #newTurbineList == 0 then
  870.         printLog("No turbines found") -- Not an error
  871.     else
  872.         for turbineIndex = 1, #newTurbineList do
  873.             local turbine = nil
  874.             turbine = newTurbineList[turbineIndex]
  875.  
  876.             if not turbine then
  877.                 printLog("turbineList["..turbineIndex.."] in findTurbines() is NOT a valid Big Reactors Turbine.")
  878.  
  879.                 table.remove(newTurbineList, turbineIndex) -- Remove invalid turbine from list
  880.                 if turbineIndex ~= #newTurbineList then    -- If we're not at the end, clean up
  881.                     turbineIndex = turbineIndex - 1 -- We just removed an element
  882.                 end -- turbineIndex ~= #newTurbineList then
  883.  
  884.                 return -- Invalid turbineIndex
  885.             else
  886.            
  887.                 _G[turbineNames[turbineIndex]] = {}
  888.                 _G[turbineNames[turbineIndex]]["TurbineOptions"] = {}
  889.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["LastSpeed"] = 0
  890.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["BaseSpeed"] = 2726
  891.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["autoStart"] = true
  892.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["LastFlow"] = 2000 --open up with all the steam wide open
  893.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] = false
  894.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["turbineName"] = turbineNames[turbineIndex]
  895.                 printLog("turbineList["..turbineIndex.."] in findTurbines() is a valid Big Reactors Turbine.")
  896.                 if turbine.getConnected() then
  897.                     printLog("turbine["..turbineIndex.."] in findTurbines() is connected.")
  898.                 else
  899.                     printLog("turbine["..turbineIndex.."] in findTurbines() is NOT connected.")
  900.                     return -- Disconnected turbine
  901.                 end
  902.             end
  903.            
  904.             --failsafe
  905.             local tempTable = _G[turbineNames[turbineIndex]]
  906.            
  907.             --check to make sure we get a valid config
  908.             if (config.load(turbineNames[turbineIndex]..".options")) ~= nil then
  909.                 tempTable = config.load(turbineNames[turbineIndex]..".options")
  910.             else
  911.                 --if we don't have a valid config from disk, make a valid config
  912.                 config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
  913.             end
  914.            
  915.             --load values from tempTable, checking for nil values along the way
  916.             if tempTable["TurbineOptions"]["LastSpeed"] ~= nil then
  917.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["LastSpeed"] = tempTable["TurbineOptions"]["LastSpeed"]
  918.             end
  919.            
  920.             if tempTable["TurbineOptions"]["BaseSpeed"] ~= nil then
  921.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["BaseSpeed"] = tempTable["TurbineOptions"]["BaseSpeed"]
  922.             end
  923.            
  924.             if tempTable["TurbineOptions"]["autoStart"] ~= nil then
  925.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["autoStart"] = tempTable["TurbineOptions"]["autoStart"]
  926.             end
  927.            
  928.             if tempTable["TurbineOptions"]["LastFlow"] ~= nil then
  929.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["LastFlow"] = tempTable["TurbineOptions"]["LastFlow"]
  930.             end
  931.            
  932.             if tempTable["TurbineOptions"]["flowOverride"] ~= nil then
  933.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] = tempTable["TurbineOptions"]["flowOverride"]
  934.             end
  935.            
  936.             if tempTable["TurbineOptions"]["turbineName"] ~= nil then
  937.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["turbineName"] = tempTable["TurbineOptions"]["turbineName"]
  938.             end
  939.            
  940.             --save once more just to make sure we got it
  941.             config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
  942.         end -- for turbineIndex = 1, #newTurbineList do
  943.  
  944.         -- Overwrite old turbine list with the now updated list
  945.         turbineList = newTurbineList
  946.     end -- if #newTurbineList == 0 then
  947.  
  948.     printLog("Found "..#turbineList.." turbine(s) in findTurbines().")
  949. end -- function findTurbines()
  950.  
  951.  
  952. -- Return current energy buffer in a specific reactor by %
  953. local function getReactorStoredEnergyBufferPercent(reactor)
  954.     printLog("Called as getReactorStoredEnergyBufferPercent(reactor).")
  955.  
  956.     if not reactor then
  957.         printLog("getReactorStoredEnergyBufferPercent() did NOT receive a valid Big Reactor Reactor.")
  958.         return -- Invalid reactorIndex
  959.     else
  960.         printLog("getReactorStoredEnergyBufferPercent() did receive a valid Big Reactor Reactor.")
  961.     end
  962.  
  963.     local energyBufferStorage = reactor.getEnergyStored()
  964.     return round(energyBufferStorage/100000, 1) -- (buffer/10000000 RF)*100%
  965. end -- function getReactorStoredEnergyBufferPercent(reactor)
  966.  
  967.  
  968. -- Return current energy buffer in a specific Turbine by %
  969. local function getTurbineStoredEnergyBufferPercent(turbine)
  970.     printLog("Called as getTurbineStoredEnergyBufferPercent(turbine)")
  971.  
  972.     if not turbine then
  973.         printLog("getTurbineStoredEnergyBufferPercent() did NOT receive a valid Big Reactor Turbine.")
  974.         return -- Invalid reactorIndex
  975.     else
  976.         printLog("getTurbineStoredEnergyBufferPercent() did receive a valid Big Reactor Turbine.")
  977.     end
  978.  
  979.     local energyBufferStorage = turbine.getEnergyStored()
  980.     return round(energyBufferStorage/10000, 1) -- (buffer/1000000 RF)*100%
  981. end -- function getTurbineStoredEnergyBufferPercent(turbine)
  982.  
  983. local function reactorCruise(cruiseMaxTemp, cruiseMinTemp, reactorIndex)
  984.     printLog("Called as reactorCruise(cruiseMaxTemp="..cruiseMaxTemp..",cruiseMinTemp="..cruiseMinTemp..",lastPolledTemp=".._G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"]..",reactorIndex="..reactorIndex..").")
  985.    
  986.     --sanitization
  987.     local lastPolledTemp = tonumber(_G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"])
  988.     cruiseMaxTemp = tonumber(cruiseMaxTemp)
  989.     cruiseMinTemp = tonumber(cruiseMinTemp)
  990.    
  991.     if ((lastPolledTemp < cruiseMaxTemp) and (lastPolledTemp > cruiseMinTemp)) then
  992.         local reactor = nil
  993.         reactor = reactorList[reactorIndex]
  994.         if not reactor then
  995.             printLog("reactor["..reactorIndex.."] in reactorCruise(cruiseMaxTemp="..cruiseMaxTemp..",cruiseMinTemp="..cruiseMinTemp..",lastPolledTemp="..lastPolledTemp..",reactorIndex="..reactorIndex..") is NOT a valid Big Reactor.")
  996.             return -- Invalid reactorIndex
  997.         else
  998.             printLog("reactor["..reactorIndex.."] in reactorCruise(cruiseMaxTemp="..cruiseMaxTemp..",cruiseMinTemp="..cruiseMinTemp..",lastPolledTemp="..lastPolledTemp..",reactorIndex="..reactorIndex..") is a valid Big Reactor.")
  999.             if reactor.getConnected() then
  1000.                 printLog("reactor["..reactorIndex.."] in reactorCruise(cruiseMaxTemp="..cruiseMaxTemp..",cruiseMinTemp="..cruiseMinTemp..",lastPolledTemp="..lastPolledTemp..",reactorIndex="..reactorIndex..") is connected.")
  1001.             else
  1002.                 printLog("reactor["..reactorIndex.."] in reactorCruise(cruiseMaxTemp="..cruiseMaxTemp..",cruiseMinTemp="..cruiseMinTemp..",lastPolledTemp="..lastPolledTemp..",reactorIndex="..reactorIndex..") is NOT connected.")
  1003.                 return -- Disconnected reactor
  1004.             end -- if reactor.getConnected() then
  1005.         end -- if not reactor then
  1006.  
  1007.         local rodPercentage = math.ceil(reactor.getControlRodLevel(0))
  1008.         local reactorTemp = math.ceil(reactor.getFuelTemperature())
  1009.         _G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"] = rodPercentage
  1010.        
  1011.         if ((reactorTemp < cruiseMaxTemp) and (reactorTemp > cruiseMinTemp)) then
  1012.             if (reactorTemp < lastPolledTemp) then
  1013.                 rodPercentage = (rodPercentage - 1)
  1014.                 --Boundary check
  1015.                 if rodPercentage < 0 then
  1016.                     reactor.setAllControlRodLevels(0)
  1017.                 else
  1018.                     reactor.setAllControlRodLevels(rodPercentage)
  1019.                 end
  1020.             else
  1021.                 rodPercentage = (rodPercentage + 1)
  1022.                 --Boundary check
  1023.                 if rodPercentage > 99 then
  1024.                     reactor.setAllControlRodLevels(99)
  1025.                 else
  1026.                     reactor.setAllControlRodLevels(rodPercentage)
  1027.                 end
  1028.             end -- if (reactorTemp > lastPolledTemp) then
  1029.         else
  1030.             --disengage cruise, we've fallen out of the ideal temperature range
  1031.             _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = false
  1032.         end -- if ((reactorTemp < cruiseMaxTemp) and (reactorTemp > cruiseMinTemp)) then
  1033.     else
  1034.         --I don't know how we'd get here, but let's turn the cruise mode off
  1035.         _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = false
  1036.     end -- if ((lastPolledTemp < cruiseMaxTemp) and (lastPolledTemp > cruiseMinTemp)) then
  1037.     _G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"] = reactorTemp
  1038.     _G[reactorNames[reactorIndex]]["ReactorOptions"]["activeCooled"] = true
  1039.     _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"] = cruiseMaxTemp
  1040.     _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"] = cruiseMinTemp
  1041.     config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
  1042. end -- function reactorCruise(cruiseMaxTemp, cruiseMinTemp, lastPolledTemp, reactorIndex)
  1043.  
  1044. -- Modify reactor control rod levels to keep temperature with defined parameters, but
  1045. -- wait an in-game half-hour for the temperature to stabalize before modifying again
  1046. local function temperatureControl(reactorIndex)
  1047.     printLog("Called as temperatureControl(reactorIndex="..reactorIndex..")")
  1048.  
  1049.     local reactor = nil
  1050.     reactor = reactorList[reactorIndex]
  1051.     if not reactor then
  1052.         printLog("reactor["..reactorIndex.."] in temperatureControl(reactorIndex="..reactorIndex..") is NOT a valid Big Reactor.")
  1053.         return -- Invalid reactorIndex
  1054.     else
  1055.         printLog("reactor["..reactorIndex.."] in temperatureControl(reactorIndex="..reactorIndex..") is a valid Big Reactor.")
  1056.  
  1057.         if reactor.getConnected() then
  1058.             printLog("reactor["..reactorIndex.."] in temperatureControl(reactorIndex="..reactorIndex..") is connected.")
  1059.         else
  1060.             printLog("reactor["..reactorIndex.."] in temperatureControl(reactorIndex="..reactorIndex..") is NOT connected.")
  1061.             return -- Disconnected reactor
  1062.         end -- if reactor.getConnected() then
  1063.     end
  1064.  
  1065.     local reactorNum = reactorIndex
  1066.     local rodPercentage = math.ceil(reactor.getControlRodLevel(0))
  1067.     local reactorTemp = math.ceil(reactor.getFuelTemperature())
  1068.     local localMinReactorTemp, localMaxReactorTemp = _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"], _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"]
  1069.  
  1070.     --bypass if the reactor itself is set to not be auto-controlled
  1071.     if ((not _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]) or (_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] == "false")) then
  1072.         -- No point modifying control rod levels for temperature if the reactor is offline
  1073.         if reactor.getActive() then
  1074.             -- Actively cooled reactors should range between 0^C-300^C
  1075.             -- Actually, active-cooled reactors should range between 300 and 420C (Mechaet)
  1076.             -- Accordingly I changed the below lines
  1077.             if reactor.isActivelyCooled() and not knowlinglyOverride then
  1078.                 -- below was 0
  1079.                 localMinReactorTemp = 300
  1080.                 -- below was 300
  1081.                 localMaxReactorTemp = 420
  1082.             else
  1083.                 localMinReactorTemp = _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMinTemp"]
  1084.                 localMaxReactorTemp = _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorMaxTemp"]
  1085.             end
  1086.             local lastTempPoll = _G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"]
  1087.             if _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] then
  1088.                 --let's bypass all this math and hit the much-more-subtle cruise feature
  1089.                 --printLog("min: "..localMinReactorTemp..", max: "..localMaxReactorTemp..", lasttemp: "..lastTempPoll..", ri: "..reactorIndex.."  EOL")
  1090.                 reactorCruise(localMaxReactorTemp, localMinReactorTemp, reactorIndex)
  1091.             else
  1092.                 -- Don't bring us to 100, that's effectively a shutdown
  1093.                 if (reactorTemp > localMaxReactorTemp) and (rodPercentage ~= 99) then
  1094.                     --increase the rods, but by how much?
  1095.                     if (reactorTemp > lastTempPoll) then
  1096.                         --we're climbing, we need to get this to decrease
  1097.                         if ((reactorTemp - lastTempPoll) > 100) then
  1098.                             --we're climbing really fast, arrest it
  1099.                             if (rodPercentage + (10 * controlRodAdjustAmount)) > 99 then
  1100.                                 reactor.setAllControlRodLevels(99)
  1101.                             else
  1102.                                 reactor.setAllControlRodLevels(rodPercentage + (10 * controlRodAdjustAmount))
  1103.                             end
  1104.                         else
  1105.                             --we're not climbing by leaps and bounds, let's give it a rod adjustment based on temperature increase
  1106.                             local diffAmount = reactorTemp - lastTempPoll
  1107.                             diffAmount = (round(diffAmount/10, 0))/5
  1108.                             controlRodAdjustAmount = diffAmount
  1109.                             if (rodPercentage + controlRodAdjustAmount) > 99 then
  1110.                                 reactor.setAllControlRodLevels(99)
  1111.                             else
  1112.                                 reactor.setAllControlRodLevels(rodPercentage + controlRodAdjustAmount)
  1113.                             end
  1114.                         end --if ((reactorTemp - lastTempPoll) > 100) then
  1115.                     elseif (reactorTemp == lastTempPoll) then
  1116.                         --temperature has stagnated, kick it very lightly
  1117.                         local controlRodAdjustment = 1
  1118.                         if (rodPercentage + controlRodAdjustment) > 99 then
  1119.                             reactor.setAllControlRodLevels(99)
  1120.                         else
  1121.                             reactor.setAllControlRodLevels(rodPercentage + controlRodAdjustment)
  1122.                         end
  1123.                     end --if (reactorTemp > lastTempPoll) then
  1124.                         --worth noting that if we're above temp but decreasing, we do nothing. let it continue decreasing.
  1125.  
  1126.                 elseif (reactorTemp < localMinReactorTemp) and (rodPercentage ~=0) then
  1127.                     --we're too cold. time to warm up, but by how much?
  1128.                     if (reactorTemp < lastTempPoll) then
  1129.                         --we're descending, let's stop that.
  1130.                         if ((lastTempPoll - reactorTemp) > 100) then
  1131.                             --we're headed for a new ice age, bring the heat
  1132.                             if (rodPercentage - (10 * controlRodAdjustAmount)) < 0 then
  1133.                                 reactor.setAllControlRodLevels(0)
  1134.                             else
  1135.                                 reactor.setAllControlRodLevels(rodPercentage - (10 * controlRodAdjustAmount))
  1136.                             end
  1137.                         else
  1138.                             --we're not descending quickly, let's bump it based on descent rate
  1139.                             local diffAmount = lastTempPoll - reactorTemp
  1140.                             diffAmount = (round(diffAmount/10, 0))/5
  1141.                             controlRodAdjustAmount = diffAmount
  1142.                             if (rodPercentage - controlRodAdjustAmount) < 0 then
  1143.                                 reactor.setAllControlRodLevels(0)
  1144.                             else
  1145.                                 reactor.setAllControlRodLevels(rodPercentage - controlRodAdjustAmount)
  1146.                             end
  1147.                         end --if ((lastTempPoll - reactorTemp) > 100) then
  1148.                     elseif (reactorTemp == lastTempPoll) then
  1149.                         --temperature has stagnated, kick it very lightly
  1150.                         local controlRodAdjustment = 1
  1151.                         if (rodPercentage - controlRodAdjustment) < 0 then
  1152.                             reactor.setAllControlRodLevels(0)
  1153.                         else
  1154.                             reactor.setAllControlRodLevels(rodPercentage - controlRodAdjustment)
  1155.                         end --if (rodPercentage - controlRodAdjustment) < 0 then
  1156.  
  1157.                     end --if (reactorTemp < lastTempPoll) then
  1158.                     --if we're below temp but increasing, do nothing and let it continue to rise.
  1159.                 end --if (reactorTemp > localMaxReactorTemp) and (rodPercentage ~= 99) then
  1160.  
  1161.                 if ((reactorTemp > localMinReactorTemp) and (reactorTemp < localMaxReactorTemp)) then
  1162.                     --engage cruise mode
  1163.                     _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] = true
  1164.                 end -- if ((reactorTemp > localMinReactorTemp) and (reactorTemp < localMaxReactorTemp)) then
  1165.             end -- if reactorCruising then
  1166.             --always set this number
  1167.             _G[reactorNames[reactorIndex]]["ReactorOptions"]["lastTempPoll"] = reactorTemp
  1168.             config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
  1169.         end -- if reactor.getActive() then
  1170.     else
  1171.         printLog("Bypassed temperature control due to rodOverride being "..tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]).." EOL")
  1172.     end -- if not _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] then
  1173. end -- function temperatureControl(reactorIndex)
  1174.  
  1175. -- Load saved reactor parameters if ReactorOptions file exists
  1176. local function loadReactorOptions()
  1177.     local reactorOptions = fs.open("ReactorOptions", "r") -- See http://computercraft.info/wiki/Fs.open
  1178.  
  1179.     if reactorOptions then
  1180.         -- The following values were added by Lolmer
  1181.         minStoredEnergyPercent = reactorOptions.readLine()
  1182.         maxStoredEnergyPercent = reactorOptions.readLine()
  1183.         --added by Mechaet
  1184.         -- If we succeeded in reading a string, convert it to a number
  1185.  
  1186.         if minStoredEnergyPercent ~= nil then
  1187.             minStoredEnergyPercent = tonumber(minStoredEnergyPercent)
  1188.         end
  1189.  
  1190.         if maxStoredEnergyPercent ~= nil then
  1191.             maxStoredEnergyPercent = tonumber(maxStoredEnergyPercent)
  1192.         end
  1193.  
  1194.         reactorOptions.close()
  1195.     end -- if reactorOptions then
  1196.  
  1197.     -- Set default values if we failed to read any of the above
  1198.     if minStoredEnergyPercent == nil then
  1199.         minStoredEnergyPercent = 15
  1200.     end
  1201.  
  1202.     if maxStoredEnergyPercent == nil then
  1203.         maxStoredEnergyPercent = 85
  1204.     end
  1205.  
  1206. end -- function loadReactorOptions()
  1207.  
  1208.  
  1209. -- Save our reactor parameters
  1210. local function saveReactorOptions()
  1211.     local reactorOptions = fs.open("ReactorOptions", "w") -- See http://computercraft.info/wiki/Fs.open
  1212.  
  1213.     -- If we can save the files, save them
  1214.     if reactorOptions then
  1215.         local reactorIndex = 1
  1216.         -- The following values were added by Lolmer
  1217.         reactorOptions.writeLine(minStoredEnergyPercent)
  1218.         reactorOptions.writeLine(maxStoredEnergyPercent)
  1219.         reactorOptions.close()
  1220.     else
  1221.         printLog("Failed to open file ReactorOptions for writing!")
  1222.     end -- if reactorOptions then
  1223. end -- function saveReactorOptions()
  1224.  
  1225.  
  1226. local function displayReactorBars(barParams)
  1227.     -- Default to first reactor and first monitor
  1228.     setmetatable(barParams,{__index={reactorIndex=1, monitorIndex=1}})
  1229.     local reactorIndex, monitorIndex =
  1230.         barParams[1] or barParams.reactorIndex,
  1231.         barParams[2] or barParams.monitorIndex
  1232.  
  1233.     printLog("Called as displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
  1234.  
  1235.     -- Grab current monitor
  1236.     local monitor = nil
  1237.     monitor = monitorList[monitorIndex]
  1238.     if not monitor then
  1239.         printLog("monitor["..monitorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT a valid monitor.")
  1240.         return -- Invalid monitorIndex
  1241.     end
  1242.  
  1243.     -- Grab current reactor
  1244.     local reactor = nil
  1245.     reactor = reactorList[reactorIndex]
  1246.     if not reactor then
  1247.         printLog("reactor["..reactorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT a valid Big Reactor.")
  1248.         return -- Invalid reactorIndex
  1249.     else
  1250.         printLog("reactor["..reactorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is a valid Big Reactor.")
  1251.         if reactor.getConnected() then
  1252.             printLog("reactor["..reactorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is connected.")
  1253.         else
  1254.             printLog("reactor["..reactorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT connected.")
  1255.             return -- Disconnected reactor
  1256.         end -- if reactor.getConnected() then
  1257.     end -- if not reactor then
  1258.  
  1259.     -- Draw border lines
  1260.     local width, height = monitor.getSize()
  1261.     printLog("Size of monitor is "..width.."w x"..height.."h in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..")")
  1262.  
  1263.     for i=3, 5 do
  1264.         monitor.setCursorPos(22, i)
  1265.         monitor.write("|")
  1266.     end
  1267.  
  1268.     drawLine(2, monitorIndex)
  1269.     drawLine(6, monitorIndex)
  1270.  
  1271.     -- Draw some text
  1272.     local fuelString = "Fuel: "
  1273.     local tempString = "Temp: "
  1274.     local energyBufferString = ""
  1275.  
  1276.     if reactor.isActivelyCooled() then
  1277.         energyBufferString = "Steam: "
  1278.     else
  1279.         energyBufferString = "Energy: "
  1280.     end
  1281.  
  1282.     local padding = math.max(string.len(fuelString), string.len(tempString), string.len(energyBufferString))
  1283.  
  1284.     local fuelPercentage = round(reactor.getFuelAmount()/reactor.getFuelAmountMax()*100,1)
  1285.     print{fuelString,2,3,monitorIndex}
  1286.     print{fuelPercentage.." %",padding+2,3,monitorIndex}
  1287.  
  1288.     local reactorTemp = math.ceil(reactor.getFuelTemperature())
  1289.     print{tempString,2,5,monitorIndex}
  1290.     print{reactorTemp.." C",padding+2,5,monitorIndex}
  1291.  
  1292.     local rodPercentage = math.ceil(reactor.getControlRodLevel(0))
  1293.     printLog("Current Rod Percentage for reactor["..reactorIndex.."] is "..rodPercentage.."% in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
  1294.     -- Allow controlling Reactor Control Rod Level from GUI
  1295.     -- Decrease rod button: 23X, 4Y
  1296.     -- Increase rod button: 28X, 4Y
  1297.     if (xClick == 23) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
  1298.         printLog("Decreasing Rod Levels in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
  1299.         --Decrease rod level by amount
  1300.         newRodPercentage = rodPercentage - (5 * controlRodAdjustAmount)
  1301.         if newRodPercentage < 0 then
  1302.             newRodPercentage = 0
  1303.         end
  1304.         sideClick, xClick, yClick = 0, 0, 0
  1305.  
  1306.         printLog("Setting reactor["..reactorIndex.."] Rod Levels to "..newRodPercentage.."% in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
  1307.         reactor.setAllControlRodLevels(newRodPercentage)
  1308.         _G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"] = newRodPercentage
  1309.  
  1310.         -- Save updated rod percentage
  1311.         config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
  1312.         rodPercentage = newRodPercentage
  1313.     elseif (xClick == 29) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
  1314.         printLog("Increasing Rod Levels in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
  1315.         --Increase rod level by amount
  1316.         newRodPercentage = rodPercentage + (5 * controlRodAdjustAmount)
  1317.         if newRodPercentage > 100 then
  1318.             newRodPercentage = 100
  1319.         end
  1320.         sideClick, xClick, yClick = 0, 0, 0
  1321.  
  1322.         printLog("Setting reactor["..reactorIndex.."] Rod Levels to "..newRodPercentage.."% in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
  1323.         reactor.setAllControlRodLevels(newRodPercentage)
  1324.         _G[reactorNames[reactorIndex]]["ReactorOptions"]["baseControlRodLevel"] = newRodPercentage
  1325.        
  1326.         -- Save updated rod percentage
  1327.         config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
  1328.         rodPercentage = round(newRodPercentage,0)
  1329.     else
  1330.         printLog("No change to Rod Levels requested by "..progName.." GUI in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
  1331.     end -- if (xClick == 29) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
  1332.  
  1333.     print{"Rod (%)",23,3,monitorIndex}
  1334.     print{"<     >",23,4,monitorIndex}
  1335.     print{stringTrim(rodPercentage),25,4,monitorIndex}
  1336.  
  1337.  
  1338.     -- getEnergyProducedLastTick() is used for both RF/t (passively cooled) and mB/t (actively cooled)
  1339.     local energyBuffer = reactor.getEnergyProducedLastTick()
  1340.     if reactor.isActivelyCooled() then
  1341.         printLog("reactor["..reactorIndex.."] produced "..energyBuffer.." mB last tick in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
  1342.     else
  1343.         printLog("reactor["..reactorIndex.."] produced "..energyBuffer.." RF last tick in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
  1344.     end
  1345.  
  1346.     print{energyBufferString,2,4,monitorIndex}
  1347.  
  1348.     -- Actively cooled reactors do not produce energy, only hot fluid mB/t to be used in a turbine
  1349.     -- still uses getEnergyProducedLastTick for mB/t of hot fluid generated
  1350.     if not reactor.isActivelyCooled() then
  1351.         printLog("reactor["..reactorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT an actively cooled reactor.")
  1352.  
  1353.         -- Draw stored energy buffer bar
  1354.         drawBar(2,8,28,8,colors.gray,monitorIndex)
  1355.  
  1356.         local curStoredEnergyPercent = getReactorStoredEnergyBufferPercent(reactor)
  1357.         if curStoredEnergyPercent > 4 then
  1358.             drawBar(2, 8, math.floor(26*curStoredEnergyPercent/100)+2, 8, colors.yellow, monitorIndex)
  1359.         elseif curStoredEnergyPercent > 0 then
  1360.             drawPixel(2, 8, colors.yellow, monitorIndex)
  1361.         end -- if curStoredEnergyPercent > 4 then
  1362.  
  1363.         print{"Energy Buffer",2,7,monitorIndex}
  1364.         print{curStoredEnergyPercent, width-(string.len(curStoredEnergyPercent)+2),7,monitorIndex}
  1365.         print{"%",28,7,monitorIndex}
  1366.  
  1367.         print{math.ceil(energyBuffer).." RF/t",padding+2,4,monitorIndex}
  1368.     else
  1369.         printLog("reactor["..reactorIndex.."] in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is an actively cooled reactor.")
  1370.         print{math.ceil(energyBuffer).." mB/t",padding+2,4,monitorIndex}
  1371.     end -- if not reactor.isActivelyCooled() then
  1372.  
  1373.     -- Print rod override status
  1374.     local reactorRodOverrideStatus = ""
  1375.  
  1376.     print{"Rod Auto-adjust:",2,9,monitorIndex}
  1377.  
  1378.     if not _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] then
  1379.         printLog("Reactor Rod Override status is: "..tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]).." EOL")
  1380.         reactorRodOverrideStatus = "Enabled"
  1381.         monitor.setTextColor(colors.green)
  1382.     else
  1383.         printLog("Reactor Rod Override status is: "..tostring(_G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]).." EOL")
  1384.         reactorRodOverrideStatus = "Disabled"
  1385.         monitor.setTextColor(colors.red)
  1386.     end -- if not reactorRodOverride then
  1387.     printLog("reactorRodOverrideStatus is \""..reactorRodOverrideStatus.."\" in displayReactorBars(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..").")
  1388.  
  1389.     print{reactorRodOverrideStatus, width - string.len(reactorRodOverrideStatus) - 1, 9, monitorIndex}
  1390.     monitor.setTextColor(colors.white)
  1391.  
  1392.     print{"Reactivity: "..math.ceil(reactor.getFuelReactivity()).." %", 2, 10, monitorIndex}
  1393.     print{"Fuel: "..round(reactor.getFuelConsumedLastTick(),3).." mB/t", 2, 11, monitorIndex}
  1394.     print{"Waste: "..reactor.getWasteAmount().." mB", width-(string.len(reactor.getWasteAmount())+10), 11, monitorIndex}
  1395.  
  1396.     monitor.setTextColor(colors.blue)
  1397.     printCentered(_G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorName"],12,monitorIndex)
  1398.     monitor.setTextColor(colors.white)
  1399. end -- function displayReactorBars(barParams)
  1400.  
  1401.  
  1402. local function reactorStatus(statusParams)
  1403.     -- Default to first reactor and first monitor
  1404.     setmetatable(statusParams,{__index={reactorIndex=1, monitorIndex=1}})
  1405.     local reactorIndex, monitorIndex =
  1406.         statusParams[1] or statusParams.reactorIndex,
  1407.         statusParams[2] or statusParams.monitorIndex
  1408.     printLog("Called as reactorStatus(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..")")
  1409.  
  1410.     -- Grab current monitor
  1411.     local monitor = nil
  1412.     monitor = monitorList[monitorIndex]
  1413.     if not monitor then
  1414.         printLog("monitor["..monitorIndex.."] in reactorStatus(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT a valid monitor.")
  1415.         return -- Invalid monitorIndex
  1416.     end
  1417.  
  1418.     -- Grab current reactor
  1419.     local reactor = nil
  1420.     reactor = reactorList[reactorIndex]
  1421.     if not reactor then
  1422.         printLog("reactor["..reactorIndex.."] in reactorStatus(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT a valid Big Reactor.")
  1423.         return -- Invalid reactorIndex
  1424.     else
  1425.         printLog("reactor["..reactorIndex.."] in reactorStatus(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is a valid Big Reactor.")
  1426.     end
  1427.  
  1428.     local width, height = monitor.getSize()
  1429.     local reactorStatus = ""
  1430.  
  1431.     if reactor.getConnected() then
  1432.         printLog("reactor["..reactorIndex.."] in reactorStatus(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is connected.")
  1433.  
  1434.         if reactor.getActive() then
  1435.             reactorStatus = "ONLINE"
  1436.  
  1437.             -- Set "ONLINE" to blue if the actively cooled reactor is both in cruise mode and online
  1438.             if _G[reactorNames[reactorIndex]]["ReactorOptions"]["reactorCruising"] and reactor.isActivelyCooled() then
  1439.                 monitor.setTextColor(colors.blue)
  1440.             else
  1441.                 monitor.setTextColor(colors.green)
  1442.             end -- if reactorCruising and reactor.isActivelyCooled() then
  1443.         else
  1444.             reactorStatus = "OFFLINE"
  1445.             monitor.setTextColor(colors.red)
  1446.         end -- if reactor.getActive() then
  1447.  
  1448.         if xClick >= (width - string.len(reactorStatus) - 1) and xClick <= (width-1) and (sideClick == monitorNames[monitorIndex]) then
  1449.             if yClick == 1 then
  1450.                 reactor.setActive(not reactor.getActive()) -- Toggle reactor status
  1451.                 _G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = reactor.getActive()
  1452.                 config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
  1453.                 sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
  1454.  
  1455.                 -- If someone offlines the reactor (offline after a status click was detected), then disable autoStart
  1456.                 if not reactor.getActive() then
  1457.                     _G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] = false
  1458.                 end
  1459.             end -- if yClick == 1 then
  1460.         end -- if (xClick >= (width - string.len(reactorStatus) - 1) and xClick <= (width-1)) and (sideClick == monitorNames[monitorIndex]) then
  1461.  
  1462.         -- Allow disabling rod level auto-adjust and only manual rod level control
  1463.         if ((xClick > 23 and xClick < 28 and yClick == 4)
  1464.                 or (xClick > 20 and xClick < 27 and yClick == 9))
  1465.                 and (sideClick == monitorNames[monitorIndex]) then
  1466.             _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] = not _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"]
  1467.             config.save(reactorNames[reactorIndex]..".options", _G[reactorNames[reactorIndex]])
  1468.             sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
  1469.         end -- if (xClick > 23) and (xClick < 28) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
  1470.  
  1471.     else
  1472.         printLog("reactor["..reactorIndex.."] in reactorStatus(reactorIndex="..reactorIndex..",monitorIndex="..monitorIndex..") is NOT connected.")
  1473.         reactorStatus = "DISCONNECTED"
  1474.         monitor.setTextColor(colors.red)
  1475.     end -- if reactor.getConnected() then
  1476.  
  1477.     print{reactorStatus, width - string.len(reactorStatus) - 1, 1, monitorIndex}
  1478.     monitor.setTextColor(colors.white)
  1479. end -- function reactorStatus(statusParams)
  1480.  
  1481.  
  1482. -- Display all found reactors' status to monitor 1
  1483. -- This is only called if multiple reactors and/or a reactor plus at least one turbine are found
  1484. local function displayAllStatus()
  1485.     local reactor, turbine = nil, nil
  1486.     local onlineReactor, onlineTurbine = 0, 0
  1487.     local totalReactorRF, totalReactorSteam, totalTurbineRF = 0, 0, 0
  1488.     local totalReactorFuelConsumed = 0
  1489.     local totalCoolantStored, totalSteamStored, totalEnergy, totalMaxEnergyStored = 0, 0, 0, 0 -- Total turbine and reactor energy buffer and overall capacity
  1490.     local maxSteamStored = (2000*#turbineList)+(5000*#reactorList)
  1491.     local maxCoolantStored = (2000*#turbineList)+(5000*#reactorList)
  1492.  
  1493.     local monitor, monitorIndex = nil, 1
  1494.     monitor = monitorList[monitorIndex]
  1495.     if not monitor then
  1496.         printLog("monitor["..monitorIndex.."] in displayAllStatus() is NOT a valid monitor.")
  1497.         return -- Invalid monitorIndex
  1498.     end
  1499.  
  1500.     for reactorIndex = 1, #reactorList do
  1501.         reactor = reactorList[reactorIndex]
  1502.         if not reactor then
  1503.             printLog("reactor["..reactorIndex.."] in displayAllStatus() is NOT a valid Big Reactor.")
  1504.             break -- Invalid reactorIndex
  1505.         else
  1506.             printLog("reactor["..reactorIndex.."] in displayAllStatus() is a valid Big Reactor.")
  1507.         end -- if not reactor then
  1508.  
  1509.         if reactor.getConnected() then
  1510.             printLog("reactor["..reactorIndex.."] in displayAllStatus() is connected.")
  1511.             if reactor.getActive() then
  1512.                 onlineReactor = onlineReactor + 1
  1513.                 totalReactorFuelConsumed = totalReactorFuelConsumed + reactor.getFuelConsumedLastTick()
  1514.             end -- reactor.getActive() then
  1515.  
  1516.             -- Actively cooled reactors do not produce or store energy
  1517.             if not reactor.isActivelyCooled() then
  1518.                 totalMaxEnergyStored = totalMaxEnergyStored + 10000000 -- Reactors store 10M RF
  1519.                 totalEnergy = totalEnergy + reactor.getEnergyStored()
  1520.                 totalReactorRF = totalReactorRF + reactor.getEnergyProducedLastTick()
  1521.             else
  1522.                 totalReactorSteam = totalReactorSteam + reactor.getEnergyProducedLastTick()
  1523.                 totalSteamStored = totalSteamStored + reactor.getHotFluidAmount()
  1524.                 totalCoolantStored = totalCoolantStored + reactor.getCoolantAmount()
  1525.             end -- if not reactor.isActivelyCooled() then
  1526.         else
  1527.             printLog("reactor["..reactorIndex.."] in displayAllStatus() is NOT connected.")
  1528.         end -- if reactor.getConnected() then
  1529.     end -- for reactorIndex = 1, #reactorList do
  1530.  
  1531.     for turbineIndex = 1, #turbineList do
  1532.         turbine = turbineList[turbineIndex]
  1533.         if not turbine then
  1534.             printLog("turbine["..turbineIndex.."] in displayAllStatus() is NOT a valid Turbine.")
  1535.             break -- Invalid turbineIndex
  1536.         else
  1537.             printLog("turbine["..turbineIndex.."] in displayAllStatus() is a valid Turbine.")
  1538.         end -- if not turbine then
  1539.  
  1540.         if turbine.getConnected() then
  1541.             printLog("turbine["..turbineIndex.."] in displayAllStatus() is connected.")
  1542.             if turbine.getActive() then
  1543.                 onlineTurbine = onlineTurbine + 1
  1544.             end
  1545.  
  1546.             totalMaxEnergyStored = totalMaxEnergyStored + 1000000 -- Turbines store 1M RF
  1547.             totalEnergy = totalEnergy + turbine.getEnergyStored()
  1548.             totalTurbineRF = totalTurbineRF + turbine.getEnergyProducedLastTick()
  1549.             totalSteamStored = totalSteamStored + turbine.getInputAmount()
  1550.             totalCoolantStored = totalCoolantStored + turbine.getOutputAmount()
  1551.         else
  1552.             printLog("turbine["..turbineIndex.."] in displayAllStatus() is NOT connected.")
  1553.         end -- if turbine.getConnected() then
  1554.     end -- for turbineIndex = 1, #turbineList do
  1555.  
  1556.     print{"Reactors online/found: "..onlineReactor.."/"..#reactorList, 2, 3, monitorIndex}
  1557.     print{"Turbines online/found: "..onlineTurbine.."/"..#turbineList, 2, 4, monitorIndex}
  1558.  
  1559.     if totalReactorRF ~= 0 then
  1560.         monitor.setTextColor(colors.blue)
  1561.         printRight("Reactor", 9, monitorIndex)
  1562.         monitor.setTextColor(colors.white)
  1563.         printRight(math.ceil(totalReactorRF).." (RF/t)", 10, monitorIndex)
  1564.     end
  1565.  
  1566.     if #turbineList then
  1567.         -- Display liquids
  1568.         monitor.setTextColor(colors.blue)
  1569.         printLeft("Steam (mB)", 6, monitorIndex)
  1570.         monitor.setTextColor(colors.white)
  1571.         printLeft(math.ceil(totalSteamStored).."/"..maxSteamStored, 7, monitorIndex)
  1572.         printLeft(math.ceil(totalReactorSteam).." mB/t", 8, monitorIndex)
  1573.         monitor.setTextColor(colors.blue)
  1574.         printRight("Coolant (mB)", 6, monitorIndex)
  1575.         monitor.setTextColor(colors.white)
  1576.         printRight(math.ceil(totalCoolantStored).."/"..maxCoolantStored, 7, monitorIndex)
  1577.  
  1578.         monitor.setTextColor(colors.blue)
  1579.         printLeft("Turbine", 9, monitorIndex)
  1580.         monitor.setTextColor(colors.white)
  1581.         printLeft(math.ceil(totalTurbineRF).." RF/t", 10, monitorIndex)
  1582.     end -- if #turbineList then
  1583.  
  1584.     printCentered("Fuel: "..round(totalReactorFuelConsumed,3).." mB/t", 11, monitorIndex)
  1585.     print{"Buffer: "..math.ceil(totalEnergy,3).."/"..totalMaxEnergyStored.." RF", 2, 12, monitorIndex}
  1586. end -- function displayAllStatus()
  1587.  
  1588.  
  1589. -- Get turbine status
  1590. local function displayTurbineBars(turbineIndex, monitorIndex)
  1591.     printLog("Called as displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
  1592.  
  1593.     -- Grab current monitor
  1594.     local monitor = nil
  1595.     monitor = monitorList[monitorIndex]
  1596.     if not monitor then
  1597.         printLog("monitor["..monitorIndex.."] in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is NOT a valid monitor.")
  1598.         return -- Invalid monitorIndex
  1599.     end
  1600.  
  1601.     -- Grab current turbine
  1602.     local turbine = nil
  1603.     turbine = turbineList[turbineIndex]
  1604.     if not turbine then
  1605.         printLog("turbine["..turbineIndex.."] in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is NOT a valid Big Turbine.")
  1606.         return -- Invalid turbineIndex
  1607.     else
  1608.         printLog("turbine["..turbineIndex.."] in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is a valid Big Turbine.")
  1609.         if turbine.getConnected() then
  1610.             printLog("turbine["..turbineIndex.."] in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is connected.")
  1611.         else
  1612.             printLog("turbine["..turbineIndex.."] in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is NOT connected.")
  1613.             return -- Disconnected turbine
  1614.         end -- if turbine.getConnected() then
  1615.     end -- if not turbine then
  1616.  
  1617.     --local variable to match the view on the monitor
  1618.     local turbineBaseSpeed = tonumber(_G[turbineNames[turbineIndex]]["TurbineOptions"]["BaseSpeed"])
  1619.  
  1620.     -- Draw border lines
  1621.     local width, height = monitor.getSize()
  1622.  
  1623.     for i=3, 6 do
  1624.         monitor.setCursorPos(21, i)
  1625.         monitor.write("|")
  1626.     end
  1627.  
  1628.     drawLine(2,monitorIndex)
  1629.     drawLine(7,monitorIndex)
  1630.  
  1631.     -- Allow controlling Turbine Flow Rate from GUI
  1632.     -- Decrease flow rate button: 22X, 4Y
  1633.     -- Increase flow rate button: 28X, 4Y
  1634.     local turbineFlowRate = tonumber(_G[turbineNames[turbineIndex]]["TurbineOptions"]["LastFlow"])
  1635.     if (xClick == 22) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
  1636.         printLog("Decrease to Flow Rate requested by "..progName.." GUI in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
  1637.         --Decrease rod level by amount
  1638.         newTurbineFlowRate = turbineFlowRate - flowRateAdjustAmount
  1639.         if newTurbineFlowRate < 0 then
  1640.             newTurbineFlowRate = 0
  1641.         end
  1642.         sideClick, xClick, yClick = 0, 0, 0
  1643.  
  1644.         -- Check bounds [0,2000]
  1645.         if newTurbineFlowRate > 2000 then
  1646.             newTurbineFlowRate = 2000
  1647.         elseif newTurbineFlowRate < 0 then
  1648.             newTurbineFlowRate = 25 -- Don't go to zero, might as well power off
  1649.         end
  1650.  
  1651.         turbine.setFluidFlowRateMax(newTurbineFlowRate)
  1652.         _G[turbineNames[turbineIndex]]["TurbineOptions"]["LastFlow"] = newTurbineFlowRate
  1653.         -- Save updated Turbine Flow Rate
  1654.         turbineFlowRate = newTurbineFlowRate
  1655.         config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
  1656.     elseif (xClick == 29) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
  1657.         printLog("Increase to Flow Rate requested by "..progName.." GUI in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
  1658.         --Increase rod level by amount
  1659.         newTurbineFlowRate = turbineFlowRate + flowRateAdjustAmount
  1660.         if newTurbineFlowRate > 2000 then
  1661.             newTurbineFlowRate = 2000
  1662.         end
  1663.         sideClick, xClick, yClick = 0, 0, 0
  1664.  
  1665.         -- Check bounds [0,2000]
  1666.         if newTurbineFlowRate > 2000 then
  1667.             newTurbineFlowRate = 2000
  1668.         elseif newTurbineFlowRate < 0 then
  1669.             newTurbineFlowRate = 25 -- Don't go to zero, might as well power off
  1670.         end
  1671.  
  1672.         turbine.setFluidFlowRateMax(newTurbineFlowRate)
  1673.        
  1674.         -- Save updated Turbine Flow Rate
  1675.         turbineFlowRate = math.ceil(newTurbineFlowRate)
  1676.         _G[turbineNames[turbineIndex]]["TurbineOptions"]["LastFlow"] = turbineFlowRate
  1677.         config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
  1678.     else
  1679.         printLog("No change to Flow Rate requested by "..progName.." GUI in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
  1680.     end -- if (xClick == 29) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
  1681.  
  1682.     if (xClick == 22) and (yClick == 6) and (sideClick == monitorNames[monitorIndex]) then
  1683.         printLog("Decrease to Turbine RPM requested by "..progName.." GUI in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
  1684.         rpmRateAdjustment = 909
  1685.         newTurbineBaseSpeed = turbineBaseSpeed - rpmRateAdjustment
  1686.         if newTurbineBaseSpeed < 908 then
  1687.             newTurbineBaseSpeed = 908
  1688.         end
  1689.         sideClick, xClick, yClick = 0, 0, 0
  1690.         _G[turbineNames[turbineIndex]]["TurbineOptions"]["BaseSpeed"] = newTurbineBaseSpeed
  1691.         config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
  1692.     elseif (xClick == 29) and (yClick == 6) and (sideClick == monitorNames[monitorIndex]) then
  1693.         printLog("Increase to Turbine RPM requested by "..progName.." GUI in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
  1694.         rpmRateAdjustment = 909
  1695.         newTurbineBaseSpeed = turbineBaseSpeed + rpmRateAdjustment
  1696.         if newTurbineBaseSpeed > 2726 then
  1697.             newTurbineBaseSpeed = 2726
  1698.         end
  1699.         sideClick, xClick, yClick = 0, 0, 0
  1700.         _G[turbineNames[turbineIndex]]["TurbineOptions"]["BaseSpeed"] = newTurbineBaseSpeed
  1701.         config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
  1702.     else
  1703.         printLog("No change to Turbine RPM requested by "..progName.." GUI in displayTurbineBars(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
  1704.     end -- if (xClick == 29) and (yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
  1705.     print{"  mB/t",22,3,monitorIndex}
  1706.     print{"<      >",22,4,monitorIndex}
  1707.     print{stringTrim(turbineFlowRate),24,4,monitorIndex}
  1708.     print{"  RPM",22,5,monitorIndex}
  1709.     print{"<      >",22,6,monitorIndex}
  1710.     print{stringTrim(tonumber(_G[turbineNames[turbineIndex]]["TurbineOptions"]["BaseSpeed"])),24,6,monitorIndex}
  1711.     local rotorSpeedString = "Speed: "
  1712.     local energyBufferString = "Energy: "
  1713.     local padding = math.max(string.len(rotorSpeedString), string.len(energyBufferString))
  1714.  
  1715.     local energyBuffer = turbine.getEnergyProducedLastTick()
  1716.     print{energyBufferString,1,4,monitorIndex}
  1717.     print{math.ceil(energyBuffer).." RF/t",padding+1,4,monitorIndex}
  1718.  
  1719.     local rotorSpeed = math.ceil(turbine.getRotorSpeed())
  1720.     print{rotorSpeedString,1,5,monitorIndex}
  1721.     print{rotorSpeed.." RPM",padding+1,5,monitorIndex}
  1722.  
  1723.     -- PaintUtils only outputs to term., not monitor.
  1724.     -- See http://www.computercraft.info/forums2/index.php?/topic/15540-paintutils-on-a-monitor/
  1725.  
  1726.     -- Draw stored energy buffer bar
  1727.     drawBar(1,9,28,9,colors.gray,monitorIndex)
  1728.  
  1729.     local curStoredEnergyPercent = getTurbineStoredEnergyBufferPercent(turbine)
  1730.     if curStoredEnergyPercent > 4 then
  1731.         drawBar(1, 9, math.floor(26*curStoredEnergyPercent/100)+2, 9, colors.yellow,monitorIndex)
  1732.     elseif curStoredEnergyPercent > 0 then
  1733.         drawPixel(1, 9, colors.yellow, monitorIndex)
  1734.     end -- if curStoredEnergyPercent > 4 then
  1735.  
  1736.     print{"Energy Buffer",1,8,monitorIndex}
  1737.     print{curStoredEnergyPercent, width-(string.len(curStoredEnergyPercent)+2),8,monitorIndex}
  1738.     print{"%",28,8,monitorIndex}
  1739.  
  1740.     -- Print rod override status
  1741.     local turbineFlowRateOverrideStatus = ""
  1742.  
  1743.     print{"Flow Auto-adjust:",2,10,monitorIndex}
  1744.  
  1745.     if ((not _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"]) or (_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] == "false")) then
  1746.         turbineFlowRateOverrideStatus = "Enabled"
  1747.         monitor.setTextColor(colors.green)
  1748.     else
  1749.         turbineFlowRateOverrideStatus = "Disabled"
  1750.         monitor.setTextColor(colors.red)
  1751.     end -- if not reactorRodOverride then
  1752.  
  1753.     print{turbineFlowRateOverrideStatus, width - string.len(turbineFlowRateOverrideStatus) - 1, 10, monitorIndex}
  1754.     monitor.setTextColor(colors.white)
  1755.  
  1756.     monitor.setTextColor(colors.blue)
  1757.     printCentered(_G[turbineNames[turbineIndex]]["TurbineOptions"]["turbineName"],12,monitorIndex)
  1758.     monitor.setTextColor(colors.white)
  1759.  
  1760.     -- Need equation to figure out rotor efficiency and display
  1761. end -- function displayTurbineBars(statusParams)
  1762.  
  1763.  
  1764. -- Display turbine status
  1765. local function turbineStatus(turbineIndex, monitorIndex)
  1766.     -- Grab current monitor
  1767.     local monitor = nil
  1768.  
  1769.     printLog("Called as turbineStatus(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..").")
  1770.  
  1771.     monitor = monitorList[monitorIndex]
  1772.     if not monitor then
  1773.         printLog("monitor["..monitorIndex.."] in turbineStatus(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is NOT a valid monitor.")
  1774.         return -- Invalid monitorIndex
  1775.     end
  1776.  
  1777.     -- Grab current turbine
  1778.     local turbine = nil
  1779.     turbine = turbineList[turbineIndex]
  1780.     if not turbine then
  1781.         printLog("turbine["..turbineIndex.."] in turbineStatus(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is NOT a valid Big Turbine.")
  1782.         return -- Invalid turbineIndex
  1783.     else
  1784.         printLog("turbine["..turbineIndex.."] in turbineStatus(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is a valid Big Turbine.")
  1785.     end
  1786.  
  1787.     local width, height = monitor.getSize()
  1788.     local turbineStatus = ""
  1789.  
  1790.     if turbine.getConnected() then
  1791.         printLog("turbine["..turbineIndex.."] in turbineStatus(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is connected.")
  1792.         if turbine.getActive() then
  1793.             turbineStatus = "ONLINE"
  1794.             monitor.setTextColor(colors.green)
  1795.         else
  1796.             turbineStatus = "OFFLINE"
  1797.             monitor.setTextColor(colors.red)
  1798.         end -- if turbine.getActive() then
  1799.  
  1800.         if (xClick >= (width - string.len(turbineStatus) - 1)) and (xClick <= (width-1)) and (sideClick == monitorNames[monitorIndex]) then
  1801.             if yClick == 1 then
  1802.                 turbine.setActive(not turbine.getActive()) -- Toggle turbine status
  1803.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["autoStart"] = turbine.getActive()
  1804.                 config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
  1805.                 sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
  1806.             end -- if yClick == 1 then
  1807.         end -- if (xClick >= (width - string.len(turbineStatus) - 1)) and (xClick <= (width-1)) and (sideClick == monitorNames[monitorIndex]) then
  1808.  
  1809.         -- Allow disabling/enabling flow rate auto-adjust
  1810.         if (xClick > 23 and xClick < 28 and yClick == 4) and (sideClick == monitorNames[monitorIndex]) then
  1811.             _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] = true
  1812.             sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
  1813.         elseif (xClick > 20 and xClick < 27 and yClick == 10) and (sideClick == monitorNames[monitorIndex]) then
  1814.            
  1815.             if ((_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"]) or (_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] == "true")) then
  1816.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] = false
  1817.             else
  1818.                 _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] = true
  1819.             end
  1820.             sideClick, xClick, yClick = 0, 0, 0 -- Reset click after we register it
  1821.         end
  1822.         config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
  1823.  
  1824.     else
  1825.         printLog("turbine["..turbineIndex.."] in turbineStatus(turbineIndex="..turbineIndex..",monitorIndex="..monitorIndex..") is NOT connected.")
  1826.         turbineStatus = "DISCONNECTED"
  1827.         monitor.setTextColor(colors.red)
  1828.     end -- if turbine.getConnected() then
  1829.  
  1830.     print{turbineStatus, width - string.len(turbineStatus) - 1, 1, monitorIndex}
  1831.     monitor.setTextColor(colors.white)
  1832. end -- function function turbineStatus(turbineIndex, monitorIndex)
  1833.  
  1834.  
  1835. -- Maintain Turbine flow rate at 900 or 1,800 RPM
  1836. local function flowRateControl(turbineIndex)
  1837.     if ((not _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"]) or (_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] == "false")) then
  1838.        
  1839.         printLog("Called as flowRateControl(turbineIndex="..turbineIndex..").")
  1840.  
  1841.         -- Grab current turbine
  1842.         local turbine = nil
  1843.         turbine = turbineList[turbineIndex]
  1844.  
  1845.         -- assign for the duration of this run
  1846.         local lastTurbineSpeed = tonumber(_G[turbineNames[turbineIndex]]["TurbineOptions"]["LastSpeed"])
  1847.         local turbineBaseSpeed = tonumber(_G[turbineNames[turbineIndex]]["TurbineOptions"]["BaseSpeed"])
  1848.  
  1849.         if not turbine then
  1850.             printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is NOT a valid Big Turbine.")
  1851.             return -- Invalid turbineIndex
  1852.         else
  1853.             printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is a valid Big Turbine.")
  1854.  
  1855.             if turbine.getConnected() then
  1856.                 printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is connected.")
  1857.             else
  1858.                 printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is NOT connected.")
  1859.             end -- if turbine.getConnected() then
  1860.         end -- if not turbine then
  1861.  
  1862.         -- No point modifying control rod levels for temperature if the turbine is offline
  1863.         if turbine.getActive() then
  1864.             printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is active.")
  1865.  
  1866.             local flowRate = tonumber(_G[turbineNames[turbineIndex]]["TurbineOptions"]["LastFlow"])
  1867.             local flowRateUserMax = math.ceil(turbine.getFluidFlowRateMax())
  1868.             local rotorSpeed = math.ceil(turbine.getRotorSpeed())
  1869.             local newFlowRate = 0
  1870.  
  1871.             -- Going to control the turbine based on target RPM since changing the target flow rate bypasses this function
  1872.             if (rotorSpeed < turbineBaseSpeed) then
  1873.                 printLog("BELOW COMMANDED SPEED")
  1874.                 if (rotorSpeed > lastTurbineSpeed) then
  1875.                     --we're still increasing, let's let it level off
  1876.                     --also lets the first control pass go by on startup
  1877.                 elseif (rotorSpeed < lastTurbineSpeed) then
  1878.                     --we're decreasing where we should be increasing, do something
  1879.                     if ((lastTurbineSpeed - rotorSpeed) > 100) then
  1880.                         --kick it harder
  1881.                         newFlowRate = 2000
  1882.                         printLog("HARD KICK")
  1883.                     else
  1884.                         --let's adjust based on proximity
  1885.                         flowAdjustment = (turbineBaseSpeed - rotorSpeed)/5
  1886.                         newFlowRate = flowRate + flowAdjustment
  1887.                         printLog("Light Kick: new flow rate is "..newFlowRate.." mB/t and flowAdjustment was "..flowAdjustment.." EOL")
  1888.                     end
  1889.                 else
  1890.                     --we've stagnated, kick it.
  1891.                     flowAdjustment = (turbineBaseSpeed - lastTurbineSpeed)
  1892.                     newFlowRate = flowRate + flowAdjustment
  1893.                     printLog("Stagnated: new flow rate is "..newFlowRate.." mB/t and flowAdjustment was "..flowAdjustment.." EOL")
  1894.                 end --if (rotorSpeed > lastTurbineSpeed) then
  1895.             else
  1896.                 --we're above commanded turbine speed
  1897.                 printLog("ABOVE COMMANDED SPEED")
  1898.                 if (rotorSpeed < lastTurbineSpeed) then
  1899.                 --we're decreasing, let it level off
  1900.                 --also bypasses first control pass on startup
  1901.                 elseif (rotorSpeed > lastTurbineSpeed) then
  1902.                     --we're above and ascending.
  1903.                     if ((rotorSpeed - lastTurbineSpeed) > 100) then
  1904.                         --halt
  1905.                         newFlowRate = 25
  1906.                     else
  1907.                         --let's adjust based on proximity
  1908.                         flowAdjustment = (rotorSpeed - turbineBaseSpeed)/5
  1909.                         newFlowRate = flowRate - flowAdjustment
  1910.                         printLog("Light Kick: new flow rate is "..newFlowRate.." mB/t and flowAdjustment was "..flowAdjustment.." EOL")
  1911.                     end
  1912.                 else
  1913.                     --we've stagnated, kick it.
  1914.                     flowAdjustment = (lastTurbineSpeed - turbineBaseSpeed)
  1915.                     newFlowRate = flowRate - flowAdjustment
  1916.                     printLog("Stagnated: new flow rate is "..newFlowRate.." mB/t and flowAdjustment was "..flowAdjustment.." EOL")
  1917.                 end --if (rotorSpeed < lastTurbineSpeed) then
  1918.             end --if (rotorSpeed < turbineBaseSpeed)
  1919.  
  1920.             --check to make sure an adjustment was made
  1921.             if (newFlowRate == 0) then
  1922.                 --do nothing, we didn't ask for anything this pass
  1923.             else
  1924.                 --boundary check
  1925.                 if newFlowRate > 2000 then
  1926.                     newFlowRate = 2000
  1927.                 elseif newFlowRate < 25 then
  1928.                     newFlowRate = 25 -- Don't go to zero, might as well power off
  1929.                 end -- if newFlowRate > 2000 then
  1930.                 --no sense running an adjustment if it's not necessary
  1931.                 if ((newFlowRate < flowRate) or (newFlowRate > flowRate)) then
  1932.                     printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is being commanded to "..newFlowRate.." mB/t flow")
  1933.                     newFlowRate = round(newFlowRate, 0)
  1934.                     turbine.setFluidFlowRateMax(newFlowRate)
  1935.                     _G[turbineNames[turbineIndex]]["TurbineOptions"]["LastFlow"] = newFlowRate
  1936.                     config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
  1937.                 end
  1938.             end
  1939.             --always set this
  1940.             _G[turbineNames[turbineIndex]]["TurbineOptions"]["LastSpeed"] = rotorSpeed
  1941.             config.save(turbineNames[turbineIndex]..".options", _G[turbineNames[turbineIndex]])
  1942.         else
  1943.             printLog("turbine["..turbineIndex.."] in flowRateControl(turbineIndex="..turbineIndex..") is NOT active.")
  1944.         end -- if turbine.getActive() then
  1945.     else
  1946.         printLog("turbine["..turbineIndex.."] has flow override set to "..tostring(_G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"])..", bypassing flow control.")
  1947.     end -- if not _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] then
  1948. end -- function flowRateControl(turbineIndex)
  1949.  
  1950.  
  1951. function main()
  1952.     -- Load reactor parameters and initialize systems
  1953.     loadReactorOptions()
  1954.  
  1955.     -- Get our initial list of connected monitors and reactors
  1956.     -- and initialize every cycle in case the connected devices change
  1957.     findMonitors()
  1958.     findReactors()
  1959.     findTurbines()
  1960.  
  1961.     while not finished do
  1962.         local reactor = nil
  1963.         local monitorIndex = 1
  1964.  
  1965.         -- For multiple reactors/monitors, monitor #1 is reserved for overall status
  1966.         -- or for multiple reactors/turbines and only one monitor
  1967.         if ( ( ((#reactorList + #turbineList) > 1) and (#monitorList >= 1) )   or
  1968.              ( ((#reactorList + #turbineList) >=1) and (#monitorList >  1) ) ) then
  1969.             local monitor = nil
  1970.             monitor = monitorList[monitorIndex]
  1971.             if not monitor then
  1972.                 printLog("monitor["..monitorIndex.."] in main() is NOT a valid monitor.")
  1973.                 return -- Invalid monitorIndex
  1974.             end
  1975.  
  1976.             clearMonitor(progName.." "..progVer, monitorIndex) -- Clear monitor and draw borders
  1977.             printCentered(progName.." "..progVer, 1, monitorIndex)
  1978.             displayAllStatus()
  1979.             monitorIndex = 2 -- Next monitor, #1 is reserved for overall status
  1980.         end
  1981.  
  1982.         -- Iterate through reactors, continue to run even if not enough monitors are connected
  1983.         for reactorIndex = 1, #reactorList do
  1984.             local monitor = nil
  1985.             local reactorMonitorIndex = monitorIndex + reactorIndex - 1 -- reactorIndex starts at 1
  1986.  
  1987.             printLog("Attempting to display reactor["..reactorIndex.."] on monitor["..reactorMonitorIndex.."]...")
  1988.  
  1989.             reactor = reactorList[reactorIndex]
  1990.             if not reactor then
  1991.                 printLog("reactor["..reactorIndex.."] in main() is NOT a valid Big Reactor.")
  1992.                 break -- Invalid reactorIndex
  1993.             else
  1994.                 printLog("reactor["..reactorIndex.."] in main() is a valid Big Reactor.")
  1995.             end --  if not reactor then
  1996.  
  1997.             -- Only attempt to assign a monitor if we have a monitor for this reactor
  1998.             if (reactorMonitorIndex <= #monitorList) then
  1999.                 printLog("Displaying reactor["..reactorIndex.."] on monitor["..reactorMonitorIndex.."].")
  2000.                 monitor = monitorList[reactorMonitorIndex]
  2001.  
  2002.                 if not monitor then
  2003.                     printLog("monitor["..reactorMonitorIndex.."] in main() is NOT a valid monitor.")
  2004.                 else
  2005.                     clearMonitor(progName, reactorMonitorIndex) -- Clear monitor and draw borders
  2006.                     printCentered(progName, 1, reactorMonitorIndex)
  2007.  
  2008.                     -- Display reactor status, includes "Disconnected" but found reactors
  2009.                     reactorStatus{reactorIndex, reactorMonitorIndex}
  2010.  
  2011.                     -- Draw the borders and bars for the current reactor on the current monitor
  2012.                     displayReactorBars{reactorIndex, reactorMonitorIndex}
  2013.                 end -- if not monitor
  2014.             else
  2015.                 printLog("You may want "..(#reactorList + #turbineList + 1).." monitors for your "..#reactorList.." connected reactors and "..#turbineList.." connected turbines.")
  2016.             end -- if (#monitorList ~= 1) and (reactorMonitorIndex < #monitorList) then
  2017.  
  2018.             if reactor.getConnected() then
  2019.                 printLog("reactor["..reactorIndex.."] is connected.")
  2020.                 local curStoredEnergyPercent = getReactorStoredEnergyBufferPercent(reactor)
  2021.  
  2022.                 -- Shutdown reactor if current stored energy % is >= desired level, otherwise activate
  2023.                 -- First pass will have curStoredEnergyPercent=0 until displayBars() is run once
  2024.                 if curStoredEnergyPercent >= maxStoredEnergyPercent then
  2025.                     reactor.setActive(false)
  2026.                 -- Do not auto-start the reactor if it was manually powered off (autoStart=false)
  2027.                 elseif (curStoredEnergyPercent <= minStoredEnergyPercent) and (_G[reactorNames[reactorIndex]]["ReactorOptions"]["autoStart"] == true) then
  2028.                     reactor.setActive(true)
  2029.                 end -- if curStoredEnergyPercent >= maxStoredEnergyPercent then
  2030.  
  2031.                 -- Don't try to auto-adjust control rods if manual control is requested
  2032.                 if not _G[reactorNames[reactorIndex]]["ReactorOptions"]["rodOverride"] then
  2033.                     temperatureControl(reactorIndex)
  2034.                 end -- if not reactorRodOverride then
  2035.             else
  2036.                 printLog("reactor["..reactorIndex.."] is NOT connected.")
  2037.             end -- if reactor.getConnected() then
  2038.         end -- for reactorIndex = 1, #reactorList do
  2039.  
  2040.         -- Monitors for turbines start after turbineMonitorOffset
  2041.         for turbineIndex = 1, #turbineList do
  2042.             local monitor = nil
  2043.             local turbineMonitorIndex = turbineIndex + turbineMonitorOffset
  2044.  
  2045.             printLog("Attempting to display turbine["..turbineIndex.."] on monitor["..turbineMonitorIndex.."]...")
  2046.  
  2047.             -- Only attempt to assign a monitor if we found a monitor for this turbine
  2048.             if (turbineMonitorIndex <= #monitorList) then
  2049.                 printLog("Displaying turbine["..turbineIndex.."] on monitor["..turbineMonitorIndex.."].")
  2050.                 monitor = monitorList[turbineMonitorIndex]
  2051.                 if not monitor then
  2052.                     printLog("monitor["..turbineMonitorIndex.."] in main() is NOT a valid monitor.")
  2053.                 else
  2054.                     clearMonitor(progName, turbineMonitorIndex) -- Clear monitor and draw borders
  2055.                     printCentered(progName, 1, turbineMonitorIndex)
  2056.  
  2057.                     -- Display turbine status, includes "Disconnected" but found turbines
  2058.                     turbineStatus(turbineIndex, turbineMonitorIndex)
  2059.  
  2060.                     -- Draw the borders and bars for the current turbine on the current monitor
  2061.                     displayTurbineBars(turbineIndex, turbineMonitorIndex)
  2062.                 end -- if not monitor
  2063.             else
  2064.                 printLog("You may want "..(#reactorList + #turbineList + 1).." monitors for your "..#reactorList.." connected reactors and "..#turbineList.." connected turbines.")
  2065.             end -- if (#monitorList ~= 1) and (turbineMonitorIndex < #monitorList) then
  2066.  
  2067.             turbine = turbineList[turbineIndex]
  2068.             if not turbine then
  2069.                 printLog("turbine["..turbineIndex.."] in main() is NOT a valid Big Turbine.")
  2070.                 break -- Invalid turbineIndex
  2071.             else
  2072.                 printLog("turbine["..turbineIndex.."] in main() is a valid Big Turbine.")
  2073.             end -- if not turbine then
  2074.  
  2075.             if turbine.getConnected() then
  2076.                 printLog("turbine["..turbineIndex.."] is connected.")
  2077.  
  2078.                 if not _G[turbineNames[turbineIndex]]["TurbineOptions"]["flowOverride"] then
  2079.                     flowRateControl(turbineIndex)
  2080.                 end -- if not turbineFlowRateOverride[turbineIndex] then
  2081.             else
  2082.                 printLog("turbine["..turbineIndex.."] is NOT connected.")
  2083.             end -- if turbine.getConnected() then
  2084.         end -- for reactorIndex = 1, #reactorList do
  2085.  
  2086.         sleep(loopTime) -- Sleep
  2087.         saveReactorOptions()
  2088.     end -- while not finished do
  2089. end -- main()
  2090.  
  2091.  
  2092. local function eventHandler()
  2093.     while not finished do
  2094.         -- http://computercraft.info/wiki/Os.pullEvent
  2095.         -- http://www.computercraft.info/forums2/index.php?/topic/1516-ospullevent-what-is-it-and-how-is-it-useful/
  2096.         event, arg1, arg2, arg3 = os.pullEvent()
  2097.  
  2098.         if event == "monitor_touch" then
  2099.             sideClick, xClick, yClick = arg1, math.floor(arg2), math.floor(arg3)
  2100.             printLog("Side: "..arg1.." Monitor touch X: "..xClick.." Y: "..yClick)
  2101.         elseif event == "char" and not inManualMode then
  2102.             local ch = string.lower(arg1)
  2103.             if ch == "q" then
  2104.                 finished = true
  2105.             elseif ch == "r" then
  2106.                 finished = true
  2107.                 os.reboot()
  2108.             end -- if ch == "q" then
  2109.         end -- if event == "monitor_touch" then
  2110.     end -- while not finished do
  2111. end -- function eventHandler()
  2112.  
  2113.  
  2114. while not finished do
  2115.     parallel.waitForAny(eventHandler, main)
  2116.     sleep(loopTime)
  2117. end -- while not finished do
  2118.  
  2119.  
  2120. -- Clear up after an exit
  2121. term.clear()
  2122. term.setCursorPos(1,1)
Advertisement
Add Comment
Please, Sign In to add comment