software_challenge_client 21.2.0 → 22.0.2

data/lib/software_challenge_client/game_state.rb

@@ -4,6 +4,7 @@ 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.
@@ -19,36 +20,6 @@ class GameState
   # @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
@@ -57,14 +28,14 @@ class GameState
   # @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] 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)
@@ -82,25 +53,18 @@ class GameState
 
   # 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
+    case player.color
+    when Color::RED
       @player_one = player
-    when PlayerType::TWO
+    when Color::BLUE
       @player_two = player
     end
   end
@@ -115,45 +79,11 @@ class GameState
     turn.even? ? player_two : player_one
   end
 
-  # @return [PlayerType] Typ des Spielers, der gerade nicht an der Reihe ist.
-  def other_player_type
+  # @return [Team] Typ des Spielers, der gerade nicht an der Reihe ist.
+  def other_team
     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
@@ -173,11 +103,6 @@ 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
@@ -227,6 +152,6 @@ class GameState
 
   # @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)
+    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,77 @@
 
 # Ein Spielstein mit Ausrichtung, Koordinaten und Farbe
 class Piece
-  # @!attribute [r] Farbe
+  # @!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
   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)

data/lib/software_challenge_client/protocol.rb

@@ -2,8 +2,8 @@
 # frozen_string_literal: true
 require 'socket'
 require_relative 'board'
-require_relative 'set_move'
-require_relative 'skip_move'
+require_relative 'move'
+require_relative 'piece_type'
 require_relative 'player'
 require_relative 'network'
 require_relative 'client_interface'
@@ -61,26 +61,23 @@ class Protocol
     case name
     when 'board'
       logger.debug @gamestate.board.to_s
-    when 'color'
-      if @context[:color] == :valid_colors
-        @gamestate.valid_colors << Color.to_a.find {|s| s.key == @context[:last_text].to_sym }
+    when 'startTeam'
+      @gamestate.add_player(Player.new(Color::RED, "ONE", 0))
+      @gamestate.add_player(Player.new(Color::BLUE, "TWO", 0))
+      if @context[:last_text] == "ONE"
+        @gamestate.start_team = @gamestate.player_one
+      else
+        @gamestate.start_team = @gamestate.player_two
       end
-    when 'shape'
-      case @context[:piece_target] 
-      when :blue_shapes
-        last = @context[:last_text]
-        arr = PieceShape.to_a
-        shape = arr.find {|s| s.key == @context[:last_text].to_sym }
-        @gamestate.undeployed_blue_pieces << shape
-      when :yellow_shapes
-        shape = PieceShape.to_a.find {|s| s.key == @context[:last_text].to_sym }
-        @gamestate.undeployed_yellow_pieces << shape
-      when :red_shapes
-        shape = PieceShape.to_a.find {|s| s.key == @context[:last_text].to_sym }
-        @gamestate.undeployed_red_pieces << shape
-      when :green_shapes
-        shape = PieceShape.to_a.find {|s| s.key == @context[:last_text].to_sym }
-        @gamestate.undeployed_green_pieces << shape
+    when 'team'
+      @context[:team] = @context[:last_text]
+    when 'int'
+      if @context[:team] == "ONE"
+        logger.info 'Got player one amber'
+        @gamestate.player_one.amber = @context[:last_text].to_i
+      else
+        logger.info 'Got player two amber'
+        @gamestate.player_two.amber = @context[:last_text].to_i
       end
     end
   end
@@ -99,7 +96,7 @@ class Protocol
     when 'data'
       logger.debug "data(class) : #{attrs['class']}"
       @context[:data_class] = attrs['class']
-      if attrs['class'] == 'sc.framework.plugins.protocol.MoveRequest'
+      if attrs['class'] == 'moveRequest'
         @client.gamestate = gamestate
         move = @client.move_requested
         sendString(move_to_xml(move))
@@ -117,85 +114,31 @@ class Protocol
       logger.debug 'new gamestate'
       @gamestate = GameState.new
       @gamestate.turn = attrs['turn'].to_i
-      @gamestate.round = attrs['round'].to_i
-      @gamestate.start_piece = PieceShape.to_a.find {|s| s.key == attrs['startPiece'].to_sym }
+      @gamestate.round = @gamestate.turn / 2
       logger.debug "Round: #{@gamestate.round}, Turn: #{@gamestate.turn}"
-    when 'first'
-      logger.debug 'new first player'
-      player = Player.new(PlayerType::ONE, attrs['displayName'])
-      @gamestate.add_player(player)
-      @context[:player] = player
-      @context[:color] = :one
-    when 'second'
-      logger.debug 'new second player'
-      player = Player.new(PlayerType::TWO, attrs['displayName'])
-      @gamestate.add_player(player)
-      @context[:player] = player
-      @context[:color] = :two
-    when 'validColors'
-      @context[:color] = :valid_colors
-      @gamestate.valid_colors = []
     when 'board'
       logger.debug 'new board'
       @gamestate.board = Board.new()
-    when 'field'
-      x = attrs['x'].to_i
-      y = attrs['y'].to_i
-      color = Color.find_by_key(attrs['content'].to_sym)
-      field = Field.new(x, y, color)
-      @gamestate.board.add_field(field)
-      @context[:piece_target] = :field
-      @context[:field] = field
-    when 'blueShapes'
-      @context[:piece_target] = :blue_shapes
-      @gamestate.undeployed_blue_pieces = []
-    when 'yellowShapes'
-      @context[:piece_target] = :yellow_shapes
-      @gamestate.undeployed_yellow_pieces = []
-    when 'redShapes'
-      @context[:piece_target] = :red_shapes
-      @gamestate.undeployed_red_pieces = []
-    when 'greenShapes'
-      @context[:piece_target] = :green_shapes
-      @gamestate.undeployed_green_pieces = []
+    when 'pieces'
+      @context[:entry] = :pieces
+    when 'coordinates'
+      @context[:x] = attrs['x'].to_i
+      @context[:y] = attrs['y'].to_i
     when 'piece'
-      color = Color.find_by_key(attrs['color'].to_sym)
-      kind = PieceShape.find_by_key(attrs['kind'].to_sym)
-      rotation = Rotation.find_by_key(attrs['rotation'].to_sym)
-      is_flipped = attrs['isFlipped'].downcase == "true"
-      piece = Piece.new(color, kind, rotation, is_flipped, Coordinates.origin)
-      case @context[:piece_target]
-      when :blue_shapes
-        @gamestate.undeployed_blue_pieces << piece
-      when :yellow_shapes
-        @gamestate.undeployed_yellow_pieces << piece
-      when :red_shapes 
-        @gamestate.green_red_pieces << piece
-      when :green_shapes
-        @gamestate.undeployed_green_pieces << piece
-      when :last_move
-        @context[:last_move_piece] = piece
-      else
-        raise "unknown piece target #{@context[:piece_target]}"
-      end
-    when 'lastMove'
-      type = attrs['class']
-      if type == 'skipmove'
-        @gamestate.last_move = SkipMove.new
-      else
-        @context[:last_move_type] = type
-        @context[:piece_target] = :last_move
-      end
-    when 'position'
-      case @context[:piece_target] 
-      when :last_move
-        x = attrs['x'].to_i
-        y = attrs['y'].to_i
-        piece = @context[:last_move_piece]
-        @gamestate.last_move = SetMove.new(Piece.new(piece.color, piece.kind, piece.rotation, piece.is_flipped, Coordinates.new(x, y)))
-      end
-    when 'startColor'
-      @gamestate.start_color = Color::BLUE
+      x = @context[:x]
+      y = @context[:y]
+      team = Team.find_by_key(attrs['team'].to_sym)
+      type = PieceType.find_by_key(attrs['type'].to_sym)
+      count = attrs['count'].to_i
+      field = Field.new(x, y, Piece.new(team.to_c, type, Coordinates.new(x, y), count))
+      @gamestate.board.add_field(field)
+    when 'from'
+      @context[:from] = Coordinates.new(attrs['x'].to_i, attrs['y'].to_i)
+    when 'to'
+      from = @context[:from]
+      @gamestate.last_move = Move.new(Coordinates.new(from.x, from.y), Coordinates.new(attrs['x'].to_i, attrs['y'].to_i))
+    when 'ambers'
+      @context[:entry] = :ambers
     when 'winner'
       # TODO
       # winning_player = parsePlayer(attrs)
@@ -239,28 +182,21 @@ class Protocol
   # @param move [Move] The move to convert to XML.
   def move_to_xml(move)
     builder = Builder::XmlMarkup.new(indent: 2)
+
+    if move.nil?
+      raise 'nil moves are not sendable!'
+    end
+
     # Converting every the move here instead of requiring the Move
     # class interface to supply a method which returns the XML
     # because XML-generation should be decoupled from internal data
     # structures.
-    case move
-    when SetMove
-      builder.data(class: 'sc.plugin2021.SetMove') do |data|
-        data.piece(color: move.piece.color, kind: move.piece.kind, rotation: move.piece.rotation, isFlipped: move.piece.is_flipped) do |piece|
-          piece.position(x: move.piece.position.x, y: move.piece.position.y)
-        end
-        move.hints.each do |hint|
-          data.hint(content: hint.content)
-        end
-      end
-    when SkipMove
-      builder.data(class: 'sc.plugin2021.SkipMove') do |data|
-        data.color(@gamestate.current_color.key.to_s)
-        move.hints.each do |hint|
-          data.hint(content: hint.content)
-        end
-      end
+
+    builder.data(class: 'move') do |d|
+      d.from(x: move.from.x, y: move.from.y)
+      d.to(x: move.to.x, y: move.to.y)
     end
+    
     builder.target!
   end
 end