scan

local r = require('robot')
local comp = require('computer')
local term = require('term')
local com = require('component')
local geolyzer = com.geolyzer
local inv = com.inventory_controller
local gen = com.generator
--количество кластеров
x2=1
y2=1
z2=1
--радиус кластера
xk = 32
yk = 32
allSlots=r.inventorySize()
--==============СПИСОК СНОСЯЩИХ УЛЬИ ИНСТРУМЕНТОВ=============--
uleyInstr={}
uleyInstr['ExtraBees:hive'] = true
uleyInstr['IC2:itemToolMiningLaser'] = true
--========================СПИСОК МУСОРА=======================--
musor={}
musor['minecraft:stone'] = true
musor['minecraft:cobblestone'] = true
musor['minecraft:dirt'] = true
musor['minecraft:gravel'] = true
musor['minecraft:sandstone'] = true
musor['minecraft:stonebrick'] = true
musor['minecraft:flint'] = true
--========================СПИСОК БУРОВ========================--
instr = {}
instr['IC2:ItemToolDrill'] = true
instr['IC2:itemToolDDrill'] = true
instr['IC2:itemToolIridiumDrill'] = true
instr['GraviSuiteAdvDDrill'] = true
--======================ЗАМЕНА ИНСТРУМЕНТА====================--
function zamena()
  slotInstr = 1
  while (inv.getStackInInternalSlot(slotInstr) ~= nil) and (slotInstr < allSlots) do
    slotInstr = slotInstr + 1
  end
  r.select(slotInstr)
  inv.equip()
  if r.count(slotInstr) == 0 then
    turnLeft()
    r.suck()
    inv.equip()
    turnRight()
  elseif instr[inv.getStackInInternalSlot(slotInstr).name] == nil then
    turnAround()
    while not r.drop() do
      os.sleep(0.2)
    end
    turnRight()
    r.suck()
    inv.equip()
    turnRight()
  elseif instr[inv.getStackInInternalSlot(slotInstr).name] ~= nil then
    turnLeft()
    r.drop()
    while inv.getStackInSlot(3,1).charge < inv.getStackInSlot(3,1).maxCharge do
      os.sleep(0.2)
    end
    r.suck()
    inv.equip()
    turnRight()
  end
  slotInstr = nil
end
--======================ПОИСК ПО ИНВЕНТАРЮ====================--
function poisk(item)
  for slot=1,allSlots do
    if inv.getStackInInternalSlot(slot) ~= nil then
      if inv.getStackInInternalSlot(slot).name == item then
        r.select(slot)
        return true
      end
    end
  end
  return false
end
--===========================СНОС УЛЬЯ========================--
function snos(storona)
  if geolyzer.analyze(storona).name == "ExtraBees:hive"  then
    if poisk('Forestry:scoop') then
      inv.equip()
      if storona == 1 then
        r.swingUp()
      elseif storona == 2 then
        r.swingDown()
      elseif storona == 3 then
        r.swing()
      end
      inv.equip()
      return true
    else
      poisk('IC2:itemToolMiningLaser')
      inv.equip()
      if storona == 1 then
         r.useUp()
         os.sleep(0.5)
         r.suckUp()
      elseif storona == 2 then
        r.useDown()
        os.sleep(0.5)
        r.suckDown()
      elseif storona == 3 then
        r.use()
        os.sleep(0.5)
        r.suck()
      end
      inv.equip()
      return true
    end
  end
  return false
end
--===================== Н А В И Г А Ц И Я ====================--
loc = {x=0, y=0, z=0, b=0}
function forward()
    attempt = 0
    while r.detect() do
      r.swing()
      attempt = attempt + 1
      if attempt > 20 then
        snos(3)
        attempt = 0
      end
    end
    while not r.forward() do r.swing() end
    if loc.b == 0 then loc.y = loc.y+1
    elseif loc.b == 1 then loc.x = loc.x+1
    elseif loc.b == 2 then loc.y = loc.y-1
    else loc.x = loc.x-1 end
    return true
end
function back()
   if not r.back() then
     r.turnAround()
     while not r.forward() do
       r.swing()
     end
     r.turnAround()
    end
    if loc.b == 0 then loc.y = loc.y-1
    elseif loc.b == 1 then loc.x = loc.x-1
    elseif loc.b == 2 then loc.y = loc.y+1
    else loc.x = loc.x+1 end
    return true
end
function up()
  attempt = 0
  while r.detectUp() do
    r.swingUp()
    attempt = attempt +1
    if attempt > 20 then
      snos(1)
      attempt = 0
    end
  end
  while not r.up() do r.swingUp() end
  loc.z = loc.z+1
  return true
end
function down()
  attempt = 0
  while r.detectDown() do
    r.swingDown()
    attempt = attempt + 1
    if attempt > 20 then
      snos(1)
      attempt = 0
    end
  end
  while not r.down() do r.swingDown() end
  loc.z = loc.z-1
  return true
end
function turnRight()
  loc.b = (loc.b+3)%4
  r.turnRight()
end
function turnAround()
  loc.b = (loc.b+2)%4
  r.turnAround()
end
function turnLeft()
  loc.b = (loc.b+1)%4
  r.turnLeft()
end
--=========================ПОВЕРНУТЬ В НУЖНУЮ СТОРОНУ======================--
function povernut(tuda)
  if tuda == 0 and loc.b == 3 then
    turnLeft()
  elseif tuda == 3 and loc.b == 0 then
    turnRight()
  end
  while (loc.b < tuda) do
    turnLeft()
  end
  while loc.b > tuda do
    turnRight()
  end
end
--============================К О П К А    Ж И Л Ы=========================--
function check(b, x, y, z)
  if b[x] == nil then return false end
  if b[x][y] == nil then return false end
  if b[x][y][z] == nil then
    return false
  else
    return true
  end
  return false
end
function zila()
--запись предыдущей позиции
c[u]={x1=loc.x,y1=loc.y,z1=loc.z,b1=loc.b}
--проверка на соседство и добыча блоков
  if check(b, loc.x, loc.y, loc.z+1) then
    r.swingUp()
    up()
    os.sleep(0.2)
    a[  b[loc.x][loc.y][loc.z] ] = {x=l,y=l,z=l}
    b[loc.x][loc.y][loc.z] = nil
    u=u+1
    zila()
  elseif check(b, loc.x, loc.y+1, loc.z) then
    povernut(0)
    u=u+1
    r.swing()
    forward()
    os.sleep(0.2)
    a[ b[loc.x][loc.y][loc.z] ] = {x=l,y=l,z=l}
    b[loc.x][loc.y][loc.z] = nil
    zila()
  elseif check(b, loc.x, loc.y-1, loc.z) then
    povernut(2)
    u=u+1
    r.swing()
    forward()
    os.sleep(0.2)
    a[ b[loc.x][loc.y][loc.z] ] = {x=l,y=l,z=l}
    b[loc.x][loc.y][loc.z] = nil
    zila()
  elseif check(b, loc.x+1, loc.y, loc.z) then
    povernut(1)
    u=u+1
    r.swing()
    forward()
    os.sleep(0.2)
    a[ b[loc.x][loc.y][loc.z] ] = {x=l,y=l,z=l}
    b[loc.x][loc.y][loc.z] = nil
    zila()
  elseif check(b, loc.x-1, loc.y, loc.z) then
    povernut(3)
    u=u+1
    r.swing()
    forward()
    os.sleep(0.2)
    a[b[loc.x][loc.y][loc.z] ] = {x=l,y=l,z=l}
    b[loc.x][loc.y][loc.z] = nil
    zila()
  elseif check(b, loc.x, loc.y, loc.z-1) then
    u=u+1
    r.swingDown()
    down()
    os.sleep(0.2)
    a[ b[loc.x][loc.y][loc.z] ] = {x=l,y=l,z=l}
    b[loc.x][loc.y][loc.z] = nil
    zila()
  else
 --возврат на предыдущую точку если нету блоков по соседству
    u=u-1
    os.sleep(0.2)
    if u>0 then
      if loc.z==c[u].z1 then
         back()
      else
        while c[u].z1>loc.z do
          up()
        end
        while c[u].z1<loc.z do
          down()
        end
      end
      povernut(c[u].b1)
      zila()
    else
      return
    end
  end
end
--=========================ПОИСК БЛИЖАЙШЕГО БЛОКА РУДЫ=====================--
function sravn()
 if n>0 then
  e={a[1].x,a[1].y,a[1].z}
  q=math.abs(a[1].x-loc.x)+math.abs(a[1].y-loc.y) +math.abs(a[1].z-loc.z)
  for i=2,n do
    if q>math.abs(a[i].x-loc.x)+math.abs(a[i].y-loc.y) +math.abs(a[i].z-loc.z) and q~=0 then
       q=math.abs(a[i].x-loc.x)+math.abs(a[i].y-loc.y) +math.abs(a[i].z-loc.z)
       e={a[i].x,a[i].y,a[i].z}
    end
  end
  if q==0 then
    a[b[loc.x][loc.y][loc.z]]={x=l,y=l,z=l}
    sravn()
  end
  else
--если нету полезных блоков
     e={l,l,l}
  end
end
--=======================ВЫБРАСЫВАНИЕ ОТХОДОВ==========================--
function vibros()
  kolMus = 0
  turnAround()
  for MusorSlot=1,allSlots do
   if (inv.getStackInInternalSlot(MusorSlot) ~= nil) then
     if musor[inv.getStackInInternalSlot(MusorSlot).name] then
         r.select(MusorSlot)
         r.drop()
         kolMus = kolMus + 1
      end
    end
  end
  r.select(1)
  turnAround()
end
--Уплотнение Ресурсов в Инвентаре
function uplotnenie(i2)
    for i1 = i2, 1 , -1  do
        while(r.count(i1) == 0 and i1 > 0) do i1 = i1 - 1 end
        if (i1 > 0) then
            r.select(i1)
            local slot = 1
            while (r.transferTo(slot) == false and slot < i1) do slot = slot + 1 end
            i1 = i1 - 1
        end
    end
end
--=========================КОНТРОЛЬ ЭНЕРГИИ============================--
function fuel()
  if (comp.maxEnergy() - comp.energy()) > 500000 then
    if gen.count() == 0 then
      for i=1, allSlots do
        r.select(i)
        if gen.insert() then break end
      end
    end
  end
end
--=========================ВОЗВРАТ ДОМОЙ===============================--
function dom()
local x=loc.x
local y=loc.x
local z=loc.x
  while loc.z<0 do
    r.swingUp()
    up()
  end
  while loc.z>0 do
    r.swingDown()
    down()
  end
    povernut(1)
    while loc.x<0 do
      r.swing()
      forward()
    end
    povernut(2)
    while loc.y>0 do
      r.swing()
      forward()
    end
--выброс мусора
    vibros()
--сброс полезностей
    r.select(1)
    for sl=1,allSlots do
if  inv.getStackInInternalSlot(sl) ~= nil then
if uleyInstr[inv.getStackInInternalSlot(sl).name] ~= true then
  r.select(sl)
  while r.drop() == false do
    os.sleep(0.2)
  end
end
end
    end
    r.select(1)
    turnAround()
    if r.durability() < 0.3 then
      zamena()
    end
    while comp.energy()<comp.maxEnergy() * 0.7 do
      os.sleep(10)
    end
--возврат на предыдущую точку,если нужно
  if not noreturn then
    while loc.y<y do
      forward()
    povernut(1)
    while loc.x>x do
      forward()
    end
    while loc.z>z do
      down()
    end
    while loc.z<z do
      up()
    end
  end
end
end
--==============================УСЛОВИЯ ДЛЯ ВОЗВРАТА ДОМОЙ==============================--
function usl()
  if comp.energy() < comp.maxEnergy() * 0.3 then
   dom()
  end
  if r.count(allSlots-1)>0 then
    vibros()
    uplotnenie(allSlots)
     if kolMus < 2 then
       dom()
     end
   end
  if r.durability() < 0.3 then
    dom()
  end
end
--===============================ГЛАВНЫЙ ЦИКЛ==========================================--
l=1000
-- топорный алгоритм вычисления стороны света(зато без gps)
forward()
s={}
n=0
s[1]=geolyzer.scan(0,2)[33]
s[2]=geolyzer.scan(0,-2)[33]
s[3]=geolyzer.scan(2,0)[33]
s[4]=geolyzer.scan(-2,0)[33]
for r=1,4 do
  if s[r]>2 then
    n=n+1
  end
end
if n>1 then
  turnLeft()
  for r1=1,3 do
    forward()
    a,b = r.detect()
    if b == 'solid' then
      r.swing()
    end
    back()
    turnRight()
  end
  turnAround()
  s[1]=geolyzer.scan(0,2)[33]
  s[2]=geolyzer.scan(0,-2)[33]
  s[3]=geolyzer.scan(2,0)[33]
  s[4]=geolyzer.scan(-2,0)[33]
  a=nil
  b=nil
  n=nil
  r1=nil
end
if s[1]>2 then
  napr=1
elseif s[2]>2 then
  napr=3
elseif s[3]>2 then
  napr=4
else
  napr=2
end
s=nil
for qz=1,z2 do
for qx=1,x2 do
for qy=1,y2 do
-- переезд на точку для скана
while loc.z<20*(qz-1) do
  r.swingUp()
  up()
end
while loc.y<yk+1+(yk*2+1)*(qy-1) do
  r.swing()
  forward()
end
turnRight()
while math.abs(loc.x)<xk+(xk*2+1)*(qx-1) do
  r.swing()
  forward()
end
  turnLeft()
--таблицы для координат полезных блоков
a={}
b={}
n=0
--уровень бедрока если найдёт
z2=19
--сканирование
for x1 = -1 * xk, xk do
  b[x1+loc.x] = {}
  for y1 = -1*yk, yk do
    b[x1+loc.x][y1+loc.y] = {}
    sk=geolyzer.scan(x1,y1)
    for z1=21,45 do
      if sk[z1]>2 and sk[z1]<40 then
        n=n+1
        if napr == 3 then
          a[n] = {x=x1+loc.x,y=y1+loc.y,z=z1+loc.z-33}
        elseif napr  ==  1 then
          a[n] = {x=-x1+loc.x,y=-y1+loc.y,z=z1+loc.z-33}
        elseif napr == 2 then
          a[n] = {x=-y1+loc.x,y=x1+loc.y,z=z1+loc.z-33}
        else
          a[n] = {x=y1+loc.x,y=-x1+loc.y,z=z1+loc.z-33}
        end
      end
      -- поиск бедрока и запись его высоты
      if sk[z1]<0 and z2<z1 and z1<33 then
        z2=z1
      end
    end
  end
end
if n>0 then
  for r1=1,n do
    b[a[r1].x][a[r1].y][a[r1].z] = r1
  end
end
r1=nil
z2=z2-33
--отсев блоков если они ниже бедрока
for i=1,n do
 if a[i].z<=z2+loc.z then
   a[i]={x=l,y=l,z=l}
 end
end
sravn()
--подход к ближайшему блоку
while e[3] < 257 do
  if e[2]>loc.y then
    povernut(0)
  else
    povernut(2)
  end
  for i=1,math.abs(e[2]-loc.y) do
    r.swing()
    forward()
    fuel()
  end
  if e[1]>loc.x then
    povernut(1)
  else
    povernut(3)
  end
  for i=1,math.abs(e[1]-loc.x)-1 do
    r.swing()
    fuel()
    forward()
  end
  while e[3]>loc.z do
    r.swingUp()
    up()
    fuel()
  end
  while e[3]<loc.z do
    r.swingDown()
    down()
    fuel()
  end
--проверка условий
  usl()
--объявление таблицы для функции zila
  u=1
  c={}
  zila()
  while loc.z<=z2 do
    r.swingUp()
    up()
  end
  sravn()
end
--удаление таблиц
a=nil
b=nil
--возврат в один конец
dom(true)
end
end
end