software_challenge_client 0.1.5 → 0.2.0

data/lib/software_challenge_client/invalid_move_exception.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+# Exception indicating a move which was performed is not valid for the given
+# state.
+class InvalidMoveException < StandardError
+  def initialize(msg, move_or_action)
+    # This exception will be thrown by a move or by an individual action,
+    # depending where the rule violation was detected.
+    @move_or_action = move_or_action
+    super(msg)
+  end
+
+  def message
+    "#{super}: #{@move_or_action}"
+  end
+end

data/lib/software_challenge_client/logging.rb

@@ -0,0 +1,24 @@
+require 'logger'
+
+# This module provides a shared logger to all classes into which it is mixed.
+# See http://stackoverflow.com/a/6768164/390808
+#
+# Usage:
+#
+#   class MyClass
+#     include Logging
+#
+#     def a_method(x)
+#       logger.debug "you provided #{x}"
+#     end
+#   end
+module Logging
+  def logger
+    Logging.logger
+  end
+
+  # Global, memoized, lazy initialized instance of a logger
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+end

data/lib/software_challenge_client/move.rb

@@ -1,59 +1,60 @@
 # encoding: UTF-8
 require_relative 'debug_hint'
+require_relative 'action'
 
-# @author Ralf-Tobias Diekert
-# A move, that can be performed in twixt
+# A move that can be performed in Mississippi Queen. A move consists of multiple
+# actions in a specific order.
 class Move
-  # @!attribute [r] x
-  # @return [Integer] x-coordinate
-  attr_reader :x
-  # @!attribute [r] y
-  # @return [Integer] y-coordinate
-  attr_reader :y
+  # @!attribute [r] actions
+  #
+  # @return [Array<Action>] List of actions which should be performed in this
+  #                         move in the order determined by the array order.
+  attr_reader :actions
+
   # @!attribute [r] hints
   # @return [Array<DebugHint>] the move's hints
   attr_reader :hints
 
   # Initializer
   #
-  # @param x [Integer] x-coordinate
-  # @param y [Integer] y-coordinate
-  def initialize(x, y)
-    @x = x
-    @y = y
-    @hints = Array.new
+  def initialize
+    @actions = []
+    @hints = []
   end
 
-  # @overload addHint(hint)
   # adds a hint to the move
   # @param hint [DebugHint] the added hint
-  # @overload addHint(key, value)
-  # adds a hint to the move
-  # @param key the added hint's key
-  # @param value the added hint's value
-  # @overload addHint(string)
-  # adds a hint to the move
-  # @param hint [String] the added hint's content
-  def addHint(hint)
-    @hints.push(hint);
+  def add_hint(hint)
+    @hints.push(hint)
   end
 
-  # adds a hint to the move
-  def addHint(key, value)
-    self.addHint(DebugHint.new(key, value))
+  def ==(other)
+    actions.size == other.actions.size &&
+      actions.zip(other.actions).map { |a, b| a == b }.all?
   end
 
-  # adds a hint to the move
-  def addHint(string)
-    self.addHint(DebugHint.new(string))
+  def to_s
+    "Move: #{actions}"
   end
 
-  def ==(another_move)
-    return self.x == another_move.x && self.y == another_move.y
+  def add_action(action)
+    @actions << action
   end
 
-  def to_s
-    return "Move:(#{self.x},#{self.y})"
+  def add_action_with_order(action, index)
+    @actions[index] = action
   end
 
-end
+  def perform!(gamestate, current_player)
+    # check if acceleration is only first action
+    other_action_before = false
+    @actions.each do |a|
+      if a.type != :acceleration
+        other_action_before = true
+      elsif other_action_before
+        raise InvalidMoveException.new('Beschleunigung muss am Anfang des Zuges geschehen.', self)
+      end
+    end
+    @actions.each { |a| a.perform!(gamestate, current_player) }
+  end
+end

data/lib/software_challenge_client/network.rb

@@ -1,14 +1,17 @@
 # encoding: UTF-8
 require 'socket'
+require 'rexml/document'
+require 'rexml/element'
+
 require_relative 'protocol'
 require_relative 'board'
 require_relative 'client_interface'
-require 'rexml/document'
-require 'rexml/element'
 
-# @author Ralf-Tobias Diekert
 # This class handles the socket connection to the server
 class Network
+
+  include Logging
+
   @socket
   @host
   @port
@@ -31,8 +34,6 @@ class Network
     @protocol = Protocol.new(self, @client)
     @reservationID = reservation || ''
     @receiveBuffer = ''
-
-    puts '> Network/Socket created.'
   end
 
   # connects the client with a given server
@@ -40,6 +41,7 @@ class Network
   # @return [Boolean] true, if successfully connected to the server
   def connect
     @socket = TCPSocket.open(@host, @port)
+    logger.info 'Connection to server established.'
     @connected = true
 
     self.sendString('<protocol>')
@@ -52,7 +54,7 @@ class Network
     else
       document = REXML::Document.new
       element = REXML::Element.new('join')
-      element.add_attribute('gameType', 'swc_2016_twixt')
+      element.add_attribute('gameType', 'swc_2017_mississippi_queen')
       document.add(element)
       self.sendXML(document)
     end
@@ -67,12 +69,12 @@ class Network
       @connected = false
       @socket.close
     end
-    puts '> Disconnected.'
+    logger.info 'Connection to server closed.'
   end
 
   # reads from the socket until "</room>" is read
   def readString
-    puts 'reading'
+    logger.debug 'reading'
     sockMsg = ''
     if(!@connected)
       return
@@ -80,8 +82,7 @@ class Network
 
     line =''
     char = ''
-    while line!="</room>"
-      char = @socket.getc
+    while line != "</room>" && !(char = @socket.getc).nil?
       line+=char
       if char=='\n' || char==' '
 
@@ -89,7 +90,7 @@ class Network
       end
       sockMsg += char
     end
-    puts 'ended reading'
+    logger.debug 'ended reading'
     if sockMsg != ''
 
       @receiveBuffer.concat(sockMsg)
@@ -97,12 +98,10 @@ class Network
       # Remove <protocol> tag
       @receiveBuffer = @receiveBuffer.gsub('<protocol>', '')
 
-      puts 'Receive:'
-      puts ''
-      #puts @receiveBuffer
+      logger.debug "Received XML from server: #{@receiveBuffer}"
 
       # Process text
-      @protocol.processString('<msg>'+@receiveBuffer+'</msg>');
+      @protocol.process_string("<msg>#{@receiveBuffer}</msg>");
       self.emptyReceiveBuffer
     end
     return true
@@ -129,15 +128,13 @@ class Network
   def sendString(s)
     if(@connected)
       @socket.print(s);
-      puts 'Send:'
-      puts ''
-      puts(s);
+      logger.debug "Sending: #{s}"
     end
   end
 
   # sends a xml Document to the buffer
   #
-  # @param xml [REXML::Docuent] the Document, that will be sent
+  # @param xml [REXML::Document] the Document, that will be sent
   def sendXML(xml)
     text  = ''
     xml.write(text)

data/lib/software_challenge_client/player.rb

@@ -1,25 +1,62 @@
 # encoding: UTF-8
-require_relative 'player_color'
 
-# @author Ralf-Tobias Diekert
-# A player, participating at a game
+# A player, participating in a game
 class Player
+  # @!attribute [r] name
+  # @return [PlayerColor] the player's name
+  attr_reader :name
+
   # @!attribute [r] color
   # @return [PlayerColor] the player's color
   attr_reader :color
+
   # @!attribute [rw] points
   # @return [Integer] the player's points
   attr_accessor :points
 
+  # @!attribute [rw] velocity
+  # @return [Integer] the player's current velocity
+  attr_accessor :velocity
+
+  # @!attribute [rw] coal
+  # @return [Integer] the player's current coal supply
+  attr_accessor :coal
+
+  # @!attribute [rw] direction
+  # @return [Direction] the player's current direction
+  attr_accessor :direction
+
+  # @!attribute [rw] x
+  # @return [Direction] the player's current x-position
+  attr_accessor :x
+
+  # @!attribute [rw] y
+  # @return [Direction] the player's current y-position
+  attr_accessor :y
+
+  # @!attribute [rw] movement
+  # @return [Direction] the player's current movement points
+  attr_accessor :movement
+
+  # @!attribute [rw] passengers
+  # @return [Integer] how many passengers the player's has picked up
+  attr_accessor :passengers
+
   # Initializer
-  # @param the new player's color
-  def initialize(color)
+  # @param color [PlayerColor] the new player's color
+  # @param name [String] the new player's name (for displaying)
+  def initialize(color, name)
     @color = color
-    self.points = 0
+    @name = name
+    @points = 0
+    @velocity = 1
+    @movement = 1
+    @coal = 6
+    @passengers = 0
+    @direction = Direction::RIGHT
   end
 
-  def ==(another_player)
-    return self.color == another_player.color
+  def ==(other)
+    color == other.color
   end
-
-end
+end

data/lib/software_challenge_client/player_color.rb

@@ -1,10 +1,11 @@
 # encoding: UTF-8
-# @author Ralf-Tobias Diekert
-#player color constants
-module PlayerColor
-  NONE = 1
-  RED = 2
-  BLUE = 4
+# player color constants
+require 'typesafe_enum'
+class PlayerColor < TypesafeEnum::Base
+
+  new :NONE
+  new :RED
+  new :BLUE
 
   # Returns the opponents Color
   #
@@ -21,4 +22,4 @@ module PlayerColor
       return PlayerColor::NONE
     end
   end
-end
+end

data/lib/software_challenge_client/protocol.rb

@@ -1,43 +1,46 @@
 # encoding: UTF-8
+# frozen_string_literal: true
 require 'socket'
 require_relative 'board'
 require_relative 'move'
 require_relative 'player'
 require_relative 'network'
-require_relative 'connection'
 require_relative 'client_interface'
 require 'rexml/document'
 require 'rexml/streamlistener'
+require 'builder'
 
-# @author Ralf-Tobias Diekert
-# This class handles the parsing of xml strings according to the network protocol of twixt
+# This class handles communication to the server over the XML communication
+# protocol. Messages from the server are parsed and moves are serialized and
+# send back.
 class Protocol
+  include Logging
   include REXML::StreamListener
 
   # @!attribute [r] gamestate
   # @return [Gamestate] current gamestate
   attr_reader :gamestate
-  # @!attribute [rw] roomID
+  # @!attribute [rw] roomId
   # @return [String] current room id
-  attr_accessor :roomID
+  attr_accessor :roomId
   # @!attribute [r] client
   # @return [ClientInterface] current client
   attr_reader :client
-  @network
 
   def initialize(network, client)
     @gamestate = GameState.new
-    @network, @client = network, client
-    self.client.gamestate = self.gamestate
+    @network = network
+    @client = client
+    @context = {} # for saving context when stream-parsing the XML
+    @client.gamestate = @gamestate
   end
 
   # starts xml-string parsing
   #
   # @param text [String] the xml-string that will be parsed
-  def processString(text)
-    list = self
-    #puts "Parse XML:\n#{text}\n----END XML"
-    REXML::Document.parse_stream(text, list)
+  def process_string(text)
+    logger.debug "Parse XML:\n#{text}\n----END XML"
+    REXML::Document.parse_stream(text, self)
   end
 
   # called if an end-tag is read
@@ -45,10 +48,10 @@ class Protocol
   # @param name [String] the end-tag name, that was read
   def tag_end(name)
     case name
-    when "board"
-      puts @gamestate.board.to_s
-    when "condition"
-      puts "Game ended"
+    when 'board'
+      logger.debug @gamestate.board.to_s
+    when 'condition'
+      logger.info 'Game ended'
       @network.disconnect
     end
   end
@@ -61,85 +64,91 @@ class Protocol
   # @param attrs [Dictionary<String, String>] Attributes attached to the tag
   def tag_start(name, attrs)
     case name
-    when "room"
-      @roomID = attrs['roomId']
-      puts "roomId : "+@roomID
-    when "data"
-      puts "data(class) : "+attrs['class']
-      if attrs['class'] == "sc.framework.plugins.protocol.MoveRequest"
-        @client.gamestate = self.gamestate
+    when 'room'
+      @roomId = attrs['roomId']
+      logger.info 'roomId : ' + @roomId
+    when 'data'
+      logger.debug "data(class) : #{attrs['class']}"
+      if attrs['class'] == 'sc.framework.plugins.protocol.MoveRequest'
+        @client.gamestate = gamestate
         move = @client.getMove
-        document = REXML::Document.new
-        document.add_element('room',{'roomId' => @roomID})
-        data = REXML::Element.new('data')
-        data.add_attribute('class', 'move')
-        data.add_attribute('x', move.x)
-        data.add_attribute('y', move.y)
-        document.root.add_element(data)
-        for h in move.hints
-          hint = REXML::Element.new('hint')
-          hint.add_attribute('content', h.content)
-          document.root.elements['data'].elements << hint
-        end
-        self.sendXml(document)
+        sendString(move_to_xml(move))
       end
-      if attrs['class'] == "error"
-        puts "Game ended - ERROR"
-        puts attrs['message']
+      if attrs['class'] == 'error'
+        logger.info "Game ended - ERROR: #{attrs['message']}"
         @network.disconnect
       end
-    when "state"
-      puts 'new gamestate'
+    when 'state'
+      logger.debug 'new gamestate'
+      @gamestate = GameState.new
       @gamestate.turn = attrs['turn'].to_i
-      @gamestate.startPlayerColor = attrs['startPlayer'] == 'RED' ? PlayerColor::RED : PlayerColor::BLUE
-      @gamestate.currentPlayerColor = attrs['currentPlayer'] == 'RED' ? PlayerColor::RED : PlayerColor::BLUE
-      puts "Turn: #{@gamestate.turn}"
-    when "red"
-      puts 'new red player'
-      @gamestate.addPlayer(Player.new(attrs['color'] == 'RED' ? PlayerColor::RED : PlayerColor::BLUE))
-      @gamestate.red.points = attrs['points'].to_i
-    when "blue"
-      puts 'new blue player'
-      @gamestate.addPlayer(Player.new(attrs['color'] == 'RED' ? PlayerColor::RED : PlayerColor::BLUE))
-      @gamestate.blue.points = attrs['points'].to_i
-    when "board"
-      puts 'new board'
-      @gamestate.board = Board.new(true)
-    when "field"
-      type = FieldType::NORMAL
-      ownerColor = PlayerColor::NONE
-      case attrs['type']
-      when 'SWAMP'
-        type = FieldType::SWAMP
-      when 'RED'
-        type = FieldType::RED
-      when 'BLUE'
-        type = FieldType::BLUE
-      when "winner"
-        puts "Game ended"
-        @network.disconnect
-      end
-
-      case attrs['owner']
-      when 'RED'
-        ownerColor = PlayerColor::RED
-      when 'BLUE'
-        ownerColor = PlayerColor::BLUE
-      end
+      @gamestate.start_player_color = attrs['startPlayer'] == 'RED' ? PlayerColor::RED : PlayerColor::BLUE
+      @gamestate.current_player_color = attrs['currentPlayer'] == 'RED' ? PlayerColor::RED : PlayerColor::BLUE
+      @gamestate.additional_free_turn_after_push = attrs['freeTurn'] == 'true'
+      logger.debug "Turn: #{@gamestate.turn}"
+    when 'red'
+      logger.debug 'new red player'
+      @gamestate.add_player(parsePlayer(PlayerColor::RED, attrs))
+    when 'blue'
+      logger.debug 'new blue player'
+      @gamestate.add_player(parsePlayer(PlayerColor::BLUE, attrs))
+    when 'board'
+      logger.debug 'new board'
+      @gamestate.board = Board.new
+      @context[:current_tile_index] = nil
+      @context[:current_tile_direction] = nil
+    when 'tile'
+      @context[:current_tile_index] = attrs['index'].to_i
+      @context[:current_tile_direction] = attrs['direction'].to_i
+    when 'field'
+      type = FieldType.find_by_key(attrs['type'].to_sym)
+      raise "unexpected field type: #{attrs['type']}. Known types are #{FieldType.map { |t| t.key.to_s }}" if type.nil?
       x = attrs['x'].to_i
       y = attrs['y'].to_i
+      points = attrs['points'].to_i
+      index = @context[:current_tile_index]
+      direction = @context[:current_tile_direction]
 
-      @gamestate.board.fields[x][y] = Field.new(type, x, y)
-      @gamestate.board.fields[x][y].ownerColor = ownerColor
-    when "connection"
-      @gamestate.board.connections.push(Connection.new(attrs['x1'].to_i, attrs['y1'].to_i, attrs['x2'].to_i, attrs['y2'].to_i, attrs['owner']))
-    when "lastMove"
-      @gamestate.lastMove = Move.new(attrs['x'], attrs['y'])
-    when "condition"
+      @gamestate.board.fields[[x, y]] = Field.new(type, x, y, index, direction, points)
+    when 'lastMove'
+      @gamestate.lastMove = Move.new
+    when 'acceleration'
+      @gamestate.lastMove.add_action_with_order(Acceleration.new(attrs['acc'].to_i), attrs['order'].to_i)
+    when 'advance'
+      @gamestate.lastMove.add_action_with_order(Advance.new(attrs['distance'].to_i), attrs['order'].to_i)
+    when 'turn'
+      @gamestate.lastMove.add_action_with_order(Turn.new(attrs['direction'].to_i), attrs['order'].to_i)
+    when 'push'
+      @gamestate.lastMove.add_action_with_order(Push.new(Direction.find_by_key(attrs['direction'].to_sym)), attrs['order'].to_i)
+    when 'condition'
       @gamestate.condition = Condition.new(attrs['winner'], attrs['reason'])
     end
   end
 
+  # Converts XML attributes for a Player to a new Player object
+  #
+  # @param expectedColor [PlayerColor] Color the player should have. Method will
+  # throw an exception when expectedColor and color in attributes don't match.
+  # @param attributes [Hash] Attributes for the new Player.
+  # @return [Player] The created Player object.
+  def parsePlayer(expectedColor, attributes)
+    player = Player.new(
+      PlayerColor.find_by_key(attributes['color'].to_sym),
+      attributes['displayName']
+    )
+    if player.color != expectedColor
+      throw new IllegalArgumentException("expected #{expectedColor} Player but got #{attributes['color']}")
+    end
+    player.points = attributes['points'].to_i
+    player.direction = Direction.find_by_key(attributes['direction'].to_sym)
+    player.x = attributes['x'].to_i
+    player.y = attributes['y'].to_i
+    player.passengers = attributes['passenger'].to_i
+    player.velocity = attributes['speed'].to_i
+    player.movement = player.velocity
+    player
+  end
+
   # send a xml document
   #
   # @param document [REXML::Document] the document, that will be send to the connected server
@@ -147,4 +156,43 @@ class Protocol
     @network.sendXML(document)
   end
 
+  # send a string
+  #
+  # @param document [String] The string that will be send to the connected server.
+  def sendString(string)
+    @network.sendString("<room roomId=\"#{@roomId}\">#{string}</room>")
+  end
+
+  # Converts a move to XML for sending to the server.
+  #
+  # @param move [Move] The move to convert to XML.
+  def move_to_xml(move)
+    builder = Builder::XmlMarkup.new(indent: 2)
+    builder.data(class: 'move') do |data|
+      move.actions.each_with_index do |action, index|
+        # Converting every action type here instead of requiring the Action
+        # class interface to supply a method which returns the action hash
+        # because XML-generation should be decoupled from internal data
+        # structures.
+        attribute = case action.type
+                    when :acceleration
+                      { acc: action.acceleration }
+                    when :push, :turn
+                      { direction: action.direction }
+                    when :advance
+                      { distance: action.distance }
+                    when default
+                      raise "unknown action type: #{action.type.inspect}. "\
+                            "Can't convert to XML!"
+                    end
+        attribute[:order] = index
+        data.tag!(action.type, attribute)
+      end
+    end
+    move.hints.each do |hint|
+      data.hint(content: hint.content)
+    end
+    builder.target!
+  end
+
 end