software_challenge_client 0.1.5 → 0.2.0

data/lib/software_challenge_client/direction.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+require 'typesafe_enum'
+# A direction on the hexagonal board of the game. Possible directions are:
+# * RIGHT
+# * UP_RIGHT
+# * UP_LEFT
+# * LEFT
+# * DOWN_LEFT
+# * DOWN_RIGHT
+# Access them as Direction::RIGHT for example.
+class Direction < TypesafeEnum::Base
+  new :RIGHT
+  new :UP_RIGHT
+  new :UP_LEFT
+  new :LEFT
+  new :DOWN_LEFT
+  new :DOWN_RIGHT
+
+  # @param direction [Direction] starting direction
+  # @param turns [Integer] number of turns (positive means turning
+  #                        counterclockwise).
+  # @return [Direction] The direction when turning the given number of steps
+  #                     from the given direction.
+  def self.get_turn_direction(direction, turns)
+    # order of directions is equal to counterclockwise turning
+    Direction.find_by_ord((direction.ord + turns) % 6)
+  end
+
+  # @return [Turn] The Turn action to get from from_direction to to_direction.
+  def self.from_to(from_direction, to_direction)
+    distance = (to_direction.ord - from_direction.ord + 6) % 6
+    if distance > 3
+      distance = distance - 6
+    end
+    Turn.new(distance)
+  end
+
+end

data/lib/software_challenge_client/field.rb

@@ -1,13 +1,8 @@
 # encoding: UTF-8
-require_relative 'player_color'
 require_relative 'field_type'
 
-# @author Ralf-Tobias Diekert
-# A field on the game board
+# A field on the game board.
 class Field
-  # @!attribute [rw] ownerColor
-  # @return [PlayerColor] the field's owner's color
-  attr_accessor :ownerColor
   # @!attribute [rw] type
   # @return [PlayerColor] the field's type
   attr_accessor :type
@@ -18,26 +13,53 @@ class Field
   # @return [Integer] the field's y-coordinate
   attr_reader :y
 
+  # @!attribute [r] direction
+  # @return [Integer] the direction of the tile which the field belongs to
+  attr_reader :direction
+
+  # @!attribute [r] index
+  # @return [Integer] the index of the tile which the field belongs to
+  attr_reader :index
+
+  # @!attribute [r] points
+  # @return [Integer] the points awarded to a player placed on this field additionally to points for current tile and passengers
+  attr_reader :points
+
   # Initializer
   #
   # @param type [FieldType] field type
   # @param x [Integer] x-coordinate
   # @param y [Integer] y-coordinate
-  def initialize(type, x, y)
-    self.ownerColor = PlayerColor::NONE
+  # @param index [Integer] index of tile
+  # @param direction [Integer] direction of tile
+  # @param points [Integer] points
+  def initialize(type, x, y, index, direction, points)
     self.type = type
     @x = x
     @y = y
+    @index = index
+    @direction = direction
+    @points = points
   end
 
   def ==(another_field)
-    return self.ownerColor == another_field.ownerColor &&
-      self.type == another_field.type &&
+    return self.type == another_field.type &&
       self.x == another_field.x &&
       self.y == another_field.y
   end
 
+  # @return [Boolean] true if the field may never be moved onto.
+  def blocked?
+    [FieldType::BLOCKED,
+     FieldType::PASSENGER0,
+     FieldType::PASSENGER1,
+     FieldType::PASSENGER2,
+     FieldType::PASSENGER3,
+     FieldType::PASSENGER4,
+     FieldType::PASSENGER5].include? type
+  end
+
   def to_s
-    return "Field: x = #{self.x}, y = #{self.y}, owner = #{self.ownerColor}, type = #{self.type}"
+    return "Field: x = #{self.x}, y = #{self.y}, type = #{self.type}"
   end
-end
+end

data/lib/software_challenge_client/field_type.rb

@@ -1,9 +1,30 @@
 # encoding: UTF-8
-# @author Ralf-Tobias Diekert
-#Fieldtype constants
-module FieldType
-  NORMAL = 1
-  RED = 2
-  BLUE = 4
-  SWAMP = 8
-end
+
+require 'typesafe_enum'
+# All possible field types:
+# * WATER
+# * BLOCKED
+# * PASSENGER0
+# * PASSENGER1
+# * PASSENGER2
+# * PASSENGER3
+# * PASSENGER4
+# * PASSENGER5
+# * SANDBANK
+# * LOG
+# * GOAL
+# Access them with FieldType::WATER.
+class FieldType < TypesafeEnum::Base
+  new :WATER
+  new :BLOCKED
+  new :PASSENGER0
+  new :PASSENGER1
+  new :PASSENGER2
+  new :PASSENGER3
+  new :PASSENGER4
+  new :PASSENGER5
+  new :SANDBANK
+  new :LOG
+  new :GOAL
+
+end

data/lib/software_challenge_client/field_unavailable_exception.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+# Exception indicating that a requested field does not exist.
+class FieldUnavailableException < StandardError
+  # @!attribute [r] x
+  # @return [Integer] the X-coordinate of the requested field.
+  attr_reader :x
+
+  # @!attribute [r] y
+  # @return [Integer] the Y-coordinate of the requested field.
+  attr_reader :y
+
+  def initialize(x, y)
+    super("Field with coordinates (#{x},#{y}) is not available.")
+    @x = x
+    @y = y
+  end
+end

data/lib/software_challenge_client/game_state.rb

@@ -1,25 +1,22 @@
-# encoding: UTF-8
+# encoding: utf-8
 require_relative './util/constants'
 require_relative 'player'
 require_relative 'board'
 require_relative 'move'
 require_relative 'condition'
-require_relative 'player_color'
 require_relative 'field_type'
 
-# @author Ralf-Tobias Diekert
-# The state of a game
+# The state of a game, as received from the server.
 class GameState
-
   # @!attribute [rw] turn
   # @return [Integer] turn number
   attr_accessor :turn
-  # @!attribute [rw] startPlayerColor
+  # @!attribute [rw] start_player_color
   # @return [PlayerColor] the start-player's color
-  attr_accessor :startPlayerColor
-  # @!attribute [rw] currentPlayerColor
+  attr_accessor :start_player_color
+  # @!attribute [rw] current_player_color
   # @return [PlayerColor] the current player's color
-  attr_accessor :currentPlayerColor
+  attr_accessor :current_player_color
   # @!attribute [r] red
   # @return [Player] the red player
   attr_reader :red
@@ -35,310 +32,146 @@ class GameState
   # @!attribute [rw] condition
   # @return [Condition] the winner and winning reason
   attr_accessor :condition
+  # @!attribute [rw] free_acceleration
+  # @return [Boolean] true if the free acceleration for this turn is still
+  #                   available.
+  attr_accessor :free_acceleration
+  alias free_acceleration? free_acceleration
+
+  # @!attribute [rw] free_turn
+  # @return [Boolean] True if the free turning for this turn is still
+  # available.
+  attr_accessor :free_turn
+  alias free_turn? free_turn
+
+  # @!attribute [rw] additional_free_turn_after_push
+  # @return [Boolean] True if the free turning for this turn is still
+  # available.
+  attr_accessor :additional_free_turn_after_push
+  alias additional_free_turn_after_push? additional_free_turn_after_push
+
+  POINTS_PER_TILE = 5
+  POINTS_PER_PASSENGER = 5
 
   def initialize
-    self.currentPlayerColor = PlayerColor::RED
-    self.startPlayerColor = PlayerColor::RED
-    self.board = Board.new(true)
+    @current_player_color = PlayerColor::RED
+    @start_player_color = PlayerColor::RED
+    @board = Board.new
+    @free_acceleration = true
+    @free_turn = true
+    @additional_free_turn_after_push = false
   end
 
   # adds a player to the gamestate
   #
   # @param player [Player] the player, that will be added
-  def addPlayer(player)
+  def add_player(player)
     if player.color == PlayerColor::RED
       @red = player
-    else if player.color == PlayerColor::BLUE
-        @blue = player
-      end
+    elsif player.color == PlayerColor::BLUE
+      @blue = player
     end
   end
 
   # gets the current player
   #
   # @return [Player] the current player
-  def currentPlayer
-    if self.currentPlayerColor == PlayerColor::RED
-      return self.red
-    else
-      return self.blue
+  def current_player
+    if current_player_color == PlayerColor::RED
+    then red
+    else blue
     end
   end
 
   # gets the other (not the current) player
   #
   # @return [Player] the other (not the current) player
-  def otherPlayer
-    if self.currentPlayerColor == PlayerColor::RED
-      return self.blue
+  def other_player
+    if current_player_color == PlayerColor::RED
+      return blue
     else
-      return self.red
+      return red
     end
   end
 
   # gets the other (not the current) player's color
   #
   # @return [PlayerColor] the other (not the current) player's color
-  def otherPlayerColor
-    return PlayerColor.opponentColor(self.currentPlayerColor)
-  end
-
-  # gets the start player
-  #
-  # @return [Player] the startPlayer
-  def startPlayer
-    if self.startPlayer == PlayerColor::RED
-      return self.red
-    else
-      return self.blue
-    end
-  end
-
-  # switches current player
-  def switchCurrentPlayer
-    if currentPlayer.color == PlayerColor::RED
-      @currentPlayer = self.blue
-    else
-      @currentPlayer = self.red
-    end
-  end
-
-  # prepares next turn and sets the last move
-  #
-  # @param [Move] the last move
-  def prepareNextTurn(lastMove)
-    @turn++
-    @lastMove = lastMove;
-    self.switchCurrentPlayer()
+  def other_player_color
+    PlayerColor.opponent_color(current_player_color)
   end
 
   # gets the current round
   #
   # @return [Integer] the current round
   def round
-    return self.turn / 2
-  end
-
-  # gets all possible moves
-  #
-  # @return [Array<Move>] a list of all possible moves
-  def getPossibleMoves
-    enemyFieldType = currentPlayer.color == PlayerColor::RED ? FieldType::BLUE : FieldType::RED
-    moves = Array.new
-    for x in 0..(Constants::SIZE-1)
-      for y in 0..(Constants::SIZE-1)
-        if (self.board.fields[x][y].ownerColor == PlayerColor::NONE &&
-              self.board.fields[x][y].type != FieldType::SWAMP &&
-              self.board.fields[x][y].type != enemyFieldType)
-          moves.push(Move.new(x, y))
-        end
-      end
-    end
-    return moves
+    turn / 2
   end
 
   # performs a move on the gamestate
   #
   # @param move [Move] the move, that will be performed
   # @param player [Player] the player, who makes the move
-  def perform(move, player)
-    if !move.nil?
-      if move.x < Constants::SIZE && move.y < Constants::SIZE &&
-          move.x >= 0 && move.y >= 0
-        if self.getPossibleMoves.include?(move)
-          self.board.put(move.x, move.y, player)
-          player.points = self.pointsForPlayer(player)
-        else
-          raise "Der Zug ist nicht möglich, denn der Platz ist bereits besetzt oder nicht besetzbar."
-        end
-      else
-        raise "Startkoordinaten sind nicht innerhalb des Spielfeldes."
-      end
-    end
-  end
-
-  # gets a player's points
-  #
-  # @param player [Player] the player, whos statistics will be returned
-  # @return [Integer] the points of the player
-  def playerStats(player)
-    return self.playerStats(player.color)
-  end
-
-  # gets a player's points by the player's color
-  #
-  # @param playerColor [PlayerColor] the player's color, whos statistics will be returned
-  # @return [Integer] the points of the player
-  def playerStats(playerColor)
-    if playerColor == PlayerColor::RED
-      return self.gameStats[0];
-    else
-      return self.gameStats[1]
-    end
-  end
-
-  # gets the players' statistics
-  #
-  # @return [Array<Integer>] the points for both players
-  def gameStats
-    stats = Array.new(2, Array.new(1))
-
-    stats[0][0] = self.red.points
-    stats[1][0] = self.blue.points
-
-    return stats
-  end
-
-  # get the players' names
-  #
-  # @return [Array<String>] the names for both players
-  def playerNames
-    return [red.displayName, blue.displayName]
-  end
-
-  # sets the game-ended condition
-  #
-  # @param winner [Player] the winner of the game
-  # @param reason [String] the winning reason
-  def endGame(winner, reason)
-    if condition.nil?
-      @condition = Condition.new(winner, reason)
+  def perform!(move, player)
+    move.actions.each do |action|
+      action.perform!(self, player)
     end
   end
 
   # has the game ended?
   #
   # @return [Boolean] true, if the game has allready ended
-  def gameEnded?
-    return !self.condition.nil?
+  def game_ended?
+    !condition.nil?
   end
 
   # gets the game's winner
   #
   # @return [Player] the game's winner
   def winner
-    return condition.nil? ? nil : self.condition.winner
+    condition.nil? ? nil : condition.winner
   end
 
   # gets the winning reason
   #
   # @return [String] the winning reason
-  def winningReason
-    return condition.nil? ? nil : self.condition.reason
+  def winning_reason
+    condition.nil? ? nil : condition.reason
   end
 
-  # calculates a player's points
+  # calculates a player's points based on the current gamestate
   #
-  # @param player [Player] the player, whos point will be calculated
+  # @param player [Player] the player, whos point will be calculated
   # @return [Integer] the points of the player
-  def pointsForPlayer(player)
-    playerColor = player.color
-    longestPath = 0
-
-    outermostFieldsInCircuit = Array.new(Array.new)
-    visited = Array.new(Constants::SIZE).map {|j| Array.new(Constants::SIZE).map {|i| false}} #// all by default initialized to false
-    for x in 0..(Constants::SIZE-1)
-      for y in 0..(Constants::SIZE-1)
-        if visited[x][y] == false
-          if self.board.fields[x][y].ownerColor == playerColor
-            startOfCircuit = Array.new
-            startOfCircuit.push(self.board.fields[x][y])
-            circuit = self.circuit(startOfCircuit, Array.new)
-            for f in circuit
-              visited[f.x][f.y] = true
-            end
-            outermost = Array.new(2)
-            if playerColor == PlayerColor::RED
-
-              outermost[0] = self.bottomMostFieldInCircuit(circuit)
-              outermost[1] = self.topMostFieldInCircuit(circuit)
-            else
-              outermost[0] = leftMostFieldInCircuit(circuit)
-              outermost[1] = rightMostFieldInCircuit(circuit)
-            end
-            outermostFieldsInCircuit.push(outermost)
-
-          end
-          visited[x][y] = true
-        end
-      end
-    end
-    for fields in outermostFieldsInCircuit
-      if (playerColor == PlayerColor::RED && fields[1].y - fields[0].y > longestPath)
-        longestPath = fields[1].y - fields[0].y
-      end
-      if (playerColor == PlayerColor::BLUE && fields[1].x - fields[0].x > longestPath)
-        longestPath = fields[1].x - fields[0].x
-      end
-    end
-
-    return longestPath # return longestPath
-  end
-
-  # the following functions are helpers for the points calculation
-  def bottomMostFieldInCircuit(circuit)
-    bottomMostField = circuit[0]
-    for f in circuit
-      if f.y < bottomMostField.y
-        bottomMostField = f
-      end
-    end
-    return bottomMostField
-  end
-
-  def topMostFieldInCircuit(circuit)
-    topMostField = circuit[0]
-    for f in circuit
-      if f.y > topMostField.y
-        topMostField = f
-      end
-    end
-    return topMostField
-  end
-
-  def leftMostFieldInCircuit(circuit)
-    leftMostField = circuit[0]
-    for f in circuit
-      if f.x < leftMostField.x
-        leftMostField = f
-      end
-    end
-    return leftMostField
-  end
-
-  def rightMostFieldInCircuit(circuit)
-    rightMostField = circuit[0]
-    for f in circuit
-      if f.x > rightMostField.x
-        rightMostField = f
-      end
-    end
-    return rightMostField
-  end
-
-  def circuit(circuit, visited)
-    changed = false;
-    toBeAddedFields = Array.new
-    for f in circuit
-      if !visited.include?(f)
-        changed = true
-        visited.push(f)
-        for c in self.board.getConnections(f.x,f.y)
-          if !circuit.include?(self.board.fields[c.x2][c.y2])
-            toBeAddedFields.push(self.board.fields[c.x2][c.y2])
-          end
-          if !circuit.include?(self.board.fields[c.x1][c.y1])
-            toBeAddedFields.push(self.board.fields[c.x1][c.y1])
-          end
-        end
-      end
-    end
-    circuit.push(*toBeAddedFields)
-    if changed
-      return self.circuit(circuit, visited)
-    else
-      return circuit
-    end
-  end
-
-end
+  def points_for_player(player)
+    player_field = board.field(player.x, player.y)
+    POINTS_PER_TILE * player_field.index +
+      POINTS_PER_PASSENGER * player.passengers +
+      player_field.points
+  end
+
+  # @return [Boolean] true if the given field is occupied by the other (not
+  #                   current) player.
+  def occupied_by_other_player?(field)
+    field.x == other_player.x && field.y == other_player.y
+  end
+
+  # Compared with other state.
+  def ==(other)
+    turn == other.turn &&
+      start_player_color == other.start_player_color &&
+      current_player_color == other.current_player_color &&
+      red == other.red &&
+      blue == other.blue &&
+      board == other.board &&
+      lastMove == other.lastMove &&
+      free_acceleration == other.free_acceleration &&
+      condition == other.condition
+  end
+
+  # Create a deep copy of the gamestate. Can be used to perform moves on without
+  # changing the original gamestate.
+  def deep_clone
+    Marshal.load(Marshal.dump(self))
+  end
+end