software_challenge_client 22.1.0.1 → 23.0.2

data/lib/software_challenge_client/network.rb

@@ -1,126 +1,126 @@
-# encoding: UTF-8
-# frozen_string_literal: false
-
-require 'socket'
-require 'rexml/document'
-require 'rexml/element'
-
-require_relative 'protocol'
-require_relative 'board'
-require_relative 'client_interface'
-require_relative 'util/constants'
-
-# This class handles the socket connection to the server
-class Network
-  include Logging
-  include Constants
-
-  # @!attribute [r] connected
-  # @return [Boolean] true, if the client is connected to a server
-  attr_reader :connected
-
-  def initialize(host, port, board, client, reservation = nil)
-    @host = host
-    @port = port
-    @board = board
-    @client = client
-
-    @connected = false
-    @protocol = Protocol.new(self, @client)
-    @reservation_id = reservation || ''
-    @receive_buffer = ''
-  end
-
-  # connects the client with a given server
-  #
-  # @return [Boolean] true, if successfully connected to the server
-  def connect
-    @socket = TCPSocket.open(@host, @port)
-    logger.info 'Connection to server established.'
-    @connected = true
-
-    sendString('<protocol>')
-    document = REXML::Document.new
-    if @reservation_id != ''
-      element = REXML::Element.new('joinPrepared')
-      element.add_attribute('reservationCode', @reservation_id)
-    else
-      element = REXML::Element.new('join')
-      element.add_attribute('gameType', GAME_IDENTIFIER)
-    end
-    document.add(element)
-    sendXML(document)
-    @connected
-  end
-
-  # disconnects the client from a server
-  def disconnect
-    if @connected
-      sendString('</protocol>')
-      @connected = false
-      @socket.close
-    end
-    logger.info 'Connection to server closed.'
-  end
-
-  # reads from the socket until "</room>" is read
-  def readString
-    return false unless @connected
-    sock_msg = ''
-
-    line = ''
-    @socket.each_char do |char|
-      line += char
-      sock_msg += char
-      line = '' if ['\n', ' '].include? char
-      break if ['</room>', '</protocol>'].include? line
-    end
-    if sock_msg != ''
-      @receive_buffer.concat(sock_msg)
-
-      # Remove <protocol> tag
-      @receive_buffer = @receive_buffer.gsub('<protocol>', '')
-      @receive_buffer = @receive_buffer.gsub('</protocol>', '')
-
-      logger.debug "Received XML from server: #{@receive_buffer}"
-
-      # Process text
-      @protocol.process_string(@receive_buffer)
-      emptyReceiveBuffer
-    end
-    true
-  end
-
-  # sends a xml Document to the buffer
-  #
-  # @param xml [REXML::Document] the Document, that will be sent
-  def sendXML(xml)
-    text = ''
-    xml.write(text)
-    sendString(text)
-  end
-
-  # processes an incomming message
-  #
-  # @return [Boolean] true, if the processing of a incomming message was successfull
-  def processMessages
-    return false unless @connected
-    readString
-  end
-
-  # sends a string to the socket
-  #
-  # @param s [String] the message, to be sent
-  def sendString(s)
-    return unless @connected
-    logger.debug "Sending: #{s}"
-    @socket.print(s)
-  end
-
-  private
-
-  # empties the receive buffer
-  def emptyReceiveBuffer
-    @receive_buffer = ''
-  end
-end
+# encoding: UTF-8
+# frozen_string_literal: false
+
+require 'socket'
+require 'rexml/document'
+require 'rexml/element'
+
+require_relative 'protocol'
+require_relative 'board'
+require_relative 'client_interface'
+require_relative 'util/constants'
+
+# This class handles the socket connection to the server
+class Network
+  include Logging
+  include Constants
+
+  # @!attribute [r] connected
+  # @return [Boolean] true, if the client is connected to a server
+  attr_reader :connected
+
+  def initialize(host, port, board, client, reservation = nil)
+    @host = host
+    @port = port
+    @board = board
+    @client = client
+
+    @connected = false
+    @protocol = Protocol.new(self, @client)
+    @reservation_id = reservation || ''
+    @receive_buffer = ''
+  end
+
+  # connects the client with a given server
+  #
+  # @return [Boolean] true, if successfully connected to the server
+  def connect
+    @socket = TCPSocket.open(@host, @port)
+    logger.info 'Connection to server established.'
+    @connected = true
+
+    sendString('<protocol>')
+    document = REXML::Document.new
+    if @reservation_id != ''
+      element = REXML::Element.new('joinPrepared')
+      element.add_attribute('reservationCode', @reservation_id)
+    else
+      element = REXML::Element.new('join')
+      element.add_attribute('gameType', GAME_IDENTIFIER)
+    end
+    document.add(element)
+    sendXML(document)
+    @connected
+  end
+
+  # disconnects the client from a server
+  def disconnect
+    if @connected
+      sendString('</protocol>')
+      @connected = false
+      @socket.close
+    end
+    logger.info 'Connection to server closed.'
+  end
+
+  # reads from the socket until "</room>" is read
+  def readString
+    return false unless @connected
+    sock_msg = ''
+
+    line = ''
+    @socket.each_char do |char|
+      line += char
+      sock_msg += char
+      line = '' if ['\n', ' '].include? char
+      break if ['</room>', '</protocol>'].include? line
+    end
+    if sock_msg != ''
+      @receive_buffer.concat(sock_msg)
+
+      # Remove <protocol> tag
+      @receive_buffer = @receive_buffer.gsub('<protocol>', '')
+      @receive_buffer = @receive_buffer.gsub('</protocol>', '')
+
+      logger.debug "Received XML from server: #{@receive_buffer}"
+
+      # Process text
+      @protocol.process_string(@receive_buffer)
+      emptyReceiveBuffer
+    end
+    true
+  end
+
+  # sends a xml Document to the buffer
+  #
+  # @param xml [REXML::Document] the Document, that will be sent
+  def sendXML(xml)
+    text = ''
+    xml.write(text)
+    sendString(text)
+  end
+
+  # processes an incomming message
+  #
+  # @return [Boolean] true, if the processing of a incomming message was successfull
+  def processMessages
+    return false unless @connected
+    readString
+  end
+
+  # sends a string to the socket
+  #
+  # @param s [String] the message, to be sent
+  def sendString(s)
+    return unless @connected
+    logger.debug "Sending: #{s}"
+    @socket.print(s)
+  end
+
+  private
+
+  # empties the receive buffer
+  def emptyReceiveBuffer
+    @receive_buffer = ''
+  end
+end

data/lib/software_challenge_client/piece.rb

@@ -1,81 +1,43 @@
-# frozen_string_literal: true
-
-# Ein Spielstein mit Ausrichtung, Koordinaten und Farbe
-class Piece
-  include Constants
-  
-  # @!attribute [rw] Color
-  # @return [Color]
-  attr_accessor :color
-
-  # @!attribute [r] Typ des Spielsteins
-  # @return [PieceType]
-  attr_reader :type
-
-  # @!attribute [rw] Koordinaten
-  # @return [Coordinates]
-  attr_accessor :position
-
-  # @!attribute [rw] tower_height
-  # @return [Integer] Die Anzahl Spielsteine übereinander inklusive des obersten
-  attr_accessor :height
-
-  # Erstellt einen neuen Spielstein.
-  def initialize(color, type, position = Coordinates.origin, height = 0)
-    @color = color
-    @type = type
-    @position = position
-    @height = height
-  end
-
-  # Berechnet die Koordinaten zu denen sich dieser Spielstein bewegen könnte.
-  #
-  # @return [Array<Coordinates>] Die Zielkoordinaten 
-  def target_coords
-    xdir = 0
-    if color == Color::RED
-      xdir = 1
-    else
-      xdir = -1
-    end
-
-    case type
-    when PieceType::Herzmuschel
-      coords = [Coordinates.new(xdir,-1), Coordinates.new(xdir,1)]
-    when PieceType::Moewe
-      coords = [Coordinates.new(1,0), Coordinates.new(-1,0), Coordinates.new(0,1), 
-        Coordinates.new(0,-1)]
-    when PieceType::Seestern
-      coords = [Coordinates.new(xdir,0), Coordinates.new(1,1), Coordinates.new(-1,1), 
-        Coordinates.new(1,-1), Coordinates.new(-1,-1)]
-    when PieceType::Robbe
-      coords = [Coordinates.new(-1,2), Coordinates.new(1,2), Coordinates.new(-2,1), 
-        Coordinates.new(2,1), Coordinates.new(-1,-2), Coordinates.new(1,-2), 
-        Coordinates.new(-2,-1), Coordinates.new(2,-1)]
-    end
-
-    coords.map{ |x| x + position }.to_a
-    coords.map{ |x| x + position }.select{ |c| c.x >= 0 && c.y >=0 && c.x < BOARD_SIZE && c.y < BOARD_SIZE}.to_a
-  end
-
-  def ==(other)
-    !other.nil? &&
-      color == other.color &&
-      position == other.position &&
-      type == other.type
-  end
-
-  # @return [String] Gibt die String-Repräsentation zurück
-  def to_s
-    "#{color.key} #{type.key} at #{position}"
-  end
-
-  # @return [String] Gibt eine Kurzfassung der String-Repräsentation zurück
-  def to_ss
-    "#{color.key.to_s[0]}#{type.key.to_s[0]}"
-  end
-
-  def inspect
-    to_s
-  end
-end
+# frozen_string_literal: true
+
+require_relative 'direction'
+
+# Ein Spielstein mit Ausrichtung, Koordinaten und Farbe
+class Piece
+  include Constants
+  
+  # @!attribute [rw] Team
+  # @return [Team]
+  attr_accessor :team
+
+  # @!attribute [rw] Koordinaten
+  # @return [Coordinates]
+  attr_accessor :coords
+
+  # Erstellt einen neuen Spielstein.
+  def initialize(team, coords = Coordinates.origin)
+    @team = team
+    @coords = coords
+  end
+
+  def ==(other)
+    !other.nil? &&
+      team == other.team &&
+      coords == other.coords
+  end
+
+  # @return [String] Gibt die String-Repräsentation zurück
+  def to_s
+    "#{team.key} at #{coords}"
+  end
+
+  # To short string
+  # @return [String] Gibt eine Kurzfassung der String-Repräsentation zurück
+  def to_ss
+    "#{team.key.to_s[0]}"
+  end
+
+  def inspect
+    to_s
+  end
+end

data/lib/software_challenge_client/player.rb

@@ -1,31 +1,31 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# Ein Spieler
-class Player
-  # @!attribute [r] name
-  # @return [String] der Name des Spielers, hat keine Auswirkungen auf das Spiel
-  attr_reader :name
-
-  # @!attribute [r] color
-  # @return [Color] erster (Color::RED) oder zweiter (Color::BLUE) Spieler
-  attr_reader :color
-
-  # @!attribute [rw] amber
-  # @return [Integer] Anzahl Bernsteine die dieser Spieler gesammelt hat
-  attr_accessor :amber
-
-  # Konstruktor
-  # @param type [Color] Rot oder blau
-  # @param name [String] Name
-  # @param amber [Integer] Menge des Bernsteins die der Spieler hat
-  def initialize(color, name, amber = 0)
-    @color = color
-    @name = name
-    @amber = amber
-  end
-
-  def ==(other)
-    color == other.color
-  end
-end
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Ein Spieler
+class Player
+  # @!attribute [r] name
+  # @return [String] der Name des Spielers, hat keine Auswirkungen auf das Spiel
+  attr_reader :name
+
+  # @!attribute [r] team
+  # @return [Team] erster (Team::ONE) oder zweiter (Team::TWO) Spieler
+  attr_reader :team
+
+  # @!attribute [rw] fishes
+  # @return [Integer] Anzahl Fische die dieser Spieler gesammelt hat
+  attr_accessor :fishes
+
+  # Konstruktor
+  # @param type [Team] One oder Two
+  # @param name [String] Name
+  # @param amber [Integer] Menge der Fische die der Spieler hat
+  def initialize(team, name, fishes = 0)
+    @team = team
+    @name = name
+    @fishes = fishes
+  end
+
+  def ==(other)
+    team == other.team
+  end
+end

data/lib/software_challenge_client/protocol.rb

@@ -3,7 +3,6 @@
 require 'socket'
 require_relative 'board'
 require_relative 'move'
-require_relative 'piece_type'
 require_relative 'player'
 require_relative 'network'
 require_relative 'client_interface'
@@ -28,12 +27,25 @@ class Protocol
   # @return [ClientInterface] current client
   attr_reader :client
 
+  # @!attribute [rw] x
+  # @return [Integer] x
+  attr_reader :x
+  # @!attribute [rw] y
+  # @return [Integer] y
+  attr_reader :y
+  # @!attribute [rw] i
+  # @return [Integer] i
+  attr_reader :i
+
   def initialize(network, client)
     @gamestate = GameState.new
     @network = network
     @client = client
     @context = {} # for saving context when stream-parsing the XML
     @client.gamestate = @gamestate
+    @x = 0
+    @y = 0
+    @i = 0
   end
 
   # starts xml-string parsing
@@ -42,7 +54,7 @@ class Protocol
   def process_string(text)
     #logger.debug "Parse XML:\n#{text}\n----END XML"
     begin
-      REXML::Document.parse_stream(text, self)
+      REXML::Document.parse_stream(text.encode('UTF-8', :invalid => :replace, :undef => :replace), self)
     rescue REXML::ParseException => e
       # to parse incomplete xml, ignore missing end tag exceptions
       raise e unless e.message =~ /Missing end tag/
@@ -54,34 +66,6 @@ class Protocol
     @context[:last_text] = text
   end
 
-  # called if an end-tag is read
-  #
-  # @param name [String] the end-tag name, that was read
-  def tag_end(name)
-    case name
-    when 'board'
-      logger.debug @gamestate.board.to_s
-    when 'startTeam'
-      @gamestate.add_player(Player.new(Color::RED, "ONE", 0))
-      @gamestate.add_player(Player.new(Color::BLUE, "TWO", 0))
-      if @context[:last_text] == "ONE"
-        @gamestate.start_team = @gamestate.player_one
-      else
-        @gamestate.start_team = @gamestate.player_two
-      end
-    when 'team'
-      @context[:team] = @context[:last_text]
-    when 'int'
-      if @context[:team] == "ONE"
-        logger.info 'Got player one amber'
-        @gamestate.player_one.amber = @context[:last_text].to_i
-      else
-        logger.info 'Got player two amber'
-        @gamestate.player_two.amber = @context[:last_text].to_i
-      end
-    end
-  end
-
   # called if a start tag is read
   # Depending on the tag the gamestate is updated
   # or the client will be asked for a move
@@ -98,6 +82,14 @@ class Protocol
       @context[:data_class] = attrs['class']
       if attrs['class'] == 'moveRequest'
         @client.gamestate = gamestate
+        if gamestate.turn == 0
+          gamestate.myself_player = gamestate.start_player
+          logger.debug "I am #{gamestate.myself_player}"
+        elsif gamestate.turn == 1
+          gamestate.myself_player = gamestate.not_player(gamestate.start_player) 
+          logger.debug "I am #{gamestate.myself_player}"
+        end
+        gamestate.current_player = gamestate.myself_player
         move = @client.move_requested
         sendString(move_to_xml(move))
       end
@@ -112,32 +104,35 @@ class Protocol
       end
     when 'state'
       logger.debug 'new gamestate'
-      @gamestate = GameState.new
+      #@gamestate = GameState.new
       @gamestate.turn = attrs['turn'].to_i
       logger.debug "Round: #{@gamestate.round}, Turn: #{@gamestate.turn}"
     when 'board'
+      @x = 0
+      @y = 0
+      @i = 0
       logger.debug 'new board'
       @gamestate.board = Board.new()
-    when 'pieces'
-      @context[:entry] = :pieces
-    when 'coordinates'
-      @context[:x] = attrs['x'].to_i
-      @context[:y] = attrs['y'].to_i
-    when 'piece'
-      x = @context[:x]
-      y = @context[:y]
-      team = Team.find_by_key(attrs['team'].to_sym)
-      type = PieceType.find_by_key(attrs['type'].to_sym)
-      count = attrs['count'].to_i
-      field = Field.new(x, y, Piece.new(team.to_c, type, Coordinates.new(x, y), count))
-      @gamestate.board.add_field(field)
-    when 'from'
-      @context[:from] = Coordinates.new(attrs['x'].to_i, attrs['y'].to_i)
-    when 'to'
-      from = @context[:from]
-      @gamestate.last_move = Move.new(Coordinates.new(from.x, from.y), Coordinates.new(attrs['x'].to_i, attrs['y'].to_i))
-    when 'ambers'
-      @context[:entry] = :ambers
+    # when 'pieces'
+    #   @context[:entry] = :pieces
+    # when 'coordinates'
+    #   @context[:x] = attrs['x'].to_i
+    #   @context[:y] = attrs['y'].to_i
+    # when 'piece'
+    #   x = @context[:x]
+    #   y = @context[:y]
+    #   team = Team.find_by_key(attrs['team'].to_sym)
+    #   type = PieceType.find_by_key(attrs['type'].to_sym)
+    #   count = attrs['count'].to_i
+    #   field = Field.new(x, y, Piece.new(team.to_c, type, Coordinates.new(x, y), count))
+    #   @gamestate.board.add_field(field)
+    # when 'from'
+    #   @context[:from] = Coordinates.new(attrs['x'].to_i, attrs['y'].to_i)
+    # when 'to'
+    #   from = @context[:from]
+    #   @gamestate.last_move = Move.new(Coordinates.new(from.x, from.y), Coordinates.new(attrs['x'].to_i, attrs['y'].to_i))
+    # when 'ambers'
+    #   @context[:entry] = :ambers
     when 'winner'
       # TODO
       # winning_player = parsePlayer(attrs)
@@ -155,6 +150,50 @@ class Protocol
     end
   end
 
+  # called if an end-tag is read
+  #
+  # @param name [String] the end-tag name, that was read
+  def tag_end(name)
+    case name
+    when 'board'
+      logger.debug @gamestate.board.to_s
+    when 'startTeam'
+      @gamestate.add_player(Player.new(Team::ONE, "ONE", 0))
+      @gamestate.add_player(Player.new(Team::TWO, "TWO", 0))
+      if @context[:last_text] == "ONE"
+        @gamestate.start_player = @gamestate.player_one
+      else
+        @gamestate.start_player = @gamestate.player_two
+      end
+    when 'int'
+      @i += 1
+      if i == 1
+        logger.info 'Got player one fishes'
+        @gamestate.player_one.fishes = @context[:last_text].to_i
+      elsif i == 2
+        logger.info 'Got player two fishes'
+        @gamestate.player_two.fishes = @context[:last_text].to_i
+      else
+        logger.info 'We got a problemo'
+      end
+    when 'list'
+      @y += 1
+      @x = 0
+    when 'field'
+      if @context[:last_text] == "ONE"
+        field = Field.new(@x, @y, Piece.new(Team::ONE, Coordinates.new(@x, @y)))
+      elsif @context[:last_text] == "TWO"
+        field = Field.new(@x, @y, Piece.new(Team::TWO, Coordinates.new(@x, @y)))
+      else
+        field = Field.new(@x, @y, nil, @context[:last_text].to_i)
+      end
+      @gamestate.board.add_field(field)
+      @x += 1
+    else
+      why = 'tho'
+    end
+  end
+
   # send a xml document
   #
   # @param document [REXML::Document] the document, that will be send to the connected server
@@ -191,9 +230,19 @@ class Protocol
     # because XML-generation should be decoupled from internal data
     # structures.
 
-    builder.data(class: 'move') do |d|
-      d.from(x: move.from.x, y: move.from.y)
-      d.to(x: move.to.x, y: move.to.y)
+    to_d = Coordinates.oddr_to_doubled(move.to)
+
+    if move.from.nil?
+      builder.data(class: 'move') do |d|
+        d.to(x: to_d.x, y: to_d.y)
+      end
+    else
+      from_d = Coordinates.oddr_to_doubled(move.from)
+
+      builder.data(class: 'move') do |d|
+        d.from(x: from_d.x, y: from_d.y)
+        d.to(x: to_d.x, y: to_d.y)
+      end
     end
     
     builder.target!