View difference between Paste ID: k9RUH1pw and jj1V1d7n

 -- 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 stepUp = true
+local stepUp = false
 
 -- Record Keeping Variables: These are for recoding the blocks and fuel used
 local blocks = 0
 local fuel = 0
 local crescentSlot = 15
 
 -- 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 resupply = false
 local enderchestRefilling = false
 local can_use_gps = false
 local returntohome = false -- whether the turtle shall return to start after build
 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 checkResources()
 	if resupply then
 		if turtle.getItemCount(activeslot) <= 1 then
 			while not(resupplymodule.resupply(1)) do
 				os.sleep(0.5)
 			end
 		end
 	elseif enderchestRefilling 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 (activeslot == 16) and (turtle.getItemCount(activeslot)<=1) 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 = activeslot+1
 				-- writeOut("Turtle slot almost empty, trying slot "..activeslot)
 				turtle.select(activeslot)
 			end
 			compareResources()
 			os.sleep(0.2)
 		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 >= 4 or direction < 0 then
 		return false
 	end
 	while facing ~= direction do
 		turnLeftTrack()
 	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 -- also not 0,0,0 because some shapes use the 0,0 column
 	end
 	turnToFace(0)
 end
 
 -- Shape Building functions
 
 function line(length)
 	if length <= 0 then
 		error("Error, length can not be 0")
 	end
 	local i
 	for i = 1, length do
 		placeBlock()
 		if i ~= length then
 			safeForward()
 		end
 	end
 end
 
 function rectangle(depth, width)
 	if depth <= 0 then
 		error("Error, depth can not be 0")
 	end
 	if width <= 0 then
 		error("Error, width can not be 0")
 	end
 	local lengths = {depth, width, depth, width }
 	local j
 	for j=1,4 do
 		line(lengths[j])
 		turnRightTrack()
 	end
 end
 
 function square(width)
 	rectangle(width, width)
 end
 
 function wall(length, height)
 	local i
 	local j
 	for i = 1, length do
 		for j = 1, height do
 			placeBlock()
 			if j < height then
 				safeUp()
 			end
 		end
 		safeForward()
 		for j = 1, height - 1 do
 			safeDown()
 		end
 	end
 	turnLeftTrack()
 end
 
 function platform(x, y)
 	local forward = true
 	for counterY = 0, y - 1 do
 		for counterX = 0, x - 1 do
 			if forward then
 				navigateTo(counterX, counterY)
 			else
 				navigateTo(x - counterX - 1, counterY)
 			end
 			placeBlock()
 		end
 		if forward then
 			forward = false
 		else
 			forward = true
 		end
 	end
 end
 
 function cuboid(depth, width, height, hollow)
 	platform(depth, width)
 	while (facing > 0) do
 		turnLeftTrack()
 	end
 	turnAroundTrack()
 	if ((width % 2) == 0) then -- This is for reorienting the turtle to build the walls correct in relation to the floor and ceiling
 		turnLeftTrack()
 	end
 	if not(hollow == "n") then
 		for i = 1, height - 2 do
 			safeUp()
 			if ((width % 2) == 0) then -- This as well
 			rectangle(depth, width)
 			else
 			rectangle(width, depth)
 			end
 		end
 	else
 		for i = 1, height - 2 do
 			safeUp()
 			platform(depth,width)
 		end
 	end
 	safeUp()
 	platform(depth, width)
 end
 
 function pyramid(length, hollow)
 	height = math.ceil(length / 2)
 	for i = 1, height do
 		if hollow=="y" then
 			rectangle(length, length)
 		else
 			platform(length, length)
 			navigateTo(0,0)
 			while facing ~= 0 do
 				turnRightTrack()
 			end
 		end
 		if i ~= height then
 			safeUp()
 			safeForward()
 			turnRightTrack()
 			safeForward()
 			turnLeftTrack()
 			length = length - 2
 		end
 	end
 end
 
 function stair(width, height)
 	turnRightTrack()
 	local counterX = 1
 	local counterY = 0.0
 	local goForward = 0
 	while counterY < height do
 		while counterX < width do
 			placeBlock()
 			safeForward()
 			counterX = counterX + 1
 		end
 		placeBlock()
-		if stepUp == true then
+
 		counterY = counterY + 0.5
 		if counterY < height then
 			if goForward == 1 and stepUp == true then  --gofw 1; stU 1
 				turnRightTrack()
 				safeForward()
 				turnRightTrack()
 				goForward = 0
-			if goForward == 1 and stepUp == true then
+
 			end
 			if goForward == 1 and stepUp == false then		--gofw 1; stU 0
 				turnRightTrack()
 				safeUp()
 				safeForward()
-			else if goForward == 1 then
+
 				goForward = 0
 				stepUp = true
 			end
 			if goForward == 0 and stepUp == true then		--gofw 0; stU 1
 				turnLeftTrack()
 				safeUp()
 				safeForward()
 				turnLeftTrack()
 				goForward = 1
 				stepUp = true
 				end
 			if goForward == 0 and stepUp == false then		--gofw 0; stU 0
 				turnLeftTrack()
 				safeUp()
 				turtle.select(15)
 				turtle.placeDown()
 				turtle.select(1)
 				safeForward()
 				turnLeftTrack()
 				goForward = 1
 				stepUp = true
 				end
 			end
 		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
 			safeUp()
 		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)
 		safeUp()
 	end
 end
 
 function hexagon(sideLength)
 	local changeX = sideLength / 2
 	local changeY = round(math.sqrt(3) * changeX, 0)
 	changeX = round(changeX, 0)
 	local counter = 0
 
 	navigateTo(changeX, 0)
 
 	for currentSide = 1, 6 do
 		counter = 0
 
 		if currentSide == 1 then
 			for placed = 1, sideLength do
 				navigateTo(positionX + 1, positionY)
 				placeBlock()
 			end
 		elseif currentSide == 2 then
 			navigateTo(positionX, positionY + 1)
 			while positionY <= changeY do
 				if counter == 0 or counter == 2 or counter == 4 then
 					navigateTo(positionX + 1, positionY)
 				end
 				placeBlock()
 				navigateTo(positionX, positionY + 1)
 				counter = counter + 1
 				if counter == 5 then
 					counter = 0
 				end
 			end
 		elseif currentSide == 3 then
 			while positionY <= (2 * changeY) do
 				if counter == 0 or counter == 2 or counter == 4 then
 					navigateTo(positionX - 1, positionY)
 				end
 				placeBlock()
 				navigateTo(positionX, positionY + 1)
 				counter = counter + 1
 				if counter == 5 then
 					counter = 0
 				end
 			end
 		elseif currentSide == 4 then
 			for placed = 1, sideLength do
 				navigateTo(positionX - 1, positionY)
 				placeBlock()
 			end
 		elseif currentSide == 5 then
 			navigateTo(positionX, positionY - 1)
 			while positionY >= changeY do
 				if counter == 0 or counter == 2 or counter == 4 then
 					navigateTo(positionX - 1, positionY)
 				end
 				placeBlock()
 				navigateTo(positionX, positionY - 1)
 				counter = counter + 1
 				if counter == 5 then
 					counter = 0
 				end
 			end
 		elseif currentSide == 6 then
 			while positionY >= 0 do
 				if counter == 0 or counter == 2 or counter == 4 then
 					navigateTo(positionX + 1, positionY)
 				end
 				placeBlock()
 				navigateTo(positionX, positionY - 1)
 				counter = counter + 1
 				if counter == 5 then
 					counter = 0
 				end
 			end
 		end
 	end
 end
 
 function octagon(sideLength)
 	local sideLength2 = sideLength - 1
 	local change = round(sideLength2 / math.sqrt(2), 0)
 
 	navigateTo(change, 0)
 
 	for currentSide = 1, 8 do
 		if currentSide == 1 then
 			for placed = 1, sideLength2 do
 				navigateTo(positionX + 1, positionY)
 				placeBlock()
 			end
 		elseif currentSide == 2 then
 			for placed = 1, change do
 				navigateTo(positionX + 1, positionY + 1)
 				placeBlock()
 			end
 		elseif currentSide == 3 then
 			for placed = 1, sideLength2 do
 				navigateTo(positionX, positionY + 1)
 				placeBlock()
 			end
 		elseif currentSide == 4 then
 			for placed = 1, change do
 				navigateTo(positionX - 1, positionY + 1)
 				placeBlock()
 			end
 		elseif currentSide == 5 then
 			for placed = 1, sideLength2 do
 				navigateTo(positionX - 1, positionY)
 				placeBlock()
 			end
 		elseif currentSide == 6 then
 			for placed = 1, change do
 				navigateTo(positionX - 1, positionY - 1)
 				placeBlock()
 			end
 		elseif currentSide == 7 then
 		for placed = 1, sideLength2 do
 				navigateTo(positionX, positionY - 1)
 				placeBlock()
 			end
 		elseif currentSide == 8 then
 			for placed = 1, change do
 				navigateTo(positionX + 1, positionY - 1)
 				placeBlock()
 			end
 		end
 	end
 end
 
 function sixprism(length, height)
 	for i = 1, height do
 		hexagon(length)
 		safeUp()
 	end
 end
 
 function eigthprism(length, height)
 	for i = 1, height do
 		octagon(length)
 		safeUp()
 	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, also 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, enderchestRefilling = tempProgTable.enderchestRefilling, 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
 	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 choiceFunction()
 	if sim_mode == false and cmd_line == false then -- If we are NOT resuming progress
 		choice = io.read()
 		choice = string.lower(choice) -- All checks are aginst lower case words so this is to ensure that
 		tempProgTable = {shape = choice}
 		progTable = {shape = choice}
 		if choice == "next" then
 			WriteMenu2()
 			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
 			showHelp()
 			return
 		end
 		if choice == "credits" then
 			showCredits()
 			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
 			returntohome = true
 		end
 		local yes = getInput("string","Want the turtle to refill from enderchest (slot 16)?","y","n")
 		if yes == 'y' then
 			enderchestRefilling = true
 			tempProgTable.enderchestRefilling = 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
 		enderchestRefilling =  tempProgTable.enderchestRefilling
 	elseif cmd_line == true then -- If running from command line
 		choice = tempProgTable.shape
 		choice = string.lower(choice) -- All checks are aginst lower case words so this is to ensure that
 		enderchestRefilling =  tempProgTable.enderchestRefilling
 		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) == 0 do
 				os.sleep(2)
 			end
 		end
 	else
 		activeslot = 1
 	end
 	-- shape selection if cascade
 	if choice == "rectangle" then
 		local depth = 0
 		local width = 0
 		if sim_mode == false and cmd_line == false then
 			depth = getInput("int","How deep does it need to be?")
 			width = getInput("int","How wide does it need to be?")
 		elseif sim_mode == true or cmd_line == true then
 			depth = tempProgTable.param1
 			width = tempProgTable.param2
 		end
 		tempProgTable.param1 = depth
 		tempProgTable.param2 = width
 		progTable = {param1 = depth, param2 = width} -- THIS is here because we NEED to update the local table!
 		rectangle(depth, width)
 	end
 	if choice == "square" then
 		local sideLength
 		if sim_mode == false and cmd_line == false then
 			sideLength = getInput("int","What depth/width does it 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 lineLength = 0
 		if sim_mode == false and cmd_line == false then
 			lineLength = getInput("int","How long does it need to be?")
 		elseif sim_mode == true or cmd_line == true then
 			lineLength = tempProgTable.param1
 		end
 		tempProgTable.param1 = lineLength
 		progTable = {param1 = lineLength}
 		line(lineLength)
 	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 depth = 0
 		local width = 0
 		if sim_mode == false and cmd_line == false then
 			depth = getInput("int","How deep does it need to be?")
 			width = getInput("int","How wide does it need to be?")
 		elseif sim_mode == true or cmd_line == true then
 			depth = tempProgTable.param1
 			width = tempProgTable.param2
 		end
 		tempProgTable.param1 = depth
 		tempProgTable.param2 = width
 		progTable = {param1 = depth, param2 = width}
 		platform(width, depth)
 	end
 	if choice == "stair" 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 depth = 0
 		local width = 0
 		local height = 0
 		local hollow = ""
 		if sim_mode == false and cmd_line == false then
 			depth = getInput("int","How deep does it need to be?")
 			width = getInput("int","How wide 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
 			depth = tempProgTable.param1
 			width = tempProgTable.param2
 			height = tempProgTable.param3
 			hollow = tempProgTable.param4
 		end
 		tempProgTable.param1 = depth
 		tempProgTable.param2 = width
 		tempProgTable.param3 = height
 		tempProgTable.param4 = hollow
 		if height < 3 then
 			height = 3
 		end
 		if depth < 3 then
 			depth = 3
 		end
 		if width < 3 then
 			width = 3
 		end
 		progTable = {param1 = depth, param2 = width, param3 = height}
 		cuboid(depth, width, height, hollow)
 	end
 	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)
 		else
 			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 == "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
 	if choice == "pyramid" then
 		local length = 0
 		local hollow = ""
 		if sim_mode == false and cmd_line == false then
 			length = getInput("int","What depth/width 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
 			length = tempProgTable.param1
 			hollow = tempProgTable.param2
 		end
 		tempProgTable.param1 = length
 		tempProgTable.param2 = hollow
 		progTable = {param1 = length, param2 = hollow}
 		pyramid(length, hollow)
 	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 == "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","What height 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","What height 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 returntohome 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.5 by Keridos/Happydude/pokemane")
 	if resupply then					-- Any ideas to make this more compact/betterlooking (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("")
 	end
 	if not cmd_line then
 		writeOut("What should be built? [page 1/2]");
 		writeOut("next for page 2")
 		writeOut("+---------+-----------+-------+-------+")
 		writeOut("| square  | rectangle | wall  | line  |")
 		writeOut("| cylinder| platform  | stair | cuboid|")
 		writeOut("| pyramid | 1/2-sphere| circle| next  |")
 		writeOut("+---------+-----------+-------+-------+")
 		writeOut("")
 	end
 end
 
 function WriteMenu2()
 	term.clear()
 	term.setCursorPos(1, 1)
 	writeOut("Shape Maker 1.5 by Keridos/Happydude/pokemane")
 	if resupply then					-- Any ideas to make this more compact/betterlooking (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("")
 	end
 	writeOut("What should be built [page 2/2]?");
 	writeOut("")
 	writeOut("+---------+-----------+-------+-------+")
 	writeOut("| hexagon | octagon   | help  |       |")
 	writeOut("| 6-prism | 8-prism   | end   |       |")
 	writeOut("| sphere  | credits   |       |       |")
 	writeOut("+---------+-----------+-------+-------+")
 	writeOut("")
 end
 
 function showHelp()
 	writeOut("Usage: shape [shape-type [param1 param2 param3 ...]] [-c] [-h] [-z] [-r]")
 	writeOut("-c: Activate cost only mode")
 	writeOut("-h: Show this page")
 	writeOut("-z: Set chain_next_shape to true, lets you chain together multiple shapes")
 	io.read() -- Pause here
 	writeOut("-r: Resume the last shape if there is a resume file")
 	writeOut("shape-type can be any of the shapes in the menu")
 	writeOut("After shape-type input all of the paramaters for the shape")
 	io.read() -- Pause here, too
 end
 
 function showCredits()
 	writeOut("Credits for the shape builder:")
 	writeOut("Based on work by Michiel,Vliekkie, and Aeolun")
 	writeOut("Sphere/dome code by pruby")
 	writeOut("Additional improvements by Keridos,Happydude and pokemane")
 	io.read() -- Pause here, too
 end
 
 function main()
 	if wrapmodules()=="resupply" then
 		linkToRSStation()
 	end
 	if checkCommandLine() then
 		if needsHelp() then
 			showHelp()
 			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()