software_challenge_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b08956211b43e0c2cd823c5351ca8834295d848a
+  data.tar.gz: a6eb47e5ed59e726ca330d7cd2d8687b056d2de9
+SHA512:
+  metadata.gz: 7473a1158058138f9c7b46bf4f254f940451452b67433974af963382c2418c1ef05c440bff6bcef9d085d1e803e7eb02cb42c923b76fbc4966ca30df6109aec3
+  data.tar.gz: d91262b781f43d53e9f4cee8a82c8f0cb6a95d8dcdf6501b1da407ffb08b43d406479eaf6c428d402dcd51bba8aa95416984f31afa066c13d5b2111e9ae5970a

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+/bin/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in SoftwareChallengeClient.gemspec
+gemspec

data/README.md

@@ -0,0 +1,45 @@
+# Software Challenge Client
+
+This gem includes everything to build a client for the coding
+competition [Software-Challenge](http://www.software-challenge.de).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'software_challenge_client'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install software_challenge_client
+
+## Usage
+
+See the example client in the example directory.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install
+dependencies. Then, run `rake false` to run the tests. You can also
+run `bin/console` for an interactive prompt that will allow you to
+experiment.
+
+To install this gem onto your local machine, run `bundle exec rake
+install`. To release a new version, update the version number in
+`version.rb`, and then run `bundle exec rake release`, which will
+create a git tag for the version, push git commits and tags, and push
+the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/CAU-Kiel-Tech-Inf/socha_ruby_client. This project
+is intended to be a safe, welcoming space for collaboration, and
+contributors are expected to adhere to the
+[Contributor Covenant](contributor-covenant.org) code of conduct.

data/RELEASES.md

@@ -0,0 +1,3 @@
+= 0.1.0
+
+First complete version.

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "yard"
+
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb']   # optional
+  t.options = ['--any', '--extra', '--opts'] # optional
+end

data/example/client.rb

@@ -0,0 +1,30 @@
+require 'software_challenge_client'
+
+class Client < ClientInterface
+  attr_accessor :gamestate
+
+  def initialize
+    puts "Zufallsspieler erstellt."
+  end
+
+  # gets called, when it's your turn
+  def getMove
+    puts "Spielstand: #{self.gamestate.pointsForPlayer(self.gamestate.currentPlayer)} - #{self.gamestate.pointsForPlayer(self.gamestate.otherPlayer)}"
+    mov = self.randomMove
+    unless mov.nil?
+      puts 'Zug gefunden: '
+      puts mov.to_s
+    end
+    return mov
+  end
+
+  # choose a random move
+  def randomMove
+    possibleMoves = self.gamestate.getPossibleMoves
+    if possibleMoves.length > 0
+      return possibleMoves[SecureRandom.random_number(possibleMoves.length)]
+    else
+      return nil
+    end
+  end
+end

data/example/main.rb

@@ -0,0 +1,36 @@
+require 'software_challenge_client'
+require 'optparse'
+require 'ostruct'
+
+require_relative 'client'
+
+options = OpenStruct.new
+options.host = '127.0.0.1'
+options.port = 13050
+options.reservation = ''
+
+opt_parser = OptionParser.new do |opt|
+  opt.banner = "Usage: main.rb [OPTIONS]"
+  opt.separator  ""
+  opt.separator  "Options"
+
+  opt.on("-p","--port PORT", Integer,"connect to the server at PORT (default #{options.port})") do |p|
+    options.port = p
+  end
+
+  opt.on("-h","--host HOST","the host's IP address (default #{options.host})") do |h|
+    options.host = h
+  end
+
+  opt.on_tail("-?", "--help", "Show this message") do
+    puts opt
+    exit
+  end
+
+end
+
+opt_parser.parse!(ARGV)
+
+client = Client.new
+runner = Runner.new(options.host, options.port, client)
+runner.start()

data/lib/software_challenge_client.rb

@@ -0,0 +1,17 @@
+module SoftwareChallengeClient
+  require "software_challenge_client/version"
+  require "software_challenge_client/board"
+  require "software_challenge_client/client_interface"
+  require "software_challenge_client/condition"
+  require "software_challenge_client/connection"
+  require "software_challenge_client/debug_hint"
+  require "software_challenge_client/field"
+  require "software_challenge_client/field_type"
+  require "software_challenge_client/game_state"
+  require "software_challenge_client/move"
+  require "software_challenge_client/network"
+  require "software_challenge_client/player"
+  require "software_challenge_client/player_color"
+  require "software_challenge_client/protocol"
+  require "software_challenge_client/runner"
+end

data/lib/software_challenge_client/board.rb

@@ -0,0 +1,315 @@
+require_relative './util/constants'
+require_relative 'game_state'
+require_relative 'player'
+require_relative 'field_type'
+require_relative 'field'
+
+require 'securerandom'
+
+# @author Ralf-Tobias Diekert
+# A representation of a twixt game board
+class Board
+  # @!attribute [r] fields
+  # @return [Array<Array<Field>>] the board's fields
+  attr_reader :fields
+  # @!attribute [r] connections
+  # @return [Array<Connection>] the board's connections
+  attr_reader :connections
+  
+  def initialize
+    self.init
+  end
+  
+  # Initializes the board
+  #
+  # @param init [Boolean] if 'true', then the board will be initialized with swamps, otherwise the board will be completely empty
+  def initialize(init)
+    if init
+      self.init
+    else
+      self.makeClearBoard
+    end
+  end
+  
+  # Initializes the board with swamps
+  def init 
+    @fields = Array.new(Constants::SIZE) {Array.new(Constants::SIZE)}
+    @fields[0][0] = Field.new(FieldType::SWAMP, 0, 0)
+    @fields[0][Constants::SIZE - 1] = Field.new(FieldType::SWAMP, 0, Constants::SIZE - 1)
+    @fields[Constants::SIZE - 1][0] = Field.new(FieldType::SWAMP, Constants::SIZE - 1, 0)
+    @fields[Constants::SIZE - 1][Constants::SIZE - 1] = Field.new(FieldType::SWAMP, Constants::SIZE - 1, Constants::SIZE - 1)
+    for x in 1..(Constants::SIZE - 2)
+      @fields[x][0] = Field.new(FieldType::RED, x, 0);
+      @fields[x][Constants::SIZE - 1] = Field.new(FieldType::RED, x, Constants::SIZE - 1);
+    end
+    for y in 1..(Constants::SIZE - 2)
+      @fields[0][y] = Field.new(FieldType::BLUE, 0, y);
+      @fields[Constants::SIZE - 1][y] = Field.new(FieldType::BLUE, Constants::SIZE - 1, y);
+    end
+    for x in 1..(Constants::SIZE - 2)
+      for y in 1..(Constants::SIZE - 2) 
+        @fields[x][y] = Field.new(FieldType::NORMAL, x, y);
+      end
+    end
+    self.placeSwamps()
+    @connections = Array.new;
+  end
+  
+  # Places swamps at random coordinates
+  def placeSwamps
+    # big swamp
+    x = 1 + SecureRandom.random_number(Constants::SIZE - 4)
+    y = 1 + SecureRandom.random_number(Constants::SIZE - 4)
+    for i in x..(x + 2)
+      for j in y..(y + 2)
+        self.fields[i][j].type = FieldType::SWAMP
+      end
+    end
+    # first medium swamp
+    x = 1 + SecureRandom.random_number(Constants::SIZE - 3)
+    y = 1 + SecureRandom.random_number(Constants::SIZE - 3)
+    for i in x..(x + 1)
+      for j in y..(y + 1)
+        self.fields[i][j].type = FieldType::SWAMP
+      end
+    end
+    # second medium swamp
+    x = 1 + SecureRandom.random_number(Constants::SIZE - 3)
+    y = 1 + SecureRandom.random_number(Constants::SIZE - 3)
+    for i in x..(x + 1)
+      for j in y..(y + 1)
+        self.fields[i][j].type = FieldType::SWAMP
+      end
+    end
+    # little swamp
+    x = 1 + SecureRandom.random_number(Constants::SIZE - 2)
+    y = 1 + SecureRandom.random_number(Constants::SIZE - 2)
+    self.fields[x][y].type = FieldType::SWAMP
+  end
+
+  
+  # creates a cleared board  
+  def makeClearBoard
+    @fields = Array.new(Constants::SIZE, Array.new(Constants::SIZE))
+    @connections = Array.new
+  end
+  
+  # gets the owner's color for the field at the coordinate (x, y)
+  # 
+  # @param x [Integer] x-coordinate
+  # @param y [Integer] y-coordinate
+  # @return [PlayerColor] owner's color of field (x, y)
+  def getOwnerColor(x, y) 
+    return self.fields[x][y].ownerColor
+  end
+  
+  
+  # sets the owner's color for the field at the coordinate (x, y)
+  # 
+  # @param x [Integer] x-coordinate
+  # @param y [Integer] y-coordinate
+  # @param player [Player] new owner of field (x, y)
+  def put(x, y, player)
+    self.fields[x][y].owner = player.color;
+    self.createNewWires(x, y);
+  end
+
+  # creates wires at the coordinate (x, y), if it is possible
+  # 
+  # @param x [Integer] x-coordinate
+  # @param y [Integer] y-coordinate
+  def createNewWires(x, y)
+    if self.checkPossibleWire(x, y, x - 2, y - 1)
+      self.createWire(x, y, x - 2, y - 1)
+    end
+    if self.checkPossibleWire(x, y, x - 1, y - 2)
+      self.createWire(x, y, x - 1, y - 2)
+    end
+    if self.checkPossibleWire(x, y, x - 2, y + 1)
+      self.createWire(x, y, x - 2, y + 1)
+    end
+    if self.checkPossibleWire(x, y, x - 1, y + 2)
+      self.createWire(x, y, x - 1, y + 2)
+    end
+    if self.checkPossibleWire(x, y, x + 2, y - 1)
+      self.createWire(x, y, x + 2, y - 1)
+    end
+    if self.checkPossibleWire(x, y, x + 1, y - 2)
+      self.createWire(x, y, x + 1, y - 2)
+    end
+    if self.checkPossibleWire(x, y, x + 2, y + 1)
+      self.createWire(x, y, x + 2, y + 1)
+    end
+    if self.checkPossibleWire(x, y, x + 1, y + 2)
+      self.createWire(x, y, x + 1, y + 2)
+    end
+    
+  end 
+
+  # creates a new wire
+  # 
+  # @param x1 [Integer] x-coordinate starting point
+  # @param y1 [Integer] y-coordinate starting point
+  # @param x2 [Integer] x-coordinate ending point
+  # @param y2 [Integer] y-coordinate ending point
+  def createWire(x1, y1, x2, y2)
+    self.connections.push(Connection.new(x1, y1, x2, y2, self.fields[x1][y1].ownerColor))
+  end
+
+  # checks, if a wire can be placed at specified coordinates
+  # 
+  # @param x1 [Integer] x-coordinate starting point
+  # @param y1 [Integer] y-coordinate starting point
+  # @param x2 [Integer] x-coordinate ending point
+  # @param y2 [Integer] y-coordinate ending point
+  # @return [Boolean] 'true', if a wire can be placed at specified coordinates
+  def checkPossibleWire(x1, y1, x2, y2)
+    if x2 < Constants::SIZE && y2 < Constants::SIZE && x2 >= 0 && y2 >= 0
+      if self.fields[x2][y2].ownerColor == self.fields[x1][y1].ownerColor
+        return !self.existsBlockingWire(x1, y1, x2, y2)
+      end
+    end
+    return false
+  end
+
+  # checks, if a blocking wire exists
+  # 
+  # @param x1 [Integer] x-coordinate starting point
+  # @param y1 [Integer] y-coordinate starting point
+  # @param x2 [Integer] x-coordinate ending point
+  # @param y2 [Integer] y-coordinate ending point
+  # @return [Boolean] 'true', if another wire would block the creation of a new wire at specified coordinates
+  def existsBlockingWire(x1, y1, x2, y2)
+    smallerX, biggerX = [x1, x2].minmax
+    smallerY, biggerY = [y1, y2].minmax
+    for x in smallerX..biggerX
+      for y in smallerY..biggerY # checks all 6 Fields, from
+        # where there could be
+        # blocking connections
+        if !self.fields[x][y].ownerColor.nil? && (x != x1 || y != y1) && 
+            (x != x2 || y != y2) # excludes the Fields with no owner and
+          # the fields (x1, y2), (x2, y2)
+          # themselves.
+          if self.isWireBlocked(x1, y1, x2, y2, x, y)
+            return true
+          end
+        end
+      end
+    end
+    return false
+  end
+  
+  # gets connections for the coordinate (x, y)
+  # 
+  # @param x [Integer] x-coordinate
+  # @param y [Integer] y-coordinate
+  # @return [Array] Array of connections from field (x, y)
+  def getConnections(x, y)
+    xyConnections = Array.new
+    if !self.connections.nil?
+      for c in self.connections
+        if c.x1 == x && c.y1 == y 
+          xyConnections.push(Connection.new(x, y, c.x2, c.y2, c.ownerColor))
+        end
+        if c.x2 == x && c.y2 == y
+          xyConnections.push(Connection.new(x, y, c.x1, c.y1, c.ownerColor))
+        end
+      end
+    end
+    return xyConnections
+  end
+
+  # following functions are helper functions for the blocking wire check
+  #http://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/
+  def onSegment(px,py,qx,qy,rx,ry)
+    if qx <= [px, rx].max && qx >= [px, rx].min &&
+        qy <= [py, ry].max && qy >= [py, ry].min
+      return true
+    end
+    return false
+  end
+ 
+  def orientation(px,py,qx,qy,rx,ry)
+    val = (qy - py) * (rx - qx) -
+      (qx - px) * (ry - qy)
+ 
+    if val == 0
+      return 0
+    end
+    if val > 0
+      return 1
+    end
+    return 2
+  end
+ 
+  def doIntersect(p1x,p1y, q1x,q1y, p2x,p2y, q2x,q2y)
+    o1 = orientation(p1x,p1y, q1x,q1y, p2x,p2y)
+    o2 = orientation(p1x,p1y, q1x,q1y, q2x,q2y)
+    o3 = orientation(p2x,p2y, q2x,q2y, p1x,p1y)
+    o4 = orientation(p2x,p2y, q2x,q2y, q1x,q1y)
+ 
+    if o1 != o2 && o3 != o4
+      return true
+    end
+ 
+    if o1 == 0 && onSegment(p1x,p1y, p2x,p2y, q1x,q1y)
+      return true
+    end
+ 
+    if o2 == 0 && onSegment(p1x,p1y, q2x,q2y, q1x,q1y)
+      return true
+    end
+ 
+    if o3 == 0 && onSegment(p2x,p2x, p1x,p1y, q2x,q2y)
+      return true
+    end
+     
+    if o4 == 0 && onSegment(p2x,p2y, q1x,q1y, q2x,q2y)
+      return true
+    end
+ 
+    return false
+  end
+
+  # checks for the wire (x1, y1) -> (x2, y2), if it is blocked by any connection going out from (x,y).
+  # 
+  # @param x1 [Integer] x-coordinate starting point
+  # @param y1 [Integer] y-coordinate starting point
+  # @param x2 [Integer] x-coordinate ending point
+  # @param y2 [Integer] y-coordinate ending point
+  # @param x [Integer] x-coordinate comparison field
+  # @param y [Integer] y-coordinate comparison field 
+  # @return [Boolean]  'true', if another wire would block the creation of a new wire at specified coordinates
+  def isWireBlocked(x1, y1, x2, y2, x, y)
+    for c in getConnections(x, y)
+      if self.doIntersect(x1, y1, x2, y2, x, y, c.x2, c.y2)
+        return true
+      end
+    end
+    return false
+  end
+
+  def to_s
+    return self.fields.map { |f| f.map {|i| (i.ownerColor==PlayerColor::RED ? 'R' : (i.ownerColor==PlayerColor::BLUE ? 'B' : (i.type==FieldType::SWAMP ? 'S' : (i.type==FieldType::RED ? 'r' : (i.type==FieldType::BLUE ? 'b' : ' '))))) }.join(",")}.join("\n")
+  end
+  
+  def ==(another_board)
+    for x in 0..(Constants.SIZE - 1)
+      for y in 0..(Constants.SIZE - 1)
+        if self.fields[x][y] != another_board.fields[x][y]
+          return false;
+        end
+      end
+    end
+    if self.connections.length != another_board.connections.length
+      return false;
+    end
+    for c in another_board.connections
+      if self.connections.include?(c)
+        return false
+      end
+    end
+    
+    return true;
+  end
+end