View difference between Paste ID: HyQVxnAC and NY6MU58s

--- pay attention to the fact that things return error now instead of origin values
+
--- especially on reassembling on restart of server and things of the sort
+
 -- **             Reactor Madness Program              ** --
 -- **                 for Big Reactor                  ** --
 -- **                Written by krakaen                ** --
 -- **                  Video Tutorial                  ** --
 -- ** 	https://www.youtube.com/watch?v=SbbT7ncyS2M    ** --
 -- ****************************************************** --
 -- ****************************************************** --
 
 -- ******** Version 0.1 Changelog (02/16/2016) ********
 -- Changed currentRFTotal to 1 (makes power show at start)
 
 -- ******** Version 0.2 Changelog (02/16/2016) ********
 -- Added fuel usage (mb/t)
--- ******** Version 0.1 Changelog (02/16/2016) ********
+
 -- Added function comma_value
 -- Added function format_num
--- ******** Version 0.2 Changelog (02/16/2016) ********
+
 -- ******** Version 0.3 Changelog (02/17/2016) ********
 -- Change Rod looking for 0 instead of 1
 
 
 local monitors = {peripheral.find("monitor")}
--- ******** Version 0.3 Changelog (02/17/2016) ********
+local mon = monitors[1]
 local reactors = {peripheral.find("BigReactors-Reactor")}
 
--- ******** Version 0.4 Changelog (10/18/2016) ********
+local button={}
--- Change rodLevel to do a Math.ceil instead of Math.floor
+
 local boxes = {}
--- ******** Version 0.5 Changelog (03/01/2017) ********
+
--- Change drawBoxed and drawFilledBox for drawLines with for loop
+
--- to get compatibility with 1.60+
+
 local refresh = true
--- ******** Version 0.6 Changelog (03/22/2017) ********
+
--- Added Custom error handling
+
--- fixed typo in controlsSize for controlsSize
+local contorlsSize = {}
 local numbersSize = {}
--- ******** Version 0.7 Changelog (05/15/2018) ********
+
--- Added new functions for extreme reactor handling. Will work on both new and old versions
+
 local currentFuelConsumedLastTick = 0.00001
--- ******** Version 0.8 Changelog (31/10/2020) ********
+
--- Added new functions for Bigger reactor handling. Will work on both new, newer and old versions
+
 local rfPerTickMax = 1
--- ******** Version 0.9 Changelog (24/04/2021) ********
+
--- Added new functions for newer Bigger reactor handling. Will work on both new, newer and old versions.
+
 local currentRodLevel = 1
--- ******** Version 0.10 Changelog (19/09/2021) ********
+
--- Added fix to calculate size of power tank on Extreme Reactor and fixed the total RB decimal issue.
+-- you need to give the index to be able to use the program
 -- ex : NameOfProgram Index   (reactor Krakaen)
--- you need to give the index to be able to use the program
+
--- ex : NameOfProgram Index   (reactor Krakaen)
+
 local index = ""
 
 if (#args == 0) then
-local button = {}
+	error("No index Given")
 end
 
 if (#args == 1) then
 	index = args[1]
 end
 
 -- use the black thingy sponge to clear the chalkboard
 
-local controlsSize = {}
+
 mon.clear()
 mon.setTextColor(colors.white)
 mon.setBackgroundColor(colors.black)
 
 function clearTable()
 	button = {}
 end
-local rfTotalMax = 10000000
+
 -- All the things that make my buttons work
 
 function setButton(name, title, func, xmin, ymin, xmax, ymax, elem, elem2, color)
 	button[name] = {}
 	button[name]["title"] = title
   	button[name]["func"] = func
-local reactors = {}
+
-local monitors = {}
+
    	button[name]["ymin"] = ymin
-local VERSION = "NONE"
+
    	button[name]["ymax"] = ymax
-function checkVersionTooOld()
+
-	local uselessMonitors = {peripheral.find("monitor")}
+
    	button[name]["elem2"] = elem2
 end
-function checkMBFunctionAvailability()
+
-	local uselessMbConnected = reactors[1].mbIsConnected()
+
-	local uselessMbAssembled = reactors[1].mbIsAssembled()
+
 function fill(text, color, bData)
    mon.setBackgroundColor(color)
-function checkEnergyCapacityFunction()
+
-	local uselessEnergyCapacity = reactors[1].getEnergyStats().energyCapacity
+
    local xspot = math.floor((bData["xmax"] - bData["xmin"] - string.len(bData["title"])) /2) +1
    for j = bData["ymin"], bData["ymax"] do
--- VERSIONS - BIG, EXTREME, BIGGERv1, BIGGERv2
+
-function initReactor()
+
-	if pcall(checkVersionTooOld) then
+
-		monitors = {peripheral.find("monitor")}
+
                mon.write(bData["title"])
-		-- allow 5 seconds to detect if the reactor is on the network
+
-		print("Detecting reactor. This may take up to 5 seconds.")
+
-		local looptyloop = 0
+
-		while looptyloop ~= 5 do
+
-			if peripheral.find("BigReactors-Reactor") ~= nil then
+
-				reactors = {peripheral.find("BigReactors-Reactor")}
+
-				if pcall(checkEnergyCapacityFunction) then
+
-					rfTotalMax = reactors[1].getEnergyStats().energyCapacity
+
-				end
+
-				if pcall(checkMBFunctionAvailability) then
+
-					VERSION = "EXTREME"
+
-				else
+
-					VERSION = "BIG"
+
-				end
+
-				break
+
-			elseif peripheral.find("bigger-reactor") ~= nil then
+
-				reactors = {peripheral.find("bigger-reactor")}
+
-				VERSION = "BIGGERv1"
+
-				break
+
-			elseif peripheral.find("BiggerReactors_Reactor") ~= nil then
+
-				reactors = {peripheral.find("BiggerReactors_Reactor")}
+
-				VERSION = "BIGGERv2"
+
-				rfTotalMax = reactors[1].battery().capacity()
+
-				break
+
-			end
+
 
-			sleep(1)
+
-			looptyloop = looptyloop + 1
+
 	screen()
 end
-		if monitors[1] == nil then
+
-			error("The Monitor is not being detected, make sure the connections(modem) are activated", 0)
+
 
 function checkxy(x, y)
-		if reactors[1] == nil then
+
-			error("The Reactor is not being detected, make sure the connections(modem) are activated. The problem could also be related to chunk protection on some public servers, ask an admin about it.", 0)
+
          if x>=data["xmin"] and x<= data["xmax"] then
             data["func"](data["elem"], data["elem2"])
-		error("The version of ComputerCraft is too old to use this program, sorry", 0)
+
             return true
-	print("Reactor detected. Program Starting.")
+
             --print(name)
          end
       end
-	error("No index Given, Make sure to start the 'start' program and not the 'reactor' program", 0)
+
    return false
 end
 
 -- Don't question my code, it works on my machine...
 
 function label(w, h, text)
-initReactor() -- Init and Verify that everything is okay to start the program
+
    mon.write(text)
-local mon = monitors[1]
+
 
--- Use the black thingy sponge to clear the chalkboard
+
 
 function draw()
 
 	for key,value in pairs(filleds) do
 		paintutils.drawFilledBox(value[1] , value[2], value[3], value[4], value[5])
 	end
 
 	for key,value in pairs(boxes) do
 		paintutils.drawBox(value[1] , value[2], value[3], value[4], value[5])
 	end
 
 	for key,value in pairs(lines) do
 		paintutils.drawLine(value[1] , value[2], value[3], value[4], value[5])
 	end
 
 	for key,value in pairs(texts) do
 		mon.setCursorPos(value[1], value[2])
 		mon.setTextColor(value[4])
 		mon.setBackgroundColor(value[5])
 		mon.write(value[3])
 	end
 	screen()
 	resetDraw()
 end
 
 -- Resets the elements to draw to only draw the neccessity
 
 function resetDraw()
 	filleds = {}
 	boxes = {}
 	lines = {}
 	texts = {}
 end
 
 -- Handles all the clicks for the buttons
 
 function clickEvent()
 	local myEvent={os.pullEvent("monitor_touch")}
 	checkxy(myEvent[3], myEvent[4])
 end
 
 -- Power up the reactor (M&N are a good source of food right?)
 
 function powerUp(m,n)
 	local reactor = reactors[1]
 	reactor.setActive(true)
 end
 
 -- Power down the reactor (M&N are a good source of food right?)
 
 function powerDown(m,n)
 	local reactor = reactors[1]
 	reactor.setActive(false)
 end
 
 -- Handles and calculate the Min and Max of the power limitation
 
 function modifyRods(limit, number)
 	local tempLevel = 0
 
 	if limit == "min" then
 		tempLevel = minPowerRod + number
 		if tempLevel <= 0 then
 			minPowerRod = 0
 		end
 
 		if tempLevel >= maxPowerRod then
 			minPowerRod = maxPowerRod -10
 		end
 
 		if tempLevel < maxPowerRod and tempLevel > 0 then
 			minPowerRod = tempLevel
 		end
 	else
 		tempLevel = maxPowerRod + number
 		if tempLevel <= minPowerRod then
 			maxPowerRod = minPowerRod +10
 		end
 
 		if tempLevel >= 100 then
 			maxPowerRod = 100
 		end
 
 		if tempLevel > minPowerRod and tempLevel < 100 then
 			maxPowerRod = tempLevel
 		end
 	end
 
 	table.insert(lines, {contorlsSize['inX'], contorlsSize['inY'] +(contorlsSize['sectionHeight']*1)+4, contorlsSize['inX'] + contorlsSize['width'], contorlsSize['inY']+(contorlsSize['sectionHeight']*1)+4, colors.black})
 
 	table.insert(texts, {contorlsSize['inX']+5, contorlsSize['inY'] +(contorlsSize['sectionHeight']*1)+4, minPowerRod .. '%', colors.lightBlue, colors.black})
 	table.insert(texts, {contorlsSize['inX']+13, contorlsSize['inY'] +(contorlsSize['sectionHeight']*1)+4, '--', colors.white, colors.black})
 	table.insert(texts, {contorlsSize['inX']+20, contorlsSize['inY'] +(contorlsSize['sectionHeight']*1)+4, maxPowerRod .. '%', colors.purple, colors.black})
 
 	setInfoToFile()
 	adjustRodsLevel()
 end
 
-		local counter = 1
+
-		for i=value[2],value[4],1 do
+
-			paintutils.drawLine(value[1] , value[2]+counter, value[3], value[2]+counter, value[5])
+
-			counter = counter + 1
+
 	local rfTotalMax = 10000000
 	local currentRfTotal = reactor.getEnergyStored()
 
 	differenceMinMax = maxPowerRod - minPowerRod
-		paintutils.drawLine(value[1] , value[2], value[1], value[4], value[5])
+
-		paintutils.drawLine(value[1] , value[2], value[3], value[2], value[5])
+
-		paintutils.drawLine(value[1] , value[4], value[3], value[4], value[5])
+
-		paintutils.drawLine(value[3] , value[2], value[3], value[4], value[5])
+
 	if currentRfTotal >= maxPower then
 		currentRfTotal = maxPower
 	end
 
 	if currentRfTotal <= minPower then
 		currentRfTotal = minPower
 	end
 
 	currentRfTotal = currentRfTotal - (rfTotalMax/100) * minPowerRod
 
 	local rfInBetween = (rfTotalMax/100) * differenceMinMax
 	local rodLevel = math.floor((currentRfTotal/rfInBetween)*100)
 
 	reactor.setAllControlRodLevels(rodLevel)
 end
 
 -- Creates the frame and the basic of the visual
 -- Also adds the variables informations for placement of stuff and things
 
 function addDrawBoxesSingleReactor()
 	local w, h = mon.getSize()
 	local margin = math.floor((w/100)*2)
 
 	infosSize['startX'] = margin + 1
 	infosSize['startY'] =  margin + 1
 	infosSize['endX'] = (((w-(margin*2))/3)*2)-margin
 	infosSize['endY'] = h - margin
 	infosSize['height'] = infosSize['endY']-infosSize['startY']-(margin*2)-2
 	infosSize['width'] = infosSize['endX']-infosSize['startX']-(margin*2)-2
 	infosSize['inX'] = infosSize['startX'] + margin +1
 	infosSize['inY'] = infosSize['startY'] + margin +1
 	infosSize['sectionHeight'] = math.floor(infosSize['height']/3)
 
 	table.insert(boxes, {infosSize['startX'] , infosSize['startY'], infosSize['endX'], infosSize['endY'], colors.gray})
 	local name = "INFOS"
 	table.insert(lines, {infosSize['startX'] + margin , infosSize['startY'], infosSize['startX'] + (margin*2) + #name+1, infosSize['startY'], colors.black})
 	table.insert(texts, {infosSize['startX'] + (margin*2), infosSize['startY'], name, colors.white, colors.black})
 
 	local names = {}
 	names[1] = 'ENERGY LAST TICK'
 	names[2] = 'ENERGY STORED'
 	names[3] = 'CONTROL ROD LEVEL'
 
 	for i=0,2,1 do
 		table.insert(texts, {infosSize['inX'] + margin, infosSize['inY'] + (infosSize['sectionHeight']*i) +i, names[i+1], colors.white, colors.black})
 		table.insert(filleds, {infosSize['inX'] , infosSize['inY'] + 2 + (infosSize['sectionHeight']*i) +i, infosSize['inX'] + infosSize['width'], infosSize['inY'] + (infosSize['sectionHeight']*(i+1))-2 +i, colors.lightGray})
 	end
 
 
 	-- Controls
 
 	contorlsSize['startX'] = infosSize['endX'] + margin + 1
 	contorlsSize['startY'] =  margin + 1
 	contorlsSize['endX'] = w-margin
 	contorlsSize['endY'] = (((h - (margin*2))/3)*2) +1
 	contorlsSize['height'] = contorlsSize['endY']-contorlsSize['startY']-(margin)-1
 	contorlsSize['width'] = contorlsSize['endX']-contorlsSize['startX']-(margin*2)-2
 	contorlsSize['inX'] = contorlsSize['startX'] + margin +1
 	contorlsSize['inY'] = contorlsSize['startY'] + margin
 
 	table.insert(boxes, {contorlsSize['startX'] , contorlsSize['startY'], contorlsSize['endX'], contorlsSize['endY'], colors.gray})
 	name = "CONTROLS"
 	table.insert(lines, {contorlsSize['startX'] + margin , contorlsSize['startY'], contorlsSize['startX'] + (margin*2) + #name+1, contorlsSize['startY'], colors.black})
 	table.insert(texts, {contorlsSize['startX'] + (margin*2), contorlsSize['startY'], name, colors.white, colors.black})
 
 	contorlsSize['sectionHeight'] = math.floor(contorlsSize['height']/4)
 
 	reactor = reactors[1]
 
 	mon.setTextColor(colors.white)
 	setButton("ON","ON", powerUp, contorlsSize['inX'], contorlsSize['inY'], contorlsSize['inX'] + math.floor(contorlsSize['width']/2) -1, contorlsSize['inY'] +2, 0, 0, colors.green)
 	setButton("OFF","OFF", powerDown, contorlsSize['inX'] + math.floor(contorlsSize['width']/2) +2, contorlsSize['inY'], contorlsSize['inX'] + contorlsSize['width'], contorlsSize['inY'] +2,0, 0, colors.red)
 
 	table.insert(texts, {contorlsSize['inX']+8, contorlsSize['inY'] +(contorlsSize['sectionHeight']*1)+1, 'AUTO-CONTROL', colors.white, colors.black})
 
 	table.insert(texts, {contorlsSize['inX']+5, contorlsSize['inY'] +(contorlsSize['sectionHeight']*1)+3, 'MIN', colors.lightBlue, colors.black})
 	table.insert(texts, {contorlsSize['inX']+5, contorlsSize['inY'] +(contorlsSize['sectionHeight']*1)+4, minPowerRod..'%', colors.lightBlue, colors.black})
 
 	table.insert(texts, {contorlsSize['inX']+13, contorlsSize['inY'] +(contorlsSize['sectionHeight']*1)+4, '--', colors.white, colors.black})
-	table.insert(lines, {controlsSize['inX'], controlsSize['inY'] +(controlsSize['sectionHeight']*1)+4, controlsSize['inX'] + controlsSize['width'], controlsSize['inY']+(controlsSize['sectionHeight']*1)+4, colors.black})
+	table.insert(texts, {contorlsSize['inX']+20, contorlsSize['inY'] +(contorlsSize['sectionHeight']*1)+3, 'MAX', colors.purple, colors.black})
 	table.insert(texts, {contorlsSize['inX']+20, contorlsSize['inY'] +(contorlsSize['sectionHeight']*1)+4, maxPowerRod..'%', colors.purple, colors.black})
-	table.insert(texts, {controlsSize['inX']+5, controlsSize['inY'] +(controlsSize['sectionHeight']*1)+4, minPowerRod .. '%', colors.lightBlue, colors.black})
+
-	table.insert(texts, {controlsSize['inX']+13, controlsSize['inY'] +(controlsSize['sectionHeight']*1)+4, '--', colors.white, colors.black})
+
-	table.insert(texts, {controlsSize['inX']+20, controlsSize['inY'] +(controlsSize['sectionHeight']*1)+4, maxPowerRod .. '%', colors.purple, colors.black})
+	setButton("low-10","-10", modifyRods, contorlsSize['inX'], contorlsSize['inY'] +(contorlsSize['sectionHeight']*2)+2, contorlsSize['inX'] + math.floor(contorlsSize['width']/2) -1, contorlsSize['inY'] +(contorlsSize['sectionHeight']*2)+4, "min", -10, colors.lightBlue)
 	setButton("high-10","-10", modifyRods, contorlsSize['inX'] + math.floor(contorlsSize['width']/2) +2, contorlsSize['inY'] +(contorlsSize['sectionHeight']*2)+2, contorlsSize['inX'] + contorlsSize['width'], contorlsSize['inY'] +(contorlsSize['sectionHeight']*2)+4, "max", -10, colors.purple)
 
 	setButton("low+10","+10", modifyRods, contorlsSize['inX'], contorlsSize['inY'] +(contorlsSize['sectionHeight']*3)+2, contorlsSize['inX'] + math.floor(contorlsSize['width']/2) -1, contorlsSize['inY'] +(contorlsSize['sectionHeight']*3)+4, "min", 10, colors.lightBlue)
 	setButton("high+10","+10", modifyRods, contorlsSize['inX'] + math.floor(contorlsSize['width']/2) +2, contorlsSize['inY'] +(contorlsSize['sectionHeight']*3)+2, contorlsSize['inX'] + contorlsSize['width'], contorlsSize['inY'] +(contorlsSize['sectionHeight']*3)+4, "max", 10, colors.purple)
 
 	-- Numbers
--- TOMODIFY
+
 	numbersSize['startX'] = infosSize['endX'] + margin + 1
 	numbersSize['startY'] = contorlsSize['endY'] + margin + 1
 	numbersSize['endX'] = w-margin
-	local allStats = getAllStats()
+
-	local currentRfTotal = allStats["rfTotal"]
+
-	local reactorRodsLevel = allStats["reactorRodsLevel"]
+
 	numbersSize['inX'] = numbersSize['startX'] + margin +1
 	numbersSize['inY'] = numbersSize['startY'] + margin
 
 	table.insert(boxes, {numbersSize['startX'] , numbersSize['startY'], numbersSize['endX'], numbersSize['endY'], colors.gray})
 	name = "NUMBERS"
 	table.insert(lines, {numbersSize['startX'] + margin , numbersSize['startY'], numbersSize['startX'] + (margin*2) + #name+1, numbersSize['startY'], colors.black})
 	table.insert(texts, {numbersSize['startX'] + (margin*2), numbersSize['startY'], name, colors.white, colors.black})
 
 	refresh = true
 	while refresh do
 		parallel.waitForAny(refreshSingleReactor,clickEvent)
 	end
 end
 
 -- Makes and Handles the draw function for less lag in the visual
 
 function refreshSingleReactor()
-	local rodLevel = math.ceil((currentRfTotal/rfInBetween)*100)
+
-	if VERSION == "EXTREME" then
+
-		for key,value in pairs(reactorRodsLevel) do
+	local rfTotalMax = 10000000
-			reactorRodsLevel[key] = rodLevel
+
 
-		reactor.setControlRodsLevels(reactorRodsLevel)
+	rfTotal = reactor.getEnergyStored()
 	rfPerTick = math.floor(reactor.getEnergyProducedLastTick())
-		reactor.setAllControlRodLevels(rodLevel)
+	rodLevel = math.floor(reactor.getControlRodLevel(0))
 	fuelPerTick = reactor.getFuelConsumedLastTick();
 
 	local i = 0
 	local infotoAdd = 'RF PER TICK : '
 
 	if currentRfTick ~= rfPerTick then
 		currentRfTick = rfPerTick
 		if rfPerTick > rfPerTickMax then
 			rfPerTickMax = rfPerTick
 		end
 
 		table.insert(lines, {numbersSize['inX'] , numbersSize['inY'],numbersSize['inX'] + numbersSize['width'] , numbersSize['inY'], colors.black})
 		table.insert(texts, {numbersSize['inX'], numbersSize['inY'], infotoAdd .. rfPerTick .. " RF", colors.white, colors.black})
 		table.insert(filleds, {infosSize['inX'] , infosSize['inY'] + 1 + (infosSize['sectionHeight']*i) +i, infosSize['inX'] + infosSize['width'], infosSize['inY'] + (infosSize['sectionHeight']*(i+1))-2 +i, colors.lightGray})
 
 		width = math.floor((infosSize['width'] / rfPerTickMax)*rfPerTick)
 		table.insert(filleds, {infosSize['inX'] , infosSize['inY'] + 1 + (infosSize['sectionHeight']*i) +i, infosSize['inX'] + width, infosSize['inY'] + (infosSize['sectionHeight']*(i+1))-2 +i, colors.green})
 
 	end
 
 	i = 1
 	infotoAdd = 'ENERGY STORED : '
 	if currentRfTotal ~= rfTotal then
 		currentRfTotal = rfTotal
 
 		table.insert(filleds, {infosSize['inX'] , infosSize['inY'] + 1 + (infosSize['sectionHeight']*i) +i, infosSize['inX'] + infosSize['width'], infosSize['inY'] + (infosSize['sectionHeight']*(i+1))-2 +i, colors.lightGray})
 
 		width = math.floor((infosSize['width'] / rfTotalMax)*rfTotal)
 		table.insert(filleds, {infosSize['inX'] , infosSize['inY'] + 1 + (infosSize['sectionHeight']*i) +i, infosSize['inX'] + width, infosSize['inY'] + (infosSize['sectionHeight']*(i+1))-2 +i, colors.green})
 		table.insert(lines, {numbersSize['inX'] , numbersSize['inY'] +2 ,numbersSize['inX'] + numbersSize['width'] , numbersSize['inY'] +2, colors.black})
 		table.insert(texts, {numbersSize['inX'], numbersSize['inY']+ 2 , infotoAdd .. rfTotal .. " RF", colors.white, colors.black})
 	end
 
 	i = 2
 	infotoAdd = 'CONTROL ROD LEVEL : '
 	if currentRodLevel ~= rodLevel then
 		currentRodLevel = rodLevel
 
-	controlsSize['startX'] = infosSize['endX'] + margin + 1
+
-	controlsSize['startY'] =  margin + 1
+
-	controlsSize['endX'] = w-margin
+
-	controlsSize['endY'] = (((h - (margin*2))/3)*2) +1
+
-	controlsSize['height'] = controlsSize['endY']-controlsSize['startY']-(margin)-1
+
-	controlsSize['width'] = controlsSize['endX']-controlsSize['startX']-(margin*2)-2
+		table.insert(texts, {numbersSize['inX'], numbersSize['inY']+ 4 , infotoAdd .. rodLevel .. "%", colors.white, colors.black})
-	controlsSize['inX'] = controlsSize['startX'] + margin +1
+
-	controlsSize['inY'] = controlsSize['startY'] + margin
+
 	i = 3
-	table.insert(boxes, {controlsSize['startX'] , controlsSize['startY'], controlsSize['endX'], controlsSize['endY'], colors.gray})
+
 	if currentFuelConsumedLastTick ~= fuelPerTick then
-	table.insert(lines, {controlsSize['startX'] + margin , controlsSize['startY'], controlsSize['startX'] + (margin*2) + #name+1, controlsSize['startY'], colors.black})
+
-	table.insert(texts, {controlsSize['startX'] + (margin*2), controlsSize['startY'], name, colors.white, colors.black})
+
 		table.insert(lines, {numbersSize['inX'] , numbersSize['inY']+6 ,numbersSize['inX'] + numbersSize['width'] , numbersSize['inY'] +6, colors.black})
-	controlsSize['sectionHeight'] = math.floor(controlsSize['height']/4)
+		table.insert(texts, {numbersSize['inX'], numbersSize['inY']+ 6 , infotoAdd .. format_num(tonumber(fuelPerTick),3) .. "mb/t", colors.white, colors.black})
 	end
 
 	mon.setTextColor(colors.white)
 	adjustRodsLevel()
-	setButton("ON","ON", powerUp, controlsSize['inX'], controlsSize['inY'], controlsSize['inX'] + math.floor(controlsSize['width']/2) -1, controlsSize['inY'] +2, 0, 0, colors.green)
+
-	setButton("OFF","OFF", powerDown, controlsSize['inX'] + math.floor(controlsSize['width']/2) +2, controlsSize['inY'], controlsSize['inX'] + controlsSize['width'], controlsSize['inY'] +2,0, 0, colors.red)
+
 
-	table.insert(texts, {controlsSize['inX']+8, controlsSize['inY'] +(controlsSize['sectionHeight']*1)+1, 'AUTO-CONTROL', colors.white, colors.black})
+
 end
-	table.insert(texts, {controlsSize['inX']+5, controlsSize['inY'] +(controlsSize['sectionHeight']*1)+3, 'MIN', colors.lightBlue, colors.black})
+
-	table.insert(texts, {controlsSize['inX']+5, controlsSize['inY'] +(controlsSize['sectionHeight']*1)+4, minPowerRod..'%', colors.lightBlue, colors.black})
+
 -- ** Get the informations from the index file
-	table.insert(texts, {controlsSize['inX']+13, controlsSize['inY'] +(controlsSize['sectionHeight']*1)+4, '--', colors.white, colors.black})
+
-	table.insert(texts, {controlsSize['inX']+20, controlsSize['inY'] +(controlsSize['sectionHeight']*1)+3, 'MAX', colors.purple, colors.black})
+
-	table.insert(texts, {controlsSize['inX']+20, controlsSize['inY'] +(controlsSize['sectionHeight']*1)+4, maxPowerRod..'%', colors.purple, colors.black})
+
 
 function getInfoFromFile()
-	setButton("low-10","-10", modifyRods, controlsSize['inX'], controlsSize['inY'] +(controlsSize['sectionHeight']*2)+2, controlsSize['inX'] + math.floor(controlsSize['width']/2) -1, controlsSize['inY'] +(controlsSize['sectionHeight']*2)+4, "min", -10, colors.lightBlue)
+
-	setButton("high-10","-10", modifyRods, controlsSize['inX'] + math.floor(controlsSize['width']/2) +2, controlsSize['inY'] +(controlsSize['sectionHeight']*2)+2, controlsSize['inX'] + controlsSize['width'], controlsSize['inY'] +(controlsSize['sectionHeight']*2)+4, "max", -10, colors.purple)
+
 	 	file = io.open(index..".txt","w")
-	setButton("low+10","+10", modifyRods, controlsSize['inX'], controlsSize['inY'] +(controlsSize['sectionHeight']*3)+2, controlsSize['inX'] + math.floor(controlsSize['width']/2) -1, controlsSize['inY'] +(controlsSize['sectionHeight']*3)+4, "min", 10, colors.lightBlue)
+
-	setButton("high+10","+10", modifyRods, controlsSize['inX'] + math.floor(controlsSize['width']/2) +2, controlsSize['inY'] +(controlsSize['sectionHeight']*3)+2, controlsSize['inX'] + controlsSize['width'], controlsSize['inY'] +(controlsSize['sectionHeight']*3)+4, "max", 10, colors.purple)
+
 	    file:write("100")
 	    file:close()
 	else
 		file = fs.open(index..".txt","r")
-	numbersSize['startY'] = controlsSize['endY'] + margin + 1
+
 		maxPowerRod = tonumber(file.readLine())
 	    file.close()
 	end
 end
 
-	numbersSize['inY'] = numbersSize['startY'] + margin
+
 
 function setInfoToFile()
 	file = io.open(index..".txt","w")
 	file:write(minPowerRod .. "\n" .. maxPowerRod)
     file:flush()
     file:close()
 end
 
 ---============================================================
 -- add comma to separate thousands
 -- From Lua-users.org/wiki/FormattingNumbers
 --
--- Gets the stats needed for the program to function based on the version of the reactor
+--
--- TOMODIFY
+
-function getAllStats()
+
-	local stats = {}
+  while true do
     formatted, k = string.gsub(formatted, "^(-?%d+)(%d%d%d)", '%1,%2')
     if (k==0) then
-	if VERSION == "EXTREME" then
+
-		local reactorEnergyStats = reactor.getEnergyStats()
+
-		local reactorFuelStats = reactor.getFuelStats()
+
   return formatted
-		stats["reactorRodsLevel"] = reactor.getControlRodsLevels()
+
-		stats["rfTotal"] = math.floor(reactorEnergyStats["energyStored"])
+
-		stats["rfPerTick"] = math.floor(reactorEnergyStats["energyProducedLastTick"])
+
-		stats["rodLevel"] = stats["reactorRodsLevel"][0]
+
-		stats["fuelPerTick"] = round(reactorFuelStats["fuelConsumedLastTick"], 2)
+
-	elseif VERSION == "BIG" or VERSION == "BIGGERv1" then
+
-		stats["rfTotal"] = math.floor(reactor.getEnergyStored())
+
-		stats["rfPerTick"] = math.floor(reactor.getEnergyProducedLastTick())
+
-		stats["rodLevel"] = math.floor(reactor.getControlRodLevel(0))
+
-		stats["fuelPerTick"] = reactor.getFuelConsumedLastTick()
+
-	elseif VERSION == "BIGGERv2" then
+
-		stats["rfTotal"] = reactor.battery().stored()
+
-		stats["rfPerTick"] = math.floor(reactor.battery().producedLastTick())
+
-		stats["rodLevel"] = math.floor(reactor.getControlRod(0).level())
+
-		stats["fuelPerTick"] = reactor.fuelTank().burnedLastTick()
+
 --===================================================================
 -- given a numeric value formats output with comma to separate thousands
-	return stats
+
 -- From Lua-users.org/wiki/FormattingNumbers
 --
 function format_num(amount, decimal, prefix, neg_prefix)
   local str_amount,  formatted, famount, remain
 
   decimal = decimal or 2  -- default 2 decimal places
   neg_prefix = neg_prefix or "-" -- default negative sign
 
-	local allStats = getAllStats()
+
-	rfTotal = allStats["rfTotal"]
+
-	rfPerTick = allStats["rfPerTick"]
+
-	rodLevel = allStats["rodLevel"]
+
-	fuelPerTick = allStats["fuelPerTick"]
+
         -- comma to separate the thousands
   formatted = comma_value(famount)
 
         -- attach the decimal portion
   if (decimal > 0) then
     remain = string.sub(tostring(remain),3)
     formatted = formatted .. "." .. remain ..
                 string.rep("0", decimal - string.len(remain))
   end
 
         -- attach prefix string e.g '$'
   formatted = (prefix or "") .. formatted
 
         -- if value is negative then format accordingly
   if (amount<0) then
     if (neg_prefix=="()") then
       formatted = "("..formatted ..")"
     else
       formatted = neg_prefix .. formatted
     end
   end
 
   return formatted
 end
 
 -- Clear and make the pixel smaller because we are not blind
 
 mon.setBackgroundColor(colors.black)
 mon.clear()
 mon.setTextScale(0.5)
 
 -- Get the information from the index file
 getInfoFromFile()
 
 
 -- Add's the visual and starts the Loop
 addDrawBoxesSingleReactor()