software_challenge_client 1.2.1 → 19.0.0

data/lib/software_challenge_client/invalid_move_exception.rb

@@ -1,16 +1,14 @@
-# encoding: UTF-8
+# encoding: utf-8
 
-# Exception indicating a move which was performed is not valid for the given
-# state.
+# Exception, die geworfen wird, wenn ein ungültiger Zug ausgeführt wird.
+# @see Move#perform!
 class InvalidMoveException < StandardError
-  def initialize(msg, move_or_action)
-    # This exception will be thrown by a move or by an individual action,
-    # depending where the rule violation was detected.
-    @move_or_action = move_or_action
+  def initialize(msg, move)
+    @move = move
     super(msg)
   end
 
   def message
-    "#{super}: #{@move_or_action}"
+    "#{super}: #{@move}"
   end
 end

data/lib/software_challenge_client/line.rb

@@ -0,0 +1,126 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require_relative './util/constants'
+require_relative 'direction'
+require_relative 'coordinates'
+require_relative 'line_direction'
+
+# Ein Iterator, der alle Koordinatenpaare auf einer Linie des Spielbrettes enthält.
+class Line
+  include Enumerable
+  include Constants
+
+  # Erzeugt einen neuen Iterator.
+  #
+  # @param start [Coordinates]
+  # @param direction [LineDirection]
+  def initialize(start, direction)
+    @direction = direction
+    @start = start
+    # we will iterate from left to right, so find the leftmost field on the line
+    # inside the field note that (0,0) is the lowest, leftmost point, x-axis
+    # goes to the right, y-axis goes up
+    case @direction
+    when LineDirection::HORIZONTAL
+      leftmost_x = 0
+      leftmost_y = @start.y
+    when LineDirection::VERTICAL
+      leftmost_x = @start.x
+      leftmost_y = SIZE - 1
+    when LineDirection::RISING_DIAGONAL
+      # for rising diagonals, we have to decrease x and y
+      shift = [@start.x, @start.y].min
+      leftmost_x = @start.x - shift
+      leftmost_y = @start.y - shift
+    when LineDirection::FALLING_DIAGONAL
+      # for falling diagonals, we have to decrease x and increase y
+      shift = [@start.x, (SIZE - 1) - @start.y].min
+      leftmost_x = @start.x - shift
+      leftmost_y = @start.y + shift
+    end
+    @xi = leftmost_x
+    @yi = leftmost_y
+
+    @members = []
+    while @xi >= 0 && @yi >= 0 && @xi < SIZE && @yi < SIZE
+      @members << Coordinates.new(@xi, @yi)
+      # horizontal lines and diagonals move right
+      if [LineDirection::HORIZONTAL,
+          LineDirection::RISING_DIAGONAL,
+          LineDirection::FALLING_DIAGONAL].include? @direction
+        @xi += 1
+      end
+      # vertical lines and falling diagonals move down
+      if [LineDirection::VERTICAL,
+          LineDirection::FALLING_DIAGONAL].include? @direction
+        @yi -= 1
+      elsif @direction == LineDirection::RISING_DIAGONAL
+        # rising diagonals move up
+        @yi += 1
+      end
+    end
+  end
+
+  def each(&block)
+    @members.each(&block)
+  end
+
+  # Begrenzt den Iterator auf Koordinatenpaare von Feldern innerhalb der gegebenen beiden Koordinatenpaare (exklusive).
+  # Kann als Filter verwendet werden.
+  #
+  # @example
+  #   Line.new(
+  #     Coordinates.new(2, 3), LineDirection::HORIZONTAL
+  #   ).select do |c|
+  #     Line.between(Coordinates.new(2, 3), Coordinates.new(5, 3), LineDirection::HORIZONTAL).call(c)
+  #   end
+  def self.between(start, bound, direction)
+    lower_x = [start.x, bound.x].min
+    lower_y = [start.y, bound.y].min
+    higher_x = [start.x, bound.x].max
+    higher_y = [start.y, bound.y].max
+    proc do |f|
+      case direction
+      when LineDirection::HORIZONTAL
+        f.x > lower_x && f.x < higher_x
+      when LineDirection::VERTICAL
+        f.y > lower_y && f.y < higher_y
+      when LineDirection::RISING_DIAGONAL, LineDirection::FALLING_DIAGONAL
+        f.x > lower_x && f.x < higher_x && f.y > lower_y && f.y < higher_y
+      else
+        throw `unknown direction ${direction}`
+      end
+    end
+  end
+
+  # @param line_direction [LineDirection] Ausrichtung der Linie
+  # @return [Array<Direction>] Die beiden Bewegungsrichtungen, die auf einer Linie mit der Ausrichtung möglich sind.
+  def self.directions_for_line_direction(line_direction)
+    case line_direction
+    when LineDirection::HORIZONTAL
+      [Direction::LEFT, Direction::RIGHT]
+    when LineDirection::VERTICAL
+      [Direction::UP, Direction::DOWN]
+    when LineDirection::RISING_DIAGONAL
+      [Direction::UP_RIGHT, Direction::DOWN_LEFT]
+    when LineDirection::FALLING_DIAGONAL
+      [Direction::UP_LEFT, Direction::DOWN_RIGHT]
+    end
+  end
+
+  # @param line_direction [Direction] Bewegungsrichtung
+  # @return [Array<Direction>] Die Ausrichtung einer Linie, die auf der Bewegungsrichtung liegt.
+  def self.line_direction_for_direction(direction)
+    case direction
+    when Direction::LEFT, Direction::RIGHT
+      LineDirection::HORIZONTAL
+    when Direction::UP, Direction::DOWN
+      LineDirection::VERTICAL
+    when Direction::UP_RIGHT, Direction::DOWN_LEFT
+      LineDirection::RISING_DIAGONAL
+    when Direction::UP_LEFT, Direction::DOWN_RIGHT
+      LineDirection::FALLING_DIAGONAL
+    end
+  end
+end

data/lib/software_challenge_client/line_direction.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'typesafe_enum'
+# Ausrichtung einer Linie auf dem Spielbrett. Mögliche Werte sind:
+# - HORIZONTAL
+# - VERTICAL
+# - RISING_DIAGONAL
+# - FALLING_DIAGONAL
+
+class LineDirection < TypesafeEnum::Base
+  new :HORIZONTAL
+  new :VERTICAL
+  new :RISING_DIAGONAL
+  new :FALLING_DIAGONAL
+end

data/lib/software_challenge_client/logging.rb

@@ -1,9 +1,10 @@
+# coding: utf-8
 require 'logger'
 
-# This module provides a shared logger to all classes into which it is mixed.
+# Dieses Modul kann inkludiert werden, um eine Logausgabe auf der Konsole verwenden zu können.
 # See http://stackoverflow.com/a/6768164/390808
 #
-# Usage:
+# Verwendung:
 #
 #   class MyClass
 #     include Logging

data/lib/software_challenge_client/move.rb

@@ -1,70 +1,83 @@
-# encoding: UTF-8
+# encoding: utf-8
 require_relative 'debug_hint'
-require_relative 'action'
 
-# A move that can be performed in Mississippi Queen. A move consists of multiple
-# actions in a specific order.
+# Ein Spielzug. Er ist definiert durch das Koordinatenpaar des Ausgangsfeldes (ein Fisch des Spielers, der den Zug machen will) und eine Bewegungsrichtung.
 class Move
-  # @!attribute [r] actions
+  # @!attribute [r] x
+  # @return [Integer] X-Koordinate des Fisches, der bewegt werden soll. Die Spalte ganz links auf dem Spielbrett hat X-Koordinate 0, die ganz rechts 9.
+  attr_reader :x
+
+  # @!attribute [r] y
+  # @return [Integer] Y-Koordinate des Fisches, der bewegt werden soll. Die Zeile ganz unten auf dem Spielbrett hat Y-Koordinate 0, die ganz oben 9.
+  attr_reader :y
+
+  # @!attribute [r] direction
   #
-  # @return [Array<Action>] List of actions which should be performed in this
-  #                         move in the order determined by the array order.
-  attr_reader :actions
+  # @return [Direction] Die Richtung, in die bewegt werden soll.
+  attr_reader :direction
 
   # @!attribute [r] hints
-  # @return [Array<DebugHint>] the move's hints
+  # @return [Array<DebugHint>] Hinweise, die an den Zug angeheftet werden sollen. Siehe {DebugHint}.
   attr_reader :hints
 
-  # Initializer
-  #
-  def initialize(actions = [], hints = [])
-    @actions = actions
-    @hints = hints
+  # Erstellt einen neuen Zug.
+  # @param x [Integer]
+  # @param y [Integer]
+  # @param direction [Direction]
+  def initialize(x, y, direction)
+    @x = x
+    @y = y
+    @direction = direction
+    @hints = []
   end
 
-  # adds a hint to the move
-  # @param hint [DebugHint] the added hint
+  # @param hint [DebugHint]
   def add_hint(hint)
     @hints.push(hint)
   end
 
   def ==(other)
-    actions.size == other.actions.size &&
-      actions.zip(other.actions).map { |a, b| a == b }.all?
+    x == other.x && y == other.y && direction == other.direction
   end
 
   def to_s
-    "Move: #{actions}"
+    "Move: (#{x},#{y}) #{direction}"
   end
 
-  def add_action(action)
-    @actions << action
+  # @return [Coordinates] Die Koordinaten des Ausgangsfeldes des Zuges als Koordinatenpaar.
+  def from_field
+    Coordinates.new(x, y)
   end
 
-  def add_action_with_order(action, index)
-    @actions[index] = action
+  # Überprüft, ob der Zug in dem gegebenen Spielzustand regelkonform ausgeführt werden kann.
+  # @param gamestate [GameState]
+  # @return [Boolean]
+  def valid?(gamestate)
+    GameRuleLogic.valid_move(self, gamestate.board)
   end
 
+  # Führt den Zug in dem gegebenen Spielzustand aus. Sollte dabei gegen Spielregeln verstossen werden, wird eine InvalidMoveException geworfen.
+  # @param gamestate [GameState]
   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)
+    if GameRuleLogic.valid_move(self, gamestate.board)
+      type = gamestate.board.field(x, y).type
+      gamestate.board.change_field(x, y, FieldType::EMPTY)
+      target = GameRuleLogic.move_target(self, gamestate.board)
+      gamestate.board.change_field(target.x, target.y, type)
+    else
+      raise InvalidMoveException.new('Invalid move', self)
     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
+  end
+
+
+  # Ermittelt die Koordinaten des Zielfeldes des Zuges mit einer gegebenen Zugweite.
+  # @param speed [Integer] Die Zugweite. Entspricht normalerweise der Anzahl der Fische auf der Bewegungslinie.
+  # @return [Coordinates] Koordinaten des Zielfeldes. Eventuell ausserhalb des Spielbrettes.
+  def target_field(speed)
+    direction.translate(from_field, speed)
   end
 end

data/lib/software_challenge_client/network.rb

@@ -7,10 +7,12 @@ require 'rexml/element'
 require_relative 'protocol'
 require_relative 'board'
 require_relative 'client_interface'
+require_relative 'util/constants'
 
 # This class handles the socket connection to the server
 class Network
   include Logging
+  include Constants
 
   # @!attribute [r] connected
   # @return [Boolean] true, if the client is connected to a server
@@ -43,7 +45,7 @@ class Network
       element.add_attribute('reservationCode', @reservation_id)
     else
       element = REXML::Element.new('join')
-      element.add_attribute('gameType', 'swc_2018_hase_und_igel')
+      element.add_attribute('gameType', GAME_IDENTIFIER)
     end
     document.add(element)
     sendXML(document)

data/lib/software_challenge_client/player.rb

@@ -1,5 +1,4 @@
 # encoding: UTF-8
-require_relative 'card_type'
 
 # Ein Spieler
 class Player
@@ -11,53 +10,15 @@ class Player
   # @return [PlayerColor] die Farbe des Spielers, Rot oder Blau
   attr_reader :color
 
-  # @!attribute [rw] points
-  # @return [Integer] der aktuelle Punktestand des Spielers
-  attr_accessor :points
-
-  # @!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] carrots
-  # @return [Integer] die aktuelle Anzahl Karotten des Spielers
-  attr_accessor :carrots
-
-  # @!attribute [rw] salads
-  # @return [Integer] die aktuelle Anzahl Salate des Spielers
-  attr_accessor :salads
-
-  # @!attribute [rw] cards
-  # @return [Array[CardType]] die noch nicht gespielten Karten
-  attr_accessor :cards
-
-  # @!attribute [rw] last_non_skip_action
-  # @return [Action] letzte Aktion, die kein Skip war
-  attr_accessor :last_non_skip_action
-
-  # @!attribute [rw] must_play_card
-  # @return [Boolean] zeigt an, ob eine Karte gespielt werden muss, wird in Zugvalidierung verwendet.
-  attr_accessor :must_play_card
-
   # Konstruktor
   # @param color [PlayerColor] Farbe
   # @param name [String] Name
   def initialize(color, name)
     @color = color
     @name = name
-    @points = 0
-    @index = 0
-    @carrots = 68
-    @salads = 5
-    @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

@@ -1,25 +1,35 @@
-# encoding: UTF-8
+# encoding: utf-8
 # player color constants
 require 'typesafe_enum'
-class PlayerColor < TypesafeEnum::Base
 
+# Die Spielerfarben. RED, BLUE oder NONE.
+class PlayerColor < TypesafeEnum::Base
   new :NONE
   new :RED
   new :BLUE
 
-  # Returns the opponents Color
-  #
-  # @param color [PlayerColor] The player's color, whose opponent needs to be found
-  # @return [PlayerColor] the opponent's color
+  # @param color [PlayerColor]
+  # @return [PlayerColor] Farbe des Gegenspielers
   def self.opponent_color(color)
-    if color == PlayerColor::RED
-      return PlayerColor::BLUE
-    end
-    if color == PlayerColor::BLUE
-      return PlayerColor::RED
+    case color
+    when PlayerColor::RED
+      PlayerColor::BLUE
+    when PlayerColor::BLUE
+      PlayerColor::RED
+    when PlayerColor::NONE
+      PlayerColor::NONE
     end
-    if color == PlayerColor::NONE
-      return PlayerColor::NONE
+  end
+
+  # @param color [PlayerColor] Die Spielerfarbe, zu dem der Feldtyp ermittelt werden soll.
+  # @return [FieldType] Der zur Spielerfarbe gehörende Feldtyp, also FieldType::RED für PlayerColor::RED und FieldType::BLUE für PlayerColor::BLUE. In allen anderen Fällen nil.
+  # @see FieldType#player_color
+  def self.field_type(color)
+    case color
+    when PlayerColor::RED
+      FieldType::RED
+    when PlayerColor::BLUE
+      FieldType::BLUE
     end
   end
 end

data/lib/software_challenge_client/protocol.rb

@@ -56,8 +56,6 @@ class Protocol
     case name
     when 'board'
       logger.debug @gamestate.board.to_s
-    when 'type'
-      @context[:player].cards << CardType.find_by_key(@context[:last_text].to_sym)
     end
   end
 
@@ -92,8 +90,8 @@ class Protocol
       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.start_player_color = attrs['startPlayerColor'] == 'RED' ? PlayerColor::RED : PlayerColor::BLUE
+      @gamestate.current_player_color = attrs['currentPlayerColor'] == 'RED' ? PlayerColor::RED : PlayerColor::BLUE
       logger.debug "Turn: #{@gamestate.turn}"
     when 'red'
       logger.debug 'new red player'
@@ -116,38 +114,18 @@ class Protocol
       @gamestate.board = Board.new
       @context[:current_tile_index] = nil
       @context[:current_tile_direction] = nil
-    when 'fields'
-      type = FieldType.find_by_key(attrs['type'].to_sym)
-      index = attrs['index'].to_i
+    when 'field'
+      type = FieldType.find_by_key(attrs['state'].to_sym)
+      x = attrs['x'].to_i
+      y = attrs['y'].to_i
       raise "unexpected field type: #{attrs['type']}. Known types are #{FieldType.map { |t| t.key.to_s }}" if type.nil?
-      @gamestate.board.fields[index] = Field.new(type, index)
+      @gamestate.board.add_field(Field.new(x, y, type))
     when 'lastMove'
-      @gamestate.last_move = Move.new
-    when 'advance'
-      @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
-      )
+      direction = Direction.find_by_key(attrs['direction'].to_sym)
+      x = attrs['x'].to_i
+      y = attrs['y'].to_i
+      raise "unexpected direction: #{attrs['direction']}. Known directions are #{Direction.map { |d| d.key.to_s }}" if direction.nil?
+      @gamestate.last_move = Move.new(x, y, direction)
     when 'winner'
       winning_player = parsePlayer(attrs)
       @gamestate.condition = Condition.new(winning_player)
@@ -155,24 +133,6 @@ class Protocol
     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
 
@@ -181,16 +141,10 @@ class Protocol
   # @param attributes [Hash] Attributes for the new Player.
   # @return [Player] The created Player object.
   def parsePlayer(attributes)
-    player = Player.new(
+    Player.new(
       PlayerColor.find_by_key(attributes['color'].to_sym),
       attributes['displayName']
     )
-    player.points = attributes['points'].to_i
-    player.index = attributes['index'].to_i
-    player.carrots = attributes['carrots'].to_i
-    player.salads = attributes['salads'].to_i
-    player.cards = []
-    player
   end
 
   # send a xml document
@@ -219,32 +173,15 @@ class Protocol
   # @param move [Move] The move to convert to XML.
   def move_to_xml(move)
     builder = Builder::XmlMarkup.new(indent: 2)
-    builder.data(class: 'move') do |data|
-      move.actions.each_with_index do |action, index|
-        # Converting every action type here instead of requiring the Action
-        # class interface to supply a method which returns the action hash
-        # because XML-generation should be decoupled from internal data
-        # structures.
-        attribute = case action.type
-                    when :advance
-                      { distance: action.distance }
-                    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!(snake_case_to_lower_camel_case(action.type.to_s), attribute)
+    # Converting every the move here instead of requiring the Move
+    # class interface to supply a method which returns the XML
+    # because XML-generation should be decoupled from internal data
+    # structures.
+    builder.data(class: 'move', x: move.x, y: move.y, direction: move.direction.key) do |data|
+      move.hints.each do |hint|
+        data.hint(content: hint.content)
       end
     end
-    move.hints.each do |hint|
-      data.hint(content: hint.content)
-    end
     builder.target!
   end