View difference between Paste ID: hiuHnz5z and x5Ve1KSK

 function pickTargets(targetList, targetWanted) -- given a list of targets, finds targets of the desired type from said list.
 	targets = {}
 	for k,v in pairs(targetList) do
 		if v.RawName == targetWanted
 		then
 			table.insert(targets,k)
 		end
 	end
 	return targets
 end
 
 function printInColumns(row) -- prints out a of data in equal sized columns. "row" must be a table of strings.
 	w,h  = term.getSize()
 	colSize = (w / (#row))
 	x, y = term.getCursorPos()
 	for i = 1,#row do
 		term.setCursorPos(((i - 1) * colSize + 1),y)
 		term.write(row[i])
 	end
 	print()
 end
 
 function validateTargets(targetList, sensorUsed, printResults) -- Checks that desired targets actually exist. If not, removes them from the returned list. Assumes target names (in OCS sens) are table key, anything in V is fluff to be passed through.
 	printResults = printResults or true
 	validTargetList = {}
 	for k,v in pairs(targetList) do
 		reading = sensorUsed.getTargetDetails(k)
 		if reading == nil
 		then
 			if printResults
 			then
 				print("Target at " .. k .. " does not exist. Removing.")
 			end
 		else
 			if printResults
 			then
 				print("Valid target found at " .. k)
 			end
 			validTargetList[k] = v
 		end
 	end
 	return validTargetList
 end
 
 function printPairs(tableToPrint) -- Ronseal
 	for k, v in pairs(tableToPrint) do
 		print(k .. " , " .. v)
 	end
 end
 
 function getPeripherals() -- Finds one of each connected peripheral. Adapted from the buggy version included with ccSensors.
 -- WARNING: Will only feed back the last discovered of each peripheral. Do not use this if you wish to use multiple monitors or sensors!
 	local dict = {sensor=nil,monitor=nil,modem=nil,pipe=nil,ITank=nil}
 	local sides = rs.getSides()
 	for i=1,#sides do
 		if peripheral.isPresent( sides[i] ) then
 			if peripheral.getType( sides[i])  == "SensorController" then
 				dict["sensor"]=sides[i]
 			elseif peripheral.getType( sides[i])  == "monitor" then
 				dict["monitor"]=sides[i]
 				dict["monitor"].restoreTo = term.current()
 				term.redirect(peripheral.wrap(sides[i]))
-				term.restore()
+
 				term.redirect(dict["monitor"].restoreTo)
 			elseif peripheral.getType( sides[i])  == "modem" then
 				dict["modem"]=sides[i]
 				rednet.open(sides[i])
 			elseif peripheral.getType( sides[i]) == "" then -- turns out this is a bug, and it should return something like "LogisticsPipes:Request" - depends on order of placing
 				dict["pipe"]=sides[i]
 				print("Pipe found by getPeripherals")
 			elseif peripheral.getType( sides[i]) == "rcirontankvalvetile" then
 				dict["ITank"]=sides[i]
 				print("Iron Tank found by getPeripherals")
 			else
 				dict[peripheral.getType( sides[i])] = sides[i]
 				-- guess this will find printers etc.
 			end
 		end
 	end
 	return dict
 end
 
 function findAllPeripherals(filter) -- Finds all networked or local peripherals whose type matches filter (if used). Returns a table of index side and value a wrapped peripheral
 	locs = peripheral.getNames()
 	periphs = {}
 	for k,v in pairs(locs) do
 		if filter ~= nil
 		then
 			if (peripheral.getType(v):find(filter)) ~= nil
 			then
 				periphs[v] = peripheral.wrap(v)
 			end
 		else
 			periphs[v] = peripheral.wrap(v)
 		end
 	end
 	return periphs
 end
 
 function pulseCable(side, colour) -- turns on the wires of a designated colour for 0.2 sec, then turns them off again. Note - assumes that said signals were low in the first place
 	initalState = rs.getBundledOutput(side) -- get the current cable state
 	rs.setBundledOutput(side, colours.combine(initalState, colour))
 	sleep(0.2)
 	rs.setBundledOutput(side, initalState)
 	sleep(0.2)
 end
 
 function cableOn(side, colour) -- turns on wires of designated colours
 	initalState = rs.getBundledOutput(side) -- get the current cable state
 	--print("inital colours:" .. initalState )
 	--print("requested colour: " .. colour)
 	newState = colours.combine(initalState, colour)
 	--print("new colours: " .. newState)
 	rs.setBundledOutput(side, newState)
 	sleep(0.2)
 end
 
 function cableOff(side, colour) -- turn off a certain colour wire
 	initalState = rs.getBundledOutput(side) -- get the current cable state
 	rs.setBundledOutput(side, colours.subtract(initalState, colour))
 	sleep(0.2)
 end
 
 function cableCheck(side, colour) -- Is a certain colour wire on?
 	if colours.test(rs.getBundledInput(side), colour) then
 		return true
 	else
 		return false
 	end
 end
 
 function menu(menuItems, menuHeading) -- Runs a menu for the user to interact with. menuItems should be a table of all the objects in the menu, in top to bottom order. Returns index of selected menu item.
 	--ToDo - make this SCROLL
 	w, h = term.getSize()
 	selectedItem = 1
 
 	firstItem = 1
 	if #menuItems < (h - 2)
 	then
 		lastItem = #menuItems
 		startLine = (h/2) - (#menuItems/2) - 1
 	else
 		lastItem = (h-2)
 		startLine = 1
 	end
 	while true do
 		term.clear()
 		if menuHeading ~= nil
 		then
 			term.setCursorPos((w/2)-(#menuHeading/2), startLine)
 			term.write(menuHeading)
 		end
 		j = 1
 		for i = firstItem, lastItem do  -- draw the menu in the middle
 			toWrite =  menuItems[i].text or menuItems[i]
 			if i == selectedItem -- If the current item is the selected one, make it obvious to the user
 			then
 				toWrite = "=" .. toWrite .. "="
 			end
 			term.setCursorPos((w/2)-((#toWrite + 2)/2), startLine + j)
 			term.write(toWrite)
 			j = j + 1
 		end
 
 		event, result = os.pullEvent("key") -- wait here until a key is pressed
 		if result == 200 -- On "up" Go up one item if there are still items available
 		then
 			if selectedItem > 1
 			then
 				selectedItem = selectedItem - 1
 				if selectedItem < firstItem -- scheck we haven't moved out of the current displayed range. If so, scroll.
 				then
 					firstItem = selectedItem
 					lastItem = lastItem - 1
 				end
 			end
 		elseif result == 208
 		then -- on "down" Go down one item if there are still items available
 			if selectedItem < #menuItems
 			then
 				selectedItem = selectedItem + 1
 				if selectedItem > lastItem -- scheck we haven't moved out of the current displayed range. If so, scroll.
 				then
 					lastItem = selectedItem
 					firstItem = firstItem + 1
 				end
 			end
 		elseif result == 28 then -- on "enter" return that item number
 			if menuItems[selectedItem].func ~= nil -- if the menu is "functional" then call the function. Else don't)
 			then
 				p =  menuItems[selectedItem].params or {}
 				menuItems[selectedItem].func(p[1],p[2],p[3],p[4],p[5],p[6])
 			end
 			return selectedItem
 		end
 	end
 end
 
 function sideCheck(check) -- checks that a named side is a valid side
 	for k,v in pairs(redstone.getSides) do
 		if check == v
 		then
 			return true
 		end
 	end
 	return false
 end
 
 function findTargets(sensorUsed, targetTypes) -- given a sensor and a list of types to search for, will return a table of target locations for those matching
 	allTargets = sensorUsed.getTargets()
 	targets = {}
 	for k,v in pairs(allTargets) do
 		for l,u in pairs (targetTypes) do
 			if v.RawName == l
 			then
 				table.insert(targets,k)
 			end
 		end
 	end
 	return targets
 end
 
 function saveData(dataToSave, saveFileName, userResponse) -- saves any variable away in the specified location in serialized form.
 	userResponse = userResponse or true
 	print("")
 	term.write("Saving to " .. saveFileName)
 	fs.delete(saveFileName)
 	term.write("...")
 	targetFile = io.open(saveFileName, "w")
 	term.write("......")
 	targetFile:write(textutils.serialize(dataToSave))
 	term.write("......")
 	targetFile:close()
 	print("...Done")
 --	if userResponse
 --	then
 --		print("Enter to continue")
 --		read()
 --	end
 end
 
 function loadData(fileName) -- loads a requested serialized text file, returns the contents
 	if fs.exists(fileName)
 	then
 		targetFile = io.open(fileName)
 		data = textutils.unserialize(targetFile:read("*a"))
 		targetFile:close()
 
 	else
 		print("No ".. fileName .. " file exists")
 	end
 	return data
 end
 
 
 function combineTables(tab1,tab2)
 	newTab = {}
 	for k, v in pairs(tab1) do
 		newTab[k] = v
 	end
 	for k, v in pairs(tab2) do
 		newTab[k] = v
 	end
 	return newTab
 end
 
 function selectPeripheral(periphType) -- This function should move to common functions
 	periphs  = commonFunctions.findAllPeripherals(periphType) -- Scan for network attached and side attached peripherals of the given type
 	if periphs == nil -- Check that there are any periphs returned
 	then
 		print ("No linked " .. periphType .. "s detected")
 		return "none"
 	end
 
 	-- Create the menu for the user to pick from
 	menuItems = {}
 	for k, v in pairs(periphs) do
 		table.insert(menuItems, k)
 	end
 	table.insert(menuItems, "none")
 	periphType = periphType or "peripheral"
 	heading = "Select " .. periphType .. "to Use:"
 	menuResult = commonFunctions.menu(menuItems, heading)
 	return menuItems[menuResult] -- return which peripheral was picked.
 end