software_challenge_client 19.1.0 → 20.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5eac2f41124e1ee9f61d00d598895df4dd553c2c
-  data.tar.gz: 3d2d15d84c9363fe171a7a127998b7b673388508
+SHA256:
+  metadata.gz: 5f9c0fc11c46d62fc8f289da4a17ec7b1bde4af3b8b4a678a213f4ad663f2ff2
+  data.tar.gz: aac39e99052feb22f58929f8a7271ff4ce412910fd4bdb9ee41a72bab59a4499
 SHA512:
-  metadata.gz: f5ab4676a7e0a78e5c3a099a03b3983bcbb5a3a9a32386a89dff18b85f9a266ef896206541cedcf6bd870d2eaf416cc6191f47d3643c6ab32a34b0869d6b8b47
-  data.tar.gz: 02a1405157463238828852063aeab0da67c34ed2d2265fc21c7b830762d06d00699657db6fc0a15fae532190fe92d123c65777ae5781b44116c79e36b4061f2b
+  metadata.gz: 31e76449052b5ffc665bb5d4e62f26fdeda42a982aefc701e00aa22759d6467b0bbd0ef8dc50c31733d38a91ef3fa99b7a7413d7f67dffbc58145be92c5ec3e0
+  data.tar.gz: 32a796bf7bbf4e91163abc90bb9686bf5027ca0f669b27d3b408f62c75bc8064886f03abad706f47ecd4dcb3c6e7255e1517f53352792b6af84addeeb81f84c6

data/.ruby-version

@@ -1 +1 @@
-2.4.1
+2.6.5

data/.stickler.yml

@@ -0,0 +1,7 @@
+linters:
+  rubocop:
+    fixer: true
+  shellcheck:
+    shell: bash
+fixers:
+  enable: true

data/RELEASES.md

@@ -1,3 +1,7 @@
+= 20.2.0
+
+First version for game "Hive"
+
 = 19.1.0
 
 - winning condition is now set when changing a gamestate with Move#perform!

data/example/client.rb

@@ -16,12 +16,23 @@ class Client < ClientInterface
   # gets called, when it's your turn
   def move_requested
     logger.info "Spielstand: #{gamestate.points_for_player(gamestate.current_player)} - #{gamestate.points_for_player(gamestate.other_player)}"
+    logger.debug "Board: #{gamestate.board.to_s}"
     move = best_move
     logger.debug "Zug gefunden: #{move}" unless move.nil?
     move
   end
 
   def best_move
-    gamestate.possible_moves.sample
+    #gamestate.board.add_field(Field.new(5, 0))
+    logger.debug "Berechne zuege fuer Board #{gamestate.board.to_s}"
+    logger.debug "Felder"
+    gamestate.board.field_list.each do |f|
+      if !f.empty?
+        logger.debug "Feld (#{f.x}, #{f.y}) #{f.obstructed ? 'OO' : f.pieces.last.to_s}"
+      end
+    end
+    possible_moves = GameRuleLogic.possible_moves(gamestate)
+    logger.debug "#{possible_moves.size} moegliche Zuege gefunden"
+    possible_moves.sample
   end
 end

data/lib/software_challenge_client.rb

@@ -8,9 +8,12 @@ module SoftwareChallengeClient
   require 'software_challenge_client/condition'
   require 'software_challenge_client/debug_hint'
   require 'software_challenge_client/field'
-  require 'software_challenge_client/field_type'
+  require 'software_challenge_client/piece'
+  require 'software_challenge_client/piece_type'
   require 'software_challenge_client/game_state'
-  require 'software_challenge_client/move'
+  require 'software_challenge_client/set_move'
+  require 'software_challenge_client/drag_move'
+  require 'software_challenge_client/skip_move'
   require 'software_challenge_client/network'
   require 'software_challenge_client/player'
   require 'software_challenge_client/player_color'
@@ -18,6 +21,5 @@ module SoftwareChallengeClient
   require 'software_challenge_client/runner'
   require 'software_challenge_client/game_rule_logic'
   require 'software_challenge_client/direction'
-  require 'software_challenge_client/line_direction'
-  require 'software_challenge_client/coordinates'
+  require 'software_challenge_client/cube_coordinates'
 end

data/lib/software_challenge_client/board.rb

@@ -3,69 +3,78 @@
 
 require_relative './util/constants'
 require_relative 'game_state'
-require_relative 'field_type'
 require_relative 'field'
 
-# Ein Spielbrett bestehend aus 10x10 Feldern.
+# Ein Spielbrett fuer Hive
 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 Koordinaten im Array gespeichert.
+  #   seiner x und y CubeCoordinates im Array gespeichert.
   attr_reader :fields
 
+  def self.field_amount(radius)
+    return 1 if radius == 1
+    (radius - 1) * 6 + Board.field_amount(radius - 1)
+  end
+
+  FIELD_AMOUNT = Board.field_amount((BOARD_SIZE + 1)/2)
+
   # Erstellt ein neues leeres Spielbrett.
-  def initialize
-    @fields = []
-    (0..9).to_a.each do |y|
-      @fields[y] = []
-      (0..9).to_a.each do |x|
-        @fields[y][x] = Field.new(x, y, FieldType::EMPTY)
+  def initialize(fields = [])
+    @fields = Board.empty_game_field
+    fields.each{ |f| add_field(f) }
+  end
+
+  def self.empty_game_field
+    fields = []
+    (-SHIFT..SHIFT).to_a.each do |x|
+      fields[x + SHIFT] ||= []
+      ([-SHIFT, -x-SHIFT].max..[SHIFT, -x+SHIFT].min).to_a.each do |y|
+        fields[x + SHIFT][y + SHIFT] = Field.new(x, y)
       end
     end
+    fields
+  end
+
+  def clear
+    @fields = []
+  end
+
+  def field_list
+    @fields.flatten.select{ |e| !e.nil? }
   end
 
   # Vergleicht zwei Spielbretter. Gleichheit besteht, wenn zwei Spielbretter die
   # gleichen Felder enthalten.
   def ==(other)
-    fields.each_with_index do |row, y|
-      row.each_with_index do |field, x|
-        return false if field != other.field(x, y)
-      end
-    end
-    true
+    field_list == other.field_list
   end
 
   # Fügt ein Feld dem Spielbrett hinzu. Das übergebene Feld ersetzt das an den Koordinaten bestehende Feld.
   #
   # @param field [Field] Das einzufügende Feld.
   def add_field(field)
-    @fields[field.y][field.x] = field
-  end
-
-  # Ändert den Typ eines bestimmten Feldes des Spielbrettes.
-  #
-  # @param x [Integer] Die X-Koordinate des zu ändernden Feldes. 0..9, wobei Spalte 0 ganz links und Spalte 9 ganz rechts liegt.
-  # @param y [Integer] Die Y-Koordinate des zu ändernden Feldes. 0..9, wobei Zeile 0 ganz unten und Zeile 9 ganz oben liegt.
-  # @param type [FieldType] Der neue Typ des Feldes.
-  def change_field(x, y, type)
-    @fields[y][x].type = type
+    @fields[field.x + SHIFT][field.y + SHIFT] = field
   end
 
   # Zugriff auf die Felder des Spielfeldes
   #
-  # @param x [Integer] Die X-Koordinate des Feldes. 0..9, wobei Spalte 0 ganz links und Spalte 9 ganz rechts liegt.
-  # @param y [Integer] Die Y-Koordinate des Feldes. 0..9, wobei Zeile 0 ganz unten und Zeile 9 ganz oben liegt.
-  # @return [Field] Das Feld mit den gegebenen Koordinaten. Falls das Feld nicht
-  #   exisitert (weil die Koordinaten ausserhalb von (0,0)..(9,9) liegen), wird nil zurückgegeben.
+  # @param x [Integer] Die X-Koordinate des Feldes.
+  # @param y [Integer] Die Y-Koordinate des Feldes.
+  # @return [Field] Das Feld mit den gegebenen Koordinaten. Falls das Feld nicht exisitert, wird nil zurückgegeben.
   def field(x, y)
-    return nil if x.negative? || y.negative?
-    fields.dig(y, x) # NOTE that #dig requires ruby 2.3+
+    return nil if (x < -SHIFT) || (y < -SHIFT)
+    fields.dig(x + SHIFT, y + SHIFT) # NOTE that #dig requires ruby 2.3+
   end
 
   # Zugriff auf die Felder des Spielfeldes über ein Koordinaten-Paar.
   #
-  # @param coordinates [Coordinates] X- und Y-Koordinate als Paar, sonst wie bei {Board#field}.
+  # @param coordinates [CubeCoordinates] X- und Y-Koordinate als Paar, sonst wie
+  # bei {Board#field}.
+  #
   # @return [Field] Wie bei {Board#field}.
   #
   # @see #field
@@ -73,21 +82,31 @@ class Board
     field(coordinates.x, coordinates.y)
   end
 
-  # Liefert alle Felder eines angegebenen Typs des Spielbrettes.
+  # Liefert alle Felder die dem Spieler mit der gegebenen Farbe gehoeren
   #
-  # @param field_type [FieldType] Der Typ, dessen Felder zurückgegeben werden sollen.
-  # @return [Array<Field>] Alle Felder des angegebenen Typs die das Spielbrett enthält.
-  def fields_of_type(field_type)
-    fields.flatten.select{ |f| f.type == field_type }
+  # @param color [PlayerColor] Die Spielerfarbe
+  # @return [Array<Field>] Alle Felder der angegebenen Farbe die das Spielbrett enthält.
+  def fields_of_color(color)
+    field_list.select{ |f| f.color == color }
+  end
+
+  def pieces
+    field_list.map(&:pieces).flatten
+  end
+
+  def deployed_pieces(color)
+    pieces.select { |p| p.color == color }
+  end
+
+  def clone
+    Marshal.load(Marshal.dump(self))
   end
 
   # Gibt eine textuelle Repräsentation des Spielbrettes aus. Hier steht R für
   # einen roten Fisch, B für einen blauen, ~ für ein leeres Feld und O für ein
   # Kraken-Feld.
   def to_s
-    fields.reverse.map do |row|
-      row.map { |f| f.type.value }.join(' ')
-    end.join("\n")
+    field_list.sort_by(&:z).map{ |f| f.obstructed ? 'OO' : f.empty? ? '--' : f.pieces.last.to_s }.join
   end
 
 end

data/lib/software_challenge_client/cube_coordinates.rb

@@ -0,0 +1,23 @@
+class CubeCoordinates
+
+  attr_reader :x, :y, :z
+
+  def initialize(x, y, z = nil)
+    @x = x
+    @y = y
+    @z = z.nil? ? -x - y : z
+    throw InvalidArgumentException("sum of coordinates #{@x}, #{@y}, #{@z} have to be equal 0") if @x + @y + @z != 0
+  end
+
+  def ==(other)
+    x == other.x && y == other.y && z == other.z
+  end
+
+  def to_s
+    "(#{x}, #{y}, #{z})"
+  end
+
+  def inspect
+    to_s
+  end
+end

data/lib/software_challenge_client/direction.rb

@@ -2,24 +2,20 @@
 
 require 'typesafe_enum'
 
-# Die acht möglichen Bewegungsrichtungen auf dem Spielbrett. Die Richtungen sind:
+# Die sechs möglichen Bewegungsrichtungen auf dem Spielbrett. Die Richtungen sind:
 #
-# - UP
 # - UP_RIGHT
 # - RIGHT
 # - DOWN_RIGHT
-# - DOWN
 # - DOWN_LEFT
 # - LEFT
 # - UP_LEFT
 #
 # Zugriff erfolgt z.B. durch Direction::UP_RIGHT.
 class Direction < TypesafeEnum::Base
-  new :UP
   new :UP_RIGHT
   new :RIGHT
   new :DOWN_RIGHT
-  new :DOWN
   new :DOWN_LEFT
   new :LEFT
   new :UP_LEFT
@@ -28,26 +24,32 @@ class Direction < TypesafeEnum::Base
   # entsprechende Richtung. Der resultierende Punkt kann ausserhalb des
   # Spielbrettes liegen. Dies kann mit {GameRuleLogic#inside_bounds?} geprüft
   # werden.
-  # @param coordinates [Coordinates] Das zu verschiebende Koordinatenpaar.
+  # @param coordinates [CubeCoordinates] Das zu verschiebende Koordinatenpaar.
   # @param distance [Integer] Um wieviele Felder in die Richtung verschoben werden soll.
-  def translate(coordinates, distance = 1)
-    case key
-    when :UP
-      Coordinates.new(coordinates.x, coordinates.y + distance)
-    when :UP_RIGHT
-      Coordinates.new(coordinates.x + distance, coordinates.y + distance)
+  def translate(start, distance = 1)
+    shiftX = start.x
+    shiftY = start.y
+    shiftZ = start.z
+    case self.key
     when :RIGHT
-      Coordinates.new(coordinates.x + distance, coordinates.y)
-    when :DOWN_RIGHT
-      Coordinates.new(coordinates.x + distance, coordinates.y - distance)
-    when :DOWN
-      Coordinates.new(coordinates.x, coordinates.y - distance)
-    when :DOWN_LEFT
-      Coordinates.new(coordinates.x - distance, coordinates.y - distance)
+      shiftX = start.x + distance
+      shiftY = start.y - distance
     when :LEFT
-      Coordinates.new(coordinates.x - distance, coordinates.y)
+      shiftX = start.x - distance
+      shiftY = start.y + distance
+    when :UP_RIGHT
+      shiftX = start.x + distance
+      shiftZ = start.z - distance
     when :UP_LEFT
-      Coordinates.new(coordinates.x - distance, coordinates.y + distance)
+      shiftY = start.y + distance
+      shiftZ = start.z - distance
+    when :DOWN_RIGHT
+      shiftY = start.y - distance
+      shiftZ = start.z + distance
+    when :DOWN_LEFT
+      shiftX = start.x - distance
+      shiftZ = start.z + distance
     end
+    return CubeCoordinates.new(shiftX, shiftY, shiftZ)
   end
 end

data/lib/software_challenge_client/drag_move.rb

@@ -0,0 +1,19 @@
+require_relative 'has_hints'
+
+class DragMove
+
+  include HasHints
+
+  attr_reader :start
+  attr_reader :destination
+
+  def initialize(start, destination)
+    @start = start
+    @destination = destination
+    @hints = []
+  end
+
+  def to_s
+    "[Move: Drag from #{start} to #{destination}]"
+  end
+end

data/lib/software_challenge_client/field.rb

@@ -1,45 +1,82 @@
 # encoding: UTF-8
-require_relative 'field_type'
 
 # Ein Feld des Spielfelds. Ein Spielfeld ist durch die Koordinaten eindeutig identifiziert.
 # Das type Attribut gibt an, um welchen Feldtyp es sich handelt
 class Field
-  # @!attribute [rw] type
-  # @return [FieldType] der Typ des Feldes
-  attr_accessor :type
-  # @!attribute [r] x
-  # @return [Integer] die X-Koordinate des Feldes (0 bis 9, 0 ist ganz links, 9 ist ganz rechts)
-  attr_reader :x
-  # @!attribute [r] y
-  # @return [Integer] die Y-Koordinate des Feldes (0 bis 9, 0 ist ganz unten, 9 ist ganz oben)
-  attr_reader :y
+  # @!attribute [rw] pieces
+  # @return [Array<Piece>] Spielsteine auf dem Feld, beginnend beim untersten Stein
+  attr_accessor :pieces
+  # @!attribute [r] coordinates
+  # @return [CubeCoordinates] die Cube-Coordinates des Feldes
+  attr_reader :coordinates
+  # @!attribute [r] obstructed
+  # @return [Boolean] ob das Feld durch eine Brombeere blockiert ist
+  attr_reader :obstructed
 
   # Konstruktor
   #
   # @param type [FieldType] Feldtyp
   # @param x [Integer] X-Koordinate
   # @param y [Integer] Y-Koordinate
-  def initialize(x, y, type)
-    @type = type
-    @x = x
-    @y = y
+  # @param pieces [Array<Piece>] Spielsteine auf dem Feld
+  # @param obstructed [Boolean] Ob das Feld blockiert ist (Brombeere)
+  def initialize(x, y, pieces = [], obstructed = false)
+    @pieces = pieces
+    @coordinates = CubeCoordinates.new(x, y)
+    @obstructed = obstructed
   end
 
   # Vergleicht zwei Felder. Felder sind gleich, wenn sie gleiche Koordinaten und gleichen Typ haben.
   # @return [Boolean] true bei Gleichheit, false sonst.
   def ==(other)
-    type == other.type &&
-      x == other.x &&
-      y == other.y
+    coordinates == other.coordinates &&
+      obstructed == other.obstructed &&
+      pieces == other.pieces
   end
 
-  # @return [Coordinates] Die Koordinaten des Feldes als Koordinatenpaar.
-  def coordinates
-    Coordinates.new(x, y)
+  def x
+    coordinates.x
+  end
+
+  def y
+    coordinates.y
+  end
+
+  def z
+    coordinates.z
+  end
+
+  def empty?
+    pieces.empty? && !obstructed
+  end
+
+  def obstructed?
+    obstructed
+  end
+
+  def add_piece(piece)
+    pieces.push(piece)
+  end
+
+  def remove_piece
+    pieces.pop
+  end
+
+  def color
+    pieces.last&.color
+  end
+
+  def has_owner
+    !color.nil?
   end
 
   # @return [String] Textuelle Darstellung des Feldes.
   def to_s
-    "Feld (#{x},#{y}), Typ = #{type}"
+    s = "Feld #{coordinates}, "
+    if obstructed?
+      s += 'blockiert'
+    else
+      s += "Steine: #{pieces.map(&:to_s).join(', ')}"
+    end
   end
 end