software_challenge_client 0.1.0

data/lib/software_challenge_client/move.rb

@@ -0,0 +1,58 @@
+require_relative 'debug_hint'
+
+# @author Ralf-Tobias Diekert
+# A move, that can be performed in twixt
+class Move
+  # @!attribute [r] x
+  # @return [Integer] x-coordinate
+  attr_reader :x
+  # @!attribute [r] y
+  # @return [Integer] y-coordinate
+  attr_reader :y
+  # @!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
+  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);
+  end
+  
+  # adds a hint to the move
+  def addHint(key, value)
+    self.addHint(DebugHint.new(key, value))
+  end
+  
+  # adds a hint to the move
+  def addHint(string)
+    self.addHint(DebugHint.new(string))
+  end
+  
+  def ==(another_move)
+    return self.x == another_move.x && self.y == another_move.y
+  end
+
+  def to_s
+    return "Move:(#{self.x},#{self.y})"
+  end
+
+end

data/lib/software_challenge_client/network.rb

@@ -0,0 +1,146 @@
+require 'socket'
+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
+  @socket
+  @host
+  @port
+    
+  @board
+  @client
+  @protocol
+    
+  @receiveBuffer
+  @reservationID
+  
+  # @!attribute [r] connected
+  # @return [Boolean] true, if the client is connected to a server
+  attr_reader :connected
+    
+  def initialize(host, port, board, client)
+    @host, @port, @connected, @board, @client = 
+      host, port, false, board, client
+  
+    @protocol = Protocol.new(self, @client)
+    @reservationID = ''
+    @receiveBuffer = ''
+  
+    puts '> Network/Socket created.'
+  end
+
+  # connects the client with a given server
+  # 
+  # @return [Boolean] true, if successfully connected to the server
+  def connect
+    @socket = TCPSocket.open(@host, @port)
+    @connected = true
+  
+    self.sendString('<protocol>')
+    if @reservationID != ''
+      document = REXML::Docuent.new
+      element = REXML::Element.new('joinPrepared')
+      element.add_attribute('reservationCode', @reservationID)
+      document.add(element)
+      self.sendXML(document)
+    else 
+      document = REXML::Document.new
+      element = REXML::Element.new('join')
+      element.add_attribute('gameType', 'swc_2016_twixt')
+      document.add(element)
+      self.sendXML(document)
+    end
+    return @connected
+  end
+  
+  # disconnects the client from a server
+  def disconnect
+
+    if @connected
+      sendString("</protocol>")
+      @connected = false
+      @socket.close
+    end
+    puts '> Disconnected.'
+  end
+
+  # reads from the socket until "</room>" is read
+  def readString
+    puts 'reading'
+    sockMsg = ''
+    if(!@connected) 
+      return
+    end
+  
+    line =''
+    char = ''
+    while line!="</room>"
+      char = @socket.getc
+      line+=char
+      if char=='\n' || char==' '
+
+        line = ''
+      end
+      sockMsg += char
+    end
+    puts 'ended reading'
+    if sockMsg != ''
+    
+      @receiveBuffer.concat(sockMsg)
+
+      # Remove <protocol> tag
+      @receiveBuffer = @receiveBuffer.gsub('<protocol>', '')
+
+      puts 'Receive:'
+      puts ''
+      #puts @receiveBuffer
+    
+      # Process text
+      @protocol.processString('<msg>'+@receiveBuffer+'</msg>');
+      self.emptyReceiveBuffer
+    end
+    return true
+  end
+
+  # empties the receive buffer
+  def emptyReceiveBuffer
+    @receiveBuffer = ''
+  end
+
+  # processes an incomming message
+  #
+  # @return [Boolean] true, if the processing of a incomming message was successfull
+  def processMessages
+    if !@connected
+      return false
+    end
+    return self.readString
+  end
+
+  # sends a string to the socket
+  #
+  # @param s [String] the message, to be sent
+  def sendString(s)
+    if(@connected)
+      @socket.print(s);
+      puts 'Send:'
+      puts ''
+      puts(s);
+    end
+  end
+
+  # sends a xml Document to the buffer
+  #
+  # @param xml [REXML::Docuent] the Document, that will be sent
+  def sendXML(xml)
+    text  = ''
+    xml.write(text)
+    self.sendString(text);
+  end
+
+end

data/lib/software_challenge_client/player.rb

@@ -0,0 +1,24 @@
+require_relative 'player_color'
+
+# @author Ralf-Tobias Diekert
+# A player, participating at a game
+class Player
+  # @!attribute [r] color
+  # @return [PlayerColor] the player's color
+  attr_reader :color
+  # @!attribute [rw] points
+  # @return [Integer] the player's points
+  attr_accessor :points
+  
+  # Initializer
+  # @param the new player's color
+  def initialize(color)
+    @color = color
+    self.points = 0
+  end
+  
+  def ==(another_player)
+    return self.color == another_player.color
+  end
+  
+end

data/lib/software_challenge_client/player_color.rb

@@ -0,0 +1,23 @@
+# @author Ralf-Tobias Diekert
+#player color constants
+module PlayerColor
+  NONE = 1
+  RED = 2
+  BLUE = 4
+  
+  # Returns the opponents Color
+  #
+  # @param color [PlayerColor] The player's color, whose opponent needs to be found
+  # @return [PlayerColor] the opponent's color
+  def self.opponentColor(color)
+    if color == PlayerColor::RED
+      return PlayerColor::BLUE
+    end
+    if color == PlayerColor::BLUE
+      return PlayerColor::RED
+    end
+    if color == PlayerColor::NONE
+      return PlayerColor::NONE
+    end
+  end
+end

data/lib/software_challenge_client/protocol.rb

@@ -0,0 +1,149 @@
+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'
+
+# @author Ralf-Tobias Diekert
+# This class handles the parsing of xml strings according to the network protocol of twixt
+class Protocol
+  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
+  @network
+
+  def initialize(network, client)
+    @gamestate = GameState.new
+    @network, @client = network, client  
+    self.client.gamestate = self.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)
+  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"
+      puts @gamestate.board.to_s
+    when "condition"
+      puts "Game ended"
+      @network.disconnect
+    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']
+      puts "roomId : "+@roomID
+    when "data"
+      puts "data(class) : "+attrs['class']
+      if attrs['class'] == "sc.framework.plugins.protocol.MoveRequest"
+        @client.gamestate = self.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)
+      end
+      if attrs['class'] == "error"
+        puts "Game ended - ERROR"
+        puts attrs['message']
+        @network.disconnect
+      end
+    when "state"
+      puts 'new gamestate'
+      @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
+      x = attrs['x'].to_i
+      y = attrs['y'].to_i
+
+      @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.condition = Condition.new(attrs['winner'], attrs['reason'])
+    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
+  
+end

data/lib/software_challenge_client/runner.rb

@@ -0,0 +1,33 @@
+require_relative 'board'
+require_relative 'client_interface'
+require_relative 'network'
+
+class Runner
+  attr_reader :network
+
+  def initialize(host, port, client)
+    puts 'Software Challenge 2015'
+    puts 'Ruby Client'
+    puts "Host: #{host}"
+    puts "Port: #{port}"
+
+    board = Board.new(true)
+    @network = Network.new(host, port, board, client)
+  end
+
+  def start
+    self.network.connect
+    if self.network.connected == false
+      puts 'Not connected'
+      return
+    end
+
+    while self.network.connected
+      self.network.processMessages
+      sleep(0.01)
+    end
+
+    puts 'Program end...'
+    self.network.disconnect
+  end
+end

data/lib/software_challenge_client/util/constants.rb

@@ -0,0 +1,5 @@
+#Game constants
+module Constants
+  ROUND_LIMIT = 100
+  SIZE = 24 #board's width and height
+end