hearthstone 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6688c037c7bb15f4b7af8a2b6229c1862d227496
+  data.tar.gz: 03f39b68809b08190ee873aa82b3fae9d77bc2c3
+SHA512:
+  metadata.gz: 7279bb27c93d6944e1110c38c38241632ca61466f51544649d3de57fe3abd64faa97688b666d9836dd98d092e7d402167770ebcde4bceb5f35960169b6e2f92b
+  data.tar.gz: d0a7adce7b9fec83076513a41f5c20abb7e046b0639d465c8f912b5a4ebf6c462801a29ce784bb2b6fbb9521c2466e2de8ce8f648574850dba499d67fd752e3c

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.DS_Store

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Francis Chong
+
+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,43 @@
+# Hearthstone
+
+Utlities for Hearthstone.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hearthstone'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hearthstone
+
+## Usage
+
+To record a game, run following command:
+
+    $ hearthstone-recorder
+
+Start hearthstone, any games will be saved to ~/Documents/hearthstone-recorder/
+
+## Attributions
+
+Card names and text are all copyright Blizzard Entertainment.
+
+This app is not affiliated with Blizzard Entertainment in any way.
+
+Used data from [hearthstonejson.com](http://hearthstonejson.com/).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/hearthstone/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/hearthstone-recorder

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'claide'
+
+require_relative '../lib/hearthstone'
+
+RecorderCommand.run(ARGV)

data/hearthstone.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hearthstone/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hearthstone"
+  spec.version       = Hearthstone::VERSION
+  spec.authors       = ["Francis Chong"]
+  spec.email         = ["francis@ignition.hk"]
+  spec.summary       = %q{Utlities for Hearthstone.}
+  spec.description   = %q{Utlities for Hearthstone. First, a game recorder.}
+  spec.homepage      = "https://github.com/siuying/hearthstone"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1"
+  spec.add_development_dependency "pry", "~> 0"
+
+  spec.add_dependency "claide", "~> 0.7"
+  spec.add_dependency "file-tail", "~> 1.0"
+end

data/lib/hearthstone.rb

@@ -0,0 +1,7 @@
+require_relative "./hearthstone/version"
+
+module Hearthstone
+end
+
+require_relative "./hearthstone/log"
+require_relative "./hearthstone/commands/recorder_command"

data/lib/hearthstone/commands/recorder_command.rb

@@ -0,0 +1,86 @@
+require 'claide'
+require 'json'
+
+require 'fileutils'
+require 'file/tail'
+
+require_relative '../log'
+
+class RecorderCommand < CLAide::Command
+  attr_reader :input, :output, :config, :complete
+
+  self.description = 'Record hearthstone games.'
+  self.command = 'hearthstone-recorder'
+  self.arguments = []
+
+  def self.options
+    [
+      ['--input-path', 'File path of the Hearthstone log files.'],
+      ['--config-path', 'Hearthstone config file path. (Default: ~/Library/Preferences/Blizzard/Hearthstone/log.config)'],
+      ['--output-path', 'File path of the output record files. (Default: ~/Documents/hearthstone-recorder)'],
+      ['--complete', 'Read the log file completely and re-create every games. Default: only watch for new games.']
+    ].concat(super)
+  end
+
+  def initialize(argv)
+    @input = argv.option('input-path', "#{Dir.home}/Library/Logs/Unity/Player.log")
+    @output = argv.option('output-path', "#{Dir.home}/Documents/hearthstone-recorder")
+    @config = argv.option('config-path', "#{Dir.home}/Library/Preferences/Blizzard/Hearthstone/log.config")
+    @complete = argv.flag?('complete', false)
+    super
+  end
+
+  def validate!
+    super
+
+    unless Dir.exists? self.output
+      Dir.mkdir(self.output)
+    end
+
+    configurator = Hearthstone::Log::Configurator.new(self.config)
+    if configurator.needs_config?
+      puts "Configure Hearthstone, if hearthstone is running, please restart it. (#{self.config})"
+      configurator.configure
+    end
+  end
+
+  def run
+    logger = Hearthstone::Log::GameLogger.new(self)
+
+    if self.complete
+      logger.log_file(File.open(self.input).read)
+    end
+
+    params = {}
+    params[:backward] = 10 unless self.complete
+
+    File::Tail::Logfile.open(self.input, params) do |file|
+      begin
+        file.interval = 10
+        file.tail do |line|
+          logger.log_line(line)
+        end
+      rescue Interrupt
+      end
+    end
+  end
+
+  # when game over, write the logs to output folder
+  def on_game_over(game)
+    json = game.to_json
+    filename = game.filename + ".json"
+
+    puts "Game recorded: #{game.players.first.name} vs #{game.players.last.name}"
+    File.open(File.join(self.output, filename), "w") do |f|
+      f.write(json)
+    end
+  end
+
+  def on_game_mode(mode)
+    puts "Game mode detected: #{mode}"
+  end
+
+  def on_event(event, data)
+    # puts "event: #{event.to_s} -> #{data}"
+  end
+end

data/lib/hearthstone/log.rb

@@ -0,0 +1,7 @@
+module Hearthstone
+  module Log
+  end
+end
+
+require_relative "./log/game_logger"
+require_relative "./log/configurator"

data/lib/hearthstone/log/configurator.rb

@@ -0,0 +1,41 @@
+module Hearthstone
+  module Log
+    class Configurator
+      attr_reader :path
+
+      def initialize(path="~/Library/Preferences/Blizzard/Hearthstone/log.config")
+        @path = path
+      end
+
+      def needs_config?
+        unless File.exists?(path)
+          return true
+        end
+
+        data = File.read(path)
+        !(data =~ /\[Zone\]/ && data =~ /\[Power\]/)
+      end
+
+      def configure
+        config = """[Zone]
+LogLevel=1
+FilePrinting=false
+ConsolePrinting=true
+ScreenPrinting=false
+
+[Power]
+LogLevel=1
+ConsolePrinting=true
+"""
+        mode = "w"
+        if File.exists?(path)
+          mode = "a"
+        end
+
+        File.open(path, mode) do |f|
+          f.write(config)
+        end
+      end
+    end
+  end
+end

data/lib/hearthstone/log/data.rb

@@ -0,0 +1 @@
+require_relative "./data/game"

data/lib/hearthstone/log/data/game.rb

@@ -0,0 +1,74 @@
+require_relative "./game_turn"
+require_relative "./game_player"
+require 'json'
+
+module Hearthstone
+  module Log
+    class Game
+      attr_accessor :mode
+      attr_reader :turns, :players, :results
+
+      def initialize(mode)
+        @mode = mode
+
+        @results = {}
+        @players = []
+        @turns = []
+
+        add_turn(number: 0, player: nil, timestamp: nil)
+      end
+
+      # proceed to next turn
+      def add_turn(number: nil, player: nil, timestamp: nil)
+        @turns << GameTurn.new(number: number, player: player, timestamp: timestamp)
+      end
+
+      # current turn
+      def current_turn
+        @turns.last
+      end
+
+      # create or get the player, with given id or name
+      def player_with_id_or_name(id: nil, name: nil)
+        player = players.detect {|p| (id && p.id == id) || (name && p.name == name) }
+        unless player
+          player = GamePlayer.new(name: name, id: id)
+          players << player
+        end
+        player
+      end
+
+      # if the game is completed
+      def completed?
+        self.results.count == 2
+      end
+
+      # convert the game into hash
+      def to_hash
+        players_hash = players.collect(&:to_hash)
+        turns_hash = turns.collect(&:to_hash)
+
+        {
+          mode: mode, 
+          players: players_hash, 
+          turns: turns_hash, 
+          results: results
+        }
+      end
+
+      # convert the game into JSON
+      def to_json
+        JSON.pretty_generate(to_hash)
+      end
+
+      # A unique filename for this Game
+      def filename
+        timestamp = turns.detect {|t| t.timestamp != nil }.timestamp rescue Time.now.to_i
+        time = Time.at(timestamp).strftime("%Y%m%d_%H%M%S")
+        player1 = players.first.name
+        player2 = players.last.name
+        "#{time}_#{mode}_#{player1}_vs_#{player2}"
+      end
+    end
+  end
+end

data/lib/hearthstone/log/data/game_player.rb

@@ -0,0 +1,25 @@
+module Hearthstone
+  module Log
+    class GamePlayer
+      attr_accessor :id, :name, :first_player
+      attr_accessor :hero, :hero_power
+
+      def initialize(id: nil, name: nil)
+        @name = name
+        @id = id
+        @first_player = false
+      end
+
+      def to_hash
+        {
+          id: id, 
+          name: name, 
+          first_player: first_player, 
+          hero: hero,
+          hero_power: hero_power
+        }
+      end
+
+    end
+  end
+end

data/lib/hearthstone/log/data/game_turn.rb

@@ -0,0 +1,32 @@
+module Hearthstone
+  module Log
+    class GameTurn
+      attr_accessor :number, :player, :timestamp
+      attr_reader :events
+
+      def initialize(number: nil, player: nil, timestamp: nil)
+        @events = []
+        @number = number
+        @player = player
+        @timestamp = timestamp        
+      end
+
+      def add_event(event, data, line=nil)
+        if line
+          @events.push([event, data, line])
+        else
+          @events.push([event, data])
+        end
+      end
+
+      def to_hash
+        {
+          number: number,
+          player: player,
+          timestamp: timestamp,
+          events: events
+        }
+      end
+    end
+  end
+end

data/lib/hearthstone/log/game_logger.rb

@@ -0,0 +1,128 @@
+require_relative "./parser"
+require_relative "./data"
+
+module Hearthstone
+  module Log
+    class GameLogger
+      attr_reader :parser, :debug
+      attr_accessor :game, :delegate, :mode
+
+      def initialize(delegate, debug: false)
+        @delegate = delegate
+        @parser = Parser.new
+        @game = Game.new(nil)
+        @debug = debug
+        @mode = nil
+      end
+
+      def log_file(io)
+        io.each_line do |line|
+          log_line(line)
+        end
+      end
+
+      def log_line(line)
+        result = parser.parse_line(line)
+        if result
+          name = result[0]
+          data = result[1]
+          log_line = line if self.debug
+          process_event(name, data, log_line)
+        end
+      end
+
+      private
+      def process_event(event, data, line=nil)
+        case event
+        when :game_start
+          # ignored
+        when :game_over
+          on_game_over(data)
+        when :turn_start
+          on_turn_start(data)
+        when :turn
+          on_turn(data)
+        when :begin_spectator_mode, :end_spectator_mode
+          # ignored
+        when :mode
+          on_game_mode(data)
+        when :player_id
+          on_player_id(data)
+        when :first_player
+          on_first_player(data)
+        when :attack, :attacked
+          # ignored
+        when :set_hero
+          on_set_hero(data)
+        when :set_hero_power
+          on_set_hero_power(data)
+        when :hero_destroyed
+          on_hero_destroyed(data)
+        else
+          if event
+            on_event(event, data, line)
+          end
+        end
+      end
+
+      def on_game_mode(mode)
+        self.mode = mode
+        self.game = Game.new(mode)
+
+        if delegate.respond_to?(:on_game_mode)
+          delegate.on_game_mode(mode)
+        end
+      end
+
+      def on_player_id(name: nil, player_id: nil)
+        player = self.game.player_with_id_or_name(name: name, id: player_id)
+        player.name = name
+        player.id = player_id
+      end
+
+      def on_first_player(name: nil)
+        self.game.player_with_id_or_name(name: name).first_player = true
+      end
+
+      def on_set_hero(player_id: nil, id: nil, card_id: nil)
+        self.game.player_with_id_or_name(id: player_id).hero = {id: id, card_id: card_id}
+      end
+
+      def on_set_hero_power(player_id: nil, id: nil, card_id: nil)
+        self.game.player_with_id_or_name(id: player_id).hero_power = {id: id, card_id: card_id}
+      end
+
+      def on_game_over(name: nil, state: nil)
+        self.game.results[name] = state
+
+        if delegate.respond_to?(:on_game_over)
+          if self.game.completed? && self.game.results.count == 2
+            delegate.on_game_over(self.game)
+          end
+        end
+      end
+
+      def on_hero_destroyed(player_id: nil, id: nil, card_id: nil)
+        # when hero destroyed, the game is ended, we should proceed to next game
+        self.game = Game.new(self.mode)
+      end
+
+      def on_turn_start(name: nil, timestamp: nil)
+        self.game.current_turn.player = name
+        self.game.current_turn.timestamp = timestamp
+      end
+
+      def on_turn(turn)
+        self.game.add_turn(number: turn)
+      end
+
+      def on_event(event, data, line=nil)
+        self.game.current_turn.add_event(event, data, line)
+
+        if delegate.respond_to?(:on_event)
+          delegate.on_event(event, data)
+        end
+      end
+    end
+  end
+end