UG_RRobots 1.2

data/bin/rrobots

@@ -0,0 +1,202 @@
+#!/usr/bin/env ruby
+
+require 'robot'
+require 'yaml'
+require 'overloads'
+require 'configuration'
+require 'battlefield'
+require 'toolboxes'
+require 'explosions'
+require 'bullets'
+
+##############################################
+# arena
+##############################################
+
+def usage
+  puts "usage: rrobots.rb [resolution] [#match] [-nogui] [-speed=<N>] [-timeout=<N>] [-teams=<N>] [-with-toolboxes] <FirstRobotClassName[.rb]> <SecondRobotClassName[.rb]> <...>"
+  puts "\t[resolution] (optional) should be of the form 640x480 or 800*600. default is 800x800"
+  puts "\t[match] (optional) to replay a match, put the match# here, including the #sign.  "
+  puts "\t[-nogui] (optional) run the match without the gui, for highest possible speed.(ignores speed value if present)"
+  puts "\t[-speed=<N>] (optional, defaults to 1) updates GUI after every N ticks.  The higher the N, the faster the match will play."
+  puts "\t[-timeout=<N>] (optional, default 50000) number of ticks a match will last at most."
+  puts "\t[-teams=<N>] (optional) split robots into N teams. Match ends when only one team has robots left."
+  puts "\t[-with-toolboxes] (optional) to accept the spawning of healing toolboxes (randomly)."
+  puts "\t[-ignore-config] (optional) to ignore the config file present in the path."
+  puts "\t[-write-config] (optional) to write the config in a file in the path."
+  puts "\tthe names of the rb files have to match the class names of the robots"
+  puts "\t(up to 8 robots)"
+  puts "\te.g. 'ruby rrobots.rb SittingDuck NervousDuck'"
+  puts "\t or 'ruby rrobots.rb 600x600 #1234567890 SittingDuck NervousDuck'"
+  exit
+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, speed_multiplier)
+  require 'tkarena'
+  arena = TkArena.new(battlefield, xres, yres, speed_multiplier)
+  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
+    exit 0 if game_over_counter < 0
+    game_over_counter -= 1
+  }
+  arena.run
+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}"
+    if battlefield.with_toolboxes
+      puts "    damage_taken:       #{'%.1f' % (100 + (robot.catched_toolboxes*20) - robot.energy)}" 
+    else
+      puts "    damage_taken:       #{'%.1f' % (100 - robot.energy)}"
+    end
+    puts "    kills:              #{robot.kills}"
+    puts "    toolboxes catched:  #{robot.catched_toolboxes}" if battlefield.with_toolboxes
+  end
+end
+
+$stdout.sync = true
+
+# look for resolution arg
+xres, yres = 800, 800
+ARGV.grep(/^(\d+)[x\*](\d+$)/) do |item|
+  xres, yres = $1.to_i, $2.to_i
+  ARGV.delete(item)
+end
+
+# look for match arg
+seed = Time.now.to_i + Process.pid
+ARGV.grep(/^#(\d+)/) do |item|
+  seed = $1.to_i
+  ARGV.delete(item)
+end
+
+#look for with_toolboxes arg
+with_toolboxes = false
+ARGV.grep( /^(-with-toolboxes)/ ) do |item|
+with_toolboxes = true 
+  ARGV.delete(item)
+end
+
+
+#look for mode arg
+mode = :run_in_gui
+ARGV.grep( /^(-nogui)/ )do |item|
+  mode = :run_out_of_gui
+  ARGV.delete(item)
+end
+
+#look for config arg
+merge = true
+ARGV.grep( /^(-ignore-config)/ )do |item|
+  merge = false
+  ARGV.delete(item)
+end
+
+#look for config write arg
+write_config = false
+ARGV.grep( /^(-write-config)/ )do |item|
+  write_config = true
+  ARGV.delete(item)
+end
+
+#look for speed multiplier arg
+speed_multiplier = 1
+ARGV.grep( /^-speed=(\d\d?)/ )do |item|
+  x = $1.to_i
+  speed_multiplier = x if x > 0 && x < 100
+  ARGV.delete(item)
+end
+
+#look for timeout arg
+timeout = 50000
+ARGV.grep( /^-timeout=(\d+)/ )do |item|
+  timeout = $1.to_i
+  ARGV.delete(item)
+end
+
+
+
+#look for teams arg
+team_count = 8
+ARGV.grep( /^-teams=(\d)/ )do |item|
+  x = $1.to_i
+  team_count = x if x > 0 && x < 8
+  ARGV.delete(item)
+end
+teams = Array.new([team_count, ARGV.size].min){ [] }
+
+usage if ARGV.size > 8 || ARGV.empty?
+
+battlefield = Battlefield.new xres*2, yres*2, timeout, seed, with_toolboxes, merge, write_config
+
+c = 0
+team_divider = (ARGV.size / teams.size.to_f).ceil
+ARGV.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
+    usage
+  end
+  in_game_name
+end
+
+if mode == :run_out_of_gui
+  run_out_of_gui(battlefield)
+else
+  run_in_gui(battlefield, xres, yres, speed_multiplier)
+end

data/bin/tournament

@@ -0,0 +1,413 @@
+#!/usr/bin/env ruby
+
+require "yaml"
+
+class Match
+  attr_reader :bots
+  attr_reader :seed
+  attr_reader :match
+  
+  def initialize(data)
+    @bots = data['robots']
+    @seed = data['seed']
+    @ticks= data['elapsed_ticks']
+    @timedout = data['timedout']
+    @match = data['match']
+  end
+  
+  def winner
+    sorted = @bots.sort{|a,b| a[1]['damage_given'] <=> b[1]['damage_given']}
+    return sorted[1][0]
+  end
+
+  def loser
+    sorted = @bots.sort{|a,b| a[1]['damage_given'] <=> b[1]['damage_given']}
+    return sorted[0][0]
+  end
+  
+  def tie?
+    return margin == 0.0 
+  end
+  
+  def margin
+    @bots[winner]['damage_given'] - @bots[loser]['damage_given']
+  end
+  
+  def winner_points
+    return 0.5 if simul?
+    return winner_health / (winner_health + loser_health)
+  end
+  
+  def loser_points
+    return 0.5 if simul?
+    return loser_health / (winner_health + loser_health)
+  end
+  
+  def simul?
+    winner_health + loser_health == 0
+  end
+  
+  def timedout?
+    @timedout == 1
+  end
+  
+  #between 100 and 0
+  def winner_health 
+    [100 - @bots[winner]['damage_taken'], 0].max
+  end
+  
+  #between 100 and 0
+  def loser_health 
+    [100 - @bots[loser]['damage_taken'], 0].max
+  end
+  
+  def one_line_summary
+    if !tie?
+      line = "#{winner} beats #{loser} by #{'%.1f' % margin} energy in #{@ticks} ticks"
+      if @timedout then line += " (match timed out, so #{winner} gets #{winner_points}, loser gets #{loser_points})" end
+    else
+      line = "#{winner} ties #{loser} at #{'%.1f' % winner_health} energy in #{@ticks} ticks"
+      if @timedout then line += " (match timed out.)" end
+    end
+    line += " (timed out)" if @timeout
+    return line
+  end
+end
+
+
+class Round
+  attr_accessor :matches
+  attr_accessor :winner
+  #attr_accessor :total_margin
+  attr_reader :bots
+  
+  # matches should be an array of Matches
+  def initialize (matches)
+    @matches = matches
+    @bots = Hash.new {|h,key| h[key] = {}}
+    
+    both_bots =  [@bots[@matches[0].winner], @bots[@matches[0].loser]]
+    stats_to_init = ['wins', 'points', 'ties', 'margin', 'simul', 'timedout', 'round_wins']
+    stats_to_init.each {|stat| both_bots.each {|b| b[stat] = 0 }}
+    
+    @matches.each do |match|
+      @bots[match.winner]['points'] += match.winner_points
+      @bots[match.loser]['points'] += match.loser_points
+      both_bots.each {|b| b['ties'] += 1 if match.tie?}
+      both_bots.each {|b| b['timedout'] += 1 if match.timedout?}
+      both_bots.each {|b| b['simul'] += 1 if match.simul?}
+      @bots[match.winner]['margin'] += match.margin
+      if match.tie?
+        both_bots.each {|b| b['wins'] += 0.5}
+      else
+        @bots[match.winner]['wins'] += 1
+      end
+      if both_bots[0]['wins'] > both_bots[1]['wins'] then both_bots[0]['round_wins'] = 1 end
+      if both_bots[1]['wins'] > both_bots[0]['wins'] then both_bots[1]['round_wins'] = 1 end
+      if both_bots[1]['wins'] == both_bots[0]['wins'] then both_bots[0]['round_wins'] = 0.5 ;both_bots[1]['round_wins'] = 0.5 end
+    end
+  end
+  
+  def winner
+    sorted = @bots.sort{|a,b| a[1]['wins'] <=> b[1]['wins']}
+    return sorted[1][0]
+  end
+  
+  def loser
+    sorted = @bots.sort{|a,b| a[1]['wins'] <=> b[1]['wins']}
+    return sorted[0][0]
+  end
+  
+  def tie?
+    @bots[winner]['wins'] == @bots[loser]['wins']
+  end
+  #calc how many points for losing bot
+  
+  def one_line_summary
+    if !tie?
+      line = "#{winner} conquers #{loser} (#{@bots[winner]['wins']} to #{@bots[loser]['wins']} )"
+    else
+      line = "#{winner} ties #{loser} (#{@bots[winner]['wins']} to #{@bots[loser]['wins']} )"
+    end
+  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 <<ENDHTML
+  <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>
+ENDHTML
+  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 insted 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
+####################################################################
+
+def usage
+  puts "Usage: ruby tournament.rb [-timeout=<N>] [-matches=<N>] [-with-toolboxes] (-dir=<Directory> | <RobotClassName[.rb]>+)"
+  puts "\t[-with-toolboxes] (optional) to accept the spawning of healing toolboxes (randomly)."
+  puts "\t[-ignore-config] (optional) to ignore the config file present in the path."
+  puts "\t[-timeout=<N>] (optional, default 10000) number of ticks a match will last at most."  
+  puts "\t[-matches=<N>] (optional, default 2) how many times each robot fights every other robot."  
+  puts "\t-dir=<Directory> All .rb files from that directory will be matched against each other."
+  puts "\t[-ignore-config] (optional) to ignore the config file present in the path."  
+  puts "\tthe names of the rb files have to match the class names of the robots."
+  exit(0)
+end
+
+#look for timeout arg
+timeout = 10000
+ARGV.grep( /^-timeout=(\d+)/ )do |item|
+  timeout = $1.to_i
+  ARGV.delete(item)
+end
+
+matches_per_round = 2
+ARGV.grep( /^-matches=(\d+)/ )do |item|
+  matches_per_round = $1.to_i
+  ARGV.delete(item)
+end
+
+#look for with_toolboxes arg
+with_toolboxes = false
+ARGV.grep( /^(-with-toolboxes)/ ) do |item|
+with_toolboxes = true 
+  ARGV.delete(item)
+end
+
+#look for config arg
+merge = true
+ARGV.grep( /^(-ignore-config)/ )do |item|
+  merge = false
+  ARGV.delete(item)
+end
+
+
+folder = '.'
+robots = ARGV
+ARGV.grep( /^-dir=(.+)$/ )do |item|
+  begin
+    folder = $1
+    pwd = Dir.pwd
+    Dir.chdir(folder)
+    robots = Dir.glob('*.rb')
+    Dir.chdir(pwd)
+    ARGV.delete(item)
+  rescue Exception
+    puts "can't change directory to '#{folder}'"
+    exit(0)
+  end
+end
+
+ARGV.grep( /^-(.*)$/ )do |item|
+  puts "Unknown option '-#{$1}'"
+  puts
+  usage
+end
+
+usage if robots.length <= 1
+$stdout.sync = true
+
+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 = []
+    matches_per_round.times do |i|
+      puts "- Match #{i+1} of #{matches_per_round} -"
+      cmd = "rrobots -nogui -timeout=#{timeout} "
+      cmd += "-with-toolboxes " if with_toolboxes  
+      cmd += "-ignore-config" if merge
+      cmd += "#{folder}/#{bot1} #{folder}/#{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 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}
+
+