build

--------------------------------------------------------
--Position Management
--------------------------------------------------------
local depth = 0
local unloaded = 0
local collected = 0
local xPos,zPos = 0,0
local xDir,zDir = 0,1

movements = {}
movements["forward"] = {}
movements["forward"]["detect"] = turtle.detect
movements["forward"]["dig"] = turtle.dig
movements["forward"]["move"] = turtle.forward
movements["forward"]["attack"] = turtle.attack

movements["up"] = {}
movements["up"]["detect"] = turtle.detectUp
movements["up"]["dig"] = turtle.digUp
movements["up"]["move"] = turtle.up
movements["up"]["attack"] = turtle.attackUp

movements["down"] = {}
movements["down"]["detect"] = turtle.detectDown
movements["down"]["dig"] = turtle.digDown
movements["down"]["move"] = turtle.down
movements["down"]["attack"] = turtle.attackDown

local function move(direction)
	--print("Attempting to move with " .. direction)
	while not movements[direction].move() do
		if movements[direction].detect() then
			if movements[direction].dig() == false then
				error("Failed to dig block")
			end
		elseif movements[direction].attack() then
			-- Do nothing, next loop after attacking
		else
			sleep( 0.5 )
		end
	end

	if direction == "forward" then
		xPos = xPos + xDir
		zPos = zPos + zDir
	elseif direction == "up" then
		depth = depth - 1
	elseif direction == "down" then
		depth = depth + 1
	end
end

local function turnLeft()
	turtle.turnLeft()
	xDir, zDir = -zDir, xDir
end

local function turnRight()
	turtle.turnRight()
	xDir, zDir = zDir, -xDir
end

function alignXDir( xGoalDir )
	print("Turning to " .. xGoalDir)

	if xGoalDir == xDir then
		return
	elseif xGoalDir == zDir then
		turnRight()
	elseif xGoalDir == -zDir then
		turnLeft()
	else
		turnRight()
		turnRight()
	end

	if xGoalDir ~= xDir then
		error("Failed to fix direction")
	end
end

function alignZDir( zGoalDir )
	if zGoalDir == zDir then
		return
	elseif zGoalDir == xDir then
		turnLeft()
	elseif zGoalDir == -xDir then
		turnRight()
	else
		turnRight()
		turnRight()
	end

	if zGoalDir ~= zDir then
		error("Failed to fix direction")
	end
end

function doNothing ()
	-- Do nothing
end

function goTo( x, y, z, atEachSqurare, xd, zd)
	print( "GoTo: " .. x .. "," .. y .. "," .. z .. " From: " .. xPos .. "," .. depth .. "," .. zPos)

	if atEachSqurare == nil then
		atEachSqurare = doNothing
	end

	while depth ~= y do
		-- print("Depth = " .. depth .. " | y = " .. y)
		if depth > y then
			move("up")
		elseif depth < y then
			move("down")
		end
		atEachSqurare()
	end

	local xGoalDir = (x - xPos) / math.abs(x - xPos)
	while xPos ~= x do
		alignXDir(xGoalDir)
		move("forward")
		atEachSqurare()
	end

	local zGoalDir = (z - zPos) / math.abs(z - zPos)
	while zPos ~= z do
		alignZDir(zGoalDir)
		move("forward")
		atEachSqurare()
	end

	--Fix alignment
	if xd then
		alignXDir(xd)
	end

	if zd then
		alignZDir(zd)
	end
end

--------------------------------------------------------
--Inventory Management
--------------------------------------------------------
local marble = {}
marble['material'] = 1
marble['manualReload'] = true

local firstSlot = marble['material']

local chestZDir = -1
local chestXDir = 0

local preChestZDir;
local preChestXDir;

local function placeChest(item)
	preChestXdir = xDir
	preChestZdir = zDir
	alignZDir(chestZDir)
	alignXDir(chestXDir)

	if turtle.detect() then
		error("Block where chest should go")
	end

	turtle.select(item.chest)

	if turtle.place() == false then
		error("Failed to place chest from slot " .. item.chest)
	end
end

local function getChest(item)
	turtle.select(item.chest)

	if turtle.dig() == false then
		error("Failed to retreive chest to slot " .. item.chest)
	end

	alignZDir(preChestZdir)
	alignXDir(preChestXdir)
end

local function unload(item)
	placeChest(item)

	if item.lastItem then
		for n=item.material,16 do
			turtle.select(n)
			turtle.drop()
		end
	else
		turtle.select(item.material)
		turtle.drop()
	end

	getChest(item)
end

local function reload(item)
	if turtle.getItemSpace(item.material) == 0 then
		return
	elseif item.manualReload then
		for s = firstSlot, 16 do
			turtle.select(s)
			turtle.transferTo(item.material)
		end

		while turtle.getItemSpace(item.material) ~= 0 do
			print("Waiting for restock on " .. item.material)
			os.pullEvent("turtle_inventory")

			for s = firstSlot, 16 do
				turtle.select(s)
				turtle.transferTo(item.material)
			end
		end
	else
		placeChest(item)
		turtle.select(item.material)
		while turtle.getItemSpace() > 0 do
			if turtle.suck(turtle.getItemSpace()) == false then
				print("Couldn't get an item for slot " .. item.material)
				sleep(30)
			end
		end
		getChest(item)
	end
end

local function refuel(item, fuelLimit)
	if fuelLimit == nil then
		fuelLimit = turtle.getFuelLimit()
	end

	while turtle.getFuelLevel() < fuelLimit do
		turtle.select(item.material)
		if turtle.getItemCount() > 1 then
			turtle.refuel(turtle.getItemCount() - 1)
		else
			reload(item)
		end
	end
end

local Item = {}
Item["detect"] = {}
Item["detect"]["forward"] = turtle.detect
Item["detect"]["up"] = turtle.detectUp
Item["detect"]["down"] = turtle.detectDown
Item["place"] = {}
Item["place"]["forward"] = turtle.place
Item["place"]["up"] = turtle.placeUp
Item["place"]["down"] = turtle.placeDown
Item["compare"] = {}
Item["compare"]["forward"] = turtle.compare
Item["compare"]["up"] = turtle.compareUp
Item["compare"]["down"] = turtle.compareDown
local function place(item, direction)
	if turtle.getItemCount(item.material) <= 1 then
		reload(item)
	end

	turtle.select(item.material)
	while Item.detect[direction]() == true do
		if Item.compare[direction]() == false then
			if movements[direction]["dig"]() == false then
				error("Failed to dig a block different than item.material")
			end
		else
			break
		end
	end

	if Item.detect[direction]() == false then
		while Item.place[direction]() == false do
			print("Failed to place an item from slot " .. item.material)
			movements[direction]["attack"]()
		end
	end
end

local function isFull()
	for n=firstSlot,16 do
		if turtle.getItemCount(n) == 0 then
			--Empty slots
			return false;
		end
	end
	print( "No empty slots left." )
	return true;
end

-----------------------------------------------------------------------------
--Main Program Functions
-----------------------------------------------------------------------------

function stock()
	if turtle.getFuelLimit() ~= 0 and turtle.getFuelLevel() < 10000 then
		refuel(fuel, 20000)
	end

	if isFull() then
		unload(loot)
	end
end

function fillBelow()
	place(marble, "down")
end

function placeTorch()
	alignZDir(-1)
	place(torch, "forward")
end


function fillSquare(maxX, maxZ, yDepth)
	--Move to start
	goTo(0,yDepth,0,fillBelow)
	for z = 0, maxZ do
		--Move to the column
		goTo(xPos,yDepth,z,fillBelow)

		--Move to the other end of the column
		if xPos == 0 then
			goTo(maxX,yDepth,z,fillBelow)
		elseif xPos == maxX then
			goTo(0,yDepth,z,fillBelow)
		else
			error("Wasn't at either end of the column. Xpos = " .. xPos)
		end
	end

	--Move to start
	goTo(0,yDepth,0)
end

function outlineSquare(maxX, maxZ, yDepth)
	goTo(0,yDepth,0,fillBelow)

	goTo(maxX,yDepth,0,fillBelow)
	goTo(maxX,yDepth,maxZ,fillBelow)
	goTo(0,yDepth,maxZ,fillBelow)
	goTo(0,yDepth,0,fillBelow)
end

-----------------------------------------------------------------------------
--Main Program
-----------------------------------------------------------------------------

local tArgs = { ... }
if #tArgs < 4 then
	print( "My Version Usage: build shape length width height" )
	return
end

local shape = tArgs[1]
local length = tonumber( tArgs[2] ) -1
local width = tonumber( tArgs[3] ) -1
local height = tonumber( tArgs[4] ) - 1

print( "Building " .. shape )
if shape == "fill" then
	for y = 0, height, 1 do
		fillSquare(length, width, y * -1)
	end

elseif shape == "outline" then
	for y = 0, height, 1 do
		outlineSquare(length, width, y * -1)
	end
end

alignZDir(1)
print("Done")