software_challenge_client 21.2.0 → 22.1.0.1

data/lib/software_challenge_client/game_state.rb

@@ -1,232 +1,153 @@
-# frozen_string_literal: true
-
-require_relative './util/constants'
-require_relative 'player'
-require_relative 'board'
-require_relative 'condition'
-
-# 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] Aktuelle Zugnummer (von 0 beginnend)
-  attr_accessor :turn
-
-  # @!attribute [rw] round
-  # @return [Integer] Aktuelle Rundennummer (von 1 beginnend)
-  attr_accessor :round
-
-  # @!attribute [rw] startColor
-  # @return [Color] Die Farbe, die zuerst legen darf
-  attr_accessor :start_color
-
-  # @!attribute [rw] valid_colors
-  # @return [Array<Color>] Ein Array aller Farben die ziehen können in
-  #                        der Reihenfolge in der sie drankommen
-  attr_accessor :valid_colors
-
-  # @!attribute [rw] ordered_colors
-  # @return [Array<Color>] Ein Array aller Farben in
-  #                        der Reihenfolge in der sie drankommen
-  attr_accessor :ordered_colors
-
-  # @!attribute [r] undeployed_blue_pieces
-  # @return [Array<PieceShape>] Die blauen, nicht gesetzten Spielsteine
-  attr_accessor :undeployed_blue_pieces
-
-  # @!attribute [r] undeployed_yellow_pieces
-  # @return [Array<PieceShape>] Die gelben, nicht gesetzten Spielsteine
-  attr_accessor :undeployed_yellow_pieces
-
-  # @!attribute [r] undeployed_red_pieces
-  # @return [Array<PieceShape>] Die roten, nicht gesetzten Spielsteine
-  attr_accessor :undeployed_red_pieces
-
-  # @!attribute [r] undeployed_green_pieces
-  # @return [Array<PieceShape>] Die grünen, nicht gesetzten Spielsteine
-  attr_accessor :undeployed_green_pieces
-
-  # @!attribute [r] player_one
-  # @return [Player] Der erste Spieler
-  attr_reader :player_one
-
-  # @!attribute [r] player_two
-  # @return [Player] Der zweite Spieler
-  attr_reader :player_two
-
-  # @!attribute [rw] board
-  # @return [Board] Das aktuelle Spielbrett
-  attr_accessor :board
-
-  # @!attribute [rw] startPiece
-  # @return [PieceShape] Der Stein, der im ersten Zug von allen Farben gelegt werden muss
-  attr_accessor :start_piece
-
-  # @!attribute [rw] last_move
-  # @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] Gewinner und Gewinngrund, falls das Spiel bereits
-  #                     entschieden ist, sonst nil.
-  attr_accessor :condition
-
-  # Zugriff auf ein Feld des Spielbrettes. Siehe {Board#field}.
-  def field(x, y)
-    board.field(x, y)
-  end
-
-  # Erstellt einen neuen leeren Spielstand.
-  def initialize
-    @ordered_colors = [Color::BLUE, Color::YELLOW, Color::RED, Color::GREEN]
-    @board = Board.new
-    @turn = 0
-    @undeployed_blue_pieces = PieceShape.to_a
-    @undeployed_yellow_pieces = PieceShape.to_a
-    @undeployed_red_pieces = PieceShape.to_a
-    @undeployed_green_pieces = PieceShape.to_a
-    @start_piece = GameRuleLogic.get_random_pentomino
-    @start_color = Color::BLUE
-  end
-
-  # Fügt einen Spieler zum Spielzustand hinzu.
-  #
-  # @param player [Player] Der hinzuzufügende Spieler.
-  def add_player(player)
-    case player.type
-    when PlayerType::ONE
-      @player_one = player
-    when PlayerType::TWO
-      @player_two = player
-    end
-  end
-
-  # @return [Player] Spieler, der gerade an der Reihe ist.
-  def current_player
-    turn.even? ? player_one : player_two
-  end
-
-  # @return [Player] Spieler, der gerade nicht an der Reihe ist.
-  def other_player
-    turn.even? ? player_two : player_one
-  end
-
-  # @return [PlayerType] Typ des Spielers, der gerade nicht an der Reihe ist.
-  def other_player_type
-    other_player.type
-  end
-
-  # @return [Color] Der jetzige Index in der Zug Reihenfolge der Farben.
-  def current_color_index
-    turn % 4
-  end
-
-  # @return [Color] Farbe, der gerade an der Reihe ist.
-  def current_color
-    ordered_colors[current_color_index]
-  end
-
-  # @return [Color] Farbe des aktuellen Spielers, die gerade nicht an der Reihe ist.
-  def other_color
-    Color.find_by_ord((current_color.ord + 2) % 4)
-  end
-
-  # @return [Array<PieceShape>] Array aller Shapes, der gegebenen Farbe, die noch nicht gelegt wurden
-  def undeployed_pieces(color)
-    case color
-    when Color::RED
-      undeployed_red_pieces
-    when Color::BLUE
-      undeployed_blue_pieces
-    when Color::YELLOW
-      undeployed_yellow_pieces
-    when Color::GREEN
-      undeployed_green_pieces
-    end
-  end
-
-  # @return [Array<PieceShape>] Array aller Shapes, der gegebenen Farbe, die schon gelegt wurden
-  def deployed_pieces(color)
-    board.deployed_pieces(color)
-  end
-
-  # @return [Bool] Ob diese gamestate in der ersten Runde ist
-  def is_first_move?
-    round == 1
-  end
-
-  # Führt einen Zug auf dem Spielzustand aus. Das Spielbrett wird entsprechend
-  # modifiziert.
-  #
-  # @param move [Move] Der auszuführende Zug.
-  def perform!(move)
-    GameRuleLogic.perform_move(self, move)
-  end
-
-  # @return [Boolean] true, falls das Spiel bereits geendet hat, false bei noch
-  #                   laufenden Spielen.
-  def game_ended?
-    !condition.nil?
-  end
-
-  # Entfernt die jetzige Farbe aus der Farbrotation
-  def remove_active_color
-    ordered_colors.delete current_color
-  end
-
-  # @return [Player] Der Spieler, der das Spiel gewonnen hat, falls dies schon
-  #                  entschieden ist. Sonst false.
-  def winner
-    condition.nil? ? nil : condition.winner
-  end
-
-  # @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
-
-  # 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] Der Spieler, dessen Punkte berechnet werden sollen.
-  # @return [Integer] Die Punkte des Spielers
-  def points_for_player(_player)
-    # TODO
-    -1
-  end
-
-  def ==(other)
-    turn == other.turn &&
-      start_color == other.start_color &&
-      current_color == other.current_color &&
-      blue == other.blue &&
-      yellow == other.yellow &&
-      red == other.red &&
-      green == other.green &&
-      board == other.board &&
-      lastMove == other.lastMove &&
-      condition == other.condition
-  end
-
-  # 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 clone
-    Marshal.load(Marshal.dump(self))
-  end
-
-  # Wechselt den Spieler, der aktuell an der Reihe ist.
-  def switch_current_player
-    @current_player_color = other_player_color
-  end
-
-  # @return [Array<Field>] Alle Felder mit Blöcken des Spielers, der gerade an der Reihe ist.
-  def own_fields
-    board.fields_of_color(current_color)
-  end
-end
+# frozen_string_literal: true
+
+require_relative './util/constants'
+require_relative 'player'
+require_relative 'board'
+require_relative 'condition'
+require_relative 'color'
+
+# 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] Aktuelle Zugnummer (von 0 beginnend)
+  attr_accessor :turn
+
+  # @!attribute [r] player_one
+  # @return [Player] Der erste Spieler
+  attr_reader :player_one
+
+  # @!attribute [r] player_two
+  # @return [Player] Der zweite Spieler
+  attr_reader :player_two
+
+  # @!attribute [rw] start_team
+  # @return [Team] Der Spieler der zuerst zieht
+  attr_accessor :start_team
+
+  # @!attribute [rw] board
+  # @return [Board] Das aktuelle Spielbrett
+  attr_accessor :board
+
+  # @!attribute [rw] last_move
+  # @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] Gewinner und Gewinngrund, falls das Spiel bereits
+  #                     entschieden ist, sonst nil.
+  attr_accessor :condition
+
+  # Zugriff auf ein Feld des Spielbrettes. Siehe {Board#field}.
+  def field(x, y)
+    board.field(x, y)
+  end
+
+  # Erstellt einen neuen leeren Spielstand.
+  def initialize
+    @board = Board.new
+    @turn = 0
+  end
+
+  # Fügt einen Spieler zum Spielzustand hinzu.
+  #
+  # @param player [Player] Der hinzuzufügende Spieler.
+  def add_player(player)
+    case player.color
+    when Color::RED
+      @player_one = player
+    when Color::BLUE
+      @player_two = player
+    end
+  end
+
+  # @return [Player] Spieler, der gerade an der Reihe ist.
+  def current_player
+    turn.even? ? player_one : player_two
+  end
+
+  # @return [Player] Spieler, der gerade nicht an der Reihe ist.
+  def other_player
+    turn.even? ? player_two : player_one
+  end
+
+  # @return [Team] Typ des Spielers, der gerade nicht an der Reihe ist.
+  def other_team
+    other_player.type
+  end
+
+  # @return [Integer] Aktuelle Rundennummer (von 1 beginnend)
+  def round
+    turn / 2 + 1
+  end
+
+  # @return [Bool] Ob diese gamestate in der ersten Runde ist
+  def is_first_move?
+    round == 1
+  end
+
+  # Führt einen Zug auf dem Spielzustand aus. Das Spielbrett wird entsprechend
+  # modifiziert.
+  #
+  # @param move [Move] Der auszuführende Zug.
+  def perform!(move)
+    GameRuleLogic.perform_move(self, move)
+  end
+
+  # @return [Boolean] true, falls das Spiel bereits geendet hat, false bei noch
+  #                   laufenden Spielen.
+  def game_ended?
+    !condition.nil?
+  end
+
+  # @return [Player] Der Spieler, der das Spiel gewonnen hat, falls dies schon
+  #                  entschieden ist. Sonst false.
+  def winner
+    condition.nil? ? nil : condition.winner
+  end
+
+  # @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
+
+  # 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] Der Spieler, dessen Punkte berechnet werden sollen.
+  # @return [Integer] Die Punkte des Spielers
+  def points_for_player(_player)
+    # TODO
+    -1
+  end
+
+  def ==(other)
+    turn == other.turn &&
+      start_color == other.start_color &&
+      current_color == other.current_color &&
+      blue == other.blue &&
+      yellow == other.yellow &&
+      red == other.red &&
+      green == other.green &&
+      board == other.board &&
+      lastMove == other.lastMove &&
+      condition == other.condition
+  end
+
+  # 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 clone
+    Marshal.load(Marshal.dump(self))
+  end
+
+  # @return [Array<Field>] Alle Felder mit Blöcken des Spielers, der gerade an der Reihe ist.
+  def own_fields
+    board.fields_of_color(current_player.color)
+  end
+end

data/lib/software_challenge_client/move.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'has_hints'
+
+# Ein Move repräsentiert eine Bewegung eines Steins auf dem Spielbrett
+class Move
+  include HasHints
+
+  # @!attribute [r] Koordinaten von dem der Spielstein in diesem Zug wegbewegt wird
+  # @return [Coordinates]
+  attr_reader :from
+
+  # @!attribute [r] Koordinaten zu denen der Spielstein in diesem Zug hinbewegt wird
+  # @return [Coordinates]
+  attr_reader :to
+
+  # Erstellt ein neuen Zug.
+  def initialize(from, to)
+    @from = from
+    @to = to
+    @hints = []
+  end
+
+  def piece(gamestate)
+    gamestate.board.field_at(from).piece
+  end
+
+  def piece_t(gamestate)
+    gamestate.board.field_at(to).piece
+  end
+
+  def ==(other)
+    from == other.from &&
+      to == other.to
+  end
+
+  # @return [String] Gibt die String-Repräsentation zurück
+  def to_s
+    "Move(#{from}->#{to})"
+  end
+end

data/lib/software_challenge_client/piece.rb

@@ -2,88 +2,80 @@
 
 # Ein Spielstein mit Ausrichtung, Koordinaten und Farbe
 class Piece
-  # @!attribute [r] Farbe
+  include Constants
+  
+  # @!attribute [rw] Color
   # @return [Color]
-  attr_reader :color
+  attr_accessor :color
 
-  # @!attribute [r] Form
-  # @return [PieceShape]
-  attr_reader :kind
+  # @!attribute [r] Typ des Spielsteins
+  # @return [PieceType]
+  attr_reader :type
 
-  # @!attribute [r] Drehung
-  # @return [Rotation]
-  attr_reader :rotation
-
-  # @!attribute [r] Ob der Stein an der Y-Achse gespiegelt ist
-  # @return [Boolean]
-  attr_reader :is_flipped
-
-  # @!attribute [r] Koordinaten
+  # @!attribute [rw] Koordinaten
   # @return [Coordinates]
-  attr_reader :position
+  attr_accessor :position
 
-  # @!attribute [r] Ein Array der Positionsdaten aller Bestandteile von dem Stein in Board Koordinaten, also schon ggf. gedreht und um position versetzt.
-  # return [Array<Coordinates>]
-  attr_reader :coords
+  # @!attribute [rw] tower_height
+  # @return [Integer] Die Anzahl Spielsteine übereinander inklusive des obersten
+  attr_accessor :height
 
-  # Erstellt einen neuen leeren Spielstein.
-  def initialize(color, kind, rotation = Rotation::NONE, is_flipped = false, position = Coordinates.origin)
+  # Erstellt einen neuen Spielstein.
+  def initialize(color, type, position = Coordinates.origin, height = 0)
     @color = color
-    @kind = kind
-    @rotation = rotation
-    @is_flipped = is_flipped
+    @type = type
     @position = position
-
-    @coords = coords_priv
-  end
-
-  # Dreht den Stein
-  def rotate!(rotation)
-    @rotation = @rotation.rotate(rotation)
-    @coords = coords_priv
+    @height = height
   end
 
-  # Flipped den Stein
-  def flip!(f = true)
-    @is_flipped = @is_flipped ^ f
-    @coords = coords_priv
-  end
-
-  # Setzt den Stein auf eine Position
-  def locate!(position)
-    @position = position
-    @coords = coords_priv
-  end
-
-  # Verschiebt den Stein
-  def move!(shift)
-    @position = position + shift
-    @coords = coords_priv
-  end
-
-  # Gibt die Fläche der transformierten Steinform von diesem Stein zurück
-  def area()
-    CoordinateSet.new(coords).area
+  # Berechnet die Koordinaten zu denen sich dieser Spielstein bewegen könnte.
+  #
+  # @return [Array<Coordinates>] Die Zielkoordinaten 
+  def target_coords
+    xdir = 0
+    if color == Color::RED
+      xdir = 1
+    else
+      xdir = -1
+    end
+
+    case type
+    when PieceType::Herzmuschel
+      coords = [Coordinates.new(xdir,-1), Coordinates.new(xdir,1)]
+    when PieceType::Moewe
+      coords = [Coordinates.new(1,0), Coordinates.new(-1,0), Coordinates.new(0,1), 
+        Coordinates.new(0,-1)]
+    when PieceType::Seestern
+      coords = [Coordinates.new(xdir,0), Coordinates.new(1,1), Coordinates.new(-1,1), 
+        Coordinates.new(1,-1), Coordinates.new(-1,-1)]
+    when PieceType::Robbe
+      coords = [Coordinates.new(-1,2), Coordinates.new(1,2), Coordinates.new(-2,1), 
+        Coordinates.new(2,1), Coordinates.new(-1,-2), Coordinates.new(1,-2), 
+        Coordinates.new(-2,-1), Coordinates.new(2,-1)]
+    end
+
+    coords.map{ |x| x + position }.to_a
+    coords.map{ |x| x + position }.select{ |c| c.x >= 0 && c.y >=0 && c.x < BOARD_SIZE && c.y < BOARD_SIZE}.to_a
   end
 
   def ==(other)
-    color == other.color &&
-      coords == other.coords
+    !other.nil? &&
+      color == other.color &&
+      position == other.position &&
+      type == other.type
   end
 
+  # @return [String] Gibt die String-Repräsentation zurück
   def to_s
-    "#{color.key} #{kind.key} at #{position} rotation #{rotation.key}#{is_flipped ? ' (flipped)' : ''}"
+    "#{color.key} #{type.key} at #{position}"
   end
 
-  def inspect
-    to_s
+  # @return [String] Gibt eine Kurzfassung der String-Repräsentation zurück
+  def to_ss
+    "#{color.key.to_s[0]}#{type.key.to_s[0]}"
   end
 
-  private
-
-  def coords_priv
-    kind.transform(@rotation, @is_flipped).transform do |it|
-      Coordinates.new(it.x + @position.x, it.y + @position.y)
-    end.coordinates
+  def inspect
+    to_s
   end
 end

data/lib/software_challenge_client/piece_type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'typesafe_enum'
+
+# Die Spielsteintypen. Herzmuschel, Möwe, Seestern und Robbe
+class PieceType < TypesafeEnum::Base
+  new :Herzmuschel, 'C'
+  new :Moewe, 'G'
+  new :Seestern, 'S'
+  new :Robbe, 'R'
+
+  # @return [String] Gibt den color namen zurück
+  def to_s
+    self.key.to_s
+  end
+end

data/lib/software_challenge_client/player.rb

@@ -7,16 +7,22 @@ class Player
   # @return [String] der Name des Spielers, hat keine Auswirkungen auf das Spiel
   attr_reader :name
 
-  # @!attribute [r] type
-  # @return [PlayerType] erster (PlayerType::ONE) oder zweiter (PlayerType::TWO) Spieler
-  attr_reader :type
+  # @!attribute [r] color
+  # @return [Color] erster (Color::RED) oder zweiter (Color::BLUE) Spieler
+  attr_reader :color
+
+  # @!attribute [rw] amber
+  # @return [Integer] Anzahl Bernsteine die dieser Spieler gesammelt hat
+  attr_accessor :amber
 
   # Konstruktor
-  # @param type [PlayerType] Erster oder zweiter
+  # @param type [Color] Rot oder blau
   # @param name [String] Name
-  def initialize(type, name)
-    @type = type
+  # @param amber [Integer] Menge des Bernsteins die der Spieler hat
+  def initialize(color, name, amber = 0)
+    @color = color
     @name = name
+    @amber = amber
   end
 
   def ==(other)