software_challenge_client 21.0.1 → 22.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb6f7046235b14fdf74c293c8c4f1b40a014373f949e9c9987f1ee36db6e579f
-  data.tar.gz: 95cb06324e9ae3ef77e7a76200bd45f47af3176f18f744f138c835d14ef7ade2
+  metadata.gz: 5409d523f45de264ef1616783fc0e901ea63460f831df5b65a014cc5effba23c
+  data.tar.gz: 1e9d622dbb0008fff464ca1e39a02ae3bab89192f07674ebd0f63b09b45f0fab
 SHA512:
-  metadata.gz: 382fe8164ebb55803018b0ebec3c04061d9fbc65e770702383190ea9a5279f5cb6e0ddcbb12e3a3b3057d31450f416f4388d3ddafb1e14447c15bd2fb16a937a
-  data.tar.gz: fa76ba63c8634597486a9b34665a0c731870a25ace4ddef3d4b9b05206b6c31e97077a2bf12106193e321dfec6225c99d3361435d8938229169e77ecad9b0c3a
+  metadata.gz: 02e77e4cc105dbccc0c52df6c3d3f7486cf36015d49ed08d6132c69983724e1cdff0fef12c0267b348137c5693b209aff80123dd5a297d28e0e6227ead3a9bbc
+  data.tar.gz: 9ee8e0a060c2b214353ca95647dd40bc844043688354663a9ccdd959269f38a70c85fae6bc531ec0eec5a862522e01c876984bc4bf1b4920de8e67f80d311c93

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/RELEASES.md

@@ -1,3 +1,15 @@
+= 21.2.0
+
+Adjustments for Backend version 21.2.0
+
+= 21.1.0
+
+Pieces are now mutable and `==` of pieces considers rotated shapes which result in the same covered board fields as equal.
+
+= 21.0.2
+
+Fixed problem which caused `last_move` of a `GameState` always be `nil` (thanks to wollw!).
+
 = 21.0.1
 
 Improved performance and defined Ruby version 2.5.5 as minimum requirement

data/lib/software_challenge_client.rb

@@ -4,7 +4,6 @@ module SoftwareChallengeClient
   require 'software_challenge_client/client_interface.rb'
   require 'software_challenge_client/color.rb'
   require 'software_challenge_client/condition.rb'
-  require 'software_challenge_client/coordinate_set.rb'
   require 'software_challenge_client/coordinates.rb'
   require 'software_challenge_client/debug_hint.rb'
   require 'software_challenge_client/field.rb'
@@ -13,16 +12,14 @@ module SoftwareChallengeClient
   require 'software_challenge_client/has_hints.rb'
   require 'software_challenge_client/invalid_move_exception.rb'
   require 'software_challenge_client/logging.rb'
+  require 'software_challenge_client/move.rb'
   require 'software_challenge_client/network.rb'
   require 'software_challenge_client/piece.rb'
-  require 'software_challenge_client/piece_shape.rb'
+  require 'software_challenge_client/piece_type.rb'
   require 'software_challenge_client/player.rb'
-  require 'software_challenge_client/player_type.rb'
   require 'software_challenge_client/protocol.rb'
-  require 'software_challenge_client/rotation.rb'
   require 'software_challenge_client/runner.rb'
-  require 'software_challenge_client/set_move.rb'
-  require 'software_challenge_client/skip_move.rb'
+  require 'software_challenge_client/team.rb'
   require 'software_challenge_client/util/constants.rb'
   require 'software_challenge_client/version.rb'
 end

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,251 +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
-  # @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.
+  # Hilfsmethode um Legezüge für einen [Piece] zu berechnen.
   # @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)
-    # Check whether the color's move is currently active
-    return false if move.piece.color != gamestate.current_color
+    return false unless gamestate.board.in_bounds?(move.to)
 
-    # Check whether the shape is valid
-    if gamestate.is_first_move?
-      return false if move.piece.kind != gamestate.start_piece
-    elsif !gamestate.undeployed_pieces(move.piece.color).include?(move.piece.kind)
-      return false
-    end
+    return false if gamestate.board.field_at(move.to).color == move.piece(gamestate).color
 
-    # Check whether the piece can be placed
-    move.piece.coords.each do |it|
-      return false unless gamestate.board.in_bounds?(it)
-      return false if obstructed?(gamestate.board, it)
-      return false if borders_on_color?(gamestate.board, it, move.piece.color)
-    end
+    return false unless move.piece(gamestate).target_coords.include? move.to
 
-    if gamestate.is_first_move?
-      # Check if it is placed correctly in a corner
-      return false if move.piece.coords.none? { |it| corner?(it) }
-    else
-      # Check if the piece is connected to at least one tile of same color by corner
-      return false if move.piece.coords.none? { |it| corners_on_color?(gamestate.board, it, move.piece.color) }
-    end
+    # TODO 2022: Forgot checks?
 
     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
-
-  # Ü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
-  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 ------------------------------------------------------------
@@ -271,66 +89,48 @@ 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)
-      # gamestate.deployed_pieces(move.piece.color).add(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
+
     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