rubycraft 0.1.0 → 0.1.1

data/lib/block_type.rb

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

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

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

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

@@ -1,48 +0,0 @@
-#!/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