ComputerCraft Turtle Tower Builder

-- Tower builder by Eli Delventhal aka demonpants, v 0.6

local tArgs = { ... }
if #tArgs < 2
then
    print( "Usage: tower <#diameter> <#height> [round|square] [#roofHeight] [#roofDiameter] [crenellation|saddleback|apex|flat]" )
    return
end

-- If our diameter is too small, kick out

local diameter = tonumber( tArgs[1] )
local radius = diameter / 2
if radius < 1
then
    print( "Tower diameter must be positive" )
    return
end

-- If our height is too small, kick out

local height = tonumber( tArgs[2] )
if height < 1
then
    print( "Tower height must be positive" )
    return
end

-- check optional parameters

local towerType = "round"
if #tArgs >= 3
then
    towerType = tArgs[3]
    if towerType ~= "round" and towerType ~= "square"
    then
        print("Tower type must be round or square "..towerType)
        return
    end
end

local roofHeight = 0
if #tArgs >= 4
then
    roofHeight = tonumber( tArgs[4] )
end

local roofDiameter = 0
if #tArgs >= 5
then
    roofDiameter = tonumber( tArgs[5] )
end

local roofType = "crenellation"
if roofHeight > 0 and #tArgs >= 6
then
    roofType = tArgs[6]
    if roofType ~= "crenellation" and roofType ~= "saddleback" and roofType ~= "apex" and roofType ~= "flat"
    then
        print("Tower roof type myst be crenellation, saddleback, or apex")
        return
    end
end

-- we need to store off our position and which way we're
-- facing so that we can move along our way correctly

local centerX = math.floor(radius)
local centerZ = centerX
local startDirX = 0
local startDirZ = 1
local xPos = centerX
local yPos = 0
local zPos = centerZ
local xDir = startDirX
local zDir = startDirZ
local placedBlockCount = 0
local xPoints = {}
local xPointsLength = 0
local zPoints = {}
local zPointsLength = 0

-- Builds below the current position if that spot is free.
-- If a block is already there and it's not the same type as what's
-- in our active slot, the block is dug and a new one is placed
-- If we have no blocks left, returns false, otherwise returns true.

local function build()

    local itemSlot = -1
    local freeSlot = -1

    -- store off the first empty slot and the first slot we can pull an item from
    for n=1,9
    do
        if turtle.getItemCount(n) > 0
        then
            if itemSlot < 0
            then
                itemSlot = n
            end
        elseif freeSlot < 0
            then
            freeSlot = n
        end
    end

    -- we have items in any slot, go ahead and build
    if itemSlot >= 0
    then
        -- this block is not the same type as what we have, dig it out
        if turtle.detectDown() and not turtle.compareDown()
        then
            turtle.digDown()
            -- if we had a free slot and now have only 1 item in it, throw that out
            if freeSlot >= 0 and turtle.getItemCount(freeSlot) == 1
            then
                turtle.select(freeSlot)
                turtle.drop(1)
            end
        end
        -- we know we have an empty spot, place the block
        turtle.select(itemSlot)
        turtle.placeDown()
        placedBlockCount = placedBlockCount + 1
        return true
    end

    -- no items in any slots, we can't build
    return false
end

-- sorts the movement coordinates so that the turtle is moving optimally

local function sortMovementCoordinates()

    -- first find the one closest to the turtle and put that in front
    --[[ local closest = 0
    local closestDist = math.abs( xPoints[closest] - xPos ) + math.abs( zPoints[closest] - zPos )
    for i = 1, xPointsLength - 1
    do
        local dist = math.abs( xPoints[i] - xPos ) + math.abs( zPoints[i] - zPos )
        if dist < closestDist
        then
            closest = i
            closestDist = dist
        end
    end
    local swap = xPoints[0]
    xPoints[0] = xPoints[closest]
    xPoints[closest] = swap
    swap = zPoints[0]
    zPoints[0] = zPoints[closest]
    zPoints[closest] = swap ]]

    -- next sort all points to be the one closest to the previous point
    for i = 0, xPointsLength - 2
    do
        closest = i + 1
        closestDist = math.abs( xPoints[closest] - xPoints[i] ) + math.abs( zPoints[closest] - zPoints[i] )

        for j = i + 2, xPointsLength - 1
        do
            local dist = math.abs( xPoints[j] - xPoints[i] ) + math.abs( zPoints[j] - zPoints[i] )
            if dist < closestDist
            then
                closest = j
                closestDist = dist
            end
        end
        swap = xPoints[i+1]
        xPoints[i+1] = xPoints[closest]
        xPoints[closest] = swap
        swap = zPoints[i+1]
        zPoints[i+1] = zPoints[closest]
        zPoints[closest] = swap
    end
end

-- populates the two lists of movement coordinates with X and Y coordinates for a round tower

local function populateMovementCoordinatesRound()
    xPoints = {}
    xPointsLength = 0
    zPoints = {}
    zPointsLength = 0
    local d = 3 - (2 * radius)
    local x = 0
    local z = math.floor(radius);

    -- use the midpoint circle algorithm to construct a list of exactly which points we need
    repeat
        xPoints[xPointsLength] = centerX + x;
        zPoints[zPointsLength] = centerZ + z;
        xPointsLength = xPointsLength + 1
        zPointsLength = zPointsLength + 1

        xPoints[xPointsLength] = centerX + x;
        zPoints[zPointsLength] = centerZ - z;
        xPointsLength = xPointsLength + 1
        zPointsLength = zPointsLength + 1

        xPoints[xPointsLength] = centerX - x;
        zPoints[zPointsLength] = centerZ + z;
        xPointsLength = xPointsLength + 1
        zPointsLength = zPointsLength + 1

        xPoints[xPointsLength] = centerX - x;
        zPoints[zPointsLength] = centerZ - z;
        xPointsLength = xPointsLength + 1
        zPointsLength = zPointsLength + 1

        xPoints[xPointsLength] = centerX + z;
        zPoints[zPointsLength] = centerZ + x;
        xPointsLength = xPointsLength + 1
        zPointsLength = zPointsLength + 1

        xPoints[xPointsLength] = centerX + z;
        zPoints[zPointsLength] = centerZ - x;
        xPointsLength = xPointsLength + 1
        zPointsLength = zPointsLength + 1

        xPoints[xPointsLength] = centerX - z;
        zPoints[zPointsLength] = centerZ + x;
        xPointsLength = xPointsLength + 1
        zPointsLength = zPointsLength + 1

        xPoints[xPointsLength] = centerX - z;
        zPoints[zPointsLength] = centerZ - x;
        xPointsLength = xPointsLength + 1
        zPointsLength = zPointsLength + 1

        if d < 0
        then
            d = d + (4 * x) + 6
        else
            d = d + 4 * (x - z) + 10
            z = z - 1
        end

        x = x + 1
    until x > z
end

-- populates the two lists of movement coordinates with X and Y coordinates for a square tower

local function populateMovementCoordinatesSquare()
    xPoints = {}
    xPointsLength = 0
    zPoints = {}
    zPointsLength = 0

    local left = math.floor( diameter / 2)
    local right = math.ceil( diameter / 2)

    for i = 0, diameter - 1
    do
        xPoints[xPointsLength] = 0
        zPoints[zPointsLength] = i
        xPointsLength = xPointsLength + 1
        zPointsLength = zPointsLength + 1

        xPoints[xPointsLength] = diameter - 1
        zPoints[zPointsLength] = i
        xPointsLength = xPointsLength + 1
        zPointsLength = zPointsLength + 1

        xPoints[xPointsLength] = i
        zPoints[zPointsLength] = 0
        xPointsLength = xPointsLength + 1
        zPointsLength = zPointsLength + 1

        xPoints[xPointsLength] = i
        zPoints[zPointsLength] = diameter - 1
        xPointsLength = xPointsLength + 1
        zPointsLength = zPointsLength + 1
    end
end

-- populates the two lists of movement coordinates with X and Y coordinates for crenellations

local function populateMovementCoordinatesRoofCrenellations()

end

-- the turtle will turn towards the passed direction
-- returns true if he is facing that way, false if he needs to keep turning

local function turnTo( x, z )

    --       0,1
    -- -1,0      1,0
    --      0,-1

    -- early out in case we're already facing that way
    if xDir == x and zDir == z
    then
        return true
    end

    -- facing up or down
    if xDir == 0
    then
        -- want to face right
        if x == 1
        then
            if zDir == -1
            then
                turtle.turnLeft()
            else
                turtle.turnRight()
            end
            xDir = 1
            zDir = 0
        -- want to face left
        else
            if zDir == -1
            then
                turtle.turnRight()
            else
                turtle.turnLeft()
            end
            xDir = -1
            zDir = 0
        end
    -- facing left or right
    else
        -- want to face up
        if z == 1
        then
            if xDir == -1
            then
                turtle.turnRight()
            else
                turtle.turnLeft()
            end
            xDir = 0
            zDir = 1
        -- want to face down
        else
            if xDir == -1
            then
                turtle.turnLeft()
            else
                turtle.turnRight()
            end
            xDir = 0
            zDir = -1
        end
    end

    -- if we're now facing that way, return true
    if xDir == x and zDir == z
    then
        return true
    end

    return false

end

-- the turtle will attempt to move to the passed location
-- returns true if he got there or was blocked, false if he needs to keep moving

local function moveTo( x, z )

    -- early out in case we're already there
    if xPos == x and zPos == z
    then
        return true
    end

    -- first move along x, then along z
    if xPos ~= x
    then
        if xPos > x
        then
            if turnTo(-1,0)
            then
                if turtle.forward()
                then
                    xPos = xPos - 1
                end
            end
        else
            if turnTo(1,0)
            then
                if turtle.forward()
                then
                    xPos = xPos + 1
                end
            end
        end
    elseif zPos ~= z
    then
        if zPos > z
        then
            if turnTo(0,-1)
            then
                if turtle.forward()
                then
                    zPos = zPos - 1
                end
            end
        else
            if turnTo(0,1)
            then
                if turtle.forward()
                then
                    zPos = zPos + 1
                end
            end
        end
    end

    if xPos == x and zPos == z
    then
        return true
    end

    return false

end

-- //////////////////////////// start of real program ///////////////////////////// --

-- populate the list of points of where we need to go

if towerType == "round"
then
    populateMovementCoordinatesRound()
else
    populateMovementCoordinatesSquare()
end

sortMovementCoordinates()

-- loop through our height until we finish, run out of blocks, or get stuck

local success = true
for yPos = 0, height - 1
do
    -- we will be building below for easy unobstructed movement
    turtle.up()
    yPos = yPos + 1

    -- move to all the points
    for i = 0, xPointsLength - 1
    do
        -- keep trying to move to the nearest point
        local tries = 0

        while not moveTo(xPoints[i], zPoints[i])
        do
            tries = tries + 1
            if tries > diameter * 2
            then
                print( "Failed to reach destination, giving up." )
                success = false
                break
            end
        end

        if not success
        then
            break
        end

        -- we are at the next point, build
        if not build()
        then
            print( "Ran out of blocks, stopping.")
            success = false
            break
        end
    end

    if not success
    then
        break
    end

    -- we finished this floor successfully, yay

end

-- we have built the entire tower, now build the roof

if success and roofHeight > 0
then
    print("Walls completed. Building roof.")


end

-- move back to the center

local tries = 0
while not moveTo(centerX, centerZ) or not turnTo(startDirX, startDirZ)
do
    tries = tries + 1
    if tries > diameter * 2
    then
        break
    end
end

if success
then
    print("Tower completed.")
else
    turtle.down() -- go down so we can try again
end