View difference between Paste ID: 8tmhk19g and 7Ksx4qUJ

 --Quarry Receiver Version 3.6.5
 --Made by Civilwargeeky
 --[[
 Recent Changes:
   Fixed bugs with hardcoded keys for CC: Tweaked
 ]]
 
 
 --Config
 local doDebug = false --For testing purposes
 local ySizes = 3 --There are 3 different Y Screen Sizes right now
 local quadEnabled = false --This is for the quadrotors mod by Lyqyd
 local autoRestart = false --If true, will reset screens instead of turning them off. For when reusing turtles.
 
 --Initializing Program-Wide Variables
 local expectedMessage = "Civil's Quarry" --Expected initial message
 local expectedFingerprint = "quarry"
 local replyMessage = "Turtle Quarry Receiver" --Message to respond to  handshake with
 local replyFingerprint = "quarryReceiver"
 local stopMessage = "stop"
 local expectedFingerprint = "quarry"
 local themeFolder = "quarryResources/receiverThemes/"
 local modemSide --User can specify a modem side, but it is not necessary
 local modem --This will be the table for the modem
 local computer --The main screen is special. It gets defined first :3
 local continue = true --This keeps the main while loop going
 local quadDirection = "north"
 local quadDirections = {n = "north", s = "south", e = "east", w = "west"}
 local quadBase, computerLocation
 local tArgs = {...}
 --These two are used by controller in main loop
 local commandString = "" --This will be a command string sent to turtle. This var is stored for display
 local lastCommand --If a command needs to be sent, this gets set
 local defaultSide
 local defaultCommand
 local stationsList = {}
 
 for i=1, #tArgs do --Parameters that must be set before rest of program for proper debugging
   local val = tArgs[i]:lower()
   if val == "-v" or val == "-verbose" then
     doDebug = true
   end
   if val == "-q" or val == "-quiet" then
     doDebug = false
   end
 end
 
 local keyMap = {[keys.space] = " ", [keys.minus] = "_", [keys.period] = ".", [keys.numPadDecimal] = "."} --This is for command string
 keyMap[keys.numPad0] = "0"
 keyMap[keys.numPad1] = "1"
 keyMap[keys.numPad2] = "2"
 keyMap[keys.numPad3] = "3"
 keyMap[keys.numPad4] = "4"
 keyMap[keys.numPad5] = "5"
 keyMap[keys.numPad6] = "6"
 keyMap[keys.numPad7] = "7"
 keyMap[keys.numPad8] = "8"
 keyMap[keys.numPad9] = "9"
 
 keyMap[keys.zero] = "0"
 keyMap[keys.one] = "1"
 keyMap[keys.two] = "2"
 keyMap[keys.three] = "3"
 keyMap[keys.four] = "4"
 keyMap[keys.five] = "5"
 keyMap[keys.six] = "6"
 keyMap[keys.seven] = "7"
 keyMap[keys.eight] = "8"
 keyMap[keys.nine] = "9"
 
 for a,b in pairs(keys) do --Add all letters from keys api
   if #a == 1 then
     keyMap[b] = a:upper()
   end
 end
 keyMap[keys.enter] = "enter"
 keyMap[keys.numPadEnter] = "enter"
 keyMap[keys.backspace] = "backspace"
 keyMap[keys.up] = "up"
 keyMap[keys.down] = "down"
 keyMap[keys.left] = "left"
 keyMap[keys.right] = "right"
 
 local helpResources = { --$$ is a new page
 main = [[$$Hello and welcome to Quarry Receiver Help!
 
 This goes over everything there is to know about the receiver
 
 Use the arrow keys to navigate!
 Press '0' to come back here!
 Press 'q' to quit!
 
 Press a section number at any time to go the beginning of that section
  1. Basic Use
  2. Parameters
  3. Commands
  4. Turtle Commands
 
 $$A secret page!
 You found it! Good job :)
 ]],
 [[$$Your turtle and you!
 
 To use this program, you need a wireless modem on both this computer and the turtle
 
 Make sure they are attached to both the turtle and this computer
 $$Using your new program!
 
 Once you have done that, start the turtle and when it says "Rednet?", say "Yes"
   Optionally, you can use the parameter "-rednet true"
 Then remember the channel it tells you to open.
 
 Come back to this computer, and run the program. Follow onscreen directions.
   Optionally, you can use the parameter "-receiveChannel"
 
 Check out the other help sections for more parameters
 $$Adding Screens!
 You can add screens with the "-screen" parameter or the "SCREEN" command
 An example would be "SCREEN LEFT 2 BLUE" for a screen on the left side with channel 2 and blue theme
 
 You can connect screens over wired modems. Attach a modem to the computer and screen, then right click the modem attached to the screen.
 Then you can say "SCREEN MONITOR_0" or whatever it says
 
 ]],
 [[$$Parameters!
   note: <> means required, [] means optional
 
 -help/help/-?/?/-usage/usage: That's this!
 
 -autoRestart [t/f]: If true, the receiver will not exit when all quarries are done and will automagically reconnect to new quarries
   With no argument, this is set to true.
 
 -receiveChannel/channel <channel>: Sets the main screen's receive channel
 
 -theme <name>: sets the "default" theme that screens use when they don't have a set theme
 $$Parameters!
   note: <> means required, [] means optional
 
 -screen <side> [channel] [theme]: makes a new screen on the given side with channel and theme
   example: -screen left 10 blue    This adds a new screen on the left receiving channel 10 with a blue theme.
 
 -station [side]: makes the screen a "station" that monitors all screens.
   if no side, uses computer
 
 -auto [channel list]: This finds all attached monitors and initializes them (with channels)
   example: -auto 1 2 5 9   finds screens and gives them channels
 $$Parameters!
   note: <> means required, [] means optional
 
 -colorEditor: makes the main screen a color editor that just prints the current colors. Good for theme making
 current typeColors: default title, subtitle, pos, dim, extra, error, info, inverse, command, help, background
 
 -modem <side>: Sets the modem side to side
 
 -v/-verbose: turns on debug
 
 -q/-quiet: turns off debug
 ]],
 [[$$Commands!
 
 COMMAND [screen] [text]: Sends text to the connected turtle. See turtle commands for valid commands
 
 SCREEN [side] [channel] [theme]: Adds a screen. You can also specify the channel and theme of the screen.
 
 REMOVE [screen]: Removes the selected screen (cannot remove the main screen)
 
 THEME [screen] [name]: Sets the theme of the given screen. THEME [screen] resets the screen to default theme
 $$Commands!
 
 THEME [name]: Sets the default theme.
 
 RECEIVE [screen] [channel]: Changes the receive channel of the given screen
 
 SEND [screen] [channel]: Changes the send channel of the given screen (for whatever reason)
 
 STATION [screen] [channel]: Sets the given screen to/from a station. If changing from a station, will set the screen's channel
 $$Commands!
 
 SET [text]: Sets a default command that can be backspaced. Useful for color editing or command sending
   Use SET with nothing after to remove text
 
 SIDE [screen]: Sets a default screen for "sided" commands.
   Any command that takes a [screen] is sided
 
 EXIT/QUIT: Quits the program gracefully
 $$Commands!
 
 COLOR [themeName] [typeColor] [textColor] [backColor]: Sets the the text and background colors of the given typeColor of the given theme. See notes on "colorEditor" parameter for more info
 
 SAVETHEME [themeName] [fileName]: Saves the given theme as fileName for later use
 
 SAVETHEME [screen] [fileName]: Same as above but for a screen's theme
 
 AUTO [channelList]: Automatically searches for nearby screens, providing them sequentially with channels if a channel list is given
   Example Use: AUTO 1 2 5 9
 $$Commands!
 
 HELP: Displays this again!
 
 VERBOSE: Turns debug on
 
 QUIET: Turns debug off
 
 ]],
 [[$$Turtle Commands!
 
 Stop: Stops the turtle where it is
 
 Return: The turtle will return to its starting point, drop off its load, and stop
 
 Drop: Turtle will immediately go and drop its inventory
 
 Pause: Pauses the turtle
 
 Resume: Resumes paused turtles
 
 Refuel: Turtle will schedule an emergency refuel
   This could take from fuelChest, or quadCopter
   or fuel in inventory (in that order)
 ]]
 }
 
 --Generic Functions--
 local function debug(...)
   --if doDebug then return print(...) end --Basic
   if doDebug then
     print("\nDEBUG: ",...)
     os.pullEvent("char")
   end
 end
 local function clearScreen(x,y, periph)
   periph, x, y = periph or term, x or 1, y or 1
   periph.clear()
   periph.setCursorPos(x,y)
 end
 
 local function swapKeyValue(tab)
   for a,b in pairs(tab) do
     tab[b] = a
   end
   return tab
 end
 local function copyTable(tab)
   local toRet = {}
   for a,b in pairs(tab) do
     toRet[a] = b
   end
   return toRet
 end
 local function checkChannel(num)
   num = tonumber(num)
   if not num then return false end
   if 1 <= num and num <= 65535 then
     return num
   end
   return false
 end
 local function truncate(text, xDim)
   if #text <= xDim then return text end
   return #text >= 4 and text:sub(1,xDim-3).."..." or text:sub(1,3)
 end
 local function align(text, xDim, direction, trunc)
   text = tostring(text or "None")
   if trunc == nil then trunc = true end
   if #text >= xDim and trunc then return truncate(text,xDim) end
   for i=1, xDim-#text do
     if direction == "right" then
       text = " "..text
     elseif direction == "left" then
       text = text.." "
     end
   end
   return text
 end
 local function alignR(text, xDim, trunc)
   return align(text, xDim, "right", trunc)
 end
 local function alignL(text, xDim, trunc)
   return align(text, xDim, "left", trunc)
 end
 local function center(text, xDim, char)
   if not xDim then error("Center: No dim given",2) end
   char = char or " "
   local a = (xDim-#text)/2
   for i=1, a do
     text = char..text..char
   end
   return #text == xDim and text or text..char --If not full length, add a space
 end
 local function leftRight(first, second, dim)
   return alignL(tostring(first),dim-#tostring(second))..tostring(second)
 end
 local function roundNegative(num) --Rounds numbers up to 0
   if num >= 0 then return num else return 0 end
 end
 
 
 local function testPeripheral(periph, periphFunc)
   if type(periph) ~= "table" then return false end
   if type(periph[periphFunc]) ~= "function" then return false end
   if periph[periphFunc]() == nil then --Expects string because the function could access nil
     return false
   end
   return true
 end
 
 local function initModem() --Sets up modem, returns true if modem exists
   if not testPeripheral(modem, "isWireless") then
     if modemSide then
       if peripheral.getType(modemSide) == "modem" then
         modem = peripheral.wrap(modemSide)
         if modem.isWireless and not modem.isWireless() then --Apparently this is a thing
           modem = nil
           return false
         end
         return true
       end
     end
     if peripheral.find then
       modem = peripheral.find("modem", function(side, obj) return obj.isWireless() end)
     end
     return modem and true or false
   end
   return true
 end
 
 --COLOR/THEME RELATED
 for a, b in pairs(colors) do --This is so commands color commands can be entered in one case
   colors[a:lower()] = b
 end
 colors.none = 0 --For adding things
 
 local requiredColors = {"default","title", "subtitle", "pos", "dim", "extra", "error", "info", "inverse", "command", "help", "background"}
 
 local function checkColor(name, text, back) --Checks if a given color works
   local flag = false
   for a, b in ipairs(requiredColors) do
     if b == name then
       flag = true
       break
     end
   end
   if not flag or not (tonumber(text) or colors[text]) or not (tonumber(back) or colors[back]) then return false end
   return true
 end
 
 
 local themes = {} --Loaded themes, gives each one a names
 local function newTheme(name)
   name = name:lower() or "none"
   local self = {name = name}
   self.addColor = function(self, colorName, text, back) --Colors are optional. Will default to "default" value. Make sure default is a color
     if colorName == "default" and (not text or not back) then return self end
     if not text then text = 0 end
     if not back then back = 0 end
     if not checkColor(colorName, text, back) then debug("Color check failed: ",name," ",text," ",back); return self end --Back or black because optional
     colorName = colorName or "none"
     self[colorName] = {text = text, background = back}
     return self --Allows for chaining :)
   end
   themes[name] = self
   return self
 end
 
 local function parseTheme(file)
   local addedTheme = newTheme(file:match("^.-\n") or "newTheme") --Initializes the new theme to the first line
   file:sub(file:find("\n") or 1) --If there is a newLine, this cuts everything before it. I don't care that the newLine is kept
   for line in file:gmatch("[^\n]+\n") do --Go through all the color lines (besides first one)
     local args = {}
     for word in line:gmatch("%S+") do
       table.insert(args,word)
     end
     addedTheme:addColor(args[1]:match("%a+") or "nothing", tonumber(args[2]) or colors[args[2]], tonumber(args[3]) or colors[args[3]]) --"nothing" will never get used, so its just lazy error prevention
   end
   local flag = true --Make sure a theme has all required elements
   for a,b in ipairs(requiredColors) do
     if not addedTheme[b] then
       flag = false
       debug("Theme is missing color '",b,"'")
     end
   end
   if not flag then
     themes[addedTheme.name] = nil
     debug("Failed to load theme")
     return false
   end
   return addedTheme
 end
 --This is how adding colors will work
 --regex for adding from file:
 --(\w+) (\w+) (\w+)
 --  \:addColor\(\"\1\"\, \2\, \3\)
 
 
 newTheme("default")
   :addColor("default",colors.white, colors.black)
   :addColor("title", colors.green, colors.gray)
   :addColor("subtitle", colors.white, colors.black)
   :addColor("pos", colors.green, colors.black)
   :addColor("dim", colors.lightBlue, colors.black)
   :addColor("extra", colors.lightGray, colors.black)
   :addColor("error", colors.red, colors.white)
   :addColor("info", colors.blue, colors.lightGray)
   :addColor("inverse", colors.yellow, colors.blue)
   :addColor("command", colors.lightBlue, colors.black)
   :addColor("help", colors.cyan, colors.black)
   :addColor("background", colors.none, colors.none)
 
 newTheme("blue")
   :addColor("default",colors.white, colors.blue)
   :addColor("title", colors.lightBlue, colors.gray)
   :addColor("subtitle", 1, 2048)
   :addColor("pos", 16, 2048)
   :addColor("dim", colors.lime, 0)
   :addColor("extra", 8, 2048)
   :addColor("error",  8, 16384)
   :addColor("info", 2048, 256)
   :addColor("inverse", 2048, 1)
   :addColor("command", 2048, 8)
   :addColor("help", 16384, 1)
   :addColor("background", 1, 2048)
 
 newTheme("seagle")
   :addColor("default",colors.white, colors.black)
   :addColor("title", colors.white, colors.black)
   :addColor("subtitle", colors.red, colors.black)
   :addColor("pos", colors.gray, colors.black)
   :addColor("dim", colors.lightBlue, colors.black)
   :addColor("extra", colors.lightGray, colors.black)
   :addColor("error", colors.red, colors.white)
   :addColor("info", colors.blue, colors.lightGray)
   :addColor("inverse", colors.yellow, colors.lightGray)
   :addColor("command", colors.lightBlue, colors.black)
   :addColor("help", colors.red, colors.white)
   :addColor("background", colors.white, colors.black)
 
 newTheme("random")
   :addColor("default",colors.white, colors.black)
   :addColor("title", colors.pink, colors.blue)
   :addColor("subtitle", colors.black, colors.white)
   :addColor("pos", colors.green, colors.black)
   :addColor("dim", colors.lightBlue, colors.black)
   :addColor("extra", colors.lightGray, colors.lightBlue)
   :addColor("error", colors.white, colors.yellow)
   :addColor("info", colors.blue, colors.lightGray)
   :addColor("inverse", colors.yellow, colors.lightGray)
   :addColor("command", colors.green, colors.lightGray)
   :addColor("help", colors.white, colors.yellow)
   :addColor("background", colors.white, colors.red)
 
 newTheme("rainbow")
   :addColor("dim", 32, 0)
   :addColor("background", 16384, 0)
   :addColor("extra", 2048, 0)
   :addColor("info", 2048, 0)
   :addColor("inverse", 32, 0)
   :addColor("subtitle", 2, 0)
   :addColor("title", 16384, 0)
   :addColor("error", 1024, 0)
   :addColor("default", 1, 512)
   :addColor("command", 16, 0)
   :addColor("pos", 16, 0)
   :addColor("help", 2, 0)
 
 newTheme("green")
  :addColor("dim", 16384, 0)
  :addColor("background", 0, 0)
  :addColor("extra", 2048, 0)
  :addColor("info", 32, 256)
  :addColor("inverse", 8192, 1)
  :addColor("subtitle", 1, 0)
  :addColor("title", 8192, 128)
  :addColor("error", 16384, 32768)
  :addColor("default", 1, 8192)
  :addColor("command", 2048, 32)
  :addColor("pos", 16, 0)
  :addColor("help", 512, 32768)
 
 
 --If you modify a theme a bunch and want to save it
 local function saveTheme(theme, fileName)
   if not theme or not type(fileName) == "string" then return false end
   local file = fs.open(fileName,"w")
   if not file then return false end
   file.writeLine(fileName)
   for a,b in pairs(theme) do
     if type(b) == "table" then --If it contains color objects
       file.writeLine(a.." "..tostring(b.text).." "..tostring(b.background))
     end
   end
   file.close()
   return true
 end
 
 --BUTTON CLASS
 local button = {}
 
 button.checkPoint = function(buttons, pos) --Returns a command or nil
   for a, b in pairs(buttons) do
     if pos[2] == b.line then
       if pos[1] >= b.xDim[1] and pos[1] <= b.xDim[2] then
         return b.command
       end
     end
   end
 end
 
 button.makeLine = function(buttons, sep, xDim)
   local toRet = ""
   for a, b in ipairs(buttons) do
     toRet = toRet..center(b.text, (b.xDim[2]-b.xDim[1]))..sep
   end
   return toRet:sub(1,-2).."" --Take off the last sep
 end
 
 button.new = function(line, xStart, xEnd, command, display)
   local toRet = {}
   setmetatable(toRet, {__index = button})
   toRet.line = line
   toRet.xDim = {math.min(xStart, xEnd), math.max(xStart, xEnd)}
   toRet.command = command
   toRet.text = display
   return toRet
 end
 
 
 --==SCREEN CLASS FUNCTIONS==
 local screenClass = {} --This is the class for all monitor/screen objects
 screenClass.screens = {} --A simply numbered list of screens
 screenClass.sides = {} --A mapping of screens by their side attached
 screenClass.channels = {} --A mapping of receiving channels that have screens attached. Used for the receiver part
 screenClass.sizes = {{7,18,29,39,50}, {5,12,19} , computer = {51, 19}, turtle = {39,13}, pocket = {26,20}}
 
 screenClass.setTextColor = function(self, color) --Accepts raw color
   if color and self.term.isColor() then
     self.textColor = color
     self.term.setTextColor(color)
     return true
   end
   return false
 end
 screenClass.setBackgroundColor = function(self, color) --Accepts raw color
   if color and self.term.isColor() then
     self.backgroundColor = color
     self.term.setBackgroundColor(color)
     return true
   end
   return false
 end
 screenClass.setColor = function(self, color) --Wrapper, accepts themecolor objects
   if type(color) ~= "table" then error("Set color received a non-table",2) end
   local text, back = color.text, color.background
   if not text or text == 0 then text = self.theme.default.text end
   if not back or back == 0  then back = self.theme.default.background end
   return self:setTextColor(text) and self:setBackgroundColor(back)
 end
 
 screenClass.themeName = "default" --Setting super for fallback
 screenClass.theme = themes.default
 
 screenClass.rec = { --Initial values for all displayed numbers
   label = "Quarry Bot",
   id = 1,
   percent = 0,
   xPos = 0,
   zPos = 0,
   layersDone = 0,
   x = 0,
   z = 0,
   layers = 0,
   openSlots = 0,
   mined = 0,
   moved = 0,
   chestFull = false,
   isAtChest = false,
   isGoingToNextLayer = false,
   foundBedrock = false,
   fuel = 0,
   volume = 0,
   distance = 0,
   yPos = 0
 }
 
 screenClass.new = function(side, receive, themeFile)
   local self = {}
   setmetatable(self, {__index = screenClass}) --Establish Hierarchy
   self.side = side
   if side == "computer" then
     self.term = term
   else
     self.term = peripheral.wrap(side)
     if not (self.term and peripheral.getType(side) == "monitor") then --Don't create an object if it doesn't exist
       if doDebug then
         error("No monitor on side "..tostring(side))
       end
       self = nil --Save memory?
       return false
     end
   end
 
   --Channels and ids
   self.receive = tonumber(receive) --Receive Channel
   self.send = nil --Reply Channel, obtained in handshake
   self.id = #screenClass.screens+1
   --Colors
   self.themeName = nil --Will be set by setTheme
   self.theme = nil
   self.isColor = self.term.isColor() --Just for convenience
   --Other Screen Properties
   self.dim = {self.term.getSize()} --Raw dimensions
   --Initializations
   self.isDone = false --Flag for when the turtle is done transmitting
   self.size = {} --Screen Size, assigned in setSize
   self.textColor = colors.white --Just placeholders until theme is loaded and run
   self.backColor = colors.black
   self.toPrint = {}
   self.isComputer = false
   self.isTurtle = false
   self.isPocket = false
   self.acceptsInput = false
   self.legacy = false --Whether it expects tables or strings
   self.rec = copyTable(screenClass.rec)
 
   screenClass.screens[self.id] = self
   screenClass.sides[self.side] = self
   if self.receive then
     modem.open(self.receive) --Modem should be defined by the time anything is open
     screenClass.channels[self.receive] = self --If anyone ever asked, you could have multiple screens per channel, but its silly if no one ever needs it
   end
   self:setSize() --Finish Initialization
   self:setTheme(themeFile)
   return self
 end
 
 screenClass.remove = function(tab) --Cleanup function
   if type(tab) == "number" then --Expects table, can take id (for no apparent reason)
     tab = screenClass.screens[tab]
   end
   tab:removeStation()
   if tab.side == "REMOVED" then return end
   if tab.side == "computer" then error("Tried removing computer screen",2) end --This should never happen
   tab:reset() --Clear screen
   tab:say("Removed", tab.theme.info, 1) --Let everyone know whats up
   screenClass.screens[tab.id] = {side = "REMOVED"} --Not nil because screw up len()
   screenClass.sides[tab.side] = nil
   tab:removeChannel()
 end
 
 --Init Functions
 screenClass.removeChannel = function(self)
   self.send = nil
   if self.receive then
     screenClass.channels[self.receive] = nil
     if modem and modem.isOpen(self.receive) then
       modem.close(self.receive)
     end
     self.receive = nil
   end
   self:setSize()
 end
 
 screenClass.setChannel = function(self, channel)
   if self.isStation then return false end --Don't want to set channel station
   self:removeChannel()
   if type(channel) == "number" then
     self.receive = channel
     screenClass.channels[self.receive] = self
     if modem and not modem.isOpen(channel) then modem.open(channel) end
   end
   self:setSize() --Sets proper draw function
 end
 
 screenClass.setStation = function(self) --Note: This only changes the "set" methods so that "update" methods remain intact per object :)
   self:removeChannel()
   if not self.isStation then --Just in case this gets called more than once
     self.isStation = true
     table.insert(stationsList,self)
   end
   self:setSize()
 end
 
 screenClass.removeStation = function(self)
   if self.isStation then
     for i=1, #stationsList do --No IDs so have to do a linear traversal
       if stationsList[i] == self then table.remove(stationsList, i) end
     end
   end
   self.isStation = false
   self:setSize()
 end
 
 screenClass.setSize = function(self) --Sets screen size
   if self.side ~= "computer" and not self.term then self.term = peripheral.wrap(self.side) end
   if not self.term.getSize() then --If peripheral is having problems/not there. Don't go further than term, otherwise index nil (maybe?)
     debug("There is no term...")
     self.updateDisplay = function() end --Do nothing on screen update, overrides class
     return true
   elseif self.isStation then
     self:setStationDisplay()
   elseif not self.receive then
     self:setBrokenDisplay() --This will prompt user to set channel
   elseif self.send then --This allows for class inheritance
     self:setNormalDisplay() --In case objects have special updateDisplay methods --Remove function in case it exists, defaults to super
   else --If the screen needs to have a handshake display
     self:setHandshakeDisplay()
   end
   self:resetButtons()
   self.dim = { self.term.getSize()}
   local tab = screenClass.sizes
   for a=1, 2 do --Want x and y dim
     for b=1, #tab[a] do --Go through all normal sizes, x and y individually
       if tab[a][b] <= self.dim[a] then --This will set size higher until false
         self.size[a] = b
       end
     end
   end
   local function isThing(toCheck, thing) --E.G. isThing(self.dim,"computer")
     return toCheck[1] == tab[thing][1] and toCheck[2] == tab[thing][2]
   end
   self.isComputer = isThing(self.dim, "computer")
   self.isTurtle = isThing(self.dim, "turtle")
   self.isPocket = isThing(self.dim, "pocket")
   self.acceptsInput = self.isComputer or self.isTurtle or self.isPocket
   return self
 end
 
 screenClass.setTheme = function(self, themeName, stopReset)
   if not themes[themeName] then --If we don't have it already, try to load it
     local fileName = themeName or ".." --.. returns false and I don't think you can name a file this
     if fs.exists(themeFolder) then fileName = themeFolder..fileName end
     if fs.exists(fileName) then
       debug("Loading theme: ",fileName)
       local file = fs.open(fileName, "r")
       if not file then debug("Could not load theme '",themeName,"' file not found") end
       parseTheme(file.readAll()) --Parses the text to make a theme, returns theme
       file.close()
       self.themeName = themeName:lower() --We can now set our themeName to the fileName
     else
       --Resets theme to super
       if not stopReset then --This exists so its possible to set default theme without breaking world
         self.themeName = nil
         self.theme = nil
       end
       return false
     end
    else
     self.themeName = themeName:lower()
    end
    self.theme = themes[self.themeName] --Now the theme is loaded or the function doesn't get here
    return true
 end
 
 --Adds text to the screen buffer
 screenClass.tryAddRaw = function(self, line, text, color, ...) --This will try to add text if Y dimension is a certain size
   local doAdd = {...} --booleans for small, medium, and large
   if type(text) ~= "string" then error("tryAddRaw got "..type(text)..", expected string",2) end
   if not text then
     debug("tryAddRaw got no string on line ",line)
     return false
   end
   if type(color) ~= "table" then error("tryAddRaw did not get a color",2) end
   --color = color or {text = colors.white}
   for i=1, ySizes do --As of now there are 3 Y sizes
     local test = doAdd[i]
     if test == nil then test = doAdd[#doAdd] end --Set it to the last known setting if doesn't exist
     if test and self.size[2] == i then --If should add this text for this screen size and the monitor is this size
       if #text <= self.dim[1] then
         self.toPrint[line] = {text = text, color = color}
         return true
       else
         debug("Tried adding '",text,"' on line ",line," but was too long: ",#text," vs ",self.dim[1])
       end
     end
   end
   return false
 end
 screenClass.tryAdd = function(self, text, color,...) --Just a wrapper
   return self:tryAddRaw(#self.toPrint+1, text, color, ...)
 end
 screenClass.tryAddC = function(self, text, color, ...) --Centered text
   return self:tryAdd(center(text, self.dim[1]), color, ...)
 end
 
 screenClass.reset = function(self,color)
   color = color or self.theme.background
   self:setColor(color)
   self.term.clear()
   self.term.setCursorPos(1,1)
 end
 screenClass.say = function(self, text, color, line)
   local currColor = self.backgroundColor
   color = color or debug("Printing ",text," but had no themeColor: ",self.theme.name) or {} --Set default for nice error, alert that errors occur
   self:setColor(color)
   local line = line or ({self.term.getCursorPos()})[2] or self:setSize() or 1 --If current yPos not found, sets screen size and moves cursor to 1
   if doDebug and #text > self.dim[1] then error("Tried printing: '"..text.."', but was too big") end
   self.term.setCursorPos(1,line)
   for i=1, self.dim[1]-#text do --This is so the whole line's background gets filled.
     text = text.." "
   end
   self.term.write(text)
   self.term.setCursorPos(1, line+1)
 end
 screenClass.pushScreenUpdates = function(self)
   for i=1, self.dim[2] do
     local tab = self.toPrint[i]
     if tab then
       self:say(tab.text, tab.color, i)
     end
   end
   self.term.setCursorPos(1,self.dim[2]) --So we can see errors
 end
 screenClass.resetButtons = function(self)
   self.buttons = {}
 end
 screenClass.addButton = function(self, button)
   self.buttons[#self.buttons+1] = button
 end
 
 screenClass.updateNormal = function(self) --This is the normal updateDisplay function
   local str = tostring
   self.toPrint = {} --Reset table
   local message, theme, x = self.rec, self.theme, self.dim[1]
   if not self.isDone then --Normally
 
 
     if self.size[1] == 1 then --Small Width Monitor
       if not self:tryAdd(message.label, theme.title, false, false, true) then --This will be a title, basically
         self:tryAdd("Quarry!", theme.title, false, false, true)
       end
 
       self:tryAdd("-Fuel-", theme.subtitle , false, true, true)
       if not self:tryAdd(str(message.fuel), theme.extra, false, true, true) then --The fuel number may be bigger than the screen
         self:tryAdd("A lot", theme.extra, false, true, true)
       end
 
       self:tryAdd("--%%%--", theme.subtitle, false, true, true)
       self:tryAdd(alignR(str(message.percent).."%", 7), theme.pos , false, true, true) --This can be an example. Print (receivedMessage).percent in blue on all different screen sizes
       self:tryAdd(center(str(message.percent).."%", x), theme.pos, true, false) --I want it to be centered on 1x1
 
       self:tryAdd("--Pos--", theme.subtitle, false, true, true)
       self:tryAdd("X:"..alignR(str(message.xPos), 5), theme.pos, true)
       self:tryAdd("Z:"..alignR(str(message.zPos), 5), theme.pos , true)
       self:tryAdd("Y:"..alignR(str(message.layersDone), 5), theme.pos , true)
 
       if not self:tryAdd(str(message.x).."x"..str(message.z).."x"..str(message.layers), theme.dim , true, false) then --If you can't display the y, then don't
         self:tryAdd(str(message.x).."x"..str(message.z), theme.dim , true, false)
       end
       self:tryAdd("--Dim--", theme.subtitle, false, true, true)
       self:tryAdd("X:"..alignR(str(message.x), 5), theme.dim, false, true, true)
       self:tryAdd("Z:"..alignR(str(message.z), 5), theme.dim, false, true, true)
       self:tryAdd("Y:"..alignR(str(message.layers), 5), theme.dim, false, true, true)
 
       self:tryAdd("-Extra-", theme.subtitle, false, false, true)
       self:tryAdd(alignR(textutils.formatTime(os.time()):gsub(" ","").."", 7), theme.extra, false, false, true) --Adds the current time, formatted, without spaces.
       self:tryAdd("Used:"..alignR(str(16-message.openSlots),2), theme.extra, false, false, true)
       self:tryAdd("Dug"..alignR(str(message.mined), 4), theme.extra, false, false, true)
       self:tryAdd("Mvd"..alignR(str(message.moved), 4), theme.extra, false, false, true)
       if message.status then
         self:tryAdd(alignL(message.status, x), theme.info, false, false, true)
       end
       if message.chestFull then
         self:tryAdd("ChstFll", theme.error, false, false, true)
       end
 
     end
     if self.size[1] == 2 then --Medium Monitor
       if not self:tryAdd(message.label, theme.title, false, false, true) then --This will be a title, basically
         self:tryAdd("Quarry!", theme.title, false, false, true)
       end
 
       self:tryAdd(center("Fuel",x,"-"), theme.subtitle , false, true, true)
       if not self:tryAdd(str(message.fuel), theme.extra, false, true, true) then --The fuel number may be bigger than the screen
         self.toPrint[#self.toPrint] = nil
         self:tryAdd("A lot", theme.extra, false, true, true)
       end
 
       self:tryAdd(str(message.percent).."% Complete", theme.pos , true) --This can be an example. Print (receivedMessage).percent in blue on all different screen sizes
 
       self:tryAdd(center("Pos",x,"-"), theme.subtitle, false, true, true)
       self:tryAdd(leftRight("X Coordinate:",message.xPos, x), theme.pos, true)
       self:tryAdd(leftRight("Z Coordinate:",message.zPos, x), theme.pos , true)
       self:tryAdd(leftRight("On Layer:",message.layersDone, x), theme.pos , true)
 
       if not self:tryAdd("Size: "..str(message.x).."x"..str(message.z).."x"..str(message.layers), theme.dim , true, false) then --This is already here... I may as well give an alternative for those people with 1000^3quarries
         self:tryAdd(str(message.x).."x"..str(message.z).."x"..str(message.layers), theme.dim , true, false)
       end
       self:tryAdd(center("Dim",x,"-"), theme.subtitle, false, true, true)
       self:tryAdd(leftRight("Total X:", message.x, x), theme.dim, false, true, true)
       self:tryAdd(leftRight("Total Z:", message.z, x), theme.dim, false, true, true)
       self:tryAdd(leftRight("Total Layers:", message.layers, x), theme.dim, false, true, true)
       self:tryAdd(leftRight("Volume", message.volume, x), theme.dim, false, false, true)
 
       self:tryAdd(center("Extras",x,"-"), theme.subtitle, false, false, true)
       self:tryAdd(leftRight("Time: ", textutils.formatTime(os.time()):gsub(" ","").."", x), theme.extra, false, false, true) --Adds the current time, formatted, without spaces.
       self:tryAdd(leftRight("Used Slots:", 16-message.openSlots, x), theme.extra, false, false, true)
       self:tryAdd(leftRight("Blocks Mined:", message.mined, x), theme.extra, false, false, true)
       self:tryAdd(leftRight("Spaces Moved:", message.moved, x), theme.extra, false, false, not self.isPocket)
       if message.status then
         self:tryAdd(message.status, theme.info, false, false, true)
       end
       if message.chestFull then
         self:tryAdd("Chest Full, Fix It", theme.error, false, true, true)
       end
     end
     if self.size[1] >= 3 then --Large or larger screens
       if not self:tryAdd(message.label..alignR(" Turtle #"..str(message.id),x-#message.label), theme.title, true) then
         self:tryAdd("Your turtle's name is long...", theme.title, true)
       end
       self:tryAdd("Fuel: "..alignR(str(message.fuel),x-6), theme.extra, true)
 
       self:tryAdd("Percentage Done: "..alignR(str(message.percent).."%",x-17), theme.pos, true)
 
       local var1 = math.max(#str(message.x), #str(message.z), #str(message.layers))
       local var2 = (x-6-var1+3)/3
       self:tryAdd("Pos: "..alignR(" X:"..alignR(str(message.xPos),var1),var2)..alignR(" Z:"..alignR(str(message.zPos),var1),var2)..alignR(" Y:"..alignR(str(message.layersDone),var1),var2), theme.pos, true)
       self:tryAdd("Size:"..alignR(" X:"..alignR(str(message.x),var1),var2)..alignR(" Z:"..alignR(str(message.z),var1),var2)..alignR(" Y:"..alignR(str(message.layers),var1),var2), theme.dim, true)
       self:tryAdd("Volume: "..str(message.volume), theme.dim, false, true, true)
       self:tryAdd("",{}, false, false, true)
       self:tryAdd(center("____---- EXTRAS ----____",x), theme.subtitle, false, false, true)
       self:tryAdd(center("Time:"..alignR(textutils.formatTime(os.time()),10), x), theme.extra, false, true, true)
       self:tryAdd(center("Current Day: "..str(os.day()), x), theme.extra, false, false, true)
       self:tryAdd("Used Inventory Slots: "..alignR(str(16-message.openSlots),x-22), theme.extra, false, true, true)
       self:tryAdd("Blocks Mined: "..alignR(str(message.mined),x-14), theme.extra, false, true, true)
       self:tryAdd("Blocks Moved: "..alignR(str(message.moved),x-14), theme.extra, false, true, true)
       self:tryAdd("Distance to Turtle: "..alignR(str(message.distance), x-20), theme.extra, false, false, true)
       self:tryAdd("Actual Y Pos (Not Layer): "..alignR(str(message.yPos), x-26), theme.extra, false, false, true)
 
       if message.chestFull then
         self:tryAdd("Dropoff is Full, Please Fix", theme.error, false, true, true)
       end
       if message.foundBedrock then
         self:tryAdd("Found Bedrock! Please Check!!", theme.error, false, true, true)
       end
       if message.status then
         self:tryAdd("Status: "..message.status, theme.info, false, true, true)
       end
       if message.isAtChest then
         self:tryAdd("Turtle is at home chest", theme.info, false, true, true)
       end
       if message.isGoingToNextLayer then
         self:tryAdd("Turtle is going to next layer", theme.info, false, true, true)
       end
 
 
 
     end
     if self.term.isColor() and ((self.size[2] >= 2 and self.size[1] >= 3) or self.isPocket) then
         local line = self.acceptsInput and self.dim[2]-1 or self.dim[2]
         local part = math.floor(x/4)
         if #self.buttons == 0 then
           self:addButton(button.new(line, part*0, part*1-1, "drop","Drop"))
           self:addButton(button.new(line, part*1, part*2-1, "pause","Pause"))
           self:addButton(button.new(line, part*2, part*3-1, "return","Return"))
           self:addButton(button.new(line, part*3, part*4-1, "refuel","Refuel"))
         end
         self:tryAddRaw(line, button.makeLine(self.buttons,"|"):sub(1,self.isPocket and -2 or -1), theme.command, false, true) --Silly code because pocket breaks
       end
   else --If is done
     if self.size[1] == 1 then --Special case for small monitors
       self:tryAdd("Done", theme.title, true)
       if not self:tryAdd("Dug"..alignR(str(message.mined),4, false), theme.pos, true) then
         self:tryAdd("Dug", theme.pos, true)
         self:tryAdd(alignR(str(message.mined),x), theme.pos, true)
       end
       if not self:tryAdd("Fuel"..alignR(str(message.fuel),3, false), theme.pos, true) then
         self:tryAdd("Fuel", theme.pos, true)
         self:tryAdd(alignR(str(message.fuel),x), theme.pos, true)
       end
       self:tryAdd("-------", theme.subtitle, false,true,true)
       self:tryAdd("Turtle", theme.subtitle, false, true, true)
       self:tryAdd(center("is", x), theme.subtitle, false, true, true)
       self:tryAdd(center("Done!", x), theme.subtitle, false, true, true)
     else
       self:tryAdd("Done!", theme.title, true)
       self:tryAdd("Curr Fuel: "..str(message.fuel), theme.pos, true)
       if message.preciseTotals then
         local tab = {}
         for a,b in pairs(message.preciseTotals) do --Sorting the table
           a = a:match(":(.+)")
           if #tab == 0 then --Have to initialize or rest does nothing :)
             tab[1] = {a,b}
           else
             for i=1, #tab do --This is a really simple sort. Probably not very efficient, but I don't care.
               if b > tab[i][2] then --Gets the second value from the table, which is the itemCount
                 table.insert(tab, i, {a,b})
                 break
               elseif i == #tab then --Insert at the end if not bigger than anything
                 table.insert(tab,{a,b})
               end
             end
           end
         end
         for i=1, #tab do --Print all the blocks in order
           local firstPart = "#"..tab[i][1]..": "
           self:tryAdd(firstPart..alignR(tab[i][2], x-#firstPart), (i%2 == 0) and theme.inverse or theme.info, true, true, true) --Switches the colors every time
         end
       else
         self:tryAdd("Blocks Dug: "..str(message.mined), theme.inverse, true)
         self:tryAdd("Cobble Dug: "..str(message.cobble), theme.pos, false, true, true)
         self:tryAdd("Fuel Dug: "..str(message.fuelblocks), theme.pos, false, true, true)
         self:tryAdd("Others Dug: "..str(message.other), theme.pos, false, true, true)
       end
     end
   end
 end
 screenClass.updateHandshake = function(self)
   self.toPrint = {}
   local half = math.ceil(self.dim[2]/2)
   if self.size[1] == 1 then --Not relying on the parameter system because less calls
     self:tryAddRaw(half-2, "Waiting", self.theme.error, true)
     self:tryAddRaw(half-1, "For Msg", self.theme.error, true)
     self:tryAddRaw(half, "On Chnl", self.theme.error, true)
     self:tryAddRaw(half+1, tostring(self.receive), self.theme.error, true)
   else
     local str = "for"
     if self.size[1] == 2 then str = "4" end--Just a small grammar change
     self:tryAddRaw(half-2, "", self.theme.error, true) --Filler
     self:tryAddRaw(half-1, center("Waiting "..str.." Message", self.dim[1]), self.theme.error, true)
     self:tryAddRaw(half, center("On Channel "..tostring(self.receive), self.dim[1]), self.theme.error, true)
     self:tryAddRaw(half+1, "",self.theme.error, true)
   end
 end
 screenClass.updateBroken = function(self) --If screen needs channel
   self.toPrint = {}
   if self.size[1] == 1 then
     self:tryAddC("No Rec", self.theme.pos, false, true, true)
     self:tryAddC("Channel", self.theme.pos, false, true, true)
     self:tryAddC("-------", self.theme.title, false, true, true)
     self:tryAddC("On Comp", self.theme.info, true)
     self:tryAddC("Type:", self.theme.info, true)
     self:tryAddC("RECEIVE", self.theme.command, true)
     if not self:tryAddC(self.side:upper(), self.theme.command, true) then --If we can't print the full side
       self:tryAddC("[side]",self.theme.command, true)
     end
     self:tryAddC("[Chnl]", self.theme.command, true)
   else
     self:tryAddC("No receiving", self.theme.pos, false, true, true)
     self:tryAddC("channel for", self.theme.pos, false, true, true)
     self:tryAddC("this screen", self.theme.pos, false, true, true)
     self:tryAddC("-----------------", self.theme.title, false, true, true)
     self:tryAddC("On main computer,", self.theme.info, true)
     self:tryAddC("Type:", self.theme.info, true)
     self:tryAdd("", self.theme.command, false, true, true)
     self:tryAddC('"""', self.theme.command, false, true, true)
     self:tryAddC("RECEIVE", self.theme.command, true)
     if not self:tryAddC(self.side:upper(), self.theme.command, true) then --If we can't print the full side
       self:tryAddC("[side]",self.theme.command, true)
     end
     self:tryAddC("[desired channel]", self.theme.command, true)
     self:tryAddC('"""', self.theme.command, false, true, true)
   end
 end
 screenClass.updateStation = function(self)
   self.toPrint = {}
   sepChar = "| "
   local part = math.floor((self.dim[1]-3*#sepChar - 3)/3)
   self:tryAdd(alignL("ID",3)..sepChar..alignL("Side",part)..sepChar..alignL("Channel",part)..sepChar..alignL("Theme",part), self.theme.title, true, true, true)--Headings
   local line = ""
   for i=1, self.dim[1] do line = line.."-" end
   self:tryAdd(line, self.theme.title, false, true, true)
   for a,b in ipairs(screenClass.screens) do
     if b.side ~= "REMOVED" then
       self:tryAdd(alignL(b.id,3)..sepChar..alignL(b.side,part)..sepChar..alignL(b.receive, part)..sepChar..alignL(b.theme.name,part), self.theme.info, true, true, true)--Prints info about all screens
     end
   end
 end
 
 screenClass.updateDisplay = screenClass.updateNormal --Update screen method is normally this one
 
 --Misc
 screenClass.setNormalDisplay = function(self)
   self.updateDisplay = self.updateNormal --This defaults to super if doesn't exist
 end
 screenClass.setHandshakeDisplay = function(self)
   self.updateDisplay = self.updateHandshake --Sets update to handshake version, defaults to super if doesn't exist
 end
 screenClass.setBrokenDisplay = function(self)
   self.updateDisplay = self.updateBroken
 end
 screenClass.setStationDisplay = function(self)
   self.updateDisplay = self.updateStation
 end
 
 --Help Function. Goes so low so can see screenClass.theme
 local function displayHelp()
   local dummy = {term = term} --This will be a dummy "screnClass object" for setting color
   setmetatable(dummy, {__index = screenClass})
   local theme = dummy.theme
   local tab = {}
   local indexOuter = "main"
   local indexInner = 1
   for key, value in pairs(helpResources) do
     tab[key] = {}
     for a in value:gmatch("$$([^$]+)") do
       table.insert(tab[key], a) --Just inserting pages
     end
   end
   while true do
     dummy:setColor(theme.help)
     clearScreen(1,2)
     print(tab[indexOuter][indexInner]:match("\n(.+)")) --Print all but first line
     dummy:setColor(theme.title)
     dummy.term.setCursorPos(1,1)
     print(alignL(tab[indexOuter][indexInner]:match("[^\n]+") or "",({dummy.term.getSize()})[1])) --Print first line
     dummy:setColor(theme.info)
     local text = tostring(indexInner).."/"..tostring(#tab[indexOuter])
     term.setCursorPos(({term.getSize()})[1]-#text,1)
     term.write(text) --Print the current page number
     local event, key = os.pullEvent("key")
     key = keyMap[key]
     if tonumber(key) and tab[tonumber(key)] then
       indexOuter = tonumber(key)
       indexInner = 1
     elseif key == "Q" then
       os.pullEvent("char") --Capture extra event (note: this always works because only q triggers this)
       return true
     elseif key == "0" then --Go back to beginning
       indexOuter, indexInner = "main",1
     elseif key == "up" and indexInner > 1 then
       indexInner = indexInner-1
     elseif key == "down" and indexInner < #tab[indexOuter] then
       indexInner = indexInner + 1
     end
   end
 
 end
 
 
 local function wrapPrompt(prefix, str, dim) --Used to wrap the commandString
   return prefix..str:sub(roundNegative(#str+#prefix-computer.dim[1]+2), -1).."_" --it is str + 2 because we add in the "_"
 end
 
 local function updateAllScreens()
   for a, b in pairs(screenClass.sides) do
     b:updateDisplay()
     b:reset()
     b:pushScreenUpdates()
   end
 end
 --Rednet
 local function newMessageID()
   return math.random(1,2000000000) --1 through 2 billion. Good enough solution
 end
 local function transmit(send, receive, message, legacy, fingerprint)
   fingerprint = fingerprint or replyFingerprint
   if legacy then
     modem.transmit(send, receive, message)
   else
     modem.transmit(send, receive, {message = message, id = newMessageID(), fingerprint = fingerprint})
   end
 end
 
 --QuadRotor
 local function launchQuad(message)
   if quadEnabled and message.emergencyLocation then --This means the turtle is out of fuel. Also that it sent its two initial positions
     local movement = {}
     local function add(what) table.insert(movement,what) end
     add(quadDirection) --Get to the fuel chest
     add("suck")
     add(quadDirection) --So it can properly go down/up first
     local function go(dest, orig, firstMove) --Goes to a place. firstMove because I'm lazy. Its for getting away from computer. If false, its the second move so go one above turtle. If nothing then nothing
       local distX, distY, distZ = dest[1]-orig[1], dest[2]-orig[2], dest[3]-orig[3]
       if firstMove then
         distX = distX - 3 * (quadDirection == "east" and 1 or (quadDirection == "west" and -1 or 0))
         distZ = distZ - 3 * (quadDirection == "south" and 1 or (quadDirection == "north" and -1 or 0))
         distY = distY - 1 --Because the quad is a block above the first thing
       elseif firstMove == false then
         local num = 2
         if message.layersDone  <= 1 then
           num = 1
         end
         distY = distY + num * (distY < 0 and 1 or -1) --This is to be above the turtle and accounts for invert
       end
       add((distY > 0 and "up" or "down").." "..tostring(math.abs(distY)))
       add((distX > 0 and "east" or "west").." "..tostring(math.abs(distX)))
       add((distZ > 0 and "south" or "north").." "..tostring(math.abs(distZ)))
       if firstMove == false and message.layersDone > 1 then
         add(distY < 0 and "down" or "up") --This is so it goes into the turtle's proper layer (invert may or may not work, actually)
       end
     end
     debug("Location Types")
     debug(computerLocation)
     debug(message.firstPos)
     debug(message.secondPos)
     debug(message.emergencyLocation)
     go(message.firstPos, computerLocation, true) --Get to original position of turtle
     go(message.secondPos,message.firstPos) --Get into quarry
     go(message.emergencyLocation, message.secondPos, false)
 
     add("drop")
     add("return")
     for a,b in pairs(movement) do
       debug(a,"   ",b)
     end
     quadBase.flyQuad(movement) --Note, if there are no quadrotors, nothing will happen and the turtle will sit forever
 
   end
 end
 
 --==SET UP==
 clearScreen()
 print("Welcome to Quarry Receiver!")
 sleep(1)
 
 --==ARGUMENTS==
 
 --[[
 Parameters:
   -help/-?/help/?
   -v/verbose --Turn on debugging
   -receiveChannel/channel [channel] --For only the main screen
   -theme --Sets a default theme
   -screen [side] [channel] [theme]
   -station
   -auto --Prompts for all sides, or you can supply a list of receive channels for random assignment!
   -colorEditor
   -quad [cardinal direction] --This looks for a quadrotor from the quadrotors mod. The direction is of the fuel chest.
   -autoRestart --Will reset any attached screen when done, instead of bricking them
 ]]
 
 --tArgs init
 local parameters = {} --Each command is stored with arguments
 
 local function addParam(value)
   val = value:lower()
   if val:match("^%-") then
     parameters[#parameters+1] = {val:sub(2)} --Starts a chain with the command. Can be unpacked later
     parameters[val:sub(2)] = {} --Needed for force/before/after parameters
   elseif parameterIndex ~= 0 then
-    table.insert(parameters[#parameters], value) --value because arguments should be case sensitive for filenames
+
   end
 end
 
 for a,b in ipairs(tArgs) do
   addParam(b)
 end
 
 if parameters.theme then --This goes here so help can display in different theme :)
   screenClass:setTheme(parameters.theme[1])
 end
 
 for a,b in ipairs(tArgs) do
   val = b:lower()
   if val == "help" or val == "-help" or val == "?" or val == "-?" or val == "usage" or val == "-usage" then
     displayHelp() --To make
     error("The End of Help",0)
   end
 end
 
 --Debug parameters
 if parameters.v or parameters.verbose then --Why not
   doDebug = true
 end
 
 for i=1,#parameters do
   debug("Parameter: ",parameters[i][1])
 end
 
 --Options before screen loads
 
 if parameters.modem then
   modemSide = parameters.modem[1]
 end
 
 if parameters.quad then
   if not parameters.quad[1] then parameters.quad[1] = "direction doesn't exist" end
   local dir = parameters.quad[1]:lower():sub(1,1)
   if quadDirections[dir] then
     quadEnabled = true
     quadDirection = quadDirections[dir]
   else
     clearScreen()
     print("Please specify the cardinal direction your quad station is in")
     print("Make sure you have a quad station on one side with a chest behind it, forming a line")
     print("Like this: [computer] [station] [fuel chest]")
     print("The program will now terminate")
     error("",0)
   end
 end
 
 if parameters.autorestart then
   local val = parameters.autorstart[1]
   if not val then
     autoRestart = true --Assume no value = force true
   else
    val = val:sub(1,1):lower()
    autoRestart = not (val == "n" or val == "f")
   end
 end
 
 --Init Modem
 while not initModem() do
   clearScreen()
   print("No modem is connected, please attach one")
   if not peripheral.find then
     print("What side was that on?")
     modemSide = read()
   else
     os.pullEvent("peripheral")
   end
 end
 debug("Modem successfully connected!")
 
 local function autoDetect(channels)
   if type(channels) ~= "table" then channels = {} end
   local tab = peripheral.getNames()
   local index = 1
   for i=1, #tab do
     if peripheral.getType(tab[i]) == "monitor" and not screenClass.sides[tab[i]] then
       screenClass.new(tab[i], channels[index]) --You can specify a list of channels in "auto" parameter
       index = index+1
     end
   end
 end
 
 --Init QuadRotor Station
 if quadEnabled then
   local flag
   while not flag do
     for a,b in ipairs({"front","back","left","right","top"}) do
       if peripheral.isPresent(b) and peripheral.getType(b) == "quadbase" then
         quadBase = peripheral.wrap(b)
       end
     end
     clearScreen()
     if not quadBase then
       print("No QuadRotor Base Attached, please attach one")
     elseif quadBase.getQuadCount() == 0 then
       print("Please install at least one QuadRotor in the base")
       sleep(1) --Prevents screen flickering and overcalling gps
     else
       flag = true
       debug("QuadBase successfully connected!")
     end
     if not computerLocation and not gps.locate(5) then
       flag = false
       error("No GPS lock. Please make a GPS network to use quadrotors")
     else
       computerLocation = {gps.locate(5)}
       debug("GPS Location Acquired")
     end
   end
 end
 
 --Init Computer Screen Object (was defined at top)
 computer = screenClass.new("computer", (parameters.receivechannel and parameters.receivechannel[1]) or (parameters.channel and parameters.channel[1]))--This sets channel, checking if parameter exists
 computer.updateNormal = function(self)
   screenClass.updateNormal(self)
   computer:displayCommand()
 end
 computer.updateHandshake = function(self) --Not in setHandshake because that func checks object updateHandshake
   screenClass.updateHandshake(self)
   computer:displayCommand()
 end
 computer.updateBroken = function(self)
   screenClass.updateBroken(self)
   computer:displayCommand()
 end
 computer.updateStation = function(self)--This gets set in setSize
   screenClass.updateStation(self)
   self:displayCommand()
 end
 
 
 for i=1, #parameters do --Do actions for parameters that can be used multiple times
   local command, args = parameters[i][1], parameters[i] --For ease
   if command == "screen" then
     if not screenClass.sides[args[2]] then --Because this screwed up the computer
       local a = screenClass.new(args[2], args[3], args[4])
       debug(type(a))
     else
       debug("Overwriting existing screen settings for '",args[2],"'")
       local a = screenClass.sides[args[2]]
       a:setChannel(tonumber(args[3]))
       a:setTheme(args[4])
     end
   end
   if command == "station" then --This will set the screen update to display stats on all other monitors
     if not args[2] or args[2]:lower() == "computer" then --Not below because it exists
       computer:setStation() --This handles setting updateNormal, setHandshakeDisplay, etc
     else
       local a = screenClass.new(args[2], nil, args[3]) --This means syntax is -station [side] [theme]
       if a then --If the screen actually exists
         a:setStation()
       end
     end
   end
 end
 
 if parameters.auto then --This must go after computer declaration so computer ID is 1
   autoDetect(parameters.auto)
   addParam("-station") --Set computer as station
   addParam("computer") --Yes, I'm literally just feeding in more tArgs like from IO
 end
 
 computer.displayCommand = function(self)
   local sideString = ((defaultSide and " (") or "")..(defaultSide or "")..((defaultSide and ")") or "")
   if self.size == 1 then
     self:tryAddRaw(self.dim[2], wrapPrompt("Cmd"..sideString:sub(2,-2)..": ", commandString, self.dim[1]), self.theme.command, true)
   else
     self:tryAddRaw(self.dim[2], wrapPrompt("Command"..sideString..": ",commandString, self.dim[1]), self.theme.command, true) --This displays the last part of a string.
   end
 end
 --Initializing the computer screen
 if parameters.coloreditor then
 
   computer:removeChannel() --So it doesn't receive messages
   computer.isStation = true --So we can't assign a channel
 
   computer.updateNormal = function(self) --This is only for editing colors
     self.toPrint = {}
     for i=1, #requiredColors do
       self:tryAdd(requiredColors[i], self.theme[requiredColors[i]],true)
     end
     self:displayCommand()
   end
   computer.updateHandshake = computer.updateNormal
   computer.updateBroken = computer.updateNormal
   computer.updateStation = computer.updateNormal
 end
 computer:setSize() --Update changes made to display functions
 
 for a,b in pairs(screenClass.sides) do debug(a) end
 
 --==FINAL CHECKS==
 
 --If only one screen and computer has no channel, make it a station
 if #screenClass.screens > 1 and not computer.receive then
   debug("Only one screen, no comp channel. Setting station")
   computer:setStation()
 end
 
 --Updating all screen for first time and making sure channels are open
 for a, b in pairs(screenClass.sides) do
   b:setSize()
   b:updateDisplay()--Finish initialization process
   b:reset()
   b:pushScreenUpdates()
 end
 
 --Handshake will be handled in main loop
 
 --[[Workflow
   Wait for events
   modem_message
     if valid channel and valid message, update appropriate screen
   key
     if any letter, add to command string if room.
     if enter key
       if valid self command, execute command. Commands:
         command [side] [command] --If only one screen, then don't need channel. Send a command to a turtle
         screen [side] [channel] [theme] --Links a new screen to use.
         remove [side] --Removes a screen
         theme [themeName] --Sets the default theme
         theme [side] [themeName] --Changes this screen's theme
         savetheme [new name] [themeName]
         color [side/theme] [colorName] [textColor] [backgroundColor]
         side [side] --Sets a default side, added to prompts
         set [string] --Sets a default command, added to display immediately
         receive [side] [newChannel] --Changes the channel of the selected screen
         send [side] [newChannel]
         auto --Automatically adds screens not connected
         station --Sets the selected screen as a station (or resets if already a station)
         exit/quit/end
   peripheral_detach
     check what was lost, if modem, set to nil. If screen side, do screen:setSize()
   peripheral
     check if screen side already added
       reset screen size
   monitor_resize
     resize proper screen
   monitor_touch
     if screen already added
       select screen on main computer
     else
       add screen
 
 ]]
 
 --Modes: 1 - Sided, 2 - Not Sided, 3 - Both sided and not
 local validCommands = {command = 1, screen = 2, remove = 1, theme = 3, exit = 2, quit = 2, ["end"] = 2, color = 3, side = 2, set = 2, receive = 1, send = 1, savetheme = 2,
                        auto = 2, verbose = 2, quiet = 2, station = 1}
 while continue do
   local event, par1, par2, par3, par4, par5 = os.pullEvent()
   ----MESSAGE HANDLING----
   if event == "modem_message" and screenClass.channels[par2] then --If we got a message for a screen that exists
     local screen = screenClass.channels[par2] --For convenience
     if not screen.send then --This is the handshake
       debug("\nChecking handshake. Received: ",par4)
       local flag = false
       if par4 == expectedMessage then --Legacy quarries don't accept receiver dropping in mid-run
         screen.legacy = true --Accepts serialized tables
         flag = true
       elseif type(par4) == "table" and par4.fingerprint == expectedFingerprint then --Don't care about expected message, allows us to start receiver mid-run, fingerprint should be pretty specific
         screen.legacy = false
         flag = true
       end
 
       if flag and (autoRestart or (not autoRestart and not screen.isDone)) then --We don't accept handshakes when we don't want autorestarts
         screen.isDone = false
         screen.rec = copyTable(screenClass.rec) --Need to reset this. Existing message from restart doesn't have everything
         debug("Screen ",screen.side," received a handshake")
         screen.send = par3
         screen:setSize() --Resets update method to proper since channel is set
         debug("Sending back on ",screen.send)
         transmit(screen.send,screen.receive, replyMessage, screen.legacy)
       end
 
     else --Everything else is for regular messages
 
       local rec
       if screen.legacy then --We expect strings here
         if type(par4) == "string" then --Otherwise its not ours
           if par4 == "stop" then --This is the stop message. All other messages will be ending ones
             screen.isDone = true
           elseif par4 == expectedMessage then --We support dropping in mid-run
             debug("Screen ",screen.side," received mid-run handshake")
             transmit(screen.send,screen.receive, replyMessage, screen.legacy)
           elseif textutils.unserialize(par4) then
             rec = textutils.unserialize(par4)
             rec.distance = par5
           end
         end
       elseif type(par4) == "table" and par4.fingerprint == expectedFingerprint then --Otherwise, we check if it is valid message
 
         if type(par4.message) == "table" then
           rec = par4.message
           if not par4.distance then --This is cool because it can add distances from the repeaters
             rec.distance = par5
           else
             rec.distance = par4.distance + par5
           end
           if rec.isDone then
             screen.isDone = true
             screen.send = nil --So that we can receive handshakes again.
           end
         elseif par4.message == expectedMessage then
           debug("Screen ",screen.side," received mid-run handshake")
           transmit(screen.send,screen.receive, replyMessage, screen.legacy)
         else
           debug("Message received did not contain table")
         end
       end
 
       if rec then
         rec.distance = math.floor(rec.distance)
         rec.label = rec.label or "Quarry!"
         screen.rec = rec --Set the table
         --Updating screen occurs outside of the if
         local toSend
         if screen.queuedMessage then
           toSend = screen.queuedMessage
           screen.queuedMessage = nil
         else
           toSend = replyMessage
         end
         if not screen.isDone then --Because then sendChannel doesn't exist
           transmit(screen.send,screen.receive, toSend, screen.legacy) --Send reply message for turtle
         end
       end
 
     end
 
     launchQuad(screen.rec) --Launch the Quad! (This only activates when turtle needs it)
 
     screen:updateDisplay() --isDone is queried inside this
     screen:reset(screen.theme.background)
     screen:pushScreenUpdates() --Actually write things to screen
     --if screen.isDone and not autoRestart then screen:removeChannel() end --Don't receive any more messages. Allows turtle to think connected. Done after message sending so no error :)
 
   ----KEY HANDLING----
   elseif event == "key" and keyMap[par1] then
     local key = keyMap[par1]
     if key ~= "enter" then --If we aren't submitting a command
       if key == "backspace" then
         if #commandString > 0 then
           commandString = commandString:sub(1,-2)
         end
       elseif key == "up" then
         commandString = lastCommand or commandString --Set to last command, or do nothing if it doesn't exist
       elseif key == "down" then
         commandString = "" --If key down, clear
       elseif #key == 1 then
         commandString = commandString..key
       end
     --ALL THE COMMANDS
     else --If we are submitting a command
       lastCommand = commandString --For using up arrow
       local args = {}
       for a in commandString:gmatch("%S+") do --This captures all individual words in the command string
         args[#args+1] = a:lower()
       end
       local command = args[1]
       if validCommands[command] then --If it is a valid command...
         local commandType = validCommands[command]
         if commandType == 1 or commandType == 3 then --If the command requires a "side" like transmitting commands, versus setting a default
           if defaultSide then table.insert(args, 2, defaultSide) end
           local screen
           local test = screenClass.screens[tonumber(args[2])]
           if test and test.side ~= "REMOVED" then --This way we can specify IDs as well
             screen = test
           else
             screen = screenClass.sides[args[2]]
           end
           if screen then --If the side exists
             if command == "command" and screen.send then --If sending command to the turtle
               screen.queuedMessage = table.concat(args," ", 3) --Tells message handler to send appropriate message
               --transmit(screen.send, screen.receive, table.concat(args," ", 3), screen.legacy) --This transmits all text in the command with spaces. Duh this is handled when we get message
             end
 
             if command == "color" then
               screen.theme:addColor(args[3],colors[args[4]],colors[args[5]] )
               updateAllScreens() --Because we are changing a theme color which others may have
             end
             if command == "theme" then
               screen:setTheme(args[3])
             end
             if command == "send" then --This changes a send channel, and can also revert to handshake
               local chan = checkChannel(tonumber(args[3]) or -1)
               if chan then screen.send = chan else screen.send = nil end
               screen:setSize() --If on handshake, resets screen
             end
             if command == "receive" and not screen.isStation then
               local chan = checkChannel(tonumber(args[3]) or -1)
               if chan and not screenClass.channels[chan] then
                 screen:setChannel(chan)
                 screen:setSize() --Update broken status
               end
             end
             if command == "station" then
               if screen.isStation then screen:removeStation() else screen:setStation() end
             end
             if command == "remove" and screen.side ~= "computer" then --We don't want to remove the main display!
               print()
               screen:remove()
             else --Because if removed it does stupid things
               screen:reset()
               debug("here")
               screen:updateDisplay()
               debug("Here")
               screen:pushScreenUpdates()
               debug("Hereer")
             end
           end
         end
         if commandType == 2 or commandType == 3 then--Does not require a screen side
           if command == "screen" and peripheral.getType(args[2]) == "monitor" then  --Makes sure there is a monitor on the screen side
             if not args[3] or not screenClass.channels[tonumber(args[3])] then --Make sure the channel doesn't already exist
               local mon = screenClass.new(args[2], args[3], args[4])
                 --args[3] is the channel  and will set broken display if it doesn't exist
                 --args[4] is the theme, and will default if doesn't exists.
               mon:updateDisplay()
               mon:reset()
               mon:pushScreenUpdates()
             end
           end
           if command == "theme" then
             screenClass:setTheme(args[2], true) --Otherwise this would set base theme to nil, erroring
             updateAllScreens()
           end
           if command == "color" and themes[args[2]] then
             themes[args[2]]:addColor(args[3],colors[args[4]],colors[args[5]])
             updateAllScreens() --Because any screen could have this theme
           end
           if command == "side" then
             if screenClass.sides[args[2]] then
               defaultSide = args[2]
             else
               defaultSide = nil
             end
           end
           if command == "set" then
             if args[2] then
               defaultCommand = table.concat(args," ",2)
               defaultCommand = defaultCommand:upper()
             else
               defaultCommand = nil
             end
           end
           if command == "savetheme" then
             if saveTheme(themes[args[2]], args[3]) then
               computer:tryAddRaw(computer.dim[2]-1, "Save Theme Succeeded!", computer.theme.inverse, true)
             else
               computer:tryAddRaw(computer.dim[2]-1, "Save Theme Failed!", computer.theme.inverse, true)
             end
             computer:reset()
             computer:pushScreenUpdates()
             sleep(1)
           end
           if command == "auto" then
             local newTab = copyTable(args) --This is so we can pass all additional words as channel numbers
             table.remove(newTab, 1)
             autoDetect(newTab)
             updateAllScreens()
           end
           if command == "verbose" then doDebug = true end
           if command == "quiet" then doDebug = false end
           if command == "quit" or command == "exit" or command == "end" then
             continue = false
           end
         end
       else
         debug("\nInvalid Command")
       end
       if defaultCommand then commandString = defaultCommand.." " else commandString = "" end --Reset command string because it was sent
     end
 
 
     --Update computer display (computer is only one that displays command string
     computer:updateDisplay() --Note: Computer's method automatically adds commandString to last line
     if not continue then computer:tryAddRaw(computer.dim[2]-1,"Program Exiting", computer.theme.inverse, false, true, true) end
     computer:reset()
     computer:pushScreenUpdates()
 
   elseif event == "monitor_resize" then
     local screen = screenClass.sides[par1]
     if screen then
       screen:setSize()
       screen:updateDisplay()
       screen:reset()
       screen:pushScreenUpdates()
     end
   elseif event == "monitor_touch" then
     local screen = screenClass.sides[par1]
     debug("Side: ",par1," touched")
     if screen then --This part is copied from the "side" command
       local test = button.checkPoint(screen.buttons, {par2, par3})
       if test then
         screen.queuedMessage = test
       else
         if not screen.receive then
           commandString = "RECEIVE "..par1:upper().." "
         end
       end
     else
       debug("Adding Screen")
       local mon = screenClass.new(par1)
       commandString = "RECEIVE "..mon.side:upper().." "
       mon:reset()
       mon:updateDisplay()
       mon:pushScreenUpdates()
 
     end
     computer:reset()
     computer:updateDisplay()
     computer:pushScreenUpdates() --Need to update computer for command string
   elseif event == "mouse_click" then
     screen = computer
     local test = button.checkPoint(screen.buttons, {par2, par3})
     if test then
       screen.queuedMessage = test
     end
 
   elseif event == "peripheral_detach" then
     local screen = screenClass.sides[par1]
     if screen then
       screen:setSize()
     end
     --if screen then
     --  screen:remove()
     --end
 
   elseif event == "peripheral" then
     local screen = screenClass.sides[par1]
     if screen then
       screen:setSize()
     elseif peripheral.getType(par1) == "monitor" then
       commandString = "SCREEN "..par1:upper().." "
     end
 
   end
 
   local flag = false --Saying all screens are done, must disprove
   local count = 0 --We want it to wait if no screens have channels
   for a,b in pairs(screenClass.channels) do
     count = count + 1
     if autoRestart or not b.isDone then
       flag = true
     end
   end
   if continue and count > 0 then --If its not already false from something else
     continue = flag
   end
 
   if #stationsList > 0 and event ~= "key" and event ~= "char" then --So screen is properly updated
     for a, b in ipairs(stationsList) do
       b:reset()
       b:updateDisplay()
       b:pushScreenUpdates()
     end
   end
 
 
 end
 
 sleep(1.5)
 for a in pairs(screenClass.channels) do
   modem.close(a)
 end
 for a, b in pairs(screenClass.sides) do
   if not b.isDone then --Otherwise we want it display the ending stats
     b:setTextColor(colors.white)
     b:setBackgroundColor(colors.black)
     b.term.clear()
     b.term.setCursorPos(1,1)
   end
 end
 
 local text --Fun :D
 if computer.isComputer then text = "SUPER COMPUTER OS 9000"
 elseif computer.isTurtle then text = "SUPER DIAMOND-MINING OS XXX"
 elseif computer.isPocket then text = "PoCkEt OOS AMAYZE 65"
 end
 if text and not computer.isDone then
   computer:say(text, computer.theme.title,1)
 else
   computer.term.setCursorPos(1,computer.dim[2])
   computer.term.clearLine()
 end
 --Down here shut down all the channels, remove the saved file, other cleanup stuff