tassadar 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color --format nested

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create 1.9.2@tassadar

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# CHANGELOG
+
+## 0.0.2
+
+* Converts serialized strings ASCII-8BIT => UTF-8. This was the source of serious encoding problems in replay parsing.
+
+## 0.0.1
+
+* Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in tassadar.gemspec
+gemspec
+
+gem 'rspec'
+gem 'watchr'
+gem 'ruby-debug19'
+gem 'rr'
+gem 'rake'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2011-2012 Agora Games
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# Tassadar
+
+Starcraft 2 replay parser written in pure-Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```
+gem 'tassadar'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install tassadar
+```
+
+## Usage
+
+Create a replay object:
+
+```ruby
+replay = Tassadar::SC2::Replay.new(path_to_replay)
+```
+
+All of the important information is in the game object:
+
+```ruby 
+replay.game
+=> #<Tassadar::SC2::Game:0x007f9e41e31408 @winner=#<Tassadar::SC2::Player:0x007f9e41e31728 @name="redgar", @id=2569192, @won=true, @color={:alpha=>255, :red=>0, :green=>66, :blue=>255}, @chosen_race="Zerg", @actual_race="Zerg", @handicap=100>, @time=2011-07-05 17:01:08 -0500, @map="Delta Quadrant">
+```
+
+Or the player objects:
+
+```ruby
+replay.players.first	
+=> #<Tassadar::SC2::Player:0x007f9e41e31a48 @name="guitsaru", @id=1918894, @won=false, @color={:alpha=>255, :red=>180, :green=>20, :blue=>30}, @chosen_race="Terran", @actual_race="Terran", @handicap=100>
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Copyright
+
+Copyright (c) 2012 Agora Games. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,22 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake'
+require 'rspec/core/rake_task'
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "bundle exec irb -rubygems -I lib -r tassadar.rb"
+end
+
+desc "Automatically run specs when files change."
+task :"spec:watchr" do
+  sh "watchr spec/spec_watchr.rb"
+end
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['--backtrace']
+  # spec.ruby_opts = ['-w']
+end
+
+task :default => :spec

data/lib/tassadar.rb

@@ -0,0 +1,7 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+
+require 'tassadar/mpq'
+require 'tassadar/sc2/replay'
+
+module Tassadar
+end

data/lib/tassadar/mpq.rb

@@ -0,0 +1,49 @@
+require 'bindata'
+
+require 'tassadar/mpq/archive_size'
+require 'tassadar/mpq/archive_header'
+require 'tassadar/mpq/sector'
+require 'tassadar/mpq/file_data'
+require 'tassadar/mpq/block_table'
+require 'tassadar/mpq/hash_table'
+require 'tassadar/mpq/block_encryptor'
+
+module Tassadar
+  module MPQ
+    class MPQ < BinData::Record
+      endian :little
+
+      string :magic, :length => 3, :check_value => "MPQ"
+      int8   :magic_4, :check_value => 27
+      int32  :user_data_size
+      int32  :archive_header_offset
+      string :user_data, :read_length => :user_data_size
+
+      archive_header :archive_header, :adjust_offset => lambda { archive_header_offset }
+      encrypted_block_table :block_table, :entries => lambda { archive_header.block_table_entries },
+                                          :adjust_offset => lambda { archive_header_offset + archive_header.block_table_offset }
+      encrypted_hash_table  :hash_table,  :entries => lambda { archive_header.hash_table_entries },
+                                          :adjust_offset => lambda { archive_header_offset + archive_header.hash_table_offset },
+                                          :compressed => lambda { archive_header.block_table_offset != archive_header.hash_table_offset + archive_header.hash_table_entries * 16 }
+      file_data_array :file_data,         :blocks => lambda { block_table.blocks },
+                                          :sector_size_shift => lambda { archive_header.sector_size_shift },
+                                          :archive_header_offset => :archive_header_offset
+
+      def files
+        @files ||= read_file('(listfile)').split
+      end
+
+      def read_file(filename)
+        get_hash_table_entry(filename).decompressed_data
+      end
+
+      def get_hash_table_entry(filename)
+        hash_a = BlockEncryptor.hash_string(filename, 0x100)
+        hash_b = BlockEncryptor.hash_string(filename, 0x200)
+
+        block = self.block_table.blocks[self.hash_table.hashes.select {|hash| hash.file_path_hash_a == hash_a && hash.file_path_hash_b == hash_b}.first.file_block_index]
+        self.file_data.select {|f| f.block_offset == block.block_offset}.first
+      end
+    end
+  end
+end

data/lib/tassadar/mpq/archive_header.rb

@@ -0,0 +1,31 @@
+module Tassadar
+  module MPQ
+    class ArchiveHeader < BinData::Record
+      endian :little
+
+      string :magic, :length => 3, :check_value => "MPQ"
+      uint8   :magic_4, :check_value => 26
+
+      uint32  :header_size, :check_value => 44
+
+      # archive_size actually here, but not used and is computed from later data
+      skip    :length => 4
+
+      uint16  :format_version
+      uint8   :sector_size_shift, :check_value => 3
+      skip    :length => 1
+      uint32  :hash_table_offset
+      uint32  :block_table_offset
+      uint32  :hash_table_entries
+      uint32  :block_table_entries
+      uint64  :extended_block_table_offset
+      uint16  :hash_table_offset_high
+      uint16  :block_table_offset_high
+
+      archive_size :archive_size, :hash_table_offset => :hash_table_offset,
+                                  :hash_table_entries => :hash_table_entries,
+                                  :block_table_offset => :block_table_offset,
+                                  :block_table_entries => :block_table_entries
+    end
+  end
+end

data/lib/tassadar/mpq/archive_size.rb

@@ -0,0 +1,17 @@
+module Tassadar
+  module MPQ
+    class ArchiveSize < BinData::Primitive
+      endian :little
+
+      def get
+        [eval_parameter(:hash_table_offset) + (eval_parameter(:hash_table_entries) * 16),
+         eval_parameter(:block_table_offset) + (eval_parameter(:block_table_entries) * 16)].max
+      end
+
+      def set(v)
+        [eval_parameter(:hash_table_offset) + (eval_parameter(:hash_table_entries) * 16),
+         eval_parameter(:block_table_offset) + (eval_parameter(:block_table_entries) * 16)].max
+      end
+    end
+  end
+end

data/lib/tassadar/mpq/block_encryptor.rb

@@ -0,0 +1,105 @@
+module Tassadar
+  module MPQ
+    class BlockEncryptor
+      attr_accessor :key, :offset, :buffer, :size
+
+      def initialize(key, offset, buffer, size)
+        @key = key
+        @offset = offset
+        @buffer = buffer
+        @size = size
+      end
+
+      def self.hash_string(key, offset)
+        BlockEncryptor.new(key, offset, nil, nil).hash_string
+      end
+
+      def decrypt
+        seed1 = hash_string
+        seed2 = 0xEEEEEEEE
+        result = ""
+        size = @size
+
+        while size >= 4
+          seed2 += encryption_table[0x400 + (seed1 & 0xFF)]
+          seed2 &= 0xFFFFFFFF
+
+          value = buffer.readbytes(4).unpack("V").first
+          value = (value ^ (seed1 + seed2)) & 0xFFFFFFFF
+
+          result += [value].pack("V")
+
+          seed1 = ((~seed1 << 0x15) + 0x11111111) | (seed1 >> 0x0B)
+          seed1 &= 0xFFFFFFFF
+          seed2 = value + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF
+          size = size - 4
+        end
+
+        result
+      end
+
+      def encrypt
+        seed1 = hash_string
+        seed2 = 0xEEEEEEEE
+        encrypted_block = []
+
+        while @size >= 4
+          seed2 += encryption_table[0x400 + (seed1 & 0xFF)]
+          seed2 &= 0xFFFFFFFF
+
+          value = buffer.readbytes(4).unpack("V").first
+          value = (value ^ (seed1 + seed2)) & 0xFFFFFFFF
+
+          encrypted_block << value
+
+          seed = ((~seed1 << 0x15) + 0x11111111) | (seed1 >> 0x0B)
+          seed2 = value + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF
+
+          @size = @size - 4
+        end
+
+        encrypted_block.pack("V*")
+      end
+
+      def hash_string
+        seed1 = 0x7FED7FED
+        seed2 = 0xEEEEEEEE
+
+        @key.upcase.each_byte do |char|
+          value = encryption_table[@offset + char]
+          seed1 = (value ^ (seed1 + seed2)) & 0xFFFFFFFF
+          seed2 = char + seed1 + seed2 + (seed2 << 5) + 3 & 0xFFFFFFFF
+        end
+
+        seed1
+      end
+
+      private
+      def encryption_table
+        @encryption_table ||= begin
+          crypt_buf = []
+          seed = 0x00100001
+
+          0.upto(0x100 - 1) do |index1|
+            index2 = index1
+
+            0.upto(4) do |i|
+              seed = (seed * 125 + 3) % 0x2AAAAB
+              temp1 = (seed & 0xFFFF) << 0x10
+
+              seed = (seed * 125 + 3) % 0x2AAAAB
+              temp2 = (seed & 0xFFFF)
+
+              crypt_buf[index2] = (temp1 | temp2)
+
+              index2 = index2 + 0x100
+            end
+          end
+
+          crypt_buf
+        end
+      end
+
+    end
+  end
+end

data/lib/tassadar/mpq/block_table.rb

@@ -0,0 +1,36 @@
+module Tassadar
+  module MPQ
+    class BlockTable < BinData::Record
+      endian :little
+
+      array :blocks, :read_until => :eof do
+        uint32 :block_offset
+        uint32 :block_size
+        uint32 :file_size
+        uint32 :flags
+      end
+    end
+
+    class EncryptedBlockTable < BinData::BasePrimitive
+      mandatory_parameters :entries
+
+      def read_and_return_value(io)
+        value = BlockEncryptor.new("(block table)", 0x300, io, eval_parameter(:entries) * 16).decrypt
+        BlockTable.read(value)
+      end
+
+      def value_to_binary_string(value)
+        packed_string = ""
+        value.blocks.each do |block|
+          packed_string += [block.block_offset, block.block_size, block.file_size, block.flags].pack("VVVV")
+        end
+
+        BlockEncryptor.new("(block table)", 0x300, BinData::IO.new(packed_string), eval_parameter(:entries) * 16).encrypt
+      end
+
+      def sensible_default
+        [0,0,0,0].pack("VVVV")
+      end
+    end
+  end
+end

data/lib/tassadar/mpq/crypt_buf.rb

@@ -0,0 +1,16 @@
+module Tassadar
+  module MPQ
+    module CryptBuf
+      def self.[](index)
+        crypt_buf[index]
+      end
+
+      def self.crypt_buf
+        @@crypt_buff ||= crypt_buf!
+      end
+
+      def self.crypt_buf!
+              end
+    end
+  end
+end

data/lib/tassadar/mpq/file_data.rb

@@ -0,0 +1,84 @@
+require 'zlib'
+require 'bzip2'
+
+module Tassadar
+  module MPQ
+    class FileData < BinData::Record
+      MPQ_FILE_ENCRYPTED = 0x00010000
+      MPQ_FILE_EXISTS = 0x80000000
+      MPQ_SINGLE_UNIT = 0x01000000
+      MPQ_COMPRESSED = 0x00000200
+
+      attr_accessor :block_offset
+
+      endian :little
+
+      string :data, :read_length => lambda { block.block_size }
+
+      def decompressed_data
+        result = nil
+        block = eval_parameter(:block)
+
+        if (block.flags & MPQ_FILE_EXISTS) > 0
+          result = self.data
+        end
+
+        if (block.flags & MPQ_FILE_ENCRYPTED) > 0
+          raise NotImplementedError
+        end
+
+        if (block.flags & MPQ_SINGLE_UNIT) > 0
+          if block.flags & MPQ_COMPRESSED && block.file_size > block.block_size
+            result = decompress(self.data)
+          end
+        else
+        end
+
+        result
+      end
+
+      private
+      def decompress(data)
+        compression_type = data.bytes.first
+        case compression_type
+        when 0
+          data
+        when 2
+          Zlib::Deflate.deflate(data[1,data.size - 1])
+        when 16
+          Bzip2.uncompress(data[1,data.size - 1])
+        else
+          raise NotImplementedError
+        end
+      end
+    end
+
+    class FileDataArray < BinData::BasePrimitive
+      mandatory_parameters :blocks, :sector_size_shift
+
+      def read_and_return_value(io)
+        result = []
+        sector_size = 512 * (2 ** eval_parameter(:sector_size_shift))
+
+        eval_parameter(:blocks).each do |block|
+          num_sectors = block.flags & 0x01000000 ? 1 : (block["block_size"] / sector_size)
+          file = FileData.new(:adjust_offset => block.block_offset + eval_parameter(:archive_header_offset),
+                              :block => block).read(io)
+          file.block_offset = block.block_offset
+
+          result << file
+        end
+
+        result
+      end
+
+      def value_to_binary_string(value)
+        value.pack("V*")
+      end
+
+      def sensible_default
+        ''
+      end
+    end
+  end
+end

data/lib/tassadar/mpq/hash_table.rb

@@ -0,0 +1,52 @@
+module Tassadar
+  module MPQ
+    class FileTime < BinData::Record
+      endian :little
+
+      uint32 :low_date_time
+      uint32 :high_date_time
+    end
+
+    class Md5 < BinData::Record
+      endian :little
+
+      string :md5_hash, :length => 16
+    end
+
+    class HashTable < BinData::Record
+      endian :little
+
+      array :hashes, :read_until => :eof do
+        uint32 :file_path_hash_a
+        uint32 :file_path_hash_b
+        uint16 :language
+        uint8  :platform
+        skip  :length => 1
+        uint32 :file_block_index
+      end
+    end
+
+    class EncryptedHashTable < BinData::BasePrimitive
+      mandatory_parameters :entries
+
+      def read_and_return_value(io)
+        value = BlockEncryptor.new("(hash table)", 0x300, io, eval_parameter(:entries) * 16).decrypt
+        HashTable.read(value)
+      end
+
+      def value_to_binary_string(value)
+        packed_string = ""
+        value.hashes.each do |hash|
+          packed_string += [hash.file_path_hash_a, hash.file_path_hash_b, hash.language, hash.platform, 0, hash.file_block_index].pack("VVvCCV")
+        end
+
+        BlockEncryptor.new("(hash table)", 0x300, value, eval_parameter(:entries) * 16).encrypt
+      end
+
+      def sensible_default
+        [0,0,0,0,0,0].pack("VVvCCV")
+      end
+    end
+
+  end
+end

data/lib/tassadar/mpq/sector.rb

@@ -0,0 +1,25 @@
+module Tassadar
+  module MPQ
+    class Sector < BinData::Record
+      endian :little
+
+      uint8 :compression_mask
+    end
+
+    class SectorArray < BinData::BasePrimitive
+      mandatory_parameters :sector_offsets, :sector_size
+
+      def read_and_return_value(io)
+        result = []
+        file_data_offset = parent.offset
+
+        eval_parameter(:sector_offsets).each do |offset|
+          raise offset.inspect
+          result << Sector.new(:adjust_offset => offset + file_data_offset).read(io)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/tassadar/sc2/attributes.rb

@@ -0,0 +1,23 @@
+# https://github.com/GraylinKim/sc2reader/wiki/replay.attributes.events
+
+module Tassadar
+  module SC2
+    class Attribute < BinData::Record
+      endian :little
+
+      string :header, :read_length => 4, :check_value => "\xE7\x03\x00\x00"
+      uint32 :id
+      uint8 :player_number
+      reverse_string :attribute_value, :read_length => 4
+    end
+
+    class Attributes < BinData::Record
+      endian :little
+
+      skip :length => 5
+      uint32 :num_attributes
+
+      array :attributes, :type => :attribute, :initial_length => :num_attributes
+    end
+  end
+end

data/lib/tassadar/sc2/details.rb

@@ -0,0 +1,7 @@
+module Tassadar
+  module SC2
+    class Details < BinData::Record
+      serialized_data :data
+    end
+  end
+end

data/lib/tassadar/sc2/game.rb

@@ -0,0 +1,27 @@
+module Tassadar
+  module SC2
+    class Game
+      attr_accessor :map, :time, :winner, :speed, :type, :category
+
+      def initialize(replay)
+        @winner = replay.players.select {|p| p.won}.first
+        @time = convert_windows_to_ruby_date_time(replay.details.data[5], replay.details.data[6])
+        @map = replay.details.data[1]
+        @type = replay.attributes.attributes.select {|a| a.id == 2001}.first.attribute_value
+
+        speeds = {"Fasr" => "Faster", "Slow" => "Slow", "Fast" => "Fast", "Norm" => "Normal", "Slor" => "Slower"}
+        @speed = speeds[replay.attributes.attributes.select {|a| a.id == 3000}.first.attribute_value]
+
+        categories = {"Amm" => "Ladder", "Priv" => "Private", "Pub" => "Public"}
+        @category = categories[replay.attributes.attributes.select {|a| a.id == 3009}.first.attribute_value]
+      end
+
+      private
+      def convert_windows_to_ruby_date_time(time, zone)
+        unix_time = (time - 116444735995904000) / (10 ** 7)
+
+        @time = Time.at(unix_time)
+      end
+    end
+  end
+end

data/lib/tassadar/sc2/player.rb

@@ -0,0 +1,22 @@
+module Tassadar
+  module SC2
+    class Player
+      attr_accessor :name, :id, :won, :color, :chosen_race, :actual_race, :handicap
+
+      def initialize(details_hash, attributes)
+        @name = details_hash[0]
+        @id = details_hash[1][4]
+        @won = [false, true, false][details_hash[8]]
+        @color = {:alpha => details_hash[3][0], :red => details_hash[3][1], :green => details_hash[3][2], :blue => details_hash[3][3]}
+        races = {"Terr" => "Terran", "Prot" => "Protoss", "Zerg" => "Zerg", "RAND" => "Random"}
+        @chosen_race = races[attributes.select {|a| a.id == 0x0BB9 && a.player_number == details_hash[7] + 1}.first.attribute_value]
+        @actual_race = details_hash[2]
+        @handicap = details_hash[6]
+      end
+
+      def winner?
+        @won
+      end
+    end
+  end
+end

data/lib/tassadar/sc2/replay.rb

@@ -0,0 +1,23 @@
+require 'tassadar/sc2/reverse_string'
+require 'tassadar/sc2/serialized_data'
+require 'tassadar/sc2/attributes'
+require 'tassadar/sc2/details'
+require 'tassadar/sc2/player'
+require 'tassadar/sc2/game'
+
+module Tassadar
+  module SC2
+    class Replay
+      attr_accessor :mpq, :attributes, :details, :players, :game
+
+      def initialize(filename)
+        @mpq = MPQ::MPQ.read(File.read(filename))
+        @attributes = Attributes.read(@mpq.read_file("replay.attributes.events"))
+        @details = Details.read(@mpq.read_file("replay.details"))
+
+        @players = @details.data[0].map {|h| Player.new(h, @attributes.attributes)}
+        @game = Game.new(self)
+      end
+    end
+  end
+end

data/lib/tassadar/sc2/reverse_string.rb

@@ -0,0 +1,15 @@
+module Tassadar
+  module SC2
+    class ReverseString < BinData::String
+      mandatory_parameters :read_length
+
+      def read_and_return_value(io)
+        super.reverse.gsub("\x00", '')
+      end
+
+      def value_to_binary_string(value)
+        clamp_to_length(val.reverse)
+      end
+    end
+  end
+end

data/lib/tassadar/sc2/serialized_data.rb

@@ -0,0 +1,86 @@
+module Tassadar
+  module SC2
+    class SerializedData < BinData::BasePrimitive
+      def read_and_return_value(io)
+        key = io.readbytes(1).unpack("C").first
+
+        case key
+        when 2
+          read_byte_string(io)
+        when 4
+          read_array(io)
+        when 5
+          read_kvo(io)
+        when 6
+          read_small_int(io)
+        when 7
+          read_big_int(io)
+        when 9
+          read_vlf_int(io)
+        else
+          puts "No parser for key: #{key}"
+        end
+      end
+
+      def value_to_binary_string(value)
+        value.pack("V")
+      end
+
+      private
+      def read_byte_string(io)
+        num_bytes = io.readbytes(1).unpack("C").first >> 1
+
+        io.readbytes(num_bytes).unpack("A#{num_bytes}").first.force_encoding('UTF-8')
+      end
+
+      def read_small_int(io)
+        io.readbytes(1).unpack("C").first
+      end
+
+      def read_big_int(io)
+        io.readbytes(4).unpack("v").first
+      end
+
+      def read_vlf_int(io)
+        byte = io.readbytes(1).unpack("C").first
+        value = (byte & 0x7F)
+        shift = 1
+
+        while byte & 0x80 > 0
+          byte = io.readbytes(1).unpack("C").first
+          value += (byte & 0x7F) << (7 * shift)
+          shift += 1
+        end
+
+        (value & 1) == 1 ? -(value >> 1) : (value >> 1)
+      end
+
+      def read_array(io)
+        result = []
+        2.times { io.readbytes(1).unpack("C").first }
+
+        num_elements = io.readbytes(1).unpack("C").first >> 1
+
+        num_elements.times do
+          result << read_and_return_value(io)
+        end
+
+        result
+      end
+
+      def read_kvo(io)
+        result = {}
+        num_pairs = io.readbytes(1).unpack("C").first >> 1
+
+        num_pairs.times do
+          key = io.readbytes(1).unpack("C").first >> 1
+          value = read_and_return_value(io)
+
+          result[key] = value
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/tassadar/version.rb

@@ -0,0 +1,3 @@
+module Tassadar
+  VERSION = "0.0.2"
+end

data/spec/mpq/archive_header_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Tassadar::MPQ::ArchiveHeader do
+  before(:each) do
+    @archive_header = Tassadar::MPQ::ArchiveHeader.read("MPQ\x1A,\x00\x00\x00P5\x00\x00\x01\x00\x03\x00\xB03\x00\x00\xB04\x00\x00\x10\x00\x00\x00\n\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+  end
+
+  describe "require a valid magic string" do
+    it "should accept a valid magic string" do
+      expect { Tassadar::MPQ::ArchiveHeader.read("MPQ\x1A,\x00\x00\x00P5\x00\x00\x01\x00\x03\x00\xB03\x00\x00\xB04\x00\x00\x10\x00\x00\x00\n\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00") }.to_not raise_error
+    end
+
+    it "should not accept an invalid magic string" do
+      expect { Tassadar::MPQ.ArchiveHeader.read("MPQ\x1A,\x00\x00\x00P5\x00\x00\x01\x00\x03\x00\xB03\x00\x00\xB04\x00\x00\x10\x00\x00\x00\n\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00") }.to raise_error
+    end
+  end
+
+  it "should read the magic header" do
+    @archive_header.magic.should == "MPQ"
+  end
+
+  it "should read magic 4" do
+    @archive_header.magic_4.should == 26
+  end
+
+  it "should read the header size" do
+    @archive_header.header_size.should == 44
+  end
+
+  it "should read the archive size" do
+    @archive_header.archive_size.should == 13648
+  end
+
+  it "should read the format version" do
+    @archive_header.format_version.should == 1
+  end
+
+  it "should read the sector size shift" do
+    @archive_header.sector_size_shift.should == 3
+  end
+
+  it "should read the hash table offset" do
+    @archive_header.hash_table_offset.should == 13232
+  end
+
+  it "should read the block table offset" do
+    @archive_header.block_table_offset.should == 13488
+  end
+
+  it "should read the hash table entries" do
+    @archive_header.hash_table_entries.should > 0
+    @archive_header.hash_table_entries.should < 2 ** 20
+    Math.log2(@archive_header.hash_table_entries.to_i).floor.should == Math.log2(@archive_header.hash_table_entries.to_i).ceil
+    @archive_header.hash_table_entries.should == 16
+  end
+
+  it "should read the block table entries" do
+    @archive_header.block_table_entries.should == 10
+  end
+
+  it "should read the extended_block_table_offset" do
+    @archive_header.extended_block_table_offset.should == 0
+  end
+
+  it "should read the hash table offset high" do
+    @archive_header.hash_table_offset_high.should == 0
+  end
+
+  it "should read the block table offset high" do
+    @archive_header.block_table_offset_high.should == 0
+  end
+end

data/spec/mpq/block_table_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Tassadar::MPQ::ArchiveHeader do
+  before(:each) do
+    @mpq = Tassadar::MPQ::MPQ.read(File.read("spec/replays/Delta\ Quadrant.SC2Replay"))
+  end
+
+  it "should have some blocks" do
+    @mpq.block_table.blocks.size.should == 10
+  end
+
+  it "should have a valid block table entry" do
+    block = @mpq.block_table.blocks.first
+    block.block_offset.should == 0x0000002C
+    block.block_size.should == 448
+    block.file_size.should == 448
+    block.flags.should == 0x81000200
+  end
+  
+  it "should have another valid block table entry" do
+    block = @mpq.block_table.blocks[1]
+    block.block_offset.should == 0x000001EC
+    block.block_size.should == 652
+    block.file_size.should == 1216
+    block.flags.should == 0x81000200
+  end
+end
+
+#  MPQ archive block table
+#  -----------------------------------
+#  Offset  ArchSize RealSize  Flags
+#  0000002C      448      448 81000200
+#  000001EC      652     1216 81000200
+#  00000478     9984    19453 81000200
+#  00002B78      113      149 81000200
+#  00002BE9       96       96 81000200
+#  00002C49      578      760 81000200
+#  00002E8B      682     1112 81000200
+#  00003135      254      581 81000200
+#  00003233      120      164 81000200
+#  000032AB      261      288 81000200

data/spec/mpq_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Tassadar::MPQ::MPQ do
+  before(:each) do
+    @mpq = Tassadar::MPQ::MPQ.read(File.read("spec/replays/Delta\ Quadrant.SC2Replay"))
+  end
+
+  it "should have a valid magic string" do
+    @mpq.magic.should == "MPQ"
+  end
+
+  it "should read the user data size" do
+    @mpq.user_data_size.should == 512
+  end
+
+  it "should have block_table entries" do
+    @mpq.block_table.blocks.size.should == 10
+  end
+
+  it "should have hash_table entries" do
+    @mpq.hash_table.hashes.size.should == 16
+  end
+
+  it "should have files" do
+    @mpq.file_data.size.should > 1
+  end
+
+  it "should have a list of files" do
+    @mpq.files.size.should == 8
+    @mpq.files.should include("replay.attributes.events")
+  end
+end

data/spec/sc2/game_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Tassadar::SC2::Game do
+  before(:each) do
+    @replay = Tassadar::SC2::Replay.new("spec/replays/Delta\ Quadrant.SC2Replay")
+  end
+
+  it "should set the winner" do
+    @replay.game.winner.name.should == "redgar"
+  end
+
+  it "should set the map" do
+    @replay.game.map.should == "Delta Quadrant"
+  end
+
+  it "should set the time" do
+    @replay.game.time.should == Time.new(2011, 07, 05, 17, 01, 8, "-05:00")
+  end
+
+  it "should set the speed" do
+    @replay.game.speed.should == "Faster"
+  end
+
+  it "should set the game type" do
+    @replay.game.type.should == "1v1"
+  end
+
+  it "should set the category" do
+    @replay.game.category.should == "Ladder"
+  end
+end

data/spec/sc2/player_spec.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Tassadar::SC2::Player do
+  context 'NA Sc2 Replay' do
+    before(:each) do
+      @replay = Tassadar::SC2::Replay.new("spec/replays/Delta\ Quadrant.SC2Replay")
+      @player = @replay.players.first
+    end
+
+    it "should set the name" do
+      @player.name.should == "guitsaru"
+    end
+
+    it "should set the id" do
+      @player.id.should == 1918894
+    end
+
+    it "should tell if the player won" do
+      @player.should_not be_winner
+    end
+
+    it "should have a color" do
+      @player.color.should == {:alpha => 255, :red => 180, :green => 20, :blue => 30}
+    end
+
+    it "should have a chosen race" do
+      @player.chosen_race.should == "Terran"
+    end
+
+    it "should have random as the chosen race if random" do
+      replay = Tassadar::SC2::Replay.new("spec/replays/random.sc2replay")
+      replay.players.last.chosen_race.should == "Random"
+    end
+
+    it "should have an actual race" do
+      @player.actual_race.should == "Terran"
+    end
+
+    it "should have a handicap" do
+      @player.handicap.should == 100
+    end
+  end
+
+  context 'EU SC2 Replay' do
+    let(:replay) { Tassadar::SC2::Replay.new('spec/replays/eu_replay.SC2Replay') }
+    subject  { replay.players.last }
+
+    it 'encodes the name in UTF-8' do
+      subject.name.encoding.to_s.should == 'UTF-8'
+      subject.name.should == 'MǂStephano'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'tassadar'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end
+

data/spec/spec_watchr.rb

@@ -0,0 +1,77 @@
+ENV["WATCHR"] = "1"
+system 'clear'
+
+$spec_cmd = "bundle exec rspec --tty --color --format nested -d"
+
+def run(cmd)
+  puts(cmd)
+  if system("which growlnotify > /dev/null")
+    run_with_notifier :growl, cmd
+  elsif system("which notify-send > /dev/null")
+    run_with_notifier :libnotify, cmd
+  else
+    `#{cmd}`
+  end
+end
+
+def run_with_notifier(notifier, cmd)
+  pass = system(cmd)
+  if pass
+    image = File.join(File.dirname(__FILE__), 'support', 'rails_ok.png')
+    message = "Success!"
+  else
+    image = File.join(File.dirname(__FILE__), 'support', 'rails_fail.png')
+    message = "Failure!"
+  end
+
+  case notifier
+  when :growl
+    `growlnotify -n "StarLeagues Specs" -m "StarLeagues Specs" --image #{image} #{message}`
+  when :libnotify
+    `notify-send --icon #{image} "StarLeagues Specs" #{message}`
+  end
+end
+
+def run_spec(file)
+  system('clear')
+  result = run "#{$spec_cmd} #{file}"
+  result.split("\n").last rescue nil
+  puts result
+end
+
+def run_all_specs
+  system('clear')
+  result = run "#{$spec_cmd} spec/"
+  puts result
+end
+
+def related_specs(path)
+  Dir['spec/**/*.rb'].select { |file| file =~ /#{File.basename(path).split(".").first}_spec.rb/ }
+end
+
+watch('.*') { run_all_specs }
+
+# Ctrl-\
+Signal.trap 'QUIT' do
+  puts " --- Running all specs ---\n\n"
+  run_all_specs
+end
+
+@interrupted = false
+
+# Ctrl-C
+Signal.trap 'INT' do
+  if @interrupted then
+    @wants_to_quit = true
+    abort("\n")
+  else
+    puts "Interrupt a second time to quit"
+    @interrupted = true
+    Kernel.sleep 1.5
+    # raise Interrupt, nil # let the run loop catch it
+    run_all_specs
+    @interrupted = false
+  end
+end
+
+puts "Watching..."

data/tassadar.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tassadar/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tassadar"
+  s.version     = Tassadar::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Matt Pruitt", "Andrew Nordman"]
+  s.email       = ["mpruitt@agoragames.com", "anordman@agoragames.com"]
+  s.homepage    = "https://github.com/agoragames/tassadar"
+  s.summary     = %q{Pure ruby MPQ and SC2 Replay parser}
+  s.description = %q{Pure ruby MPQ and SC2 Replay parser}
+
+  s.rubyforge_project = "tassadar"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("bindata")
+  s.add_dependency("bzip2-ruby")
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: tassadar
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Matt Pruitt
+- Andrew Nordman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-04 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: &70239924932500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70239924932500
+- !ruby/object:Gem::Dependency
+  name: bzip2-ruby
+  requirement: &70239924854920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70239924854920
+description: Pure ruby MPQ and SC2 Replay parser
+email:
+- mpruitt@agoragames.com
+- anordman@agoragames.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tassadar.rb
+- lib/tassadar/mpq.rb
+- lib/tassadar/mpq/archive_header.rb
+- lib/tassadar/mpq/archive_size.rb
+- lib/tassadar/mpq/block_encryptor.rb
+- lib/tassadar/mpq/block_table.rb
+- lib/tassadar/mpq/crypt_buf.rb
+- lib/tassadar/mpq/file_data.rb
+- lib/tassadar/mpq/hash_table.rb
+- lib/tassadar/mpq/sector.rb
+- lib/tassadar/sc2/attributes.rb
+- lib/tassadar/sc2/details.rb
+- lib/tassadar/sc2/game.rb
+- lib/tassadar/sc2/player.rb
+- lib/tassadar/sc2/replay.rb
+- lib/tassadar/sc2/reverse_string.rb
+- lib/tassadar/sc2/serialized_data.rb
+- lib/tassadar/version.rb
+- spec/mpq/archive_header_spec.rb
+- spec/mpq/block_table_spec.rb
+- spec/mpq_spec.rb
+- spec/replays/Delta Quadrant.SC2Replay
+- spec/replays/eu_replay.SC2Replay
+- spec/replays/random.sc2replay
+- spec/sc2/game_spec.rb
+- spec/sc2/player_spec.rb
+- spec/spec_helper.rb
+- spec/spec_watchr.rb
+- tassadar.gemspec
+homepage: https://github.com/agoragames/tassadar
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1060130835485239362
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1060130835485239362
+requirements: []
+rubyforge_project: tassadar
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Pure ruby MPQ and SC2 Replay parser
+test_files:
+- spec/mpq/archive_header_spec.rb
+- spec/mpq/block_table_spec.rb
+- spec/mpq_spec.rb
+- spec/replays/Delta Quadrant.SC2Replay
+- spec/replays/eu_replay.SC2Replay
+- spec/replays/random.sc2replay
+- spec/sc2/game_spec.rb
+- spec/sc2/player_spec.rb
+- spec/spec_helper.rb
+- spec/spec_watchr.rb