herostats 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2e9eec958e321b00d2434120062516717d26d62b
+  data.tar.gz: 055ca62159d8f848df4e174a970bc45010d3c3ee
+SHA512:
+  metadata.gz: d176418cf9aeb55778fbd173c6caa56245baddd42c76077d58dfac0e7bbf4c5fcd9fec36edaa4b2405fc0b4b31d85bba8f83eaf7b808d53075eafa0ec71ce05d
+  data.tar.gz: 0d5deb4bd12a5f5973593ffcfbce7f45727ffac74b61cbb4b07407ad65a4acd5d39b6817d6fe55ca01ef98dacf712ff8f5c05ab89d459c119f798253229c9bc9

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in herostats.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2016 Ronald Leask
+
+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,34 @@
+# Herostats
+
+Library for collecting stats from Heros of the Storm replays
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'herostats'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install herostats
+
+## Usage
+
+Herostats.parse('/path/to/replay')
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Helaisgem push squid-utils-0.1.0.gem/herostats. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "herostats"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/herostats.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'herostats/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'herostats'
+  spec.version       = Herostats::VERSION
+  spec.authors       = ['Ronald Leask']
+  spec.email         = ['ronald.leask@gmail.com']
+
+  spec.summary       = %q{Ruby library for extracting stats from Heroes of the Storm replays}
+  spec.description   = %q{Ruby library for extracting important statistics from Heroes of the Storm replays}
+  spec.homepage      = 'https://github.com/Helais/herostats'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.8'
+end

data/lib/heroprotocol/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015 Blizzard Entertainment
+
+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/lib/heroprotocol/README.md

@@ -0,0 +1,91 @@
+# Hero Protocol
+
+heroprotocol is a reference Python library and standalone tool to decode Heroes of the Storm replay files into Python data structures.
+
+Currently heroprotocol can decode these structures and events:
+* replay header
+* game details
+* replay init data
+* game events
+* message events
+* tracker events
+
+heroprotocol can be used as a base-build-specific library to decode binary blobs, or it can be run as a standalone tool to pretty print information from supported replay files.
+
+Note that heroprotocol does not expose game balance information or provide any kind of high level analysis of replays; it's meant
+to be just the first tool in the chain for your data mining application.
+
+# Supported Versions
+
+heroprotocol supports all Hereos of the Storm replay files that were written with retail versions of the game. The current plan is to support all future publicly released versions, including public betas.
+
+# How to Use
+
+A working installation of Python 2.x is required. From the folder where *heroprotocol* is located, type the following into the command line, assuming that the replay file was also copied into the same folder:
+```python
+py heroprotocol.py --<option> "<replayFileName>" > output.txt
+```
+
+If you want the output shown directly in the terminal, leave out the `> output.txt`.
+
+## Example Usage
+
+```python
+py heroprotocol.py --details "Blackheart's Bay.StormReplay" > output.txt
+```
+
+## --<option> arguments
+
+`-h, --help` Show the options that are available.
+
+`--gameevents` print all game events including coordinates
+
+`--messageevents` print message events such as ping events
+
+`--trackerevents` print tracker events such as units killed, game stat events, score result event
+
+`--attributeevents` print attribute events, a table of attrid, namespace, and attribute values
+
+`--header` print protocol header including HotS build and elapsedGameLoops
+
+`--details` print protocol details, e.g. teamId, player names and chosen heroes, player region, game result, observer status
+
+`--initdata` print protocol initdata, e.g. interface settings for every player
+
+`--stats` print game stats
+
+
+# Tracker Events
+
+Some notes on tracker events:
+* Convert unit tag index, recycle pairs into unit tags (as seen in game events) with protocol.unit_tag(index, recycle)
+* Interpret the NNet.Replay.Tracker.SUnitPositionsEvent events like this:
+
+```python
+    unitIndex = event['m_firstUnitIndex']
+    for i in xrange(0, len(event['m_items']), 3):
+        unitIndex += event['m_items'][i + 0]
+        x = event['m_items'][i + 1] * 4
+        y = event['m_items'][i + 2] * 4
+        # unit identified by unitIndex at the current event['_gameloop'] time is at approximate position (x, y)
+```
+* Only units that have inflicted or taken damage are mentioned in unit position events, and they occur periodically with a limit of 256 units mentioned per event.
+* NNet.Replay.Tracker.SUnitInitEvent events appear for units under construction. When complete you'll see a NNet.Replay.Tracker.SUnitDoneEvent with the same unit tag.
+* NNet.Replay.Tracker.SUnitBornEvent events appear for units that are created fully constructed.
+* You may receive a NNet.Replay.Tracker.SUnitDiedEvent after either a UnitInit or UnitBorn event for the corresponding unit tag.
+* In NNet.Replay.Tracker.SPlayerStatsEvent, m_scoreValueFoodUsed and m_scoreValueFoodMade are in fixed point (divide by 4096 for integer values). All other values are in integers.
+* There's a known issue where revived units are not tracked, and placeholder units track death but not birth.
+
+# License
+
+Copyright (c) 2015 Blizzard Entertainment
+
+Open sourced under the MIT license. See the included LICENSE file for more information.
+
+# Acknowledgements
+
+The standalone tool uses [mpyq](https://github.com/eagleflo/mpyq) to read mopaq files.
+
+Thanks to David Joerg and Graylin Kim of [GGTracker](http://www.ggtracker.com) for design feedback and beta-testing of the s2protocol library that heroprotocol is based upon.
+
+Thanks to Ben Barrett of [HOTSLogs](http://www.hotslogs.com) for feedback on and beta-testing of the heroprotocol library.

data/lib/heroprotocol/decoders.py

@@ -0,0 +1,311 @@
+# Copyright (c) 2015 Blizzard Entertainment
+#
+# 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.
+
+import struct
+
+
+class TruncatedError(Exception):
+    pass
+
+
+class CorruptedError(Exception):
+    pass
+
+
+class BitPackedBuffer:
+    def __init__(self, contents, endian='big'):
+        self._data = contents or []
+        self._used = 0
+        self._next = None
+        self._nextbits = 0
+        self._bigendian = (endian == 'big')
+
+    def __str__(self):
+        return 'buffer(%02x/%d,[%d]=%s)' % (
+            self._nextbits and self._next or 0, self._nextbits,
+            self._used, '%02x' % (ord(self._data[self._used]),) if (self._used < len(self._data)) else '--')
+
+    def done(self):
+        return self._nextbits == 0 and self._used >= len(self._data)
+
+    def used_bits(self):
+        return self._used * 8 - self._nextbits
+
+    def byte_align(self):
+        self._nextbits = 0
+
+    def read_aligned_bytes(self, bytes):
+        self.byte_align()
+        data = self._data[self._used:self._used + bytes]
+        self._used += bytes
+        if len(data) != bytes:
+            raise TruncatedError(self)
+        return data
+
+    def read_bits(self, bits):
+        result = 0
+        resultbits = 0
+        while resultbits != bits:
+            if self._nextbits == 0:
+                if self.done():
+                    raise TruncatedError(self)
+                self._next = ord(self._data[self._used])
+                self._used += 1
+                self._nextbits = 8
+            copybits = min(bits - resultbits, self._nextbits)
+            copy = (self._next & ((1 << copybits) - 1))
+            if self._bigendian:
+                result |= copy << (bits - resultbits - copybits)
+            else:
+                result |= copy << resultbits
+            self._next >>= copybits
+            self._nextbits -= copybits
+            resultbits += copybits
+        return result
+
+    def read_unaligned_bytes(self, bytes):
+        return ''.join([chr(self.read_bits(8)) for i in xrange(bytes)])
+
+
+class BitPackedDecoder:
+    def __init__(self, contents, typeinfos):
+        self._buffer = BitPackedBuffer(contents)
+        self._typeinfos = typeinfos
+
+    def __str__(self):
+        return self._buffer.__str__()
+
+    def instance(self, typeid):
+        if typeid >= len(self._typeinfos):
+            raise CorruptedError(self)
+        typeinfo = self._typeinfos[typeid]
+        return getattr(self, typeinfo[0])(*typeinfo[1])
+
+    def byte_align(self):
+        self._buffer.byte_align()
+
+    def done(self):
+        return self._buffer.done()
+
+    def used_bits(self):
+        return self._buffer.used_bits()
+
+    def _array(self, bounds, typeid):
+        length = self._int(bounds)
+        return [self.instance(typeid) for i in xrange(length)]
+
+    def _bitarray(self, bounds):
+        length = self._int(bounds)
+        return (length, self._buffer.read_bits(length))
+
+    def _blob(self, bounds):
+        length = self._int(bounds)
+        result = self._buffer.read_aligned_bytes(length)
+        return result
+
+    def _bool(self):
+        return self._int((0, 1)) != 0
+
+    def _choice(self, bounds, fields):
+        tag = self._int(bounds)
+        if tag not in fields:
+            raise CorruptedError(self)
+        field = fields[tag]
+        return {field[0]: self.instance(field[1])}
+
+    def _fourcc(self):
+        return self._buffer.read_unaligned_bytes(4)
+
+    def _int(self, bounds):
+        return bounds[0] + self._buffer.read_bits(bounds[1])
+
+    def _null(self):
+        return None
+
+    def _optional(self, typeid):
+        exists = self._bool()
+        return self.instance(typeid) if exists else None
+
+    def _real32(self):
+        return struct.unpack('>f', self._buffer.read_unaligned_bytes(4))
+
+    def _real64(self):
+        return struct.unpack('>d', self._buffer.read_unaligned_bytes(8))
+
+    def _struct(self, fields):
+        result = {}
+        for field in fields:
+            if field[0] == '__parent':
+                parent = self.instance(field[1])
+                if isinstance(parent, dict):
+                    result.update(parent)
+                elif len(fields) == 1:
+                    result = parent
+                else:
+                    result[field[0]] = parent
+            else:
+                result[field[0]] = self.instance(field[1])
+        return result
+
+
+class VersionedDecoder:
+    def __init__(self, contents, typeinfos):
+        self._buffer = BitPackedBuffer(contents)
+        self._typeinfos = typeinfos
+
+    def __str__(self):
+        return self._buffer.__str__()
+
+    def instance(self, typeid):
+        if typeid >= len(self._typeinfos):
+            raise CorruptedError(self)
+        typeinfo = self._typeinfos[typeid]
+        return getattr(self, typeinfo[0])(*typeinfo[1])
+
+    def byte_align(self):
+        self._buffer.byte_align()
+
+    def done(self):
+        return self._buffer.done()
+
+    def used_bits(self):
+        return self._buffer.used_bits()
+
+    def _expect_skip(self, expected):
+        if self._buffer.read_bits(8) != expected:
+            raise CorruptedError(self)
+
+    def _vint(self):
+        b = self._buffer.read_bits(8)
+        negative = b & 1
+        result = (b >> 1) & 0x3f
+        bits = 6
+        while (b & 0x80) != 0:
+            b = self._buffer.read_bits(8)
+            result |= (b & 0x7f) << bits
+            bits += 7
+        return -result if negative else result
+
+    def _array(self, bounds, typeid):
+        self._expect_skip(0)
+        length = self._vint()
+        return [self.instance(typeid) for i in xrange(length)]
+
+    def _bitarray(self, bounds):
+        self._expect_skip(1)
+        length = self._vint()
+        return (length, self._buffer.read_aligned_bytes((length + 7) / 8))
+
+    def _blob(self, bounds):
+        self._expect_skip(2)
+        length = self._vint()
+        return self._buffer.read_aligned_bytes(length)
+
+    def _bool(self):
+        self._expect_skip(6)
+        return self._buffer.read_bits(8) != 0
+
+    def _choice(self, bounds, fields):
+        self._expect_skip(3)
+        tag = self._vint()
+        if tag not in fields:
+            self._skip_instance()
+            return {}
+        field = fields[tag]
+        return {field[0]: self.instance(field[1])}
+
+    def _fourcc(self):
+        self._expect_skip(7)
+        return self._buffer.read_aligned_bytes(4)
+
+    def _int(self, bounds):
+        self._expect_skip(9)
+        return self._vint()
+
+    def _null(self):
+        return None
+
+    def _optional(self, typeid):
+        self._expect_skip(4)
+        exists = self._buffer.read_bits(8) != 0
+        return self.instance(typeid) if exists else None
+
+    def _real32(self):
+        self._expect_skip(7)
+        return struct.unpack('>f', self._buffer.read_aligned_bytes(4))
+
+    def _real64(self):
+        self._expect_skip(8)
+        return struct.unpack('>d', self._buffer.read_aligned_bytes(8))
+
+    def _struct(self, fields):
+        self._expect_skip(5)
+        result = {}
+        length = self._vint()
+        for i in xrange(length):
+            tag = self._vint()
+            field = next((f for f in fields if f[2] == tag), None)
+            if field:
+                if field[0] == '__parent':
+                    parent = self.instance(field[1])
+                    if isinstance(parent, dict):
+                        result.update(parent)
+                    elif len(fields) == 1:
+                        result = parent
+                    else:
+                        result[field[0]] = parent
+                else:
+                    result[field[0]] = self.instance(field[1])
+            else:
+                self._skip_instance()
+        return result
+
+    def _skip_instance(self):
+        skip = self._buffer.read_bits(8)
+        if skip == 0:  # array
+            length = self._vint()
+            for i in xrange(length):
+                self._skip_instance()
+        elif skip == 1:  # bitblob
+            length = self._vint()
+            self._buffer.read_aligned_bytes((length + 7) / 8)
+        elif skip == 2:  # blob
+            length = self._vint()
+            self._buffer.read_aligned_bytes(length)
+        elif skip == 3:  # choice
+            tag = self._vint()
+            self._skip_instance()
+        elif skip == 4:  # optional
+            exists = self._buffer.read_bits(8) != 0
+            if exists:
+                self._skip_instance()
+        elif skip == 5:  # struct
+            length = self._vint()
+            for i in xrange(length):
+                tag = self._vint()
+                self._skip_instance()
+        elif skip == 6:  # u8
+            self._buffer.read_aligned_bytes(1)
+        elif skip == 7:  # u32
+            self._buffer.read_aligned_bytes(4)
+        elif skip == 8:  # u64
+            self._buffer.read_aligned_bytes(8)
+        elif skip == 9:  # vint
+            self._vint()