software_challenge_client 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f271f5ffeec2737047b1f9a9b3a0bcac709e3ba
-  data.tar.gz: a36d50d1de945f9b1a101a4bc6d3398d25f9eacf
+  metadata.gz: 0f6e73a26e7e73031e6e8753b4530a3a97d7c6d4
+  data.tar.gz: 94b865f5a9919c92fdd383c7ee130b5a8444cc2a
 SHA512:
-  metadata.gz: 38ccd36b8e494e1c6c7f23ba921f2a2ff6918c0148d2343438c4c6dd064fc4bd9b22308a43ad61c733ff2b9d3a45ed545de466a6e40dcc7fe64401e2530a90fc
-  data.tar.gz: 38c78da170187d31242a3661a79fb128d114da59ee940d75bb9e429c1c38c20e6de477627651f25b64821c16dda71002c68165c294b70597cfb92f0ae32af624
+  metadata.gz: 2af181e53250e162c328d70512f12e98c01535f5cea29570dd787c34a2627575d73bd8ee832e4b72ffd33e390d15b064014b0f6d6019269cccd73c4d21d50a9a
+  data.tar.gz: 57434f1b54bd0723e8d1af763780cc3ad25cb79ec0476eeb924d1b812d4862e05451a1b88baf98a9816860e0c4b8c9d18c0b7ffb348e129a93f917aac8d32922

data/.gitignore

@@ -9,3 +9,4 @@
 /tmp/
 /bin/
 /vendor
+/spec/examples.txt

data/.rspec

@@ -1,2 +1,3 @@
 --color
 --require spec_helper
+--format Fuubar

data/.rubocop.yml

@@ -0,0 +1,6 @@
+AllCops:
+  DefaultFormatter: fuubar
+  DisplayStyleGuide: true
+  DisplayCopNames: false
+  TargetRubyVersion: 2.0
+#require: rubocop-rspec

data/AUTHORS

@@ -0,0 +1,6 @@
+# This file lists all individuals having contributed content to the repository.
+# For how it is generated, see `generate-authors.sh`.
+
+kwollw <kwollw@users.noreply.github.com>
+Ralf-Tobias Diekert <ralfbias@hotmail.com>
+Sven Koschnicke <s.koschnicke@gfxpro.com>

data/Guardfile

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+directories %w(lib lib/software_challenge_client spec)
+# the following seems to cause problems in certain ruby versions:
+# directories %w(lib lib/software_challenge_client spec).select do |d|
+#   Dir.exist?(d) ? d : UI.warning("Directory #{d} does not exist")
+# end
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# This group allows to skip running RuboCop when RSpec failed.
+group :red_green_refactor, halt_on_fail: true do
+  guard :rspec, cmd: 'rspec', all_after_pass: true, all_on_start: true do
+    watch(%r{^lib/software_challenge_client/(.+)\.rb$}) do |match|
+      spec_file = "spec/#{match[1]}_spec.rb"
+      if File.exist?(spec_file)
+        spec_file # run spec belonging to the file which was changed
+      else
+        'spec' # run all specs
+      end
+    end
+    watch(%r{^spec/.+_spec\.rb$}) # no block means the matched file is returned
+
+    watch('lib/software_challenge_client.rb') { 'spec' }
+    watch('spec/spec_helper.rb') { 'spec' }
+  end
+
+  guard :rubocop, all_on_start: false do
+    # This never includes external ruby files because of the
+    # directory constraint at the top of this file:
+    watch(/.*.rb/)
+  end
+end

data/README.md

@@ -33,6 +33,37 @@ 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.
 
+## 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
+```
+
+After generation, the docs can be found in the `doc` directory. Start at
+`index.html`.
+
+Documentation for the latest source can also be found
+on
+[rubydoc.info](http://www.rubydoc.info/github/CAU-Kiel-Tech-Inf/socha_ruby_client).
+
+When updating the docs, you may use
+
+```console
+yard server --reload
+```
+
+or inside a docker container
+
+```console
+yard server --reload --bind 0.0.0.0
+```
+
+to get a live preview of them at [http://localhost:8808](http://localhost:8808).
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install
@@ -43,6 +74,20 @@ experiment.
 To install this gem onto your local machine, run `bundle exec rake
 install`.
 
+To develop inside a docker container, use the included `Dockerfile` and
+`develop.sh`.
+
+### Specs
+
+The gem is tested using RSpec. To run all tests, execute `rspec`. When
+developing, you may use Guard to execute tests when files change. To do this,
+execute `guard`. Tests will then be automatically run when you change a file.
+
+### Linting
+
+Linting by rubocop is included in the guard config. It is run when all specs
+pass.
+
 ### Releasing
 
 To release a new version, update the version number in

data/RELEASES.md

@@ -1,3 +1,7 @@
+= 0.2.0
+
+- First working version for Mississippi Queen
+
 = 0.1.5
 
 - Fixed bug in reservation code.

data/develop.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+set -x # echo commands as they are executed
+docker run -it --rm -p 8808:8808 -v "$PWD":/usr/src/app -w /usr/src/app ruby:latest /bin/bash

data/example/client.rb

@@ -1,31 +1,59 @@
 # encoding: UTF-8
 require 'software_challenge_client'
 
+# This is an example of a client playing the game using the software challenge
+# gem.
 class Client < ClientInterface
+  include Logging
+
   attr_accessor :gamestate
 
-  def initialize
-    puts "Zufallsspieler erstellt."
+  def initialize(log_level)
+    logger.level = log_level
+    logger.info 'Einfacher Spieler wurde erstellt.'
   end
 
   # gets called, when it's your turn
-  def getMove
-    puts "Spielstand: #{self.gamestate.pointsForPlayer(self.gamestate.currentPlayer)} - #{self.gamestate.pointsForPlayer(self.gamestate.otherPlayer)}"
-    mov = self.randomMove
-    unless mov.nil?
-      puts 'Zug gefunden: '
-      puts mov.to_s
-    end
-    return mov
+  def move_requested
+    logger.info "Spielstand: #{gamestate.points_for_player(gamestate.current_player)} - #{gamestate.points_for_player(gamestate.other_player)}"
+    mov = best_move
+    logger.debug "Zug gefunden: #{mov}" unless mov.nil?
+    mov
   end
 
-  # choose a random move
-  def randomMove
-    possibleMoves = self.gamestate.getPossibleMoves
-    if possibleMoves.length > 0
-      return possibleMoves[SecureRandom.random_number(possibleMoves.length)]
-    else
-      return nil
+  # choose a move giving the most points
+  def best_move
+    # try all moves in all directions
+    best = nil
+    points_for_best = 0
+    Direction.each do |direction|
+      [1, 2].each do |speed|
+        move = Move.new
+        if gamestate.current_player.velocity != speed
+          move.add_action(Acceleration.new(speed - gamestate.current_player.velocity))
+        end
+        # turn in that direction
+        possible_turn = Direction.from_to(gamestate.current_player.direction, direction)
+        if possible_turn.direction != 0
+          move.add_action(possible_turn)
+        end
+        move.add_action(Advance.new(speed))
+        gamestate_copy = gamestate.deep_clone
+        begin
+          logger.debug("Teste Zug #{move} auf gueltigkeit")
+          move.perform!(gamestate_copy, gamestate_copy.current_player)
+          points_for_move = gamestate_copy.points_for_player(gamestate_copy.current_player)
+          logger.debug("Zug #{move} gueltig und wuerde #{points_for_move} Punkte geben!.")
+          on_sandbank = gamestate_copy.board.field(gamestate_copy.current_player.x, gamestate_copy.current_player.y).type == FieldType::SANDBANK
+          if !on_sandbank && (best.nil? || points_for_move > points_for_best)
+            best = move
+            points_for_best = points_for_move
+          end
+        rescue InvalidMoveException => e
+          logger.debug("Zug #{move} ist ungueltig: #{e}")
+        end
+      end
     end
+    best
   end
 end

data/example/main.rb

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

data/generate-authors.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+# Thanks to the docker project!
+# https://github.com/docker/docker/blob/2c224e4fc09518d33780d818cf74026f6aa32744/hack/generate-authors.sh
+set -e
+
+# change to the directory where the script is located, this should be the project root
+pushd "$(dirname "$(readlink -f "$BASH_SOURCE")")/"
+
+# see also ".mailmap" for how email addresses and names are deduplicated
+
+{
+	cat <<-'EOH'
+	# This file lists all individuals having contributed content to the repository.
+	# For how it is generated, see `generate-authors.sh`.
+	EOH
+	echo
+	git log --format='%aN <%aE>' | LC_ALL=C.UTF-8 sort -uf
+} > AUTHORS
+popd

data/lib/software_challenge_client.rb

@@ -1,18 +1,21 @@
 # encoding: UTF-8
 module SoftwareChallengeClient
-  require "software_challenge_client/version"
-  require "software_challenge_client/board"
-  require "software_challenge_client/client_interface"
-  require "software_challenge_client/condition"
-  require "software_challenge_client/connection"
-  require "software_challenge_client/debug_hint"
-  require "software_challenge_client/field"
-  require "software_challenge_client/field_type"
-  require "software_challenge_client/game_state"
-  require "software_challenge_client/move"
-  require "software_challenge_client/network"
-  require "software_challenge_client/player"
-  require "software_challenge_client/player_color"
-  require "software_challenge_client/protocol"
-  require "software_challenge_client/runner"
+  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'
+  require 'software_challenge_client/debug_hint'
+  require 'software_challenge_client/field'
+  require 'software_challenge_client/field_type'
+  require 'software_challenge_client/game_state'
+  require 'software_challenge_client/move'
+  require 'software_challenge_client/network'
+  require 'software_challenge_client/player'
+  require 'software_challenge_client/player_color'
+  require 'software_challenge_client/protocol'
+  require 'software_challenge_client/runner'
+  require 'software_challenge_client/direction'
 end

data/lib/software_challenge_client/action.rb

@@ -0,0 +1,278 @@
+# encoding: utf-8
+
+# An action is a part of a move. A move can have multiple actions. The specific
+# actions are inherited from this Action class which should be considered
+# abstract/interface.
+class Action
+  # @return [ActionType] Type of the action.
+  def type
+    raise 'must be overridden'
+  end
+
+  def ==(_other)
+    raise 'must be overridden'
+  end
+
+  def perform!(_gamestate, _current_player)
+    raise 'must be overridden'
+  end
+
+  # Helper to make raising InvalidMoveExceptions easier. It is defined in the
+  # Action class instead of the Move class because performing individual actions
+  # normally trigger invalid moves, not the move itself.
+  #
+  # @param message [String] Message why the move is invalid.
+  # @return Nothing. Raises an exception.
+  def invalid(message)
+    raise InvalidMoveException.new(message, self)
+  end
+end
+
+# Accelerate by {#acceleration}. To decelerate, use a negative value.
+class Acceleration < Action
+  attr_reader :acceleration
+
+  def initialize(acceleration)
+    @acceleration = acceleration
+  end
+
+  # Perform the action.
+  #
+  # @param gamestate [GameState] The game state on which the action will be performed. Performing may change the game state.
+  # @param current_player [Player] The player for which the action will be performed.
+  def perform!(gamestate, current_player)
+    new_velocity = current_player.velocity + acceleration
+    if new_velocity < 1
+      invalid 'Geschwindigkeit darf nicht unter 1 verringert werden.'
+    end
+    if new_velocity > 6
+      invalid 'Geschwindigkeit darf nicht über 6 erhöht werden.'
+    end
+    acceleration.times do
+      if gamestate.free_acceleration?
+        gamestate.free_acceleration = false
+      elsif current_player.coal.zero?
+        invalid 'Nicht genug Kohle zum Beschleunigen.'
+      else
+        current_player.coal -= 1
+      end
+    end
+    if gamestate.board.field(current_player.x, current_player.y).type == FieldType::SANDBANK
+      invalid 'Auf einer Sandbank kann nicht beschleunigt werden.'
+    end
+    current_player.velocity = new_velocity
+    # This works only when acceleration is the first action in a move. The move
+    # class has to check that.
+    current_player.movement = new_velocity
+  end
+
+  def type
+    :acceleration
+  end
+
+  def ==(other)
+    other.type == type && other.acceleration == acceleration
+  end
+end
+
+# Turn by {#direction}.
+class Turn < Action
+  # Number of steps to turn. Negative values for turning clockwise, positive for
+  # counterclockwise.
+  attr_reader :direction
+
+  def initialize(direction)
+    @direction = direction
+  end
+
+  # (see Acceleration#perform!)
+  def perform!(gamestate, current_player)
+    invalid 'Drehung um 0 ist ungültig' if direction.zero?
+    if gamestate
+       .board
+       .field(current_player.x, current_player.y)
+       .type == FieldType::SANDBANK
+      invalid 'Drehung auf Sandbank nicht erlaubt'
+    end
+    needed_coal = direction.abs
+    needed_coal -= 1 if gamestate.free_turn?
+    if needed_coal > 0 && gamestate.additional_free_turn_after_push?
+      needed_coal -= 1
+      gamestate.additional_free_turn_after_push = false
+    end
+    if needed_coal > current_player.coal
+      invalid "Nicht genug Kohle für Drehung um #{direction}. "\
+              "Habe #{current_player.coal}, brauche #{needed_coal}."
+    end
+
+    current_player.direction =
+      Direction.get_turn_direction(current_player.direction, direction)
+    current_player.coal -= [0, needed_coal].max
+    gamestate.free_turn = false
+  end
+
+  def type
+    :turn
+  end
+
+  def ==(other)
+    other.type == type && other.direction == direction
+  end
+end
+
+# Go forward in the current direction by {#distance}. When on a sandbank, a
+# value of -1 to go backwards is also legal.
+class Advance < Action
+  attr_reader :distance
+
+  def initialize(distance)
+    @distance = distance
+  end
+
+  # (see Acceleration#perform!)
+  def perform!(gamestate, current_player)
+    invalid 'Bewegung um 0 ist unzulässig.' if distance.zero?
+    if distance < 0 && gamestate.board.field(current_player.x, current_player.y).type != FieldType::SANDBANK
+      invalid 'Negative Bewegung ist nur auf Sandbank erlaubt.'
+    end
+    begin
+      fields = gamestate.board.get_all_in_direction(
+        current_player.x, current_player.y, current_player.direction, distance
+      )
+    rescue FieldUnavailableException => e
+      invalid "Feld (#{e.x}, #{e.y}) ist nicht vorhanden"
+    end
+    # test if all fields are passable
+    if fields.any?(&:blocked?)
+      invalid 'Der Weg ist blockiert.'
+    end
+    # Test if movement is enough.
+    req_movement = required_movement(gamestate, current_player)
+    if req_movement > current_player.movement
+      invalid 'Nicht genug Bewegungspunkte.'
+    end
+    # test if opponent is not on fields over which is moved
+    if fields[0...-1].any? { |f| gamestate.occupied_by_other_player? f }
+      invalid 'Man darf nicht über den Gegner fahren.'
+    end
+    # test if moving over sandbank
+    if fields[0...-1].any? { |f| f.type == FieldType::SANDBANK }
+      invalid 'Die Bewegung darf nur auf einer Sandbank enden, '\
+              'nicht über sie hinaus gehen.'
+    end
+    target_field = fields.last
+    current_player.x = target_field.x
+    current_player.y = target_field.y
+
+    if target_field.type == FieldType::SANDBANK
+      current_player.movement = 0
+      current_player.velocity = 1
+    else
+      current_player.movement -= req_movement
+    end
+
+    # test for passenger
+    if current_player.velocity == 1
+      required_field_for_direction = {
+        Direction::RIGHT.key=> FieldType::PASSENGER3.key,
+        Direction::UP_RIGHT.key=> FieldType::PASSENGER4.key,
+        Direction::UP_LEFT.key=> FieldType::PASSENGER5.key,
+        Direction::LEFT.key=> FieldType::PASSENGER0.key,
+        Direction::DOWN_LEFT.key=> FieldType::PASSENGER2.key,
+        Direction::DOWN_RIGHT.key=> FieldType::PASSENGER1.key
+      }
+      Direction.each do |direction|
+        begin
+          neighbor = gamestate.board.get_in_direction(current_player.x, current_player.y, direction)
+          if neighbor.type.key == required_field_for_direction[direction.key]
+            if current_player.passengers < 2
+              current_player.passengers += 1
+              neighbor.type = FieldType::BLOCKED
+            end
+          end
+        rescue FieldUnavailableException
+          # neighbor did not exist, that is okay
+        end
+      end
+    end
+
+  end
+
+  # returns the required movement points to perform this action
+  def required_movement(gamestate, current_player)
+    gamestate.board.get_all_in_direction(current_player.x, current_player.y, current_player.direction, distance).map do |field|
+      # pushing costs one more movement
+      on_opponent = field.x == gamestate.other_player.x && field.y == gamestate.other_player.y
+      case field.type
+      when FieldType::WATER, FieldType::GOAL, FieldType::SANDBANK
+        on_opponent ? 2 : 1
+      when FieldType::LOG
+        on_opponent ? 3 : 2
+      end
+    end.reduce(:+)
+  end
+
+  def type
+    :advance
+  end
+
+  def ==(other)
+    other.type == type && other.distance == distance
+  end
+end
+
+# Push the opponent in {#direction}
+class Push < Action
+  # @return [Direction] the direction where to push.
+  attr_reader :direction
+
+  # @param direction [Direction]
+  def initialize(direction)
+    @direction = direction
+  end
+
+  # (see Acceleration#perform!)
+  def perform!(gamestate, current_player)
+    if gamestate.other_player.x != current_player.x ||
+       gamestate.other_player.y != current_player.y
+      invalid 'Abdrängen ist nur auf dem Feld des Gegners möglich.'
+    end
+    other_player_field =
+      gamestate.board.field(gamestate.other_player.x, gamestate.other_player.y)
+    if other_player_field.type == FieldType::SANDBANK
+      invalid 'Abdrängen von einer Sandbank ist nicht erlaubt.'
+    end
+    if direction == Direction.get_turn_direction(current_player.direction, 3)
+      invalid 'Man darf nicht hinter sich abdrängen.'
+    end
+
+    target_x, target_y =
+      gamestate.board.get_neighbor(
+        gamestate.other_player.x,
+        gamestate.other_player.y,
+        direction
+      )
+
+    required_movement = 1
+    if gamestate.board.field(target_x, target_y).type == FieldType::LOG
+      required_movement += 1
+    end
+    if required_movement > current_player.movement
+      invalid 'Nicht genug Bewegungspunkte zum abdrängen '\
+              "(brauche #{required_movement})"
+    end
+
+    current_player.movement -= required_movement
+
+    gamestate.other_player.x = target_x
+    gamestate.other_player.y = target_y
+  end
+
+  def type
+    :push
+  end
+
+  def ==(other)
+    other.type == type && other.direction == direction
+  end
+end