software_challenge_client 1.2.1 → 19.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f17d0f5a06ce3da01d2700ea50e20e6f8ccb9d4f
-  data.tar.gz: 85f493205e07e2ec8c4e66b61a51da5b4a2e43dd
+  metadata.gz: 42f624c3d6632a5451ccd927967699ce2c663340
+  data.tar.gz: 5e8540a594b7a896535c64a617c80e50d801c9db
 SHA512:
-  metadata.gz: ab46b529b1874eecfc1c9a3449d7e0c70734d06247004c473b183054c31e1251fabcd3be7877a4f80b6ecf3412766a0eebcb009dd852d50dcdf27fb68a397ee3
-  data.tar.gz: cb7cd641de2dbdf3caf1b60fb5058a00436ea985b69866938dac4988accc5e833ce1e69fd094b17d00d877e43460757480ae8b103fd104870002dc14eeec23a7
+  metadata.gz: efbae299e27a8a7db3aa5cf706c2e0c4a987647822103d59394ebee3bbb6367d7f0308cf8173c519a81a228277ab0f1ca0e78cd8b914e6afef681eb5d7a8a309
+  data.tar.gz: 2b35430ade3b3cb6edfda0c8f29b5b6dc131f5f278da1f88a4cbec9a1f06b336d7fa2fb457eefd8ac758f6086021b12e10767eb6364494823477ea560e7afb93

data/Dockerfile

@@ -0,0 +1,3 @@
+FROM ruby:2.4.2
+
+RUN gem install --no-document software_challenge_client

data/README.md

@@ -1,47 +1,89 @@
-# Software Challenge Client
+# Software-Challenge Client
 
 This gem includes everything to build a client for the coding
 competition [Software-Challenge](http://www.software-challenge.de).
 
+------------------------------------------------------------------------
+
+_Language:_ Most documentation will be in german language, because it is intended
+to be used by pupils taking part in the Software-Challenge programming
+competition. Only internal documentation is in english.
+
+------------------------------------------------------------------------
+
+_Sprache:_ Ein Grossteil der Dokumentation ist in deutscher Sprache verfasst, da
+sie dazu gedacht ist, von am Programmierwettbewerb Software-Challenge
+teilnehmenden Schülerinnen und Schülern gelesen zu werden. Interne Dokumentation
+ist weiterhin in englisch.
+
+------------------------------------------------------------------------
+
 ## Installation
 
-Add this line to your application's Gemfile:
+Um die Software-Challenge Bibliothek in deinem Computerspieler zu verwenden, füge folgende Zeile in das Gemfile deines Projektes ein:
 
-```ruby
-gem 'software_challenge_client'
-```
+    gem 'software_challenge_client'
 
-And then execute:
+Installiere das Gem dann mit dem Befehl:
 
     $ bundle
 
-Or install it yourself as:
+Oder installiere das Gem ohne ein Gemfile mit:
 
     $ gem install software_challenge_client
 
-## Usage
+## Verwendung
+
+Ein Beispielprojekt zur Verwendung der Bibliothek findet man im Verzeichnis `example` ([Beipspielprojekt auf GitHub](https://github.com/CAU-Kiel-Tech-Inf/socha_ruby_client/tree/master/example)).
+
+Du kannst den Beispielclient mittels
+
+    ruby main.rb
+
+in einer Konsole ausführen (dazu musst du dich im Verzeichnis `example` befinden).
+
+Damit dies funktioniert, muss das Gem bereits wie oben beschrieben installiert
+sein und es muss ein Spielserver auf eine Verbindung warten (also zum Beispiel
+ein Spiel mit einem manuell gestarteten Spieler in der grafischen Oberfläche
+angelegt worden sein).
+
+Neben Beiwerk wie dem Initialisieren der Verbindung zum Spielserver und
+Verarbeiten der Startparameter (was beides in `main.rb` des Beispielprojektes
+passiert), musst du nur eine Klasse implementieren, um einen lauffähigen
+Computerspieler zu haben (`client.rb` im Beispielprojekt):
+
+    require 'software_challenge_client'
+
+    class Client < ClientInterface
+      include Logging
 
-See the example client in the example directory.
+      attr_accessor :gamestate
 
-You can execute the example client by entering
+      def initialize(log_level)
+        logger.level = log_level
+        logger.info 'Einfacher Spieler wurde erstellt.'
+      end
 
-```console
-ruby main.rb
-```
+      # 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)}"
+        move = best_move
+        logger.debug "Zug gefunden: #{move}" unless move.nil?
+        move
+      end
 
-in a shell (while being in the example directory). Note that the
-`software_challenge_client` gem needs to be installed for this to work and a
-server waiting for a manual client has to be running.
+      def best_move
+        gamestate.possible_moves.sample
+      end
+    end
 
-## Documentation
+## Generating the Documentation
 
 Code documentation can be generated using YARD in the project root (source code
 needs to be checked out and `bundle` has to be executed,
 see [Installation](#installation)):
 
-```console
-yard
-```
+    yard
 
 After generation, the docs can be found in the `doc` directory. Start at
 `index.html`.
@@ -52,15 +94,11 @@ on
 
 When updating the docs, you may use
 
-```console
-yard server --reload
-```
+    yard server --reload
 
 or inside a docker container
 
-```console
-yard server --reload --bind 0.0.0.0
-```
+    yard server --reload --bind 0.0.0.0
 
 to get a live preview of them at [http://localhost:8808](http://localhost:8808).
 

data/example/client.rb

@@ -8,9 +8,6 @@ class Client < ClientInterface
 
   attr_accessor :gamestate
 
-  # Anzahl der Spielfelder
-  NUM_FIELDS = 65
-
   def initialize(log_level)
     logger.level = log_level
     logger.info 'Einfacher Spieler wurde erstellt.'
@@ -25,73 +22,6 @@ class Client < ClientInterface
   end
 
   def best_move
-    possible_moves = gamestate.possible_moves # Enthält mindestens ein Element
-    salad_moves = []
-    winning_moves = []
-    selected_moves = []
-
-    index = gamestate.current_player.index
-    possible_moves.each do |move|
-      move.actions.each do |action|
-        case action.type
-          when :advance
-            target_field_index = action.distance + index
-            if target_field_index == NUM_FIELDS - 1
-              winning_moves << move
-            elsif gamestate.field(target_field_index).type == FieldType::SALAD
-              salad_moves << move
-            else
-              selected_moves << move
-            end
-          when :card
-            if action.card_type == CardType::EAT_SALAD
-              # Zug auf Hasenfeld und danach Salatkarte
-              salad_moves << move
-              # Muss nicht zusätzlich ausgewählt werden, wurde schon durch Advance ausgewählt
-            end
-          when :exchange_carrots
-            if action.value == 10 &&
-                gamestate.current_player.carrots < 30 &&
-                index < 40 &&
-                !gamestate.current_player.last_non_skip_action.instance_of?(ExchangeCarrots)
-              # Nehme nur Karotten auf, wenn weniger als 30 und nur am Anfang und nicht zwei
-              # mal hintereinander
-              selected_moves << move
-            elsif action.value == -10 &&
-                gamestate.current_player.carrots > 30 &&
-                index >= 40
-              # Abgeben von Karotten ist nur am Ende sinnvoll
-              selected_moves << move
-            end
-          when :fall_back
-            if index > 56 && # letztes Salatfeld
-                 gamestate.current_player.salads > 0
-              # Falle nur am Ende (index > 56) zurück, außer du musst noch einen Salat loswerden
-              selected_moves << move
-            elsif index <= 56 &&
-                  gamestate.previous_field_of_type(FieldType::HEDGEHOG, index) &&
-                  index - gamestate.previous_field_of_type(FieldType::HEDGEHOG, index).index < 5
-              # Falle zurück, falls sich Rückzug lohnt (nicht zu viele Karotten aufnehmen)
-              selected_moves << move
-              end
-          else
-            # Füge Salatessen oder Skip hinzu
-            selected_moves << move
-          end
-      end
-    end
-
-    if !winning_moves.empty?
-      logger.info("Waehle Gewinnzug")
-      winning_moves.sample
-    elsif !salad_moves.empty?
-      # es gibt die Möglichkeit einen Salat zu essen
-      logger.info("Waehle Zug zum Salatessen")
-      salad_moves.sample
-    elsif !selected_moves.empty?
-      selected_moves.sample
-    else
-      possible_moves.sample
-    end
+    gamestate.possible_moves.sample
   end
 end

data/example/main.rb

@@ -39,4 +39,4 @@ opt_parser.parse!(ARGV)
 
 client = Client.new(Logger::DEBUG)
 runner = Runner.new(options.host, options.port, client, options.reservation)
-runner.start()
+runner.start

data/lib/software_challenge_client.rb

@@ -3,7 +3,6 @@ module SoftwareChallengeClient
   require 'software_challenge_client/version'
   require 'software_challenge_client/logging'
   require 'software_challenge_client/invalid_move_exception'
-  require 'software_challenge_client/field_unavailable_exception'
   require 'software_challenge_client/board'
   require 'software_challenge_client/client_interface'
   require 'software_challenge_client/condition'
@@ -17,5 +16,8 @@ module SoftwareChallengeClient
   require 'software_challenge_client/player_color'
   require 'software_challenge_client/protocol'
   require 'software_challenge_client/runner'
-  require 'software_challenge_client/game_rules'
+  require 'software_challenge_client/game_rule_logic'
+  require 'software_challenge_client/direction'
+  require 'software_challenge_client/line_direction'
+  require 'software_challenge_client/coordinates'
 end

data/lib/software_challenge_client/board.rb

@@ -1,46 +1,93 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
 require_relative './util/constants'
 require_relative 'game_state'
-require_relative 'player'
 require_relative 'field_type'
 require_relative 'field'
 
-# Ein Spielbrett bestehend aus 65 Feldern.
+# Ein Spielbrett bestehend aus 10x10 Feldern.
 class Board
   # @!attribute [r] fields
   # @note Besser über die {#field} Methode auf Felder zugreifen.
-  # @return [Array<Field>] Ein Feld wird an der Position entsprechend seines
-  #   Index im Array gespeichert.
+  # @return [Array<Array<Field>>] Ein Feld wird an der Position entsprechend
+  #   seiner Koordinaten im Array gespeichert.
   attr_reader :fields
 
-  # Initializes the board
+  # 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)
+      end
+    end
   end
 
-  def to_s
-    fields.map { |f| f.type.value }.join(' ')
-  end
-
+  # Vergleicht zwei Spielbretter. Gleichheit besteht, wenn zwei Spielbretter die
+  # gleichen Felder enthalten.
   def ==(other)
-    fields.each_with_index do |field, index|
-      return false if field != other.field(index)
+    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
   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.index] = 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
   end
 
   # Zugriff auf die Felder des Spielfeldes
   #
-  # @param index [Integer] Der Index des Feldes
-  # @return [Field] Das Feld mit dem gegebenen Index. Falls das Feld nicht
-  #   exisitert (weil der Index ausserhalb von 0..64 liegt), wird ein neues
-  #   Feld vom Typ INVALID zurückgegeben.
-  def field(index)
-    return Field.new(FieldType::INVALID, index) if index.negative?
-    fields.fetch(index, Field.new(FieldType::INVALID, index))
+  # @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.
+  def field(x, y)
+    return nil if x.negative? || y.negative?
+    fields.dig(y, x) # 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}.
+  # @return [Field] Wie bei {Board#field}.
+  #
+  # @see #field
+  def field_at(coordinates)
+    field(coordinates.x, coordinates.y)
+  end
+
+  # Liefert alle Felder eines angegebenen Typs des Spielbrettes.
+  #
+  # @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 }
   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")
+  end
+
 end

data/lib/software_challenge_client/client_interface.rb

@@ -1,12 +1,17 @@
-# encoding: UTF-8
+# encoding: utf-8
 
-# The interface a client should implement to work with the gem.
+# Das Interface sollte von einem Client implementiert werden, damit er über das
+# Gem an einem Spiel teilnehmen kann.
 class ClientInterface
-  # Is updated by the gem, when a new gamestate is received from the server.
+  # Wird automatisch aktualisiert und ist immer der Spielzustand des aktuellen Zuges.
   attr_accessor :gamestate
 
-  # Is called when the server requests a move from the client.
-  # @return [Move] Needs to return a valid move.
+  # Wird aufgerufen, wenn der Client einen Zug machen soll. Dies ist der
+  # Einstiegspunkt für die eigentliche Logik des Computerspielers. Er muss auf
+  # Basis des Spielzustandes entscheiden, welchen Zug er machen möchte und diese
+  # zurückgeben.
+  #
+  # @return [Move] Ein für den aktuellen Spielzustand gültiger Spielzug.
   def move_requested
     raise 'Not yet implemented'
   end

data/lib/software_challenge_client/condition.rb

@@ -1,10 +1,10 @@
 # encoding: UTF-8
 require_relative 'player'
 
-# Represents the winning condition received from the server when the game ended.
+# Das Ergebnis eines Spieles. Ist im `GameState#condition` zu finden, wenn das Spiel beendet wurde.
 class Condition
   # @!attribute [r] winner
-  # @return [Player] winning player
+  # @return [Player] Spieler, der das Spiel gewonnen hat.
   attr_reader :winner
 
   # Initializes the winning Condition with a player

data/lib/software_challenge_client/coordinates.rb

@@ -0,0 +1,17 @@
+# 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/debug_hint.rb

@@ -1,11 +1,15 @@
-# encoding: UTF-8
-# A debug hint, that can be added to a move
+# encoding: utf-8
+
+# Ein Hinweis, der zu einem Zug hinzugefügt werden kann. Z.B. zu
+# Diagnosezwecken. Der Hinweis wird in der grafischen Oberfläche angezeigt und
+# in Replay-Dateien gespeichert.
 class DebugHint
   # @!attribute [r] content
-  # @return [String] a hint
+  # @return [String] Der Text des Hinweises.
   attr_reader :content
 
-  # @param content [Object] of the hint, will be converted to a string
+  # Erstellt einen neuen Hinweis.
+  # @param content [Object] Inhalt des Hinweises. Wird zu String konvertiert.
   def initialize(content)
     @content = content.to_s
   end