rubycraft 0.1.0 → 0.1.1

data/lib/rubycraft/matrix3d.rb

@@ -0,0 +1,87 @@
+module RubyCraft
+  class IndexOutOfBoundsError < StandardError
+  
+  end
+
+  class Matrix3d
+    include Enumerable
+
+    def bounds
+      [@xlimit, @ylimit, @zlimit]
+    end
+
+    def initialize(d1,d2,d3)
+      @xlimit = d1
+      @ylimit = d2
+      @zlimit = d3
+      @data = Array.new(d1) { Array.new(d2) { Array.new(d3) } }
+    end
+
+    def [](x, y, z)
+      @data[x][y][z]
+    end
+
+    def []=(x, y, z, value)
+      @data[x][y][z] = value
+    end
+
+    def put(index, value)
+      ar = indexToArray(index)
+      self[*ar] = value
+    end
+
+    def get(index)
+      ar = indexToArray(index)
+      self[*ar]
+    end
+
+    def each(&block)
+      for z in @data
+        for y in z
+          for x in y
+            yield x
+          end
+        end
+      end
+    end
+
+    def each_triple_index(&block)
+      return enum_for:each_triple_index unless block_given?
+      @data.each_with_index do |plane, x|
+        plane.each_with_index do |column, y|
+          column.each_with_index do |value, z|
+            yield value, x ,y ,z
+          end
+        end
+      end
+    end
+
+    #Actually from any iterable
+    def fromArray(ar)
+      ar.each_with_index { |obj,i| put i, obj }
+      return self
+    end
+
+
+    def to_a(default = nil)
+      map do |x|
+        if x.nil?
+          default
+        else
+          x
+        end
+      end
+    end
+
+    protected
+    def indexToArray(index)
+      x = index / (@zlimit * @ylimit)
+      index -= x * (@zlimit * @ylimit)
+      y = index / @zlimit
+      z = index % @zlimit
+      return x, y, z
+    end
+
+
+  end
+end

data/lib/rubycraft/nbt_helper.rb

@@ -0,0 +1,49 @@
+require 'nbtfile'
+require 'zlib'
+require 'rubycraft/byte_converter'
+# Patching nbtfile clases so that they don't gzip/ungzip incorrectly the zlib bytes from
+#mcr files. Use the methods from ZlibHelper
+class NBTFile::Private::Tokenizer
+  def initialize(io)
+    @gz = io
+    @state = NBTFile::Private::TopTokenizerState.new
+  end
+end
+
+class NBTFile::Emitter
+  def initialize(stream)
+    @gz = stream
+    @state = NBTFile::Private::TopEmitterState.new
+  end
+end
+
+module RubyCraft
+  module ZlibHelper
+    def compress(str)
+      Zlib::Deflate.deflate(str)
+    end
+
+    def decompress(str)
+      Zlib::Inflate.inflate(str)
+    end
+    extend self
+  end
+
+  # Handles converting bytes to/from nbt regions, which are compressesed/decompress
+  module NbtHelper
+    extend ByteConverter
+    extend ZlibHelper
+
+    module_function
+    def fromNbt(bytes)
+      NBTFile.read stringToIo decompress toByteString bytes
+    end
+
+    def toBytes(nbt)
+      output = StringIO.new
+      name, body = nbt
+      NBTFile.write(output, name, body)
+      stringToByteArray compress output.string
+    end
+  end
+end

data/lib/rubycraft/region.rb

@@ -0,0 +1,259 @@
+require 'rubycraft/chunk'
+
+module RubyCraft
+  class LazyChunkDelegate
+    include ByteConverter
+    include ZlibHelper
+
+    def initialize(bytes)
+      @bytes = bytes
+      @chunk = nil
+    end
+
+    def each(&block)
+      _getchunk.each &block
+    end
+  
+    def block_map(&block)
+      _getchunk.block_map &block
+    end
+    def block_type_map(&block)
+      _getchunk.block_type_map &block
+    end
+
+    def [](z, x, y)
+      _getchunk[z, x, y]
+    end
+
+    def []=(z, x, y, value)
+      _getchunk[z, x, y] = value
+    end
+
+    def export
+      _getchunk.export
+    end
+
+
+    def toNbt
+      return @bytes if @chunk.nil?
+      @chunk.toNbt
+    end
+
+
+    # unloacs the loaded chunk. Needed for memory optmization
+    def _unload
+      return if @chunk.nil?
+      @bytes = @chunk.toNbt
+      @chunk = nil
+    end
+
+    protected
+    def _getchunk
+      if @chunk.nil?
+        @chunk = Chunk.fromNbt @bytes
+      end
+      @chunk
+    end
+
+  end
+
+  # Enumerable over chunks
+  class Region
+    include Enumerable
+    include ByteConverter
+    include ZlibHelper
+  
+    class RegionWritter
+      def initialize(io)
+        @io = io
+      end
+
+      def pad(count, value = 0)
+        self << Array.new(count) { value }
+      end
+
+      def <<(o)
+        input = o.kind_of?(Array) ? o : [o]
+        @io <<  ByteConverter.toByteString(input)
+      end
+
+      def close
+        @io.close
+      end
+    end
+
+    def self.fromFile(filename)
+      new ByteConverter.stringToByteArray IO.read filename
+    end
+
+    def initialize(bytes)
+      raise "Must be an io" if bytes.kind_of?(String)
+      @bytes = bytes
+      @chunks = Array.new(32) { Array.new(32) }
+      readChunks bytes
+    end
+
+    def chunk(z, x)
+      @chunks[z][x]
+    end
+
+    def unloadChunk(z, x)
+      @chunks[z][x]._unload
+    end
+
+    def each(&block)
+      @chunks.each do |line|
+        line.each do |chunk|
+          yield chunk
+        end
+      end
+    end
+
+    def cube(z, y, x, opts = {}, &block)
+      c = ChunkCube.new(self, [z, y, x], opts[:width], opts[:length], opts[:height])
+      return c unless block_given?
+      c.each &block
+    end
+
+    def exportTo(io)
+      output = RegionWritter.new io
+      chunks = getChunks
+      writeChunkOffsets output, chunks
+      output.pad blockSize, dummytimestamp
+      writeChunks output, chunks
+      output.close
+    end
+
+    def exportToFile(filename)
+      File.open(filename, "wb") { |f| exportTo f }
+    end
+
+
+    protected
+    def readChunks(bytes)
+      bytes[0..(blockSize - 1)].each_slice(4).each_with_index do |ar, i|
+        offset = bytesToInt [0] + ar[0..-2]
+        count = ar.last
+        if count > 0
+          @chunks[i / 32][i % 32 ] = readChunk(offset, bytes)
+        end
+      end
+    end
+
+    def readChunk(offset, bytes)
+      o = offset * blockSize
+      bytecount = bytesToInt bytes[o..(o + 4)]
+      o += 5
+      nbtBytes = bytes[o..(o + bytecount - 2)]
+      LazyChunkDelegate.new nbtBytes
+    end
+
+    def chunkSize(chunk)
+      chunk.size + chunkMetaDataSize
+    end
+
+    def chunkBlocks(chunk)
+      ((chunkSize chunk).to_f / blockSize).ceil
+    end
+
+    def writeChunks(output, chunks)
+      for chunk in chunks
+        next if chunk.nil?
+        output << intBytes(chunk.size + 1)
+        output << defaultCompressionType
+        output << chunk
+        remaining = blockSize - chunkSize(chunk)
+        output.pad remaining % blockSize
+      end
+    end
+
+    def writeChunkOffsets(output, chunks)
+      lastVacantPosition = 2
+      for chunk in chunks
+        if chunk
+          sizeCount = chunkBlocks chunk
+          output << intBytes(lastVacantPosition)[1..3]
+          output << sizeCount
+          lastVacantPosition += sizeCount
+        else
+          output.pad 4
+        end
+      end
+    end
+
+    def getChunks
+      map do |chunk|
+        if chunk.nil?
+          nil
+        else
+          chunk.toNbt
+        end
+      end
+    end
+  
+    def chunkMetaDataSize
+      5
+    end
+
+    def defaultCompressionType
+      2
+    end
+
+    def dummytimestamp
+      0
+    end
+
+    def blockSize
+      4096
+    end
+
+  end
+
+
+  class ChunkCube
+    include Enumerable
+
+    # width corresponds do z, length to x, and height to y.
+    def initialize(region, initialPos, width, length, height)
+      @region = region
+      @initialPos = initialPos
+      @width = width || 1
+      @length = length || 1
+      @height = height || 1
+    end
+
+    def each(&block)
+      z, x, y = @initialPos
+      firstChunkX = x / chunkSide
+      firstChunkZ = z / chunkSide
+      lastChunkX = (x + @length - 1) / chunkSide
+      lastChunkZ = (z + @width - 1) / chunkSide
+      for j in firstChunkZ..lastChunkZ
+        for i in firstChunkX..lastChunkX
+          iterateOverChunk j, i, &block
+        end
+      end
+    end
+
+    protected
+    def iterateOverChunk(j, i, &block)
+      chunk = @region.chunk(j, i)
+      return if chunk.nil?
+      z, x, y = @initialPos
+      chunk.each do |b|
+        globalZ = b.z + (j * chunkSide)
+        globalX = b.x + (i * chunkSide)
+        if globalZ.between?(z, z + @width - 1) and
+            globalX.between?(x, x + @length - 1) and
+            b.y.between?(y, y + @height - 1)
+          yield b, globalZ - z, globalX - x , b.y - y
+        end
+      end
+      @region.unloadChunk(j, i)
+    end
+
+    def chunkSide
+      16
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rubycraft
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Daniel Ribeiro
@@ -48,13 +48,14 @@ files:
 - README.md
 - Rakefile
 - VERSION
-- lib/block.rb
-- lib/block_type.rb
-- lib/byte_converter.rb
-- lib/chunk.rb
-- lib/matrix3d.rb
-- lib/nbt_helper.rb
-- lib/region.rb
+- lib/rubycraft.rb
+- lib/rubycraft/block.rb
+- lib/rubycraft/block_type.rb
+- lib/rubycraft/byte_converter.rb
+- lib/rubycraft/chunk.rb
+- lib/rubycraft/matrix3d.rb
+- lib/rubycraft/nbt_helper.rb
+- lib/rubycraft/region.rb
 has_rdoc: true
 homepage: http://github.com/danielribeiro/RubyCraft
 licenses: []

data/lib/block.rb

@@ -1,77 +0,0 @@
-require 'block_type'
-
-# A minecraft block. Its position is given by a coord[x, z, y]
-class Block
-
-  attr_accessor :block_type, :pos, :data
-  def initialize(blockType, data = 0)
-    @blockType = blockType
-    @data = 0
-  end
-
-  def self.get(key)
-    new BlockType.get key
-  end
-
-  def self.of(key)
-    self[key]
-  end
-
-  def self.[](key)
-    new BlockType[key]
-  end
-
-
-  def color=(color)
-    @data = BlockColor::InvertedColor[color]
-  end
-
-  def color
-    BlockColor.typeColor[@data].name
-  end
-
-  def blockColor
-    BlockColor.typeColor[@data]
-  end
-
-  def is(name)
-    self.name == name.to_s
-  end
-
-  def name
-    @blockType.name
-  end
-
-  def id
-    @blockType.id
-  end
-
-  def transparent
-    @blockType.transparent
-  end
-
-  #sets block type by name
-  def name=(newName)
-    return if name == newName.to_s
-    @blockType = BlockType[newName]
-  end
-
-  #sets block type by id
-  def id=(id)
-    return if id == id
-    @blockType = BlockType.get id
-  end
-
-  def y
-    pos[2]
-  end
-
-  def z
-    pos[1]
-  end
-
-  def x
-    pos[0]
-  end
-end
-