software_challenge_client 20.2.4 → 21.2.0

data/lib/software_challenge_client/game_state.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require_relative './util/constants'
@@ -15,36 +14,62 @@ class GameState
   # @!attribute [rw] turn
   # @return [Integer] Aktuelle Zugnummer (von 0 beginnend)
   attr_accessor :turn
-  # @!attribute [rw] start_player_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] 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] undeployed_red_pieces
-  # @return [Player] Die nicht gesetzten Spielsteine des roten Spielers
-  attr_accessor :undeployed_red_pieces
+  # @!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 [Player] Die nicht gesetzten Spielsteine des roten Spielers
+  # @return [Array<PieceShape>] Die blauen, nicht gesetzten Spielsteine
   attr_accessor :undeployed_blue_pieces
 
-  # @!attribute [r] red
-  # @return [Player] Der rote Spieler
-  attr_reader :red
-  # @!attribute [r] blue
-  # @return [Player] Der blaue Spieler
-  attr_reader :blue
+  # @!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.
@@ -54,78 +79,86 @@ class GameState
   def field(x, y)
     board.field(x, y)
   end
-  def self.parse_pieces_string(string, color)
-    string.chars.map do |c|
-      case c
-      when 'Q'
-        Piece.new(color, PieceType::BEE)
-      when 'S'
-        Piece.new(color, PieceType::SPIDER)
-      when 'G'
-        Piece.new(color, PieceType::GRASSHOPPER)
-      when 'B'
-        Piece.new(color, PieceType::BEETLE)
-      when 'A'
-        Piece.new(color, PieceType::ANT)
-      end
-    end
-  end
 
+  # Erstellt einen neuen leeren Spielstand.
   def initialize
-    @current_player_color = PlayerColor::RED
-    @start_player_color = PlayerColor::RED
+    @ordered_colors = [Color::BLUE, Color::YELLOW, Color::RED, Color::GREEN]
     @board = Board.new
     @turn = 0
-    @undeployed_red_pieces = GameState.parse_pieces_string(Constants::STARTING_PIECES, PlayerColor::RED)
-    @undeployed_blue_pieces = GameState.parse_pieces_string(Constants::STARTING_PIECES, PlayerColor::BLUE)
+    @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)
-    if player.color == PlayerColor::RED
-      @red = player
-    elsif player.color == PlayerColor::BLUE
-      @blue = 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
-    return red if current_player_color == PlayerColor::RED
-    return blue if current_player_color == PlayerColor::BLUE
+    turn.even? ? player_one : player_two
   end
 
   # @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
+    turn.even? ? player_two : player_one
   end
 
-  # @return [PlayerColor] Farbe des Spielers, der gerade nicht an der Reihe ist.
-  def other_player_color
-    PlayerColor.opponent_color(current_player_color)
+  # @return [PlayerType] Typ des Spielers, der gerade nicht an der Reihe ist.
+  def other_player_type
+    other_player.type
   end
 
-  # @return [Integer] Aktuelle Runde (von 0 beginnend).
-  def round
-    turn / 2
+  # @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 PlayerColor::RED
+    when Color::RED
       undeployed_red_pieces
-    when PlayerColor::BLUE
+    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.
   #
@@ -140,6 +173,11 @@ class GameState
     !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
@@ -156,22 +194,23 @@ class GameState
   # 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, entspricht der Anzahl der Fische
-  #                   im größten Schwarm des Spielers.
-  def points_for_player(player)
+  # @return [Integer] Die Punkte des Spielers
+  def points_for_player(_player)
     # TODO
     -1
   end
 
   def ==(other)
     turn == other.turn &&
-        start_player_color == other.start_player_color &&
-        current_player_color == other.current_player_color &&
-        red == other.red &&
-        blue == other.blue &&
-        board == other.board &&
-        lastMove == other.lastMove &&
-        condition == other.condition
+      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
@@ -186,9 +225,8 @@ class GameState
     @current_player_color = other_player_color
   end
 
-  # @return [Array<Field>] Alle Felder mit Fischen des Spielers, der gerade an der Reihe ist.
+  # @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)
+    board.fields_of_color(current_color)
   end
-
 end

data/lib/software_challenge_client/has_hints.rb

@@ -1,5 +1,5 @@
+# frozen_string_literal: true
 module HasHints
-
   # @!attribute [r] hints
   # @return [Array<DebugHint>] Hinweise, die an den Zug angeheftet werden sollen. Siehe {DebugHint}.
   attr_reader :hints

data/lib/software_challenge_client/invalid_move_exception.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 # Exception, die geworfen wird, wenn ein ungültiger Zug ausgeführt wird.
 # @see GameRuleLogic#perform_move

data/lib/software_challenge_client/logging.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 require 'logger'
 
 # Dieses Modul kann inkludiert werden, um eine Logausgabe auf der Konsole verwenden zu können.

data/lib/software_challenge_client/network.rb

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+# frozen_string_literal: false
 
 require 'socket'
 require 'rexml/document'
@@ -122,5 +123,4 @@ class Network
   def emptyReceiveBuffer
     @receive_buffer = ''
   end
-
 end

data/lib/software_challenge_client/piece.rb

@@ -1,31 +1,89 @@
+# frozen_string_literal: true
+
+# Ein Spielstein mit Ausrichtung, Koordinaten und Farbe
 class Piece
+  # @!attribute [r] Farbe
+  # @return [Color]
+  attr_reader :color
 
-  # @!attribute [r] type
-  # @return [PieceType]
-  attr_reader :type
+  # @!attribute [r] Form
+  # @return [PieceShape]
+  attr_reader :kind
 
-  # @!attribute [r] color
-  # @return [PlayerColor]
-  attr_reader :color
+  # @!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
+  # @return [Coordinates]
+  attr_reader :position
 
-  def initialize(color, type)
-    @type = type
+  # @!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
+
+  # Erstellt einen neuen leeren Spielstein.
+  def initialize(color, kind, rotation = Rotation::NONE, is_flipped = false, position = Coordinates.origin)
     @color = color
+    @kind = kind
+    @rotation = rotation
+    @is_flipped = is_flipped
+    @position = position
+
+    @coords = coords_priv
   end
 
-  def ==(other)
-    type == other.type && color == other.color
+  # Dreht den Stein
+  def rotate!(rotation)
+    @rotation = @rotation.rotate(rotation)
+    @coords = coords_priv
+  end
+
+  # Flipped den Stein
+  def flip!(f = true)
+    @is_flipped = @is_flipped ^ f
+    @coords = coords_priv
   end
 
-  def owner
-    color
+  # 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
+  end
+
+  def ==(other)
+    color == other.color &&
+      coords == other.coords
   end
 
   def to_s
-    color.value + type.value
+    "#{color.key} #{kind.key} at #{position} rotation #{rotation.key}#{is_flipped ? ' (flipped)' : ''}"
   end
 
   def inspect
     to_s
   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
+  end
 end

data/lib/software_challenge_client/piece_shape.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'typesafe_enum'
+
+require_relative 'coordinates'
+require_relative 'coordinate_set'
+
+# Die Form eines Spielsteins. Es gibt folgende Formen:
+#
+#   MONO
+#   DOMINO
+#   TRIO_L
+#   TRIO_I
+#   TETRO_O
+#   TETRO_T
+#   TETRO_I
+#   TETRO_L
+#   TETRO_Z
+#   PENTO_L
+#   PENTO_T
+#   PENTO_V
+#   PENTO_S
+#   PENTO_Z
+#   PENTO_I
+#   PENTO_P
+#   PENTO_W
+#   PENTO_U
+#   PENTO_R
+#   PENTO_X
+#   PENTO_Y
+#
+# Zugriff z.B. mit PieceShape::PENTO_S
+class PieceShape < TypesafeEnum::Base
+  def self.c(x, y)
+    Coordinates.new(x, y)
+  end
+  new :MONO, [c(0, 0)]
+  new :DOMINO, [c(0, 0), c(1, 0)]
+  new :TRIO_L, [c(0, 0), c(0, 1), c(1, 1)]
+  new :TRIO_I, [c(0, 0), c(0, 1), c(0, 2)]
+  new :TETRO_O, [c(0, 0), c(1, 0), c(0, 1), c(1, 1)]
+  new :TETRO_T, [c(0, 0), c(1, 0), c(2, 0), c(1, 1)]
+  new :TETRO_I, [c(0, 0), c(0, 1), c(0, 2), c(0, 3)]
+  new :TETRO_L, [c(0, 0), c(0, 1), c(0, 2), c(1, 2)]
+  new :TETRO_Z, [c(0, 0), c(1, 0), c(1, 1), c(2, 1)]
+  new :PENTO_L, [c(0, 0), c(0, 1), c(0, 2), c(0, 3), c(1, 3)]
+  new :PENTO_T, [c(0, 0), c(1, 0), c(2, 0), c(1, 1), c(1, 2)]
+  new :PENTO_V, [c(0, 0), c(0, 1), c(0, 2), c(1, 2), c(2, 2)]
+  new :PENTO_S, [c(1, 0), c(2, 0), c(3, 0), c(0, 1), c(1, 1)]
+  new :PENTO_Z, [c(0, 0), c(1, 0), c(1, 1), c(1, 2), c(2, 2)]
+  new :PENTO_I, [c(0, 0), c(0, 1), c(0, 2), c(0, 3), c(0, 4)]
+  new :PENTO_P, [c(0, 0), c(1, 0), c(0, 1), c(1, 1), c(0, 2)]
+  new :PENTO_W, [c(0, 0), c(0, 1), c(1, 1), c(1, 2), c(2, 2)]
+  new :PENTO_U, [c(0, 0), c(0, 1), c(1, 1), c(2, 1), c(2, 0)]
+  new :PENTO_R, [c(0, 1), c(1, 1), c(1, 2), c(2, 1), c(2, 0)]
+  new :PENTO_X, [c(1, 0), c(0, 1), c(1, 1), c(2, 1), c(1, 2)]
+  new :PENTO_Y, [c(0, 1), c(1, 0), c(1, 1), c(1, 2), c(1, 3)]
+
+  @transformations
+  Transform = Struct.new(:r, :f, :coords)
+
+  # Anzahl Felder, die der Stein belegt
+  def size
+    value.size
+  end
+
+  # Die Felder, die der Stein belegt
+  def coordinates
+    CoordinateSet.new(value)
+  end
+
+  # Eine Koordinate, die das kleinstmögliche Rechteck beschreibt, welches alle Felder umfasst.
+  def dimension
+    coordinates.area
+  end
+
+  # Erzeugt eine nach Rotation und Flip transformierte Form
+  def transform(rotation, flip)
+    coordinates.rotate(rotation).flip(flip)
+  end
+
+  # Gibt alle Kombinationen aus Rotation und Flipping zurück, welche zu einzigartigen 
+  # Koordinatenmengen dieser Form führen. 
+  # @return [Array<Transform>] Transform Structs mit Rotation r, Boolean f
+  def unique_transforms()
+    if not defined? @transformations then
+      existing_transforms = []
+
+      Rotation.each do |r|
+        [true, false].each do |f|
+          new_transform = Transform.new(r, f, transform(r, f))
+
+          if existing_transforms.none? { |t| t.coords == new_transform.coords } then
+            existing_transforms << new_transform
+          end
+        end
+      end
+
+      @transformations = existing_transforms
+    end
+
+    @transformations
+  end
+
+  # Gibt den Form Namen zurück
+  def to_s
+    self.key.to_s
+  end
+end