Quarry Receiver 3.5.4

--Quarry Receiver Version 3.5.4
--Made by Civilwargeeky
--[[
Ideas:


]]
--[[
Recent Changes:
  Completely Remade!
]]

local commandHelpParagraph = [[
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
Help: This :D
]]


--Config
local doDebug = false --For testing purposes
local ySizes = 3 --There are 3 different Y Screen Sizes right now

--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
--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 queuedMessage --If a command needs to be sent, this gets set
local defaultSide
local defaultCommand

local keyMap = {[57] = " ", [11] = "0", [12] = "_", [52] = "."} --This is for command string
for i=2,10 do keyMap[i] = tostring(i-1) end --Add numbers
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.backspace] = "backspace"

--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 align(text, xDim, direction)
  text = tostring(text or "None")
  if #text >= xDim then return text 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)
  return align(text, xDim, "right")
end
local function alignL(text, xDim)
  return align(text, xDim, "left")
end
local function center(text, xDim)
  xDim = xDim or dim[1] --Temp fix
  local a = (xDim-#text)/2
  for i=1, a do
    text = " "..text.." "
  end
  return text
end
local function roundNegative(num) --Rounds numbers up to 0
  if num >= 0 then return num else return 0 end
end
local function displayHelp()
  print("I am help!")
  print("This will be done later")
  print("For now just check the forum")
  print("Press any key")
  os.pullEvent("key")
  error("",0)
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 peripheral.getType(modemSide or "") == "modem" then
      modem = peripheral.wrap(modemSide)
      if not modem.isWireless() then --Apparently this is a thing
        modem = nil
        return false
      end
      return true
    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

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, name, text, back) --Background is optional. Will not change if nil
    name = name or "none"
    self[name] = {text = text, background = back}
    return self --Allows for chaining :)
  end
  themes[name] = self
  return self
end

local requiredColors = {"title", "subtitle", "pos", "dim", "extra", "error", "info", "inverse", "command", "help", "background"}

--This is how adding colors will work
newTheme("default")
  :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.lightGray)
  :addColor("command", colors.lightBlue, colors.black)
  :addColor("help", colors.red, colors.white)
  :addColor("background", colors.white, colors.black)

newTheme("random")
  :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)

--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


--==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
  return self:setTextColor(color.text) and self:setBackgroundColor(color.background)
end

screenClass.themeName = "default" --Setting super for fallback
screenClass.theme = themes.default


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 = { --Initial values for all displayed numbers
    label = "Quarry Bot",
    id = 1,
    percent = 0,
    relxPos = 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
    --Maybe add in some things like if going to then add a field
  }

  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
  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
  screenClass.channels[tab.receive] = nil
  if modem and modem.isOpen(tab.receive) then
    modem.close(tab.receive)
  end
end

--Init Functions
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 not self.receive then
    self:setBrokenDisplay() --This will prompt user to set channel
  elseif self.send then --This allows for class inheritance
    self:init() --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.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
      local addedTheme = newTheme(file.readLine() or "newTheme") --Initializes the new theme
      for line in function() return file.readLine() end do --Go through all the color lines (hopefully not the first one. Requires testing)
        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
      file.close()
      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
      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
  text = text or "NIL"
  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")
      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.updateNormal = function(self) --This is the normal updateDisplay function
  local str = tostring
  self.toPrint = {} --Reset table
  local message, theme = self.rec, self.theme

  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).."%", self.dim[1]), 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.relxPos), 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("Open:"..alignR(str(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.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("-------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.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("-------Pos--------", theme.subtitle, false, true, true)
      self:tryAdd("X Coordinate:"..alignR(str(message.relxPos), 5), theme.pos, true)
      self:tryAdd("Z Coordinate:"..alignR(str(message.zPos), 5), theme.pos , true)
      self:tryAdd("On Layer:"..alignR(str(message.layersDone), 9), 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("-------Dim--------", theme.subtitle, false, true, true)
      self:tryAdd("Total X:"..alignR(str(message.x), 10), theme.dim, false, true, true)
      self:tryAdd("Total Z:"..alignR(str(message.z), 10), theme.dim, false, true, true)
      self:tryAdd("Total Layers:"..alignR(str(message.layers), 5), theme.dim, false, true, true)
      self:tryAdd("Volume"..alignR(str(message.volume),12), theme.dim, false, false, true)

      self:tryAdd("------Extras------", theme.subtitle, false, false, true)
      self:tryAdd("Time: "..alignR(textutils.formatTime(os.time()):gsub(" ","").."", 12), theme.extra, false, false, true) --Adds the current time, formatted, without spaces.
      self:tryAdd("Used Slots:"..alignR(str(16-message.openSlots),7), theme.extra, false, false, true)
      self:tryAdd("Blocks Mined:"..alignR(str(message.mined), 5), theme.extra, false, false, true)
      self:tryAdd("Spaces Moved:"..alignR(str(message.moved), 5), theme.extra, false, false, true)
      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),self.dim[1]-#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),self.dim[1]-6), theme.extra, true)

      self:tryAdd("Percentage Done: "..alignR(str(message.percent).."%",self.dim[1]-17), theme.pos, true)

      local var1 = math.max(#str(message.x), #str(message.z), #str(message.layers))
      local var2 = (self.dim[1]-6-var1+3)/3
      self:tryAdd("Pos: "..alignR(" X:"..alignR(str(message.relxPos),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 ----____",self.dim[1]), theme.subtitle, false, false, true)
      self:tryAdd(center("Time:"..alignR(textutils.formatTime(os.time()),8), self.dim[1]), theme.extra, false, true, true)
      self:tryAdd(center("Current Day: "..str(os.day()), self.dim[1]), theme.extra, false, false, true)
      self:tryAdd("Used Inventory Slots: "..alignR(str(16-message.openSlots),self.dim[1]-22), theme.extra, false, true, true)
      self:tryAdd("Blocks Mined: "..alignR(str(message.mined),self.dim[1]-14), theme.extra, false, true, true)
      self:tryAdd("Blocks Moved: "..alignR(str(message.moved),self.dim[1]-14), theme.extra, false, true, true)
      self:tryAdd("Distance to Turtle: "..alignR(str(message.distance), self.dim[1]-20), theme.extra, false, false, true)
      self:tryAdd("Actual Y Pos (Not Layer): "..alignR(str(message.yPos), self.dim[1]-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.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
  else --If is done
    if self.size[1] == 1 then --Special case for small monitors
      self:tryAdd("Done", theme.title, true)
      self:tryAdd("Dug"..alignR(str(message.mined),4), theme.pos, true)
      self:tryAdd("Fuel"..alignR(str(message.fuel),3), theme.pos, true)
      self:tryAdd("-------", theme.subtitle, false,true,true)
      self:tryAdd("Turtle", theme.subtitle, false, true, true)
      self:tryAdd(center("is", self.dim[1]), theme.subtitle, false, true, true)
      self:tryAdd(center("Done!", self.dim[1]), theme.subtitle, false, true, true)
    else
      self:tryAdd("Done!", theme.title, true)
      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)
      self:tryAdd("Curr Fuel: "..str(message.fuel), theme.inverse, true)
    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.updateDisplay = screenClass.updateNormal --Update screen method is normally this one

--Misc
screenClass.init = function(self) --Currently used by computer screen to replace its original method
  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


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

--==SET UP==
clearScreen()
print("Welcome to Quarry Receiver!")
sleep(1)

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!")

--==ARGUMENTS==

--[[
Parameters:
  -help/-?/help/?
  -receiveChannel [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
]]

--tArgs and peripheral list init
local tArgs = {...}
local parameters = {} --Each command is stored with arguments
local parameterIndex = 0 --So we can add new commands to the right table
for a,b in ipairs(tArgs) do
  val = b:lower()
  if val == "help" or val == "-help" or val == "?" or val == "-?" then
    displayHelp() --To make
    error("The End of Help",0)
  end
  if val:match("^%-") then
    parameterIndex = parameterIndex + 1
    parameters[parameterIndex] = {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[parameterIndex], b) --b because arguments should be case sensitive for filenames
    table.insert(parameters[parameters[parameterIndex][1]], b) --Needed for force/after parameters
  end
end

for i=1,#parameters do
  debug("Parameter: ",parameters[i][1])
end

--Options before screen loads
if parameters.theme then
  screenClass:setTheme(parameters.theme[1])
end

--Init Computer Screen Object (was defined at top)
computer = screenClass.new("computer", parameters.receivechannel and parameters.receivechannel[1])--This sets channel, checking if parameter exists


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
--Technically, you could have any screen be the station, but oh well.
--Initializing the computer screen
if parameters.station then --This will set the screen update to display stats on all other monitors. For now it does little
  if computer.receive then
    screenClass.receiveChannels[computer.receive] = nil --Because it doesn't have a channel
  end
  computer.receive = nil --So it doesn't receive messages
  computer.send = nil
  computer.isStation = true --For updating

  computer.updateNormal = function(self)--This gets set in setSize
    self.toPrint = {}
    local part = math.floor(self.dim[1]/4)-1
    self:tryAdd(alignL(" ID",part).."| "..alignL("Side",part).."| "..alignL("Channel",part).."| "..alignL("Theme",part), self.theme.title, false, 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
      self:tryAdd(" "..alignL(b.id,part-1).."| "..alignL(b.side,part).."| "..alignL(b.receive, part).."| "..alignL(b.theme.name,part), self.theme.info, false, true, true) --Prints info about all screens
    end
    self:displayCommand()
  end
  computer.setHandshakeDisplay = computer.init --Handshake is same as regular
  computer.setBrokenDisplay = computer.init
elseif parameters.coloreditor then

  if computer.receive then --This part copied from above
    screenClass.receiveChannels[computer.receive] = nil --Because it doesn't have a channel
  end
  computer.receive = nil --So it doesn't receive messages
  computer.send = nil
  computer.isStation = true --So we can't assign a channel

  computer.updateNormal = function(self) --This is only for editing colors
    self.toPrint = {}
    for a,b in pairs(self.theme) do
      if type(b) == "table" then
        self:tryAdd(a, b, true)
      end
    end
    self:displayCommand()
  end
  computer.updateHandshake = computer.updateNormal
  computer.updateBroken = computer.updateNormal
else --If computer is a regular screen
  computer.updateNormal = function(self)
    screenClass.updateDisplay(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
end
computer:setSize() --Update changes made to display functions


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
    local a = screenClass.new(args[2], args[3], args[4])
    debug(type(a))
  end

end

for a,b in pairs(screenClass.sides) do debug(a) end

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
if parameters.auto then autoDetect(parameters.auto) end


--==FINAL CHECKS==

--Updating all screen for first time and making sure channels are open
for a, b in pairs(screenClass.sides) do
  if b.receive then --Because may not have channel
    if not modem.isOpen(b.receive) then modem.open(b.receive) end
  end
  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
        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}
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
        screen.legacy = true --Accepts serialized tables
        flag = true
      elseif type(par4) == "table" and par4.message == expectedMessage and par4.fingerprint == expectedFingerprint then
        screen.legacy = false
        flag = true
      end

      if flag then
        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
          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 queuedMessage then
          toSend = queuedMessage
          queuedMessage = nil
        else
          toSend = replyMessage
        end
        transmit(screen.send,screen.receive, toSend, screen.legacy) --Send reply message for turtle
      end

    end

    screen:updateDisplay() --isDone is queried inside this
    screen:reset(screen.theme.background)
    screen:pushScreenUpdates() --Actually write things to screen


  ----KEY HANDLING----
  elseif event == "key" and keyMap[par1] then
    local key = par1
    if key ~= keys.enter then --If we aren't submitting a command
      if key == keys.backspace then
        if #commandString > 0 then
          commandString = commandString:sub(1,-2)
        end
      else
        commandString = commandString..keyMap[key]
      end
    else --If we are submitting a command
      local args = {}
      for a in commandString:gmatch("%S+") do
        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 = screenClass.sides[args[2]]
          if screen then --If the side exists
            if command == "command" and screen.send then --If sending command to the turtle
              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] or ""],colors[args[5] or ""])
              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
                if screen.receive then --Computer may not have a channel yet
                  modem.close(screen.receive)
                  screenClass.channels[screen.receive] = nil
                end
                modem.open(chan)
                screen.receive = chan
                screenClass.channels[chan] = screen
                screen:setSize() --Update broken status
              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()
              screen:updateDisplay()
              screen:pushScreenUpdates()
            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
            autoDetect()
            updateAllScreens()
          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
      if defaultSide ~= par1 then
        defaultSide = par1
      else
        defaultSide = nil
      end
    else
      debug("Adding Screen")
      local mon = screenClass.new(par1)
      mon:reset()
      mon:updateDisplay()
      mon:pushScreenUpdates()

    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()
    end
    --Maybe prompt to add a new screen? I don't know

  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 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 computer.isStation and event ~= "key" then --So screen is properly updated
    computer:reset()
    computer:updateDisplay()
    computer:pushScreenUpdates()
  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