View difference between Paste ID: C1nGR1dA and UFvjc1bw

-version = 20250410.0800
+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
-		T:go("L1C1B1")
+
-		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
-			if T:getBlockType("forward"):find("sign") ~= nil then
+
-				T:up(1)
+
 					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:dig("down")
 			end
-				T:place("stone", "up")
+
 	end
 
 	function lib.initialise(R)
 		if R.subChoice == 1 or R.subChoice == 4 then
-	function lib.fillBuckets(withSort)
+
-		local emptyBuckets = T:getItemCount("minecraft:bucket")
+
 				T:go(oTurn.."1F1D1"..R.side.."2")			-- move right/left forward, down onto ice canal top, face canal wall
-			if T:getWater("down") then
+
-				sleep(0.5)
+
 			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
-		return T:getItemCount("minecraft:water_bucket")
+
 			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
-		T:place(dirt, "forward", false) 					-- placed at end of potential water source, next to ladder
+
 		local numBlocks, errorMsg = 0, ""
-		T:place(dirt, "down", false) 						-- placed in ground, next to ladder
+
 		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")
-	--lib.fillBuckets(R.height, true)							-- fill as many buckets as required or until inventory full, sort inventory as well
+
-	lib.fillBuckets(true)							-- fill as many buckets as required or until inventory full, sort inventory as well
+
 		end
 		-- if user requested shelter create chamber at this level
 		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
 
-		T:go("L1C1 R1C1 R1C1 L1", false, 0, true)		-- prepare layer 1
+
 	-- go down to water/lava with alternaate solid/open layers
-		T:go("U1F1 R1F1 L1C1 R1C1 R1C1 L1", false, 0, true)	-- prepare layer 2
+
 	-- 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("soul_sand", "down", false)
+	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 {}
 end
 
 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
-			T:place("stone", "forward", false)
+
 	end
 
-			T:place("stone", "forward", false)
+
 		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)
 				end
 				if j < 11 then
 					T:forward(1)
 					T:go("R2C1L2", false, 0, 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
-						T:place("minecraft:torch", "down")
+
 					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
 							place = true
 							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
 
-		T:place("minecraft:ladder", "down")
+
 		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
-	T:place("minecraft:obsidian", "down")
+
 				T:turnRight(1)
 			else
 				T:turnLeft(1)
 			end
 		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)
 			else
 				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
-		T:place("fence", "down", false)
+
 						end
-		T:place(preferredBlock, "down", false)
+
 					found, position = lib.isSpawner() -- true/false, top/bottom/nil
-		T:place(preferredBlock, "down", false)
+
 						T:go("R2F"..moves + 2 .."R2")
-		T:place(preferredBlock, "down", false)
+
 				end
 			end
 		end
-		T:place(preferredBlock, "down", false)
+
 		return found, position
-		T:place(preferredBlock, "down", false)
+
 
 
 	if not continue then -- new mob cube either dungeon or blaze
-		T:place("sign", "forward", false, message)
+
 		-- determine spawner position level 4, move to top of spawner (level 6)
 		print("Checking if already at spawner")
 		local found, position = lib.isSpawner() -- already on spawner?
 		if blaze then
 			if not found then -- away from spawner
 				if R.subChoice == 3 then
 					T:go("U5")
 				end
 				found, position = lib.findSpawner(blaze)
 			end
 		else -- go to bottom of dungeon and empty chests
 			if not found then --outside dungeon
 				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")
-					T:place(preferredBlock, "down", false)
+
 			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
 
 			if blaze then
 				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
-			if not T:place("fence", "down", false) then-- first side
+
-				T:place(preferredBlock, "down", false)
+
 				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
 				-- ends with turtle facing spawner, in front of exit hole
 			end
 		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:
-		T:place("minecraft:soul_sand", "down", false) -- over block 1 of water source
+
 ~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)
 		read()
 		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
-				T:place("door", "forward", false)
+
 			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:place(preferredBlock, "down", false)
+
 		T:checkInventoryForItem({"sign"}, {1})
 		T:checkInventoryForItem({"hopper"}, {1})
 		T:checkInventoryForItem({"chest", "barrel"}, {1, 1})
 		print("Stand clear. Starting in 2 secs")
 		os.sleep(2)    -- pause for 2 secs to allow time to press esc
 		-- place upper floor and slabs under it
-				T:place("door", "forward", false)
+
 		lib.placeFloor(9, 9, brick) 			-- place brick floor on level 10
 		T:down(2)
 		T:place(brick, 0, "up")
 		T:go("D1R2")
 		lib.ceiling(true)						-- true uses slabs
 
 		-- 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:go("F8 R1")
 		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
-		T:place("fence", "down", false)							-- fence centre of bottom side layer 22
+
 end
 
-		T:place("ladder", "forward", false)
+
 	--[[Part 2 / 3 Mob Spawner Farm turtle on floor, pointing towards water source wall, single hole]]
-		T:place("ladder", "forward", false)
+
 
 	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
 		if addWater then
 			T:placeWater("down") 			 			-- place water down
-		T:place("minecraft:soul_sand", "down", false)
+
 		T:turnLeft(2)									-- turn round
 		while turtle.forward() do
 			width = width + 1
 		end			-- go forward 7
-		T:place("ladder", "down", false)
+
 			T:placeWater("down") 						-- place water
-		T:place("sign", "forward", false, "UP\n^\n|\n|")
+
 		T:go("L2F".. math.floor(width / 2) .."L1")		-- turn round, go forward 3 (centre of wall), turn left
 	end
-		T:place("sign", "forward", false, "UP\n^\n|\n|")
+
 	function lib.digFloor()
 		T:go("x2F1 x2")									-- first block, move forward
-		T:place("sign", "forward", false, "UP\n^\n|\n|")
+
 		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("sign", "forward", false, "UP\n^\n|\n|")
+
 		utils.goBack(1)
 		T:go("x2 F1x2 F1x2 F1x2 F1x2 L1F1")				-- go left to right dig 5 blocks, forward on right side
 
 		T:turnLeft(1)									-- left turn, go back into right side, facing left
 		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: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
 
 	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:place("fence", "up", false)
+
 		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:go("D1F1 L1F8")
 		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")
-local function createFarmNetworkStorage(R, withStorage, removeLegacy)
+			if not T:place("minecraft:soul_sand", -1, "down", false) then
-	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
+
 		blockType = T:getBlockType("forward")
 		local turns = 0
-	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
+
 		return {""}
 	end
-	function lib.placeNetwork(count, pattern)
+
 	function lib.createWaterSource(oTurn)
-			T:place("computercraft:cable", "up", true)
+
-			if i < count then
+
-				T:go(pattern)
+
 			T:go("C2 L1C1 R2C1 L1")
 			if i < 3 then
 				T:go("F1x0")
 			end
-	-- called when starting at lower left side of plot, facing crops
+
-	if removeLegacy then
+
 		T:placeWater("forward")
-		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:go("F1L1 F1U1 R2")	-- remove barrel/wall or double chest. face tree
+
-		T:place("stone", "down")
+
 		sleep(0.1)
-		T:place("modem", "down")
+
-		-- could be tree/sapling in front
+
 
-		if T:getBlockType("down") == "minecraft:dirt" then
+
-			T:place("barrel", "down")
+
-			T:go("U1x0")
+
-			T:place("dirt", "up")
+
-			T:go("B1U2")
+
-			if T:getBlockType("forward"):find("log") ~= nil then
+			T:place("chest", 0, "down")
-				T:place("sapling", "forward")
+
 			T:dig("down")
-			T:go("D3F1 R1F1")
+			T:place("chest", 0, "down")
 			T:go(turn.."1")
-			T:place("barrel", "down")
+
 			T:go("D1x1")
 			T:place("hopper", 0, "forward")
-		while turtle.suckDown() do end
+
-		T:place("modem", "down")
+
-		network.attachModem()
+
-		T:go("F1x2 R2C2 F1L1 F1D1")
+
 	function lib.up()
-	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")
+
 	end
-			lib.placeNetwork(11, "F1x0x2")
+
 	function lib.createChamber()
-		if c < 4 then
+
-			T:go("L1F1 x0x2 L1C1R1")
+
 		D.length = 7
 		D.height = 4
-	-- 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)
+
 
-	T:go("C1L1 C1L1 C1L1 C1L1 D1L1")-- ready for clearing rectangle up/down
+
-	T:place("computercraft:cable", "up", true)
+
 
-	T:place("computercraft:cable", "up", true)
+
-	lib.createBasement(R, true, true, 11, 11)
+
 			T:go("F1C0C2 R1C1 R1C1 R1C1 R1C1")
-	lib.placeNetwork(11, "F1")
+
-	T:go("R2F4 R1")
+
-	lib.placeNetwork(11, "F1")
+
-	T:go("L1F5 L1F9 R1D1 C1")	-- ready to make ladder column
+
 		end
-		if i < 5 then
+
-			T:go("U1C1")
+
 	local turn = "R"
 	local oTurn = "L"
 	if R.subChoice == 1 then
-		T:place("ladder", "down")
+
 		oTurn = "R"
-	if withStorage then
+
-		T:go("R1F4 R1F3 D1x2")
+
-		T:place("computercraft:cable", "down", true) --ready to build chest storage area
+
 	if data[1] ~= "" then
-		utils.createStorage()
+
-		T:go("U1R1 F5R1 F5U1 C2U1 R2")	-- end on plot starting position, facing crops
+
 	lib.createWaterSource(oTurn)			-- everything in place, build a water source, facing spawner
-		T:go("U1F2 L1F1 U1C2 U1L1")	-- end on plot starting position, facing crops
+
 		T:go(turn.."1C1"..turn.."1C1"..turn.."1x1"..turn.."1U1", false, 0, true)
 	end
-	return "Farm converted to network storage"
+
 	local colHeight = 19
 	for i = 1, colHeight do		-- tunnel up, filling 3 sides
 		T:go(turn.."1C1"..turn.."1C1"..turn.."1x1"..turn.."1C1 U1", false, 0, true)
 	end
-	-- extend "right" or "forward". only adds a single new farm.
+
 	T:go("C0"..turn.."2C1"..turn.."1F1 C0C1"..turn.."1C1"..turn.."2C1"..oTurn.."1", false, 0, true) -- fill top of column
 
 	lib.mobTransporter()
 	T:go("x2x0 F1x2x0 F1x2x0 R2") -- over water source
 	-- now create bubble column
 	T:down(colHeight + 2)
 	local moves = 0
 	repeat
 		lib.goToWater(moves)	-- get water
 		moves = lib.up()
 		T:go("F1")
 		T:placeWater("forward")
 		T:go("U1C2")
 		T:placeWater("forward")
-				T:place("dirt", "forward", false)
+
 		T:go("C1")
-				--if not T:place("minecraft:crafting_table", "forward", false) then
+
-				if T:place(storage, "forward", false) then
+
 	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:place("dirt", "forward", false) -- dirt if no storage available
+
 	utils.goBack(7)			-- over down shaft
 	T:down(1)				-- start shaft, facing bubble column
-				T:place(R.useBlockType, "forward", false)
+
 		-- tunnel down, filling all 4 sides
 		T:go("R1C1 R1C1 R1C1 R1C1 D1", false, 0, true)
 	end
 	lib.createChamber()
-		T:placeWater("down")	-- ends facing same direction as started, over water source
+
 	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")
 		if i == 6 then
 			T:go(oTurn.."1")
 		end
-				T:place("dirt", "down", false)
+
 		T:go("C1")
 	end
 
 	T:go("D2F2"..turn.."1F5")
 	T:placeWater("forward")
 	T:go(turn.."1F1"..oTurn.."1") -- facing down mob channel floor
 	for i = 1, 5 do
-				T:place("dirt", "down", false)
+
 		utils.goBack(1)
 	end
 	T:go("C1"..turn.."1F1"..turn.."1F1")
 	for i = 1, 7 do
 		T:go("C2x0")
 		if i < 7 then
-		if not T:place(storage, "down", false) then-- place barrel/chest below
+
-			T:place(storageBackup, "down", false) -- place chest below
+
 	end
 	T:go("U3R2")
 	for i = 1, 7 do
 		T:go("F1x2")
-	-- current position if extend == nil is on ground/farm level facing N
+
-	-- if extend = "right", "front" above water source facing crops
+
-	local numPlots = 0
+
 	lib.placeCollector(turn, oTurn) -- if hopper / chests present
 
 	return {}
 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
+
 			T:go("x2C2", false, 0, false, R.useBlockType)
 			if R.up then
 				T:dig("up")
 			end
-			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
+
 			end
 		end
-	-- 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)
+
 end
-		T:place(R.useBlockType, "down", false)
+
 local function createPortal(R) -- 42
-	-- stage 2 place sapling
+
 	R.length = length of portal NOT width default 4
-	T:place("dirt", "down")
+
-	T:up(1)
+
-	T:place("sapling", "down") -- plant sapling
+
-	T:go("F1D4")
+
-	if R.networkFarm then
+
-		T:place("modem", "down", false)
+
-		network.attachModem()
+
 	function lib.buildBase()
-		T:place(R.useBlockType, "down", false)
+
 		T:go("C2", false, 0, false, R.useBlockType)
-		-- stage 2 place double barrel/chest
+
 		for i = 1, R.length - 2 do -- R.length = 4: place when i=1,2
 			T:place("minecraft:obsidian", 0, "down", false)
-		T:go("R1F1L1")
+
 		end
 		T:go("C2", false, 0, false, R.useBlockType)
 	end
 
 	function lib.buildLayer()
 		T:place("minecraft:obsidian", 0, "down", false)
 		for i = 1, R.length - 1 do -- R.length = 4: forward when i=1,2,3
-			T:go("F1 x0x2C 2", false, 0, false, R.useBlockType)
+
 		end
 		T:place("minecraft:obsidian", 0, "down", false)
 	end
 
-	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)
+
 	for width = 1, R.width do
-		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)
+
 			lib.buildLayer()
-		T:go("R1F1L1")
+
-		if T:getBlockType("down"):find(storage) == nil and T:getBlockType("down"):find(storageBackup) == nil then
+
-			lib.placeStorage(storage, storageBackup)
+
 		lib.buildBase()
-		T:go("F1D1")
+
 			T:go("R2F"..R.length - 1)
 		end
 		if width < R.width then
 			T:go("R1F1D"..R.height.."R1")
-		T:go("F1U1x0C2"..turn.."1F1"..turn.."1x0 x2C2 F1D1", false, 0, false, R.useBlockType)
+
 		else
 			T:go("L1F"..R.width.."D"..R.height - 1 .."R2")
 			if R.data ~= "bury" then
 				T:down(1)
 			end
 		end
 	end
 
-	lib.addWaterSource(R, {"d","c","c","d"}, storage)	-- bottom right
+
 end
-	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
+
 	local lib ={}
 
-	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
 		if found then
 			-- are we under the centre block, or one of the sides?
 			if turtle.detect() then -- under a side
-		utils.goBack(numPlots * 11)
+
 			else	-- nothing in front, probably under centre, or facing wrong direction so check
 				for i = 1, 4 do
-		T:go("R1U1F".. numPlots * 11 .."D1L1")
+
 					if turtle.detect() then
 						onSide = true
 						break
 					end
 				end
 			end
 			if onSide then-- move to centre
 				T:go("D1F1")
-	--T:setUseLog(true, "farmCreateLog.txt", true)
+
-	--dbug = true	-- set dbug flag
+
-	--utils.waitForInput("Logging and debugging enabled")	--utils.waitForInput(message)
+
 		while turtle.down() do
 			height = height + 1
 		end
 		return found, height
 	end
 
-	R = utils.checkFarmPosition(R)
+
 		for i = 1, length do
-	if not R.ready then
+
-		return {"Unable to determine starting position"}
+
 			else
 				T:go("C2", false, 0, true)
-	createFarm(R, extend)
+
 		end
 	end
 
 	function lib.buildLadder(height)
 		for i = 1, height do
 			--T:go("F1C1 R1C1 L2C1 L1F1L2", false, 0, true)
 			T:go("F1C1 R1C1 L2C1 R1", false, 0, true)
 			utils.goBack(1)
 			if i > 3 then
-	R.data == "random" for random floor placement
+
 			end
 			T:place("minecraft:ladder", 0, "forward", true)
 			T:up(1)
 		end
-	function lib.goToRemote(R)
+
 
 	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})
 		T:checkInventoryForItem({"stone"},{height * 4 + 18})
 		T:checkInventoryForItem({"trapdoor"},{1})
 		lib.buildLadder(height) -- ends facing ladder, 1 block above
 
 		T:go("R1")
 		utils.goBack(1)
 		T:go("C2F1 C2F1 C2F1 C2")
 		T:go("R1F1R1")
 		T:go("C2F1 C2F1 C2F1 C2")
 		utils.goBack(2)
-			return "Measured depth/height of "..depth.." > setting: "..R.height
+
 		T:place("trapdoor", -1, "up", false)
 	else
 		return {"Portal not found. Move me under","the centre if possible.", "wait for purple beacon."}
 	end
 	return {}
-	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
+	--[[Build steps up or down ready for railtrack]]
-			-- 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
+
 					T:go("C2", false, 0, true)
 				end
 			end
-	function lib.placeRow(R, direction, waterPresent)
+
 			for i = 1, R.height - 1 do
 				T:go("U1x0 D1x1 F1x0x1 D1x1 C2", false, 0, false)
 			end
 		end
 	elseif R.up then
 		for i = 1, R.height do
 			T:go("C1U2 x0D1F1", false, 0, false) --put stone in front, up 2 excavate 1, down 1, forward 1
-			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
+
 
 local function createRectanglePath(R) -- 710, 83 direct commands
 	-- allow user to control length / width of each path
 	-- T:go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
-		return waterPresent, R
+
 	local lib = {}
 
-	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
+
 	end
 
 	function lib.back(R)
 		for i = 1, R.length do
-			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.right(R)
 		T:turnRight(R.length)
 	end
-		end
+
 	function lib.up(R)
-		return R
+
 			T:go("U2R2 x1R2 D1C2", false, 0, true)
 		else
-	function lib.changeStripe(R)
+
-		if R.data == "striped" then
+
-			R.size = R.size + 1
+
-			if R.size > R.inventory.blockTypeCount then
+
-				R.size = 1
+
 		T:go("D1C2", false, 0, true)
-			R.inventory.useBlock = R.inventory.names[R.size]
+
 
-		return R
+
 		-- mimics direct commands using f.lua, r.lua etc with space between commands and number
 		local width = 0
-	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]
+
 			"Back 1 block",
-				R.inventory.useBlock = R.inventory.names[1]
+
 			"Turn Right",
 			"Turn Left",
-		return R
+
 			"Down 1 block",
 			"Quit"
 		}
 		local choice, modifier
-	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")
+
 				-- getInteger(prompt, minValue, maxValue, row, fg, bg, default)
 				R.length = menu.getInteger("Move forward how many blocks?", 1, 250, nil, colors.lime)
 				lib.forward(R)
 			elseif choice == 3 then
 				R.length = 1
 				lib.back(R)
 			elseif choice == 4 then
-		local message = lib.goToRemote(R)
+
-		if message ~= "" then	-- error encountered
+
-			return {message}
+
 				R.length = 1
 				lib.right(R)
 			elseif choice == 6 then
-	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
+
 		end
-		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
+
 
 direction + ~blue~number ~yellow~eg ~white~f2 ~yellow~= forward ~blue~2
 ~lightGray~direction without number = ~blue~1
-		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)
+
 
-			R = lib.changeStripe(R)
+
-			--R = lib.changeCheckered(R)
+
-			waterPresent, R = lib.placeRow(R, direction, waterPresent)
+
 		local cmd = ""
 		while cmd ~= "q" do
 			local line = menu.clear()
-				R = lib.changeStripe(R)
+
 			-- menu.getString(prompt, withTitle, minValue, maxValue, row, fg, bg, default)
 			input = menu.getString("command ", false, 1, 5, line, colors.yellow, colors.black):lower()
 			-- remove spaces
 			input = input:gsub( " ", "")
-			R = lib.changeStripe(R)
+
-			waterPresent, R = lib.placeRow(R, direction, waterPresent)
+
 			if #input > 1 then
 				R.length = tonumber(input:sub(2))
 			end
 			if cmd == "q" then
 				return{"User has quit application"}
 			end
 			if cmd == "f" then
 				lib.forward(R)
 			elseif cmd == "b" then
 				lib.back(R)
 			elseif cmd == "l" then
 				lib.left(R)
 			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
-					T:place("torch", "forward")				-- place torch, move forward
+
 	end
 
 	function lib.patchMissingBlock()
 		if turtle.back() then
 			T:go("C1")
 		else
-				if not T:place("slab", "down") then			-- break if out of slabs
+
 		end
 	end
 
 	function lib.placeSingle(height)
 		local y = 0
 		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
 				place = utils.clearVegetation("down")
 				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)
-				-- T:place(blockType, direction, leaveExisting, signText)
+
-				if not T:place("stone", "forward", false) then
+
 			local place = utils.clearVegetation("down")
 			-- build back column
 			while place do -- loop will be entered at least once
-				if T:getItemSlot("minecraft:torch") > 0 then
+
-					T:place("torch", "forward", false)
+
 					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
-				if not T:place("slab", "forward", false) then
+
 			turtle.back() -- back at starting point
 			T:go("C1", false, 0, true)
 		end
 		-- return to surface, placing below
 		for i = 1, y do
 			T:go("U1C2", false, 0, true)
 		end
 	end
 
 	function lib.placeTriple(height)
 		--T:go(path, useTorch, torchInterval, leaveExisting, preferredBlock)
 		local y = 0
-				if not T:place("stone", "forward", false) then
+
 			T:go("C1")
 		else
 			T:go("B1C1")
-				if T:getItemSlot("minecraft:torch") > 0 then
+
-					T:place("torch", "forward", false)
+
 			for i = 1, height do
 				T:go("C1D1", false, 0, true)
 			end
 			for i = 1, height do
 				T:go("C1D1", false, 0, true)
 			end
 			T:go("C1R2C1", false, 0, true) --fill last block, then turn 180 to build opposite side
 			y = height
-			T:place("ice", "down", true)
+
 			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:go("F1") -- move under first column
 			lib.checkFloor()
 			T:go("B1C1R2F1", false, 0, true)
 			lib.checkFloor()
-					if not T:place("ice", "down", true) then -- out of ice
+
 			-- 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 R.data == "withPath" then
 		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 not T:place("ladder", "forward", false) then
+
 			 drop = drop + 1
 		else
 			isBedrock = true
 			break
-			T:place("common", direction, false) -- any common block
+
 		if T:isWaterOrLava("up") ~= "" then
-			T:place("minecraft:torch", direction, false)
+
 		end
 	end
 	if not isBedrock then -- not sitting on bedrock, so break foot level exit block
 		T:go("U1R2x1")
 	end
 	T:placeWater("down")
 	if isBedrock then
 		T:go("U1x1 U1x1")
 	else
 		T:go("U1x1")
 	end
 	T:up(drop - 2)
 
 	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
-		T:place("ladder", "up")
+
 			if l < R.length then
 				T:forward(1)
 			end
 		end
-	T:place("ladder", "forward")
+
 			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:go("U2")
 
 	return {}
 end
 
-	T:place("minecraft:chest", "up", false)
+
 	-- 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...
 ]]
 	read()
 	while turtle.down()do
 		depth = depth + 1
-	while T:getItemSlot("minecraft:torch") > 0 do
+
-		turtle.select(T:getItemSlot("minecraft:torch"))
+
 	R.height = 21 - depth
 	R.width = 15
 	R.length = 15
 	R.silent = true
 	R.data = "down"
 	clearSolid(R)
 	T:up(depth + 4)
 	return {}
 end
 
 local function createSandWall(R) -- 81
 	local success = true
 	--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
-					T:place("slab", "up", false)
+
 			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:go("L2C1 R2", false, 0, false) -- | |<| | to | |>|* | to | |<|*|
 				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
-					T:place("slab", "up", false)
+
 			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)
 			end
 			forward = not forward
 		end										-- far side
 		if goingRight then
 			if forward then
 				lib.stage1b(R)
 			else
 				lib.stage1a(R)
-							T:place("slab", "up", false)
+
 		else
 			if forward then
 				lib.stage1a(R)
 			else
 				lib.stage1b(R)
 			end
 		end
 		goingRight = not goingRight
 		T:turnRight(2)
 		forward = not forward
 	end
 	return {}
 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
-		-- T:place(blockType, direction, leaveExisting, signText)
+
 			blockType = T:isWaterOrLava("forward")
 			if blockType:find("lava") ~= nil or blockType:find("water") ~= nil then
-				T:place(blockType, "down", false)
+
 			end
 		end
 		return isFluid
 	end
 
 	function lib.createStaircaseSection(onGround, levels, level)
 		-- start 1,1,1, n
 		-- stage A
 		local isFluid = lib.checkFluids()
 		local blockType = ""
 		local data = T:getStock("stairs")
 		if data.total == 0 then
 			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
-			T:place("chest", "forward", false)
+
 		--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
 
 	--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:place("slab", "down", true) 				-- place slab on top T:place(blockType, direction, leaveExisting)
+
 		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("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
-		T:place(brick, "up")
+	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
-			T:place("lava", "down")
+	lib.placeCorners(R.length - 2, 4, R.useBlockType)
 	outward = lib.turn(outward)
 	lib.placeCorners(R.length - 2, 3, R.useBlockType)
 	outward = lib.turn(outward)
 	lib.placeCorners(R.length - 2, 2, R.useBlockType)
 	outward = lib.turn(outward)
-		T:place("sign", true, "")
+	lib.placeCorners(R.length - 2, 1, R.useBlockType)
 	if outward then
-		T:place(brick, "up")
+		T:go("R1F"..R.width - 9 .."R1")
 	else
 		T:go("L1F"..R.width - 9 .."L1")
 	end
-			T:place(brick, "forward")
+
 	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)
-		if not T:place("chest", "down") then
+	outward = lib.turn(outward)
-			T:place("barrel", "down")
+	lib.placeCorners(R.length - 2, 4, R.useBlockType) -- should be back in starting corner facing front
 
 	T:go("U1R1")
-		T:place("hopper", "down")
+	lib.placeWater(R.length - 3) -- place water down then move forward, turn right
 	lib.placeWater(R.width - 3)
-		T:place("slab", "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")
 
 	return {"Tree farm ready for planting"}
 end
 
 local function createWallOrFence(R)
 	local lib = {}
 
 	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("fence", "down", false)
+					T:place(R.useBlockType, 0, "forward")
 					blocks = blocks + 1 -- facing start
-		T:place("fence", "down", false)
+
 					T:go("F1R2")
 					T:place(R.useBlockType, 0, "forward")
-		T:place("sign", "down", false)
+
 				else -- cant go forward, go up instead
-		T:place("slab", "up", false)
+
 						while turtle.detectUp() do -- will only run if block above
-		T:place("sign", "forward", false)
+
 							blocks = blocks - 1
-		if not T:place("minecraft:soul_sand", "down", false) then
+
-			T:place("minecraft:dirt", "down", false)
+
 						T:place(R.useBlockType, 0, "down", true)
 						blockType = T:getBlockType("forward")
 					end
 					T:turnRight(2) -- facing start
 				end
 			end
 		end
 	end
 
 	T:turnRight(2) --facing start position
 	if R.width == 0 then -- single fence
 		lib.buildWall(R, R.length)
 	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)
-			if not T:place("minecraft:soul_sand", "down", false) then
+
 
 	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 =
 		1 = left side, ground level (on towpath)
 		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:place("chest", "down")
+
 			end
 			T:go(R.side.."1")							-- *|V| | | to *|>| | | turn to face start
-			T:place("chest", "down")
+
 		end
 		T:go("C2", false, 0, false)
 	end
-			T:place("hopper", "forward")
+
 	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
 			oTurn = "L"
 		end
 		lib.newCanalSide(oTurn)								-- *|<| | | wall fixed. to -- *|^| | |
 		lib.newCanalSide(oTurn)								-- *|^| | | wall fixed. to -- *|>| | |
 		lib.newCanalBase(R)									-- *|>| | | base fixed
 		T:go("F1"..R.side.."1") 							-- *|>| | | to *| |>| | to *| |^| |
 		lib.newCanalSide(oTurn)								-- *| |^| | to *| |>| |
 		lib.newCanalBase(R)									-- *| |>| | base fixed
 		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
-		T:place("slab", "down")
+
 					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:go(R.side.."2") 							-- check if water behind
 				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
-			T:place("minecraft:obsidian", "down", false)
+
 					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:place("minecraft:obsidian", "down", false)
+
 				end
 			else
 				T:forward(1) 								-- move forward to extend canal
-		T:place("minecraft:obsidian", "down", false)
+
 				if isSource then							-- ? source ahead
 					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
 							if R.side == "L" then			-- only left side repairs, so wait 1 second
 								sleep(1)
 								T:go("C1")					-- repair neighbouring canal base
 							end
 							T:go(R.side.."1")				-- face forward
 						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:place("minecraft:ladder", "forward", true)
+
 					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
 					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
 							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
-		T:place("trapdoor", "up", false)
+
 							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
-		Build steps up or down ready for railtrack
+
-		R.depth = headroom, default 2
+
 				T:go(R.side.."1C1"..oTurn.."1", false, 0, true) -- face canal wall, replace with stone if empty, face forward
 				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
 								print("Out of water buckets")
 								sleep(1)
 							end
-				--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
 					end
 					utils.getWater() 							-- collects 2 water *| |W|<|W|
 					T:go(R.side.."2F1") 						-- face along new canal *| |W|>|W| to *| |W|W|>|
-			--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
+
 		end
 	end
 
 	local maxLength = 512
 	if R.length ~= 0 then
 		maxLength = R.length
 	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
 	if R.data == 1 then -- 2 turtles
 		lib.side(R, maxLength - moves)
 	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")
-			T:place("slab", "down", false)
+
 		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
 		-- while obsidian in front or below (previously entered tower) measure width and return to centre
 		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
-			--T:place("stone", "forward", false) -- place does not allow for specific blocktype
+
 			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
 				lib.attack()
 			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
-				T:place("minecraft:torch", "down")
+
 				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
 				outward = lib.turnRound(outward)
 			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
-	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")
+
 		while not turtle.detectUp() do
-				T:place(useBlockType, "down")
+
 			if success then
-			if i < #section then
+
 			end
 			height = height + count
 		end
 		T:turnRight(2)
 		while not turtle.detectDown() do
 			if lib.approach("down", 64, true) then
 				lib.attack()
-			while turtle.digUp() do end
+
-			turtle.digDown()
+
-			T:place(useBlockType, "down")
+
-			--T:go("x0C2", false, 0, false, useBlockType)
+
 			turtle.forward()
-				while not turtle.forward() do
+
-					turtle.dig()
+
 			turtle.down()
-				--T:forward(1)
+
 		T:turnRight(2)
 	end
 
 	function lib.walls()
 		local doContinue = lib.checkPosition()
 		if doContinue then
 			T:go("F2R1 F2R2 D1x2")		-- on corner outside middle of wall, facing along its length, dig light rod
 			for i = 1, 4 do
 				lib.clearWall()
 			end
 			T:go("F2L1 U1F2 R2")
 		else
 			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()
-	function lib.findLegacyStart()
+
 			lib.walls()
-		local block = T:getBlockType("down")
+
-		if block:find("polished") ~= nil then
+
-			return ""	-- in correct position, facing centre of front wall
+
 	if doContinue then
-		-- assume on left corner
+
-		T:forward (1)
+
-		local couint = 0
+
-		while (T:getBlockType("down")):find("polished") == nil do
+
 		lib.home(direction, moves)
 	end
-			if count > 10 then
+
-				return "Unable to locate polished block"
+
 end
 
 local function manageFarm(R)
 	local lib = {}
 
-	function lib.floodFarm(R)
+	function lib.checkEquipment()
 		--[[ Needs pickaxe and hoe equipped ]]
-		T:sortInventory(false)
+
-		for i = 1, R.width - 2 do
+		--T:checkInventoryForItem(items{}, quantities{}, required, message)
-			lib.placeFloor(R.length - 2, R.useBlockType)
+
-			if i < R.width - 2 then
+		local equippedRight, equippedLeft, inInventory = T:setEquipment() -- any tools equipped except diamond_pickaxe and crafting_table have been removed to inventory
-				outward = lib.turn(outward)
+		--[[if equippedRight ~= "minecraft:crafting_table" then
 			T:checkInventoryForItem({"minecraft:crafting_table"}, {1})
 			local equippedRight, equippedLeft = T:setEquipment()
-		T:go("U1R2") -- over 13 x 13 internal area opposite corner
+
-		-- now add corners
+		T:suck("down")		-- if hoe already in storage get it out
-		lib.placeCorners(R.length - 2, 4, R.useBlockType)
+		if inInventory ~= "minecraft:diamond_hoe" then
-		outward = lib.turn(outward)
+			if T:getItemSlot("minecraft:diamond_hoe") > 0 then
-		lib.placeCorners(R.length - 2, 3, R.useBlockType)
+
-		outward = lib.turn(outward)
+
-		lib.placeCorners(R.length - 2, 2, R.useBlockType)
+				T:checkInventoryForItem({"minecraft:diamond_hoe"}, {1}, true, "Diamond Hoe required for planting!")
-		outward = lib.turn(outward)
+
-		lib.placeCorners(R.length - 2, 1, R.useBlockType)
+
 		if T:getItemSlot("minecraft:diamond_hoe") > 0 then
-			T:go("R1F"..R.width - 9 .."R1")
+
 		end
-			T:go("L1F"..R.width - 9 .."L1")
+
 		return false
 	end
-		lib.placeCorners(R.length - 2, 1, R.useBlockType)
+
-		outward = lib.turn(outward)
+
-		lib.placeCorners(R.length - 2, 2, R.useBlockType)
+		--[[ first function called on start]]
-		outward = lib.turn(outward)
+		local atHome = false
-		lib.placeCorners(R.length - 2, 3, R.useBlockType)
+
-		outward = lib.turn(outward)
+		print("Checking position "..blockType.. " below")
-		lib.placeCorners(R.length - 2, 4, R.useBlockType) -- should be back in starting corner facing front
+		if blockType:find("water") ~= nil then -- over water
 			if lib.isStorage("forward") then
-		T:go("U1R1")
+				atHome = true
-		lib.placeWater(R.length - 3) -- place water down then move forward, turn right
+
-		lib.placeWater(R.width - 3)
+				if lib.isStorage("forward") then-- confirms in correct position, back to crops
-		lib.placeWater(R.length - 3)
+
-		lib.placeWater(R.width - 3)
+				else -- facing crafting table
-		T:go("F".. math.floor((R.length - 2) / 2).."R1F".. math.floor((R.width - 2) / 2)) -- should be in centre
+
 				end
-		--T:go("D6x2 F1x2 F1x2 F1x2 F1x2 F1x2 F1x2 F1x2 F1x2 F1x2 R1F7 R1U1")
+			else -- not a chest: facing crops or crafting table
-		T:go("D6F7 R1F7 R1U1") -- end facing back at left corner, 1 block above floor/1 below ceiling
+
 				if lib.isStorage("forward") then -- confirms was facing crops
 					atHome = true
-	function lib.clearBasement()
+					T:turnLeft(1)
-		T:sortInventory(false)
+
-		T:dropItem("seeds", "forward")
+
-		T:dropItem("flint", "forward")
+			-- should now be facing crops. may be crafting table to left
-		clearRectangle({width = 15, length = 15, up = true, down = true})
+
-		-- area has been cleared. starts facing back, 1 block above ground, 1 block below ceiling
+		return atHome-- now facing crops
 	end
-		for i = 1, 14 do	-- place cable into gutter beneath front of farm
+
-			T:place("cable", "up")
+	function lib.crossFarm()
-			if i < 14 then
+
 		local blockType = ""
 		local isReady, cropType, status = lib.isCropReady("down")
 		-- will go forward until chest or cobble detected below
-		-- ends right side facing right, just below ceiling
+
 		local numMoves = 0
 		local endOfPath = false
 		while not endOfPath do
 			blockType = T:getBlockType("down", -1)
 			if blockType == "" or cropType ~= "" then --crops or nothing below
-	-- R.data = "new", "left", "right" or "back" to extend tree farm
+
 			elseif  blockType:find("barrel") ~= nil or blockType:find("chest") ~= nil or blockType:find("cobble") ~= nil then
-	-- R.networkFarm to create storage area
+
 			end
 			numMoves = numMoves + 1
 		end
-	-- R.data = "new", "left", "right", "back", "convertStorage", "convert"
+		return blockType -- either chest or cobble
-	if R.data == "new" then -- new treeFarm, Start at current position
+
-		-- build 4 wall sections in 2 passes
+
 	function lib.farmInFront()
-		lib.buildWallSection("---------------", R.useBlockType)		-- left wall (15 blocks)
+
-		T:go("R1F1")
+		T:go("U1L1F11D1R1")							-- on next farm, facing crops
 		local crop = lib.manageTree()				-- refuel, gather seeds and other crops
-			lib.buildWallSection("--------------", R.useBlockType)	-- back/ right wall (14 blocks)
+		local isFarmToRight, _ = lib.harvest(crop)	-- harvest field, store crops
 		return isFarmToRight
 	end
-		lib.buildWallSection("------c------", R.useBlockType)		-- front wall (14 blocks) c = network cable
+
 	function lib.farmToRight()
-		lib.buildWallSection("---------------", R.useBlockType)		-- left wall top (15 blocks)
+
-		T:go("R1F1")
+		T:go("U1F11 D1")				-- on next farm, facing crops
 		local crop = lib.manageTree()	-- refuel, gather seeds and other crops
-			lib.buildWallSection("--------------", R.useBlockType)	--back/right wall (14 blocks)
+		lib.harvest(crop)				-- harvest field, store crops
 	end
 
-		--lib.buildWallSection("-----lmb-----", R.useBlockType)	--front wall (14 blocks) log/modem/barrel
+	function lib.getCrops()
-		lib.buildWallSection("-----lmb", R.useBlockType)
+
 
-		network.attachModem()
+		if lib.isStorage("forward") then
 			lib.getSeeds("forward")
-		lib.buildWallSection("-----", R.useBlockType)
+
-		T:go("R1F1 D2") -- over 13 x 13 internal area
+
-	elseif R.data == "left" or R.data == "right" or R.data == "back" then
+		if lib.isStorage("forward") then
-		-- build 3 wall sections in 2 passes
+			lib.getVeg("forward")
-		if R.data == "left" then										-- should be on left corner of existing
+
-			T:go("L1F1 D1") 											-- move left 1 blocks, down 1: <-
+
-			lib.buildWallSection("------c-------", R.useBlockType)		-- front wall (14 blocks) c = network cable <-
+
 
-			lib.buildWallSection("--------------", R.useBlockType)		-- left wall (14 blocks) ^
+	function lib.getSaplings(direction)
 		--[[ get a single sapling from the chest ]]
-			lib.buildWallSection("-------------", R.useBlockType)		-- back wall (13 blocks) ->
+
-			T:go("U1R2")												-- turn round ready to add next layer <-
+
-			lib.buildWallSection("--------------", R.useBlockType)		-- back wall top (14 blocks) <-
+
 		while T:suck(direction, 1) do end -- remove saplings/ seeds
-			lib.buildWallSection("--------------", R.useBlockType)		-- left wall top (14 blocks) v
+
 		T:dropItem("sapling", direction, 1) -- drop all but 1 saplings
-			lib.buildWallSection("-----bm", R.useBlockType)				-- front wall (7 blocks) barrel/modem ->
+		if not T:dropItem("seeds", direction, 0) then-- drop all seeds
-			network.attachModem()
+			T:dropItem("seeds", "up", 0)
 		end
-			lib.buildWallSection("l-----", R.useBlockType)				-- front wall (5 blocks) log ->
+
-			T:go("R2F12 R1F1 D2") 										-- over 13 x 13 internal area lower left side
+		return T:getItemSlot("sapling", -1)
-		elseif R.data == "right" then									-- should be on right corner of existing
+
-			T:go("R1F1 D1") 											-- move right, forward, down 1
+
-			lib.buildWallSection("------c-------", R.useBlockType)		-- front wall (14 blocks) c = network cable
+	function lib.getSeeds(direction)
 		--[[ get 1 stack of wheat seeds or 1 stack of beetroot seeds ]]
-			lib.buildWallSection("--------------", R.useBlockType)		-- right wall (14 blocks)
+		print("Collecting seeds from storage")
 		while T:suck(direction, 1) do end -- remove saplings/ seeds
-			lib.buildWallSection("-------------", R.useBlockType)		-- back wall (13 blocks)
+		T:dropItem("sapling", direction, 0) -- drop all saplings
-			T:go("U1R2")												-- turn round ready to add next layer
+		T:dropItem("minecraft:wheat_seeds", direction, 64) -- drop all but 64 seeds
-			lib.buildWallSection("--------------", R.useBlockType)		-- back wall top (14 blocks)
+		T:dropItem("minecraft:beetroot_seeds", direction, 64)
 		local crop = ""
-			lib.buildWallSection("--------------", R.useBlockType)		-- left wall top (14 blocks)
+		if T:getItemSlot("minecraft:wheat_seeds", -1) > 0 then
 			crop = "wheat"
-			lib.buildWallSection("-----lmb", R.useBlockType)
+			print("Field crop = "..crop)
 		elseif T:getItemSlot("minecraft:beetroot_seeds", -1) > 0 then
-			network.attachModem()
+			crop = "beetroot"
-			T:forward(2)
+			print("Field crop = "..crop)
-			lib.buildWallSection("-----", R.useBlockType)
+
-			T:go("R1F1 D2") 											-- over 13 x 13 internal area
+
-		elseif R.data == "back" then									-- should be on left front corner of existing
+		return crop
-			T:go("R2F1 D4R2 F1") 										-- move forward 14 blocks, down 1
+
-			for i = 1, 15 do
+
-				T:place("cable", "up")
+	function lib.getVeg(direction)
 		-- assume only one type of crop per field
 		print("Collecting crops from storage")
 		direction = direction or "forward"
-			if T:getBlockType("up") == R.useBlockType then				-- already a farm on left side
+		while T:suck(direction, 1) do end -- remove carrots / potatoes / wheat / beetroot
-				T:go("U2C2 U1C2 F13R1 F1D1", false, 0, false, R.useBlockType)
+		--clsTurtle.dropItem(self, item, direction, keepAmount)
-				lib.buildWallSection("--------------", R.useBlockType)	-- back wall (14 blocks)
+		T:dropItem("wheat", direction, 0)		-- drop all wheat
 		T:dropItem("beetroot", direction, 0)	-- drop all beetroot
 		T:dropItem("carrot", direction, 64)		-- drop all but 64 carrots
 		T:dropItem("potato", direction, 64)		-- drop all but 64 potato
-				lib.buildWallSection("--------------", R.useBlockType)	-- left wall (14 blocks)
+		local crop = ""
 		if T:getItemSlot("potato", -1) > 0 then
-				lib.buildWallSection("--------------", R.useBlockType)	-- back wall (14 blocks)
+			crop = "potato"
 			print("Field crop = "..crop)
 		elseif T:getItemSlot("carrot", -1) > 0 then
 			crop = "carrot"
-			lib.buildWallSection("-------------", R.useBlockType)		--right wall (13 blocks) no special blocks
+			print("Field crop = "..crop)
-			T:go("U1R2")	-- turn round ready to add next layer
+
-			for i = 1, 2 do
+
-				lib.buildWallSection("--------------", R.useBlockType)	--right wall top (14 blocks) no special blocks
+		--T:turnRight(2) -- face crops
-				T:go("L1F1")
+		return crop
 	end
-			lib.buildWallSection("-------------", R.useBlockType)		-- left wall top (13 blocks) no special blocks
+
-			T:go("F1L1 F7x2")
+	function lib.goHome()
-			T:go("D1x2")
+
-			T:place("cable", "down")
+
 		-- is tree above or in front
-			T:place("modem", "down")
+
-			T:go("F1R2x2")
+
-			T:place("log", "down")
+			lib.harvestTree("forward") -- will only harvest if fuel below half of limit
-			T:go("F2x2")
+
-			T:place("barrel", "down")
+
 			lib.harvestTree("up")
-			network.attachModem()
+
-			T:go("F6R1 F1D2")
+		elseif T:getItemSlot("log", -1) > 0 then -- tree just harvested
 			onTree = true
-	else -- convertStorage or convert
+
-		-- legacy farm had polished block on positions 4 / (10) from left corner
+
-		 local message = lib.findLegacyStart()
+				lib.harvestTree("up")
-		 if message ~= "" then
+
-			return {message}
+				while turtle.down() do end
-		 end
+
-		 -- now on top of polished block, 4 from left corner, facing Centre
+
-		 T:forward(2)
+
-		 T:place("barrel", "down")
+		if onTree then -- tree harvested, but direction unknown
-		 T:go("F1D1")
+
-		 T:place("cable", "down")
+			local turns = 0
-		 T:up(1)
+			local onChest = lib.isStorage("down")
-		 T:place("modem", "down")
+			while not onChest do
-		 network.attachModem()
+
-		 T:forward(1)
+					if lib.isStorage("down") then
-		 T:place("log", "down")
+						onChest = true
-		 T:go("R1F1 R1F1 D5R1 F1L1 F7R1")-- left corner, facing back ready to clear basement
+
 						turtle.back()
-	if (R.data):find("convert") == nil then
+
-		lib.floodFarm(R)
+
 				if not onChest then
-	lib.clearBasement() -- area has been cleared. ends right side facing right, just below ceiling
+
 					turns = turns + 1
-	if R.data == "back" then
+
-		T:go("R2F6 R1D1")
+				if turns == 4 then
 					break
-		T:go("R2F6 L1F1 U4D5 R2F1") -- make exit for player. end mid floor/ceiling height, facing back, in centre
+
 			end -- should be on chest. If not should be over water
-	if R.data == "new" or R.data == "convertStorage" then	-- put storage in this farm
+			if onChest then -- onChest and onTree, go left,down
 				T:go("R1F1D1R1")
-			T:place("cable", "up")
+
 			atHome = lib.checkPosition()
 			if atHome then
-		T:place("cable", "up")
+				return true -- exit function
 			end
-		utils.createStorage()	-- creates on ground, 1 below current
+
 			while turtle.down() do end -- no tree around, no logs onboard
-		T:place("cable", "forward")
+
 
 		return false
-			T:place("cable", "up")
+
 
 	function lib.gotoTree(logSlot)
 		-- assume facing crops
-		for i = 1, 6 do
+
-			T:place("cable", "up")
+		print("Extracting saplings from storage")
 		lib.getSaplings("forward") -- gets one sapling only (if present)
 		print("Moving to tree position")
 		T:go("U1F1R1")
-	T:place("modem", "up")
+		lib.harvestTree("forward") -- fell tree or plant sapling, ends facing tree / dirt / sapling. sticks already used for fuel. excess saplings placed
-	T:go("F1R2U2")
+
-	T:place("barrel", "down")
+		if logSlot == 0 then -- no logs passed as parameter
-	T:drop("down", "dirt", 64)-- override 'slot' with item string
+			logSlot = T:getItemSlot("log")
-	T:up(1)
+
-	T:place("hopper", "down")
+		T:go("R1F1D1")			-- return to base, facing buried storage
 		if logSlot == 0 then 	-- has logs so needs to craft and refuel
-	network.attachModem()
+			T:turnRight(1)		-- facing crops
-	T:go("U1C2 U2F6 R2")
+
-	--network.attachModem()
+
 		return logSlot
 	end
 
 	function lib.harvest(crop)
 		--[[
 		cover the field in a set pattern.
 		harvest crops if ripe
 		till soil and plant new ones
 		place seeds / harvest in chests
 		return farm(s) to right / front
 		]]
-			T:place("barrel", "down", false)
+
 		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
 					turtle.digDown("right")				-- use hoe
 					lib.plantCrop(crop, "down")			-- plant crop
 				elseif isReady then						-- crop below is ready
 					turtle.digDown("left")				-- use pickaxe
-		T:place("torch", "forward", true)
+					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)
-		-- T:place(blockType, direction, leaveExisting, signText)
+					if lib.isStorage("down") then
 						isFarmToRight = true
 					end
 					turtle.back()
 				end
 			end
-				T:place(R.useBlockType, "forward", true)
+
 			if l < length then -- do not turn at final row
 				lib.plantCrop(crop, "down")
 				if toRight then
 					T:go("L1F1L1")
 				else
 					T:go("R1F1R1")
 				end
-					T:place(R.useBlockType, "up", true)
+
 			toRight = not toRight
 		end
 		T:go("R1F1") -- goes over chest/cobble on top wall
 		if lib.isStorage("down") then
 			isFarmToFront = true
 		end
-					T:place(R.useBlockType, "forward")
+
 		lib.storeCrops() -- rotates from start to deposit seeds and crops, ends facing crops
 		return isFarmToRight, isFarmToFront
 	end
 
-					T:place(R.useBlockType, "forward")
+	function lib.harvestTree(direction)
 		--[[
 			start in front of / during tree harvest
 			Check if sapling present
-					T:place(R.useBlockType, "forward")
+
 			Dispose of apples. Use sticks as fuel
 			Return to base
 		]]
 		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")
 			if inFront == "" then -- no tree or sapling
-						T:place(R.useBlockType, "down", true)
+				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
 				-- 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
 			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
-		T:place(R.useBlockType, "down", true)
+
 	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
 
 		if turtle.getFuelLevel() < turtle.getFuelLimit() / 2 then
 			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
-					T:place("torch", "down")				-- place torch, move forward
+
 	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)
-				if not T:place("stone", "down") then		-- place stone below
+
 		planted = T:place("carrot", -1, direction)
 		if not planted then
 			planted = T:place("potato", -1, direction)
 		end
 		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
 
 	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
-						T:place("torch", "down")		-- place torch
+
 					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")
 
 		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
-						T:place("torch", "down")		-- place torch
+	-- 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
 	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)
-		T:place("slab", "down")					-- place slab layer 1
+
 		elseif R.subChoice == 2 then	-- end of blocks in front of turtle eg cliff, wall
-		T:place("slab", "down")					-- place slab layer 2
+
 			while turtle.detect() and doContinue do
-		T:place("redstone", "down")
+
 					doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
-		T:place("redstone", "forward")			-- redstone on ground level slab
+
 					message = "Obstruction above stopped measurement"
-		T:place("slab", "down")					-- slab on layer 1
+
 					doContinue = false
-		T:place("slab", "down")					-- slab on layer 3
+
 			end
-		T:place("redstone", "down")				-- redstone on layer 3 slab
+
 			method = "Method:Until search: '"..R.data.."' met"
 			while turtle.detect() and doContinue do
-		T:place("redstone", "forward")			-- redstone on layer 1 slab
+
 					doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
-		T:place("redstone", "forward")			-- redstone on level 0 floor
+
 						local blockType = T:getBlockType("forward")
 						if blockType:find(R.data) ~= nil then
 							measure = "Height measured: "..blocks.." blocks"
 							message = "Found "..blockType
 							doContinue = false
 						end
-			T:place("redstone", "down")			-- redstone under chest etc
+
 				else
 					message = "Obstruction above stopped measurement"
 					measure = ""
 					doContinue = false
 				end
 			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"
-		T:place("chest", "forward")				-- end chest
+
 				T:up(1)
-		T:place("slab", "down")					-- slab above chest
+
 				if doContinue then
 					blockType = T:getBlockType("up")
 				end
-		T:place("chest", "forward")				-- start chest
+
 			measure = "Height measured: "..blocks.." blocks"
-		T:place("wall", "forward")				-- place wall
+
 		end
-		T:place("pressure", "down")				-- place pressure plate
+
 		for i = 1, blocks do
-		T:place("hopper", "forward")				-- place hopper into chest
+
 		end
-		T:place("wall", "forward")				-- place second wall
+
 		T:go("F1R2D1") -- go off the edge and face cliff/pit wall
 		blocks = blocks + 1
 		if R.subChoice == 1 then		-- obstruction water / lava below
 			local move = true
 			while move do
 				local blockType = T:getBlockType("down")
-		T:place(R.useBlockType, "forward", false)	-- replace back wall with polished block layer 2
+
 					message1 = blockType.." found at "..blocks
-		T:place(R.useBlockType, "forward", false)	-- replace back wall with polished block layer 3
+
 				else
 					move = turtle.down()
-			T:place(R.useBlockType, "forward", false)-- polished block above second wall layer 3
+
 						blocks = blocks + 1
 					else
 						measure = "Depth measured: "..blocks.." blocks"
-			T:place("piston", "forward")				-- lower replacer piston placed
+
 				end
 			end
-		T:place("piston", "forward")					-- lower piston placed
+
 		elseif R.subChoice == 2 then	-- end of wall in front`
 			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
+
 				else
 					message1 = "Obstruction below stopped measurement"
-		T:place("slab", "down")						-- lower piston slab placed
+
 				end
-			T:place(R.useBlockType, "forward", false)-- polished block above second wall layer 4
+
 			method = "Method: Until no block detected ahead"
 		elseif R.subChoice == 3 then	-- specific block detected ahead
 			method = "Method:Until search: '"..R.data.."' met"
 			while turtle.detect() do
-			T:place("computercraft:computer_normal", "forward", false)	-- place computer
+
 					blocks = blocks + 1
 					local blockType = T:getBlockType("forward")
-		T:place(R.useBlockType, "forward", false)	-- polished block back wall layer 4
+
 						measure = "Depth measured: "..blocks.." blocks"
 						message = "Found "..blockType
-		T:place("piston", "forward")					-- upper piston placed
+
 					end
 				else
-		T:place(R.useBlockType, "forward", false)	-- polished block back wall layer 5
+
 					break
 				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
+
 		end
 		for i = 1, blocks do
 			turtle.up()
-			T:place("piston", "forward")				-- upper replacer piston placed
+
 		T:go("F1R2")
 	elseif R.choice == 103 then	-- length
-		T:place("slab", "forward")					-- upper piston slab placed
+
 			method = "Method: Until obstruction ahead"
 			while turtle.forward() and doContinue  do
 				doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
 			end
 		elseif R.subChoice == 2 then	-- end of ceiling above
 			method = "Method: Until no block detected above"
-		T:place("computercraft:computer_normal", "forward", false)		-- place computer in gap, layer 4
+
 				if turtle.forward() then
 					doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
 				else
-		T:place(R.useBlockType, "forward", false)
+
 					measure = ""
-		T:place(R.useBlockType, "forward", false)
+
 				end
-		T:place(R.useBlockType, "forward", false)	-- facing right
+
 		elseif R.subChoice == 3 then	-- end of floor below
 			method = "Method: Until no block detected below"
 			while turtle.detectDown() and doContinue do
 				if turtle.forward() then
 					doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
-		T:place("glass", "down", false)
+
 					message = "Obstruction ahead stopped measurement"
-		T:place("glass", "down", false)				-- on top of glass facing back wall at dungeon base level 5
+
 					doContinue = false
-		T:place(R.useBlockType, "down", false)		-- level 6 dungeon exit
+
 			end
 		elseif R.subChoice == 4 then	-- search for specific block up min 3 characters
 			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
 						local blockType = T:getBlockType("up")
 						if blockType:find(R.data) ~= nil then
-		T:place(R.useBlockType, "forward", false)
+
 							measure = "Length measured: "..blocks.." blocks"
-		T:place(R.useBlockType, "forward", false)	-- facing right
+
 						end
 					end
 				else
-		T:place(R.useBlockType, "forward", false)
+
 					measure = ""
 					doContinue = false
 				end
 			end
 		elseif R.subChoice == 5 then	-- search for specific block down min 3 characters
-		T:place("computercraft:wired_modem", "forward", false)	-- place modem
+
 			--while turtle.detectDown() and doContinue do
-		T:place("computercraft:cable", "forward", false)			-- place network cable
+
-		T:place("computercraft:cable", "forward", false)			-- place network cable (no need to move)
+
 					doContinue, blocks, measure, message = lib.checkBlocks(R, blocks)
-		T:place("computercraft:cable", "forward", false)
+
 						local blockType = T:getBlockType("down")
-		T:place("computercraft:cable", "forward", false)
+
 							message = "Found "..blockType
-		T:place("computercraft:wired_modem", "forward", false)	-- place modem
+
 							doContinue = false
-		T:place("computercraft:cable", "forward", false)
+
-		T:place("computercraft:cable", "forward", false)
+
 				else
 					message = "Obstruction ahead stopped measurement"
 					measure = ""
 					doContinue = false
 				end
 			end
 		end
 		T:turnRight(2)	-- head home
 		for i = 1, blocks do
 			turtle.forward()
 		end
 		T:turnRight(2)
 	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
-local function createTrialCover(R)
+
 				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
 	end
 
 	local goRight = true
 	for i = 1, R.width do
 		for j = 1, R.length do
 			lib.clearColumn(R)
 			T:forward(1)
-	function lib.findSpawner()
+
 		if goRight then
 			T:go("R1F1R1")
-		-- assume turtle placed facing trial spawner
+
 			T:go("L1F1L1")
 		end
 		goRight = not goRight
 	end
 	return {}
 end
-				if moves > 32 then
+
 local function oceanMonumentColumns(R)
 	-- utility to find corners and build columns to surface
 	local lib = {}
 
-			if not found then	-- could be behind a wall
+
-				print("Assuming spawner behind a wall")
+
 		while T:isWater("forward") do
 			T:go("U1C2")
-				while turtle.forward() and not quit do
+
 		end
-					if moves > 32 then
+
-						quit = true
+
 
 	function lib.buildTower()
-				found, position = lib.isSpawner() -- true/false, top/bottom/nil
+
-				if not found then
+
-					T:go("R2F"..moves + 2 .."R2")
+
 		T:go("L1F1 L1C2 F1C2 F1C2 F1C2")
 
 		T:go("R2")
 		for i = 1, 4 do
 			T:go("U1C2")
 			for j = 1, 4 do
 				T:go("F1C2 F1C2 F1C2 R1")
 			end
 		end
 	end
 
 	R.silent = true
 	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 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")
+
 					blockType = T:getBlockType("down")
-		T:go("B2U1")
+
 				turtle.back()
-	T:go("R1F2R2")	--on lower right corner
+
-	-- starts with wall across spawner
+
-	buildStructure(R)
+
-	T:go("U3F1 R1F1 L1U1 F1")
+
 		lib.buildTower()
-	R.width = 3
+
-	R.length = 3
+
 	return {}
-	createFloorCeiling(R)
+
-	T:go("F1R1 B1D1 B1D2 F1")
+
 local function placeRedstoneTorch(R) -- 91, 92
 	local moves = 2
 	local blockType = T:getBlockType("down")
 	if R.data == "level" then
 		T:turnLeft(1)
 		utils.goBack(1)
 		if blockType:find("rail") ~= nil then
 			 moves = 3
 		end
 		T:down(moves)
 		T:go("F1R1")
 		--clsTurtle.place(self, blockType, damageNo, direction, leaveExisting)
 		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:place("cobble", "down", false) -- place cobblestone or cobbled deepslate to mark zero coordinate
+
 		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:up(1)
 		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)
-		T:place("minecraft:end_stone", "forward", false) -- place endstone to mark facing direction
+
 		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)
 		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, 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
-		-- assumes legacy tree farm with turtle on polished block 4 blocks from corner
+
-		local message  = ""
+
-		R.treeSize = "single"
+
 	createCorridor(R, true)
-		--local logType = ""
+
-		--local startHeight = 0
+
 	createCorridor(R, true)
 	T:turnRight(1)
 
 	return {}
 end
 
 local function repairWall(startAt, height, width, replaceWith)
 	-- go up to startAt
 
 	-- if width = 1
-		if blockType:find("dirt") ~= nil then	-- dirt found
+
-			T:go("R1F1L1")
+
 
-			if blockType:find("dirt") ~= nil then
+
-				R.treeSize = "double"
+
 			-- move up
-			T:go("L1F1 R1")
+
-		else	-- dirt NOT found where expected
+
-			message = "Unable to determine position"
+
 		-- move back to beginning
 
-		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"
+
 				-- move up
-				R.useBlockType = parts[2].."_sapling"	-- eg "oak_sapling"
+
 			--end
 
-		T:down(1)	-- facing dirt
+
 
-		return R, message
+
 
 				-- replace block with replaceWith ("" = any)
-	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
+
 	--MINING
 	text[11] = {"1 ladder for each level","levels / 4 torch (optional)","levels * 4 stone"}				-- ladder to bedrock
-					if blockType:find("propagule") ==  nil then	-- either grown or deleted by roots
+
-						ready[facings[i]] = true
+
 	text[14] = {"levels * 4 stone","water_bucket"} 														-- safe drop to water block
 	text[15] = {"levels * 4 stone", "1 soul sand", "1 water bucket"} 									-- single column bubble lift
 	text[16] = {"1 bucket (optional)", "64 stone"} 														-- quick corridor
-				if ready.left and ready.right and ready.top and ready.bottom then
+
 	text[18] = {"1 bucket (optional)"}																	-- mine to bedrock
 	text[19] = {"1 UNUSED diamond sword (optional)"}													-- rob mineshaft
-					sleep(15)
+
-					elapsed = elapsed + 15
+
-					if  elapsed / 60 > 15 then	-- max 15 mins real time before farm is harvested
+
 	text[22] = {"320 stone", "4 polished stone"} 														-- Create treefarm
 	text[23] = {"min 4 saplings", "16 dirt"} 															-- plant treefarm
 	text[24] = {"No items required"} 																	-- Harvest treefarm
-				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[32] = {"64 stone","128 dirt (optional)", "4 water buckets","5 chests/ barrels","1 sapling"}	-- extend modular farm
 	text[33] = {"No items required"} 																	-- Manual harvest and auto setup
-			--T:go("L1D1")
+
-			T:turnLeft(1)	-- face front
+
 
-			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[45] = {"84 stone"} 																			-- undermine dragon towers
-				if pattern == "single" then
+
-					--alternate between 2 trees, starts facing left
+
 	text[48] = {"height * 4 stone","height * ladders", "1 trapdoor"}									-- build end portal platform
-					if facing == "left" then
+
-						facing = "right"
+
-					elseif facing == "right" then
+
-						facing = "left"
+
 	text[53] = {"2 * length stone or dirt","2 water buckets","torches (optional)"} 						-- water canal
-					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
-					T:down(1)	-- drop below sapling to dirt level
+
-				elseif pattern == "double" then
+
-					if ready.left and facing == "left" then-- tree on left now grown. check right
+
-						T:go("R2F2")
+
-						facing = "right"
+
 	text[63] = {"2 water buckets","If using bubble lift","2 fence","2 signs","1 slab",
-					blockType = T:getBlockType("forward")
+
-					if blockType:find("log") ~=  nil then
+
-						ready[facing] = true
+
 				"23 polished stone + 7 slabs","2 glass","1 stone pressure plate","1 dispenser",
-					T:down(1)	-- drop below sapling to dirt level
+
 	text[66] = {"1856 stone, diorite etc (inc polished)","1 chest","10 empty buckets",
 				"2 water buckets","192 fence","8 signs","3 ladder","2 soul sand"} 						-- build endermen observation tower
-				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[76] = {"No items required"}																	-- clear solid
-					elseif pattern == "double" and elapsed / 60 > 15 then	-- max 15 mins real time before farm is harvested
+
 	text[78] = {"No items required"} 																	-- carve mountain
 	text[79] = {"width * height Any material floor / ceiling"} 											-- floor or ceiling
 	text[710] =	{"Blocks to add 'floor as you go'"} 													-- Direct control of movement
 
 	-- LAVA WATER
-		-- growth complete
+
-		if pattern == "single" then
+
-			if facing == "right" then
+
 	text[84] = {"width * length + extra stone"} 														-- water clearing by repeated block deletion
 	text[85] = text[84] 																				-- sinking platform
 	text[86] = {"Full inventories of sand or stone"}													-- Ocean monument utilities
 	text[87] = {"ladder to height","stone, dirt netherrack 4 X height"} 								-- ladder to water/lava
-			--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")
+
 	text[91] = {"length * height stone"}																-- Build a wall
-				T:go("L1F1 R1F2 R1")
+
 	text[93] = {"length * width * height stairs", "length * slabs"}										-- build a gable roof
-		elseif pattern == "mangrove" then
+
-			T:go("D2F6 U1F1 R1F6 R1F1 U1")
+
 	text[96] = {"1 block of choice","1 redstone torch"} 												-- place redstone torch on upward slope
-		-- ends facing dirt at base of first tree
+
-		-- no return needed, function exit so trees are grown
+
 	return text
 end
-	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"
+
 	info.main = {}
-			T:saveToLog("lib.watchFarm: R.treeSize set to '"..R.treeSize.."'")
+
-			T:turnLeft(2)	-- face lower left double dirt
+
 	[[                ~lightGray~MINING:~white~
-		lib.waitForGrowth(R)
+
 Ladders and ~lightGray~stairs up/down
-		return R
+
 mine at chosen level.
 ~blue~Bubble lift and ~cyan~safe drop to water.~magenta~
-	function lib.harvestSingle(direction, moves)
+
-		-- if direction == "up": starting inside tree on dirt at dirt level
+
-		T:saveToLog("lib.harvestSingle('"..direction.."', moves = "..moves)
+
 the fuel and time)
-			while turtle.detectUp() do
+
 ]])
 	table.insert(info.main,
 	[[               ~lime~FORESTRY:~brown~
-		else	-- direction = "down", but could be mid-tree
+
-			local movesUp = 0
+
-			while turtle.detectUp() do
+
 or 4 double size (Dark oak or any type)
-				movesUp = movesUp + 1
+
 ~brown~ fence or wall a rectangle keeping
-			T:down(movesUp)
+
-			T:down(moves)
+
 (Must be walled off)
 
 ]])
 	table.insert(info.main,
-	function lib.harvestSingleRow()
+
-		-- start next to tree/dirt
+
 and placed next to each other in linear
-		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)
+
 ]])
 	table.insert(info.main,
-	function lib.harvestDouble()
+
-		T:forward(1)	-- dig dirt, move into left (S) corner
+
 lava areas safely.~pink~
-		while turtle.detectUp() do
+
-			turtle.dig()
+
-			turtle.digUp()
+
 undermined ready for deactivating.
 End world towers can have the crystals
 destroyed.~red~
-		turtle.dig()
+
-		T:go("R1F1L1")	-- move to right corner
+
 ]])
-			turtle.dig()
+
-			turtle.digDown()
+
 Can be used in Nether and End.~lightGray~
 Build pathways over air, water or lava
-		turtle.dig()
+
-		T:go("F1L1F1R1") -- move to left corner (N)
+
 at the same time.~blue~
 Build a water canal with towpath.~cyan~
-	--T:setUseLog(true, "treeFarmLog.txt", true)	-- T:setUseLog(use, filename, delete)
+
-	--dbug = true								-- set dbug flag
+
 Sinking version is removed and replaced
 1 block lower each time
-	-- if on modem, R.networkFarm has already been set
+
-	T:saveToLog("harvestTreeFarm(R) R.networkFarm = "..tostring(R.networkFarm))
+
 	[[             ~lightGray~SPAWNER FARMS:~brown~
-	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)
+
 Choice of bubble lift mob dropper
 or ~brown~simple deep 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))
+
 	[[    ~orange~AREA CLEARING AND REFORMING:~lime~
 Tools to clear a field including trees~magenta~
 Clear rectangles.~pink~
 Clear single walls.~brown~
-	if R.networkFarm then			-- monitor trees for growth
+
-		if R.logType == "mangrove" then
+
 Carve away side of a mountain.~lightBlue~
-			T:place("dirt", "up")
+
-			T:go("F6x2U1L1")	-- move under dirt covering, clear roots from hopper, move level with dirt, face left
+
 
-			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"}
+
 sand dropping and recycling~cyan~
 Destructive draining uses solid block
 placing and recycling.~green~
-		R = lib.watchFarm(R)	-- wait for trees to grow, then start harvest
+
 damaging structures.~lightBlue~
-		--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}
+
 	[[         ~cyan~BUILDING, MINECART TOOLS:~lightGray~
 Build simple walls, buildings and ~gray~roofs
-	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)
+
 
-				T:go("F1R1 F6L1 F3R2")
+
 
 	info.sub[11] =
-			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")
+
 	info.sub[12] =
 [[~lightGray~Place me on the ground at ~red~^
-	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"
+
 [[~yellow~Press F3 to check Y level.
-		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)
+
 	else
-			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)
+
 ~lightGray~| | | | | |
 
 ]] -- safe drop
-	return {}	-- if player initiated, stops here. If R.auto then returns to plantTreeFarm()
+
 [[~magenta~Direction of travel = UP!
 ~yellow~Place me on the ground. I will build a
 3 x 1 ~blue~water ~yellow~source and a single column
 bubble lift to the chosen height.
 If near a ladder, place left or right:
 
 ~lightGray~| | | | | |
 ~lightGray~| | |*| | | * = Ladder support block
 | |~blue~^~brown~|L|~blue~^~lightGray~| | ~brown~L = ladder
 ~lightGray~| | | | | | ~blue~^ = Turtle facing forward
 ~lightGray~| | | | | | ~blue~^ = Bubble column above
 
 ]] -- 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~|*|*|*|*|*|*|*|
-local function upgradeFarmland(R)
+
-	local essences = {":inferium", ":prudentium", ":tertium", ":imperium", ":supremium", ":awakened" , ":insanium"}
+
 
 
 
-	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
+
 [[~yellow~Place turtle <64 blocks from shulker
 Same level, or 1 block above/below
 Plan view:
-		for index = 1, #essences do
+
-			if essence:find(essences[index]) ~= nil then
+
-				if index > teir then
+
    ~red~T~lightGray~ | | | | | |~gray~T~lightGray~|
    ~red~T~lightGray~ | | | | |~gray~T~lightGray~|~lime~S~lightGray~|   ~gray~T = kill positions
    ~red~T~lightGray~ | | | | | |~gray~T~lightGray~|
 
  ~red~> T~lightGray~ = Turtle   ~lime~S~lightGray~ = Shulker]] -- Shulker is ahead
 
 	info.sub[493] =
-	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()
+
        ~gray~T
      ~gray~> ~lime~S ~gray~<       > T < = kill positions
 ~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()
+
 ~lightGray~|*|~orange~+~lightGray~| |~lime~S|~red~+~lightGray~| | |~blue~+~lightGray~|*| T = turtle places
-	if slot > 0 then
+
-		T:go("D2")
+
 ~lightGray~|*|~orange~+|+|+|~red~+|~blue~+|+|+~lightGray~|*|    |*|*|*|*|*|
-		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
+
 Face ~red~direction ~yellow~shown. It will exit up,
 clear the roof above and return
-				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 roof above
 
 	info.sub[496] =
-				lib.upgrade(name, slot)
+
-				if w == 1 then
+
-					T:go("L1F1 L2C1 R1")
+
-				elseif w == 9 then
+
-					T:go("L1F1 L1F1 L2C1 L2")
+
 ~lightGray~|*|~red~<~lightGray~| | | | | | |~red~^~lightGray~|*|  ~yellow~automatically.
 ~lightGray~|*| | | | | | | | |*|
 
 ~lightGray~|*| | | | | | | | |*|
-				if w < 10 then
+
-					lib.upgrade(name, slot)
+
 
 	info.sub[51] =
-					T:go("L1F1 L2C1 R2F8 L1U1 C2U2") -- 1 above normal position
+
 
 ~yellow~Start:~blue~  |-|-|-|    - = air/water
 ~orange~        |-|-|-|    - = lava
 ~blue~        |-|-|-|
-		-- 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()
+
 ~lightGray~        |*|*|*|    * = Solid block
 ]] -- Single path
 	info.sub[52] =
-				turtle.suckDown()
+
-				turtle.suck()
+
 ~yellow~Plan view    Face view
 
-				if w < 10 then
+
-					turtle.suckDown()
+
-					turtle.suck()
+
 ~lightGray~|*|~green~*~lightGray~|*|      *|*|~red~T~lightGray~|*|*   ~red~^ T = Turtle
    ~red~^~lightGray~         ~green~- - * - -   ground
-					T:go("L1F9 L1D1") -- normal position
+
 ~green~Floor + ceiling ~yellow~placed for your safety!
 ]] -- Covered walkway / tunnel
 	info.sub[53] =
 [[~yellow~plan view
 
-	return ({"Farmland Upgraded"})
+
 ~lightGray~|*|~blue~-|-~lightGray~|*|    ~yellow~Cross section view
 ~lightGray~|*|~blue~-|-~lightGray~|*|     ~lime~1 ~orange~2 ~brown~3 ~green~4  ~lightGray~= on ground
 ~lightGray~|~lime~^~lightGray~|~blue~^~lightGray~|~cyan~^~lightGray~|~green~^~lightGray~|    |*|~blue~5~lightGray~|~cyan~6~lightGray~|*| ~lightGray~= in water
 
 ~yellow~New canal       ~lime~1 ~orange~2 ~brown~3 ~green~4 ~yellow~ground level-63
-	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"}
+
 
 ~lightGray~ |*| | |*| 	 * = Slab
-		if crop == "none" then
+
-			return "", ""
+
-		elseif crop == "mysticalagriculture" then
+
-			T:checkInventoryForItem({"seeds"}, {95}, true, "Add one type of M. Agriculture seeds")
+
 ~lightBlue~  5 6 7 8    Convert water canal
-			T:checkInventoryForItem({crop}, {95}, true, "Do not mix! add as many as you want")
+
 ~red~All turtles placed at ground level!
-		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
+
 
 | | | | | | | |
-	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
 ]] -- Platform
-	function lib.checkEquipment(R, itemRequired)
+
-		-- Check if item is equipped and return it to slot
+
 Existing platform replaced below
 
-		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
+
 | |~red~^~lightGray~|*|*|*|*| |  ~red~^ = Turtle~lightGray~
 | | | | | | | |
-		return 0	-- not found
+
 Blocks placed under the turtle
 ]] -- Sinking platform
-	function lib.crossFarm(R)
+
 [[~yellow~Boat Lift (Ice or Water)
 Place turtle left side. ~blue~Source~yellow~ to right
-		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
+
              |*|~cyan~S|S|~lightGray~*| ~cyan~S ~lightGray~= Soul sand
 |*|*|*|*|    |*|~brown~S|S~lightGray~|*| ~brown~S = ~lightGray~Sand + gate
 |~red~^~lightGray~|~blue~W|W~lightGray~|*|    |*~blue~|W|W|~lightGray~*| ~red~^ ~lightGray~= Turtle
 |*|~blue~W|W~lightGray~|*|    |*|~blue~W|W~lightGray~|*|
 |*|~blue~ | ~lightGray~|*|    |*|~blue~ | ~lightGray~|*| ~yellow~Ice canal needs
 ~lightGray~|*|~blue~ | ~lightGray~|*|    |*|~blue~ | ~lightGray~|*| ~yellow~2x2 water source
 ]] -- boat bubble lift
-			elseif  blockType:find("barrel") ~= nil or
+
-					blockType:find("chest") ~= nil or
+
-					blockType:find("modem") ~= nil or
+
-					blockType:find("cobble") ~= nil then
+
  |*|*|*|*|*|*|*|   |*|~brown~1~lightGray~|*|*|*|~yellow~2~lightGray~|*| Top
 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
-		return R, blockType -- either barrel, chest, modem or cobble
+
 T|*| | | | | |*|T  * = Dungeon Wall
  |*|*|*|*|*|*|*|   ~orange~S = Spawner
-	function lib.farmAll(R, isFarmToRight, isFarmToFront)
+
-		local plotCountR = 0		-- plot a1 harvested
+
-		local plotCountF = 0		-- plot a1 harvested
+
 	info.sub[62] =
-			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~|*|*|*|*|*|*|*|*|  ~lime~> T = Continue build
-			lib.goToLeft(R, plotCountR)
+
 ~lightGray~|*| | | | | | | |
 |*| | | |~purple~S~lightGray~| | | |~lime~>~red~<          T
-			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
+
 
-					lib.goToLeft(R, plotCountR)	-- return home and continue with front
+
 ~red~>~lightGray~|*| | | | |~purple~S~lightGray~| | | | |*|~red~<~lightGray~ |*| | | | |~purple~S~lightGray~|
-				plotCountF = plotCountF + 1
+
  |*| | | | | | | | | |*|  |*| | | | | |
-			lib.goToFront(R, plotCountF)
+
  |*| | | | | | | | | |*|  |*| | | | | |
  |*|*|*|*|*|*|*|*|*|*|*| ~red~T~lightGray~|*|*|*|*|*|*|
             ~red~^
-	function lib.farmInFront(R)
+
 ]] -- Flood spawner chamber
-		T:go("U1L1 F11D1 R1")						-- on next farm, facing crops
+
-		local seed, crop = lib.manageTree(R)		-- refuel, gather seeds or other crops
+
  |*| | | | | | | | | |*|
-		R, isFarmToRight = lib.harvest(R, seed, crop)		-- harvest field, store crops
+
-		return R, isFarmToRight
+
            ~brown~|~red~^~brown~|~lightGray~= Turtle on ~brown~Soul Sand
 
-	function lib.farmToRight(R)
+
  |*| | | | |~brown~F~lightGray~| | | | |*|
-		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
+
 [[~yellow~Computercraft mob grinder
 
-	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"
+
 ]] -- Computercraft mob grinder
-			if crop:find("beetroot") ~= nil then
+
-				return "minecraft:beetroot_seeds", "minecraft:beetroot"
+
 1.New tower lower base: place me on
 flat ground in open plain.
-		if crop:find("wheat") ~= nil then
+
-			return "minecraft:wheat_seeds", "minecraft:wheat"
+
 the existing chest at tower base.
-		if crop:find("beetroot") ~= nil then
+
-			return "minecraft:beetroot_seeds", "minecraft:beetroot"
+
 mobs. Expensive, not recommended.
-		if crop:find("carrot") ~= nil then
+
-			return "", "minecraft:carrot"
+
 
 	info.sub[71] =
-			return "", "minecraft:potato"
+
 
-		-- planted crops are plural, harvested singular: carrots / carrot, pototoes/ potato
+
-		return "", crop -- no seed for carrot / potato
+
 ~lightGray~| | | | | |  Remove blocks > ground
 | | | | | |
-	function lib.getHoe()
+
 |~red~^~lightGray~| | | | |  ~red~^ ~lightGray~= Turtle position
-		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")
+
 [[~yellow~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 =
+
 |~red~^~lightGray~| | | | |  ~red~^ ~lightGray~= Turtle position
  ~red~^
 
 ~yellow~Can be used to clear 3 layers at a time
 
-	instead.
+
 
 	info.sub[73] =
 [[~yellow~Clear wall
-				return 0, message
+
                   ~gray~T ~lightBlue~T
-			-- 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")
+
 
 T = Turtle top / bottom/ inside / out
 ~yellow~Bottom to top or top to bottom
-		return hoeSlot, ""
+
 	info.sub[74] =
 [[~yellow~Clear rectangle ~red~perimeter only
-	function lib.getSaplings(R, direction)
+
 ~yellow~Plan view
 ~lightGray~| | | | | |  Remove all blocks
 ~lightGray~| |*|*|*| |  Optional dig ~lime~up
 ~lightGray~| |*|*|*| |  Optional dig ~blue~down
-		if R.networkFarm then
+
-			network.getItemFromNetwork("barrel", "sapling", 1)
+
-			--lib.getItemFromNetworkBarrels(R, "sapling", 1)
+
 ~red~ ^
-			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)
+
 [[~yellow~Demolish cube structure
 Plan view        Side view
                ~gray~T ~lightBlue~T
-		return T:getItemSlot("sapling")
+
 |*|*|*|*|*|*|   |*|*|*|*|*|*|
 |*|*|*|*|*|*|   |*|*|*|*|*|*|
-	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
+
 	info.sub[76] = info.sub[75]
-		if seed == "" then
+
-			return "", 0
+
 
-		local inventorySlot, seedCount = 0, 0
+
-		T:saveToLog("Collecting seeds from storage")
+
-		if R.networkFarm then
+
-			inventorySlot, seedCount = network.getItemFromNetwork("chest", seed, 64)
+
 | |
-			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)
+
 	info.sub[78] =
-		if seedCount > 0 then
+
-			T:saveToLog("planting " ..seed)
+
 
-		return seed, seedCount	-- could be: "", 0 or "minecraft:wheat_seeds", 64
+
 ~gray~ 	    |*~lightGray~|*|            ~gray~|*~lightGray~|*|*|*|    ~yellow~E
 ~gray~      |*~lightGray~|*|*|*|      ~gray~|*|*~lightGray~|*|*|*|*|  ~yellow~N
-	function lib.getVeg(R, direction, crop)
+
 ~gray~      |*~lightGray~|*|*|*|       ~red~^~gray~|*~lightGray~|*|*|*|    ~yellow~T
-		-- local item, itemName, shortName, slot = "", "","", 0
+
-		local inventorySlot, cropCount = 0, 0
+
     ~yellow~<--> no. of rows <-->
-		if R.networkFarm then
+
-			inventorySlot, cropCount = network.getItemFromNetwork("chest", crop, 64)
+
 [[~yellow~Place / Replace 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"
+
 
-				if T:getItemSlot("carrot") > 0 then
+
-					T:dropItem("carrot", direction, 64)		-- drop all but 64 carrots
+
-					found = true
+
-					crop = "minecraft:carrot"
+
 
-				if not found then
+
-					T:dropAll(direction)					-- drop everything back
+
 direction + ~blue~number ~yellow~eg ~white~f2 ~yellow~= forward ~blue~2
 
-			cropCount = T:getItemCount(crop)
+
 ~lime~l = left     ~red~r = right
 ~lightGray~u = up       ~cyan~d = down
-		if cropCount > 0 then
+
-			print("planting " ..crop)
+
 	info.sub[81] =
-		return crop, cropCount -- could be: "", 0 or "minecraft:potato", 64
+
   ~yellow~Place me on water/lava surface
 
-	function lib.goHome(R)
+
   ~yellow~Place  on left corner of area
 
 ~yellow~3.Clear ~blue~(1) sand wall
   ~yellow~Place me on the surface of sand.
 
-			lib.harvestTree(R, "forward") 		-- will only harvest if fuel below half of limit
+
-			onTree = true					-- end on dirt
+
 ]] -- Sand based utilities
-			lib.harvestTree(R, "up")			-- end on dirt
+
 [[~yellow~Turtle position ~red~> T ~gray~(~red~V ~gray~to enclose)
-		elseif T:getItemSlot("log") > 0 then-- tree just harvested
+
 ~blue~|~red~>~blue~| | | | | | ~yellow~to ~lightGray~|*|*|*|*|*|~red~V~lightGray~|~gray~ enclose
                             ~gray~*  area
 ~yellow~Side view
-				lib.harvestTree(R, "up")		-- end on dirt
+
 ~blue~| | | | | | | ~yellow~to ~lightGray~|*|*|*|*|*|*|
-				while turtle.down() do end	-- end on dirt
+
 ~blue~| | | | | | |    ~lightGray~|*|*|*|*|*|*|
 ~yellow~|S|~blue~ | | |~yellow~S|S|    |S|~lightGray~*|*|*|~yellow~S|S|
 ~yellow~|S|S|S|S|S|S|    |S|S|S|S|S|S|
-		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
+
 ~yellow~e ~lightGray~|*| | | | |*|
-				success, storage = utils.isStorage("forward")
+
 ~yellow~g ~lightGray~|*| | | | |*|
-					T:go("L2U1")
+
-					T:place("dirt", "down")
+
-					T:go("B1R1 F1D1R1")
+
-					R.ready = true
+
 
 ]] -- Create enclosed area
 	info.sub[84] =
-			-- if networked will be in air 2 blocks above barrel or stone
+
 
-			T:place("dirt", "up")
+
-			T:down(1)	 --should be on corner
+
-			for turns = 1, 4 do
+
 |*~blue~| | | | | | |~lightGray~*|
-				success, storage = utils.isStorage("down")
+
-				if storage == "modem" then
+
-					T:go("R1F1D1")
+
-					R.ready = true
+
 |*|*|*|*|*|*|*|*|  ~yellow~Width~blue~: ~yellow~6, ~orange~length~blue~:~orange~ 6
 
-				T:go("B1R1")
+
 	info.sub[85] = info.sub[56] -- Sinking platform
 	info.sub[861] =
 [[~yellow~Turtle placement  ~red~V~lime~ < ^ > ~yellow~over monument
 
 ~red~******    ******  * ~lightGray~= Avoid this area
-		return R	-- R.ready == false
+
 ******    ******  ~lime~< ^ > ~lightGray~Ideal facing~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")
+
 
-			R.config.currentPlot = coord
+
 [[~yellow~Turtle positions ~red~> ^ < V
 
 ~lightGray~|*|~red~>~lightGray~|*|*|*|*|*|~red~<~lightGray~|*|  ~red~NOT ~lightGray~corner blocks!
-	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")
+
 |~red~^~lightGray~|             |~red~^~lightGray~|  ~yellow~with stone.~lightGray~
-			R.config.currentPlot = coord
+
 ]] -- Ocean monument build retaining walls
 
 	info.sub[863] =
-	function lib.gotoTree(R)
+
 
-		if not R.networkFarm then
+
-			T:turnRight(1)							-- face storage
+
 ~lightGray~|~red~>~cyan~| *****   ***** |~red~<~lightGray~|
-		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
+
 |*|*|*|*|*|*|*|*|*|*|
-		T:go("U1F1R1")								-- move on top of wall/storage. face tree direction
+
 	info.sub[864] = info.sub[863]
-		-- 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
+
 ~green~|*|*|*|*|*~brown~|*|*|*|~red~V~brown~|*|
 ~green~|~red~>~green~|- - - - ~brown~- - - -|*|
-				if turtle.detectUp() then			-- dirt above = new tree layout
+
-					if T:getBlockType("up") == "minecraft:dirt" then
+
-						T:go("B1U2")				-- check tree in elevated position
+
 ~orange~|*|- - - - ~lime~- - - -|*| ~lightGray~6 chests / area
-						turtle.back()				-- not dirt above ? removed or lost
+
 ~orange~|*|- - - - ~lime~- - - -|*|
 ~orange~|*|- - - - ~lime~- - - -|~red~<~lime~| ~lightGray~30,000 fuel each!
 ~orange~|*|~red~^~orange~|*|*|*~lime~|*|*|*|*|*| ~lightGray~3,000 stone each!
 ]] -- Ocean monument drain and remove 1 of 4 quarters
-		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
+
  ~red~- ~blue~- ~red~- ~blue~- ~red~- ~blue~- ~red~-    ~red~- ~blue~- ~red~-~lightGray~|*|- ~blue~- ~red~-
-			T:turnRight(1)							-- facing plot storage
+
-			T:saveToLog("Dropping saplings into storage")
+
-			T:dropItem("sapling", "forward", 0)	-- drop all saplings forward into chest/barrel
+
 |*|*|*|*|*|*|*|  |*|*|*|*|*|*|*|
 
-		-- ends in field facing crops
+
 ~brown~L ~lightGray~= Ladder
 
-	function lib.harvest(R, seed, crop)
+
 	info.sub[88] =
 [[~yellow~Place ~red~T~yellow~urtle at water edge.
-		harvest crop if ripe
+
 
    ~red~T                       T
 ~lightGray~|*|*| ~blue~| | | | | | | | | | ~lightGray~|*|
-		crop is full name. if mixed seeds only one type returned
+
 |*|*| ~blue~| | | | | | | ~lightGray~|*|*|*|*|
 |*|*|*| ~blue~| | |~green~p~blue~| | ~lightGray~|*|*|*|*|*|
 |*|*|*| ~blue~| | |~green~p~lightGray~|*|*|*|*|*|*|*|
 |*|*|*|*~blue~|d~lightGray~|*|*|*|*|*|*|*|*|*|
 |*|*|*|*|*|*|*|*|*|*|*|*|*|*|
 ]] -- Clear water plants from enclosed area
 	info.sub[89] =
 [[Place me on the left corner of the top
 of retaining wall facing water
-				lib.replant(R, seed, crop)	-- check and replant crop below
+
 	info.sub[810] =
 [[Place me on the left corner of the top
 of retaining wall facing water.
-					if utils.isStorage("down") then	-- chest, barrel or modem
+
 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~| | | | | | |   |*|*|*|*|*|*|
                  |*|*|*|*|*|*|
                  |*|*|*|*|*|*|
                  |*|*|*|*|*|*|
-				lib.replant(R, seed, crop)
+
 
 ~red~> T~lightGray~ = Turtle
 
 ]] -- Build a wall
-		if utils.isStorage("down") then
+
 [[~yellow~Build a walled rectangle / house
 
 Plan view         Side view
-		lib.storeCrops(R) -- rotates from start to deposit seeds and crops, ends facing crops
+
-		return R, isFarmToRight, isFarmToFront
+
 ~yellow~e ~lightGray~|*| | | | |*|   |*|*|*|*|*|*|
 ~yellow~n ~lightGray~|*| | | | |*|   |*|*|*|*|*|*|
-	function lib.harvestTree(R, direction)
+
 ~yellow~t ~lightGray~|~red~^~lightGray~|*|*|*|*|*|  ~red~T~lightGray~|~red~T~lightGray~|*|*|*|*|*|
 ~yellow~h  ~red~^
 ~yellow~   W i d t h      ~red~^ T ~lightGray~= Turtle
 
 ]] -- Build a rectangular structure
-			Return to top of storage
+
 [[~yellow~Build a gable roof
 Gable built on right side of turtle
 Plan view       End view (width)
-		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")
+
 Plan view        End view (width)
-		print("Disposing of apples")
+
-		T:dropItem("apple", "up", 0) -- drop any apples
+
-		utils.useSticksAsFuel()
+
 ~yellow~e ~lightGray~|*| | |*|      |*|*|*|*|
-		while turtle.down() do end	-- ends facing tree, on top of plot storage
+
 ~yellow~g ~lightGray~|*| | |*|      |*|*|*|*|
 ~yellow~t ~lightGray~|*| | |*|
-	function lib.manageTree(R)
+
 ~yellow~  W i d t h     ~red~^ T ~lightGray~= Turtle
-		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,
+
 Redstone torch will go below me
 
 ~lightGray~_____
 ~lightGray~|*|*|\                           ~red~>~lightGray~|*|
     |*|~red~<                       ~lightGray~/|*|
       ~lightGray~|*|______~red~T~lightGray~_________    /~lightGray~|*|~red~!
        ~red~!~lightGray~|*|*|*|*|*|*|*|*|\ /|*|
                ~red~!        ~lightGray~|*|*|
 
 ~red~T < > ~lightGray~= Turtle ~red~! ~lightGray~= Redstone Torch
 On block or above rail, face up slope
 ]] -- Place redstone torch under block
 	info.sub[96] = info.sub[95]
 	info.sub[97] =
-			T:saveToLog("Running Tree Manager")
+
-			lib.gotoTree(R) 					-- check for sapling or harvest tree, retuns to facing crops
+
 Build down            Build up~lightGray~
 
 _____~red~T~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
+
           |*|__________~red~T~lightGray~|*|
-				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
+
 	info.sub[98] =  info.sub[97]
 
-			if not R.networkFarm then
+
 	info.sub[101] =
 [[~yellow~Place me on floor.~lightGray~
             Measured Height:
-		-- 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.")
+
   |*|*|*|
-		else	-- seed  = ""
+
-			local veg, vegCount = "", 0
+
-			if R.networkFarm then
+
-				veg, vegCount = lib.getVeg(R, "forward", crop)	-- gets any carrots / potatoes
+
 	info.sub[102] =
-				T:turnRight(1)					-- face crop chests
+
-				veg, vegCount = lib.getVeg(R, "forward", crop)	-- gets any carrots / potatoes
+
-				T:turnRight(2)					-- face crops
+
     ~red~T~lightGray~
-			if veg ~= "" then
+
-				crop = veg
+
 3|*|*|
 4|*|*|         Measured depth:
 5|*|~lime~S~lightGray~|         ~lime~5. Specific block found
-		return seed, crop	-- name of seed / "",  crop / ""
+
 7|*|*|~lightBlue~*~lightGray~|*| |   ~lightBlue~6. Obstruction below
 ]] -- measure depth
-	function lib.isCropReady(R, direction)
+
 [[~yellow~Length measurement
 
 ~lightGray~1 2 3 4 ~lime~5~lightGray~ 6 ~lime~7 ~cyan~8 ~lightBlue~9~lightGray~ 10
-		local crop, seed = "", ""
+
 ~lightGray~*|*|*|*|*|*|~lime~S~lightGray~| |*|*|  ~lime~7. Search block
 ~red~T~lightGray~                |*|  ~lightBlue~9. Obstruction
 ~lightGray~*|*|*|*|~lime~S~lightGray~|*|*| |*|*|  ~lime~5. Search block
                       ~cyan~8. No block down
 
 ~red~T ~lightGray~= Turtle
 
 ]] -- measure length
 	info.sub[104] = info.sub[88] -- measure deepest section of water
-		--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
+
 ]] -- Borehole: Analyse blocks below
-				else			-- all other crops inc Mystical Agriculture
+
-					status = data.state.age.." / 7"
+
-					if data.state.age == 7 then
+
-						isReady = true
+
 ~lightGray~| |~lime~1~lightGray~|~lime~2~lightGray~| |  |~lime~1~lightGray~| | |~lime~2~lightGray~| | | | | | ground 2
 ~lightGray~|*|~blue~W|W~lightGray~|*|  |*|~blue~W|W~lightGray~|*| |*|~blue~1~lightGray~|~blue~2~lightGray~|*| water  2
 
-			seed, crop = lib.getCropSeed(crop)
+
 ~lightGray~|~orange~1~lightGray~|~orange~2~lightGray~|~orange~3~lightGray~|~orange~4~lightGray~|                      ground 4
-		--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"
+
 	local line = menu.clear()
 	if menuLevel == 1 then -- general help
-	function lib.locateFarm(R)
+
-		T:saveToLog("? over water = false")
+
 		read()
 		return ""
-				detected = i
+
 		if info.sub[menuItem] ~= nil then -- help file exists
 			line = menu.colourText(line, info.sub[menuItem], true, true)
 			if noMenu then
-		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
+
 				end
 			else
-				success, storage = utils.isStorage("down")
+
-				T:saveToLog("i = "..i..",success = "..tostring(success)..". storage = "..storage)
+
 				return read()
-					discovered = discovered .. storage
+
-					if storage == "modem" then
+
-						R.networkFarm = true
+
 end
 
-					if storage == "" then
+
-						discovered = discovered .. "_"
+
 	options.main =
-						discovered = discovered .. "wall"
+
 		"Mining (includes Nether)",
 		"Forestry",
 		"Farming",
 		"Obsidian, Nether & End",
 		"Canal, bridge and walkway",
-			T:saveToLog("Neighbouring blocks found:"..discovered)
+
 		"Area shaping and clearing",
-		-- check discovered for patterns eg {_wall_barrel}
+
-		-- |W|*|B| * = turtle on wall
+
-		-- | | |M|
+		"Measuring tools"
-		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 mine at this level",
-			elseif discovered == "_barrel_wall" then
+
-				T:go("R2F1D1R1")
+
-			elseif discovered == "wall_barrel_" then
+
-				T:go("L1F1D1R1")
+
 		"Mine bedrock level",
-		else	-- normal storage farm
+
-			if discovered == "_chest_chest" then
+
-				T:go("F1D1R1")
+
-			elseif discovered == "chest__chest" then
+
 		"Fell Tree",
-			elseif discovered == "_chest_chest" then
+		"Create tree farm",
-				T:go("R2F1D1R1")
+
-			elseif discovered == "chest_chest_" then
+
-				T:go("L1F1D1R1")
+
 		"Harvest and replant forest"
 	})
 	table.insert(options,
 	{
 		"Create modular crop farm",
-				success, storage = utils.isStorage("forward")	-- true/false, chest, barrel, modem / ""
+
-				if success and storage == "modem" then
+		"Plant, harvest or manage crop farm",
-					R.networkFarm = true
+
 		"Fence or wall an enclosure"
 	})
 	table.insert(options,
-			R.ready = true
+
 		"Dig obsidian field",
 		"Build Nether Portal",
 		"Demolish Nether Portal",
-	function lib.plantCrop(R, seed, crop, direction)
+
 		"Undermine Dragon Towers",
 		"Deactivate Dragon Tower",
 		"Build dragon water trap",
 		"Build portal ladder & platform",
 		"Shulker harvester"
-		--T:saveToLog("lib.plantCrop(R, seed = "..seed..", crop = "..crop)
+
 	table.insert(options,
-		-- 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))
+
 		"Platform",
-			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))
+
 	table.insert(options,
-		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))
+
 		"Create mob bubble lift",
-		return success
+
 		"Build Endermen observation tower"
 	})
-	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
+
 		"Place a floor or ceiling",
 		"Direct control of movement"
-		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
+
 		"Clear volume of water",
 		"Sinking platform",
-		-- 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)
+
 		"Build a wall",
-			while T:suck("down") do end					-- empty out barrel/chest to find crafting table
+
 		"Build a gable end roof",
 		"Build a pitched roof",
 		"Place Redstone:torch level track",
 		"Place Redstone:torch upward track",
 		"Build downward track",
-			if R.networkFarm then
+
-				network.sendItemToNetworkStorage(R, "barrel", "minecraft:diamond_hoe", 1)
+
 	table.insert(options,
 	{
 		"Measure height",
-					T:drop("down", i)	-- into water if networked, buried chest otherwise
+
 		"Measure length",
 		"Measure greatest depth",
 		"Borehole: Analyse blocks below"
 	})
 
 	return options
 end
 
-			while logSlot > 0 and turtle.getFuelLevel() < turtle.getFuelLimit() do
+
 	local options = {}
-				turtle.refuel()						-- refuel using planks
+
 	{
 		colors.lightGray, 	-- Mining (includes Nether)
-			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.lightGray, 	-- Mob farm tools
-			if not T:equip("right", "minecraft:diamond_hoe") then		-- re-equip hoe/remove crafting table
+
 		colors.blue, 		-- Lava and Water
 		colors.cyan,		-- Railway
-			if R.networkFarm then
+		colors.purple 		-- Measuring tools
-				network.sendItemToNetworkStorage(R, "barrel", "minecraft:crafting_table", 1)
+
 	table.insert(options,
-				T:dropItem("minecraft:crafting_table", "down")
+
 		colors.brown, 		-- Ladder up or down
 		colors.lightGray, 	-- Stairs up or down
 		colors.lightGray, 	-- Create mine at this level
 		colors.blue, 		-- Safe drop to water block
 		colors.blue, 		-- Single column bubble lift
 		colors.magenta, 	-- QuickMine corridor system
 		colors.pink, 		-- QuickMine rectangle
-	function lib.storeCrops(R)
+
-		-- place crops and seeds into chests. starts facing crops
+
 	})
 	table.insert(options,
-		if R.networkFarm then
+
-			network.emptyInventory(R, {"sapling", "diamond_hoe", "crafting"}, {"all"}, true)
+
 		colors.lightGray, 	-- Create tree farm
-			T:turnRight(1)	-- face seed storage
+
-			lib.storeSeeds(R, "forward")
+
 		colors.brown, 		-- Fence or wall an enclosure
-			if utils.isStorage(direction) then
+
-				T:dropAll(direction) -- drops everything including essences
+
 	table.insert(options,
-			T:turnRight(2) -- facing crops again
+
 		colors.yellow, 		-- Create modular crop farm
 		colors.green, 		-- Extend modular crop farm
 		colors.lime, 		-- Manage modular crop farm
-	function lib.storeSeeds(R, direction)
+
 		colors.brown 		-- Build rectangle wall or fence
-		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.blue, 		-- Build dragon water trap
-				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.lightGray, 	-- Continuous path
 		colors.gray, 		-- Covered walkway / tunnel
 		colors.blue, 		-- Water canal
 		colors.lightBlue, 	-- Ice canal (4 options)
 		colors.brown, 		-- Platform
-	function lib.watchFarm(R)
+
 		colors.cyan 		-- Boat bubble lift
 	})
 	table.insert(options,
 	{
 		colors.brown, 		-- Cube around spawner (NOT blaze)
-		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.blue, 		-- Create mob bubble lift
 		colors.brown, 		-- Dig mob drop trench
 		colors.gray 		-- Build Endermen observation tower
 	})
 	table.insert(options,
 	{
 		colors.lime, 		-- Clear field (inc trees)
 		colors.magenta, 	-- Clear a rectangle (+ u/d opt)
 		colors.pink, 		-- Clear single wall up/down
-					if crop:find("mysticalagriculture") ~= nil then
+
-						R.mysticalAgriculture = true
+
 		colors.orange, 		-- Clear solid structure up/down
 		colors.brown, 		-- Dig a trench
 		colors.gray, 		-- Carve mountain side
-				isReady, crop, seed, status, R = lib.isCropReady(R, "forward")			-- eg true, "minecraft:carrots", "7 / 7" or false, "", ""
+
 		colors.red 			-- Direct control of movement
-		until isReady
+
-		T:saveToLog("Local crops ripe", true)
+
-		seed, crop = lib.manageTree(R) -- "", "" or name of seed, crop
+
-		return seed, crop
+
 		colors.blue, 		-- Vertical wall from surface
 		colors.blue, 		-- Create enclosed area
 		colors.cyan, 		-- Clear volume of water
-		ENTRY POINT**********************************************
+
 		colors.orange, 		-- Ocean monument utilities
 		colors.brown, 		-- Ladder down to water/lava
 		colors.green, 		-- Clear water plants
 		colors.lightBlue, 	-- Convert all water to source
 		colors.blue 		-- Create sloping water
 	})
 	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
+
 		colors.red, 		-- Place Redstone:torch level track
-	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
+
 	table.insert(options,
-	if not R.ready then		-- not in correct starting place
+
-		R = lib.goHome(R)
+
-		if not R.ready then -- try to find home
+
 		colors.magenta, 	-- Measure length
 		colors.pink, 		-- Measure greatest depth
 		colors.lightBlue	-- Borehole: Analyse blocks below
 	})
 
-				"barrel or chest to my right and behind",
+
-				"(or modem behind if networked farm)"
+
 
 local function chooseTask(R)
 --[[
-	if not T:isEmpty() then		-- items in turtle inventory
+
-		local logSlot = T:getItemSlot("log")
+
 	coloured menu:
-			if R.networkFarm then
+
-				lib.refuelWithLogs(R, logSlot) 	-- use any logs for fuel
+
 		prompt = colors.green,
-				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
+
 	choice, modifier = menu.menu or menu.new("Choose your option", options, pp)
 	]]
-		if not T:isEmpty() then					-- still items in turtle inventory
+
-			lib.storeCrops(R)
+
 	function lib.getHelp(choice, itemsRequired, pp)
 		local listOfItems = itemsRequired[choice]
-	-- 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
+
 			lib.showItems(listOfItems)
-	if hoeSlot == 0 then		-- hoe not in inventory
+
-		local message
+
-		hoeSlot, message = lib.getHoe()
+
-		if message ~= "" then
+
-			return {message}
+
 		if option == 2 then
 			choice = -2	-- return to subMenu
-	-- 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")
+
 	end
-	else	-- hoe not present: return to start and exit
+
-		if not R.networkFarm then
+
-			T:go("B1R1")
+
 		if next(listOfItems) ~= nil then
 			menu.colourPrint("Items required:", colors.lime)
 			for k,v in pairs(listOfItems) do
 				menu.colourPrint("  "..v, colors.lightGray)
 			end
-	local isFarmToRight, isFarmToFront = false, false
+
-	local isReady, crop, seed, status
+
-	isReady, crop, seed, status, R = lib.isCropReady(R, "forward")
+
 		menu.colourWrite("Enter to continue", colors.yellow, colors.black, nil, true)
-	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
+
 
-			watch = false	-- not watching, continue with planting
+
 		if subChoice > 9 then -- need more than 9 sub-options
 			choice = subChoice + (choice * 100) -- 10 = 10 + 1000 = 1100
 		else -- eg main option 1 (mining), sub-option 1 (create mine) = 1 + 10 = 11
-		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
+
 	end
-		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)
+
 	local prompt = "Choose an option"
-			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
+
 	local menuState = 0 -- use main menu
-				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
+
 		menu returns choice=nil if user enters just q or h
 		menu returns choice=2, modifier = "h" if 2h entered
 		Mining (includes Nether)		white
 		Forestry						lime
 		Farming							lime
 		Obsidian, Nether & End Portal	brown
 		Canal, bridge and walkway		pink
 		Mob farm tools					gray
 		Area shaping and clearing		purple
 		Lava and Water					blue
 		Railway							magenta
 		Measuring tools					cyan
 		]]
 
 		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
-	--local pp = utils.getPrettyPrint()
+
-	local choices = {"Plant or harvest this farm complex"}	-- 1.
+
 					R.choice = -1
 					return R
 				elseif index == 0 then
-		table.insert(choices, "Disable automatic farm management") -- 2.
+
 					menuState = 0 -- if R.choice reset to 0 then back to main menu
-		table.insert(choices, "Enable automatic farm management") -- 2.
+
 			end
 			if subChoice ~= nil then
-	if not R.networkFarm then
+
-		table.insert(choices, "Convert to Network Storage")		-- 3.
+
-		table.insert(pp.itemColours, colors.magenta)
+
 		end
-	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 function getTask(R)
 	-- Called from main(): R = getTask(R)
 	local lib = {}
 
 	function lib.isAutoHelp(choice, noAutoHelp)
 		for _, v in ipairs(noAutoHelp) do
 			if choice == v then
 				return true
 			end
 		end
 		return false
 	end
-	elseif R.subChoice == 2 then -- enable/disable auto farm
+
 	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
 		local currentLevel = menu.getInteger("Current level (F3->Y coord)? ", bedrock + 5, ceiling, nil, colors.lightGray)
 		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
-	--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
+
 						 "On ceiling, move forward to start"}
-		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
+
 		R.width 	= menu.getInteger("Width (2-64 default 17) ", 2, 64, nil, colors.yellow, nil, 17)
-		T:checkInventoryForItem({"stone"}, {16})
+
-		T:checkInventoryForItem({"dirt"}, {2})
+
 		if mcMajorVersion >= 1.18 then
-		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")
+
 						 "On ceiling, move forward to start",
-			T:checkInventoryForItem({"wired_modem_full"}, {2})
+
-			T:checkInventoryForItem({"computercraft:cable"}, {57})
+
-			return createFarm(R, "convert")
+
 		if modifier == "q" then -- quit chosen
-	--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)
+
 		R.subChoice = userChoice
 	elseif R.choice == 18 then -- Mine bedrock area
 		--getTaskHelp(2, R.choice, true)
 		--menu.clear()
 		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)
 		if menu.getBoolean("Leave bedrock exposed? (y/n) ", nil, colors.yellow) then
 			R.data = "leaveExposed"
 		end
 	elseif R.choice == 19 then -- salvage mine shaft
 		R.torchInterval = menu.getInteger("Torch spacing? (0-64)", 0, 64, nil, colors.red)
 -- 02. FORESTRY
 	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
-		T:place(R.useBlockType, "forward", false)
+
 		R.length  	= menu.getInteger("Length of the area (1-64)", 1, 64, nil, colors.orange)
-		T:place("minecraft:redstone_torch", "forward", true)
+
 			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)
 		end
 	elseif R.choice == 73 then -- Clear wall
 		R.width 	= 1
 		R.length 	= menu.getInteger("Length of wall (1-256) ", 1, 256, nil, colors.orange)
-		T:place("minecraft:redstone_torch", "up", false)
+
 		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
-	-- already known R.networkFarm, R.subChoice (1 = singe, 2 = double, 3 = mangrove)
+
-	--T:place(blockType, damageNo, leaveExisting, signText)
+
 				T:forward(1)
 			elseif choice == 4 then
-	function lib.checkSaplings(firstChoice, secondChoice)
+
 			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
 			R.up = true
 		end
 		if menu.getBoolean("Remove blocks below? (y/n)", 4, colours.red) then
 			R.down = true
-	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)
+
 		if R.choice == 75 then -- hollow building so need to check if floors/ceilings to be removed
 			R.data = {}
 			R.data.ceiling = false
-	function lib.getSaplingInventory(R)
+
 			if menu.getBoolean("Remove ceiling? (y/n)", nil, colors.yellow, colors.black) then
 				R.data.ceiling = true
 			end
 			if menu.getBoolean("Remove floor? (y/n)", nil, colors.orange, colors.black) then
 				R.data.floor = true
 			end
 		end
-		saplings.cherry_sapling = 0
+
-		saplings.mangrove_propagule = 0
+
 		if R.subChoice == 1 then
 			if menu.getBoolean("Am I outside clearing zone (y/n)?", nil, colors.yellow) then
 				T:forward(1)
 			end
 		else
-		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
+
 				T:go("D1F1")
 			end
 		end
-		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
+
 						"New floor over existing",
 						"Replacing current ceiling",
-				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")
+
 		R.height = menu.getInteger({"Enter 0 for on-site placement",
-				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)
+
 			R.width 	= menu.getInteger("Width of floor (1-64) ", 1, 64, nil, colors.yellow)
-				if turtleCount == 0 then	-- ask player
+
-					T:checkInventoryForItem({"minecraft:dirt"}, {16}, true, "Dirt required for tree farm")
+
 			R.up = true
-				return saplings, R.useBlockType, R.useBlockType
+
 			R.length  	= menu.getInteger("Length of ceiling (1-64) ", 1, 64, nil, colors.orange)
 		end
 	elseif R.choice == 710 or R.choice == 83 then -- Direct movement
 		local choices = {"Simple path", "Covered 2 block high path"}
 		pp.itemColours = {colors.lime, colors.orange}
 		local userChoice = menu.menu("Choose your path option", choices, pp, "Type number + Enter ")
 		R.subChoice	= userChoice -- 1 open, 2 covered
 		choices = {"Command driven", "Menu driven"}
 		userChoice = menu.menu("Choose your preference", choices, pp, "Type number + Enter ")
 		if userChoice == 1 then
 			R.data = "cmd"
 		else
 			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
-			T:place("dirt", "down", false, "", true)
+
 		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
-				T:place(sapling, "down", false, "", true)
+
 			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 ")
-				T:place(sapling, "down", false, "", true)
+
 				R.data = "return"
 			end
 		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
 		end
 		if menu.getBoolean("Am I outside the active zone (y/n)?", nil, colors.yellow) then
 			T:forward(1)
 		end
 	elseif R.choice == 82 then -- build wall from water or lava surface downwards
 		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()
-		T:place("dirt", "down", false, "", true)
+
 			R.data = "withPath" -- ensures turtle will break through path
-		if not T:place(sapling, "down", false, "", true) then -- try specific sapling
+
-			T:place("sapling", "down", false, "", true)		-- any available sapling
+
 		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
 			R.length = menu.getInteger("Length of water", 1, 64, nil, colors.orange)
 		end
 		R.height 	= menu.getInteger("Depth of water (0=autodetect)", 0, 64, nil, colors.blue)
 	elseif R.choice == 85 then -- 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})
+
 			"Build 4 corner marker columns",
 			"Retaining wall beween 2 columns",
-		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")
+
 			"Sinking platform",
 			"Drain and remove structure"
 		}
-	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()})
+
 		menu.clear()
-		--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
+
 			T:clear()
 			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)
-			if x % 2 == 1 then
+
-				if x < 5 then
+
 			R.data = "clearWaterPlants"
 			R.silent = true
 			R.width 	= menu.getInteger("water width (0=auto detect) ", 0, 64, nil, colors.yellow)
 			R.length  	= menu.getInteger("water length (0=auto detect) ", 0, 64, nil, colors.orange)
 		elseif R.subChoice == 4 then -- Drain using sand utilities
 			R.width	  = 1
-		T:go("L1F2 L1F2 D2U2 F7R2 D2")
+
 		elseif R.subChoice == 5 then -- remove sand wall using sand utilities
-		T:place("propagule", "down")	-- left 1
+
 			R.length  = 0
-		T:place("propagule", "down")	-- left 2
+
 			R.width = menu.getInteger("Width (excluding retaining wall)? ", 1, 1024, nil, colors.yellow)
-		T:place("propagule", "down")	-- left 3/top 1
+
 			R.height = menu.getInteger("Levels to go down?", 1, 1024 / R.width * R.length, nil, colors.blue)
-		T:go("R1F1")
+
-		T:place("propagule", "down")	-- top 2
+
 			R.length = 28
-		T:place("propagule", "down")	-- top 3/right 1
+
-		T:go("R1F1")
+
 	elseif R.choice == 87 then -- Ladder to water/lava
-		T:place("propagule", "down")	-- right 2
+
 	elseif R.choice == 88 then -- Clear water plants from enclosed area
-		T:place("propagule", "down")	-- right 3/bottom 1
+
-		T:go("R1F1")
+
-		T:place("propagule", "down")	-- bottom 2]]
+
 	elseif R.choice == 89 then -- convert flowing water to source
-		--T:go("R1F1R2 D2U2 F7R2 D2")
+
 		if R.width > 0 then
 			R.length = menu.getInteger("water length (0=auto detect) ", 0, 64, nil, colors.orange)
-	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
+
 
-				T:go("U1F4") -- outside first area
+
 	elseif R.choice == 91 then -- Build wall
-			for i = 1, 3 do	-- column 1/4
+
-				lib.createSingle(sapling, "forward")
+
 		R.height 	= menu.getInteger("Height of wall (1-50) ", 1, 50, nil, colors.lightGray)
 		pp.itemColours = {colors.lime, colors.magenta}
-			for i = 1, 2 do
+
-				lib.createSingle(sapling, "right") -- place 4th dirt/saling and exit to right
+
 		R.width 	= menu.getInteger("Building width (1-256)", 1, 256, nil, colors.yellow)
 		R.length 	= menu.getInteger("Building length (1-256) ", 1, 256, nil, colors.orange)
-			for i = 1, 2 do -- column 2/4
+
-				lib.createSingle(sapling, "forward")
+
 		R.subChoice = menu.menu("What is my current position?", {"Outside building: Start ahead","Within the walls: start here"}, pp, "Type number + Enter")
 	elseif R.choice == 93 or R.choice == 94 then -- Build gable roof / pitched roof
-			for i = 1, 2 do
+
-				lib.createSingle(sapling, "left") -- place 4th dirt/saling and exit to right
+
 	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 -- column 3/4
+
-				lib.createSingle(sapling, "forward")
+
 		R.height  	= menu.getInteger("Go up by how many blocks?", 1, 256, nil, colors.lightGray)
 		R.up = true
-			for i = 1, 2 do
+
-				lib.createSingle(sapling, "right") -- place 4th dirt/saling and exit to right
+
 	elseif R.choice == 101 then -- measure height
 		pp.itemColours = {colors.lightBlue, colors.cyan, colors.lime, colors.gray}
-			for i = 1, 3 do -- column 4/4
+
-				lib.createSingle(sapling, "forward")
+
 			R.data = menu.getString({"Search for? eg 'ore', 'obsidian'",">"}, false, 3, 20, nil, {colors.lime, colors.yellow})
 		end
-			if R.networkFarm then
+
-				T:go("R1F3 R1F2L1") -- in-between 2 trees
+
-				if R.auto then
+
-					harvestTreeFarm(R)
+
 		if R.subChoice == 3 then
-					T:go("L1F4R2D1")
+
 		end
 	elseif R.choice == 103 then -- measure length
-				T:go("R1F6 L1F2 R2D1")
+
 		R.subChoice	= menu.menu("Measure using?", {"Obstruction ahead",
 													"No further blocks above",
-			return "No saplings to plant"
+
 													"Detect specific block above",
 													"Detect specific block below"}, pp, "Type number + Enter") -- open direction menu options
 		if R.subChoice == 4 or R.subChoice == 5 then
 			R.data = menu.getString({"Search for? eg 'ore', 'obsidian'",">"}, false, 3, 20, nil, {colors.lime, colors.yellow})
 		end
-	function lib.plantDouble(R)
+
 	elseif R.choice == 104 then -- measure greatest depth of water body
 		pp.itemColours = {colors.lime, colors.orange}
 		R.subChoice	= menu.menu("Measure using?", {"Player entered", "No further water below"}, pp, "Type number + Enter ") -- open direction menu options
 		-- 1 = player entry, 2 = water length
-			if R.networkFarm then
+
-				T:go("U1L1 F3R1 F3") -- outside first area
+
 		end
-				T:go("U1F3") -- outside first area
+
 		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)
-			sapling, count = lib.checkSaplings(firstChoice, secondChoice)
+
 
 	return R
-			sapling, count = lib.checkSaplings(firstChoice, secondChoice)
+
 
 local function getTaskInventoryTo30(R)
-			sapling, count = lib.checkSaplings(firstChoice, secondChoice)
+
 	local thanks = "Thank you.\n\nPress the ESC key\n\nStand Back..\n"
 	--local pp = utils.getPrettyPrint()
 
-			if R.networkFarm then
+
-				T:go("R1F4 R1F1 L1") 			-- on left side of double tree
+
-				if R.auto then
+
-					harvestTreeFarm(R)
+
 	elseif R.choice == 1 then --Missing crafting table
-					T:go("L1F4 L1F1 L1D1")	-- back to start
+
 		print("Crafting table being tested...")
 		T:setEquipment()
-				T:go("R1D1 F6L1 F3R2") -- outside first area
+
 		T:checkInventoryForItem({"minecraft:chest"}, {1}) -- 0 if not present
 		sleep(1.5)
-			return "Insufficient saplings to plant"
+
 	-- MINING
 
 	elseif R.choice == 11 or R.choice == 12 then			-- ladder down / up / stairs down / stairs up
 		local description = "Creating ladder going down"	-- default action description
-	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)
+
 
-	if R.subChoice == 3 then	-- mangrove, R.networkFarm only
+
-		lib.getMangroveSupplies()
+
-		lib.plantMangrove()
+
 		end
-		local saplings, firstChoice, secondChoice = lib.getSaplingInventory(R)
+
-		if firstChoice ~= "" then
+
-			print("first sapling: "..firstChoice .. " ("..saplings[firstChoice]..")")
+
 			R.height = menu.getInteger("Current level (F3->Y coord)? ", bedrock + 5, ceiling, nil, colors.lightGray)
-		if secondChoice ~= "" then
+
-			print("second sapling: "..secondChoice .. " ("..saplings[secondChoice]..")")
+
 				if menu.getBoolean("Build a shelter at base? (y/n) ", nil, colors.yellow, colors.black) then
 					R.data = "chamber"
-		-- check type/size of farm
+
 			end
-		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
+
 			R.up = true
 			--R.depth = utils.getSize(true,"Current level (F3->Y coord)? ", bedrock + 5, ceiling)
-	if R.networkFarm then
+
-		lib.emptyInventory(R)
+
 			R.height = menu.getInteger("Go up to level? ("..R.depth + 2 .." to "..ceiling ..") ", R.depth + 2, ceiling, nil, colors.lightGray)
-	return {message}
+
 				description = "Creating ladder going up"
 			else
 				description = "Creating stairs going up"
 			end
 		end
 		local range = math.abs(R.height - R.depth)
 
 		if not inAir then
 			inAir = menu.getBoolean("Are you in air (add blocks)? (y/n) ", nil, colors.yellow, colors.black)
 		end
 		--[[
 		range examples
 		-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)
-	text[15] = {"1 soul sand", "3 water bucket", "levels * 4 stone", "1-9 buckets (optional)",
+
-				"2 signs if no ladder present"} 														-- single column bubble lift
+
 		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})
-				"2 water buckets","192 fence","8 signs","3 ladder","2 soul sand"}						-- build endermen observation tower
+
-	text[67] = {"24 blocks of any type"}																-- Cover Trial spawners to prevent mobs escaping
+
 		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})
 		T:checkInventoryForItem({"chest", "barrel"}, {5,5})
 		T:checkInventoryForItem({"sapling"}, {1})
 		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
-	[[           ~yellow~NETWORK TOOLS:
+
-Still on ToDo List!
+
 		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
 		return getTaskInventoryTo30(R) -- Mining, Forestry
 	elseif R.choice < 71 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
+
 			sleep(2)
 			print("Clearing area: size "..R.width.. " x "..R.length)
-[[~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)
+
 			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()
 			retValue = createFloorCeiling(R) -- R.subChoice integer 1 to 4
 		elseif R.choice == 710 then -- direct commands
-~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
+
 					print("Building sand wall. Auto length: ")
 				else
-[[~yellow~Place on any ~brown~T ~blue~T ~magenta~T~yellow~ facing < > ^ v
+
 				end
-~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
+
 					print("Digging sand. Auto length")
 				else
-[[~yellow~Place as below ~blue~T~yellow~ facing < > ^ v
+
 				end
-~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
+
 			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)
 			menu.colourPrint(tostring(value), clr[count])
 			count = count + 1
-	info.sub[67] =
+
-[[Turtle moves toward spawner
+
-Place at spawner level.
+
 		end
-Can be behind a wall for protection
+
-of player.
+
 	end
-Embeds in wall with attack working
+
 
-Needs 24 blocks
+