rubycraft 0.1.0

data/README.md

@@ -0,0 +1,83 @@
+RubyCraft
+==============
+
+RubyCraft is a simple library for manipulating [Minecraft](http://www.minecraft.net/)
+region files.
+
+Region files are files with the mcr extension on the region folder of a save folder. The
+save folders are located below the saves folder of the minecraft data folder (for
+instance, on Linux it is ~/.minecraft/saves/$SAVENAME/region, and on mac it is
+~/Library/Application Support/minecraft/$SAVENAME/region). More about save folders
+[here](http://www.minecraftwiki.net/wiki/Tutorials/Minecraft_Help_FAQ#Common_fixes).
+
+
+Quick Example
+--------
+        filename = " ~/.minecraft/saves/$SAVENAME/region/r.0.0.mcr"
+        r = Region.fromFile(filename)
+        r.chunk(0, 0).block_map { :gold }
+        r.exportToFile filename
+
+For more examples, check the
+[examples](https://github.com/danielribeiro/RubyCraft/tree/master/examples) folder.
+
+Regions
+---------
+When getting many chunks from Region#chunk method, don't forget to invoke Region#unloadChunk(z,
+x). This way the chunk will not occupy memory.
+
+Alternatively you can use the Region#cube method. Example
+
+              r = Region.fromFile(filename)
+              c = r.cube(0, 0, 0, :width => 50, :length => 50, :height => 128)
+              c.each do |block, z, x, y|
+                     block.name = :wool
+                     block.color = :orange
+              end
+
+It receives the z, x, y of the origin point of the cube, and its respective width, length
+and height. The chunk load/unload is abstracted way on this interface. The cube can
+receive a block, or it will return an Enumerable that iterates over the blocks of the
+cube. The proc receives four arguments: the block, and its relative coordinates to the
+cube's origin point.
+
+Chunks
+---------
+Chunks are both enumerable and indexable:
+
+       chunk[0, 0, 0].name = :gold
+       chunk.each { |block| block.name = :gold }
+
+
+Note that chunks have size 16x16x128 (width, length, height). Usually you don't create
+chunks directly, but get them through Region#chunk method.
+
+Blocks
+---------
+Blocks have 3 attributes: block_type, pos and data. [Block type](https://github.com/danielribeiro/RubyCraft/blob/master/lib/block_type.rb) tells the name, id and
+transparency (boolean) of the block. The pos attribute indicates the position of the block
+inside its chunk, and data is the integer [data
+value](http://www.minecraftwiki.net/wiki/Data_values).
+
+Id is not usually accessed directly, as the name attribute provides a more friendly
+interface. For wool blocks, changing the color directly is also possible in a more
+friendly way.
+
+         block.name = :wool
+         block.color = :purple
+         p block.color
+
+
+Dependencies:
+---------
+[Nbtfile](http://github.com/mental/nbtfile)
+
+Meta
+----
+
+Created by Daniel Ribeiro
+
+Released under the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+http://github.com/danielribeiro/RubyCraft
+

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rubycraft"
+    gem.summary = %Q{Lib for manipualting Minecraft world files}
+    gem.description = %Q{It allows you to change all the
+blocks in region files in whatever way you see fit. Example: http://bit.ly/r62qGo}
+    gem.email = "danrbr@gmail.com"
+    gem.homepage = "http://github.com/danielribeiro/RubyCraft"
+    gem.authors = ["Daniel Ribeiro"]
+    gem.add_dependency 'nbtfile', '>=0.2.0'
+    gem.files = FileList["[A-Z]*", "{bin,lib}/**/*"]
+#    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "RubyCraft Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*spec.rb']
+  t.libs << Dir["lib"]
+end
+
+desc "Acceptance test"
+task :atest do
+  require 'spec/acceptanceEdit'
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/block.rb

@@ -0,0 +1,77 @@
+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
+

data/lib/block_type.rb

@@ -0,0 +1,191 @@
+BlockTypeDSL = proc do
+  transparent_block 0, :air
+  block 1, :stone
+  block 2, :grass
+  block 3, :dirt
+  block 4, :cobblestone
+  block 5, :planks
+  transparent_block 6, :sapling
+  block 7, :bedrock
+  block 8, :watersource
+  block 9, :water
+  block 10, :lavasource
+  block 11, :lava
+  block 12, :sand
+  block 13, :gravel
+  block 14, :goldore
+  block 15, :ironore
+  block 16, :coal
+  block 17, :log
+  block 18, :leaves
+  block 19, :sponge
+  transparent_block 20, :glass
+  block 21, :lapisore
+  block 22, :lapis
+  block 23, :dispenser
+  block 24, :sandstone
+  block 25, :note
+  block 26, :bed
+  transparent_block 27, :powered_rail
+  transparent_block 28, :detector_rail
+  block 29, :sticky_piston
+  transparent_block 30, :cobweb
+  transparent_block 31, :tall_grass
+  transparent_block 32, :dead_shrubs
+  block 33, :piston
+  block 34, :piston_extension
+  block 35, :wool
+  transparent_block 37, :dandelion
+  transparent_block 38, :rose
+  transparent_block 39, :brown_mushroom
+  transparent_block 40, :red_mushroom
+  block 41, :gold
+  block 42, :iron
+  block 43, :slabs
+  block 44, :slab
+  block 45, :brick
+  block 46, :tnt
+  block 47, :bookshelf
+  block 48, :mossy
+  block 49, :obsidian
+  transparent_block 50, :torch
+  transparent_block 51, :fire
+  block 52, :spawner
+  block 53, :stairs
+  block 54, :chest
+  transparent_block 55, :redstone_wire
+  block 56, :diamond_ore
+  block 57, :diamond_block
+  block 58, :crafting_table
+  block 59, :seeds
+  block 60, :farmland
+  block 61, :furnace
+  block 62, :burning_furnace
+  transparent_block 63, :signpost
+  transparent_block 64, :door
+  transparent_block 65, :ladder
+  transparent_block 66, :rails
+  block 67, :cobblestone_stairs
+  transparent_block 68, :wall_sign
+  transparent_block 69, :lever
+  transparent_block 70, :stone_pressure_plate
+  transparent_block 71, :iron_door
+  transparent_block 72, :wooden_pressure_plate
+  block 73, :redstone_ore
+  block 74, :glowing_redstone_ore
+  transparent_block 75, :redstone_torch_off
+  transparent_block 76, :redstone_torch_on
+  transparent_block 77, :stone_button
+  block 78, :snow
+  block 79, :ice
+  block 80, :snow_block
+  transparent_block 81, :cactus
+  block 82, :clay
+  block 83, :sugar_cane
+  block 84, :jukebox
+  transparent_block 85, :fence
+  block 86, :pumpkin
+  block 87, :netherrack
+  block 88, :soulsand
+  block 89, :glowstone
+  transparent_block 90, :portal
+  block 91, :jock_o_lantern
+  transparent_block 92, :cake
+  transparent_block 93, :repeater_off
+  transparent_block 94, :repeater_on
+  block 95, :locked_chest
+  transparent_block 96, :trapdoor
+end
+
+
+# DSL: color name r, g, b
+BlockColorDSL = proc do
+  white 221, 221, 221
+  orange 233, 126, 55
+  magenta 179, 75, 200
+  light_blue 103, 137, 211
+  yellow 192, 179, 28
+  light_green 59, 187, 47
+  pink 217, 132, 153
+  dark_gray 66, 67, 67
+  gray 157, 164, 165
+  cyan 39, 116, 148
+  purple 128, 53, 195
+  blue 39, 51, 153
+  brown 85, 51, 27
+  dark_green 55, 76, 24
+  red 162, 44, 42
+  black 26, 23, 23
+end
+
+class BlockColor
+  @typeColor = []
+
+  def self.method_missing(name, *args)
+    args << @typeColor.size
+    @typeColor << new(name, *args)
+  end
+
+  def self.typeColor
+    @typeColor
+  end
+
+  attr_reader :name, :r, :g, :b, :data
+  def initialize(name, r, g, b, data)
+    @name = name
+    @r = r
+    @g = g
+    @b = b
+    @data = data
+  end
+
+  def rgb
+    [r, g, b]
+  end
+
+  class_eval &BlockColorDSL
+  InvertedColor = Hash[typeColor.each_with_index.map { |obj, i| [obj.name, i] }]
+end
+
+# class methods and dsl for block
+class BlockType
+  @blocks = {}
+  @blocks_by_name = {}
+  attr_reader :id, :name, :transparent
+  
+  def initialize(id, name, transparent)
+    @id = id
+    @name = name.to_s
+    @transparent = transparent
+  end
+
+  def self.block(id, name, transparent = false)
+    block = new id, name, transparent
+    @blocks[id] = block
+    @blocks_by_name[name.to_s] = block
+
+  end
+
+  def self.transparent_block(id, name)
+    block id, name, true
+  end
+
+  def self.get(key)
+    if @blocks.has_key?(key)
+      return @blocks[key].clone
+    end
+    new(key, "unknown(#{key})", false)
+  end
+
+  def self.of(key)
+    self[key]
+  end
+
+  def self.[](key)
+    key = key.to_s
+    return @blocks_by_name[key] if @blocks_by_name.has_key?(key)
+    raise "no such name: #{key}"
+  end
+
+  class_eval &BlockTypeDSL
+end

data/lib/byte_converter.rb

@@ -0,0 +1,46 @@
+require 'stringio'
+
+# Utils for manipulating bytes back and forth as strings, strings and numbers
+module ByteConverter
+  def toByteString(array)
+    array.pack('C*')
+  end
+
+  def intBytes(i)
+    [i >> 24, (i >> 16) & 0xFF, (i >> 8) & 0xFF, i & 0xFF]
+  end
+
+  def stringToByteArray(str)
+    str.bytes.to_a
+  end
+
+  def arrayToIO(arr)
+    io = StringIO.new
+    io.write toByteString arr
+    io.rewind
+    io
+  end
+
+  def stringToIo(str)
+    arrayToIO stringToByteArray(str)
+  end
+
+  def concat(array, enum)
+    for i in enum
+      array << i
+    end
+  end
+
+  def bytesToInt(array)
+    array.pack('C*').unpack("N").first
+  end
+
+  def pad(array, count, value = 0)
+    count.times do
+      array << value
+    end
+    array
+  end
+
+  extend self
+end

data/lib/chunk.rb

@@ -0,0 +1,118 @@
+# Represents a chunk data
+require 'nbt_helper'
+require 'byte_converter'
+require 'block'
+require 'matrix3d'
+
+# Chunks are enumerable over blocks
+class Chunk
+  include Enumerable
+  include ZlibHelper
+
+  Width = 16
+  Length = 16
+  Height = 128
+
+  def self.fromNbt(bytes)
+    new NbtHelper.fromNbt bytes
+  end
+
+  def initialize(nbtData)
+    name, @nbtBody = nbtData
+    bytes = level["Blocks"].value.bytes
+    @blocks = matrixfromBytes bytes
+    @blocks.each_triple_index do |b, z, x, y|
+      b.pos = [z, x, y]
+    end
+    data = level["Data"].value.bytes.to_a
+    @blocks.each_with_index do |b, index|
+      v = data[index / 2]
+      if index % 2 == 0
+        b.data = v & 0xF
+      else
+        b.data = v >> 4
+      end
+    end
+  end
+
+  # Iterates over the blocks
+  def each(&block)
+    @blocks.each &block
+  end
+
+
+  # Converts all blocks on data do another type. Gives the block and sets
+  # the received name
+  def block_map(&block)
+    each { |b| b.name = yield b }
+  end
+
+  # Converts all blocks on data do another type. Gives the block name sets
+  # the received name
+  def block_type_map(&block)
+    each { |b| b.name = yield b.name.to_sym }
+  end
+
+  def [](z, x, y)
+    @blocks[z, x, y]
+  end
+
+  def []=(z, x, y, value)
+    @blocks[z, x, y] = value
+  end
+
+  def export
+    level["Data"] = byteArray exportLevelData
+    level["Blocks"] = byteArray @blocks.map { |b| b.id }
+    level["HeightMap"] = byteArray exportHeightMap
+    ["", @nbtBody]
+  end
+
+  def toNbt
+    NbtHelper.toBytes export
+  end
+
+  protected
+  def exportHeightMap
+    zwidth, xwidth, ywidth = @blocks.bounds
+    matrix = Array.new(zwidth) { Array.new(xwidth) { 1 }}
+    @blocks.each_triple_index do |b, z, x, y|
+      unless b.transparent
+        matrix[z][x] = [matrix[z][x], y + 1].max
+      end
+    end
+    ret = []
+    matrix.each do |line|
+      line.each do |height|
+        ret << height
+      end
+    end
+    ret
+  end
+
+  def level
+    @nbtBody["Level"]
+  end
+
+  def exportLevelData
+    data = []
+    @blocks.each_with_index do |b, i|
+      if i % 2 == 0
+        data << b.data
+      else
+        data[i / 2] += (b.data << 4)
+      end
+    end
+    data
+  end
+
+  def byteArray(data)
+    NBTFile::Types::ByteArray.new ByteConverter.toByteString(data)
+  end
+
+  def matrixfromBytes(bytes)
+    Matrix3d.new(Width, Length, Height).fromArray bytes.map {|byte| Block.get(byte) }
+  end
+
+
+end

data/lib/matrix3d.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+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

data/lib/nbt_helper.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+require 'nbtfile'
+require 'zlib'
+require '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 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

data/lib/region.rb

@@ -0,0 +1,257 @@
+require 'chunk'
+
+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

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: rubycraft
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Daniel Ribeiro
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-03 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nbtfile
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id001
+description: |-
+  It allows you to change all the
+  blocks in region files in whatever way you see fit. Example: http://bit.ly/r62qGo
+email: danrbr@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+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
+has_rdoc: true
+homepage: http://github.com/danielribeiro/RubyCraft
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Lib for manipualting Minecraft world files
+test_files: []
+