View difference between Paste ID: C1nGR1dA and UFvjc1bw

-version = 20241122.1730
+version = 20231005.1900
 
 local tkVersion = version -- otherwise over-written by clsTurtle when loaded
 --[[
 	**********Toolkit v2**********
 	https://pastebin.com/UFvjc1bw
 	Last edited: see version YYYYMMDD.HHMM
 	if NOT online:
 		Make sure you create a folder 'lib' and place menu.lua and clsTurtle.lua into it
 	else
 		lib folder will be created and files obtained automatically!
 	end
 ]]
 
 args = {...} -- eg "farm", "tree"
 
 local menu, T
 --[[
 Computercraft started with mc version 1.7.10 and went to 1.8.9
-ccTweaked started around mc 1.12.2 and currently at 1.21.1
+ccTweaked started around mc 1.12.2 and currently at 1.18
-mc 1.18 onwards has new blocks and bedrock at -64, so needs to be taken into account.
+mc 1.18 has new blocks and bedrock at -64, so needs to be taken into account.
 _HOST = The ComputerCraft and Minecraft version of the current computer environment.
 For example, ComputerCraft 1.93.0 (Minecraft 1.15.2).
 ]]
 local dbug = false -- debug is reserved word
 local bedrock = 0
 local netherBedrock = 0
 local ceiling = 255
 local deletesWater = false
 local brick = "minecraft:nether_brick" -- pre 1.16+ name
 local ccMajorVersion = _HOST:sub(15, _HOST:find("Minecraft") - 2) --eg ComputerCraft 1.93.0 (Minecraft 1.15.2)
 local ccMinorVersion = 0
-local barrelItems = nil	-- list of items and the barrels where they are usually found
+
-local chestItems = nil	-- list of items and the chests where they are usually found
+
 Chunk borders F3+G or:
 math.floor(x / 16) * 16 add 16 for each border. same for z
 ]]
 function string:split(sSeparator, nMax, bRegexp, noEmpty)
 	--[[return a table split with sSeparator. noEmpty removes empty elements
 		use: tblSplit = SplitTest:split('~',[nil], [nil], false) or tblSplit = string.split(SplitTest, '~')]]
 	assert(sSeparator ~= '','separator must not be empty string')
 	assert(nMax == nil or nMax >= 1, 'nMax must be >= 1 and not nil')
 	if noEmpty == nil then noEmpty = true end
 
 	local aRecord = {}
 	local newRecord = {}
 	-- self refers to the 'string' being split
 	if self:len() > 0 then
 		local bPlain = not bRegexp
 		nMax = nMax or -1
 
 		local nField, nStart = 1, 1
 		local nFirst,nLast = self:find(sSeparator, nStart, bPlain)
 		while nFirst and nMax ~= 0 do
 			aRecord[nField] = self:sub(nStart, nFirst-1)
 			nField = nField+1
 			nStart = nLast+1
 			nFirst,nLast = self:find(sSeparator, nStart, bPlain)
 			nMax = nMax-1
 		end
 		aRecord[nField] = self:sub(nStart)
 
 		if noEmpty then --split on newline preserves empty values
 			for i = 1, #aRecord do
 				if aRecord[i] ~= "" then
 					table.insert(newRecord, aRecord[i])
 				end
 			end
 		else
 			newRecord = aRecord
 		end
 	end
 
 	return newRecord
 end
 
 if tonumber(ccMajorVersion) == nil then -- 1.93.0 NAN
 	--ccMajorVersion = ccMajorVersion:sub(1, ccMajorVersion:find(".", 3, true) - 1)
 	local parts = ccMajorVersion:split(".")
 	ccMajorVersion = parts[1]
 	if parts[2] ~= nil then
 		ccMajorVersion = ccMajorVersion.."."..parts[2]
 	end
 	ccMajorVersion = tonumber(ccMajorVersion)
 	if parts[3] ~= nil then
 		ccMinorVersion = tonumber(parts[3])
 	end
 end
 
 local mcMajorVersion = _HOST:sub(_HOST:find("Minecraft") + 10, _HOST:find("\)") - 1) -- eg 1.18 or 1.20 -> 1.18, 1.20
 local mcMinorVersion = 0
 if tonumber(mcMajorVersion) == nil then -- 1.18.3 NAN
 	--mcMajorVersion = tonumber(_HOST:sub(_HOST:find("Minecraft") + 10, _HOST:find("\)") - 3)) -- eg 1.19.4 -> 1.19
 	local parts = mcMajorVersion:split(".")
 	mcMajorVersion = parts[1]
 	if parts[2] ~= nil then
 		mcMajorVersion = mcMajorVersion.."."..parts[2]
 	end
 	mcMajorVersion = tonumber(mcMajorVersion)
 	if parts[3] ~= nil then
 		mcMinorVersion = tonumber(parts[3])
 	end
 end
 
 if mcMajorVersion < 1.7  and mcMajorVersion >= 1.18 then -- 1.12 to 1.??
 	bedrock = -64
 	ceiling = 319
 end
 if mcMajorVersion < 1.7  and mcMajorVersion >= 1.16 then -- 1.12 to 1.??
 	brick = "minecraft:nether_bricks"
 end
 if mcMajorVersion < 1.7  and mcMajorVersion <= 1.12 then --- turtle in source deletes it. 1.7.10 to 1.12
 	deletesWater = true
 end
 
 local utils = {}
 
 function utils.tableConcat(tbl, sep)
-local network = {}
+
     for i,value in pairs(tbl) do
-function network.addToStorageList(storageType, itemKey, storageName, writeToFile)
+
-	-- itemKey is a table, so is passed byRef. No need to return a value
+
-	-- eg itemKey: [ "minecraft:dark_oak_sapling" ] = {"minecraft:barrel_94", "minecraft:barrel_96"}
+
-	-- storageName = "minecraft:barrel_99"
+
-	local itemTable = {}
+
-	if storageType == "chest" then
+
-		itemTable = chestItems[itemKey]	-- eg [ "minecraft:dark_oak_sapling" ] = {"minecraft:barrel_94", "minecraft:barrel_96"}
+
 end
-		itemTable = barrelItems[itemKey]
+
 function utils.calculateDimensions(R)
-	if itemTable == nil then				-- key does not match. This item not previously stored
+
-		if storageType == "chest" then
+
-			chestItems[itemKey] = {storageName}	-- eg U.chestItems[minecraft:diorite] = {chest_105}
+
 			print("Calculated Length = "..R.length)
-			barrelItems[itemKey] = {storageName}
+
 			R.width = utils.calculateDistance(R.width) -- now facing right
 			print("Calculated width = "..R.width)
-		for _, storage in ipairs(itemTable) do	-- is "minecraft:barrel_99" already in the list?
+
-			if storage == storageName then
+
-				return	-- exit function
+
 	if R.height == 0 then -- use auto settings based on water detection
 		R.height = 64
-		-- not found so add to table. return not required as funcion is ended
+
-		table.insert(itemTable, storageName)	-- add to table eg table[ "minecraft:dark_oak_sapling" ] = {"minecraft:barrel_94", "minecraft:barrel_96",, "minecraft:barrel_99"}
+
 end
-	if writeToFile then
+
-		network.updateList(storageType)
+
 	--[[
 	measure length
 	movement stops when either solid block in front or solid below
-function network.attachModem()
+
-	-- modem cannot be "attached". Has to be player right-click!
+
-	-- place on  top or next to a modem and ask player to right-click
+
 	local nonSolidBelow = utils.clearVegetation("down")
-	menu.colourPrint("Please right-click on the modem(s) I am next to or above/below"..
+
-					"\nThe centre square should be lit red.\n"..
+
-					"If embedded use narrow gap at side\n", colors.red)
+
-	local event, side = os.pullEvent("peripheral")
+
-	for timer = 5, 0, -1 do
+
-		-- text, fg, bg, width, isInput, cr
+
-		menu.colourWrite("Thanks. continuing in ".. timer.." seconds", colors.lime, colors.black, 0, false, true)
+
 			if turtle.forward() then -- able to move forward
 				moves = moves + 1
 			else
 				break
-function network.checkInventory(inventory, itemName, itemsPerSlot, matchPart)
+
 			if not utils.clearVegetation("down") then -- solid below
-	Find an item already in an inventory
+
-	inventory = The wrapped inventory or it's name
+
-	itemName = The name of the item to find.
+
-	return no of items already present, and storage space for additional
+
 		end
-	itemsPerSlot = itemsPerSlot or 64
+
-	matchPart = matchPart or ""
+
-	local contents = nil
+
-	local numSlots = 0
+
-	if type(inventory) == "string" then
+
-		contents = peripheral.call(inventory, "list")
+    local quantity = tonumber(quantity)
-		numSlots = peripheral.call(inventory, "size")
+	local fuelNeeded = quantity - tonumber(turtle.getFuelLevel()) -- eg 600
-		--assert(contents ~= nil, "Nil contents from inventory "..tostring(inventory))
+
-		T:saveToLog("network.checkInventory('"..inventory.."', itemName = "..itemName..", itemsPerSlot = "..itemsPerSlot..", matchPart = "..tostring(matchPart))
+
 			if T:checkInventoryForItem({"coal"}, {math.ceil(fuelNeeded / 60)}, false) == nil then
-		contents = inventory.list()
+
-		numSlots = inventory.size()
+
 		end
-	local inStock = 0
+
-	local partMatch = false
+
-	local canStore = 0
+
-	if contents ~= nil then
+
-		T:saveToLog("#slots in use = "..#contents)
+
-		canStore = (numSlots - #contents) * itemsPerSlot 	-- capacity of empty slots
+
-		for slot, item in pairs(contents) do
+	-- blockType, blockModifier, data
-			if item.name == itemName then
+	local blockType, blockModifier = T:getBlockType(direction)
-				inStock = inStock  + item.count
+
-				canStore = canStore + itemsPerSlot - item.count
+
 			T:dig(direction)
-				if matchPart ~= "" then	-- eg check for "cobblestone" or "slab"
+
-					if item.name:find(matchPart) ~= nil then
+
-						partMatch = true
+
 			   and blockType:find("ice") == nil then
 			-- NOT water, ice or lava
 			isAirWaterLava = false -- solid block
 		end
 	end
-	T:saveToLog("network.checkInventory return inStock = "..inStock..", canStore = "..canStore..", partMatch = "..tostring(partMatch))
+
-	return inStock, canStore, partMatch -- eg 1, 3647, false if contains only 1 matching item in otherwise empty chest
+
 end
 
-function network.emptyInventory(R, barrels, chests, sticksAsFuel)
+
-	--[[network.emptyInventory(R, {"sapling", "propagule", "dirt", "crafting"}, {"all"}, true)]]
+
-	if not T:isEmpty() then
+
-		if sticksAsFuel then
+
-			utils.useSticksAsFuel()
+
 	if type(R) == "table" then
-		for _, item in ipairs(barrels) do
+
-			network.sendItemToNetworkStorage(R, "barrel", item, 0)
+
 			reduce = true
-		for _, item in ipairs(chests) do
+
-			network.sendItemToNetworkStorage(R, "chest", item, 0)
+
 	else
 		length = R
 	end
 	local numBlocks = 0
-function network.loadStorageLists()
+
 	if reduce then
 		T:forward(1)
-	function lib.createList(storageType)
+
-		local storage, turtleName, storageNames = network.wrapModem(R, storageType)	-- list of barrel/chest peripherals, name of turtle, names of barrels / chests
+
-		local total = 0
+
-		local locations = {}
+
-		for _, store in pairs(storageNames) do					-- eg "minecraft:chest_1"
+
-			T:clear()
+
-			T:saveToLog("Checking "..store.. " contents")		-- eg "checking minecraft:chest_1 contents"
+
-			local contents = peripheral.call(store, "list")		-- list of items / slots for this chest
+
-			for slot, item in pairs(contents) do				-- for each item check if this storage is listed
+
-				if locations[item.name] == nil then				-- this item not yet found
+
-					locations[item.name] = {store}				-- add to table eg locations["minecraft:cobblestone"] = {"minecraft:chest_1"}
+
-				else											-- already has at least 1 location
+
-					network.addToStorageList(storageType, locations[item.name], store, false)
+
 		end
 		local place = utils.clearVegetation("down")
-			total = total + 1
+
 			if T:fillVoid("down", {}, false) then -- false if out of blocks
-		T:saveToLog("found ".. total.." "..storageType)
+
-		local output = textutils.serialize(locations)		-- serialise to json ready to write to file
+
-		local fileName = storageType.."Items.lua"			-- barrelList.lua or chestList.lua
+
-		local outputHandle = fs.open(fileName, "w")			-- open file
+
-		outputHandle.writeLine("return")					-- start file with return
+
-		outputHandle.write(output)							-- add serialised table
+						T:place("minecraft:torch", -1, "forward", false)
-		outputHandle.close()								-- close file
+
 					end
-		return locations
+
 			else
 				break
-	function lib.listNeedUpdating(storageType, list)
+
-		-- see if named chest/barrel in list is found in fresh peripheral.find
+
-		-- turtle may have moved to a different network
+
-		-- list = eg [ "minecraft:stick" ] = {"minecraft:barrel_91","minecraft:barrel_114"}
+
-		local rawStorage = {peripheral.find(storageType)}
+
-		if not utils.isTableEmpty(rawStorage) then		-- chests / barrels are attached see if they match
+
-			for item, storeList in pairs(list) do		-- existing storage names can be found here
+
-				local found = false
+
-				for key, value in ipairs(rawStorage) do	-- look in the fresh list of storage names to see if there are missing entries
+
-					local name = peripheral.getName(value)
+
-					for _, storageName in ipairs(storeList) do 	-- check each storage name found
+
-						if storageName == name then 	-- recorded name matches, check next one
+
-							found = true
+
-							break
+
 	D.height = #
 	D.ceiling = false
-					if found then break end
+
 	D.vDirection = "U" or "D"
-				if not found then
+
-					-- no match in existing list for this storage: list needs updating
+
-					return true-- list does not match
+
 	]]
 	local turn  = "R1"
 	local oTurn = "L1"
-		return false	-- list is ok
+
 		turn    = "L1"
 		oTurn   = "R1"
-	local _, turtleName, storageNames = network.wrapModem(R, "chest")	-- _, name of turtle, list of names of storage
+
-	if turtleName == "Modem not found" then return turtleName end
+
-	local redo = false
+
-	if barrelItems == nil then	-- not yet loaded
+
-		T:saveToLog("barrelItems == nil")
+
-		if fs.exists("barrelItems.lua") then
+
-			T:saveToLog("require('barrelItems')")
+
-			barrelItems = require("barrelItems")	-- global variable
+
-			redo = lib.listNeedUpdating("barrel", barrelItems)
+
 					return "C2"
-			T:saveToLog("lib.createList('barrel'")
+
-			barrelItems = lib.createList("barrel")
+
 				if D.ceiling then
 					return "C0"
-	if chestItems == nil then	-- not yet loaded
+
-		T:saveToLog("chestItems == nil")
+
-		if fs.exists("chestItems.lua") then
+
-			T:saveToLog("require('chestItems')")
+
-			chestItems = require("chestItems")	-- global variable
+
-			redo = lib.listNeedUpdating("chest", barrelItems)
+
 				end
-			T:saveToLog("lib.createList('chest'")
+
-			chestItems = lib.createList("chest")
+
-		end
+
 				end
-	if redo then
+
-		barrelItems = lib.createList("barrel")
+
-		chestItems = lib.createList("chest")
+
 		return ""							-- start and finish both false
 	end
 
-function network.findEmptySlot(list, size)
+
-	--[[ adapted from https://github.com/cc-tweaked/CC-Tweaked/discussions/1552
+
-	Find the first empty slot in a chest.
+
-	list = list of items in the chest/barrel/dropper
+
-	size = The size of the inventory
+
-	return integer? slot The slot number of the first empty slot, or nil if none are empty.
+
 					T:go(place, false, 0, true)-- place floor / ceiling
-	for slot = 1, size do
+
-		if not list[slot] then
+
-			return slot
+
 				elseif width == D.width then						-- checking opposite wall
 					if outward then									-- travelling away from start
 						T:go(turn..placeF..oTurn, false, 0, true)	-- face wall and check if block
-	return nil
+
 						T:go(oTurn..placeF..turn, false, 0, true)	-- face wall and check if block
 					end
-function network.findItemCountInInventory(list, itemName, exactMatch)
+
 				-- move forward
-	Find an item in an inventory
+
-	list = The list of items in the inventory
+
-	itemName = The name of the item to find.
+
-	return integer? The slot number of the item, or nil if not found.
+
 			if width < D.width then
-	exactMatch = exactMatch or false
+
-	if type(list) == "string" then
+
-		list = peripheral.call(list, "list")
+
 				else
-	local retValue = nil
+
-	local count = 0
+
-	for slot, item in pairs(list) do
+
 			else
-		if exactMatch then
+
-			if item.name == itemName then found = true end
+
 				else
-			if item.name:find(itemName) ~= nil then found = true end
+
 				end
 			end
-			if retValue == nil then
+
-				retValue = {}
+
 
-			table.insert(retValue,{slot, item.count}) -- eg {1, 64}
+
-			count = count + item.count
+
 		if height == 1 then
 			lib.layer(D, true, false)					-- first layer, so start = true, finish = false
-	return count, retValue -- either nil or eg {{1, 64},{4, 22}}
+
 			lib.layer(D, false, true)					-- final layer, so start = false, finish = true
 		else
-function network.findItemInInventory(inventory, itemName, exactMatch)
+
-	--[[ adapted from https://github.com/cc-tweaked/CC-Tweaked/discussions/1552
+
-	Find an item in an inventory
+
-	inventory = name of inventory or wrapped peripheral
+
-	itemName = The name of the item to find.
+
-	return integer?, integer? The slot number and count of the item, or nil if not found.
+
 	if D.goHome then-- ends at starting point
-	exactMatch = exactMatch or false
+
-	if type(inventory) == "string" then
+
-		T:saveToLog("network.findItemInInventory("..inventory..", "..itemName..", exactMatch = "..tostring(exactMatch)..")", true)
+
-		contents = peripheral.call(inventory, "list")
+
-	else	-- should be supplied with .list() already
+
-		T:saveToLog("network.findItemInInventory(<inventory>, "..itemName..", exactMatch = "..tostring(exactMatch)..")", true)
+
-		contents = inventory
+
 
-	--T:saveToLog("contents = "..table.concat(contents, ", "))
+
-	--utils.writeTraceTable("contents = ", contents)
+
-	if contents ~= nil then
+
-		for slot, item in pairs(contents) do
+
-			--T:saveToLog("item.name = "..item.name..", item.count = "..item.count)
+
-			if exactMatch then
+
-				if item.name == itemName then
+
-					T:saveToLog("Item found in "..slot..", quantity = "..item.count)
+
-					return slot, item.count
+
 	-- assume on flat surface, but allow for blocks above
 	T:go("x0C2F1 x0C2F1 x0C2F1 x0C2R1 F1 x0C2F1 x0C2F1 x0C2R1 F1 x0C2F1 x0C2F1 x0C2R1 F1 x0C2F1 x0C2", false, 0, false)
-				if (item.name):find(itemName) ~= nil then
+
-					T:saveToLog("Matching Item found in "..slot..", quantity = "..item.count)
+
-					return slot, item.count
+
 	for i = 1, 2 do
 		T:placeWater("down")
 		T:go("F1R1F1R1", false, 0, false)
 	end
-	T:saveToLog("Item not found")
+
-	return 0,0
+
 		sleep(0.5)
 		T:placeWater("down")
-function network.getItemFromNetwork(storageType, itemRequired, countRequired, toTurtleSlot, ignoreStock)
+
 	T:go("R2F1R1F1R1")
 	-- end above lower left of pond (starting point)
-	function lib.getItem(storageTable, turtleName, itemRequired, countRequired, toTurtleSlot, sent)
+
-		local exit = false
+
-		for k, storageName in pairs(storageTable) do 	-- eg {"minecraft:barrel_17", "minecraft:barrel_18"...}
+
-			local available, data = network.findItemCountInInventory(storageName, itemRequired, false)		-- either nil or eg {{1, 64},{4, 22}}
+
-			T:saveToLog("network.findItemCountInInventory("..storageName..", "..itemRequired..", false")
+
-			if data ~= nil then
+
-				for i = 1, #data do
+
-					local request = countRequired
+
-					if countRequired > 64 then
+
-						request = 64
+
 	end
-					local received = network.sendItemsToTurtle(turtleName, storageName, data[i][1], request, toTurtleSlot)	-- request items, returns number sent
+
-					if received == nil then received = 0 end
+
-					sent = sent + received
+
-					T:saveToLog("received = "..received..", request = "..request.." from "..storageName..", sent = "..sent)
+
-					if sent >= countRequired then
+
-						exit = true
+
-						break
+
-					end			-- job done, no need to check remaining slots
+
-					countRequired = countRequired - sent			-- this line not reached if sent >= count
+
 		T:go("D1R1C1 R1C1 U1C1 L1C1 U1C1 R1C1 L2D1 C2C0", false, 0, true)
 		-- finished on same mid 3 high column with wall behind and right completed
-			--if sent >= countRequired then break end				-- no need to check other storage
+
-			--if countRequired <= 0 then break end
+
-			if exit then
+
-				return sent, countRequired
+
 		T:go("L1F"..offset.."L2C1 R1D1C1 U1C1 U1C1 D1")
 		-- end next row along the width, facing the back, mid point
 		-- wall ahead completed
-		return sent, countRequired
+
 
 	function lib.frontTurn()
-	-- eg slot, count = network.getItemFromNetwork("barrel", "minecraft:crafting_table", 1)
+
-	-- storageType either "chest" or "barrel"
+
-	if countRequired == nil then return 0,0 end
+
-	--if toTurtleSlot not specified then nil = use any slot
+
-	ignoreStock = ignoreStock or false	-- return only no of items obtained from storage
+
-	T:saveToLog("network.getItemFromNetwork(storageType = "..storageType..", itemRequired = ".. itemRequired..
+
-				", countRequired = ".. countRequired..", toTurtleSlot = "..tostring(toTurtleSlot)..", ignoreStock = "..tostring(ignoreStock))
+
-	-- Must be next to a modem: MUST remove crafting table if modem on that side. Other tools ok
+
-	local sent = 0
+
-	local turtleSlot, turtleCount = T:getItemSlot(itemRequired)	-- check local stock
+
-	if not ignoreStock then	-- take account of existing items and reduce count accordingly
+
-		countRequired = countRequired - turtleCount
+
 				lib.startCorner()
-	local savedItems = nil
+
-	if storageType == "barrel" then
+
-		savedItems = barrelItems
+
-	elseif storageType == "chest" then
+
-		savedItems = chestItems
+
 				end
-	local storage, turtleName, storageNames = network.wrapModem(R, storageType)	-- list of chest/barrel peripherals, name of turtle, list of storage names
+
-	--if turtleName == "Modem not found" then return 0, nil, nil, turtleName end
+
-	if countRequired > 0 then 						-- not enough in stock, or ignore current stock
+
-		-- check if item in storageLists
+
-		local testStores = nil
+
-		if savedItems[itemRequired] ~= nil then	-- only works with full item names
+
-			T:saveToLog("savedItems key in list: "..textutils.serialise(savedItems[itemRequired], {compact = true}))
+
-			testStores = savedItems[itemRequired]
+
 		return 1
-			for key, value in pairs(savedItems) do
+
-				if key:find(itemRequired)~= nil then
+
-					T:saveToLog("savedItems found in list: "..textutils.serialise(value, {compact = true}))
+
-					testStores = value
+
 		local waterPresent = false
 		for i = 1, distance do
 			if T:isWater("down") then
 				waterPresent = true
-		if testStores == nil then	-- no match in storage lists
+
-			T:saveToLog("Unable to find recorded storage, using all "..storageType.."s")
+
-			sent, countRequired = lib.getItem(storageNames, turtleName, itemRequired, countRequired, toTurtleSlot, sent)
+
-		else -- match found, list of storage availble -- eg {"minecraft:barrel_17", "minecraft:barrel_18"...}
+
-			T:saveToLog("Using recorded list alias 'testStores'")
+
-			sent, countRequired = lib.getItem(testStores, turtleName, itemRequired, countRequired, toTurtleSlot, sent)
+
 				T:go("C1", false, 0, true)
 			end
-		-- slotData.lastSlot, total, slotData -- integer, integer, table
+
-	local data = {}
+
-	turtleSlot, turtleCount, data = T:getItemSlot(itemRequired)
+
-	T:saveToLog("turtleSlot = "..turtleSlot..", turtleCount = "..turtleCount..", sent = "..sent) --..", data = "..textutils.serialise(data))
+
-	if ignoreStock then
+
-		return turtleSlot, sent	-- 0 -> count
+
 		for i = 1, distance do
-		return turtleSlot, turtleCount	-- 0 -> count
+
 			if i < distance then
 				T:forward(1)
 			end
-function network.getSlotContains(inventoryName, inSlot)
+
-	local list = peripheral.call(inventoryName, "list")
+
-	for slot, item in pairs(list) do
+
-		if inSlot == slot then
+
-			return item.name
+
 	if R.data == "" then
 		if turtle.detectDown() then -- on solid surface
-	return ""
+
 		end
 	end
-function network.moveItem(inventoryName, itemName, toSlot)
+
-	--[[ adapted from https://github.com/cc-tweaked/CC-Tweaked/discussions/1552
+
-	Move a specific item to specific slot eg 1, moving other items out of the way if needed.
+
-	inventoryName = The name of the chest/barrel/dropper to search.
+
-	itemName = The name of the item to find.
+
-	toSlot optional. default is slot 1
+
-	return boolean success Whether or not the item was successfully moved to toSlot (or already existed there)
+
 		R = utils.calculateDimensions(R)
-	toSlot = toSlot or 1
+
-	local list = peripheral.call(inventoryName, "list")
+
-	local size = peripheral.call(inventoryName, "size")
+
-	local slot = network.findItemInInventory(list, itemName)
+
 			T:go("R2D2", false, 0, true)	-- at start, level 2, facing towards the front, move backards
-  -- If the item didn't exist, or is already in the first slot, we're done.
+
-	if not slot then
+
-		T:saveToLog("network.moveItem(): Item not found")
+
 			if lib.placeDam(R.length) then
 				waterPresent = true
-	if slot == toSlot then
+
 			row = row + 1
 			-- left side wall has been built, 2 rows of walls laid. row = 2
 			while row < R.width - 1 do -- eg width=2, row=2, this will not run. width=5, row=2
-	-- If an item is blocking the first slot (we already know it's not the one we want), we need to move it.
+
-	if list[toSlot] then
+
-		T:saveToLog("network.moveItem() Slot "..toSlot.." occupied, moving..")
+
-		local emptySlot = network.findEmptySlot(list, size)
+
 					waterPresent = true
-		-- If there are no empty slots, we can't move the item.
+
-		if not emptySlot then
+
-			T:saveToLog("network.moveItem(): No empty slots")
+
 			-- lay right wall
 			lib.frontTurn()
 			lib.removeDam(R.length)
-		-- Move the item to the first empty slot.
+
 			row = row + lib.placeRetainingWall(R.length)
-		if not network.moveItemStack(inventoryName, toSlot, emptySlot) then
+
-			T:saveToLog("network.moveItem(): Failed to move item to slot " .. emptySlot)
+
 			T:go("L1F1R1")
 			lib.removeDam(R.length) -- faces to front on finish
 			depth = depth + 3
-		T:saveToLog("network.moveItem(): Moved item to slot " .. emptySlot)
+
 			if depth == R.height or not waterPresent then -- still replacing water
 				T:up(depth - 1) -- when h == R.height will go up
-	-- Move the item to slot 1.
+
-	if not network.moveItemStack(inventoryName, slot, toSlot) then
+
-		T:saveToLog("network.moveItem(): Failed to move item to slot "..toSlot)
+
 	end
 	return {}
 end
-	T:saveToLog("network.moveItem(): Moved item to slot "..toSlot)
+
-	return true
+
 	while not turtle.detectDown() do -- over water. will be infinite loop if out of sand
 		if not T:place("sand", -1, "down", false) then
-function network.moveItemsFromTurtle(turtleName, toInventoryName, fromTurtleSlot, quantity, toSlot)
+
 			sleep(2)
-	Move quantity of an item from one inventory to another. Turtles MUST use attachedInventory.pullItems()
+
-	eg network.moveItemsFromTurtle(turtleName, chestName, turtleSlot, turtleCount, nil)
+
-	turtleName:			The name of the turtle (via getLocalName())
+
-	toInventoryName: 	The name of the inventory to move items into.
+
-	fromTurtleSlot: 	The slot to move from. must be pre-determined for the item required
+
-	quantity: 			The amount to transfer (nil for full stack)
+
-	toSlot: 			The slot to move to. (nil will use any available slot(s))
+
 	allows 2 turtles to co-operate
-	return peripheral.call(toInventoryName, "pullItems", turtleName, fromTurtleSlot, quantity, toSlot)
+
 	R.side = "R" or "L"
 	]]
-function network.moveItemStack(inventoryName, fromSlot, toSlot)
+
-	--[[ adapted from https://github.com/cc-tweaked/CC-Tweaked/discussions/1552
+
-	Move an item from one slot to another in a given inventory.
+
-	inventoryName The name of the inventory to move items in.
+
-	fromSlot The slot to move from.
+
-	toSlot The slot to move to.
+
 	local finished = false
-	return peripheral.call(inventoryName, "pushItems", inventoryName, fromSlot, nil, toSlot)
+
 	rs.setAnalogueOutput("front", 0) -- switch off output
 	local blockType = T:getBlockType("forward")
-function network.sendItemToNetworkStorage(R, storageType, itemToSend, amountToSend)
+
-	-- used to remove items from turtle inventory
+
-	-- Must be next to a modem: MUST remove crafting table if modem on that side. Other tools ok
+
 		sleep(0.1)
 		timer = timer + 0.1
-	function lib.sendItem(savedItems, peripheralNames, turtleName, turtleSlot, item, slotCount, itemsPerSlot)
+
-		local storageToUse = ""
+
-		local storageList = lib.getStorageFromList(savedItems, item, slotCount, itemsPerSlot)	-- try from savedList
+
-		if storageList == nil then	-- no match found, but use first one found with network.wrapModem
+
-			T:saveToLog("No storage with matching items found, using first empty chest")
+
-			storageToUse = lib.findEmptyStorage(peripheralNames, item, itemsPerSlot, slotCount)
+
 	endTimer = 0
-			T:saveToLog("Storage with matching items found, checking capacity")
+
-			storageToUse  = lib.checkCapacity(storageList, item, slotCount, itemsPerSlot)
+
-			if storageToUse == "" then	-- no capacity in known storage list, so start a new one
+
-				storageToUse = lib.findEmptyStorage(peripheralNames, item, itemsPerSlot, slotCount)
+
 				if confirmed then
 					menu.colourWrite("Turtle confirmed: input = "..rsIn.." output = "..rsOut, colors.orange, nil, nil, false, true)
-		--network.moveItemsFromTurtle(turtleName, toInventoryName, fromTurtleSlot, quantity, toSlot)
+
-		T:saveToLog("network.moveItemsFromTurtle(turtleName = "..turtleName..", storageToUse = "..tostring(storageToUse)..", slot = "..tostring(turtleSlot)..", slotCount = "..tostring(slotCount)..")")
+
-		network.moveItemsFromTurtle(turtleName, storageToUse, turtleSlot, slotCount)
+
 			else
 				menu.colourWrite("Waiting: input = "..rsIn.." output = "..rsOut, colors.orange, nil, nil, false, true)
-	function lib.findEmptyStorage(peripheralNames, itemName, itemsPerSlot, itemCount)
+
-		T:saveToLog("lib.findEmptyStorage("..textutils.serialise(peripheralNames,{compact = true})..", itemName = "..itemName.. ", itemsPerSlot = "..itemsPerSlot)
+
-		for store = 1, #peripheralNames do
+
-			inStock, canStore, partMatch = network.checkInventory(peripheralNames[store], itemName, itemsPerSlot, "")
+
-			if canStore > itemCount then
+
-				return peripheralNames[store]
+
 		end
 		if endTimer >= 10 then -- allows time for other computer to get ready
-		return nil
+
 		end
 		rs.setAnalogueOutput("front", 1) -- output 1 as a signal initially
-	function lib.getStorageFromList(savedItems, item, sendAmount, itemsPerSlot)
+
-		if savedItems[item] == nil then								-- no record of this item stored
+
-			T:saveToLog("lib.getStorageFromList() "..item.." not found")
+
-			local parts = T:getNames(item)								-- eg minecraft:jungle_planks = "minecraft", "jungle", "planks"
+
-			for part = #parts, 1, -1 do 								-- iterate "planks", "jungle", "minecraft"
+
-				local searchTerm = parts[part]
+
-				if searchTerm ~= "minecraft" and searchTerm ~= "mysticalagriculture" then
+
-					for itemName, storageList in pairs(savedItems) do	-- iterate items used as keys eg minecraft:jungle_log matches jungle
+
-						if itemName:find(searchTerm) ~= nil then 		-- partial match eg "sapling" found in "minecraft:oak_sapling"
+
-							T:saveToLog("lib.getStorageFromList() matched "..searchTerm.." with "..itemName)
+
-							return storageList							-- eg {"minecraft:chest_22", "minecraft:chest_23"}
+
 			confirmed = true
 			rsOut = 15
 		elseif rsIn == 15 or confirmed then
 			menu.colourWrite("endTimer active = "..endTimer, colors.orange, nil, nil, false, true)
 			endTimer = endTimer + 1 -- start endTimer
-			T:saveToLog("lib.getStorageFromList() ["..item.."] found")
+
-			return savedItems[item]	-- list of chests with this item available
+
 	T:go(R.side.."3")
-		return nil
+
 	return rsIn -- 15
 end
-	function lib.checkCapacity(storageList, item, sendAmount, itemsPerSlot)
+
-		-- find a chest/barrel with sufficient capacity from list of storage
+
-		for store = 1, #storageList do
+
-			local inStock, canStore, partMatch = network.checkInventory(storageList[store], item, itemsPerSlot, "")
+
-			if canStore > sendAmount then
+
-				return storageList[store]
+
 	maxDescent = maxDescent or 1 -- prevents continuous down due to lack of water
 	if goIn == nil then	-- turtle should submerge
 		goIn = true
 	end
 	local descent = 0 -- counter for going down
-	amountToSend = amountToSend or 0						-- 0 = remove all of this item
+
-	local totalSent = 0										-- track quantity sent
+
-	local minSend = 0										-- minimum amount to send
+
-	if amountToSend > 0 then minSend = amountToSend end		-- update minimum to send
+
-	local _, turtleName, peripheralNames = network.wrapModem(R, storageType)	-- _, name of turtle, list of names of storage
+
 			if T:getBlockType("forward"):find("water") ~= nil or T:getBlockType("forward"):find("bubble") ~= nil then
-	T:saveToLog("network.sendItemToNetworkStorage(R, storageType = '"..storageType.."', itemToSend = '"..itemToSend.."', amountToSend = "..amountToSend..")")
+
-	T:saveToLog("network.wrapModem(R, storageType = "..storageType..", turtleName = "..turtleName..")")
+
-	local savedItems = nil
+
-	if storageType == "barrel" then
+
-		savedItems = barrelItems
+
-	elseif storageType == "chest" then
+
-		savedItems = chestItems
+
 	end
 	-- should now be above water, but may be further down so onWater still false
-	if itemToSend == "all" then	-- empty Turtle, so item names not relevant
+
-		T:saveToLog("itemToSend = all")
+
 			descent = descent + 1
-			local item, turtleSlot, slotCount, itemsPerSlot = "", 0, 0, 64
+
-			for slot = 1, 16 do
+
-				item, slotCount = T:getSlotContains(slot)
+
-				if slotCount > 0 then
+
-					turtleSlot = slot
+
-					T:saveToLog("for slot = 1, 16 do: item = "..item..", slotCount = "..slotCount)
+
-					itemsPerSlot = utils.getSlotCapacity(slot)	-- most items capacity is 64 per slot
+
-					T:saveToLog("sending'"..item.."' from slot "..slot..", quantity = "..slotCount)
+
 	end
 	-- now above water
 	if goIn then
-			if turtleSlot > 0 then
+
-				lib.sendItem(savedItems, peripheralNames, turtleName, turtleSlot, item, slotCount, itemsPerSlot)
+
 	end
-		until turtleSlot == 0
+
-		return 0	-- exit function
+
 
-		local storageToUse  = ""
+
-		repeat	-- until item no longer present in inventory or requested amount has been sent
+
-			local sourceSlot, total, data = T:getItemSlot(itemToSend)	-- which slot and how much of itemToSend is in turtle?
+
-			local slotCount = data.leastCount
+
-			T:saveToLog("T:getItemSlot('"..itemToSend.."' sourceSlot = "..sourceSlot..", total = "..total..")")
+
-			if sourceSlot == 0 then
+
-				T:saveToLog(itemToSend.." not found in turtle inventory")
+
-				return 0	-- exit function
+
 
-				local itemsPerSlot = utils.getSlotCapacity(sourceSlot)	-- most items capacity is 64 per slot
+
-				itemToSend = data.leastName								-- full name of item with lowest itemCount
+	local lastSlot, leastModifier, total, slotData = T:getItemSlot("minecraft:bucket", -1)
-				T:saveToLog("network.sendItemToNetworkStorage(R, '"..itemToSend.."', sourceSlot = "..sourceSlot..", slotCount = "..slotCount) --..", data = "..textutils.serialise(data)..")")
+
-				if sourceSlot > 0 then									-- item is present in turtle inventory
+
-					local newStore = false
+
-					local sent = 0
+
-					local storageList = lib.getStorageFromList(savedItems, itemToSend, slotCount, itemsPerSlot)
+
-					if storageList == nil then
+
-						T:saveToLog("not found in any storage, finding empty")
+
-						storageToUse = lib.findEmptyStorage(peripheralNames, itemToSend, itemsPerSlot, total)
+
-						T:saveToLog("new storage: "..storageToUse.." is available")
+
-						network.addToStorageList(storageType, itemToSend, storageToUse, true)
+
-						sent = network.moveItemsFromTurtle(turtleName, storageToUse, sourceSlot, slotCount)
+
 
-						storageToUse  = lib.checkCapacity(storageList, itemToSend, slotCount, itemsPerSlot)
+
-						if storageToUse == "" then	-- no capacity in known storage list, so start a new one
+
-							storageToUse = lib.findEmptyStorage(peripheralNames, itemToSend, itemsPerSlot, total)
+
-							newStore = true
+
 	end
-						T:saveToLog("sent = network.moveItemsFromTurtle(turtleName = "..turtleName..", storageToUse = "..storageToUse..", sourceSlot = "..sourceSlot..", slotCount = ".. slotCount)
+
-						sent = network.moveItemsFromTurtle(turtleName, storageToUse, sourceSlot, slotCount)
+
 	end
-					totalSent = totalSent + sent
+
-					if minSend > 0 and totalSent >= minSend then
+
-						return totalSent
+
 
-					if amountToSend > 0 then	-- sending specified amount
+
-						amountToSend = amountToSend - sent
+
 		T:getWater("down") -- take water from source
-					if newStore then
+
-						network.addToStorageList(storageType, itemToSend, storageName, true)
+
 	else
 		if not turtle.detectDown() then
 			T:go("C2", false, 0, false)
-		until sourceSlot == 0
+
 		T:getWater("forward") -- take water from source
 		sleep(0.2)
-	return totalSent
+
 	end
 end
-function network.sendItemsToCrafter(crafterName, fromInventoryName, fromInventorySlot, quantity, toCrafterSlot)
+
 function utils.getWaterBucketCount()
-	fromInventoryName: 	The name of the inventory to move items from.
+	-- lastSlot, leastModifier, total, slotData  = T:getItemSlot(item, useDamage)
-	fromInventorySlot: 	The slot to move from. must be pre-determined for the item required
+	local lastSlot, leastModifier, total, slotData = T:getItemSlot("minecraft:water_bucket", -1)
-	quantity: 			The amount to transfer (nil for full stack)
+
-	toCrafterSlot: 		The slot to move to. (nil will use any available slot(s))
+
 
-	return peripheral.call(fromInventoryName, "pushItems", crafterName, fromInventorySlot, quantity, toCrafterSlot)
+
 	--[[ Usage:
 	local inWater, onWater = utils.getWaterStatus() -- returns turtle position near water
-function network.sendItemsToTurtle(turtleName, fromInventoryName, fromInventorySlot, quantity, toTurtleSlot)
+
-	--network.sendItemsToTurtle(turtleName, storageName, storageSlot, count, toTurtleSlot)
+
 	]]
-	Move quantity of an item from one inventory to another. Turtles MUST use attachedInventory.pushItems()
+
-	eg network.sendItemsToTurtle(turtleName, chestName, chestSlot, chestCount, 16) -- move to slot 16 so must be empty
+
-	fromInventoryName: 	The name of the inventory to move items from.
+
-	fromInventorySlot: 	The slot to move from. must be pre-determined for the item required
+
-	quantity: 			The amount to transfer (nil for full stack)
+
-	toTurtleSlot: 		The slot to move to. (nil will use any available slot(s))
+
 		T:turnRight(1)
-	return peripheral.call(fromInventoryName, "pushItems", turtleName, fromInventorySlot, quantity, toTurtleSlot)
+
 	if T:getBlockType("down"):find("water") ~= nil or T:getBlockType("down"):find("bubble") ~= nil then
 		onWater = true
-function network.transferItem(fromInventoryName, toInventoryName, itemName, quantity, toSlot)
+
 	return inWater, onWater
-	Move a specific number of an item from one inventory to another
+
-	fromInventoryName:	The name of the chest/barrel/dropper to search.
+
-	toInventoryName:	The name of the receiving inventory (chest/barrel/dropper/smelter)
+
-	itemName: 			The name of the item to find.
+
-	toSlot: 			optional. nil picks any slot
+
-	return: 			boolean success Whether or not the item was successfully moved to toSlot (or already existed there)
+
 		if not turtle.back() then
-	--T:saveToLog("network.transferItem(from: "..fromInventoryName..", to: "..toInventoryName..", itemName = "..itemName..", quantity = "..tostring(quantity)..", toSlot = "..tostring(toSlot))
+
-	local list = peripheral.call(fromInventoryName, "list")
+
-	local size = peripheral.call(fromInventoryName, "size")
+
-	--T:saveToLog("network.transferItem() size = "..size..", list = \n"..textutils.serialize(list))
+
-	local count, data = network.findItemCountInInventory(list, itemName)	-- either nil or eg {{1, 64},{4, 22}}
+
-	--T:saveToLog("network.transferItem() data = "..textutils.serialize(data, {compact = true}))
+
-	local remaining = quantity			-- eg 22 items needed
+
 
-	if data == nil then	-- Item not found
+
-		return quantity	-- return amount requested = nothing sent
+
 	menuPromptColour = menuPromptColour or colors.white
 
-	local fromSlot = 0
+
-	local count = 64
+
-	local available = 0
+
-	for _, v in pairs(data) do	-- eg {1, 64},{2, 64}
+
-		if v[2] < count and v[2] >= quantity then
+
-			fromSlot = v[1]
+
-			count = v[2]
+
 end
-			available = available + v[2]
+
 function utils.move(R, blocks, reverse)
 	if reverse == nil then
-	if fromSlot > 0 then						-- now have slot with min required quantity
+
-		T:saveToLog("network.transferItem() from: "..fromInventoryName..", to: "..toInventoryName..", fromSlot: "..fromSlot..", toSlot: "..tostring(toSlot)..", quantity: "..tostring(quantity))
+
-		network.transferItems(fromInventoryName, toInventoryName, fromSlot, toSlot, quantity)
+
-		return 0
+		if R.subChoice == 2 then -- reverse direction
-	else									-- available must be at least 1
+
-		for i = 1, #data do					-- itreate all slots containg at least 1 item
+
-			fromSlot = data[i][1]			-- eg slot 1
+
-			local send = data[i][2]			-- eg 10 items
+
-			if remaining - send < 0 then	-- eg 22 - 10 = 12
+
-				send = remaining
+
-				remaining = 0
+
 			T:up(blocks)
-				remaining = remaining - send-- eg remaining = 22 - 10 = 12
+
 			T:down(blocks)
-			network.transferItems(fromInventoryName, toInventoryName, fromSlot, toSlot, send)
+
-			if remaining <= 0 then			-- all required items transferred
+
-				return 0
+
 end
 
 function utils.setStorageOptions()
 	local storage = ""
-	return remaining						-- return remaining items to be found from a  different inventory
+
 	if T:getItemSlot("barrel") > 0 then
 		storage = "barrel"
-function network.transferItems(fromInventoryName, toInventoryName, fromSlot, toSlot, quantity)
+
 	end
-	Move quantity of an item from one inventory to another
+
-	fromInventoryName:	The name of the inventory to move items from.
+
-	toInventoryName: 	The name of the inventory to move items into.
+
-	fromSlot: 			The slot to move from. must be pre-determined for the item required
+
-	toSlot: 			The slot to move to. (nil will use any available slot(s))
+
-	quantity: 			The amount to transfer (nil for full stack)
+
 	return storage, storageBackup
-	T:saveToLog("network.transferItems(from: "..fromInventoryName..", to: "..toInventoryName..", fromSlot: "..fromSlot..", toSlot: "..tostring(toSlot)..", quantity: "..tostring(quantity)..")")
+
-	return peripheral.call(fromInventoryName, "pushItems", toInventoryName, fromSlot, quantity, toSlot)
+
 local pp = utils.getPrettyPrint()
 
-function network.transferItemToTurtle(availableStorage, availableStorageKeys, turtleName, crafterData)
+
-	-- network.transferItemToTurtle(<availableStorage>, data = {{1, 64},{4, 22}}, "crafter_01", <crafterData>)
+
-	-- availableStorage.minecraft:chest_114 = {count = 86, data = {{1, 64},{4, 22}},
+
-	-- availableStorage.minecraft:chest_115 = {count = 1024, data = {{1, 64},{2, 64},{3, 64}, ... }
+
-	-- crafterData = {{2,64}, {4,64}, {6,64}, {8,64}} 64 items in each of 4 slots in the crafter
+
-	-- glitch? in crafter inventory, cannot add sequentially to existing items.
+
-	-- send to turtle slot first, then transfer
+
-	T:saveToLog("network.transferItemToTurtle(availableStorage = "..textutils.serialise(availableStorage, {compact = true})..
+
-				"\navailableStorageKeys = "..textutils.serialise(availableStorageKeys, {compact = true})..
+
-				"\n"..turtleName..", crafterData = "..textutils.serialise(crafterData, {compact = true}))
+
 			T:go("C1", false, 0, false, R.useBlockType)
-	local total = 0
+
-	local numSlots = 0
+
-	local sent = 0
+
-	for _, v in ipairs(crafterData) do								-- how many items required in total?
+
-		total = total + v[2]										-- how many slots does it go in
+
-		numSlots = numSlots + 1
+
 			if l == R.length and R.data == "house" then
-	for _, availableStorageKey in ipairs(availableStorageKeys) do	-- eg {minecraft:chest_114, minecraft:chest_115}
+
-		local storageName = availableStorageKey						-- eg minecraft:chest_114
+
-		local object = availableStorage[storageName]				-- availableStorage.minecraft:chest_114 = {count = 90, data = {{14,64},{15,26}}
+
-		local storageData = object.data								-- eg data = {{14,64},{15,26}}
+
-		local storageCount = object.count							-- eg count = 90
+
-		for _, crafterSlotData in ipairs(crafterData) do			-- eg {{2,22}, {4,22}, {6,22}, {8,22}} -> iteration 1 = {2, 22} iterate crafter slots to be filled
+
-			local toCrafterSlot = crafterSlotData[1]				-- eg slot 2 in turtle
+
-			local amountToSend = crafterSlotData[2]					-- eg place 22 items in slot 2
+
-			T:saveToLog("storageData = "..textutils.serialise(storageData, {compact = true}))
+
-			T:saveToLog("crafterSlotData = "..textutils.serialise(crafterSlotData, {compact = true}))
+
-			for i = 1, #storageData do								-- {{14,64},{15,26}}
+
-				local slotData = storageData[i]						-- {14,64}
+
-				local availableToSend = slotData[2]					-- 64
+
-				local fromStorageSlot = slotData[1]					-- 14
+
-				local confirmedSent = 0
+
 		end
-				T:saveToLog("i = "..i..", slotData = "..textutils.serialise(slotData, {compact = true}))
+
-				if availableToSend >= amountToSend then
+
-					T:saveToLog("availableToSend ("..availableToSend..") >= amountToSend: ("..amountToSend.."), current value of sent = "..sent)
+
-					T:saveToLog("?confirmedSent = peripheral.call("..storageName..", 'pushItems', "..turtleName..
+
-								", from slot "..fromStorageSlot..", amountToSend = "..
+
-								amountToSend..", to turtle slot "..toCrafterSlot)
+
-					confirmedSent = peripheral.call(storageName, "pushItems", turtleName, fromStorageSlot, amountToSend, toCrafterSlot)
+
-					sent = sent + confirmedSent
+
-					T:saveToLog("verified confirmedSent = "..confirmedSent..", sent = "..sent)
+
-					slotData[2] = slotData[2] - confirmedSent
+
-					crafterSlotData[2] = 0
+
-					T:saveToLog("slotData[2] = "..slotData[2]..", crafterSlotData[2] = "..crafterSlotData[2])
+
 		T:turnRight(2)				-- rotate 180
-					T:saveToLog("availableToSend ("..availableToSend..") < amountToSend: ("..amountToSend.."), current value of sent = "..sent)
+
-					T:saveToLog("?confirmedSent = peripheral.call("..storageName..", 'pushItems', "..turtleName..
+
-								", from slot "..fromStorageSlot..", availableToSend = "..
+
-								availableToSend..", to turtle slot "..toCrafterSlot)
+
-					-- taking items from multiple storage slots requires loading into turtle first
+
-					confirmedSent = peripheral.call(storageName, "pushItems", turtleName, fromStorageSlot, availableToSend, toCrafterSlot)
+
-					sent = sent + confirmedSent
+
-					T:saveToLog("verified confirmedSent = "..confirmedSent..", sent = "..sent)
+
-					amountToSend = amountToSend - confirmedSent
+
-					slotData[2] = slotData[2] - confirmedSent
+
-					crafterSlotData[2] = amountToSend
+
-					T:saveToLog("slotData[2] = "..slotData[2]..", crafterSlotData[2] = "..crafterSlotData[2])
+
 				T:go("U3F1R2")
 			end
-				if crafterSlotData[2] == 0 then
+
-					T:saveToLog("crafterSlotData[2]("..crafterSlotData[2]..") == 0: breaking\n")
+
-					break	-- already sent correct amount
+
 		elseif remaining == 2 then
 			lib.doubleLayer(R)
 		end
-		if sent >= total then
+
-			T:saveToLog("sent("..sent..") >= total ("..total.."): breaking\n")
+
 		while turtle.down() do end
 	end
 
 	return {}
-	return sent
+
 
 local function buildStructure(R)
-function network.pullItems(fromName, fromSlot, quantity, toName, toSlot)
+
-	quantity = quantity or 1
+
-	toSlot = toSlot or nil
+
-	if type(fromName) == "table" then			-- already a wrapped peripheral
+
-		fromName = peripheral.getName(fromName)
+
 			T:down(1)
-	if type(toName) == "string" then
+
-		toName = peripheral.wrap(toName)
+
 	local buildHeight = R.height
-	toName.pullItems(fromName, fromSlot, quantity, toSlot)
+
 	local width = R.width
 	local length = R.length
-function network.updateList(storageType)
+
-	local output = ""
+
-	if storageType == "barrel" then
+
-		output = textutils.serialize(barrelItems)		-- serialise to json ready to write to file
+
-	elseif storageType == "chest" then
+
-		output = textutils.serialize(chestItems)		-- serialise to json ready to write to file
+
 	end
-	local fileName = storageType.."Items.lua"			-- barrelList.lua or chestList.lua
+
-	local outputHandle = fs.open(fileName, "w")			-- open file
+
-	outputHandle.writeLine("return")					-- start file with return
+
-	outputHandle.write(output)							-- add serialised table
+
-	outputHandle.close()								-- close file
+
 		buildWall(R)
 
-function network.wrapModem(R, storageType)
+
-	--[[To move turtle inventory items use the target peripheral:
+
-		local modem = peripheral.wrap("front")		-- wrap modem next to turtle (beware crafting table!)
+
-		local turtleName = modem.getNameLocal()		-- get name of the turtle
+
-		local barrel = peripheral.find("barrel")	-- find barrel name you want to receive goods
+
-		barrel.pushItems(turtleName, 1, 1)			-- push items FROM turtle to barrel  pushItems(toName, fromSlot , limit , toSlot)
+
-		barrel.pullItems(turtleName, fromSlot , limit , toSlot)
+
 		lib.goDown(R)
-	local modem = peripheral.find("modem")		-- find modem
+
-	if modem == nil then
+
-		return nil, "Modem not found"
+
 		height = height - R.height	-- 1, 2 or 3
-	local turtleName = modem.getNameLocal()		-- get name of the turtle
+
-	local rawStorage = nil						-- peripheral find can return duplicate values
+
-	if storageType:find("barrel") ~= nil then
+
-		rawStorage = {peripheral.find("minecraft:barrel")}
+
-	elseif storageType:find("chest") ~= nil then
+
-		rawStorage = {peripheral.find("minecraft:chest")}
+
 			R.length = length
-	local storage = {}
+
-	local names = {}
+
-	for k, value in ipairs(rawStorage) do
+
-		local name = peripheral.getName(value)
+
-		if not utils.tableContains(names, name, true) then	-- use exact match as checking peripherals
+
-			table.insert(storage, value)
+
-			table.insert(names, name)
+
 	return {}
 end
-	return storage, turtleName, names
+
 local function buildGableRoof(R)
 	--[[
-function utils.assessFarm(R)
+
-	-- sets R.networkFarm and R.mysticalAgriculture
+
-	menu.colourPrint("Assessing farm properties...", colors.yellow)
+
-	--local storage = true
+
-	for turns = 1, 4 do
+
 	    |   down
-		local itemAhead = T:getBlockType("forward")
+
-		if itemAhead:find("modem") ~= nil then
+
-			if not R.networkFarm then	-- prevents repeated text display
+
-				R.networkFarm = true
+
-				menu.colourPrint("Network storage in use.", colors.magenta)
+
 		for i = 1, R.length + 2 do
 			if R.useBlockType:find("stairs") ~= nil then
-		if itemAhead:find("mysticalagriculture") ~= nil then
+				T:place("stairs", 0, "up")
-			R.mysticalAgriculture = true
+
-			menu.colourPrint("Mystical Agriculture deployed.", colors.lime)
+
 			end
 			if i < R.length + 2 then
-	sleep(1.5)
+
 					T:go("L1F1R1")
 				else
 					T:go("R1F1L1")
 				end
-function utils.assessTreeFarm(R)
+
 		end
 	end
-	function lib.getSaplingType(R, blockType)
+
-		if blockType == "minecraft:mangrove_log" then
+
-			R.logType = "mangrove"
+
-			R.useBlockType ="mangrove_propagule"
+
 			for w = 1, width do
-			local parts = T:getNames(blockType)
+
-			if parts[2] == "dark" then
+
-				R.logType = "dark_oak"
+
-				parts[2] = "dark_oak"
+
 					else
-				R.logType = parts[2]				-- eg "oak"
+
 					end
 				end
-			R.useBlockType = parts[2].."_sapling"	-- eg "oak_sapling"
+
 			if h < R.height then
 				if outward then
-		turtle.turnLeft()
+
 				else
-		return R
+
 				end
 			end
 			width = width - 2
-	if blockType:find("modem") ~= nil then
+
-		R.networkFarm = true
+
 		return outward
-		if blockType:find("polished") == nil then
+
-			R.message = "Not on modem or polished. Check position"
+
 	local outward = true
 	-- go to centre of end wall if odd no, or half width if even
 	R.height = math.floor(R.width / 2)
-	if R.networkFarm then
+
 
 	utils.goBack(1)
-		T:saveToLog("T:forward(1): blockType = "..blockType)
+
-		if blockType:find("log") ~= nil then
+
-			R = lib.getSaplingType(R, blockType)
+
-		elseif blockType:find("barrel") ~= nil then
+
-			T:go("R2F2")
+
 			T:down(1)
-			if blockType:find("log") ~= nil then
+
-				R = lib.getSaplingType(R, blockType)
+
 	end
-		else	-- if in correct position water is 2 blocks below
+
 		T:go("F"..R.height + 2 .."R2U"..R.height)
 	else
-				if blockType:find("water") == nil then
+
-					R.message = "No modem below. Check position"
+
 	for h = 1, R.height + 1 do						-- place tiles on right side of roof
 		lib.placeRoof(R, outward)
-					turtle.up()
+
-					utils.goBack(1)
+
-					T:go("R1F1")
+
 			outward = not outward
-					if blockType:find("log") ~= nil then
+
-						R = lib.getSaplingType(R, blockType)
+
 	-- gable ends
-						R.message = "Unable to determine location. Check position"
+
-						return R
+
 	else
 		T:go("F1L1U1")
 	end
-				R.message = "Unable to determine location. Check position"
+
-				return R
+
 	if outward then
 		T:go("R1F"..R.height - 1 .."R1")
 	else
 		T:go("L1F"..R.height - 1 .."L1")
-	return R	-- sets R.networkFarm and R.useBlockType to sapling type
+
 	outward = not outward
 	outward = lib.placeGable(R, outward)
 	if isOdd then
 		if outward then
 			T:go("L1F1R1U2F1")
 		else
 			T:go("R1F1L1U2F1")
 		end
 		for i = 1, R.length do
 			T:go("C2F1", false, 0, false)
 		end
 		for i = 1, R.length + 2 do
 			utils.goBack(1)
 			T:place("slab", 0, "forward")
 		end
 	end
 	while turtle.down() do end
 
 	return {}
 end
 
 local function buildPitchedRoof(R)
 	--[[
 	stairs placement:
 	   _|   up
 
 	   T L  forward
 	   _
 	    |   down
 
 	]]
 	local lib = {}
 
 	function lib.placeRoofSection(length)
 		-- starts facing centre of building
 		for i = 1, length do
 			if i < length then
 				if R.useBlockType:find("stairs") ~= nil then
 					T:place("stairs", 0, "up")
 				else
 					T:go("C0", false, 0, false, R.useBlockType)
 				end
 				T:go("L1F1R1")
 			end
 		end
 		-- ends facing centre of building
 	end
 
 	function lib.placeRoof(R, width, length)
-function utils.checkFarmPosition(R)
+
-	local discovered = ""
+
-	local success, storage, detected = false, "", 0
+
 		T:go("R1")
-	T:saveToLog("Checking position "..blockType.. " down")
+
-	if blockType:find("water") ~= nil then -- over water, ? facing E (crops)
+
-		-- network: E = __modem_, N = _modem__, W = modem___, S = ___modem
+
-		-- storage: E = _chestchest_, N = chestchest__, W = chest__chest, S = __chestchest
+
-		-- storage: E = _barrelbarrel_, N = barrelbarrel__, W = barrel__barrel, S = __barrelbarrel
+
-		T:saveToLog("? over water = true")
+
 		-- add slabs at top
-			success, storage = utils.isStorage("forward")	-- true/false, chest, barrel, modem / ""
+
-			local itemAhead = T:getBlockType("forward")
+
 			T:forward(length - 3)
-				discovered = discovered .. storage
+
-				if storage == "modem" then
+				T:place("slab", 0, "forward")
-					R.networkFarm = true
+
 			end
 			T:place("slab", 0, "forward")
-				discovered = discovered .. "_"
+
 			T:place("slab", 0, "forward")
-			if itemAhead:find("mysticalagriculture") ~= nil then
+
-				R.mysticalAgriculture = true
+
 		utils.goBack(1)
 	end
 	--[[
-		T:saveToLog("Storage blocks found:"..discovered)
+
-		if R.networkFarm then
+
-			if discovered == "modemmodem__" then
+
-			   T:turnLeft(1)
+
-			elseif discovered == "modem__modem" then
+
-			   T:turnLeft(2)
+
-			elseif discovered == "__modemmodem" then
+
-			   T:turnRight(1)
+
 	if width is odd, ignore top layer as is only 1 block wide
-			R.ready = true
+
 	local isWidthOdd, isLengthOdd, width, length = false, false, 0, 0
-			if discovered == "barrelbarrel__" or
+
-			   discovered == "barrelchest__" or
+
-			   discovered == "chestchest__" then
+
-			   T:turnLeft(1)
+
-			elseif discovered == "barrel__barrel" or discovered == "chest__chest" then
+
-			   T:turnLeft(2)
+
-			elseif discovered == "__barrelbarrel" or discovered == "__chestchest" then
+
-			   T:turnRight(1)
+
 		width = width + 2
-			R.ready = true
+
 			utils.goBack(1)
-	end	-- else not over water
+
 			utils.goBack(1)
-	T:saveToLog("utils.checkFarmPosition(R) return R = "..textutils.serialise(R, {compact = true}))
+
-	return R -- now facing crops, R.ready = true/false, R.networkFarm = true/false
+
 	while turtle.down() do end
 
 	return {}
-	local fuelNeeded = quantity - turtle.getFuelLevel() -- eg 600
+
 
 local function clearAndReplantTrees() -- 25
 	--[[ clear all trees in a rectangle area defined by walls, fences or non-dirt blocks
 	replant with same type of sapling. If original tree 2 blocks wide, replant 4 if possible. ]]
 
 	local lib = {}
 
 	function lib.getSaplingFromLogType(log)
 		--[[ get type of sapling to plant from log type ]]
 		if log:find("oak") ~= nil then
 			return "minecraft:oak_sapling"
 		elseif log:find("spruce") ~= nil then
-	-- blockType, data
+
-	local blockType = T:getBlockType(direction)
+
 			return "minecraft:birch_sapling"
 		elseif log:find("jungle") ~= nil then
 			return "minecraft:jungle_sapling"
 		elseif log:find("acacia") ~= nil then
 			return "minecraft:acacia_sapling"
 		elseif log:find("dark_oak") ~= nil then
 			return "minecraft:dark_oak_sapling"
 		end
 		return "sapling"
 	end
 
 	function lib.plantSapling(sapling, double)
 		--[[ plant sapling(s) ]]
 		if sapling == "" or sapling == nil then sapling = "sapling" end
 		T:up(1)
-function utils.convertEssence(R)
+
-	-- R.subChoice = 1 to 5
+
-	-- R.size = quantity
+
-	-- 1 = inferium to prudentium
+
-	-- 2 = prudentium to tertium
+
-	-- 3 = Tertium to Imperium
+
-	-- 4 = Imperium to Supremium
+					T:place(sapling, -1, "down")
-	-- 5 = Supremium to Insanium
+
 				end
 				T:forward(1)		-- above pre-planted sapling
-	function lib.getCrystal()
+
-		local turtleSlot, turtleCount = 0, 0
+				if not T:place(sapling, -1, "down") then
-		if utils.isStorage("up") then
+					T:place("sapling", -1, "down")
-			turtle.select(2)
+
-			turtle.suckUp()
+
 		else
-		turtleSlot = T:getItemSlot("crystal")
+			if not T:place(sapling, -1, "down") then
-		if turtleSlot == 0 then
+				T:place("sapling", -1, "down")
-			turtleSlot, turtleCount = network.getItemFromNetwork("chest", "infusion_crystal", 1)
+
 		end
-		if turtleSlot > 0 then
+
-			turtle.select(turtleSlot)
+
-			turtle.transferTo(2)
+
 	function lib.suck()
 		--[[ Collect saplings, sticks and apples ]]
 		turtle.select(1)
 		turtle.suck()
 		turtle.suckUp()
 		turtle.suckDown()
-	function lib.loadCrafter(crafterName)
+
-		-- up to 64 essences stored in turtle slots 2, 4, 6, 8
+
-		local slots = {2, 4, 6, 8}
+
-		for _, slot in ipairs(slots) do		-- drop each slot contents into crafter ? slot 1
+
 		if direction == "r" then
-			turtle.drop()
+
-			peripheral.call(crafterName, "pushItems", crafterName, 1, nil, slot)	-- move to correct place
+
 		else
 			T:turnLeft(1)
 			direction = "r"
-	function lib.loadTurtle(availableStorage, availableStorageKeys, turtleName, essence, loaded)
+
-		-- collect essence as above and place in minecraft:crafter slots 2, 4, 6, 8
+
-		local crafterData = {{2, loaded}, {4, loaded}, {6, loaded}, {8, loaded}} -- eg 64 items in each of 4 slots in the crafter
+
-		network.transferItemToTurtle(availableStorage, availableStorageKeys, turtleName, crafterData)
+
 	function lib.emptyInventory(blockTypeD)
 		--[[ Empty all except 32 of each sapling and 1 chest ]]
-	function lib.runCrafter(crafterName, count)
+
-		-- can only craft once, then crystal + output is returned to turtle
+
-		-- repeat process count times
+
-		-- drop crystal into crafter, move to slot 5
+
 			-- empty logs, apples, sticks and all but 1 stack of each sapling type
-			local slot = T:getItemSlot("crystal")
+
-			if slot > 0 then
+
 		else
-				turtle.drop()
+
-				network.moveItem(crafterName, "crystal", 5)
+
-				for i = 1, 3 do
+
-					rs.setAnalogOutput("front",15)
+
-					sleep(0.1)
+
-					rs.setAnalogOutput("front", 0)
+
 		if blockTypeD == nil then
 			blockTypeD = T:getBlockType("down")
 		end
-		while turtle.suck() do end
+
 			T:down(1)
 			lib.suck()
-	function lib.storeCrystal()
+
-		if utils.isStorage("up") then
+
-			T:dropItem("crystal", "up")
+
 	end
-			network.sendItemToNetworkStorage(R, "chest", "crystal", 0)	-- empty turtle to storage chests
+
 	function lib.moveForward()
 		--[[ Move forward 1 block only, go down to ground while air or leaves below ]]
 		local blockTypeF = T:getBlockType("forward")
-	function lib.storeOutput()
+
-		if utils.isStorage("up") then
+
-			T:dropItem("crystal", "up")
+
 			T:dig("up")													-- remove leaves / low branches above to allow space for player
-		network.sendItemToNetworkStorage(R, "chest", "all", 0)	-- empty turtle to storage chests
+
 			blockTypeD = lib.moveDown()
 			if not lib.emptyInventory(blockTypeD) then					-- check if above a corner chest / barrel
-	function lib.getStorageData(essence)
+
-		local _, turtleName, storageNames = network.wrapModem(R, "chests")	-- _, turtleName, list of chest names
+
-		if turtleName == "Modem not found" then return 0, nil, nil, turtleName end
+
-		local availableStorage = {}
+
-		local availableStorageKeys = {}
+
-		local total = 0
+
-		for _, storageName in pairs(storageNames) do
+
-			local storageCount, storageData = network.findItemCountInInventory(storageName, essence)	-- eg 86, {{1, 64},{4, 22}}
+
-			if storageCount > 0 then		-- eg 86: storage has some items
+
-				T:saveToLog("storageCount = "..storageCount)
+
-				availableStorage[storageName] = {}
+
-				availableStorage[storageName].count = storageCount
+
-				availableStorage[storageName].data = storageData
+
-				table.insert(availableStorageKeys, storageName)
+
-				total = total + storageCount
+
 		while blockTypeF:find("dirt") ~= nil or
 			  blockTypeF:find("grass_block") ~= nil or
 			  T:isVegetation(blockTypeF) do	-- go up while dirt, grass-block or any vegetation in front
-		return total, availableStorage, availableStorageKeys, turtleName
+
 			blockTypeF = T:getBlockType("forward")
-			availableStorage.minecraft:chest_114 = {count = 86, data = {{1, 64},{4, 22}},
+
-			availableStorage.minecraft:chest_115 = {count = 1024, data = {{1, 64},{2, 64},{3, 64}, ... }
+
 				return T:getBlockType("forward")
 			elseif blockTypeF:find("leaves") ~= nil then
 				T:dig("forward")
-	local essences = {"mysticalagriculture:inferium_essence",
+
-					"mysticalagriculture:prudentium_essence",
+
-					"mysticalagriculture:tertium_essence",
+
-					"mysticalagriculture:imperium_essence",
+
-					"mysticalagriculture:supremium_essence",
+
-					"mysticalagriculture:insanium_essence"}
+
 	function lib.harvestTree(blockTypeF)
-	local message = network.loadStorageLists()
+
-	if message ~= nil then return {message} end
+
-	local essence = essences[R.subChoice]
+
-	local missing = ""
+
-	local crafter = peripheral.find("minecraft:crafter")
+
-	local crafterName = ""
+
-	local completed = 0
+
-	if R.size > 0 then
+
-		R.size = math.floor(R.size / 4) * 4
+
-		if R.size == 0 then R.size = 4 end
+
 		local success = true
-	if crafter == nil then
+
-		return {"No crafter found"}
+
 			if not success then 								-- did not move forwards, block in the way: either log, dirt/grass, border block or vegetation
-		crafterName = peripheral.getName(crafter)
+
-		T:saveToLog("utils.convertEssence started using "..essence..", quantity = "..R.size )
+
-		while turtle.suck() do end						-- empty crafter
+
-		lib.storeOutput()	-- empty turtle to storage chests, (except crystal if storage above)
+
-		if not lib.getCrystal() then
+
-			return {"Failed: missing infusion crystal"}
+
 						blockTypeF = lib.moveUp(blockTypeF)		-- move up until leaves/log/air
-		lib.storeCrystal()
+
-		local totalInStorage, availableStorage, availableStorageKeys, turtleName = lib.getStorageData(essence)
+
-		if totalInStorage < 4 then
+
-			return {"Only "..totalInStorage.." ".. essence:sub(20).." available"}
+
 							end
-			-- can only transfer full amount direct to crafter
+
-			-- if a chest has 32 items in 1 slot and 32 in another Slot
+
-			-- these have to be sent into the turtle first, dropped into crafter slot 1 and moved to correct position
+
-			totalInStorage = math.floor(totalInStorage / 4) * 4
+
-			if R.size == 0 then	-- process all
+
-				T:saveToLog("initial call lib.loadTurtle("..turtleName..", "..totalInStorage.." essence")
+
-				local processed = 0
+
-				local loaded = 0
+
 	function lib.isBorder(blockType)
-				while totalInStorage > 0 do		-- use ALL stored essence
+
-					if totalInStorage - 256 > 0 then
+
-						loaded = 64
+
 		end
-						loaded = totalInStorage / 4
+
 			return false, ""
-					lib.loadTurtle(availableStorage, availableStorageKeys, turtleName, essence, loaded)
+
-					lib.loadCrafter(crafterName)
+
-					lib.getCrystal()
+
-					processed = processed + loaded
+
-					totalInStorage = totalInStorage - loaded * 4
+
-					lib.runCrafter(crafterName, loaded)
+
-					lib.storeOutput()
+
 		end
-			elseif R.size <= 64 then
+
-				local loaded = math.min(R.size, totalInStorage)	-- process requested or available if less
+
-				if loaded > 0 then
+
-					lib.loadTurtle(availableStorage, availableStorageKeys, turtleName, essence, loaded)
+
-					lib.loadCrafter(crafterName)
+
-					lib.getCrystal()
+
-					lib.runCrafter(crafterName, loaded)
+
-					lib.storeOutput()
+
 		end
-			else	-- amount > 64
+
-				local processed = 0
+
-				local loaded = 0
+
-				while totalInStorage > 0 and processed < R.size do	-- stop if run out of essence, or reached target
+
-					if totalInStorage - 256 > 0 and R.size - processed >= 64 then
+
-						loaded = 64
+
-					elseif totalInStorage - 256 > 0 and R.size - processed > 0 then
+
-						loaded = R.size - processed
+
 		else
-					lib.loadTurtle(availableStorage, availableStorageKeys, turtleName, essence, loaded)
+
-					lib.loadCrafter(crafterName)
+
-					lib.getCrystal()
+
-					processed = processed + loaded
+
-					totalInStorage = totalInStorage - loaded * 4
+
-					lib.runCrafter(crafterName, loaded)
+
-					lib.storeOutput()
+
 		--[[ assume started after reset. if log above harvest tree else return to ground. Find starting corner]]
 		local blockType = T:getBlockType("up")					-- dig any logs above, return to ground
-			lib.storeOutput()
+
 		if blockType:find("log") ~= nil then					-- originally felling a tree so complete it
-		return {"success"}
+
 			local double = T:harvestTree(false, false, "up")	-- assume single tree, will auto-discover
 			lib.plantSapling(log, double)
 		else													-- no log above so go downm
-function utils.craftItem(R)
+
-	local message = network.loadStorageLists()	-- initialises or creates lists of where an item can be found: GLOBAL LISTS!
+
-	if message ~= nil then return {message} end
+
-	T:saveToLog("call network.emptyInventory(R, {'sapling', 'propagule', 'dirt', 'crafting'}, {'all'}, true)")
+
-	network.emptyInventory(R, {"sapling", "propagule", "dirt", "crafting"}, {"all"}, true)	-- 2 lists, one for barrels, one for chests
+
-	T:saveToLog("\ncall network.getItemFromNetwork('barrel', 'minecraft:dirt', 169)")
+
-	--network.getItemFromNetwork(storageType, itemRequired, countRequired, toTurtleSlot, ignoreStock)
+
-	local turtleSlot, turtleCount = network.getItemFromNetwork("barrel", "minecraft:dirt", 169, nil, false)
+
-	T:saveToLog("Get from barrel completed: turtleSlot = "..turtleSlot..", turtleCount = "..turtleCount..", ignoreStock = "..tostring(ignoreStock))
+
-	if turtleCount < 169 then
+
-		T:saveToLog("\ncall network.getItemFromNetwork('chest', 'minecraft:dirt', ".. 169 - turtleCount..", ignoreStock = "..tostring(ignoreStock)..")")
+
-		turtleSlot, turtleCount = network.getItemFromNetwork("chest", "minecraft:dirt", 169 - turtleCount, nil, true)
+
-		if turtleCount < 169 then	-- ask player for saplings
+
-			T:checkInventoryForItem({"dirt"}, {169 - turtleCount})
+
 	end
 	local secondBorderFound = false
 	while not secondBorderFound do
 		lib.safeMove()														-- moves forward until reaches border forward or below
 		lib.turn(direction)													-- turn r or l. direction is not changed
 		success, blockTypeF = lib.isBorder()								-- no blockType passed as parameter so will return current block in new forward direction
 		if success then
 			secondBorderFound = true										-- game over
 		elseif blockTypeF:find("log") ~= nil then							-- tree in front
 			lib.harvestTree(blockTypeF)
 		elseif blockTypeF == "" or blockTypeF:find("leaves") ~= nil then	-- air or leaves in front
 			T:forward(1)													-- move forward 1 block
 			lib.moveDown()													-- go down if required
 		elseif	blockTypeF:find("dirt") ~= nil or
 				blockTypeF:find("grass_block") ~= nil or
 				T:isVegetation(blockTypeF) then								-- dirt, grass_block or vegetation in front
 			blockTypeF = lib.moveUp(blockTypeF)								-- move up until air or border ahead.
 			if lib.isBorder(blockTypeF) then								-- border ahead
 				secondBorderFound = true
 			else															-- air ahead
 				T:forward(1)												-- move forward 1 block
 			end
 		end
 		direction = lib.turn(direction)										-- turn r or l. direction is changed to opposite
 	end
 	lib.moveDown()															-- return to ground level
 	lib.emptyInventory()
 	return {}
 end
 
 local function clearArea(R) -- 71, called from 22
 	local evenWidth = false
 	local evenHeight = false
 	local loopWidth
 	-- go(path, useTorch, torchInterval, leaveExisting)
 	if R.width % 2 == 0 then
 		evenWidth = true
 		loopWidth = R.width / 2
 	else
 		loopWidth = math.ceil(R.width / 2)
 	end
 	if R.length % 2 == 0 then
 		evenHeight = true
 	end
 	turtle.select(1)
-						T:place("minecraft:torch", "forward", false)
+
 	-- if R.width is even no, then complete the up/down run
 	-- if R.width odd no then finish at top of up run and reverse
 	-- should be on flat ground, check voids below, harvest trees
 	for x = 1, loopWidth do
 		-- Clear first column (up)
 		for y = 1, R.length do
 			if R.useBlockType == "dirt" then
 				if not turtle.detectDown() then
 					T:place("minecraft:dirt", -1, "down", true)
 				else --if not water, dirt, grass , stone then replace with dirt
 					blockType, blockModifier = T:getBlockType("down")
 					if blockType ~= "" then
 						if blockType ~= "minecraft:dirt" and blockType ~= "minecraft:grass_block" then
 							turtle.digDown()
 							T:place("minecraft:dirt", -1, "down", true)
-function utils.createStorage()
+
-	-- start in centre, above 1st level
+
-	T:place("modem", "down")
+
 			end
 			if y < R.length then
-	T:place("chest", "down")	-- places with handle at back of turtle
+
 			end
-	T:place("chest", "down")	-- 2nd of pair
+
-	for i = 1, 3 do
+
 		if x < loopWidth or (x == loopWidth and evenWidth) then -- go down if on R.width 2,4,6,8 etc
-		T:place("chest", "down")
+
-		T:go("R1F1L1")
+
-		T:place("chest", "down")
+
 					if not turtle.detectDown() then
 						T:place("minecraft:dirt", -1, "down", true)
-	T:go("F1L1F1")	-- end at starting position
+
-	network.attachModem()
+						blockType, blockModifier = T:getBlockType("down")
 						if blockType ~= "" then
 							if blockType ~= "minecraft:dirt" and blockType ~= "minecraft:grass_block" then
 								turtle.digDown()
 								T:place("minecraft:dirt", -1, "down", true)
 							end
 						end
 					end
 				end
 				if y < R.length then
 					T:go("F1+1", false, 0, false)
 				end
 			end
 			if x < loopWidth then
 				T:go("L1F1+1L1", false,0,false)
 			else
 				T:turnRight(1)
 				T:forward(R.width - 1)
 				T:turnRight(1)
 			end
 		else -- equals R.width but is 1,3,5,7 etc
 			T:turnLeft(2) --turn round 180
 			T:forward(R.length - 1)
 			T:turnRight(1)
 			T:forward(R.width - 1)
 			T:turnRight(1)
 		end
 	end
 	return {}
 end
 
 local function clearRectangle(R) -- 72
 	--local function clearRectangle(width, length, up, down)
 	-- height = 0: one level, 1 = +up, 2 = +down, 3 = +up/down
 	local lib = {}
 	function lib.UpDown(length)
 		for l = 1, length do
 			T:go("x0x2F1x0x2")
 		end
 	end
 
 	function lib.Up(length)
 		for l = 1, length do
 			T:go("x0F1x0")
 		end
 	end
 
 	function lib.Down(length)
 		for l = 1, length do
 			T:go("x2F1x2")
 		end
 	end
 
 	function lib.Forward(length)
 		T:forward(length)
 	end
 
 	-- could be 1 wide x xx R.length (trench) R.up and return
 	-- could be 2+ x 2+
 	-- even no of runs return after last run
 	-- odd no of runs forward, back, forward, reverse and return
 	turtle.select(1)
 	if R.width == 1 then 					-- single block trench ahead only
 		if R.up and R.down then				-- single block wide trench dig R.up and R.down = 3 blocks deep
 			lib.UpDown(R.length - 1)
 		elseif R.up then					-- single block wide trench dig R.up = 2 blocks deep
 			lib.Up(R.length - 1)
 		elseif R.down then				-- single block wide trench dig R.down = 2 blocks deep
 			lib.Down(R.length - 1)
 		else 							-- single block wide = 1 block deep
 			lib.Forward(R.length - 1)
 		end
 		T:turnRight(2)					-- turn at the top of the run
 		T:forward(R.length - 1)			-- return to start
 		T:turnRight(2)					-- turn round to original position
 	else 								-- R.width 2 or more blocks
 		local iterations = 0 			-- R.width = 2, 4, 6, 8 etc
 		if R.width % 2 == 1 then  		-- R.width = 3, 5, 7, 9 eg R.width 7
 			iterations = (R.width - 1) / 2 -- iterations 1, 2, 3, 4 for widths 3, 5, 7, 9
 		else
 			iterations = R.width / 2		-- iterations 1, 2, 3, 4 for widths 2, 4, 6, 8
 		end
 		for i = 1, iterations do 		-- eg 3 blocks wide, iterations = 1
 			if R.up and R.down then							-- dig R.up and R.down
 				lib.UpDown(R.length - 1)
 				T:go("x0x2R1F1x0x2R1x0x2")				-- turn round
 				lib.UpDown(R.length - 1)
 			elseif R.up then								-- dig R.up
 				lib.Up(R.length - 1)
 				T:go("x0R1F1x0R1x0")
 				lib.Up(R.length - 1)
 			elseif R.down then							-- dig R.down
 				lib.Down(R.length - 1)
 				T:go("x2R1F1x2R1x2")
 				lib.Down(R.length - 1)
 			else										-- no digging R.up or R.down
 				lib.Forward(R.length - 1)
 				T:go("R1F1R1")
 				lib.Forward(R.length - 1)
 			end
 			-- if 1 less than end, reposition for next run
 			if i < iterations then
 				T:go("L1F1L1", false, 0, false)
 			end
 		end
 		if R.width % 2 == 1 then  -- additional run and return to base needed
 			T:go("L1F1L1", false, 0, false)
 			if R.up and R.down then
 				lib.UpDown(R.length - 1)
 			elseif R.up then
 				lib.Up(R.length - 1)
 			elseif R.down then
 				lib.Down(R.length - 1)
 			else
 				lib.Forward(R.length - 1)
 			end
 			T:turnRight(2)
 			T:forward(R.length - 1)
 		end
 		T:go("R1F"..R.width - 1 .."R1", false, 0, false)
 	end
 	return {}
 end
 
 local function clearPerimeter(R) -- 74
 	local lib = {}
 	function lib.UpDown(length)
 		for l = 1, length do
 			T:go("x0x2F1x0x2")
 		end
 	end
 
 	function lib.Up(length)
 		for l = 1, length do
 			T:go("x0F1x0")
 		end
 	end
 
 	function lib.Down(length)
 		for l = 1, length do
 			T:go("x2F1x2")
 		end
 	end
 
 	function lib.Forward(length)
 		T:forward(length)
 	end
 
 	if R.up and R.down then
 		for i = 1, 2 do
 			lib.UpDown(R.length - 1)
 			T:turnRight(1)
 			lib.UpDown(R.width - 1)
 			T:turnRight(1)
 		end
 	elseif R.up then
 		for i = 1, 2 do
 			lib.Up(R.length - 1)
 			T:turnRight(1)
 			lib.Up(R.width - 1)
 			T:turnRight(1)
 		end
 	elseif R.down then
 		for i = 1, 2 do
 			lib.Down(R.length - 1)
 			T:turnRight(1)
 			lib.Down(R.width - 1)
 			T:turnRight(1)
 		end
 	else
 		for i = 1, 2 do
 			lib.Forward(R.length - 1)
 			T:turnRight(1)
 			lib.Forward(R.width - 1)
 			T:turnRight(1)
 		end
 	end
 	return {}
 end
 
 local function clearBuilding(R) -- 75, 43
 	--[[
 	Clear the outer shell of a building, leaving inside untouched. Optional floor/ceiling removal
 	clearBuilding(R)
 	R.subChoice = 1-'up' or 2-'down'
 	R.data.ceiling = true / false
 	R.data.floor = true / false
 	]]
 	local height = 1
 	local remaining = R.height -- eg 5
 	local start = true
 	local finish = false
 	local lib = {}
 
 	function lib.floorOrCeiling(R)
 		T:go("F1R1 F1L1")
 		R.length = R.length - 2
 		R.width = R.width - 2
 		clearRectangle(R)
 		R.length = R.length + 2
 		R.width = R.width + 2
 		T:go("L1F1R1")
 		utils.goBack(1)
 	end
 
 	function lib.singleLayer(R)
 		R.up = false
 		R.down = false
 		if start then
 			if R.data.ceiling or R.data.floor then	-- floor / ceiling to go. only one layer, so clearRectangle
 				lib.floorOrCeiling(R)
 			end
 			start = false
 		end
 		if finish then
 			if R.data.ceiling or R.data.floor then	-- floor / ceiling to go. only one layer, so clearRectangle
 				lib.floorOrCeiling(R)
 			end
 			finish = false
 		end
 		clearPerimeter(R)						-- no floor / ceiling
 	end
 
 	function lib.doubleLayer(R)
 		R.up = false
 		R.down = false
 		if start then
 			if R.data.floor and R.subChoice == 1 then		-- going up and floor needs removing
 				lib.floorOrCeiling(R)						-- remove floor/ceiling
 			elseif R.data.ceiling and R.subChoice == 2 then -- going down and ceiling needs removing
 				lib.floorOrCeiling(R)						-- remove floor/ceiling
 			end
 			start = false
 		end
 		if finish then
 			if R.data.ceiling and R.subChoice == 1 then		-- going down and ceiling needs removing
 				lib.floorOrCeiling(R)						-- remove floor/ceiling
 			elseif R.data.floor and R.subChoice == 2 then 	-- going down and floor needs removing
 				lib.floorOrCeiling(R)						-- remove floor/ceiling
 			end
 			finish = false
 		end
 		if R.subChoice == 1 then
 			R.up = true
 		else
 			R.down = true
 		end
 		clearPerimeter(R)
 	end
 
 	function lib.tripleLayer(R)
 		-- turtle in centre layer
 		R.up = false
 		R.down = false
 		if start then
 			if R.data.floor and R.subChoice == 1 then		-- going up and floor needs removing
 				height = height + utils.move(R, 1, true)	-- move down 1 block
 				lib.floorOrCeiling(R)						-- remove floor/ceiling
 				height = height + utils.move(R, 1)		-- move up 1 block
 			elseif R.data.ceiling and R.subChoice == 2 then -- going down and ceiling needs removing
 				height = height + utils.move(R, 1, true)	-- move up 1 block
 				lib.floorOrCeiling(R)						-- remove floor/ceiling
 				height = height + utils.move(R, 1)		-- move down 1 block
 			end
 			start = false
 		end
 		if finish then
 			if R.data.ceiling and R.subChoice == 1 then		-- going up and ceiling needs removing
 				height = height + utils.move(R, 1, true)					-- move down 1 block
 				lib.floorOrCeiling(R)						-- remove floor/ceiling
 				height = height + utils.move(R, 1)							-- move up 1 block
 			elseif R.data.floor and R.subChoice == 2 then 	-- going down and floor needs removing
 				height = height + utils.move(R, 1, true)					-- move up 1 block
 				lib.floorOrCeiling(R)						-- remove floor/ceiling
 				height = height + utils.move(R, 1)							-- move up 1 block
 			end
 			finish = false
 		end
 		R.up = true
 		R.down = true
 		clearPerimeter(R)
 	end
 	--[[
 	R.data = "up" or "down" as direction of travel
 	R.up = true to remove ceiling
 	R.down = true to remove floor
 	]]
-		if not T:place("sand", "down", false) then
+
 	if R.height < 3 then 						--1-3 layers only
 		if R.height == 1 then 					--one layer only
 			lib.singleLayer(R)
 		elseif R.height == 2 then 				--2 layers only current + dig up/down
 			lib.doubleLayer(R)
 		end
 	else -- 3 or more levels
 		height = height + utils.move(R, 1)							-- move up/down 1 block for first layer
 		while remaining >= 3 do -- min 3 levels
 			lib.tripleLayer(R)
 			remaining = remaining - 3
 			if remaining == 0 then				-- all finished
 				break
 			elseif remaining == 1 then
 				height = height + utils.move(R, 2)					-- move up/down 2 blocks
 				lib.singleLayer(R)
 			elseif remaining == 2 then
 				height = height + utils.move(R, 2)					-- move up/down 2 blocks
 				lib.doubleLayer(R)
 			else
 				height = height + utils.move(R, 3)					-- move up/down 3 blocks
 				if remaining == 3 then
 					finish = true
 				else
 					--height = height + 3
 				end
 			end
 		end
 	end
 
 	if height > 1 then
 		utils.move(R, height - 1, true) -- reverse direction
 	end
 
 	return {}
 end
 
 local function clearMineshaft(R, equippedRight, equippedLeft, inInventory) -- 19
 	local lib = {}
 
 	function lib.checkCobweb(directions, inInventory)
 		assert(type(directions) == "table", "directions must be a table eg {'up','down'}")
 		for _, direction in ipairs(directions) do
 			local blockType = T:getBlockType(direction)
 			if inInventory == "minecraft:diamond_sword" then -- using a sword
 				local side = "left"
 
 				if blockType:find("cobweb") ~= nil then
 					--clsTurtle.equip(self, side, useItem, useDamage)
 					if equippedRight == "minecraft:diamond_pickaxe" then
 						side = "right"
 					end
 					T:equip(side, "minecraft:diamond_sword")
 					T:dig(direction)
 					T:equip(side, "minecraft:diamond_pickaxe")
 				elseif blockType ~= "" then
 					T:dig(direction)
 				end
 			else
 				T:dig(direction)
 			end
 		end
 	end
 
 	-- check position by rotating until facing away from wall
 	length = 0
 	torch = 0
 	turns = 0
 	while not turtle.detect() do
 		T:turnRight(1)
 		turns = turns + 1
 		if turns > 4 then
 			return {"I am not facing a wall. Unable to continue"}
 		end
 	end
 	T:turnRight(2)
 	-- move forward until obstructed, digging up/down. place torches
 	while not turtle.detect() do
 		lib.checkCobweb({"up","down"}, inInventory) -- dig cobweb or any other block up/down
 		length = length + 1
 		torch = torch + 1
 		if torch == R.torchInterval then
 			torch = 0
 			T:place("minecraft:torch", -1, "down", false) ---(self, blockType, damageNo, direction, leaveExisting, signText)
 		end
 		lib.checkCobweb({"forward"}, inInventory) -- dig cobweb or any other block in front
 		T:forward(1)
 	end
 	-- turn right, forward, right, return to start with up/down dig
 	T:go("R1")
 	lib.checkCobweb({"up","down"}, inInventory) -- dig cobweb or any other block up/down
 	T:go("F1R1")
 	for i = 1, length, 1 do
 		lib.checkCobweb({"up", "down", "forward"}, inInventory) -- dig cobweb or any other block up/down/forward
 		T:forward(1)
 	end
 	-- move to other wall and repeat.
 	T:go("R1")
 	lib.checkCobweb({"up","down"}, inInventory) -- dig cobweb or any other block up/down
 	T:go("F1")
 	lib.checkCobweb({"up","down"}, inInventory) -- dig cobweb or any other block up/down
 	T:go("F1R1")
 	lib.checkCobweb({"up","down"}, inInventory) -- dig cobweb or any other block up/down
 	for i = 1, length, 1 do
 		lib.checkCobweb({"up", "down", "forward"}, inInventory) -- dig cobweb or any other block up/down/forward
 		T:forward(1)
 	end
 	lib.checkCobweb({"up", "down"}, inInventory) -- dig cobweb or any other block up/down/forward
 
 	return {}
 end
 
 local function clearMonumentLayer(R) -- 85
 	R.up = true
 	R.down = true
 	R.silent = true
 	if R.subChoice == 0 then
 		R.up = false
 		R.down = false
 	end
 	-- send turtle down until it hits bottom
 	-- then clear rectangle of given size
 	-- start above water, usually on cobble scaffold above monument
 	if T:detect("down") then -- in case not over wall
 		T:forward(1)
 	end
 	local height = 1
 	-- go down until solid block detected
 	while utils.clearVegetation("down") do
 		T:down(1)
 		height = height + 1
 	end
 	T:down(1)
 	height = height + 1
 	clearRectangle(R)
-	local lastSlot, leastModifier, total, slotData = T:getItemSlot("minecraft:bucket")
+
 
 	return {}
 end
 
 local function clearWaterPlants(R) -- 87
 	local lib = {}
 
 	function lib.getLength()
 		local length = 1
 		print("Checking water length")
 		while utils.clearVegetation("forward") do
 			T:forward(1)
 			length = length + 1
 		end
 		for i = 1, length do
 			turtle.back()
 		end
 		return length
 	end
 
 	function lib.clearDown(D)
 		while utils.clearVegetation("down") do --clears any grass or sea plants, returns true if air or water, bubble column or ice
 			T:down(1)
 			D.depth = D.depth + 1
-function utils.getSlotCapacity(slot)
+
-	return turtle.getItemSpace(slot) + turtle.getItemCount(slot)
+
 		D.blockType = T:getBlockType("down")
 		if D.blockType:find("slab") ~= nil then
 			T:go("C2")
 		end
 		if D.depth > D.maxDepth then
 			D.maxDepth = D.depth
 		end
 
 		return D
 	end
 
 	function lib.clearLength(D)
 		local moves = 0
 		local blockHeight = 1
 		D.floorLength = 0 -- reset
 		while moves < D.length - 1 do
 			if utils.clearVegetation("forward") then
 				T:forward(1)
-	-- lastSlot, leastModifier, total, slotData  = T:getItemSlot(item)
+
-	local lastSlot, leastModifier, total, slotData = T:getItemSlot("minecraft:water_bucket")
+
 					if not D.monumentArchesClear then
 						D = lib.checkArches(D)
 					end
 				end
 				local temp = D.depth
 				D = lib.clearDown(D) -- go down if in water/air
 				if blockHeight == 4 and D.depth - temp == 3 then -- could be just gone over 3 block high column in ocean monument
 					if not D.monumentTopClear then
 						D = lib.checkTop(D)
 					end
 					blockHeight = 1
 				end
 				if D.useBlockType == "prismarine" then
 					if D.blockType:find("prismarine") == nil then
 						-- on monument floor so restrict forward movement to 8 blocks
 						D.floorLength = D.floorLength + 1
 						if D.floorLength == 8 then
 							D.blockType = T:getBlockType("forward")
 							while D.blockType:find("prismarine") == nil do
 								T:up(1)
 								D.blockType = T:getBlockType("forward")
 							end
 							D.floorLength = 0
 						end
 					end
 				end
 				if moves >= D.length - 1 then
 					D.width = D.width + 1	-- another length completed so increase width
 					return D
 				end
 			else -- block in front
 				blockHeight = 1
 				local waterAbove = utils.clearVegetation("up")
 				local waterAhead = utils.clearVegetation("forward") -- true if air/water in front
 				while not waterAhead do 	-- solid block in front
 					if waterAbove then 		-- move up
 						T:up(1)
 						D.depth = D.depth - 1
 						blockHeight = blockHeight + 1
 						if D.depth < 1 then
 							D.width = D.width + 1	-- another length completed so increase width
 							return D
 						end
 					else 					-- block above so go back
 						while not waterAbove do
 							utils.goBack()	--  returns true if no object behind, but moves anyway
 							waterAbove = utils.clearVegetation("up")
 							moves = moves - 1
 							if moves == 0 then
-function utils.isStorage(direction)
+
-	local blockType = T:getBlockType(direction)
+
-	if blockType:find("barrel") ~= nil then
+
-		return true, "barrel"
+
-	elseif blockType:find("chest") ~= nil then
+
-		return true, "chest"
+
-	elseif blockType:find("modem") ~= nil then
+
-		return true, "modem"
+
 						end
 						-- go up 1 to prevent loop
-	return false, blockType
+
 						D.depth = D.depth - 1
 					end
-function utils.isTableEmpty(aTable)
+
-	if next(aTable) == nil then
+
 				end
 			end
-	return false
+
 		D.width = D.width + 1	-- another length completed so increase width
 		D.maxDepth = D.maxDepth + 1 -- +1 to allow for starting pos in top layer
 
-	if blocks == 0 then return 0 end
+
 	end
 
 	function lib.checkArches(D)
 		-- gone under a block so could be monument arch (6)
-		--if R.subChoice == 2 then -- reverse direction
+
-		if R.direction == "down" or R.subChoice == 2 then -- reverse direction
+
 			T:go("B1U2F1R1")
 			if T:getBlockType("forward"):find("prismarine") ~= nil then -- correct guess
 				direction = "R"
 			else	-- wrong direction. turn round and check other side
 				T:go("R2")
 				if T:getBlockType("forward"):find("prismarine") ~= nil then
-		--if R.subChoice == 1 then
+
-		if R.direction == "up" or R.subChoice == 1 then
+
 			end
 			local path = "U1F1 U1F3 D1F1 D1R2 U2F5 D2"
 			--for i = 1, 6 do
 			T:go(path) -- clears arch top 1 and returns
 			T:go(direction.."1F6"..direction.."1")
 			T:go(path) -- clears arch top 2 and returns
 			T:go(direction.."1F6"..direction.."1")
 			T:go(path) -- clears arch top 3 and returns
-function utils.printR(R)
+
 			T:go(path) -- clears arch top 4 and returns
-		choice = 0,
+
-		subChoice = 0,
+
-		size = 0,
+
-		width = 0,
+
-		length = 0,
+
-		height = 0,
+
-		depth = 0,
+
-		up = false,
+
-		down = false,
+
-		silent = false,
+
-		data = {},
+
-		torchInterval = 0,
+
-		useBlockType = "",
+
-		auto = false,
+
-		side = "",
+
-		direction = "",
+
-		ready = false,
+
-		networkFarm = false,
+
-		mysticalAgriculture = false,
+
-		logType = "",
+
-		treeSize = "",
+
-		message = ""
+
 				end
 			end
-	print("choice= ".. tostring(R.choice)..", subChoice= ".. tostring(R.subChoice))
+
-	print("size= ".. tostring(R.size)..", width= ".. tostring(R.width))
+
-	print("length= ".. tostring(R.length)..", height= ".. tostring(R.height)..", depth= ".. tostring(R.depth))
+
-	print("silent= "..tostring(R.silent)..", up= ".. tostring(R.up)..", down= "..tostring(R.down))
+
-	print("torchInterval= ".. tostring(R.torchInterval))
+
-	print("useBlockType= "..tostring(R.useBlockType))
+
-	print("auto= ".. tostring(R.auto)..", side= "..tostring(R.side)..", direction= "..tostring(R.direction))
+
-	print("ready= ".. tostring(R.ready)..", networkFarm= "..tostring(R.networkFarm)..", mysticalAgriculture= "..tostring(R.mysticalAgriculture))
+
-	print("logType= ".. tostring(R.logType)..", treeSize= "..tostring(R.treeSize)..", message= "..tostring(R.message))
+
-	if type(R.data) == "table" then
+
-		io.write("data= ")
+
-		for k,v in pairs(R.data) do
+
-			print(k ..": "..tostring(v))
+
 		repeat
 			if utils.clearVegetation("forward") then
-		print("data= ".. tostring(R.data))
+
 				D = lib.clearDown(D) -- go down if in water/air, D.blockType is updated with floor type
-	io.write("Enter to continue")
+
 				local waterAbove = utils.clearVegetation("up")
 				local waterAhead = utils.clearVegetation("forward") -- true if air/water in front
 				while not waterAhead do 	-- solid block in front
 					if waterAbove then 		-- move up
 						T:up(1)
 					else 					-- block above so go back
 						while not waterAbove do
 							utils.goBack()	--  returns true if no object behind, but moves anyway
 							waterAbove = utils.clearVegetation("up")
 						end
 					end
 					waterAbove = utils.clearVegetation("up")
 					waterAhead = utils.clearVegetation("forward")
 				end
 			end
 		until D.blockType:find(D.useBlockType) == nil
 		-- now above a non-prismarine block, facing away from monument
 		T:turnRight(2) -- facing monument
 		D.blockType = T:getBlockType("forward")
 		while D.blockType:find(D.useBlockType) ~= nil do
 			T:up(1)
 			D.blockType = T:getBlockType("forward")
 		end
 		T:go("F1L1")
 		D.blockType = T:getBlockType("down")
 		while D.blockType:find(D.useBlockType) ~= nil do
 			T:forward(1)
 			D.blockType = T:getBlockType("down")
 		end
 		turtle.back()
 		-- should now be at end of monument base
-function utils.tableContains(tableName, value, exactMatch)
+
-	exactMatch = exactMatch or false
+
-	for k, v in ipairs(tableName) do
+
-		if exactMatch then
+
-			if v == value then
+
 			direction = "L"
 		end
 		T:go(direction.. 1)
-			if v:find(value) ~= nil then
+
 			T:forward(1)
 			--D.depth = D.depth + lib.clearDown(depth)
 			D = lib.clearDown(D)
 		else
-	return false
+
 				T:up(1)
 				D.depth = D.depth - 1
-function utils.useSticksAsFuel()
+
-	local slot = T:getItemSlot("minecraft:stick")
+
-	if slot > 0 then -- use any sticks to refuel
+
-		turtle.select(slot)
+
-		turtle.refuel()
+
 
-	slot = T:getItemSlot("minecraft:mangrove_roots")
+
-	if slot > 0 then -- use any roots to refuel
+
-		turtle.select(slot)
+
-		turtle.refuel()
+
 	D.depth = 0
 	D.maxDepth = 0
 	D.blockType = ""
-function utils.waitForInput(message)
+
-	-- debugging. Pause script and asks user to continue
+
-	-- global dbug flag has to be set first
+
-	if dbug then
+
-		if message ~= nil then
+
-			print(message)
+
-			T:saveToLog(message, false)
+
 	D.onWater = false
-		menu.colourPrint("Enter to continue...", colors.lightBlue)
+
-		--io.write("Press Enter to continue...")
+
-		return read()
+
 	if R.data == "clearWaterPlants" then -- NOT monument corner discovery
 		D.inWater, D.onWater = utils.startWaterFunction(D.onWater, D.inWater, 2, true) -- move into water
 		if R.length == 0 then
-function utils.writeTraceTable(description, tbl)
+
-	local text = ""
+
-	for key, value in pairs(tbl) do
+
-		if type(value) == "table" then
+
-			for k,v in pairs(value) do
+
-				text = text.."k = "..k..", v = "..v.."; "
+
 		end
 	end
-			text = "key = "..key..", value = "..value
+
 	D = lib.clearDown(D) -- go down to floor, set depth, maxDepth, blockType
 	if R.data == "clearWaterPlants" then -- NOT monument corner discovery
-	T:saveToLog(description.."\n".. text)
+
 			print("Single row clearing")
 			D = lib.clearLength(D) --D.width also increased
 		else
 			while D.width < R.width do -- D.width starts at 0
 				-- now on floor, move along sea/river bed following contour
 				D = lib.clearLength(D) --D.width also increased
 				-- now turn and repeat
 				if D.width < R.width then
 					D = lib.turn(D)
 					if D.depth <= 0 then
 						break
 					end
 				end
 			end
 		end
 		-- finished so return to surface
 		T:up(1) -- up 1 to check for water below
 		while T:getBlockType("down"):find("water") ~= nil do
 			T:up(1)
 		end
 		T:down(2) -- return to surface
 		--[[while utils.clearVegetation("forward") do
 			T:forward(1)
 		end]]
 	elseif R.data == "oceanMonumentColumns" then -- monument corner discovery
 		-- this function used to find edge of monument base
 		if D.blockType:find(D.useBlockType) ~= nil then
 			lib.findBlockTypeEnd(D)
 			return {""}
 		else
 			T:up(D.depth)
 			return {"Prismarine not found on ocean floor"}
 		end
 	end
 	if R.silent then
 		return {D.maxDepth, R.length}
 	else
 		return {""}
 	end
 end
 
 local function clearMountainSide(R) -- 78
 	--[[
 	First row              outward  l  s  f  mid    (length, start, finish, midPoint)
 
 	      >|*|*|           true                     lib.clearRow() moves: 7-5=2, midPoint starts at 2
 	      +|*|*|
 	      +|*|*|
 	      ^|*|*|        <  false    7  5  6  2      lib.clearRow() moves: 9-2=7, midPoint starts at -4 -1 = -5
 	       |*|*|*|	    +
 	     |*|*|*|*|*|    +
 	  >  |*|*|*|*|*|    ^  true     9  2  6  -4     lib.getStartingLength(). Ends 1 block after block finish
 	  ^|*|*|*|*|*|*|*|*|                            starts here, moves up 1
 	    1 2 3 4 5 6 7 8                             block index
 
 	Second row                outward l  s  f  mid
 	             <            false
                  +
           |*|*|  +
 	   >|*|*|*|*|^            true
 	   +|*|*|*|*|
 	   +|*|*|*|*|
 	   ^|*|*|*|*|          <  false   6  5  6  2
 	    |*|*|*|*|*|*|      +
 	  |*|*|*|*|*|*|*|*|    +
 	  |*|*|*|>|*|*|*|*|    ^  true    7+5   5 -7    lib.getHalf(R); goBack(7)
 	|*|*|*|*|*|*|*|*|*|*|*|                           starts at midPoint of previous row eg block 4
 	 0 1 2 3 4 5 6 7 8 9 10
 	]]
 
 	-- variables declared before lib for them to be used within lib as is then in scope
 	local turn = "R"
 	local oTurn = "L"
 	if R.subChoice == 1 then 	-- remove left side
 		turn = "L"
 		oTurn = "R"
 	end
 	local outward = true		-- direction flag
 
 	local lib = {}
 
 	function lib.isAnyAbove(above)
 		T:saveToLog("lib.isAnyAbove: "..utils.tableConcat(above, ", "), false)
 		for k,v in ipairs(above) do
 			if v then
 				T:saveToLog("lib.isAnyAbove Found: "..k , false)
 				return true
 			end
 		end
 		return false
 	end
 
 	function lib.clearLevel(R, above)	-- eg 9, 2, 6, -4 from lib.getStartingLength OR 7, 5, 6, 3 from previous
 		-- clearLevel always follows either lib.getStartingLength or a previous lib.clearLevel
 		-- midPoint should be adjusted as turtle moves to reflect current row length
 		if #above == 0 then return above, 1 end
 		--local index = 0
 		local minMoves = math.floor(#above / 2)
 		local up, forward, down = lib.getDetect()
 		if outward then										-- follow table indexes
 			for x = 1, minMoves do							-- clear first half
 				above[x] = up								-- reset this with new value
 				T:go("x0x2F1")								-- clear and move forward
 				up, forward, down = lib.getDetect()
 				--index = index + 1
 			end
 			for x = minMoves + 1, #above do					-- check remaing half and clear
 				T:go("x0x2")								-- clear above / below
 				if above[x] then							-- is a block recorded as present?(now below)
 					above[x] = up							-- reset this with new value
 					T:forward(1)							-- move forward
 					up, forward, down = lib.getDetect()
 					--index = index + 1
 				else
 					break
 				end
 			end
 		else												-- iterate table in reverse
 			--index = #above
 			for x = #above, minMoves, -1 do					-- clear first half
 				above[x] = up								-- reset this with new value
 				T:go("x0x2F1")								-- clear and move forward
 				up, forward, down = lib.getDetect()
 				--index = index - 1
 			end
 			for x = minMoves - 1, 1, -1 do					-- check remaing half and clear
 				T:go("x0x2")								-- clear up / down
 				if above[x] then							-- is a block recorded as present?(now below)
 					above[x] = up							-- reset this with new value
 					T:forward(1)							-- move forward
 					up, forward, down = lib.getDetect()
 					--index = index - 1
 				else
 					break
 				end
 			end
 		end
 		T:go("x0x2 F1R2 x0x2 F1")							-- face opposite direction, delete blocks above and below
 		outward = not outward								-- switch direction flag
 		return above										-- eg {false, true, true, true, false}
 	end
 
 	function lib.getDetect()
 		return turtle.detectUp(),  turtle.detect(),  turtle.detectDown()
 	end
 
 	function lib.getStartingLength(R)
 		--[[
 			length of column by excavating blocks above, ahead or below
 			Rotate 180 at end of run ready to return
-				T:place("stairs", "up")
+
 		]]
 		local above = {}									-- empty table of boolean values
 		local length = 0									-- used as counter
 		T:forward(1)										-- start check 1 block ahead
 		local up, forward, down = lib.getDetect() 			-- check if anything around current block
 		if up or forward or down then						-- block found nearby: continue
 			while up or forward or down do					-- while blocks ahead / up / down move forward
 				table.insert(above, up)
 				T:go("x0x2F1")
 				up, forward, down = lib.getDetect() 		-- check if anything around current block
 				length = length + 1
 				if length >= R.length then					-- check if going out of range
 					T:saveToLog("lib.getStartingLength(R) : outward = "..tostring(outward).." MaxLength "..maxLength.." reached", false)
 					break
 				end
 			end
 			T:go("R2x0x2")									-- Rotate 180 and clear blocks above/below
 		else												-- no blocks nearby: exit
 			T:go("R2F1")									-- return to start position rotated 180
 		end
 		outward = not outward
 
 		return above 										-- above = {false, true, true, true, true, false, false}
 	end
 
 	function lib.firstRow(R)
 		local height = 1									-- starts at ground level, but forced up 1
 		T:up(1)
 		local above = lib.getStartingLength(R)				-- clear the ground level and 1 above eg 9, 2, 5, 4
 		if T:saveToLog("startLength: "..#above, true) then
 			T:saveToLog(utils.tableConcat(above, ", "), false)
 			if dbug then read() end
 		end													-- at end of first row as already turned 180, outward set to false in getStartingLength
 		while lib.isAnyAbove(above) do
 			T:go("U3")	-- go up 3
 			height = height + 3
 			above = lib.clearLevel(R, above)	-- returns start and finish of blocks above, rotates 180
 			if T:saveToLog("checking level: "..height, true) then
 				T:saveToLog(utils.tableConcat(above, ", "), false)
 				if dbug then read() end
 			end
 		end													-- first row all levels completed.
 		T:down(height)										-- now on ground + 1, facing last column cleared.
 
 		return above
 	end
 
 	function lib.deepCopy(tbl)
 		local copy = {}
 		for key, value in ipairs(tbl) do
 			table.insert(copy, value)
 		end
 		return copy
 	end
 
 	function lib.getHalf(R, above)
 		-- already 1 block above ground
 		local maxLength = R.length
 		local temp = {}
 		local retValue = {}
 		if #above > 0 then								-- not empty table, so must be second half
 			temp = lib.deepCopy(above)					-- copy existing table
 			above = {}									-- initialise above
 		end
 		local up, forward, down = lib.getDetect()
 
 		while up or forward or down do					-- while blocks ahead / up / down move forward
 			T:go("x0x2F1")
 			table.insert(above, up)
 			up, forward, down = lib.getDetect() 		-- check if anything around current block
 
 			if #above >= math.floor(maxLength / 2) then	-- check if going out of range
 				T:saveToLog("lib.getHalf(R) : outward = "..tostring(outward).." MaxLength "..maxLength.." reached", false)
 				T:go("x0x2")
 				break
 			end
 		end
 		T:turnRight(2)									-- ready for next half or return
 		outward = not outward
 		if #temp > 0 then								-- completing a second half measurement
 			for i = #above, 1, -1 do
 				table.insert(retValue, above[i])		-- combine 2 tables into 1
 			end
 			for i = 1, #temp do
 				table.insert(retValue, temp[i])
 			end
 		else
 			retValue = above
 		end
 		return retValue
 	end
 
 	function lib.nextRow(R)
-			T:place("slab", "forward")
+
 		T:saveToLog("lib.nextRow(R)", false)
 		T:up(1)
 		local pattern = turn.."1F1"..turn.."1"
 		if not outward then
 			pattern = oTurn.."1F1"..oTurn.."1"
 		end
 		T:go(pattern)
 		T:saveToLog("    T:go("..pattern..")", false)
 		outward = not outward -- reverse direction flag
 		-- now in next vertical row
 		local above = lib.getHalf(R, {})
 		local index = 0
 		if T:saveToLog("\t  first half Length: "..#above.." Enter", true) then
 			T:saveToLog(utils.tableConcat(above, ", "), false)
 			if dbug then read() end
 		end
 		lib.returnToMidPoint(#above)					-- return to starting point
 		T:forward(1)
 		above = lib.getHalf(R, above)					-- returns length - 1 eg 5, 4
 		if T:saveToLog("\t  total length: "..#above.." Enter", true) then
 			T:saveToLog(utils.tableConcat(above, ", "), false)
 			if dbug then read() end
 		end
 
-					T:place("stairs", "up")
+
 			T:go("U3")				-- go up 3
 			height = height + 3		-- increment height
 			T:saveToLog("\tClear height loop: height = "..height, false)
 			above = lib.clearLevel(R, above)	-- returns start and finish of blocks above
 		end
 		T:down(height)	-- now on ground + 1
 		lib.returnToMidPoint(above)
 	end
 
 	function lib.returnToMidPoint(above)
 		--[[ value can be integer or table]]
 		if type(above) == "table" then
 			T:saveToLog("lib.returnToMidPoint("..#above..")", false)
 			if #above > 0 then
 				local midPoint = math.floor(#above / 2)
 				if #above % 2 == 1 and  not outward then -- length is odd no
 					midPoint = math.ceil(#above / 2)
 					T:saveToLog("    midPoint adjusted "..midPoint..")", false)
 				end
 				T:saveToLog("    T:forward("..midPoint..")", false)
 				T:forward(midPoint)
 			end
 		else
 			T:saveToLog("lib.returnToMidPoint("..above..")", false)
 			if above > 0 then
-				T:place("slab", "forward")
+
 				T:forward(above)
 			end
-			T:place("slab", "forward")
+
 		-- now back at starting point
-			T:place("slab", "forward")
+
 
 	-- Start here
 	-- if "tk log d.." typed instead of "tk" will start logfile and display comments. read() will be activated for debugging
 	T:saveToLog("Starting function clearMountainSide", false)
 	local above = lib.firstRow(R) 			-- outward depends on height eg 1-2 = false, 3-5 = true, 6-8 = false
 	lib.returnToMidPoint(above)				-- return to mid first row of blocks
 	for row = 1, R.width -1 do
 		lib.nextRow(R)
 	end
 
 	return {}
 end
 
 local function clearSandWall(R) -- 81
 	--dig down while on top of sand/red_sand/soul_sand
 	local lib = {}
 
 	function lib.checkAbove(height)
 		if turtle.detectUp() then -- moved under a ledge
 			T:go("B1U1")
 			height = height - 1
 		end
 		return height
 	end
 
 	function lib.moveDown(height)
 		blockType = T:getBlockType("down")
 		while blockType:find("sand") ~= nil do
 			T:down(1)
 			height = height + 1
 			blockType = T:getBlockType("down")
 		end
 		return height
 	end
 
 	function lib.moveForward(length)
 		lib.digForward()
 		T:forward(1)
 		length = length + 1
 		local blockType = T:getBlockType("forward")
 		return length, blockType
 	end
 
 	function lib.digForward()
 		while T:dig("forward") do
 			while T:suck("forward") do end
 			while T:suck("up") do end
 		end
 	end
 
 	local moves  = 0
 	local height = 0
 	local length = 0
 	local search = 0
 	local reverse = false
 	local blockType = T:getBlockType("down")
 	if R.length == 0 then
 		R.length = 64
 	end
 
 	print("Checking for sand below")
 	while blockType:find("sand") == nil do --move forward until sand detected or 3 moves
 		T:forward(1)
 		search = search + 1
 		blockType = T:getBlockType("down")
 		if search > 3 then
 			T:go("B"..search)
 			return {"Unable to locate sand"}
 		end
 	end
-					T:place(sapling, "down")
+
 	height = lib.moveDown(height)	-- go down if sand below
 	-- repeat until height == 0
 	repeat -- starts at bottom of sand wall
 		blockType = T:getBlockType("forward")
-				if not T:place(sapling, "down") then
+
-					T:place("sapling", "down")
+
 			if blockType == "" or  blockType:find("sand") ~= nil then -- sand or nothing in front
 				height = lib.moveDown(height)	-- go down if sand below
 			end
-			if not T:place(sapling, "down") then
+
-				T:place("sapling", "down")
+
 				blockType = T:getBlockType("down")
 				if blockType:find("sand") ~= nil then -- sand below
 					T:dig("down")
 				end
 				T:up(1)
 				height = height - 1
 			else -- air/water in front so move forward
 				if length < 60 then -- in case missing wall and in open ocean
 					length, blockType = lib.moveForward(length) -- move forward 1 and dig sand
 					height = lib.checkAbove(height)
 				else -- already > monument length of 56
 					T:up(1)
 					height = height - 1
 				end
 			end
 		end
 	until height == 0 or length == R.length
 	blockType = T:getBlockType("down")
 	if blockType:find("sand") ~= nil then -- sand below
 		T:dig("down")
 	end
 	if height > 0 then -- finished as length ran out
 		T:up(height)
 	end
 	-- stay at end of cleared wall unless user chose to return
 	if R.data == "return" then
 		T:go("R2F"..length.."R2")
 	end
 
 	return {}
 end
 
 local function clearSolid(R) -- 76
 	--[[ direction = R.subChoice = 1 up or 2 down ]]
 	local height = 1
 	local remaining = R.height
 	local lib = {}
 
 	function lib.singleLayer(R)
 		R.up = false
 		R.down = false
 		clearRectangle(R)
 	end
 
 	function lib.doubleLayer(R)
 		R.up = false
 		R.down = false
 		if R.subChoice == 1 then
 			R.up = true
 		else
 			R.down = true
 		end
 		clearRectangle(R)
 	end
 
 	function lib.tripleLayer(R)
 		-- turtle in centre layer
 		R.up = true
 		R.down = true
 		clearRectangle(R)
 	end
 
 	R.silent = true
 	if R.height < 3 then 							--1-3 layers only
 		if R.height == 1 then 						--one layer only
 			lib.singleLayer(R)
 		elseif R.height == 2 then 					--2 layers only current + dig up/down
 			lib.doubleLayer(R)
 		end
 	else -- 3 or more levels
 		height = height + utils.move(R, 1)			-- move up/down 1 block for first layer
 		while remaining >= 3 do 					-- min 3 levels
 			lib.tripleLayer(R)
 			remaining = remaining - 3
 			if remaining == 0 then					-- all finished
 				break
 			elseif remaining == 1 then
 				height = height + utils.move(R, 2)	-- move up/down 2 blocks
 				lib.singleLayer(R)
 			elseif remaining == 2 then
 				height = height + utils.move(R, 2)	-- move up/down 2 blocks
 				lib.doubleLayer(R)
 			else
 				height = height + utils.move(R, 3)	-- move up/down 3 blocks
 				if remaining == 3 then
 					finish = true
 				end
 			end
 		end
 	end
 
 	if height > 1 then
 		utils.move(R, height - 1, true) -- reverse direction
 	end
 
 	return {}
 end
 
 local function clearSandCube(R) -- 81
 	R.data = ""
 	for w = 1, R.width do
 		clearSandWall(R)
 		if w < R.width then
 			if w % 2 == 1 then
 				T:go("R1F1R1")
 			else
 				T:go("L1F1L1")
 			end
 		end
 	end
 
 	return {}
 end
 
 local function clearWall(R) -- 73
 	local lib = {}
 
 	function lib.move(direction, blocks, reverse)
 		--[[ Move up or down by blocks count ]]
 		if reverse == nil then
 			reverse = false
 		end
 		if reverse then
 			if direction == "down" then -- reverse direction
 				T:up(blocks)
 			else
 				T:down(blocks)
 			end
 		else
 			if direction == "up" then
 				T:up(blocks)
 			else
 				T:down(blocks)
 			end
 		end
 		return blocks
 	end
 
 	function lib.singleLayer(length)
 		T:go("F"..length - 1)
 	end
 
 	function lib.doubleLayer(modifier, length)
 		for i = 1, length do
 			if i < length then
 				T:go("x"..modifier.."F1")
 			else
 				T:go("x"..modifier)
 			end
 		end
 	end
 
 	function lib.tripleLayer(direction, length)
 		for i = 1, length do
 			if i < length then
 				T:go("x0x2F1")
 			else
 				T:go("x0x2")
 			end
 		end
 	end
 
 
 	-- R.width preset to 1
 	-- R.subChoice = 1 up / 2 down
 	if R.height < 3 then
 		R.silent = true
 	end
 	-- dig along and up/down for specified R.length
 	local modifier = "0"
 	local direction = "U"
 	local outbound = true
 	local height = 0
 	if R.subChoice == 2 then
 		 modifier = "2"
 		 direction = "D"
 	end
 	if R.height == 1 then 				-- single block so dig and return
 		lib.singleLayer(R.length)
 	elseif R.height == 2 then
 		lib.doubleLayer(modifier, R.length)
 	else								-- 4 blocks or more. start with bulk 3 blocks
 		local remaining = R.height
 		T:go(direction.."1")			-- up 1 or down 1
 		height = 1
 		while remaining >= 3 do
 			lib.tripleLayer(direction, R.length)
 			remaining = remaining - 3
 
 			if remaining == 0 then		-- no more, return home, already in position
 
 			elseif remaining == 1 or remaining == 2 then
 				T:go(direction.."2")
 				height = height + 2
 			else
 				T:go(direction.."3")
 				height = height + 3
 				if remaining >= 3 then -- another iteration
 					T:go("R2")
 					outbound = not outbound
 				end
 			end
 		end
 		-- 0, 1 or 2 layers left
 		if remaining > 0 then
 			T:go("R2")
 			outbound = not outbound
 			if remaining == 1 then
 				lib.singleLayer(R.length)
 			elseif remaining == 2 then
 				lib.doubleLayer(modifier, R.length)
 			end
 		end
 	end
 	if outbound then
 		T:go("R2F"..R.length)
 	else
 		T:forward(1)
 	end
 	direction = "D" -- reverse direction
 	if R.subChoice == 2 then
 		 direction = "U"
 	end
 	if height > 0 then
 		T:go(direction..height.."R2")
 	else
 		T:go("R2")
 	end
 	return {}
 end
 
 local function convertWater(R) -- 88
 	--[[
 	if dry need enough buckets to place along (width + length - 1) / 2
 	use 12 buckets
 	start on floor + 1
 	place slab down and water up along 2 edges. stay on this level
 	return round same 2 edges removing slabs and and placing them 1 above
 	placeUp water onto slabs on both edges
 	repeat recover slabs, place 1 above , placeUp water
 
 	for sloping water, place full area with slabs
 	place sloping water on top of slabs
 	remove slabs
-					T:place("minecraft:dirt", "down", true)
+
 	]]
 	local lib = {}
 
 	function lib.checkStartPosition()
 		--[[
-							T:place("minecraft:dirt", "down", true)
+
 		1 W|S|F|F|F|F|F -- sloping flowing water
 		2 W|F|F|F|F|F|F -- blocks removed after placing flowing water above
 		3 W|S|S|S|S|S|S -- original sources
 		4 W|?|?|?|?|?|? -- may be sources
 		]]
 		-- need to be on floor or R.height if specified
 		local depth = 0
 		local blockType = T:getBlockType("down")
 		local isWaterUp, isSourceUp = T:isWater("up")
 		local isWaterForward, isSourceForward = T:isWater("forward")
 		local isWaterDown, isSourceDown = T:isWater("down")
 		print("Block below is "..blockType)
 		print("Water above is "..tostring(isWaterUp))
 		print("Water forward is "..tostring(isWaterForward))
-						T:place("minecraft:dirt", "down", true)
+
 		if blockType:find("water") == nil then -- on at least level 0
-						blockType = T:getBlockType("down")
+
 			sleep(2)
 			T:forward(1)
 			blockType = T:getBlockType("down")
-								T:place("minecraft:dirt", "down", true)
+
 				print("Water found. Going down to floor")
 				depth = -1
 			else
 				T:down(1)
 				blockType = T:getBlockType("down")
 				if blockType:find("water") ~= nil then
 					depth = -2
 				else
 					return 0, "Not close to water. Aborting..."
 				end
 			end
 		end
 		while turtle.down() do
 			depth = depth + 1
 		end
 		local emptyBuckets = utils.getEmptyBucketCount()
 		for i = depth, 0, -1 do
 			if emptyBuckets > 0 then
 				lib.fillBuckets()
 				emptyBuckets = utils.getEmptyBucketCount()
 			end
 			turtle.up()
 		end
 
 		return depth, ""
 	end
 
 	function lib.fillBuckets()
 		local emptyBuckets = utils.getEmptyBucketCount()
 		local direction = "forward"-- start with forward
 		local isWater, isSource, isIce = T:isWater(direction)
 		if emptyBuckets > 0 then
-			--T:go("x0x2F1x0x2")
+
-			turtle.digDown()				-- dig below
+
-			while turtle.digUp() do end		-- dig up including gravity blocks
+
-			while not turtle.forward() do	-- if no block in front, moves forward
+
-				turtle.dig()				-- block in front, so dig it
+
 					isWater, isSource, isIce = T:isWater(direction)
-			turtle.digDown()				-- now moved forward so dig down again
+
-			while turtle.digUp() do end		-- dig up again including gravity blocks
+
 					end
 				end
 			end
 			if direction == "" then
 				print("Unable to locate water source")
-			--T:go("x0F1x0")
+
-			while turtle.digUp() do end
+
-			while not turtle.forward() do	-- if no block in front, moves forward
+
-				turtle.dig()				-- block in front, so dig it
+
 						sleep(0.3)
-			while turtle.digUp() do end
+
 						print("Unable to fill bucket ".. i .." / "..emptyBuckets)
 					end
 				end
 			end
 		end
-			--T:go("x2F1x2")
+
-			turtle.digDown()
+
-			while not turtle.forward() do	-- if no block in front, moves forward
+
-				turtle.dig()				-- block in front, so dig it
+
 		for i = 1, length do
-			turtle.digDown()
+			T:place("slab", -1, "down", false)
 			if i < length then
 				T:forward(1)
 			end
 		end
 	end
 
 	function lib.placeSources(length, place)
 		local moves = 1
 		local waterBuckets = utils.getWaterBucketCount()
 		-- place sources alternate positions + start and finish
 		while moves < length do
 			if place then
 				if T:placeWater("up") then
 					print("Placed source up")
 					waterBuckets = waterBuckets - 1
 				end
 			end
-		elseif R.down then					-- single block wide trench dig R.down = 2 blocks deep
+
 			if moves < length then
-		else 								-- single block wide = 1 block deep
+
 				moves = moves + 1
 			end
-		T:turnRight(2)						-- turn at the top of the run
+
-		T:forward(R.length - 1)				-- return to start
+
-		T:turnRight(2)						-- turn round to original position
+
-	else 									-- R.width 2 or more blocks
+
-		local iterations = 0 				-- R.width = 2, 4, 6, 8 etc
+				T:place("slab", -1, "down", false)
-		if R.width % 2 == 1 then  			-- R.width = 3, 5, 7, 9 eg R.width 7
+
-			iterations = (R.width - 1) / 2 	-- iterations 1, 2, 3, 4 for widths 3, 5, 7, 9
+
 		if T:placeWater("up") then -- end of length
 			print("Placed final source up")
 		end
-		for i = 1, iterations do 			-- eg 3 blocks wide, iterations = 1
+
 	end
 
 	function lib.moveSlabs(length)
 		for i = 1, length do
 			T:dig("down")
 			T:up(1)
 			T:place("slab", -1, "down", true)
 			if i < length then
 				T:forward(1)
 				T:down(1)
 			end
 		end
 	end
 
 	function lib.recoverSlabs(length)
 		for i = 1, length do
 			T:dig("down")
 			if i < length then
 				T:forward(1)
 			end
 		end
 	end
 
 	local depth, message = lib.checkStartPosition()
 	if message ~= "" then
 		return {message}
 	end
 	local maxDepth = R.height
 	local buckets = utils.getWaterBucketCount()
 	R = utils.calculateDimensions(R) -- if R.width or R.length == 0
 	T:down(depth)
 	lib.placeSlabs(R.length)
 	T:go("R1")
 	lib.placeSlabs(R.width)
 	T:go("R2")
 
 	while depth > 0 do
 		local place = true
 		lib.fillBuckets()
 		place = lib.placeSources(R.width, place)
 		T:go("L1")
 		place = lib.placeSources(R.length, place)
 		lib.fillBuckets()
 		T:go("R2")
 		lib.moveSlabs(R.length) -- dig slab from below, move up and replace below
 		T:go("R1F1D1")
 		lib.moveSlabs(R.width - 1)
 		T:go("R2") -- now moved up 1 layer
 		depth = depth - 1
 		if depth == 0 then
 			place = lib.placeSources(R.width, true)
 			T:go("L1")
 			place = lib.placeSources(R.length, place)
 			T:go("R2")
 			lib.recoverSlabs(R.length)
 			T:go("R1")
 			lib.recoverSlabs(R.width)
 		end
 	end
 
 	return {}
 end
 
 local function createBoatLift(R) -- 59 state:0=new, size:1=extend, side:0=left, 1=right
 	-- build stepped lift with fencing gates and soul sand
 	local lib = {}
 
 	function lib.getWater(backToWater, downToWater)
 		if backToWater > 0 then
 			utils.goBack(backToWater)
 		end
 		if downToWater > 0 then
 			T:down(downToWater)
 		end
 		T:getWater("down") -- take water from source
 		sleep(0.2)
 		T:getWater("down") -- take water from source
 		if downToWater > 0 then
 			T:up(downToWater)
 		end
 		if backToWater > 0 then
 			T:forward(backToWater)
 		end
 	end
 
 	--T:place(blockType, damageNo, direction, leaveExisting, signText)
 
 	local backToWater = 0
 	local downToWater = 0
 
 	T:go("R1F1L1") 										-- over canal facing forward
 	for h = 1, R.height do
 		lib.getWater(backToWater, downToWater)			-- check water supplies, return to starting position
 		T:go("L1C1 R1D1 L1C1 R1", false, 0, false)		-- place towpath, forward, down, place towpath, face forward
 		T:place("soul", -1, "down", false) 				-- place soulsand down
 		T:place("soul", -1, "forward", false) 			-- place soulsand forward
 		T:go("R1F1C1L1", false, 0, false)				-- place right towpath face forward
 		T:place("soul", -1, "down", false) 				-- place soulsand down
 		T:place("soul", -1, "forward", false) 			-- place soulsand forward
-	menu item: Clear hollow structure
+
 		T:placeWater("down") 							-- place water down
-	if outside active area will have already moved in
+
-	R.direction = "up" or "down" as direction of travel
+		T:place("gate", -1, "forward", false) 			-- place fence gate
-	R.up = true / false to dig up as well
+
-	R.down = true / false to dig down as well
+
-	R.data.ceiling = true / false to remove ceiling
+
-	R.data.floor = true / false to remove floor
+		T:place("gate", -1, "forward", false) 			-- place fence gate
-	examples use a 5 x 5 x 7 cube
+
 		T:go("R1F1 L1x1 R1C1")
---utils.printR(R)									-- debug values in R
+
-	local height = 1								-- current level of turtle
+
-	local cleared = false
+
 			backToWater = 1
-	R.up = false
+
-	R.down = false
+
-	-- check if floor/ceiling is to be cleared
+
-	if R.direction == "up" then						-- from bottom to top
+
-		if R.data.floor then
+
-			clearRectangle(R)
+
-			cleared = true
+
 	T:go("D1 L1C1 U1C1")					-- build left towpath, facing towpath, above water level
-	else											-- from top to bottom
+
-		if R.data.ceiling then
+
-			clearRectangle(R)
+
-			cleared = true
+
 	utils.goBack(1)
 	T:go("L1F1")
 	T:placeWater("down")
-	if R.height == 1 and not cleared then			-- only 1 layer, perimeter only eg R.height = 7
+
 	return {}
-	elseif R.height == 2 and not cleared then		-- only 2 layers, perimeter only
+
-		if R.direction == "up" then					-- from bottom to top
+
 local function createBorehole(R)
 	--[[go down to bedrock and return. Chart all blocks dug/ passed through]]
 	local diary = {}
 	local lib = {}
 	local depth = R.height	-- eg 63 start position
-	elseif R.height >= 3 then 						-- 3 or more levels, floor/ceiling already assessed eg R.height = 7
+
 	--R.height = current level
 
-		height = height + utils.move(R, 1)			-- move up/down 1 block for first layer eg height: 1 + 1 = 2
+
-		-- height h + 3 R.height   loop
+
-		--	2		5		5		end
+
-		--	2		5		7		+
+
-		--	5		8		7		end
+
-		repeat
+
-			clearPerimeter(R)						-- runs at least once, removes 3 layers: 1,2,3
+
-			local move = 3
+
-			--if height + 3 < R.height then			-- range with min 3(0), 4(1), 5(2), 6(3), 7(4), 8(5), 9(6) etc
+
-				--height = height + utils.move(R, move)	-- move up/down 3 blocks eg height 5, 8, 11, 14
+
-			--else
+
-				--move = R.height - height - 1
+
-				--height = height + utils.move(R, move)	-- move up/down 1-2 blocks eg height = 2 + 3 = 5
+
 				end
 			end
-			if height + 3 >= R.height then			-- range with min 3(0), 4(1), 5(2), 6(3), 7(4), 8(5), 9(6) etc
+
-				move = R.height - height
+
 			end
-			height = height + utils.move(R, move)	-- move up/down 1-2 blocks eg height = 2 + 3 = 5
+
-		until height > R.height - 3				-- min 3 levels eg height = 2, R.height - 3 --> 7 - 3 = 4, 4 - 3 = 1
+
 		return diary
-		R.down = false
+
-		if height == R.height then						-- already on top/bottom layer eg height = 5, R.height = 5
+
-			if R.direction == "up" then						-- reverse digging direction. Up = move to top and dig down
+
-				R.down = true
+
-			else										-- reverse digging direction. Up = move to floor and dig up
+
-				R.up = true
+
 		return item
-			clearPerimeter(R)
+
 
-			if R.direction == "up" then						-- reverse digging direction. Up = move to top and dig down
+
-				R.down = true
+
-			else										-- reverse digging direction. Up = move to floor and dig up
+
-				R.up = true
+
 		for l = 1, levelsPerCol do						-- add 32 empty strings
 			table.insert(lines, "")
-			clearPerimeter(R)
+
 		local lineNo = 1
 		for k, v in ipairs(diary) do
 			local level = R.height - k 					-- eg 63 range 63 to -59
-	R.up = false
+
-	R.down = false
+
-	if R.direction == "up" then
+
-		if R.data.ceiling then		-- from bottom to top
+
-			clearRectangle(R)
+
 				lev = "-0"..math.abs(level).."   "		-- "-09   " to "-01   "
-	elseif R.direction == "down" then
+
-		if R.data.floor then	-- from top to bottom
+
-			clearRectangle(R)
+
 				lev = " "..level.."   "					-- " 10   " to " 99   "
 			else
 				lev = " "..level.."  " 					-- " 100  " to " 319  "
 			end
 			local output = lev..item					-- eg "-10   grass_block"
 			if #output > 20 then						-- eg "-10   some_long_block_name"
 				output = output:sub(1, 20)				-- eg "-10   some_long_block_"
 			else
 				output = menu.padRight(output, 20, " ")	-- eg "-10   grass_block     "
 			end
 			lines[lineNo] = lines[lineNo]..output		-- add new entry to this line
 			lineNo = lineNo + 1							-- increase line no
 			if lineNo > levelsPerCol then				-- past last line number
 				lineNo = 1								-- reset to 1
 			end
 		end
 
 		local fileName = "borehole"..os.getComputerID()..".txt"
 		local handle = fs.open(fileName, "w") 		--create file eg "borehole0.txt"
 		handle.writeLine("Level Block         Level Block         Level Block         Level Block")
 		for k,v in ipairs(lines) do
 			handle.writeLine(v)
 		end
 
 		handle.close()
 
 		return fileName
 	end
 
 	local blockType = T:getBlockType("down")
 	while T:down(1) do
 		depth = depth - 1
 		moves = moves + 1
 		if depth == R.depth then
 			break
 		end
 		diary = lib.addBlock(depth, blockType, diary)
 		blockType = T:getBlockType("down")
 	end
 	local fileName = lib.writeReport(R, diary)
 	T:up(moves)
 
 	return {"File '"..fileName.."' written"}
 end
 
 local function createBubbleLift(R) -- 15
 	local lib = {}
 
 	function lib.addLayer()
 		T:go("F2 L1C1 R1C1 R1C1 L1", false, 0, true)
 		turtle.back()
 		T:dig("up")	-- clear block above so completed lift can be found
 		T:placeWater("forward")
 		turtle.back()
 		T:go("C1x0")
 	end
-			T:place("minecraft:torch", "down", false) ---(self, blockType, damageNo, direction, leaveExisting, signText)
+
 	function lib.addSign()
 		turtle.back()
 		T:placeWater("forward")
 		T:go("L1B1")
 		T:place("sign", -1, "forward")
 	end
 
 	function lib.buildLift(toHeight)
 		local built = lib.goToWater() 		-- returns lift blocks already placed, total height of drop from starting point
 		local toBuild = toHeight - built 	-- no of blocks remaining to increase lift size
 		local water = 0
 		while toBuild > 0 do 				-- at least 1 block height remaining
 			water = lib.fillBuckets(toBuild, false) -- no of water buckets onboard (could be more than required)
 			if water > toBuild then			-- more water than required
 				water = toBuild				-- reduce to correct amount
 			end
 			T:up(built)						-- climb to top of existing lift
 			while water > 0 and toBuild > 0 do
 				lib.addLayer()
 				water = water - 1
 				T:up(1)
 				toBuild = toBuild - 1
 			end
 			-- may still be some height to complete, but needs refill
 			if toBuild > 0 then
 				built = lib.goToWater() --return to source
 				toBuild = toHeight - built
 				--lib.fillBuckets(toBuild)
 			end
 		end
 	end
 
 	function lib.cleanUp(fromHeight)
 		local plug = false
 		T:turnRight(2)
 		for i = 1, fromHeight do
 			plug = false
 			if turtle.detect() then
 				plug = true
 			end
 			turtle.down()
 			if plug then
 				T:place("stone", -1, "up")
 			end
 		end
 		T:go("D1 C1R1x1 R1C1 R1F1 R1x1 L2x1 L1C1 x1") -- delete water sources
 		T:go("D1 C1R1x1 R1")
 		local blockType = T:getBlockType("forward")
 		if blockType:find("dirt") == nil and blockType:find("soul") == nil then -- not dirt or soul sand in front
 			T:go("C1")
 		end
 		T:go("R1F1 R1x1 L2x1 L1C1 x1")
 	end
 
 	function lib.fillBuckets(toBuild, withSort)
 		local emptySlots, water = lib.stackBuckets(withSort)-- gets no of empty slots + no of water buckets
 		if water < toBuild then 					-- no of water buckets onboard less than required quantity
 			for i = 1, toBuild do 					-- fill required no of buckets up to max space in inventory
 				if emptySlots == 0 then 			-- inventory full
 					break
 				else
 					if T:getWater("down") then
 						water = water + 1
 						sleep(0.5)
 					end
 				end
 				emptySlots = lib.getEmptySlots()
 			end
 		end
 
 		return water
 	end
 
 	function lib.getEmptySlots()
 		local empty = 0
 		for i = 1, 16 do
 			if turtle.getItemCount(i) == 0 then
 				empty = empty + 1
 			end
 		end
 		return empty
 	end
 
 	function lib.goToWater()
 		local built = 0 -- measures completed lift height
 		while turtle.down() do -- takes turtle to bottom of water source
 			if turtle.detect() then
 				built = built + 1
 			end
 		end
 		T:up(1) -- above watersource ready to fill buckets
 		-- height = height - 1
 		-- built = built - 1 not required as next block is water source: not detected
 		return built -- , height
 	end
 
 	function lib.stackBuckets(withSort)
 		if withSort == nil then withSort = false end
 		local data = {}
 		local bucketSlot = 0
 		local emptySlots = 0
 		local water = 0
 		if withSort then
 			T:sortInventory()
 		end
 		for i = 1, 16 do
 			-- find first empty bucket
 			if turtle.getItemCount(i) > 0 then
 				data = turtle.getItemDetail(i)
 				if data.name == "minecraft:bucket" then
 					if bucketSlot == 0 then
 						bucketSlot = i
 					else
 						turtle.select(i)
 						turtle.transferTo(bucketSlot)
 					end
 				elseif data.name == "minecraft:water_bucket" then
 					water = water + 1
 				end
 			else
 				emptySlots = emptySlots + 1
 			end
 		end
 		return emptySlots, water
 	end
 
 
 	T:go("C1R1")												-- place block next to ladder support block, turn right to check ladder
 	local blockType = T:getBlockType("forward") 				-- Is there a ladder to the right?
 	if blockType:find("ladder") == nil then
 		T:go("C1L2")											-- Place block as ladder not present
 	else														-- ladder present
 		T:go("L2")												-- ready to check other side
 	end
 	blockType = T:getBlockType("forward")
 	if blockType:find("ladder") == nil then
 		T:go("C1R1")
 	else
 		T:go("R1")
 	end
 	blockType = T:getBlockType("down")
 	local dirt = "minecraft:dirt"
 	if T:getItemSlot("minecraft:soul_sand") > 0 then
 		dirt = "minecraft:soul_sand"
 	end
 	if blockType:find("bedrock") ~= nil then
 		utils.goBack(1)
 		T:place(dirt, -1, "forward", false) 					-- placed at end of potential water source, next to ladder
 	else
 		T:place(dirt, -1, "down", false) 						-- placed in ground, next to ladder
 		utils.goBack(1)
 		T:placeWater("forward") 							-- place extra water source
 	end
 	T:go("R1C1 R2C1 L1F1C2 R1C1 L2C1 R1F1C2 R1C1 L1C1 L1C1 L1F1", false, 0, true)
 	-- ready for water sources to be placed
 	T:placeWater("forward") 								-- place front water source
 	T:turnRight(2)											-- facing backward
 	T:placeWater("forward") 								-- place back water source
 	T:go("R2U1") 											-- facing forward, U1, above centre of water source
 	lib.fillBuckets(R.height, true)							-- fill as many buckets as required or until inventory full, sort inventory as well
 	local nextToLadder = false
 	--T:go("F2R1")
 	T:go("x0F1 x0F1C1 R1") 									-- move forward 2 taking out blocks above, plug behind soul sand
 	if T:getBlockType("forward"):find("ladder") == nil then	-- no ladder here
 		T:turnLeft(2)
 		if T:getBlockType("forward"):find("ladder") ~= nil then	-- ladder here
 			nextToLadder = true
 		end
 		T:turnRight(1)
 	else
 		nextToLadder = true
 		T:turnLeft(1)
 	end
 	-- now above soul sand, facing forward
 	if nextToLadder then								-- if nextToLadder, no need for signs
 		utils.goBack(2) 								-- return to source centre
 	else
 		T:go("F2 L1C1R1C1R1C1L1", false, 0, true)		-- prepare layer 1
 		lib.addSign()
 		T:go("U1F1R1F1 L1C1R1C1R1C1L1", false, 0, true)	-- prepare layer 2
 		lib.addSign()
 		T:go("L1F1 R1F1R1", false, 0, true)	 			-- above source, level 2
 	end
 	-- ready to build lift
 	lib.buildLift(R.height - 1)
 	lib.cleanUp(R.height - 1)
 
 	return {"Bubble lift created", "Check correct operation", "Check exit before using" }
 end
 
 local function createBubbleTrap(R) -- 34
 	--[[
 	Replace floor of existing volume of water with soulsand
 	Used in river biome for squid farm. Area should be enclosed
 	with solid walls surface to floor.
 	Usually 7 blocks wide
 	]]
 	local lib = {}
 
 	function lib.clearDown(depth)
 		while utils.clearVegetation("down") do
 			T:down(1)
 			depth = depth + 1
 		end
 		T:place("soul_sand", -1, "down", false)
 		return depth
 	end
 
 	function lib.clearLength(length, depth)
 		local moves = 0
 		while moves < length - 1 do
 			if utils.clearVegetation("forward") then
 				T:forward(1)
 				moves = moves + 1
 				depth = lib.clearDown(depth) -- go down if in water/air
 				if moves >= length - 1 then
 					return depth
 				end
 			else -- block in front
 				local waterAhead = utils.clearVegetation("forward") -- true if air/water in front
 				while not waterAhead do 	-- solid block in front
 					T:up(1)
 					depth = depth - 1
 					if depth < 1 then
 						return 0
 					end
 					waterAhead = utils.clearVegetation("forward")
 				end
 			end
 		end
 
 		return depth
 	end
 
 	function lib.turn(facingForward, depth)
 		local direction = "R"
 		if not facingForward then
 			direction = "L"
 		end
 		T:go(direction.. 1)
 		if utils.clearVegetation("forward") then
 			T:forward(1)
 			depth = depth + lib.clearDown(depth)
 		else
 			while not utils.clearVegetation("forward") do
 				T:up(1)
 				depth = depth - 1
 			end
 		end
 		T:go(direction.. 1)
 
 		return depth
 	end
 
 	local depth = 0
 	local length = 0
 	local width = 0
 	local outbound = true
 	local facingForward = true
 	local inWater, onWater = utils.getWaterStatus()
 	inWater, onWater = utils.startWaterFunction(onWater, inWater, 2 ,true) -- move into water, max descent 2
 	if R.length == 0 then
 		R.length = lib.getLength()
 	end
 	if R.width == 0 then
 		T:turnRight(1)
 		R.width = lib.getLength()
 		T:turnLeft(1)
 	end
 	-- go down to floor
 	depth = lib.clearDown(depth)
 	while width < R.width do
 		-- now on floor, move along sea/river bed following contour
 		depth = lib.clearLength(R.length, depth)
 		width = width + 1
 		-- now turn and repeat
 		if width < R.width then
 			depth = lib.turn(facingForward, depth)
 			facingForward = not facingForward
 		end
 	end
 	-- finished so return to surface
 	T:up(1) -- up 1 to check for water below
 	while T:isWater("down") do
 		T:up(1)
 	end
 
 	return {}
 end
 
 local function createCorridor(R) -- 52
 	--[[create a corridoor 2 blocks high, with floor and ceiling guaranteed
 	T:go(path, useTorch, torchInterval, leaveExisting, preferredBlock)]]
 	local lib = {}
 
 	function lib.continue(R, currentSteps, totalSteps)
 		if not R.silent then
 			if currentSteps >= 64 and R.length == 0 then
 				-- request permission to continue if infinite
 				T:clear()
 				print("Completed "..totalSteps..". Ready for 64 more")
 				print("Do you want to continue? (y/n)")
 				response = read()
 				if response:lower() ~= "y" then
 					return true, 0
 				else
 					return false, currentSteps
 				end
 			end
 		end
 		return true, currentSteps
 	end
 
 	function lib.seal()
 		local blockType = T:getBlockType("forward")
 		if blockType:find("water") ~= nil then
 			T:place("stone", 0, "forward", false)
 			return "water"	-- water found
 		elseif blockType:find("lava") ~= nil then
 			T:place("stone", 0, "forward", false)
 			return "lava"	-- lava found
 		end
 		return ""	-- no water or lava
 	end
 
 	function lib.checkSeal(R)
 		local fluidType = ""
 		if R.data == "seal" then 		-- check for lava/water at the sides
 			T:turnRight(1)
 			fluidType = lib.seal()		-- could be "", "water", "lava"
 			T:turnLeft(2)
 			local blockType = lib.seal()
 			if fluidType == "" then		-- no water / lava so far
 				fluidType = blockType	-- could be "", "water", "lava"
 			end
 			T:turnRight(1)
 		end
 		return fluidType				-- could be "", "water", "lava"
 	end
 
 	function lib.placeTorch(R, torchSpaces, totalSteps)
 		if R.torchInterval > 0 then -- torches onboard
 			if torchSpaces == R.torchInterval then -- time to place another torch
 				if totalSteps < R.length then -- not at end of run
 					if T:getItemSlot("minecraft:torch") > 0 then
 						T:place("minecraft:torch", -1, "down")
 					end
 					torchSpaces = 1
 				end
 			end
 		end
 		return torchSpaces -- original value or 1
 	end
 
 	local currentSteps = 0					-- counter for infinite length. pause every 64 blocks
 	local totalSteps = 0					-- counter for all steps so far
 	local torchSpaces = R.torchInterval		-- if torches present, counter to place with 8 blocks between
 	local fluidType = ""
 	local damLength = 0
 	local damStarted = false
 	local doContinue = true
 	if T:getItemSlot("minecraft:torch") == 0 then
 		R.torchInterval = 0 -- set to default 9 in getTask()
 	end
 	for steps = 1, R.length do
 		-- starts on floor of tunnel
 		doContinue, currentSteps = lib.continue(R, currentSteps, totalSteps) -- continue tunnelling?
 		if not doContinue then
 			break
 		end
 		T:go("C2U1C0", false, 0, true)		-- place floor, up 1, place ceiling
 		fluidType = lib.checkSeal(R)		-- if R.data == "seal", check for water/lava at ceiling level
 		if fluidType == "" then	-- either R.data ~= "seal" or no fluid found
 			torchSpaces = lib.placeTorch(R, torchSpaces, totalSteps) -- original value or 1 if torch placed
 			T:go("F1D1")
 		elseif fluidType == "water" then
 			T:go("F1R2 C1D1 C1L2", false, 0, true)
 			damStarted = true
 			damLength = damLength + 1
 		else	--lava
 			T:go("F1D1")
 		end
 		blockType = lib.checkSeal(R)
 		if blockType ~= "" then
 			fluidType = blockType
 		end
 		currentSteps = currentSteps + 1
 		totalSteps = totalSteps + 1
 		torchSpaces = torchSpaces + 1
 		if damStarted and fluidType == "" then -- was in water, but no more
 			T:go("R2 F"..damLength + 1 .."U1L2F"..damLength + 1 .."D1")
 			damStarted = false
 		end
 	end
 	if fluidType ~= "" then -- water or lava found while tunnelling
 		T:go("U1C0", false, 0, true)
 		lib.checkSeal(R)
 		T:go("C1", false, 0, true)
 		T:down(1)
 	end
 	return {}
 end
 
 local function createDragonTrap() -- 49
 	local lib = {}
 
 	function lib.attack()
 		local totalHitsF = 0
 		local totalHitsU = 0
 		local totalHitsD = 0
 		while true do
 			local hitF = false
 			local hitU = false
 			local hitD = false
 			if turtle.attackUp() then
 				hitU = true
 				totalHitsU = totalHitsU + 1
 			end
 			if turtle.attackDown() then
 				hitD = true
 				totalHitsD = totalHitsD + 1
 			end
 			if turtle.attack() then
 				hitF = true
 				totalHitsF = totalHitsF + 1
 			end
 			if hitF or hitU or hitD then
 				print("hits forward: "..totalHitsF..", up: "..totalHitsU..", down: "..totalHitsD)
 			end
 		end
 	end
 	-- build up 145 blocks with ladders
 	T:clear()
 	menu.colourPrint("Press Enter to start 1 minute delay\n", colors.red)
 	menu.colourPrint("Run to island centre across the bridge\n", colors.orange)
 	menu.colourPrint("You have already made the bridge?...", colors.lime)
 	read()
 	for t = 60, 1, -1 do
 		sleep(1)
 		T:clear()
 		io.write("Starting in "..t.. " seconds ")
 	end
 	for i = 1, 145 do
 		T:go("U1C2")
 		turtle.back()
 		T:place("minecraft:ladder", -1, "down")
 		turtle.forward()
 	end
 	T:go("R2F1C1 L1C1 L2C1 R1")
 	for i = 1, 100 do
 		T:go("F1C2U1C0D1")
 	end
 	T:forward(1)
 	T:place("minecraft:obsidian", -1, "down")
 	T:go("R2F1x2R2")
 	T:placeWater("forward")
 	T:go("R2F6R2")
 	lib.attack()
 
 	return {}
 end
 
 local function createEnderTower(stage) -- 66
 	--[[ lower base = stage 1, upper base = 2, tower = 3 ]]
 	local lib = {}
 	--[[ go(path, useTorch, torchInterval, leaveExisting, preferredBlock) ]]
 	function lib.getEmptySlots()
 		local empty = 0
 		for i = 1, 16 do
 			if turtle.getItemCount(i) == 0 then
 				empty = empty + 1
 			end
 		end
 		return empty
 	end
 
 	function lib.getStone(direction, stacks)
 		--[[ get block user wants to use ]]
 		local suck = turtle.suck
 		if direction == "down" then
 			suck = turtle.suckDown
 		end
 		if T:getBlockType(direction) == "minecraft:chest" then
 			T:sortInventory()
 			local slot = T:getFirstEmptySlot() --find spare slot
 			if slot > 0 then --empty slot found
 				turtle.select(1)
 				if stacks == 0 then
 					while suck() do end
 				else
 					for i = 1, stacks do -- get # stacks of stone from chest
 						suck()
 					end
 				end
 				if T:getSlotContains(slot) == "" then
 					return T:getMostItem()				-- empty chest
 				else
 					return T:getSlotContains(slot) 		-- use this as default building block
 				end
 			else
 				return T:getMostItem()				-- full inventory
 			end
 		else
-			utils.waitForInput()
+
 		end
 	end
 
 	function lib.stackBuckets()
 		local data = {}
 		local bucketSlot = 0
 		local emptySlots = 0
-				utils.waitForInput()
+
 		T:sortInventory()
 		for i = 1, 16 do
 			-- find first empty bucket
 			if turtle.getItemCount(i) > 0 then
 				data = turtle.getItemDetail(i)
 				if data.name == "minecraft:bucket" then
 					if bucketSlot == 0 then
 						bucketSlot = i
 					else
 						turtle.select(i)
 						turtle.transferTo(bucketSlot)
 					end
 				elseif data.name == "minecraft:water_bucket" then
 					water = water + 1
 				end
 			else
 				emptySlots = emptySlots + 1
 			end
 		end
 		return emptySlots, water
 	end
 
 	function lib.countWaterBuckets()
 		local data = {}
 		local buckets = 0
 		for i = 1, 16 do
 			data = turtle.getItemDetail(i)
 			if data.name == "minecraft:water_bucket" then
 				buckets = buckets + 1
 			end
 		end
 		return buckets
 	end
 
 	function lib.baseRun(preferredBlock, count, turn)
 		for i = 1, count do
 			T:go("C2F1", false, 0, false, preferredBlock)
 		end
 		T:go("C2"..turn, false, 0, false, preferredBlock)
 	end
 
 	function lib.outsideRun(preferredBlock)
 		T:place("fence", -1, "down", false)
 		T:forward(1)
 		T:place(preferredBlock, -1, "down", false)
 		T:forward(1)
 		T:place(preferredBlock, -1, "down", false)
 		T:forward(2)
 		T:place(preferredBlock, -1, "down", false)
 	end
 
 	function lib.signRun(preferredBlock ,message)
 		T:place(preferredBlock, -1, "down", false)
 		T:forward(4)
 		T:place(preferredBlock, -1, "down", false)
 		turtle.back()
 		turtle.back()
 		T:down(1)
 		T:place("sign", -1, "forward", false, message)
 		T:go("U1F2")
 	end
 
 	function lib.goToWater(height)
 		local built = 0 -- measures completed lift height
 		while turtle.down() do -- takes turtle to bottom of water source
 			height = height + 1
 			if turtle.detect() then
 				built = built + 1
-			utils.waitForInput()
+
 		end
 		T:up(1) -- above watersource assuming it is 1-1.5 blocks deep
 		height = height - 1
 		-- built = built - 1 not required as next block is water source: not detected
 		return built, height
 	end
-			utils.waitForInput()
+
 	function lib.fillBuckets(toBuild)
 		local emptySlots, water = lib.stackBuckets() -- gets no of empty slots + no of water buckets
 		if water < toBuild then -- no of water buckets onboard less than required quantity
 			for i = 1, toBuild do -- fill required no of buckets up to max space in inventory
 				emptySlots = lib.getEmptySlots()
 				if emptySlots == 0 then -- inventory full
 					break
 				else
 					if T:getWater("down") then
 						water = water + 1
 						sleep(0.5)
 					end
 				end
 			end
 		end
 
 		return water
 	end
 
 	function lib.buildLift(preferredBlock)
 		local built = 0 -- measures completed lift height
 		local height = 0 -- measures total height from starting position
 		built, height = lib.goToWater(height) -- returns lift blocks already placed, total height of drop from starting point
 		local toBuild = height - built -- no of blocks to increase lift size
 		while toBuild > 0 do -- at least 1 block height remaining
 			local water = lib.fillBuckets(toBuild) -- no of water buckets onboard (could be more than required)
 			if water > toBuild then
 				water = toBuild
 			end
 			while turtle.detect() do -- climb to top of existing lift
 				turtle.up()
 				height = height - 1
 			end
 			T:forward(1)
 			for i = 1, water do -- build lift by no of water buckets
 				if T:placeWater("forward")  then
 					T:up(1)
 					height = height - 1
 					toBuild = toBuild - 1
 					T:place(preferredBlock, -1, "down", false)
 				end
 			end
 			turtle.back()
 			-- may still be some height to complete, but needs refill
 			if toBuild > 0 then
 				lib.goToWater(0) --return to source
 				lib.fillBuckets(toBuild)
 			end
 		end
 		if height > 0 then -- if any remaining distance
 			T:up(height)
 		end
 
 	end
 
 	function lib.buildSection(preferredBlock, solid)
 		-- builds a section without any blocks in the centre
 		-- second layer of each section end walls have fence posts
 		T:go("F1C2 F2C2 F1R1", false, 0, false, preferredBlock) -- first side solid row
 		if solid then -- first layer of each section
 			T:go("F1C2 F1R1", false, 0, false, preferredBlock) -- top side solid row
 		else
 			T:go("F1") -- top side solid row
 			if not T:place("fence", -1, "down", false) then-- first side
 				T:place(preferredBlock, -1, "down", false)
 			end
 			T:go("F1R1") -- top side solid row
 		end
 		T:go("F1C2 F2C2 F1R1", false, 0, false, preferredBlock) -- far side solid row
 		T:go("F1C2 F1R1U1", false, 0, false, preferredBlock) -- bottom side solid row
 	end
 	--[[
 		clsTurtle methods:
 		clsTurtle.place(self, blockType, damageNo, direction, leaveExisting)
 		clsTurtle.go(self, path, useTorch, torchInterval, leaveExisting, preferredBlock)
 	]]
 	-- remove 1 stack stone from chest
 	local preferredBlock = lib.getStone("down", 1) -- use this as default building block
 	if stage == 1 then
 		-- build base floor
 		--T:go("R2F2R1F3R1", false, 0, false, preferredBlock)
 		T:go("R2F1C2R1F1C2F1C2F1C2R1", false, 0, false, preferredBlock)
 		for i = 1, 2 do
 			lib.baseRun(preferredBlock, 8, "R1F1R1")
 			lib.baseRun(preferredBlock, 8, "L1F1L1")
 			lib.baseRun(preferredBlock, 8, "R1F4R1")
 		end
 		-- move back to centre, build water source, with soul sand at base of first source
 		--T:go("R1F3L1C2F1C2F2D1", false, 0, false, preferredBlock) --just behind chest, 1 below ground level
 		T:go("R1F3L1F2C2F1D1", false, 0, false, preferredBlock) --1 block behind chest, 1 below ground level
 		T:place("minecraft:soul_sand", -1, "down", false) -- over block 1 of water source
 		T:go("F1C2F1C2", false, 0, false, preferredBlock) -- over block 2 of water source
 		T:go("F1C2U1C2", false, 0, false, preferredBlock) -- over block 4 of water source
 		T:go("F1C2F1C2R2F5R2", false, 0, false, preferredBlock) -- over block 1 of water source
 		T:placeWater("down")
 		T:forward(2) -- over block 3 of water source
 		T:placeWater("down")
 		turtle.back() -- over block 2 of water source
 		T:getWater("down")
 		T:go("F2D1R2C2") -- over block 4 of water source
 		T:go("U1", false, 0, false, preferredBlock)
 		T:placeWater("down")
 		T:forward(4)
 		lib.stackBuckets() -- put all buckets in same slot
 		T:dropItem("minecraft:dirt", "up", 0) -- drop dirt up:  clsTurtle.dropItem(self, item, direction, keepAmount)
 		preferredBlock = lib.getStone("down", 6)
 		T:go("R1F2R1U1") -- move to start position
 		for i = 1, 2 do
 			-- build first level of tower: 2 x outside run, 2 x sign run
 			lib.outsideRun(preferredBlock)
 			if i == 1 then -- place door
 				T:go("L1F1L1F1L1D1")
 				T:place("door", -1, "forward", false)
 				T:go("U1L1F1R1F1L1")
 			end
 			T:go("R1F1R1")
 			lib.signRun(preferredBlock, "Pint size\nzombies\nProhibited")
 			T:go("L1F1L1C2", false, 0, false, preferredBlock)
 			T:forward(4) -- miss out centre block
 			T:place(preferredBlock, -1, "down", false)
 			T:go("R1F1R1")
 			lib.signRun(preferredBlock, "Pint size\nzombies\nProhibited")
 			T:go("L1F1L1")
 			lib.outsideRun(preferredBlock)
 			if i == 1 then -- layer 1
 				T:go("R1F1R1F1R1D1") -- place door
 				T:place("door", -1, "forward", false)
 				T:go("U1 R1F1 L1F5 L1U1 F2D1  F2R2 U1") -- go over door
 			else -- layer 2
 				T:go("L1F5L1F6R2U1") -- over corner of lower platform
 			end
 		end
 		for i = 1, 2 do -- build both sides of platform, leave centre missing
 			lib.baseRun(preferredBlock, 8, "R1F1R1")
 			lib.baseRun(preferredBlock, 8, "L1F1L1")
 			lib.baseRun(preferredBlock, 8, "R1F4R1")
 		end
 		T:go("R1F3L1C2F1C2F1C2F4C2F1C2F1C2", false, 0, false, preferredBlock) --fill in centre row
 		--T:go("R2F6R1F1R1U1") -- go to start of tower base
 		T:go("R2F7R2D3") -- go to start on top of chest
 		T:sortInventory()
 	elseif stage == 2 then
 		-- start on top of chest, should have sufficient stone in inventory
 		T:go("U3L1F1R1F1U1") -- go to start of tower base
 		for i = 1, 7 do -- build 14 block high tower
 			lib.buildSection(preferredBlock, false)
 			lib.buildSection(preferredBlock, true)
 		end
 		T:go("R2F4R1F4R1", false, 0, false, preferredBlock) -- build upper platform (154 blocks remaining)
-	--[[ direction = R.direction "up" or "down" ]]
+
 			lib.baseRun(preferredBlock, 12, "R1F1R1")
 			lib.baseRun(preferredBlock, 12, "L1F1L1")
 			lib.baseRun(preferredBlock, 12, "R1F1R1")
 			lib.baseRun(preferredBlock, 12, "L1F1L1")
 			lib.baseRun(preferredBlock, 12, "R1F6R1")
 		end
 		T:go("R1F5 L1C2 F1C2 F1C2 F1C2 F1C2 F4C2 F1C2 F1C2 F1C2 F1C2 ", false, 0, false, preferredBlock) --fill in centre row
 		T:go("R2F5") -- return to drop area
 		lib.buildLift(preferredBlock) -- build bubble lift
 		T:go("F3R1F1R1U1") -- go to start of tower base
 		T:go("C2F4 C2R1F1R1", false, 0, false, preferredBlock) 		-- left side layer 21
 		T:go("F2C2 F2C2 L1F1L1", false, 0, false, preferredBlock) 	-- centre layer 21
 		T:go("C2F4 C2R2U1", false, 0, false, preferredBlock) 		-- right side layer 21
-		if R.direction == "up" then
+
 		T:place("fence", -1, "down", false)							-- fence centre of bottom side layer 22
 		T:go("F2C2 F2L1F1L1", false, 0, false, preferredBlock)		-- centre layer 22
 		T:go("C2F4 C2R2F2L1F1R2D2", false, 0, false, preferredBlock) --ready to place ladder
 		T:place("ladder", -1, "forward", false)
 		T:up(1)
 		T:place("ladder", -1, "forward", false)
 		--T:go("U2R1F4R1F1R1") -- ready to make upper part of tower base
 		T:go("U2R1F4R1F1R1") -- ready to make upper part of tower base
 		for i = 1, 2 do -- build both sides of platform, leave centre missing
 			lib.baseRun(preferredBlock, 8, "R1F1R1")
 			lib.baseRun(preferredBlock, 8, "L1F1L1")
 			lib.baseRun(preferredBlock, 8, "R1F4R1")
 		end
 		T:go("R1F3 L1C2 F1C2 F1C2 F1", false, 0, false, preferredBlock) --fill in centre row
 		T:place("minecraft:soul_sand", -1, "down", false)
 		T:go("F1C2 F2C2 F1C2 F1C2", false, 0, false, preferredBlock)
 		T:go("R2F6R1F1R1U1") -- go to start of tower base
 		-- build 2 levels, finish signs and ladders
 		T:go("C2F2 R1D2 U1", false, 0, false, preferredBlock)
 		T:place("ladder", -1, "down", false)
 		T:turnRight(1)
 		T:place("sign", -1, "forward", false, "UP\n^\n|\n|")
 		T:go("U1R2F2C2 R1F2C2 R1", false, 0, false, preferredBlock) --top right corner
 		T:go("F4C2B2D1", false, 0, false, preferredBlock)
 		T:place("sign", -1, "forward", false, "UP\n^\n|\n|")
 		T:go("U1F2R1F1C2F1R1U1", false, 0, false, preferredBlock) --ready for second level
 		T:go("C2F2 R2D1", false, 0, false, preferredBlock)
 		T:place("sign", -1, "forward", false, "UP\n^\n|\n|")
 		T:go("U1R2F2C2R1", false, 0, false, preferredBlock) --top left corner
 		T:go("F1R1C2F4C2", false, 0, false, preferredBlock) --mid bottom row
 		T:go("L1F1L1C2", false, 0, false, preferredBlock) -- bottom right corner
 		T:go("F2R2D1", false, 0, false, preferredBlock)
 		T:place("sign", -1, "forward", false, "UP\n^\n|\n|")
 		T:go("U1R2F2C2", false, 0, false, preferredBlock) -- top right corner
 		-- return to chest
 		T:go("L1F1L1 F5D23R2", false, 0, false, preferredBlock) -- return to chest
 		T:sortInventory()
 	elseif stage == 3 then
 		--[[ move to top of structure
 		| 4 |
 		|3 5|
 		| X |
 		|2 6|
 		| 1 |
 		]]
 		local towerHeight = 128 -- even no only suggest 128
 		while turtle.detect() do
 			turtle.up()
 		end
 		T:go("F1U1", false, 0, false, preferredBlock) -- return to finish tower
 		for i = 1, towerHeight do -- 1
 			T:go("C2U1", false, 0, false, preferredBlock)
 		end
 		T:go("F1L1F1R1D2")
 		while turtle.down() do -- 2
 			T:fillVoid("up", {preferredBlock})
 		end
 		T:go("F1R2C1R2F1D1", false, 0, false, preferredBlock)
 		for i = 1, towerHeight / 2 do -- 3
 			T:go("U2C2", false, 0, false, preferredBlock)
 		end
 		T:go("U1F1R1F1R1D1", false, 0, false, preferredBlock) -- back of tower facing front
 		local deviate = false
 		while turtle.down() do -- 4
 			T:place("fence", -1, "up", false)
 			if turtle.down() then
 				T:fillVoid("up", {preferredBlock})
 			else
 				T:go("F1R2C1R1F1R1D1", false, 0, false, preferredBlock)
 				deviate = true
 				break
 			end
 		end
 		if not deviate then
 			T:go("F1L1F1R1D1", false, 0, false, preferredBlock)
 		end
 		for i = 1, towerHeight / 2 do -- 5
 			T:go("U2C2", false, 0, false, preferredBlock)
 		end
 		T:go("F2R2", false, 0, false, preferredBlock) -- facing back of tower
 		while turtle.down() do -- 6
 			T:fillVoid("up", {preferredBlock}) --layer 129
 		end
 		T:go("F1L2C1U"..towerHeight)
 		T:go("F4R1F3R1U1", false, 0, false, preferredBlock)
 		-- add small platform at the top
 		lib.baseRun(preferredBlock, 8, "R1F1R1")
 		lib.baseRun(preferredBlock, 8, "L1F3L1")
 		lib.baseRun(preferredBlock, 8, "L1F1L1")
 		lib.baseRun(preferredBlock, 8, "R1F1R1")
 		T:go("C2 F1C2 F1C2 F4C2 F1C2 F1C2 R2F3", false, 0, false, preferredBlock) --fill in centre row
 		lib.buildLift(preferredBlock) -- build bubble lift
 	end
 	return {}
 end
 
 local function createFarm(R, extend) -- 31
 	-- if extend ~= nil then this has been called from createFarmExtension()
 	-- T:go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 	local lib = {}
 	function lib.addWaterSource(R, pattern, storage)
 		-- pattern = {"d","c","c","d"} t = place crafting  instead of dirt
 		-- place(self, blockType, damageNo, direction, leaveExisting, signText)
 		T:go("D1x2C2", false, 0, false, R.useBlockType)
 		for i = 1, 4 do
 			T:dig("forward")
 			if pattern[i] == "d" then
 				T:place("dirt", -1, "forward", false)
 			elseif pattern[i] == "t" then
 				--if not T:place("minecraft:crafting_table", -1, "forward", false) then
 				if T:place(storage, -1, "forward", false) then
 					if T:dropItem("crafting", "forward", 0) then
 						print("Crafting table -> buried storage")
 					end
 				else
 					T:place("dirt", -1, "forward", false) -- dirt if no storage available
 				end
 			else
 				T:place(R.useBlockType, -1, "forward", false)
 			end
 			T:turnRight(1)
 		end
 		T:up(1)
 		T:placeWater("down")
 	end
 
 	function lib.placeDirt(count, atCurrent)
 		if atCurrent then
 			local blockType = T:getBlockType("down")
 			if blockType:find("dirt") == nil and blockType:find("grass_block") == nil then
 				T:place("dirt", -1, "down", false)
 			end
 		end
 		for  i = 1, count do
 			T:forward(1)
 			T:dig("up")
 			local blockType = T:getBlockType("down")
 			if blockType:find("dirt") == nil and blockType:find("grass_block") == nil then
 				T:place("dirt", -1, "down", false)
 			end
 		end
 	end
 
 	function lib.placeStorage(storage, storageBackup)
 		T:dig("down")
 		if not T:place(storage, -1, "down", false) then-- place barrel/chest below
 			T:place(storageBackup, -1, "down", false) -- place chest below
 		end
 	end
 
 
 	-- extend "", "right" or "forward". only adds a single new farm.
 	-- right adds farm and checks for existing front extensions, dealt with separately
 	-- clsTurtle.place(blockType, damageNo, direction, leaveExisting)
 	if extend == nil then
 		extend = ""
 	end
 	local blockType = ""
 	-- extend = "right": placed on cobble corner of existing farm facing right side
 	-- extend = "front": placed on cobble corner of existing farm facing front
 	-- else placed on ground at corner of potential new farm facing front
 
 	local storage, storageBackup = utils.setStorageOptions()
 	-- step 1 dig ditch round perimeter wall
 	if extend == "right" then
 		-- move to front corner ground ready for ditch
 		T:go("F1L1F12D1R1", false, 0, false, R.useBlockType)
 		-- cut ditch round new farm extension
 		for i = 1, 12 do
 			T:go("x0F1")
 		end
 		T:go("R1x0")
 		for i = 1, 13 do
 			T:go("x0F1")
 		end
 		T:go("R1x0")
 		-- now at lower right corner. if extension below, do not cut ditch
 		blockType = T:getBlockType("forward")
 		if blockType:find("stone") ~= nil then -- already a farm extension on left side
 			-- return to start for adding chests and walls
 			T:go("U1R1F1L1F12", false, 0, false, R.useBlockType)
 		else -- finish ditch
 			for i = 1, 12 do
 				T:go("x0F1")
 			end
 			T:go("R1U1F1") -- on corner of new extension
 		end
 	elseif extend == "forward" then
 		T:go("L1F2R1D1", false, 0, false, R.useBlockType)
 		-- cut ditch round new farm extension
 		for i = 1, 12 do
 			T:go("x0F1", false, 0, false, R.useBlockType)
 		end
 		T:go("R1x0", false, 0, false, R.useBlockType)
 		for i = 1, 13 do
 			T:go("x0F1", false, 0, false, R.useBlockType)
 		end
 		T:go("R1x0", false, 0, false, R.useBlockType)
 		for i = 1, 11 do
 			T:go("x0F1", false, 0, false, R.useBlockType)
 		end
 		T:go("U1x0F1R1F12R1", false, 0, false, R.useBlockType) -- on corner of new extension
 	else -- new farm. cut a groove round the entire farm base
 		-- move to left side of intended wall
 		T:go("L1F1x0R1", false, 0, false, R.useBlockType)
 		for j = 1, 4 do
 			for i = 1, 12 do
 				T:go("x0F1", false, 0, false, R.useBlockType)
 			end
 			T:go("R1x0F1", false, 0, false, R.useBlockType)
 		end
 		T:go("R1F1L1U1", false, 0, false, R.useBlockType)
 	end
 	-- stage 2 place sapling and double barrel/chest
 	T:dig("down") --remove cobble if present
 	T:place("dirt", -1, "down", false)
 	T:go("F1R2")
 	T:place("sapling", -1, "forward", false) -- plant sapling
 	T:go("L1")
 	lib.placeStorage(storage, storageBackup)
 	T:go("L1F1R1")
 	lib.placeStorage(storage, storageBackup)
 	T:turnLeft(1)
 	if extend == "right" then -- cobble wall exists so go forward to its end
 		T:forward(9)
 	else -- new farm or extend forward
 		for i = 1, 9 do -- complete left wall to end of farm
 			T:go("F1x0x2C2", false, 0, false, R.useBlockType)
 		end
 	end
 	T:go("R1F1 R1x0 x2C2 F1D1", false, 0, false, R.useBlockType)-- turn round ready for first dirt col
 	lib.addWaterSource(R, {"d","c","c","d"}, storage) -- water at top of farm
 	lib.placeDirt(9, false) -- place dirt back to start
 	lib.addWaterSource(R, {"c","c","t","d"}, storage) -- water source next to chests, includes crafting table
 	T:go("U1F1R2")
 	if T:getBlockType("down"):find(storage) == nil and T:getBlockType("down"):find(storageBackup) == nil then
 		lib.placeStorage(storage, storageBackup)
 	end
 	T:go("R1F1L1")
 	if T:getBlockType("down"):find(storage) == nil and T:getBlockType("down"):find(storageBackup) == nil then
 		lib.placeStorage(storage, storageBackup)
 	end
 	T:go("F1D1")
 	lib.placeDirt(9, true)
 	local turn = "R"
 	for i = 1, 7 do
 		T:go("F1U1x0C2"..turn.."1F1"..turn.."1x0x2C2F1D1", false, 0, false, R.useBlockType)
 		lib.placeDirt(9, true)
 		if turn == "R" then
 			turn = "L"
 		else
 			turn = "R"
 		end
 	end
 	T:go("F1U1x0C2"..turn.."1F1"..turn.."1x0x2C2F1D1", false, 0, false, R.useBlockType)
 	lib.addWaterSource(R, {"d","c","c","d"}, storage)
 	lib.placeDirt(9, false)
 	lib.addWaterSource(R, {"c","c","d","d"}, storage)
 	T:go("F1U1R1C2x0F1x0x2C2R1", false, 0, false, R.useBlockType)
 	for i = 1, 11 do
 		T:go("F1x0x2C2", false, 0, false, R.useBlockType)
 	end
 	-- add barrel/chest to any existing farm extension to the right
 	T:go("L1F1L1")
 	if T:getBlockType("down"):find("stone") == nil then -- farm extension already exists to right
 		lib.placeStorage(storage, storageBackup)
 	end
 	T:go("L1F11")
 
 	return {"Modular farm completed"}
 end
 
 local function createFarmExtension(R) -- 32
 	-- assume inventory contains 4 chests, 64 cobble, 128 dirt, 4 water, 1 sapling
 	-- check position by rotating to face tree/sapling
 	local doContinue = true
 	local treePresent = false
 	local extend = "right" -- default
 	if R.subChoice == 1 then
 		extend = "forward"
 	end
 	local storage, storageBackup = utils.setStorageOptions()
 	local blockType = T:getBlockType("down")
 	if blockType:find(storage) == nil and blockType:find(storageBackup) == nil then
 		return
-			T:place("slab", "down", false)
+
 			"Barrel or chest not present below\n",
 			"Unable to calculate position",
 			"Move me next to/front of the tree/sapling",
 			"lower left corner of the existing farm."
 		}
 	else
 		for i = 1, 4 do
 			blockType = T:getBlockType("forward")
 			if blockType:find("log") ~= nil or blockType:find("sapling") ~= nil then
 				treePresent = true
 				break
 			end
 			T:turnRight()
 		end
 		if not treePresent then
 			return
 			{
 				"Unable to locate tree or sapling",
 				"Plant a sapling on the lower left",
 				"corner of the farm, or move me there"
 			}
 		end
 	end
 	if doContinue then -- facing tree. check if on front or l side of farm
 		if extend == "forward" then
 			T:go("R1F11") -- to other side of farm. may be stone or barrel/chest below
-				T:place("slab", "down", false)
+
 			if blockType:find(storage) ~= nil or blockType:find(storageBackup) ~= nil then
 				doContinue = false
 			end
 		else
 			T:go("R2F9") -- to right of farm, may be sapling/tree in front
 			blockType = T:getBlockType("forward")
 			if blockType:find("log") ~= nil or blockType:find("sapling") ~= nil then
 				doContinue = false
 			end
 		end
 		if doContinue then -- extend farm.
 			createFarm(R, extend)
-			T:place("slab", "down", true)
+
 			return
 			{
 				"This farm has already been extended",
 				"Move me next to/front of the tree / sapling",
 				"of the last extension in this direction."
 			}
 		end
 	end
 	return {"Modular crop farm extended"}
 end
 
 local function createFloorCeiling(R) -- 79 size integer 1 to 4
 	--[[
 	R.up = true for ceiling
 	R.down = true for floor
 	R.height = 0 for normal
 	R.height combined with R.up/R.down used for remote access
 	]]
 
 	local useBlock = T:getSlotContains(1)
 	local waterPresent = false
 
 	if R.useBlockType ~= "" then
 		useBlock = R.useBlockType
 	end
 	print("Using ".. useBlock)
 	local direction = "down"
 	if R.up then
 		direction = "up"
 	end
 	if R.height > 0 then -- remote placing. go up/down R.height first
 		R.silent = true
 		local depth = 0
 		if R.down then -- floor could be under water
 			while turtle.down() do
 				depth = depth + 1
 			end
 		elseif R.up then
 			while turtle.up() do
 				depth = depth + 1
 				if depth > R.height + 3 then
 					break
 				end
 			end
 		end
 		if not(R.height - depth <= 2 or depth - R.height <= 2) then
 			T:up(depth)
 			return {"Measured depth/height of "..depth.." > setting: "..R.height}
 		end
 		-- not returned so depth acceptable
 	end
 	-- check if block above/below
 	local blockBelow = turtle.detectDown()
 	local blockAbove = turtle.detectUp()
 	if R.subChoice == 2 then -- New floor over existing
 		-- if no block below, assume in correct position and continue
 		-- else move up 1 and continue
 		if blockBelow then T:up(1) end
 	elseif R.subChoice == 4 then -- New ceiling under existing
 		-- if no block above, assume in correct position and continue
 		-- else move down 1 and continue
 		if blockAbove then T:down(1) end
 	end
 
 	local evenWidth = false
 	local evenHeight = false
 	local loopWidth
 	-- go(path, useTorch, torchInterval, leaveExisting)
 	if R.width % 2 == 0 then
 		evenWidth = true
 		loopWidth = R.width / 2
 	else
 		loopWidth = math.ceil(R.width / 2)
 	end
 	if R.length % 2 == 0 then
 		evenHeight = true
 	end
 	-- if R.width is even no, then complete the up/down run
-	--T:place(blockType, direction, leaveExisting, signText)
+
 	for x = 1, loopWidth do
 		-- Clear first column (up)
 		local tAvailable = T:getStock(useBlock, -1)
 		if tAvailable.total < R.length and not R.silent then
 			return {"Insufficient resources to complete current row"}
 		end
 		for y = 1, R.length do
 			local blockType = T:getBlockType("forward")
-		T:place("soul", "down", false) 				-- place soulsand down
+
-		T:place("soul", "forward", false) 			-- place soulsand forward
+
 					waterPresent = true
-		T:place("soul", "down", false) 				-- place soulsand down
+
-		T:place("soul", "forward", false) 			-- place soulsand forward
+
 			T:place(useBlock, -1, direction, false) -- leaveExisting = false
 			if y < R.length then
 				T:go("F1", false, 0, false)
-		T:place("gate", "forward", false) 			-- place fence gate
+
 		end
 		-- clear second column (down)
 		if x < loopWidth or (x == loopWidth and evenWidth) then -- go down if on R.width 2,4,6,8 etc
-		T:place("gate", "forward", false) 			-- place fence gate
+			T:go("R1F1R1", false,0,false)
 			tAvailable = T:getStock(useBlock, -1)
 			if tAvailable.total < R.length and not R.silent then
 				return {"Insufficient resources to complete current row"}
 			end
 			for y = 1, R.length do
 				T:place(useBlock, -1, direction, false) -- leaveExisting = false
 				if y < R.length then
 					T:go("F1", false, 0, false)
 				end
 			end
 			if x < loopWidth then
 				T:go("L1F1L1", false,0,false)
 			else
 				T:turnRight(1)
 				T:forward(R.width - 1)
 				T:turnRight(1)
 			end
 		else -- equals R.width but is 1,3,5,7 etc
 			T:turnLeft(2) --turn round 180
 			T:forward(R.length - 1)
 			T:turnRight(1)
 			T:forward(R.width - 1)
 			T:turnRight(1)
 		end
 	end
 	if waterPresent then
 		return {"water or lava found"}
 	end
 	return {""}
 end
 
 local function createIceCanal(R) -- 55
 	--[[
 		R.subChoice =
 		1: move right into canal, build left towpath
 		2: build left towpath
 		3: build right towpath
 		4: move left into canal, build right towpath
 		5/8: clear path 3 blocks high, place slabs/torches
 		6/7: build alternating ice road / create 3 block high air gap (2 over water)
 	]]
 	local oTurn = "R"
 	if R.side == "R" then
 		oTurn = "L"
 	end
 	local lib = {}
 
 	function lib.convertTowpath(R)
 		-- only used to convert existing water canal, so assume towpath already present
 		-- starting position 1 block above existing towpath
 		for i = 1, R.length do
 			if turtle.detectDown() then							-- eg existing torch
 				T:dig("down")
 			end
 			local placeSlab = true
 			if R.torchInterval > 0 then							-- place torches
 				if i == 1 or i % R.torchInterval == 0 then		-- ready to place torch
 					--go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 					T:go("C2x0", false, 0, false, R.useBlockType)-- place solid block below
 					T:go("F1R2x0")
 					T:place("torch", 0, "forward")				-- place torch, move forward
 					T:turnRight(2)								-- turn round
 					placeSlab = false
 				end
 			end
 			if placeSlab then
 				T:dig("up")
 				if not T:place("slab", 0, "down") then			-- break if out of slabs
 					break
 				end
 				if i < R.length then
 					T:forward(1)								-- move forward
 				end
 			end
 		end
 	end
 
 	function lib.iceCanalTowpath(R)
 		-- move forward placing slabs along the way. If existing water canal, ceiling will be raised by 1 block
 		local torchInterval = 0
 		local placeIce = true
 		for i = 1, R.length do
 			local addTorch = false
 			if R.torchInterval > 0 then
 				if i == 1 then addTorch = true end
 				if torchInterval >= R.torchInterval then
 					addTorch = true
 					torchInterval = 0
 				end
 			end
 			lib.iceCanalEdge(R, addTorch, i, placeIce)
 			torchInterval = torchInterval + 1
 			placeIce = not placeIce
 		end
 		T:go(oTurn.."1")
 	end
 
 	function lib.iceCanalEdge(R, addTorch, numBlocks, placeIce)
 		-- starting position facing canal side
 		local blockType = T:getBlockType("forward")			-- ? air / slab / other
 		local isWater, isSource, isIce = T:isWater("down")	-- water / ice below
 		if blockType:find("slab") == nil then 				-- add slab
 			if addTorch then								-- check if torch needed
 				-- T:place(blockType, damageNo, direction, leaveExisting, signText)
 				if not T:place("stone", -1, "forward", false) then
 					T:checkInventoryForItem({"stone"}, {math.ceil(R.length / R.torchInterval)}, true)
 				end
 				T:go("U1x1 U1x1 D1")	 				-- water level to 2 above water level
 				if T:getItemSlot("minecraft:torch", -1) > 0 then
 					T:place("torch", -1, "forward", false)
 				end
 				T:down(1)								-- back to above water level
 				if not isIce then						-- break block below if NOT ice
 					T:dig("down")
 				end
 			else
 				if not T:place("slab", -1, "forward", false) then
 					T:checkInventoryForItem({"slab"}, {R.length - numBlocks}, true)
 				end
 				if not isSource then					-- NOT on water, so dig above
 					T:go("U1x1 U1x1 D2")
 				end
 				if not isIce and not isSource then
 					T:dig("down")
 				end
 			end
 		else -- slab already on side
 			if addTorch then							-- check if torch needed
 				T:dig("forward")
 				if not T:place("stone", -1, "forward", false) then
 					T:checkInventoryForItem({"stone"}, {math.ceil(R.length / R.torchInterval)}, true)
 				end
 				T:go("U1x1 U1x1 D1")	 				-- water level to 2 above water level
 				if T:getItemSlot("minecraft:torch", -1) > 0 then
 					T:place("torch", -1, "forward", false)
 				end
 				T:down(1)								-- back to above water level
 				if not isIce then						-- break block below if NOT ice
 					T:dig("down")
 				end
 			end
 		end
 		if R.data == "ice" and placeIce and not isIce then -- R.data = "ice", placeIce = true, not already ice present
-		T:place("sign", "forward")
+			T:place("ice", -1, "down", true)
 		end
 		if numBlocks < R.length then
 			T:go(oTurn.."1F1"..R.side.."1")
 		end
 	end
 
 	function lib.convertIcepath(length)
 		-- use only for placing ice to convert a water canal
 		-- place ice on alternate blocks until length reached or run out of ice
 		local placeIce = true
 		for i = 1, length do
 			if T:getBlockType("down"):find("ice") == nil then -- no ice below
 				T:dig("down") -- remove any existing block
 				if placeIce then
 					if not T:place("ice", -1, "down", true) then -- out of ice
 						break
 					end
 					if i == length - 1 then
 						break
 					end
 				end
 			else -- ice already below
 				placeIce = true
 			end
 			T:go("U1x0 D1F1")
 			placeIce = not placeIce -- reverse action
 		end
 	end
 
 	function lib.convertToAir(length)
 		-- use only for converting a water canal. start at ground level
 		-- dig up/down/forward to clear space
 		for i = 1, length + 1 do
 			T:go("U1x0D1")
 			if i < length + 1 then
 				T:go("x2F1")
 			else
-				T:place("stone", "up")
+
 			end
 		end
 	end
 
 	function lib.initialise(R)
 		if R.subChoice == 1 or R.subChoice == 4 then
 			local blockType = T:getBlockType("down")		-- ? at ground/water level or on top of existing slab
 			if blockType:find("slab") ~= nil then 			-- slab already present
 				T:go(oTurn.."1F1D1"..R.side.."2")			-- move right/left forward, down onto ice canal top, face canal wall
 			elseif blockType:find("torch") ~= nil then
 				T:go(oTurn.."1F1D2"..R.side.."2")			-- move right/left forward, down onto ice canal top, face canal wall
 			else											-- assume on ground / water level
 				T:go(oTurn.."1F1"..R.side.."2")				-- move right/left forward onto ice canal top, face canal wall
 			end
 		else
 			if T:isWater("forward") then 					-- player put turtle inside canal water
 				T:up(1)
 			end
 			T:go(R.side.."1")								-- face canal wall
 		end
 	end
 
 	if R.length == 0 then R.length = 1024 end
 
 	if R.subChoice <= 4  then								-- towpath 1,2,3,4
 		lib.initialise(R)									-- reposition
 		lib.iceCanalTowpath(R)								-- build towpath
 	elseif R.subChoice == 5 or R.subChoice == 8 then		-- assume placed on towpath
 		if T:getBlockType("down"):find("slab") ~= nil then 	-- slab already present
 			T:go("F1")
 		else
 			T:up(1)
 		end
 		lib.convertTowpath(R)
 	elseif R.subChoice == 6 or R.subChoice == 7 then
 		if R.data == "ice" then							-- assume placed on existing ice or initial ice position
 			lib.convertIcepath(R.length)-- place ice
 		else											-- assume placed on empty path
 			lib.convertToAir(R.length)					-- clear 3 high area
 		end
 	end
 
 	return {}
 end
 
 local function createLadder(R) -- 12
 	-- createLadder(R.data ="bedrock", R.height = 70, R.depth = -48)
 	-- go(path, useTorch, torchInterval, leaveExisting)
 	-- place(blockType, damageNo, direction, leaveExisting)
 	local lib = {}
 
 	function lib.placeLadder(direction, ledge, i, height)
 		-- 1 check both sides and behind
 		local fluid = false
 		local block = T:isWaterOrLava("forward", ledge)
 		if block:find("water") ~= nil or block:find("lava") ~= nil then
 			--[[ surround 2 block shaft with blocks ]]
 			T:go("R1C1 R1C1 R1C1 R1F1 L1C1 R1C1 R1C1 R1C1F1 R2C1 x1")
 		else
 			--[[ no water/lava so prepare ladder site]]
 			T:go("F1 L1C1 R1C1 R1C1 L1B1", false, 0, true)
 		end
 		if not T:place("ladder", -1, "forward", false) then
 			T:checkInventoryForItem({"ladder"}, {height - i}, false)
 		end
 		-- 3 check if ledge, torch
 		if ledge == 0 and i > 1 then -- place block above unless new ladder
 			T:place("common", -1, direction, false) -- any common block
 		elseif ledge == 1 then
 			T:place("minecraft:torch", -1, direction, false)
 		elseif ledge == 2 then
 			ledge = -1
 		end
 
 		return ledge
 	end
 
 	local retValue = {}
 	local ledge = 0
 	local height = math.abs(R.depth - R.height) --height of ladder
 	local blockType = T:getBlockType("forward")
 	if R.up then -- create ladder from current level to height specified
 		for i = 1, height do -- go up, place ladder as you go
 			ledge = lib.placeLadder("down", ledge, i, height) -- ladder placed forward, stone ledge for torch placed down
 			if i <  height then
 				T:up(1)
 				ledge = ledge + 1
 			end
 		end
 	else -- R.down = true: ladder towards bedrock
 		local success = true
 		local numBlocks, errorMsg = 0, ""
 		T:down(1)
 		for i = 1, height do -- go down, place ladder as you go
 			ledge = lib.placeLadder("up", ledge, i, heigt) -- ladder placed forward, stone torch placed up
 			--success, blocksMoved, errorMsg, blockType = clsTurtle.down(self, steps, getBlockType)
 			if i < height then
 				success, numBlocks, errorMsg, blockType = T:down(1, true) -- true = return blockType
 				ledge = ledge + 1
 			end
 			-- if looking for stronghold then check for stone_bricks
 			if blockType:find("stone_bricks") ~= nil then
 				table.insert(retValue, "Stronghold discovered")
 				break -- stop descent at stronghold
-		T:place(dirt, "forward", false) 					-- placed at end of potential water source, next to ladder
+
 		end
-		T:place(dirt, "down", false) 						-- placed in ground, next to ladder
+
 		if R.data == "chamber" then -- user has chosen to build a chamber
 			table.insert(retValue, "Shelter constucted at level".. R.depth)
 			if blockType:find("bedrock") ~= nil then
 				T:findBedrockTop(0) -- test to check if on safe level immediately above tallest bedrock
 			end
 			-- In shaft, facing start direction, on lowest safe level
 			-- create a square space round shaft base, end facing original shaft, 1 space back
 			T:go("L1n1 R1n3 R1n2 R1n3 R1n1", false, 0, true)
 			T:go("U1Q1 R1Q3 R1Q2 R1Q3 R1Q1 R1D1", false, 0, true)
 		end
 	end
 
 	return retValue
 end
 
 local function createLadderToWater(R) -- 86
 	-- go down to water/lava with alternaate solid/open layers
 	-- create a working area at the base
 	-- Return to surface facing towards player placing ladders
 	local inAir = true
 	local numBlocks, errorMsg = 0, ""
 	local height = 2
 	local blockType = T:getBlockType("down")
 	if blockType ~= "" then -- not over air
 		T:forward(1)
 	end
 	T:go("R2D1") -- face player, go down 2
 	while inAir do --success = false when hits water/lava
 		blockType = T:isWaterOrLava("down")
 		if blockType:find("water") ~= nil or blockType:find("lava") ~= nil then
 			inAir = false
 		end
 		T:go("C1R1 C1R2 C1R1", false, 0, false)	-- surround front  and sides with cobble
 		if inAir then
 			T:down(1)
 			height = height + 1
 		end
 		T:place("ladder", 0, "up")
 	end
 	-- In shaft, facing opposite start direction, on water/lava, ladders above
 	T:go("C2", false, 0, false)
 	utils.goBack(1)
 	T:place("ladder", 0, "forward")
 	T:up(3)
 	height = height - 3
 	for i = 1, height do
 		if i < height then
 			T:go("C2U1", false, 0, false)
 		else
 			T:go("C2", false, 0, false)
 		end
 	end
 
 	return {}
-		T:place("soul_sand", "down", false)
+
 
 local function createMine() -- 11
 	-- go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 	T:clear()
 	T:go("m32U1R2M16", true, 8, true) -- mine ground level, go up, reverse and mine ceiling to mid-point
 	T:go("U2D2") -- create space for chest
 	T:place("minecraft:chest", -1, "up", false)
 	T:emptyTrash("up")
 	T:go("D1R1m16U1R2M16", true, 8, true) -- mine floor/ceiling of right side branch
 	T:emptyTrash("up")
 	T:go("D1m16U1R2M16", true, 8, true) -- mine floor/ceiling of left side branch
 	T:emptyTrash("up")
 	T:go("L1M15F1R1D1", true, 8, true) -- mine ceiling of entry corridor, turn right
 	T:go("F1x0 F1x0 n14 R1n32 R1n32 R1n32 R1n14 F1x0 F1U1", true, 8, true)-- mine floor of 36 x 36 square corridor
 	T:go("R1F16R2") --return to centre
 	T:emptyTrash("up")
 	T:go("F16R1") --return to entry shaft
 	T:go("F2Q14R1Q32R1Q32R1Q32R1Q14F2R1", true, 8, true) --mine ceiling of 36x36 square corridor. return to entry shaft + 1
 	T:go("F16R2") --return to centre
 	T:emptyTrash("up")
 	-- get rid of any remaining torches
 	while T:getItemSlot("minecraft:torch", -1) > 0 do
 		turtle.select(T:getItemSlot("minecraft:torch", -1))
 		turtle.dropUp()
 	end
 	T:go("F16R1F1R1") --return to shaft + 1
 	for i = 1, 8 do
 		T:go("N32L1F1L1", true, 8, true)
 		T:go("N16L1F"..(i * 2).."R2", true, 8, true)
 		T:emptyTrash("up")
 		if i < 8 then
 			T:go("F"..(i * 2).."L1N16R1F1R1", true, 8, true)
 		else
 			T:go("F"..(i * 2).."L1N16L1", true, 8, true)
 		end
 	end
 	T:go("F17L1") -- close gap in wall, return to ladder + 1
 	for i = 1, 8 do
 		T:go("N32R1F1R1", true, 8, true)
 		T:go("N16R1F"..(i * 2).."R2", true, 8, true)
 		T:emptyTrash("up")
 		if i < 8 then
 			T:go("F"..(i * 2).."R1N16L1F1L1", true, 8, true)
 		else
 			T:go("F"..(i * 2).."R1N16R1", true, 8, true)
 		end
 	end
 	T:go("F16R1")
 	T:clear()
 	return{"Mining operation complete"}
 end
 
 local function createMobFarmCube(R) -- 61, 62
 	--[[
 	Part 1 / 3 Mob Spawner Farm
 	blaze = true: blaze spawner in nether
 		R.subChoice is set to:
 		1 = on top of spawner
 		2 = line of sight
 		3 = room below
 	blaze = false: overworld mob spawner
 		R.subChoice is set to:
 		1 = on top of spawner
 		2 = bottom left corner
 		3 = top left corner
 		4 = bottom right, corner
 		5 = top right corner
 		R.width / R.length set by player (external size)
 	]]
 	local blaze = true
 	if R.data == "spawner" or R.data == "chest" then
 		blaze = false
 	end
 	local continue = false
 	if R.data == "restart" then
 		continue = true
 	end
 	R.direction = "clock"		-- starting on right side
 	if not blaze then
 		print("R.width: "..tostring(R.width))
 		R.width = R.width - 2		-- internal width
 		R.length = R.length - 2		-- internal length
 
 		if R.subChoice == 2 or R.subChoice == 3 then
 			R.direction = "anticlock"
 		end
 	end
 	-- R.data allows for 2-part operation "blaze" = main cube, "restart" = killzone
 	T:clear()
 	local lib = {}
 
 	function lib.floorSection(length)
 		for i = 1, length do		-- starts on top left corner
 			T:go("C2")
 			if i < length then
 				T:forward(1)
 			else
 				T:go("R1F1")
 			end
 		end
 	end
 
 	function lib.wallSection(blaze)
 		blaze = blaze or false
 		for i = 1, 4 do
 			for j = 1, 11 do
 				if blaze then
 					T:place("slab", 0, "up", false)
 					T:go("C2", false, 0, false)
 				else
 					T:go("C0C2", false, 0, false)
-			T:place("stone", "forward", false)
+
 				if j < 11 then
 					T:forward(1)
-			T:place("stone", "forward", false)
+
 				else
 					T:turnRight(1)
 				end
 			end
 		end
 	end
 
 	function lib.ceiling(blaze)
 		-- T:go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 		-- all outer walls complete, now for remaining 9x9 ceiling
 		blaze = blaze or false
 		for i = 1, 9 do
 			for j = 1, 9 do
 				if blaze then
 					T:place("slab", 0, "up", false)
 					T:dig("down")
 				else
 					T:go("C0x2", false, 0, true)
 				end
 				if j < 9 then
 					T:forward(1)
 				else	-- end of length
 					local place = false
 					if i%2 == 1 then -- odd numbers 1,3,5,7,9
 						if i < 9 then
-						T:place("minecraft:torch", "down")
+
 							T:go("R1F1 R1")
 						end
 					else
 						place = true
 						T:go("L1F1 L1")
 					end
 					if place then
 						if blaze then
 							T:place("slab", 0, "up", false)
 							T:dig("down")
 						else
 							T:go("C0x2", false, 0, true)
 						end
 					end
 				end
 			end
 		end
 	end
 
 	function lib.clearWall(length)
 		for i = 1, 4 do
 			for j = 1, length do
 				if j < length then
 					T:go("x0x2F1")
 				else
 					T:go("x0x2R1")
 				end
 			end
 		end
 	end
 
 	function lib.isSpawner()
 		local blockType = T:getBlockType("down")
 		if blockType:find("spawner") ~= nil then
 			return true, "top"
 		end
 		blockType = T:getBlockType("up")
 		if blockType:find("spawner") ~= nil then
 			return true, "bottom"
 		end
 		blockType = T:getBlockType("forward")
 		if blockType:find("spawner") ~= nil then
 			return true, "forward"
 		end
 		return false, ""
 	end
 
 	function lib.placeFloor(width, length, blockType)
 		-- T:place(blockType, damageNo, direction, leaveExisting, signText)
 		for i = 1, width do
 			for j = 1, length do
 				T:place(blockType, -1, "down", false)
 				if j < length then
 					T:forward(1)
 				else
 					if i%2 == 1 then -- odd numbers 1,3,5,7,9
 						if i < width then
 							T:go("R1F1R1", false, 0, true)
 						end
 					else
 						T:go("L1F1L1", false, 0, true)
 					end
 				end
 			end
 		end
 	end
 
 	function lib.searchStrip(distance)
 		--go forward until hit either a wall or a chest
 		local blocks = 1
 		print("Searching strip, distance = "..distance)
 		while blocks < distance do --max travel is external width/length
 			if turtle.forward() then
 				blocks = blocks + 1
 			else
 				print("Checking for chest")
 				if lib.isChest("forward") then
 					if turtle.forward() then
 						blocks = blocks + 1
 					end
 				else
 					break
 				end
 			end
 		end
 	end
 
 	function lib.findChests(R)
 		for i = 1, 4 do
 			print("Searching wall "..i)
 			if i == 1 or i == 3 then
 				lib.searchStrip(R.width) 	-- find and empty chests along width
 			else
 				lib.searchStrip(R.length) 	-- find and empty chests along length
 			end
 			if R.direction == "clock" then
 				T:turnRight(1)
 			else
 				T:turnLeft(1)
-		T:place("minecraft:ladder", "down")
+
 		end
 
 		-- checked all walls
 		T:go("F".. math.floor(R.width / 2)) -- now at mid-dungeon, next to wall
 		if T:getItemSlot("chest") > 0 then
 			if R.direction == "clock" then
 				T:turnLeft(1)
-	T:place("minecraft:obsidian", "down")
+
 				T:turnRight(1)
 			end
 			-- now at mid-dungeon, facing wall
 			-- deposit chest outside the dungeon
 			while turtle.back() do end -- backing spawner
 			T:go("x0 F1x0 F1x0 F1x0 F1x0 F1x0 F1x0 x1x2")
 			-- place(self, blockType, damageNo, direction, leaveExisting, signText)
 			T:place("chest", -1, "forward", false)
 			-- empty out all except stone and slab
 			T:emptyInventorySelection("forward", {"cobble", "tuff", "slab", "granite", "andesite", "diorite" }, {0,0,0,0,0,0})
 			T:turnLeft(2)
 			T:checkInventoryForItem({"stone"}, {512}, false, "Full cube uses ~700 blocks\nEstimate your requirements")
 			while turtle.forward() do end -- facing spawner
 		else
 			if R.direction == "clock" then
 				T:turnRight(1)
 			else
 				T:turnLeft(1)
 			end
 		end -- now at mid-dungeon, facing spawner
 	end
 
 	function lib.enterDungeon(R)
 		--[[ find and empty any chests, return to dungeon wall ]]
 		print("Entering dungeon")
 		local blockType = T:getBlockType("forward")
 		if blockType == "" then -- nothing in front.Error
 			return false, "No block in front: Check position."
 		else -- attempt entry into dungeon wall
 			if R.subChoice == 2 then 		-- bottom left
 				T:go("R1F1 L1U2 F2R1")
 			elseif R.subChoice == 3 then	-- top left
 				T:go("R1F1 L1D1 F2R1")
 			elseif R.subChoice == 4 then	-- bottom right
 				T:go("L1F1 R1U2 F2L1")
 			elseif R.subChoice == 5 then	-- top right
 				T:go("L1F1 R1D1 F2L1")
 			end
 			while turtle.down() do end -- either on floor or chest
 			if lib.isChest("down") then
 				turtle.down()
 			end
 			print("Searching for chests")
 			lib.findChests(R)	-- go round inside walls  emptying chests. Finish mid-wall
 		end
 		return true, ""-- success, message
 	end
 
 	function lib.isChest(direction)
 		direction = direction or "forward"
 		local blockType = T:getBlockType(direction)
 		if blockType:find("chest") ~= nil then -- chest found. early stages so empty and break it
 			print("Chest found")
 			while T:suck(direction) do end
 			T:dig(direction, false) -- false prevents checking for chests
 			return true
 		elseif blockType:find("torch") ~= nil then
 			print("Torch found")
 			T:dig(direction, false) -- false prevents checking for chests
 			return true
 		end
 		return false
 	end
 
 	function lib.findSpawner(blaze)
 		local moves  = 0
 		local quit = false
 		-- assume turtle placed on centre of inside spawner wall in front of spawner
 		-- or as close as possible in Nether
 		print("Checking if next to spawner")
 		local found, position = lib.isSpawner() -- true/false, top/bottom/nil
 		if not found then -- move forward towards spawner
 			print("Not close to spawner")
 			while turtle.forward() and not quit do
 				moves = moves + 1
 				if moves > 16 then
 					quit = true
 				end
 			end
 			found, position = lib.isSpawner() -- true/false, top/bottom/nil
 			if not found then
 				if blaze then -- could be behind a wall
 					print("Assuming blaze spawner behind a wall")
 					T:forward(1)
 					moves = moves + 1
 					while turtle.forward() and not quit do
 						moves = moves + 1
 						if moves > 16 then
 							quit = true
 						end
 					end
 					found, position = lib.isSpawner() -- true/false, top/bottom/nil
 					if not found then
 						T:go("R2F"..moves + 2 .."R2")
 					end
 				end
 			end
 		end
 
 		return found, position
-		T:place("fence", "down", false)
+
 
-		T:place(preferredBlock, "down", false)
+
 	if not continue then -- new mob cube either dungeon or blaze
-		T:place(preferredBlock, "down", false)
+
 		-- determine spawner position level 4, move to top of spawner (level 6)
-		T:place(preferredBlock, "down", false)
+
 		local found, position = lib.isSpawner() -- already on spawner?
 		if blaze then
 			if not found then -- away from spawner
-		T:place(preferredBlock, "down", false)
+
 					T:go("U5")
-		T:place(preferredBlock, "down", false)
+
 				found, position = lib.findSpawner(blaze)
 			end
 		else -- go to bottom of dungeon and empty chests
-		T:place("sign", "forward", false, message)
+
 				local success, message = lib.enterDungeon(R)
 				if not success then
 					return {message}
 				end
 				found, position = lib.findSpawner(blaze) -- is spawner in front / above / below?
 			end
 		end
 
 		if found then -- true: move to correct starting position
 			--[[
 			1 |c|c|c|c|c|c|c|c|c|c|c|
 			2 |w| | | | | | | | | |w|
 			3 |w| | | | | | | | | |w|
 			4 |w| | | | | | | | | |w|
 			5 |w| | | | | | | | | |w|
 			6 |w| | | | |s| | | | |w|
 			7 |w| | | | | | | | | |w|
 			8 |w| | | | | | | | | |w|
 			9 |w| | | | | | | | | |w|
 		   10 |w| | | | | | | | | |w| exit level for overworld
 		   11 |f|f|f|f|f|f|f|f|f|f|f|
 		   12 |f|f|f|f|f|f|f|f|f|f|f| sub floor for overworld
 			   1 2 3 4 5 6 7 8 9 1 1
 			                     0 1
 			]]
 			-- T:go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 			if position == "bottom" then
 				T:go("B1U2F1")
 			elseif position == "forward" then
 				T:go("U1F1")
 			end
 
 			T:up(1)
 			T:place("slab", -1, "down", true) 				-- place slab on top T:place(blockType, damageNo, direction, leaveExisting)
 			-- go up 2 blocks, forward 5, right, forward 5, right
 			T:go("U2F5 R1F5 R1") 							-- Level 2: now placed 1 below ceiling inside wall, top right corner of new dungeon
 			lib.wallSection(blaze) 							-- fix layers 1, 2, 3 including ceiling margin turtle at Level 2
 			T:go("F1R2 C1L1 F1R2 C1R1", false, 0, false)	-- exit wall, repair behind, still Level 2
 			lib.ceiling(blaze)								-- fix ceiling, end opposite corner to start
 			T:go("R2D3")									-- clear the inner walls inside original dungeon
 			lib.clearWall(9)								-- clear the 9 x 9 area around the spawner
 			T:go("F1R1F1L1")
 			lib.clearWall(7)								-- clear the 7 x 7 area around the spawner
 			T:go("F1R1F1L1")
 			lib.clearWall(5)								-- clear the 5 x 5 area around the spawner. Also needed for cave spiders
 			T:go("R2F1R1F1R1")
 			T:go("F7R1 F8L1F1R2", false, 0, false)			-- return from ceiling, enter wall below previous section: Level 5
 			lib.wallSection() 								-- deal with areas from spawner level up (4,5,6). walls only
 			T:go("F1R2 C1L1 F1R2 C1R1 D3", false, 0, false) -- exit wall, repair behind, embed 1 below original floor: Level 8
 			clearRectangle({width = 9, length = 9, up = true, down = true}) -- clear levels 7,8,9
 			T:go("L1F1 L1F1L2", false, 0, false) 			-- go inside wall sectio, ready for next wall section
 			lib.wallSection() 								-- deal with walls on levels 7,8,9
 			T:go("F1R2 C1L1 F1R2 C1R1 D3", false, 0, false) -- exit wall, repair behind, embed 4 below original floor: Level 11
 			--print("Check: about to clear 3 floors 3 below spawner") read()
 			clearRectangle({width = 9, length = 9, up = true, down = true}) -- clear levels 10,11,12
 
-					T:place(preferredBlock, "down", false)
+
 				T:go("L1F1 L1F1L2", false, 0, false) 			-- ready for next wall section
 				lib.wallSection() 								-- wall on layers 10,11,12
 				T:go("F1R2 C1L1 F1R2 C1R1 D3", false, 0, false) -- exit wall, repair behind, embed 1 below original floor: Level 8
 				clearRectangle({width = 9, length = 9, up = true, down = true}) -- clear levels 13, 14, 15
 			end
 
 			T:go("L1F1L1F1L2", false, 0, false) -- ready for next wall section
 			--print("Check: level 11, 5 north, 5 east")
 			--read()
 			lib.wallSection() 	-- wall on layers 10,11,12 or 12,13,14 if blaze
 			T:go("F1R1 F1R2 C1R1 U1", false, 0, false) -- exit wall, repair behind: Level 10, facing entry point top right corner
 			T:down(1)
 			if blaze then
 				lib.placeFloor(9, 9, brick) 			-- place brick floor on level 14
 				T:go("L1F4 R1F2 U4")					-- ends facing out to lower chamber ?below staircase
 				-- now needs to build killzone
 			else
 				lib.placeFloor(9, 9, "stone") 			-- ends facing wall on entrance side
 				T:go("U1R2")
 				lib.placeFloor(9, 9, "stone") 			-- ends facing wall on opposite side
 				-- return to mid-point front
 				T:go("R2F8 R1F4 L1F2")					-- exit at bottom of dungeon
 				T:go("x1U1 x1U1 x1U1 x1D3 R2") 			-- rise to chest, then return ready for next stage
-			if not T:place("fence", "down", false) then-- first side
+
-				T:place(preferredBlock, "down", false)
+
 		else
 			return
 			{
 				"Spawner not found. Place me on top,",
 				"immediately below, or facing it.",
 				"\nEnter to quit"
 			}
 		end
 	end
 	if continue then
 		T:clear()
 		local text =
 [[~yellow~Items required to continue:
 
 ~lightGray~slabs            81
 ~orange~nether bricks    88
 ~yellow~lava buckets     4
 ~brown~chest / barrel   1
 ~gray~hopper           1
 
 ~red~WARNING ~yellow~Inventory ejects items if you
 continue! ~orange~(Choose at next menu.)
 
 ~white~Next -> Enter]]
 		menu.colourText(nil, text, true)
-		T:place("minecraft:soul_sand", "down", false) -- over block 1 of water source
+
 		pp.itemColours = {colors.red, colors.lime}
 		local choice = menu.new("Choose your option", {"Continue with build", "Re-start later"}, pp, "Type number + Enter") -- 1 = continue, 2= quit
 		if choice == 1 then
 			choice = menu.new("Choose your option", {"Turtle is above me", "Turtle is below or next to me"}, pp, "Type number + Enter") -- 1 = up, 2= down
 			if choice == 1 then
 				T:emptyInventory("down")
 			else
 				T:emptyInventory("up")
 			end
 		else
 			return {"Blaze spawner partial build halted"}
 		end
 
 		--clsTurtle.getItemSlot(self, item, useDamage): return slotData.lastSlot, slotData.leastModifier, total, slotData
 		T:checkInventoryForItem({brick}, {88})
 		T:checkInventoryForItem({"slab"}, {81})
 		T:checkInventoryForItem({"lava"}, {4})
 		T:checkInventoryForItem({"sign"}, {1})
 		T:checkInventoryForItem({"hopper"}, {1})
 		T:checkInventoryForItem({"chest", "barrel"}, {1, 1})
 		print("Stand clear. Starting in 2 secs")
-				T:place("door", "forward", false)
+
 		-- place upper floor and slabs under it
 		T:go("R2D4F2 L1F4 R1U4")
 		lib.placeFloor(9, 9, brick) 			-- place brick floor on level 10
 		T:down(2)
 		T:place(brick, 0, "up")
 		T:go("D1R2")
-			T:place(preferredBlock, "down", false)
+
 
 		-- place lava
 		T:go("L1F4 L1F4 U4")					-- through hole in ceiling
 		T:go("F4 L1F4 R2")
 		for i = 1, 4 do
 			T:place("lava", 0 , "down")
-				T:place("door", "forward", false)
+
 		end
 		T:go("F4 R1F4 D2 F1 R2")
 		-- place sign and repair above
 		T:dig("forward")
 		T:place("sign", 0, true, "")
 		T:down(1)
 		T:place(brick, 0 , "up")
 		T:forward(1)
 		-- place blocks under exit hole
 		for i = 1, 4 do
 			T:place(brick, 0 , "forward")
 			T:turnRight(1)
 		end
 		-- place chest and hopper
 
 		T:go("D2x2")
 		if not T:place("chest", 0, "down") then
 			T:place("barrel", 0, "down")
 		end
 		T:up(1)
 		T:place("hopper", 0, "down")
 		utils.goBack(1)
 		T:place("slab", 0, "forward")
 		T:go("R2F5U3")-- return to starting point and create entrance
 	end
 	return {}
 end
 
 local function floodMobFarm(R) -- 63
 	--[[Part 2 / 3 Mob Spawner Farm turtle on floor, pointing towards water source wall, single hole]]
 	local lib ={}
 
 	function lib.setPosition(addWater)
 		local width = 0
 		while turtle.forward() do end					-- move forward until hit wall
 		T:go("U1L1")
 		while turtle.forward() do end					-- move forward until hit left wall
-		T:place("fence", "down", false)							-- fence centre of bottom side layer 22
+
 			T:placeWater("down") 			 			-- place water down
 		end
-		T:place("ladder", "forward", false)
+
 		while turtle.forward() do
-		T:place("ladder", "forward", false)
+
 		end			-- go forward 7
 		if addWater then								-- back 1
 			T:placeWater("down") 						-- place water
 		end
 		T:go("L2F".. math.floor(width / 2) .."L1")		-- turn round, go forward 3 (centre of wall), turn left
 	end
 
 	function lib.digFloor()
-		T:place("minecraft:soul_sand", "down", false)
+
 
 		T:turnLeft(1)									-- left turn, go back into right side, facing left
 		utils.goBack(1)
 		T:go("x2 F1x2 F1x2 R1F1")						-- go right to left dig 3 blocks, forward on left side
-		T:place("ladder", "down", false)
+
 		T:turnRight(1)									-- right turn, go back into left side, facing right
-		T:place("sign", "forward", false, "UP\n^\n|\n|")
+
 		T:go("x2 F1x2 F1x2 F1x2 F1x2 L1F1")				-- go left to right dig 5 blocks, forward on right side
 
-		T:place("sign", "forward", false, "UP\n^\n|\n|")
+
 		utils.goBack(1)
 		T:go("x2 F1x2 F1x2 F1x2 F1x2 F1x2 F1x2 R1F1")	-- go right to left dig 7 blocks, forward on left side
-		T:place("sign", "forward", false, "UP\n^\n|\n|")
+
 		T:turnRight(1)									-- right turn, go back into left side, facing right
 		utils.goBack(1)
 		T:go("x2 F1x2 F1x2 F1x2 F1x2 F1x2  F1x2  F1x2  F1x2 L1")	-- go left to right dig 5 blocks, face forward on right side
 	end
-		T:place("sign", "forward", false, "UP\n^\n|\n|")
+
 	lib.setPosition(false)					-- move to back of cube and verify position
 	if R.subChoice == 1 then
 		T:forward(3)						-- forward 4 (centre of chamber)
 	else
 		T:forward(2)						-- forward 3
 	end
 	T:down(1)
 	lib.digFloor()
 	if R.subChoice == 1 then
 		T:go("D1F1 L1F8")
 		utils.goBack(4)
 		T:go("L1U1")
 		lib.setPosition(true)				-- place water sources
 		T:go("F8D2")
 		-- go down 2, check floor, up 1, place fence
 		T:go("D2C2U1", false, 0, true)
 		T:place("fence", -1, "down", false)
 		T:go("F1D1C2U1", false, 0, true)
 		T:place("fence", -1, "down", false)
 		T:go("F1U1R2", false, 0, true)
 		T:go("F1R1U1")
 		T:place("sign", -1, "down", false)
 		T:go("U1C0D1")
 		T:place("slab", -1, "up", false)
 		T:go("R2F1R2")
 		T:place("sign", -1, "forward", false)
 		T:go("R1F1R2C1R1F1D1L1") --sitting on soul sand/dirt facing spawner
 		if not T:place("minecraft:soul_sand", -1, "down", false) then
 			T:place("minecraft:dirt", -1, "down", false)
 		end
 	else
-			T:place("fence", "up", false)
+
 		T:go("R1F1 R1F8")
 		utils.goBack(4)
 		T:go("R1U1")
 		lib.setPosition(true)		-- place water sources
 		T:go("F8D2 F1C2C0 F1")		-- exit leaving single hole in wall, facing away from spawner
 	end
 
 	return {}
 end
 
 local function createMobBubbleLift(R) -- 64
 	-- Part 3 / 3 Mob Spawner Farm
 	-- R.subChoice = 1 or 2 (left/right)
 	local lib = {}
 
 	function lib.initialise()
 		local blockType = T:getBlockType("down")
 		if blockType ~= "minecraft:soul_sand" then
 			T:dig("down")
 			if not T:place("minecraft:soul_sand", -1, "down", false) then
 				return {"Unable to find or place soulsand."}
 			end
 		end
 		-- check facing sign, rotate if not
 		blockType = T:getBlockType("forward")
 		local turns = 0
 		while blockType:find("sign") == nil do
 			T:turnRight(1)
 			turns = turns + 1
 			if turns == 4 then
 				return {"Unable to find sign."}
-local function createFarmNetworkStorage(R, withStorage, removeLegacy)
+
-	removeLegacy = removeLegacy or false
+
-	-- new or converted farm will have:
+
-	-- 2 modems, 1 barrel per plot
+
-	-- primary plot and storage needs 1 modem, 1 barrel, 8 chests
+
 
 	function lib.createWaterSource(oTurn)
-	function lib.createBasement(R, up, down, width, length)
+
-		-- start facing lower left
+
-		R.up = up
+
-		R.down = down
+
-		R.width = width
+
-		R.length = length
+
-		clearRectangle(R)	-- dig 10 x 10 x 2 area, return to starting position
+
-		-- add network cable, modems and chests
+
 		T:go("R2F1") 				-- face column move to middle
 		T:placeWater("forward")
-	function lib.placeNetwork(count, pattern)
+
 		T:placeWater("forward")
-			T:place("computercraft:cable", "up", true)
+
-			if i < count then
+
-				T:go(pattern)
+
 	function lib.goToWater(moves)
 		T:down(moves)
 		T:getWater("down")
 		sleep(0.1)
-	-- called when starting at lower left side of plot, facing crops
+
-	if removeLegacy then
+
 
-		while turtle.suckDown() do end
+
-		--T:dig("down", false)	-- do not bypass chests
+
-		turtle.digDown()
+
-		T:place("dirt", "down")
+
-		T:go("R2F1")
+
-		while turtle.suck() do end
+			T:place("chest", 0, "down")
-		T:go("F1L1 F1U1 R2")	-- remove barrel/wall or double chest. face tree
+
-		T:place("stone", "down")
+
 			T:place("chest", 0, "down")
-		T:place("modem", "down")
+
-		-- could be tree/sapling in front
+
 			T:go("D1x1")
-		if T:getBlockType("down") == "minecraft:dirt" then
+			T:place("hopper", 0, "forward")
-			T:place("barrel", "down")
+
-			T:go("U1x0")
+
-			T:place("dirt", "up")
+
-			T:go("B1U2")
+
-			if T:getBlockType("forward"):find("log") ~= nil then
+
-				T:place("sapling", "forward")
+
 		while turtle.detect() do
-			T:go("D3F1 R1F1")
+
 			moves = moves + 1
-			T:place("barrel", "down")
+
 
 		return moves
-		while turtle.suckDown() do end
+
-		T:place("modem", "down")
+
-		network.attachModem()
+
-		T:go("F1x2 R2C2 F1L1 F1D1")
+
 		D.width  = 4
-	T:go("L1D3") -- move below crop field, face N
+
-	lib.createBasement(R, true, true, 10, 10)	-- ends facing N below water source
+
-	T:go("U1 F9R1 F1R2 C1R2 F8R1 F1R2 C1R2 F8R1 F1R2 C1R2 F8") -- facing W below water source
+
-	T:go("F1 R2C1 R1 F1L1 x0x2")	-- move to corner, face along front edge
+
-	for c = 1, 4 do
+
-		if c == 1 then
+
-			lib.placeNetwork(12, "F1x0x2")
+
 
-			lib.placeNetwork(11, "F1x0x2")
+
 	end
-		if c < 4 then
+
-			T:go("L1F1 x0x2 L1C1R1")
+
 		for i = 1, 9 do -- fill in a solid block bar from bubble column for 8 spaces
 			T:go("F1C0C2 R1C1 R1C1 R1C1 R1C1")
-	-- now in bottom left facing S
+
-	T:go("L2F1R1")	-- under modem/netwok cable facing in
+
-	for i = 1, 3 do
+
-		T:go("L1C1 R1C1 R1C1 L1D1")
+
-		T:place("computercraft:cable", "up", true)
+
 	end
-	T:go("C1L1 C1L1 C1L1 C1L1 D1L1")-- ready for clearing rectangle up/down
+
-	T:place("computercraft:cable", "up", true)
+
 	local oTurn = "L"
-	T:place("computercraft:cable", "up", true)
+
-	lib.createBasement(R, true, true, 11, 11)
+
 		oTurn = "R"
-	lib.placeNetwork(11, "F1")
+
-	T:go("R2F4 R1")
+
-	lib.placeNetwork(11, "F1")
+
-	T:go("L1F5 L1F9 R1D1 C1")	-- ready to make ladder column
+
 		return data 						-- eg {"Unable to find sign."}
-		if i < 5 then
+
-			T:go("U1C1")
+
 	for i = 1, 3 do		-- fill in back and one side, go up
 		T:go(turn.."1C1"..turn.."1C1"..turn.."1x1"..turn.."1U1", false, 0, true)
 	end
-		T:place("ladder", "down")
+
 	local colHeight = 19
-	if withStorage then
+
-		T:go("R1F4 R1F3 D1x2")
+
-		T:place("computercraft:cable", "down", true) --ready to build chest storage area
+
 	-- facing spawner 20 blocks up. move either left/right 8 blocks, repairing ceiling and sides
-		utils.createStorage()
+
-		T:go("U1R1 F5R1 F5U1 C2U1 R2")	-- end on plot starting position, facing crops
+
 	lib.mobTransporter()
-		T:go("U1F2 L1F1 U1C2 U1L1")	-- end on plot starting position, facing crops
+
 	-- now create bubble column
 	T:down(colHeight + 2)
-	return "Farm converted to network storage"
+
 	repeat
 		lib.goToWater(moves)	-- get water
 		moves = lib.up()
 		T:go("F1")
-	-- extend "right" or "forward". only adds a single new farm.
+
 		T:go("U1C2")
 		T:placeWater("forward")
 		utils.goBack(1)
 		T:go("C1")
 		moves = moves + 1
 	until moves >= colHeight + 1
 	lib.goToWater(moves)	-- get water for last time
 	lib.up()				-- finishes above lower part of the transport bar
 	T:go("F2R2C1D1")		-- seal off bubble column
 	utils.goBack(1)
 	T:placeWater("forward")	-- place source on top of bubble column
 	utils.goBack(7)			-- over down shaft
 	T:down(1)				-- start shaft, facing bubble column
 	for i = 1, 17 do
-				T:place("dirt", "forward", false)
+
 		T:go("R1C1 R1C1 R1C1 R1C1 D1", false, 0, true)
-				--if not T:place("minecraft:crafting_table", "forward", false) then
+
-				if T:place(storage, "forward", false) then
+
 	T:go("x0")
 	T:go(oTurn.."1C1".. turn.."1D1C2"..oTurn.."1C1"..turn.."1F1".. oTurn.."1F1"..oTurn.."1") -- facing end wall ready to place slabs
 	for i = 1, 6 do
 		T:place("slab", 0, "down")
-					T:place("dirt", "forward", false) -- dirt if no storage available
+
 			T:go(oTurn.."1")
 		end
-				T:place(R.useBlockType, "forward", false)
+
 		T:go("C1")
 	end
 
 	T:go("D2F2"..turn.."1F5")
-		T:placeWater("down")	-- ends facing same direction as started, over water source
+
 	T:go(turn.."1F1"..oTurn.."1") -- facing down mob channel floor
 	for i = 1, 5 do
 		T:go("C1")
 		utils.goBack(1)
 	end
 	T:go("C1"..turn.."1F1"..turn.."1F1")
-				T:place("dirt", "down", false)
+
 		T:go("C2x0")
 		if i < 7 then
 			T:forward(1)
 		end
 	end
 	T:go("U3R2")
 	for i = 1, 7 do
-				T:place("dirt", "down", false)
+
 	end
 	T:go("D3")
 
 	lib.placeCollector(turn, oTurn) -- if hopper / chests present
 
 	return {}
-		if not T:place(storage, "down", false) then-- place barrel/chest below
+
-			T:place(storageBackup, "down", false) -- place chest below
+
 local function createPlatform(R) -- 56
 	-- T:go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 	local forward = true
 	for w = 1, R.width do
-	-- current position if extend == nil is on ground/farm level facing N
+
-	-- if extend = "right", "front" above water source facing crops
+
-	local numPlots = 0
+
 				T:dig("up")
 			end
 			if l < R.length then
 				T:forward(1)
 			end
-			T:forward(11)
+
-			numPlots = numPlots + 1
+
-		until not utils.isStorage("down") -- on top of chest, barrel or modem
+
-		T:go("R1F1R2")	-- move to front right corner of last plot on right side
+
-		--T:go("R1U1 F1L1 F10L1") -- move to front right corner
+
 				else
 					T:go("R1F1 R1")
 				end
 			else
-			T:forward(11)
+
-			numPlots = numPlots + 1
+
-		until not utils.isStorage("down") -- on top of chest, barrel or modem
+
-		T:go("L1F1 R1x2")	-- could dig tree or sapling + block below
+
-		--T:go("L2U1 F1R1 F10")
+
-	elseif extend == "convertWithStorage" then
+
-		-- convert normal (storage) primary plot farm to networked storage
+
-		--T:turnLeft(1)	-- over water source, facing N
+
-		local response = createFarmNetworkStorage(R, true, true)
+
-		return {response}
+
-	elseif extend == "convert" or extend == "convertWithStorage" then
+
-		-- convert normal (storage) extended farm to networked storage
+
-		--T:turnLeft(1)	-- over water source, facing N
+
-		createFarmNetworkStorage(R, false, true)
+
-		return {"Farm converted to network storage"}
+
-	else -- new farm.
+
-		T:up(1) -- assume on the ground, go up 1
+
 	R.data = "bury" to embed bottom into ground
 	R.subChoice 1 = facing portal, 2 = aligned
-	-- design change: sapling placed 2 blocks above corner for ease of walking round
+
-	if R.networkFarm then	-- barrel on corner of plot, modems on each side N/E
+
-		T:place("barrel", "down", false)
+
 	function lib.buildBase()
-		T:place(R.useBlockType, "down", false)
+
 		T:go("C2", false, 0, false, R.useBlockType)
-	-- stage 2 place sapling
+
 		for i = 1, R.length - 2 do -- R.length = 4: place when i=1,2
-	T:place("dirt", "down")
+			T:place("minecraft:obsidian", 0, "down", false)
-	T:up(1)
+
-	T:place("sapling", "down") -- plant sapling
+
-	T:go("F1D4")
+
-	if R.networkFarm then
+
-		T:place("modem", "down", false)
+
-		network.attachModem()
+
 		T:place("minecraft:obsidian", 0, "down", false)
-		T:place(R.useBlockType, "down", false)
+
 			T:forward(1)
-		-- stage 2 place double barrel/chest
+
 		T:place("minecraft:obsidian", 0, "down", false)
 	end
-		T:go("R1F1L1")
+
 	if R.data ~= "bury" then
 		T:up(1)
 	end
 	if R.subChoice == 1 then
 		T:go("F1R1")
 	end
 	local out = true
-			T:go("F1 x0x2C 2", false, 0, false, R.useBlockType)
+
 		lib.buildBase()
 		for i = 1, R.height - 2 do
 			T:go("R2U1")
 			out = not out
-	lib.placeDirt(9, false) 	-- place dirt back to start
+
-	if R.networkFarm then	-- water source next to modem
+
-		lib.addWaterSource(R, {"c","c","d","d"}, storage)
+
-		-- T:go(path, useTorch, torchInterval, leaveExisting, preferredBlock
+
-		T:go("U1F1L1")
+
-		T:place("modem", "down", false)
+
-		T:go("F1C2 L1F1 D1", false, 0, false, R.useBlockType)
+
 		end
-		lib.addWaterSource(R, {"c","c","t","d"}, storage)  -- put barrel / chest in floor
+
-		T:go("U1F1R2")
+
-		if T:getBlockType("down"):find(storage) == nil and T:getBlockType("down"):find(storageBackup) == nil then
+
-			lib.placeStorage(storage, storageBackup)
+
 			T:go("L1F"..R.width.."D"..R.height - 1 .."R2")
-		T:go("R1F1L1")
+
-		if T:getBlockType("down"):find(storage) == nil and T:getBlockType("down"):find(storageBackup) == nil then
+
-			lib.placeStorage(storage, storageBackup)
+
 		end
-		T:go("F1D1")
+
 
 	return {}
 end
 
-		T:go("F1U1x0C2"..turn.."1F1"..turn.."1x0 x2C2 F1D1", false, 0, false, R.useBlockType)
+
 	--[[ Used in End World to use a trapdoor to push player through portal ]]
 	local lib ={}
 
 	function lib.findPortal()
 		local found = false
 		local onSide = false
 		for i = 1, 64 do
 			if not turtle.up() then -- hit block above
-	lib.addWaterSource(R, {"d","c","c","d"}, storage)	-- bottom right
+
 				break
-	lib.addWaterSource(R, {"c","c","d","d"}, storage)	-- top right, facing away from plot
+
-	T:go("F1U1 R1C2 x0F1 x0x2 C2R1", false, 0, false, R.useBlockType)
+
-	for i = 1, 11 do	-- build right wall from top of plot to bottom
+
 			-- are we under the centre block, or one of the sides?
 			if turtle.detect() then -- under a side
-	T:go("R1F10")				-- ends on top of front storage/ modem facing tree
+
-	if R.networkFarm then		-- network storage
+
-		network.attachModem()
+
-		T:go("R1F1D1R1")	-- over water source, facing E (crops)
+
-		if extend == "" then	-- primary plot
+
-			createFarmNetworkStorage(R, true)
+
 						break
-			createFarmNetworkStorage(R, false)
+
 				end
 			end
 			if onSide then-- move to centre
 				T:go("D1F1")
-		utils.goBack(numPlots * 11)
+
 		end
 		local height = 3 -- allows for 2 bedrock + starting space
-		T:go("R1U1F".. numPlots * 11 .."D1L1")
+
 			height = height + 1
 		end
 		return found, height
 	end
 
 	function lib.addFloor(length)
 		for i = 1, length do
 			if i < length then
-	--T:setUseLog(true, "farmCreateLog.txt", true)
+
-	--dbug = true	-- set dbug flag
+
-	--utils.waitForInput("Logging and debugging enabled")	--utils.waitForInput(message)
+
 			end
 		end
 	end
 
 	function lib.buildLadder(height)
 		for i = 1, height do
-	R = utils.checkFarmPosition(R)
+
 			T:go("F1C1 R1C1 L2C1 R1", false, 0, true)
-	if not R.ready then
+
-		return {"Unable to determine starting position"}
+
 				T:go("C2")
 			end
-	createFarm(R, extend)
+			T:place("minecraft:ladder", 0, "forward", true)
 			T:up(1)
 		end
 	end
 
 	local found, height = lib.findPortal()
 	if found then	-- position under centre of beacon
 		-- build ladder up and create platform
 		T:go("L1F1L1F2L2")
 		T:checkInventoryForItem({"minecraft:ladder"},{height})
-	R.data == "random" for random floor placement
+
 		T:checkInventoryForItem({"trapdoor"},{1})
 		lib.buildLadder(height) -- ends facing ladder, 1 block above
 
 		T:go("R1")
-	function lib.goToRemote(R)
+
 		T:go("C2F1 C2F1 C2F1 C2")
 		T:go("R1F1R1")
 		T:go("C2F1 C2F1 C2F1 C2")
 		utils.goBack(2)
 		T:go("R1F1")			-- facing portal entrance
 		T:place("trapdoor", -1, "up", false)
 	else
 		return {"Portal not found. Move me under","the centre if possible.", "wait for purple beacon."}
 	end
 	return {}
 end
 
 local function createRailway(R) -- 93
 	-- go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 	--[[Build steps up or down ready for railtrack]]
 	if R.down then
-			return "Measured depth/height of "..depth.." > setting: "..R.height
+
 			local blockType = ""
 			while blockType == "" do
 				T:go("F1D1", false, 0, true)
 				blockType = T:getBlockType("down")
 				if blockType == "" then
-	function lib.checkPosition(R)
+
-		-- check if block above/below
+
-		local blockBelow = turtle.detectDown()
+
-		local blockAbove = turtle.detectUp()
+
-		if R.subChoice == 2 then -- New floor over existing
+
-			-- if no block below, assume in correct position and continue
+				T:go("U1x0 D1x1 F1x0x1 D1x1 C2", false, 0, false)
-			-- else move up 1 and continue
+
-			if blockBelow then T:up(1) end
+
-		elseif R.subChoice == 4 then -- New ceiling under existing
+
-			-- if no block above, assume in correct position and continue
+
-			-- else move down 1 and continue
+			T:go("C1U2 x0D1F1", false, 0, false) --put stone in front, up 2 excavate 1, down 1, forward 1
-			if blockAbove then T:down(1) end
+
 	end
 	return {}
 end
-	function lib.placeRow(R, direction, waterPresent)
+
 local function createRectanglePath(R) -- 710, 83 direct commands
 	-- allow user to control length / width of each path
 	-- T:go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 	--local pp = utils.getPrettyPrint()
 	local lib = {}
 
 	function lib.forward(R)
-			R = lib.getRandomBlock(R)	-- changes block randomly ONLY if R.data == "random"
+
-			R = lib.changeCheckered(R)	-- changes to next block type ONLY if R.data == "checked"
+
-			-- ONLY if R.data == "striped" has already been changed for whole row
+
-			T:place(R.inventory.useBlock, direction, false) -- leaveExisting = false
+
 		else
 			for i = 1, R.length do
 				T:go("F1U1C0D1C2", false, 0, true)
 			end
-		return waterPresent, R
+
 	end
 
-	function lib.getRandomBlock(R)
+
-		if R.data == "random" then
+
-			local index = math.random(1, #R.inventory.names)	-- random index between 1 and no of block types
+
-			local success = false
+
-			for i = index, R.inventory.blockTypeCount do		-- iterate from index upwards
+
-				if R.inventory.quantities[i] > 0 then			-- at least 1 block left
+
-					R.inventory.useBlock = R.inventory.names[i]
+
-					R.inventory.quantities[i] = R.inventory.quantities[i] - 1
+
-					R.inventory.blockCount = R.inventory.blockCount - 1
+
-					success = true
+
 	function lib.right(R)
 		T:turnRight(R.length)
 	end
 
-			if not success then								-- no blocks left in the range of index -> no of block types
+
-				for i = index, 1, -1 do						-- go backwards from index to 1
+
-					if R.inventory.quantities[i] > 0 then		-- at least 1 block left
+
-						R.inventory.useBlock = R.inventory.names[i]
+
-						R.inventory.quantities[i] = R.inventory.quantities[i] - 1
+
-						R.inventory.blockCount = R.inventory.blockCount - 1
+
-						success = true
+
 
 	function lib.down()
 		T:go("D1C2", false, 0, true)
 	end
-		end
+
 	if R.data == "menu" then
-		return R
+
 		local width = 0
 		local length = 0
-	function lib.changeStripe(R)
+
-		if R.data == "striped" then
+
-			R.size = R.size + 1
+
-			if R.size > R.inventory.blockTypeCount then
+
-				R.size = 1
+
 			"Back # blocks",
-			R.inventory.useBlock = R.inventory.names[R.size]
+
 			"Turn Left",
-		return R
+
 			"Down 1 block",
 			"Quit"
-	function lib.changeCheckered(R)
+
-		--swap between 2 block types
+
-		if R.data == "checked" then
+
-			if R.inventory.useBlock == R.inventory.names[1] then
+
-				R.inventory.useBlock = R.inventory.names[2]
+
 			if choice == 1 then
-				R.inventory.useBlock = R.inventory.names[1]
+
 				lib.forward(R)
 			elseif choice == 2 then
-		return R
+
 				R.length = menu.getInteger("Move forward how many blocks?", 1, 250, nil, colors.lime)
 				lib.forward(R)
 			elseif choice == 3 then
 				R.length = 1
-	if R.data == "random" then
+
-		math.randomseed(R.inventory.blockCount)
+
-		print("Using random blocks")
+
-	elseif R.data == "striped" then
+
-		print("Using striped pattern")
+
-	elseif R.data == "checked" then
+
-		print("Using checkered pattern")
+
 			elseif choice == 6 then
 				R.length = 1
 				lib.left(R)
 			elseif choice == 7 then
 				lib.up(R)
 			elseif choice == 8 then
 				lib.down()
-		local message = lib.goToRemote(R)
+
-		if message ~= "" then	-- error encountered
+
-			return {message}
+
 		local instructions =
 [[~lightGray~Commands:
 
-	lib.checkPosition(R)
+
-	-- based on clearRectangle code
+
-	if R.width == 1 then 					-- single block ahead only
+
-		waterPresent, R = lib.placeRow(R, direction, waterPresent)
+
-		T:turnRight(2)						-- turn at the top of the run
+
-		T:forward(R.length - 1)				-- return to start
+
-		T:turnRight(2)						-- turn round to original position
+
 ~red~q = quit
-		local iterations = 0 				-- R.width = 2, 4, 6, 8 etc
+
-		if R.width % 2 == 1 then  			-- R.width = 3, 5, 7, 9 eg R.width 7
+
-			iterations = (R.width - 1) / 2 	-- iterations 1, 2, 3, 4 for widths 3, 5, 7, 9
+
 		while cmd ~= "q" do
 			local line = menu.clear()
 			line = menu.colourText(line, instructions)
-		R = lib.changeStripe(R)
+
-		R = lib.changeCheckered(R)
+
-		for i = 1, iterations do 			-- eg 3 blocks wide, iterations = 1
+
-			waterPresent, R = lib.placeRow(R, direction, waterPresent)
+
 			cmd = input:sub(1,1)
-			R = lib.changeStripe(R)
+
-			--R = lib.changeCheckered(R)
+
-			waterPresent, R = lib.placeRow(R, direction, waterPresent)
+
 			end
 			if cmd == "q" then
 				return{"User has quit application"}
-				R = lib.changeStripe(R)
+
 			if cmd == "f" then
 				lib.forward(R)
 			elseif cmd == "b" then
 				lib.back(R)
-			R = lib.changeStripe(R)
+
-			waterPresent, R = lib.placeRow(R, direction, waterPresent)
+
 			elseif cmd == "r" then
 				lib.right(R)
 			elseif cmd == "u" then
 				lib.up(R)
 			elseif cmd == "d" then
 				lib.down()
 			end
 		end
 	end
 	return {}
 end
 
 local function createRetainingWall(R) -- 34, 82
 	-- facing direction wall will take
 	-- will need to rotate 180 to build
 	-- if R.height > 0 then build to specified depth
 	local lib = {}
 
 	function lib.checkFloor()
 		local newDepth = 0
 		place = utils.clearVegetation("down") -- in case col in front is deeper
 		while place do -- loop will be entered at least once
 			T:down(1)
 			newDepth = newDepth + 1
 			place = utils.clearVegetation("down")
 		end
 		if newDepth > 0 then
 			for j = 1, newDepth do	-- go up until column base is met
 				T:go("U1C2")
 			end
 		end
 	end
 
 	function lib.patchMissingBlock()
 		if turtle.back() then
 			T:go("C1")
 		else
 			T:go("B1C1")
 		end
 	end
 
 	function lib.placeSingle(height)
-					T:place("torch", "forward")				-- place torch, move forward
+
 		if height > 0 then
 			T:go("D"..height)
 			y = height
 		else
 			local place = utils.clearVegetation("down")
 			while place do -- loop will be entered at least once
-				if not T:place("slab", "down") then			-- break if out of slabs
+
 				if place then
 					T:down(1)
 					y = y + 1
 				end
 			end
 		end
 		-- return to surface, placing below
 		for i = 1, y do
 			T:go("U1C2", false, 0, true)
 		end
 	end
 
 	function lib.placeDouble(height)
 		--T:go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 		local y = 0
 		if not turtle.back() then
 			T:go("B1")
 		end
 		if height > 0 then
 			for i = 1, height do
 				T:go("C1D1", false, 0, true)
 			end
 			T:go("C1", false, 0, true)
 			y = height
 		else
 			local place = utils.clearVegetation("down")
 			-- build back column
 			while place do -- loop will be entered at least once
 				place = utils.clearVegetation("down")
 				if place then
 					T:go("C1D1", false, 0, true)
 					y = y + 1
 				end
 			end
 			-- reached bottom. floor in front could drop down
-				-- T:place(blockType, direction, leaveExisting, signText)
+
-				if not T:place("stone", "forward", false) then
+
 			turtle.back() -- back at starting point
 			T:go("C1", false, 0, true)
 		end
-				if T:getItemSlot("minecraft:torch") > 0 then
+
-					T:place("torch", "forward", false)
+
 			T:go("U1C2", false, 0, true)
 		end
 	end
 
 	function lib.placeTriple(height)
 		--T:go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
-				if not T:place("slab", "forward", false) then
+
 		if turtle.back() then
 			T:go("C1")
 		else
 			T:go("B1C1")
 		end
 		if height > 0 then
 			for i = 1, height do
 				T:go("C1D1", false, 0, true)
 			end
 			for i = 1, height do
 				T:go("C1D1", false, 0, true)
 			end
-				if not T:place("stone", "forward", false) then
+
 			y = height
 		else
 			local place = utils.clearVegetation("down")
-				if T:getItemSlot("minecraft:torch") > 0 then
+
-					T:place("torch", "forward", false)
+
 				place = utils.clearVegetation("down")
 				if place then
 					T:go("C1D1", false, 0, true)
 					y = y + 1
 				end
 			end
 			-- reached bottom. floor in front could drop down
 			T:go("F1") -- move under first column
-			T:place("ice", "down", true)
+
 			T:go("B1C1R2F1", false, 0, true)
 			lib.checkFloor()
 			T:go("B1C1")
 			-- return to surface , placing below and to front
 		end
 		for i = 1, y do
 			T:go("C1U1C2", false, 0, true)
 		end
 		T:go("F1R2C1", false, 0, true)
 		-- facing back again inside edge of col 3
 		return y -- depth of this run
 	end
 
 	local topInPlace = false -- topInPlace = true already a path across the water eg monument rectangle
-					if not T:place("ice", "down", true) then -- out of ice
+
 		topInPlace = true
 	end
 	local place = false
 	local inWater = false
 	local onWater = false
 	if not topInPlace then
 		if R.length > 1 then
 			inWater, onWater = utils.getWaterStatus() -- returns whether above water, or immersed
 		end
 	end
 
 	local maxDepth = 5 --initial estimated value
 	-- start at surface, move back 1 block
 	-- each iteration completes 3 columns
 	local numBlocks = T:getSolidBlockCount()
 	print("Solid blocks in inventory: "..numBlocks)
 
 	if R.length == 1 then -- single column down to water bed
 		lib.placeSingle(R.height)
 	elseif R.length == 2 then--down then up: 2 cols
 		inWater, onWater = utils.startWaterFunction(onWater, inWater, 2, true) -- move into water
 		T:go("R2") -- move to face player
 		lib.placeDouble(R.height)
 		if not inWater then
 			T:go("U1C2", false, 0, true)
 		end
 	else -- R.length 3 or more
 		if topInPlace then
 			T:down(1) -- break through top
 		else
 			inWater, onWater = utils.startWaterFunction(onWater, inWater, 2, true) -- move into water
 		end
 		T:go("R2") -- move to face player
 		-- now at water surface
 		local remain = R.length
 		while remain >= 3 do
 			numBlocks = T:getSolidBlockCount()
 			print("Inventory blocks: "..numBlocks.." depth: "..maxDepth)
 			if numBlocks < maxDepth * 3 then
 				--ask player for more
 				T:checkInventoryForItem({"stone"}, {maxDepth * remain}, false)
 			end
 			local y = lib.placeTriple(R.height) -- moves back, places col in front, centre and behind. R.height = 0 for auto depth
 			if y > maxDepth then
 				maxDepth = y
 			end
 			remain = remain - 3
 			if remain > 1 then
 				lib.patchMissingBlock()
 			end
 		end
 		if remain == 1 then -- 1 more column
 			lib.patchMissingBlock()
 			lib.placeSingle(R.height)
 		elseif remain == 2 then -- 2 cols
 			lib.placeDouble(R.height)
 		end
 		T:go("U1C2") -- above surface
 	end
 	return {}
 end
 
 local function createSafeDrop(R) -- 14
 	-- dig down height blocks, checking for blocks on all sides
 	local drop = 0
 	local isBedrock = false
 	T:down(2)
 	drop = 2
 	for i = 1, R.height - 1 do
 		for j = 1, 4 do
 			-- go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 			T:go("C1R1", false, 0, true)
 		end
 		if T:down(1) then
 			 drop = drop + 1
 		else
 			isBedrock = true
 			break
 		end
 		if T:isWaterOrLava("up") ~= "" then
 			T:go("C0x0", false, 0, false) -- delete water/ lava block
 		end
 	end
 	if not isBedrock then -- not sitting on bedrock, so break foot level exit block
 		T:go("U1R2x1")
-		if not T:place("ladder", "forward", false) then
+
 	T:placeWater("down")
 	if isBedrock then
 		T:go("U1x1 U1x1")
 	else
-			T:place("common", direction, false) -- any common block
+
 	end
-			T:place("minecraft:torch", direction, false)
+
 
 	return {"Safe drop completed "..drop .. " blocks"}
 end
 
 local function createSlopingWater(R) -- 34, 89
 	--[[
 	creates a sloping water area above existing lake/river/ocean
 	R.width is usually 7 with an existing wall on 8th row
 	R.length  is user choice, limited to bucket/slab quantities
 	Places slabs into existing surface, places row of sources
 	Removes slabs
 	]]
 	local lib = {}
 
 	function lib.fillBuckets()
 		local emptyBuckets = utils.getEmptyBucketCount()
 		for i = 1, emptyBuckets do
 			if utils.fillBucket("down") then
 				print("Bucket filled down")
 				sleep(0.3)
 			else
 				print("Unable to fill bucket ".. i .." / "..emptyBuckets)
 			end
 		end
 		return utils.getWaterBucketCount()
 	end
 
 	local outbound = true
 	local inWater, onWater = utils.getWaterStatus()
 	inWater, onWater = utils.startWaterFunction(onWater, inWater, 2 ,false) -- move above water, max descent 2
 	local waterBuckets = lib.fillBuckets()
 	for w = 1, R.width do
 		for l = 1, R.length do
 			T:place("slab", -1, "down", false)
 			if l < R.length then
 				T:forward(1)
 			end
 		end
 		if w < R.width then
 			if outbound then
 				T:go("R1F1R1")
 			else
 				T:go("L1F1L1")
 			end
 			outbound = not outbound
 		end
 	end
 	if outbound then
 		T:go("L1F"..R.width - 1 .."L1")
 	else
 		T:go("R1F"..R.width - 1 .."R1")
 	end
 	T:placeWater("up")  -- place in corner
 	local move = true
 	while move do
 		move = turtle.forward()
 		move = turtle.forward() -- false if at end of run
 		T:placeWater("up")  -- alternate positions + end of run
 	end
 	T:go("R2D1")
 	T:sortInventory() -- get all buckets into 1 slot
 	for w = 1, R.width do
 		for l = 1, R.length do
 			if l < R.length then
 				T:forward(1)
 			end
 		end
 		if w < R.width then
 			if outbound then
 				T:go("R1F1R1")
 			else
 				T:go("L1F1L1")
 			end
 			outbound = not outbound
-		T:place("ladder", "up")
+
 	end
 	if outbound then
 		T:go("L1F"..R.width - 1 .."L1")
 	else
-	T:place("ladder", "forward")
+
 	end
 	T:go("U2")
 
 	return {}
 end
 
 local function createSquidFarmBase(R) -- 34
 	-- dig down to y=45. assume starting at water level (64)
 	local depth = 0
 	local message =
 [[Place the turtle under the grid
 left corner above current pit
 opening.
 It will descend to the base and
 continue to level y=45.
 
 Enter to continue...
 ]]
-	T:place("minecraft:chest", "up", false)
+
 	while turtle.down()do
 		depth = depth + 1
 	end
 	T:down(1)
 	R.height = 21 - depth
 	R.width = 15
 	R.length = 15
 	R.silent = true
 	R.data = "down"
 	clearSolid(R)
 	T:up(depth + 4)
 	return {}
 end
 
-	while T:getItemSlot("minecraft:torch") > 0 do
+
-		turtle.select(T:getItemSlot("minecraft:torch"))
+
 	--move above water
 	local maxMove = 2
 	while turtle.detectDown() and maxMove > 0 do
 		T:forward(1)
 		maxMove = maxMove - 1
 	end
 	if R.length > 0 then
 		for i = 1, R.length - 1 do
 			success = utils.dropSand()
 			T:forward(1, false)
 		end
 		success = utils.dropSand()
 	else
 		while not turtle.detectDown() do -- over water
 			while not turtle.detectDown() do -- nested to allow forward movement
 				success = utils.dropSand() -- drops sand and checks supplies
 			end
 			if success then
 				T:forward(1, false)
 			else -- out of sand
 				break
 			end
 		end
 	end
 	return {}
 end
 
 local function createSinkingPlatform(R) -- 58
 	local lib = {}
 
 	function lib.stage1a(R)							-- build side wall left side
 		for l = 1, R.length do 						--            | |*| |
 			T:go("L1C1 R1C2", false, 0, false)		-- |*|>| | to |*|>| | place left wall
 			if l == 1 then							-- first iteration
 				T:go("U1C2 D1 F1C2", false, 0, false)-- |*|>| | to |*|*|>| up/down block to delete source at corner
 			elseif l < R.length then				-- mid run
 				T:go("F1C2", false, 0, false)		-- |*|>| | to |*|*|>| move forward
 			else									-- end of run
 				T:go("C1U1 C2D1", false, 0, false)	-- |*|>| | to |*|>|*| place end wall
 			end
 		end
 	end
 
 	function lib.stage1b(R)							-- same as stage1a on right side
 		for l = 1, R.length do
 			T:go("R1C1 L1C2", false, 0, false)
 			if l == 1 then
 				T:go("U1C2 D1 F1C2", false, 0, false)
 			elseif l < R.length then
 				T:go("F1C2", false, 0, false)
 			else
 				T:go("C1U1 C2D1", false, 0, false)
 			end
 		end
 	end
 
 	function lib.stage2(forward)
 		if forward then
 			T:go("C1R1 F1L1 C1R2", false, 0, false)
 		else
 			T:go("C1L1 F1R1 C1L2", false, 0, false)
 		end
 	end
 
 	local forward = true
 	local goingRight = true
 	local blockType = T:getBlockType("down")
 	if blockType:find("water") ~= nil or blockType:find("lava") ~= nil then
 		T:up(1)
 	end
 	for h = 1, R.height do						-- repeatedly create a platform, move down and repeat
 		T:down(1) 								-- move down into existing platform
 		if goingRight then 						-- first side
 			if forward then						-- complete left side
 				T:go("R2C1 L2", false, 0, false) -- | |>| | to |*|<| | to |*|>| |
 				lib.stage1a(R)					-- build left wall
 				T:go("R1F1 L1C1 R2C2", false, 0, false)			-- turn ready for next side
 			else
 				T:go("L2C1 R2", false, 0, false) -- block 1, 1
 				lib.stage1b(R)					-- turn ready for next side
 				T:go("L1F1 R1C1 L2C2", false, 0, false)
 			end
 		else 									-- on right side so different approach
 			if forward then
-					T:place("slab", "up", false)
+
 				lib.stage1b(R)
 				T:go("C1L1 F1R1 C1L2 C2", false, 0, false)		-- turn ready for next side
 			else								-- complete left side
 				T:go("R2C1 L2", false, 0, false) -- block 1, 1
 				lib.stage1a(R)					-- turn ready for next side
 				T:go("C1R1 F1L1 C1R2 C2", false, 0, false)
 			end
 		end
 		forward = not forward					-- continue strips across until at far edge
 		for w = 1, R.width - 2 do
 			for l = 1, R.length do
 				if l < R.length then
 					T:go("C2F1", false, 0, false)
 				else
 					T:go("C2", false, 0, false)
 				end
 			end
 			if goingRight then
 				lib.stage2(forward)
 			else
 				lib.stage2(not forward)
-					T:place("slab", "up", false)
+
 			forward = not forward
 		end										-- far side
 		if goingRight then
 			if forward then
 				lib.stage1b(R)
 			else
 				lib.stage1a(R)
 			end
 		else
 			if forward then
 				lib.stage1a(R)
 			else
 				lib.stage1b(R)
 			end
 		end
 		goingRight = not goingRight
 		T:turnRight(2)
 		forward = not forward
 	end
-							T:place("slab", "up", false)
+
 end
 
 local function createStaircase(R) -- 13
 	-- R# L# F# B# U# D# +0 -0 = Right, Left, Forward, Back, Up, Down, up while detect and return, down while not detect
 	-- dig:			  x0,x1,x2 (up/fwd/down)
 	-- suck:		  s0,s1,s2
 	-- place chest:   H0,H1,H2
 	-- place sapling: S0,S1,S2
 	-- place Torch:   T0,T1,T2
 	-- place Hopper:  P0,P1,P2
 	-- mine floor:	  m# = mine # blocks above and below, checking for valuable items below, and filling space with cobble or dirt
 	-- mine ceiling:  M# = mine # blocks, checking for valuable items above, and filling space with cobble or dirt
 	-- mine ceiling:  N# same as M but not mining block below unless valuable
 	-- place:		  C,H,r,S,T,P,^ = Cobble / cHest / DIrT / Sapling / Torch / hoPper /stair in direction 0/1/2 (up/fwd/down) eg C2 = place cobble down
 
 	-- 3| |B| |
 	--   - - -
 	-- 2|A| |C|
 	--   - - -
 	-- 1|^|D| |
 	--   - - -
 	--   1 2 3
 	local lib = {}
 
 	function lib.checkFluids()
 		local isFluid = false
 		-- check if water or lava present
 		for i = 1, 4 do
 			blockType = T:isWaterOrLava("forward")
 			if blockType:find("lava") ~= nil or blockType:find("water") ~= nil then
 				isFluid = true
 			end
 		end
 		return isFluid
 	end
 
 	function lib.createStaircaseSection(onGround, levels, level)
 		-- start 1,1,1, n
 		-- stage A
-		-- T:place(blockType, direction, leaveExisting, signText)
+
 		local blockType = ""
 		local data = T:getStock("stairs")
-				T:place(blockType, "down", false)
+
 			T:craft('stairs', 4)
 		end
 		if onGround and isFluid then
 			-- add right side and block entrance
 			T:go("R1C1R1C1R2")
 		end
 		if isFluid then
 			T:go("L1C1 R1F1C2 L1C1 R1x1 R1C1 L1C2B1 C1x1 ^1C2", false, 0, true) --start:1,1,1,n stairs A on level 1, going back to 1,1,1,n
 		else
 			T:go("F1x1 R1C1 L1C2B1 ^1C2", false, 0, true)
 		end
 		if not onGround then
 			-- stage A1
 			T:go("L2C1L2", false, 0, true) -- start 1,1,1,n fix corner on level 1 end: 1,1,1,n
 		end
 		-- stage B
 		T:go("U1L1", false, 0, true) -- end  1,1,1,w layer 2
 		level = level + 1
 		isFluid = lib.checkFluids()
 		if isFluid then
 			T:go("C1", false, 0, true) -- end  1,1,1,w layer 2
 		end
 		if not onGround then
 			if isFluid then
 				T:go("L1C1R1", false, 0, true) -- end  1,1,1,w layer 2
 			end
 		end
 		-- stage C1
 		if isFluid then
 			T:go("R1C1F1C1x1 L1C1 R2C1 L1B1", false, 0, true)
 		else
 			T:go("R1F1 R1C1 L1B1", false, 0, true)
 		end
 		--level = level + 1
 		--if level == levels then
 			--return false, level
 		--end
 		-- stage C2
 		T:go("U1")
 		level = level + 1
 		--if level == levels then
 			--return true, level
 		--end
 		isFluid = lib.checkFluids()
 		if isFluid then
 			T:go("L1C1L1 C1L2 C1F1L1 C1R2 C1L1 B1C2 D1", false, 0, true) -- end 1,1,2,n
 		else
 			T:go("F1R1 C1L1 B1D1", false, 0, true) -- end 1,1,2,n
 		end
 		level = level - 1 -- went down in branch above
 		--if level == levels then
 			--return false, level
 		--end
 		-- stage D
 		isFluid = lib.checkFluids()
 		if isFluid then
 			T:go("C1F1C1F1C1x1L1 C1R1 C1R1", false, 0, true) -- 3,1,2,e
 		else
 			T:go("F2 C1R1", false, 0, true) -- 3,1,2,e
 		end
 
 		return false, level
 	end
-			T:place("chest", "forward", false)
+
 	--local height = currentLevel -- eg 64 at top or 5 at bedrock
 	local data = T:getStock("stairs")
 	--{rt.total, rt.mostSlot, rt.leastSlot, rt.mostCount, rt.leastCount}
 	local numStairs = data.total
 	local levels = math.abs(R.depth - R.height) --height of stairs
 	local numStairsNeeded = levels
 	numStairsNeeded = numStairsNeeded - numStairs
 	if numStairsNeeded > 40 then
 		print('crafting '..numStairsNeeded..' : '..numStairs.. ' in stock')
 		if T:craft('stairs', 40) then	-- max 40 so repeat
 			data = T:getStock("stairs")
 			if data.total == 0 then
 				data = T:getStock("stairs")
 			end
 			numStairs = data.total
 			numStairsNeeded = numStairsNeeded - numStairs
 		else
 			return {"Unable to craft stairs"}
 		end
 	end
 	if numStairsNeeded > 0 then
 		T:craft('stairs', numStairsNeeded)
 	end
 	local level = 0
 	if R.down then -- go down towards bedrock
 		local atBedrock = false
 		for i = 1, levels do
 			level = level - 1
 			if not T:down() then
 				atBedrock = true
 				break
 			end
 		end
 		if atBedrock then -- hit bedrock so get to level 5 / -59
 			level = T:findBedrockTop(level)
 			T:go("R1F1R1", false, 0, true)
 		end
 	end
 	local onGround = true
 	level = 0
 	while level < levels do
 		onGround, level = lib.createStaircaseSection(onGround, levels, level)
 	end
 	if not turtle.detectDown() then
 		T:go("C2")
 	end
 
 	return{"Staircase completed"}
 end
 
 local function createStripMine(R)
 	--[[
 	R.length should be a multiple of 16
 	mine a corridoor repairing floor and ceiling
 	check sides, remove valuable items
 	plug if lava present
 	Every 16 blocks dig a side passage 1 block deep 2 blocks long
 	]]
 	local lib = {}
 
 	function lib.seal(R)
 		if T:isValuable("forward") then	-- valuable block in front. If debris then refuse already dumped
 			T:dig("forward")
 		end
 		local blockType = T:getBlockType("forward")
 		if blockType:find("lava") ~= nil then
 			--T:place("stone", 0, "forward", false) -- place does not allow for specific blocktype
 			T:go("C1", false, 0, false, R.useBlockType)
 			return true
 		end
 
 		return false
 	end
 
 	function lib.checkSeal(R)
 		local retValue = false
 		T:turnRight(1)
 		if lib.seal(R) then
 			retValue = true
 		end
 		T:turnLeft(2)
 		if lib.seal(R) then
 			retValue = true
 		end
 		T:turnRight(1)
 		return retValue
 	end
 
 	function lib.alcove(R)
 		-- right side, starting at ceiling
 		T:go("R1F1 C0", false, 0, false, R.useBlockType)-- stone ceiling, facing alcove wall (upper)
 		lib.seal(R)										-- seal alcove wall (upper)
 		T:go("D1C2", false, 0, false, "cobble")			-- cobble floor, facing alcove wall (lower)
 		lib.seal(R)										-- seal alcove wall (lower)
 		T:go("L2 F1")									-- down 1, turn round, return to corridoor.
 		-- left side
 		T:go("F1 C2", false, 0, false, "cobble")		-- cobble floor, facing alcove wall (lower)
 		lib.seal(R)										-- seal alcove wall (lower)
 		T:go("U1 C0", false, 0, false, R.useBlockType)	-- stone ceiling, still facing alcove wall
 		lib.seal(R)										-- seal alcove wall (upper)
 		T:go("L2F1L1")									-- return to corridoor at ceiling position
 		lib.placeTorch(R)
 	end
 
 	function lib.placeTorch(R)
 		if R.torchInterval > 0 then 					-- torches onboard
 			if T:getItemSlot("minecraft:torch") > 0 then
 				T:place("minecraft:torch", -1, "down")
 			end
 		end
 	end
 
 	local seal = false
 	if T:getItemSlot("minecraft:torch") == 0 then
 		R.torchInterval = 0 -- set to default 16 above
 	end
 	for steps = 1, R.length do
 		-- go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 		T:go("C2U1C0", false, 0, true, R.useBlockType)		-- check and repair floor / ceiling
 		if steps % 16 == 0 or steps % 16 == 1 then
 			lib.alcove(R) -- enter and exit at ceiling position
 		else
 			seal = lib.checkSeal(R)
 		end
 		T:go("F1D1", false, 0, true)
 		seal = lib.checkSeal(R)
 	end
 	if seal then -- water or lava found while tunnelling
 		T:go("U1C0", false, 0, true, R.useBlockType)
 		lib.checkSeal(R)
 		T:go("C1", false, 0, true, R.useBlockType)
 		T:down(1)
 	end
 	return {}
 end
 
 local function createTreefarm(R) -- 22
 	local lib = {}
 	--go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 	function lib.buildWallSection(length, placePolished, useBlockType)
 		for i = 1, length do
 			if placePolished and i == length - 4 then
-			T:place("slab", "down", true) 				-- place slab on top T:place(blockType, direction, leaveExisting)
+				T:place("polished", 0, "down")
 				T:forward(1)
 			else
 				if i < length then
 					T:go("C2F1", false, 0, false, useBlockType)
 				end
 			end
 		end
 	end
 
 	function lib.placeFloor(length, useBlockType)
 		for i = 1, length do
 			T:go("x0C2", false, 0, false, useBlockType)
 			if i < length then
 				T:forward(1)
 			end
 		end
 	end
 
 	function lib.placeWater(length)
 		T:placeWater("down")
 		T:go("F"..length.."R1")
 	end
 
 	function lib.placeCorners(length, numBlocks, useBlockType)
 		for i = 1, numBlocks do
 			T:go("C2F1", false, 0, false, useBlockType)
 		end
 		-- now at 5th space
 		T:forward(length - (numBlocks * 2))
 		for i = 1, numBlocks do
 			T:go("C2", false, 0, false, useBlockType)
 			if i < numBlocks then
 				T:forward(1)
 			end
 		end
 	end
 
 	function lib.turn(outward)
 		if outward then
 			T:go("R1F1R1")
 		else
 			T:go("L1F1L1")
 		end
 		return not outward
 	end
 
 	local blockType
 	local blockModifier
 	-- R.data = "existing" if on existing tree farm
 	-- R.up = true if clear area
 	if R.up then
 		clearArea(R)
 	end
 
 	if R.data == "existing" then
 		T:go("R1F1 D1", false, 0, false) -- move 14 blocks, right, forward, down 1
 		lib.buildWallSection(R.width - 1, false, R.useBlockType)
 		T:turnLeft(1)
 		lib.buildWallSection(R.length, false, R.useBlockType)
 		T:turnLeft(1)
 		lib.buildWallSection(R.width - 1, false, R.useBlockType)
 		T:go("C2U1R2")
 		lib.buildWallSection(R.width - 1, true, R.useBlockType)
 		T:turnRight(1)
 		lib.buildWallSection(R.length, true, R.useBlockType)
 		T:turnRight(1)
 		lib.buildWallSection(R.width, true, R.useBlockType)
 		T:go("R1") -- on lower left corner facing forward
 	else
 		T:down(1)
 		local placePolished = false
 		for i = 1, 2 do
 			lib.buildWallSection(R.length, placePolished, R.useBlockType)
 			T:turnRight(1)
 			lib.buildWallSection(R.width, placePolished, R.useBlockType)
 			T:turnRight(1)
 			lib.buildWallSection(R.length, placePolished, R.useBlockType)
 			T:turnRight(1)
 			lib.buildWallSection(R.width, placePolished, R.useBlockType)
 			T:turnRight(1)
 			placePolished = true
 			if i == 1 then
 				T:up(1)
 			end
 		end -- on lower left corner facing forward
 	end
 	T:go("F1R1 F1L1 D2") -- over 13 x 13 internal area
 	local outward = true
 	for i = 1, R.width - 2 do
 		lib.placeFloor(R.length - 2, R.useBlockType)
 		if i < R.width - 2 then
 			outward = lib.turn(outward)
 		end
 	end
 	T:go("U1R2") -- over 13 x 13 internal area opposite corner
 	-- now add corners
 	lib.placeCorners(R.length - 2, 4, R.useBlockType)
 	outward = lib.turn(outward)
 	lib.placeCorners(R.length - 2, 3, R.useBlockType)
 	outward = lib.turn(outward)
-		T:place(brick, "up")
+	lib.placeCorners(R.length - 2, 2, R.useBlockType)
 	outward = lib.turn(outward)
 	lib.placeCorners(R.length - 2, 1, R.useBlockType)
 	if outward then
 		T:go("R1F"..R.width - 9 .."R1")
 	else
 		T:go("L1F"..R.width - 9 .."L1")
 	end
-			T:place("lava", "down")
+
 	lib.placeCorners(R.length - 2, 1, R.useBlockType)
 	outward = lib.turn(outward)
 	lib.placeCorners(R.length - 2, 2, R.useBlockType)
 	outward = lib.turn(outward)
 	lib.placeCorners(R.length - 2, 3, R.useBlockType)
-		T:place("sign", true, "")
+	outward = lib.turn(outward)
 	lib.placeCorners(R.length - 2, 4, R.useBlockType) -- should be back in starting corner facing front
-		T:place(brick, "up")
+
 	T:go("U1R1")
 	lib.placeWater(R.length - 3) -- place water down then move forward, turn right
 	lib.placeWater(R.width - 3)
-			T:place(brick, "forward")
+	lib.placeWater(R.length - 3)
 	lib.placeWater(R.width - 3)
 	T:go("F".. math.floor((R.length - 2) / 2).."R1F".. math.floor((R.width - 2) / 2)) -- should be in centre
 	T:go("D4C2 R1C1 R1C1 R1C1 R1F1 R2") -- facing back of hole ready to place water
 	T:placeWater("forward")
 	T:go("R2F7U4")
-		if not T:place("chest", "down") then
+
-			T:place("barrel", "down")
+
 end
 
-		T:place("hopper", "down")
+
 	local lib = {}
-		T:place("slab", "forward")
+
 	function lib.placeBarrel(R)
 		if R.data == "barrel" then
 			utils.goBack(1)
 			T:go("L1F1")
 			T:place("barrel", 0, "down", false)
 			utils.goBack(1)
 			T:go("R1")
 			T:forward(1)
 		end
 	end
 
 	function lib.placeTorch(R)
 		T:up(1)
 		local up = 1
 		local blockType = T:getBlockType("forward")
 		while blockType:find(R.useBlockType) ~= nil and blockType ~= "" do -- prevent continuous upward travel
 			T:up(1)
 			up = up + 1
 			blockType = T:getBlockType("forward")
 		end
 		T:place("torch", 0, "forward", true)
 		T:down(up)
 	end
 
 	function lib.buildWall(R, length)
 		-- T:place(blockType, damageNo, direction, leaveExisting, signText)
 		local blockType = ""
 		local blocks = 0
 		lib.placeBarrel(R)
 		while blocks < length do
 			if turtle.back() then
 				T:place(R.useBlockType, 0, "forward", true)
 				if R.torchInterval > 0 then
 					if blocks == 0 or blocks % R.torchInterval == 0 then
 						lib.placeTorch(R)
 					end
 				end
 				blocks = blocks + 1 -- still facing start position
 				while turtle.down() do
 					T:place(R.useBlockType, 0, "up", true)
 				end
 			else -- obstruction
 				T:turnRight(2) -- facing away from start
 				blockType = T:getBlockType("forward")
 				if blockType:find("torch") ~= nil then
 					T:go("F1R2")
 					T:place(R.useBlockType, 0, "forward")
 					blocks = blocks + 1 -- facing start
 				elseif blockType:find("log") ~= nil then
 					T:harvestTree()
 					T:turnRight(2)
 					T:place(R.useBlockType, 0, "forward")
 					blocks = blocks + 1 -- facing start
 				elseif T:isVegetation(blockType) then
 					T:go("F1R2")
 					T:place(R.useBlockType, 0, "forward")
 					blocks = blocks + 1 -- facing start
 				else -- cant go forward, go up instead
 					while turtle.detect() and blockType:find("torch") == nil and blockType:find("log") == nil and not T:isVegetation(blockType) do -- block ahead, but not torch or tree
 						while turtle.detectUp() do -- will only run if block above
 							utils.goBack(1)
 							blocks = blocks - 1
 						end
-		T:place("fence", "down", false)
+
 						T:place(R.useBlockType, 0, "down", true)
-		T:place("fence", "down", false)
+
 					end
 					T:turnRight(2) -- facing start
-		T:place("sign", "down", false)
+
 			end
-		T:place("slab", "up", false)
+
 	end
-		T:place("sign", "forward", false)
+
 	T:turnRight(2) --facing start position
-		if not T:place("minecraft:soul_sand", "down", false) then
+
-			T:place("minecraft:dirt", "down", false)
+
 	else
 		lib.buildWall(R, R.length - 1)
 		T:go("R1") -- facing start so left turn = turnRight
 		lib.buildWall(R, R.width - 1)
 		T:go("R1")
 		lib.buildWall(R, R.length - 1)
 		T:go("R1")
 		lib.buildWall(R, R.width - 2)
 		T:go("U1")
 		T:place(R.useBlockType, 0, "down", true)
 	end
 
 	return {"Wall or fence completed"}
 end
 
 local function createWaterCanal(R) -- 53
 	--[[
 	designed for 4 turtles, but can be done with 2 as well
 	R.data = 1 (2 turtles) or 2 (4 turtles)
 	R.height = 0 (in water/ on canal floor) or 1 (at ground level)
 	R.side = "R" or "L"
 	R.subChoice =
-			if not T:place("minecraft:soul_sand", "down", false) then
+
 		2 = left side above canal water (new canal only)
 		3 = right side above canal water (new canal only)
 		4 = right side, ground level (on towpath)
 		5 = left side in canal water (if present)
 		6 = right side in canal water (if present)
 
 	if R.height = 0 then already at correct height on canal floor
 		check block below, block to left and block above, move forward tunnelling
 		if entering water then move up, onto canal wall and continue pathway
 		if tunnelling then flood canal
 	else R.height = 1 then above water and on path across
 		move forward, checking for water below
 		if water finishes, move into canal, drop down and continue tunnelling
 	]]
 	local lib = {}
 
 	function lib.newCanalSide(oTurn)
 		T:go("C1 U1x1 U1x1 D2"..oTurn.."1", false, 0, false)
 	end
 
 	function lib.newCanalBase(R)
 		local oTurn = "R"								-- assume R.side = "L"
 		if R.side == "R" then
 			oTurn = "L"
 		end
 		if not turtle.detectDown() then					-- air / water below: fill floor
 			T:go(oTurn.."1D1")							-- *|>| | | to *|V| | | turn towards canal centre, go down ready to repair neighbouring canal base
 			if T:getBlockType("forward"):find("turtle") ~= nil then -- turtle in similar position
 				if R.side == "L" then					-- only left side repairs, so wait 1 second
 					sleep(1)
 					T:go("C1")							-- repair neighbouring canal base
 				end
 			else
 				T:go("C1")								-- repair neighbouring canal base
 			end
 			T:go(R.side.."1")							-- *|V| | | to *|>| | | turn to face start
 			T:up(1)										-- *|>| | | return to canal floor
 		end
 		T:go("C2", false, 0, false)
 	end
 
 	function lib.newCanal(R)
 		--  no source in front as this function called												-- *|<| | |  facing end wall ready for new canal canal base level
 		local oTurn = "R"									-- assume R.side = "L"
 		if R.side == "R" then
-			T:place("chest", "down")
+
 		end
 		lib.newCanalSide(oTurn)								-- *|<| | | wall fixed. to -- *|^| | |
-			T:place("chest", "down")
+
 		lib.newCanalBase(R)									-- *|>| | | base fixed
 		T:go("F1"..R.side.."1") 							-- *|>| | | to *| |>| | to *| |^| |
 		lib.newCanalSide(oTurn)								-- *| |^| | to *| |>| |
-			T:place("hopper", "forward")
+
 		T:go("F1"..R.side.."1") 							-- *| |>| | to *| | |>| to *| | |^|
 		lib.newCanalSide(oTurn)								-- *| | |^| to *| | |>|
 		lib.newCanalBase(R)									-- *| | |>| base fixed
 		T:go(R.side.."2") 									-- *| | |>| to *| | |<|facing existing / back wall
 		T:forward(1)										-- *| |<| |
 		T:placeWater("forward") 							-- *|W|<| | placed against start wall
 		T:go("L2")											-- *|W|>| |
 		T:placeWater("forward") 							-- *|W|>|W| placed direction of travel
 		T:go("R2") 											-- *|W|<|W| rotate
 		if deletesWater then
 			T:up(1)
 		else
 			sleep(0.2)
 		end
 		utils.getWater()									-- *|W|<|W|
 		T:go(oTurn.."2F1")									-- *|W|<|W|  to *|W|W|>|  ready to go
 	end
 
 	function lib.towpathOnly(R)
 		--[[single turtle on towpath only using 4 turtles. Starts at ground level]]
 		for i = 1, R.length do
 			if turtle.detectDown() then						-- eg dirt, stone
 				T:dig("down")								-- remove block below
 			end
 			local placeOnly = true
 			if R.torchInterval > 0 then						-- place torches
 				if i == 1 or i % R.torchInterval == 0 then	-- ready to place torch
 					T:go("C2U1")							-- place solid block below, up 1
 					T:place("torch", 0, "down")				-- place torch, move forward
 					T:go("F1D1")							-- move forward, down
 					placeOnly = false
 				end
 			end
 			if placeOnly then
 				T:dig("up")									-- clear blocks above
 				if not T:place("stone", 0, "down") then		-- place stone below
 					break
 				end
 				if i < R.length then
 					T:forward(1)							-- move forward
 				end
 			end
 		end
 	end
 
 	function lib.initialiseCanal(R)
 		--[[ move turtle to correct position. return moves]]
 		local moves = 1
 		local oTurn = "R"
 		if R.side == "R" then
 			oTurn = "L"
 		end
 		local newCanal, isWater, isSource = false, false, false
 		if R.data == 1 then -- use 2 turtles only
 			if R.subChoice == 1 or R.subChoice == 4 then 	-- left / right side on towpath- move into canal space
 				if deletesWater then
 					T:go(oTurn.."1F1")						-- turn to face canal centre, go forward over water
 					isWater, isSource = T:isWater("down")
 					if isSource then 						-- canal already exists
 						T:go(oTurn.."1")					-- stay above water, face existing canal
 					else									-- NOT above source
 						T:go("D1"..oTurn.."1")				-- go to canal floor, face existing
 						newCanal = true						-- flag create 6 water source blocks
 					end
 				else										-- NOT deletesWater
 					T:go(oTurn.."1F1D1"..oTurn.."1") 		-- move into canal, face back along any existing canal
 					isWater, isSource = T:isWater("forward")
 					if isSource then
 						T:go(R.side.."2") 					-- face forward for new canal
 					else
 						newCanal = true
 					end
 				end
 			elseif R.subChoice == 2 or R.subChoice == 3 then-- left / right side above canal finishing pos if deletesWater
 				if deletesWater then
 					isWater, isSource = T:isWater("down")
 					if isSource then
 						T:go(R.side.."2")					-- face towards existing canal
 					else
 						T:go("D1"..R.side.."2")				-- go down and face existing canal		 				-- no water ahead
 						newCanal = true						-- already in newCanal starting position
 					end
 				else										-- NOT deletesWater
 					T:go("D1"..R.side.."2")					-- facing existing on canal floor
 					isWater, isSource = T:isWater("forward")
 					if isSource then						-- water ahead
 						T:go(R.side.."2")					-- face forward for new canal
 					else
 						newCanal = true
 					end
 				end
 			elseif R.subChoice == 5 or R.subChoice == 6 then -- left / right  side in canal base. Assume NOT deletesWater
-		T:place("slab", "down")
+
 				isWater, isSource = T:isWater("forward")
 				if isSource then
 					T:go(oTurn.."2")
 				else
 					newCanal = true
 				end
 			end
 		else	-- use 4 turtles
 			if R.subChoice == 1 or R.subChoice == 4 then 	-- left / right side on towpath stays in place for 4 part canal
 
 			elseif R.subChoice == 2 or R.subChoice == 3 then-- left / right side above canal finishing pos if deletesWater
 
 			elseif R.subChoice == 5 or R.subChoice == 6 then -- left / right  side in canal base. Assume NOT deletesWater
 
 			end
 		end
 		if newCanal then 								-- no water ahead, facing start wall of new canal *|<| | |
 			lib.newCanal(R) 							-- start new canal, finish facing new canal 6 block water sources
 			moves = 2
 		end
 
 		return moves 									-- facing forward ready for new canal *|>| | |
 	end
 
 	function lib.side(R, maxLength)
 		-- Already in position facing new canal, 2 water buckets
 		local torch = R.length - maxLength					-- start torch count at 1-2 depending on lib.initialise()
 		local sourceCount = 0								-- allow for 1 iteration of placing source blocks when changing from solid to water
 		local numBlocks = 0									-- distance travelled
 		local _, isSource = nil, false						-- initialise variables
 		local oTurn = "R"									-- assume R.side == "L" -> oTurn = "R"
 		if R.side == "R" then								-- R.side = "R"
 			oTurn = "L"										-- oTurn = "L"
 		end
 
 		while numBlocks < maxLength do						-- loop from here. Facing forwards to extend canal
 			torch = torch + 1								-- increase torch spacing interval
 			numBlocks = numBlocks + 1						-- inrease block count
 			if deletesWater then							-- up to and including mc 1.12.2
 				T:forward(1)								-- move forward to extend canal  | |>|
 				_, isSource = T:isWater("down")				-- check if source water below
 				if isSource then
 					sourceCount = sourceCount + 1			-- count source blocks
 				else
 					T:down(1)								-- down to canal floor
 					sourceCount = 0							-- reset
 					T:go("C2", false, 0, false)				-- place block below
 					T:up(1)									-- up to water level
 				end											-- still facing away from canal
 				T:go(R.side.."1F1C2", false, 0, false) 		-- go above towpath, place stone down, facing out
 				if turtle.detectUp() then 					-- ? block above
 					T:go(R.side.."2U1F1D1"..R.side.."2")	-- rotate to face canal, up 1 forward over canal, back down to water level, face towpath
 				else
 					utils.goBack(1)							-- face towpath
 				end
 				-- facing towpath
 				if R.torchInterval > 0 then					-- Are torches required?
 					if torch == R.torchInterval  or numBlocks == 0 then		-- check if ready to place
 						torch = 0							-- reset interval counter
 						T:go("U1F1")
 						T:place("torch", -1, "down")		-- place torch
 						utils.goBack(1)
 						T:down(1)
 					end
 				end											-- facing towpath, above water
 				-- facing towpath
 				if isSource and scoreCount > 0 then
 					T:go(oTurn.."1x0")						-- face new canal direction
 				else										-- not source below, or first time found, ensures continous canal
 					T:go(R.side.."1x0")						-- face back to existing canal
 					T:placeWater("down")					-- place water
 					T:forward(1)							-- forward 1
 					T:placeWater("down")					-- place water
 					utils.getWater() 							-- collects water from below
 					utils.goBack(1) 						-- back 1
 					T:go(oTurn.."1x0")						-- face new canal
 				end
 			else
 				T:forward(1) 								-- move forward to extend canal
 				_, isSource = T:isWater("forward")			-- check if source water ahead
-			T:place("minecraft:obsidian", "down", false)
+
 					sourceCount = sourceCount + 1
 				else
 					sourceCount = 0
 					if not turtle.detectDown() then			-- air / water below, but no source in front, so fill it
 						T:go(oTurn.."1D1")					-- ready to repair neighbouring canal base
 						if T:getBlockType("forward"):find("turtle") ~= nil then -- turtle in similar position
-		T:place("minecraft:obsidian", "down", false)
+
 								sleep(1)
 								T:go("C1")					-- repair neighbouring canal base
 							end
-		T:place("minecraft:obsidian", "down", false)
+
 						else
 							T:go("C1"..R.side.."1")			-- repair neighbouring canal base if air
 						end
 						T:up(1)
 					end
 					T:go("C2", false, 0, false)				-- place block below if not already source
 				end
 				T:go(R.side.."1C1", false, 0, false) 		-- face canal wall, replace with stone
 
 				local placeTorch = false
 				if R.torchInterval > 0 then					-- Are torches required?
 					if torch == R.torchInterval  or numBlocks == 0 then		-- check if ready to place
 						torch = 0							-- reset interval counter
 						placeTorch = true
 					end
 				end
 				if (isSource and placeTorch) or not isSource then
 					T:go("U1x1 U1x1")						-- up 2 and excavate blocks above tow path
 					if placeTorch then						-- torch required
 						T:forward(1)						-- move over towpath
 						T:place("torch", -1, "down")		-- place torch
 						utils.goBack(1)						-- move back
 					end
 					T:down(2)								-- return to canal base
 				end
 				if isSource and sourceCount > 1 then 		-- source ahead found at least once
 					T:go(oTurn.."1")						-- face newcanal as no water refill required
 				else										-- not source in front, or first time found, ensures continous canal
 					T:go(oTurn.."1C1") 						-- *| | | |>| face along new canal and block entrance
 					utils.goBack(1)							-- *| | |>| | back 1
 					T:placeWater("forward")					-- *| | |>|W| place water
 					T:go(oTurn.."2") 						-- *| | |<|W| face existing canal
 					_, isSource = T:isWater("forward")		-- *| |?|<|W| check if source water ahead
 					if not isSource then
 						if not T:placeWater("forward") then	-- place water again *| |W|<|W|
 							while not T:getWater("forward") do -- wait for other turtle
 								print("Out of water buckets")
 								sleep(1)
 							end
 							sleep(0.2)
 							T:getWater("forward")
 						end
 					end
 					utils.getWater() 							-- collects water *| |W|<|W|
 					T:go(R.side.."2F1") 						-- face along new canal *| |W|>|W| to *| |W|W|>|
 				end
 			end
 		end
 	end
 
 	function lib.waterOnly(R, maxLength)
 		-- Already in position facing new canal, 2 water buckets
 		local torch = R.length - maxLength					-- start torch count at 1-2 depending on lib.initialise()
 		local sourceCount = 0								-- allow for 1 iteration of placing source blocks when changing from solid to water
 		local numBlocks = 0									-- distance travelled
 		local _, isSource = nil, false						-- initialise variables
 		local oTurn = "R"									-- assume R.side == "L" -> oTurn = "R"
 		if R.side == "R" then								-- R.side = "R"
 			oTurn = "L"										-- oTurn = "L"
 		end
 
 		while numBlocks < maxLength do						-- loop from here. Facing forwards to extend canal
 			torch = torch + 1								-- increase torch spacing interval
 			numBlocks = numBlocks + 1						-- inrease block count
 			if deletesWater then							-- up to and including mc 1.12.2
 				T:forward(1)								-- move forward to extend canal  | |>|
 				_, isSource = T:isWater("down")				-- check if source water below
 				if isSource then
 					sourceCount = sourceCount + 1			-- count source blocks
 				else
 					T:down(1)								-- down to canal floor
 					sourceCount = 0							-- reset
 					T:go("C2", false, 0, false)				-- place block below
 					T:up(1)									-- up to water level
 				end											-- still facing away from canal
 				if turtle.detectUp() then 					-- ? block above
 					T:go("U1x0")							-- break block above
 				end
 				if not isSource or scoreCount == 0 then		-- not source below, or first time found, ensures continous canal
 					T:go(R.side.."2x0")						-- face back to existing canal
 					T:placeWater("down")					-- place water
 					T:forward(1)							-- forward 1
 					T:placeWater("down")					-- place water
 					utils.getWater() 						-- collects water from below
 					utils.goBack(1) 						-- back 1
 					T:go(R.side.."2")						-- face new canal
 				end
 			else
 				T:forward(1) 								-- move forward to extend canal
 				_, isSource = T:isWater("forward")			-- check if source water ahead
 				if isSource then							-- ? source ahead
-			T:place("minecraft:ladder", "forward", true)
+
 				else
 					sourceCount = 0
 					if not turtle.detectDown() then			-- air / water below, but no source in front, so fill it
 						T:go(oTurn.."1D1")					-- ready to repair neighbouring canal base
 						if T:getBlockType("forward"):find("turtle") ~= nil then -- turtle in similar position
 							if R.side == "L" then			-- only left side repairs, so wait 1 second
 								sleep(1)
 								T:go("C1", false, 0, true)	-- repair neighbouring canal base
 							end
 							T:go(R.side.."1")				-- face forward
 						else
 							T:go("C1"..R.side.."1",false, 0, true)	-- repair neighbouring canal base if air
 						end
 						T:up(1)
 					end
 					T:go("C2", false, 0, false)				-- place block below if not already source
 				end
 				if not isSource then
 					T:go("U1x0D1")							-- up 1 and excavate blocks above canal. return to canal base
 				end
-		T:place("trapdoor", "up", false)
+
 				if not isSource	and sourceCount == 0 then	-- not source in front, or first time found, ensures continous canal
 					T:go("C1", false, 0, true) 				-- *| | | |>| face along new canal and block entrance
 					utils.goBack(1)							-- *| | |>| | back 1
 					T:placeWater("forward")					-- *| | |>|W| place water
 					T:go(oTurn.."2") 						-- *| | |<|W| face existing canal
 					_, isSource = T:isWater("forward")		-- *| |?|<|W| check if source water ahead
 					if not isSource then
 						if not T:placeWater("forward") then	-- place water again *| |W|<|W|
 							while not T:getWater("forward") do -- wait for other turtle
-		Build steps up or down ready for railtrack
+
-		R.depth = headroom, default 2
+
 							end
 							sleep(0.2)
 							T:placeWater("forward")
 						end
 					end
 					utils.getWater() 							-- collects 2 water *| |W|<|W|
 					T:go(R.side.."2F1") 						-- face along new canal *| |W|>|W| to *| |W|W|>|
 				end
 			end
 		end
 	end
 
 	local maxLength = 512
-				--T:go("U1x0 D1x1 F1x0x1 D1x1 C2", false, 0, false)
+
-				T:go("U"..R.depth - 1 .."x0 D"..R.depth - 1 .."x1 F1x0x1 D1x1 C2", false, 0, false)
+
 	end
 	menu.clear()
 	menu.colourWrite("Building canal "..R.side.." side", colors.yellow, nil, nil, false, true)
 	local moves = lib.initialiseCanal(R) -- move to correct position and/or start new canal
-			--T:go("C1U2 x0D1F1", false, 0, false) --put stone in front, up 2 excavate 1, down 1, forward 1
+
-			T:go("C1U"..R.depth.." x0D"..R.depth.."F1", false, 0, false) --put stone in front, up 2 (or headroom) excavate 1, down 1, forward 1
+
 	else -- 4 turtles
 		if R.subChoice == 1 or R.subChoice == 4 then -- towpath
 			lib.towpathOnly(R)
 			--lib.waterCanalTowpath(R, maxLength - moves)
 		else -- main canal only
 			lib.waterOnly(R, maxLength - moves)
 		end
 	end
 
 	return {}
 end
 
 local function createMobGrinder(R)
 	-- go down 5 and create a cavity 9 wide, 5 long, 8 high
 	-- assume facing out from spawner cube at base of exit (6 blocks above ground
 	-- R.subChoice = 1 or 2 (sticky or normal pistons)
 
 	local lib = {}
 
 	function lib.getInventory(R)
 		T:clear()
 		menu.colourPrint("All blocks to be ejected. Ready? Enter", colors.red)
 		read()
 		T:emptyInventory("up")
 		T:checkInventoryForItem({"stone"}, {20}, true, "Match existing walls?")
 		if R.subChoice == 1 then -- sticky pistons
 			T:checkInventoryForItem({"computercraft:computer_normal"}, {1})
 			T:checkInventoryForItem({"minecraft:sticky_piston"}, {2})
 		else
 			T:checkInventoryForItem({"computercraft:computer_normal"}, {2})
 			T:checkInventoryForItem({"minecraft:piston"}, {4})
 			T:checkInventoryForItem({"computercraft:cable"}, {6})
 			T:checkInventoryForItem({"computercraft:wired_modem"}, {2})
 		end
 		T:checkInventoryForItem({"polished"}, {23}, true, "Any polished block")
 		T:checkInventoryForItem({"wall"}, {2}, true, "Any wall block ? match")
 		T:checkInventoryForItem({"slab"}, {7}, true, "Any stone slab. ? polished / match")
 		T:checkInventoryForItem({"minecraft:glass"}, {2})
 		T:checkInventoryForItem({"minecraft:stone_pressure_plate"}, {1})
 		T:checkInventoryForItem({"minecraft:dispenser"}, {1})
 		T:checkInventoryForItem({"hopper"}, {1})
 		T:checkInventoryForItem({"chest"}, {2})
 		T:checkInventoryForItem({"minecraft:redstone"}, {9})
 		T:checkInventoryForItem({"lava"}, {1})
 		R.useBlockType = T:getPolishedItem("")
 		if R.useBlockType == "" then
 			R.useBlockType = T:getMostItem("", true)
 		end
 	end
 
 	function lib.placeRedstone()
 		T:go("D2U2")								-- in left corner facing right
 		T:place("slab", 0, "down")					-- place slab layer 1
 		T:up(2)
 		T:place("slab", 0, "down")					-- place slab layer 2
 		T:up(1)
 		T:place("redstone", 0, "down")
 		T:go("F1D4 C2L1C1 L1U1", false, 0, false)	-- facing ground level slab
 		T:place("redstone", 0, "forward")			-- redstone on ground level slab
 		T:up(1)
 		T:place("slab", 0, "down")					-- slab on layer 1
 		T:up(2)
 		T:place("slab", 0, "down")					-- slab on layer 3
 		T:up(1)
 		T:place("redstone", 0, "down")				-- redstone on layer 3 slab
 		utils.goBack(1)
 		T:down(3)									-- facing layer 1 slab
 		T:place("redstone", 0, "forward")			-- redstone on layer 1 slab
 		T:go("D2C2", false, 0, false)				-- under end of chest position
 		T:place("redstone", 0, "forward")			-- redstone on level 0 floor
 		T:go("R1C1R1", false, 0, false)				-- face right, repair back wall
 		T:go("F1C2 L1C1 R1", false, 0, false)		-- under chest start
 		T:go("F1C2 L1C1 R1", false, 0, false)		-- under hopper
 		T:go("F1C2 L1C1 R1", false, 0, false)		-- under right side wall block
 		T:go("U1L2")								-- ready for redstone
 		for i = 1, 4 do
 			T:place("redstone", 0, "down")			-- redstone under chest etc
 			if i < 4 then
 				T:forward(1)
 			end
 		end
 		-- finishes facing slab at ground level, redstone below
 	end
 
 	function lib.placeStorage()
 		-- starts facing slab at ground level, redstone below
 		T:go("L1F1L2")								-- up and out ready for chest placement
 		T:place("chest", 0, "forward")				-- end chest
 		T:go("R1F1 L1F1 R1U2")						-- at above start chest position facing right
 		T:place("slab", 0, "down")					-- slab above chest
 		T:turnLeft(1)
 		utils.goBack(1)
 		T:down(2)									-- in front of start chest position
 		T:place("chest", 0, "forward")				-- start chest
 		T:go("R1F2L2")								-- at pressure plate position facing left
 		T:place("wall", 0, "forward")				-- place wall
 		T:up(1)
 		T:place("pressure", 0, "down")				-- place pressure plate
 		T:go("R1F1 L1D1")							-- at second wall position
 		T:place("hopper", 0, "forward")				-- place hopper into chest
 		utils.goBack(1)
 		T:place("wall", 0, "forward")				-- place second wall
 		-- finishes on level 1 (ground) facing right side wall block
 	end
 
 	function lib.placePistons(R)
 		-- starts on level 1 (ground) facing right side wall block
 		T:go("U1F2 R1")									-- go over wall block, facing back wall layer 2
 		T:place(R.useBlockType, 0, "forward", false)	-- replace back wall with polished block layer 2
 		T:up(1)											-- layer 3
 		T:place(R.useBlockType, 0, "forward", false)	-- replace back wall with polished block layer 3
 		T:turnRight(1)									-- face right side
 		if R.subChoice == 1 then						-- use sticky pistons x 2
 			T:place(R.useBlockType, 0, "forward", false)-- polished block above second wall layer 3
 			T:go("R2F1")								-- ready to place lower piston (works ok as slab already in place behind it)
 		else
 			T:go("F2R2")								-- move forward 2 and face left
 			T:place("piston", 0, "forward")				-- lower replacer piston placed
 			T:go("U1F2D1F1")							-- go up and over piston forward 1 ready for other piston
 		end
 		T:place("piston", 0, "forward")					-- lower piston placed
 		utils.goBack(1)
 		T:go("U1R1")									-- layer 4
 		T:place(R.useBlockType, 0, "forward", false)	-- polished block back wall layer 4
 		T:go("L1F2R2")									-- head left ready for dispenser
 		T:place("dispenser", 0, "forward")				-- dispenser placed
 		T:dropItem("lava", "forward")					-- drop lava bucket into dispenser
 		T:go("U1F2 D1")									-- up and over dispenser, facing right side
 		T:place("slab", 0, "down")						-- lower piston slab placed
 		if R.subChoice == 1 then
 			T:place(R.useBlockType, 0, "forward", false)-- polished block above second wall layer 4
 			T:turnLeft(1)								-- facing back wall
 		else
 			T:go("F1L1")								-- at second computer position, facing back wall
 			utils.goBack(1)								-- ready to place computer
 			T:place("computercraft:computer_normal", 0, "forward", false)	-- place computer
 			T:go("L1F1R1F1")							-- facing back wall in mob drop, level 4
 		end
 		T:place(R.useBlockType, 0, "forward", false)	-- polished block back wall layer 4
 		T:turnLeft(1)
 		T:go("U1F3R2")									-- level 5 ready for upper piston
 		T:place("piston", 0, "forward")					-- upper piston placed
 		T:go("U1F3D1R2")								-- up and over piston, facing left, level 5
 		T:turnRight(1)									-- at mob drop, facing wall, level 5
 		T:place(R.useBlockType, 0, "forward", false)	-- polished block back wall layer 5
 		T:turnRight(1)									-- facing right side
 		if R.subChoice == 1 then
 			T:place(R.useBlockType, 0, "forward", false)-- right side polished block layer 5, facing right side, in mob drop 							-- layer 5 facing left side, in mob drop
 		else
 			T:go("F1C1")								-- move forward, place temporary block
 			utils.goBack(1)
 			T:place("piston", 0, "forward")				-- upper replacer piston placed
 		end
 		T:turnRight(2)
 		T:place("slab", 0, "forward")					-- upper piston slab placed
 		T:turnLeft(1)									-- facing away from back wall
 	end
 
 	function lib.placeComputer(R)
 		-- starts facing away from back wall, layer 5, in mob drop
 		T:go("F1R1 F2R1 D1")							-- move to left computerposition, facing back wall, layer 4
 		T:place("computercraft:computer_normal", 0, "forward", false)		-- place computer in gap, layer 4
 	end
 
 	function lib.placeColumnSection(direction)
 		T:place(R.useBlockType, 0, "forward", false)
 		T:go(direction.."1")
 		T:place(R.useBlockType, 0, "forward", false)
 		T:go(direction.."1")
 		T:place(R.useBlockType, 0, "forward", false)	-- facing right
 	end
 
 	function lib.placeColumns(R)
 		-- starts facing left computer, layer 4
 		T:go("R1F2 L1")									-- facing mob drop level 4
 		T:place("glass", 0, "down", false)
 		T:up(1)											-- facing mob drop level 5
 		T:place("glass", 0, "down", false)				-- on top of glass facing back wall at dungeon base level 5
 		T:up(1)
 		T:place(R.useBlockType, 0, "down", false)		-- level 6 dungeon exit
 		T:go("F1L1")
 		lib.placeColumnSection("L")						-- facing right
 		T:up(1)
 		lib.placeColumnSection("R")						-- facing left
 		T:up(1)
 		lib.placeColumnSection("L")						-- facing right
 		T:up(1)
 		lib.placeColumnSection("R")						-- facing left
 		T:up(1)
 		T:place(R.useBlockType, 0, "forward", false)
 		T:turnLeft(2)
 		T:place(R.useBlockType, 0, "forward", false)	-- facing right
 		T:turnLeft(1)									-- at top of column
 		T:go("x1D1 x1D1 x1U2")							-- open exit for mobs
 		utils.goBack(2)
 		T:place(R.useBlockType, 0, "forward", false)
 		T:down(9)
 	end
 
 	function lib.placeNetwork()
 		T:go("R1F2L1 F3U3 F1L1F1 L1x1")								-- go behind second computer and remove block
 		T:place("computercraft:wired_modem", 0, "forward", false)	-- place modem
 		utils.goBack(1)
 		T:place("computercraft:cable", 0, "forward", false)			-- place network cable
 		T:place("computercraft:cable", 0, "forward", false)			-- place network cable (no need to move)
 		T:go("R1F1 x2L1")											-- move forward, face back wall
 		T:place("computercraft:cable", 0, "forward", false)
 		T:go("R1F1 x2L1")
 		T:place("computercraft:cable", 0, "forward", false)
 		T:go("R1F1 x2L1F1 x1x2")									-- come behind left computer and expose back
 		T:place("computercraft:wired_modem", 0, "forward", false)	-- place modem
 		utils.goBack(1)
 		T:place("computercraft:cable", 0, "forward", false)
 		T:place("computercraft:cable", 0, "forward", false)
 		T:go("L1D3 F4R1 F3U4 D4")									-- removes temporary block
 	end
 
 	local tempSubChoice = R.subChoice	-- store for later use
 	R.width = 4							-- settings for createFloorCeiling()
 	R.length = 9
 	R.height = 0
 	R.up = true
 	T:turnRight(2)
 	local isWater, isSource, isIce, level, isAir = T:isWater("forward")
 	if not isWater then
 		T:turnRight(2)
 		return{"Not in correct position. Must be water behind"}
 	end
 	--T:go("U1x1 U1L1 F4R2")					-- go up to starting point
 	T:go("U2L1 F4R2")					-- go up to starting point
 	local data = createFloorCeiling(R)[1] 	-- place ceiling, returns to starting position. if water or lava present is returned as "water or lava found"
 	if data == "water or lava found" then
 		R.height = 10
 		R.silent = true
 		T:up(1)
 		createSinkingPlatform(R)
 		T:go("F4L1 U5x1 U1x1 U3R1 F4C0 R1F3C0 R1F8C0 R1F3C0 R1D9") 			-- re-open exit hole, return to floor level
 	else -- no water or lava found so empty out area
 		R.height = 10
 		R.subChoice = 2
 		clearSolid(R) -- 76
 		T:down(R.height - 1)
 		R.width = 4							-- settings for createFloorCeiling()
 		R.length = 9
 		R.height = 0
 		R.down = true
 		R.up = false
 		R.subChoice = 1						-- replace existing floor
 		createFloorCeiling(R)
 	end
 
 	R.subChoice = tempSubChoice
 	lib.getInventory(R)
 	lib.placeRedstone()
 	lib.placeStorage()
 	lib.placePistons(R)
 	lib.placeComputer(R)		-- ends facing computer
 	lib.placeColumns(R)
 	if R.subChoice == 2 then
 		lib.placeNetwork()
 	end
 
 	return {}
 end
 
 local function sandFillArea(R) -- 81
 	--clearRectangle with sand drop
 	-- could be 1 wide x xx length (trench) up and return
 	-- could be 2+ x 2+
 	-- even no of runs return after last run
 	-- odd no of runs forward, back, forward, reverse and return
 	local success
 	local directReturn = true
 	if R.width % 2 == 1 then
 		directReturn = false
 	end
 	if R.width == 1 then -- trench ahead, so fill then return
 		for i = 1, R.length - 1 do
 			success = utils.dropSand()
 			T:forward(1, false)
 		end
 		success = utils.dropSand()
 		T:go("R2F"..(R.length - 1).."R2", false, 0, false)
 	else --2 or more columns
 		if directReturn then -- R.width = 2,4,6,8 etc
 			for i = 1, R.width, 2 do -- i = 1,3,5,7 etc
 				-- move along R.length, dropping sand
 				for j = 1, R.length - 1 do
 					success = utils.dropSand()
 					T:forward(1, false)
 				end
 				success = utils.dropSand()
 				T:go("R1F1R1") --turn right and return on next column
 				for j = 1, R.length - 1 do
 					success = utils.dropSand()
 					T:forward(1, false)
 				end
 				success = utils.dropSand()
 				if i < R.width - 2 then -- eg R.width = 8, i compares with 6: 1, 3, 5, 7
 					T:go("L1F1L1")
 				end
 			end
 			T:go("R1F"..R.width - 1 .."R1") --return home
 		else
 			for i = 1, R.width, 2 do -- i = 1,3,5,7 etc
 				-- move along R.length, dropping sand
 				for j = 1, R.length - 1 do
 					success = utils.dropSand()
 					T:forward(1, false)
 				end
 				success = utils.dropSand()
 				T:go("R1F1R1") --turn right and return on next column
 				for j = 1, R.length - 1 do
 					success = utils.dropSand()
 					T:forward(1, false)
 				end
 				success = utils.dropSand()
 				T:go("L1F1L1")
 			end
 			-- one more run then return
 			for j = 1, R.length - 1 do
 				success = utils.dropSand()
 				T:forward(1, false)
 			end
 			success = utils.dropSand()
 			T:go("R2F"..R.length.."R1F"..R.width - 1 .."R1")
 		end
 	end
 	return {}
 end
 
 local function deactivateDragonTower() -- 45
 	-- go up centre of tower to bedrock
 	local height = 0
 	--numBlocksMoved, errorMsg = clsTurtle.doMoves(self, numBlocksRequested, direction)
 	local numBlocks, message = T:doMoves(1, "up")
 	while message == nil do
 		numBlocks, message = T:doMoves(1, "up")
 		height = height + 1
 	end
 	-- go round bedrock and destroy crystal
 	T:go("F1R2U2x1U1x1")
 	-- return to start
 	T:down(height + 5)
 	return {}
 end
 
 local function undermineDragonTowers() -- 44
 	--[[
 	        -13, -40....12, -40						NNW (4)   	NNE (5)
 
 	    -34, -25............33, -25				NWW	(2)				NEE (9)
 
 	-42, -1....................42, 0		W (1)						E (8)
 
 	     -34, 24............33,24				SWW	(3)				SEE (10)
 
 		      -13,39....12, 39						SSW	(7)		SSE (6)
 
 	North towers centres 25 blocks apart, 40 blocks north of axis
 	Mid-North towers 67 blocks apart, 25 blocks north of axis
 	W-E centres 84 blocks apart, on 0 axis
 	Mid-south towers 67 blocks apart, 24 blocks south of axis
 	South towers centres 25 blocks apart, 39 blocks south of axis
 	]]
 
 	local lib = {}
 	function lib.findNextTower(maxDistance, withMarker)
 		local distance = 0
 		local blockTypeF = T:getBlockType("forward")
 		local blockTypeD = T:getBlockType("down")
 		for i = 1, maxDistance do
 			if blockTypeF ~= "minecraft:obsidian" and blockTypeD ~= "minecraft:obsidian" then -- not in a tower
 				if withMarker and blockTypeD ~= "minecraft:obsidian" then -- used to mark 0 coordinate
 					T:place("cobble", -1, "down", false) -- place cobblestone or cobbled deepslate to mark zero coordinate
 				end
 			else	-- obsidian found, could still be in an earlier tower
 				if i > 10 then
 					break
 				end
 			end
 			T:go("F1x0")
 			distance = distance + 1
 			blockTypeF = T:getBlockType("forward")
 			blockTypeD = T:getBlockType("down")
 		end
 		if distance == maxDistance then -- obsidian not found ? wrong place/ direction
 			print("Obsidian not found")
 			error()
 		end
 		-- will now be at side of a tower
 		lib.findCentre() -- move into tower to find the other side
 		return distance
 	end
 
 	function lib.findCentre()
 		local width = 0
-			T:place("slab", "down", false)
+
 		local blockTypeF = T:getBlockType("forward")
 		local blockTypeD = T:getBlockType("down")
 		while blockTypeF == "minecraft:obsidian" or blockTypeD == "minecraft:obsidian" do
 			T:go("F1x0")
 			width = width + 1
 			blockTypeF = T:getBlockType("forward")
 			blockTypeD = T:getBlockType("down")
 		end
 		-- will always go outside the tower 1 block. width of 5 block tower = 6
 		T:go("R2F"..math.ceil(width / 2)) --return to centre of tower
 		T:turnLeft(1) -- now find another edge of the tower, dig forward until out of obsidian
 		for i = 1, math.ceil(width) do  -- give additional loops if missed centre
 			blockTypeF = T:getBlockType("forward")
 			blockTypeD = T:getBlockType("down")
 			if blockTypeF == "minecraft:obsidian" or blockTypeD == "minecraft:obsidian" then
 				T:go("F1x0")
 			else
 				break
 			end
 		end
 		-- now outside different edge of the tower
 		-- reverse and move width/2, dig up + 1 to mark centre, face original direction
 		T:go("L2F"..math.ceil(width / 2).."R1U2x1")
 		T:place("minecraft:end_stone", -1, "forward", false) -- place endstone to mark facing direction
 		T:down(2)
 	end
 
 	function lib.findPath(maxLength)
 		local blockTypeD = T:getBlockType("down")
 		local distance = 0
 		while blockTypeD:find("cobble") == nil and distance < maxLength do
 			T:go("F1x0")							-- return to 0 axis,
 			distance = distance + 1
 			blockTypeD = T:getBlockType("down")
 		end
 		return distance
 	end
 
 	-- start at 0,y,0, facing West
 	T:dig("up")									-- in case not already done
 	local maxLength = 0
 	local blockTypeD
 	local distance = lib.findNextTower(45, true)-- find W tower (1) and mark trail with cobble
 	T:turnRight(2)
 	for i = 1, 8 do								-- head back East 8 blocks, turn left (facing north)
 		T:go("F1x0")							-- this path may be off-axis, so dig double height
 	end
 	T:turnLeft(1)
 	lib.findNextTower(30)						-- find NWW tower (2)
 	T:turnRight(2)
 	distance = lib.findPath(30)
 	distance = distance + lib.findNextTower(30)	-- find SWW tower (3)
 	T:turnRight(2)
 	distance = lib.findPath(30)
 	T:turnRight(1) 								-- should be on cobble path
 	for i = 1, 21 do							-- move East 21 blocks, turn left facing North
 		T:go("F1x0")
 	end
 	T:turnLeft(1)
 
 	distance = lib.findNextTower(45)		-- find NNW tower (4)
 	T:turnRight(1)
 	distance = lib.findNextTower(30)		-- find NNE tower (5)
 	T:turnRight(1)
 	distance = lib.findNextTower(85)		-- find SSE tower (6)
 	T:turnRight(1)
 
 	distance = lib.findNextTower(30)		-- find SSW tower (7)
 	T:turnRight(1)
 	distance = lib.findPath(40)				-- head North to 0 axis
 	T:go("R1F13") 							-- return to 0,0 facing East
 	distance = lib.findNextTower(45, true)	-- find E tower (8)
 
 	T:turnRight(2)
 	for i = 1, 9 do
 		T:go("F1x0")						-- this path may be off-axis, so dig double height
 	end
 	T:turnRight(1)
 
 	distance = lib.findNextTower(30)		-- find NEE tower (9)
 	T:turnRight(2)
 	distance = lib.findPath(30) -- return to 0 axis
 	distance = lib.findNextTower(30)		-- find SEE tower (10)
 	T:turnRight(2)
 	distance = lib.findPath(30) 			-- return to 0 axis
 	T:go("L1F33")							-- return to 0, 0
 
 	return {}
 end
 
 local function demolishPortal(R) -- 43
 	--[[
 	R.length = length of portal NOT width default 4
 	R.height = height of portal default 5
 	R.width = thickness of portal default 1
 	R.data = "bury" to embed bottom into ground
 	R.subChoice 1 = facing portal, 2 = aligned
 	]]
 	local data = R.data
 	if R.subChoice == 1 then -- facing portal
 		T:go("F"..R.width.."R1")
 	else
 		T:forward(1)
 	end
 	if R.data == "bury" then
 		T:down(1)
 	end
 
 	R.data = "up"
 	R.silent = true
 	if R.width == 1 then
 		clearWall(R)
 	else
 		clearBuilding(R, true, true)
 	end
 	if data == "bury" then
 		T:up(1)
 	end
 	if R.subChoice == 1 then -- facing portal
 		T:go("R1F1L1F1L1")
 	end
 
 	return {}
 end
 
 local function digTrench(R) -- 77
 	local blockType
 	-- go down R.height, move forward
 	if R.length == 0 then
 		R.length = 4096 -- will go out of loaded chunks and stop or max 4096 on a server
 	end
 	for i = 1, R.length do
 		local count = 0
 		for down = 1, R.height do
 			blockType = T:isWaterOrLava("down")
 			-- go down only if no water or lava below
 			if blockType:find("water") == nil and blockType:find("lava") == nil then
 				T:down(1)
 				count = count + 1
 			end
 		end
 		T:go("C2", false, 0, true)				-- if empty below fill void
 		T:go("U"..count)						-- return to surface, continue if block above
 		while turtle.detect() do				-- go up while block in front
 			blockType = T:getBlockType("forward")
 			if T:isVegetation(blockType) then
 				T:dig("forward")
 				break
 			elseif blockType:find("log") ~= nil then
 				T:harvestTree("forward", false)
 			else
 				T:up(1)
 			end
 		end
 		T:forward(1)							-- move forward
 		while not turtle.detectDown() do		-- go down until block detected
 			blockType = T:isWaterOrLava("down")
 			if blockType:find("water") == nil and blockType:find("lava") == nil then
 				T:down(1)
 			else
 				break
 			end
 		end
 	end
 
 	return {}
 end
 
 local function harvestTreeFarm(R) -- 24
 	local lib = {}
 
 	function lib.getLogCount()
 		local count = 0
 		for i = 1,16 do
 			local item, itemCount = T:getSlotContains(i)
 			if item:find("log") ~= nil then
 				count = count + itemCount
 			end
 		end
 
 		return count
 	end
 
 	function lib.initialise()
 		local blockType = T:getBlockType("forward")
 		local logType = ""
 		local startHeight = 0
 		local range = 0
 		if blockType == "" then
 			while turtle.forward() do
 				range = range + 1
 				if range == 3 then
 					break
 				end
 			end
 		end
 		blockType = T:getBlockType("forward")
 		if blockType:find("dirt") ~= nil then
 			T:up(1)
 			startHeight = 1
 		else
 			if blockType:find("log") ~= nil or blockType:find("sapling") ~= nil then
 				logType = blockType
 			end
 		end
 
 		return logType, startHeight
 	end
 
 	R.silent = true
 	local treeType, startHeight = lib.initialise() -- possible ID tree type + move to correct position 1 above dirt
 
 	T:forward(1)	-- dig first log/sapling/ air if not planted
 	clearRectangle({width = 7, length = 7, up = true, down = true})
 	T:go("L1F2L1F2R2")
 	local height = 0
 	local pastLogCount = -1
 	local currentLogCount = lib.getLogCount()
 	while currentLogCount ~= pastLogCount do
 		T:up(3)
 		height = height + 3
 		pastLogCount = currentLogCount -- 0 when loop starts
 		clearRectangle({width = 12, length = 12, up = true, down = true})
 		currentLogCount = lib.getLogCount() -- eg 20 logs from first round
 	end
 	T:down(height + startHeight)
 	T:go("R1F2R1F2R2")
 
 	return {}
 end
 
 local function harvestObsidian(R) -- 41
 	local lib = {}
 
 	function lib.forward(move)
 		T:isWaterOrLava("forward")	-- automatically use lava ahead to refuel
 		T:isWaterOrLava("down") 	-- automatically use lava down to refuel
 		T:go("C2", false, 0, false)	-- place / replace block below
 		if move then
 			T:forward(1)
 		end
 	end
 
 	function lib.home(outward)
 		if outward then
 			T:go("L1F"..R.width - 1 .."L1F"..R.length - 1)
 		else
 			T:go("R1F"..R.width - 1 .."R1")
 		end
 	end
 
 	function lib.start()
 		local lavaSlot = T:getItemSlot("lava")
 		if lavaSlot > 0 then
 			turtle.select(slot)
 			turtle.refuel()
 		end
 		T:down(1)
 	end
 
 	local outward = true
 
 	lib.start()						-- use lava bucket if placed, move down into block below
 	for w = 1, R.width do
 		for l = 1, R.length do
 			if l < R.length then
 				lib.forward(true)
 			else
 				lib.forward(false)
 			end
 		end
 		if w < R.width then
 			if outward then
 				T:go("R1F1R1")
 			else
 				T:go("L1F1L1")
 			end
 			outward = not outward
 		end
 	end
 
 	lib.home(outward)
 
 	return {}
 end
 
 local function harvestShulkers(R)
 	local lib = {}
 
 	function lib.attackAll()
 		return turtle.attack(), turtle.attackUp(), turtle.attackDown()
 	end
 
 	function lib.attack()
 		local forward, up, down = lib.attackAll()
 		while forward or up or down do
 			forward, up, down = lib.attackAll()
 			sleep(0.2)
 		end
 	end
 
 	function lib.approach(direction, limit, dig)
 		-- move forward until stopped by shulker
 		limit = limit or 64
 		dig = dig or false
 		local count = 0
 		local solidDown = false
 		move = turtle.forward
 		if direction == "up" then
 			move = turtle.up
 		elseif direction == "down" then
 			move = turtle.down
 		end
 		local forward, up, down = lib.attackAll()
 		if forward or up or down then -- attacks suceeded
 			return true, 0, solidDown
 		else
 			while move() do
 				count = count + 1
 				if turtle.detectDown() then
 					solidDown = true
 				end
 				if count >= limit then
 					return false, count, solidDown
 				end
 				forward, up, down = lib.attackAll()
 				if forward or up or down then
 					return true, count, solidDown
 				else
 					if dig then
 						T:dig("forward")
 					end
 				end
 			end
 			return false, count, solidDown
 		end
 	end
 
 	function lib.home(direction, moves)
 		local move = turtle.back
 		if direction == "up" then
 			move = turtle.down
 		elseif direction == "down" then
 			move = turtle.up
 		end
 		for i = 1, moves do
 			move()
 		end
 	end
 
 	function lib.checkPosition()
 		if T:detect("forward") then			-- wall in front
 			T:turnRight(1)
 			if T:detect("forward") then		-- wall to right
 				T:turnLeft(1)
 				return true					-- position corrected
 			else
 				T:turnLeft(2)
 				if T:detect("forward") then	-- wall in front. position correct
 					return true
 				end
 			end
 		end
 		return false
 	end
 
 	function lib.getLength()
 		local count = 0
 		while turtle.detectDown() do
 			count = count + 1
 			T:forward(1)
 		end
 		utils.goBack(1)
 		return count
 	end
 
 	function lib.clearWall()
 		local distance = 0
 		while distance < 9 do	-- smallest external walls are 8 x 8
 			local success, count = lib.approach("forward", 8 - distance)
 			if success then
-			--T:place("stone", "forward", false) -- place does not allow for specific blocktype
+
 			end
 			distance = distance + count
 		end
 		T:turnLeft(1)
 		if T:detect("forward") then	-- larger than 8 blocks
 			T:turnRight(1)
 			while distance < 14 do	-- larger builds are 14 x 14
 				local success, count = lib.approach("forward", 13 - distance)
 				if success then
 					lib.attack()
 				end
 				distance = distance + count
 			end
 			T:go("L1x2")
 		end
 	end
 
 	function lib.roof()
 		-- check position
 		local doContinue = lib.checkPosition()
 
 		if doContinue then
 			T:go("U2F3 R1F3 R1")
 			local length = lib.getLength()
 			local width = 1
 			local outward = lib.turnRound(true)
 			local success, count, onRoof = false, 0, true
 			while onRoof do
 				local distance = 0
 				while distance < length - 1 do
 					success, count, onRoof = lib.approach("forward", length - 1 - distance)
 					if success then
 						lib.attack()
 					end
 					if count == 0 then
 						turtle.dig()
 					end
 					distance = distance + count
 				end
 				width = width + 1
-				T:place("minecraft:torch", "down")
+
 			end
 			if outward then
 				T:go("F".. 3 .."L1F"..width - 3 .."D2L1")
 			else
 				T:go("F".. length - 3 .."R1F"..width - 3 .."D2L1")
 			end
 			return {}
 		else
 			return {"Turtle not in front of a wall"}
 		end
 	end
 
 	function lib.turnRound(outward)
 		if outward then
 			T:go("R1F1R1")
 		else
 			T:go("L1F1L1")
 		end
 		return not outward
 	end
 
 	function lib.upAndOver()
 		local start, height, forward = 0, 0, 0
 		while turtle.detect() do
 			turtle.up()
 			start = start + 1
 		end
 		while turtle.forward() do
 			forward = forward + 1
 		end
 		turtle.turnRight()
-	function lib.buildWallSection(section, useBlockType)
+
-		-- build a layer 1 block high below turtle
+
-		for i = 1, #section do
+
-			local block = section:sub(i, i)
+
-			if block == "l" then
+
-				T:place("log", "down")
+
-			elseif block == "m" then
+
-				T:place("modem", "down")
+
-			elseif block == "b" then
+
-				T:place("barrel", "down")
+
-			elseif block == "c" then
+
-				T:place("cable", "down")
+
 		end
-				T:place(useBlockType, "down")
+
 		for i = 1, forward do
-			if i < #section then
+
 		end
 		for i = 1, start do
 			turtle.down()
 		end
 		T:turnRight(2)
 	end
 
-			while turtle.digUp() do end
+
-			turtle.digDown()
+
-			T:place(useBlockType, "down")
+
-			--T:go("x0C2", false, 0, false, useBlockType)
+
 			for i = 1, 4 do
-				while not turtle.forward() do
+
-					turtle.dig()
+
 			T:go("F2L1 U1F2 R2")
-				--T:forward(1)
+
 			return {"Turtle not in front of a wall"}
 		end
 	end
 
 	local direction = "forward"
 	local doContinue = false
 
 	if R.subChoice == 1 then		-- Shulker is above
 		direction = "up"
 		doContinue = true
 	elseif R.subChoice == 2 then	-- Shulker is ahead
 		doContinue = true
 	elseif R.subChoice == 3 then	-- Shulker is below
 		direction = "down"
 		doContinue = true
 	else
 		if R.subChoice == 4 then	-- Climb tower wall
 			lib.upAndOver()
 		elseif R.subChoice == 5 then	-- Clear roof above
 			return lib.roof()
 		elseif R.subChoice == 6 then	-- Clear outside walls
 			lib.walls()
 		end
 
 	end
 	if doContinue then
 		local success, moves = lib.approach(direction, 64)
 		if success then
 			lib.attack()
 		end
 		lib.home(direction, moves)
 	end
-	function lib.findLegacyStart()
+
 	return {}
-		local block = T:getBlockType("down")
+
-		if block:find("polished") ~= nil then
+
-			return ""	-- in correct position, facing centre of front wall
+
 	local lib = {}
-		-- assume on left corner
+
-		T:forward (1)
+	function lib.checkEquipment()
-		local couint = 0
+		--[[ Needs pickaxe and hoe equipped ]]
-		while (T:getBlockType("down")):find("polished") == nil do
+
 		--T:checkInventoryForItem(items{}, quantities{}, required, message)
 		print("Checking equipment. Please wait...")
-			if count > 10 then
+		local equippedRight, equippedLeft, inInventory = T:setEquipment() -- any tools equipped except diamond_pickaxe and crafting_table have been removed to inventory
-				return "Unable to locate polished block"
+		--[[if equippedRight ~= "minecraft:crafting_table" then
 			T:checkInventoryForItem({"minecraft:crafting_table"}, {1})
 			local equippedRight, equippedLeft = T:setEquipment()
 		end]]
 		T:suck("down")		-- if hoe already in storage get it out
 		if inInventory ~= "minecraft:diamond_hoe" then
-	function lib.floodFarm(R)
+			if T:getItemSlot("minecraft:diamond_hoe") > 0 then
 				return true
-		T:sortInventory(false)
+
-		for i = 1, R.width - 2 do
+				T:checkInventoryForItem({"minecraft:diamond_hoe"}, {1}, true, "Diamond Hoe required for planting!")
-			lib.placeFloor(R.length - 2, R.useBlockType)
+
-			if i < R.width - 2 then
+
-				outward = lib.turn(outward)
+		if T:getItemSlot("minecraft:diamond_hoe") > 0 then
 			return true
 		end
-		T:go("U1R2") -- over 13 x 13 internal area opposite corner
+
-		-- now add corners
+
-		lib.placeCorners(R.length - 2, 4, R.useBlockType)
+
-		outward = lib.turn(outward)
+
-		lib.placeCorners(R.length - 2, 3, R.useBlockType)
+
-		outward = lib.turn(outward)
+		--[[ first function called on start]]
-		lib.placeCorners(R.length - 2, 2, R.useBlockType)
+		local atHome = false
-		outward = lib.turn(outward)
+
-		lib.placeCorners(R.length - 2, 1, R.useBlockType)
+		print("Checking position "..blockType.. " below")
 		if blockType:find("water") ~= nil then -- over water
-			T:go("R1F"..R.width - 9 .."R1")
+			if lib.isStorage("forward") then
 				atHome = true
-			T:go("L1F"..R.width - 9 .."L1")
+
 				if lib.isStorage("forward") then-- confirms in correct position, back to crops
 					T:turnRight(2)
-		lib.placeCorners(R.length - 2, 1, R.useBlockType)
+				else -- facing crafting table
-		outward = lib.turn(outward)
+
-		lib.placeCorners(R.length - 2, 2, R.useBlockType)
+
-		outward = lib.turn(outward)
+			else -- not a chest: facing crops or crafting table
-		lib.placeCorners(R.length - 2, 3, R.useBlockType)
+
-		outward = lib.turn(outward)
+				if lib.isStorage("forward") then -- confirms was facing crops
-		lib.placeCorners(R.length - 2, 4, R.useBlockType) -- should be back in starting corner facing front
+					atHome = true
 					T:turnLeft(1)
-		T:go("U1R1")
+
-		lib.placeWater(R.length - 3) -- place water down then move forward, turn right
+
-		lib.placeWater(R.width - 3)
+			-- should now be facing crops. may be crafting table to left
-		lib.placeWater(R.length - 3)
+
-		lib.placeWater(R.width - 3)
+		return atHome-- now facing crops
-		T:go("F".. math.floor((R.length - 2) / 2).."R1F".. math.floor((R.width - 2) / 2)) -- should be in centre
+
 
-		--T:go("D6x2 F1x2 F1x2 F1x2 F1x2 F1x2 F1x2 F1x2 F1x2 F1x2 R1F7 R1U1")
+	function lib.crossFarm()
-		T:go("D6F7 R1F7 R1U1") -- end facing back at left corner, 1 block above floor/1 below ceiling
+
 		local blockType = ""
 		local isReady, cropType, status = lib.isCropReady("down")
-	function lib.clearBasement()
+		-- will go forward until chest or cobble detected below
-		T:sortInventory(false)
+
-		T:dropItem("seeds", "forward")
+
-		T:dropItem("flint", "forward")
+
-		clearRectangle({width = 15, length = 15, up = true, down = true})
+
-		-- area has been cleared. starts facing back, 1 block above ground, 1 block below ceiling
+			blockType = T:getBlockType("down", -1)
 			if blockType == "" or cropType ~= "" then --crops or nothing below
-		for i = 1, 14 do	-- place cable into gutter beneath front of farm
+
-			T:place("cable", "up")
+			elseif  blockType:find("barrel") ~= nil or blockType:find("chest") ~= nil or blockType:find("cobble") ~= nil then
-			if i < 14 then
+
 			end
 			numMoves = numMoves + 1
 		end
-		-- ends right side facing right, just below ceiling
+		return blockType -- either chest or cobble
 	end
 
 	function lib.farmInFront()
 		--[[ facing crops on first farm. move to next farm in front ]]
 		T:go("U1L1F11D1R1")							-- on next farm, facing crops
-	-- R.data = "new", "left", "right" or "back" to extend tree farm
+		local crop = lib.manageTree()				-- refuel, gather seeds and other crops
 		local isFarmToRight, _ = lib.harvest(crop)	-- harvest field, store crops
-	-- R.networkFarm to create storage area
+		return isFarmToRight
 	end
 
 	function lib.farmToRight()
-	-- R.data = "new", "left", "right", "back", "convertStorage", "convert"
+
-	if R.data == "new" then -- new treeFarm, Start at current position
+		T:go("U1F11 D1")				-- on next farm, facing crops
-		-- build 4 wall sections in 2 passes
+		local crop = lib.manageTree()	-- refuel, gather seeds and other crops
 		lib.harvest(crop)				-- harvest field, store crops
-		lib.buildWallSection("---------------", R.useBlockType)		-- left wall (15 blocks)
+
-		T:go("R1F1")
+
 	function lib.getCrops()
-			lib.buildWallSection("--------------", R.useBlockType)	-- back/ right wall (14 blocks)
+
 
 		if lib.isStorage("forward") then
-		lib.buildWallSection("------c------", R.useBlockType)		-- front wall (14 blocks) c = network cable
+			lib.getSeeds("forward")
 		end
-		lib.buildWallSection("---------------", R.useBlockType)		-- left wall top (15 blocks)
+
-		T:go("R1F1")
+		if lib.isStorage("forward") then
 			lib.getVeg("forward")
-			lib.buildWallSection("--------------", R.useBlockType)	--back/right wall (14 blocks)
+
 		T:turnRight(2)
 	end
-		--lib.buildWallSection("-----lmb-----", R.useBlockType)	--front wall (14 blocks) log/modem/barrel
+
-		lib.buildWallSection("-----lmb", R.useBlockType)
+	function lib.getSaplings(direction)
 		--[[ get a single sapling from the chest ]]
-		network.attachModem()
+
 			direction = "forward"
-		lib.buildWallSection("-----", R.useBlockType)
+
-		T:go("R1F1 D2") -- over 13 x 13 internal area
+		while T:suck(direction, 1) do end -- remove saplings/ seeds
-	elseif R.data == "left" or R.data == "right" or R.data == "back" then
+
-		-- build 3 wall sections in 2 passes
+		T:dropItem("sapling", direction, 1) -- drop all but 1 saplings
-		if R.data == "left" then										-- should be on left corner of existing
+		if not T:dropItem("seeds", direction, 0) then-- drop all seeds
-			T:go("L1F1 D1") 											-- move left 1 blocks, down 1: <-
+			T:dropItem("seeds", "up", 0)
-			lib.buildWallSection("------c-------", R.useBlockType)		-- front wall (14 blocks) c = network cable <-
+
 
-			lib.buildWallSection("--------------", R.useBlockType)		-- left wall (14 blocks) ^
+		return T:getItemSlot("sapling", -1)
 	end
-			lib.buildWallSection("-------------", R.useBlockType)		-- back wall (13 blocks) ->
+
-			T:go("U1R2")												-- turn round ready to add next layer <-
+	function lib.getSeeds(direction)
-			lib.buildWallSection("--------------", R.useBlockType)		-- back wall top (14 blocks) <-
+		--[[ get 1 stack of wheat seeds or 1 stack of beetroot seeds ]]
 		print("Collecting seeds from storage")
-			lib.buildWallSection("--------------", R.useBlockType)		-- left wall top (14 blocks) v
+		while T:suck(direction, 1) do end -- remove saplings/ seeds
 		T:dropItem("sapling", direction, 0) -- drop all saplings
-			lib.buildWallSection("-----bm", R.useBlockType)				-- front wall (7 blocks) barrel/modem ->
+		T:dropItem("minecraft:wheat_seeds", direction, 64) -- drop all but 64 seeds
-			network.attachModem()
+		T:dropItem("minecraft:beetroot_seeds", direction, 64)
 		local crop = ""
-			lib.buildWallSection("l-----", R.useBlockType)				-- front wall (5 blocks) log ->
+		if T:getItemSlot("minecraft:wheat_seeds", -1) > 0 then
-			T:go("R2F12 R1F1 D2") 										-- over 13 x 13 internal area lower left side
+			crop = "wheat"
-		elseif R.data == "right" then									-- should be on right corner of existing
+			print("Field crop = "..crop)
-			T:go("R1F1 D1") 											-- move right, forward, down 1
+		elseif T:getItemSlot("minecraft:beetroot_seeds", -1) > 0 then
-			lib.buildWallSection("------c-------", R.useBlockType)		-- front wall (14 blocks) c = network cable
+			crop = "beetroot"
 			print("Field crop = "..crop)
-			lib.buildWallSection("--------------", R.useBlockType)		-- right wall (14 blocks)
+
 
-			lib.buildWallSection("-------------", R.useBlockType)		-- back wall (13 blocks)
+		return crop
-			T:go("U1R2")												-- turn round ready to add next layer
+
-			lib.buildWallSection("--------------", R.useBlockType)		-- back wall top (14 blocks)
+
 	function lib.getVeg(direction)
-			lib.buildWallSection("--------------", R.useBlockType)		-- left wall top (14 blocks)
+
 		print("Collecting crops from storage")
-			lib.buildWallSection("-----lmb", R.useBlockType)
+
 		while T:suck(direction, 1) do end -- remove carrots / potatoes / wheat / beetroot
-			network.attachModem()
+		--clsTurtle.dropItem(self, item, direction, keepAmount)
-			T:forward(2)
+		T:dropItem("wheat", direction, 0)		-- drop all wheat
-			lib.buildWallSection("-----", R.useBlockType)
+		T:dropItem("beetroot", direction, 0)	-- drop all beetroot
-			T:go("R1F1 D2") 											-- over 13 x 13 internal area
+		T:dropItem("carrot", direction, 64)		-- drop all but 64 carrots
-		elseif R.data == "back" then									-- should be on left front corner of existing
+		T:dropItem("potato", direction, 64)		-- drop all but 64 potato
-			T:go("R2F1 D4R2 F1") 										-- move forward 14 blocks, down 1
+		local crop = ""
-			for i = 1, 15 do
+		if T:getItemSlot("potato", -1) > 0 then
-				T:place("cable", "up")
+			crop = "potato"
 			print("Field crop = "..crop)
 		elseif T:getItemSlot("carrot", -1) > 0 then
 			crop = "carrot"
-			if T:getBlockType("up") == R.useBlockType then				-- already a farm on left side
+			print("Field crop = "..crop)
-				T:go("U2C2 U1C2 F13R1 F1D1", false, 0, false, R.useBlockType)
+
-				lib.buildWallSection("--------------", R.useBlockType)	-- back wall (14 blocks)
+
 		--T:turnRight(2) -- face crops
 		return crop
 	end
-				lib.buildWallSection("--------------", R.useBlockType)	-- left wall (14 blocks)
+
 	function lib.goHome()
-				lib.buildWallSection("--------------", R.useBlockType)	-- back wall (14 blocks)
+
 		local onTree = false
 		-- is tree above or in front
 		-- check if log in front
-			lib.buildWallSection("-------------", R.useBlockType)		--right wall (13 blocks) no special blocks
+
-			T:go("U1R2")	-- turn round ready to add next layer
+			lib.harvestTree("forward") -- will only harvest if fuel below half of limit
-			for i = 1, 2 do
+
-				lib.buildWallSection("--------------", R.useBlockType)	--right wall top (14 blocks) no special blocks
+
-				T:go("L1F1")
+			lib.harvestTree("up")
 			onTree = true
-			lib.buildWallSection("-------------", R.useBlockType)		-- left wall top (13 blocks) no special blocks
+		elseif T:getItemSlot("log", -1) > 0 then -- tree just harvested
-			T:go("F1L1 F7x2")
+
-			T:go("D1x2")
+
-			T:place("cable", "down")
+
 				lib.harvestTree("up")
-			T:place("modem", "down")
+
-			T:go("F1R2x2")
+				while turtle.down() do end
-			T:place("log", "down")
+
-			T:go("F2x2")
+
-			T:place("barrel", "down")
+
 		if onTree then -- tree harvested, but direction unknown
-			network.attachModem()
+
-			T:go("F6R1 F1D2")
+			local turns = 0
 			local onChest = lib.isStorage("down")
-	else -- convertStorage or convert
+			while not onChest do
-		-- legacy farm had polished block on positions 4 / (10) from left corner
+
-		 local message = lib.findLegacyStart()
+					if lib.isStorage("down") then
-		 if message ~= "" then
+						onChest = true
-			return {message}
+
-		 end
+						turtle.back()
-		 -- now on top of polished block, 4 from left corner, facing Centre
+
-		 T:forward(2)
+
-		 T:place("barrel", "down")
+				if not onChest then
-		 T:go("F1D1")
+
-		 T:place("cable", "down")
+					turns = turns + 1
-		 T:up(1)
+
-		 T:place("modem", "down")
+				if turns == 4 then
-		 network.attachModem()
+
-		 T:forward(1)
+
-		 T:place("log", "down")
+			end -- should be on chest. If not should be over water
-		 T:go("R1F1 R1F1 D5R1 F1L1 F7R1")-- left corner, facing back ready to clear basement
+			if onChest then -- onChest and onTree, go left,down
 				T:go("R1F1D1R1")
-	if (R.data):find("convert") == nil then
+
-		lib.floodFarm(R)
+			atHome = lib.checkPosition()
 			if atHome then
-	lib.clearBasement() -- area has been cleared. ends right side facing right, just below ceiling
+				return true -- exit function
 			end
-	if R.data == "back" then
+
-		T:go("R2F6 R1D1")
+
 		end
-		T:go("R2F6 L1F1 U4D5 R2F1") -- make exit for player. end mid floor/ceiling height, facing back, in centre
+
 		return false
-	if R.data == "new" or R.data == "convertStorage" then	-- put storage in this farm
+
 
-			T:place("cable", "up")
+	function lib.gotoTree(logSlot)
 		-- assume facing crops
 		T:turnRight(1)
-		T:place("cable", "up")
+		print("Extracting saplings from storage")
 		lib.getSaplings("forward") -- gets one sapling only (if present)
-		utils.createStorage()	-- creates on ground, 1 below current
+		print("Moving to tree position")
 		T:go("U1F1R1")
-		T:place("cable", "forward")
+		lib.harvestTree("forward") -- fell tree or plant sapling, ends facing tree / dirt / sapling. sticks already used for fuel. excess saplings placed
 
 		if logSlot == 0 then -- no logs passed as parameter
-			T:place("cable", "up")
+			logSlot = T:getItemSlot("log")
 		end
 		T:go("R1F1D1")			-- return to base, facing buried storage
 		if logSlot == 0 then 	-- has logs so needs to craft and refuel
-		for i = 1, 6 do
+			T:turnRight(1)		-- facing crops
-			T:place("cable", "up")
+
 
 		return logSlot
 	end
-	T:place("modem", "up")
+
-	T:go("F1R2U2")
+	function lib.harvest(crop)
-	T:place("barrel", "down")
+
-	T:drop("down", "dirt", 64)-- override 'slot' with item string
+
-	T:up(1)
+		harvest crops if ripe
-	T:place("hopper", "down")
+
 		place seeds / harvest in chests
-	network.attachModem()
+
-	T:go("U1C2 U2F6 R2")
+
-	--network.attachModem()
+
 		local isFarmToRight = false
 		local isFarmToFront = false
 		local width = 9
 		local length = 10
 		local toRight = true
 		for l = 1, length do
 			for w = 1, width do
 				isReady, blockType, _ = lib.isCropReady("down")	-- eg true, "minecraft:carrots", "7 / 7" or false, "", ""
 				turtle.select(1)
 				if blockType == "" then					-- air (above water, storage or dirt)
 					--turtle.digDown("left")			-- use pickaxe
-			T:place("barrel", "down", false)
+					turtle.digDown("right")				-- use hoe
 					lib.plantCrop(crop, "down")			-- plant crop
 				elseif isReady then						-- crop below is ready
 					turtle.digDown("left")				-- use pickaxe
 					lib.plantCrop(blockType, "down")	-- plant crop
 				end
 				T:forward(1)
 				if l == 1 and w == width then -- last block of first row at front of farm
 					T:forward(1)
 					if lib.isStorage("down") then
 						isFarmToRight = true
 					end
 					turtle.back()
 				end
 			end
 			-- end of the row: change direction
-		T:place("torch", "forward", true)
+
 				lib.plantCrop(crop, "down")
 				if toRight then
 					T:go("L1F1L1")
 				else
-		-- T:place(blockType, direction, leaveExisting, signText)
+
 				end
 			end
 			toRight = not toRight
 		end
 		T:go("R1F1") -- goes over chest/cobble on top wall
-				T:place(R.useBlockType, "forward", true)
+		if lib.isStorage("down") then
 			isFarmToFront = true
 		end
 		T:go("R2F"..length.."D1L1") -- go straight across to seed chest 10 blocks, facing crops
 		lib.storeCrops() -- rotates from start to deposit seeds and crops, ends facing crops
 		return isFarmToRight, isFarmToFront
 	end
 
-					T:place(R.useBlockType, "up", true)
+	function lib.harvestTree(direction)
 		--[[
 			start in front of / during tree harvest
 			Check if sapling present
 			Harvest tree if present, replant sapling
 			Dispose of apples. Use sticks as fuel
 			Return to base
-					T:place(R.useBlockType, "forward")
+
 		if turtle.getFuelLevel() < turtle.getFuelLimit() / 2 then -- only harvest tree if fuel < half max
 			direction = direction or "forward"
 			local inFront = T:getBlockType("forward")
 			print("Checking tree")
-					T:place(R.useBlockType, "forward")
+			if inFront == "" then -- no tree or sapling
 				print("No sapling: planting sapling")
 				T:place("sapling", -1, "forward", false)
 			elseif inFront:find("log") ~= nil or direction == "up" then -- tree above or in front
-					T:place(R.useBlockType, "forward")
+				-- clsTurtle.harvestTree(self, extend, craftChest, direction)
 				print("Harvesting tree")
 				T:harvestTree(false, false, direction) --do not investigate side branches in case chunk unloaded
 				T:go("R2F1R2") -- face dirt
 				-- place(self, blockType, damageNo, direction, leaveExisting, signText)
 				T:place("sapling", -1, "forward", false)
 			end
 			print("Dropping saplings into storage")
 			T:dropItem("sapling", "down", 0) -- drop all saplings down into chest
-						T:place(R.useBlockType, "down", true)
+			print("Disposing of apples")
 			T:dropItem("apple", "up", 0) -- drop any apples
 			local slot = T:getItemSlot("minecraft:stick")
 			if slot > 0 then -- use any sticks to refuel
 				turtle.select(slot)
 				turtle.refuel()
 			end
 		end
 	end
 
 	function lib.manageTree()
 		--[[ starting position facing crops ]]
 		local crop = ""
 		local logSlot = T:getItemSlot("stick")
 		if logSlot > 0 then
 			turtle.select(logSlot)
 			turtle.refuel()
 		end
 		logSlot = T:getItemSlot("log")
 		local needsFuel = false
 
-		T:place(R.useBlockType, "down", true)
+
 			needsFuel = true
 		end
 		if needsFuel then
 			print("Running Tree Manager")
 			logSlot = lib.gotoTree(logSlot) -- check for sapling or harvest tree, retuns to start, ends facing buried barrel/chest if has logs, logSlot returned
 		end
 		if logSlot > 0 then
 			if not needsFuel then 			-- logs already onboard, no tree harvest, so turn towards buried chest
 				T:turnLeft(1)
 			end
 			T:go("F1") 						-- move to buried storage chest/barrel
 			lib.refuelWithLogs(logSlot) 	-- use any logs for fuel
 			T:go("R2F1")					-- facing seed chest/barrel
 		else
 			T:turnRight(1) 					-- facing seed chest/barrel
 		end
 
 		crop = lib.getSeeds("forward") 		-- get 1 stack of beetroot / wheat seeds
 		if crop == "" then
 			print("No seeds available. Checking root veg")
 			T:turnRight(1)					-- face crop chests
 			crop = lib.getVeg("forward")	-- gets any carrots / potatoes
 			T:turnRight(2)					-- face crops
 		else
 			T:turnLeft(1)					-- face crops
 		end
 		return crop
 	end
 
 	function lib.isCropReady(direction)
 		local isReady = false
 		local status = ""
 		local cropType = ""
 		local success = false
 		local data = {}
 
 		direction = direction or "forward"
 
 		if direction == "down" then
 			success, data = turtle.inspectDown()
 		else
 			success, data = turtle.inspect()
 		end
 		if success then
 			cropType = data.name
 			--print("cropType: "..cropType) read()
 			if data.name == "minecraft:carrots" then
 				status = data.state.age.." / 7"
 				--print("Carrots status: "..status) read()
 				if data.state.age == 7 then
 					isReady = true
 				end
 			elseif data.name == "minecraft:potatoes" then
 				status = data.state.age.." / 7"
 				if data.state.age == 7 then
 					isReady = true
 				end
 			elseif data.name == "minecraft:wheat" then
 				status = data.state.age.." / 7"
 				if data.state.age == 7 then
 					isReady = true
 				end
 			elseif data.name == "minecraft:beetroots" then
 				status = data.state.age.." / 3"
 				if data.state.age == 3 then
 					isReady = true
 				end
 			end
 		end
 		return isReady, cropType, status	-- eg true, "minecraft:carrots", "7 / 7" or false, "", ""
 	end
 
 	function lib.isStorage(direction)
 		blockType = T:getBlockType(direction)
 		if blockType:find("barrel") ~= nil then
 			return true, "barrel"
 		elseif blockType:find("chest") ~= nil then
 			return true, "chest"
 		end
 
 		return false, ""
 	end
 
 	function lib.plantCrop(crop, direction)
 		local planted = false
 		--turtle.digDown("left") -- harvest existing
 		--turtle.digDown("right") -- till soil
 		if crop:find("potato") ~= nil then
 			T:dropItem("poison", "up", 0)
 		end
 		planted = T:place("carrot", -1, direction)
 		if not planted then
 			planted = T:place("potato", -1, direction)
 		end
-					T:place("torch", "down")				-- place torch, move forward
+		if not planted then
 			planted = T:place("beetroot_seeds", -1, direction)
 		end
 		if not planted then
 			planted = T:place("wheat_seeds", -1, direction)
 		end
 	end
-				if not T:place("stone", "down") then		-- place stone below
+
 	function lib.refuelWithLogs(logSlot)
 		-- assume positioned in front of buried chest / barrel, saplings already dropped, apples dumped, sticks used as fuel
 		print("Logs present: collecting crafting table")
 		-- earlier versions used crafting table buried in the ground
 		-- newer versions have a barrel or chest embedded in the ground, containing the crafting table
 		print("Sorting Inventory")
 		T:sortInventory()
 		while T:suck("down") do end					-- empty out barrel/chest to find crafting table
 		if T:getItemSlot("crafting") == 0 then
 			T:checkInventoryForItem({"crafting"}, {1}, true, "Crafting table required for logs->planks")
 		end
 		if T:equip("right", "minecraft:crafting_table") then -- swap equipment on right side
 			for i = 1, 16 do						-- drop anything except logs down into barrel/chest/pit
 				if T:getSlotContains(i):find("log") == nil then
 					T:drop("down", i)
 				else
 					logSlot = i
 				end
 			end
 			turtle.select(logSlot)
 			turtle.transferTo(1)
 			turtle.craft()							-- craft logs to planks
 			logSlot = T:getItemSlot("planks")
 			while logSlot > 0 do
 				turtle.select(logSlot)
 				turtle.refuel()
 				logSlot = T:getItemSlot("planks")
 			end
 							-- refuel using planks
 			while T:suck("down") do end				-- recover items from storagebelow
 			if not T:equip("right", "minecraft:diamond_hoe") then		-- re-equip
 				T:equip("right", "minecraft:diamond_pickaxe")
 			end
 			if T:dropItem("minecraft:crafting_table", "down") then
 				turtle.refuel() -- use any sticks
 			end
 		else
 			print("Unable to equip crafting table.\n\nCheck turtle inventory and chest or barrel below")
 			error()
 		end
 	end
 
 	function lib.returnToBack()
 		--[[ move from farm at front back to starting farm ]]
 		T:go("U1R1F11D1L1")
 	end
 
 	function lib.returnToLeft()
 		--[[ move from farm on right back to starting farm ]]
 		T:go("U1R2F11D1R2")
 	end
 
 	function lib.storeCrops()
 		-- place crops and seeds into chests
 		T:turnRight(1)
 		if lib.isStorage("forward") then
 			lib.storeSeeds("forward")
 		end
 		T:turnRight(1)
 		if lib.isStorage("forward") then
 			lib.storeVeg("forward")
 		end
 		T:turnRight(2) -- facing crops again
 	end
 
 	function lib.storeSeeds(direction)
 		direction = direction or "forward"
 		if lib.isStorage(direction) then -- chest exists
 			if T:getItemSlot("minecraft:wheat_seeds") > 0 then
 				if not T:dropItem("minecraft:wheat_seeds", direction, 0) then
 					T:dropItem("minecraft:wheat_seeds", "up", 0)
 				end -- drop all wheat seeds
 			elseif T:getItemSlot("minecraft:beetroot_seeds") > 0 then
 				if not T:dropItem("minecraft:beetroot_seeds", direction, 0) then-- drop all beetroot seeds
 					T:dropItem("minecraft:beetroot_seeds", "up", 0)
 				end
 			end
 		end
 	end
 
 	function lib.storeVeg(direction)
 		direction = direction or "forward"
 		T:dropItem("apple", "up", 0) -- drop all apples
 		T:dropItem("poison", "up", 0) -- drop all poison potatoes
 		if lib.isStorage(direction) then
 			if not T:dropItem("carrot", direction, 0) then-- drop carrots
 				--return false
 			end
 			T:dropItem("potato", direction, 0) -- drop potato
 			T:dropItem("minecraft:wheat", direction, 0) -- drop all wheat
 			T:dropItem("minecraft:beetroot", direction, 0) -- drop all beetroot
 		end
 	end
 
 	function lib.watchFarm()
 		--[[
 		check status of crops in front of turtle.
 		call lib.harvest when ripe
 		return farm(s) found in front or to the right
 		]]
 		local isReady, crop, status = lib.isCropReady("forward")		-- eg true, "minecraft:carrots", "7 / 7" or false, "", ""
 		-- check state of crop in front. Harvest if ripe
 		while not isReady do
 			isReady, crop, status = lib.isCropReady("forward")			-- eg true, "minecraft:carrots", "7 / 7" or false, "", ""
 			if not isReady then
 				if crop == "" then
 					print("No crops found in front")
 					print("Plant seeds, carrots, potatoes")
 					error()
 				else
 					print("Waiting for "..crop.." status: "..status)
 				end
 				sleep(60)
 			end
 		end
 		print("Local crops ripe")
 
-						T:place("torch", "down")		-- place torch
+		return lib.manageTree() -- "" or collected seeds / root crops
 	end
 
 	--[[
 		called from args on start, or from user choice
 		farm already built, needs planting and/or harvesting
 		needs both pickaxe and hoe
 		may start in any position if chunk unloaded while running
 	]]
 	--local pp = utils.getPrettyPrint()
 
 	local atHome = lib.checkPosition()-- facing crops, placed above water source
 	if not atHome then
 		if not lib.goHome() then -- try to find home
 			return
 			{
 				"Unable to determine my position.\n",
 				"Place me in the lower left corner",
 				"over water, facing the crops with",
 				"barrels or chests to my right and behind"
 			}
 		end
 	end
 	-- check equipment
 	T:go("L1F1") -- over barrel
 	local isStorage, storageType = lib.isStorage("down")
 	if not isStorage then
 		local message =
 [["Farm upgrade required:
 Previous designs had a crafting table
 next to the water source.
 
  1. Place a barrel or chest under the turtle
     instead.
 
  2. Restart"
 ]]
 		print(message)
 		error()
 	end
 	-- must be storage below to get this far
 	if lib.checkEquipment() then
 		T:equip("right", "minecraft:diamond_hoe", 0) -- equip hoe and put crafting chest into inventory
 		T:dropItem("crafting", "down")
 		utils.goBack(1)
 		T:turnRight(1)
 	else
 		return {"Unable to equip hoe."}
 	end
 
 
 	-- check if crops already planted
-						T:place("torch", "down")		-- place torch
+	local isReady, crop, status = lib.isCropReady("forward")
 	local watch = true	-- assume watching farm already planted
 	if crop == "" then	-- nothing has been planted
 		watch = false-- not watching, continue with planting
 		pp.itemColours = {colors.lightGray, colors.red, colors.orange, colors.brown}
 		crops = {"minecraft:wheat_seeds", "minecraft:beetroot_seeds", "minecraft:carrots", "minecraft:potatoes"}
 		choices = {"wheat (seeds)", "beetroot (seeds)", "carrot", "potato"}
 		choice = menu.menu("Choose preferred crop", choices, pp, "Type number of your choice")
 		crop = crops[choice]
 		T:checkInventoryForItem({crop}, {95}, true, "Do not mix! add as many as you want")
 	end
 
 	while true do -- start infinite loop of watching crops, farming all modules
 		if watch then -- not already in inventory
 			crop = lib.watchFarm() --waits if required, returns crop type when ripe
 		end
 		print("Beginning "..crop.." management")
 		local isFarmToRight, isFarmToFront = lib.harvest(crop)
 		if isFarmToRight then
 			lib.farmToRight() -- no action if no farmToRight
 			lib.returnToLeft() -- return home and continue with front
 			isFarmToRight = false
 		end
 
 		if isFarmToFront then
 			isFarmToRight = lib.farmInFront()
 			if isFarmToRight then
 				lib.farmToRight() -- no action if no farmToRight
 				lib.returnToLeft() -- return home
 			end
 			lib.returnToBack()
 		end
 		if not R.auto then -- not started from startup.lua
 			T:go("L1F1")
 			while T:suck("down") do end						-- recover items from storagebelow
 			T:equip("right", "minecraft:crafting_table", 0) -- equip crafting_table
 			T:dropItem("diamond_hoe", "down") 				-- drop hoe into storage
 			T:dropItem("crafting", "down") 					-- in case spare one picked by mistake
 			utils.goBack(1)
 			T:turnRight(1)
 			return {"Crop management of all modules completed"}
 		end
 	end
 	return {}
 end
 
 local function manageFarmSetup(R) -- 33
 	local lib = {}
 
 	function lib.disableAutostart()
 		if fs.exists("start.txt") then
 			fs.delete("start.txt")
 		end
 		if fs.exists("startup.lua") then
 			fs.delete("startup.lua")
 		end
 	end
 
 	function lib.enableAutostart()
 		if not fs.exists("startup.lua") then
 			local h = fs.open("startup.lua", "w")
 			h.writeLine('function main()')
 			h.writeLine('	if fs.exists("start.txt") then')
 			h.writeLine('		local handle = fs.open("start.txt", "r")')
 			h.writeLine('		local cmd = handle.readLine()')
 			h.writeLine('		handle.close()')
 			h.writeLine('		shell.run("tk.lua "..cmd)')
 			h.writeLine('	end')
 			h.writeLine('end')
 			h.writeLine('main()')
 			h.close()
 		end
 		local h = fs.open("start.txt", "w")
 		if R.data == "farm" then
 			h.writeLine('farm')
 		end
 		h.close()
 		print("Startup files written")
 	end
 
 	T:clear()
 	--local pp = utils.getPrettyPrint()
 	local choices = {"Plant or harvest this farm complex"}
 	local isManaged = fs.exists("start.txt")
 	if isManaged then
 		table.insert(choices, "Disable automatic farm management")
 	else
 		table.insert(choices, "Enable automatic farm management")
 	end
 	pp.itemColours = {colors.lime, colors.lightGray}
 	local userChoice, modifier = menu.menu("Choose your option", choices, pp) -- 1 to 2
 	if modifier == "q" then -- quit chosen
 		return {"Player has quit"}
 	end
 	R.subChoice = userChoice
 	if R.subChoice == 1 then -- harvest now
 		R.silent = false
 		R.data = "farm"
 		R.auto = false
 		return manageFarm(R)
 	else -- enable/disable auto farm
 		local line = menu.clear()
 		if isManaged then
 			local message = ( "This turtle has been configured to"..
 							  "start automatically and run the farm"..
 							  "management program.\n")
 			line = menu.colourText(line, message, true, true)
 			if menu.getBoolean("Do you want to disable this? (y/n)", line, colors.yellow, colors.black) then
 				lib.disableAutostart()
 			end
 			return {"Autostart disabled. Reboot to activate"}
 		else -- not managed
 			local message = ( "~yellow~This turtle can be configured to be\n"..
 							  "a dedicated farm manager.\n\n"..
 							  "~lightGray~It will then start automatically and\n"..
 							  "monitor the farm complex:\n\n"..
 							  "~green~harvesting~yellow~ and ~lime~replanting ~yellow~continuously.\n")
 			line = menu.colourText(line, message, true, true)
 			if menu.getBoolean("Do you want to enable this? (y/n)", line + 2, colors.orange, colors.black) then
 				lib.enableAutostart()
 			else
 				return {"Player cancelled operation"}
 			end
 			return {"Autostart enabled. Reboot to activate"}
 		end
 	end
 
 	return {}
 end
 
 local function measure(R) -- 101
 	-- measure height/ depth / length
 	local lib = {}
 
 	function lib.checkBlocks(R, blocks)
 		local dimension = "height"
 		local message = ""
 		local measure = ""
 		local doContinue = true
 		if R.choice == 102 then
 			dimension = "depth"
 		elseif R.choice == 103 then
 			dimension = "length"
 		end
 		blocks = blocks + 1
 		if blocks > R.size then
 			message = "Max "..dimension.." of "..R.size.." stopped measurement"
 			measure = ""
 			doContinue = false
 		else
 			measure = dimension.." measured: "..blocks.." blocks"
 		end
 		return doContinue, blocks, measure, message
 	end
 
 	local blocks = 1
 	local method = ""
 	local measure = ""
 	local message = ""
 	local doContinue = true
 	if R.choice == 101 then				-- height
 		if R.subChoice == 1 then		-- obstruction above
 			method = "Method: Until obstruction above"
 			while turtle.up() and doContinue do
 				doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
 			end
 		elseif R.subChoice == 2 then	-- end of blocks in front of turtle eg cliff, wall
 			method = "Method: Until no block detected in front"
 			while turtle.detect() and doContinue do
 				if turtle.up() then
 					doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
 				else
 					message = "Obstruction above stopped measurement"
 					measure = ""
 					doContinue = false
 				end
 			end
-		T:place("slab", "down")					-- place slab layer 1
+
 			method = "Method:Until search: '"..R.data.."' met"
-		T:place("slab", "down")					-- place slab layer 2
+
 				if turtle.up() then
-		T:place("redstone", "down")
+
 					if doContinue then
-		T:place("redstone", "forward")			-- redstone on ground level slab
+
 						if blockType:find(R.data) ~= nil then
-		T:place("slab", "down")					-- slab on layer 1
+
 							message = "Found "..blockType
-		T:place("slab", "down")					-- slab on layer 3
+
 						end
-		T:place("redstone", "down")				-- redstone on layer 3 slab
+
 				else
 					message = "Obstruction above stopped measurement"
-		T:place("redstone", "forward")			-- redstone on layer 1 slab
+
 					doContinue = false
-		T:place("redstone", "forward")			-- redstone on level 0 floor
+
 			end
 		elseif R.subChoice == 4 then	-- When block above changes eg dragon tower height
 			local blockType = T:getBlockType("up")
 			local compare = blockType
 			method = "Method: Until "..blockType.." changes"
 			while blockType == compare and doContinue do
-			T:place("redstone", "down")			-- redstone under chest etc
+
 				doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
 				if doContinue then
 					blockType = T:getBlockType("up")
 				end
 			end
 			measure = "Height measured: "..blocks.." blocks"
 			message = "Found "..blockType
 		end
 
 		for i = 1, blocks do
-		T:place("chest", "forward")				-- end chest
+
 		end
-		T:place("slab", "down")					-- slab above chest
+
 		T:go("F1R2D1") -- go off the edge and face cliff/pit wall
 		blocks = blocks + 1
 		if R.subChoice == 1 then		-- obstruction water / lava below
-		T:place("chest", "forward")				-- start chest
+
 			while move do
-		T:place("wall", "forward")				-- place wall
+
 				if blockType:find("water") ~= nil or blockType:find("lava") ~= nil then
-		T:place("pressure", "down")				-- place pressure plate
+
 					move = false
-		T:place("hopper", "forward")				-- place hopper into chest
+
 					move = turtle.down()
-		T:place("wall", "forward")				-- place second wall
+
 						blocks = blocks + 1
 					else
 						measure = "Depth measured: "..blocks.." blocks"
 					end
 				end
 			end
-		T:place(R.useBlockType, "forward", false)	-- replace back wall with polished block layer 2
+
 		elseif R.subChoice == 2 then	-- end of wall in front`
-		T:place(R.useBlockType, "forward", false)	-- replace back wall with polished block layer 3
+
 				if turtle.down() then
 					blocks = blocks + 1
-			T:place(R.useBlockType, "forward", false)-- polished block above second wall layer 3
+
 				else
 					message1 = "Obstruction below stopped measurement"
 					break
-			T:place("piston", "forward")				-- lower replacer piston placed
+
 			end
 			method = "Method: Until no block detected ahead"
-		T:place("piston", "forward")					-- lower piston placed
+
 			method = "Method:Until search: '"..R.data.."' met"
 			while turtle.detect() do
-		T:place(R.useBlockType, "forward", false)	-- polished block back wall layer 4
+
 					blocks = blocks + 1
-		T:place("dispenser", "forward")				-- dispenser placed
+
 					if blockType:find(R.data) ~= nil then
 						measure = "Depth measured: "..blocks.." blocks"
-		T:place("slab", "down")						-- lower piston slab placed
+
 						break
-			T:place(R.useBlockType, "forward", false)-- polished block above second wall layer 4
+
 				else
 					message = "Obstruction below stopped measurement"
 					break
 				end
-			T:place("computercraft:computer_normal", "forward", false)	-- place computer
+
 		end
 		for i = 1, blocks do
-		T:place(R.useBlockType, "forward", false)	-- polished block back wall layer 4
+
 		end
 		T:go("F1R2")
-		T:place("piston", "forward")					-- upper piston placed
+
 		if R.subChoice == 1 then		-- obstruction ahead
 			method = "Method: Until obstruction ahead"
-		T:place(R.useBlockType, "forward", false)	-- polished block back wall layer 5
+
 				doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
 			end
-			T:place(R.useBlockType, "forward", false)-- right side polished block layer 5, facing right side, in mob drop 							-- layer 5 facing left side, in mob drop
+
 			method = "Method: Until no block detected above"
 			while turtle.detectUp() and doContinue do
 				if turtle.forward() then
-			T:place("piston", "forward")				-- upper replacer piston placed
+
 				else
 					message = "Obstruction ahead stopped measurement"
-		T:place("slab", "forward")					-- upper piston slab placed
+
 					doContinue = false
 				end
 			end
 		elseif R.subChoice == 3 then	-- end of floor below
 			method = "Method: Until no block detected below"
 			while turtle.detectDown() and doContinue do
-		T:place("computercraft:computer_normal", "forward", false)		-- place computer in gap, layer 4
+
 					doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
 				else
 					message = "Obstruction ahead stopped measurement"
-		T:place(R.useBlockType, "forward", false)
+
 					doContinue = false
-		T:place(R.useBlockType, "forward", false)
+
 			end
-		T:place(R.useBlockType, "forward", false)	-- facing right
+
 			method = "Method:Until search: '"..R.data.."' above met"
 			while turtle.detectUp() and doContinue do
 				if turtle.forward() then
 					doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
 					if doContinue then
-		T:place("glass", "down", false)
+
 						if blockType:find(R.data) ~= nil then
-		T:place("glass", "down", false)				-- on top of glass facing back wall at dungeon base level 5
+
 							measure = "Length measured: "..blocks.." blocks"
-		T:place(R.useBlockType, "down", false)		-- level 6 dungeon exit
+
 						end
 					end
 				else
 					message = "Obstruction ahead stopped measurement"
 					measure = ""
 					doContinue = false
 				end
 			end
 		elseif R.subChoice == 5 then	-- search for specific block down min 3 characters
-		T:place(R.useBlockType, "forward", false)
+
 			--while turtle.detectDown() and doContinue do
-		T:place(R.useBlockType, "forward", false)	-- facing right
+
 				if turtle.forward() then
 					doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
 					if doContinue then
-		T:place(R.useBlockType, "forward", false)
+
 						if blockType:find(R.data) ~= nil then
 							message = "Found "..blockType
 							measure = "Length measured: "..blocks.." blocks"
 							doContinue = false
 						end
-		T:place("computercraft:wired_modem", "forward", false)	-- place modem
+
 				else
-		T:place("computercraft:cable", "forward", false)			-- place network cable
+
-		T:place("computercraft:cable", "forward", false)			-- place network cable (no need to move)
+
 					doContinue = false
-		T:place("computercraft:cable", "forward", false)
+
 			end
-		T:place("computercraft:cable", "forward", false)
+
 		T:turnRight(2)	-- head home
-		T:place("computercraft:wired_modem", "forward", false)	-- place modem
+
 			turtle.forward()
-		T:place("computercraft:cable", "forward", false)
+
-		T:place("computercraft:cable", "forward", false)
+
 	elseif R.choice == 104 then	-- depth of stretch of water
 		--R.length = 0 to auto calculate
 		R.width = 1
 		R.silent = true
 		R.useBlockType = ""
 		R.data = "clearWaterPlants"
 		local data = clearWaterPlants(R)
 		R.height = data[1]
 		local length = data[2]
 		T:go ("R2F"..length - 1 .."R2U1")
 		return {"Greatest depth measured: ".. R.height,"Width of water: "..R.length}
 	end
 	if message == "" then
 		return{method, measure}
 	else
 		return{method, measure, message}
 	end
 end
 
 local function mineBedrockArea(R) -- 19
 	--[[
 	Assume on level 5 or -59
 	for 1, width do
 		for 1, length do
 			go down until bedrock, digging/replacing all directions
 			return to 5 / -59
 			move forward 1 blocks
 		end
 		turn right/ forward 2 turn right
 	end
 	]]
 	local lib = {}
 
 	function lib.clearColumn(R)
 		local level = 0
 		--T:go("L1x1R2x1L1")
 		local success = T:down(1)
 		while success do
 			level = level + 1
 			if R.data == "leaveExposed" then
 				T:go("R1x1R1x1R1x1R1x1", false, 0, true)
 			else
 				T:go("R1C1R1C1R1C1R1C1", false, 0, true)
 			end
 			success = T:down(1)
 		end
 		if R.data == "leaveExposed" then
 			T:go("U"..level)
 		else
 			T:go("U"..level.."C2")
 		end
-local function createTrialCover(R)
+
 
 	local goRight = true
 	for i = 1, R.width do
 		for j = 1, R.length do
 			lib.clearColumn(R)
 			T:forward(1)
 		end
 		if goRight then
 			T:go("R1F1R1")
 		else
 			T:go("L1F1L1")
 		end
 		goRight = not goRight
 	end
 	return {}
 end
 
 local function oceanMonumentColumns(R)
-	function lib.findSpawner()
+
 	local lib = {}
 
-		-- assume turtle placed facing trial spawner
+
 		local depth = 0
 		while T:isWater("forward") do
 			T:go("U1C2")
 			depth = depth + 1
 		end
 		return depth
-				if moves > 32 then
+
 
 	function lib.buildTower()
 		T:go("F1C2 F1C2 F1C2")
 		T:go("L1F1 L1C2 F1C2 F1C2 F1C2")
-			if not found then	-- could be behind a wall
+
-				print("Assuming spawner behind a wall")
+
 
 		T:go("R2")
-				while turtle.forward() and not quit do
+
 			T:go("U1C2")
-					if moves > 32 then
+
-						quit = true
+
 			end
 		end
-				found, position = lib.isSpawner() -- true/false, top/bottom/nil
+
-				if not found then
+
-					T:go("R2F"..moves + 2 .."R2")
+
 	local blockType = T:getBlockType("down")
 	while blockType:find("water") == nil do
 		T:down(1) -- if on a platform will break through
 		blockType = T:getBlockType("down")
 	end
 	--R.useBlockType = "prismarine", R.data = "oceanMonumentColumns" from getTask
 	--local tempData = R.data
 	--R.data = "clearWaterPlants"
 	local result = clearWaterPlants(R)[1]
 	if result ~= "" then
 		return {result}
 	else
 		--on corner of monument, facing out to ocean
 		local depth = lib.buildColumn()
 		-- now above surface, block below at surface level
 		for i = 1, 4 do
 			T:turnRight(1)
 			R.length = 57
 			utils.createPath(R) -- roughly at next corner
 			if i < 4 then
 				T:down(depth-2) -- roughly at correct depth
 				local waterBelow = utils.clearVegetation("down")
 				while waterBelow do
 					T:down(1)
 					waterBelow = utils.clearVegetation("down")
 				end
 				blockType = T:getBlockType("down")
 				while blockType:find("prismarine") ~= nil do
 					T:forward(1)
 					blockType = T:getBlockType("down")
 				end
 				turtle.back()
 				depth = lib.buildColumn()
-	local found, position = lib.findSpawner() -- move forwards until meet Spawner, go through wall if present
+
-	if not found then --outside dungeon
+
-		return {"Trial spawner not found"}
+
-	end
+
-	if position == "top" then
+
-		T:go("B2D1")
+
-	elseif position == "forward" then
+
-		T:go("B1")
+
 
-		T:go("B2U1")
+
 	local moves = 2
-	T:go("R1F2R2")	--on lower right corner
+
-	-- starts with wall across spawner
+
-	buildStructure(R)
+
-	T:go("U3F1 R1F1 L1U1 F1")
+
 		if blockType:find("rail") ~= nil then
-	R.width = 3
+
-	R.length = 3
+
 		T:down(moves)
-	createFloorCeiling(R)
+
-	T:go("F1R1 B1D1 B1D2 F1")
+
 		T:place(R.useBlockType, -1, "forward", false)
 		utils.goBack(1)
 		T:place("minecraft:redstone_torch", -1, "forward", true)
 		T:turnLeft(1)
 		utils.goBack(1)
 		T:up(moves)
 		T:go("F1R1F1")
 	elseif R.data == "up" then -- sloping rail up/down is relative to dirtection facing
 		moves = 3
 		T:turnLeft(1)
 		utils.goBack(1)
 		if blockType:find("rail") ~= nil then
 			 moves = 4
 		end
 		T:down(moves)
 		T:go("F1L1")
 		T:place("minecraft:redstone_torch", -1, "up", false)
 
 		T:turnRight(1)
 		utils.goBack(1)
 		T:up(moves)
 		T:go("F1R1")
 	end
 	return {}
 end
 
 local function plantTreefarm(R) -- 23
 	--T:place(blockType, damageNo, direction, leaveExisting, signText)
 	local lib = {}
 
 	function lib.checkSaplings(saplings, firstChoice, secondChoice)
 		local saplingSlot, sapling, count = T:getSaplingSlot(firstChoice)
 		if count < 4  and secondChoice ~= "" then
 			saplingSlot, sapling, count = T:getSaplingSlot(secondChoice)
 		end
 		if count == 0 then
 			sapling = ""
 		end
 
 		return sapling, count
 	end
 
 	function lib.getSaplingInventory()
 		local saplings = {}
 		saplings.oak_sapling = 0
 		saplings.spruce_sapling = 0
 		saplings.birch_sapling = 0
 		saplings.jungle_sapling = 0
 		saplings.acacia_sapling = 0
 		saplings.dark_oak_sapling = 0
 
 		local firstChoice = ""
 		local firstCount = 0
 		local secondChoice  = ""
 		local secondCount = 0
 		for i = 1, 16 do
 			if turtle.getItemCount(i) > 0 then
 				local data = turtle.getItemDetail(i)
 				if data.name:find("sapling") ~= nil then
 					local name = data.name:sub(11) -- removes "minecraft:"
 					saplings[name] = saplings[name] + data.count
 				end
 			end
 		end
 
 		for sapling, count in pairs(saplings) do
 			if count > firstCount then
 				firstCount = count
 				firstChoice = sapling
 			else
 				if count > secondCount then
 					secondCount = count
 					secondChoice = sapling
 				end
 			end
 		end
 		return saplings, firstChoice, secondChoice -- table, "oak_sapling", "dark_oak_sapling"
 	end
 
 	function lib.createIsland(sapling, count, exit)
 		-- place 4 dirt with saplings on all 4 unless jungle
 		-- sapling count/type already checked
 		T:forward(2) -- assume starting outside planting area
 		for i = 1, 4 do
 			T:go("R1F1")
 			T:place("dirt", -1, "down", false)
 		end
 		T:up(1)
 		if count >= 4 then
 			for i = 1, 4 do
 				T:go("R1F1")
 				T:place(sapling, -1, "down", false)
 			end
 		else
 			if sapling:find("dark") == nil and sapling ~= "" then
 				T:place(sapling, -1, "down", false)
 			end
 		end
 		if exit == "forward" then
 			T:go("F1D1")
 		elseif exit == "right" then
 			T:go("R1F2D1")
 		elseif exit == "left" then
 			T:go("L1F1D1")
 		elseif exit == "back" then
 			T:go("R2F2D1")
 		end
 	end
 
 	function lib.createSingle(sapling, exit)
 		-- place single dirt with sapling on top
 		-- sapling count/type already checked
 		T:place("dirt", -1, "down", false)
-					T:place("cobble", "down", false) -- place cobblestone or cobbled deepslate to mark zero coordinate
+
 		if not T:place(sapling, -1, "down", false) then -- try specific sapling
 			T:place("sapling", -1, "down", false)		-- any available sapling
 		end
 		if exit == "forward" then
 			T:go("F1D1")
 		elseif exit == "right" then
 			T:go("R1F1D1")
 		elseif exit == "left" then
 			T:go("L1F1D1")
 		elseif exit == "back" then
 			T:go("R2F1D1")
 		end
 	end
 
 	local saplings, firstChoice, secondChoice = lib.getSaplingInventory()
 
 	if firstChoice ~= "" then
 		print("first sapling choice: "..firstChoice .. " ("..saplings[firstChoice]..")")
 	end
 	if secondChoice ~= "" then
 		print("second sapling choice: "..secondChoice .. " ("..saplings[secondChoice]..")")
 	end
 
 	-- check type/size of farm
 	if R.subChoice == 1 then -- 16 single trees
 		local sapling, count = lib.checkSaplings(saplings, firstChoice, secondChoice)
 		T:go("U1F4") -- outside first area
 		for i = 1, 3 do	-- column 1/4
 			lib.createSingle(sapling, "forward")
 			T:forward(1)
 		end
 		for i = 1, 2 do
 			lib.createSingle(sapling, "right") -- place 4th dirt/saling and exit to right
 			T:forward(1)
 		end
 		for i = 1, 2 do -- column 2/4
 			lib.createSingle(sapling, "forward")
 			T:forward(1)
 		end
 		for i = 1, 2 do
 			lib.createSingle(sapling, "left") -- place 4th dirt/saling and exit to right
 			T:forward(1)
 		end
 		for i = 1, 2 do -- column 3/4
 			lib.createSingle(sapling, "forward")
 			T:forward(1)
-		T:place("minecraft:end_stone", "forward", false) -- place endstone to mark facing direction
+
 		for i = 1, 2 do
 			lib.createSingle(sapling, "right") -- place 4th dirt/saling and exit to right
 			T:forward(1)
 		end
 		for i = 1, 3 do -- column 4/4
 			lib.createSingle(sapling, "forward")
 			T:forward(1)
 		end
 		T:go("R1F6L1F2R2D1")
 	elseif R.subChoice == 2 then -- 4 double trees (4 saplings)
 		-- assume placed 4 blocks from start
 		local sapling, count = lib.checkSaplings(mostName, secondMostName)
 
 		if count >= 4 then
 			T:go("U1F3") -- outside first area
 			lib.createIsland(sapling, count, "forward")
 			sapling, count = lib.checkSaplings(mostName, secondMostName)
 			T:go("F2")
 			lib.createIsland(sapling, count, "right")
 			sapling, count = lib.checkSaplings(mostName, secondMostName)
 			T:go("F2")
 			lib.createIsland(sapling, count,  "right")
 			sapling, count = lib.checkSaplings(mostName, secondMostName)
 			T:go("F2")
 			lib.createIsland(sapling, count, "forward")
 			T:go("R1D1F6L1F3R2") -- outside first area
 		else
 			return {"Insufficient saplings to plant"}
 		end
 	end
 	return {}
 end
 
 local function quickMine(R) -- 17
 	--[[
 	mine valuable blocks from specified area
 	if R.up set or lava/water found, ceiling is formed
 	if R.down is set, or lava/water found layer is kept 1 block high
 	R.subChoice
 	1 At mine area start, on the floor
 	2 At mine area start, on the ceiling
 	3 On floor, start 1 block ahead
 	4 On ceiling, start 1 block ahead
 	5 On floor diagonally to left"
 	]]
 	local lib = {}
 
 	function lib.refuel(direction)
 		if T:getWater(direction)  then
 			T:refuel(1000, false)
 		end
 	end
 
 	function lib.mine(R)
 		-- starts on ceiling
 		local isValuable, blockType
 		for i = 1, R.length do
 			local fillUp = R.up
 			local fillDown = R.down
 			isValuable, blockType = T:isValuable("down")
 			if isValuable then
 				T:dig("down")
 			elseif blockType:find("water") ~= nil then
 				fillDown = true
 			elseif blockType:find("lava") ~= nil then
 				lib.refuel("down")
 				fillDown = true
 			end
 			isValuable, blockType = T:isValuable("up")
 			if isValuable then
 				T:dig("up")
 			elseif blockType:find("water") ~= nil then
 				fillUp = true
 			elseif blockType:find("lava") ~= nil then
 				lib.refuel("up")
 				fillUp = true
 			end
 			--if not turtle.detectUp() and fillUp then
 			if fillUp then
 				T:fillVoid("up")
 			end
 			--if not turtle.detectDown() and fillDown then
 			if fillDown then
 				T:fillVoid("down")
 			end
 			if i < R.length then
 				T:forward(1)
 			end
 		end
 	end
 
 	local outbound = true
 
 	if R.subChoice == 1 then
 		T:up(1)
 	elseif R.subChoice == 3 then
 		T:go("U1F1")
 	elseif R.subChoice == 4 then
 		T:go("F1")
 	elseif R.subChoice == 5 then
 		T:go("U1R1 F1L1 F1")
 	end
 
 	for w = 1, R.width do
 		lib.mine(R)
 		if w < R.width then
 			if outbound then
 				T:go("R1F1R1")
 			else
 				T:go("L1F1L1")
 			end
 			outbound = not outbound
 		end
 		if T:getFirstEmptySlot() == 0 then
 			T:dumpRefuse("forward", 1)
 		end
 	end
 	if outbound then
 		T:go("L1F"..R.width - 1 .."L1F"..R.length - 1)
 	else
 		T:go("R1F"..R.width - 1 .."R1")
 	end
 
 	return {}
 end
 
 local function quickMineCorridor(R) -- 16
 	--[[
 	R.subChoice
 	1: At corridor start, on the floor
 	2: At corridor start, on the ceiling
 	3: On floor, start 1 block ahead
 	4: On ceiling, start 1 block ahead
 	]]
 	if R.subChoice == 2 then
 		T:down(1)
 	elseif R.subChoice == 3 then
 		T:forward(1)
 	elseif R.subChoice == 4 then
 		T:go("D1F1")
 	end
 	local width = R.width - 1
 	local length = R.length - 1
 	R.silent = true
 	R.length = length
 	createCorridor(R, true) -- put floor and ceiling for R.length, place torch at start
 	T:turnRight(1)
 	R.length = width
 	createCorridor(R, true)
 	T:turnRight(1)
 	R.length = length
 	createCorridor(R, true)
 	T:turnRight(1)
 	R.length = width
 	createCorridor(R, true)
 	T:turnRight(1)
 
 	return {}
 end
 
-		-- assumes legacy tree farm with turtle on polished block 4 blocks from corner
+
-		local message  = ""
+
-		R.treeSize = "single"
+
 	-- if width = 1
-		--local logType = ""
+
-		--local startHeight = 0
+
 
 			-- replace block with replaceWith ("" = any)
 
 			-- move up
 
 		--end
 
 		-- move back to beginning
 
 	-- else
-		if blockType:find("dirt") ~= nil then	-- dirt found
+
-			T:go("R1F1L1")
+
 
-			if blockType:find("dirt") ~= nil then
+
-				R.treeSize = "double"
+
 			-- for h = startAt, height, 1 do
-			T:go("L1F1 R1")
+
-		else	-- dirt NOT found where expected
+
-			message = "Unable to determine position"
+
 				-- move up
 
-		blockType = T:getBlockType("forward")	-- 1 block above dirt
+
-		if blockType:find("log") ~= nil or blockType:find("sapling") ~= nil or blockType:find("propagule") ~= nil then
+
-			local parts = T:getNames(blockType)
+
-			if parts[2] == "dark" then
+
-				R.logType = "dark_oak"
+
 
-				R.logType = parts[2]				-- eg "oak"
+
 
-			if R.logType == "mangrove" then
+
-				R.useBlockType = "mangrove_propagule"
+
 			--end
-				R.useBlockType = parts[2].."_sapling"	-- eg "oak_sapling"
+
 		-- end
 
-		T:down(1)	-- facing dirt
+
 
-		return R, message
+
 
 local function getTaskItemsList()
-	function lib.waitForGrowth(R)
+
-		local pattern = R.treeSize	--"single","double"
+
-		local elapsed = 0
+
-		local facing = "left"
+
-		local ready = {}
+
-		ready.left = false
+
-		ready.top = false
+
-		ready.right = false
+
-		ready.bottom = false
+
-		if R.logType == "mangrove" then
+
-			pattern = "mangrove"
+
-			local facings = {"left", "top", "right", "bottom"}
+
-			T:up(1)	-- go up from dirt to sapling level
+
-			while not ready.left or not ready.right or not ready.top or not ready.bottom do
+
 	text[21] = {"1 chest (optional)"}																	-- Fell Tree
 	text[22] = {"320 stone", "4 polished stone"} 														-- Create treefarm
-					if blockType:find("propagule") ==  nil then	-- either grown or deleted by roots
+
-						ready[facings[i]] = true
+
 	text[25] = {"width * length * 2 walls or fences", "torches (optional)", "4 barrels (optional)"}		-- fence or wall a forest
 	text[26] = {"1 chest", " any saplings"} 															-- harvest and replant walled rectangle of natural forest
 
-				if ready.left and ready.right and ready.top and ready.bottom then
+
 	text[31] = {"64 stone","128 dirt (optional)", "4 water buckets","4 chests / barrels","1 sapling"}	-- Create modular crop farm
 	text[32] = {"64 stone","128 dirt (optional)", "4 water buckets","5 chests/ barrels","1 sapling"}	-- extend modular farm
-					sleep(15)
+
-					elapsed = elapsed + 15
+
-					if  elapsed / 60 > 15 then	-- max 15 mins real time before farm is harvested
+
 
 	-- OBSIDIAN
 	text[41] = {"stone to cover area of obsidian"}														-- Harvest obsidian
-				print("Waiting for mangrove growth "..elapsed / 60 .." minutes")
+
-				print("Left = "..tostring(ready.left)..
+
-					  ", top = "..tostring(ready.top)..
+
-					  ", right = "..tostring(ready.right)..
+
-					  ", bottom = "..tostring(ready.bottom))
+
 	text[47] = {"448 stone, 145 ladders, 1 obsidian, 1 water bucket"} 									-- dragon water trap
 	text[48] = {"height * 4 stone","height * ladders", "1 trapdoor"}									-- build end portal platform
-			--T:go("L1D1")
+
-			T:turnLeft(1)	-- face front
+
 	text[51] = {"dirt or stone * length","torch (optional)"} 											-- single path
-			while not ready.left or not ready.right do
+
-				T:up(1)	-- go up from dirt to sapling level
+
-				local blockType = T:getBlockType("forward")
+
-				if blockType:find("log") ~=  nil then
+
-					ready[facing] = true
+
 	text[57] = {"height * 10 stone","height * 4 + 2 soul sand, 2 water buckets"} 						-- Boat bubble lift
-				if pattern == "single" then
+
-					--alternate between 2 trees, starts facing left
+
 	text[61] = {"512 stone","1 slab"} 																	-- 9x9 cube round spawner
-					if facing == "left" then
+
-						facing = "right"
+
-					elseif facing == "right" then
+
-						facing = "left"
+
 	text[64] = {"128 stone","2 water buckets","1 soul sand"} 											--Build bubble tower kill zone
-					blockType = T:getBlockType("forward")
+
-					if blockType:find("log") ~=  nil then
+
-						ready[facing] = true
+
 	text[66] = {"1856 stone, diorite etc (inc polished)","1 chest","10 empty buckets",
-					T:down(1)	-- drop below sapling to dirt level
+				"2 water buckets","192 fence","8 signs","3 ladder","2 soul sand"} 						-- build endermen observation tower
-				elseif pattern == "double" then
+
-					if ready.left and facing == "left" then-- tree on left now grown. check right
+
-						T:go("R2F2")
+
-						facing = "right"
+
 	text[73] = {"No items required"} 																	-- Clear wall height, length
-					blockType = T:getBlockType("forward")
+
-					if blockType:find("log") ~=  nil then
+
-						ready[facing] = true
+
 	text[77] = {"No items required"} 																	-- Dig a trench
-					T:down(1)	-- drop below sapling to dirt level
+
 	text[79] = {"width * height Any material floor / ceiling"} 											-- floor or ceiling
 	text[710] =	{"Blocks to add 'floor as you go'"} 													-- Direct control of movement
-				print("Farm type: "..pattern)
+
-				print("Waiting for tree growth "..elapsed / 60 .." minutes")
+
-				print("Left grown = "..tostring(ready.left)..", right grown = "..tostring(ready.right))
+
-				if not ready.left or not ready.right then
+
-					sleep(15)
+
-					elapsed = elapsed + 15
+
-					if pattern == "single" and elapsed / 60 > 10 then	-- max 10 mins real time before farm is harvested
+
 	text[86] = {"Full inventories of sand or stone"}													-- Ocean monument utilities
-					elseif pattern == "double" and elapsed / 60 > 15 then	-- max 15 mins real time before farm is harvested
+
 	text[88] = {"No items required"} 																	-- clear water plants
 	text[89] = {"water buckets / buckets"} 																-- convert flowing water to source
 	text[810] = {"6 buckets","slabs to cover area"} 													-- create sloping water
 
 	-- BUILDING and MINECART
-		-- growth complete
+
-		if pattern == "single" then
+
-			if facing == "right" then
+
 	text[94] = {"length * width * height stairs", "length * slabs"}										-- Build a pitched roof
 	text[95] = {"1 block of choice","1 redstone torch"} 												-- place redstone torch under current block
 	text[96] = {"1 block of choice","1 redstone torch"} 												-- place redstone torch on upward slope
 	text[97] = {"height x block of choice","height/3 x redstone torch"} 								-- build downward slope
-			--T:go("F1R1 F3R1")			-- facing first dirt
+
-			T:go("F1R1 F1R1")			-- facing first dirt
+
-		elseif pattern == "double" then -- assume on right side
+
-			if facing == "right" then
+
-				T:go("R1F1 R1F4 R1")
+
 	-- display help about selected task
-				T:go("L1F1 R1F2 R1")
+
 --[[This line of text = 39 characters]]
-		elseif pattern == "mangrove" then
+
-			T:go("D2F6 U1F1 R1F6 R1F1 U1")
+
 	info = {}
-		-- ends facing dirt at base of first tree
+
-		-- no return needed, function exit so trees are grown
+
 	table.insert(info.main,
 	[[                ~lightGray~MINING:~white~
-	function lib.watchFarm(R)
+
-		-- rotate to check if dirt on both sides
+
-		-- R.subChoice == 1: 16 single trees, 2 = 4 doubles
+
-		if R.logType ~= "mangrove" then
+
-			R.treeSize = "single"
+
-			T:turnRight(2)	-- if no dirt then on 4 x doubles
+
-			if T:getBlockType("forward") == "" then
+
-				R.treeSize = "double"
+
 the fuel and time)
-			T:saveToLog("lib.watchFarm: R.treeSize set to '"..R.treeSize.."'")
+
-			T:turnLeft(2)	-- face lower left double dirt
+
 	table.insert(info.main,
-		lib.waitForGrowth(R)
+
 Fell Tree can be used in Nether as well
-		return R
+
 Create a simple 16 single tree farm
 or 4 double size (Dark oak or any type)
-	function lib.harvestSingle(direction, moves)
+
-		-- if direction == "up": starting inside tree on dirt at dirt level
+
-		T:saveToLog("lib.harvestSingle('"..direction.."', moves = "..moves)
+
 ~green~Forest can be harvested and replanted.
-			while turtle.detectUp() do
+
 
 ]])
 	table.insert(info.main,
-		else	-- direction = "down", but could be mid-tree
+
-			local movesUp = 0
+
-			while turtle.detectUp() do
+
 or rectangular pattern.~lime~
-				movesUp = movesUp + 1
+
 turtle, which must be equipped with a
-			T:down(movesUp)
+
-			T:down(moves)
+
 corner of each module.
 Double chests store produce and seeds.
 ]])
 	table.insert(info.main,
-	function lib.harvestSingleRow()
+
-		-- start next to tree/dirt
+
 lava areas safely.~pink~
-		local moves = lib.harvestSingle("up", 0)
+
-		T:go("F2")
+
-		lib.harvestSingle("down", moves)
+
-		T:go("F2")
+
-		moves = lib.harvestSingle("up", 0)
+
-		T:go("F2")
+
-		lib.harvestSingle("down", moves)
+
 Minecart end portal stations built.
 ]])
-	function lib.harvestDouble()
+
-		T:forward(1)	-- dig dirt, move into left (S) corner
+
 Can be used in Nether and End.~lightGray~
-		while turtle.detectUp() do
+
-			turtle.dig()
+
-			turtle.digUp()
+
 at the same time.~blue~
 Build a water canal with towpath.~cyan~
 Build a super-fast ice canal.~brown~
-		turtle.dig()
+
-		T:go("R1F1L1")	-- move to right corner
+
 1 block lower each time
-			turtle.dig()
+
-			turtle.digDown()
+
 	[[             ~lightGray~SPAWNER FARMS:~brown~
 Tools to create mob farms round
-		turtle.dig()
+
-		T:go("F1L1F1R1") -- move to left corner (N)
+
 uses rail collection.~cyan~
 Choice of bubble lift mob dropper
-	--T:setUseLog(true, "treeFarmLog.txt", true)	-- T:setUseLog(use, filename, delete)
+
-	--dbug = true								-- set dbug flag
+
 built >128 above ground: is ~red~expensive.~gray~
 Re-spawns new mobs when used.~red~
-	-- if on modem, R.networkFarm has already been set
+
-	T:saveToLog("harvestTreeFarm(R) R.networkFarm = "..tostring(R.networkFarm))
+
 	table.insert(info.main,
-	if R.networkFarm then
+
-		local message = network.loadStorageLists()	-- initialises or creates lists of where an item can be found: GLOBAL LISTS!
+
-		if message ~= nil then return {message} end
+
-		network.emptyInventory(R, {"sapling", "propagule", "dirt"}, {"all"}, true)
+
 Clear hollow and~orange~solid structures.~brown~
 Dig a trench.~gray~
-	if turtle.getFuelLevel() < turtle.getFuelLimit() / 2 then
+
-		local turtleSlot, turtleCount = network.getItemFromNetwork("chest", "log", 16)
+
-		if turtleSlot > 0 then
+
-			if turtle.craft() then
+
 
-				T:saveToLog("harvestTreeFarm(R) R.networkFarm = "..tostring(R.networkFarm))
+
 	table.insert(info.main,
 	[[      ~blue~WATER AND LAVA TOOLS:~white~
 Used to drain ocean monuments and
 shipwrecks. Can also be used to make
-	if R.networkFarm then			-- monitor trees for growth
+
-		if R.logType == "mangrove" then
+
 Destructive draining uses solid block
-			T:place("dirt", "up")
+
-			T:go("F6x2U1L1")	-- move under dirt covering, clear roots from hopper, move level with dirt, face left
+
 damaging structures.~lightBlue~
-			T:go("F4R1")				-- either in between 2 trees or in gap between double trees at dirt level
+
-			if turtle.detect() then		-- single trees, move between 1st and 2nd rows
+
-				T:go("R1F1 R1F2 R1F1 L1")
+
-			else	-- using double trees
+
-				T:go("R2F1")
+
-				if not turtle.detect() then
+
-					return {"Unable to determine position"}
+
 ~orange~Used to build diagonal uphill slope~brown~
 and downhill slope for placing
 45 degree rail tracks.~red~
-		R = lib.watchFarm(R)	-- wait for trees to grow, then start harvest
+
 rails when above ground level (viaduct)
-		--logType, startHeight, R = lib.initialise(R) -- possible ID tree type + move to correct position 1 above dirt
+
-		R, message = lib.initialise(R) 		-- possible ID tree type + move to correct position next to first dirt
+
-		if message ~= "" then
+
-			return{message}
+
 	table.insert(info.main,
 	[[           ~yellow~MEASURING TOOLS:
-	T:saveToLog("R.networkFarm = "..tostring(R.networkFarm)..", logType = "..R.logType..", treeSize = "..R.treeSize)
+
-	-- different clearing for different trees:
+
-	-- double spruce and jungle: staight up/down or small
+
-	if R.logType == "mangrove" then
+
-		clearRectangle({width = 13, length = 13, up = true, down = true })
+
-		T:go("U2F2 R1F2L1")
+
-		clearSolid({width = 9, length = 9, height = 18, direction ="up"})
+
-		T:go("D3R1 F4R1 F3R2")
+
-		network.emptyInventory(R, {"sapling", "propagule", "dirt", "crafting"}, {"all"}, true)
+
-	elseif R.logType == "birch" or R.logType == "spruce" or R.logType == "jungle" then	-- use column harvest
+
-		if R.treeSize == "single" then
+
-			lib.harvestSingleRow()
+
-			T:go("F1R1F2R1")
+
-			lib.harvestSingleRow()
+
-			T:go("F1L1F2L1")
+
-			lib.harvestSingleRow()
+
-			T:go("F1R1F2R1")
+
-			lib.harvestSingleRow()
+
-			if R.networkFarm then
+
-				T:go("F1R1 F3L1 F3R2")
+
-				network.emptyInventory(R, {"sapling", "propagule", "dirt", "crafting"}, {"all"}, true)
+
 ~lightGray~| | | | | |
-				T:go("F1R1 F6L1 F3R2")
+
 
 ]]-- Ladder up/down
-			lib.harvestDouble()
+
-			T:go("F3")
+
-			lib.harvestDouble()
+
-			T:go("R1F4")
+
-			lib.harvestDouble()
+
-			T:go("R1F4")
+
-			lib.harvestDouble()
+
-			if R.networkFarm then
+
-				T:go("F1R1 F3L1 F3R2")
+
-				network.emptyInventory(R, {"sapling", "propagule", "dirt", "crafting"}, {"all"}, true)
+
 
-				T:go("F1R1 F6L1 F3R2")
+
 ]] -- Stairs up/down
 		info.sub[13] =
-	else	-- use cube harvest, including mangrove
+
-		local size = 10
+
-		local start = "L1F1 L1F1 R2"
+
-		local finish = "R1F1 R1F3 R2"
+
-		if R.logType == "acacia" then
+
-			size = 12
+
-			start = "L1F2 L1F2 R2"
+
-			finish = "R1F2 R1F2 R2"
+
-		elseif R.logType == "cherry" then
+
-			size = 14
+
-			start = "L1F3 L1F3 R2"
+
-			finish = "R1F3 R1F1 R2"
+
 	else
-		T:go("U1F1")	-- into first log at base of tree
+
-		clearRectangle({width = 7, length = 7, up = true, down = true})
+
-		--T:go("L1F2 L1F2 R2")	-- rect size 12
+
-		--T:go("L1F1 L1F1 R2")	-- rect size 10
+
-		T:go(start)
+
-		local height = 0
+
-		local pastLogCount = -1
+
-		local currentLogCount = lib.getLogCount()
+
-		--while currentLogCount ~= pastLogCount do
+
-		while currentLogCount - pastLogCount > 5 do	-- ony continue if at least 5 logs harvested last round
+
-			T:up(3)
+
 ~lightGray~| | | | | | ~red~^ = Turtle facing forward
-			pastLogCount = currentLogCount -- 0 when loop starts
+
-			--clearRectangle({width = 12, length = 12, up = true, down = true})
+
-			clearRectangle({width = size, length = size, up = true, down = true})
+
-			currentLogCount = lib.getLogCount() -- eg 20 logs from first round
+
-		end
+
-		T:down(height + 1)
+
-		--T:go("R1F2 R1F2 R2")		-- on polished stone rect size 12
+
-		--T:go("R1F1 R1F3 R2")		-- on polished stone rect size 10
+
-		T:go(finish)
+
-		if R.networkFarm then
+
-			T:go("R1F3 L1")			-- on modem
+
-			network.emptyInventory(R, {"sapling", "propagule", "dirt", "crafting"}, {"all"}, true)
+
 | |~blue~^~brown~|L|~blue~^~lightGray~| | ~brown~L = ladder
 ~lightGray~| | | | | | ~blue~^ = Turtle facing forward
 ~lightGray~| | | | | | ~blue~^ = Bubble column above
-	return {}	-- if player initiated, stops here. If R.auto then returns to plantTreeFarm()
+
 ]] -- single column bubble lift
 	info.sub[16] =
 [[~yellow~Place me as below:
  1. On ~blue~floor   ~yellow~(feet height)
  2. On ~lime~ceiling ~yellow~(eye height)
 
 ~lightGray~B|B|B|B|B|B|B    ~yellow~W I D T H
 ~lightGray~B| | | | | |B               ~orange~L
 ~lightGray~B| |B|B|B| |B               ~orange~E
 ~lightGray~B| |B|B|B| |B               ~orange~N
 ~lightGray~B| |B|B|B| |B               ~orange~G
 ~lightGray~B|~red~^~lightGray~| | | | |B  ~red~^~lightGray~ = Turtle   ~orange~T
 ~lightGray~B|~cyan~P~lightGray~|B|B|B|B|B  ~cyan~P~lightGray~ = Player   ~orange~H
 ]] -- quick corridor system
 	info.sub[17] =
 [[~yellow~~yellow~Place me as below:
  1. On ~blue~floor   ~yellow~(feet height)
  2. On ~lime~ceiling ~yellow~(eye height)
 ~lightGray~B|B|B|B|B|B|B
 B| | | | | |B
 B| |B|B|B| |B
 B| |B|B|B| |B
 B| |~lime~^~lightGray~|B|B| |B
 B|~red~^~lightGray~|~magenta~^~lightGray~| | | |B ~white~^~lightGray~ = turtle
 B|~cyan~P~lightGray~|B|B|B|B|B ~cyan~P~lightGray~ = Player
 ~yellow~Note colour of ~white~^~yellow~ matches next screen->
 ]] -- quick mine
 		info.sub[18] =
 [[~yellow~Place me level -59 / 5 on the floor to
 expose bedrock ~red~(slow and inefficient)
 
 ~lightGray~| | | |B| |B|     ~yellow~W I D T H
 ~lightGray~|B| | | | | |B               ~orange~L
 ~lightGray~| | | |B|B| |                ~orange~E
 ~lightGray~| | |B| | |B|                ~orange~N
 ~lightGray~|B| | | |B| |                ~orange~G
 ~lightGray~| | | | | | |B               ~orange~T
 ~lightGray~|~red~^~lightGray~| | | |B| |B  ~red~^~lightGray~ = Turtle   ~orange~H
 ]] -- mine all blocks to bedrock pre 1.12
 		info.sub[19] =
 [[~yellow~Place me on the end wall of a disused
 mine in the centre block, 1 block above
 the floor.
 Provide a ~cyan~diamond ~yellow~sword for
 harvesting string from spider webs~lightGray~
 
 ~gray~-------   - = Ceiling
 ~lightGray~| | | |
 | |~red~T~lightGray~| |  ~red~T = Turtle (facing wall)
 ~lightGray~| | | |
 ~gray~-------  - = Floor
 ]] -- salvage mineshaft
 	info.sub[21] =
 [[~yellow~Place me as below.
 ~brown~Chest ~yellow~ONLY required if ~blue~0 ~yellow~fuel
 
 Plan view:
 
 ~green~   | | | |
 ~green~   | |~lime~T~green~| |  ~lime~T = Tree
 ~green~   | |~red~^~green~| |  ~red~^ = Turtle
 ~green~   | | | |
 
 
 
 ]] -- Fell Tree
 	info.sub[22] =
 [[~yellow~Place me on ground as below ~red~^
 ~lime~|*|~blue~ | | | | | | ~green~or |*|~blue~ | | ~brown~|D| |D|
 ~lime~|*|~blue~ | | ~brown~|D|D|~blue~ | ~green~or |*|~blue~ | | | | | |
 ~lime~|*|~blue~ | | ~brown~|D|D|~blue~ | ~green~or |*|~blue~ | | ~brown~|D| |D|
 ~lime~|*|~blue~ | | | | | | ~green~or |*|~blue~ | | | | | |
 ~lime~|*|~blue~ | | | | | | ~green~or |*|~blue~ | | | | | |
 ~lime~|*|~blue~ | | | | | | ~green~or |*|~blue~ | | | | | |
 ~lime~|~red~^~lime~|*|*|*|~blue~M~lime~|*| | ~green~or |~red~^~green~|*|*|*|~blue~M~green~|*|*|
 ~lime~4 ~brown~double ~green~       or 16 ~brown~single
 ~brown~D = Dirt, ~red~^ = Turtle, ~blue~M = Marker stone
 ]] -- Create treefarm
 	info.sub[23] =
 [[~yellow~Place me on ground as below ~red~^
 ~lime~|*|~blue~ | | | | | | ~green~or |*|~blue~ | | ~brown~|D| |D|
 ~lime~|*|~blue~ | | ~brown~|D|D|~blue~ | ~green~or |*|~blue~ | | | | | |
 ~lime~|*|~blue~ | | ~brown~|D|D|~blue~ | ~green~or |*|~blue~ | | ~brown~|D| |D|
 ~lime~|*|~blue~ | | | | | | ~green~or |*|~blue~ | | | | | |
 ~lime~|*|~blue~ | | | | | | ~green~or |*|~blue~ | | | | | |
 ~lime~|*|~blue~ | | | | | | ~green~or |*|~blue~ | | | | | |
 ~lime~|*|*|*|*|~red~^~lime~|*| | ~green~or |*|*|*|*|~red~^~green~|*|*|
 ~green~4 ~brown~double ~green~       or 16 ~brown~single
 ~brown~D = dirt,~red~^ = Turtle, ~yellow~Max 16 saplings
 Mixed OK. ~lime~Group 4 for double trees
 ]] -- Plant treefarm / Harvest treefarm
 	info.sub[24] = info.sub[23]
 	info.sub[25] =
 [[~yellow~Place me at ~red~^
 
 ~lightGray~|F|F|F|F|F|F|F| F = Fence or Wall
 ~lightGray~|F|~brown~B~lime~| | | |~brown~B~lightGray~|F| ~brown~B = Barrel (corners)
 ~lightGray~|F|~lime~ | | | | ~lightGray~|F|
 ~lightGray~|F|~lime~ | | | |~cyan~T~lightGray~|F| ~cyan~T = Tree
 ~lightGray~|F|~lime~ |~cyan~T~lime~| | | ~lightGray~|F|
 ~lightGray~|F|~lime~ | | | | ~lightGray~|F|
 ~lightGray~|F|~brown~B~lime~| |~cyan~T~lime~| |~brown~B~lightGray~|F|
 ~lightGray~|~red~^~lightGray~|F|F|F|F|F|F| ~red~^ = Turtle
 ~yellow~Fence/Wall follows land contours
 ]] --
 	info.sub[26] =
 [[~yellow~A rectangular walled area of forest:
 Place me at ~red~^
 
 ~lightGray~|F|F|F|F|F|F|F| F = Fence or wall
 ~lightGray~|F|~brown~B~lime~| | | |~brown~B~lightGray~|F| ~brown~B = Barrel (corners)
 ~lightGray~|F|~lime~ | | | | ~lightGray~|F|
 ~lightGray~|F|~lime~ | | | |~cyan~T~lightGray~|F| ~cyan~T = Tree
 ~lightGray~|F|~lime~ |~cyan~T~lime~| | | ~lightGray~|F|
 ~lightGray~|F|~lime~ | | | | ~lightGray~|F|
 ~lightGray~|F|~red~^~lime~| |~cyan~T~lime~| |~brown~B~lightGray~|F| ~red~^ = Turtle ~brown~(on Barrel)
 ~lightGray~|F|F|F|F|F|F|F|
 
 ]] -- manage walled forest
 	info.sub[31] =
 [[~yellow~Place me on the ground as below ~red~^
 
 ~lightGray~|*|~green~ | | | | | | | | ~lightGray~* = Wall
 ~lightGray~|*|~green~ | | | | | | | |
 ~lightGray~|*|~green~ | | | | | | | |
 ~lightGray~|*|~green~ | | | | | | | |
 ~lightGray~|*|~green~ | | | | | | | |
 ~brown~|B|B~green~| | | | | | | | ~brown~B = Barrel or Chest
 ~brown~|B|~blue~W~green~| | | | | | | | ~blue~W = Water
 ~lime~|~red~^~lime~|~brown~B|B|~lightGray~*|*|*|*|*|*| ~red~^ = Turtle
 ~yellow~                    Size = 13 x 13
 ]] -- Create modular crop farm
 	info.sub[32] =
 [[~yellow~Place next to the tree as below ~red~^
 
 ~lightGray~|*|~green~ | | | | | | | | ~lightGray~* = Wall
 ~lightGray~|*|~green~ | | | | | | | |
 ~lightGray~|*|~green~ | | | | | | | |
 ~lightGray~|*|~green~ | | | | | | | |
 ~lightGray~|*|~green~ | | | | | | | | ~brown~B = Barrel or Chest
 ~brown~|B|B~green~| | | | | | | | ~blue~W = Water
 ~brown~|B|~blue~W~green~| | | | | | | | ~orange~S = Sapling or Tree
 ~orange~|S|~red~^~brown~|B|~lightGray~*|*|*|*|*|*| ~red~^ = Turtle
 ~yellow~                    Size = 13 x 13
 ]] -- Extend farm
 	info.sub[33] =
 [[~yellow~Place as below (2 choices) ~blue~> ~yellow~or ~red~<
 
 ~lightGray~|*|~green~ | | | | | | | | ~lightGray~* = Wall
 ~lightGray~|*|~green~ | | | | | | | |
 ~lightGray~|*|~green~ | | | | | | | |
 ~lightGray~|*|~green~ | | | | | | | | ~brown~B = Barrel or Chest
 ~lightGray~|*|~green~ | | | | | | | | ~blue~> = turtle on Water
 ~brown~|B|B~green~| | | | | | | | C = Crop (first)
 ~brown~|B|~blue~>~green~|C| | | | | | | ~orange~S = Sapling or Tree
 ~orange~|S|~red~<~brown~|B|~lightGray~*|*|*|*|*|*| ~red~< = Turtle on Chest
 ~yellow~Options to harvest or manage to follow.
 ]] -- Manual harvest and auto setup
 	info.sub[34] =
 [[~yellow~Build a ~brown~fence ~yellow~or ~lightGray~wall ~yellow~to chosen length.
 
 Turtle goes ~orange~BACKWARDS ~yellow~when started.
 
 Start: length = 6, Turtle facing right
 
 ~lightGray~| |~red~>~lightGray~| | | | | | | ~red~> = Turtle
 
 Finish:
 
 ~lightGray~| |F|F|F|F|F|F| | F = Fence or Wall
 ]] -- build fence or wall
 	info.sub[35] =
 [[~yellow~Build a ~brown~fence ~yellow~or ~lightGray~wall ~yellow~
 rectangular area.
 
 ~lightGray~| | | | | | | | ~brown~F = Fence or Wall
 ~lightGray~| ~brown~|F|F|F|F|F~lightGray~| |
 ~lightGray~| ~brown~|F| | | |F~lightGray~| |
 ~lightGray~| ~brown~|F| | | |F~lightGray~| |
 ~lightGray~| ~brown~|F| | | |F~lightGray~| |
 ~lightGray~| |~red~^~brown~|F|F|F|F| | ~red~^ = Turtle
 ~lightGray~| | | | | | | |
 
 ]] -- build rectangular fence or wall
 	info.sub[41] =
 [[~yellow~Place me on any block on the left
 side facing the obsidian field.
 
 ~gray~|O|O|O|O|O| O = Obsidian
 |O|O|O|O|O|
 |O|O|O|O|O|
 |O|O|O|O|O|
 |~red~^~gray~|O|O|O|O| ~red~^ = Turtle
 |~red~^~gray~| | | | |
 
 ]] -- Harvest obsidian
 	info.sub[42] =
 [[~yellow~Place me on the ground as below ~red~> ~pink~^
 ~yellow~Start ~red~> ~yellow~(facing right) or ~pink~^ ~yellow~ahead
 
 ~lightGray~| |~red~>~lightGray~|O|O|*| | |    |*|O|O|*| face view
    ~pink~^~lightGray~               |O|~purple~+ +~lightGray~|O|
                    |O|~purple~+ +~lightGray~|O|
 ~yellow~Result (plan)      ~lightGray~|O|~purple~+ +~lightGray~|O|
 ~lightGray~| |O|O|O|O| | |    |*|O|O|*|
                    ~green~--------- ground
 ~yellow~width=4, ~orange~height=5 ~red~(frame size)
 ]] -- build Nether portal
 	info.sub[43] = info.sub[42] -- Demolish Nether portal
 	info.sub[44] =
 [[~yellow~Press F3+G for chunk boundaries
 Netherite stripmine plan view
 
 ~lightGray~|*|*|*~lime~N~lightGray~*|*|*|
 ~lightGray~|*|*|*~lime~|~lightGray~*|*|*| ~lime~-| = Chunk Boundaries
 ~lightGray~|*|~red~^~lightGray~|*~lime~|~lightGray~*|~red~^~lightGray~|*|  ~red~^ = Turtle
 ~lime~W*-*-*~blue~+~lime~*-*-*E  ~blue~+ = Boundaries junction
 ~lightGray~|*|*|*~lime~|~lightGray~*|*|*|
 ~lightGray~|*|*|*~lime~|~lightGray~*|*|*|  ~yellow~North of WE
 ~lightGray~|*|*|*~lime~S~lightGray~*|*|*|  ~yellow~1 block from NS
 Most generate close to chunk boundaries
 ]] -- Netherite stripping
 	info.sub[45] =
 [[~yellow~Place me on the ground ~red~<~yellow~ facing ~red~West.
 
 ~lime~x
                  ~lightGray~N
 ~lime~a~lightGray~   -1        | | | |
 ~lime~x~lightGray~    0       ~red~W~lightGray~| |~red~<~lightGray~| |E  ~red~< = Turtle
 ~lime~i~lightGray~    1        | | | |
 ~lime~s~lightGray~                S
     ~green~z axis    ~lightGray~-1 0 1
 
 Centre of the dragon arena ~lime~X = 0, ~green~Z = 0
 ~yellow~                           facing ~red~West
 ]] -- Find dragon tower centres
 	info.sub[46] =
 [[~yellow~Place turtle in ceiling facing endstone
 
 Plan view    Side view
 ~gray~             |*|*|*|*|*|
     |*|      |*|*|*|*|*|
   |*|*|*|    |*|*|*|*|*|
 |*|*|*|*|*|  |*|*|*|*|*|  * ~lightGray~= Obsidian
 ~gray~|*|*|~yellow~E~gray~|*|*|  |*|*|*|*|*|  ~yellow~E ~lightGray~= Endstone
 ~gray~  |*|~red~^~gray~|*|    |*|*|~red~T~gray~|*|*|~red~ ^T ~lightGray~= Turtle
 ~gray~    |*|      |*|*| |*|*|
              |*|*| |*|*|
 ]] -- deactivate dragon tower
 	info.sub[47] =
 [[~yellow~Place turtle on the ground at 100,49,0
 
 |*|*|*|*|*|*|*|*|*|   ~lightGray~= Dragon Island
 
 
 ~yellow~    Facing WEST
 ~gray~    |*|*|*|*|*|     * ~lightGray~= Obsidian plate
 ~gray~    |*|*|*|*|*|
 ~yellow~  S ~gray~|*|*|~red~T~gray~|*|*| ~yellow~N   ~red~T ~lightGray~= Turtle
 ~gray~    |*|*|*|*|*|
     |*|*|*|*|*|
 ~yellow~         E]] -- build dragon water trap
 	info.sub[48] =
 [[~yellow~Place turtle under end world portal
 
 ~gray~        |B|     B ~lightGray~= Bedrock
 ~gray~      |B|B|B|
         ~purple~|P|     P ~lightGray~= Portal
 ~gray~      |B|B|B|
         |B|
          ~green~|
          ~green~|      ~lime~Height measured first
          ~green~|
 ~red~         T	     T ~lightGray~= Turtle
 ~yellow~  |*|*|*|*|*|*| ~red~Inventory AFTER height
 ]] -- build end portal minecart
 
 	info.sub[491] =
 [[~yellow~Place turtle <64 blocks from shulker
 Directly below or 1 block in front
 ~lightGray~|*|*|*|*|*|*|*|
      ~gray~> ~lime~S ~gray~<       > T < = kill positions
        ~gray~T
 
 
 
      ~red~> T <       Attacks ahead / above
 ~lightGray~|*|*|*|*|*|*|*|
 
 ~red~> T <~lightGray~ = Turtle   ~lime~S~lightGray~ = Shulker]] -- Shulker is above
 
 	info.sub[492] =
 [[~yellow~Place turtle <64 blocks from shulker
-local function upgradeFarmland(R)
+
-	local essences = {":inferium", ":prudentium", ":tertium", ":imperium", ":supremium", ":awakened" , ":insanium"}
+
    ~red~>~lightGray~ | | | | | |~lime~S~lightGray~|
 
 ~yellow~Side view:
-	function lib.isHigherTeir(essence, farmLand)
+
-		-- eg "ma:prudentium_essence", "mc:farmland"
+
-		local teir = 0
+
-		for index = 1, #essences do
+
-			if farmLand:find(essences[index]) ~= nil then
+
-				teir = index	-- 0 if vanilla, else eg 2 for prudentium
+
 	info.sub[493] =
 [[~yellow~Place turtle <64 blocks from shulker
 Directly above or 1 block in front
-		for index = 1, #essences do
+
-			if essence:find(essences[index]) ~= nil then
+
-				if index > teir then
+
 
 
        ~gray~T
      ~gray~> ~lime~S ~gray~<       > T < = kill positions
 ~lightGray~|*|*|*|*|*|*|*|
 
 ~red~> T <~lightGray~ = Turtle   ~lime~S~lightGray~ = Shulker]] -- Shulker is below
-	function lib.upgrade(essence, slot)
+
-		-- essence is the slot no of any essence
+
-		turtle.select(slot)
+
-		local blockType = T:getBlockType("up")
+
-		if blockType:find("farmland") ~= nil then			-- farmland found (vanilla or modded)
+
-			if lib.isHigherTeir(essence, blockType) then	-- eg "ma:inferium", mc:farmland"
+
-				turtle.placeUp()
+
 ~lightGray~|*|~orange~+~lightGray~| | |~red~+~lightGray~| | |~blue~+~lightGray~|*|     ~yellow~Plan view
 ~lightGray~|*|~orange~+|+|+|~red~+|~blue~+|+|+~lightGray~|*|    |*|*|*|*|*|
 ~lightGray~|*|*|*|~orange~+|~red~+|~blue~+~lightGray~|*|*|*|    |*| |~red~T~lightGray~| |*|
-	-- check if any essence still onboard
+
-	T:checkInventoryForItem({"essence"}, {95}, false)
+
-	-- return slotData.lastSlot, total, slotData -- integer, integer, table
+
-	local name = ""
+
-	local slot, amount, data = T:getItemSlot("essence")
+
-	name = data.mostName or ""
+
-	local empty = T:getFirstEmptySlot()
+
 clear the roof above and return
-	if slot > 0 then
+
-		T:go("D2")
+
 ~lightGray~|*|~red~<~lightGray~| | | | | | |~red~^~lightGray~|*|  ~yellow~area regardless
-		for w = 1, 10 do
+
-			for i = 1, 9 do
+
-				if turtle.getItemCount(slot) == 0 then
+
-					slot, amount, data = T:getItemSlot("essence")
+
-					name = data.mostName or ""
+
-					if slot == 0 then
+
-						slot = empty
+
 [[~yellow~Place turtle in corner against ceiling
 Face ~red~direction ~yellow~shown. It will exit out,
-				lib.upgrade(name, slot)
+
-				if w == 1 and i == 1 then
+
-					T:go("F1R2 C1R2")
+
-				elseif w == 10 and i == 1 then
+
-
+
 
 ~lightGray~|*| | | | | | | | |*|
 ~lightGray~|*|~red~V~lightGray~| | | | | | |~red~>~lightGray~|*|
 ~lightGray~|*|*|*|*|*|*|*|*|*|*|]] -- Clear outside wall
 
-				lib.upgrade(name, slot)
+
-				if w == 1 then
+
-					T:go("L1F1 L2C1 R1")
+
-				elseif w == 9 then
+
-					T:go("L1F1 L1F1 L2C1 L2")
+
 ~blue~        |-|-|-|
 ~lightGray~        |*|~red~^~lightGray~|*|    ~red~^ = Turtle
 
 ~yellow~Result:~blue~ |-|~lightGray~*|~blue~-|    - = air/water
-				if w < 10 then
+
-					lib.upgrade(name, slot)
+
 ~lightGray~        |*|*|*|    * = Solid block
 ]] -- Single path
-					T:go("L1F1 L2C1 R2F8 L1U1 C2U2") -- 1 above normal position
+
 [[~yellow~Place ~red~^ T~yellow~ at start of path or tunnel
 
 ~yellow~Plan view    Face view
 
-		-- sometimes original essence pops out of the ground when upgraded, so rescue it
+
-		for w = 1, 10 do
+
-			for i = 1, 9 do
+
-				turtle.suckDown()
+
-				turtle.suck()
+
 
 ~green~Floor + ceiling ~yellow~placed for your safety!
 ]] -- Covered walkway / tunnel
-				turtle.suckDown()
+
-				turtle.suck()
+
 
 ~lightGray~|*|~blue~-|-~lightGray~|*|
-				if w < 10 then
+
-					turtle.suckDown()
+
-					turtle.suck()
+
 
 ~yellow~New canal       ~lime~1 ~orange~2 ~brown~3 ~green~4 ~yellow~ground level-63
-					T:go("L1F9 L1D1") -- normal position
+
 ~yellow~Extend existing   ~blue~5 ~cyan~6   ~yellow~water  level-62
 ]] -- new/existing canal
 	info.sub[54] =
 [[~lime~New ~yellow~ice canal or ~lightBlue~convert ~yellow~existing water
 
-	return ({"Farmland Upgraded"})
+
 ~lightGray~ |~orange~T~lightGray~|~blue~I~lightGray~| |*| 	 ~blue~I = Ice (packed or blue)
 ~lightGray~ |*| | |*| 	| | = Air (empty block)
 ~lightGray~ |*|~blue~I~lightGray~| |~orange~T~lightGray~|   ~orange~T = Torch (optional)
 ~lime~  1 2 3 4    New ice canal
 ~lightBlue~  5 6 7 8    Convert water canal
-	function lib.askPlayerForCrops()
+
-		local seed  = ""
+
-		pp.itemColours = {colors.lightGray, colors.red, colors.orange, colors.brown, colors.magenta, colors.yellow}
+
-		crops = {"minecraft:wheat_seeds", "minecraft:beetroot_seeds", "minecraft:carrots", "minecraft:potatoes", "mysticalagriculture", "none"}
+
-		choices = {"wheat (seeds)", "beetroot (seeds)", "carrot", "potato", "Mystical Agriculture", "Till soil only"}
+
 [[~yellow~Place ~red~^~yellow~ any level air, water or lava.~lightGray~
 
-		if crop == "none" then
+
-			return "", ""
+
-		elseif crop == "mysticalagriculture" then
+
-			T:checkInventoryForItem({"seeds"}, {95}, true, "Add one type of M. Agriculture seeds")
+
 | |*|*|*|*|*| |
-			T:checkInventoryForItem({crop}, {95}, true, "Do not mix! add as many as you want")
+
 | | | | | | | |
-		crop = T:getMostItem("", false)		-- not searching for any specific item, not checking stone only
+
-		-- crop could be wheat/beetroot seeds, carrots, potatoes or mystical agriculture seeds
+
-		seed, crop = lib.getCropSeed(crop)	-- seed type or "", crop type
+
-		return seed, crop
+
 [[~yellow~Place ~red~^~yellow~ above water.~lightGray~
 Existing platform replaced below
-	function lib.assessPlot(R)
+
-		local crop = T:getBlockType("forward")	-- convert ma:inferium_crop to ma:inferium_seeds
+
-		local seed = lib.getCropSeed(crop)
+
-		turtle.down()									-- into water source
+
-		local soil = T:getBlockType("forward")
+
-		turtle.up()										-- at crop level
+
-		return crop, seed, soil
+
 
 Blocks placed under the turtle
-	function lib.checkEquipment(R, itemRequired)
+
-		-- Check if item is equipped and return it to slot
+
 [[~yellow~Boat Lift (Ice or Water)
 Place turtle left side. ~blue~Source~yellow~ to right
-		local equipped, slot = T:getEquipped("right", false)	-- see what is equipped and replace it
+
-		if equipped == itemRequired then
+
-			equipped, slot = T:getEquipped("right", true)		-- remove item and return slot
+
-			return slot
+
 |*|*|*|*|    |*|~brown~S|S~lightGray~|*| ~brown~S = ~lightGray~Sand + gate
 |~red~^~lightGray~|~blue~W|W~lightGray~|*|    |*~blue~|W|W|~lightGray~*| ~red~^ ~lightGray~= Turtle
-		return 0	-- not found
+
 |*|~blue~ | ~lightGray~|*|    |*|~blue~ | ~lightGray~|*| ~yellow~Ice canal needs
 ~lightGray~|*|~blue~ | ~lightGray~|*|    |*|~blue~ | ~lightGray~|*| ~yellow~2x2 water source
-	function lib.crossFarm(R)
+
 	info.sub[61] =
 [[~red~NOT ~yellow~for Blaze spawners!
-		local isReady, cropType, seed, status
+
-		isReady, cropType, seed, status, R = lib.isCropReady(R,"down")
+
-		-- will go forward until chest, barrel, modem or cobble detected below
+
 T|*| | | | | |*|T  |*| | | | | |*|
  |*| | |~magenta~5~lightGray~| | |*|   |*| | |~magenta~5~lightGray~| | |*|
  |*| |~magenta~5~lightGray~|~orange~S~lightGray~|~magenta~5~lightGray~| |*|   |*|~lime~3~lightGray~|~magenta~5|~orange~S~lightGray~|~magenta~5|~green~4~lightGray~|*| Base
  |*| | |~magenta~5~lightGray~| | |*|
 T|*| | | | | |*|T  * = Dungeon Wall
  |*|*|*|*|*|*|*|   ~orange~S = Spawner
 ~lightGray~    T       T      T = Turtle ~brown~1 ~yellow~2 ~lime~3 ~green~4
-			elseif  blockType:find("barrel") ~= nil or
+
-					blockType:find("chest") ~= nil or
+
-					blockType:find("modem") ~= nil or
+
-					blockType:find("cobble") ~= nil then
+
 Plan view          Side view
 
 ~lightGray~|*|*|*|*|*|*|*|*|  ~lime~> T = Continue build
 ~lightGray~|*| | | | | | | |  ~red~< T = New build
-		return R, blockType -- either barrel, chest, modem or cobble
+
 |*| | | |~purple~S~lightGray~| | | |~lime~>~red~<          T
 ~lightGray~|*| | | | | | | |   |*| | | |~purple~S~lightGray~| | | |~red~T
-	function lib.farmAll(R, isFarmToRight, isFarmToFront)
+
-		local plotCountR = 0		-- plot a1 harvested
+
-		local plotCountF = 0		-- plot a1 harvested
+
                                      ~red~T]] -- 9x9 cube round blaze spawner
-			while isFarmToRight do	-- do all plots on this axis
+
-				R, isFarmToRight = lib.farmToRight(R) -- plot harvested and back to plot origin
+
-				plotCountR = plotCountR + 1
+
 ~lightGray~ |*| | | | | | | | | |*|  |*| | | | | |
-			lib.goToLeft(R, plotCountR)
+
  |*| | | | | | | | | |*|  |*| | | | | |
  |*| | | | | | | | | |*|  |*| | | | | |
-			while isFarmToFront do	-- do all plots on this axis
+
-				plotCountR = 0				-- reset
+
-				R, isFarmToRight, isFarmToFront = lib.farmInFront(R)
+
-				if isFarmToRight then
+
-					while isFarmToRight do	-- do all plots on this axis
+
-						R, isFarmToRight = lib.farmToRight(R) -- plot harvested and back to plot origin
+
-						plotCountR = plotCountR + 1
+
 [[~yellow~Bubble lift: Plan view at start~lightGray~
-					lib.goToLeft(R, plotCountR)	-- return home and continue with front
+
  |*| | | | |~brown~F~lightGray~| | | | |*|
-				plotCountF = plotCountF + 1
+
            ~brown~|~red~^~brown~|~lightGray~= Turtle on ~brown~Soul Sand
-			lib.goToFront(R, plotCountF)
+
 ~yellow~Plan view completed~lightGray~
  |*| | | | |~brown~F~lightGray~| | | | |*|
  |*|*|*|*|*|~brown~F~lightGray~|*|*|*|*|*|  ~brown~F ~lightGray~= Fence
-	function lib.farmInFront(R)
+
            ~lightGray~|*|        ~blue~S ~lightGray~= Bubble lift
-		T:go("U1L1 F11D1 R1")						-- on next farm, facing crops
+
-		local seed, crop = lib.manageTree(R)		-- refuel, gather seeds or other crops
+
 [[~yellow~Computercraft mob grinder
-		R, isFarmToRight = lib.harvest(R, seed, crop)		-- harvest field, store crops
+
-		return R, isFarmToRight
+
           |*~blue~| | | | | | | | | |~lightGray~*|
           |*|*|*|*|*~blue~| |~lightGray~*|*|*|*|*| Front
-	function lib.farmToRight(R)
+
 
-		T:go("U1F11 D1")								-- on next farm, facing crops
+
-		local seed, crop = lib.manageTree(R)					-- refuel, gather seeds and other crops
+
-		R, isFarmToRight = lib.harvest(R, seed, crop)		-- harvest field, store crops
+
-		-- now at starting position of current plot
+
-		return R, isFarmToRight
+
 ]] -- Computercraft mob grinder
 	info.sub[66] =
-	function lib.getCropSeed(crop)
+
-		-- change growing crops into equivalent seed names
+
-		-- crop could be seeds, so return equivalent crop
+
-		local start = crop:find("_crop")
+
-		if start ~= nil then	-- only modded seeds have "crop"
+
-			return crop:sub(1, start).."seeds", crop
+
 
-		if crop:find("seeds") ~= nil then	-- asked to return crop from seed type
+
-			if crop:find("wheat") ~= nil then
+
-				return "minecraft:wheat_seeds", "minecraft:wheat"
+
 ]] -- Build endermen observation tower
-			if crop:find("beetroot") ~= nil then
+
-				return "minecraft:beetroot_seeds", "minecraft:beetroot"
+
 [[~yellow~Clear field
 
-		if crop:find("wheat") ~= nil then
+
-			return "minecraft:wheat_seeds", "minecraft:wheat"
+
 ~lightGray~| | | | | |  Remove blocks > ground
-		if crop:find("beetroot") ~= nil then
+
-			return "minecraft:beetroot_seeds", "minecraft:beetroot"
+
 |~red~^~lightGray~| | | | |  ~red~^ ~lightGray~= Turtle position
-		if crop:find("carrot") ~= nil then
+
-			return "", "minecraft:carrot"
+
 
 ]] -- Clear field
-			return "", "minecraft:potato"
+
 [[~yellow~Clear rectangle
-		-- planted crops are plural, harvested singular: carrots / carrot, pototoes/ potato
+
-		return "", crop -- no seed for carrot / potato
+
 ~lightGray~| | | | | |  Optional dig ~lime~up
 ~lightGray~| | | | | |  Optional dig ~blue~down
-	function lib.getHoe()
+
 | | | | | |
-		if R.networkFarm then	-- get hoe from storage
+
-			hoeSlot = network.getItemFromNetwork("barrel", "minecraft:diamond_hoe", 1)
+
-			if hoeSlot == 0 then
+
-				if T:checkInventoryForItem({"minecraft:diamond_hoe"}, {1}, true, "Diamond Hoe required for planting!") ~= nil then
+
-					hoeSlot = T:getItemSlot("minecraft:diamond_hoe")
+
 ]] -- Clear rectangle
 
-		else	-- put crafting table into barrel in floor
+
-			T:go("L1F1")		-- over barrel
+
-			local isStorage, storageType = utils.isStorage("down")
+
-			if not isStorage then
+
-				message =
+
 ~lightGray~                   |*|*|*|*|*|*|
                    |*|*|*|*|*|*|
                    |*|*|*|*|*|*|
                    |*|*|*|*|*|*|
                   ~lime~T~lightGray~|~green~T~lightGray~|*|*|*|*|*| Base
-	instead.
+
 T = Turtle top / bottom/ inside / out
 ~yellow~Bottom to top or top to bottom
 ]] -- Clear wall
-				return 0, message
+
 [[~yellow~Clear rectangle ~red~perimeter only
-			-- must be storage below to get this far
+
-			T:suck("down")		-- if hoe already in storage get it out
+
-			hoeSlot = T:getItemSlot("minecraft:diamond_hoe")
+
-			if hoeSlot == 0 then
+
-				if T:checkInventoryForItem({"minecraft:diamond_hoe"}, {1}, true, "Diamond Hoe required for planting!") ~= nil then
+
-					hoeSlot = T:getItemSlot("minecraft:diamond_hoe")
+
 | |*|*|*| |
 |~red~^~lightGray~| | | | |  ~red~^ ~lightGray~= Turtle position
 ~red~ ^
-		return hoeSlot, ""
+
 
 ]] -- Clear rectangle (perimeter only)
-	function lib.getSaplings(R, direction)
+
 [[~yellow~Demolish cube structure
 Plan view        Side view
                ~gray~T ~lightBlue~T
 ~lightGray~|*|*|*|*|*|*|  ~cyan~T~lightGray~|~blue~T~lightGray~|*|*|*|*|*|
-		if R.networkFarm then
+
-			network.getItemFromNetwork("barrel", "sapling", 1)
+
-			--lib.getItemFromNetworkBarrels(R, "sapling", 1)
+
 |*|*|*|*|*|*|   |*|*|*|*|*|*|
-			while T:suck(direction, 1) do end -- remove saplings/ seeds
+
-			T:dropItem("sapling", direction, 1) -- drop all but 1 saplings
+
-			if not T:dropItem("seeds", direction, 0) then-- drop all seeds
+
-				T:dropItem("seeds", "up", 0)
+
 	info.sub[76] = info.sub[75]
 	info.sub[77] =
 [[~yellow~Dig a trench (Plan view)
-		return T:getItemSlot("sapling")
+
 ~lightGray~      |~red~>~lightGray~| | | | | | |
 
-	function lib.getSeeds(R, direction, seed)
+
-		--[[
+
-			seed = name of growing crops seed or ""
+
-			turtle facing crops on networked, else facing storage
+
-			allow for other seeds from mods eg MysticalAgriculture
+
-			get 1 stack of seeds of whatever type is being farmed
+
 ]] -- Dig a trench
-		if seed == "" then
+
-			return "", 0
+
 ~yellow~Side view            Plan view
-		local inventorySlot, seedCount = 0, 0
+
-		T:saveToLog("Collecting seeds from storage")
+
-		if R.networkFarm then
+
-			inventorySlot, seedCount = network.getItemFromNetwork("chest", seed, 64)
+
 ~gray~      |*~lightGray~|*|*|*|      ~gray~|*|*~lightGray~|*|*|*|*|  ~yellow~G
-			while T:suck(direction, 1) do end -- remove saplings/ seeds
+
-			T:dropItem("sapling", direction, 0) -- drop all saplings
+
-			T:dropItem("seeds", direction, 64)	-- drop all but 64 of any seed type
+
-			seedCount = T:getItemCount(seed)
+
 ]] -- Carve mountain
-		if seedCount > 0 then
+
-			T:saveToLog("planting " ..seed)
+
 
-		return seed, seedCount	-- could be: "", 0 or "minecraft:wheat_seeds", 64
+
 ~lightGray~| | | | | |    |*|*|*|*|*|
 | | | | | |     T          Ceiling
-	function lib.getVeg(R, direction, crop)
+
 | | | | | |
-		-- local item, itemName, shortName, slot = "", "","", 0
+
-		local inventorySlot, cropCount = 0, 0
+
 
-		if R.networkFarm then
+
-			inventorySlot, cropCount = network.getItemFromNetwork("chest", crop, 64)
+
 ]] -- (Re)place floor or ceiling
-			if not R.mysticalAgriculture then
+
-				print("Collecting root crops from storage")
+
-				direction = direction or "forward"
+
-				while T:suck(direction, 1) do end 			-- remove carrots / potatoes / wheat / beetroot / essence
+
-				--item, itemName, shortName, slot = T:getFirstItem()
+
-				local found = false
+
-				if T:getItemSlot("potato") > 0 then
+
-					T:dropItem("potato", direction, 64)		-- drop all but 65 potato
+
-					found = true
+
-					crop = "minecraft:potato"
+
 ~lightGray~u = up       ~cyan~d = down
-				if T:getItemSlot("carrot") > 0 then
+
-					T:dropItem("carrot", direction, 64)		-- drop all but 64 carrots
+
-					found = true
+
-					crop = "minecraft:carrot"
+
   ~yellow~Place me on water/lava surface
-				if not found then
+
-					T:dropAll(direction)					-- drop everything back
+
   ~yellow~Place  on left corner of area
 
-			cropCount = T:getItemCount(crop)
+
   ~yellow~Place me on the surface of sand.
 
-		if cropCount > 0 then
+
-			print("planting " ..crop)
+
 ]] -- Sand based utilities
-		return crop, cropCount -- could be: "", 0 or "minecraft:potato", 64
+
 [[~yellow~Turtle position ~red~> T ~gray~(~red~V ~gray~to enclose)
 ~yellow~Plan view                      ~gray~Start:~red~V
-	function lib.goHome(R)
+
                             ~gray~*  area
 ~yellow~Side view
  ~red~T
 ~blue~| | | | | | | ~yellow~to ~lightGray~|*|*|*|*|*|*|
 ~blue~| | | | | | |    ~lightGray~|*|*|*|*|*|*|
-			lib.harvestTree(R, "forward") 		-- will only harvest if fuel below half of limit
+
-			onTree = true					-- end on dirt
+
 ~yellow~|S|S|S|S|S|S|    |S|S|S|S|S|S|
-			lib.harvestTree(R, "up")			-- end on dirt
+
 	info.sub[83] =
-		elseif T:getItemSlot("log") > 0 then-- tree just harvested
+
 
 
 ~yellow~L ~lightGray~|*|*|*|*|*|*|
-				lib.harvestTree(R, "up")		-- end on dirt
+
 ~yellow~n ~lightGray~|*| | | | |*|
-				while turtle.down() do end	-- end on dirt
+
 ~yellow~t ~lightGray~|*|*|*|*|*|*|
 ~yellow~h  ~red~^
 ~yellow~   W i d t h      ~red~^ ~lightGray~= Turtle
-		if onTree then
+
-			local success, storage = false, ""
+
-			-- tree harvested, sitting on dirt, but direction unknown
+
-			T:down(1) 				-- dig dirt, go down
+
-			-- if storage type farm chest/barrel will give position
+
-			for turns = 1, 4 do
+
 Plan view
-				success, storage = utils.isStorage("forward")
+
 |*|*~blue~| | |~lightGray~*|*~blue~| |~lightGray~*|  ~blue~| ~lightGray~= Water
-					T:go("L2U1")
+
-					T:place("dirt", "down")
+
-					T:go("B1R1 F1D1R1")
+
-					R.ready = true
+
 |*|~red~^~lightGray~|*~blue~| | | | |~lightGray~*|  ~red~^ ~lightGray~= Turtle
 |*|*|*|*|*|*|*|*|  ~yellow~Width~blue~: ~yellow~6, ~orange~length~blue~:~orange~ 6
 
-			-- if networked will be in air 2 blocks above barrel or stone
+
 	info.sub[85] = info.sub[56] -- Sinking platform
-			T:place("dirt", "up")
+
-			T:down(1)	 --should be on corner
+
-			for turns = 1, 4 do
+
 ~red~******    ******  * ~lightGray~= Avoid this area
-				success, storage = utils.isStorage("down")
+
-				if storage == "modem" then
+
-					T:go("R1F1D1")
+
-					R.ready = true
+
 ******~lime~++++~green~******  ~green~* ~lightGray~= Good position
 ~green~****************
-				T:go("B1R1")
+
 ****************  blocks from edge
 ]]-- Ocean monument 85 subChoice 1: 4 corner pillars
 
 	info.sub[862] =
 [[~yellow~Turtle positions ~red~> ^ < V
-		return R	-- R.ready == false
+
 ~lightGray~|*|~red~>~lightGray~|*|*|*|*|*|~red~<~lightGray~|*|  ~red~NOT ~lightGray~corner blocks!
 |~red~V~lightGray~|             |~red~V~lightGray~|
-	function lib.goToLeft(R, plotCountR)
+
-		T:go("U1R2 F"..plotCountR * 11 .."D1R2")	-- return home and continue with front
+
-		if R.config ~= nil then
+
-			local coord = R.config.currentPlot
+
-			for i = 1, plotCountR do
+
-				coord = lib.configUpdateCoords(R, coord, "left")
+
 |*|~red~>~lightGray~|*|*|*|*|*|~red~<~lightGray~|*|  ~yellow~Add when asked
-			R.config.currentPlot = coord
+
 
 	info.sub[863] =
 [[~yellow~Turtle ~red~> < ~yellow~on side walls only
-	function lib.goToFront(R, plotCountF)
+
-		T:go("U1R1F"..plotCountF * 11 .."D1L1")
+
-		if R.config ~= nil then
+
-			local coord = R.config.currentPlot
+
-			for i = 1, plotCountF do
+
-				coord = lib.configUpdateCoords(R, coord, "back")
+
 ~lightGray~|~red~>~cyan~| *****+++***** |~red~<~lightGray~|
-			R.config.currentPlot = coord
+
 ~lightGray~|~red~>~cyan~| ************* |~red~<~lightGray~|
 |*|*|*|*|*|*|*|*|*|*|
 ]] -- clear plants before sand draining
-	function lib.gotoTree(R)
+
 	info.sub[865] = info.sub[863]
-		if not R.networkFarm then
+
-			T:turnRight(1)							-- face storage
+
 [[~yellow~Turtle positions ~red~> ^ < V
-		T:saveToLog("Extracting saplings from storage")
+
-		lib.getSaplings(R, "forward") 				-- gets one sapling only (if present)
+
-		T:saveToLog("Moving to tree position")
+
-		if R.networkFarm then
+
-			T:turnRight(1)							-- face wall next to corner barrel
+
 ~orange~|*|- - - - ~lime~- - - -|*| ~lightGray~6 chests / area
-		T:go("U1F1R1")								-- move on top of wall/storage. face tree direction
+
 ~orange~|*|- - - - ~lime~- - - -|*|
-		-- check if tree or dirt ahead
+
-		if turtle.forward() then 					-- No tree or sapling ahead. assume tree is missing or 2 blocks above
+
-			if T:getBlockType("down") == "minecraft:dirt" then
+
-				turtle.back()						-- older design, return
+
 [[~yellow~Ladder to water / lava: Plan view
 
-				if turtle.detectUp() then			-- dirt above = new tree layout
+
-					if T:getBlockType("up") == "minecraft:dirt" then
+
-						T:go("B1U2")				-- check tree in elevated position
+
 |*|*|*|~red~^~lightGray~|*|*|*|  |*|*|*|*|*|*|*|
-						turtle.back()				-- not dirt above ? removed or lost
+
 |*|*|*|*|*|*|*|  |*|*|*|*|*|*|*|
 
 ~red~^ ~lightGray~= Turtle facing water / lava
 ~brown~L ~lightGray~= Ladder
-		lib.harvestTree(R, "forward") 				-- fell tree or plant sapling, ends facing tree / dirt / sapling. sticks already used for fuel. excess saplings placed
+
-		T:go("R1F1D1R1")							-- return to base, facing crops
+
-		if R.networkFarm then
+
-			network.sendItemToNetworkStorage(R, "barrel", "sapling", 64) --move saplings to any attached barrel
+
 Returns max ~blue~d~yellow~epth. ~yellow~Water ~green~p~yellow~lants~yellow~ removed
-			T:turnRight(1)							-- facing plot storage
+
-			T:saveToLog("Dropping saplings into storage")
+
-			T:dropItem("sapling", "forward", 0)	-- drop all saplings forward into chest/barrel
+
 |*|*| ~blue~| | | | | | | | | ~lightGray~|*|*|
 |*|*| ~blue~| | | | | | | ~lightGray~|*|*|*|*|
-		-- ends in field facing crops
+
 |*|*|*| ~blue~| | |~green~p~lightGray~|*|*|*|*|*|*|*|
 |*|*|*|*~blue~|d~lightGray~|*|*|*|*|*|*|*|*|*|
-	function lib.harvest(R, seed, crop)
+
 ]] -- Clear water plants from enclosed area
 	info.sub[89] =
-		harvest crop if ripe
+
 of retaining wall facing water
 ]] -- Convert all water to source
 	info.sub[810] =
-		crop is full name. if mixed seeds only one type returned
+
 of retaining wall facing water.
 The source blocks are placed ahead to
 selected length
 ]] -- Create sloping water
 
 -- Building and railway
 	info.sub[91] =
 [[~yellow~Build a wall
 
-				lib.replant(R, seed, crop)	-- check and replant crop below
+
 
 ~red~>~lightGray~| | | | | | |   |*|*|*|*|*|*|
                  |*|*|*|*|*|*|
-					if utils.isStorage("down") then	-- chest, barrel or modem
+
                  |*|*|*|*|*|*|
                 ~red~T~lightGray~|~red~T~lightGray~|*|*|*|*|*|
 
 ~red~> T~lightGray~ = Turtle
 
 ]] -- Build a wall
 	info.sub[92] =
-				lib.replant(R, seed, crop)	-- check and replant crop below
+
 
 Plan view         Side view
 
 ~yellow~L ~lightGray~|*|*|*|*|*|*|   |*|*|*|*|*|*|
 ~yellow~e ~lightGray~|*| | | | |*|   |*|*|*|*|*|*|
-				lib.replant(R, seed, crop)
+
 ~yellow~g ~lightGray~|*| | | | |*|   |*|*|*|*|*|*|
 ~yellow~t ~lightGray~|~red~^~lightGray~|*|*|*|*|*|  ~red~T~lightGray~|~red~T~lightGray~|*|*|*|*|*|
 ~yellow~h  ~red~^
 ~yellow~   W i d t h      ~red~^ T ~lightGray~= Turtle
-		if utils.isStorage("down") then
+
 ]] -- Build a rectangular structure
 	info.sub[93] =
 [[~yellow~Build a gable roof
-		lib.storeCrops(R) -- rotates from start to deposit seeds and crops, ends facing crops
+
-		return R, isFarmToRight, isFarmToFront
+
                      ~gray~+      gable top
 ~yellow~L ~lightGray~|*|*|*|*|*|      ~gray~+ + +    gable end
-	function lib.harvestTree(R, direction)
+
 ~yellow~n ~lightGray~|*| | | |*|   |*|*|*|*|*| top of wall
 ~yellow~g ~lightGray~|*| | | |*|   |*|*|*|*|*|
 ~yellow~t ~lightGray~|*| | | |*|   |*|*|*|*|*|
 ~yellow~h ~lightGray~|~red~^~lightGray~|*|*|*|*|   |*|*|*|*|*|
 ~yellow~  W i d t h     W i d t h   ~red~^T ~lightGray~= Turtle
-			Return to top of storage
+
 	info.sub[94] =
 [[~yellow~Build a pitched roof
 Width ~red~MUST ~yellow~be ~red~<= ~yellow~Length eg ~red~4~yellow~ x 6
-		local inFront = T:getBlockType("forward")
+
-		print("Checking tree")
+
-		if inFront == "" then -- no tree or sapling
+
-			print("No sapling: planting sapling")
+
-			T:place("sapling", "forward")
+
-		elseif inFront:find("log") ~= nil or direction == "up" then -- tree above or in front
+
-			-- clsTurtle.harvestTree(self, extend, craftChest, direction)
+
-			print("Harvesting tree")
+
-			T:harvestTree(false, false, direction) --do not investigate side branches in case chunk unloaded
+
-			T:back(1) -- face dirt
+
-			-- place(self, blockType, direction, leaveExisting, signText)
+
-			T:place("sapling", "forward")
+
 [[~yellow~Place me on suspended railway stone
-		print("Disposing of apples")
+
-		T:dropItem("apple", "up", 0) -- drop any apples
+
-		utils.useSticksAsFuel()
+
 ~lightGray~|*|*|\                           ~red~>~lightGray~|*|
-		while turtle.down() do end	-- ends facing tree, on top of plot storage
+
       ~lightGray~|*|______~red~T~lightGray~_________    /~lightGray~|*|~red~!
        ~red~!~lightGray~|*|*|*|*|*|*|*|*|\ /|*|
-	function lib.manageTree(R)
+
 
-		local isReady, crop, seed, status, R = lib.isCropReady(R, "forward")
+
-		if crop == "" and not R.auto then			-- only ask player if not running via startup
+
-			seed, crop = lib.askPlayerForCrops()	-- "" or  specific seed type,
+
 	info.sub[96] = info.sub[95]
 	info.sub[97] =
 [[~yellow~Place me on last block before up/down
 
 Build down            Build up~lightGray~
 
 _____~red~T~lightGray~                        ___
 |*|*|*|_                     _|*|
       |*|_                 _|*|
         |*|_             _|*|
           |*|__________~red~T~lightGray~|*|
             |*|*|*|*|*|*|
 ~red~T~lightGray~ = Turtle on block, not above rail
 ]] -- build down
-			T:saveToLog("Running Tree Manager")
+
-			lib.gotoTree(R) 					-- check for sapling or harvest tree, retuns to facing crops
+
 --Measurement tools
 	info.sub[101] =
 [[~yellow~Place me on floor.~lightGray~
-		if logSlot > 0 then						--logs onboard, need to equip crafting table
+
-			if R.networkFarm then
+
-				lib.refuelWithLogs(R, logSlot) 	-- use any logs for fuel
+
   |*|*|*|
-				T:go("L1F1") 					-- move to buried storage chest/barrel
+
-				lib.refuelWithLogs(R, logSlot) 	-- use any logs for fuel
+
-				T:go("R2F1")					-- facing seed chest/barrel
+
   |*|*|*|
   |*|*|*|
-			if not R.networkFarm then
+
 ]] -- measure height
 	info.sub[102] =
 [[~yellow~Depth measurement
-		-- get seeds or veg based on what is growing
+
-		if seed ~= "" then
+
-			local seedType, seedCount = lib.getSeeds(R, "forward", seed) 	-- table: get 95 of beetroot / wheat / mysticalagriculture seeds
+
-			if seedCount == 0 then
+
-				T:saveToLog("No seeds available.")
+
 3|*|*|
-		else	-- seed  = ""
+
-			local veg, vegCount = "", 0
+
-			if R.networkFarm then
+
-				veg, vegCount = lib.getVeg(R, "forward", crop)	-- gets any carrots / potatoes
+
 ]] -- measure depth
-				T:turnRight(1)					-- face crop chests
+
-				veg, vegCount = lib.getVeg(R, "forward", crop)	-- gets any carrots / potatoes
+
-				T:turnRight(2)					-- face crops
+
 ~lightGray~1 2 3 4 ~lime~5~lightGray~ 6 ~lime~7 ~cyan~8 ~lightBlue~9~lightGray~ 10
-			if veg ~= "" then
+
-				crop = veg
+
 ~red~T~lightGray~                |*|  ~lightBlue~9. Obstruction
 ~lightGray~*|*|*|*|~lime~S~lightGray~|*|*| |*|*|  ~lime~5. Search block
                       ~cyan~8. No block down
-		return seed, crop	-- name of seed / "",  crop / ""
+
 ~red~T ~lightGray~= Turtle
 
-	function lib.isCropReady(R, direction)
+
 	info.sub[104] = info.sub[88] -- measure deepest section of water
 	info.sub[105] =
 [[~yellow~Place turtle anywhere:
-		local crop, seed = "", ""
+
  1. make a ~blue~borehole~yellow~ to chosen level.
 
  2. Write a report called:
 
  3. ~lime~borehole~blue~X~lime~.txt ~yellow~( ~blue~X ~yellow~= computer ID )
 
  4. ~orange~Return home
 
 ]] -- Borehole: Analyse blocks below
-		--T:saveToLog("lib.isCropReady(R,".. direction..")")
+
-		if success then			-- inspect() success
+
-			crop = data.name	-- name of growing plant
+
-			if crop:find("flower") ~= nil then
+
-				T:saveToLog("Flower "..crop.." found")
+
-				return true, crop, "open"	-- eg torchflower
+
 
-				if data.name:find("beetroot") ~= nil then
+
-					status = data.state.age.." / 3"
+
-					if data.state.age == 3 then
+
-						isReady = true
+
 ~yellow~Enter 1 to use ~lime~2 ~yellow~turtles or 2 to use ~orange~4]]	-- initial menu for water canal
-				else			-- all other crops inc Mystical Agriculture
+
-					status = data.state.age.." / 7"
+
-					if data.state.age == 7 then
+
-						isReady = true
+
 		read()
 		return ""
 	else -- item specific help
-			seed, crop = lib.getCropSeed(crop)
+
 			line = menu.colourText(line, info.sub[menuItem], true, true)
-		--T:saveToLog("return isReady = "..tostring(isReady)..", crop = "..crop..", seed = "..seed..", status = "..status)
+
-		-- crop: "", "minecraft:carrots", "minecraft:beetroot", "minecraft:potatoes", "minecraft:wheat", "mysticalagriculture:*_crop"
+
-		return isReady, crop, seed, status, R	-- eg true, "minecraft:carrots", "7 / 7" or false, "mysticalagriculture:inferium_crop", "1 / 7"
+
 				if getInteger then
 					return line -- ready for further input
-	function lib.locateFarm(R)
+
-		T:saveToLog("? over water = false")
+
 					menu.enterToContinue()
 				end
-				detected = i
+
 				term.setCursorPos(1, 13)
 				term.write("Enter=exit, Any key + Enter=more ")
 				return read()
-		T:saveToLog("Neighbouring blocks detected at: "..detected)
+
-		-- check if on corner
+
-		if detected > 0 then
+
-			--assume tree / sapling on corner on older farm type
+
-			T:saveToLog("Assuming next to tree / sapling. Moving..")
+
-			T:go("R"..detected .."F1D1R1")
+
-		else	-- no surrounding blocks
+
 	options.main =
 	{
-				success, storage = utils.isStorage("down")
+
-				T:saveToLog("i = "..i..",success = "..tostring(success)..". storage = "..storage)
+
 		"Farming",
-					discovered = discovered .. storage
+
-					if storage == "modem" then
+
-						R.networkFarm = true
+
 		"Area shaping and clearing",
 		"Lava and Water",
-					if storage == "" then
+
-						discovered = discovered .. "_"
+		"Measuring tools"
 	}
-						discovered = discovered .. "wall"
+
 	{
 		"Ladder up or down",
 		"Stairs up or down",
 		"Create mine at this level",
 		"Safe drop to water block",
-			T:saveToLog("Neighbouring blocks found:"..discovered)
+
 		"QuickMine corridor system",
-		-- check discovered for patterns eg {_wall_barrel}
+
-		-- |W|*|B| * = turtle on wall
+
-		-- | | |M|
+
-		if R.networkFarm then
+
-			-- E = wall_barrel_, N = _barrel_wall, W = wall_barrel_, S = _wall_barrel
+
-			if discovered == "_wall_barrel" then
+
-				T:go("F1D1R1")
+
-			elseif discovered == "barrel_wall_" then
+		"Create tree farm",
 		"Plant tree farm",
-			elseif discovered == "_barrel_wall" then
+
-				T:go("R2F1D1R1")
+
-			elseif discovered == "wall_barrel_" then
+
-				T:go("L1F1D1R1")
+
 	table.insert(options,
-		else	-- normal storage farm
+
-			if discovered == "_chest_chest" then
+
-				T:go("F1D1R1")
+
-			elseif discovered == "chest__chest" then
+		"Plant, harvest or manage crop farm",
 		"Build a wall or fence",
-			elseif discovered == "_chest_chest" then
+
-				T:go("R2F1D1R1")
+
-			elseif discovered == "chest_chest_" then
+
-				T:go("L1F1D1R1")
+
 		"Dig obsidian field",
 		"Build Nether Portal",
 		"Demolish Nether Portal",
 		"Stripmine Netherite",
 		"Undermine Dragon Towers",
-				success, storage = utils.isStorage("forward")	-- true/false, chest, barrel, modem / ""
+
-				if success and storage == "modem" then
+
-					R.networkFarm = true
+
 		"Shulker harvester"
 	})
 	table.insert(options,
-			R.ready = true
+
 		"Simple path on air, water or lava",
 		"Covered path or tunnel",
 		"Water canal (mulitple options)",
-	function lib.plantCrop(R, seed, crop, direction)
+
 		"Platform",
 		"Sinking platform",
 		"Boat bubble lift",
 	})
 	table.insert(options,
-		--T:saveToLog("lib.plantCrop(R, seed = "..seed..", crop = "..crop)
+
 		"Cube around spawner (NOT blaze)",
-		-- place(blockType, direction, leaveExisting, signText, doNotAttack)
+
-		if seed == "" then	-- must be a crop
+
-			success = T:place(crop, direction, true, "", true)
+
-			--success = T:place(crop, direction, false, "", true)
+
-			--T:saveToLog("Seed = "..seed..". Placing "..crop..": success = "..tostring(success))
+		"Build Endermen observation tower"
 	})
-			success = T:place(seed, direction, true, "", true) 	-- eg "mysticalagriculture:air_seeds"
+
-			--success = T:place(seed, direction, false, "", true) 	-- eg "mysticalagriculture:air_seeds"
+
-			--T:saveToLog("Placing "..seed..": success = "..tostring(success))
+
 		"Clear a rectangle (+ u/d opt)",
-		if not success then
+
-			success = T:place("seed", direction, true, "", true)			-- failsafe
+
-			--success = T:place("seed", direction, false, "", true)			-- failsafe
+
-			--T:saveToLog("Placing generic 'seeds' : success = "..tostring(success))
+
 		"Dig a trench",
-		return success
+
 		"Place a floor or ceiling",
 		"Direct control of movement"
-	function lib.replant(R, seed, crop)
+
-		-- check crop below. If ripe, dig and replant seed
+
-		local isReady, cropType, seedType, status
+
-		isReady, cropType, seedType, status, R = lib.isCropReady(R, "down")	-- eg true, "minecraft:carrots", "7 / 7" or false, "", ""
+
-		if cropType == "" then					-- no crop below (above water, storage or dirt)
+
-			turtle.digDown("right")				-- use hoe
+
-			lib.plantCrop(R, seed, crop, "down")-- plant crop
+
-		elseif isReady then						-- crop below is ready
+
-			turtle.digDown("left")				-- use pickaxe
+
-			lib.plantCrop(R, seedType, cropType, "down")	-- plant crop
+
 		"Clear water plants",
 		"Convert all water to source",
-		return R
+
 	})
 	table.insert(options,
-	function lib.refuelWithLogs(R, logSlot)
+
-		-- saplings already dropped, apples dumped, sticks used as fuel
+
-		-- assume positioned in front of crops if networked, or over buried storage
+
 		"Build a gable end roof",
 		"Build a pitched roof",
-		-- networked version uses remote storage, turtle faces crops and has modem at back
+
-		local slot, count = 0, 0
+
-		T:saveToLog("Sorting Inventory")	-- make sure all items collected together
+
-		T:sortInventory(true)
+
-		T:saveToLog("Logs present: collecting crafting table")
+
-		if R.networkFarm then
+
-			slot, count = network.getItemFromNetwork("barrel", "minecraft:crafting_table", 1)
+
-			--slot = lib.getItemFromNetworkBarrels(R, "minecraft:crafting_table", 1)
+
 		"Measure depth",
-			while T:suck("down") do end					-- empty out barrel/chest to find crafting table
+
 		"Measure greatest depth",
 		"Borehole: Analyse blocks below"
 	})
 
 	return options
-			if R.networkFarm then
+
-				network.sendItemToNetworkStorage(R, "barrel", "minecraft:diamond_hoe", 1)
+
 local function getTaskColours()
 	local options = {}
 	options.main =
-					T:drop("down", i)	-- into water if networked, buried chest otherwise
+
 		colors.lightGray, 	-- Mining (includes Nether)
 		colors.lime, 		-- Forestry
 		colors.green, 		-- Farming
 		colors.red, 		-- Obsidian, Nether & End Portal
 		colors.brown, 		-- Canal, bridge and walkway
 		colors.lightGray, 	-- Mob farm tools
 		colors.orange,		-- Area shaping and clearing
 		colors.blue, 		-- Lava and Water
-			while logSlot > 0 and turtle.getFuelLevel() < turtle.getFuelLimit() do
+
 		colors.purple 		-- Measuring tools
-				turtle.refuel()						-- refuel using planks
+
 	table.insert(options,
 	{
-			while T:suck("down") do end			-- recover items from water / storage below
+
-			--T:unequip("right")
+
-			if R.networkFarm then
+
-				slot = network.getItemFromNetwork("barrel", "minecraft:diamond_hoe", 1)
+
 		colors.blue, 		-- Single column bubble lift
-			if not T:equip("right", "minecraft:diamond_hoe") then		-- re-equip hoe/remove crafting table
+
 		colors.pink, 		-- QuickMine rectangle
 		colors.gray, 		-- Mine bedrock level
-			if R.networkFarm then
+
-				network.sendItemToNetworkStorage(R, "barrel", "minecraft:crafting_table", 1)
+
 	table.insert(options,
-				T:dropItem("minecraft:crafting_table", "down")
+
 		colors.brown, 		-- Fell Tree
 		colors.lightGray, 	-- Create tree farm
 		colors.lime, 		-- Plant tree farm
 		colors.green, 		-- Harvest tree farm
 		colors.brown, 		-- Fence or wall an enclosure
 		colors.lime 		-- Harvest and replant forest
 	})
-	function lib.storeCrops(R)
+
-		-- place crops and seeds into chests. starts facing crops
+
 		colors.yellow, 		-- Create modular crop farm
 		colors.green, 		-- Extend modular crop farm
-		if R.networkFarm then
+
-			network.emptyInventory(R, {"sapling", "diamond_hoe", "crafting"}, {"all"}, true)
+
 		colors.brown 		-- Build rectangle wall or fence
-			T:turnRight(1)	-- face seed storage
+
-			lib.storeSeeds(R, "forward")
+
 	{
-			if utils.isStorage(direction) then
+
-				T:dropAll(direction) -- drops everything including essences
+
 		colors.gray, 		-- Demolish Nether Portal
-			T:turnRight(2) -- facing crops again
+
 		colors.orange, 		-- Undermine Dragon Towers
 		colors.orange, 		-- Deactivate Dragon Tower
 		colors.blue, 		-- Build dragon water trap
-	function lib.storeSeeds(R, direction)
+
 		colors.red			-- Shulker harvesting
-		if utils.isStorage(direction) then -- chest exists
+
-			if not R.networkFarm then
+
-				if T:getItemSlot("minecraft:wheat_seeds") > 0 then
+
-					if not T:dropItem("minecraft:wheat_seeds", direction, 0) then
+
-						T:dropItem("minecraft:wheat_seeds", "up", 0)
+
-					end -- drop all wheat seeds
+
-				elseif T:getItemSlot("minecraft:beetroot_seeds") > 0 then
+
-					if not T:dropItem("minecraft:beetroot_seeds", direction, 0) then-- drop all beetroot seeds
+
-						T:dropItem("minecraft:beetroot_seeds", "up", 0)
+
 		colors.cyan 		-- Boat bubble lift
-				elseif T:getItemSlot("seeds") > 0 then
+
-					if not T:dropItem("seeds", direction, 0) then	-- drop all other seeds as chest is full
+
-						T:dropItem("seeds", "up", 0)
+
-						-- or could print a message and wait for player to empty storage
+
 		colors.red, 		-- Cube around Blaze spawner
 		colors.cyan, 		-- Flood mob farm floor
 		colors.blue, 		-- Create mob bubble lift
 		colors.brown, 		-- Dig mob drop trench
 		colors.gray 		-- Build Endermen observation tower
 	})
-	function lib.watchFarm(R)
+
 	{
 		colors.lime, 		-- Clear field (inc trees)
 		colors.magenta, 	-- Clear a rectangle (+ u/d opt)
 		colors.pink, 		-- Clear single wall up/down
 		colors.purple, 		-- Clear rectangular wall section
-		local isReady, crop, seed, status	-- bool, string, string, integer
+
-		isReady, crop, seed, status, R = lib.isCropReady(R, "forward")		-- eg true, "minecraft:carrots", "7 / 7" or false, "", ""
+
 		colors.brown, 		-- Dig a trench
 		colors.gray, 		-- Carve mountain side
 		colors.lightBlue, 	-- Place a floor or ceiling
 		colors.red 			-- Direct control of movement
 	})
 	table.insert(options,
 	{
 		colors.yellow, 		-- Sand based utilities
 		colors.blue, 		-- Vertical wall from surface
-					if crop:find("mysticalagriculture") ~= nil then
+
-						R.mysticalAgriculture = true
+
 		colors.lightGray,	-- Sinking platform
 		colors.orange, 		-- Ocean monument utilities
 		colors.brown, 		-- Ladder down to water/lava
-				isReady, crop, seed, status, R = lib.isCropReady(R, "forward")			-- eg true, "minecraft:carrots", "7 / 7" or false, "", ""
+
 		colors.lightBlue, 	-- Convert all water to source
-		until isReady
+
-		T:saveToLog("Local crops ripe", true)
+
-		seed, crop = lib.manageTree(R) -- "", "" or name of seed, crop
+
-		return seed, crop
+
 		colors.yellow,		-- build a wall
 		colors.orange,		-- build rectangular structure
 		colors.lightGray,	-- gable end roof
-		ENTRY POINT**********************************************
+
 		colors.red, 		-- Place Redstone:torch level track
 		colors.red, 		-- Place Redstone:torch upward track
 		colors.orange, 		-- Build downward track
 		colors.brown 		-- Build upward track
 	})
 	table.insert(options,
 	{
-	--T:setUseLog(true, "farmLog.txt", true)	-- T:setUseLog(use, filename, delete)
+
-	--dbug = true								-- set dbug flag
+
-	--if not R.auto then						-- not running from startup.lua
+
-		--utils.waitForInput("Logging and debugging enabled")	--utils.waitForInput(message)
+
-	--end
+
 	})
-	R = utils.checkFarmPosition(R)	-- should be facing crops, placed above water source. R.ready, R.networkFarm is true/false
+
-	if R.networkFarm then
+
-		local message = network.loadStorageLists()	-- initialises or creates lists of where an item can be found: GLOBAL LISTS!
+
-		if message ~= nil then return {message} end
+
 local function chooseTask(R)
-	if not R.ready then		-- not in correct starting place
+
-		R = lib.goHome(R)
+
-		if not R.ready then -- try to find home
+
 	coloured menu:
 	local pp =
 	{
 		prompt = colors.green,
 		itemColours = {colors.white, colors.red, ... one for each item},
-				"barrel or chest to my right and behind",
+
-				"(or modem behind if networked farm)"
+
 	choice, modifier = menu.menu or menu.new("Choose your option", options, pp)
 	]]
 	local lib = {}
-	if not T:isEmpty() then		-- items in turtle inventory
+
-		local logSlot = T:getItemSlot("log")
+
 		local listOfItems = itemsRequired[choice]
-			if R.networkFarm then
+
-				lib.refuelWithLogs(R, logSlot) 	-- use any logs for fuel
+
 			lib.showItems(listOfItems)
-				T:go("L1F1") 					-- move to buried storage chest/barrel
+
-				lib.refuelWithLogs(R, logSlot) 	-- use any logs for fuel
+
-				T:go("R2F1")					-- facing seed chest/barrel
+
 		local options ={"Continue with selected task", "return to menu", "Return to main menu","Quit application"}
 		local option = menu.menu("Choose your option", options, pp, "Type number + Enter ")
-		if not T:isEmpty() then					-- still items in turtle inventory
+
-			lib.storeCrops(R)
+
 		elseif option == 3 then
 			choice = 0 -- return to main menu
-	-- in correct position. Check equipment first, harvest tree, re-equip then harvest crops
+
-	local hoeSlot = lib.checkEquipment(R, "minecraft:diamond_hoe")	-- returns slot  or 0
+
 		-- else return original value of choice
-	if hoeSlot == 0 then		-- hoe not in inventory
+
-		local message
+
-		hoeSlot, message = lib.getHoe()
+
-		if message ~= "" then
+
-			return {message}
+
 	function lib.showItems(listOfItems)
 		T:clear()
-	-- hoe present or user cancelled request for hoe. Turtle is ready to exchange items
+
-	if hoeSlot > 0 then
+
-		T:equip("right", "minecraft:diamond_hoe", 0) -- equip hoe and put crafting chest into barrel
+
-		if R.networkFarm then	-- drop crafting table into storage
+
-			network.sendItemToNetworkStorage(R, "barrel", "minecraft:crafting_table", 1)
+
-		else	-- put crafting table into barrel in floor
+
-			T:dropItem("crafting", "down")
+
-			T:go("B1R1")
+
 		menu.colourWrite("Enter to continue", colors.yellow, colors.black, nil, true)
-	else	-- hoe not present: return to start and exit
+
-		if not R.networkFarm then
+
-			T:go("B1R1")
+
 	function lib.getItemList(subChoice, itemsRequired)
 		local listOfItems = itemsRequired[subChoice]
 		lib.showItems(listOfItems)
 	end
 
-	local isFarmToRight, isFarmToFront = false, false
+
-	local isReady, crop, seed, status
+
-	isReady, crop, seed, status, R = lib.isCropReady(R, "forward")
+
 		else -- eg main option 1 (mining), sub-option 1 (create mine) = 1 + 10 = 11
-	local init = false
+
 		end
-		seed, crop = lib.askPlayerForCrops()
+
-		if crop ~= "" or seed  ~= "" then	-- something has been chosen
+
-			T:saveToLog("Initial planting of "..crop, true)
+
-			R, isFarmToRight, isFarmToFront = lib.harvest(R, seed, crop)	-- harvest plot a1 plots to right / front recorded
+
-			init = true
+
 	local prompt = "Choose an option"
-			watch = false	-- not watching, continue with planting
+
 	local subPrompt = "Choose (+h = help +i = items eg 3h):"
 	local options = getTaskOptions()
 	local menuColours = getTaskColours()
-		if watch and not init then -- init true when farm first planted
+
-			seed, crop = lib.watchFarm(R) -- waits if required, returns seed / crop
+
-			init = false
+
 	--local pp = utils.getPrettyPrint()-- uses default colours
-		T:saveToLog("Beginning "..crop.. " management", true)
+
-		R, isFarmToRight, isFarmToFront = lib.harvest(R, seed, crop)	-- harvest plot a1 plots to right / front recorded
+
-		lib.farmAll(R, isFarmToRight, isFarmToFront)
+
 		menu returns choice=nil if user enters just q or h
-			if R.networkFarm then
+
-				T:unequip("right")	-- unequip hoe
+
-				network.getItemFromNetwork("barrel", "minecraft:crafting_table", 1)
+
-				network.sendItemToNetworkStorage(R, "barrel", "minecraft:diamond_hoe", 1)
+
-				T:equip("right", "minecraft:crafting_table", 0) -- equip crafting_table
+
 		Canal, bridge and walkway		pink
-				T:go("L1F1")
+
-				while T:suck("down") do end						-- recover items from storagebelow
+
-				T:equip("right", "minecraft:crafting_table", 0) -- equip crafting_table
+
-				T:dropItem("minecraft:diamond_hoe", "down") 				-- drop hoe into storage
+
-				T:dropItem("crafting", "down") 					-- in case spare one picked by mistake
+
 		]]
 
 		if menuState == 0 then
 			pp.itemColours = menuColours.main
 			local mainChoice, modifier = menu.menu(mainPrompt, options.main, pp) -- open main menu options
 			if modifier == "q" then
 				R.choice = -1
 				return R -- quit application
 			elseif modifier == "h" then -- get help on main menu items
 				getTaskHelp(1, mainChoice) -- "" or any return string for more
 				R.choice = 0
 				return R -- quit task system so it re-starts as help menu chosen R.choice = 0
 			else
 				menuState = 1 -- next level so use sub-menu
 				R.choice = mainChoice -- 1-10
 			end
 		else
 			pp.prompt = colors.yellow
 			pp.itemColours = menuColours[R.choice]
 			subChoice, modifier = menu.menu(subPrompt, options[R.choice], pp, "Back = 'q' or number + Enter: ") -- open submenu options
 			if modifier == "q" then
 				R.choice = 0	-- return to root menu. change this to -1 if quit application preferred
 				return R -- quit task system so it re-starts first menu
 			elseif modifier == "i" then -- get list of items
 				local index = lib.getChoice(R.choice, subChoice)
 				lib.getItemList(index, itemsRequired) -- list of items shown
 				subChoice = nil -- allow menu to continue
 			elseif modifier == "h" then -- get help on main menu items
 				local index = lib.getChoice(R.choice, subChoice)
 				index = lib.getHelp(index, itemsRequired, pp)
 				--R = lib.getHelp(R, itemsRequired, pp) -- if R.choice reset to 0 then will continue
 				if index == -2 then -- redraw sub-menu
 					subChoice = nil -- allow menu to continue
 				elseif index == -1 then -- if R.choice reset to 0 then will continue
 					R.choice = -1
 					return R
 				elseif index == 0 then
 					R.choice = 0
 					menuState = 0 -- if R.choice reset to 0 then back to main menu
 				end
 			end
 			if subChoice ~= nil then
 				R.choice = lib.getChoice(R.choice, subChoice)
 				return R -- exit loop
-	--local pp = utils.getPrettyPrint()
+
-	local choices = {"Plant or harvest this farm complex"}	-- 1.
+
 	end
 	return R
 end
-		table.insert(choices, "Disable automatic farm management") -- 2.
+
 local function getTask(R)
-		table.insert(choices, "Enable automatic farm management") -- 2.
+	-- Called from main(): R = getTask(R)
 	local lib = {}
 
-	if not R.networkFarm then
+
-		table.insert(choices, "Convert to Network Storage")		-- 3.
+
-		table.insert(pp.itemColours, colors.magenta)
+
 				return true
-	if R.mysticalAgriculture then
+
-		--table.insert(choices, "Convert to Mystical Agriculture")
+
-		table.insert(choices, "Upgrade Mystical Agriculture soil")	--3/4
+
-		table.insert(pp.itemColours, colors.green)
+
 
 	local prompt = "Choose an option"
 	local noAutoHelp = {24, 47, 49, 53, 54, 81, 85}
 	if not lib.isAutoHelp(R.choice, noAutoHelp) then -- exclude Water canal, ice canal, sand utilities, monument utilities, dragon trap
 		getTaskHelp(2, R.choice, true)
 		menu.clear()
 	end
 -- 01. MINING
 	if R.choice >= 11 and  R.choice <= 13 then	-- createLadder, createStaircase, createMine)
 		--getTaskHelp(2, R.choice, true)
 		--menu.clear()
 	elseif R.choice == 14 then	-- safe drop to water
-	elseif R.subChoice == 2 then -- enable/disable auto farm
+
 		local destLevel = menu.getInteger("Go down to level? ("..currentLevel - 2 .." to "..bedrock + 5 ..")", bedrock + 5 , currentLevel - 2, nil, colors.blue, nil, bedrock + 5)
 		R.height 	= math.abs(destLevel - currentLevel)
 	elseif R.choice == 15 then	-- bubble lift
 		local currentLevel = menu.getInteger("Current level (F3->Y coord)? ", bedrock + 5 , ceiling, nil, colors.blue, nil, bedrock + 5)
 		local destLevel = menu.getInteger("Go up to level? ("..currentLevel + 2 .." to "..ceiling ..") ", currentLevel + 2, ceiling, nil, colors.lightGray)
 		--[[if currentLevel <= bedrock + 5 then
 			if menu.getBoolean("Confirm close to bedrock (y / n) ", nil, colors.yellow, colors.black) then
 				R.data = "bedrock"
 			end
 		end]]
 		R.height 	= math.abs(destLevel - currentLevel)
 	elseif R.choice == 16 then -- create mining corridor system default: square 17 x 17
 		local choices = {"At corridor start, on the floor",
 						 "At corridor start, on the ceiling",
 						 "On floor, move forward to start",
 						 "On ceiling, move forward to start"}
 		pp.itemColours = {colors.lime, colors.green, colors.magenta, colors.pink}
 		local userChoice, modifier = menu.menu("Starting position?", choices, pp, "Type number + Enter ") -- 1 to 4
 		if modifier == "q" then -- quit chosen
 			R.data = "quit"
 			return R
 		end
 		R.width 	= menu.getInteger("Width (2-64 default 17) ", 2, 64, nil, colors.yellow, nil, 17)
 		R.length  	= menu.getInteger("Length (2-64 default 17) ", 2, 64, nil, colors.orange, nil, 17)
-	--elseif R.subChoice == 3 and #choices == 4 then -- convert normal farm to network storage
+
-	elseif R.subChoice == 3 then -- convert normal farm to network storage
+
-		local isMain = false
+
 		end
-		local message = ("~yellow~You have chosen to convert this farm "..
+
-						 "to ~magenta~network storage ~yellow~with modems."..
+
-						 "All ~brown~chests and barrels ~red~will be removed.\n")
+
-		line = menu.colourText(line, message, true, true)
+
-		if menu.getBoolean("Is this the main or only plot? (y/n)", line + 3, colors.orange, colors.black) then
+
-			isMain = true
+
 						 "On floor diagonally to left"} -- just finished corridor
-		T:checkInventoryForItem({"stone"}, {16})
+
-		T:checkInventoryForItem({"dirt"}, {2})
+
 		if modifier == "q" then -- quit chosen
-		T:checkInventoryForItem({"barrel"}, {1})
+
-		T:checkInventoryForItem({"ladder"}, {5})
+
-		if isMain then
+
-			T:checkInventoryForItem({"chest"}, {8})
+
-			T:checkInventoryForItem({"wired_modem_full"}, {3})
+
-			T:checkInventoryForItem({"computercraft:cable"}, {70})
+
-			return createFarm(R, "convertWithStorage")
+
 		--getTaskHelp(2, R.choice, true)
-			T:checkInventoryForItem({"wired_modem_full"}, {2})
+
-			T:checkInventoryForItem({"computercraft:cable"}, {57})
+
-			return createFarm(R, "convert")
+
 		if menu.getBoolean("Leave bedrock exposed? (y/n) ", nil, colors.yellow) then
-	--elseif R.subChoice == 3 and #choices == 3 then -- upgrade farmland with essence (network opt not present)
+
-	--elseif R.subChoice == 3 and #choices == 3 then -- upgrade farmland with essence (network opt not present)
+
-		--return upgradeFarmland(R)
+
-	elseif R.subChoice == 4 then -- upgrade farmland with essence
+
-		return upgradeFarmland(R)
+
 	elseif R.choice == 22 then --Create treefarm
 		R.width = 15
 		R.length = 15
 		pp.itemColours = {colors.lightGray, colors.green}
 		choices = {"New tree farm. Start here", "On right side of existing farm" }
 		local choice = menu.menu(prompt, choices, pp, "Type number + Enter ")
 		if choice == 2 then
 			R.data = "existing"
 		end
 		R.up = menu.getBoolean({"Any blocks/trees above current level","in a 15 x 15 block area (y/n) "}, nil, {colors.yellow, colors.orange}, colors.black)
 	elseif R.choice == 23 then -- plant treefarm
 		local choices 	= {"16 single trees", "4 double trees any type"}
 		pp.itemColours = {colors.lime, colors.green}
 		R.subChoice = menu.menu(prompt, choices, pp, "Type number + Enter ")
 	--elseif R.choice == 24 then -- Harvest treefarm
 
 	elseif R.choice == 25 then -- Build wall or fence
 		R.width 	= menu.getInteger("Width of the area (1-64)", 1, 64, nil, colors.yellow)
 		R.length  	= menu.getInteger("Length of the area (1-64)", 1, 64, nil, colors.orange)
 		R.torchInterval = menu.getInteger("Torch spacing? (0-64)", 0, 64, nil, colors.red)
 		if menu.getBoolean("Storage barrels in corners? (y/n)", nil, colors.brown) then
 			R.data = "barrel"
 		end
 	elseif R.choice == 26 then -- Harvest and replant natural forest
 
 
 -- 03. FARMING
 	elseif R.choice == 31 then -- new crop farm
 
 	elseif R.choice == 32 then -- extend crop farm
 		local choices 	= {"Add a farm at the back", "Add a farm to the right"}
 		pp.itemColours = {colors.lime, colors.green}
 		R.subChoice = menu.menu(prompt, choices, pp, "Type number + Enter ")
 	elseif R.choice == 33 then -- manage crop farm
 
 	elseif R.choice == 34 then -- fence or wall
 		R.length  	= menu.getInteger("Length of wall / fence (1-256)", 1, 256, nil, colors.orange)
 		R.torchInterval = menu.getInteger("Torch spacing? (0-64)", 0, 64, nil, colors.red)
 	elseif R.choice == 35 then -- rectangle fence or wall
 		R.width 	= menu.getInteger("Width of the area (1-64)", 1, 64, nil, colors.yellow)
 		R.length  	= menu.getInteger("Length of the area (1-64)", 1, 64, nil, colors.orange)
 		R.torchInterval = menu.getInteger("Torch spacing? (0-64)", 0, 64, nil, colors.red)
 
 -- 04. OBSIDIAN
 	elseif R.choice == 41 then	-- Harvest obsidian
 		R.width 	= menu.getInteger("Width of the area (1-64) ", 1, 64, nil, colors.yellow)
 		R.length  	= menu.getInteger("Length of the area (1-64) ", 1, 64, nil, colors.orange)
 	elseif R.choice == 42 or R.choice == 43 then -- build Nether portal / demolish Nether portal
 		local choices = {"Facing portal: forward, turn right",
 						 "Aligned with portal: start ahead"}
 		pp.itemColours = {colors.pink, colors.red}
 		local userChoice, modifier = menu.menu("Starting position?", choices, pp, "Type number + Enter ") -- 1 to 2
 		R.subChoice = userChoice
 		if modifier == "q" then -- quit chosen
 			R.data = "quit"
 			return R
 		end
 		R.length 	= menu.getInteger("Portal width", 1, 64, nil, colors.yellow, nil, 4)
 		R.height 	= menu.getInteger("Portal height (inc. buried base)", 1, 64, nil, colors.lightGray, nil, 5)
 		R.width 	= menu.getInteger("Thickness (Usually 1) Enter = 1)", 1, 64, nil, colors.red, nil, 1)
 		if menu.getBoolean("Base below surface (y/n)", nil, colors.orange) then
 			R.data = "bury"
 		end
 	elseif R.choice == 44 then -- Netherite stripping
 		R.width  	= 1
 		while R.length == 0 or R.length % 16 > 0 do
 			R.length = menu.getInteger("Strip length (divisible by 16) ", 16, 512, 1, colors.orange)
 			if R.length % 16 > 0 then
 				menu.colourText(1, "~red~Must be multiple of 16")
 			end
 		end
 		R.torchInterval = 16
 		R.data = "seal"
 	elseif R.choice == 45 then -- undermine dragon towers
 
 	elseif R.choice == 46 then -- deactivate dragon tower
 
 	elseif R.choice == 47 then -- build dragon water trap
 		local text =
 [[~yellow~You ~red~MUST ~yellow~have already constructed a
 bridge / tunnel into the dragon island
 to allow for safe construction of the
 dragon trap.
 
 If not use toolkit:
   ~brown~5.~gray~2 Covered path or tunnel~yellow~ length 100
 
 start centre of obsidian platform:
   100,49,0 facing west]]
 		menu.colourText(1, text)
 		if menu.getBoolean("Bridge already made? (y/n)", 12, colors.orange) then
 			getTaskHelp(2, R.choice, true)
 			menu.clear()
 		else
 			R.data = "quit"
 			return R
 		end
 	elseif R.choice == 48 then -- build end portal minecart station
 	elseif R.choice == 49 then -- Shulker harvesting
 		local items	=
 		{
 			"Shulker is above",
 			"Shulker is ahead",
 			"Shulker is below",
 			"Climb tower wall",
 			"Clear roof above",
 			"Clear outside walls"
 		}
 		pp.itemColours = {colors.lightGray, colors.brown, colors.blue, colors.yellow, colors.orange, colors.lightGray}
 		R.subChoice = menu.menu("Which utility? ", items, pp)
 		getTaskHelp(2, R.choice * 10 + R.subChoice, true)  -- eg 490 + 1 = 491
 		menu.clear()
 
 -- 05. CANAL BRIDGE
 	elseif R.choice == 51 then	--single path
 		if menu.getBoolean("Shorten an existing path? (y/n)", nil, colors.brown) then
 			R.data = "reduce"
 		end
 		if R.data == "reduce" then
 			R.length = menu.getInteger("Reduce by? 0 = here to end", 0, 1024, nil, colors.orange, nil, 64)
 		else
 			R.length = menu.getInteger("Path length? 0 = continuous ", 0, 1024, nil, colors.orange, nil, 64)
 			R.torchInterval = menu.getInteger("Torch spacing? (0-64)", 0, 64, line, colors.red, nil, 0)
 		end
 	elseif R.choice == 52 then	-- 2 block corridor / covered walkway
 		R.length 	= menu.getInteger("Corridor length?", 1, 1024, nil, colors.orange, nil, 64)
 		R.torchInterval = menu.getInteger("Torch spacing? (0-64)", 0, 64, nil, colors.red)
 		if menu.getBoolean("Seal off water or lava? (y/n)", nil, colors.brown) then
 			R.data = "seal"
 		end
 	elseif R.choice == 53 then	--left/right side of new/existing canal
 		local line = getTaskHelp(2, 110, true, true) -- request line no of help display if needed for getInteger
 		R.data = menu.getInteger("Choose method 1 or 2", 1, 2, line + 1, colors.white)	-- 2 or 4 turtles
 		menu.clear()
 		line = getTaskHelp(2, R.choice, true, true) -- request line no of help display if needed for getInteger
 		R.subChoice = menu.getInteger("Type position of this turtle", 1, 6, line + 1, colors.white)
 		local position = "on ground"
 		local side = "left"
 		local colour = colors.lime
 		if R.subChoice == 1 then
 			R.side = "L"
 			R.height = 1
 			position = "on ground"
 			colour = colors.lime
 		elseif R.subChoice == 2 then
 			R.side = "L"
 			R.height = 1
 			position = "above canal"
 			colour = colors.orange
 		elseif R.subChoice == 3 then
 			R.side = "R"
 			side = "right"
 			R.height = 1
 			position = "above canal"
 			colour = colors.brown
 		elseif R.subChoice == 4 then
 			R.side = "R"
 			side = "right"
 			R.height = 1
 			colour = colors.green
 		elseif R.subChoice == 5 then
 			R.side = "L"
 			R.height = 0
 			position = "on canal base"
 			colour = colors.blue
 		elseif R.subChoice == 6 then
 			R.side = "R"
 			side = "right"
 			R.height = 0
 			position = "on canal base"
 			colour = colors.cyan
 		end
 		line = menu.clear()
 		if R.data == 1 or (R.data == 2 and (R.subChoice == 1 or R.subChoice == 4)) then
 			R.torchInterval = menu.getInteger("Torch spacing? (0-64)", 0, 64, line, colors.red, nil, 0)
 		end
 		-- menu.colourPrint(text, fg, bg, width)
 		-- menu.colourText(row, text, reset)
 		menu.colourPrint("Turtle placed "..side.." "..position, colour)
 		R.length 	= menu.getInteger("Canal length? 0 = continuous ", 0, 512, line + 2, colors.orange, nil, 64)
 	elseif R.choice == 54 then	--ice canal 4 sections: edge+torch, edge, centre+ice, centre no ice
 		local line = getTaskHelp(2, R.choice, true, true) -- request line no of help display if needed for getInteger
 		R.subChoice = menu.getInteger("Type turtle position", 1, 8, line, colors.white)
 		R.side = "L"
 		local position = "on towpath"
 		local side = "left"
 		local colour = colors.lime
 		line = menu.clear()
 		--[[
 			new canal
 			1 = left towpath- move to centre left
 			2 = centre left ice or hollow
 			3 = centre right ice or hollow
 			4 = right side - move to centre right
 			convert water canal
 			5 = left towpath
 			6 = centre left ice or air
 			7 = centre right ice or air
 			8 = right towpath
 		]]
 		if R.subChoice == 1 or R.subChoice == 4 or R.subChoice == 5 or R.subChoice == 8 then
 			-- on towpath r/l
 			R.torchInterval = menu.getInteger("Torch spacing? (0-64)", 0, 64, line, colors.red, nil, 0)
 			if R.subChoice == 4 or R.subChoice == 8 then
 				side = "right"
 				R.side = "R"
 			end
 			if R.subChoice <= 4 then -- 1 or 4 only
 				if menu.getBoolean("Place Ice as well? (y/n)", line + 1, colors.blue) then
 					R.data = "ice"
 				end
 			end
 		else -- on canal centre r/l
 			if R.subChoice == 3 or R.subChoice == 7 then
 				side = "right"
 				R.side = "R"
 			end
 			if R.subChoice == 2 or R.subChoice == 3 then -- new canal
 				R.torchInterval = menu.getInteger("Torch spacing? (0-64)", 0, 64, line, colors.red, nil, 0)
 				position = "above air/ice"
 			end
 			if menu.getBoolean("Place Ice as well? (y/n)", line + 1, colors.blue) then
 				R.data = "ice"
 				if R.subChoice == 6 or R.subChoice == 7 then
 					position = "alternate air/ice"
 					colour = colors.lightBlue
 				end
 			else
 				if R.subChoice == 6 or R.subChoice == 7 then
 					position = "on air spaces"
 					colour = colors.lighGray
 					if R.subChoice == 7 then
 						side = "right"
 						R.side = "R"
 					end
 				end
 			end
 		end
 		R.length 	= menu.getInteger("Canal length? 0 = continuous ", 0, 1024, line + 2, colors.orange, nil, 64)
 		menu.colourPrint("Turtle on "..side.." side "..position, colour)
 		sleep(2)
 	elseif R.choice == 55 then	--platform
 		R.width 	= menu.getInteger("Platform width", 1, 256, 1, colors.yellow)
 		R.length 	= menu.getInteger("Platform length", 1, 256, 2, colors.orange)
 		if menu.getBoolean("Remove blocks above? (y/n)",3, colours.red) then
 			R.up = true
 		end
 
 	elseif R.choice == 56 then	--sinking platform
 		R.width 	= menu.getInteger("Width (excluding retaining wall)? ", 1, 1024, nil, colors.yellow)
 		R.length 	= menu.getInteger("Length (excluding retaining wall)? ", 1, 1024 / R.width, nil, colors.orange)
 		R.height 	= menu.getInteger("Levels to go down?", 1, 1024 / R.width * R.length, nil, colors.blue)
 	elseif R.choice == 57 then	--boat bubble lift
 		R.height 	= menu.getInteger("Levels to go up?", 1, ceiling - 2, nil, colors.lightBlue)
 
 -- 06. MOB SPAWNER TOOLS
 	elseif R.choice == 61 then -- create cube round mob spawner
 		local text =
 [[~yellow~Turtle placement options:
 
 ~lime~1. On top or in front of the spawner
    ~green~(cave spider OR no chests around)
 ~lightGray~2. Outside the dungeon at floor or
    ceiling level ~red~1 block from corner
 ~yellow~Make sure you have access to the block
 facing the spawner, as any chests
 found inside will be placed outside
 the new dungeon wall at this height
 
 ~white~Enter to continue
 ]]
 		menu.colourText(nil, text, true)
 		read()
 		menu.clear()
 		R.data = "spawner"
 		if menu.getBoolean("Any chests around spawner? (y/n)",1, colours.red) then
 			R.data = "chest"
 		end
 		local choices = {"Turtle on spawner (no chests)",
 						 "Outside wall: left side, floor",
 						 "Outside wall: left side, ceiling",
 						 "Outside wall: right side, floor",
 						 "Outside wall: right side, ceiling"}
 		pp.itemColours = {colors.red, colors.lime, colors.orange, colors.green, colors.yellow}
 		local userChoice, modifier = menu.new("Select turtle position", choices, pp) -- 1 to 5
 
 		if modifier == "q" then -- quit chosen
 			R.data = "quit"
 			return R
 		end
 		R.subChoice 	= userChoice
 		if R.subChoice > 1 then -- get dungeon wall dimensions
 			R.width 	= menu.getInteger("Dungeon external width ", 0, 11, nil, colors.yellow, nil, 11)
 			R.length 	= menu.getInteger("Dungeon external length ", 0, 11, nil, colors.orange, nil, 11)
 		end
 
 	elseif R.choice == 62 then -- Blaze spawner
 		local text =
 [[~yellow~Turtle placement options:
 
 ~red~1a On top of the spawner
 
 ~red~1b ~orange~At the same level in direct line of
 spawner.~yellow~ (can be behind a safety wall)
 
 ~red~1c~lightGray~ Room below spawner (via stairs)
 
 ~lime~2 Finish build: In brick floor outside
   existing cube. (facing player)
 
 ~white~Enter to continue]]
 		menu.colourText(nil, text, true)
 		read()
 		pp.itemColours = {colors.red, colors.lime}
 		R.subChoice = menu.new("Choose your option", {"New Blaze spawner", "Complete part build (killzone)"}, pp, "Type number + Enter") -- 1 = new, 2= continue
 		R.data = "blaze"			-- default
 		if R.subChoice == 1 then	-- new blaze spawner
 			text =
 [[~yellow~Turtle placement options:
 ~red~1. On top of the spawner
 ~orange~2. In direct sight (safety wall ok)
 ~lightGray~3. Room below spawner (via stairs)
    |*|*|*|*|*|   Ceiling
    |*|*|~red~T~lightGray~|*|*|   Turtle under ceiling
    |*|~brown~+~lightGray~|*|~brown~+~lightGray~|*|   Top of fence
    |*|~brown~+~lightGray~|*|~brown~+~lightGray~|*|
    |*|~brown~+~lightGray~|*|~brown~+~lightGray~|*|   Bottom of fence
    |*|*|*|*|*|   Floor level]]
 			--R.subChoice = menu.new("Choose your position", {"On top of spawner", "In direct sight (safety wall ok)", "Room below spawner"}, pp, "Type number + Enter")
 			--getInteger(prompt, minValue, maxValue, row, fg, bg, default)
 			T:clear()
 			menu.colourText(nil, text, true)
 			R.subChoice = menu.getInteger("Enter position number", 1, 3, 12, colors.white)
 		else
 			R.data = "restart"		-- complete part build
 		end
 	elseif R.choice == 63 then -- flood spawner cube
 		local choices = {"Bubble lift", "Computercraft mob softener"}
 		pp.itemColours = {colors.lime, colors.orange}
 		local userChoice = menu.menu("Flood for Mob grinder type?", choices, pp, "Type number + Enter ")
 		R.subChoice = userChoice -- 1 bubble, 2 computercraft
 	elseif R.choice == 64 then -- create bubble lift at mob spawner
 		local choices = {"Dropzone on left", "Dropzone on right"}
 		pp.itemColours = {colors.lime, colors.orange}
 		local userChoice = menu.menu("Which side do you want the mobs?", choices, pp, "Type number + Enter")
 		R.subChoice = userChoice -- 1 left, 2 right
 	elseif R.choice == 65 then -- Computercraft mob grinder
 		local choices = {"Use Sticky pistons", "Use non-sticky pistons"}
 		pp.itemColours = {colors.lime, colors.orange}
 		local userChoice = menu.menu("Which type of pistons?", choices, pp, "Type number + Enter ")
 		R.subChoice = userChoice -- 1 sticky, 2 normal
 
 -- 07. AREA CARVING
 	elseif R.choice == 71 then --Clear field
 		R.width 	= menu.getInteger("Width of the area (1-64)", 1, 64, nil, colors.yellow)
 		R.length  	= menu.getInteger("Length of the area (1-64)", 1, 64, nil, colors.orange)
 		if menu.getBoolean("Dirt on the surface (y/n)", nil, colors.brown) then
 			R.useBlockType = "dirt"
 		end
 	elseif R.choice == 72 then -- Clear solid rectangle R.width, R.length
 		R.width 	= menu.getInteger("Rectangle width (1-256)", 1, 256, nil, colors.yellow)
 		R.length  	= menu.getInteger("Rectangle length (1-256)", 1, 256, nil, colors.orange)
 		R.up 		= menu.getBoolean("Remove blocks above?", nil, colors.yellow)
 		R.down 		= menu.getBoolean("Remove blocks below?", nil, colors.orange)
 		if menu.getBoolean("Am I outside clearing zone (y/n)?", nil, colors.yellow) then
 			T:forward(1)
-		T:place(R.useBlockType, "forward", false)
+
 	elseif R.choice == 73 then -- Clear wall
-		T:place("minecraft:redstone_torch", "forward", true)
+
 		R.length 	= menu.getInteger("Length of wall (1-256) ", 1, 256, nil, colors.orange)
 		R.height 	= menu.getInteger("Height of wall (1-50) ", 1, 50, nil, colors.lightGray)
 		pp.itemColours = {colors.lime, colors.orange}
 		R.subChoice = menu.menu("Which direction?", {"Bottom -> Top", "Top -> Bottom"}, pp, "Type number + Enter ") -- open direction menu options
 		if R.subChoice == 1 then
 			if menu.getBoolean("Am I outside clearing zone (y/n)?", nil, colors.yellow) then
 				T:forward(1)
 			end
 		else
 			pp.itemColours = {colors.lightBlue, colors.cyan, colors.blue, colors.gray}
 			local choice = menu.menu("Exact position?", {"On top of clearing zone", "In front of clearing zone", "Inside clearing zone","Above AND outside"}, pp, "Type number + Enter ")
 			if choice == 1 then
 				T:down(1)
-		T:place("minecraft:redstone_torch", "up", false)
+
 				T:forward(1)
 			elseif choice == 4 then
 				T:go("D1F1")
 			end
 		end
 	elseif R.choice == 74 then -- Clear rectangle perimeter only R.width, R.length
 		R.width 	= menu.getInteger("Perimeter width (1-256) ", 1, 256, nil, colors.yellow)
 		R.length  	= menu.getInteger("Perimeter length (1-256) ", 1, 256, nil, colors.orange)
 		R.height 	= 1
 		if menu.getBoolean("Remove blocks above? (y/n)", 3, colours.red) then
-	-- already known R.networkFarm, R.subChoice (1 = singe, 2 = double, 3 = mangrove)
+
-	--T:place(blockType, damageNo, leaveExisting, signText)
+
 		if menu.getBoolean("Remove blocks below? (y/n)", 4, colours.red) then
 			R.down = true
-	function lib.checkSaplings(firstChoice, secondChoice)
+
 		if menu.getBoolean("Am I outside clearing zone (y/n)?", 5, colors.yellow) then
 			T:forward(1)
 		end
 	elseif R.choice == 75 or R.choice == 76 then -- Clear hollow building floor/walls/ceiling OR clear solid object
 		R.width 	= menu.getInteger("Structure width (1-256)", 1, 256, nil, colors.yellow)
 		R.length  	= menu.getInteger("Structure length (1-256)", 1, 256, nil, colors.orange)
 		R.height  	= menu.getInteger("Depth/Height (1-256)", 1, 256, nil, colors.lightGray)
 		if R.choice == 75 then -- hollow building so need to check if floors/ceilings to be removed
 			R.data = {}
 			R.data.ceiling = false
 			R.data.floor = false
-	function lib.emptyInventory(R)
+
-		if not T:isEmpty() then
+
-			utils.useSticksAsFuel()
+
-			network.sendItemToNetworkStorage(R, "barrel", "sapling", 64)
+
-			network.sendItemToNetworkStorage(R, "barrel", "propagule", 64)
+
-			network.sendItemToNetworkStorage(R, "barrel", "apple", 64)
+
-			network.sendItemToNetworkStorage(R, "barrel", "dirt", 64)
+
-			network.sendItemToNetworkStorage(R, "chest", "all", 0)
+
 		R.subChoice = menu.menu("Which direction?", {"Bottom -> Top", "Top -> Bottom"}, pp, "Type number + Enter ") -- open direction menu options
 		if R.subChoice == 1 then
 			if menu.getBoolean("Am I outside clearing zone (y/n)?", nil, colors.yellow) then
-	function lib.getSaplingInventory(R)
+
 			end
 		else
 			pp.itemColours = {colors.lightBlue, colors.cyan, colors.blue, colors.gray}
 			local choice = menu.menu("Exact position?", {"On top of clearing zone", "Outside clearing zone", "Inside clearing zone","Above AND outside"}, pp, "Type number + Enter ")
 			if choice == 1 then
 				T:down(1)
 			elseif choice == 2 then
-		saplings.cherry_sapling = 0
+
-		saplings.mangrove_propagule = 0
+
 				T:go("D1F1")
 			end
 		end
 	elseif R.choice == 77 then	-- Dig a trench
 		R.height 	= menu.getInteger("Depth of the trench (1-64) ", 1, 64, nil, colors.blue)
-		if T:getItemSlot("sapling") > 0 then
+
-			for i = 1, 16 do
+
-				if turtle.getItemCount(i) > 0 then
+
-					local data = turtle.getItemDetail(i)
+
-					if data.name:find("sapling") ~= nil then
+
-						local name = data.name:sub(11) -- removes "minecraft:"
+
-						saplings[name] = saplings[name] + data.count
+
 		local items = {	"Replacing current floor",
 						"New floor over existing",
 						"Replacing current ceiling",
-		elseif T:getItemSlot("propagule") > 0 then
+
-			saplings.mangrove_propagule = turtle.getItemCount(T:getItemSlot("propagule"))
+
-		else	-- no saplings onBoard: ? automated networked farm
+
-			if R.networkFarm then
+
-				-- networked farms use 1 type of sapling indicated by log embedded to right of modem
+
-				-- discovered from utils.assessTreeFarm() on manual Startup
+
-				if R.auto then	-- called here as NOT manual startup
+
-					R = utils.assessTreeFarm(R)
+
-					if R.message ~= "" then
+
-						return {R.message}	-- location of turtle error
+
 		else
 			R.up = true
-				local turtleSlot, turtleCount = network.getItemFromNetwork("barrel", R.useBlockType, 16)
+
-				if turtleCount == 0 then	-- ask player for saplings
+
-					T:checkInventoryForItem({R.useBlockType}, {16}, true, "Saplings required for tree farm")
+
 	elseif R.choice == 710 or R.choice == 83 then -- Direct movement
-				saplings[R.useBlockType] = saplings[R.useBlockType] + turtleCount
+
-				turtleSlot, turtleCount = network.getItemFromNetwork("barrel", "minecraft:dirt", 16)
+
-				if turtleCount == 0 then
+
-					turtleSlot, turtleCount = network.getItemFromNetwork("chest", "minecraft:dirt", 16)
+
 		choices = {"Command driven", "Menu driven"}
-				if turtleCount == 0 then	-- ask player
+
-					T:checkInventoryForItem({"minecraft:dirt"}, {16}, true, "Dirt required for tree farm")
+
 			R.data = "cmd"
-				return saplings, R.useBlockType, R.useBlockType
+
 			R.data = "menu"
 		end
 
 -- 08. WATER LAVA
 	elseif R.choice == 81 then -- Sand based utilities
 		local line = getTaskHelp(2, R.choice, true, true) -- request line no of help display if needed for getInteger
 		R.subChoice = menu.getInteger("Type number of choice", 1, 4, line, colors.white)
 		T:clear()
 		if R.subChoice == 1 then -- drop sand into water or lava surface until solid ground reached
 			R.width	  = 1
 			R.length  = menu.getInteger("Length of sand wall (0=to block) ", 0, 60, nil, colors.orange)
 		elseif R.subChoice == 2 then	-- clear rectangle on top of building and fill with sand
 			R.width   = menu.getInteger("Width of area (<=30) ", 1, 30, nil, colors.yellow)
 			R.length  = menu.getInteger("Length of of area (<=30) ", 1, 30, nil, colors.orange)
 		elseif R.subChoice == 3 then	-- clear sand wall or harvest sand
 			R.width   = 1
 			R.length  = menu.getInteger("Length of sand (0=auto-detect)", 0, 60, nil, colors.orange)
 			choices = {"Stay at end of wall", "Return home"}
 			pp.itemColours = {colors.lime, colors.orange}
 			userChoice = menu.menu("Choose your preference", choices, pp, "Type number + Enter ")
 			if userChoice == 2 then
 				R.data = "return"
-			T:place("dirt", "down", false, "", true)
+
 		elseif R.subChoice == 4 then	-- remove sand from cube. start at top
 			R.width   = menu.getInteger("Width of sand (<=30) ", 1, 30, nil, colors.yellow)
 			R.length  = menu.getInteger("Length of of sand (<=30) ", 1, 30, nil, colors.orange)
 			R.height  = 0
 			R.data = "down" -- always starts at the top
-				T:place(sapling, "down", false, "", true)
+
 		if menu.getBoolean("Am I outside the active zone (y/n)?", nil, colors.yellow) then
 			T:forward(1)
 		end
-				T:place(sapling, "down", false, "", true)
+
 		R.width 	= 1
 		if menu.getBoolean("Going 90 deg. from existing? (y/n)", nil, colors.yellow, colors.black) then
 			getTaskHelp(2, 852, true)
 			menu.clear()
 			R.length = 56
 			R.data = "withPath" -- ensures turtle will break through path
 			R.length = menu.getInteger({"Wall length minus corners","(Ocean monument default 56)","Number -> Enter or Enter only (56)"},
 										1, 64, nil, {colors.yellow, colors.orange, colors.green}, colors.black, 56)
 		else
 			R.length 	= menu.getInteger("Length of the wall (1-60) ", 1, 60, nil, colors.yellow)
 			R.height 	= menu.getInteger("Fixed depth or 0 = to floor ", 0, 60, nil, colors.yellow)
 		end
 	-- for 83 see 710
 	elseif R.choice == 84 then -- Clear area of water bounded by blocks
 		R.width 	= menu.getInteger("Width of water (0=autodetect) ", 0, 64, nil, colors.yellow)
 		if R.width > 0 then
-		T:place("dirt", "down", false, "", true)
+
 		end
-		if not T:place(sapling, "down", false, "", true) then -- try specific sapling
+
-			T:place("sapling", "down", false, "", true)		-- any available sapling
+
 		R.width 	= menu.getInteger("Width (excluding retaining wall)? ", 1, 1024, nil, colors.yellow)
 		R.length 	= menu.getInteger("Length (excluding retaining wall)? ", 1, 1024 / R.width, nil, colors.orange)
 		R.height 	= menu.getInteger("Levels to go down?", 1, 1024 / R.width * R.length, nil, colors.blue)
 	elseif R.choice == 86 then -- ocean monument utilities
 		local items	=
 		{
 			"Build 4 corner marker columns",
 			"Retaining wall beween 2 columns",
 			"Clear plants pre sand draining",
 			"Drop sand wall",
 			"Recover sand wall",
 			"Sinking platform",
-	function lib.getMangroveSupplies()
+
-		local turtleSlot, turtleCount = network.getItemFromNetwork("barrel", "minecraft:dirt", 169)
+
-		if turtleCount < 169 then
+
-			turtleSlot, turtleCount = network.getItemFromNetwork("chest", "minecraft:dirt", 169 - turtleCount)
+
-			if turtleCount < 169 then	-- ask player for saplings
+
-				T:checkInventoryForItem({"dirt"}, {169 - turtleCount})
+
 		end
 		menu.clear()
-		turtleSlot, turtleCount = network.getItemFromNetwork("barrel", "minecraft:mangrove_propagule", 25)
+
-		if turtleCount == 0 then	-- ask player for saplings
+
-			T:checkInventoryForItem({"mangrove_propagule"}, {25}, true, "Mangrove propagules required")
+
 		elseif R.subChoice == 2 then -- Retaining wall beween 2 columns
 			R.length = 56
 			R.data = "withPath" -- ensures turtle will break through path
-	function lib.plantMangrove()
+
-		T:go("L1F6 R1F1 U1")
+
-		createFloorCeiling({width = 13, length = 13, up = false, down = true,
+
-							height = 0, subChoice = 0, useBlockType = "minecraft:dirt",
+
-							inventory = T:getInventory()})
+
 			R.data = "clearWaterPlants"
-		--T:go("U1F5 R1F5 L1")			-- lower left of planting area, facing Back
+
-		T:go("U1F4 R1F4 L1")			-- lower left of planting area, facing Back
+
-		for x = 1, 5 do
+
-			for i = 1, 5 do
+
-				T:place("propagule", "down")	-- left 1
+
-				if i < 5 then
+
 		elseif R.subChoice == 5 then -- remove sand wall using sand utilities
 			R.width	  = 1
 			R.length  = 0
-			if x % 2 == 1 then
+
-				if x < 5 then
+
 			R.length = menu.getInteger("Length (excluding retaining wall)? ", 1, 1024 / R.width, nil, colors.orange)
 			R.height = menu.getInteger("Levels to go down?", 1, 1024 / R.width * R.length, nil, colors.blue)
 		elseif R.subChoice == 7 then -- Drain and remove structure
 			R.width = 28
 			R.length = 28
 			R.height = menu.getInteger("Go down how far from current", 1, 64, nil, colors.blue)
-		T:go("L1F2 L1F2 D2U2 F7R2 D2")
+
 	elseif R.choice == 87 then -- Ladder to water/lava
-		T:place("propagule", "down")	-- left 1
+
 	elseif R.choice == 88 then -- Clear water plants from enclosed area
-		T:place("propagule", "down")	-- left 2
+
 		R.width 	= menu.getInteger("water width (0=auto detect) ", 0, 64, nil, colors.yellow)
-		T:place("propagule", "down")	-- left 3/top 1
+
 	elseif R.choice == 89 then -- convert flowing water to source
-		T:go("R1F1")
+
-		T:place("propagule", "down")	-- top 2
+
 			R.length = menu.getInteger("water length (0=auto detect) ", 0, 64, nil, colors.orange)
-		T:place("propagule", "down")	-- top 3/right 1
+
-		T:go("R1F1")
+
 	elseif R.choice == 810 then -- create sloping water
-		T:place("propagule", "down")	-- right 2
+
 		R.length 	= menu.getInteger("water slope length ", 1, 64, nil, colors.orange)
-		T:place("propagule", "down")	-- right 3/bottom 1
+
-		T:go("R1F1")
+
-		T:place("propagule", "down")	-- bottom 2]]
+
 		R.width 	= 1
-		--T:go("R1F1R2 D2U2 F7R2 D2")
+
 		R.height 	= menu.getInteger("Height of wall (1-50) ", 1, 50, nil, colors.lightGray)
 		pp.itemColours = {colors.lime, colors.magenta}
-	function lib.plantSingle(R)
+
-		local sapling, count = lib.checkSaplings(firstChoice, secondChoice)
+
-		if count >= 1 then
+
-			if R.networkFarm then
+
-				T:go("U1L1 F3R1 F4") -- outside first area
+
 		pp.itemColours = {colors.lime, colors.magenta}
-				T:go("U1F4") -- outside first area
+
 	elseif R.choice == 93 or R.choice == 94 then -- Build gable roof / pitched roof
-			for i = 1, 3 do	-- column 1/4
+
-				lib.createSingle(sapling, "forward")
+
 	elseif R.choice == 97 then -- build downward slope
 		R.height  	= menu.getInteger("How many blocks down (0=to ground)?", 0, 256, nil, colors.blue)
-			for i = 1, 2 do
+
-				lib.createSingle(sapling, "right") -- place 4th dirt/saling and exit to right
+
 		R.height  	= menu.getInteger("Go up by how many blocks?", 1, 256, nil, colors.lightGray)
 		R.up = true
-			for i = 1, 2 do -- column 2/4
+
-				lib.createSingle(sapling, "forward")
+
 	elseif R.choice == 101 then -- measure height
 		pp.itemColours = {colors.lightBlue, colors.cyan, colors.lime, colors.gray}
-			for i = 1, 2 do
+
-				lib.createSingle(sapling, "left") -- place 4th dirt/saling and exit to right
+
 			R.data = menu.getString({"Search for? eg 'ore', 'obsidian'",">"}, false, 3, 20, nil, {colors.lime, colors.yellow})
 		end
-			for i = 1, 2 do -- column 3/4
+
-				lib.createSingle(sapling, "forward")
+
 		pp.itemColours = {colors.lime, colors.orange, colors.green}
 		R.subChoice	= menu.menu("Measure using?", {"Water/Lava/Obstruction below", "No further blocks ahead", "Detect specific block ahead"}, pp, "Type number + Enter") -- open direction menu options
-			for i = 1, 2 do
+
-				lib.createSingle(sapling, "right") -- place 4th dirt/saling and exit to right
+
 		end
 	elseif R.choice == 103 then -- measure length
-			for i = 1, 3 do -- column 4/4
+
-				lib.createSingle(sapling, "forward")
+
 													"No further blocks above",
 													"No further blocks below",
-			if R.networkFarm then
+
-				T:go("R1F3 R1F2L1") -- in-between 2 trees
+
-				if R.auto then
+
-					harvestTreeFarm(R)
+
 		end
-					T:go("L1F4R2D1")
+
 	elseif R.choice == 104 then -- measure greatest depth of water body
 		pp.itemColours = {colors.lime, colors.orange}
-				T:go("R1F6 L1F2 R2D1")
+
 		-- 1 = player entry, 2 = water length
 		if R.subChoice == 1 then
-			return "No saplings to plant"
+
 		end
 	elseif R.choice == 105 then -- drill borehole and write borhole.txt to file
 		R.height = menu.getInteger("Current level (F3->Y coord)? ", bedrock + 5, ceiling, nil, colors.lightGray)
 		R.depth = menu.getInteger("Go down to level? ("..R.height - 2 .." to "..bedrock + 5 ..")", bedrock + 5 ,R.height - 2, nil, colors.blue, nil, bedrock + 5)
 	end
-	function lib.plantDouble(R)
+
 	return R
 end
 
 local function getTaskInventoryTo30(R)
-			if R.networkFarm then
+
-				T:go("U1L1 F3R1 F3") -- outside first area
+
 	--local pp = utils.getPrettyPrint()
-				T:go("U1F3") -- outside first area
+
 	if R.choice == 0 then --Missing pickaxe
 		T:checkInventoryForItem({"minecraft:diamond_pickaxe"}, {1})
-			sapling, count = lib.checkSaplings(firstChoice, secondChoice)
+
 		T:setEquipment()
 	elseif R.choice == 1 then --Missing crafting table
-			sapling, count = lib.checkSaplings(firstChoice, secondChoice)
+
 		print("Crafting table being tested...")
 		T:setEquipment()
-			sapling, count = lib.checkSaplings(firstChoice, secondChoice)
+
 		T:checkInventoryForItem({"minecraft:chest"}, {1}) -- 0 if not present
 		sleep(1.5)
 
-			if R.networkFarm then
+
-				T:go("R1F4 R1F1 L1") 			-- on left side of double tree
+
-				if R.auto then
+
-					harvestTreeFarm(R)
+
 		pp.itemColours = {colors.blue, colors.lightGray}
-					T:go("L1F4 L1F1 L1D1")	-- back to start
+
 		local inAir = false
 		local inNether = menu.getBoolean("Are you in the nether? (y/n) ", nil, colors.yellow, colors.black)
-				T:go("R1D1 F6L1 F3R2") -- outside first area
+
 		if inNether then
 			bedrock = 0
-			return "Insufficient saplings to plant"
+
 		end
 		local option = menu.menu("Which direction?", {"Going down","Going up"}, pp)
 		if option == 1 then
 			R.down = true
-	if R.networkFarm then
+
-		local message = network.loadStorageLists()	-- initialises or creates lists of where an item can be found: GLOBAL LISTS!
+
-		if message ~= nil then return {message} end
+
-		lib.emptyInventory(R)
+
 					R.data = "chamber"
-	if R.subChoice == 3 then	-- mangrove, R.networkFarm only
+
-		lib.getMangroveSupplies()
+
-		lib.plantMangrove()
+
 				description = "Creating stairs going down"
-		local saplings, firstChoice, secondChoice = lib.getSaplingInventory(R)
+
-		if firstChoice ~= "" then
+
-			print("first sapling: "..firstChoice .. " ("..saplings[firstChoice]..")")
+
 			--R.depth = utils.getSize(true,"Current level (F3->Y coord)? ", bedrock + 5, ceiling)
-		if secondChoice ~= "" then
+
-			print("second sapling: "..secondChoice .. " ("..saplings[secondChoice]..")")
+
 			R.height = menu.getInteger("Go up to level? ("..R.depth + 2 .." to "..ceiling ..") ", R.depth + 2, ceiling, nil, colors.lightGray)
 			if R.choice == 11 then
-		-- check type/size of farm
+
 			else
-		if R.subChoice == 1 then 			-- 16 single trees
+
-			message = lib.plantSingle(R)	-- always ""
+
-		elseif R.subChoice == 2 then 		-- 4 double trees (4 saplings)
+
-			message = lib.plantDouble(R)	-- "" or error about numbers
+
 
 		if not inAir then
-	if R.networkFarm then
+
-		lib.emptyInventory(R)
+
 		--[[
-	return {message}
+
 		-50 to -59 = -59 -(-50) = -9   down
 		-59 to -50 = -50 -(-59) = 9    up
 		 70 to -48 = -48 -   70 = -118 down
 		  5 to  64 =  64 -   5  = 59   up
 		]]
 		T:checkInventoryForItem({"minecraft:bucket"}, {1}, false)
 		if R.choice == 11 then -- ladders
 			utils.checkFuelNeeded(range * 2)
 			T:checkInventoryForItem({"minecraft:ladder"}, {range})
 			T:checkInventoryForItem({"minecraft:torch"}, {math.floor(range / 3)}, false)
 			if inAir then
 				range = range * 4 -- more blocks needed
 			end
 			T:checkInventoryForItem({"stone"}, {range})
 		else -- stairs
 			utils.checkFuelNeeded(range * 10) -- stairs: each layer needs 10 moves
 			local numStairsNeeded = range
 			local data = T:getStock("stairs")
 			local numStairs = data.total
 			local cobbleNeeded = math.min(range * 6, 256)
 			if inAir then
 				cobbleNeeded = range * 6 -- 5 blocks / layer unless in water or lava
 			end
 			if numStairs < numStairsNeeded then
 				cobbleNeeded = cobbleNeeded + (math.floor((2 * (numStairsNeeded - numStairs)) / 3))
 			end
 			T:checkInventoryForItem({"stairs"}, {numStairsNeeded}, false)
 			T:checkInventoryForItem({"stone"}, {cobbleNeeded})
 			T:checkInventoryForItem({"minecraft:chest"}, {1}) 	-- needed for crafting
 		end
 		menu.colourPrint(description, colors.lightBlue)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		if R.choice == 11 then
 			retValue = createLadder(R) -- "bedrock", 70, -48
 		else
 			retValue = createStaircase(R)
 		end
 	elseif R.choice == 13 then --Create Mine at this level
 		utils.checkFuelNeeded(960)
 		T:checkInventoryForItem({"minecraft:torch"}, {24}, false)
 		T:checkInventoryForItem({"minecraft:bucket"}, {1}, false)
 		T:checkInventoryForItem({"stone"}, {64})
 		T:checkInventoryForItem({"minecraft:chest"}, {1})
 		menu.colourPrint("CreateMine starting", colors.lightBlue)
 		sleep(2)
 		retValue = createMine()
 	elseif R.choice == 14 then	-- safe drop to water
 		utils.checkFuelNeeded(R.height * 2)
 		T:checkInventoryForItem({"minecraft:water_bucket"}, {1})
 		T:checkInventoryForItem({"stone"}, {R.height * 2}, false) -- estimate only partial cloaking needed
 		menu.colourPrint("Creating safe drop ".. R.height.. " blocks deep", colors.lightBlue)
 		menu.colourPrint("Wait for my return!", colors.yellow)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		retValue = createSafeDrop(R)
 	elseif R.choice == 15 then	-- single column bubble lift
 		local needSigns = true
 		utils.checkFuelNeeded(R.height * 6)
 		--print(text, fg, bg, width)
 		menu.colourPrint("Checking if near ladder", colors.red)
 		T:turnRight(1)
 		local blockType = T:getBlockType("forward")
 		if blockType:find("ladder") == nil then
 			T:turnLeft(2)
 			blockType = T:getBlockType("forward")
 			if blockType:find("ladder") == nil then
 				needSigns = false
 			end
 			T:turnRight(1)
 		else
 			needSigns = false
 			T:turnLeft(1)
 		end
 		sleep(1)
 		if needSigns then
 			T:checkInventoryForItem({"sign"}, {2}, true, "Ladder not found")
 		else
 			menu.colourPrint("Ladder found, signs not required", colors.orange)
 			sleep(1)
 		end
 		if T:getBlockType("down"):find("bedrock") == nil then -- NOT bedrock below
 			T:checkInventoryForItem({"minecraft:water_bucket"}, {3})
 		else
 			T:checkInventoryForItem({"minecraft:water_bucket"}, {2})
 		end
 		T:checkInventoryForItem({"minecraft:soul_sand", "minecraft:dirt"}, {1, 1}, true, "? use dirt as soul sand placeholder")
 		T:checkInventoryForItem({"stone"}, {R.height * 2}, false) -- estimate only partial cloaking needed
 		local _, slots = T:getFirstEmptySlot() -- returns first empty slot, no of empty slots
 		T:checkInventoryForItem({"minecraft:bucket"}, {slots}, false, "Add empty buckets for speed!")
 		menu.colourPrint("Creating bubble lift ".. R.height.. " blocks high", colors.lime)
 		if not needSigns then -- ladder present as signs not required
 			menu.colourPrint("Wait at the top via ladder...", colors.orange)
 		end
 		menu.colourPrint("\nSTAND ON THE LADDER FOR SAFETY!", colors.red)
 		menu.colourPrint("\nEnter to continue", colors.yellow)
 		read()
 		retValue = createBubbleLift(R)
 	elseif R.choice == 16 then --QuickMine corridor
 		utils.checkFuelNeeded((R.width * 2 + R.length * 2) * 2)
 		T:checkInventoryForItem({"stone"}, {R.width * 2 + R.length * 2}, false)
 		T:checkInventoryForItem({"minecraft:torch"}, {math.floor((R.width * 2 + R.length * 2) / R.torchInterval)}, false)
 		T:checkInventoryForItem({"minecraft:bucket"}, {1}, false)
 		menu.colourPrint("QuickMine corridor: R.subChoice "..R.width.. " x "..R.length, colors.lightBlue)
 		retValue = quickMineCorridor(R)
 	elseif R.choice == 17 then --QuickMine
 		utils.checkFuelNeeded(R.width * R.length)
 		T:checkInventoryForItem({"stone"}, {64})
 		T:checkInventoryForItem({"minecraft:bucket"}, {1}, false)
 		menu.colourPrint("QuickMine rectangle: R.subChoice "..R.width.. " x "..R.length, colors.lightBlue)
 		retValue = quickMine(R)
 	elseif R.choice == 18 then --Mine bedrock area
 		utils.checkFuelNeeded(R.width * R.length)
 		T:checkInventoryForItem({"stone"}, {64})
 		T:checkInventoryForItem({"minecraft:bucket"}, {1}, false)
 		retValue = mineBedrockArea(R) -- R.data = "leaveExposed" or ""
 	elseif R.choice == 19 then	-- salvage mineshaft
 		local equippedRight, equippedLeft, inInventory = T:setEquipment() -- check for crafting table, sword, pickaxe, Put sword in spare slot
 		if equippedLeft ~= "minecraft:diamond_pickaxe" and equippedRight ~= "minecraft:diamond_pickaxe" then
 			T:checkInventoryForItem({"minecraft:diamond_pickaxe"}, {1}, true)
 			equippedRight, equippedLeft, inInventory = T:setEquipment() -- check for crafting table, sword, pickaxe, Put sword in spare slot
 		end
 		if inInventory ~= "minecraft:diamond_sword" then
 			T:checkInventoryForItem({"minecraft:diamond_sword"}, {1}, false, "To harvest spider webs\nyou need a diamond sword.") --checkInventoryForItem(self, items, quantities, required, message, name)
 		end
 		if T:getItemSlot("minecraft:diamond_sword") > 0 then
 			inInventory = "minecraft:diamond_sword"
 		end
 		T:checkInventoryForItem({"minecraft:torch"}, {R.torchInterval}, false)
 		if inInventory == "minecraft:diamond_sword" then
 			menu.colourPrint("Clearing Mineshaft and cobwebs", colors.orange)
 		else
 			menu.colourPrint("Clearing Mineshaft", colors.yellow)
 		end
 		retValue = clearMineshaft(R, equippedRight, equippedLeft, inInventory) -- pass whether the sword is present
 
 	-- FORESTRY
 	elseif R.choice == 21 then	-- Fell tree
 		if T:isLog("forward") then
 			if turtle.getFuelLevel() < 30 then
 				T:checkInventoryForItem({"minecraft:chest"}, {1}, false,"Fuel level critical: "..turtle.getFuelLevel())
 				turtle.select(1)
 				T:dig("forward")
 				T:craft("planks", 4)
 				T:refuel()
 				T:forward(1)
 				T:up(2)
 				T:craft("chest", 1)
 			else
 				T:forward(1)
 			end
 			menu.colourPrint("Felling tree", colors.lime)
 			os.sleep(2)    -- pause for 2 secs to allow time to press esc
 			T:harvestWholeTree("up")
 			while turtle.down() do end
 			retValue = {"Tree Harvested"}
 		else
 			retValue =
 			{
 				"No log in front..",
 				"Move me in front of a tree!"
 			}
 		end
 	elseif R.choice == 22 then --Create treefarm
 		utils.checkFuelNeeded(900)
 		--T:checkInventoryForItem({"minecraft:dirt"}, {16})
 		T:checkInventoryForItem({"stone"}, {320})
 		T:checkInventoryForItem({"polished"}, {4}) -- used to mark launch positions
 		T:checkInventoryForItem({"minecraft:water_bucket"}, {5})
 		R.useBlockType = T:getMostItem("", true)
 		menu.colourPrint("Creating Tree Farm with "..R.useBlockType, colors.lime)
 		sleep(2)
 		retValue = createTreefarm(R)
 	elseif R.choice == 23 then -- Plant treefarm
 		if R.subChoice == 1 then
 			utils.checkFuelNeeded(180)
 			T:checkInventoryForItem({"dirt"}, {16})
 			T:checkInventoryForItem({"sapling"}, {16}, false, "Max 16. NOT dark oak")
 		elseif R.subChoice == 2 then
 			utils.checkFuelNeeded(180)
 			T:checkInventoryForItem({"dirt"}, {16})
 			T:checkInventoryForItem({"sapling"}, {16}, false, "Max 16. 4 saplings / tree")
 		end
 		menu.colourPrint("plantTreefarm starting: size "..R.subChoice, colors.lime)
 		retValue = plantTreefarm(R)
 	elseif R.choice == 24 then	-- Harvest treefarm
 		print(thanks)
 		os.sleep(2)
 		menu.colourPrint("Harvesting treefarm starting", colors.lime)
 		retValue = harvestTreeFarm(R)
 	elseif R.choice == 25 then	-- Build wall / fence
 		utils.checkFuelNeeded(R.width * R.length * 2)
 		local quantity = math.ceil((R.width + R.length) * 2.3)
 		T:checkInventoryForItem({"wall", "fence"}, {quantity, quantity})
 		if R.torchInterval > 0 then
 			T:checkInventoryForItem({"minecraft:torch"}, {math.floor(quantity / R.torchInterval)}, false)
 		end
 		if R.data == "barrel" then
 			T:checkInventoryForItem({"barrel"}, {4}, false)
 		end
 		R.useBlockType = T:getMostItem("", false) -- no excluded blocks, any block type
 		menu.colourPrint("Creating "..R.width.." x "..R.length.." walled enclosure", colors.yellow)
 		menu.colourPrint("Using: "..R.useBlockType, colors.orange)
 		retValue = createWallOrFence(R)
 	elseif R.choice == 26 then	-- clear natural forest
 		T:checkInventoryForItem({"minecraft:chest"}, {1})
 		T:checkInventoryForItem({"sapling"}, {64}, false)
 		menu.colourPrint("Clearing and replanting trees", colors.lime)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		retValue = clearAndReplantTrees()
 	end
 	return retValue
 end
 
 local function getTaskInventoryTo70(R)
 	local retValue = {}
 	local thanks = "Thank you.\n\nPress the ESC key\n\nStand Back..\n"
 	-- FARMING
 	if R.choice == 31 then	-- Create modular farm
 		utils.checkFuelNeeded(300)
 		T:checkInventoryForItem({"cobble"}, {64})
 		T:checkInventoryForItem({"dirt"}, {128}, false)
 		T:checkInventoryForItem({"water_bucket"}, {4})
 		T:checkInventoryForItem({"chest", "barrel"}, {5,5})
 		T:checkInventoryForItem({"sapling"}, {1})
 		R.useBlockType = T:getMostItem("dirt", true) -- exclude dirt from count
 		print(thanks)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		print("Creating modular farm with "..R.useBlockType)
 		retValue = createFarm(R, false)
 	elseif R.choice == 32 then	-- Extend modular farm
 		utils.checkFuelNeeded(300)
 		T:checkInventoryForItem({"cobble"}, {64})
 		T:checkInventoryForItem({"dirt"}, {128}, false)
 		T:checkInventoryForItem({"water_bucket"}, {4})
-				"2 water buckets","192 fence","8 signs","3 ladder","2 soul sand"}						-- build endermen observation tower
+		T:checkInventoryForItem({"chest", "barrel"}, {5,5})
-	text[67] = {"24 blocks of any type"}																-- Cover Trial spawners to prevent mobs escaping
+
 		T:checkInventoryForItem({"crafting"}, {1}) -- will be placed inside barrel / chest next to water source
 		R.useBlockType = T:getMostItem("dirt", true) -- exclude dirt from count
 		menu.colourPrint("Checking position...\n", colors.green)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		retValue = createFarmExtension(R) -- subChoice = 1 for ahead, 2 for to the right
 	elseif R.choice == 33 then	-- manage modular farm
 		-- inventory checked in function depending on option taken
 		R.data = "farm"
 		retValue = manageFarmSetup(R)
 	elseif R.choice == 34 then	-- build single fence
 		utils.checkFuelNeeded(R.length)
 		T:checkInventoryForItem({"wall", "fence"}, {R.length, R.length})
 		if R.torchInterval > 0 then
 			T:checkInventoryForItem({"minecraft:torch"}, {math.ceil(R.length / R.torchInterval)}, false)
 		end
 		R.useBlockType = T:getMostItem("minecraft:torch") -- exclude torch
 		menu.colourPrint("Creating "..R.length.." wall or fence", colors.green)
 		menu.colourPrint("Using: "..R.useBlockType, colors.orange)
 		retValue = createWallOrFence(R) -- barrels not included in R.data, R.width = 0 so only single length
 	elseif R.choice == 35 then	-- build fence
 		utils.checkFuelNeeded(R.width * R.length * 2)
 		local quantity = math.ceil((R.width + R.length) * 2.3)
 		T:checkInventoryForItem({"wall", "fence"}, {quantity, quantity})
 		if R.torchInterval > 0 then
 			T:checkInventoryForItem({"minecraft:torch"}, {math.floor(quantity / R.torchInterval)}, false)
 		end
 		R.useBlockType = T:getMostItem("minecraft:torch") -- exclude torch
 		menu.colourPrint("Creating "..R.width.." x "..R.length.." walled enclosure", colors.green)
 		menu.colourPrint("Using: "..R.useBlockType, colors.orange)
 		retValue = createWallOrFence(R) -- barrels not included in R.data
 	-- OBSIDIAN
 	elseif R.choice == 41 then --harvest obsidian
 		utils.checkFuelNeeded(R.width * R.length * 3)
 		T:checkInventoryForItem({"stone"}, {R.width * R.length})
 		T:checkInventoryForItem({"minecraft:bucket", "minecraft:lava_bucket"}, {1, 1}, false, "Get extra fuel as well!")
 		menu.colourPrint("Harvesting obsidian area: size "..R.width.. " x "..R.length, colors.orange)
 		sleep(2)
 		retValue = harvestObsidian(R)
 	elseif R.choice == 42 then --build nether portal
 		utils.checkFuelNeeded(R.length * R.height * R.width)	-- length = width when facing standard = 5 high 4 length 1 width
 		T:checkInventoryForItem({"minecraft:obsidian"}, {((R.length - 2 + R.height - 2) * R.width * 2)})
 		T:checkInventoryForItem({"stone"}, {R.width * 4})
 		R.useBlockType = T:getMostItem("obsidian", true) -- exclude obsidian from count
 		menu.colourPrint("Building Nether portal", colors.orange)
 		sleep(2)
 		retValue = createPortal(R)
 	elseif R.choice == 43 then --demolish nether portal
 		utils.checkFuelNeeded(20)
 		print("Demolishing Nether portal")
 		retValue = demolishPortal(R)
 	elseif R.choice == 44 then -- Strip mine Netherite
 		utils.checkFuelNeeded(R.length * 2)
 		T:checkInventoryForItem({"stone"}, {R.length * 4})
 		R.useBlockType = T:getMostItem("", true) -- exclude none, use stone only/netherrack
 		T:checkInventoryForItem({"cobble"}, {math.floor(R.length / 16) * 4}, true, "For marking Chunk boundaries")
 		T:checkInventoryForItem({"minecraft:bucket", "minecraft:lava_bucket"}, {1, 1})
 		T:checkInventoryForItem({"minecraft:torch"}, {math.floor(R.length / 16)}, false)
 		retValue = createStripMine(R)
 	elseif R.choice == 45 then --undermine dragon towers
 		utils.checkFuelNeeded(500)
 		T:checkInventoryForItem({"minecraft:cobblestone", "minecraft:cobbled_deepslate"}, {84, 84})
 		print("Undermining dragon towers")
 		retValue = undermineDragonTowers()
 	elseif R.choice == 46 then --deactivate dragon tower
 		utils.checkFuelNeeded(50)
 		print("Deactivating dragon tower")
 		retValue = deactivateDragonTower()
 	elseif R.choice == 47 then --build dragon water trap
 		utils.checkFuelNeeded(256)
 		T:checkInventoryForItem({"stone"}, {356})
 		T:checkInventoryForItem({"minecraft:obsidian"}, {1})
 		T:checkInventoryForItem({"minecraft:ladder"}, {145})
 		T:checkInventoryForItem({"minecraft:water_bucket"}, {1})
 		print("Building dragon water trap")
 		retValue = createDragonTrap()
 	elseif R.choice == 48 then --build portal minecart station
 		utils.checkFuelNeeded(200)
 		menu.colourPrint("Inventory after height measurement", colors.red)
 		menu.colourPrint("Enter to start measurement.", colors.lime)
 		read()
 		print("Building portal platform")
 		retValue = createPortalPlatform()
 	elseif R.choice == 49 then -- shulker harvesting
 		retValue = harvestShulkers(R)
 
 	-- CANAL BRIDGE
 	elseif R.choice == 51 then	-- continuous path over void/water/lava
 		utils.checkFuelNeeded(R.length) -- allow for R.length
 		if R.data ~= "reduce" then
 			T:checkInventoryForItem({"stone"}, {R.length}, false)
 			if R.torchInterval > 0 then
 				T:checkInventoryForItem({"minecraft:torch"}, {math.floor(R.length/R.torchInterval)}, false)
 			end
 			print("Building continuous path")
 		end
 		retValue = utils.createPath(R) -- returns {numBlocks}
 	elseif R.choice == 52 then	-- simple 2 block corridor
 		utils.checkFuelNeeded(R.length)
 		T:checkInventoryForItem({"stone"}, {R.length * 2}, false)
 		if R.torchInterval > 0 then
 			T:checkInventoryForItem({"minecraft:torch"}, {math.ceil(R.length / R.torchInterval)}, false)
 		end
 		print(thanks)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		print("Building simple corridor")
 		retValue = createCorridor(R)
 	elseif R.choice == 53 then	-- canal management
 		local torches = 0
 		local length = R.length
 		if length > 0 then
 			utils.checkFuelNeeded(length * 4) -- allow for 1024 R.length
 			if R.torchInterval > 0 then
 				torches = math.floor(length / R.torchInterval)
 			end
 		else
 			utils.checkFuelNeeded(2048) -- allow for 1024 R.length
 			length = 256
 		end
 		T:checkInventoryForItem({"stone"}, {length})
 		R.useBlockType = T:getMostItem("", true)
 		if R.data == 1 or (R.data == 2 and (R.subChoice == 2 or R.subChoice == 3 or R.subChoice == 5 or R.subChoice == 6)) then
 			T:checkInventoryForItem({"minecraft:water_bucket"}, {2})
 		end
 		if torches > 0 then
 			T:checkInventoryForItem({"minecraft:torch"}, {torches}, false)
 		end
 		retValue = createWaterCanal(R)
 	elseif R.choice == 54 then	-- ice canal
 		local default = R.length
 		if R.length > 0 then
 			utils.checkFuelNeeded(R.length)
 		else
 			default = 64
 			utils.checkFuelNeeded(default * 2) -- allow for 128 min R.length
 		end
 		--[[
 			new canal
 			1 = left towpath- move to centre left
 			2 = centre left ice or hollow
 			3 = centre right ice or hollow
 			4 = right side - move to centre right
 			convert water canal
 			5 = left towpath
 			6 = centre left ice or air
 			7 = centre right ice or air
 			8 = right towpath
 		]]
 		if R.subChoice <= 5 or R.subChoice == 8 then	-- towpath
 			T:checkInventoryForItem({"slab"}, {default}, true, "Add slabs to length required")
 		end
 		if R.torchInterval > 0 then
 			--checkInventoryForItem(items, quantities, required, message)
 			T:checkInventoryForItem({"stone"}, {math.ceil(default / R.torchInterval)}, true, "NOT bricks!")
 			R.useBlockType = T:getMostItem("", true)
 			T:checkInventoryForItem({"torch"}, {math.ceil(default / R.torchInterval)}, false)
 		end
 		if R.data == "ice" then	-- ice canal with 2 spaces above
 			T:checkInventoryForItem({"minecraft:packed_ice", "minecraft:blue_ice"}, {math.ceil(R.length / 2), math.ceil(R.length / 2)}, false)
 		end
 		print(thanks)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		print("Building ice canal")
 		retValue = createIceCanal(R)
 	elseif R.choice == 55 then -- platform
 		local volume = R.width * R.length
 		utils.checkFuelNeeded(volume)
 		T:checkInventoryForItem({"stone", "dirt"}, {volume, volume})
 		R.useBlockType = T:getMostItem("", true)
 		print(thanks)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		print("Building platform")
 		retValue = createPlatform(R)
 	elseif R.choice == 56 then -- sinking platform
 		local volume = (R.width + 1) * (R.length + 1)
 		utils.checkFuelNeeded(volume * (R.height + 1))
 		T:checkInventoryForItem({"stone"}, {volume + ((R.length * 2) + (R.width * 2) * R.height) + 1})
 		print(thanks)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		print("Building sinking platform")
 		retValue = createSinkingPlatform(R)
 	elseif R.choice == 57 then -- boat bubble lift
 		utils.checkFuelNeeded(R.height * 20)
 		T:checkInventoryForItem({"minecraft:bucket","minecraft:water_bucket"}, {2, 2})
 		T:checkInventoryForItem({"stone"}, {R.height * 10})
 		T:checkInventoryForItem({"gate"}, {R.height * 2})
 		T:checkInventoryForItem({"minecraft:soul_sand"}, {R.height * 2 + 2})
 		print(thanks)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		print("Building boat bubble lift")
 		retValue = createBoatLift(R)
 		--retValue = createBoatLift(R) -- R.subChoice:0=new, R.subChoice:1=extend, R.length:0=left, 1=right
 
 	-- MOB SPAWNER
 	elseif R.choice == 61 then	--  9x9 hollow cube cobble lined
 		utils.checkFuelNeeded(600) -- allow for 600 moves
 		T:checkInventoryForItem({"slab","stone"}, {1, 3}, true, "Slab can be crafted from 3 stone")
 		if T:getItemSlot("stone") > 0 and T:getItemSlot("slab") == 0 then -- no slabs, but is stone
 			local craftOK, message = T:craft("slab")
 		end
 		if R.data == "chest" then
 			menu.colourText(nil, "~yellow~Chest(s) will be emptied first\nWait for me to exit and request\n~orange~around 700 stone!\n\n~lightGray~Enter to continue", true)
 			read()
 		else
 			T:checkInventoryForItem({"stone"}, {512}, false, "Full cube uses ~700 blocks\nEstimate your requirements")
 		end
 		print(thanks)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		retValue = createMobFarmCube(R) -- R.data = "spawner" or "chest": not blaze
 	elseif R.choice == 62 then	-- Blaze spawner
 		utils.checkFuelNeeded(2500) -- allow for 2500 moves
 		if R.data == "blaze" then
 			T:checkInventoryForItem({"slab"}, {122}, true)
 			T:checkInventoryForItem({"stone"}, {576})
 			print("You will be asked for more assets later")
 			print("Enter to continue")
 			read()
 		end	 -- else R.data == "restart"
 		retValue = createMobFarmCube(R)	--R.data = "blaze" or R.data = "restart"
 	elseif R.choice == 63 then	--  flood mob spawner
 		utils.checkFuelNeeded(60) -- allow for 60 moves
 		T:checkInventoryForItem({"minecraft:water_bucket"}, {2})
 		if R.subChoice == 1 then
 			T:checkInventoryForItem({"fence"}, {2})
 			T:checkInventoryForItem({"sign"}, {2})
 			T:checkInventoryForItem({"slab"}, {1})
 			T:checkInventoryForItem({"minecraft:soul_sand", "minecraft:dirt"}, {1, 1}, true)
 		end
 		print(thanks)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		retValue = floodMobFarm(R)
 	elseif R.choice == 64 then -- build bubble lift on top of soul sand
 		utils.checkFuelNeeded(200) -- allow for 200 moves
 		T:checkInventoryForItem({"slab","stone"}, {6, 3}, true, "Slabs can be crafted from 3 stone")
 		if T:getItemSlot("stone") > 0 and T:getItemSlot("slab") == 0 then -- no slabs, but is stone
 			local craftOK, message = T:craft("slab")
 		end
 		T:checkInventoryForItem({"minecraft:water_bucket"}, {2})
 		T:checkInventoryForItem({"stone"}, {256})
 		if T:getBlockType("down") ~= "minecraft:soul_sand" then
 			T:checkInventoryForItem({"minecraft:soul_sand"}, {1})
 		end
 		T:checkInventoryForItem({"hopper"}, {1}, false)
 		if T:getItemSlot("hopper") > 0 then
 			T:checkInventoryForItem({"chest"}, {2})
 		end
 		print(thanks)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		retValue = createMobBubbleLift(R)
 	elseif R.choice == 65 then -- computercraft mob grinder
 		utils.checkFuelNeeded(1000) -- allow for 1000 moves
 		T:checkInventoryForItem({"stone"}, {256}) -- for ceiling, walls and floor of area
 		R.useBlockType = T:getMostItem("", true) -- stone only, no exclusions
 		print(thanks)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		retValue = createMobGrinder(R)
 	elseif R.choice == 66 then -- build endermen tower
 		-- build in 3 sections, base, tower, top
 		getTaskHelp(2, 66) -- compulsory help display
 		read() -- pause until user ready
 		local numFuel = 700
 		local choices =
 		{
 			"New tower lower base",
 			"Add tower upper base + killzone",
 			"128 block tower to existing base"
 		}
 		pp.itemColours = {colors.lime, colors.orange, colors.green}
 		local option, modifier = menu.menu("Select build stage:", choices, pp)
 		if option == 1 then --lower base
 			T:checkInventoryForItem({"minecraft:chest"}, {1})
 			T:place("chest", -1, "down", false)
 			T:emptyInventory("up")
 			utils.checkFuelNeeded(320) -- allow for 320 moves
 			T:checkInventoryForItem({"stone"}, {144}) -- <3 stacks
 			T:checkInventoryForItem({"minecraft:water_bucket"}, {2})
 			T:checkInventoryForItem({"fence"}, {4})
 			T:checkInventoryForItem({"sign"}, {4})
 			T:checkInventoryForItem({"door"}, {2})
 			T:checkInventoryForItem({"minecraft:soul_sand"}, {1})
 		elseif option == 2 then -- upper base
 			utils.checkFuelNeeded(710) -- allow for 703 moves
 			T:checkInventoryForItem({"stone"}, {384}) -- 6 stacks
 			T:checkInventoryForItem({"minecraft:bucket"}, {4})
 			T:checkInventoryForItem({"fence"}, {15})
 			T:checkInventoryForItem({"sign"}, {4})
 			T:checkInventoryForItem({"ladder"}, {3})
 			T:checkInventoryForItem({"minecraft:soul_sand"}, {1})
 		else -- main tower
 			utils.checkFuelNeeded(3000) -- allow for 3000 moves
 			if T:getBlockType("down") ~= "minecraft:chest" then
 				T:checkInventoryForItem({"minecraft:chest"}, {1})
 				T:place("chest", -1, "down", false)
 			end
 			T:checkInventoryForItem({"stone"}, {768}) -- 12 stacks
 			T:checkInventoryForItem({"minecraft:bucket"}, {10})
 			T:checkInventoryForItem({"fence"}, {64})	-- 1 stacks
 		end
 		print(thanks)
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		retValue = createEnderTower(option) -- 1, 2, or 3
 	end
 	return retValue
 end
 
 local function getTaskInventory(R)
 	-- run this loop 2x per second to check if player has put anything in the inventory
 	-- fuel 1 coal = 60 = 4 planks. 64 planks = 16 coal = 960 units
 	local retValue = {}
 	local thanks = "Thank you.\n\nPress the ESC key\n\nStand Back..\n"
 
 	if R.choice < 31 then
-[[~yellow~New, extend left/back=~red~^ ~orange~Extend Right=^
+
-~lightGray~|*|~blue~ | | | | | | ~brown~|D| |D| ~blue~| | ~lightGray~|*|
+
-~lightGray~|*|~blue~ | | ~brown~|D|D|~blue~ | | | | | | | ~lightGray~|*|
+
-~lightGray~|*|~blue~ | | ~brown~|D|D|~blue~ | ~brown~|D| |D| ~blue~| | ~lightGray~|*|
+
-~lightGray~|*|~blue~ | | | | | | | | | | | | ~lightGray~|*|
+
-~lightGray~|*|~blue~ | | | | | | | | | | | | ~lightGray~|*|
+
-~lightGray~|*|~blue~ | | | | | | | | | | | | ~lightGray~|*|
+
-~lightGray~|~red~^~lightGray~|*|*|*|*|*|*~magenta~|M|~lightGray~*|*|*|*|*|*|~orange~^|
+
-~lime~4 ~brown~double trees~green~ or 16 ~brown~single trees
+
-~brown~D = Dirt, ~magenta~M = Modem
+
-~red~^~yellow~ = Turtle ~red~(new/left/back) ~orange~^ on right
+
 			end
 			print(thanks)
-[[~yellow~Place me on ground as below ~lightGray~^ ~magenta~^
+
-~lime~|*|~blue~ | | | | | | | ~green~or |*|~blue~ | | ~brown~|D| |D| |
+
-~lime~|*|~blue~ | | ~brown~|D|D|~blue~ | | ~green~or |*|~blue~ | | | | | | |
+
-~lime~|*|~blue~ | | ~brown~|D|D|~blue~ | | ~green~or |*|~blue~ | | ~brown~|D| |D| |
+
-~lime~|*|~blue~ | | | | | | | ~green~or |*|~blue~ | | | | | | |
+
-~lime~|*|~blue~ | | | | | | | ~green~or |*|~blue~ | | | | | | |
+
-~lime~|*|*|*|*|~lightGray~^~lime~|*| ~magenta~|^| ~green~or |*|*|*|*|~lightGray~^~green~|*|*~magenta~|^|
+
-~lime~ 4 ~brown~double trees~green~   or  16 ~brown~single trees
+
-~brown~D = dirt
+
-~lightGray~^ = Turtle on marker (Legacy storage)
+
-~magenta~^ = Turtle on Modem (Network storage)
+
 			retValue = clearWall(R)
 		elseif R.choice == 74 then --Clear single R.height perimeter wall
 			utils.checkFuelNeeded((R.width + R.length) * 2)
 			print("Recycling wall section "..R.width.." x "..R.length)
 			retValue = clearPerimeter(R)
 		elseif R.choice == 75 then --Clear hollow structure
 			utils.checkFuelNeeded((R.width * R.length) + ((R.width + R.length) * R.height))
 			print("Recycling hollow object "..R.width.." x "..R.length.." height: "..R.height)
 			retValue = clearBuilding(R)
 		elseif R.choice == 76 then --Clear solid structure / extend water pool
 			utils.checkFuelNeeded((R.width * R.length) + ((R.width + R.length) * R.height))
 			print("Recycling solid object w:"..R.width..", l:"..R.length..", h:"..R.height)
 			retValue = clearSolid(R)
 		elseif R.choice == 77 then	-- Dig trench
 			utils.checkFuelNeeded(R.height * R.length * 2)
 			print(thanks)
 			os.sleep(2)    -- pause for 2 secs to allow time to press esc
 			if R.length == 0 then
 				print("Digging continuous trench "..R.height.." blocks deep")
 			else
 				print("Digging trench "..R.length.." blocks long, "..R.height.." blocks deep")
 			end
 			retValue = digTrench(R)
 		elseif R.choice == 78 then --Carve mountain
 			utils.checkFuelNeeded(R.length * R.width * 10)
 			print("Carving mountain side "..R.width.." x "..R.length)
 			retValue = clearMountainSide(R)
 		elseif R.choice == 79 then -- Place floor or Ceiling
 			local blocks = R.width * R.length
 			utils.checkFuelNeeded(blocks)
 			T:checkInventoryForItem({"stone", "log", "planks"}, {blocks, blocks, blocks}, false)
 			R.useBlockType = T:getMostItem()
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| | ~lightGray~* = Wall
+
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| |
+
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| |
+
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| |
+
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| | ~magenta~M = Modem
+
-~brown~|B|B~green~| | |~lightGray~or |*| ~green~| | ~brown~B = Barrel or Chest
+
-~brown~|B|~blue~W~green~| | |~lightGray~or ~magenta~|M|~blue~W~green~| | ~blue~W = Water
+
-~lime~|~red~^~lime~|~brown~B|B|~lightGray~*|or ~brown~|~red~^~brown~|~magenta~M|~lightGray~*| ~red~^ = Turtle
+
-~brown~Legacy   ~lightGray~or ~magenta~Network ~yellow~Size = 12 x 12
+
 				T:checkInventoryForItem({"sand", "gravel"}, {1024, 1024}, false)
 				if R.length == 0 then
-[[~yellow~Place on any ~brown~T ~blue~T ~magenta~T~yellow~ facing < > ^ v
+
 				else
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| | ~lightGray~* = Wall
+
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| |
+
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| |
+
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| | ~magenta~M = Modem
+
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| | ~brown~B = Barrel or Chest
+
-~brown~|B|B~green~| | |~lightGray~or |*| ~green~| | ~blue~W = Water
+
-~brown~|B~blue~|T| ~green~| |~lightGray~or ~magenta~|M|~blue~T~green~| | ~orange~S = Sapling or Tree
+
-~orange~|S|~brown~T|B|~lightGray~*|or ~brown~|B~magenta~|T|~lightGray~*| ~brown~T ~lightGray~= Turtle (~blue~T ~magenta~T~lightGray~)
+
-~brown~Legacy   ~lightGray~or ~magenta~Network ~yellow~Size = 12 x 12
+
 				utils.checkFuelNeeded(200)
 				if R.length == 0 then
-[[~yellow~Place as below ~blue~T~yellow~ facing < > ^ v
+
 				else
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| | ~lightGray~* = Wall
+
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| |
+
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| |
+
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| | ~magenta~M = Modem
+
-~lightGray~|*|~green~ | | |   ~lightGray~|*| ~green~| | ~brown~B = Barrel or Chest
+
-~brown~|B|B~green~| | |~lightGray~or |*| ~green~| | C = Crop (first)
+
-~brown~|B|~blue~T~green~|C| |~lightGray~or ~magenta~|M|~blue~T~green~|C| ~orange~S = Sapling or Tree
+
-~orange~|S|~brown~B|B|~lightGray~*|or ~magenta~|M|~brown~B|~lightGray~*| ~blue~T = Turtle on Water
+
 
 		elseif R.choice == 82 then --build containing wall in water or lava
 			utils.checkFuelNeeded(R.length * R.length)
 			local depth = R.height
 			if depth == 0 then
 				depth = 20
 			end
 			T:checkInventoryForItem({"stone"}, {R.length * depth}, false)
 			print("Building retaining wall in lava/water. length "..R.length)
 			retValue = createRetainingWall(R)
 		elseif R.choice == 83 then -- create a rectangle path in water/lava
 			utils.checkFuelNeeded(200)
 			createRectanglePath(R)
 		elseif  R.choice == 84 then -- Delete water/lava
 			if R.width == 0 then
 				utils.checkFuelNeeded(2000)
 				T:checkInventoryForItem({"stone"}, {256}, false)
 				print("Deleting water using auto-detection")
 			else
 				if R.height == 0 then
 					utils.checkFuelNeeded(2000)
 					T:checkInventoryForItem({"stone"}, {256}, false)
 				else
 					utils.checkFuelNeeded(R.width * R.length * R.height)
 					T:checkInventoryForItem({"stone"}, {math.max(R.length, R.width) * 2}, false)
 				end
 				print("Deleting enclosed water "..R.width.." x "..R.length.." x ".. R.height)
 			end
 			retValue = utils.drainWaterLava(R)
 		elseif  R.choice == 85 then -- Sinking platform
 			local volume = (R.width + 1) * (R.length + 1)
 			utils.checkFuelNeeded(volume * (R.height + 1))
 			T:checkInventoryForItem({"stone"}, {volume + ((R.length * 2) + (R.width * 2) * R.height) + 1})
 			print(thanks)
 			os.sleep(2)    -- pause for 2 secs to allow time to press esc
 			print("Building sinking platform")
 			retValue = createSinkingPlatform(R)
 		elseif R.choice == 86 then -- ocean monument utilities
 			if R.subChoice == 1 then	-- Build 4 corner marker columns
 				--R.useBlockType = "prismarine", R.data = "oceanMonumentColumns"
 				T:checkInventoryForItem({"stone"}, {448})
 				retValue = oceanMonumentColumns(R)
 			elseif R.subChoice == 2 then	-- Retaining wall beween 2 columns
 				T:checkInventoryForItem({"stone"}, {1024})
 				retValue = createRetainingWall(R)
 			elseif R.subChoice == 3 then	-- Clear plants pre sand draining
 				retValue = clearWaterPlants(R)
 			elseif R.subChoice == 4 then	-- Use sand draining
 				utils.checkFuelNeeded(100)
 				T:checkInventoryForItem({"sand", "gravel"}, {1024, 1024}, false)
 				if R.length == 0 then
 					print("Building sand wall. Auto length: ")
 				else
 					print("Building sand wall. length: "..R.length)
 				end
 				retValue = createSandWall(R)
 			elseif R.subChoice == 5 then	-- remove sand wall
 				utils.checkFuelNeeded(200)
 				print("Digging sand from ocean monument")
 				retValue = clearSandWall(R)
 			elseif R.subChoice == 6 then	-- Drain and remove structure
 				T:checkInventoryForItem({"stone"}, {1024})
 				retValue = utils.drainWaterLava(R)
 			end
 		elseif R.choice == 87 then --ladder to water/lava
 			utils.checkFuelNeeded(R.height * 2)
 			T:checkInventoryForItem({"minecraft:ladder"}, {R.height}, true, "Add more to be safe!")
 			local cobble = R.height * 3 + 10
 			T:checkInventoryForItem({"stone"}, {cobble})
 			print(thanks)
 			os.sleep(2)    -- pause for 2 secs to allow time to press esc
 			print("Creating ladder to bedrock")
 			retValue = createLadderToWater()
 		elseif R.choice == 88 then --remove plants
 			utils.checkFuelNeeded(R.length * R.width * 4)
 			T:checkInventoryForItem({"sand", "stone"}, {64, 64})
 			local width = R.width
 			local length = R.length
 			if width == 0 then
 				width = "auto"
 			end
 			if length == 0 then
 				length = "auto"
 			end
 			print("Removing water plants. length: "..length.." width: "..width)
 			retValue = clearWaterPlants(R)
 		elseif R.choice == 89 then -- convert flowing water to source
 			--utils.checkFuelNeeded(R.length * R.width * 4) -- unknown as size not calculated
 			T:checkInventoryForItem({"water_bucket", "bucket"}, {12, 12})
 			T:checkInventoryForItem({"slab"}, {128})
 			print("Converting water to source "..R.width.." x "..R.length.." x ".. R.height)
 			retValue = convertWater(R)
 		elseif R.choice == 810 then -- create sloping water
 			utils.checkFuelNeeded(R.length * R.width * 3)
 			local buckets = math.floor(R.length / 2) + 1
 			T:checkInventoryForItem({"water_bucket", "bucket"}, {buckets, buckets})
 			T:checkInventoryForItem({"slab"}, {R.length * R.width})
 			print("Creating sloping water field "..R.width.." x "..R.length.." x ".. R.height)
 			retValue = createSlopingWater(R)
 		-- BUILDING & RAILWAY
 		elseif R.choice == 91 then -- Build a wall
 			local blocks = R.height * R.length
 			utils.checkFuelNeeded(blocks)
 			T:checkInventoryForItem({"stone", "planks", "bricks"}, {blocks, blocks, blocks})
 			R.useBlockType = T:getMostItem()
 			print("Building a wall using "..R.useBlockType)
 			sleep(2)
 			retValue = buildWall(R)
 		elseif R.choice == 92 then -- Build a rectangular structure
 			local blocks = (R.height * R.length * 2) + (R.height * R.width * 2)
 			utils.checkFuelNeeded(blocks)
 			T:checkInventoryForItem({"stone", "planks", "bricks"}, {blocks, blocks, blocks})
 			R.useBlockType = T:getMostItem()
 			print("Building a house using "..R.useBlockType)
 			sleep(2)
 			retValue = buildStructure(R)
 		elseif R.choice == 93 or R.choice == 94 then -- Build a gable end roof / pitched roof
 			local blocks = ((R.width + 2) * (R.length + 2))
 			utils.checkFuelNeeded(blocks)
 			if menu.getBoolean("Using stairs / planks for roof (y/n)", nil, colors.yellow) then
 				T:checkInventoryForItem({"planks", "stairs"}, {blocks, blocks})
 			else
 				T:checkInventoryForItem({"stone"}, {blocks})
 			end
 
 			R.useBlockType = T:getMostItem()
 			if R.choice == 93 then 				-- Build a gableroof
 				if R.width % 2 == 1 then
 					T:checkInventoryForItem({"slab"}, {R.length + 2}, false, "Match slabs with roof blocks")
 				end
 				blocks = (R.width * 6)
 				T:checkInventoryForItem({"stone", "planks", "bricks"}, {blocks, blocks, blocks}, true, "Match gable with existing building")
 			else
 				local isWidthOdd, isLengthOdd, width, length = false, false, 0, 0
 				R, isWidthOdd, isLengthOdd, width, length = utils.getRoofStats(R)
 				if isWidthOdd then
 					T:checkInventoryForItem({"slab"}, {length - 2}, false, "Match slabs with roof blocks")
 				end
 			end
 			print("Building a roof using "..R.useBlockType)
 			sleep(2)
 			if R.choice == 93 then 				-- Build a gableroof
 				retValue = buildGableRoof(R)
 			else								-- Build a pitched roof
 				retValue = buildPitchedRoof(R)
 			end
 		elseif R.choice == 95 or R.choice == 96 then --place redstone torch level or downward slope
 			utils.checkFuelNeeded(10)
 			if R.choice == 95 then
 				R.data = "level"
 			else
 				R.data = "up"
 			end
 			T:checkInventoryForItem({"stone"}, {1})
 			R.useBlockType = T:getMostItem("", true)
 			T:checkInventoryForItem({"minecraft:redstone_torch"}, {1})
 			print("Placing redstone torch on ".. R.useBlockType)
 			retValue = placeRedstoneTorch(R)
 		elseif R.choice == 97 or R.choice == 98 then --build downward/upward slope
 			local blocks = R.height * 2
 			if R.height == 0 then
 				blocks = 64
 			end
 			utils.checkFuelNeeded(blocks)
 			T:checkInventoryForItem({"stone"}, {blocks})
 			print("Building slope")
 			sleep(2)
 			retValue = createRailway(R)
 		elseif R.choice == 101 or R.choice == 102 or R.choice == 103 or R.choice == 104 then -- measure height/depth/length
 			retValue = measure(R)
 		elseif R.choice == 105 then--Borehole
 			retValue = createBorehole(R)
 		end
 	end
 	return retValue
 end
 
 local function test(R)
 	local lib = {}
 
 	function lib.dig(direction, bypass, slot)
 		direction = direction or "forward"
 		slot = slot or 1
 		bypass = bypass or true
 
 		print("direction: "..direction)
 		print("bypass: "..tostring(bypass))
 		print("slot: "..slot)
 
 	end
 	lib.dig("down")
 	read()
 end
 
 local function main()
 	local lib = {}
 
 	function lib.checkLabel()
 		if os.getComputerLabel() == nil then
 			os.setComputerLabel("toolkit")
 			print("Computer label set to "..os.getComputerLabel())
 		end
 	end
 
 	function lib.checkLibs(libDir, filename)
 		local fileExists = false
 		if fs.exists(libDir) then
 			if not fs.isDir(libDir) then
 				fs.move(libDir, libDir.."Renamed")
 				fs.makeDir(libDir)
 			end
 		else
 			fs.makeDir(libDir)
 		end
 		if fs.exists(fs.combine(libDir, filename)) or fs.exists(fs.combine(libDir, filename..".lua")) then
 			fileExists = true
 		end
 		return fileExists
 	end
 
 	local doContinue = true
 	lib.checkLabel() -- make sure turtle label is set
 	--check if lib folder exists
 	if not lib.checkLibs("lib", "clsTurtle") then
 		-- use pastebin get to download clsTurtle to libs folder
 		print("Missing clsTurtle.lua in libs directory")
 		print("Attempting to obtain from Pastebin...")
 		if shell.run("pastebin","get","tvfj90gK","lib/clsTurtle.lua") then
 			print("clsTurtle.lua installed from Pastebin")
 		else
 			print("failed to install clsTurtle.lua from Pastebin")
 			doContinue = false
 		end
 	end
 	if not lib.checkLibs("lib", "menu") then
 		-- use pastebin get to download menu.lua to libs folder
 		print("Missing menu.lua in libs directory")
 		print("Attempting to obtain from Pastebin...")
 		if shell.run("pastebin","get","BhjbYsw4","lib/menu.lua") then
 			print("menu.lua installed from Pastebin")
 		else
 			print("failed to install menu.lua from Pastebin")
 			doContinue = false
 		end
 	end
 	if doContinue then
 		local result = {}
 		local R =
 		{
 			choice = 0,
 			subChoice = 0,
 			size = 0,
 			width = 0,
 			length = 0,
 			height = 0,
 			depth = 0,
 			up = false,
 			down = false,
 			silent = false,
 			data = "",
 			torchInterval = 0,
 			useBlockType = "",
 			auto = false,
 			side = ""
 		}
 		menu = require("lib.menu")
 		T = require("lib.clsTurtle").new(false) -- true enables logfile to log.txt note dot NOT colon
 		T:clear()
 		doContinue = false	-- reset
 		if args[1] ~= nil then
 			if args[1]:sub(1,1) == "h" then
 local help =
 [[... = any following characters
 
 tk v...     = mc/ccTweaked versions
 tk log      = enable logging
 tk log d... = enable logging + debug
 tk find     = writes locate.txt
 tk test     = runs test(R)
 tk farm     = runs manageFarm(R)
 
 
 
 Enter to exit]]
 				menu.colourPrint(help, colours.yellow)
 				read()
 			elseif args[1] == "log" then
 				if args[2] ~= nil then
 					if args[2]:sub(1,1) == "d" then
 						dbug = true	-- set dbug flag
 						menu.colourPrint("Logging and debugging enabled", colors.lime)
 					end
 				else
 					menu.colourPrint("Logging enabled", colors.lime)
 				end
 				if T:getLogExists() then
 					if menu.getBoolean("Delete existing log file? (y/n)", 3, colors.orange) then
 						T:deleteLog()
 						menu.colourPrint("Log file deleted", colors.yellow)
 					end
 				end
 				T:setUseLog(true)
 				doContinue = true
 				if dbug then
 					menu.colourPrint("Enter to continue...", colors.lightBlue)
 					read()
 				end
 			elseif args[1] == "farm" then
 				R.silent = true
 				R.data = "farm"
 				R.auto = true
 				manageFarm(R)
 			--elseif args[1] == "tree" then
 				--manageTreeFarm() -- use file to read status
 			elseif args[1] == "find" then
 				-- missing turtle: player used 'tk find'
 				T:setUseLog(true)
 				T:setLogFileName("locate.txt")
 				T:appendLine("Booting succeeded")
 				T:appendLine("Block ahead: "..T:getBlockType("forward"))
 				T:appendLine("Block above: "..T:getBlockType("up"))
 				T:appendLine("Block below: "..T:getBlockType("down"))
 			elseif args[1] == "test" then
 				test(R)
 			elseif args[1]:find("v") ~= nil then
 				print("_HOST:")
 				print()
 				print(_HOST)
 				print()
 				print("Minecraft major version: "..mcMajorVersion)
 				print("Minecraft minor version: "..mcMinorVersion)
 				print("ccTweaked major version: "..ccMajorVersion)
 				print("ccTweaked minor version: "..ccMinorVersion)
 				print("tk version:              "..tkVersion)
 				print("clsTurtle version:       "..version)
 				print("\nEnter to exit")
 				read()
 			end
 		else
 			doContinue = true
 		end
 		if doContinue then
 			print("Minecraft major version: "..mcMajorVersion)
 			print("Bedrock level: "..bedrock)
 			if T:getUseLog() then
 				if T:saveToLog("Started with logging enabled", true) then
 					menu.colourPrint("\nEnter to continue...", colors.lightBlue)
 					read()
 				end
 			else
 				print("Logging disabled")
 			end
 			sleep(1)
 			while R.choice == 0 do
 				R = chooseTask(R)
 			end
 			if R.choice > 0 then
 				R = getTask(R)
 				if R.data ~= "quit" then
 					result = getTaskInventory(R) -- table of comments
 				end
 			end
 		end
 		T:clear()
 		table.insert(result, "Thank you for using 'survival toolkit'")
 		local clr = {colors.yellow, colors.orange, colors.green, colors.lightBlue}
 		local count = 1
 		for _, value in ipairs(result) do
 			--print(value)
 			--.print(text, fg, bg, width)
-	info.sub[67] =
+
-[[Turtle moves toward spawner
+
-Place at spawner level.
+
 				count = 1
-Can be behind a wall for protection
+
-of player.
+
 	else
-Embeds in wall with attack working
+
 	end
-Needs 24 blocks
+
 
-]] -- Build 3*3*3 wall around trial spawner
+