View difference between Paste ID: 0gjBQHk9 and 9e1Y9FCM

 -- Made By Orwell
 -- version 0.2 - 3 june 2012
 --local type
 
 function save(name,table)
 	local h = fs.open(name,"w")
 	table = textutils.serialize(table)
 	h.write(table)
 	h.close()
 end
 
 
 local block_id = {}
 
 block_id[0] = "Air"
 block_id[1] = "Stone"
 block_id[2] = "Grass"
 block_id[3] = "Dirt"
 block_id[4] = "Cobblestone"
 block_id[5] = "Wooden Plank"
 block_id[6] = "Sapling"
 block_id[7] = "Bedrock"
-block_id = {}
+
 block_id[9] = "Stationary water"
 block_id[10] = "Lava"
 block_id[11] = "Stationary lava"
 block_id[12] = "Sand"
 block_id[13] = "Gravel"
 block_id[14] = "Gold Ore"
 block_id[15] = "Iron (Ore)"
 block_id[16] = "Coal Ore"
 block_id[17] = "Log"
 block_id[18] = "Leaves"
 block_id[19] = "Sponge"
 block_id[20] = "Glass"
 block_id[21] = "Lapis Lazuli (Ore)"
 block_id[22] = "Lapis Lazuli (Block)"
 block_id[23] = "Dispenser"
 block_id[24] = "Sandstone"
 block_id[25] = "Note Block Tile entity"
 block_id[26] = "Bed"
 block_id[27] = "Powered Rail "
 block_id[28] = "Detector Rail "
 block_id[29] = "Sticky Piston"
 block_id[30] = "Cobweb"
 block_id[31] = "Tall Grass"
 block_id[32] = "Dead Bush"
 block_id[33] = "Piston"
 block_id[34] = "Piston Extension"
 block_id[35] = "Wool"
 block_id[36] = "Block moved by Piston"
 block_id[37] = "Dandelionandelion"
 block_id[38] = "Rose"
 block_id[39] = "Brown Mushroom"
 block_id[40] = "Red Mushroom"
 block_id[41] = "Block of Gold"
 block_id[42] = "Block of Iron"
 block_id[43] = "Double Slabs"
 block_id[44] = "Slabs"
 block_id[45] = "Brick Block"
 block_id[46] = "TNT"
 block_id[47] = "Bookshelf"
 block_id[48] = "Moss Stone"
 block_id[49] = "Obsidian"
 block_id[50] = "Torch"
 block_id[51] = "Fire"
 block_id[52] = "Monster Spawner"
 block_id[53] = "Wooden Stairs"
 block_id[54] = "Chest"
 block_id[55] = "Redstone (Wire)"
 block_id[56] = "Diamond (Ore)"
 block_id[57] = "Block of Diamond"
 block_id[58] = "Crafting Table"
 block_id[59] = "Seeds"
 block_id[60] = "Farland"
 block_id[61] = "Furnace"
 block_id[62] = "Burning Furnace"
 block_id[63] = "Sign Post"
 block_id[64] = "Wooden Door"
 block_id[65] = "Ladders"
 block_id[66] = "Rails"
 block_id[67] = "Cobblestone Stairs"
 block_id[68] = "Wall Sign"
 block_id[69] = "Lever"
 block_id[70] = "Stone Pressure Plate"
 block_id[71] = "Iron Door"
 block_id[72] = "Wooden Pressure Plates"
 block_id[73] = "Redstone Ore"
 block_id[74] = "Glowing Redstone Ore"
 block_id[75] = "Redstone Torch"
 block_id[76] = "Redstone Torch"
 block_id[77] = "Stone Button "
 block_id[78] = "Snow"
 block_id[79] = "Ice"
 block_id[80] = "Snow Block"
 block_id[81] = "Cactus"
 block_id[82] = "Clay (Block)"
 block_id[83] = "Sugar Cane"
 block_id[84] = "Jukebox"
 block_id[85] = "Fence"
 block_id[86] = "Pumpkin"
 block_id[87] = "Netherrack"
 block_id[88] = "Soul Sand"
 block_id[89] = "Glowstone"
 block_id[90] = "Portal"
 block_id[91] = "Jack-O-Lantern"
 block_id[92] = "Cake Block"
 block_id[93] = "Redstone Repeater"
 block_id[94] = "Redstone Repeater"
 block_id[95] = "Locked Chest"
 block_id[96] = "Trapdoors"
 block_id[97] = "Hidden Silverfish"
 block_id[98] = "Stone Brick"
 block_id[99] = "Huge brown and red mushroom"
 block_id[100] = "Huge brown and red mushroom"
 block_id[101] = "Iron Bars"
 block_id[102] = "Glass Pane"
 block_id[103] = "Melon"
 block_id[104] = "Pumpkin Stem"
 block_id[105] = "Melon Stem"
 block_id[106] = "Vines"
 block_id[107] = "Fence Gate"
 block_id[108] = "Brick Stairs"
 block_id[109] = "Stone Brick Stairs"
 block_id[110] = "Mycelium"
 block_id[111] = "Lily Pad"
 block_id[112] = "Nether Brick"
 block_id[113] = "Nether Brick Fence"
 block_id[114] = "Nether Brick Stairs"
 block_id[115] = "Nether Wart"
 block_id[116] = "Enchantment Table"
 block_id[117] = "Brewing Stand"
 block_id[118] = "Cauldron"
 block_id[119] = "End Portal"
 block_id[120] = "End Portal Frame"
 block_id[121] = "End Stone "
 block_id[256] = "Iron Ingotron Shovel"
 block_id[257] = "Iron Pickaxe"
 block_id[258] = "Iron Axe"
 block_id[259] = "Flint and Steel"
 block_id[260] = "Red Apple"
 block_id[261] = "Bow"
 block_id[262] = "Arrow"
 block_id[263] = "Coal"
 
 local woolColors = {}
 woolColors[0] = "White"
 woolColors[1] = "Orange"
 woolColors[2] = "Magenta"
 woolColors[3] = "Light Blue"
 woolColors[4] = "Yellow"
 woolColors[5] = "Lime"
 woolColors[6] = "Pink"
 woolColors[7] = "Gray"
 woolColors[8] = "Light Gray"
-woolColors = {}
+
 woolColors[10] = "Purple"
 woolColors[11] = "Blue"
 woolColors[12] = "Brown"
 woolColors[13] = "Green"
 woolColors[14] = "Red"
 woolColors[15] = "Black"
 
 --[[
 local tArgs = { ... }
 if #tArgs ~= 1 then
   print("Usage: build <gunzipped schematic file>")
   return
 end
 
 local filename = tArgs[1]
 
 if not fs.exists(filename) then
   print("File does not exist.")
   return
 end
 ]]--
 
 
 local length = 0
 local height = 0
 local width = 0
 local blocks = {}
 local data = {}
 
 function getBlockName(id, blockData)
   blockData = blockData or nil
   if(block_id[id] == nil) then
     return "UNKNOWN"
   else
     if(blockData) then
       if(id == 35) then
         str = woolColors[blockData] .. " " .. block_id[id]
         return str
       end
     end
     return block_id[id]
   end
 end
 
 function getBlockId(x,y,z)
   return blocks[y + z*width + x*length*width + 1]
 end
-  n1 = h.read()
+
-  n2 = h.read()
+
   return data[y + z*width + x*length*width + 1]
 end
 
 function readbytes(h, n)
   for i=1,n do
-  n = n1*256 + n2
+
   end
-  str = ""
+
 
-    c = h.read()
+
   local n1 = h.read()
   local n2 = h.read()
 
   if(n1 == nil or n2 == nil) then
     return ""
   end
 
   local n = n1*256 + n2
 
-  containsName = containsName or true
+  local str = ""
   for i=1,n do
     local c = h.read()
     if c == nil then
       return
     end
     str = str .. string.char(c)
   end
   return str
 end
 
 function parse(a, h, containsName)
   local containsName = containsName or true
   local i,i1,i2,i3,i4
   if a==0 then
     return
   end
   if containsName then
     name = readname(h)
   end
 
   if a==1 then
     readbytes(h,1)
   elseif a==2 then
     i1 = h.read()
     i2 = h.read()
     i = i1*256 + i2
     if(name=="Height") then
       height = i
     elseif (name=="Length") then
       length = i
     elseif (name=="Width") then
       width = i
     end
   elseif a==3 then
     readbytes(h,4)
   elseif a==4 then
     readbytes(h,8)
   elseif a==5 then
     readbytes(h,4)
   elseif a==6 then
     readbytes(h,8)
   elseif a==7 then
     i1 = h.read()
     i2 = h.read()
     i3 = h.read()
     i4 = h.read()
     i = i1*256*256*256 + i2*256*256 + i3*256 + i4
     if name == "Blocks" then
       for i=1,i do
         table.insert(blocks, h.read())
       end
     elseif name == "Data" then
-  	type = h.read()
+
         table.insert(data, h.read())
       end
     else
       readbytes(h,i)
     end
   elseif a==8 then
     i1 = h.read()
     i2 = h.read()
     i = i1*256 + i2
     readbytes(h,i)
   elseif a==9 then
   	--readbytes(h,5)
   	local type = h.read()
   	i1 = h.read()
     i2 = h.read()
     i3 = h.read()
     i4 = h.read()
     i = i1*256*256*256 + i2*256*256 + i3*256 + i4
     for j=1,i do
       parse(h.read(), h, false)
     end
   end
 end
 
 function forward()
   while not turtle.forward() do
     turtle.dig()
   end
 end
 
 function up()
   while not turtle.up() do
     turtle.digUp()
   end
 end
-h = fs.open(filename, "rb")
+
 function down()
-a = 0
+
-while (a ~= nil) do
+
-  a = h.read()
+
-  parse(a, h)
+
 
 function place()
-write("length: " .. length)
+
-write("   width: " .. width)
+
-write("   height: " .. height .. "\n")
+
 end
-uniqueblocks={}
+
-for i,v in ipairs(blocks) do
+
-  found = false
+function setup(filename)
-  for j,w in ipairs(uniqueblocks) do
+--input file
-    -- for now, data is only accounted for when the block is whool
+--returns blocks,data
-    if (w.blockID==v and (w.data==data[i] or w.blockID ~= 35)) then
+--requires parse, getBlockName
-      found = true
+	if not fs.exists(filename) then
-      w.amount = w.amount + 1
+  		error("File "..tostring(filename).." does not exist.")
-      break
+	end
 	h = fs.open(filename, "rb")
 
 	a = 0
-  if found==false then
+	while (a ~= nil) do
-    uniqueblocks[#uniqueblocks+1] = {}
+ 		a = h.read()
-    uniqueblocks[#uniqueblocks].blockID = v
+  		parse(a, h)
-    uniqueblocks[#uniqueblocks].data = data[i]
+	end
-    uniqueblocks[#uniqueblocks].amount = 1
+
 	write("length: " .. length)
 	write("   width: " .. width)
 	write("   height: " .. height .. "\n")
-print("number of block types: " .. #uniqueblocks)
+
-for i,v in ipairs(uniqueblocks) do
+	uniqueblocks={}
-  if (i%9)==0 then
+	for i,v in ipairs(blocks) do
-    read()
+  		found = false
   		for j,w in ipairs(uniqueblocks) do
-  print(" -" .. getBlockName(v.blockID, v.data) .. ": " .. v.amount)
+
 			--[[if (w.blockID==v and (w.data==data[i] or w.blockID ~= 35)) then
       			found = true
       			w.amount = w.amount + 1
       			break
-print("Give the numbers of all slots containing the specified block type:")
+    		end]]--
 
-slots={}
+    		--for now, data is only accounted for when the block is whool
-for i,block in ipairs(uniqueblocks) do
+    		if (w.blockID==v) and (w.data==data[i]) then
-  blockData = block.data
+      			found = true
-  print(" -in which slots is " .. getBlockName(block.blockID, blockData) .. "?")
+      			w.amount = w.amount + 1
-  if not slots[block.blockID] then
+      			break
-    slots[block.blockID] = {}
+    		end
 
-  slots[block.blockID][blockData] = {}
+
-  write("   ")
+
-  str = read()
+
-  for i = 1, #str do
+  		end
-    local c = str:sub(i,i)
+
-    n = tonumber(c)
+  		if found==false then
-    if(n) then
+    		uniqueblocks[#uniqueblocks+1] = {}
-      if(n>0 and n<10) then
+    		uniqueblocks[#uniqueblocks].blockID = v
-        table.insert(slots[block.blockID][blockData], n)
+    		uniqueblocks[#uniqueblocks].data = data[i]
     		uniqueblocks[#uniqueblocks].amount = 1
   		end
 	end
 
 	print("number of block types: " .. #uniqueblocks)
 	for i,v in ipairs(uniqueblocks) do
   		if (i%9)==0 then
     		read()
   		end
   		print(" -" .. getBlockName(v.blockID, v.data) .. ": " .. v.amount)
 	end
 
 	read()
 
 	print("Give the numbers of all slots containing the specified block type:")
 
 	slots={}
 	for i,block in ipairs(uniqueblocks) do
   		blockData = block.data
   		print(" -in which slots is " .. getBlockName(block.blockID, blockData) .. "?")
   		if not slots[block.blockID] then
     		slots[block.blockID] = {}
   		end
   		slots[block.blockID][blockData] = {}
   		write("   ")
   		str = read()
   		for i = 1, #str do
     		local c = str:sub(i,i)
     		n = tonumber(c)
     		if(n) then
       			if(n>0 and n<10) then
         			table.insert(slots[block.blockID][blockData], n)
       			end
    			end
   		end
 	end
 
 	h.close()
 	save("slots",slots)
 	save("blocks",blocks)
 	save("data",data)
 	save("uniqueblocks",uniqueblocks)
 end
 
 
 setup(...)
 -- [[ Iterators ]] --
 
 function checkIfAir()
 	--finds the location to place the next block
     while true do
 	x,y,z = iterate(x,y,z,startx,starty,startz,height-1,width-1,length-1)
 		--makes the turtle build faster by having to travel less
         blockID2 = getBlockId(x,y,z)	-- temporary variable
         blockData2 = getData(x,y,z) 	-- temporary variable
         if slots[blockID2] then
 			-- makes sure the next block to place at location is not air
-end
+            slot_2nd = slots[blockID2][blockData2]
             if slot_2nd then
                 if #slot_2nd > 0 then
                     recordObj(x,y,z)
                     break
                 end
             end
         end
     end
 end
 
 function check(x,y,z,startx,starty,startz)
     if x%2==startx%2 then
         oddx = true
         if y%2==starty%2 then
             oddy = true
         else
             oddy = false
         end
     else
         oddx = false
         if y%2==starty%2 then
             oddy = false
         else
             oddy = true
         end
     end
 	return oddx,oddy
 end
 
 
 function Yiterate(x,y,z,startx,starty,startz,finalx,finaly,finalz)
 
 	local height = finalx
 	local width = finaly
 	local length = finalz
 
     if oddx then
         if y < width then
             y = y + 1
         elseif y == width then
             if x < height then
                 x = x + 1
             --elseif x == height then
                 --x,y,z = "max","max","max"
             end
         end
     else
         if y <= starty then
             if x < height then
                 x = x + 1
 			elseif x == height then
 				x = "max"
 				y = "max"
 				z = "max"
             end
         else
             y=y-1
         end
     end
 	return x,y,z
 end
 
 function iterate(x,y,z,startx,starty,startz,finalx,finaly,finalz)
 
 	local height = finalx
 	local width = finaly
 	local length = finalz
 
 
     local oddx,oddy = check(x,y,z,startx,starty,startz)
     if z == length and oddy then
         x,y,z = Yiterate(x,y,z,startx,starty,startz,finalx,finaly,finalz)
     elseif z == startz and oddy then
         z = z + 1
     elseif z == startz and (not oddy) then
         x,y,z = Yiterate(x,y,z,startx,starty,startz,finalx,finaly,finalz)
     elseif z==length and (not oddy) then
         z = z - 1
 
     elseif z < length then
         if oddy then
             z = z + 1
         else
             z = z - 1
         end
     end
 	return x,y,z
  end
 
 
 -- [[ schematic --> blueprint ]] --
 
 --turtles[i].instructions[n] = {x,y,z,id,data}
 --i = multiturtle ie 1,2,3,4 ; n = step ie 1 - 256 (no air)
 
 --fn splits 16x16 grid between 4 turtles returning startx,y,z and endx,y,z of 4 4x4 grids
 --fn takes each 4x4 grid and turns them into instructions[n] = {x,y,z,id,data}
 --fn for master turtle to setup all slave turtles with the instructions[n] table and goto/find/place functions
 
 
 function blueprint()
 	--uses iterator to make instructions[n] table
 	local x,y,z = 0,0,0
 	local instructions = {}
 	while true do
 		if x == "max" then
 			break
 		end
 		local id = getBlockId(x,y,z)
 		local data = getData(x,y,z)
 		if id > 0 then
 			table.insert(instructions,{x,y,z,id,data})
 		end
 		x,y,z = iterate(x,y,z,0,0,0,height-1,width-1,length-1)
 	end
 	return instructions
 end
 
 
 function createInstructions(startx,starty,startz,height,width,length,nTurtles,placeMode)
 
 	 local x,y,z = startx,starty,startz
 	 instructions = {}
 	 nTurtles = nTurtles or 1
 	 --startx,starty,startz = startx,starty,startz or 0,0,0
 	 placeMode = placeMode or "horizontal"
 	 local oTurtles = {}
 
 	--if horizontal
 	for i = 1,nTurtles do
 		oTurtles[i] = {}
 		if i == tonumber(nTurtles) then
 			oTurtles[tonumber(nTurtles)].responsibleLength = math.floor(x/nTurtles) + (x - (math.floor(x/nTurtles)*nTurtles))
 		else
 			oTurtles[i].responsibleLength =  math.floor(x/nTurtles)
 		end
 		oTurtles[i].startHeight = startx
 		if i == 1 then
 			oTurtles[i].startWidth = starty
 		else
 			oTurtles[i].startWidth = oTurtles[i-1].startWidth + oTurtles[i].responsibleLength
 		end
 		oTurtles[i].startLength = startz
 		oTurtles[i].finalHeight = height-1
 		oTurtles[i].finalWidth = oTurtles[i].startWidth + oTurtles[i].responsibleLength - 1
 		oTurtles[i].finalLength = length-1
 		instructions[i] = {}
 	end
 
 
 
 		for i = 1,nTurtles do
 			x,y,z = startx,starty,startz
 
 
 			while true do
 				local n = #instructions[i]+1
 				instructions[i][n]={}
 				instructions[i][n].x,instructions[1][n].y,instructions[1][n].z = x,y,z
 				instructions[i][n].placeMode = placeMode
 				instructions[i][n].id = getBlockId(x,y,z)
 				instructions[i][n].data = getData(x,y,z)
 				x,y,z = iterate(x,y,z,
 					oTurtles[i].startHeight, oTurtles[i].startWidth, oTurtles[i].startLength,
 					oTurtles[i].finalHeight, oTurtles[i].finalWidth, oTurtles[i].finalLength
 				)
 				--attach methods here
 			end
 
 
 		end
 	return instructions
 end
 
 local ins = blueprint()
 save("instructions",ins)
 
 --[[
 print("Press key to start building...")
 read()
 
 up()
 n = 1
 turtle.select(n)
 
 for x=1,height do
   for y=1,width do
     for z=1,length do
       blockID = getBlockId(x-1,y-1,z-1)
       blockData = getData(x-1,y-1,z-1)
       forward()
       turtle.digDown()
       slot_lst = slots[blockID][blockData]
       if(slot_lst ~= nil) then
         if(#slot_lst > 0) then
           local found=false
           for i,v in ipairs(slot_lst) do
             if(turtle.getItemCount(v) > 0) then
               found=true
               turtle.select(v)
               break
             end
           end
           if not found then
             print("Not enough " .. getBlockName(blockID, blockData) .. ". Please refill...")
             read()
           end
           place()
         end
       end
     end
     turtle.turnLeft()
     forward()
     turtle.turnLeft()
     for i=1,length do
       forward()
     end
     turtle.turnRight()
     turtle.turnRight()
   end
   turtle.turnRight()
   for i=1,width do
     forward()
   end
   turtle.turnLeft()
   up()
 end
 
 for i=1,height+1 do
   down()
 end]]