Dibujar

-- Variable Setup
-- Command Line input Table
local argTable = {...}

-- Flag Variables: These are conditions for different features (all flags are named foo_bar, all other variables are named fooBar)
local cmd_line = false
local cmd_line_resume = false
local cmd_line_cost_only = false
local chain_next_shape = false -- This tells goHome() where to end, if true it goes to (0, 0, positionZ) if false it goes to (-1, -1, 0)
local special_chain = false -- For certain shapes that finish where the next chained shape should start, goHome() will  only turn to face 0 if true
local cost_only = false
local sim_mode = false
local resupply = false
local enderchest_refilling = false
local can_use_gps = false
local return_to_home = false -- whether the turtle shall return to start after build

-- Record Keeping Variables: These are for recoding the blocks and fuel used
local blocks = 0
local fuel = 0

-- Position Tracking Variables: These are for keeping track of the turtle's position
local positionX = 0
local positionY = 0
local positionZ = 0
local facing = 0
local gpsPositionX = 0
local gpsPositionY = 0
local gpsPositionZ = 0
local gpsFacing = 0

-- General Variables: Other variables that don't fit in the other categories
local choice = ""

-- Progress Table: These variables are the tables that the turtle's progress is tracked in
local tempProgTable = {}
local progTable = {} --This is the LOCAL table!  used for local stuff only, and is ONLY EVER WRITTEN when sim_mode is FALSE
local progFileName = "ShapesProgressFile"

-- Utility functions

function writeOut(...) -- ... lets writeOut() pass any arguments to print(). so writeOut(1,2,3) is the same as print(1,2,3). previously writeOut(1,2,3) would have been the same as print(1)
    for i, v in ipairs(arg) do
        print(v)
    end
end

function getInput(inputType, message, option1, option2)
    local input = ""
    if inputType == "string" then
        writeOut(message.. "(" ..option1 .. " or "..option2..")" )
        while true do
            input = io.read()
            input = string.lower(input)
            if input ~= option1 and input ~= option2 then
                writeOut("You didn't enter a valid option. Please try again.")
            else
                return input
            end
        end
    end
    if inputType == "int" then
        writeOut(message)
        while true do
            input = io.read()
            if tonumber(input) ~= nil then
                return tonumber(input)
            else
                writeOut("Need a number. Please try again")
            end
        end
    end
end

function wrapModules() -- checks for and wraps turtle modules
    local test = 0
    if peripheral.getType("left" )== "resupply" then
        resupplymodule=peripheral.wrap("left")
        resupply = true
    elseif peripheral.getType("right") == "resupply" then
        resupplymodule=peripheral.wrap("right")
        resupply = true
    end
    if peripheral.getType("left") == "modem" then
        modem=peripheral.wrap("left")
        test, _, _ = gps.locate(1)
        if test ~= nil then
            can_use_gps = true
        end
    elseif peripheral.getType("right") == "modem" then
        modem=peripheral.wrap("right")
        test, _, _ = gps.locate(1)
        if test ~= nil then
            can_use_gps = true
        end
    end
    if resupply then
        return "resupply"
    end
end

function linkToRSStation() -- Links to resupply station
    if resupplymodule.link() then
        return true
    else
        writeOut("Please put Resupply Station to the left of the turtle and press Enter to continue")
        io.read()
        linkToRSStation()
    end
end

function compareResources()
    if (turtle.compareTo(1) == false) then
        turtle.drop()
    end
end

function firstFullSlot()
    for i = 1, 16 do
        if (turtle.getItemCount(i) > 1) then
            return i
        end
    end
end

function turtleEmpty()
    for i = 1, 16 do
        if (turtle.getItemCount(i) > 1) then
            return false
        end
    end
    return true
end

function checkResources()
    if resupply then
        if turtle.getItemCount(activeSlot) <= 1 then
            while not(resupplymodule.resupply(1)) do
                os.sleep(0.5)
            end
        end
    elseif enderchest_refilling then
        compareResources()
        while (turtle.getItemCount(activeSlot) <= 1) do
            if (activeSlot == 15) and (turtle.getItemCount(activeSlot)<=1) then
                turtle.select(16)
                turtle.digUp()
                for i = 1, 15 do
                    turtle.select(i)
                    turtle.drop()
                end
                turtle.select(16)
                turtle.placeUp()
                turtle.select(1)
                for i = 1, 15 do
                    turtle.suckUp()
                end
                turtle.select(16)
                turtle.digUp()
                activeSlot = 1
                turtle.select(activeSlot)
            else
                activeSlot = activeSlot + 1
                -- writeOut("Turtle slot empty, trying slot "..activeSlot)
                turtle.select(activeSlot)
            end
            compareResources()
            os.sleep(0.2)
        end
    else
        compareResources()
        while (turtle.getItemCount(activeSlot) <= 1) do
            if turtleEmpty() then
                writeOut("Turtle is empty, please put building block in slots and press enter to continue")
                io.read()
                activeSlot = 1
                turtle.select(activeSlot)
            else
                activeSlot = firstFullSlot()
                turtle.select(activeSlot)
            end
            compareResources()
        end
    end
end

function checkFuel()
    if (not(tonumber(turtle.getFuelLevel()) == nil)) then
        while turtle.getFuelLevel() < 50 do
            writeOut("Turtle almost out of fuel, pausing. Please drop fuel in inventory. And press enter.")
            io.read()
            turtle.refuel()
        end
    end
end

function placeBlock()
    blocks = blocks + 1
    simulationCheck()
    if cost_only then
        return
    end
    if turtle.detectDown() and not turtle.compareDown() then
        turtle.digDown()
    end
    checkResources()
    turtle.placeDown()
    progressUpdate()
end

function round(toBeRounded, decimalPlace) -- Needed for hexagon and octagon
    local multiplier = 10^(decimalPlace or 0)
    return math.floor(toBeRounded * multiplier + 0.5) / multiplier
end

-- Navigation functions
-- Allow the turtle to move while tracking its position
-- This allows us to just give a destination point and have it go there

function turnRightTrack()
    simulationCheck()
    facing = facing + 1
    if facing >= 4 then
        facing = 0
    end
    progressUpdate()
    if cost_only then
        return
    end
    turtle.turnRight()
end

function turnLeftTrack()
    simulationCheck()
    facing = facing - 1
    if facing < 0 then
        facing = 3
    end
    progressUpdate()
    if cost_only then
        return
    end
    turtle.turnLeft()
end

function turnAroundTrack()
    turnLeftTrack()
    turnLeftTrack()
end

function turnToFace(direction)
    if (direction < 0) then
        return false
    end
    direction = direction % 4
    while facing ~= direction do
        turnRightTrack()
    end
    return true
end

function safeForward()
    simulationCheck()
    if facing == 0 then
        positionY = positionY + 1
    elseif facing == 1 then
        positionX = positionX + 1
    elseif facing == 2 then
        positionY = positionY - 1
    elseif facing == 3 then
        positionX = positionX - 1
    end
    fuel = fuel + 1
    progressUpdate()
    if cost_only then
        return
    end
    checkFuel()
    local success = false
    local tries = 0
    while not success do
        success = turtle.forward()
        if not success then
            while (not success) and tries < 6 do
                tries = tries + 1
                turtle.dig()
                success = turtle.forward()
                sleep(0.3)
            end
            if not success then
                writeOut("Blocked attempting to move forward.")
                writeOut("Please clear and press enter to continue.")
                io.read()
            end
        end
    end
end

function safeBack()
    simulationCheck()
    if facing == 0 then
        positionY = positionY - 1
    elseif facing == 1 then
        positionX = positionX - 1
    elseif facing == 2 then
        positionY = positionY + 1
    elseif facing == 3 then
        positionX = positionX + 1
    end
    fuel = fuel + 1
    progressUpdate()
    if cost_only then
        return
    end
    checkFuel()
    local success = false
    local tries = 0
    while not success do
        success = turtle.back()
        if not success then
            turnAroundTrack()
            while turtle.detect() and tries < 6 do
                tries = tries + 1
                if turtle.dig() then
                    break
                end
                sleep(0.3)
            end
            turnAroundTrack()
            success = turtle.back()
            if not success then
                writeOut("Blocked attempting to move back.")
                writeOut("Please clear and press enter to continue.")
                io.read()
            end
        end
    end
end

function safeUp()
    simulationCheck()
    positionZ = positionZ + 1
    fuel = fuel + 1
    progressUpdate()
    if cost_only then
        return
    end
    checkFuel()
    local success = false
    while not success do
        success = turtle.up()
        if not success then
            while turtle.detectUp() do
                if not turtle.digUp() then
                    writeOut("Blocked attempting to move up.")
                    writeOut("Please clear and press enter to continue.")
                    io.read()
                end
            end
        end
    end
end

function safeDown()
    simulationCheck()
    positionZ = positionZ - 1
    fuel = fuel + 1
    progressUpdate()
    if cost_only then
        return
    end
    checkFuel()
    local success = false
    while not success do
        success = turtle.down()
        if not success then
            while turtle.detectDown() do
                if not turtle.digDown() then
                    writeOut("Blocked attempting to move down.")
                    writeOut("Please clear and press enter to continue.")
                    io.read()
                end
            end
        end
    end
end

function moveY(targetY)
    if targetY == positionY then
        return
    end
    if (facing ~= 0 and facing ~= 2) then -- Check axis
        turnRightTrack()
    end
    while targetY > positionY do
        if facing == 0 then
            safeForward()
        else
            safeBack()
        end
    end
    while targetY < positionY do
        if facing == 2 then
            safeForward()
        else
            safeBack()
        end
    end
end

function moveX(targetX)
    if targetX == positionX then
        return
    end
    if (facing ~= 1 and facing ~= 3) then -- Check axis
        turnRightTrack()
    end
    while targetX > positionX do
        if facing == 1 then
            safeForward()
        else
            safeBack()
        end
    end
    while targetX < positionX do
        if facing == 3 then
            safeForward()
        else
            safeBack()
        end
    end
end

function moveZ(targetZ)
    if targetZ == positionZ then
        return
    end
    while targetZ < positionZ do
        safeDown()
    end
    while targetZ > positionZ do
        safeUp()
    end
end

-- I *HIGHLY* suggest formatting all shape subroutines to use the format that dome() uses;  specifically, navigateTo(x,y,[z]) then placeBlock().  This should ensure proper "data recording" and also makes readability better
function navigateTo(targetX, targetY, targetZ, move_z_first)
    targetZ = targetZ or positionZ -- If targetZ isn't used in the function call, it defaults to its current z position, this should make it compatible with all previous implementations of navigateTo()
    move_z_first = move_z_first or false -- Defaults to moving z last, if true is passed as 4th argument, it moves vertically first

    if move_z_first then
        moveZ(targetZ)
    end

    if facing == 0 or facing == 2 then -- Y axis
        moveY(targetY)
        moveX(targetX)
    else
        moveX(targetX)
        moveY(targetY)
    end

    if not move_z_first then
        moveZ(targetZ)
    end
end

function goHome()
    if chain_next_shape then
        if not special_chain then
            navigateTo(0, 0) -- So another program can chain multiple shapes together to create bigger structures
        end
    else
        navigateTo(-1, -1, 0) -- So the user can collect the turtle when it is done, not 0,0,0 because some shapes use the 0,0 column
    end
    turnToFace(0)
end

-- Shape Building functions

function drawLine(endX, endY, startX, startY)
    startX = startX or positionX
    startY = startY or positionY
    deltaX = math.abs(endX - startX)
    deltaY = math.abs(endY - startY)
    errorVar = 0
    if deltaX >= deltaY then
        deltaErr = math.abs(deltaY/deltaX)
        if startX < endX then
            if startY < endY then
                counterY = startY
                for counterX = startX, endX do
                    navigateTo(counterX, counterY)
                    placeBlock()
                    errorVar = errorVar + deltaErr
                    if errorVar >= 0.5 then
                        counterY = counterY + 1
                        errorVar = errorVar - 1
                    end
                end
            else
                counterY = startY
                for counterX = startX, endX do
                    navigateTo(counterX, counterY)
                    placeBlock()
                    errorVar = errorVar + deltaErr
                    if errorVar >= 0.5 then
                        counterY = counterY - 1
                        errorVar = errorVar - 1
                    end
                end
            end
        else
            if startY < endY then
                counterY = startY
                for counterX = startX, endX, -1 do
                    navigateTo(counterX, counterY)
                    placeBlock()
                    errorVar = errorVar + deltaErr
                    if errorVar >= 0.5 then
                        counterY = counterY + 1
                        errorVar = errorVar - 1
                    end
                end
            else
                counterY = startY
                for counterX = startX, endX, -1 do
                    navigateTo(counterX, counterY)
                    placeBlock()
                    errorVar = errorVar + deltaErr
                    if errorVar >= 0.5 then
                        counterY = counterY - 1
                        errorVar = errorVar - 1
                    end
                end
            end
        end
    else
        deltaErr = math.abs(deltaX/deltaY)
        if startY < endY then
            if startX < endX then
                counterX = startX
                for counterY = startY, endY do
                    navigateTo(counterX, counterY)
                    placeBlock()
                    errorVar = errorVar + deltaErr
                    if errorVar >= 0.5 then
                        counterX = counterX + 1
                        errorVar = errorVar - 1
                    end
                end
            else
                counterX = startX
                for counterY = startY, endY do
                    navigateTo(counterX, counterY)
                    placeBlock()
                    errorVar = errorVar + deltaErr
                    if errorVar >= 0.5 then
                        counterX = counterX - 1
                        errorVar = errorVar - 1
                    end
                end
            end
        else
            if startX < endX then
                counterX = startX
                for counterY = startY, endY, -1 do
                    navigateTo(counterX, counterY)
                    placeBlock()
                    errorVar = errorVar + deltaErr
                    if errorVar >= 0.5 then
                        counterX = counterX + 1
                        errorVar = errorVar - 1
                    end
                end
            else
                counterX = startX
                for counterY = startY, endY, -1 do
                    navigateTo(counterX, counterY)
                    placeBlock()
                    errorVar = errorVar + deltaErr
                    if errorVar >= 0.5 then
                        counterX = counterX - 1
                        errorVar = errorVar - 1
                    end
                end
            end
        end
    end
end

function rectangle(width, depth, startX, startY)
    startX = startX or positionX
    startY = startY or positionY
    endX = startX + width - 1
    endY = startY + depth - 1
    drawLine(startX, endY, startX, startY)
    drawLine(endX, endY, startX, endY)
    drawLine(endX, startY, endX, endY)
    drawLine(startX, startY, endX, startY)
end

function square(length, startX, startY)
    startX = startX or positionX
    startY = startY or positionY
    rectangle(length, length, startX, startY)
end

function wall(depth, height)
    for i = 1, depth do
        for j = 1, height do
            placeBlock()
            if j < height then
                navigateTo(positionX, positionY, positionZ + 1)
            end
        end
        if (i ~= depth) then
            navigateTo(positionX, positionY + 1, 0)
        end
    end
end

function platform(width, depth, startX, startY)
    startX = startX or positionX
    startY = startY or positionY
    endX = startX + width - 1
    endY = startY + depth - 1
    forward = true
    for counterY = startY, endY do
        if forward then
            for counterX = startX, endX do
                navigateTo(counterX, counterY)
                placeBlock()
            end
        else
            for counterX = endX, startX, -1 do
                navigateTo(counterX, counterY)
                placeBlock()
            end
        end
        forward = not forward
    end
end

function cuboid(width, depth, height, hollow)
    platform(width, depth, 0, 0)
    for i = 1, height - 1 do
        navigateTo(0, 0, i)
        if (hollow == "n") then
            platform(width, depth, 0, 0)
        else
            rectangle(width, depth, 0, 0)
        end
    end
    navigateTo(0,0,height)
    platform(width, depth, 0, 0)
end

function pyramid(length, hollow)
    -- local height = math.ceil(length / 2) - 1
    i = 0
    while (length > 0) do
        navigateTo(i, i, i)
        if (hollow == "y") then
            rectangle(length, length, i, i)
        else
            platform(length, length, i, i)
        end
        i = i + 1
        length = length - 2
    end
end

function stair(width, height, startX, startY) -- Last two might be able to be used to make a basic home-like shape later?
    startX = startX or positionX
    startY = startY or positionY
    endX = startX + width - 1
    endY = startY + height - 1
    forward = true
    for counterY = startY, endY do
        if forward then
            for counterX = startX, endX do
                navigateTo(counterX, counterY)
                placeBlock()
            end
        else
            for counterX = endX, startX, -1 do
                navigateTo(counterX, counterY)
                placeBlock()
            end
        end
        if counterY ~= endY then
            navigateTo(positionX, positionY, positionZ + 1)
            forward = not forward
        end
    end
end

function circle(diameter)
    odd = not (math.fmod(diameter, 2) == 0)
    radius = diameter / 2;
    if odd then
        width = (2 * math.ceil(radius)) + 1;
        offset = math.floor(width/2);
    else
        width = (2 * math.ceil(radius)) + 2;
        offset = math.floor(width/2) - 0.5;
    end
    --diameter --radius * 2 + 1
    sqrt3 = 3 ^ 0.5
    boundaryRadius = radius + 1.0
    boundary2 = boundaryRadius ^ 2
    radius2 = radius ^ 2
    z = math.floor(radius)
    cz2 = (radius - z) ^ 2
    limitOffsetY = (boundary2 - cz2) ^ 0.5
    maxOffsetY = math.ceil(limitOffsetY)
    -- We do first the +x side, then the -x side to make movement efficient
    for side = 0,1 do
            -- On the right we go from small y to large y, on the left reversed
            -- This makes us travel clockwise (from below) around each layer
            if (side == 0) then
                yStart = math.floor(radius) - maxOffsetY
                yEnd = math.floor(radius) + maxOffsetY
                yStep = 1
            else
                yStart = math.floor(radius) + maxOffsetY
                yEnd = math.floor(radius) - maxOffsetY
                yStep = -1
            end
            for y = yStart,yEnd,yStep do
                cy2 = (radius - y) ^ 2
                remainder2 = (boundary2 - cz2 - cy2)
                if remainder2 >= 0 then
                    -- This is the maximum difference in x from the centre we can be without definitely being outside the radius
                    maxOffsetX = math.ceil((boundary2 - cz2 - cy2) ^ 0.5)
                    -- Only do either the +x or -x side
                    if (side == 0) then
                        -- +x side
                        xStart = math.floor(radius)
                        xEnd = math.floor(radius) + maxOffsetX
                    else
                        -- -x side
                        xStart = math.floor(radius) - maxOffsetX
                        xEnd = math.floor(radius) - 1
                    end
                    -- Reverse direction we traverse xs when in -y side
                    if y > math.floor(radius) then
                        temp = xStart
                        xStart = xEnd
                        xEnd = temp
                        xStep = -1
                    else
                        xStep = 1
                    end

                    for x = xStart,xEnd,xStep do
                        -- Only blocks within the radius but still within 1 3d-diagonal block of the edge are eligible
                        if isSphereBorder(offset, x, y, z, radius2) then
                            navigateTo(x, y)
                            placeBlock()
                        end
                    end
                end
            end
        end
end

function blockInSphereIsFull(offset, x, y, z, radiusSq)
    x = x - offset
    y = y - offset
    z = z - offset
    x = x ^ 2
    y = y ^ 2
    z = z ^ 2
    return x + y + z <= radiusSq
end

function isSphereBorder(offset, x, y, z, radiusSq)
    spot = blockInSphereIsFull(offset, x, y, z, radiusSq)
    if spot then
        spot = not blockInSphereIsFull(offset, x, y - 1, z, radiusSq) or
            not blockInSphereIsFull(offset, x, y + 1, z, radiusSq) or
            not blockInSphereIsFull(offset, x - 1, y, z, radiusSq) or
            not blockInSphereIsFull(offset, x + 1, y, z, radiusSq) or
            not blockInSphereIsFull(offset, x, y, z - 1, radiusSq) or
            not blockInSphereIsFull(offset, x, y, z + 1, radiusSq)
    end
    return spot
end

function dome(typus, diameter)
    -- Main dome and sphere building routine
    odd = not (math.fmod(diameter, 2) == 0)
    radius = diameter / 2;
    if odd then
        width = (2 * math.ceil(radius)) + 1;
        offset = math.floor(width/2);
    else
        width = (2 * math.ceil(radius)) + 2;
        offset = math.floor(width/2) - 0.5;
    end
    --diameter --radius * 2 + 1
    sqrt3 = 3 ^ 0.5
    boundaryRadius = radius + 1.0
    boundary2 = boundaryRadius ^ 2
    radius2 = radius ^ 2

    if typus == "dome" then
        zstart = math.ceil(radius)
    elseif typus == "sphere" then
        zstart = 1
    elseif typus == "bowl" then
        zstart = 1
    end
    if typus == "bowl" then
        zend = math.floor(radius)
    else
        zend = width - 1
    end

    -- This loop is for each vertical layer through the sphere or dome.
    for z = zstart,zend do
        if not cost_only and z ~= zstart then
            navigateTo(positionX, positionY, positionZ + 1)
        end
        --writeOut("Layer " .. z)
        cz2 = (radius - z) ^ 2
        limitOffsetY = (boundary2 - cz2) ^ 0.5
        maxOffsetY = math.ceil(limitOffsetY)
        -- We do first the +x side, then the -x side to make movement efficient
        for side = 0,1 do
            -- On the right we go from small y to large y, on the left reversed
            -- This makes us travel clockwise (from below) around each layer
            if (side == 0) then
                yStart = math.floor(radius) - maxOffsetY
                yEnd = math.floor(radius) + maxOffsetY
                yStep = 1
            else
                yStart = math.floor(radius) + maxOffsetY
                yEnd = math.floor(radius) - maxOffsetY
                yStep = -1
            end
            for y = yStart,yEnd,yStep do
                cy2 = (radius - y) ^ 2
                remainder2 = (boundary2 - cz2 - cy2)
                if remainder2 >= 0 then
                    -- This is the maximum difference in x from the centre we can be without definitely being outside the radius
                    maxOffsetX = math.ceil((boundary2 - cz2 - cy2) ^ 0.5)
                    -- Only do either the +x or -x side
                    if (side == 0) then
                        -- +x side
                        xStart = math.floor(radius)
                        xEnd = math.floor(radius) + maxOffsetX
                    else
                        -- -x side
                        xStart = math.floor(radius) - maxOffsetX
                        xEnd = math.floor(radius) - 1
                    end
                    -- Reverse direction we traverse xs when in -y side
                    if y > math.floor(radius) then
                        temp = xStart
                        xStart = xEnd
                        xEnd = temp
                        xStep = -1
                    else
                        xStep = 1
                    end

                    for x = xStart,xEnd,xStep do
                        -- Only blocks within the radius but still within 1 3d-diagonal block of the edge are eligible
                        if isSphereBorder(offset, x, y, z, radius2) then
                            navigateTo(x, y)
                            placeBlock()
                        end
                    end
                end
            end
        end
    end
end

function cylinder(diameter, height)
    for i = 1, height do
        circle(diameter)
        navigateTo(positionX, positionY, positionZ + 1)
    end
end

polygonCornerList = {} -- Public list of corner coords for n-gons, will be used for hexagons, octagons, and future polygons.
-- It should be constructed as a nested list eg. {{x0,y0},{x1,y1},{x2,y2}...}

function constructPolygon() -- Uses polygonCornerList to draw sides between each point
    if #polygonCornerList == 0 then
        return false
    end
    for i = 1, #polygonCornerList do
        startX = polygonCornerList[i][1]
        startY = polygonCornerList[i][2]
        if i == #polygonCornerList then
            j = 1
        else
            j = i + 1
        end
        stopX = polygonCornerList[j][1]
        stopY = polygonCornerList[j][2]
        drawLine(stopX, stopY, startX, startY)
    end
    return true
end

function arbitraryPolygon(numberOfSides, Radius) -- Future function, this will eventually replace octagon and hexagon functions
end

function hexagon(sideLength) -- Fills out polygonCornerList with the points for a hexagon
    sideLength = sideLength - 1
    local changeX = sideLength / 2
    local changeY = round(math.sqrt(3) * changeX, 0)
    changeX = round(changeX, 0)
    polygonCornerList[1] = {changeX, 0}
    polygonCornerList[2] = {(changeX + sideLength), 0}
    polygonCornerList[3] = {((2 * changeX) + sideLength), changeY}
    polygonCornerList[4] = {(changeX + sideLength), (2 * changeY)}
    polygonCornerList[5] = {changeX, (2 * changeY)}
    polygonCornerList[6] = {0, changeY}
    if not constructPolygon() then
        error("This error should never happen.")
    end
end

function octagon(sideLength) -- Fills out polygonCornerList with the points for an octagon
    sideLength = sideLength - 1
    local change = round((sideLength - 1) / math.sqrt(2), 0)
    polygonCornerList[1] = {change, 0}
    polygonCornerList[2] = {(change + sideLength), 0}
    polygonCornerList[3] = {((2 * change) + sideLength), change}
    polygonCornerList[4] = {((2 * change) + sideLength), (change + sideLength)}
    polygonCornerList[5] = {(change + sideLength), ((2 * change) + sideLength)}
    polygonCornerList[6] = {change, ((2 * change) + sideLength)}
    polygonCornerList[7] = {0, (change + sideLength)}
    polygonCornerList[8] = {0, change}
    if not constructPolygon() then
        error("This error should never happen.")
    end
end

function sixprism(length, height)
    for i = 1, height do
        hexagon(length)
        if i ~= height then
            navigateTo(positionX, positionY, positionZ + 1)
        end
    end
end

function eightprism(length, height)
    for i = 1, height do
        octagon(length)
        if i ~= height then
            navigateTo(positionX, positionY, positionZ + 1)
        end
    end
end

-- Previous Progress Resuming, Simulation functions, Command Line, and File Backend
-- Will check for a "progress" file.
function CheckForPrevious()
    if fs.exists(progFileName) then
        return true
    else
        return false
    end
end

-- Creates a progress file, containing a serialized table consisting of the shape type, shape input params, and the last known x, y, and z coords of the turtle (beginning of build project)
function ProgressFileCreate()
    if not CheckForPrevious() then
        fs.makeDir(progFileName)
        return true
    else
        return false
    end
end

-- Deletes the progress file (at the end of the project, or at beginning if user chooses to delete old progress)
function ProgressFileDelete()
    if fs.exists(progFileName) then
        fs.delete(progFileName)
        return true
    else
        return false
    end
end

-- To read the shape params from the file.  Shape type, and input params (e.g. "dome" and radius)
function ReadShapeParams()
    -- TODO. Unneeded for now, can just use the table elements directly
end

function WriteShapeParams(...) -- The ... lets it take any number of arguments and stores it to the table arg{} | This is still unused anywhere
    local paramTable = arg
    local paramName = "param"
    local paramName2 = paramName
    for i, v in ipairs(paramTable) do -- Iterates through the args passed to the function, ex. paramTable[1] i = 1 so paramName2 should be "param1", tested and works!
        paramName2 = paramName .. i
        tempProgTable[paramName2] = v
        progTable[paramName2] = v
    end
end

-- function to write the progress to the file (x, y, z)
function writeProgress()
    local progFile
    local progString = ""
    if not (sim_mode or cost_only) then
        progString = textutils.serialize(progTable) -- Put in here to save processing time when in cost_only
        progFile = fs.open(progFileName, "w")
        progFile.write(progString)
        progFile.close()
    end

end

-- Reads progress from file (shape, x, y, z, facing, blocks, param1, param2, param3)
function readProgress()
    local progFile = fs.open(progFileName, "r")
    local readProgTable = textutils.unserialize(progFile.readAll())
    progFile.close()
    return readProgTable
end

-- compares the progress read from the file to the current sim progress.  needs all four params
function compareProgress()
    local progTableIn = progTable
    local readProgTable = readProgress()
    if (progTableIn.shape == readProgTable.shape and progTableIn.x == readProgTable.x and progTableIn.y == readProgTable.y and progTableIn.blocks == readProgTable.blocks and progTableIn.facing == readProgTable.facing) then
        writeOut("All caught up!")
        return true -- We're caught up!
    else
        return false -- Not there yet...
    end
end

function getGPSInfo() -- TODO: finish this
    position = gps.locate()
    gpsPositionX = position.x
    gpsPositionZ = position.y
    gpsPositionY = position.z

end

function setSimFlags(b)
    sim_mode = b
    cost_only = b
    if cmd_line_cost_only then
        cost_only = true
    end
end

function simulationCheck() -- checks state of the simulation
    if sim_mode then
        if compareProgress() then
            setSimFlags(false) -- If we're caught up, un-set flags
        else
            setSimFlags(true)  -- If not caught up, just re-affirm that the flags are set
        end
    end
end

function continueQuery()
    if cmd_line_resume then
         return true
    else
         if not cmd_line then
             writeOut("Do you want to continue the last job?")
             local yes = io.read()
             if yes == "y" then
                 return true
             else
                 return false
             end
         end
    end
end

function progressUpdate()  -- This ONLY updates the local table variable.  Writing is handled above. -- I want to change this to allow for any number of params
    progTable = {shape = choice, enderchest_refilling = tempProgTable.enderchest_refilling, param1 = tempProgTable.param1, param2 = tempProgTable.param2, param3 = tempProgTable.param3, param4 = tempProgTable.param4, x = positionX, y = positionY, z = positionZ, facing = facing, blocks = blocks}
    if not sim_mode then
        writeProgress()
    end
end

 -- Command Line
function checkCommandLine() --True if arguments were passed
    if #argTable > 0 then
        cmd_line = true
        return true
    else
        cmd_line = false
        return false
    end
end

function needsHelp() -- True if -h is passed
    for i, v in pairs(argTable) do
        if v == "-h" or v == "-help" or v == "--help" then
            return true
        else
            return false
        end
    end
end

function setFlagsFromCommandLine() -- Sets count_only, chain_next_shape, and sim_mode
    for i, v in pairs(argTable) do
        if v == "-c" or v == "-cost" or v == "--cost" then
            cost_only = true
            cmd_line_cost_only = true
            writeOut("Cost Only Mode")
        end
        if v == "-z" or v == "-chain" or v == "--chain" then
            chain_next_shape = true
            writeOut("Chained Shape Mode")
        end
        if v == "-r" or v == "-resume" or v == "--resume" then
            cmd_line_resume = true
            writeOut("Resuming")
        end
        if v == "-e" or v == "-ender" or v == "--ender" then
            enderchest_refilling = true
            tempProgTable.enderchest_refilling = true
            writeOut("Enderchest Mode")
        end
        if v == "-g" or v == "-home" or v == "--home" then
            return_to_home = true
            writeOut("Will return home")
        end
    end
end

function setTableFromCommandLine() -- Sets progTable and tempProgTable from command line arguments
    progTable.shape = argTable[1]
    tempProgTable.shape = argTable[1]
    local paramName = "param"
    local paramName2 = paramName
    for i = 2, #argTable do
        local addOn = tostring(i - 1)
        paramName2 = paramName .. addOn
        progTable[paramName2] = argTable[i]
        tempProgTable[paramName2] = argTable[i]
    end
end

-- Menu, Drawing and Main functions

function choiceIsValidShape(choice)
    local validShapes = {"rectangle", "square", "line", "wall", "platform", "stair", "stairs", "cuboid", "1/2-sphere", "1/2 sphere", "dome", "bowl", "sphere", "circle", "cylinder", "pyramid", "hexagon", "octagon", "6-prism", "6 prism", "8-prism", "8 prism"}
    for i = 1, #validShapes do
        if choice == validShapes[i] then
            return true
        end
    end
    return false
end

function choiceFunction()
    if sim_mode == false and cmd_line == false then -- If we are NOT resuming progress
        local page = 1
        choice = io.read()
        choice = string.lower(choice) -- All checks are aginst lower case words so this is to ensure that
        while ((choice == "next") or (choice == "back")) do
            if (choice == "next") then
                if page == 1 then
                    writeMenu2()
                    page = 2
                else
                    writeMenu()
                    page = 1
                end
            end
            if (choice == "back") then
                if page == 1 then
                    writeMenu2()
                    page = 2
                else
                    writeMenu()
                    page = 1
                end
            end
            choice = io.read()
            choice = string.lower(choice) -- All checks are aginst lower case words so this is to ensure that
        end
        if choice == "end" or choice == "exit" then
            writeOut("Goodbye.")
            return
        end
        if choice == "help" then
            getHelp()
            return
        end
        if choice == "credits" then
            showCredits()
            return
        end
        tempProgTable = {shape = choice}
        progTable = {shape = choice}
        if not choiceIsValidShape(choice) then
            writeOut(choice ..  " is not a valid shape choice.")
            return
        end
        writeOut("Building a "..choice)
        local yes = getInput("string","Want to just calculate the cost?","y","n")
        if yes == 'y' then
            cost_only = true
        end
        local yes = getInput("string","Want turtle to return to start after build?","y","n")
        if yes == 'y' then
            return_to_home = true
        end
        local yes = getInput("string","Want the turtle to refill from enderchest (slot 16)?","y","n")
        if yes == 'y' then
            enderchest_refilling = true
            tempProgTable.enderchest_refilling = true
        end
    elseif sim_mode == true then -- If we ARE resuming progress
        tempProgTable = readProgress()
        choice = tempProgTable.shape
        choice = string.lower(choice) -- All checks are aginst lower case words so this is to ensure that
        enderchest_refilling =  tempProgTable.enderchest_refilling
    elseif cmd_line == true then -- If running from command line
        if needsHelp() then
            showCmdLineHelp()
            return
        end
        choice = tempProgTable.shape
        choice = string.lower(choice) -- All checks are aginst lower case words so this is to ensure that
        enderchest_refilling =  tempProgTable.enderchest_refilling
        writeOut("Building a "..choice)
    end
    if not cost_only then
        turtle.select(1)
        activeSlot = 1
        if turtle.getItemCount(activeSlot) == 0 then
            if resupply then
                writeOut("Please put building blocks in the first slot.")
            else
                writeOut("Please put building blocks in the first slot (and more if you need them)")
            end
            while turtle.getItemCount(activeSlot) <= 1 do
                os.sleep(.1)
            end
        end
    else
        activeSlot = 1
    end
    -- Shape selection if cascade
    -- Line based shapes
    if choice == "rectangle" then
        local depth = 0
        local width = 0
        if sim_mode == false and cmd_line == false then
            width = getInput("int","How wide does it need to be?")
            depth = getInput("int","How deep does it need to be?")
        elseif sim_mode == true or cmd_line == true then
            width = tempProgTable.param1
            depth = tempProgTable.param2
        end
        tempProgTable.param1 = width
        tempProgTable.param2 = depth
        progTable = {param1 = width, param2 = depth} -- THIS is here because we NEED to update the local table!
        rectangle(width, depth)
    end
    if choice == "square" then
        local sideLength
        if sim_mode == false and cmd_line == false then
            sideLength = getInput("int","How long does each side need to be?")
        elseif sim_mode == true or cmd_line == true then
            sideLength = tempProgTable.param1
        end
        tempProgTable.param1 = sideLength
        progTable = {param1 = sideLength}
        square(sideLength)
    end
    if choice == "line" then
        local startX = 0
        local startY = 0
        local endX = 0
        local endY = 0
        if sim_mode == false and cmd_line == false then
            writeOut("Note that the turtle's starting position is 0, 0.")
            startX = getInput("int","Where does the start X need to be?")
            startY = getInput("int","Where does the start Y need to be?")
            endX = getInput("int","Where does the end X need to be?")
            endY = getInput("int","Where does the end Y need to be?")
        elseif sim_mode == true or cmd_line == true then
            startX = tempProgTable.param1
            startY = tempProgTable.param2
            endX = tempProgTable.param3
            endY = tempProgTable.param4
        end
        tempProgTable.param1 = startX
        tempProgTable.param2 = startY
        tempProgTable.param3 = endX
        tempProgTable.param4 = endY
        progTable = {param1 = startX, param2 = startY, param3 = endX, param4 = endY}
        drawLine(endX, endY, startX, startY)
    end
    if choice == "wall" then
        local depth = 0
        local height = 0
        if sim_mode == false and cmd_line == false then
            depth = getInput("int","How deep does it need to be?")
            height = getInput("int","How high does it need to be?")
        elseif sim_mode == true or cmd_line == true then
            depth = tempProgTable.param1
            height = tempProgTable.param2
        end
        tempProgTable.param1 = depth
        tempProgTable.param2 = height
        progTable = {param1 = depth, param2 = height}
        wall(depth, height)
    end
    if choice == "platform" then
        local width = 0
        local depth = 0
        if sim_mode == false and cmd_line == false then
            width = getInput("int","How wide does it need to be?")
            depth = getInput("int","How deep does it need to be?")
        elseif sim_mode == true or cmd_line == true then
            width = tempProgTable.param1
            depth = tempProgTable.param2
        end
        tempProgTable.param1 = width
        tempProgTable.param2 = depth
        progTable = {param1 = width, param2 = depth}
        platform(width, depth)
    end
    if choice == "stair" or choice == "stairs" then
        local width = 0
        local height = 0
        if sim_mode == false and cmd_line == false then
            width = getInput("int","How wide does it need to be?")
            height = getInput("int","How high does it need to be?")
        elseif sim_mode == true or cmd_line == true then
            width = tempProgTable.param1
            height = tempProgTable.param2
        end
        tempProgTable.param1 = width
        tempProgTable.param2 = height
        progTable = {param1 = width, param2 = height}
        stair(width, height)
        special_chain = true
    end
    if choice == "cuboid" then
        local width = 0
        local depth = 0
        local height = 0
        local hollow = ""
        if sim_mode == false and cmd_line == false then
            width = getInput("int","How wide does it need to be?")
            depth = getInput("int","How deep does it need to be?")
            height = getInput("int","How high does it need to be?")
            hollow = getInput("string","Does it need to be hollow?","y","n")
        elseif sim_mode == true or cmd_line == true then
            width = tempProgTable.param1
            depth = tempProgTable.param2
            height = tempProgTable.param3
            hollow = tempProgTable.param4
        end
        tempProgTable.param1 = width
        tempProgTable.param2 = depth
        tempProgTable.param3 = height
        tempProgTable.param4 = hollow
        progTable = {param1 = width, param2 = depth, param3 = height}
        cuboid(width, depth, height, hollow)
    end
    if choice == "pyramid" then
        local length = 0
        local hollow = ""
        if sim_mode == false and cmd_line == false then
            length = getInput("int","How long does each side of the base layer need to be?")
            hollow = getInput("string","Does it need to be hollow?","y","n")
        elseif sim_mode == true or cmd_line == true then
            length = tempProgTable.param1
            hollow = tempProgTable.param2
        end
        tempProgTable.param1 = length
        tempProgTable.param2 = hollow
        progTable = {param1 = length, param2 = hollow}
        pyramid(length, hollow)
    end
    -- Circle based shapes
    if choice == "1/2-sphere" or choice == "1/2 sphere" then
        local diameter = 0
        local half = ""
        if sim_mode == false and cmd_line == false then
            diameter = getInput("int","What diameter does it need to be?")
            half = getInput("string","What half of the sphere does it need to be?","bottom","top")
        elseif sim_mode == true or cmd_line == true then
            diameter = tempProgTable.param1
            half = tempProgTable.param2
        end
        tempProgTable.param1 = diameter
        tempProgTable.param2 = half
        progTable = {param1 = diameter, param2 = half}
        if half == "bottom" then
            dome("bowl", diameter)
        elseif half == "top" then
            dome("dome", diameter)
        end
    end
    if choice == "dome" then
        local diameter = 0
        if sim_mode == false and cmd_line == false then
            diameter = getInput("int","What diameter does it need to be?")
        elseif sim_mode == true or cmd_line == true then
            diameter = tempProgTable.param1
        end
        tempProgTable.param1 = diameter
        progTable = {param1 = diameter}
        dome("dome", diameter)
    end
    if choice == "bowl" then
        local diameter = 0
        if sim_mode == false and cmd_line == false then
            diameter = getInput("int","What diameter does it need to be?")
        elseif sim_mode == true or cmd_line == true then
            diameter = tempProgTable.param1
        end
        tempProgTable.param1 = diameter
        progTable = {param1 = diameter}
        dome("bowl", diameter)
    end
    if choice == "sphere" then
        local diameter = 0
        if sim_mode == false and cmd_line == false then
            diameter = getInput("int","What diameter does it need to be?")
        elseif sim_mode == true or cmd_line == true then
            diameter = tempProgTable.param1
        end
        tempProgTable.param1 = diameter
        progTable = {param1 = diameter}
        dome("sphere", diameter)
    end
    if choice == "circle" then
        local diameter = 0
        if sim_mode == false and cmd_line == false then
            diameter = getInput("int","What diameter does it need to be?")
        elseif sim_mode == true or cmd_line == true then
            diameter = tempProgTable.param1
        end
        tempProgTable.param1 = diameter
        progTable = {param1 = diameter}
        circle(diameter)
    end
    if choice == "cylinder" then
        local diameter = 0
        local height = 0
        if sim_mode == false and cmd_line == false then
            diameter = getInput("int","What diameter does it need to be?")
            height = getInput("int","How high does it need to be?")
        elseif sim_mode == true or cmd_line == true then
            diameter = tempProgTable.param1
            height = tempProgTable.param2
        end
        tempProgTable.param1 = diameter
        tempProgTable.param2 = height
        progTable = {param1 = diameter, param2 = height}
        cylinder(diameter, height)
    end
    -- Polygon shapes
    if choice == "hexagon" then
        local length = 0
        if sim_mode == false and cmd_line == false then
            length = getInput("int","How long does each side need to be?")
        elseif sim_mode == true or cmd_line == true then
            length = tempProgTable.param1
        end
        tempProgTable.param1 = length
        progTable = {param1 = length}
        hexagon(length)
    end
    if choice == "octagon" then
        local length = 0
        if sim_mode == false and cmd_line == false then
            length = getInput("int","How long does each side need to be?")
        elseif sim_mode == true or cmd_line == true then
            length = tempProgTable.param1
        end
        tempProgTable.param1 = length
        progTable = {param1 = length}
        octagon(length)
    end
    if choice == "6-prism" or choice == "6 prism" then
        local length = 0
        local height = 0
        if sim_mode == false and cmd_line == false then
            length = getInput("int","How long does each side need to be?")
            height = getInput("int","How high does it need to be?")
        elseif sim_mode == true or cmd_line == true then
            length = tempProgTable.param1
            height = tempProgTable.param2
        end
        tempProgTable.param1 = length
        tempProgTable.param2 = height
        progTable = {param1 = length, param2 = height}
        sixprism(length, height)
    end
    if choice == "8-prism" or choice == "8 prism" then
        local length = 0
        local height = 0
        if sim_mode == false and cmd_line == false then
            length = getInput("int","How long does each side need to be?")
            height = getInput("int","How high does it need to be?")
        elseif sim_mode == true or cmd_line == true then
            length = tempProgTable.param1
            height = tempProgTable.param2
        end
        tempProgTable.param1 = length
        tempProgTable.param2 = height
        progTable = {param1 = length, param2 = height}
        eightprism(length, height)
    end
    if return_to_home then
        goHome() -- After all shape building has finished
    end
    writeOut("Done") -- Saves a few lines when put here rather than in each if statement
end

function writeMenu()
    term.clear()
    term.setCursorPos(1, 1)
    writeOut("Shape Maker 1.7 by Keridos/CupricWolf/pokemane")
    if resupply then                    -- Any ideas to make this more compact/better looking (in terms of code)?
        writeOut("Resupply Mode Active")
    elseif (resupply and can_use_gps) then
        writeOut("Resupply and GPS Mode Active")
    elseif can_use_gps then
        writeOut("GPS Mode Active")
    else
        writeOut("Standard Mode Active")
    end
    if not cmd_line then
        writeOut("What shape do you want to build? [page 1/2]");
        writeOut("next for page 2")
        writeOut("+---------+-----------+-------+-------+")
        writeOut("| square  | rectangle | wall  | line  |")
        writeOut("| cylinder| platform  | stair | cuboid|")
        writeOut("| pyramid | 1/2-sphere| sphere| circle|")
        writeOut("+---------+-----------+-------+-------+")
        writeOut("")
    end
end

function writeMenu2()
    term.clear()
    term.setCursorPos(1, 1)
    writeOut("Shape Maker 1.7 by Keridos/CupricWolf/pokemane")
    if resupply then                    -- Any ideas to make this more compact/better looking (in terms of code)?
        writeOut("Resupply Mode Active")
    elseif (resupply and can_use_gps) then
        writeOut("Resupply and GPS Mode Active")
    elseif can_use_gps then
        writeOut("GPS Mode Active")
    else
        writeOut("Standard Mode Active")
    end
    writeOut("What shape do you want to build? [page 2/2]");
    writeOut("back for page 1")
    writeOut("+---------+-----------+-------+-------+")
    writeOut("| hexagon | octagon   | dome  |       |")
    writeOut("| 6-prism | 8-prism   | bowl  |       |")
    writeOut("| help    | credits   | end   |       |")
    writeOut("+---------+-----------+-------+-------+")
    writeOut("")
end

function showCmdLineHelp()
    term.clear()
    term.setCursorPos(1, 1)
    writeOut("Command line help")
    writeOut("Usage: shape [shape-type] [param1] [param2] [param3] [param4] [-c] [-h] [-z] [-r]\n")
    writeOut("-c or -cost or --cost: Activate cost only mode\n")
    writeOut("-h or -help or --help: Show this information")
    io.read()
    writeOut("-z or -chain or --chain: Lets you chain together multiple shapes\n")
    writeOut("-g or -home or --home: Make turtle go 'home' after build\n")
    writeOut("-r or -resume or --resume: Resume the last build if possible")
    io.read()
    writeOut("-e or -ender or --ender: Activate enderchest refilling\n")
    writeOut("shape-type can be any of the shapes in the menu\n")
    writeOut("After shape-type input all of the paramaters for the shape, varies by shape\n")
    writeOut("Put any flags (-c, -h, etc.) at the end of your command")
end

function getHelp()
    term.clear()
    term.setCursorPos(1, 1)
    writeOut("Width is to the right of the turtle. (X-Axis)")
    writeOut("Depth is to the front of the turtle. (Y-Axis)")
    writeOut("Height is to the top of the turtle. (Z-Axis)")
    writeOut("Length is the side length of some shapes. (Squares and Polygons)")
    io.read()
    term.clear()
    term.setCursorPos(1, 1)
    local page = 1
    writeOut("What shape do you want help with? [page 1/2]");
    writeOut("next for page 2")
    writeOut("+---------+-----------+-------+-------+")
    writeOut("| square  | rectangle | wall  | line  |")
    writeOut("| cylinder| platform  | stair | cuboid|")
    writeOut("| pyramid | 1/2-sphere| sphere| circle|")
    writeOut("+---------+-----------+-------+-------+")
    writeOut("")
    choice = io.read()
    choice = string.lower(choice)
    while ((choice == "next") or (choice == "back")) do
        if (choice == "next") then
            if (page == 1) then
                page = 2
                term.clear()
                term.setCursorPos(1, 1)
                writeOut("What shape do you want help wih? [page 2/2]?");
                writeOut("back for page 1")
                writeOut("+---------+-----------+-------+-------+")
                writeOut("| hexagon | octagon   | dome  |       |")
                writeOut("| 6-prism | 8-prism   | bowl  |       |")
                writeOut("|         |           |       |       |")
                writeOut("+---------+-----------+-------+-------+")
                writeOut("")
            else
                page = 1
                term.clear()
                term.setCursorPos(1, 1)
                writeOut("What shape do you want help with? [page 1/2]");
                writeOut("next for page 2")
                writeOut("+---------+-----------+-------+-------+")
                writeOut("| square  | rectangle | wall  | line  |")
                writeOut("| cylinder| platform  | stair | cuboid|")
                writeOut("| pyramid | 1/2-sphere| sphere| circle|")
                writeOut("+---------+-----------+-------+-------+")
                writeOut("")
            end
        end
        if (choice == "back") then
            if (page == 1) then
                page = 2
                term.clear()
                term.setCursorPos(1, 1)
                writeOut("What shape do you want help wih? [page 2/2]?");
                writeOut("back for page 1")
                writeOut("+---------+-----------+-------+-------+")
                writeOut("| hexagon | octagon   | dome  |       |")
                writeOut("| 6-prism | 8-prism   | bowl  |       |")
                writeOut("|         |           |       |       |")
                writeOut("+---------+-----------+-------+-------+")
                writeOut("")
            else
                page = 1
                term.clear()
                term.setCursorPos(1, 1)
                writeOut("What shape do you want help with? [page 1/2]");
                writeOut("next for page 2")
                writeOut("+---------+-----------+-------+-------+")
                writeOut("| square  | rectangle | wall  | line  |")
                writeOut("| cylinder| platform  | stair | cuboid|")
                writeOut("| pyramid | 1/2-sphere| sphere| circle|")
                writeOut("+---------+-----------+-------+-------+")
                writeOut("")
            end
        end
        choice = io.read()
        choice = string.lower(choice)
    end
    if not choiceIsValidShape(choice) then
        writeOut(choice ..  " is not a valid shape choice.")
        return
    end
    -- If cascade time!
    if choice == "rectangle" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The rectangle is a perimiter of width by depth. Use platform if you want a filled in rectangle. The rectangle takes two parameters (two integers) Width then Depth.")
    end
    if choice == "square" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The square is a perimiter of length by length. Use platform if you want a filled in square. The square takes one parameter (one integer) Length.")
    end
    if choice == "line" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The line is drawn between the start and end points given. The turtle's initial position is 0, 0 so that must by taken into account. The line takes four parameters (four integers) Start X then Start Y then End X then End Y.")
    end
    if choice == "wall" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The wall is a vertical plane. The wall takes two parameters (two integers) Depth then Height.")
    end
    if choice == "platform" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The platform is a horizontal plane of width by depth. Use rectangle or square if you want just a perimeter. The platform takes two parameters (two integers) Width then Depth.")
    end
    if choice == "stair" or choice == "stairs" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The stair or stairs are an incline of width by height. The stair takes two parameters (two integers) Width then Height.")
    end
    if choice == "cuboid" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The cuboid is a rectangular prism of width by depth by height. The hollow parameter determines if the shape is solid or like a rectangular tube. The cuboid takes four parameters (three intergers and one y/n) Width then Depth then Height then Hollow(y/n).")
    end
    if choice == "1/2-sphere" or choice == "1/2 sphere" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The half sphere is the top or bottom half of a sphere. The half parameter determines of the top or bottom half of the sphere built. The half sphere takes two parameters (one integer and one top/bottom) Diameter then half(top/bottom).")
    end
    if choice == "dome" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The dome shape is a shortcut to the top half sphere. The dome takes one parameter (one integer) Diameter.")
    end
    if choice == "bowl" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The bowl shape is a shortcut to the bottom half sphere. The bowl takes one parameter (one integer) Diameter.")
    end
    if choice == "sphere" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The sphere is just that, a sphere. It is hollow. The sphere takes one parameter (one integer) Diameter.")
    end
    if choice == "circle" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The circle is just that, a circle. It is just a perimeter. The circle takes one parameter (one integer) Diameter.")
    end
    if choice == "cylinder" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The cylinder is a cylindrical tube of diameter by height. The cylinder takes two parameters (two integers) Diameter then Height.")
    end
    if choice == "pyramid" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The pyramid is a four sided pyramid with base length by length. The hollow parameter determines if the inside is filled. The pyramid takes two parameters (one integer and one y/n) Base Length then Hollow(y/n).")
    end
    if choice == "hexagon" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The hexagon is a hexagonal perimeter. The hexagon takes one parameter (one integer) Length.")
    end
    if choice == "octagon" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The octagon is and octagonal perimeter. The octagon takes one parameter (one integer) Length.")
    end
    if choice == "6-prism" or choice == "6 prism" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The 6 prism is a hexagonal prism shaped tube. The 6 prism takes two parameters (two integers) Length then Height.")
    end
    if choice == "8-prism" or choice == "8 prism" then
        term.clear()
        term.setCursorPos(1, 1)
        writeOut("The 8 prism is an octagonal prism shaped tube. The 8 prism takes two parameters (two integers) Length then Height.")
    end
end

function showCredits()
    term.clear()
    term.setCursorPos(1, 1)
    writeOut("Credits for the shape builder:")
    writeOut("Based on work by Michiel, Vliekkie, and Aeolun")
    writeOut("Sphere/dome code by IMarvinTPA")
    writeOut("Additional improvements by Keridos, CupricWolf, and pokemane")
end

function main()
    if wrapModules()=="resupply" then
        linkToRSStation()
    end
    if checkCommandLine() then
        if needsHelp() then
            showCmdLineHelp()
            return -- Close the program after help info is shown
        end
        setFlagsFromCommandLine()
        setTableFromCommandLine()
    end
    if (CheckForPrevious()) then  -- Will check to see if there was a previous job and gps is enabled, and if so, ask if the user would like to re-initialize to current progress status
        if not continueQuery() then -- If the user doesn't want to continue
            ProgressFileDelete()
            setSimFlags(false) -- Just to be safe
            writeMenu()
            choiceFunction()
        else    -- If the user wants to continue
            setSimFlags(true)
            choiceFunction()
        end
    else
        setSimFlags(false)
        writeMenu()
        choiceFunction()
    end
    if (blocks ~= 0) and (fuel ~= 0) then -- Do not show on help or credits page or when selecting end
        writeOut("Blocks used: " .. blocks)
        writeOut("Fuel used: " .. fuel)
    end
    ProgressFileDelete() -- Removes file upon successful completion of a job, or completion of a previous job.
    progTable = {}
    tempProgTable = {}
end

main()