smack_engine 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7c4e50efbe47d2ab9915687ca010ce6d2f35087
+  data.tar.gz: f3ca15482f06974c3391a54ed916ea3c67f5d987
+SHA512:
+  metadata.gz: cc5215dd6f4b80e982944423d16518b30ca5f1ae2e5612728b8a5c182dcd770a994aca456d6e027efd0af64c357b89cdeee40f93caea3ce05f50379b47e0ba9b
+  data.tar.gz: b0813b73ac38610d46a1eacf5ad45a6e6f6da0318e4f39f29292b0fc89495fb0a7a78441a3031f091e6be4c0bb0b3a5069ab6648366613b48b1ded7634233176

data/lib/smack_engine.rb

@@ -0,0 +1,14 @@
+module GameEngine
+end
+
+
+require 'smack_engine/game_rules'
+require 'smack_engine/cache'
+require 'smack_engine/card'
+require 'smack_engine/controller'
+require 'smack_engine/deck'
+require 'smack_engine/game_resolver'
+require 'smack_engine/game_state'
+require 'smack_engine/io'
+require 'smack_engine/player'
+

data/lib/smack_engine/cache.rb

@@ -0,0 +1,15 @@
+module GameEngine
+  module Cache
+    def self.save_game_state(game, caching_interface)
+      caching_interface.write "#{game.id}#{game.player_one.id}#{game.player_two.id}", game
+    end
+
+    def self.fetch_game_state(game_data, caching_interface)
+      caching_interface.read "#{game_data.id}#{game_data.player_one.id}#{game_data.player_two.id}"
+    end
+
+    def self.clear_game_state(game_data, caching_interface)
+      caching_interface.delete "#{game_data.id}#{game_data.player_one.id}#{game_data.player_two.id}"
+    end
+  end
+end

data/lib/smack_engine/card.rb

@@ -0,0 +1,22 @@
+module GameEngine
+  class Card
+    attr_reader :id, :card_type, :name, :description, :strength, :intelligence, :charisma, :time_period
+
+    def initialize(card_data)
+      @id = card_data.id
+      @type = card_data.card_type
+      @name = card_data.name
+      @description = card_data.description
+      @strength = card_data.strength
+      @intelligence = card_data.intelligence
+      @charisma = card_data.charisma
+      @time_period = card_data.time_period
+      @picture_url = card_data.picture_url
+    end
+
+    def max_stat
+      [strength,intelligence,charisma].max
+    end
+
+  end
+end

data/lib/smack_engine/controller.rb

@@ -0,0 +1,92 @@
+module GameEngine
+  module Controller
+
+    def self.save_game_state(game_state, caching_interface)
+      GameEngine::Cache.save_game_state(game_state, caching_interface)
+    end
+
+    def self.fetch_game_state(game_data, caching_interface)
+      GameEngine::Cache.fetch_game_state(game_data, caching_interface)
+    end
+
+    def self.update_game_state_time(game_state)
+      game_state.time = Time.now
+    end
+
+    def self.output_player_data(game_state, player_id)
+      GameEngine::IO.output_player_data(game_state, player_id)
+    end
+
+    def self.selection_made?(player)
+      !player.selection.empty?
+    end
+
+    def self.updatetime_savegamestate_and_outputplayerdata(game_state, player_id, caching_interface)
+      update_game_state_time(game_state)
+      save_game_state(game_state, caching_interface)
+      output_player_data(game_state, player_id)
+    end
+
+    def self.phase_time_check(game_state, time_input)
+      Time.now - game_state.time >= GAME_RULES[time_input]
+    end
+
+    def self.both_players_moved?(game_state)
+      selection_made?(game_state.player_one) && selection_made?(game_state.player_two)
+    end
+
+    def self.advance_game(game_data, player_id, caching_interface)
+      # This method is responsible for switching phases inside of the GameEngine::Game
+      # class when passed the ActiveRecord model of the game and the player_id for the
+      # client that's making the request.
+      game_state = GameEngine::Cache.fetch_game_state(game_data, caching_interface)
+      current_time = Time.now
+
+      current_player = game_state.target_player(player_id.to_i)
+      player_one = game_state.player_one
+      player_two = game_state.player_two
+
+      case game_state.phase
+      when :setup
+        if phase_time_check(game_state, :setup_time)
+          game_state.phase = :move
+          GameEngine::GameResolver.deal_cards(game_state)
+          updatetime_savegamestate_and_outputplayerdata(game_state, player_id, caching_interface)
+
+        end
+      when :move
+        if phase_time_check(game_state, :move_time) && !selection_made?(current_player)
+            current_player.selection << nil
+            save_game_state(game_state, caching_interface)
+            output_player_data(game_state, player_id)
+        end
+
+        if both_players_moved?(game_state)
+          game_state.phase = :resolution
+          updatetime_savegamestate_and_outputplayerdata(game_state, player_id, caching_interface)
+        end
+      when :won
+        output_player_data(game_state, player_id)
+      else
+        if phase_time_check(game_state, :resolution_time)
+          GameEngine::GameResolver.resolve_round(game_state)
+          unless game_state.won?
+            game_state.round += 1
+            game_state.phase = :move
+            GameEngine::GameResolver.deal_cards(game_state)
+          end
+          save_game_state(game_state, caching_interface)
+        end
+      end
+      output_player_data(game_state, player_id)
+    end
+
+    def self.get_player_move(game_data, player_id, card_id, caching_interface)
+      game_state = GameEngine::Cache.fetch_game_state(game_data, caching_interface)
+      if game_state.target_player(player_id).selection.empty? && game_state.phase == :move
+        GameEngine::IO.input_player_move(game_state, player_id, card_id)
+        save_game_state(game_state, caching_interface)
+      end
+    end
+  end
+end

data/lib/smack_engine/deck.rb

@@ -0,0 +1,12 @@
+module GameEngine
+  class Deck
+    attr_reader :list
+    def initialize(deck_data)
+      @list = deck_data.cards.map { |card| GameEngine::Card.new(card) }
+    end
+
+    def shuffle
+      list.shuffle!
+    end
+  end
+end

data/lib/smack_engine/game_resolver.rb

@@ -0,0 +1,46 @@
+module GameEngine
+  module GameResolver
+    def self.resolve_round(game_state)
+      @player_one = game_state.player_one
+      @player_two = game_state.player_two
+
+      calc_points
+      reset_selections
+      game_state.phase = :won if game_state.won?
+    end
+
+    def self.determine_maxstat(player)
+      player.selection.first.nil? ? 0 : player.selection.first.max_stat
+    end
+
+    #if player one has a higher maxstat, the overall damage value returned is positive.  If player two has a higher maxstat, the overall damage value returned is negative.
+    def self.damage
+      determine_maxstat(@player_one) - determine_maxstat(@player_two)
+    end
+
+    #Calc_points should work when the damage value returned from damage above is negative (when player two has a higher maxstat) or positive (when player one has a higher maxstat).  (For example, consider that the subtraction of a negative value adds a positive value and the addition of negative value subtracts that value.)
+    def self.calc_points
+      @player_one.points += damage
+      @player_two.points -= damage
+    end
+
+    def self.reset_selections
+      @player_one.selection = []
+      @player_two.selection = []
+    end
+
+    def self.deal_cards(game_state)
+      player_one = game_state.player_one
+      player_two = game_state.player_two
+
+      until player_one.hand.size == GAME_RULES[:hand_size]
+        player_one.hand << player_one.deck.list.pop
+      end
+
+      until player_two.hand.size == GAME_RULES[:hand_size]
+        player_two.hand << player_two.deck.list.pop
+      end
+    end
+
+  end
+end

data/lib/smack_engine/game_rules.rb

@@ -0,0 +1,3 @@
+module GameEngine
+  GAME_RULES = { starting_points: 20, hand_size: 6, setup_time: 5, move_time: 10, resolution_time: 5 }
+end

data/lib/smack_engine/game_state.rb

@@ -0,0 +1,30 @@
+module GameEngine
+  class GameState
+    attr_reader :id, :player_one, :player_two
+    attr_accessor :round, :time, :phase
+
+    def initialize(game_data)
+      @id = game_data.id
+      @player_one = GameEngine::Player.new(game_data.player_one)
+      @player_two = GameEngine::Player.new(game_data.player_two)
+      @round = 0
+      @phase = :setup
+      @time = Time.now
+    end
+
+    def target_player(player_id)
+      return player_one if player_one.id.to_i == player_id.to_i
+      return player_two if player_two.id.to_i == player_id.to_i
+      raise ArgumentError.new("No player found with id = #{player_id}")
+    end
+
+    def winner
+      return player_one if player_one.points > 0 && player_two.points <= 0
+      return player_two if player_two.points > 0 && player_one.points <= 0
+    end
+
+    def won?
+      winner != nil
+    end
+  end
+end

data/lib/smack_engine/io.rb

@@ -0,0 +1,18 @@
+module GameEngine
+  module IO
+    def self.output_player_data(game_state, player_id)
+      time_remaining = (Time.now - game_state.time).to_i
+
+      case player_id
+      when game_state.player_one.id
+        return { player_hand: game_state.player_one.hand, player_points: game_state.player_one.points, round: game_state.round, phase: game_state.phase, time_remaining: time_remaining }
+      when game_state.player_two.id
+        return { player_hand: game_state.player_two.hand, player_points: game_state.player_two.points, round: game_state.round, phase: game_state.phase, time_remaining: time_remaining  }
+      end
+    end
+
+     def self.input_player_move(game_state, player_id, card_id)
+        game_state.target_player(player_id).play_cards([card_id])
+     end
+  end
+end

data/lib/smack_engine/player.rb

@@ -0,0 +1,18 @@
+module GameEngine
+  class Player
+    attr_reader :id, :deck, :hand
+    attr_accessor :points, :selection
+
+    def initialize(player_data)
+      @id = player_data.id
+      @deck = GameEngine::Deck.new(player_data.deck)
+      @hand = []
+      @selection = []
+      @points = GameEngine::GAME_RULES[:starting_points]
+    end
+
+    def play_cards(indexes)
+      indexes.each { |i| selection << hand.delete_at(i) }
+    end
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: smack_engine
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Beatrix Carroll
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-05 00:00:00.000000000 Z
+dependencies: []
+description: The game engine for the game that was initially and affectionately known
+  as Smackwangler.
+email: beatrixcarroll@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/smack_engine.rb
+- lib/smack_engine/game_rules.rb
+- lib/smack_engine/cache.rb
+- lib/smack_engine/card.rb
+- lib/smack_engine/controller.rb
+- lib/smack_engine/deck.rb
+- lib/smack_engine/game_resolver.rb
+- lib/smack_engine/game_state.rb
+- lib/smack_engine/io.rb
+- lib/smack_engine/player.rb
+homepage: http://rubygems.org/gems/hola
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Smackwangler!
+test_files: []