rrobots 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/README.rdoc

@@ -0,0 +1,93 @@
+= RRobots
+RRobots is a simulation environment for robots, these robots have a scanner
+and a gun, can move forward and backwards and are entirely controlled by
+ruby scripts. 
+
+== Example script
+
+  require 'rrobots'
+  class NervousDuck
+     include Robot
+
+    def tick events
+      turn_radar 1 if time == 0
+      turn_gun 30 if time < 3
+      accelerate 1
+      turn 2
+      fire 3 unless events['robot_scanned'].empty? 
+    end
+  end
+
+All you need to implement is the tick method which should accept a hash of events that occurred during the last tick.
+
+The following methods are available to your bot:
+
+  battlefield_height  #the height of the battlefield
+  battlefield_width   #the width of the battlefield
+  energy              #your remaining energy (if this drops below 0 you are dead)
+  gun_heading         #the heading of your gun, 0 pointing east, 90 pointing 
+                      #north, 180 pointing west, 270 pointing south
+  gun_heat            #your gun heat, if this is above 0 you can't shoot
+  heading             #your robots heading, 0 pointing east, 90 pointing north,
+                      #180 pointing west, 270 pointing south
+  size                #your robots radius, if x <= size you hit the left wall
+  radar_heading       #the heading of your radar, 0 pointing east, 
+                      #90 pointing north, 180 pointing west, 270 pointing south
+  time                #ticks since match start
+  speed               #your speed (-8/8)
+  x                   #your x coordinate, 0...battlefield_width
+  y                   #your y coordinate, 0...battlefield_height
+  accelerate(param)   #accelerate (max speed is 8, max accelerate is 1/-1, 
+                      #negativ speed means moving backwards)
+  stop                #accelerates negativ if moving forward (and vice versa), 
+                      #may take 8 ticks to stop (and you have to call it every tick)
+  fire(power)         #fires a bullet in the direction of your gun, 
+                      #power is 0.1 - 3, this power will heat your gun
+  turn(degrees)       #turns the robot (and the gun and the radar), 
+                      #max 10 degrees per tick
+  turn_gun(degrees)   #turns the gun (and the radar), max 30 degrees per tick
+  turn_radar(degrees) #turns the radar, max 60 degrees per tick
+  dead                #true if you are dead
+  say(msg)            #shows msg above the robot on screen
+  broadcast(msg)      #broadcasts msg to all bots (they receive 'broadcasts'
+                      #events with the msg and rough direction)
+
+These methods are intentionally of very basic nature, you are free to
+unleash the whole power of ruby to create higher level functions.
+(e.g. move_to, fire_at and so on)
+
+Some words of explanation: The gun is mounted on the body, if you turn
+the body the gun will follow. In a similar way the radar is mounted on
+the gun. The radar scans everything it sweeps over in a single tick (100 
+degrees if you turn your body, gun and radar in the same direction) but
+will report only the distance of scanned robots, not the angle. If you 
+want more precision you have to turn your radar slower.
+
+RRobots is implemented in pure ruby using a Gosu ui and should run on all
+platforms that have ruby and Gosu.
+
+== Usage
+
+To start a match call:
+
+  Usage: rrobots [options] file1 file2 ...
+          --resolution x,y             X and Y resolution
+          --match N                    Replay match number N
+          --timeout N                  Maximum number of ticks for a match
+          --teams N                    Splits robots into N teams
+          --[no-]gui                   Run the match with the GUI
+      -h, --help                       Show this message
+
+If you want to run a tournament call:
+
+  Usage: tournament [options] file1 file2 ...
+          --resolution x,y             X and Y resolution
+          --matches N                  Number of times each robot fights each other robot N
+          --timeout N                  Maximum number of ticks for a match
+          --dir N                      All robots from this directory will be matched against each other
+      -h, --help                       Show this message
+    
+The names of the rb files have to match the class names of the robots.
+
+Each robot is matched against each other 1on1. The results are available 
+as yaml or html files.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/rrobots

@@ -0,0 +1,154 @@
+#!/usr/bin/env ruby
+require 'rrobots'
+require 'optparse'
+require 'ostruct'
+
+class OptionsParser
+  def self.parse!(args)
+    options = OpenStruct.new
+    options.resolution  = [800,800]
+    options.match = Time.now.to_i + Process.pid
+    options.gui = true
+    options.timeout = 50000
+    options.teams = 8
+
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: rrobots [options] file1 file2 ..."
+
+      opts.on("--resolution x,y", Array, "X and Y resolution") do |resolution|
+        options.resolution = resolution.map &:to_i
+      end
+
+      opts.on("--match N", Integer, "Replay match number N") do |n|
+        options.match = n
+      end
+
+      opts.on("--timeout N", Integer, "Maximum number of ticks for a match") do |n|
+        options.timeout = n
+      end
+
+      opts.on("--teams N", Integer, "Splits robots into N teams") do |n|
+        options.teams = n if n > 0 && n < 8
+      end
+
+      opts.on("--[no-]gui", "Run the match with the GUI") do |y|
+        options.gui = y
+      end
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    end
+    opts.parse!(args)
+    if ARGV.size == 0
+      puts opts
+      exit
+    end
+    return options
+  end
+end
+    
+def run_out_of_gui(battlefield)
+  $stderr.puts 'match ends if only 1 bot/team left or dots get here-->|'
+
+  until battlefield.game_over
+    battlefield.tick
+    $stderr.print "." if battlefield.time % (battlefield.timeout / 54).to_i == 0
+  end
+  print_outcome(battlefield)
+  exit 0
+end
+
+def run_in_gui(battlefield, xres, yres)
+  require 'rrobots/gui'
+  arena = RRobotsGameWindow.new(battlefield, xres, yres)
+  game_over_counter = battlefield.teams.all?{|k,t| t.size < 2} ? 250 : 500
+  outcome_printed = false
+  arena.on_game_over{|battlefield|
+    unless outcome_printed
+      print_outcome(battlefield)
+      outcome_printed = true
+    end
+    if game_over_counter < 0
+      arena.close
+      exit 0
+    end
+    game_over_counter -= 1
+  }
+  arena.show
+end
+
+def print_outcome(battlefield)
+  winners = battlefield.robots.find_all{|robot| !robot.dead}
+  puts
+  if battlefield.robots.size > battlefield.teams.size
+    teams = battlefield.teams.find_all{|name,team| !team.all?{|robot| robot.dead} }
+    puts "winner_is:     { #{
+      teams.map do |name,team|
+        "Team #{name}: [#{team.join(', ')}]"
+      end.join(', ')
+    } }"
+    puts "winner_energy: { #{
+      teams.map do |name,team|
+        "Team #{name}: [#{team.map do |w| ('%.1f' % w.energy) end.join(', ')}]"
+      end.join(', ')
+    } }"
+  else
+    puts "winner_is:     [#{winners.map{|w|w.name}.join(', ')}]"
+    puts "winner_energy: [#{winners.map{|w|'%.1f' % w.energy}.join(', ')}]"
+  end
+  puts "elapsed_ticks: #{battlefield.time}"
+  puts "seed :         #{battlefield.seed}"
+  puts
+  puts "robots :"
+  battlefield.robots.each do |robot|
+    puts "  #{robot.name}:"
+    puts "    damage_given: #{'%.1f' % robot.damage_given}"
+    puts "    damage_taken: #{'%.1f' % (100 - robot.energy)}"
+    puts "    kills:        #{robot.kills}"
+  end
+end
+
+def setup_battlefield(options, robots)
+  teams = Array.new([options.teams, robots.size].min){ [] }
+  battlefield = Battlefield.new options.resolution[0]*2, options.resolution[1]*2, options.timeout, options.match
+
+  c = 0
+  team_divider = (robots.size / teams.size.to_f).ceil
+  robots.map! do |robot|
+    begin
+      begin
+        require "./"+robot.downcase
+      rescue LoadError
+      end
+      begin
+        require "./"+robot
+      rescue LoadError
+    end
+    in_game_name = File.basename(robot).sub(/\..*$/, '')
+    in_game_name[0] = in_game_name[0,1].upcase
+    team = c / team_divider
+    c += 1
+    robotrunner = RobotRunner.new(Object.const_get(in_game_name).new, battlefield, team)
+    battlefield << robotrunner
+    rescue Exception => error
+      puts 'Error loading ' + robot + '!'
+      warn error
+    end
+    in_game_name
+  end
+  battlefield
+end
+
+$stdout.sync = true
+
+options = OptionsParser.parse!(ARGV)
+robots = ARGV
+battlefield = setup_battlefield(options, robots)  
+  
+if options.gui
+  run_in_gui(battlefield, options.resolution[0], options.resolution[1])
+else
+  run_out_of_gui(battlefield)
+end

data/bin/tournament

@@ -0,0 +1,275 @@
+#!/usr/bin/env ruby
+
+require "YAML"
+require 'optparse'
+require 'ostruct'
+require 'rrobots/tournament'
+
+
+class OptionsParser
+  def self.parse!(args)
+    options = OpenStruct.new
+    options.resolution  = [800,800]
+    options.matches = 2
+    options.timeout = 10000
+
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: tournament [options] file1 file2 ..."
+
+      opts.on("--resolution x,y", Array, "X and Y resolution") do |resolution|
+        options.resolution = resolution.map &:to_i
+      end
+
+      opts.on("--matches N", Integer, "Number of times each robot fights each other robot N") do |n|
+        options.matches = n
+      end
+
+      opts.on("--timeout N", Integer, "Maximum number of ticks for a match") do |n|
+        options.timeout = n
+      end
+      
+      opts.on("--dir N", String, "All robots from this directory will be matched against each other") do |n|
+        options.directory = n
+      end
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    end
+    opts.parse!(args)
+    if ARGV.size == 0 and options.directory.nil?
+      puts opts
+      exit
+    end
+    return options
+  end
+end
+
+
+
+def print_header(html)
+  header = '''  
+  <html>
+  <head> <title>RRobots Tournament Results </title>
+  <style type="text/css">
+  <!--
+    body, p{font-family: verdana, arial, helvetica, sans-serif; font-size: 12px;}
+    table{background-color:white;	border:none;	padding:0px;	font-size: 12px;}
+    tr{}
+    td {
+      background-color:#efefef;
+      border-left:white 1px solid;
+      border-top:white 1px solid;
+      border-right:white 1px solid;
+      border-bottom:white 1px solid;
+      margin:0px;
+      padding:4px;
+    }
+    td.sum {font-weight:bold;}
+    td.blank {background-color:white}	
+  -->
+  </style>	
+  </head>
+  <body>
+  '''
+html.print(header)
+end
+
+def print_footer(html)
+  footer = '''
+  </body>
+  </html>
+  '''
+  html.print(footer)
+end
+
+def rank_by_round_stat(stat, rounds)
+  bots = Hash.new {|h,k| h[k] = 0}
+  rounds.each do |round|
+    bots[round.winner] += round.bots[round.winner][stat]
+    bots[round.loser] += round.bots[round.loser][stat]
+  end
+  sorted = bots.sort {|a,b| b[1] <=> a[1]}
+  return sorted
+end
+
+# print a html page with a table containing once cell per round
+# include  stat in that cell.  if r is the round in question 
+# then r.bots[current_bot][stat] had better exist!
+def print_round_table(stat, rounds, ranking, round_tables, html)
+  #ranking is an array of 2 element arrays - we just want the first element in the 'sub' array,
+  # which is the robot name
+  rows = ranking.collect {|a| a[0]}
+  cols = rows.clone
+
+  html.puts "<hr style='width: 100%; height: 2px;'>"
+  html.puts"<a name='#{stat}'></a>"
+  html.puts "<h1>#{stat}</h1>"
+  html.puts "<table>"
+  html.puts "<th>"
+  cols.each {|col| html.puts "<td> #{col[0..2]} </td>"}
+  html.puts "<td class='sum'>Sum</td></th>"
+  rows.each do |row|
+    html.puts "  <tr>"
+    html.puts "  <td> #{row} </td> "
+    row_total = 0
+    cols.each do |col|
+      round = nil
+      if row != col
+        round = rounds.find {|x| x.bots.has_key?(row) and x.bots.has_key?(col)}
+        if round == nil then puts "couldn't find round bewtween #{row} and #{col}" end
+        html.puts "    <td> #{ '%.1f'% round.bots[row][stat] } </td>"
+        row_total += round.bots[row][stat]
+      else  
+        html.puts"    <td> --- </td>"
+      end
+    end
+    html.puts "<td class='sum'> #{'%.1f'% row_total}</td>"
+    html.puts "  </tr>"
+  end
+  html.puts "</table>"
+end
+
+def print_index(round_tables, rankings, stats, html)
+  html.puts"<a name='top'></a>"
+  html.puts "<h1> Round Summary Tables </h1>"
+  html.puts "<ul>"
+  
+  round_tables.each { |t| html.puts "<li><a href='##{t}'>#{t}</a></li>"  }
+  
+  html.puts "</ul>"
+  html.puts "<h1> Rankings</h1>"
+  html.puts "<table><tr>"
+  
+  stats.each do |stat|
+    html.puts "<td>#{stat}<table>"
+    list = rankings[stat]
+    list.each {|row| html.puts "<tr><td>#{row[0]}</td> <td> #{'%.1f'%row[1]}</td></tr>"}
+    
+    html.puts "</table></td>"
+  end
+  
+  html.puts "</tr></table>"
+  
+  html.puts """
+    <h1>Definitions:</h1>
+    <ul>
+      <li>  Wins:  The numer of matches (battles) won by a robot.  (ties or timeouts earn both bots 0.5)</li>
+      <li>  Points:  Similar to wins, but timeouts earn bots points proportional to their amount of health.  There is a chance this doesn't work properly yet</li>
+      <li>  Round_wins:  Number of rounds won by a robot.  Indicates how many robots this robot can beat.  Ties earn 0.5 </li>
+      <li>  Margin:  The margin of one match is how much energy the winning robot won by</li>
+      <li>  Simul:  Number of times a robot was involved in Simultaneous deaths</li>
+      <li>  Timedout:  Number of times a robot was in a match that timed out</li>
+      <li>  Ties:  Number of matches a robot was in that ended in a tie </li>
+    </ul>
+  """
+  print_footer(html)
+end
+
+def to_html match_data, html
+	print_header(html)
+	
+	round_matches = Hash.new {|h,k| h[k] = []}
+	robots = []
+	
+	match_data.each do |m|
+	  match = Match.new(m)
+	  round_matches[m['round']] << match
+	  robots << match.winner
+	  robots << match.loser
+	end
+	robots = robots.uniq
+	
+	rounds = []
+	round_matches.values.each do |matches|
+	  r = Round.new(matches)
+	  rounds << r
+	end
+	
+	stats = ['wins', 'points','round_wins', 'margin', 'simul', 'timedout', 'ties']
+	rankings = {}
+	stats.each{|stat| rankings[stat] = rank_by_round_stat(stat, rounds)}
+	
+	print_index(stats, rankings, stats, html) #pass stats array in instead of using rankings.keys so we can preserve order
+	stats.each {|stat|  print_round_table(stat, rounds, rankings[stat],stats, html) }
+	print_footer(html)
+	html.close
+end
+
+####################################################################
+# Main
+####################################################################
+
+$stdout.sync = true
+
+options = OptionsParser.parse!(ARGV)
+robots = ARGV
+
+if(!options.directory.nil?)
+  pwd = Dir.pwd
+  Dir.chdir(options.directory)
+  robots = Dir.glob('*.rb')
+  Dir.chdir(pwd)
+else
+  options.directory = '.'
+end
+
+suffix=0
+while File.exists?('tournament'  + suffix.to_s.rjust(2, '0') + '.yml')
+  suffix = suffix + 1
+end
+results_file = 'tournament'  + suffix.to_s.rjust(2, '0') + ".yml"
+
+rounds = []
+round_number = 0
+opponents = robots.clone
+@all_match_data = []
+robots.each do |bot1|
+	
+  opponents.delete bot1
+  opponents.each do |bot2|
+    round_number += 1
+    puts
+    puts "===== Round #{round_number}:   #{bot1} vs  #{bot2}   ====="
+    i = 1
+    matches = []
+    options.matches.times do |i|
+      puts "- Match #{i+1} of #{options.matches} -"
+      cmd = "rrobots --no-gui --timeout #{options.timeout} #{options.directory}/#{bot1} #{options.directory}/#{bot2}"
+      
+      # using popen instead of `cmd` lets us see the progress dots (......) output as the match progresses.
+      sub = IO.popen(cmd)
+      results_string = sub.read
+      sub.close
+
+      match_data = YAML.load(results_string)
+      match_data['match'] = i
+      match_data['round'] = round_number
+      match_data['timedout'] = 1 if options.timeout <= match_data['elapsed_ticks']
+      @all_match_data << match_data
+      
+      match = Match.new(match_data)
+      puts
+      puts match.one_line_summary
+      matches << match
+    end
+    rounds << Round.new(matches)
+  end
+end
+
+# write out match results to a file for possible later analysis
+File.open(results_file, 'w').puts(YAML::dump(@all_match_data))
+to_html(@all_match_data, File.open(results_file.sub(/\..*$/, '.html'), 'w'))
+
+puts
+puts
+puts "####################################################################"
+puts "                     TOURNAMENT SUMMARY"
+puts "####################################################################"
+round_results = []
+rounds.each {|round| round_results << round.one_line_summary}
+round_results = round_results.sort
+round_results.each {|r| puts r}
+
+