software_challenge_client 19.1.0 → 20.2.0

data/lib/software_challenge_client/coordinates.rb

@@ -1,17 +0,0 @@
-# coding: utf-8
-# frozen_string_literal: true
-
-# Ein Koordinatenpaar für ein zweidimensionales Koordinatensystem.
-class Coordinates
-
-  # X-Koordinate
-  attr_reader :x
-  # Y-Koordinate
-  attr_reader :y
-
-  # Erstellt ein neues Koordinatenpaar aus X- und Y-Koordinate.
-  def initialize(x, y)
-    @x = x
-    @y = y
-  end
-end

data/lib/software_challenge_client/field_type.rb

@@ -1,30 +0,0 @@
-# encoding: utf-8
-
-require 'typesafe_enum'
-# Der Typ eines Feldes des Spielbrettes. Es gibt folgende Typen:
-# - EMPTY
-# - RED
-# - BLUE
-# - OBSTRUCTED
-#
-# Zugriff z.B. mit FieldType::RED
-class FieldType < TypesafeEnum::Base
-  new :EMPTY, '~'
-  new :RED, 'R'
-  new :BLUE, 'B'
-  new :OBSTRUCTED, 'O'
-
-  # @param field_type [FieldType] Der Feldtyp, zu dem die Spielerfarbe ermittelt werden soll.
-  # @return [PlayerColor] Die zum Feldtyp gehörende Spielerfarbe, also PlayerColor::RED für FieldType::RED und PlayerColor::BLUE für FieldType::BLUE. In allen anderen Fällen PlayerColor::NONE.
-  # @see PlayerColor#field_type
-  def self.player_color(field_type)
-    case field_type
-    when FieldType::RED
-      PlayerColor::RED
-    when FieldType::BLUE
-      PlayerColor::BLUE
-    else
-      PlayerColor::NONE
-    end
-  end
-end

data/lib/software_challenge_client/line.rb

@@ -1,126 +0,0 @@
-# coding: utf-8
-# frozen_string_literal: true
-
-require_relative './util/constants'
-require_relative 'direction'
-require_relative 'coordinates'
-require_relative 'line_direction'
-
-# Ein Iterator, der alle Koordinatenpaare auf einer Linie des Spielbrettes enthält.
-class Line
-  include Enumerable
-  include Constants
-
-  # Erzeugt einen neuen Iterator.
-  #
-  # @param start [Coordinates]
-  # @param direction [LineDirection]
-  def initialize(start, direction)
-    @direction = direction
-    @start = start
-    # we will iterate from left to right, so find the leftmost field on the line
-    # inside the field note that (0,0) is the lowest, leftmost point, x-axis
-    # goes to the right, y-axis goes up
-    case @direction
-    when LineDirection::HORIZONTAL
-      leftmost_x = 0
-      leftmost_y = @start.y
-    when LineDirection::VERTICAL
-      leftmost_x = @start.x
-      leftmost_y = SIZE - 1
-    when LineDirection::RISING_DIAGONAL
-      # for rising diagonals, we have to decrease x and y
-      shift = [@start.x, @start.y].min
-      leftmost_x = @start.x - shift
-      leftmost_y = @start.y - shift
-    when LineDirection::FALLING_DIAGONAL
-      # for falling diagonals, we have to decrease x and increase y
-      shift = [@start.x, (SIZE - 1) - @start.y].min
-      leftmost_x = @start.x - shift
-      leftmost_y = @start.y + shift
-    end
-    @xi = leftmost_x
-    @yi = leftmost_y
-
-    @members = []
-    while @xi >= 0 && @yi >= 0 && @xi < SIZE && @yi < SIZE
-      @members << Coordinates.new(@xi, @yi)
-      # horizontal lines and diagonals move right
-      if [LineDirection::HORIZONTAL,
-          LineDirection::RISING_DIAGONAL,
-          LineDirection::FALLING_DIAGONAL].include? @direction
-        @xi += 1
-      end
-      # vertical lines and falling diagonals move down
-      if [LineDirection::VERTICAL,
-          LineDirection::FALLING_DIAGONAL].include? @direction
-        @yi -= 1
-      elsif @direction == LineDirection::RISING_DIAGONAL
-        # rising diagonals move up
-        @yi += 1
-      end
-    end
-  end
-
-  def each(&block)
-    @members.each(&block)
-  end
-
-  # Begrenzt den Iterator auf Koordinatenpaare von Feldern innerhalb der gegebenen beiden Koordinatenpaare (exklusive).
-  # Kann als Filter verwendet werden.
-  #
-  # @example
-  #   Line.new(
-  #     Coordinates.new(2, 3), LineDirection::HORIZONTAL
-  #   ).select do |c|
-  #     Line.between(Coordinates.new(2, 3), Coordinates.new(5, 3), LineDirection::HORIZONTAL).call(c)
-  #   end
-  def self.between(start, bound, direction)
-    lower_x = [start.x, bound.x].min
-    lower_y = [start.y, bound.y].min
-    higher_x = [start.x, bound.x].max
-    higher_y = [start.y, bound.y].max
-    proc do |f|
-      case direction
-      when LineDirection::HORIZONTAL
-        f.x > lower_x && f.x < higher_x
-      when LineDirection::VERTICAL
-        f.y > lower_y && f.y < higher_y
-      when LineDirection::RISING_DIAGONAL, LineDirection::FALLING_DIAGONAL
-        f.x > lower_x && f.x < higher_x && f.y > lower_y && f.y < higher_y
-      else
-        throw `unknown direction ${direction}`
-      end
-    end
-  end
-
-  # @param line_direction [LineDirection] Ausrichtung der Linie
-  # @return [Array<Direction>] Die beiden Bewegungsrichtungen, die auf einer Linie mit der Ausrichtung möglich sind.
-  def self.directions_for_line_direction(line_direction)
-    case line_direction
-    when LineDirection::HORIZONTAL
-      [Direction::LEFT, Direction::RIGHT]
-    when LineDirection::VERTICAL
-      [Direction::UP, Direction::DOWN]
-    when LineDirection::RISING_DIAGONAL
-      [Direction::UP_RIGHT, Direction::DOWN_LEFT]
-    when LineDirection::FALLING_DIAGONAL
-      [Direction::UP_LEFT, Direction::DOWN_RIGHT]
-    end
-  end
-
-  # @param line_direction [Direction] Bewegungsrichtung
-  # @return [Array<Direction>] Die Ausrichtung einer Linie, die auf der Bewegungsrichtung liegt.
-  def self.line_direction_for_direction(direction)
-    case direction
-    when Direction::LEFT, Direction::RIGHT
-      LineDirection::HORIZONTAL
-    when Direction::UP, Direction::DOWN
-      LineDirection::VERTICAL
-    when Direction::UP_RIGHT, Direction::DOWN_LEFT
-      LineDirection::RISING_DIAGONAL
-    when Direction::UP_LEFT, Direction::DOWN_RIGHT
-      LineDirection::FALLING_DIAGONAL
-    end
-  end
-end

data/lib/software_challenge_client/move.rb

@@ -1,84 +0,0 @@
-# encoding: utf-8
-require_relative 'debug_hint'
-
-# Ein Spielzug. Er ist definiert durch das Koordinatenpaar des Ausgangsfeldes (ein Fisch des Spielers, der den Zug machen will) und eine Bewegungsrichtung.
-class Move
-  # @!attribute [r] x
-  # @return [Integer] X-Koordinate des Fisches, der bewegt werden soll. Die Spalte ganz links auf dem Spielbrett hat X-Koordinate 0, die ganz rechts 9.
-  attr_reader :x
-
-  # @!attribute [r] y
-  # @return [Integer] Y-Koordinate des Fisches, der bewegt werden soll. Die Zeile ganz unten auf dem Spielbrett hat Y-Koordinate 0, die ganz oben 9.
-  attr_reader :y
-
-  # @!attribute [r] direction
-  #
-  # @return [Direction] Die Richtung, in die bewegt werden soll.
-  attr_reader :direction
-
-  # @!attribute [r] hints
-  # @return [Array<DebugHint>] Hinweise, die an den Zug angeheftet werden sollen. Siehe {DebugHint}.
-  attr_reader :hints
-
-  # Erstellt einen neuen Zug.
-  # @param x [Integer]
-  # @param y [Integer]
-  # @param direction [Direction]
-  def initialize(x, y, direction)
-    @x = x
-    @y = y
-    @direction = direction
-    @hints = []
-  end
-
-  # @param hint [DebugHint]
-  def add_hint(hint)
-    @hints.push(hint)
-  end
-
-  def ==(other)
-    x == other.x && y == other.y && direction == other.direction
-  end
-
-  def to_s
-    "Move: (#{x},#{y}) #{direction}"
-  end
-
-  # @return [Coordinates] Die Koordinaten des Ausgangsfeldes des Zuges als Koordinatenpaar.
-  def from_field
-    Coordinates.new(x, y)
-  end
-
-  # Überprüft, ob der Zug in dem gegebenen Spielzustand regelkonform ausgeführt werden kann.
-  # @param gamestate [GameState]
-  # @return [Boolean]
-  def valid?(gamestate)
-    GameRuleLogic.valid_move?(self, gamestate.board, gamestate.current_player_color)
-  end
-
-  # Führt den Zug in dem gegebenen Spielzustand aus. Sollte dabei gegen Spielregeln verstossen werden, wird eine InvalidMoveException geworfen.
-  # @param gamestate [GameState]
-  def perform!(gamestate)
-    if GameRuleLogic.valid_move?(self, gamestate.board, gamestate.current_player_color)
-      type = gamestate.board.field(x, y).type
-      target = GameRuleLogic.move_target(self, gamestate.board)
-      gamestate.board.change_field(x, y, FieldType::EMPTY)
-      gamestate.board.change_field(target.x, target.y, type)
-    else
-      raise InvalidMoveException.new('Invalid move', self)
-    end
-    # change the state to the next turn
-    gamestate.last_move = self
-    gamestate.turn += 1
-    gamestate.switch_current_player
-    gamestate.condition = GameRuleLogic.winning_condition(gamestate)
-  end
-
-
-  # Ermittelt die Koordinaten des Zielfeldes des Zuges mit einer gegebenen Zugweite.
-  # @param speed [Integer] Die Zugweite. Entspricht normalerweise der Anzahl der Fische auf der Bewegungslinie.
-  # @return [Coordinates] Koordinaten des Zielfeldes. Eventuell ausserhalb des Spielbrettes.
-  def target_field(speed)
-    direction.translate(from_field, speed)
-  end
-end