chunkDig4

local function showUsage()
  print("chunkDig4")
  print("slot1 : chest x 64")
  print("slot2 : stone x 1")
  print("slot3 : gravel x 1")
  print("slot4 : dart x 1")
  print("slot5 : cobblestone x 32")
end
local SLOT_CHEST       = 1
local SLOT_STONE       = 2
local SLOT_GRAVEL      = 3
local SLOT_DART        = 4
local SLOT_COBBLESTONE = 5
local SLOTS_FREE     = { 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }
local SLOTS_KEEP_ALL = { SLOT_CHEST }
local SLOTS_KEEP_32  = { SLOT_COBBLESTONE }
local SLOTS_KEEP_1   = { SLOT_STONE, SLOT_GRAVEL, SLOT_DART }
local SLOTS_USELESS_SAMPLE = { SLOT_COBBLESTONE, SLOT_STONE, SLOT_GRAVEL, SLOT_DART }
-- -------------------------------
-- config
-- -------------------------------
local DEFAULT_WIDTH        = 16
local DEFAULT_DEPTH        = 16 -- forward() direction
local PREVENTION_FROM_FALL = false
local EXCAVATE_ALL         = false
local KEEP_USELESS_BLOCKS  = false
local SHOW_USAGE           = true
--
local ASK_INITIAL_HEIGHT   = true
local TURTLE_INITIAL_Y     = 71
-- HEIGHT_MODE
--   true  : use BEADROCK_HEIGHT
--   false : use RELATIVE_HEIGHT
local HEIGHT_MODE          = true
local BEADROCK_HEIGHT      = 5
local RELATIVE_HEIGHT      = 3
-- for debug
local DEBUG_LOG            = true
local SIMULATION           = false
-- -------------------------------
-- utility
-- -------------------------------
-- local log
local LOCAL_ENABLED       = true
local LOCAL_LOG_FILE_NAME = "debug.log"
-- remote log
local REMOTE_ENABLED      = false
local REMOTE_ADDR         = 20
local REMOTE_MODEM_DIR    = "right"
local function debug(txt)
  if DEBUG_LOG then
    if LOCAL_ENABLED then
      local hFile
      if fs.exists(LOCAL_LOG_FILE_NAME) then
        hFile = fs.open(LOCAL_LOG_FILE_NAME, "a");
      else
        hFile = fs.open(LOCAL_LOG_FILE_NAME, "w");
      end
      hFile.writeLine(txt);
      hFile.close();
    end
    if REMOTE_ENABLED then
      rednet.open(REMOTE_MODEM_DIR)
      rednet.send(REMOTE_ADDR, txt)
      rednet.close()
    end
  end
end
local function inRange(posX, posY, width, height)
  return 0 <= posX and posX < width and 0 <= posY and posY < height
end
local function sign(val)
  if val == 0 then
    return 0
  else
    return math.abs(val) / val
  end
end
function surelyUp()
  while not turtle.up() do turtle.digUp() end
end
function surelyDown()
  while not turtle.down() do end
end
-- http://hevohevo.hatenablog.com/entry/2014/07/14/213109
function surelyDigUp()
  while turtle.digUp() do
    os.sleep(0.4)
  end
end
-- http://hevohevo.hatenablog.com/entry/2014/07/14/213109
function surelyDig()
  while turtle.dig() do end
end
-- http://hevohevo.hatenablog.com/entry/2014/07/14/213109
function surelyFwd()
  for i=1,4 do
    local status, err = turtle.forward()
    if status then
      return true  -- success!
    elseif err=="Out of fuel" then
      return status, err
    end

    surelyDig() -- face to a normal block or a sand(gravel) hill

    if turtle.detect() and not turtle.dig() then
      return false, "bedrock!"
    end

    if turtle.forward() then return true end -- success!

    if turtle.attack() then
      -- face to monster-mob
      while turtle.attack() do end
    else
      -- face to sand-blocks which is dropping long time
      os.sleep(5) -- probably, adjustment is required
    end
  end
  return turtle.forward()
end
-- -------------------------------
-- application
-- -------------------------------
-- ---------------
-- direction control
-- ---------------
local COMPARE_BLOCKS = {SLOT_COBBLESTONE, SLOT_STONE, SLOT_DART, SLOT_GRAVEL }
local DIR_FORWARD = 1
local DIR_RIGHT   = 2
local DIR_BACK    = 3
local DIR_LEFT    = 4
local DIR_NOT     = 5
local DIR_TO_NAME = {
  [DIR_FORWARD] = "F",
  [DIR_RIGHT  ] = "R",
  [DIR_BACK   ] = "B",
  [DIR_LEFT   ] = "L",
  [DIR_NOT    ] = "*"}
local TURN_NOT     = 1
local TURN_LEFT    = 2
local TURN_RIGHT   = 3
local TURN_OPPOSIT = 4
local TURN_COSTS = { [TURN_NOT]   = 0, [TURN_LEFT]    = 1,
                     [TURN_RIGHT] = 2, [TURN_OPPOSIT] = 3 }
local TURN_RULES = { -- dir_forward, dir_right, dir_back, dir_left
  [DIR_FORWARD] = { TURN_NOT    , TURN_RIGHT  , TURN_OPPOSIT, TURN_LEFT    },
  [DIR_RIGHT  ] = { TURN_LEFT   , TURN_NOT    , TURN_RIGHT  , TURN_OPPOSIT },
  [DIR_BACK   ] = { TURN_OPPOSIT, TURN_LEFT   , TURN_NOT    , TURN_RIGHT   },
  [DIR_LEFT   ] = { TURN_RIGHT  , TURN_OPPOSIT, TURN_LEFT   , TURN_NOT     }}
local TURN_RELATIVE = { -- turn_left, turn_right
  [DIR_FORWARD] = { [TURN_LEFT] = DIR_LEFT   , [TURN_RIGHT] = DIR_RIGHT   },
  [DIR_RIGHT  ] = { [TURN_LEFT] = DIR_FORWARD, [TURN_RIGHT] = DIR_BACK    },
  [DIR_BACK   ] = { [TURN_LEFT] = DIR_RIGHT  , [TURN_RIGHT] = DIR_LEFT    },
  [DIR_LEFT   ] = { [TURN_LEFT] = DIR_BACK   , [TURN_RIGHT] = DIR_FORWARD }}
local OPPOSIT_DIR = {DIR_BACK, DIR_LEFT, DIR_FORWARD, DIR_LEFT}
-- ---------------
-- findTarget
-- ---------------
local TargetFinder = {
  iterator = function(width, depth)
    findTarget = function(scanX, scanZ, reverse, rangeWidth, rangeDepth)
      local TILE_PATTERN = {"*","b","r","l","f"}
      local SHAPE_DIRECTION = { DIR_NOT, DIR_FORWARD, DIR_LEFT,
                                DIR_RIGHT, DIR_BACK }
      local idx = ( (scanZ%5) + (scanX%5)*3 )%5 + 1
      local dirChar = TILE_PATTERN[idx]
      if (not reverse and "b" == dirChar) or
         (    reverse and "f" == dirChar) then
        return false
      end
      local DIR_TO_CENTER = {{ dx =  0, dz =  0 }, -- *
                             { dx =  0, dz = -1 }, -- b
                             { dx =  1, dz =  0 }, -- r
                             { dx = -1, dz =  0 }, -- l
                             { dx =  0, dz =  1 }} -- f
      local isCenter = false
      local found = false
      local newX, newZ
      local shape = {}
      local shapeDbg = ""
      local centerX = scanX + DIR_TO_CENTER[idx].dx
      local centerZ = scanZ + DIR_TO_CENTER[idx].dz
      if inRange(centerX, centerZ, rangeWidth, rangeDepth) then
        found    = true
        isCenter = true
        newX = centerX
        newZ = centerZ
      else
        table.insert(shape, DIR_NOT)
        shapeDbg = shapeDbg .. "*"
      end
      local testX, testZ
      for i = 2, 5 do
        testX = centerX - DIR_TO_CENTER[i].dx
        testZ = centerZ - DIR_TO_CENTER[i].dz
        if inRange(testX, testZ, rangeWidth, rangeDepth) then
          if isCenter then
            table.insert(shape, SHAPE_DIRECTION[i])
            shapeDbg = shapeDbg .. DIR_TO_NAME[SHAPE_DIRECTION[i]]
          end
          if not found then
            newX = testX
            newZ = testZ
          end
          found = true
        end
      end
      if not found then
        return false
      end
      return true, newX, newZ, shape
    end
    local xAxisIterator = function(width)
      local pos = 0
      local loopEnd = math.floor((width + 1) / 3)
      return function()
        local current = pos
        pos = pos + 1
        if loopEnd < current then
          return nil
        else
          return current * 3
        end
      end
    end
    local zAxisIterator = function(x, depth)
      local pos, step
      if 0 == x % 2 then
        pos, step = -1, 1
      else
        pos, step = depth, -1
      end
      return function()
        local current = pos
        pos = pos + step
        if current < -1 or depth < current then
          return nil
        else
          return current
        end
      end
    end
    local xIter = xAxisIterator(width)
    local zIter = nil
    local x
    local previousX
    local previousZ
    return function()
      while true do
        if nil == zIter then
          x = xIter()
          if nil == x then
            return nil
          end
          zIter = zAxisIterator(x, depth)
        end
        local z = zIter()
        if nil == z then
          zIter = nil
        else
          --return x, z
          local found, newX, newZ, shape
            = findTarget(x, z, 0 == x%2, width, depth)
          if found and (previousX ~= newX or previousZ ~= newZ) then
            previousX = newX
            previousZ = newZ
            return newX, newZ, shape
          end
        end
      end
    end
  end
}
-- ---------------
-- mining control
-- ---------------
MOVE_H_TOP    = "MOVE_H_TOP"
MOVE_V_DOWN   = "MOVE_V_DOWN"
MOVE_H_BOTTOM = "MOVE_H_BOTTOM"
MOVE_V_UP     = "MOVE_V_UP"
local mineCtrl = {
  status,
  RANGE_WIDTH,
  RANGE_DEPTH,
  BOTTOM_HEIGHT,
  newX,
  newZ,
  lastX = -1,
  lastZ = -1,

  pointBeforeX,
  pointBeforeZ,
  turtleIsTop = true,
  turtleInitialY = 0,
  interruptX,
  interruptZ,
  interruptY,
  vacantChestList = { },
  occupiedChestList = { },
  underInterruption = false,
}
-- ---------------
-- turtle
-- ---------------
local MyTurtle = {}
MyTurtle.new = function(initialY)
  local obj = {}
  obj.turtleX = 0
  obj.turtleZ = 0
  obj.turtleY = initialY
  obj.turtleDir = DIR_FORWARD
  return setmetatable(obj, {__index = MyTurtle})
end
MyTurtle.turnTo = function(self, direction)
  local turn = TURN_RULES[self.turtleDir][direction]
  if TURN_LEFT == turn then
    if not SIMULATION then
      turtle.turnLeft()
    end
  elseif TURN_RIGHT == turn then
    if not SIMULATION then
      turtle.turnRight()
    end
  elseif TURN_OPPOSIT == turn then
    if not SIMULATION then
      turtle.turnLeft()
      turtle.turnLeft()
    end
  end
  self.turtleDir = direction
end
MyTurtle.runEventHandlers = function(self, evHandlers)
  if nil == evHandlers then
    return
  end
  for _, func in ipairs(evHandlers) do
    func()
  end
end
MyTurtle.adjustX = function(self, aimX, withDigUp, beforeEvHandlers, afterEvHandlers)
  if self.turtleX < aimX and DIR_RIGHT ~= self.turtleDir then
    self:turnTo(DIR_RIGHT)
  elseif aimX < self.turtleX and DIR_LEFT ~= self.turtleDir then
    self:turnTo(DIR_LEFT)
  end
  while self.turtleX ~= aimX do
    if not SIMULATION then
      self:runEventHandlers(beforeEvHandlers)
      surelyFwd()
      self:runEventHandlers(afterEvHandlers)
      if withDigUp then
        surelyDigUp()
      end
    end
    self.turtleX = self.turtleX + sign(aimX - self.turtleX)
  end
end
MyTurtle.adjustZ = function(self, aimZ, withDigUp, beforeEvHandlers, afterEvHandlers)
  if self.turtleZ < aimZ and DIR_FORWARD ~= self.turtleDir then
    self:turnTo(DIR_FORWARD)
  elseif aimZ < self.turtleZ and DIR_BACK ~= self.turtleDir then
    self:turnTo(DIR_BACK)
  end
  while self.turtleZ ~= aimZ do
    if not SIMULATION then
      self:runEventHandlers(beforeEvHandlers)
      surelyFwd()
      self:runEventHandlers(afterEvHandlers)
      if withDigUp then
        surelyDigUp()
      end
    end
    self.turtleZ = self.turtleZ + sign(aimZ - self.turtleZ)
  end
end
MyTurtle.moveTo = function(self, aimX, aimZ, withDigUp, beforeEvHandlers, afterEvHandlers)
  self:adjustX(aimX, withDigUp, beforeEvHandlers, afterEvHandlers)
  self:adjustZ(aimZ, withDigUp, beforeEvHandlers, afterEvHandlers)
end
MyTurtle.backTo = function(self, aimX, aimZ, withDigUp, beforeEvHandlers, afterEvHandlers)
  self:adjustZ(aimZ, withDigUp, beforeEvHandlers, afterEvHandlers)
  self:adjustX(aimX, withDigUp, beforeEvHandlers, afterEvHandlers)
end
MyTurtle.moveVertical = function(self, targetY, beforeEvHandlers, afterEvHandlers)
  local vDir = sign(targetY - self.turtleY)
  while targetY ~= self.turtleY do
    if not SIMULATION then
      if 1 == vDir then
        self:runEventHandlers(beforeEvHandlers)
        turtle.digUp()
        surelyUp()
        self.turtleY = self.turtleY + vDir
        self:runEventHandlers(afterEvHandlers)
      elseif -1 == vDir then
        self:runEventHandlers(beforeEvHandlers)
        turtle.digDown()
        surelyDown()
        self.turtleY = self.turtleY + vDir
        self:runEventHandlers(afterEvHandlers)
      end
    end
  end
end
-- ---------------
-- additional action : vertical mining
-- ---------------
local function verticalMiningAction(_myT, _shape)
  local turnToNearestEdge = function (myT, shape)
    local turnMinCost = 99
    local smallestTurnDir = DIR_NOT
    local turnTmp, costTmp
    for _, dir in ipairs(shape) do
      turnTmp = TURN_RULES[myT.turtleDir][dir]
      costTmp = TURN_COSTS[turnTmp]
      if costTmp < turnMinCost then
        turnMinCost = costTmp
        smallestTurnDir = dir
      end
    end
    myT:turnTo(smallestTurnDir)
  end
  local getTurnFuncName = function(myT, shape)
    local dirWhenTurnLeft  = TURN_RELATIVE[myT.turtleDir][TURN_LEFT ]
    local dirWhenTurnRight = TURN_RELATIVE[myT.turtleDir][TURN_RIGHT]
    for _, dir in ipairs(shape) do
      if dir == dirWhenTurnLeft then
        return TURN_LEFT
      elseif dir == dirWhenTurnRight then
        return TURN_RIGHT
      end
    end
  end
  local digValuableBlockOnly = function()
    local selSlot = 16
    local checkedSlot = -1
    for _, slot in ipairs(COMPARE_BLOCKS) do
      if selSlot == slot then
        if turtle.compare() then
          return
        end
        checkedSlot = slot
        break
      end
    end
    for _, slot in ipairs(COMPARE_BLOCKS) do
      if checkedSlot ~= slot then
        turtle.select(slot)
        if turtle.compare() then
          return
        end
      end
    end
    turtle.dig()
    return true
  end
  local myT = _myT
  local shape = _shape
  local firstFlg = true
  local turnLR
  return function()
    if firstFlg then
      firstFlg = not firstFlg
      if 2 == #shape or 3 == #shape then
        turnToNearestEdge(myT, shape)
        turnLR = getTurnFuncName(myT, shape)
      else
        turnLR = TURN_RIGHT
      end
    end
    if 1 < #shape then
      for i = 1, #shape do
        if not SIMULATION then
          if EXCAVATE_ALL then
            surelyDig()
            dug = true
          else
            dug = digValuableBlockOnly()
          end
        end
        if i < #shape then
          myT:turnTo(TURN_RELATIVE[myT.turtleDir][turnLR])
        end
      end
      if 2 == #shape or 3 == #shape then
        if TURN_LEFT == turnLR then
          turnLR = TURN_RIGHT
        else
          turnLR = TURN_LEFT
        end
      end
    end
  end
end
-- ---------------
-- additional action : inventory check
-- ---------------
local function checkInventoryAction(_myT, _mineCtrl)
  local function dropUselessBlocks()
    local cnt
    for _, v in ipairs(SLOTS_KEEP_1) do
      cnt = turtle.getItemCount(v)
      if 1 < cnt then
        turtle.select(v)
        turtle.dropDown(cnt - 1)
      end
    end
    for _, v in ipairs(SLOTS_KEEP_32) do
      cnt = turtle.getItemCount(v)
      if 32 < cnt then
        turtle.select(v)
        turtle.dropDown(cnt - 32)
      end
    end
    local freeCnt = 0
    for _, v in ipairs(SLOTS_FREE) do
      cnt = turtle.getItemCount(v)
      if 0 < cnt then
        turtle.select(v)
        for _, w in ipairs(SLOTS_USELESS_SAMPLE) do
          if turtle.compareTo(w) then
            turtle.dropDown()
            freeCnt = freeCnt + 1
            break
          end
        end
      else
        freeCnt = freeCnt + 1
      end
    end
    turtle.select(1)
    debug("==== dropUselessBlocks() makes " .. tostring(freeCnt) .." vacantSlot(s)")
    return 0 < freeCnt
  end
  local function checkInventory()
    for _, i in ipairs(SLOTS_FREE) do
      if 0 == turtle.getItemCount(i) then
        return true
      end
    end
    return false
  end
  local function dump()
    surelyDigUp()
    surelyUp()
    turtle.select(SLOT_CHEST)
    turtle.placeUp()
    for _, v in ipairs(SLOTS_FREE) do
      cnt = turtle.getItemCount(v)
      if 0 < cnt then
        turtle.select(v)
        if KEEP_USELESS_BLOCKS then
          turtle.dropUp()
        else
          for _, w in ipairs(SLOTS_USELESS_SAMPLE) do
            if not turtle.compareTo(w) then
              turtle.dropUp()
            end
            break
          end
        end
      end
    end
    turtle.select(1)
    turtle.digDown()
    surelyDown()
  end
  local function backToTheGround(myT, mineCtrl)
    debug("====== backToTheGround()")
    debug("======   status    = " .. mineCtrl.status)
    debug("======   pos x,z,y = " .. myT.turtleX .. ", " .. myT.turtleZ .. ", " .. myT.turtleY)
    debug("======   last x,z  = " .. mineCtrl.lastX .. ", " .. mineCtrl.lastZ)
    local t2 = MyTurtle.new()
    t2.turtleX = myT.turtleX
    t2.turtleZ = myT.turtleZ
    t2.turtleY = myT.turtleY
    t2.turtleDir = myT.turtleDir
    if MOVE_H_TOP == mineCtrl.status then
      debug("<<<>>> backToTheGround [MOVE_H_TOP] begin")
      t2:backTo(mineCtrl.lastX, mineCtrl.lastZ, nil, nil)
      debug("<<<>>> backToTheGround [MOVE_H_TOP] end")
    elseif MOVE_V_DOWN == mineCtrl.status then
      debug("<<<>>> backToTheGround [MOVE_V_DOWN] begin")
      t2:moveVertical(mineCtrl.turtleInitialY, nil, nil)
      debug("<<<>>> backToTheGround [MOVE_V_DOWN] end")

    elseif MOVE_H_BOTTOM == mineCtrl.status then
      debug("<<<>>> backToTheGround [MOVE_H_BOTTOM] begin")
      t2:backTo(mineCtrl.lastX, mineCtrl.lastZ, nil, nil)
      t2:moveVertical(mineCtrl.turtleInitialY, nil, nil)
      debug("<<<>>> backToTheGround [MOVE_H_BOTTOM] end")

    elseif MOVE_V_UP == mineCtrl.status then
      debug("<<<>>> backToTheGround [MOVE_V_UP] begin")
      t2:moveVertical(mineCtrl.BOTTOM_HEIGHT, nil, nil)
      t2:backTo(mineCtrl.lastX, mineCtrl.lastZ, nil, nil)
      t2:moveVertical(mineCtrl.turtleInitialY, nil, nil)
      debug("<<<>>> backToTheGround [MOVE_V_UP] end")
    end
    dump()
    if MOVE_H_TOP == mineCtrl.status then
      t2:moveTo(myT.turtleX, myT.turtleZ)

    elseif MOVE_V_DOWN == mineCtrl.status then
      t2:moveVertical(myT.turtleY, nil, nil)

    elseif MOVE_H_BOTTOM == mineCtrl.status then
      t2:moveVertical(mineCtrl.BOTTOM_HEIGHT, nil, nil)
      t2:moveTo(myT.turtleX, myT.turtleZ)

    elseif MOVE_V_UP == mineCtrl.status then
      t2:moveVertical(mineCtrl.BOTTOM_HEIGHT, nil, nil)
      t2:moveTo(myT.turtleX, myT.turtleZ)
      t2:moveVertical(myT.turtleY, nil, nil)
    end
    t2:turnTo(myT.turtleDir)

    debug("<<<>>>  compreted?")
    debug("  <<<>>>  myT x,z,y = " .. myT.turtleX .. ", " .. myT.turtleZ .. ", " .. myT.turtleY)
    debug("  <<<>>>  t2  x,z,y = " .. t2.turtleX .. ", " .. t2.turtleZ .. ", " .. t2.turtleY)
  end
  return function()
    if not checkInventory() then
      debug("====================================")
      debug("== checkInventory() returns false")
      debug("==   at x : " .. tostring(_myT.turtleX) ..
                 " / z : " .. tostring(_myT.turtleZ) ..
                 " / y : " .. tostring(_myT.turtleY))
      debug("====================================")
      local result = false
      if not KEEP_USELESS_BLOCKS then
        result = dropUselessBlocks()
      end
      if not result then
        backToTheGround(_myT, _mineCtrl)
      end
    end
  end
end
-- ---------------
-- initialize
-- ---------------
local function initialize()
  if SHOW_USAGE then
    showUsage()
    print("Hit any key when ready.")
    read()
  end
  if ASK_INITIAL_HEIGHT then
    print("Input current y")
    term.write(">")
    local ch = read()
    if nil == tonumber(ch) then
      error("Not a Number!")
    end
    mineCtrl.turtleInitialY = tonumber(ch)
  else
    mineCtrl.turtleInitialY = TURTLE_INITIAL_Y
  end
  mineCtrl.RANGE_WIDTH = DEFAULT_WIDTH
  mineCtrl.RANGE_DEPTH = DEFAULT_DEPTH

  if HEIGHT_MODE then
    -- true  : use BEADROCK_HEIGHT
    mineCtrl.BOTTOM_HEIGHT = BEADROCK_HEIGHT
  else
    -- false : use RELATIVE_HEIGHT
    mineCtrl.BOTTOM_HEIGHT = mineCtrl.turtleInitialY - RELATIVE_HEIGHT
  end
end
-- -------------------------------
-- main
-- -------------------------------
debug("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@")
debug("@@ chunkDig4.1.lua")
debug("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@")
initialize()
local myT = MyTurtle.new(mineCtrl.turtleInitialY)
local beforeEvHandlers = { }
local afterEvHandlers = { }
local checkInventoryA = checkInventoryAction(myT, mineCtrl)
local newX, newZ
mineCtrl.lastX = -1
mineCtrl.lastZ = -1

mineCtrl.status = MOVE_H_TOP
for newX, newZ, shape in TargetFinder.iterator(mineCtrl.RANGE_WIDTH, mineCtrl.RANGE_DEPTH) do
  mineCtrl.newX = newX
  mineCtrl.newZ = newZ
  if -1 == mineCtrl.lastX then
    mineCtrl.lastX = mineCtrl.newX
    mineCtrl.lastZ = mineCtrl.newZ
  end
  debug("=[for loop]====================")
  debug("==  newX,  newZ = " .. tostring(mineCtrl.newX) .. ", " .. tostring(mineCtrl.newZ))
  debug("== lastX, lastZ = " .. tostring(mineCtrl.lastX) .. ", " .. tostring(mineCtrl.lastZ))
  debug("===============================")
  myT:moveTo(mineCtrl.newX, mineCtrl.newZ, {}, { checkInventoryA })
  if MOVE_H_TOP == mineCtrl.status then

    mineCtrl.status = MOVE_V_DOWN
    beforeEvHandlers = { }
    afterEvHandlers  = { verticalMiningAction(myT, shape),
                         checkInventoryA }
    myT:moveVertical(mineCtrl.BOTTOM_HEIGHT,
      beforeEvHandlers, afterEvHandlers)

    mineCtrl.status = MOVE_H_BOTTOM
  elseif MOVE_H_BOTTOM == mineCtrl.status then

    mineCtrl.status = MOVE_V_UP
    beforeEvHandlers = { verticalMiningAction(myT, shape),
                         checkInventoryA }
    afterEvHandlers  = { }
    myT:moveVertical(mineCtrl.turtleInitialY,
      beforeEvHandlers, afterEvHandlers)

    mineCtrl.status = MOVE_H_TOP
  else
    error("unexpected condition.")
  end
  mineCtrl.lastX = mineCtrl.newX
  mineCtrl.lastZ = mineCtrl.newZ
end
myT:backTo(0, 0)
myT:turnTo(DIR_FORWARD)
print("chunkDig4.1.lua was compreted!!")
debug("chunkDig4.1.lua was compreted!!")