TorchAPI

-- Turtle Torch API Version 0.9.1
-- Witten by Travoc

--Program is written to calculate torch placement to make the most
--   of each torch placed and then have a turtle place them.

--In order to use functions in here you must insert os.loadAPI("TorchAPI") in your main program
--   or you can move the API to rom/apis to be used globaly and reset your computers/turtles

--To call a function just use TorchAPI.functionName()
--Variables are local so there are get/set functions to use when neseccary

--For update call you must toggleUpdate(true). It is off by default and you must have
--  TorchAPI.passUpdate(functionForUpdate) in your main program
--functionForUpdate can be any function in your main program and is just renamed here for
--  the API's use

--ToDo's
--Height 1 high placement

--[1]Variable Declaration
torch = {
    place=false, --Turns torch placement on or off
    dist=0,      --How far apart torches are placed
    locdepth=0,     --Current location of depth.
    lastdepth=0,    --Previous location depth passed
    rowtoggle = false,   --Used to switch between row 1 and 2
    rowcount = 1,   --Used to determine current row
    count = 0,          --Counts the total torches placed.
    placecount = 0,     --Counts torches placed in each row
    block = false,    --Turns placement of a block below a torch on/off
    slot = 1,   --what slot turtle pulls torches from default 1
    blockslot = 2,   --what slot turtle pulls blocks from default 2
    short = false,   --Turns on 1 high placement of torches as torches
                    --   cannot be placed below it
    row1={},row2={}  --Rows calculated for torch placement
}
local update = false  -- Used to turn off/on an update call to main program
local upfunc = false --Used to reference a function from the Main program
--[1]end

--[2]Update Functions
function passUpdate(func)
    --Turns Update on/off when a function is passed to it
    if type(func) == "function" then
        upfunc = func
        update = true
    else
        update = false
    end
    return update
end

function updateFunc()
    --Triggers the function passed in by passUpdate to trigger in the
    --   main program so there is near realtime use/display on all
    --   variables in the API
     if update then
        upfunc()
        return true
     else return false end
end

function toggleUpdate(toggle)
    --Toggles update on and off
    if type(toggle) == "boolean" then update=toggle
    else update = not update end
    return update
end
--[2]end

--[3]Initialize Functions
function togglePlace(width,height,locwidth,locdepth,slot)
    --Used to turn on torch placement and run the calculation for
    --   torch row and spacing
    --width is the total width of the area
    --height is the total height of the area
    --locwidth is the current width location. either x or z
    --locdepth is the current depth location. either x or z opposite of cord
    torch.place = calcCords(width,locwidth)
    if torch.place then
        setDepth(locdepth)
        setShort(height)
    end
    if type(slot) == "number" then torch.slot = slot end
    return torch.place
end

function toggleBlock(block,slot)
    --Turns placement of a block below a torch on or off
    if block == nil then torch.block=not torch.block
    else torch.block = block end
    if type(slot) == "number" then torch.blockslot = slot end
    return torch.block
end

function setSlots(item,slot)
    --Sets item passed to pull from slot passed
    item = string.lower(item)
    if item == 'torch' or item == 1 then
        if slot == nil then torch.slot = 1
        else torch.slot = slot end
        updateFunc()
        return true, slot
    elseif item == 'block' or item == 2 then
        if slot == nil then torch.blockslot = 2
        else torch.blockslot = slot end
        updateFunc()
        return true, slot
    end
    return false
end

function setDepth(locdepth)
    --Used to set the starting depth cord for spacing of rows
    --locdepth defaults to 0 if it is not passed in
    if locdepth==nil then locdepth = 0 end
    torch.locdepth = locdepth
    torch.lastdepth = locdepth
    updateFunc()
    return true
end

function setShort(height)
    if height == 1 or height == true then
        torch.short = true
    else
        torch.short = false
    end
    updateFunc()
    return torch.short
end

function getShort()
    return torch.short
end

function getCount()
    return torch.count
end

function calcCords(width,locwidth)
    --Calculations for torch placement based on width of space
    --width must not be 0 but can be negative
    if width ==0 then return false end
    --locwidth defaults to 0 if not passed in. It should be the current
    --width cord not the depth cord so x or z depending on facing w/ GPS

    --Variables
    local count = 0
    local start = 0
    local neg = 1

    --Set x to 0 if not passed in
    if locwidth==nil then locwidth = 0 end
    --Check for negative values
    if width < 0 then neg = -1 end
    width = math.abs(width)

    --Calculate z distance
    torch.dist = 13-width
    if torch.dist < 3 then torch.dist = 6 end

    --Row1
    local count = math.ceil(width/13)
    local offset = 1
    if count <= 1 then
        torch.row1[1] = (math.ceil(width/2)-1)
    else
        local start = (math.ceil((width-1)/2)-6)
        while start > 6 do
            if start-12 < 0 then
                torch.row1[1]=0
                count=count+1
                offset = 2
                break
            else
                start = start - 12
            end
        end
        for i=1,count do
            if torch.row1[i]==nil then
                local cord = (locwidth+start+(12*(i-offset)))*neg
                if cord > width-1 then cord = width-1 end
                torch.row1[i]=cord
            end
        end
    end

    --Row2
    if width <= 10 then
        torch.row2[1] = math.floor(width/2)
    elseif width > 10 and width <= 13 then
        torch.row2[1] = locwidth
        torch.row2[2] = width-1
    else
        start = math.floor(width/2)
        while start > 6 do
            start = start - 12
        end
        local extra = 0
        if start < 0 then
            extra = math.abs(start)
            start = 0
        else extra = 0 end
        count = 0

        while ((locwidth+width-1) >= (locwidth+start-extra+(12*(count)))) do
            count = count + 1
            if count==1 then
                torch.row2[count] = (locwidth+start)*neg
            else
                torch.row2[count] = (locwidth+(start-extra)+(12*(count-1)))*neg
            end
        end
        if extra ~= 0 then
            count = count + 1
            torch.row2[count] = (locwidth+width-1)*neg
        end
    end
    torch.rowtoggle=false
    updateFunc()
    return true
end
--[3]end


--[4]Placement Functions
function place(locwidth,locdepth,enddepth,dir)
    --runs checkCords and if true places torch and block if it is turned
    --  on
    --enddepth can be nil for infinite depth. It is just to get
    --  the last bit of an area.
    --dir is for 1 high areas which way to place the torch
    --if endepth == nil and you want a dir you need to pass locwidth, locdepth, nil, dir
    if not torch.place then return false end
    local shortshift = 0

    --Check if block placement is on and if one exisits below turtle

    if checkCords(locwidth,locdepth,enddepth) then
        if torch.block then placeBlock() end
    end

    --Shift row back one for 1 high placement
    if torch.short then shortshift = 1 end

    --Check if torch should be placed
    if checkCords(locwidth,(locdepth+shortshift),enddepth) then
        if placeTorch(dir) then
            torch.placecount = torch.placecount + 1
            torch.count = torch.count + 1
        else return false
        end
        if (torch.placecount >= #torch.row1 and not torch.rowtoggle) or
           (torch.placecount >= #torch.row2 and torch.rowtoggle) then
            torch.placecount = 0
            torch.rowtoggle = not torch.rowtoggle
            torch.rowcount = torch.rowcount + 1
            torch.locdepth = locdepth + torch.dist
            torch.lastdepth = locdepth
        end
        updateFunc()
        return true
    end
    return false
end

function checkCords(locwidth,locdepth,enddepth)
    --Checks to see if current width and depth should have a torch
    --enddepth can be nil for infinite depth. It is just to get
    --   the last bit of an area.

    --Determine moving negative or positive on depth dimension/plane
    local neg = 1
    if locdepth-torch.lastdepth < 0 then neg = -1 end

    --Check Cord
    if torch.locdepth==locdepth or ((locdepth==enddepth) and ((enddepth-(torch.lastdepth))*neg>=(torch.dist/2))) then
        --Row1 place
        if not torch.rowtoggle then
            for i=1,#torch.row1 do
                if locwidth == torch.row1[i] then
                    return true
                end
            end

        --Row2 place
        else
            for i=1,#torch.row2 do
                if locwidth == torch.row2[i] then
                    return true
                end
            end
        end
    end
    return false
end

function placeItem(item)
    --Place an item below the turtle
    --*ItemAPI integration
    if type(item) == "string" then item = string.lower(item) end
    if item == 'torch' or item == 1 then
        turtle.select(torch.slot)
    elseif item == 'block' or item == 2 then
        turtle.select(torch.blockslot)
    end

    if (torch.short and (item == 'torch' or item == 1)) then
        turtle.dig()
        turtle.place()
        return true
    else
        turtle.digDown()
        turtle.placeDown()
        return true
    end
    return false
end

function placeBlock()
    --Checks to see if there is a block below where the torch is placed
    local placed = false
    --Check if in a 1 high area or not
    if not torch.short then
        if turtle.getFuelLevel() < 2 then return false
        else
            while not turtle.down() do
                turtle.attackDown()
                turtle.digDown()
                sleep(0.5)
            end
        end
    end
    if not turtle.detectDown() then
        placed = placeItem(2)
    end
    if not torch.short then
        while not turtle.up() do
            turtle.attackUp()
            turtle.digUp()
            sleep(0.5)
        end
    end

    return placed
end

function placeTorch(dir)
    --If it is 1 high it rotates to place a torch otherwise it places a
    --  torch below it
    if torch.short then
        --MoveAPI Integration
        if type(MoveAPI) == "table" then
            local origface = MoveAPI.getFace()
            MoveAPI.setFace((MoveAPI.getStartFace()-2)%4)
            placeItem(1)
            MoveAPI.setFace(origface)
        --*Alternative somewhat broken
        else
            local origdir = dir
            while dir ~= 0 do
                turtle.turnLeft()
                dir = (dir-1)%4
            end
            placeItem(1)
            while dir ~= origdir do
                turtle.turnLeft()
                dir = (dir-1)%4
            end
        end
    else
        return placeItem(1)
    end
end

function findCords(count,startdepth,enddepth)
    --Returns the torch cords for the torch number/count specified
    --count should be the exact number/count of the torch 1, 5, etc
    --  this should not be 0 as there is no 0 torch
    --startwidth is used to determine where torch placement started on
    --  the x/z axis whichever is width
    --startdepth is used to determine where torch placement started on
    --  the x/z axis whichever is depth
    --enddepth [optional] to determine last cords
    local row1count = #torch.row1
    local row2count = #torch.row2
    local rowtotal = 0
    if count==nil then count=torch.count+1 end
    local remain = count%(row1count+row2count)
    local rowshift = 0
    --MoveAPI integration
    if type(MoveAPI) == "table" then
        if MoveAPI.getDepthAxis() == "z" then
            startdepth = MoveAPI.getCords("z")
            enddepth = MoveAPI.getEnd("z")
        else
            startdepth = MoveAPI.getCords("x")
            enddepth = MoveAPI.getEnd("x")
        end
    end

    --Check Var
    if startdepth == nil then startdepth = 0 end
    if enddepth ~= nil then rowtotal = rowTotal(enddepth) end

    --Run Calc's
    if torch.rowcount~=1 and (remain==1 or remain==row1count+1) then
        rowshift = torch.dist
    end
    if rowtotal == torch.rowcount then rowshift = enddepth-startdepth end

    --Return Cords
    if not torch.rowtoggle then
        return torch.row1[remain], (startdepth+rowshift)
    else
        if remain == 0 then remain = row1count+row2count end
        local rev = row2count-(remain-row1count)+1
        return torch.row2[rev], (startdepth+rowshift)
    end
end

function rowTotal(depth)
    --Used to return how many rows of torches are in calculated area
    --MoveAPI integration
    if type(MoveAPI) == "table" then
        depth=MoveAPI.getDims("depth")
    end

    --Calculation
    local rowtotal = math.floor(depth/torch.dist)
    if ((depth-(torch.dist*rowtotal)) >= torch.dist/2) then
        rowtotal = rowtotal + 2
    else
        rowtotal = rowtotal + 1
    end
    return rowtotal
end

function torchTotal(depth)
    --Used to return how many torches are needed for an calculated area
    --depth is total depth of area
    local rowtotal = rowTotal(depth)
    return ((#torch.row1*math.ceil(rowtotal/2)) + (#torch.row2*math.floor(rowtotal/2)))
end
--[4]end

--end of API