Skip to content

Instantly share code, notes, and snippets.

@MacChuck

MacChuck/cc-tclear.lua

Last active August 27, 2024 04:18
Show Gist options
  • Save MacChuck/4f68db3f5943015a8ae3c5e5487969f5 to your computer and use it in GitHub Desktop.
Save MacChuck/4f68db3f5943015a8ae3c5e5487969f5 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
cc-tclear.lua
--{program="tClear",version="1.00",date="2021-03-28"}
---------------------------------------
-- tClear by Kaikaku
-- 2021-03-28, v1.00 three-way digging
-- 2016-03-13, v0.90 dig on way back
-- 2014-09-27, v0.80 dig sand
-- 2013-09-01, v0.10 initial
---------------------------------------
---------------------------------------
---- DESCRIPTION ----------------------
---------------------------------------
-- Mining turtle digs specified cuboid
-- (x,y,z) without leaving the area,
-- using tripple dig :)
-- Incl. option to missus as strip miner.
---------------------------------------
---- ASSUMPTIONS ----------------------
---------------------------------------
-- Requires a mininng turtle
---------------------------------------
---- VARIABLES: template --------------
---------------------------------------
local cVersion ="v1.00"
local cPrgName ="tClear"
local cMinFuel =110
local blnAskForParameters =true
local blnShowUsage =false
local blnDebugPrint =false--true
local blnTurtle
local isComputer =false
local baseColor=colors.blue
---------------------------------------
---- VARIABLES: specific --------------
---------------------------------------
local slotFuel=16
local digDeep=3 -- all but 0 are okay
local digWide=3 -- all but -1,0,1 -- if wide <=-1 then depth needs to be >=2
local digHeight=1 -- all but 0
local digWideOrg
local digDeepOrg
local blnLayerByLayer=false
local blnStartWithin =false
local blnStripMine =false
---------------------------------------
---- Early UI functions ---------------
---------------------------------------
local function swapColors()
local backColor=term.getBackgroundColor()
local textColor=term.getTextColor()
term.setBackgroundColor(textColor)
term.setTextColor(backColor)
end
local function printUI(strInput)
if strInput==ni then strInput="" end
if strInput=="header" then
term.write("") swapColors() print("") swapColors()
elseif strInput=="line" then
term.write("") swapColors() print("") swapColors()
elseif strInput=="footer" then
term.write("") print()
else
term.write("")
strInput=strInput.." "
term.write(string.sub(strInput,1,37))
swapColors() print("") swapColors()
end
end
local function coloredTextAt(inputText,outputRow,outputCol,textColor,backColor)
-- writes and colors text to coordinates
local oldRow, oldCol = term.getCursorPos()
local oldTextColor=term.getTextColor()
local oldBackColor=term.getBackgroundColor()
if textColor==nil then textColor=term.getTextColor() end
if backColor==nil then backColor=term.getBackgroundColor() end
term.setTextColor(textColor)
term.setBackgroundColor(backColor)
term.setCursorPos(outputRow,outputCol)
term.write(inputText)
term.setCursorPos(oldRow, oldCol)
term.setTextColor(oldTextColor)
term.setBackgroundColor(oldBackColor)
end
---------------------------------------
---- tArgs ----------------------------
---------------------------------------
local tArgs = {...}
term.clear() term.setCursorPos(1,1)
local parameterShowSleep=1
if #tArgs~=0 then
-- header
blnAskForParameters=false
term.clear() term.setCursorPos(1,1)
printUI("header")
printUI(""..cPrgName..", "..cVersion..", by Kaikaku. Enjoy!")
printUI("line")
coloredTextAt(cPrgName,2,2,baseColor)
print("Starting...")
if tArgs[1]~=nil then
digDeep=math.floor(tonumber(tArgs[1]))
if digDeep<=0 then
print("Parameter correction (depths must be >=1)!")
sleep(2)
parameterShowSleep=parameterShowSleep+2
digDeep=1
end
end
if tArgs[2]~=nil then
digWide=math.floor(tonumber(tArgs[2]))
if digWide==0 or digWide==1 or digWide==-1 then
print("Parameter correction (width not 0 or 1)!")
sleep(2)
parameterShowSleep=parameterShowSleep+2
digWide=2
end
end
if tArgs[3]~=nil then
digHeight=math.floor(tonumber(tArgs[3]))
if digHeight==0 then
print("Parameter correction (height not 0)!")
sleep(2)
parameterShowSleep=parameterShowSleep+2
digHeight=1
end
end
--check combinations of min values
if digDeep==1 and digWide<0 then
error("Parameter combination not allowed: depth=1 with width<0! Hint: increase depths or move turtle to use positive width.")
end
-- further parameters 4+
for i=4,#tArgs,1 do
if string.lower(tArgs[i])=="layerbylayer" or string.lower(tArgs[i])=="layer" or string.lower(tArgs[i])=="singlelayer" then
blnLayerByLayer=true
end
if string.lower(tArgs[i])=="startwithin" or string.lower(tArgs[i])=="within" or string.lower(tArgs[i])=="in" then
blnStartWithin=true
end
if string.lower(tArgs[i])=="stripmine" or string.lower(tArgs[i])=="strip" or string.lower(tArgs[i])=="mine" then
blnStripMine=true
end
end
-- show parameters
print("Clear depth = "..digDeep)
print("Clear width = "..digWide)
print("Clear height= "..digHeight)
term.write("Option LayerByLayert= ") if blnLayerByLayer then print("on") else print("off") end
term.write("Option StartWithin = ") if blnStartWithin then print("on") else print("off") end
term.write("Option StripMine = ") if blnStripMine then print("on") else print("off") end
sleep(parameterShowSleep)
end
if blnShowUsage then
term.clear() term.setCursorPos(1,1)
printUI("header")
printUI(""..cPrgName..", by Kaikaku")
printUI("footer")
print("Usage: ",cPrgName," depth, width [height ['LayerByLayer'] ['StartWithin'] ['StripMine']] ")
print()
print("If called with any parameter, then")
print(" there will be no info screen. Turtle")
print(" starts immediately.")
return
end
---------------------------------------
-- basic functions for turtle control -
---------------------------------------
-- 2021-03-28 partly tPos (from tClear)
-- 2021-03-20 arrangeArray, printArray (from tLoader)
-- 2021-03-13 askForNumber, pressKeyNoSpecials, checkInventory(u), getFirstEmptySlot, identifyTool, findModem, ensureModem
-- 2021-03-05 gfr -
-- 2021-02-06 select+place -
-- 2021-01-29 save turtle go func -
-- checkInventory w/ exit -
-- refuelManager -
---------------------------------------
local function gf(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.forward() do end end end
local function gb(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.back() do end end end
local function gu(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.up() do end end end
local function gd(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.down() do end end end
local function gl(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.turnLeft() do end end end
local function gr(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.turnRight() do end end end
local function df() turtle.dig() end
local function du() turtle.digUp() end
local function dd() turtle.digDown() end
local function dfs() while turtle.dig() do end end
local function dus() while turtle.digUp() do end end
local function dds() while turtle.digDown() do end end
local function pf() return turtle.place() end
local function pu() return turtle.placeUp() end
local function pd() return turtle.placeDown() end
local function sf() turtle.suck() end
local function su() turtle.suckUp() end
local function sd() turtle.suckDown() end
local function Df() turtle.drop() end
local function Du(n) turtle.dropUp(n) end
local function Dd() turtle.dropDown() end
local function ss(s) turtle.select(s) end
local function gic(s) return turtle.getItemCount(s) end
local function gfs(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.forward() do df() end end end
local function gbs(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.back() do gl() gl() df() gr() gr() end end end
local function gus(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.up() do du() end end end
local function gds(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.down() do dd() end end end
local function pfs() df() turtle.place() end
local function pus() du() turtle.placeUp() end
local function pds() dd() turtle.placeDown() end
local function gfr() return turtle.forward() end
local function gbr() return turtle.back() end
local function gur() return turtle.up() end
local function gdr() return turtle.down() end
local tPos={}
local function glPos(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.turnLeft() do end end end --tPos[4]=(tPos[4]-1)%4 end end
local function grPos(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.turnRight() do end end end --tPos[4]=(tPos[4]+1)%4 end end
local function gfPos(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.forward() do df() end end end --pCF(1) end end
local function gbPos(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.back() do gl() gl() df() gr() gr() end end end--pCF(-1) end end
local function guPos(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.up() do du() end tPos[3]=tPos[3]+1 end end
local function gdPos(n) if n==nil then n=1 end for i=1,n,1 do while not turtle.down() do dd() end tPos[3]=tPos[3]-1 end end
local function spd(s,blnForward)
if s==nil then s=turtle.currentSlot() end
if blnForward==nil then blnForward=true end
ss(s) pd() if blnForward then gf() end
end
local function spu(s,blnForward)
if s==nil then s=turtle.currentSlot() end
if blnForward==nil then blnForward=true end
ss(s) pu() if blnForward then gf() end
end
local function spf(s,blnBack)
if s==nil then s=turtle.currentSlot() end
if blnBack==nil then blnBack=true end
ss(s) pf() if blnBack then gb() end
end
local function waitKey(strText)
local event, scancode
write(strText)
event, scancode = os.pullEvent("key")
print()
end
local function askForInputText(textt)
local at=""
-- check prompting texts
if textt==nil then textt="Enter text:" end
-- ask for input
write(textt)
at=read()
return at
end
local function askForNumber(askText, minValue, maxValue)
-- gets entered data, ensures it's a number and returns it
-- keeps asking if entry is not a number
-- adapts to min and max values
-- allways writes in screen line 13 (last for turtles)
-- calls askForInputText
local blnReask=true
local returnNumber=nil
if minValue==nil then minValur=1 end
if maxValue==nil then maxValue=100 end
if askText==nil then askText="Key in number and press Enter: " end
while blnReask do
term.setCursorPos(1,13)
returnNumber=askForInputText(askText)
if returnNumber==nil then
blnReask=true
else
returnNumber=tonumber(returnNumber)
if returnNumber==nil then
blnReask=true
else
returnNumber=math.floor(returnNumber)
if returnNumber>maxValue then returnNumber=maxValue end
if returnNumber<minValue then returnNumber=minValue end
blnReask=false
end
end
end
return returnNumber
end
local function pressKeyNoSpecials(askText)
-- excludes ctrl / alt / shifts
-- catches windows
-- retruns the key number (if needed at all)
local tmpEvent, tmpKey
if askText==nil then askText="Press key to START! (stop w/ ctrl+t) " end
tmpKey=341
while tmpKey>=340 and tmpKey<=346 do -- ctrls, alts, shifts
term.write(askText) tmpEvent, tmpKey = os.pullEvent("key")
if tmpKey==nil then tmpKey=341 end -- win
end
return tmpKey
end
local function checkFuel()
local tmp=turtle.getFuelLevel()
return tmp
end
local function checkTurtle(blnOnlyIdentify)
if blnOnlyIdentify==nil then blnOnlyIdentify=false end
-- turtle?
local turtleOk, turtleVal = pcall(checkFuel)
if not turtleOk then
blnTurtle=false
if not blnOnlyIdentify then
term.clear() term.setCursorPos(1,1)
printUI("header")
printUI(""..cPrgName..", "..cVersion..", by Kaikaku ("..iPage.."/"..iPageMax..")")
printUI("line")
printUI("This is a turtle program.")
printUI(" Please, execute it with a turtle!")
printUI("footer")
coloredTextAt(cPrgName,2,2,baseColor)
error()
end
else
blnTurtle=true
end
end
local function sleepDots(sec, duration)
if sec==nil then sec=10 end
if sec<1 then return end
if duration==nil then duration=1 end -- shorten durtation for more dots
for i=1,sec-1 do
sleep(1*duration)
term.write(".")
end
sleep(1)
print(".")
end
local function checkInventory(s, nMin, nMax, textt, blnExitOnFalse, blnRepeat)
-- checks if in slot s are not less than nMin and not more than nMax items
-- returns true if okay
-- if not displays textt
-- blnExitOnFalse=true raises an error
-- blnRepeat=true repeatedly sks to put in the right number of items (overrides blnExitOnFalse)
local oldSlot = turtle.getSelectedSlot()
if s==nil then s=turtle.getSelectedSlot() end
if nMin==nil then nMin=0 end
if nMax==nil then nMax=64 end
if blnExitOnFalse==nil then blnExitOnFalse=false end
if blnRepeat==nil then blnRepeat=false end
if blnRepeat~=true then blnRepeat=false end
while true do
if turtle.getItemCount(s)<nMin or turtle.getItemCount(s)>nMax then
print(textt)
if not blnRepeat then
-- single check ends with this
if blnExitOnFalse then
error()
else
ss(oldSlot) return false
end
end
-- repeated check
ss(s)
sleepDots(3)
else
-- everything is fine
ss(oldSlot) return true
end
end
end
local function refuelFromSlot(s, n) -- slot, amount to consume
if s==nil then s=16 end
if n==nil then n=64 end
local currentSlot = turtle.getSelectedSlot()
local fuelItems = turtle.getItemCount(s)
local returnValue = false
if fuelItems>0 then
ss(s)
returnValue=turtle.refuel(n)
ss(currentSlot)
end
return returnValue
end
local function refuelManager(setMinFuel,setSlotFuel,waitTime)
local currentSlotSelected=turtle.getSelectedSlot()
ss(setSlotFuel)
while turtle.getFuelLevel()<setMinFuel do
print("Need more fuel ("..turtle.getFuelLevel().."/"..setMinFuel..").")
if not refuelFromSlot(setSlotFuel) then
-- unsucessfull try
print(" Please, put fuel items in slot "..setSlotFuel.."!")
term.write(" Sleeping "..waitTime.." seconds")
sleepDots(waitTime)
else
print("Refueled...")
end
end
ss(currentSlotSelected)
end
local function debugPrint(str)
if blnDebugPrint then print(str) end
end
local function inspectFor(blockArray, strDirection) -- <<-- from TreeFarm
if strDirection==nil then strDirection="f" end
local blnOk, data
-- inspect
if strDirection=="d" then blnOk, data = turtle.inspectDown()
elseif strDirection=="u" then blnOk, data = turtle.inspectUp()
elseif strDirection=="f" then blnOk, data = turtle.inspect()
else
print("Warning: Unknown direction '",strDirection,"' in inspectFor, taking (f)orward instead.")
strDirection="f"
blnOk, data = turtle.inspect()
end
if data.name~=nil then debugPrint("Found:"..string.lower(data.name)) end
-- compare
local i=1
while blockArray[i]~=nil do
debugPrint("Compare to:"..string.lower(blockArray[i]))
if data.name~=nil then
if string.lower(data.name) == string.lower(blockArray[i]) then return true end
end
i=i+1
end
return false -- reached a nil value
end
local function getFirstEmptySlot(startAt)
if startAt==nil then startAt=1 end
if startAt>16 or startAt<1 then return nil end
for i=startAt,16,1 do
if gic(i)==0 then return i end
end
for i=1,startAt,1 do
if gic(i)==0 then return i end
end
return nil
end
local function identifyTool(toolSide)
-- returns name of tool at side toolSide
-- returns no_tool if there is none
-- requires at least one empty slot for tool check (throws error)
if toolSide==nil then toolSide="right" end
if toolSide~="right" and toolSide~="r" then toolSide="left" end
local slotNumber = getFirstEmptySlot()
local slotSelected=turtle.getSelectedSlot()
local toolName="no_tool"
if slotNumber==nil then error("Couldn't find empty slot to check tool on side '"..toolSide.."'!") end
ss(slotNumber)
-- step 1: get name
if toolSide=="right" or toolSide=="r" then
turtle.equipRight()
else
turtle.equipLeft()
end
-- step 2: get name
local data = turtle.getItemDetail()
if data~=nil then toolName=data.name end
-- step 3: re-equipget name
if toolSide=="right" or toolSide=="r" then
turtle.equipRight()
else
turtle.equipLeft()
end
ss(slotSelected)
return toolName
end
local function findModem() -- <<-- delete if no modem used
for _, p in pairs( rs.getSides() ) do
if peripheral.isPresent(p) and peripheral.getType(p) == "modem" then return true,p end
end
return false,nil
end
------------------------------------------------------------------------------
-- main: description ---------------------------------------------------------
------------------------------------------------------------------------------
checkTurtle()
if blnAskForParameters then
term.clear() term.setCursorPos(1,1)
local iPage=0
local iPageMax=5
local event, key, isHeld
local blnLoop=true
term.clear() term.setCursorPos(1,1) iPage=iPage+1
printUI("header")
printUI(""..cPrgName..", "..cVersion..", by Kaikaku ("..iPage.."/"..iPageMax..")")
printUI("line")
-- 1234567890123456789012345678901234567
printUI("Program features:")
printUI("* Quick: mines 3 layers in 1 go")
printUI("* Precise: mines and moves only ")
printUI(" within the specified area")
printUI("* Versatile: place turtle at any")
printUI(" corner or within corner to start")
printUI("* Lava sparing: with layer by layer")
printUI("* Stripmine: may be misused for this")
printUI("footer")
coloredTextAt(cPrgName,2,2,baseColor)
coloredTextAt("Quick",4,5,baseColor)
coloredTextAt("Precise",4,6,baseColor)
coloredTextAt("Versatile",4,8,baseColor)
coloredTextAt("Lava sparing",4,10,baseColor)
coloredTextAt("Stripmine",4,11,baseColor)
pressKeyNoSpecials("Press key to START! (stop w/ ctrl+t) ")
---
term.clear() term.setCursorPos(1,1) iPage=iPage+1
printUI("header")
printUI(""..cPrgName..", "..cVersion..", by Kaikaku ("..iPage.."/"..iPageMax..")")
printUI("line")
-- 1234567890123456789012345678901234567
printUI("Program mines all blocks of a")
printUI(" d * w * h cuboid. ")
printUI(" ")
printUI(" height="..digHeight)
printUI(" ¸ ")
printUI(" | / depth="..digDeep)
printUI(" |/ ")
printUI(" +---- width="..digWide)
printUI("footer")
term.write("Key in depth and press Enter: ")
coloredTextAt(cPrgName,2,2,baseColor)
coloredTextAt("<-- enter (d>=1)",18,9,baseColor)
event, key, isHeld = os.pullEvent("key")
digDeep=askForNumber("Key in depth and press Enter: ",1,999)
---
term.clear() term.setCursorPos(1,1) iPage=iPage+1
printUI("header")
printUI(""..cPrgName..", "..cVersion..", by Kaikaku ("..iPage.."/"..iPageMax..")")
printUI("line")
-- 1234567890123456789012345678901234567
printUI("Program mines all blocks of a")
printUI(" d * w * h cuboid. ")
printUI(" ")
printUI(" height="..digHeight)
printUI(" ¸ ")
printUI(" | / depth=")
printUI(" |/ ")
printUI(" +---- width="..digWide)
printUI("footer")
term.write("Key in width and press Enter: ")
coloredTextAt(cPrgName,2,2,baseColor)
coloredTextAt( "(w>=2 or",31,10,baseColor)
coloredTextAt("<-- enter w<=-2)",21,11,baseColor)
coloredTextAt(digDeep,14,9,baseColor)
event, key, isHeld = os.pullEvent("key")
digWide=askForNumber("Key in width and press Enter: ",-999,999)
if digWide==-1 or digWide==0 or digWide==1 then digWide=2 end
---
term.clear() term.setCursorPos(1,1) iPage=iPage+1
printUI("header")
printUI(""..cPrgName..", "..cVersion..", by Kaikaku ("..iPage.."/"..iPageMax..")")
printUI("line")
-- 1234567890123456789012345678901234567
printUI("Program mines all blocks of a")
printUI(" d * w * h cuboid. ")
printUI(" ")
printUI(" height="..digHeight)
printUI(" ¸ ")
printUI(" | / depth=")
printUI(" |/ ")
printUI(" +---- width=")
printUI("footer")
term.write("Key in height and press Enter: ")
coloredTextAt(cPrgName,2,2,baseColor)
coloredTextAt("<-- enter (h<>0)",15,7,baseColor)
coloredTextAt(digDeep,14,9,baseColor)
coloredTextAt(digWide,17,11,baseColor)
event, key, isHeld = os.pullEvent("key")
digHeight=askForNumber("Key in height and press Enter: ",-999,999)
if digHeight==0 then digHeight=1 end
---
term.clear() term.setCursorPos(1,1) iPage=iPage+1
printUI("header")
printUI(""..cPrgName..", "..cVersion..", by Kaikaku ("..iPage.."/"..iPageMax..")")
printUI("line")
-- 1234567890123456789012345678901234567
printUI("Program mines all blocks of a")
printUI(" d * w * h cuboid. ")
printUI(" ")
printUI(" height= Options:")
printUI(" ¸ layer by layer: ")
printUI(" | / depth= start within: ")
printUI(' |/ "strip mine": ')
printUI(" +---- width=")
printUI("footer")
term.write("Toggle options or ENTER to start: ")
coloredTextAt(cPrgName,2,2,baseColor)
coloredTextAt("Options:",18,7,baseColor)
coloredTextAt("l",20,8,baseColor)
coloredTextAt("w",26,9,baseColor)
coloredTextAt("m",27,10,baseColor)
coloredTextAt(digDeep,14,9,baseColor)
coloredTextAt(digWide,17,11,baseColor)
coloredTextAt(digHeight,11,7,baseColor)
while blnLoop do
-- color toggles
if blnLayerByLayer then
coloredTextAt("on ",36,8,baseColor)
else
coloredTextAt("off",36,8,colors.white)
end
if blnStartWithin then
coloredTextAt("on ",36,9,baseColor)
else
coloredTextAt("off",36,9,colors.white)
end
if blnStripMine then
coloredTextAt("on ",36,10,baseColor)
else
coloredTextAt("off",36,10,colors.white)
end
-- get key
event, key, isHeld = os.pullEvent("key")
-- evaluate key
if key~=nil then
if keys.getName(key)=="l" then
blnLayerByLayer= not blnLayerByLayer
elseif keys.getName(key)=="m" then
blnStripMine= not blnStripMine
elseif keys.getName(key)=="w" then
blnStartWithin = not blnStartWithin
elseif keys.getName(key)=="enter" then
blnLoop=false
end
end
end
end
---------------------------------------
-- additional functions -
---------------------------------------
local blnDigUp=false
local blnDigDown=false
local function digUpDown()
if blnDigUp then dus() end
if blnDigDown then dds() end
end
local function gfPosDig(n)
if n==nil then n=1 end
for i=1,n,1 do
gfPos() digUpDown()
end
end
------------------------------------------------------------------------------
-- main: pre-main options ----------------------------------------------------
------------------------------------------------------------------------------
local selfCall=""
local selfLayer=""
if blnStripMine then
-- let's missuse this beautiful program for strip mining
-- srtip mine step 1: main corridor
if blnLayerByLayer then selfLayer=" LayerByLayer" end
selfCall="tClear "..digDeep.." -2 "..digHeight..selfLayer
if blnStripMine then selfCall=selfCall.." within" end
--print(selfCall)
shell.run(selfCall)
-- strip mine step 2: mining shafts right side
-- step inside
if not blnStartWithin then gfPos() end
-- mine shafts
for i=1,digDeep,4 do
-- get on position
if i>1 then
gfPos(4)
end
-- mining shafts
selfCall="tClear 1 "..(digWide+1).." "..digHeight.." within"..selfLayer
print(selfCall)
--sleep(3)
shell.run(selfCall)
end
-- strip mine step 3: mining shafts left side
-- get on position
gl() gfPos() gl()
-- mine shafts
for i=1,digDeep,4 do
-- get on position
if i>1 then
gfPos(4)
end
-- mining shafts
selfCall="tClear 1 "..(digWide+1).." "..digHeight.." within"..selfLayer
print(selfCall)
--sleep(3)
shell.run(selfCall)
end
-- strip mine step 4: return
-- to entrance
gl() gfPos() gl()
-- step outside
if not blnStartWithin then gbPos() end
-- done
return
end
------------------------------------------------------------------------------
-- main: program -------------------------------------------------------------
------------------------------------------------------------------------------
term.clear() term.setCursorPos(1,1)
---- step 0: check fuel ----
print("step 0: checking fuel...")
-- fuel
-- estimate consumption
if not blnLayerByLayer then
cMinFuel=math.floor(digHeight/3)
else
cMinFuel=math.floor(digHeight)
end
cMinFuel=cMinFuel*(math.abs(digDeep)+1)*(math.abs(digWide)+1)+(digHeight*2)
cMinFuel=math.floor(cMinFuel*1.1) + 20 -- extra
refuelManager(cMinFuel,slotFuel,10)
print("... done")
---- step 1: do deal with negative values ----
term.write("step 1: deal with negative values...")
-- first dig block is 1,1,1
tPos[1]=1 tPos[2]=0 tPos[3]=1 tPos[4]=0 -- starting position
-- save inital values for end report
digWideOrg=digWide
digDeepOrg=digDeep
--- check negative width
local blnNegativeWidth=false
if digWide<0 then
blnNegativeWidth=true
digWide=digDeepOrg
digDeep=-digWideOrg
end
--- check negative height
local blnNegativeHeight=false
local remainingDigHeight=digHeight
if digHeight<0 then
blnNegativeHeight=true
remainingDigHeight=-digHeight
end
print(" done")
---- step 2: enter and go up ----
term.write("step 2: enter and go up...")
-- step inside area
if not blnStartWithin then
-- move into cuboid
gfPosDig()
else
-- I'm already there
tPos[2]=1
end
-- positive or negative inital width?
if not blnNegativeWidth then
grPos() -- turn to show progress
else
-- orientation is already okay, due to negative inital width
end
print(" done")
-- step 3: starting height
term.write("step 3: starting height...")
if not blnLayerByLayer then
-- normal 3 layer dig mode
if digHeight>2 then
-- get to right inital digging height
guPos(digHeight-2)
elseif digHeight<-1 then
-- get to right inital negative digging height
gdPos(1)
end
else
-- layer by layer
if digHeight>1 then
-- go to very top
guPos(digHeight-1)
else
-- just stay where you are
end
end
print(" done")
while remainingDigHeight>0 do
-- step 4: set dig up/down
term.write("step 4: set dig up/down...")
if not blnLayerByLayer then
-- normal 3 layer dig mode
if not blnNegativeHeight then
-- positive dig height
if tPos[3]>1 then
-- gone up to tripple dig
blnDigUp=true
blnDigDown=true
elseif remainingDigHeight==2 then
blnDigUp=true
blnDigDown=false
else
blnDigUp=false
blnDigDown=false
end
else
-- negative dig hight
if tPos[3]>=digHeight+3 then
-- gone down to tripple dig
blnDigUp=true
blnDigDown=true
elseif remainingDigHeight==2 then
blnDigUp=true--false
blnDigDown=false--true
else
blnDigUp=false
blnDigDown=false
end
end
else
-- layer by layer mode
blnDigUp=false
blnDigDown=false
end
print(" done")
---- step 5: digging one level ----
term.write("step 5: digging one level...")
for iy=1,digDeep,1 do
if iy==1 then
gfPosDig() -- step inside track
elseif iy%2==0 then
-- u-turn left
glPos() gfPosDig() glPos()
else
-- u-turn right
grPos() gfPosDig() grPos()
end
-- lane
gfPosDig(digWide-2)
if iy==digDeep then
-- return
if iy%2==1 then
-- uneven! lets return
glPos(2) gfPosDig(digWide-2)
end
-- dig lane y=1 back
gfPosDig() glPos() gfPosDig(digDeep-1) glPos()
end
end
print(" done")
---- step 6: change level ----
term.write("step 6: change level...")
-- adjuste remainingDigHeight
remainingDigHeight=remainingDigHeight-1
if blnDigUp then remainingDigHeight=remainingDigHeight-1 end
if blnDigDown then remainingDigHeight=remainingDigHeight-1 end
-- adjust layer if there's s.th. left to dig
if remainingDigHeight>0 then
if not blnLayerByLayer then
-- normal 3 layer dig mode
-- inital dig height pos or neg?
if not blnNegativeHeight then
-- inital dig height positive
-- get to next dig level
if remainingDigHeight>=2 then
gdPos(3)
else
gdPos(tPos[3]-1)
end
else
-- inital dig height negative
-- get to next dig level
if remainingDigHeight>=2 then
gdPos(3)
else
gdPos(-digHeight+tPos[3]-2)
end
end
else
-- layer by layer mode
gdPos(1) -- just the next one
end
end
print(" done")
end
---- step 7: return to floor ----
term.write("step 7: return to floor...")
-- return to floor
if not blnNegativeHeight then
gdPos(tPos[3]-1)
else
guPos(-tPos[3]+1)
end
-- positive or negative inital width?
if not blnNegativeWidth then
glPos() -- turn to leave
else
-- orientation is already okay, due to negative inital width
end
-- step out of area
if not blnStartWithin then
-- move out of cuboid
gbPos()
else
-- I started there, so I'm already done
end
print(" done")
---- step 8: finishing stuff / report ----
print("Done with tClear "..digDeep.." "..digWide.." "..digHeight)
print("That looks much cleaner now! !") ss(1)
--sleep(0.4)
printUI("header")
printUI("Check out YouTube for more videos")
printUI("and turtle programs by Kaikaku :)")
printUI("footer")
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment