software_challenge_client 1.2.1 → 19.0.0

data/lib/software_challenge_client/direction.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'typesafe_enum'
+
+# Die acht möglichen Bewegungsrichtungen auf dem Spielbrett. Die Richtungen sind:
+#
+# - UP
+# - UP_RIGHT
+# - RIGHT
+# - DOWN_RIGHT
+# - DOWN
+# - DOWN_LEFT
+# - LEFT
+# - UP_LEFT
+#
+# Zugriff erfolgt z.B. durch Direction::UP_RIGHT.
+class Direction < TypesafeEnum::Base
+  new :UP
+  new :UP_RIGHT
+  new :RIGHT
+  new :DOWN_RIGHT
+  new :DOWN
+  new :DOWN_LEFT
+  new :LEFT
+  new :UP_LEFT
+
+  # Verschiebt den durch das Koordinatenpaar angegebenen Punkt in die
+  # entsprechende Richtung. Der resultierende Punkt kann ausserhalb des
+  # Spielbrettes liegen. Dies kann mit {GameRuleLogic#inside_bounds?} geprüft
+  # werden.
+  # @param coordinates [Coordinates] Das zu verschiebende Koordinatenpaar.
+  # @param distance [Integer] Um wieviele Felder in die Richtung verschoben werden soll.
+  def translate(coordinates, distance = 1)
+    case key
+    when :UP
+      Coordinates.new(coordinates.x, coordinates.y + distance)
+    when :UP_RIGHT
+      Coordinates.new(coordinates.x + distance, coordinates.y + distance)
+    when :RIGHT
+      Coordinates.new(coordinates.x + distance, coordinates.y)
+    when :DOWN_RIGHT
+      Coordinates.new(coordinates.x + distance, coordinates.y - distance)
+    when :DOWN
+      Coordinates.new(coordinates.x, coordinates.y - distance)
+    when :DOWN_LEFT
+      Coordinates.new(coordinates.x - distance, coordinates.y - distance)
+    when :LEFT
+      Coordinates.new(coordinates.x - distance, coordinates.y)
+    when :UP_LEFT
+      Coordinates.new(coordinates.x - distance, coordinates.y + distance)
+    end
+  end
+end

data/lib/software_challenge_client/field.rb

@@ -1,31 +1,45 @@
 # encoding: UTF-8
 require_relative 'field_type'
 
-# Ein Feld des Spielfelds. Ein Spielfeld ist durch den index eindeutig identifiziert.
+# Ein Feld des Spielfelds. Ein Spielfeld ist durch die Koordinaten eindeutig identifiziert.
 # Das type Attribut gibt an, um welchen Feldtyp es sich handelt
 class Field
   # @!attribute [rw] type
   # @return [FieldType] der Typ des Feldes
   attr_accessor :type
-  # @!attribute [r] index
-  # @return [Integer] der Index des Feldes (0 bis 64)
-  attr_reader :index
+  # @!attribute [r] x
+  # @return [Integer] die X-Koordinate des Feldes (0 bis 9, 0 ist ganz links, 9 ist ganz rechts)
+  attr_reader :x
+  # @!attribute [r] y
+  # @return [Integer] die Y-Koordinate des Feldes (0 bis 9, 0 ist ganz unten, 9 ist ganz oben)
+  attr_reader :y
 
   # Konstruktor
   #
   # @param type [FieldType] Feldtyp
-  # @param index [Integer] Index
-  def initialize(type, index)
-    self.type = type
-    @index = index
+  # @param x [Integer] X-Koordinate
+  # @param y [Integer] Y-Koordinate
+  def initialize(x, y, type)
+    @type = type
+    @x = x
+    @y = y
   end
 
-  def ==(another_field)
-    return self.type == another_field.type &&
-      self.index == another_field.index
+  # Vergleicht zwei Felder. Felder sind gleich, wenn sie gleiche Koordinaten und gleichen Typ haben.
+  # @return [Boolean] true bei Gleichheit, false sonst.
+  def ==(other)
+    type == other.type &&
+      x == other.x &&
+      y == other.y
   end
 
+  # @return [Coordinates] Die Koordinaten des Feldes als Koordinatenpaar.
+  def coordinates
+    Coordinates.new(x, y)
+  end
+
+  # @return [String] Textuelle Darstellung des Feldes.
   def to_s
-    return "Feld ##{self.index}, Typ = #{self.type}"
+    "Feld (#{x},#{y}), Typ = #{type}"
   end
 end

data/lib/software_challenge_client/field_type.rb

@@ -1,24 +1,30 @@
 # encoding: utf-8
 
 require 'typesafe_enum'
-# Zahl- und Flaggenfelder Die veränderten Spielregeln sehen nur noch die
-# Felder 1,2 vor. Die Positionsfelder 3 und 4 wurden in Möhrenfelder
-# umgewandelt, und (1,5,6) sind jetzt Position-1-Felder.
+# Der Typ eines Feldes des Spielbrettes. Es gibt folgende Typen:
+# - EMPTY
+# - RED
+# - BLUE
+# - OBSTRUCTED
+#
+# Zugriff z.B. mit FieldType::RED
 class FieldType < TypesafeEnum::Base
-  new :POSITION_1, '1'
-  new :POSITION_2, '2'
-  # Igelfeld
-  new :HEDGEHOG, 'I'
-  # Salatfeld
-  new :SALAD, 'S'
-  # Karottenfeld
-  new :CARROT, 'C'
-  # Hasenfeld
-  new :HARE, 'H'
-  # außerhalb des Spielfeldes
-  new :INVALID, 'X'
-  # Zielfeld
-  new :GOAL, 'G'
-  # Startfeld
-  new :START, '0'
+  new :EMPTY, '~'
+  new :RED, 'R'
+  new :BLUE, 'B'
+  new :OBSTRUCTED, 'O'
+
+  # @param field_type [FieldType] Der Feldtyp, zu dem die Spielerfarbe ermittelt werden soll.
+  # @return [PlayerColor] Die zum Feldtyp gehörende Spielerfarbe, also PlayerColor::RED für FieldType::RED und PlayerColor::BLUE für FieldType::BLUE. In allen anderen Fällen PlayerColor::NONE.
+  # @see PlayerColor#field_type
+  def self.player_color(field_type)
+    case field_type
+    when FieldType::RED
+      PlayerColor::RED
+    when FieldType::BLUE
+      PlayerColor::BLUE
+    else
+      PlayerColor::NONE
+    end
+  end
 end

data/lib/software_challenge_client/game_rule_logic.rb

@@ -0,0 +1,230 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require_relative 'field_type'
+require_relative 'line'
+require_relative './util/constants'
+
+# Methoden, welche die Spielregeln von Piranhas abbilden.
+#
+# Es gibt hier viele Helfermethoden, die von den beiden Hauptmethoden {GameRuleLogic#valid_move?} und {GameRuleLogic.possible_moves} benutzt werden.
+class GameRuleLogic
+
+  include Constants
+
+  # Fügt einem leeren Spielfeld zwei Krakenfelder hinzu. Die beiden Felder
+  # liegen nicht auf derselben Horizontalen, Vertikalen oder Diagonalen und sind
+  # mindestens zwei Felder von den Rändern des Spielbrettes entfernt.
+  #
+  # Diese Methode ist dazu gedacht, ein initiales Spielbrett regelkonform zu generieren.
+  #
+  # @param board [Board] Das zu modifizierende Spielbrett. Es wird nicht
+  #   geprüft, ob sich auf dem Spielbrett bereits Krakenfelder befinden.
+  # @return [Board] Das modifizierte Spielbrett.
+  def self.add_blocked_fields(board)
+    number_of_blocked_fields = 2
+    lower_bound = 2 # first row or column, in which blocked fields are allowed
+    upper_bound = 7 # last row or column, in which blocked fields are allowed
+
+    # create a list of coordinates for fields which may be blocked
+    blockable_field_coordinates = (lower_bound..upper_bound).to_a.map do |x|
+      (lower_bound..upper_bound).to_a.map do |y|
+        Coordinate.new(x, y)
+      end
+    end.flatten
+
+    # set fields with randomly selected coordinates to blocked coordinates may
+    # not lay on same horizontal, vertical or diagonal lines with other selected
+    # coordinates
+    number_of_blocked_fields.times do
+      selected_coords = blockable_field_coordinates.sample
+      board.change_field(selectedCoords, FieldType::OBSTRUCTED)
+      # remove field coordinates and fields on horizontal, vertical and diagonal
+      # lines:
+      coordinates_to_remove = ALL_DIRECTIONS.map do |direction|
+        Line.new(selected_coords, direction).to_a
+      end.flatten
+      blockable_field_coordinates = blockable_field_coordinates.filter do |c|
+        coordinates_to_remove.none? do |to_remove|
+          c.x == to_remove.x && c.y == to_remove.y
+        end
+      end
+    end
+    board
+  end
+
+  # Ermittlung der Anzahl der Fische auf einer Line des Spielbrettes.
+  #
+  # @param board [Board] Das zu betrachtende Spielbrett.
+  # @param start [Coordinates] Ein Feld auf der Linie.
+  # @param direction [LineDirection] Die Ausrichtung der Linie (vertikal, horizontal oder diagonal).
+  # @return [Integer] Anzahl der Fische auf der Linie.
+  def self.count_fish(board, start, direction)
+    # filter function for fish field type
+    fish = proc { |f| f.type == FieldType::RED || f.type == FieldType::BLUE }
+    Line.new(start, direction).to_a.map do |p|
+      board.field(p.x, p.y)
+    end.select(&fish).size
+  end
+
+  # @return [Coordinates] Die Zielkoordinaten eines Spielzuges auf einem Spielbrett.
+  def self.target_coordinates(move, board)
+    speed = GameRuleLogic.count_fish(
+      board, move.from_field,
+      Line.line_direction_for_direction(move.direction)
+    )
+    move.target_field(speed)
+  end
+
+  # @return [Field] Das Zielfeld eines Spielzuges auf einem Spielbrett.
+  def self.move_target(move, board)
+    c = GameRuleLogic.target_coordinates(move, board)
+    board.field(c.x, c.y)
+  end
+
+  # Prüft, ob sich die gegebenen Koordinaten innerhalb des Spielbrettes befinden.
+  # @return [Boolean]
+  def self.inside_bounds?(coordinates)
+    coordinates.x >= 0 &&
+      coordinates.x < SIZE &&
+      coordinates.y >= 0 &&
+      coordinates.y < SIZE
+  end
+
+  # Ermittelt, ob der gegebene Feldtyp für den Spieler mit der angegebenen Farbe ein nicht überspringbares Hindernis darstellt.
+  # @param field_type [FieldType]
+  # @param moving_player_color [PlayerColor]
+  # @return [Boolean] true, falls es ein Hindernis ist, false sonst.
+  def self.obstacle?(field_type, moving_player_color)
+    field_type == PlayerColor.field_type(
+      PlayerColor.opponent_color(moving_player_color)
+    )
+  end
+
+  # Ermittelt, ob sich zwischen den angegebenen Feldern kein Hindernis befindet.
+  # @param from_field [Coordinates] Startfeld
+  # @param to_field [Coordinates] Zielfeld
+  # @param direction [LineDirection] Ausrichtung der Linie zwischen Start- und Zielfeld.
+  # @param color [PlayerColor] Farbe des ziehenden Spielers.
+  # @param board [Board] Das aktuelle Spielbrett.
+  # @return [Boolean] true, falls der Spieler mit der angegebenen Farbe zwischen den beiden Punkten ein Hindernis vorfindet, false sonst.
+  def self.obstacle_between?(from_field, direction, to_field, color, board)
+    Line.new(from_field, direction)
+        .to_a
+        .select { |c| Line.between(from_field, to_field, direction).call(c) }
+        .any? { |f| GameRuleLogic.obstacle?(board.field(f.x, f.y).type, color) }
+  end
+
+  # Ermittelt, ob der Spieler mit der angegebenen Farbe einen Fisch auf dem Feld mit den angegebenen Koordinaten besitzt.
+  # @param target [Coordinates] Koordinaten des Feldes.
+  # @param moving_player_color [PlayerColor] Farbe des Spielers, der einen Zug machen will.
+  # @param board [Board] Aktuelles Spielbrett.
+  # @return [Boolean] true falls sich auf dem Feld ein Fisch mit der richtigen Farbe befindet (Rot für roten Spieler, Blau für blauen Spieler), false sonst.
+  def self.valid_move_target(target, moving_player_color, board)
+    target_field_type = board.field(target.x, target.y).type
+    target_field_type == FieldType::EMPTY ||
+      target_field_type == PlayerColor.field_type(
+        PlayerColor.opponent_color(moving_player_color)
+      )
+  end
+
+  # Ermittelt, ob der gegebene Zug regelkonform ausgeführt werden kann.
+  # @param move [Move] Der zu prüfende Zug
+  # @param board [Board] Spielbrett, auf dem der Zug ausgeführt werden soll.
+  # @param current_player_color [PlayerColor] Farbe des Spielers, der den Zug ausführen soll.
+  # @return [Boolean] true falls der Zug gültig ist, false sonst.
+  def self.valid_move?(move, board, current_player_color)
+    from_field_type = board.field(move.x, move.y).type
+    return false unless
+      [FieldType::BLUE, FieldType::RED].include? from_field_type
+    return false unless
+      current_player_color == FieldType.player_color(from_field_type)
+
+    return false unless
+      GameRuleLogic.inside_bounds?(
+        GameRuleLogic.target_coordinates(move, board)
+      )
+
+    target = GameRuleLogic.move_target(move, board)
+
+    GameRuleLogic.valid_move_target(target, current_player_color, board) &&
+      !GameRuleLogic.obstacle_between?(
+        move.from_field,
+        Line.line_direction_for_direction(move.direction),
+        target, current_player_color, board
+      )
+  end
+
+  # Ermittelt alle möglichen Züge von einem bestimmten Feld aus.
+  # @param board [Board] Aktuelles Spielbrett
+  # @param field [Field] Das Feld, von dem die Züge ausgehen sollen.
+  # @param current_player_color [PlayerColor] Farbe des Spielers, der den Zug macht.
+  # @return [Array<Move>] Liste von möglichen Zügen.
+  def self.possible_moves(board, field, current_player_color)
+    Direction.map { |direction| Move.new(field.x, field.y, direction) }
+             .select do |m|
+               GameRuleLogic.valid_move?(m, board, current_player_color)
+             end
+  end
+
+  # Ermittelt die Schwarmgröße eines Spielers auf dem Spielbrett.
+  # @param board [Board] Das zu betrachtende Spielbrett.
+  # @param player_color [PlayerColor] Farbe des Spielers, für den die Schwarmgröße ermittelt werden soll.
+  # @return [Integer] Anzahl der Fische im größten Schwarm des Spielers.
+  def self.swarm_size(board, player_color)
+    GameRuleLogic.greatest_swarm_from_fields(
+      board,
+      board.fields_of_type(
+        PlayerColor.field_type(player_color)
+      ).to_set,
+      Set.new
+    ).size
+  end
+
+  # @return [Array<Field>] Alle direkten Nachbarfelder des gegebenen Feldes. Für Felder im Inneren des Spielbrettes gibt es acht Nachbarfelder. Für Randfelder vier oder drei Nachbarfelder.
+  def self.neighbours(board, field)
+    Direction
+      .map { |d| d.translate(field.coordinates) }
+      .select { |c| GameRuleLogic.inside_bounds?(c) }
+      .map { |c| board.field_at(c) }
+  end
+
+  # Hilfsfunktion für {GameRuleLogic.swarm_size}.
+  # Ermittelt die größte zusammenhängende Menge von Feldern aus einer gegebenen Menge von Feldern.
+  # @param board [Board] Das zu betrachtende Spielbrett.
+  # @param fields_to_check [Set<Field>] Menge der Felder, aus der die größte zusammenhängende Menge ermittelt werden soll.
+  # @param current_biggest_swarm [Set<Field>] Aktuell größte zusammenhängende Feldmenge. Für rekursiven Aufruf.
+  # @return [Set<Field>]
+  def self.greatest_swarm_from_fields(board, fields_to_check, current_biggest_swarm = Set.new)
+    # stop searching when the size of the current found biggest set is bigger than the rest of the fields
+    return current_biggest_swarm if current_biggest_swarm.size > fields_to_check.size
+
+    # start a new set of adjacent fields with the first field in fields_to_check
+    current_swarm = Set.new
+    field = fields_to_check.to_a.first
+    fields_to_check.delete(field)
+    current_swarm.add(field)
+
+    # move all adjacent fields to the set
+    loop do
+      to_add = current_swarm
+               .map { |f| GameRuleLogic.neighbours(board, f) }
+               .flatten
+               .select { |f| fields_to_check.include? f }
+      break if to_add.empty?
+      fields_to_check -= to_add
+      current_swarm += to_add
+    end
+
+    # keep trying to find bigger sets
+    if current_swarm.size > current_biggest_swarm.size
+      GameRuleLogic.greatest_swarm_from_fields(
+        board, fields_to_check, current_swarm
+      )
+    else
+      GameRuleLogic.greatest_swarm_from_fields(
+        board, fields_to_check, current_biggest_swarm
+      )
+    end
+  end
+end

data/lib/software_challenge_client/game_state.rb

@@ -6,52 +6,51 @@ require_relative 'move'
 require_relative 'condition'
 require_relative 'field_type'
 
-# The state of a game, as received from the server.
+# Ein Spielzustand. Wird vom Server an die Computerspieler übermittelt und enthält alles, was der Computerspieler wissen muss, um einen Zug zu machen.
+#
+# Um eine Liste der gerade möglichen Züge zu bekommen, gibt es die Methode {GameState#possible_moves}.
 class GameState
   # @!attribute [rw] turn
-  # @return [Integer] turn number
+  # @return [Integer] Aktuelle Zugnummer (von 0 beginnend)
   attr_accessor :turn
   # @!attribute [rw] start_player_color
-  # @return [PlayerColor] the start-player's color
+  # @return [PlayerColor] Die Farbe des Spielers, der den ersten Zug im Spiel machen darf.
   attr_accessor :start_player_color
   # @!attribute [rw] current_player_color
-  # @return [PlayerColor] the current player's color
+  # @return [PlayerColor] Die Farbe des Spielers, der den nächsten Zug machen darf, der also gerade an der Reihe ist.
   attr_accessor :current_player_color
   # @!attribute [r] red
-  # @return [Player] the red player
+  # @return [Player] Der rote Spieler
   attr_reader :red
   # @!attribute [r] blue
-  # @return [Player] the blue player
+  # @return [Player] Der blaue Spieler
   attr_reader :blue
   # @!attribute [rw] board
-  # @return [Board] the game's board
+  # @return [Board] Das aktuelle Spielbrett
   attr_accessor :board
   # @!attribute [rw] last_move
-  # @return [Move] the last move performed
+  # @return [Move] Der zuletzt gemachte Zug (ist nil vor dem ersten Zug, also bei turn == 0)
   attr_accessor :last_move
   # @!attribute [rw] condition
-  # @return [Condition] the winner and winning reason
+  # @return [Condition] Gewinner und Gewinngrund, falls das Spiel bereits entschieden ist, sonst nil.
   attr_accessor :condition
-  # @!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)
+  # Zugriff auf ein Feld des Spielbrettes. Siehe {Board#field}.
+  def field(x, y)
+    board.field(x, y)
   end
 
+  # Erstellt einen neuen Spielzustand.
   def initialize
     @current_player_color = PlayerColor::RED
     @start_player_color = PlayerColor::RED
     @board = Board.new
-    @has_to_play_card = false
     @turn = 0
   end
 
-  # adds a player to the gamestate
+  # Fügt einen Spieler zum Spielzustand hinzu.
   #
-  # @param player [Player] the player, that will be added
+  # @param player [Player] Der hinzuzufügende Spieler.
   def add_player(player)
     if player.color == PlayerColor::RED
       @red = player
@@ -60,108 +59,58 @@ class GameState
     end
   end
 
-  # gets the current player
-  #
-  # @return [Player] the current player
+  # @return [Player] Spieler, der gerade an der Reihe ist.
   def current_player
     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
+  # @return [Player] Spieler, der gerade nicht an der Reihe ist.
   def other_player
     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
-  #
-  # @return [PlayerColor] the other (not the current) player's color
+  # @return [PlayerColor] Farbe des Spielers, der gerade nicht an der Reihe ist.
   def other_player_color
     PlayerColor.opponent_color(current_player_color)
   end
 
-  # gets the current round
-  #
-  # @return [Integer] the current round
+  # @return [Integer] Aktuelle Runde (von 0 beginnend).
   def round
     turn / 2
   end
 
-  # performs a move on the gamestate
+  # Führt einen Zug auf dem Spielzustand aus. Das Spielbrett wird entsprechend modifiziert.
   #
-  # @param move [Move] the move, that will be performed
-  # @param player [Player] the player, who makes the move
-  def perform!(move, player)
-    move.actions.each do |action|
-      action.perform!(self, player)
-    end
+  # @param move [Move] Der auszuführende Zug.
+  def perform!(move)
+    move.perform!(self)
   end
 
-  # has the game ended?
-  #
-  # @return [Boolean] true, if the game has allready ended
+  # @return [Boolean] true, falls das Spiel bereits geendet hat, false bei noch laufenden Spielen.
   def game_ended?
     !condition.nil?
   end
 
-  # gets the game's winner
-  #
-  # @return [Player] the game's winner
+  # @return [Player] Der Spieler, der das Spiel gewonnen hat, falls dies schon entschieden ist. Sonst false.
   def winner
     condition.nil? ? nil : condition.winner
   end
 
-  # gets the winning reason
-  #
-  # @return [String] the winning reason
+  # @return [String] Der Grund, warum das Spiel beendet wurde, nil falls das Spiel noch läuft.
   def winning_reason
     condition.nil? ? nil : condition.reason
   end
 
-  # calculates a player's points based on the current gamestate
+  # Ermittelt die Punkte eines Spielers. Wenn das Spiel durch Erreichen des Rundenlimits beendet wird, hat der Spieler mit den meisten Punkten gewonnen.
   #
-  # @param player [Player] the player, whos points to calculate
-  # @return [Integer] the points of the player
+  # @param player [Player] Der Spieler, dessen Punkte berechnet werden sollen.
+  # @return [Integer] Die Punkte des Spielers, entspricht der Anzahl der Fische im größten Schwarm des Spielers.
   def points_for_player(player)
-    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.index == other_player.index
+    GameRuleLogic.swarm_size(board, player)
   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 &&
@@ -170,126 +119,31 @@ class GameState
         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
-  # changing the original gamestate.
+  # Erzeugt eine Kopie des Spielzustandes. Änderungen an dieser Kopie beeinflussen den originalen Spielzustand nicht. Die Kopie kann also zum testen von Spielzügen genutzt werden.
   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
-
+  # Wechselt den Spieler, der aktuell an der Reihe ist.
   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
+  # @return [Array<Field>] Alle Felder mit Fischen des Spielers, der gerade an der Reihe ist.
+  def own_fields
+    board.fields_of_type(
+      PlayerColor.field_type(current_player_color)
+    )
   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
+  # @return [Array<Move>] Alle regelkonformen Züge, die der aktuelle Spieler gerade machen könnte.
+  def possible_moves
+    own_fields.map do |f|
+      GameRuleLogic.possible_moves(board, f, current_player_color)
+    end.flatten
   end
+
 end