software_challenge_client 21.2.0 → 22.1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 679cfef66fc6ad4179d34801147b0640e79e2930c607069c3da6e52c5ff00862
-  data.tar.gz: bf3dc2f6e06ed94e72328b8babc4741faad2c0510e965f144dcd94b9a80c66ee
+  metadata.gz: fb51cb43ad01dbd89c1201d2cfc724131e479c4046421f74f7c437c8a97572ea
+  data.tar.gz: 35209a8eee036071d32ad0d397eb0c79d91e3a99785846b2171867687fe048bd
 SHA512:
-  metadata.gz: d99e60671de8a35ad5901c46c418bce5b49ab1ef91551cccc17284bbdf82272719a3049dac3338fcd660c48eea21bc2e2ad8262c3d6803da7eab5251e33664ee
-  data.tar.gz: 2ef1c173e01c84cfdc37cd882aea28e04af7151cad00276b1d4a8d4d3f26243fd0e2f8e01584dd6f007954715b2ac6af5fed961aeb5cc0c2982788df296456eb
+  metadata.gz: c363296bfad49e86c6b5394564e1460b50e09899ab673da822497e88b04b4236618767a1ca07342234be5017a9189410514864d249679700b05cfa92ad6676e1
+  data.tar.gz: c9bde7fc8db24b18b9c47e8ac5c0b2d60a3d75fa549b442c2e64bd9f9807ab17794d5958dceb3f12c1711821a3c90150402e03748a0e2168499b0bac312c3bcf

data/.gitignore

@@ -9,4 +9,7 @@
 /tmp/
 /bin/
 /vendor
-/spec/examples.txt
+/spec/examples.txt
+/test/
+*.gem
+test/client.rb

data/Dockerfile

@@ -1,3 +1,3 @@
-FROM ruby:2.6.5
+FROM ruby:2.6.6
 
 RUN gem install --no-document software_challenge_client

data/README.md

@@ -34,7 +34,7 @@ Oder installiere das Gem ohne ein Gemfile mit:
 
 ## Verwendung
 
-Ein Beispielprojekt zur Verwendung der Bibliothek findet man im Verzeichnis `example` ([Beipspielprojekt auf GitHub](https://github.com/CAU-Kiel-Tech-Inf/socha_ruby_client/tree/master/example)).
+Ein Beispielprojekt zur Verwendung der Bibliothek findet man im Verzeichnis `example` ([Beispielprojekt auf GitHub](https://github.com/CAU-Kiel-Tech-Inf/socha_ruby_client/tree/master/example)).
 
 Du kannst den Beispielclient mittels
 

data/RELEASES.md

@@ -1,3 +1,11 @@
+= 22.1.0
+
+Fix gamestate.round
+
+= 22.0.3
+
+First tagged Version for Osteseeschach
+
 = 21.2.0
 
 Adjustments for Backend version 21.2.0

data/lib/software_challenge_client/board.rb

@@ -5,31 +5,16 @@ require_relative './util/constants'
 require_relative 'game_state'
 require_relative 'field'
 
-# Ein Spielbrett fuer Blokus
+# Ein Spielbrett fuer Ostseeschach 
 class Board
   include Constants
+
   # @!attribute [r] fields
   # @note Besser über die {#field} Methode auf Felder zugreifen.
   # @return [Array<Array<Field>>] Ein Feld wird an der Position entsprechend
   #   seiner x und y Coordinates im Array gespeichert.
   attr_reader :fields
 
-  # @!attribute [r] deployed_blue_pieces
-  # @return [Array<PieceShape>] Die blauen, gesetzten Spielsteine
-  attr_accessor :deployed_blue_pieces
-
-  # @!attribute [r] deployed_yellow_pieces
-  # @return [Array<PieceShape>] Die gelben, gesetzten Spielsteine
-  attr_accessor :deployed_yellow_pieces
-
-  # @!attribute [r] deployed_red_pieces
-  # @return [Array<PieceShape>] Die roten, gesetzten Spielsteine
-  attr_accessor :deployed_red_pieces
-
-  # @!attribute [r] deployed_green_pieces
-  # @return [Array<PieceShape>] Die grünen, gesetzten Spielsteine
-  attr_accessor :deployed_green_pieces
-
   # Erstellt ein neues leeres Spielbrett.
   def initialize(fields = [])
     @fields = Board.empty_game_field
@@ -91,39 +76,19 @@ class Board
     field(coordinates.x, coordinates.y)
   end
 
-  # TODO: Redo this recursively, starting from the corresponding corner and then moving alongside edges and corners
+  def fields_of_color(color)
+    fields = []
 
-  # Alle Felder einer bestimmten Farbe
-  #
-  # @param color [Color] Die Farbe der Felder
-  # @return [Array<Field>] Eine Liste aller felder, die die gegebene Farbe haben
-  def fields_of_color(color, fields = [Coordinates.new(0, 0),
-                                       Coordinates.new(0, BOARD_SIZE - 1),
-                                       Coordinates.new(BOARD_SIZE - 1, BOARD_SIZE - 1),
-                                       Coordinates.new(BOARD_SIZE - 1, 0)].select { |it| field_at(it).color == color })
-    copy = Array.new(fields)
-
-    copy.each do |field|
-      [Coordinates.new(1, 0),
-       Coordinates.new(1, -1),
-       Coordinates.new(0, -1),
-       Coordinates.new(-1, -1),
-       Coordinates.new(-1, 0),
-       Coordinates.new(-1, 1),
-       Coordinates.new(0, 1),
-       Coordinates.new(1, 1)].each do |neighbor|
-        new_field = field + neighbor
-        next unless Board.contains(new_field) && @fields[new_field.x][new_field.y].color == color
-
-        fields << new_field unless fields.include?(new_field)
+    (0...BOARD_SIZE).to_a.map do |x|
+      (0...BOARD_SIZE).to_a.map do |y|
+        f = field(x,y)
+        if (f.color == color)
+          fields << f
+        end
       end
     end
 
-    if copy.count == fields.count
-      fields
-    else
-      fields_of_color(color, fields)
-    end
+    fields
   end
 
   # @param it [Coordinates] Die zu untersuchenden Koordinaten
@@ -132,21 +97,6 @@ class Board
     it.x >= 0 && it.y >= 0 && it.x < BOARD_SIZE && it.y < BOARD_SIZE
   end
 
-  # @param color [Color] Die Farbe der Steine
-  # @return [Array<PieceShape>] Eine Liste aller Steintypen, die die gegebene Farbe noch nicht gespielt hat
-  def deployed_pieces(color)
-    case color
-    when Color::RED
-      deployed_red_pieces
-    when Color::BLUE
-      deployed_blue_pieces
-    when Color::YELLOW
-      deployed_yellow_pieces
-    when Color::GREEN
-      deployed_green_pieces
-    end
-  end
-
   # @return eine unabhaengige Kopie des Spielbretts
   def clone
     Marshal.load(Marshal.dump(self))

data/lib/software_challenge_client/color.rb

@@ -2,15 +2,25 @@
 
 require 'typesafe_enum'
 
-# Die Spielsteinfarben. BLUE, YELLOW, RED und GREEN
+require_relative 'team'
+
+# TODO 2022: Replace with bool?
+# Die Spielsteinfarben. BLUE, und RED
 class Color < TypesafeEnum::Base
   new :BLUE, 'B'
-  new :YELLOW, 'Y'
   new :RED, 'R'
-  new :GREEN, 'G'
 
   # Gibt den color namen zurück
   def to_s
     self.key.to_s
   end
+
+  # Gibt das zugehörige Team zurück
+  def to_t
+    if self.key == :RED
+      Team::ONE
+    else
+      Team::TWO
+    end
+  end
 end

data/lib/software_challenge_client/field.rb

@@ -4,47 +4,66 @@
 # Ein Feld des Spielfelds. Ein Spielfeld ist durch die Koordinaten eindeutig
 # identifiziert.
 class Field
-  # @!attribute [rw] color
-  # @return [Color] Farbe des überdeckenden Spielsteins, falls vorhanden, sonst
-  #                 nil
-  attr_accessor :color
   # @!attribute [r] coordinates
   # @return [Coordinates] die X-Y-Koordinaten des Feldes
   attr_reader :coordinates
 
+  # @!attribute [rw] piece
+  # @return [Piece] das Piece auf diesem Feld, falls vorhanden, sonst nil
+  attr_accessor :piece
+
   # Erstellt ein neues leeres Feld.
   #
   # @param x [Integer] X-Koordinate
   # @param y [Integer] Y-Koordinate
   # @param color [Color] Farbe des Spielsteins, der das Feld überdeckt, nil falls kein Spielstein es überdeckt
-  def initialize(x, y, color = nil)
-    @color = color
+  def initialize(x, y, piece = nil)
+    @piece = piece
     @coordinates = Coordinates.new(x, y)
   end
 
   # Vergleicht zwei Felder. Felder sind gleich, wenn sie gleiche Koordinaten und
-  # gleichen Typ haben.
+  # den gleichen Spielstein haben.
   # @return [Boolean] true bei Gleichheit, sonst false.
   def ==(other)
-    coordinates == other.coordinates &&
-      color == other.color
+    !other.nil? && coordinates == other.coordinates && piece == other.piece
   end
 
+  # @return [Integer] X-Koordinate des Felds
   def x
     coordinates.x
   end
 
+  # @return [Integer] Y-Koordinate des Felds
   def y
     coordinates.y
   end
 
+  # @return [Team] Team des Pieces auf dem Feld
+  def team
+    if piece.nil?
+      nil
+    else
+      piece.color.to_t
+    end
+  end
+
+  # @return [PieceColor] Farbe des Pieces auf dem Feld
+  def color
+    if piece.nil?
+      nil
+    else
+      piece.color
+    end
+  end
+
   # @return [Boolean] true, wenn das Feld nicht durch einen Spielstein überdeckt ist, sonst false
   def empty?
-    color.nil?
+    piece.nil?
   end
 
   # @return [String] Textuelle Darstellung des Feldes.
   def to_s
-    empty? ? '_' : color.value
+    empty? ? '__' : piece.to_ss
   end
 end

data/lib/software_challenge_client/game_rule_logic.rb

@@ -2,11 +2,11 @@
 
 require_relative './util/constants'
 require_relative 'invalid_move_exception'
-require_relative 'set_move'
+require_relative 'move'
 
 require 'set'
 
-# Methoden, welche die Spielregeln von Blokus abbilden.
+# Methoden, welche die Spielregeln von Ostseeschach abbilden.
 #
 # Es gibt hier viele Helfermethoden, die von den beiden Hauptmethoden {GameRuleLogic#valid_move?}
 # und {GameRuleLogic.possible_moves} benutzt werden.
@@ -19,250 +19,69 @@ class GameRuleLogic
 
   # Gibt alle möglichen Züge für den Spieler zurück, der in der gamestate dran ist.
   # Diese ist die wichtigste Methode dieser Klasse für Schüler.
-  #
   # @param gamestate [GameState] Der zu untersuchende Spielstand.
+  #
+  # @return [Array<Move>] Die möglichen Moves
   def self.possible_moves(gamestate)
-    re = possible_setmoves(gamestate)
+    moves = []
+    fields = gamestate.board.fields_of_color(gamestate.current_player.color)
 
-    re << SkipMove.new unless gamestate.is_first_move?
+    fields.each do |f|
+      moves.push(*moves_for_piece(gamestate, f.piece))
+    end
 
-    re
+    moves.select { |m| valid_move?(gamestate, m) }.to_a
   end
 
   # Gibt einen zufälligen möglichen Zug zurück
   # @param gamestate [GameState] Der zu untersuchende Spielstand.
+  #
+  # @return [Move] Ein möglicher Move
   def self.possible_move(gamestate)
     possible_moves(gamestate).sample
   end
 
-  # Gibt alle möglichen Legezüge zurück
+  # Hilfsmethode um Legezüge für einen [Piece] zu berechnen.
   # @param gamestate [GameState] Der zu untersuchende Spielstand.
-  def self.possible_setmoves(gamestate)
-    if gamestate.is_first_move?
-      possible_start_moves(gamestate)
-    else
-      all_possible_setmoves(gamestate).flatten
-    end
-  end
-
-  # Gibt alle möglichen Legezüge in der ersten Runde zurück
-  # @param gamestate [GameState] Der zu untersuchende Spielstand.
-  def self.possible_start_moves(gamestate)
-    color = gamestate.current_color
-    shape = gamestate.start_piece
-    area1 = shape.dimension
-    area2 = Coordinates.new(area1.y, area1.x)
-    moves = Set[]
-
-    # Hard code corners for most efficiency (and because a proper algorithm would be pretty illegible here)
-    # Upper Left
-    moves.merge(moves_for_shape_on(color, shape, Coordinates.new(0, 0)))
-
-    # Upper Right
-    moves.merge(moves_for_shape_on(color, shape, Coordinates.new(BOARD_SIZE - area1.x, 0)))
-    moves.merge(moves_for_shape_on(color, shape, Coordinates.new(BOARD_SIZE - area2.x, 0)))
-
-    # Lower Left
-    moves.merge(moves_for_shape_on(color, shape, Coordinates.new(0, BOARD_SIZE - area1.y)))
-    moves.merge(moves_for_shape_on(color, shape, Coordinates.new(0, BOARD_SIZE - area2.y)))
-
-    # Lower Right
-    moves.merge(moves_for_shape_on(color, shape, Coordinates.new(BOARD_SIZE - area1.x, BOARD_SIZE - area1.y)))
-    moves.merge(moves_for_shape_on(color, shape, Coordinates.new(BOARD_SIZE - area2.x, BOARD_SIZE - area2.y)))
-
-    moves.select { |m| valid_set_move?(gamestate, m) }.to_a
-  end
-
-  # Hilfsmethode um Legezüge für eine [PieceShape] zu berechnen.
-  # @param color [Color] Die Farbe der Spielsteine der Züge
-  # @param shape [PieceShape] Die Form der Spielsteine der Züge
-  # @param position [Coordinates] Die Position der Spielsteine der Züge
-  def self.moves_for_shape_on(color, shape, position)
-    moves = Set[]
-    Rotation.each do |r|
-      [true, false].each do |f|
-        moves << SetMove.new(Piece.new(color, shape, r, f, position))
-      end
-    end
-    moves
-  end
-
-  # Gib eine Liste aller möglichen Legezüge zurück, auch wenn es die erste Runde ist.
-  # @param gamestate [GameState] Der zu untersuchende Spielstand.
-  def self.all_possible_setmoves(gamestate)
-    moves = []
-    fields = valid_fields(gamestate)
-    gamestate.undeployed_pieces(gamestate.current_color).each do |p|
-      (moves << possible_moves_for_shape(gamestate, p, fields)).flatten
-    end
-    moves
-  end
-
-  # Gibt eine Liste aller möglichen SetMoves für diese Form zurück.
-  # @param gamestate [GameState] Der zu untersuchende Spielstand.
-  # @param shape Die [PieceShape], die die Züge nutzen sollen
+  # @param piece [Piece] Der Typ des Spielsteines
   #
-  # @return Alle möglichen Züge mit der Form
-  def self.possible_moves_for_shape(gamestate, shape, fields = valid_fields(gamestate))
-    color = gamestate.current_color
-
+  # @return [Array<Move>] Die möglichen Moves
+  def self.moves_for_piece(gamestate, piece)
     moves = Set[]
-    fields.each do |field|
-      shape.unique_transforms().each do |t|
-        piece = Piece.new(color, shape, t.r, t.f, Coordinates.new(0, 0))
-        piece.coords.each do |pos|
-          moves << SetMove.new(Piece.new(color, shape, t.r, t.f, Coordinates.new(field.x - pos.x, field.y - pos.y)))
-        end
-      end
-    end
-    moves.select { |m| valid_set_move?(gamestate, m) }.to_a
-  end
-
-  # Gibt eine Liste aller Felder zurück, an denen möglicherweise Züge gemacht werden kann.
-  # @param gamestate [GameState] Der zu untersuchende Spielstand.
-  def self.valid_fields(gamestate)
-    color = gamestate.current_color
-    board = gamestate.board
-    fields = Set[]
-    board.fields_of_color(color).each do |field|
-      [Coordinates.new(field.x - 1, field.y - 1),
-       Coordinates.new(field.x - 1, field.y + 1),
-       Coordinates.new(field.x + 1, field.y - 1),
-       Coordinates.new(field.x + 1, field.y + 1)].each do |corner|
-        next unless Board.contains(corner)
-        next unless board[corner].empty?
-        next if neighbor_of_color?(board, Field.new(corner.x, corner.y), color)
-
-        fields << corner
-      end
-    end
-    fields
-  end
-
-  # Überprüft, ob das gegebene Feld ein Nachbarfeld mit der Farbe [color] hat
-  # @param board [Board] Das aktuelle Board
-  # @param field [Field] Das zu überprüfende Feld
-  # @param color [Color] Nach der zu suchenden Farbe
-  def self.neighbor_of_color?(board, field, color)
-    [Coordinates.new(field.x - 1, field.y),
-     Coordinates.new(field.x, field.y - 1),
-     Coordinates.new(field.x + 1, field.y),
-     Coordinates.new(field.x, field.y + 1)].any? do |neighbor|
-      Board.contains(neighbor) && board[neighbor].color == color
+    piece.target_coords.each do |c| 
+      moves << Move.new(piece.position, c)
     end
+    moves.select { |m| valid_move?(gamestate, m) }.to_a
   end
 
-  # # Return a list of all moves, impossible or not.
-  # # There's no real usage, except maybe for cases where no Move validation happens
-  # # if `Constants.VALIDATE_MOVE` is false, then this function should return the same
-  # # Set as `::getPossibleMoves`
-  # def self.get_all_set_moves()
-  #   moves = []
-  #   Color.each do |c|
-  #     PieceShape.each do |s|
-  #       Rotation.each do |r|
-  #         [false, true].each do |f|
-  #           (0..BOARD_SIZE-1).to_a.each do |x|
-  #             (0..BOARD_SIZE-1).to_a.each do |y|
-  #               moves << SetMove.new(Piece.new(c, s, r, f, Coordinates.new(x, y)))
-  #             end
-  #           end
-  #         end
-  #       end
-  #     end
-  #   end
-  #   moves
-  # end
-
   # --- Move Validation ------------------------------------------------------------
 
   # Prüft, ob der gegebene [Move] zulässig ist.
   # @param gamestate [GameState] Der zu untersuchende Spielstand.
-  # @param move der zu überprüfende Zug
+  # @param move [Move] Der zu überprüfende Zug
   #
   # @return ob der Zug zulässig ist
   def self.valid_move?(gamestate, move)
-    if move.instance_of? SkipMove
-      !gamestate.is_first_move?
-    else
-      valid_set_move?(gamestate, move)
-    end
-  end
+    return false unless gamestate.current_player.color == move.piece(gamestate).color
 
-  # Prüft, ob der gegebene [SetMove] zulässig ist.
-  # @param gamestate [GameState] der aktuelle Spielstand
-  # @param move [SetMove] der zu überprüfende Zug
-  #
-  # @return ob der Zug zulässig ist
-  def self.valid_set_move?(gamestate, move)
-    return false if move.piece.color != gamestate.current_color
+    return false unless gamestate.board.in_bounds?(move.to)
 
-    if gamestate.is_first_move?
-      # on first turn, only the start piece is allowed
-      return false if move.piece.kind != gamestate.start_piece
-      # and it may only be placed in a corner
-      return false if move.piece.coords.none? { |it| corner?(it) }
-    else
-      # in all other turns, only unused pieces may be placed
-      return false unless gamestate.undeployed_pieces(move.piece.color).include?(move.piece.kind)
-      # and it needs to be connected to another piece of the same color
-      return false if move.piece.coords.none? { |it| corners_on_color?(gamestate.board, it, move.piece.color) }
-    end
+    return false if gamestate.board.field_at(move.to).color == move.piece(gamestate).color
 
-    # all parts of the piece need to be
-    move.piece.coords.each do |it|
-      # - on the board
-      return false unless gamestate.board.in_bounds?(it)
-      # - on a empty field
-      return false if obstructed?(gamestate.board, it)
-      # - not next to a field occupied by the same color
-      return false if borders_on_color?(gamestate.board, it, move.piece.color)
-    end
+    return false unless move.piece(gamestate).target_coords.include? move.to
 
-    true
-  end
-
-  # Überprüft, ob das gegebene Feld ein Nachbarfeld mit der Farbe [color] hat
-  # @param board [Board] Das aktuelle Spielbrett
-  # @param field [Field] Das zu überprüfende Feld
-  # @param color [Color] Nach der zu suchenden Farbe
-  def self.borders_on_color?(board, position, color)
-    [Coordinates.new(1, 0), Coordinates.new(0, 1), Coordinates.new(-1, 0), Coordinates.new(0, -1)].any? do |it|
-      if board.in_bounds?(position + it)
-        board[position + it].color == color
-      else
-        false
-      end
-    end
-  end
-
-  # Überprüft, ob das gegebene Feld ein diagonales Nachbarfeld mit der Farbe [color] hat
-  # @param board [Board] Das aktuelle Spielbrett
-  # @param position [Field] Das zu überprüfende Feld
-  # @param color [Color] Nach der zu suchenden Farbe
-  def self.corners_on_color?(board, position, color)
-    [Coordinates.new(1, 1), Coordinates.new(1, -1), Coordinates.new(-1, -1), Coordinates.new(-1, 1)].any? do |it|
-      board.in_bounds?(position + it) && board[position + it].color == color
-    end
-  end
+    # TODO 2022: Forgot checks?
 
-  # Überprüft, ob die gegebene [position] an einer Ecke des Boards liegt.
-  # @param position [Coordinates] Die zu überprüfenden Koordinaten
-  def self.corner?(position)
-    corner = [
-      Coordinates.new(0, 0),
-      Coordinates.new(BOARD_SIZE - 1, 0),
-      Coordinates.new(0, BOARD_SIZE - 1),
-      Coordinates.new(BOARD_SIZE - 1, BOARD_SIZE - 1)
-    ]
-    corner.include? position
+    true
   end
 
-  # Überprüft, ob die gegebene [position] schon mit einer Farbe belegt wurde.
+  # Überprüft, ob die gegebene [position] mit einem Spielstein belegt ist.
   # @param board [Board] Das aktuelle Spielbrett
   # @param position [Coordinates] Die zu überprüfenden Koordinaten
+  #
+  # @return [Boolean] Ob die position belegt wurde
   def self.obstructed?(board, position)
-    !board[position].color.nil?
+    !board.field_at(position).empty?
   end
 
   # --- Perform Move ------------------------------------------------------------
@@ -270,65 +89,53 @@ class GameRuleLogic
   # Führe den gegebenen [Move] im gebenenen [GameState] aus.
   # @param gamestate [GameState] der aktuelle Spielstand
   # @param move der auszuführende Zug
+  #
+  # @return [GameState] Der theoretische GameState
   def self.perform_move(gamestate, move)
     raise 'Invalid move!' unless valid_move?(gamestate, move)
 
-    if move.instance_of? SetMove
-      gamestate.undeployed_pieces(move.piece.color).delete(move.piece)
+    from_field = gamestate.board.field_at(move.from)
+    to_field = gamestate.board.field_at(move.to)
 
-      # Apply piece to board
-      move.piece.coords.each do |coord|
-        gamestate.board[coord].color = move.piece.color
-      end
+    # Update board pieces if one is stepped on
+    if not to_field.empty?
+      from_field.piece.height = from_field.piece.height + 1
 
-      # If it was the last piece for this color, remove it from the turn queue
-      if gamestate.undeployed_pieces(move.piece.color).empty?
-        gamestate.lastMoveMono += move.color to(move.piece.kind == PieceShape.MONO)
-        gamestate.remove_active_color
+      # Check for high tower
+      if from_field.piece.height >= 3
+        gamestate.current_player.amber = gamestate.current_player.amber + 1
+        to_field.piece = nil
       end
     end
+    
+    # Update board fields
+    to_field.piece = from_field.piece
+    from_field.piece = nil
+
+    # Update position value of the moved piece
+    if !to_field.empty? && !to_field.piece.nil?
+      to_field.piece.position = Coordinates.new(to_field.coordinates.x, to_field.coordinates.y)
+    end
+
     gamestate.turn += 1
-    gamestate.round += 1
     gamestate.last_move = move
   end
 
   # --- Other ------------------------------------------------------------
 
-  # Berechne den Punktestand anhand der gegebenen [PieceShape]s.
-  # @param undeployed eine Sammlung aller nicht gelegten [PieceShape]s
-  # @param monoLast ob der letzte gelegte Stein das Monomino war
+  # Prueft, ob ein Spieler im gegebenen GameState gewonnen hat.
+  # @param gamestate [GameState] Der zu untersuchende GameState.
   #
-  # @return die erreichte Punktezahl
-  def self.get_points_from_undeployed(undeployed, mono_last = false)
-    # If all pieces were placed:
-    if undeployed.empty?
-      # Return sum of all squares plus 15 bonus points
-      return SUM_MAX_SQUARES + 15 +
-             # If the Monomino was the last placed piece, add another 5 points
-             mono_last ? 5 : 0
+  # @return [Condition] nil, if the game is not won or a Condition indicating the winning player
+  def self.winning_condition(gamestate)
+    if gamestate.player_one.amber >= 2
+      Condition.new(gamestate.player_one, "Spieler 1 hat 2 Bernsteine erreicht")
     end
-    # One point per block per piece placed
-    SUM_MAX_SQUARES - undeployed.map(&:size).sum
-  end
-
-  # Gibt einen zufälligen Pentomino zurück, welcher nicht `x` ist.
-  def self.get_random_pentomino
-    PieceShape.map(&:value).select { |it| it.size == 5 && it != PieceShape::PENTO_X }
-  end
 
-  # Entferne alle Farben, die keine Steine mehr auf dem Feld platzieren können.
-  def remove_invalid_colors(gamestate)
-    return if gamestate.ordered_colors.empty?
-    return unless get_possible_moves(gamestate).empty?
-
-    gamestate.remove_active_color
-    remove_invalid_colors(gamestate)
-  end
+    if gamestate.player_two.amber >= 2
+      Condition.new(gamestate.player_two, "Spieler 2 hat 2 Bernsteine erreicht")
+    end
 
-  # Prueft, ob ein Spieler im gegebenen GameState gewonnen hat.
-  # @param gamestate [GameState] Der zu untersuchende GameState.
-  # @return [Condition] nil, if the game is not won or a Condition indicating the winning player
-  def self.winning_condition(_gamestate)
-    raise 'Not implemented yet!'
+    nil
   end
 end