opus-apps/farms/treefarm.lua

--[[
	Requirements:
		Place turtle against an oak tree or oak sapling
		Area around turtle must be flat and can only be dirt or grass
			(10 blocks in each direction from turtle)
		Turtle must have: crafting table, chest
		Turtle must have a pick equipped on the LEFT side

	Optional:
		Add additional sapling types that can grow with a single sapling

	Notes:
		If the turtle does not get any saplings from the initial tree, place
		down another sapling in front of the turtle.

		The program will be able to survive server restarts as long as it has
		created the cobblestone line. If the program is stopped before that time,
		place the turtle in the original position before restarting the program.
]]--

local Point  = require('point')
local Util   = require('util')

local fs     = _G.fs
local os     = _G.os
local read   = _G.read
local turtle = _G.turtle

local STARTUP_FILE = 'usr/autorun/treefarm.lua'

local FUEL_BASE = 0
local FUEL_DIRE = FUEL_BASE + 10
local FUEL_GOOD = FUEL_BASE + 2000

local MIN_CHARCOAL = 24
local MAX_SAPLINGS = 32

local GRID_WIDTH = 8
local GRID_LENGTH = 10
local GRID = {
	TL = { x =  8, y = 0, z = -8 },
	TR = { x =  8, y = 0, z =  8 },
	BL = { x = -10, y = 0, z = -8 },
	BR = { x = -10, y = 0, z =  8 },
}

local HOME_PT = { x = 0, y = 0, z = 0, heading = 0 }

local DIG_BLACKLIST = {
	[ 'minecraft:furnace'     ] = true,
	[ 'minecraft:lit_furnace' ] = true,
	[ 'minecraft:chest'       ] = true,
}

local COBBLESTONE    = 'minecraft:cobblestone:0'
local CHARCOAL       = 'minecraft:coal:1'
local OAK_LOG        = 'minecraft:log:0'
local OAK_PLANK      = 'minecraft:planks:0'
local CHEST          = 'minecraft:chest:0'
local FURNACE        = 'minecraft:furnace:0'
local SAPLING        = 'minecraft:sapling:0'
local STONE          = 'minecraft:stone:0'
local TORCH          = 'minecraft:torch:0'
local DIRT           = 'minecraft:dirt:0'
local APPLE          = 'minecraft:apple:0'
local STICK          = 'minecraft:stick:0'
local CRAFTING_TABLE = 'minecraft:crafting_table:0'

local ALL_SAPLINGS = {
	SAPLING
}

local state = Util.readTable('usr/config/treefarm') or {
	trees = {
		{ x = 1, y = 0, z = 0 }
	}
}

if not fs.exists(STARTUP_FILE) then
	Util.writeFile(STARTUP_FILE,
		[[os.sleep(1)
shell.openForegroundTab('treefarm.lua')]])
	print('Autorun program created: ' .. STARTUP_FILE)
end

local clock = os.clock()

local function inspect(fn)
	local s, item = fn()
	if s and item then
		return item.name .. ':' .. item.metadata
	end
	return 'minecraft:air:0'
end

local function setState(key, value)
	state[key] = value
	Util.writeTable('usr/config/treefarm', state)
end

local function refuel()
	if turtle.getFuelLevel() < FUEL_GOOD then
		local charcoal = turtle.getItemCount(CHARCOAL)
		if charcoal > 1 then
			turtle.refuel(CHARCOAL, math.min(charcoal - 1, MIN_CHARCOAL / 2))
			print('fuel: ' .. turtle.getFuelLevel())
		end
	end
	return true
end

local function safePlaceBlock(item)

	if turtle.placeUp(item) then
		return true
	end

	local s, m = turtle.inspectUp()
	if s and not DIG_BLACKLIST[m.name] then
		turtle.digUp()
		return turtle.placeUp(item)
	end

	turtle.forward()
	return turtle.placeUp(item)
end

local function craftItem(item, qty)
	local success, msg

	if safePlaceBlock(CHEST) then

		os.sleep(.2) -- needed for minecraft 1.12
		Util.print('Crafting %d %s', (qty or 1), item)
		success, msg = turtle.craftItem(item, qty or 1, {
				side = 'top',
				direction = 'down',
			})
		repeat until not turtle.suckUp()

		if not success then
			print(msg)
		end

		turtle.digUp()
	end

	return success
end

local function emptyFurnace()
	if state.cooking then

		print('Emptying furnace')

		turtle.suckDownAt(state.furnace)
		turtle.suckForwardAt(state.furnace)
		turtle.suckUpAt(state.furnace)
		setState('cooking')
	end
end

local function cook(item, count, result, fuel, fuelCount)

	emptyFurnace()

	setState('cooking', true)

	fuel = fuel or CHARCOAL
	fuelCount = fuelCount or math.ceil(count / 8)
	Util.print('Making %d %s', count, result)

	turtle.dropForwardAt(state.furnace, fuel, fuelCount)
	turtle.dropDownAt(state.furnace, item, count)

	count = count + turtle.getItemCount(result)
	turtle.select(1)
	turtle.pathfind(Point.below(state.furnace))

	local lastSuck = os.clock()
	repeat
		os.sleep(1)
		if turtle.suckUp() then
			lastSuck = os.clock()
		end

		if os.clock() - lastSuck > 10 then
			-- sponge bug
			Util.print('Timed out waiting for furnace')
			return
		end
	until turtle.getItemCount(result) >= count

	setState('cooking')
end

local function makeSingleCharcoal()

	local slots = turtle.getSummedInventory()

	if not state.furnace or
		 slots[CHARCOAL] or
		 not slots[OAK_LOG] or
		 slots[OAK_LOG].count < 2 then
		return true
	end

	turtle.faceAgainst(state.furnace)
	if craftItem(OAK_PLANK) then
		cook(OAK_LOG, 1, CHARCOAL, OAK_PLANK, 1)
		turtle.refuel(OAK_PLANK)
	end

	return true
end

local function makeCharcoal()

	local slots = turtle.getSummedInventory()

	if not state.furnace or
		 not slots[CHARCOAL] or
		 slots[CHARCOAL].count >= MIN_CHARCOAL then
		return true
	end

	local function getLogSlot()
		local maxslot = { count = 0 }
		for k,slot in pairs(slots) do
			if string.match(k, 'minecraft:log') then
				if slot.count > maxslot.count then
					maxslot = slot
				end
			end
		end
		return maxslot
	end

	repeat
		slots = turtle.getSummedInventory()

		local charcoal = slots[CHARCOAL].count
		local slot     = getLogSlot(slots)

		if slot.count < 8 then
			break
		end

		local toCook = math.min(charcoal, math.floor(slot.count / 8))
		toCook = math.min(toCook, math.floor((MIN_CHARCOAL + 8 - charcoal) / 8))
		toCook = toCook * 8

		cook(slot.key, toCook, CHARCOAL)

	until charcoal + toCook >= MIN_CHARCOAL

	return true
end

local function getCobblestone(count)

	local slots = turtle.getSummedInventory()

	if not slots[COBBLESTONE] or slots[COBBLESTONE].count < count then

		print('Collecting cobblestone')

		slots[COBBLESTONE] = true
		slots[DIRT] = true

		local pt = Point.copy(GRID.BR)
		pt.x = GRID.BR.x + 2
		pt.z = GRID.BR.z - 2

		turtle.pathfind(pt)

		repeat
			turtle.select(1)
			turtle.digDown()
			turtle.down()
			for _ = 1, 4 do
				if inspect(turtle.inspect) == STONE then
					turtle.dig()
				end
				turtle.turnRight()
			end

			for item in pairs(turtle.getSummedInventory()) do
				if not slots[item] then
					turtle.drop(item)
				end
			end

		until turtle.getItemCount(COBBLESTONE) >= count

		turtle.go(pt)
		turtle.placeDown(DIRT)

		turtle.drop(DIRT)
	end
end

local function createFurnace()

	if not state.furnace then
		if turtle.getFuelLevel() < FUEL_BASE + 100 then
			return true -- try again later
		end
		print('Adding a furnace')
		getCobblestone(8)

		if turtle.has(FURNACE) or craftItem(FURNACE) then
			-- turtle.drop(COBBLESTONE)
			local furnacePt = { x = GRID.BL.x + 2, y = 1, z = GRID.BL.z + 2 }
			turtle.placeAt(furnacePt, FURNACE)
			setState('furnace', furnacePt)
		end
	end
end

local function createPerimeter()

	if not state.perimeter then
		if not state.furnace or
			 turtle.getFuelLevel() < FUEL_BASE + 500 or
			 turtle.getItemCount(OAK_LOG) == 0 or
			 not craftItem(OAK_PLANK, 2) then
			return true
		end

		print('Creating a perimeter')

		getCobblestone(GRID_WIDTH * 2 + 1)
		if not turtle.has(STONE, 2) then
			cook(COBBLESTONE, 2, STONE, OAK_PLANK, 2)
		end
		turtle.refuel(OAK_PLANK)

		turtle.pathfind(GRID.BL)
		turtle.digDown()
		turtle.placeDown(STONE)

		turtle.setMoveCallback(function()
			local target = COBBLESTONE
			if math.abs(turtle.point.x) == GRID_LENGTH and
				 math.abs(turtle.point.z) == GRID_WIDTH then
				 target = STONE
			 end

			if inspect(turtle.inspectDown) ~= target then
				turtle.digDown()
				turtle.placeDown(target)
			end
		end)

		turtle.pathfind(GRID.BR)

		turtle.clearMoveCallback()
		turtle.drop(COBBLESTONE)
		turtle.drop(DIRT)

		setState('perimeter', true)
	end
end

local function createChests()
	if state.chest then
		return
	end
	if state.perimeter and
		 turtle.getFuelLevel() > FUEL_GOOD and
		 turtle.canCraft(CHEST, 4, turtle.getSummedInventory()) then

		print('Adding storage')
		if turtle.has(CHEST, 2) or craftItem(CHEST, 2) then

			local pt = Point.copy(GRID.BL)
			pt.x = pt.x + 1
			pt.y = pt.y - 1

			pt.z = pt.z + 1

			turtle.digDownAt(pt)
			turtle.placeDown(CHEST)

			pt.z = pt.z + 1

			turtle.digDownAt(pt)
			turtle.placeDown(CHEST)

			setState('chest', Util.shallowCopy(pt))

			turtle.drop(DIRT)
			turtle.refuel(OAK_PLANK)
		end
	end
	return true
end

local function dropOffItems()

	if state.chest then
		local slots = turtle.getSummedInventory()

		if state.chest and
			 slots[CHARCOAL] and
			 slots[CHARCOAL].count >= MIN_CHARCOAL and
			 (turtle.getItemCount('minecraft:log') > 0 or
				turtle.getItemCount('minecraft:log2') > 0) then

			print('Storing logs')
			turtle.pathfind(Point.above(state.chest))
			turtle.dropDown('minecraft:log')
			turtle.dropDown('minecraft:log2')

			for _, sapling in pairs(ALL_SAPLINGS) do
				if slots[sapling] and slots[sapling].count > MAX_SAPLINGS then
					turtle.dropDown(sapling, slots[sapling].count - MAX_SAPLINGS)
				end
			end

			turtle.dropDown(APPLE)
		end
	end

	return true
end

local function eatSaplings()

	local slots = turtle.getSummedInventory()

	for _, sapling in pairs(ALL_SAPLINGS) do
		if slots[sapling] and slots[sapling].count > MAX_SAPLINGS then
			turtle.refuel(sapling, slots[sapling].count - MAX_SAPLINGS)
		end
	end
	return true
end

local function placeTorches()
	if state.torches then
		return
	end

	if turtle.getFuelLevel() > 100 and
		 turtle.canCraft(TORCH, 4, turtle.getSummedInventory()) then

		print('Placing torches')

		if turtle.has(TORCH, 4) or craftItem(TORCH, 4) then
			local pts = { }
			for x = -4, 4, 8 do
				for z = -4, 4, 8 do
					table.insert(pts, { x = x, y = 0, z = z })
				end
			end
			Point.eachClosest(turtle.point, pts, function(pt)
				turtle.placeAt(pt, TORCH)
			end)
			turtle.refuel(STICK)
			turtle.refuel(OAK_PLANK)
			setState('torches', true)
		end
	end

	return true
end

local function randomSapling()

	local sapling = SAPLING

	if #state.trees > 1 then
		ALL_SAPLINGS = { }

		local slots = turtle.getFilledSlots()
		for _, slot in pairs(slots) do
			if slot.name == 'minecraft:sapling' then
				table.insert(ALL_SAPLINGS, slot.key)
			end
		end
		if #ALL_SAPLINGS > 0 then
			sapling = ALL_SAPLINGS[math.random(1, #ALL_SAPLINGS)]
		end
	end

	return sapling
end

local function fellTree(pt)

	local function desperateRefuel(min)
		if turtle.getFuelLevel() < min then
			local logs = turtle.getItemCount(OAK_LOG)
			if logs > 0 then
				if craftItem(OAK_PLANK, math.min(8, logs * 4)) then
					turtle.refuel(OAK_PLANK)
					print('fuel: ' .. turtle.getFuelLevel())
				end
			end
		end
	end

	turtle.setMoveCallback(function() desperateRefuel(FUEL_DIRE) end)

	desperateRefuel(FUEL_DIRE)

	if turtle.digUpAt(Point.above(pt)) then
		turtle.level(
			{ x = GRID_WIDTH-1,    y = 1,  z = GRID_WIDTH-1    },
			{ x = -(GRID_WIDTH-1), y = 50, z = -(GRID_WIDTH-1) },
			Point.above(pt))
	end

	desperateRefuel(FUEL_BASE + 100)
	turtle.clearMoveCallback()
	turtle.set({ attackPolicy = "attack" })

	return true
end

local function fell()

	local pts = Util.shallowCopy(state.trees)

	local rpt = table.remove(pts, math.random(1, #pts))

	-- give the pathfinder hints about what to avoid (state.trees)
	if not turtle.faceAgainst(rpt, { blocks = Util.shallowCopy(state.trees) }) or
		 not string.match(inspect(turtle.inspect), 'minecraft:log') then
		return true
	end

	print('Chopping')

	local fuel = turtle.getFuelLevel()

	-- push this point to the start of this list
	table.insert(pts, 1, rpt)

	Point.eachClosest(turtle.point, pts, function(pt)
		if turtle.faceAgainst(pt, { blocks = Util.shallowCopy(state.trees) }) and
			 string.match(inspect(turtle.inspect), 'minecraft:log') then
			turtle.dig()
			fellTree(pt)
		end
		turtle.placeAt(pt, randomSapling())
		turtle.select(1)
	end)

	print('Used ' .. (fuel - turtle.getFuelLevel()) .. ' fuel')
	return true
end

local function moreTrees()

	if #state.trees > 1 then
		return
	end

	if not state.chest or turtle.getItemCount('minecraft:sapling') < 15 then
		return true
	end

	print('Adding more trees')

	local singleTree = state.trees[1]

	state.trees = { }
	for x = -2, 2, 1 do
		for z = -2, 2, 2 do
			table.insert(state.trees, { x = x, y = 0, z = z })
		end
	end

	turtle.digAt(singleTree)
	fellTree(singleTree)

	setState('trees', state.trees)

	Point.eachClosest(turtle.point, state.trees, function(pt)
		turtle.placeDownAt(pt, randomSapling())
	end)
end

local function getTurtleFacing(block)
	local directions = {
		[5] = 2,
		[3] = 3,
		[4] = 0,
		[2] = 1,
	}

	if not safePlaceBlock(block) then
		error('unable to place chest above')
	end
	local _, bi = turtle.inspectUp()
	turtle.digUp()
	return directions[bi.metadata]
end

local function saveTurtleFacing()
	if not state.facing then
		setState('facing', getTurtleFacing(CHEST))
	end
end

local function findGround()
	print('Locating ground level')
	turtle.setPoint(HOME_PT)

	while true do
		local s, block = turtle.inspectDown()

		if not s then block = { name = 'minecraft:air', metadata = 0 } end
		local b = block.name .. ':' .. block.metadata

		if b == 'minecraft:dirt:0' or
			 b == 'minecraft:grass:0' or
			 block.name == 'minecraft:chest' then
			break
		end

		if b == COBBLESTONE then
			turtle.back()
			local s2, b2 = turtle.inspectDown()
			if not s2 then
				error('lost')
			end
			if b2.name == COBBLESTONE then
				turtle.turnLeft()
				turtle.back()
			end
			break
		end

		if b == STONE then
			error('lost')
		end

		if b == TORCH or DIG_BLACKLIST[block.name] then
			turtle.forward()
		else
			turtle.digDown()
			turtle.down()
		end

		if turtle.point.y < -20 then
			error('lost')
		end
	end
	turtle.setPoint(HOME_PT)
end

local function findHome()

	if not state.perimeter then
		return
	end

	print('Determining location')
	turtle.point.heading = (getTurtleFacing(CHEST) - state.facing) % 4

	local pt = Point.copy(turtle.point)

	while inspect(turtle.inspectDown) ~= COBBLESTONE do
		pt.x = pt.x - 1
		turtle.pathfind(pt)
		if pt.x < -20 then
			error('lost')
		end
	end
	while inspect(turtle.inspectDown) == COBBLESTONE do
		pt.z = pt.z - 1
		turtle.pathfind(pt)
		if pt.z < -20 then
			error('lost')
		end
	end

	turtle.setPoint({
		x = -(GRID_LENGTH),
		y = 0,
		z = -GRID_WIDTH,
		heading = turtle.point.heading
	})

	-- when pathfinding - don't leave this box
	turtle.setPathingBox({
		x  = GRID.TL.x,
		y  = GRID.TL.y,
		z  = GRID.TL.z,
		ex = GRID.BR.x,
		ey = 5,
		ez = GRID.BR.z,
	})
end

local function updateClock()

	local ONE_HOUR = 50

	if os.clock() - clock > ONE_HOUR then
		clock = os.clock()
	else
		print('sleeping for ' .. math.floor(ONE_HOUR - (os.clock() - clock)))
		os.sleep(ONE_HOUR - (os.clock() - clock))
		clock = os.clock()
	end

	return true
end

local function startupCheck()
	local slots = turtle.getSummedInventory()

	if not slots[CHEST] or not slots[CRAFTING_TABLE] then
		error('A chest and crafting table must be in inventory')
	end

	if state.facing and not state.perimeter then
		print('Perimeter has not been established.')
		print('Enter to continue if turtle is in the original starting position.')
		read()
	end
end

local tasks = {
	{ desc = 'Startup check',      fn = startupCheck       },
	{ desc = 'Finding ground',     fn = findGround         },
	{ desc = 'Determine facing',   fn = saveTurtleFacing   },
	{ desc = 'Finding home',       fn = findHome           },
	{ desc = 'Emptying furnace',   fn = emptyFurnace       },
	{ desc = 'Adding trees',       fn = moreTrees          },
	{ desc = 'Chopping',           fn = fell               },
--  { desc = 'Snacking',           fn = eatSaplings        },
	{ desc = 'Creating chest',     fn = createChests       },
	{ desc = 'Creating furnace',   fn = createFurnace      },
	{ desc = 'Making charcoal',    fn = makeSingleCharcoal },
	{ desc = 'Making charcoal',    fn = makeCharcoal       },
	{ desc = 'Creating perimeter', fn = createPerimeter    },
	{ desc = 'Placing torches',    fn = placeTorches       },
	{ desc = 'Refueling',          fn = refuel             },
	{ desc = 'Dropping off items', fn = dropOffItems       },
	{ desc = 'Condensing',         fn = turtle.condense    },
	{ desc = 'Sleeping',           fn = updateClock        },
}

local s, m = turtle.run(function()

	require('farms.crafting')
	require('farms.level')
	--turtle.addFeatures('level', 'core.crafting')
	turtle.set({ attackPolicy = "attack" })

	while not turtle.isAborted() do
		print('fuel: ' .. turtle.getFuelLevel())
		for _,task in ipairs(Util.shallowCopy(tasks)) do
			--print(task.desc)
			turtle.setStatus(task.desc)
			turtle.select(1)
			if not task.fn() then
				Util.filterInplace(tasks, function(v) return v.fn ~= task.fn end)
			end
		end
	end
end)

if not s then
	error(m or 'Failed')
end