software_challenge_client 22.0.3 → 22.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92678f5a67447b172349fea0f7facbb15a8343281a0cce26eae7de0193088d0a
-  data.tar.gz: 9d5ece5e7a2660d79300a99825489ebe0ac73135c2a30f7a9549bb17c59ea188
+  metadata.gz: 910f87c3bca7d1aa880039a0c4bd5953965f3ddd2ebd48aff96b0f14c2010331
+  data.tar.gz: cf0d306bc178528d2e38156dc1654efc5e67f6f877aaf542ff0fb9b80e51705a
 SHA512:
-  metadata.gz: e1ed258cfacea34dde52713e4eca66ad1c01dba6c1e6aef340858217a3c1962b71d43e15edbd8783485b8ad68c59a44f7423c7b5d455bc95999fc3cc5487d827
-  data.tar.gz: a39343c315c2905210d47d82662a49a3f5dc48c1881c8be6b3dc7e8354f69b5423997b44cfa407dcad804f07b43ed2574c996e572692dc8c5c3ca95e1414a857
+  metadata.gz: 6341fba9ff7f9dde85015a7493a5187d9fcdfea97fe912159e4dd2cdd82283109338b5788dabd25698474de9b7fad27d6b66480e3c7a34047c159bc5e5900969
+  data.tar.gz: 6ff8469aa8d35ddc861dc771d8124ed243697c1db2b3996bd17864f405c0fe91d8a348200b20b9cb359574e71cd1168b925958615d1c23dd025cb0941006dc8d

data/RELEASES.md

@@ -1,3 +1,11 @@
+= 22.1.0
+
+Fix gamestate.round
+
+= 22.0.3
+
+First tagged Version for Osteseeschach
+
 = 21.2.0
 
 Adjustments for Backend version 21.2.0

data/lib/software_challenge_client/game_state.rb

@@ -1,157 +1,158 @@
-# frozen_string_literal: true
-
-require_relative './util/constants'
-require_relative 'player'
-require_relative 'board'
-require_relative 'condition'
-require_relative 'color'
-
-# Ein Spielzustand. Wird vom Server an die Computerspieler übermittelt und
-# enthält alles, was der Computerspieler wissen muss, um einen Zug zu machen.
-#
-# Um eine Liste der gerade möglichen Züge zu bekommen, gibt es die Methode
-# {GameState#possible_moves}.
-class GameState
-  # @!attribute [rw] turn
-  # @return [Integer] Aktuelle Zugnummer (von 0 beginnend)
-  attr_accessor :turn
-
-  # @!attribute [rw] round
-  # @return [Integer] Aktuelle Rundennummer (von 1 beginnend)
-  attr_accessor :round
-
-  # @!attribute [r] player_one
-  # @return [Player] Der erste Spieler
-  attr_reader :player_one
-
-  # @!attribute [r] player_two
-  # @return [Player] Der zweite Spieler
-  attr_reader :player_two
-
-  # @!attribute [rw] start_team
-  # @return [Team] Der Spieler der zuerst zieht
-  attr_accessor :start_team
-
-  # @!attribute [rw] board
-  # @return [Board] Das aktuelle Spielbrett
-  attr_accessor :board
-
-  # @!attribute [rw] last_move
-  # @return [Move] Der zuletzt gemachte Zug (ist nil vor dem ersten Zug, also
-  #                bei turn == 0)
-  attr_accessor :last_move
-
-  # @!attribute [rw] condition
-  # @return [Condition] Gewinner und Gewinngrund, falls das Spiel bereits
-  #                     entschieden ist, sonst nil.
-  attr_accessor :condition
-
-  # Zugriff auf ein Feld des Spielbrettes. Siehe {Board#field}.
-  def field(x, y)
-    board.field(x, y)
-  end
-
-  # Erstellt einen neuen leeren Spielstand.
-  def initialize
-    @board = Board.new
-    @turn = 0
-  end
-
-  # Fügt einen Spieler zum Spielzustand hinzu.
-  #
-  # @param player [Player] Der hinzuzufügende Spieler.
-  def add_player(player)
-    case player.color
-    when Color::RED
-      @player_one = player
-    when Color::BLUE
-      @player_two = player
-    end
-  end
-
-  # @return [Player] Spieler, der gerade an der Reihe ist.
-  def current_player
-    turn.even? ? player_one : player_two
-  end
-
-  # @return [Player] Spieler, der gerade nicht an der Reihe ist.
-  def other_player
-    turn.even? ? player_two : player_one
-  end
-
-  # @return [Team] Typ des Spielers, der gerade nicht an der Reihe ist.
-  def other_team
-    other_player.type
-  end
-
-  # @return [Bool] Ob diese gamestate in der ersten Runde ist
-  def is_first_move?
-    round == 1
-  end
-
-  # Führt einen Zug auf dem Spielzustand aus. Das Spielbrett wird entsprechend
-  # modifiziert.
-  #
-  # @param move [Move] Der auszuführende Zug.
-  def perform!(move)
-    GameRuleLogic.perform_move(self, move)
-  end
-
-  # @return [Boolean] true, falls das Spiel bereits geendet hat, false bei noch
-  #                   laufenden Spielen.
-  def game_ended?
-    !condition.nil?
-  end
-
-  # @return [Player] Der Spieler, der das Spiel gewonnen hat, falls dies schon
-  #                  entschieden ist. Sonst false.
-  def winner
-    condition.nil? ? nil : condition.winner
-  end
-
-  # @return [String] Der Grund, warum das Spiel beendet wurde, nil falls das
-  #                  Spiel noch läuft.
-  def winning_reason
-    condition.nil? ? nil : condition.reason
-  end
-
-  # Ermittelt die Punkte eines Spielers. Wenn das Spiel durch Erreichen des
-  # Rundenlimits beendet wird, hat der Spieler mit den meisten Punkten gewonnen.
-  #
-  # @param player [Player] Der Spieler, dessen Punkte berechnet werden sollen.
-  # @return [Integer] Die Punkte des Spielers
-  def points_for_player(_player)
-    # TODO
-    -1
-  end
-
-  def ==(other)
-    turn == other.turn &&
-      start_color == other.start_color &&
-      current_color == other.current_color &&
-      blue == other.blue &&
-      yellow == other.yellow &&
-      red == other.red &&
-      green == other.green &&
-      board == other.board &&
-      lastMove == other.lastMove &&
-      condition == other.condition
-  end
-
-  # Erzeugt eine Kopie des Spielzustandes. Änderungen an dieser Kopie
-  # beeinflussen den originalen Spielzustand nicht. Die Kopie kann also zum
-  # testen von Spielzügen genutzt werden.
-  def clone
-    Marshal.load(Marshal.dump(self))
-  end
-
-  # Wechselt den Spieler, der aktuell an der Reihe ist.
-  def switch_current_player
-    @current_player_color = other_player_color
-  end
-
-  # @return [Array<Field>] Alle Felder mit Blöcken des Spielers, der gerade an der Reihe ist.
-  def own_fields
-    board.fields_of_color(current_player.color)
-  end
-end
+# frozen_string_literal: true
+
+require_relative './util/constants'
+require_relative 'player'
+require_relative 'board'
+require_relative 'condition'
+require_relative 'color'
+
+# Ein Spielzustand. Wird vom Server an die Computerspieler übermittelt und
+# enthält alles, was der Computerspieler wissen muss, um einen Zug zu machen.
+#
+# Um eine Liste der gerade möglichen Züge zu bekommen, gibt es die Methode
+# {GameState#possible_moves}.
+class GameState
+  # @!attribute [rw] turn
+  # @return [Integer] Aktuelle Zugnummer (von 0 beginnend)
+  attr_accessor :turn
+
+  # @!attribute [r] player_one
+  # @return [Player] Der erste Spieler
+  attr_reader :player_one
+
+  # @!attribute [r] player_two
+  # @return [Player] Der zweite Spieler
+  attr_reader :player_two
+
+  # @!attribute [rw] start_team
+  # @return [Team] Der Spieler der zuerst zieht
+  attr_accessor :start_team
+
+  # @!attribute [rw] board
+  # @return [Board] Das aktuelle Spielbrett
+  attr_accessor :board
+
+  # @!attribute [rw] last_move
+  # @return [Move] Der zuletzt gemachte Zug (ist nil vor dem ersten Zug, also
+  #                bei turn == 0)
+  attr_accessor :last_move
+
+  # @!attribute [rw] condition
+  # @return [Condition] Gewinner und Gewinngrund, falls das Spiel bereits
+  #                     entschieden ist, sonst nil.
+  attr_accessor :condition
+
+  # Zugriff auf ein Feld des Spielbrettes. Siehe {Board#field}.
+  def field(x, y)
+    board.field(x, y)
+  end
+
+  # Erstellt einen neuen leeren Spielstand.
+  def initialize
+    @board = Board.new
+    @turn = 0
+  end
+
+  # Fügt einen Spieler zum Spielzustand hinzu.
+  #
+  # @param player [Player] Der hinzuzufügende Spieler.
+  def add_player(player)
+    case player.color
+    when Color::RED
+      @player_one = player
+    when Color::BLUE
+      @player_two = player
+    end
+  end
+
+  # @return [Player] Spieler, der gerade an der Reihe ist.
+  def current_player
+    turn.even? ? player_one : player_two
+  end
+
+  # @return [Player] Spieler, der gerade nicht an der Reihe ist.
+  def other_player
+    turn.even? ? player_two : player_one
+  end
+
+  # @return [Team] Typ des Spielers, der gerade nicht an der Reihe ist.
+  def other_team
+    other_player.type
+  end
+
+  # @return [Integer] Aktuelle Rundennummer (von 1 beginnend)
+  def round
+    turn / 2 + 1
+  end
+
+  # @return [Bool] Ob diese gamestate in der ersten Runde ist
+  def is_first_move?
+    round == 1
+  end
+
+  # Führt einen Zug auf dem Spielzustand aus. Das Spielbrett wird entsprechend
+  # modifiziert.
+  #
+  # @param move [Move] Der auszuführende Zug.
+  def perform!(move)
+    GameRuleLogic.perform_move(self, move)
+  end
+
+  # @return [Boolean] true, falls das Spiel bereits geendet hat, false bei noch
+  #                   laufenden Spielen.
+  def game_ended?
+    !condition.nil?
+  end
+
+  # @return [Player] Der Spieler, der das Spiel gewonnen hat, falls dies schon
+  #                  entschieden ist. Sonst false.
+  def winner
+    condition.nil? ? nil : condition.winner
+  end
+
+  # @return [String] Der Grund, warum das Spiel beendet wurde, nil falls das
+  #                  Spiel noch läuft.
+  def winning_reason
+    condition.nil? ? nil : condition.reason
+  end
+
+  # Ermittelt die Punkte eines Spielers. Wenn das Spiel durch Erreichen des
+  # Rundenlimits beendet wird, hat der Spieler mit den meisten Punkten gewonnen.
+  #
+  # @param player [Player] Der Spieler, dessen Punkte berechnet werden sollen.
+  # @return [Integer] Die Punkte des Spielers
+  def points_for_player(_player)
+    # TODO
+    -1
+  end
+
+  def ==(other)
+    turn == other.turn &&
+      start_color == other.start_color &&
+      current_color == other.current_color &&
+      blue == other.blue &&
+      yellow == other.yellow &&
+      red == other.red &&
+      green == other.green &&
+      board == other.board &&
+      lastMove == other.lastMove &&
+      condition == other.condition
+  end
+
+  # Erzeugt eine Kopie des Spielzustandes. Änderungen an dieser Kopie
+  # beeinflussen den originalen Spielzustand nicht. Die Kopie kann also zum
+  # testen von Spielzügen genutzt werden.
+  def clone
+    Marshal.load(Marshal.dump(self))
+  end
+
+  # Wechselt den Spieler, der aktuell an der Reihe ist.
+  def switch_current_player
+    @current_player_color = other_player_color
+  end
+
+  # @return [Array<Field>] Alle Felder mit Blöcken des Spielers, der gerade an der Reihe ist.
+  def own_fields
+    board.fields_of_color(current_player.color)
+  end
+end

data/lib/software_challenge_client/protocol.rb

@@ -1,202 +1,201 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-require 'socket'
-require_relative 'board'
-require_relative 'move'
-require_relative 'piece_type'
-require_relative 'player'
-require_relative 'network'
-require_relative 'client_interface'
-require 'rexml/document'
-require 'rexml/streamlistener'
-require 'builder'
-
-# 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
-  # @return [String] current room id
-  attr_accessor :roomId
-  # @!attribute [r] client
-  # @return [ClientInterface] current client
-  attr_reader :client
-
-  def initialize(network, client)
-    @gamestate = GameState.new
-    @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 process_string(text)
-    #logger.debug "Parse XML:\n#{text}\n----END XML"
-    begin
-      REXML::Document.parse_stream(text, self)
-    rescue REXML::ParseException => e
-      # to parse incomplete xml, ignore missing end tag exceptions
-      raise e unless e.message =~ /Missing end tag/
-    end
-  end
-
-  # called when text is encountered
-  def text(text)
-    @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
-  #
-  # @param name [String] the start-tag, that was read
-  # @param attrs [Dictionary<String, String>] Attributes attached to the tag
-  def tag_start(name, attrs)
-    case name
-    when 'room'
-      @roomId = attrs['roomId']
-      logger.info 'roomId : ' + @roomId
-    when 'data'
-      logger.debug "data(class) : #{attrs['class']}"
-      @context[:data_class] = attrs['class']
-      if attrs['class'] == 'moveRequest'
-        @client.gamestate = gamestate
-        move = @client.move_requested
-        sendString(move_to_xml(move))
-      end
-      if attrs['class'] == 'error'
-        logger.info "Game ended - ERROR: #{attrs['message']}"
-        @network.disconnect
-      end
-      if attrs['class'] == 'result'
-        logger.info 'Got game result'
-        @network.disconnect
-        @gamestate.condition = Condition.new(nil, '')
-      end
-    when 'state'
-      logger.debug 'new gamestate'
-      @gamestate = GameState.new
-      @gamestate.turn = attrs['turn'].to_i
-      @gamestate.round = @gamestate.turn / 2
-      logger.debug "Round: #{@gamestate.round}, Turn: #{@gamestate.turn}"
-    when 'board'
-      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 'winner'
-      # TODO
-      # winning_player = parsePlayer(attrs)
-      # @gamestate.condition = Condition.new(winning_player, @gamestate.condition.reason)
-    when 'score'
-      # TODO
-      # there are two score tags in the result, but reason attribute should be equal on both
-      # @gamestate.condition = Condition.new(@gamestate.condition.winner, attrs['reason'])
-    when 'left'
-      logger.debug 'got left event, terminating'
-      @network.disconnect
-    when 'sc.protocol.responses.CloseConnection'
-      logger.debug 'got left close connection event, terminating'
-      @network.disconnect
-    end
-  end
-
-  # send a xml document
-  #
-  # @param document [REXML::Document] the document, that will be send to the connected server
-  def sendXml(document)
-    @network.sendXML(document)
-  end
-
-  # send a string
-  #
-  # @param string [String] The string that will be send to the connected server.
-  def sendString(string)
-    @network.sendString("<room roomId=\"#{@roomId}\">#{string}</room>")
-  end
-
-  # converts "this_snake_case" to "thisSnakeCase"
-  def snake_case_to_lower_camel_case(string)
-    string.split('_').inject([]) do |result, e|
-      result + [result.empty? ? e : e.capitalize]
-    end.join
-  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)
-
-    if move.nil?
-      raise 'nil moves are not sendable!'
-    end
-
-    # Converting every the move here instead of requiring the Move
-    # class interface to supply a method which returns the XML
-    # 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)
-    end
-    
-    builder.target!
-  end
-end
+# encoding: UTF-8
+# frozen_string_literal: true
+require 'socket'
+require_relative 'board'
+require_relative 'move'
+require_relative 'piece_type'
+require_relative 'player'
+require_relative 'network'
+require_relative 'client_interface'
+require 'rexml/document'
+require 'rexml/streamlistener'
+require 'builder'
+
+# 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
+  # @return [String] current room id
+  attr_accessor :roomId
+  # @!attribute [r] client
+  # @return [ClientInterface] current client
+  attr_reader :client
+
+  def initialize(network, client)
+    @gamestate = GameState.new
+    @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 process_string(text)
+    #logger.debug "Parse XML:\n#{text}\n----END XML"
+    begin
+      REXML::Document.parse_stream(text, self)
+    rescue REXML::ParseException => e
+      # to parse incomplete xml, ignore missing end tag exceptions
+      raise e unless e.message =~ /Missing end tag/
+    end
+  end
+
+  # called when text is encountered
+  def text(text)
+    @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
+  #
+  # @param name [String] the start-tag, that was read
+  # @param attrs [Dictionary<String, String>] Attributes attached to the tag
+  def tag_start(name, attrs)
+    case name
+    when 'room'
+      @roomId = attrs['roomId']
+      logger.info 'roomId : ' + @roomId
+    when 'data'
+      logger.debug "data(class) : #{attrs['class']}"
+      @context[:data_class] = attrs['class']
+      if attrs['class'] == 'moveRequest'
+        @client.gamestate = gamestate
+        move = @client.move_requested
+        sendString(move_to_xml(move))
+      end
+      if attrs['class'] == 'error'
+        logger.info "Game ended - ERROR: #{attrs['message']}"
+        @network.disconnect
+      end
+      if attrs['class'] == 'result'
+        logger.info 'Got game result'
+        @network.disconnect
+        @gamestate.condition = Condition.new(nil, '')
+      end
+    when 'state'
+      logger.debug 'new gamestate'
+      @gamestate = GameState.new
+      @gamestate.turn = attrs['turn'].to_i
+      logger.debug "Round: #{@gamestate.round}, Turn: #{@gamestate.turn}"
+    when 'board'
+      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 'winner'
+      # TODO
+      # winning_player = parsePlayer(attrs)
+      # @gamestate.condition = Condition.new(winning_player, @gamestate.condition.reason)
+    when 'score'
+      # TODO
+      # there are two score tags in the result, but reason attribute should be equal on both
+      # @gamestate.condition = Condition.new(@gamestate.condition.winner, attrs['reason'])
+    when 'left'
+      logger.debug 'got left event, terminating'
+      @network.disconnect
+    when 'sc.protocol.responses.CloseConnection'
+      logger.debug 'got left close connection event, terminating'
+      @network.disconnect
+    end
+  end
+
+  # send a xml document
+  #
+  # @param document [REXML::Document] the document, that will be send to the connected server
+  def sendXml(document)
+    @network.sendXML(document)
+  end
+
+  # send a string
+  #
+  # @param string [String] The string that will be send to the connected server.
+  def sendString(string)
+    @network.sendString("<room roomId=\"#{@roomId}\">#{string}</room>")
+  end
+
+  # converts "this_snake_case" to "thisSnakeCase"
+  def snake_case_to_lower_camel_case(string)
+    string.split('_').inject([]) do |result, e|
+      result + [result.empty? ? e : e.capitalize]
+    end.join
+  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)
+
+    if move.nil?
+      raise 'nil moves are not sendable!'
+    end
+
+    # Converting every the move here instead of requiring the Move
+    # class interface to supply a method which returns the XML
+    # 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)
+    end
+    
+    builder.target!
+  end
+end

data/lib/software_challenge_client/version.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 module SoftwareChallengeClient
-  VERSION = '22.0.3'
+  VERSION = '22.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: software_challenge_client
 version: !ruby/object:Gem::Version
-  version: 22.0.3
+  version: 22.1.0
 platform: ruby
 authors:
 - 'kwollw '
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-02 00:00:00.000000000 Z
+date: 2021-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -326,7 +326,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Provides functions to build a client for the coding competition Software-Challenge