software_challenge_client 0.3.4 → 1.0.0

data/lib/software_challenge_client/game_state.rb

@@ -26,40 +26,27 @@ class GameState
   # @!attribute [rw] board
   # @return [Board] the game's board
   attr_accessor :board
-  # @!attribute [rw] lastMove
-  # @return [Move] the last move, that was made
-  attr_accessor :lastMove
+  # @!attribute [rw] last_move
+  # @return [Move] the last move performed
+  attr_accessor :last_move
   # @!attribute [rw] condition
   # @return [Condition] the winner and winning reason
   attr_accessor :condition
-  # @!attribute [rw] free_acceleration
-  # @return [Boolean] true if the free acceleration for this turn is still
-  #                   available.
-  attr_accessor :free_acceleration
-  alias free_acceleration? free_acceleration
-
-  # @!attribute [rw] free_turn
-  # @return [Boolean] True if the free turning for this turn is still
-  # available.
-  attr_accessor :free_turn
-  alias free_turn? free_turn
-
-  # @!attribute [rw] additional_free_turn_after_push
-  # @return [Boolean] True if the free turning for this turn is still
-  # available.
-  attr_accessor :additional_free_turn_after_push
-  alias additional_free_turn_after_push? additional_free_turn_after_push
-
-  POINTS_PER_TILE = 5
-  POINTS_PER_PASSENGER = 5
+  # @!attribute [rw] has_to_play_card
+  # @return [Boolean] true if the current player has to play a card
+  attr_accessor :has_to_play_card
+  alias has_to_play_card? has_to_play_card
+
+  def field(index)
+    board.field(index)
+  end
 
   def initialize
     @current_player_color = PlayerColor::RED
     @start_player_color = PlayerColor::RED
     @board = Board.new
-    @free_acceleration = true
-    @free_turn = true
-    @additional_free_turn_after_push = false
+    @has_to_play_card = false
+    @turn = 0
   end
 
   # adds a player to the gamestate
@@ -77,21 +64,16 @@ class GameState
   #
   # @return [Player] the current player
   def current_player
-    if current_player_color == PlayerColor::RED
-    then red
-    else blue
-    end
+    return red if current_player_color == PlayerColor::RED
+    return blue if current_player_color == PlayerColor::BLUE
   end
 
   # gets the other (not the current) player
   #
   # @return [Player] the other (not the current) player
   def other_player
-    if current_player_color == PlayerColor::RED
-      return blue
-    else
-      return red
-    end
+    return blue if current_player_color == PlayerColor::RED
+    return red if current_player_color == PlayerColor::BLUE
   end
 
   # gets the other (not the current) player's color
@@ -141,32 +123,55 @@ class GameState
 
   # calculates a player's points based on the current gamestate
   #
-  # @param player [Player] the player, whos point will be calculated
+  # @param player [Player] the player, whos points to calculate
   # @return [Integer] the points of the player
   def points_for_player(player)
-    player_field = board.field(player.x, player.y)
-    POINTS_PER_TILE * player_field.index +
-      POINTS_PER_PASSENGER * player.passengers +
-      player_field.points
+    player.index
   end
 
   # @return [Boolean] true if the given field is occupied by the other (not
   #                   current) player.
   def occupied_by_other_player?(field)
-    field.x == other_player.x && field.y == other_player.y
+    field.index == other_player.index
+  end
+
+  # Searches backwards starting at the field with the given index. The field
+  # at the given index is not considered. If no field of the given type exists,
+  # nil is returned.
+  #
+  # @param [FieldType] type of the field to search for
+  # @param [Integer] index before which field-index to start searching
+  # @return [Field] the next field before the given index of given type
+  def previous_field_of_type(type, index)
+    return nil if index < 1
+    return nil if index >= board.fields.size
+    board.fields.slice(0..(index - 1)).reverse.find {|f| f.type == type}
+  end
+
+  # Searches forward starting at the field with the given index. The field
+  # at the given index is not considered. If no field of the given type exists,
+  # nil is returned.
+  #
+  # @param [FieldType] type of the field to search for
+  # @param [Integer] index after which field-index to start searching
+  # @return [Field] the next field after the given index of given type
+  def next_field_of_type(type, index)
+    return nil if index >= board.fields.size
+    return nil if index < 0
+    board.fields.slice((index + 1)..(board.fields.size - 1)).find {|f| f.type == type}
   end
 
   # Compared with other state.
   def ==(other)
     turn == other.turn &&
-      start_player_color == other.start_player_color &&
-      current_player_color == other.current_player_color &&
-      red == other.red &&
-      blue == other.blue &&
-      board == other.board &&
-      lastMove == other.lastMove &&
-      free_acceleration == other.free_acceleration &&
-      condition == other.condition
+        start_player_color == other.start_player_color &&
+        current_player_color == other.current_player_color &&
+        red == other.red &&
+        blue == other.blue &&
+        board == other.board &&
+        lastMove == other.lastMove &&
+        has_to_play_card == other.has_to_play_card &&
+        condition == other.condition
   end
 
   # Create a deep copy of the gamestate. Can be used to perform moves on without
@@ -174,4 +179,117 @@ class GameState
   def deep_clone
     Marshal.load(Marshal.dump(self))
   end
+
+  def set_last_action(action)
+    return if action.instance_of? Skip
+    current_player.last_non_skip_action = action
+  end
+
+  def current_field
+    field(current_player.index)
+  end
+
+  def is_first(player)
+    if PlayerColor.opponent_color(player.color) == PlayerColor::RED
+      player.index > red.index
+    else
+      player.index > blue.index
+    end
+  end
+
+  def is_second(player)
+    !is_first(player)
+  end
+
+  def switch_current_player
+    current_player_color = other_player_color
+  end
+
+  def possible_moves
+    found_moves = []
+    if GameRules.is_valid_to_eat(self)[0]
+      # Wenn ein Salat gegessen werden kann, muss auch ein Salat gegessen werden
+      found_moves << Move.new([EatSalad.new])
+      return found_moves
+    end
+    if GameRules.is_valid_to_exchange_carrots(self, 10)[0]
+      found_moves << Move.new([ExchangeCarrots.new(10)])
+    end
+    if GameRules.is_valid_to_exchange_carrots(self, -10)[0]
+      found_moves << Move.new([ExchangeCarrots.new(-10)])
+    end
+    if GameRules.is_valid_to_fall_back(self)[0]
+      found_moves << Move.new([FallBack.new])
+    end
+    # Generiere mögliche Vorwärtszüge
+    (1..(GameRules.calculate_movable_fields(self.current_player.carrots))).each do |distance|
+      actions = []
+      clone = self.deep_clone
+      # Überprüfe ob Vorwärtszug möglich ist
+      if GameRules.is_valid_to_advance(clone, distance)[0]
+        try_advance = Advance.new(distance)
+        try_advance.perform!(clone)
+        actions << try_advance
+        # überprüfe, ob eine Karte gespielt werden muss/kann
+        if GameRules.must_play_card(clone)
+          clone.check_for_playable_cards(actions).each do |card|
+            found_moves << card # TODO: this is unexpected, rename or refactor
+          end
+        else
+        # Füge möglichen Vorwärtszug hinzu
+          found_moves << Move.new(actions)
+        end
+      end
+    end
+    if found_moves.empty?
+      found_moves << Move.new([Skip.new])
+    end
+    found_moves
+  end
+
+  # @return [Array[Move]] gibt liste von Zuegen zurueck, die gemacht werden koennen, vorausgesetzt die gegebene Liste von Aktionen wurde schon gemacht.
+  def check_for_playable_cards(actions)
+    found_card_playing_moves = []
+    if current_player.must_play_card
+      if GameRules.is_valid_to_play_eat_salad(self)[0]
+        found_card_playing_moves << Move.new(actions + [Card.new(CardType::EAT_SALAD)])
+      end
+      [20, -20, 0].each do |carrots|
+        if GameRules.is_valid_to_play_take_or_drop_carrots(self,carrots)[0]
+          found_card_playing_moves << Move.new(actions + [Card.new(CardType::TAKE_OR_DROP_CARROTS, carrots)])
+        end
+      end
+      if GameRules.is_valid_to_play_hurry_ahead(self)[0]
+        actions_with_card_played = actions + [Card.new(CardType::HURRY_AHEAD)]
+        # pruefe, ob auf Hasenfeld gelandet
+        clone = self.deep_clone
+        Card.new(CardType::HURRY_AHEAD).perform!(clone)
+        moves = []
+        if GameRules.must_play_card(clone)
+          moves = clone.check_for_playable_cards(actions_with_card_played)
+        end
+        if moves.empty?
+          found_card_playing_moves << Move.new(actions_with_card_played)
+        else
+          found_card_playing_moves += moves
+        end
+      end
+      if GameRules.is_valid_to_play_fall_back(self)[0]
+        actions_with_card_played = actions + [Card.new(CardType::FALL_BACK)]
+        # pruefe, ob auf Hasenfeld gelandet
+        clone = self.deep_clone
+        Card.new(CardType::FALL_BACK).perform!(clone)
+        moves = []
+        if GameRules.must_play_card(clone)
+          moves = clone.check_for_playable_cards(actions_with_card_played)
+        end
+        if moves.empty?
+          found_card_playing_moves << Move.new(actions_with_card_played)
+        else
+          found_card_playing_moves += moves
+        end
+      end
+    end
+    found_card_playing_moves
+  end
 end

data/lib/software_challenge_client/move.rb

@@ -17,9 +17,9 @@ class Move
 
   # Initializer
   #
-  def initialize
-    @actions = []
-    @hints = []
+  def initialize(actions = [], hints = [])
+    @actions = actions
+    @hints = hints
   end
 
   # adds a hint to the move
@@ -45,16 +45,26 @@ class Move
     @actions[index] = action
   end
 
-  def perform!(gamestate, current_player)
-    # check if acceleration is only first action
-    other_action_before = false
-    @actions.each do |a|
-      if a.type != :acceleration
-        other_action_before = true
-      elsif other_action_before
-        raise InvalidMoveException.new('Beschleunigung muss am Anfang des Zuges geschehen.', self)
-      end
+  def perform!(gamestate)
+    raise InvalidMoveException.new(
+        "Zug enthält keine Aktionen (zum Aussetzen die Aktion Skip benutzen).",
+        self) if @actions.empty?
+    @actions.each do |action|
+      action.perform!(gamestate)
+    end
+    raise InvalidMoveException.new(
+      'Es muss eine Karte gespielt werden.',
+      self) if gamestate.current_player.must_play_card
+    # change the state to the next turn
+    gamestate.last_move = self
+    gamestate.turn += 1
+    gamestate.switch_current_player
+    # change carrots for next player if on first/second-position-field
+    if gamestate.current_field.type == FieldType::POSITION_1 && gamestate.is_first(gamestate.current_player)
+      gamestate.current_player.carrots += 10
+    end
+    if gamestate.current_field.type == FieldType::POSITION_2 && gamestate.is_second(gamestate.current_player)
+      gamestate.current_player.carrots += 30
     end
-    @actions.each { |a| a.perform!(gamestate, current_player) }
   end
 end

data/lib/software_challenge_client/player.rb

@@ -1,62 +1,63 @@
 # encoding: UTF-8
+require_relative 'card_type'
 
-# A player, participating in a game
+# Ein Spieler
 class Player
   # @!attribute [r] name
-  # @return [String] the player's name
+  # @return [String] der Name des Spielers, hat keine Auswirkungen auf das Spiel
   attr_reader :name
 
   # @!attribute [r] color
-  # @return [PlayerColor] the player's color
+  # @return [PlayerColor] die Farbe des Spielers, Rot oder Blau
   attr_reader :color
 
   # @!attribute [rw] points
-  # @return [Integer] the player's points
+  # @return [Integer] der aktuelle Punktestand des Spielers
   attr_accessor :points
 
-  # @!attribute [rw] velocity
-  # @return [Integer] the player's current velocity
-  attr_accessor :velocity
+  # @!attribute [rw] index
+  # @return [Integer] die aktuelle Position des Spielers auf dem Spielbrett,
+  #   entspricht index des Feldes, von 0 bis 64
+  attr_accessor :index
 
-  # @!attribute [rw] coal
-  # @return [Integer] the player's current coal supply
-  attr_accessor :coal
+  # @!attribute [rw] carrots
+  # @return [Integer] die aktuelle Anzahl Karotten des Spielers
+  attr_accessor :carrots
 
-  # @!attribute [rw] direction
-  # @return [Direction] the player's current direction
-  attr_accessor :direction
+  # @!attribute [rw] salads
+  # @return [Integer] die aktuelle Anzahl Salate des Spielers
+  attr_accessor :salads
 
-  # @!attribute [rw] x
-  # @return [Integer] the player's current x-position
-  attr_accessor :x
+  # @!attribute [rw] cards
+  # @return [Array[CardType]] die noch nicht gespielten Karten
+  attr_accessor :cards
 
-  # @!attribute [rw] y
-  # @return [Integer] the player's current y-position
-  attr_accessor :y
+  # @!attribute [rw] last_non_skip_action
+  # @return [Action] letzte Aktion, die kein Skip war
+  attr_accessor :last_non_skip_action
 
-  # @!attribute [rw] movement
-  # @return [Direction] the player's current movement points
-  attr_accessor :movement
+  # @!attribute [rw] must_play_card
+  # @return [Boolean] zeigt an, ob eine Karte gespielt werden muss, wird in Zugvalidierung verwendet.
+  attr_accessor :must_play_card
 
-  # @!attribute [rw] passengers
-  # @return [Integer] how many passengers the player's has picked up
-  attr_accessor :passengers
-
-  # Initializer
-  # @param color [PlayerColor] the new player's color
-  # @param name [String] the new player's name (for displaying)
+  # Konstruktor
+  # @param color [PlayerColor] Farbe
+  # @param name [String] Name
   def initialize(color, name)
     @color = color
     @name = name
     @points = 0
-    @velocity = 1
-    @movement = 1
-    @coal = 6
-    @passengers = 0
-    @direction = Direction::RIGHT
+    @index = 0
+    @carrots = 68
+    @salads = 2
+    @cards = CardType.to_a
   end
 
   def ==(other)
     color == other.color
   end
+
+  def owns_card_of_type(card_type)
+    cards.include? card_type
+  end
 end

data/lib/software_challenge_client/player_color.rb

@@ -11,7 +11,7 @@ class PlayerColor < TypesafeEnum::Base
   #
   # @param color [PlayerColor] The player's color, whose opponent needs to be found
   # @return [PlayerColor] the opponent's color
-  def self.opponentColor(color)
+  def self.opponent_color(color)
     if color == PlayerColor::RED
       return PlayerColor::BLUE
     end

data/lib/software_challenge_client/protocol.rb

@@ -43,6 +43,12 @@ class Protocol
     REXML::Document.parse_stream(text, self)
   end
 
+
+  # called when text is encountered
+  def text(text)
+    @context[:last_text] = text
+  end
+
   # called if an end-tag is read
   #
   # @param name [String] the end-tag name, that was read
@@ -50,9 +56,8 @@ class Protocol
     case name
     when 'board'
       logger.debug @gamestate.board.to_s
-    when 'result'
-      logger.info 'Got game result'
-      @network.disconnect
+    when 'type'
+      @context[:player].cards << CardType.find_by_key(@context[:last_text].to_sym)
     end
   end
 
@@ -79,13 +84,16 @@ class Protocol
         logger.info "Game ended - ERROR: #{attrs['message']}"
         @network.disconnect
       end
+      if attrs['class'] == 'result'
+        logger.info 'Got game result'
+        @network.disconnect
+      end
     when 'state'
       logger.debug 'new gamestate'
       @gamestate = GameState.new
       @gamestate.turn = attrs['turn'].to_i
       @gamestate.start_player_color = attrs['startPlayer'] == 'RED' ? PlayerColor::RED : PlayerColor::BLUE
       @gamestate.current_player_color = attrs['currentPlayer'] == 'RED' ? PlayerColor::RED : PlayerColor::BLUE
-      @gamestate.additional_free_turn_after_push = attrs['freeTurn'] == 'true'
       logger.debug "Turn: #{@gamestate.turn}"
     when 'red'
       logger.debug 'new red player'
@@ -94,6 +102,7 @@ class Protocol
         throw new IllegalArgumentException("expected #{PlayerColor::RED} Player but got #{player.color}")
       end
       @gamestate.add_player(player)
+      @context[:player] = player
     when 'blue'
       logger.debug 'new blue player'
       player = parsePlayer(attrs)
@@ -101,39 +110,69 @@ class Protocol
         throw new IllegalArgumentException("expected #{PlayerColor::BLUE} Player but got #{player.color}")
       end
       @gamestate.add_player(player)
+      @context[:player] = player
     when 'board'
       logger.debug 'new board'
       @gamestate.board = Board.new
       @context[:current_tile_index] = nil
       @context[:current_tile_direction] = nil
-    when 'tile'
-      @context[:current_tile_index] = attrs['index'].to_i
-      @context[:current_tile_direction] = attrs['direction'].to_i
-    when 'field'
+    when 'fields'
       type = FieldType.find_by_key(attrs['type'].to_sym)
+      index = attrs['index'].to_i
       raise "unexpected field type: #{attrs['type']}. Known types are #{FieldType.map { |t| t.key.to_s }}" if type.nil?
-      x = attrs['x'].to_i
-      y = attrs['y'].to_i
-      points = attrs['points'].to_i
-      index = @context[:current_tile_index]
-      direction = @context[:current_tile_direction]
-
-      @gamestate.board.fields[[x, y]] = Field.new(type, x, y, index, direction, points)
+      @gamestate.board.fields[index] = Field.new(type, index)
     when 'lastMove'
-      @gamestate.lastMove = Move.new
-    when 'acceleration'
-      @gamestate.lastMove.add_action_with_order(Acceleration.new(attrs['acc'].to_i), attrs['order'].to_i)
+      @gamestate.last_move = Move.new
     when 'advance'
-      @gamestate.lastMove.add_action_with_order(Advance.new(attrs['distance'].to_i), attrs['order'].to_i)
-    when 'turn'
-      @gamestate.lastMove.add_action_with_order(Turn.new(attrs['direction'].to_i), attrs['order'].to_i)
-    when 'push'
-      @gamestate.lastMove.add_action_with_order(Push.new(Direction.find_by_key(attrs['direction'].to_sym)), attrs['order'].to_i)
+      @gamestate.last_move.add_action_with_order(
+          Advance.new(attrs['distance'].to_i), attrs['order'].to_i
+      )
+    when 'card'
+      @gamestate.last_move.add_action_with_order(
+          Card.new(CardType.find_by_key(attrs['type'].to_sym), attrs['value'].to_i),
+          attrs['order'].to_i
+      )
+    when 'skip'
+      @gamestate.last_move.add_action_with_order(
+          Skip.new, attrs['order'].to_i
+      )
+    when 'eatSalad'
+      @gamestate.last_move.add_action_with_order(
+          EatSalad.new, attrs['order'].to_i
+      )
+    when 'fallBack'
+      @gamestate.last_move.add_action_with_order(
+          FallBack.new, attrs['order'].to_i
+      )
+    when 'exchangeCarrots'
+      @gamestate.last_move.add_action_with_order(
+          ExchangeCarrots.new(attrs['value'].to_i), attrs['order'].to_i
+      )
     when 'winner'
-      @gamestate.condition = Condition.new(parsePlayer(attrs))
+      winning_player = parsePlayer(attrs)
+      @gamestate.condition = Condition.new(winning_player)
+      @context[:player] = winning_player
     when 'left'
       logger.debug 'got left event, terminating'
       @network.disconnect
+    when 'lastNonSkipAction'
+      @context[:player].last_non_skip_action =
+        case attrs['class']
+        when 'advance'
+          Advance.new(attrs['distance'].to_i)
+        when 'card'
+          Card.new(CardType.find_by_key(attrs['type'].to_sym), attrs['value'].to_i)
+        when 'skip'
+          Skip.new
+        when 'eatSalad'
+          EatSalad.new
+        when 'fallBack'
+          FallBack.new
+        when 'exchangeCarrots'
+          ExchangeCarrots.new(attrs['value'].to_i)
+        else
+          raise "Unknown action type #{attrs['class']}"
+        end
     end
   end
 
@@ -147,13 +186,10 @@ class Protocol
       attributes['displayName']
     )
     player.points = attributes['points'].to_i
-    player.direction = Direction.find_by_key(attributes['direction'].to_sym)
-    player.x = attributes['x'].to_i
-    player.y = attributes['y'].to_i
-    player.passengers = attributes['passenger'].to_i
-    player.coal = attributes['coal'].to_i
-    player.velocity = attributes['speed'].to_i
-    player.movement = player.velocity
+    player.index = attributes['index'].to_i
+    player.carrots = attributes['carrots'].to_i
+    player.salads = attributes['salads'].to_i
+    player.cards = []
     player
   end
 
@@ -171,6 +207,13 @@ class Protocol
     @network.sendString("<room roomId=\"#{@roomId}\">#{string}</room>")
   end
 
+  # converts "this_snake_case" to "thisSnakeCase"
+  def snake_case_to_lower_camel_case(string)
+    string.split('_').inject([]) do |result, e|
+      result + [result.empty? ? e : e.capitalize]
+    end.join
+  end
+
   # Converts a move to XML for sending to the server.
   #
   # @param move [Move] The move to convert to XML.
@@ -183,20 +226,20 @@ class Protocol
         # because XML-generation should be decoupled from internal data
         # structures.
         attribute = case action.type
-                    when :acceleration
-                      { acc: action.acceleration }
-                    when :push
-                      { direction: action.direction.key }
-                    when :turn
-                      { direction: action.turn_steps }
                     when :advance
                       { distance: action.distance }
-                    when default
+                    when :skip, :eat_salad, :fall_back
+                      {}
+                    when :card
+                      { type: action.card_type.key.to_s, value: action.value }
+                    when :exchange_carrots
+                      { value: action.value }
+                    else
                       raise "unknown action type: #{action.type.inspect}. "\
                             "Can't convert to XML!"
                     end
         attribute[:order] = index
-        data.tag!(action.type, attribute)
+        data.tag!(snake_case_to_lower_camel_case(action.type.to_s), attribute)
       end
     end
     move.hints.each do |hint|