hearthstone 0.2.0 → 0.3.0

data/lib/hearthstone/models/card.rb

@@ -1,20 +0,0 @@
-module Hearthstone
-  module Models
-    class Card
-      attr_accessor :name, :cost, :type, :rarity, :faction, :text, :mechanics, :flavor
-      attr_accessor :artist, :attack, :health, :collectible, :id, :elite
-
-      def eql?(other)
-        other.equal?(id) || id == other.id
-      end
-
-      def hash
-        id.hash
-      end
-
-      def to_s
-        "<Card \"#{name}\">"
-      end
-    end
-  end
-end

data/lib/hearthstone/models/card_store.rb

@@ -1,50 +0,0 @@
-require 'json'
-require_relative './card'
-
-module Hearthstone
-  module Models
-    class CardStore
-      STORE_FILE = "./AllSetsAllLanguages.json"
-
-      attr_reader :cards
-
-      def initialize(lang="enUS")
-        filename = File.join(File.dirname(__FILE__), STORE_FILE)
-        config = JSON(File.read(filename))
-        @cards = {}
-
-        if config[lang]
-          config[lang].each do |set, cards_data|
-            cards_data.each do |data|
-              card = Card.new
-              card.name = data["name"]
-              card.cost = data["cost"]
-              card.type = data["type"]
-
-              card.rarity = data["rarity"]
-              card.faction = data["faction"]
-              card.text = data["text"]
-              card.mechanics = data["mechanics"]
-
-              card.flavor = data["flavor"]
-              card.artist = data["artist"]
-              card.attack = data["attack"]
-              card.health = data["health"]
-              card.collectible = data["collectible"]
-              card.id = data["id"]
-              card.elite = data["elite"]
-
-              @cards[card.id] = card
-            end
-          end
-        else
-          raise "language '#{lang}'' not found!"
-        end
-      end
-
-      def card_with_id(id)
-        @cards[id]
-      end
-    end
-  end
-end

data/lib/hearthstone/models/entity.rb

@@ -1,67 +0,0 @@
-module Hearthstone
-  module Models
-    # represent an object in game
-    class Entity
-      attr_accessor :id, :card, :damaged
-      attr_reader :attachments
-
-      def initialize(id: nil, card: nil)
-        @id = id
-        @card = card
-        @damaged = 0
-        @attachments = []
-      end
-
-      def eql?(other)
-        other.equal?(id) || id == other.id
-      end
-
-      def hash
-        id.hash
-      end
-
-      def attach(card)
-        attachments << card
-      end
-
-      def detach(card)
-        attachments.delete(card)
-      end
-
-      def current_health
-        if self.card
-          [0, self.card.health - damaged].max
-        else
-          0
-        end
-      end
-
-      def attack
-        self.card.attack
-      end
-
-      def name
-        card.name
-      end
-
-      def to_s
-        attachment_names = attachments.collect(&:name)
-        attachment_str = ""
-        if attachment_names.count > 0
-          attachment_str = attachment_names.join(", ")
-        end
-
-        if card
-          case card.type
-          when "Minion"
-            "##{id} #{card.name} (#{attack}/#{current_health}) #{attachment_str}"
-          else
-            "##{id} #{card.name}"
-          end
-        else
-          "##{id} Hidden"
-        end
-      end
-    end
-  end
-end

data/lib/hearthstone/models/game.rb

@@ -1,151 +0,0 @@
-require 'json'
-require 'set'
-
-require_relative './card_store'
-require_relative './entity'
-require_relative './player'
-
-module Hearthstone
-  module Models
-    class Game
-      attr_reader :store, :entities, :players
-      attr_accessor :turn
-
-      def initialize(store=CardStore.new)
-        @store = store
-        @entities = {}
-        @players = []
-      end
-
-      ## Events
-
-      def add_player(id: nil, name: nil, first_player: nil, hero_id: nil, hero_card_id: nil, hero_power_id: nil, hero_power_card_id: nil)
-        hero = entity_with_id(hero_id, card_id: hero_card_id)
-        hero_power = entity_with_id(hero_power_id, card_id: hero_power_card_id)
-        player = Player.new(id: id, name: name, first_player: first_player, hero: hero, hero_power: hero_power)
-        self.players << player
-      end
-
-      def open_card(id: nil, card_id: nil)
-        entity_with_id(id).card = card_with_card_id(card_id)
-      end
-
-      def card_revealed(id: nil, card_id: nil, player_id: nil)
-        entity_with_id(id).card = card_with_card_id(card_id)
-      end
-
-      def card_added_to_deck(player_id: nil, id: nil, card_id: nil)
-        entity = entity_with_id(id, card_id: card_id)
-        entity.card = card_with_card_id(card_id)
-        player = player_with_id(player_id)
-        raise "Player #{player_id} not found!" unless player
-
-        player.move_card(entity, :deck)
-      end
-
-      def card_received(player_id: nil, id: nil, card_id: nil)
-        entity = entity_with_id(id, card_id: card_id)
-        entity.card = card_with_card_id(card_id)
-        player = player_with_id(player_id)
-        raise "Player #{player_id} not found!" unless player
-
-        player.move_card(entity, :hand)
-      end
-
-      def card_drawn(player_id: nil, id: nil, card_id: nil)
-        entity = entity_with_id(id, card_id: card_id)
-        entity.card = card_with_card_id(card_id)
-        player = player_with_id(player_id)
-        raise "Player #{player_id} not found!" unless player
-
-        player.move_card(entity, :hand)
-      end
-
-      def card_attached(attachment_id: nil, target_id: nil)
-        target      = entity_with_id(target_id)
-        attachment  = entity_with_id(attachment_id)
-        target.attach(attachment)
-      end
-
-      def apply_damage(id: nil, amount: 0, card_id: nil, player_id: nil)
-        target = entity_with_id(id)
-        target.damaged = amount
-      end
-      alias_method :damage, :apply_damage
-
-      def card_played(player_id: nil, id: nil, card_id: nil)
-        player = player_with_id(player_id)
-        target = entity_with_id(id)
-        target.card = card_with_card_id(card_id)
-        raise "Player #{player_id} not found!" unless player
-        #binding.pry
-
-        player.move_card(target, :play)
-      end
-
-      def card_destroyed(player_id: nil, id: nil, card_id: nil)
-        player = player_with_id(player_id)
-        target = entity_with_id(id)
-        raise "Player #{player_id} not found!" unless player
-
-        player.move_card(target, :graveyard)
-      end
-      alias_method :card_discarded, :card_destroyed
-
-      def card_put_in_play(player_id: nil, id: nil, card_id: nil)
-        entity = entity_with_id(id, card_id: card_id)
-        entity.card = card_with_card_id(card_id)
-        player = player_with_id(player_id)
-        raise "Player #{player_id} not found!" unless player
-
-        player.move_card(entity, :play)
-      end
-
-      ## Accessors
-
-      def entity_with_id(id, card_id: nil)
-        entity = entities[id]
-        unless entity
-          entity = Entity.new(id: id, card: card_with_card_id(card_id))
-          entities[id] = entity
-        end
-        entity
-      end
-
-      def player_with_id(id)
-        self.players.detect{|p| p.id == id}
-      end
-
-      def card_with_card_id(card_id)
-        card = nil
-        if card_id && card_id != ""
-          card = self.store.card_with_id(card_id)
-          raise "Card #{card_id} not found!" unless card
-        end
-        card
-      end
-
-      ## Public
-
-      def to_s
-        player1 = self.players.first
-        player2 = self.players.last
-
-        """======================= Turn ##{turn} =====================
-#{player1.name} (#{player1.hero.current_health})
-======================================================
-
-#{player1.play.collect(&:to_s).join("\n")}
-
-----------------------------------------------------
-
-#{player2.play.collect(&:to_s).join("\n")}
-
-======================================================
-#{player2.name} (#{player2.hero.current_health})
-======================================================
-"""
-      end
-    end
-  end
-end

data/lib/hearthstone/models/game_loader.rb

@@ -1,52 +0,0 @@
-require 'json'
-
-require_relative './game'
-
-module Hearthstone
-  module Models
-    class GameLoader
-      attr_accessor :data
-      attr_reader :game
-
-      def initialize(data)
-        @data = data
-        @game = Game.new
-      end
-
-      def load_players
-        data[:players].each do |player|
-          game.add_player(id: player[:id], name: player[:name], first_player: player[:first_player], 
-            hero_id: player[:hero][:id], hero_card_id: player[:hero][:card_id], 
-            hero_power_id: player[:hero_power][:id], hero_power_card_id: player[:hero_power][:card_id])
-        end
-      end
-
-      def load_turns
-        data[:turns].each do |turn|
-          load_turn(number: turn[:number], events: turn[:events])
-        end
-      end
-
-      def load_turn(number: 0, events: [])
-        game.turn = number
-
-        events.each do |event|
-          load_event(event[0], event[1])
-        end
-      end
-
-      def load_event(name, data)
-        event_sym = name.to_sym
-        case event_sym
-        when :open_card, :card_received, :card_revealed, :card_played, :card_added_to_deck, :card_drawn, :card_discarded, :card_destroyed, :card_put_in_play
-          game.send(event_sym, data)
-        when :damaged
-          game.apply_damage(id: data[:id], amount: data[:amount])
-        when :attached
-          game.card_attached(attachment_id: data[:id], target_id: data[:target])
-        end          
-      end
-
-    end
-  end
-end

data/lib/hearthstone/models/player.rb

@@ -1,37 +0,0 @@
-module Hearthstone
-  module Models
-    class Player
-      attr_reader :id, :name, :first_player
-      attr_accessor :hero, :hero_power
-      attr_reader :deck, :hand, :play, :graveyard, :setaside
-
-      def initialize(id: nil, name: nil, first_player: nil, hero: nil, hero_power: nil)
-        @id = id
-        @name = name
-        @first_player = first_player
-        @hero = hero
-        @hero_power = hero_power
-
-        @deck = Set.new
-        @hand = Set.new
-        @play = Set.new
-        @graveyard = Set.new
-        @setaside = Set.new
-      end
-
-      def move_card(card, to_zone)
-        [:deck, :hand, :play, :graveyard, :setaside].each do |zone|
-          if to_zone != zone
-            self.send(zone).delete(card)
-          else
-            self.send(to_zone) << card
-          end
-        end
-      end
-
-      def to_s
-        "<Player ##{id} \"#{name}\">"
-      end
-    end
-  end
-end

data/spec/hearthstone/models/card_store_spec.rb

@@ -1,16 +0,0 @@
-require_relative "../../../lib/hearthstone/models"
-
-
-describe Hearthstone::Models::CardStore do
-  let(:store) { Hearthstone::Models::CardStore.new }
-
-  context "#card_with_id" do
-    it "returns the card with specific id" do
-      jenkins = store.card_with_id("EX1_116")
-      expect(jenkins.name).to eq("Leeroy Jenkins")
-
-      jenkins2 = store.card_with_id("EX1_116")
-      expect(jenkins2).to eq(jenkins)
-    end
-  end
-end

data/spec/hearthstone/models/game_loader_spec.rb

@@ -1,153 +0,0 @@
-require_relative "../../../lib/hearthstone/models"
-require 'json'
-
-describe Hearthstone::Models::GameLoader do
-  before(:all) {
-    filename = File.join(File.dirname(__FILE__), "../../fixtures/game1.json")
-    @data = JSON.parse(open(filename).read, symbolize_names: true)
-  }
-
-  context "#load_players" do
-    it "should load players" do
-      loader = Hearthstone::Models::GameLoader.new(@data)
-      loader.load_players
-
-      game = loader.game
-      expect(game.players.count).to eq(2)
-
-      first = game.players.first
-      expect(first.name).to eq("ALzard")
-      expect(first.hero.name).to eq("Thrall")
-
-      last = game.players.last
-      expect(last.name).to eq("siuying")
-      expect(last.hero.name).to eq("Rexxar")
-    end
-  end
-
-  context "Load Games" do
-    before(:each) do
-      @loader = Hearthstone::Models::GameLoader.new(@data)
-      @loader.load_players
-      @game = @loader.game
-    end
-
-    context "#load_event" do
-      it "should load open card event" do
-        @loader.load_event(:open_card, id: 5, card_id: "CS2_101")
-
-        entity = @game.entity_with_id(5)
-        expect(entity.card.id).to eq("CS2_101")
-      end
-
-      it "should load card received event" do
-        @loader.load_event(:card_received, player_id: 2, id: 7, card_id: "CS2_101")
-
-        entity = @game.entity_with_id(7)
-        expect(entity.card.id).to eq("CS2_101")
-
-        player = @game.player_with_id(2)
-        expect(player.hand).to include(entity)
-      end
-
-      it "should load card reveal event" do
-        @loader.load_event(:open_card, id: 7, card_id: "")
-        @loader.load_event(:card_revealed, id: 7, card_id: "CS2_101")
-
-        entity = @game.entity_with_id(7)
-        expect(entity.card.id).to eq("CS2_101")
-      end
-
-      it "should load card_added_to_deck event" do
-        @loader.load_event(:card_added_to_deck, player_id: 2, id: 7, card_id: "")
-
-        entity = @game.entity_with_id(7)
-        expect(entity.card).to be_nil
-
-        player = @game.player_with_id(2)
-        expect(player.deck).to include(entity)
-      end
-
-      it "should handle card_drawn event" do
-        @loader.load_event(:card_drawn, player_id: 2, id: 7, card_id: "CS2_101")
-
-        entity = @game.entity_with_id(7)
-        player = @game.player_with_id(2)
-        expect(player.hand).to include(entity)
-      end
-
-      it "should handle card_destroyed event" do
-        @loader.load_event(:card_destroyed, player_id: 1, id: 26)
-
-        entity = @game.entity_with_id(26)
-        player = @game.player_with_id(1)
-        expect(player.graveyard).to include(entity)
-      end
-
-      it "should handle card_put_in_play event" do
-        @loader.load_event(:card_put_in_play, player_id: 2, id: 7, card_id: "CS2_101")
-
-        entity = @game.entity_with_id(7)
-        player = @game.player_with_id(2)
-        expect(player.play).to include(entity)
-      end
-
-      it "should handle damaged event" do
-        @loader.load_event(:damaged, id: 7, amount: 2)
-
-        entity = @game.entity_with_id(7)
-        expect(entity.damaged).to eq(2)
-      end
-
-      it "should handle attached event" do
-        @loader.load_event(:open_card, id: 7, card_id: "")
-        @loader.load_event(:open_card, id: 26, card_id: "")
-        @loader.load_event(:attached, id: 26, target: 7)
-
-        entity = @game.entity_with_id(7)
-        attachment = @game.entity_with_id(26)
-        expect(entity.attachments).to include(attachment)
-      end
-      
-    end
-  end
-
-  context "#load_turns" do
-      before(:each) do
-      filename = File.join(File.dirname(__FILE__), "../../fixtures/gamelog1.json")
-      @data = JSON.parse(open(filename).read, symbolize_names: true)
-      @loader = Hearthstone::Models::GameLoader.new(@data)
-      @loader.load_players
-      @game = @loader.game
-    end
-
-    it "should load a game" do
-      @data[:turns].each do |turn|
-        @loader.load_turn(number: turn[:number], events: turn[:events])
-
-        @game.players.each do |player|
-          # deck cards always unknown
-          player.deck.each do |entity|
-            expect(entity.card).to be_nil
-          end
-
-          # graveyard cards always known
-          player.graveyard.each do |entity|
-            expect(entity.card).to_not be_nil
-          end
-
-          # hands cards only known for current player
-          player.hand.each do |entity|
-            if player.name == "siuying"
-              expect(entity.card).to_not be_nil
-            else
-              expect(entity.card).to be_nil
-            end
-          end
-        end
-      end
-
-    end
-  end
-
-end