software_challenge_client 22.1.0.1 → 23.0.2

data/lib/software_challenge_client/game_rule_logic.rb

@@ -1,141 +1,206 @@
-# frozen_string_literal: true
-
-require_relative './util/constants'
-require_relative 'invalid_move_exception'
-require_relative 'move'
-
-require 'set'
-
-# 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.
-class GameRuleLogic
-  include Constants
-
-  SUM_MAX_SQUARES = 89
-
-  # --- Possible Moves ------------------------------------------------------------
-
-  # 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)
-    moves = []
-    fields = gamestate.board.fields_of_color(gamestate.current_player.color)
-
-    fields.each do |f|
-      moves.push(*moves_for_piece(gamestate, f.piece))
-    end
-
-    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
-
-  # Hilfsmethode um Legezüge für einen [Piece] zu berechnen.
-  # @param gamestate [GameState] Der zu untersuchende Spielstand.
-  # @param piece [Piece] Der Typ des Spielsteines
-  #
-  # @return [Array<Move>] Die möglichen Moves
-  def self.moves_for_piece(gamestate, piece)
-    moves = Set[]
-    piece.target_coords.each do |c| 
-      moves << Move.new(piece.position, c)
-    end
-    moves.select { |m| valid_move?(gamestate, m) }.to_a
-  end
-
-  # --- Move Validation ------------------------------------------------------------
-
-  # Prüft, ob der gegebene [Move] zulässig ist.
-  # @param gamestate [GameState] Der zu untersuchende Spielstand.
-  # @param move [Move] Der zu überprüfende Zug
-  #
-  # @return ob der Zug zulässig ist
-  def self.valid_move?(gamestate, move)
-    return false unless gamestate.current_player.color == move.piece(gamestate).color
-
-    return false unless gamestate.board.in_bounds?(move.to)
-
-    return false if gamestate.board.field_at(move.to).color == move.piece(gamestate).color
-
-    return false unless move.piece(gamestate).target_coords.include? move.to
-
-    # TODO 2022: Forgot checks?
-
-    true
-  end
-
-  # Ü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.field_at(position).empty?
-  end
-
-  # --- Perform Move ------------------------------------------------------------
-
-  # 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)
-
-    from_field = gamestate.board.field_at(move.from)
-    to_field = gamestate.board.field_at(move.to)
-
-    # Update board pieces if one is stepped on
-    if not to_field.empty?
-      from_field.piece.height = from_field.piece.height + 1
-
-      # 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.last_move = move
-  end
-
-  # --- Other ------------------------------------------------------------
-
-  # 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)
-    if gamestate.player_one.amber >= 2
-      Condition.new(gamestate.player_one, "Spieler 1 hat 2 Bernsteine erreicht")
-    end
-
-    if gamestate.player_two.amber >= 2
-      Condition.new(gamestate.player_two, "Spieler 2 hat 2 Bernsteine erreicht")
-    end
-
-    nil
-  end
-end
+# frozen_string_literal: true
+
+require_relative './util/constants'
+require_relative 'invalid_move_exception'
+require_relative 'move'
+
+require 'set'
+
+# 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.
+class GameRuleLogic
+  include Constants
+
+  SUM_MAX_SQUARES = 89
+
+  # --- Possible Moves ------------------------------------------------------------
+
+  # 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)
+    if gamestate.turn < 8
+      self.possible_setmoves(gamestate)
+    else
+      self.possible_normalmoves(gamestate)
+    end
+  end
+
+  # Gibt alle möglichen Lege-Züge für den Spieler zurück, der in der gamestate dran ist.
+  # @param gamestate [GameState] Der zu untersuchende Spielstand.
+  #
+  # @return [Array<Move>] Die möglichen Moves
+  def self.possible_setmoves(gamestate)
+    moves = []
+
+    (0...BOARD_SIZE).to_a.map do |x|
+      (0...BOARD_SIZE).to_a.map do |y|
+        if gamestate.board.field(x, y).fishes == 1
+          moves.push(Move.new(nil, Coordinates.new(x, y)))
+        end
+      end
+    end
+
+    moves
+  end
+
+  def self.possible_normalmoves(gamestate)
+    moves = []
+    fields = gamestate.board.fields_of_team(gamestate.current_player.team)
+
+    fields.each do |f|
+      moves.push(*moves_for_piece(gamestate, f.piece))
+    end
+
+    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)
+    self.possible_moves(gamestate).sample
+  end
+
+  # Hilfsmethode um Legezüge für einen [Piece] zu berechnen.
+  # @param gamestate [GameState] Der zu untersuchende Spielstand.
+  # @param piece [Piece] Der Typ des Spielsteines
+  #
+  # @return [Array<Move>] Die möglichen Moves
+  def self.moves_for_piece(gamestate, piece)
+    moves = Set[]
+    self.target_coords(gamestate, piece).each do |c| 
+      moves << Move.new(piece.coords, c)
+    end
+    moves.select { |m| valid_move?(gamestate, m) }.to_a
+  end
+
+  # Berechnet die Koordinaten zu denen sich dieser Spielstein bewegen könnte.
+  #
+  # @return [Array<Coordinates>] Die Zielkoordinaten 
+  def self.target_coords(gamestate, piece)
+    coords = []
+    c = Coordinates.oddr_to_doubled(piece.coords)
+
+    Direction.each { |d|
+      x = c.x
+      y = c.y
+      disp = d.to_vec()
+
+      # doubled taversal
+      for i in 0..8 do
+        x += disp.x
+        y += disp.y
+        
+        oddr_coords = Coordinates.doubled_to_oddr_int(x, y)
+        if !gamestate.board.in_bounds?(oddr_coords) || !gamestate.board.field_at(oddr_coords).free?
+          break
+        end
+
+        coords.push(oddr_coords)
+      end
+    }
+
+    coords
+  end
+
+  # --- Move Validation ------------------------------------------------------------
+
+  # Prüft, ob der gegebene [Move] zulässig ist.
+  # @param gamestate [GameState] Der zu untersuchende Spielstand.
+  # @param move [Move] Der zu überprüfende Zug
+  #
+  # @return ob der Zug zulässig ist
+  def self.valid_move?(gamestate, move)
+    if gamestate.turn < 8
+      # Setmove
+
+      # Must be setmove
+      return false unless move.from == nil
+      
+      # Must have 1 fish to set on
+      return false unless gamestate.board.field_at(move.to).fishes == 1 
+
+      # Must have no piece on it
+      return false unless gamestate.board.field_at(move.to).piece == nil
+    else
+      # Normal move
+
+      # Must be normal move
+      return false unless !move.from.nil?
+
+      # Team must be correct
+      return false unless gamestate.current_player.team == gamestate.board.field_at(move.from).piece.team
+
+      # Move must stay in bounds
+      return false unless gamestate.board.in_bounds?(move.to)
+
+      # Move must go onto free field
+      return false unless gamestate.board.field_at(move.to).free?
+
+      # Move must go onto valid coords
+      return false unless self.target_coords(gamestate, gamestate.board.field_at(move.from).piece).include?(move.to)
+    end
+
+    # TODO 2023: Forgot checks?
+
+    true
+  end
+
+  # --- Perform Move ------------------------------------------------------------
+
+  # 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)
+
+    target_field = gamestate.board.field_at(move.to)
+
+    gamestate.current_player.fishes += target_field.fishes
+
+    if gamestate.turn < 8 
+      target_field.piece = Piece.new(gamestate.current_player.team, move.to)
+    else
+      start_field = gamestate.board.field_at(move.from)
+
+      start_field.fishes = 0
+
+      target_field.piece = start_field.piece
+      start_field.piece = nil?
+    end
+
+    other_player = gamestate.not_player(gamestate.current_player)
+    if gamestate.can_move?(other_player)
+      gamestate.current_player = other_player
+    end
+
+    gamestate.turn += 1
+  end
+
+  # --- Other ------------------------------------------------------------
+
+  # 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)
+    
+    if GameRuleLogic.possible_moves(gamestate).count == 0
+      if gamestate.player_one.fishes > gamestate.player_two.fishes
+        Condition.new(gamestate.player_one, "Spieler 1 hat mehr Fische erreicht und gewonnen!")
+      else
+        Condition.new(gamestate.player_one, "Spieler 2 hat mehr Fische erreicht und gewonnen!")
+      end
+    end
+
+    nil
+  end
+end

data/lib/software_challenge_client/game_state.rb

@@ -4,7 +4,6 @@ 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.
@@ -24,18 +23,21 @@ 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] start_player
+  # @return [Player] Der Spieler der zuerst zieht
+  attr_accessor :start_player
 
   # @!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] current_player
+  # @return [Player] Der Spieler, der akutell dran ist
+  attr_accessor :current_player
+
+  # @!attribute [rw] myself_player
+  # @return [Player] Der Spieler, der von diesem Skript gesteuert wird
+  attr_accessor :myself_player
 
   # @!attribute [rw] condition
   # @return [Condition] Gewinner und Gewinngrund, falls das Spiel bereits
@@ -57,22 +59,26 @@ class GameState
   #
   # @param player [Player] Der hinzuzufügende Spieler.
   def add_player(player)
-    case player.color
-    when Color::RED
+    case player.team
+    when Team::ONE
       @player_one = player
-    when Color::BLUE
+    when Team::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
+    current_player == player_one ? player_two : player_one
+  end
+
+  # @return [Player] Der Spieler, der nicht p ist.
+  def not_player(p)
+    if p == player_one
+      player_two
+    else
+      player_one
+    end
   end
 
   # @return [Team] Typ des Spielers, der gerade nicht an der Reihe ist.
@@ -80,13 +86,25 @@ class GameState
     other_player.type
   end
 
+  # Findet den Spieler für ein Team.
+  #
+  # @param team [Team] Das Team
+  # @return [Player] Der zugehörige Spieler
+  def player_from_team(team)
+    if team == Team::ONE
+      @player_one
+    else
+      @player_two
+    end
+  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?
+  def is_first_round?
     round == 1
   end
 
@@ -98,6 +116,21 @@ class GameState
     GameRuleLogic.perform_move(self, move)
   end
 
+  # Überprüft ob der gegebene Spieler ziehen könnte oder blockiert ist
+  #
+  # @param player [Player] Der Spieler.
+  # @return [Boolean] true, falls der Spieler ziehen könnte
+  def can_move?(player)
+    can = false
+
+    for f in board.fields_of_team(player.team) do
+      n = board.neighbors_of(f)
+      can &= n.any? { |x| x.free? }
+    end
+
+    can
+  end
+
   # @return [Boolean] true, falls das Spiel bereits geendet hat, false bei noch
   #                   laufenden Spielen.
   def game_ended?
@@ -121,15 +154,15 @@ class GameState
   #
   # @param player [Player] Der Spieler, dessen Punkte berechnet werden sollen.
   # @return [Integer] Die Punkte des Spielers
-  def points_for_player(_player)
-    # TODO
-    -1
+  def points_for_player(player)
+    player.nil? ? 0 : player.fishes
   end
 
+  # TODO: Fix
   def ==(other)
     turn == other.turn &&
-      start_color == other.start_color &&
-      current_color == other.current_color &&
+      myself_player == other.myself_player &&
+      current_player == other.current_player &&
       blue == other.blue &&
       yellow == other.yellow &&
       red == other.red &&
@@ -148,6 +181,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_player.color)
+    board.fields_of_team(current_player.team)
   end
 end

data/lib/software_challenge_client/invalid_move_exception.rb

@@ -1,15 +1,15 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-# Exception, die geworfen wird, wenn ein ungültiger Zug ausgeführt wird.
-# @see GameRuleLogic#perform_move
-class InvalidMoveException < StandardError
-  def initialize(msg, move)
-    @move = move
-    super(msg)
-  end
-
-  def to_s
-    "#{super}: #{@move}"
-  end
-end
+# encoding: utf-8
+# frozen_string_literal: true
+
+# Exception, die geworfen wird, wenn ein ungültiger Zug ausgeführt wird.
+# @see GameRuleLogic#perform_move
+class InvalidMoveException < StandardError
+  def initialize(msg, move)
+    @move = move
+    super(msg)
+  end
+
+  def to_s
+    "#{super}: #{@move}"
+  end
+end

data/lib/software_challenge_client/logging.rb

@@ -1,26 +1,26 @@
-# coding: utf-8
-# frozen_string_literal: true
-require 'logger'
-
-# Dieses Modul kann inkludiert werden, um eine Logausgabe auf der Konsole verwenden zu können.
-# See http://stackoverflow.com/a/6768164/390808
-#
-# Verwendung:
-#
-#   class MyClass
-#     include Logging
-#
-#     def a_method(x)
-#       logger.debug "you provided #{x}"
-#     end
-#   end
-module Logging
-  def logger
-    Logging.logger
-  end
-
-  # Global, memoized, lazy initialized instance of a logger
-  def self.logger
-    @logger ||= Logger.new(STDOUT)
-  end
-end
+# coding: utf-8
+# frozen_string_literal: true
+require 'logger'
+
+# Dieses Modul kann inkludiert werden, um eine Logausgabe auf der Konsole verwenden zu können.
+# See http://stackoverflow.com/a/6768164/390808
+#
+# Verwendung:
+#
+#   class MyClass
+#     include Logging
+#
+#     def a_method(x)
+#       logger.debug "you provided #{x}"
+#     end
+#   end
+module Logging
+  def logger
+    Logging.logger
+  end
+
+  # Global, memoized, lazy initialized instance of a logger
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+end

data/lib/software_challenge_client/move.rb

@@ -1,41 +1,37 @@
-# 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
+# frozen_string_literal: true
+
+# Ein Move repräsentiert eine Bewegung eines Steins auf dem Spielbrett
+class Move
+  # @!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
+  end
+
+  # TODO: Remove these?
+  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