387 lines
9.9 KiB
Lua
387 lines
9.9 KiB
Lua
Wood = {isHome = false}
|
|
|
|
function Wood:readConfig(path)
|
|
-- reading configFile into a table
|
|
if (path == nil) then
|
|
term.write("init must have a path for the config file as argument")
|
|
return -1
|
|
end
|
|
if (type(path) ~= "string") then
|
|
term.write("invalid argument")
|
|
return -1
|
|
end
|
|
if (not fs.exists(path)) then
|
|
term.write("could not find config file \n please make sure it exists and the path is correct")
|
|
return -1
|
|
end
|
|
local file = fs.open(path, "r")
|
|
local config = {}
|
|
while true do
|
|
local line = file.readLine()
|
|
if not line then
|
|
break
|
|
end
|
|
local numLine = tonumber(line)
|
|
config[#config+1] = numLine
|
|
end
|
|
file.close()
|
|
|
|
--ToDo: implement a sanity check for the config file
|
|
|
|
self.treePos = {config[1] + config[5], config[2] + config[6], config[3] + config [7], config[8]}
|
|
self.homePos = {config[1], config[2], config[3], config[4]}
|
|
end
|
|
|
|
function Wood:new(t)
|
|
t = t or {}
|
|
setmetatable(t, self)
|
|
self.__index = self
|
|
return t
|
|
end
|
|
|
|
function Wood:autoHome()
|
|
self.dir = getDir()
|
|
self.x, self.y, self.z = gps.locate()
|
|
if (self.x == self.homePos[1] and self.y == self.homePos[2] and self.z == self.homePos[3] and self.dir == self.homePos[4]) then
|
|
self.isHome = true
|
|
self:log("turtle is already at home position")
|
|
return true
|
|
else
|
|
if (self:isOnTree()) then
|
|
self.isBroken = true
|
|
self:log("broken tree detected")
|
|
end
|
|
self:log("going to home position")
|
|
self:moveTo("home")
|
|
|
|
|
|
end
|
|
end
|
|
|
|
function Wood:log(message)
|
|
if self.verbose == true then
|
|
print(message)
|
|
end
|
|
end
|
|
|
|
function Wood:isOnTree()
|
|
return false
|
|
end
|
|
|
|
function Wood:offset(position, dir, offset)
|
|
self:assertPositionFormat(position)
|
|
assert(type(dir) == "number", "dir must be a number")
|
|
assert(type(offset) == "number", "offset must be a number")
|
|
local newPosition = self:copyPositionTable(position)
|
|
dir = dir % 4
|
|
if (dir == 0) then newPosition[1] = newPosition[1] - offset
|
|
elseif (dir == 1) then newPosition[3] = newPosition[3] - offset
|
|
elseif (dir == 2) then newPosition[1] = newPosition[1] + offset
|
|
else newPosition[3] = newPosition[3] + offset
|
|
end
|
|
return newPosition
|
|
end
|
|
|
|
function Wood:copyPositionTable(position)
|
|
self:assertPositionFormat(position)
|
|
local positionClone = {}
|
|
for i = 1, 4 do
|
|
positionClone[i] = position[i]
|
|
end
|
|
return positionClone
|
|
end
|
|
|
|
function Wood:assertPositionFormat(position)
|
|
assert(type(position) == "table", "the target is not a table")
|
|
assert(type(position[1]) == "number" and type(position[2]) == "number" and type(position[3]) == "number", "the table doesn't contain the position")
|
|
assert(type(position[4]) == "number", "direction is missing")
|
|
end
|
|
|
|
function Wood:resolveTarget(target)
|
|
if target == "home" then
|
|
target = self.homePos
|
|
elseif target == "tree" then
|
|
target = self.treePos
|
|
elseif target == "sapling" then
|
|
target = self.treePos
|
|
target = self:offset(target, target[4], 1)
|
|
target[2] = target[2] + 1
|
|
elseif target == "saplingChest" then
|
|
target = self.homePos
|
|
target = self:offset(target, target[4] - 1, 1)
|
|
elseif target == "coalChest" then
|
|
target = self.homePos
|
|
target = self:offset(target, target[4] -1, 2)
|
|
elseif target == "outputChest" then
|
|
target = self.homePos
|
|
target = self:offset(target, target[4] -1, -1)
|
|
end
|
|
|
|
self:assertPositionFormat(target)
|
|
self:log("target resolved")
|
|
return target
|
|
end
|
|
|
|
function Wood:moveTo(target)
|
|
target = self:resolveTarget(target)
|
|
self:log("moving to target")
|
|
|
|
moveTo(target[1], target[2], target[3], target[4], self.dir)
|
|
|
|
self.x, self.y, self.z, self.dir = target[1], target[2], target[3], target[4]
|
|
|
|
self:log("target reached")
|
|
|
|
end
|
|
|
|
function Wood:hoverTo(target)
|
|
target = self:resolveTarget(target)
|
|
self:log("hovering to target")
|
|
|
|
hoverTo(target[1], target[2], target[3], target[4], self.dir)
|
|
self.x, self.y, self.z, self.dir = target[1], target[2], target[3], target[4]
|
|
|
|
self:log("target reached")
|
|
end
|
|
|
|
function Wood:isPos(position)
|
|
position = self:resolveTarget(position)
|
|
return self.x == position[1] and self.y == position[2] and self.z == position[3] and self.dir == position[4]
|
|
end
|
|
|
|
function Wood:checkTree(goBack)
|
|
if (goBack == nil) then goBack = true end
|
|
if(goBack == true) then
|
|
goBack = {self.x, self.y, self.z, self.dir}
|
|
end
|
|
|
|
self:log("moving to tree")
|
|
self:moveTo("tree")
|
|
|
|
self:log("inspecting tree...")
|
|
local bd, data = turtle.inspect()
|
|
local result
|
|
if (bd == false) then result = "nothing"
|
|
elseif (data.tags["minecraft:saplings"] == true) then result = "sapling"
|
|
elseif (data.tags["minecraft:logs"]) then result = "tree"
|
|
else result = "other" end
|
|
|
|
self:log(result)
|
|
|
|
if (goBack ~= false) then
|
|
self:log("moving to goBack")
|
|
self:moveTo(goBack)
|
|
end
|
|
|
|
self:log("checkTree complete")
|
|
self.treeState = result
|
|
return result
|
|
end
|
|
|
|
function Wood:cutTree(goBack)
|
|
if (goBack == nil) then goBack = true end
|
|
if(goBack == true) then
|
|
goBack = {self.x, self.y, self.z, self.dir}
|
|
end
|
|
|
|
self:moveTo("tree")
|
|
|
|
self:log("cutting tree...")
|
|
cut4()
|
|
self:log("successful")
|
|
|
|
if (goBack ~= false) then
|
|
self:log("moving to goBack")
|
|
self:moveTo(goBack)
|
|
end
|
|
|
|
end
|
|
|
|
function Wood:plantTree(goBack)
|
|
if (goBack == nil) then goBack = true end
|
|
if(goBack == true) then
|
|
goBack = {self.x, self.y, self.z, self.dir}
|
|
end
|
|
|
|
self:clearInv("saplingChest")
|
|
turtle.select(1)
|
|
turtle.suckDown(4)
|
|
|
|
self:moveTo("sapling")
|
|
plant4(1)
|
|
|
|
if (goBack ~= false) then
|
|
self:log("moving to goBack")
|
|
self:hoverTo(goBack)
|
|
end
|
|
end
|
|
|
|
function Wood:sort(goBack)
|
|
if (goBack == nil) then goBack = true end
|
|
if(goBack == true) then
|
|
goBack = {self.x, self.y, self.z, self.dir}
|
|
end
|
|
|
|
self:moveTo("home")
|
|
local hasMore = self:suckAllDown()
|
|
self:clearInv(goBack)
|
|
|
|
end
|
|
|
|
function Wood:suckAllDown()
|
|
for i = 1, 16 do
|
|
turtle.select(i)
|
|
if(turtle.getItemCount() == 0) then
|
|
if(turtle.suckDown() == false) then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function Wood:clearInv(goBack)
|
|
if (goBack == nil) then goBack = true end
|
|
if(goBack == true) then
|
|
goBack = {self.x, self.y, self.z, self.dir}
|
|
end
|
|
if (self:isInInv("sapling", true)) then
|
|
self:moveTo("saplingChest")
|
|
self:dropItemsDown("sapling", false)
|
|
end
|
|
if (self:isInInv("coal", false)) then
|
|
self:moveTo("coalChest")
|
|
self:dropItemsDown("coal", false)
|
|
end
|
|
if (self:isInvEmpty(true) == false) then
|
|
self:moveTo("outputChest")
|
|
self:dropItemsDown("any", false)
|
|
end
|
|
|
|
if (goBack ~= false) then
|
|
self:log("moving to goBack")
|
|
self:moveTo(goBack)
|
|
end
|
|
end
|
|
|
|
function Wood:isInInv(item, update)
|
|
assert(type(item) == "string", "item must be a string")
|
|
self:assertInvUpdate(update)
|
|
|
|
local tag = self:resolveTag(item)
|
|
if (tag == "") then
|
|
for i = 1, 16 do
|
|
if self:checkItemName(item, i) == true then return true end
|
|
end
|
|
else
|
|
for i = 1, 16 do
|
|
if self:checkItemTag(tag, i) == true then return true end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function Wood:dropItemsDown(item, update)
|
|
assert(type(item) == "string", "item must be a string")
|
|
self:assertInvUpdate(update)
|
|
|
|
local tag = self:resolveTag(item)
|
|
|
|
if(tag == "") then
|
|
for i = 1, 16 do
|
|
if self:checkItemName(item, i) == true then
|
|
turtle.select(i)
|
|
turtle.dropDown()
|
|
end
|
|
end
|
|
else
|
|
for i = 1, 16 do
|
|
if self:checkItemTag(tag, i) == true then
|
|
turtle.select(i)
|
|
turtle.dropDown()
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
function Wood:resolveTag(item)
|
|
local tag = ""
|
|
if (item == "sapling") then
|
|
tag = "minecraft:saplings"
|
|
elseif (item == "log" or item == "wood") then
|
|
tag = "minecraft:logs"
|
|
elseif (item == "coal") then
|
|
tag = "minecraft:coals"
|
|
end
|
|
return tag
|
|
end
|
|
|
|
function Wood:checkItemTag(tag, slot)
|
|
assert(type(tag) == "string", "tag must be a string")
|
|
assert(type(slot) == "number" and slot > 0 and slot <= 16, "slot must be between 1 and 16")
|
|
if self.inv[slot] == nil then
|
|
self:log("self.inv is empty at slot "..tostring(slot))
|
|
return false
|
|
end
|
|
if self.inv[slot].tags == nil then
|
|
self:log("no tags found")
|
|
return false
|
|
end
|
|
if self.inv[slot].tags[tag] == true then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
function Wood:checkItemName(name, slot)
|
|
assert(type(name) == "string", "tag must be a string")
|
|
assert(type(slot) == "number" and slot > 0 and slot <= 16, "slot must be between 1 and 16")
|
|
if self.inv[slot] == nil then
|
|
self:log("self.inv is empty at slot "..tostring(slot))
|
|
return false
|
|
end
|
|
if self.inv[slot].name == nil then
|
|
self:log("no name found")
|
|
return false
|
|
end
|
|
if name == "any" then
|
|
return true
|
|
end
|
|
if self.inv[slot].name == name then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
function Wood:updateInv()
|
|
self.inv = {}
|
|
for slot = 1, 16 do
|
|
self.inv[slot] = turtle.getItemDetail(slot, true)
|
|
end
|
|
end
|
|
|
|
function Wood:isInvEmpty(update)
|
|
self:assertInvUpdate(update)
|
|
for i = 1, 16 do
|
|
if (self.inv[i] ~= nil) then
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
function Wood:assertInvUpdate(update)
|
|
if (update ~= false) then update = true end
|
|
|
|
if self.inv == nil then
|
|
update = true
|
|
end
|
|
|
|
assert(type(update) == "boolean","update must be of the type boolean")
|
|
if update == true then
|
|
self:updateInv()
|
|
end
|
|
end |