Turtle Simulation on Computer

--block={"item",count,1/chance}
local drops = {stone={"cobblestone"},coal_ore={"coal"},redstone_ore={"redstone",4,2,"redstone",5},grass={"dirt"},diamond_ore={"diamond"}}
--{"block",minDepth,1/chance}
local mapGen = {{"iron_ore",4,60},{"coal_ore",5,40},{"gold_ore",25,90},{"redstone_ore",40,70},{"diamond_ore",45,200}}
--{"result",{"item",firstslot,secondslot},{"nextitem",slot}}
local craftings = {{"chest",{"planks",1,2,3,5,7,9,10,11}},{"furnace",{"cobblestone",1,2,3,5,7,9,10,11}},{"planks",{"log",1}}}
local colorMap = {stone=colors.gray,dirt=colors.brown,[false]=colors.black,grass=colors.green,coal_ore=colors.brown,bedrock=colors.lime,cobblestone=colors.gray,iron_ore=colors.orange,gold_ore=colors.yellow,diamond_ore=colors.lightBlue,redstone_ore=colors.red}
local containers = {chest=27,dispenser=9,dropper=9,hopper=5}
local fuels = {coal=80,planks=15,log=15,sticks=5}
local env = {shell=shell,multishell=multishell}

local args = {...}
env.turtle = {}
local t = env.turtle
local mu
if multishell then
mu = {launch=function(pEnv, ...) return multishell.launch(pEnv,"rom/programs/shell",...) end}
setmetatable(mu,{__index=multishell})
end
local isUsedBy = 0
local s
s = {run=function(wEnv, ...)
if not wEnv.turtle then
wEnv.turtle = t
wEnv.os = s
wEnv.multishell = mu
end
isUsedBy = isUsedBy + 1
_G.os.run(wEnv, ...)
isUsedBy = isUsedBy - 1
if isUsedBy == 0 then
os.queueEvent("simulator_exit")
end
end}
setmetatable(s,{__index=os})
env.os = s
env.multishell=mu
local ti = {fx=1,fz=0,x=0,y=0,z=0,fuel=1000,fuelMax=20000,inv={},slot=1,eL="minecraft:diamond_pickaxe",eR="minecraft:crafting_table",delay=0.4}

local map = {}
local function setM(v,x,y,z)
 if not map[x] then
   map[x]={}
 end
 if not map[x][y] then
   map[x][y]={}
 end
 map[x][y][z]=v
end
local function getM(x,y,z,gen)
  if not map[x] or not map[x][y] or map[x][y][z] == nil then
    if gen ~= false then
      local b = "stone"
      if y >= 0  or y < -60 then
        b = false
      elseif y == -1 then
        b = "grass"
      elseif y > -5 then
        b = "dirt"
      elseif y == -60 then
        b = "bedrock"
      else
        for i,j in ipairs(mapGen) do
          if y < -j[2] then
            if math.random(j[3]) == 1 then
              b = j[1]
              break
            end
          else
            break
          end
        end
      end
      setM(b,x,y,z)
      return b
    end
    return nil
  else
    return map[x][y][z]
  end
end
local x,y= term.getSize()
local mX,mY = 5,5
local oT = term.current()
local mW = window.create(oT,1,1,x-mX-8,y)
term.redirect(mW)

local tOrient = {">","^","B",[-3]="F",[-2]="V",[-1]="<"}

local function drawMap(px,py,sx,sy,dim,off,static)
  local lx1,lx2,ly,lz,ix,iy
  if static then
    lx1,lx2,ly,lz = ti.x-(ti.x-sy)%sy+sy,ti.x-ti.x%sx,ti.y-(ti.y-sy)%sy+sy,ti.z-ti.z%sx
    if dim == 1 then
      ix,iy = ti.z-lz,(ly-ti.y)%sy
    elseif dim == 2 then
      ix,iy = ti.z-lz,(lx1-ti.x)%sy
    else
      ix,iy = ti.x-lx2,(ly-ti.y)%sy
    end
  else
    lx1,lx2,ly,lz = ti.x+sy/2-0.5,ti.x-sx/2+0.5,ti.y+sy/2-0.5,ti.z-sx/2+0.5
    ix,iy = sx/2-0.5,sy/2-0.5
  end
  local o=off or 0
  for i=0,sy-1 do
    oT.setCursorPos(px,py+i)
    for j=0,sx-1 do
      if (i==iy) and (j==ix) then
        oT.setBackgroundColor(colors.lightGray)
        oT.write(tOrient[dim==1 and ti.fx*3+ti.fz or dim==2 and ti.fx*2+ti.fz or ti.fx-3*ti.fz])
      else
        if dim == 1 then
          oT.setBackgroundColor(colorMap[getM(ti.x+o,ly-i,lz+j)] or colors.magenta)
        elseif dim == 2 then
          oT.setBackgroundColor(colorMap[getM(lx1-i,ti.y+o,lz+j)] or colors.magenta)
        else
          oT.setBackgroundColor(colorMap[getM(lx2+j,ly-i,ti.z+o)] or colors.magenta)
        end
        oT.write(" ")
      end
    end
  end
  oT.setBackgroundColor(colors.black)
end

local function drawInv(px,py,maxw,start)
  for i=start or 1,math.min(16,y+(start or 1)-1) do
    oT.setCursorPos(px,py+i-1)
    if ti.inv[i] then
      oT.write(string.format("%2d %s           ",ti.inv[i].count,ti.inv[i].name:match(":(.*)")):sub(1,maxw))
    else
      oT.write("   Empty")
    end
  end
end
local drawCounter = 0
local function updateMap()
  if drawCounter == 0 then
  drawMap(x-mX+1,1,mX,mY,2,0)
  drawMap(x-mX+1,7,mX,mY,1,0)
  drawMap(x-mX+1,13,mX,mY,3,0)
  drawInv(x-mX-7,1,8)
  oT.setCursorPos(x-mX+1,y-1)
  oT.write(table.concat({ti.x,ti.y}," ").."  ")
  oT.setCursorPos(x-mX+1,y)
  oT.write(tostring(ti.z).." ")
  mW.restoreCursor()
  end
end

local mutex = false
local isWaiting = false
local function wait()
  if ti.delay >= 0 then
    while mutex do
      isWaiting = true
      os.pullEvent("turtle")
    end
    mutex = true
    local te,err = pcall(sleep,ti.delay) --because of terminate
    mutex = false
    if isWaiting then
      isWaiting = false
      os.queueEvent("turtle")
    end
    if not te then
      error(err,0)
    end
  else
    drawCounter = drawCounter - 1
    if drawCounter <= ti.delay then
      os.queueEvent("turtle")
      os.pullEvent("turtle")
      drawCounter = 0
    end
  end
end

t.getSelectedSlot = function() return ti.slot end
t.select = function(s) if type(s) == "number" and s>=1 and s<=16 then ti.slot = math.floor(s) end end
t.getFuelLimit = function() return ti.fuelMax end
t.getFuelLevel = function() return ti.fuel end
t.getItemCount = function(s) return ti.inv[s or ti.slot] and ti.inv[s or ti.slot].count or 0 end
t.getItemSpace = function(s) return ti.inv[s or ti.slot] and 64-ti.inv[s or ti.slot].count or 64 end
t.getItemDetail = function(s) return ti.inv[s or ti.slot] end

t.refuel = function(n)
if not ti.inv[ti.slot] then
return false,"No Items to refuel"
end
if not fuels[ti.inv[ti.slot].name:match(":(.*)")] then
return false,"Item isn't burnable"
end
if ti.fuel == "unlimited" then
return false,"Unnesseary"
end
n=n or 64
if type(n) ~= "number" or math.floor(n) ~= n or n < 0 then
return false,"Invalid Parameter"
end
local c = math.min(n,ti.inv[ti.slot].count)
ti.fuel=ti.fuel + fuels[ti.inv[ti.slot].name:match(":(.*)")] * c
ti.inv[ti.slot].count = ti.inv[ti.slot].count - c
if ti.inv[ti.slot].count == 0 then
ti.inv[ti.slot] = nil
end
return true
end

local function p(f,u)
  return ti.x+ti.fx*f,ti.y+u,ti.z+ti.fz*f
end

t.turnLeft = function()
  wait()
  ti.fx,ti.fz=ti.fz,-ti.fx
  updateMap()
  return true
end

t.turnRight = function()
  wait()
  ti.fx,ti.fz=-ti.fz,ti.fx
  updateMap()
  return true
end

local function move(f,u)
  return function()
    wait()
    if ti.fuel == 0 then
      return false,"No fuel"
    end
    if getM(p(f,u)) then
      return false,"Path obstruced"
    end
    ti.x,ti.y,ti.z = p(f,u)
    if ti.fuel ~= "unlimited" then
      ti.fuel=ti.fuel-1
    end
    updateMap()
    return true
  end
end
t.back = move(-1,0)
t.forward = move(1,0)
t.up = move(0,1)
t.down = move(0,-1)

local function det(f,u)
  return function()
    --wait()
    return getM(p(f,u)) ~= false
  end
end

local function addToInv(item,startWithSlot,slotCount)
  local s= startWithSlot or ti.slot
  for i=1,slotCount or 16 do
    if not ti.inv[s] then
      ti.inv[s] = item
      return true
    end
    if ti.inv[s].damage == item.damage and ti.inv[s].name == item.name then
      if t.getItemSpace(s) - item.count < 0 then
        item.count = item.count - t.getItemSpace(s)
        ti.inv[s].count = ti.inv[s].count + t.getItemSpace(s)
      else
        ti.inv[s].count = ti.inv[s].count + item.count
        return true
      end
    end
    s=s%16+1
  end
  return false
end

t.transferTo = function(s,n)
  if s == ti.slot then
    return false,"Same Slot"
  end
  if not ti.inv[ti.slot] then
    return false,"No items to transfer"
  end
  if t.getItemSpace(s) == 0 then
    return false,"Target Slot is full"
  end
  n = n or 64
  s = s or -1 --Invalid
  if s < 1 or s > 16 or n < 1 or math.floor(s) ~= s or math.floor(n) ~= n then
    return false,"Invalid Parameter"
  end
  if not ti.inv[s] then
    ti.inv[s] = {name=ti.inv[ti.slot].name,damage=ti.inv[ti.slot].damage,count=0}
  end
  if ti.inv[ti.slot].name ~= ti.inv[s].name or ti.inv[ti.slot].damage ~= ti.inv[s].damage then
    return false,"Not same items"
  end
  local tcount = math.min(n,ti.inv[ti.slot].count,t.getItemSpace(s))
  ti.inv[ti.slot].count = ti.inv[ti.slot].count - tcount
  ti.inv[s].count = ti.inv[s].count + tcount
  if ti.inv[ti.slot].count == 0 then
    ti.inv[ti.slot] = nil
  end
  updateMap()
  return true
end

local function dg(f,u)
  return function()
    wait()
    local b = getM(p(f,u))
    if b == false then
      return false,"No block"
    end
    if b == "bedrock" then
      return false,"Cant break bedrock"
    end
    local i = {count=1,damage=0,name="minecraft:"..b}
    if drops[b] then
      local alts = 1
      repeat
        i.name="minecraft:"..drops[b][alts]
        i.count = drops[b][alts+1] or i.count
        alts = alts + 3
      until not drops[b][alts-1] or math.random(drops[b][alts-1]) == 1
    end
    addToInv(i)
    setM(false,p(f,u))
    updateMap()
    return true
  end
end

local function ins(f,u)
  return function()
    wait()
    local b=getM(p(f,u))
    if b~=false then
      return true,"minecraft:"..b
    end
    return false
  end
end

local function plc(f,u)
  return function()
    wait()
    if getM(p(f,u)) then
      return false,"There is allready a block"
    end
    if not ti.inv[ti.slot] then
      return false,"No block selected"
    end
    ti.inv[ti.slot].count = ti.inv[ti.slot].count-1
    local n=ti.inv[ti.slot].name
    if ti.inv[ti.slot].count == 0 then
      ti.inv[ti.slot] = nil
    end
    setM(n:match("minecraft:(.*)"),p(f,u))
    updateMap()
    return true
  end
end

local function drp(s)
  if not ti.inv[ti.slot] then
    return false,"Slot empty"
  end
  s=tonumber(s)
  if s and ti.inv[ti.slot].count>s then
    ti.inv[ti.slot].count = ti.inv[ti.slot].count - s
    return true
  end
  ti.inv[ti.slot] = nil
  updateMap()
  return true
end
local function drpa()
 return drp
end

local allDirs = {dig=dg,inspect=ins,detect=det,place=plc,drop=drpa}
for i,j in pairs(allDirs) do
  t[i] = j(1,0)
  t[i.."Up"] = j(0,1)
  t[i.."Down"] = j(0,-1)
end

local randB = function()
wait()
return math.random(2) == 1
end
setmetatable(t,{__index=function() return randB end})

--local args = {...}
local resultTurtle
local resultMap
local result
local options = {
delay=function(s) ti.delay = tonumber(s) end,
nodelay=function() ti.delay = -1 return true end,
lconf=function(s) ti = dofile(s) or ti end,
sconf=function(s) resultTurtle=s end,
map=function(s) map = dofile(s) or map end,
smap=function(s) resultMap=s end,
load=function(s) local a,b = dofile(s) ti=a or ti map=b or map end,
saveas=function(s) result = s end,
fuel=function(s) ti.fuel = tonumber(s) or ti.fuel end,
nofuel=function() ti.fuel = "unlimited" return true end,
bigmap=function() ti.useMulti = true return true end}
options.save=options.saveas
options.newtab=options.bigmap
options.use = function(s) if fs.exists(s) then options.load(s) end options.save(s) end
options.conf = function(s) if fs.exists(s) then options.lconf(s) end options.sconf(s) end

local argsP = 1
while options[string.lower(args[argsP] or "")] do
argsP = argsP + (options[args[argsP]](args[argsP+1]) and 1 or 2)
end

local oPath = shell.path()
if not string.match(oPath,"rom/programs/turtle") then
  shell.setPath(oPath..":rom/programs/turtle")
else
  oPath = nil
end
if ti.useMulti and multishell then
  updateMap = function() drawMap(1,1,y,y,1) end
  os.run(env,"rom/programs/shell","fg",unpack(args,argsP))
  mW.setVisible(false)
  multishell.getTitle(multishell.getCurrent(),"Map")
else
  updateMap()
  os.run(env,"rom/programs/shell",unpack(args,argsP))
  if isUsedBy > 0 then
    print("Waiting for remaining programs to exit")
  end
end
while isUsedBy > 0 do
  os.pullEvent("simulator_exit")
end
if oPath then
  shell.setPath(oPath)
end
if result then
local f = fs.open(result,"w")
f.write("return ")
f.write(textutils.serialize(ti))
f.write(",")
f.write(textutils.serialize(map))
f.close()
end

if resultTurtle then
local f = fs.open(resultTurtle,"w")
f.write("return ")
f.write(textutils.serialize(ti))
f.close()
end

if resultMap then
local f = fs.open(resultMap,"w")
f.write("return ")
f.write(textutils.serialize(map))
f.close()
end

oT.clear()
mW.redraw()