rubycraft 0.1.0 → 0.1.1

data/README.md

@@ -2,7 +2,9 @@ RubyCraft
 ==============
 
 RubyCraft is a simple library for manipulating [Minecraft](http://www.minecraft.net/)
-region files.
+region files. Installation is as simple as:
+
+    $ gem install rubycraft
 
 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

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/lib/rubycraft.rb

@@ -0,0 +1,5 @@
+module RubyCraft
+  VERSION = "0.1.1".freeze
+end
+
+require 'rubycraft/region'

data/lib/rubycraft/block.rb

@@ -0,0 +1,78 @@
+require 'rubycraft/block_type'
+
+module RubyCraft
+  # 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
+end

data/lib/rubycraft/block_type.rb

@@ -0,0 +1,193 @@
+module RubyCraft
+  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
+end

data/lib/rubycraft/byte_converter.rb

@@ -0,0 +1,48 @@
+require 'stringio'
+
+module RubyCraft
+  # 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
+end

data/lib/rubycraft/chunk.rb

@@ -0,0 +1,120 @@
+# Represents a chunk data
+require 'rubycraft/nbt_helper'
+require 'rubycraft/byte_converter'
+require 'rubycraft/block'
+require 'rubycraft/matrix3d'
+
+module RubyCraft
+  # 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
+end