View difference between Paste ID: 7QVnspVp 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
+
 local VERISON = "NEW"
 
 function checkVersionTooOld()
--- ****************************************************** --
+	local monitorsCheck = {peripheral.find("monitor")}
--- ****************************************************** --
+
--- **             Reactor Madness Program              ** --
+
--- **                 for Big Reactor                  ** --
+function checkVersionNEW()
--- **                Written by krakaen                ** --
+	local reactorsArray = {peripheral.find("BigReactors-Reactor")}
--- **                  Video Tutorial                  ** --
+	reactorsArray[0].getEnergyStats();
--- ** 	https://www.youtube.com/watch?v=SbbT7ncyS2M    ** --
+
--- ****************************************************** --
+
--- ****************************************************** --
+function checkErrors()
 	if pcall(checkVersionTooOld) then
--- ******** Version 0.1 Changelog (02/16/2016) ********
+
--- Changed currentRFTotal to 1 (makes power show at start)
+
 		error("The version of ComputerCraft is too old to use this program, sorry", 0)
--- ******** Version 0.2 Changelog (02/16/2016) ********
+
--- Added fuel usage (mb/t)
+	local monitorsCheck = {peripheral.find("monitor")}
--- Added function round
+	local reactorsCheck = {peripheral.find("BigReactors-Reactor")}
--- Added function comma_value
+
--- Added function format_num
+  if monitorsCheck[1] == nil then
     error("The Monitor is not being detected, make sure the connections(modem) are activated", 0)
--- ******** Version 0.3 Changelog (02/17/2016) ********
+
--- Change Rod looking for 0 instead of 1
+
   if reactorsCheck[1] == nil then
--- ******** Version 0.4 Changelog (10/18/2016) ********
+    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)
--- Change rodLevel to do a Math.ceil instead of Math.floor
+
 
--- ******** Version 0.5 Changelog (03/01/2017) ********
+  if pcall(checkVersionNEW) then
--- Change drawBoxed and drawFilledBox for drawLines with for loop
+	VERISON = "NEW"
--- to get compatibility with 1.60+
+
 	VERISON = "OLD"
--- ******** Version 0.6 Changelog (03/22/2017) ********
+
--- Added Custom error handling
+
--- fixed typo in controlsSize for controlsSize
+
 -- you need to give the index to be able to use the program
--- ******** Version 0.7 Changelog (05/15/2018) ********
+-- ex : Reactor Data
--- Added new functions for extreme reactor handling. Will work on both new and old versions
+
 local args = { ... }
--- ******** Version 0.8 Changelog (31/10/2020) ********
+
--- Added new functions for Bigger reactor handling. Will work on both new, newer and old versions
+
 local filleds = {}
--- ******** 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 texts = {}
--- ******** 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.
+
 
 local infosSize = {}
--- ex : NameOfProgram Index   (reactor Krakaen)
+
 local numbersSize = {}
 local currentRfTotal = 1
 local currentRfTick = 1
 local currentFuelConsumedLastTick = 0.00001
 
 
 local rfPerTickMax = 1
 local minPowerRod = 0
 local maxPowerRod = 100
 local currentRodLevel = 1
 
 local index = ""
 
 checkErrors()
 
 if (#args == 0) then
 	  error("No index Given, Make sure to start the 'start' program and not the 'reactor' program", 0)
 end
 
 if (#args == 1) then
-local rfTotalMax = 10000000
+
 end
 
 local monitors = {peripheral.find("monitor")}
 local mon = monitors[1]
 local reactors = {peripheral.find("BigReactors-Reactor")}
 
-local reactors = {}
+
-local monitors = {}
+
 mon.clear()
-local VERSION = "NONE"
+
 mon.setBackgroundColor(colors.black)
 
-	local uselessMonitors = {peripheral.find("monitor")}
+
 	button = {}
 end
-function checkMBFunctionAvailability()
+
-	local uselessMbConnected = reactors[1].mbIsConnected()
+
-	local uselessMbAssembled = reactors[1].mbIsAssembled()
+
 
 function setButton(name, title, func, xmin, ymin, xmax, ymax, elem, elem2, color)
-function checkEnergyCapacityFunction()
+
-	local uselessEnergyCapacity = reactors[1].getEnergyStats().energyCapacity
+
   	button[name]["func"] = func
    	button[name]["active"] = false
--- VERSIONS - BIG, EXTREME, BIGGERv1, BIGGERv2
+
-function initReactor()
+
    	button[name]["xmax"] = xmax
-		monitors = {peripheral.find("monitor")}
+
    	button[name]["color"] = color
-		-- 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
    mon.setBackgroundColor(colors.black)
-			sleep(1)
+
-			looptyloop = looptyloop + 1
+
 
 function screen()
-		if monitors[1] == nil then
+
-			error("The Monitor is not being detected, make sure the connections(modem) are activated", 0)
+
       local on = data["active"]
       currColor = data["color"]
-		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)
+
 end
 
 
 function flash(name)
-	print("Reactor detected. Program Starting.")
+
 	screen()
 end
 
-	error("No index Given, Make sure to start the 'start' program and not the 'reactor' program", 0)
+
 function checkxy(x, y)
    for name, data in pairs(button) do
       if y>=data["ymin"] and  y <= data["ymax"] then
          if x>=data["xmin"] and x<= data["xmax"] then
             data["func"](data["elem"], data["elem2"])
             flash(data['name'])
-initReactor() -- Init and Verify that everything is okay to start the program
+
             --data["active"] = not data["active"]
             --print(name)
          end
--- Use the black thingy sponge to clear the chalkboard
+
    end
    return false
 end
 
 function label(w, h, text)
    mon.setCursorPos(w, h)
    mon.write(text)
 end
 
 function draw()
 
--- All the things that make my buttons work
+
 		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
 		end
 	end
 
 	for key,value in pairs(boxes) do
 		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])
 	end
 
 	for key,value in pairs(lines) do
--- stuff and things for buttons
+
 	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
 
 
 function resetDraw()
 	filleds = {}
 	boxes = {}
 	lines = {}
 	texts = {}
 end
 
 function clickEvent()
 	local myEvent={os.pullEvent("monitor_touch")}
 	checkxy(myEvent[3], myEvent[4])
 end
 
--- stuff and things for buttons
+
 function powerUp(m,n)
 	local reactor = reactors[1]
 	reactor.setActive(true)
 end
 --M & Ns are a good source of food, right?
 function powerDown(m,n)
 	local reactor = reactors[1]
 	reactor.setActive(false)
 end
 
--- stuff and things for buttons
+
 function modifyRods(limit, number)
 	local tempLevel = 0
 
 	if limit == "min" then
 		tempLevel = minPowerRod + number
--- magical handler for clicky clicks
+
 			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
 
--- Don't question my code, it works on my machine...
+
 			maxPowerRod = 100
 		end
 
 		if tempLevel > minPowerRod and tempLevel < 100 then
 			maxPowerRod = tempLevel
 		end
--- Draw function : put's all the beautiful magic in the screen
+
 
 	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, {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})
 
 	setInfoToFile()
 	adjustRodsLevel()
 end
 
 function adjustRodsLevel()
 	local reactor = reactors[1]
 	local rfTotalMax = 10000000
 
 	local allStats = getAllStats()
 	local currentRfTotal = allStats["rfTotal"]
 	local reactorRodsLevel = allStats["reactorRodsLevel"]
 
 	differenceMinMax = maxPowerRod - minPowerRod
 
 	maxPower = (rfTotalMax/100) * maxPowerRod
 	minPower = (rfTotalMax/100) * minPowerRod
 
 	if currentRfTotal >= maxPower then
 		currentRfTotal = maxPower
 	end
 
 	if currentRfTotal <= minPower then
 		currentRfTotal = minPower
 	end
--- Resets the elements to draw to only draw the neccessity
+
 	currentRfTotal = currentRfTotal - (rfTotalMax/100) * minPowerRod
 
 	local rfInBetween = (rfTotalMax/100) * differenceMinMax
 	local rodLevel = math.ceil((currentRfTotal/rfInBetween)*100)
 
 	if VERSION == "NEW" then
 		if reactor.mbIsConnected() == true and reactor.mbIsAssembled() == true then
 			for key,value in pairs(reactorRodsLevel) do
--- Handles all the clicks for the buttons
+				reactorRodsLevel[key] = rodLevel
 			end
 			reactor.setControlRodsLevels(reactorRodsLevel)
 		end
 	else
 		reactor.setAllControlRodLevels(rodLevel)
 	end
--- Power up the reactor (M&N are a good source of food right?)
+
 
 function addDrawBoxesSingleReactor()
 	local w, h = mon.getSize()
 	local margin = math.floor((w/100)*2)
 
 	infosSize['startX'] = margin + 1
--- Power down the reactor (M&N are a good source of food right?)
+
 	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
--- Handles and calculate the Min and Max of the power limitation
+
 
 	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
 
 
 	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
 	controlsSize['inX'] = controlsSize['startX'] + margin +1
 	controlsSize['inY'] = controlsSize['startY'] + margin
 
 	table.insert(boxes, {controlsSize['startX'] , controlsSize['startY'], controlsSize['endX'], controlsSize['endY'], colors.gray})
 	name = "CONTROLS"
 	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})
 
 	controlsSize['sectionHeight'] = math.floor(controlsSize['height']/4)
 
 	reactor = reactors[1]
 
 	mon.setTextColor(colors.white)
 	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})
 
 	table.insert(texts, {controlsSize['inX']+5, controlsSize['inY'] +(controlsSize['sectionHeight']*1)+3, 'MIN', colors.lightBlue, colors.black})
--- Calculate and adjusts the level of the rods
+
--- TOMODIFY
+
 	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})
 	mon.setTextColor(colors.white)
 
 	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)
 
 	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)
 
 
 	numbersSize['startX'] = infosSize['endX'] + margin + 1
 	numbersSize['startY'] = controlsSize['endY'] + margin + 1
 	numbersSize['endX'] = w-margin
 	numbersSize['endY'] = h-margin
 	numbersSize['height'] = numbersSize['endY']-numbersSize['startY']-(margin)-1
 	numbersSize['width'] = numbersSize['endX']-numbersSize['startX']-(margin*2)-2
 	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})
-	if VERSION == "EXTREME" then
+
-		for key,value in pairs(reactorRodsLevel) do
+
-			reactorRodsLevel[key] = rodLevel
+
 	while refresh do
-		reactor.setControlRodsLevels(reactorRodsLevel)
+
 	end
 end
 
 function getAllStats()
 	local stats = {}
--- Creates the frame and the basic of the visual
+
--- Also adds the variables informations for placement of stuff and things
+
 	if VERSION == "NEW" then
 		if reactor.mbIsConnected() == true and reactor.mbIsAssembled() == true then
 			local reactorEnergyStats = reactor.getEnergyStats()
 			local reactorFuelStats = reactor.getFuelStats()
 			stats["reactorRodsLevel"] = reactor.getControlRodsLevels()
 
 			stats["rfTotal"] = reactorEnergyStats["energyStored"]
 			stats["rfPerTick"] = math.ceil(reactorEnergyStats["energyProducedLastTick"])
 			stats["rodLevel"] = stats["reactorRodsLevel"][0]
 			stats["fuelPerTick"] = round(reactorFuelStats["fuelConsumedLastTick"], 2)
 		end
 	else
 		stats["rfTotal"] = reactor.getEnergyStored()
 		stats["rfPerTick"] = math.floor(reactor.getEnergyProducedLastTick())
 		stats["rodLevel"] = math.floor(reactor.getControlRodLevel(0))
 		stats["fuelPerTick"] = reactor.getFuelConsumedLastTick()
 	end
 
 	return stats
 end
 
 function refreshSingleReactor()
 	local rfPerTick = 0
 	local rfTotal = 0
 	local rfTotalMax = 10000000
 	local reactor = reactors[1]
 
 	local allStats = getAllStats()
 	rfTotal = allStats["rfTotal"]
 	rfPerTick = allStats["rfPerTick"]
 	rodLevel = allStats["rodLevel"]
-	-- Controls
+
 
 	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
 
 		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})
 
-	-- Numbers
+
 		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']+4 ,numbersSize['inX'] + numbersSize['width'] , numbersSize['inY'] +4, colors.black})
 		table.insert(texts, {numbersSize['inX'], numbersSize['inY']+ 4 , infotoAdd .. rodLevel .. "%", colors.white, colors.black})
 	end
 
 	i = 3
 	infotoAdd = 'FUEL USAGE : '
 	if currentFuelConsumedLastTick ~= fuelPerTick then
 		currentFuelConsumedLastTick = fuelPerTick
 
 		table.insert(lines, {numbersSize['inX'] , numbersSize['inY']+6 ,numbersSize['inX'] + numbersSize['width'] , numbersSize['inY'] +6, colors.black})
 		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()
 
 	draw()
 
 	sleep(2)
 end
--- Gets the stats needed for the program to function based on the version of the reactor
+
--- TOMODIFY
+
 function getInfoFromFile()
 
 	 if (fs.exists(index..".txt") == false) then
 	 	file = io.open(index..".txt","w")
-	if VERSION == "EXTREME" then
+
-		local reactorEnergyStats = reactor.getEnergyStats()
+
-		local reactorFuelStats = reactor.getFuelStats()
+
 	    file:close()
-		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())
+
 
 function setInfoToFile()
 	file = io.open(index..".txt","w")
-	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()
+
 function comma_value(amount)
   local formatted = amount
   while true do
     formatted, k = string.gsub(formatted, "^(-?%d+)(%d%d%d)", '%1,%2')
     if (k==0) then
--- Makes and Handles the draw function for less lag in the visual
+
     end
   end
   return formatted
 end
 
 
 function round(val, decimal)
   if (decimal) then
     return math.floor( (val * 10^decimal) + 0.5) / (10^decimal)
   else
     return math.floor(val+0.5)
   end
 end
 
 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
 
   famount = math.abs(round(amount,decimal))
   famount = math.floor(famount)
 
   remain = round(math.abs(amount) - famount, decimal)
 
   formatted = comma_value(famount)
 
   if (decimal > 0) then
     remain = string.sub(tostring(remain),3)
     formatted = formatted .. "." .. remain ..
                 string.rep("0", decimal - string.len(remain))
   end
 
   formatted = (prefix or "") .. formatted
 
   if (amount<0) then
     if (neg_prefix=="()") then
       formatted = "("..formatted ..")"
     else
       formatted = neg_prefix .. formatted
     end
   end
 
   return formatted
 end
 
 mon.setBackgroundColor(colors.black)
 mon.clear()
 mon.setTextScale(0.5)
 
 getInfoFromFile()
 
 
 addDrawBoxesSingleReactor()