software_challenge_client 0.3.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e078c2ea342feb8da789442c4ad6cdd3706ff15
-  data.tar.gz: 90bcc5974f4a1388655101874062157a4f817dcd
+  metadata.gz: 4d55ebfd85d0ed449a11437fd91481c0b7b6f2e1
+  data.tar.gz: 027eadb37b996d8e07ad680db5aa97807d661051
 SHA512:
-  metadata.gz: d673b541408a816e100fe286d370d661ac7991235049d610ecf855426c22f2548a425f0f77f82214db1c790e5b089b35bacdc5a3c083bbd85b91b0f2180d5182
-  data.tar.gz: ff79a54d09798ce8222711ace8b15db2e8e09ece78d27b4f7278ee21e4b4274a735819ee55677ed8266881b3894f327f8f2134222c4f71f0211b63816117e0c7
+  metadata.gz: c78a79ba1d86132c4abb89c489a49480b2a71d14449edc83e11d2eba20ea3bc5bdce3deaddc2d685ff63673631df65c6efd9f4ffdbb3f7638a5dc2ee12736990
+  data.tar.gz: b70311d5c10252ce0a92c78a3e0f1623d055a93d9b1a6b9bdd39fbc2b0d60a29c7c39261bd54edf41af2707b7838884a5b02331c53e23a18eff42fbf4713b248

data/.rubocop.yml

@@ -1,6 +1,8 @@
 AllCops:
+  TargetRubyVersion: 2.4
   DefaultFormatter: fuubar
   DisplayStyleGuide: true
   DisplayCopNames: false
-  TargetRubyVersion: 2.0
 #require: rubocop-rspec
+Style/AsciiComments:
+  Enabled: false # we use german comments to document relevant methods for the pupils

data/.ruby-version

@@ -0,0 +1 @@
+2.4.1

data/Guardfile

@@ -36,9 +36,9 @@ group :red_green_refactor, halt_on_fail: true do
     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
+  # 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/RELEASES.md

@@ -1,5 +1,11 @@
+= 1.0.0
+
+First version for game "Hase und Igel".
+
 = 0.3.4
 
+Last version for game "Mississippi Queen".
+
 - Renamed Turn#direction to Turn#turn_steps to make clearer that a number should be given, not a Direction instance.
 - Corrected generation of XML for Push-actions
 

data/example/client.rb

@@ -8,6 +8,9 @@ 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.'
@@ -16,44 +19,79 @@ 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)}"
-    mov = best_move
-    logger.debug "Zug gefunden: #{mov}" unless mov.nil?
-    mov
+    move = best_move
+    logger.debug "Zug gefunden: #{move}" unless move.nil?
+    move
   end
 
-  # 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
+    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
-        rescue InvalidMoveException => e
-          logger.debug("Zug #{move} ist ungueltig: #{e}")
-        end
       end
     end
-    best
+
+    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
   end
 end

data/lib/software_challenge_client.rb

@@ -17,5 +17,5 @@ module SoftwareChallengeClient
   require 'software_challenge_client/player_color'
   require 'software_challenge_client/protocol'
   require 'software_challenge_client/runner'
-  require 'software_challenge_client/direction'
+  require 'software_challenge_client/game_rules'
 end

data/lib/software_challenge_client/action.rb

@@ -13,7 +13,7 @@ class Action
     raise 'must be overridden'
   end
 
-  def perform!(_gamestate, _current_player)
+  def perform!(_gamestate)
     raise 'must be overridden'
   end
 
@@ -28,251 +28,171 @@ class Action
   end
 end
 
-# Accelerate by {#acceleration}. To decelerate, use a negative value.
-class Acceleration < Action
-  attr_reader :acceleration
+# Ein Vorwärtszug, um spezifizierte Distanz. Verbrauchte Karroten werden mit k =
+# (distance * (distance + 1)) / 2 berechnet (Gaußsche Summe)
+class Advance < Action
+  attr_reader :distance
 
-  def initialize(acceleration)
-    @acceleration = acceleration
+  def initialize(distance)
+    @distance = distance
   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.abs.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
+  # @param gamestate [GameState] The game state on which the action will be
+  # performed. Performing may change the game state. The action is performed for
+  # the current player of the game state.
+  def perform!(gamestate)
+    valid, message = GameRules.is_valid_to_advance(gamestate, distance)
+    invalid(message) unless valid
+    # perform state changes
+    required_carrots = distance * (distance + 1) / 2
+    gamestate.current_player.carrots -= required_carrots
+    gamestate.current_player.index += distance
+    if gamestate.current_field.type == FieldType::HARE
+      gamestate.current_player.must_play_card = true
     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
+    :advance
   end
 
   def ==(other)
-    other.type == type && other.acceleration == acceleration
+    other.type == type && other.distance == distance
   end
 end
 
-# Turn by {#turn_steps}.
-class Turn < Action
-  # Number of steps to turn. Negative values for turning clockwise, positive for
-  # counterclockwise.
-  attr_reader :turn_steps
-
-  def initialize(turn_steps)
-    @turn_steps = turn_steps
-  end
-
-  # (see Acceleration#perform!)
-  def perform!(gamestate, current_player)
-    invalid 'Drehung um 0 ist ungültig' if turn_steps.zero?
-    if gamestate
-       .board
-       .field(current_player.x, current_player.y)
-       .type == FieldType::SANDBANK
-      invalid 'Drehung auf Sandbank nicht erlaubt'
-    end
-    needed_coal = turn_steps.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 #{turn_steps}. "\
-              "Habe #{current_player.coal}, brauche #{needed_coal}."
+# Play a card.
+class Card < Action
+  # only for type TAKE_OR_DROP_CARROTS
+  attr_reader :value
+
+  attr_reader :card_type
+
+  def initialize(card_type, value = 0)
+    @card_type = card_type
+    @value = value
+  end
+
+  # (see Advance#perform!)
+  def perform!(gamestate)
+    gamestate.current_player.must_play_card = false
+    case card_type
+      when CardType::EAT_SALAD
+        valid, message = GameRules.is_valid_to_play_eat_salad(gamestate)
+        invalid("Das Ausspielen der EAT_SALAD Karte ist nicht möglich. " + message) unless valid
+        gamestate.current_player.salads -= 1
+        if gamestate.is_first(gamestate.current_player)
+          gamestate.current_player.carrots += 10
+        else
+          gamestate.current_player.carrots += 20
+        end
+      when CardType::FALL_BACK
+        valid, message = GameRules.is_valid_to_play_fall_back(gamestate)
+        invalid("Das Ausspielen der FALL_BACK Karte ist nicht möglich. " + message) unless valid
+        gamestate.current_player.index = gamestate.other_player.index - 1
+        if gamestate.field(gamestate.current_player.index).type == FieldType::HARE
+          gamestate.current_player.must_play_card = true
+        end
+      when CardType::HURRY_AHEAD
+        valid, message = GameRules.is_valid_to_play_hurry_ahead(gamestate)
+        invalid("Das Ausspielen der HURRY_AHEAD Karte ist nicht möglich. " + message) unless valid
+        gamestate.current_player.index = gamestate.other_player.index + 1
+        if gamestate.field(gamestate.current_player.index).type == FieldType::HARE
+          gamestate.current_player.must_play_card = true
+        end
+      when CardType::TAKE_OR_DROP_CARROTS
+        valid, message = GameRules.is_valid_to_play_take_or_drop_carrots(gamestate, value)
+        invalid("Das Ausspielen der TAKE_OR_DROP_CARROTS Karte ist nicht möglich. " + message) unless valid
+        gamestate.current_player.carrots += value
+      else
+        raise "Unknown card type #{card_type.inspect}!"
     end
-
-    current_player.direction =
-      Direction.get_turn_direction(current_player.direction, turn_steps)
-    current_player.coal -= [0, needed_coal].max
-    gamestate.free_turn = false
+    gamestate.set_last_action(self)
+    gamestate.current_player.cards.delete(self.type)
   end
 
   def type
-    :turn
+    :card
   end
 
   def ==(other)
-    other.type == type && other.turn_steps == turn_steps
+    other.card_type == card_type &&
+      (card_type != CardType::TAKE_OR_DROP_CARROTS || (other.value == value))
   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
+# Ein Aussetzzug. Ist nur erlaubt, sollten keine anderen Züge möglich sei
+class Skip < Action
+  def initialize()
   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
+  def type
+    :skip
+  end
 
+  def ==(other)
+    other.type == type
   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(:+)
+# Eine Salatessen-Aktion. Kann nur auf einem Salatfeld ausgeführt werden. Muss ausgeführt werden,
+# ein Salatfeld betreten wird. Nachdem die Aktion ausgefürht wurde, muss das Salatfeld verlassen
+# werden, oder es muss ausgesetzt werden.
+# Duch eine Salatessen-Aktion wird ein Salat verbraucht und es werden je nachdem ob der Spieler führt
+# oder nicht 10 oder 30 Karotten aufgenommen.
+class EatSalad < Action
+  def initialize()
   end
 
   def type
-    :advance
+    :eat_salad
   end
 
   def ==(other)
-    other.type == type && other.distance == distance
+    other.type == type
   end
 end
 
-# Push the opponent in {#direction}
-class Push < Action
-  # @return [Direction] the direction where to push.
-  attr_reader :direction
+# Karottentauschaktion. Es können auf einem Karottenfeld 10 Karotten abgegeben oder aufgenommen werden.
+# Dies kann beliebig oft hintereinander ausgeführt werden.
+class ExchangeCarrots < Action
+  attr_accessor :value
 
-  # @param direction [Direction]
-  def initialize(direction)
-    @direction = direction
+  def initialize(value)
+    @value = value
   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
-      )
+  def perform!(gamestate)
+    valid, message = GameRules.is_valid_to_exchange_carrots(gamestate, value)
+    raise InvalidMoveException("Es können nicht #{value} Karotten aufgenommen werden. " + message) unless valid
+    gamestate.current_player.carrots += value
+    gamestate.set_last_action(self)
+  end
 
-    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
+  def type
+    :exchange_carrots
+  end
 
-    current_player.movement -= required_movement
+  def ==(other)
+    other.type == type && other.value == value
+  end
+end
 
-    gamestate.other_player.x = target_x
-    gamestate.other_player.y = target_y
+class FallBack < Action
+  def perform!(gamestate)
+    valid, message = GameRules.is_valid_to_fall_back(gamestate)
+    raise InvalidMoveException("Es kann gerade kein Rückzug gemacht werden. " + message) unless valid
+    gamestate.current_player.index = gamestate.previous_field_of_type(FieldType::HEDGEHOG, gamestate.current_player.index).index
+    gamestate.set_last_action(self)
   end
 
   def type
-    :push
+    :fall_back
   end
 
   def ==(other)
-    other.type == type && other.direction == direction
+    other.type == type
   end
 end