bcpm 0.11

data/lib/bcpm/dist.rb

@@ -0,0 +1,133 @@
+require 'fileutils'
+require 'shellwords'
+
+# :nodoc: namespace
+module Bcpm
+
+# Battle-code distribution management.
+module Dist
+  # Hooks a player's code into the installed battlecode distribution.
+  def self.add_player(player_path)
+    team_path = File.join dist_path, 'teams', File.basename(player_path)    
+    if /mingw/ =~ RUBY_PLATFORM || (/win/ =~ RUBY_PLATFORM && /darwin/ !~ RUBY_PLATFORM)
+      Dir.rmdir team_path if File.exist? team_path
+      command = Shellwords.shelljoin(['cmd', '/C', 'mklink', '/D', team_path.gsub('/', '\\'),
+                                      player_path.gsub('/', '\\')])
+      Kernel.`(command)
+    else
+      File.unlink team_path if File.exist? team_path
+      FileUtils.ln_s player_path, team_path
+    end
+  end
+  
+  # Unhooks a player's code from the installed battlecode distribution.
+  def self.remove_player(player_path)
+    return unless contains_player?(player_path)
+    team_path = File.join dist_path, 'teams', File.basename(player_path)
+    if /mingw/ =~ RUBY_PLATFORM || (/win/ =~ RUBY_PLATFORM && /darwin/ !~ RUBY_PLATFORM)
+      Dir.rmdir team_path
+    else
+      File.unlink team_path
+    end
+    bin_path = File.join dist_path, 'bin', File.basename(player_path)
+    FileUtils.rm_rf bin_path if File.exist?(bin_path)
+  end
+
+  # True if the given path is a player that is hooked into the distribution.
+  def self.contains_player?(player_path)
+    team_path = File.join dist_path, 'teams', File.basename(player_path)
+    if /mingw/ =~ RUBY_PLATFORM || (/win/ =~ RUBY_PLATFORM && /darwin/ !~ RUBY_PLATFORM)
+      File.exist? team_path
+    else
+      File.exist?(team_path) && File.symlink?(team_path) && File.readlink(team_path) == player_path
+    end
+  end
+  
+  # Upgrades the installed battlecode distribution to the latest version.
+  #
+  # Does a fresh install if no distribution is configured.
+  def self.upgrade
+    return install unless installed?
+    Bcpm::Git.update_repo dist_path
+  end
+  
+  # Installs the latest battlecode distribution.
+  def self.install
+    Bcpm::Git.clone_repo repo_uri, 'master', dist_path
+    Bcpm::Config[:dist_repo_uri] = repo_uri
+    Bcpm::Config[:dist_path] = dist_path
+  end  
+
+  # True if a battlecode distribution is installed on the local machine.
+  def self.installed?
+    Bcpm::Config.config.has_key? :dist_path
+  end
+  
+  # Removes the battlecode distribution installed on the location machine.
+  def self.uninstall
+    return unless installed?
+    FileUtils.rm_rf dist_path
+    Bcpm::Config[:dist_path] = nil
+  end
+  
+  # Path to the battlecode ant file.
+  def self.ant_file
+    File.join dist_path, 'build.xml'
+  end
+  
+  # Path to the battlecode maps directory.
+  def self.maps_path
+    File.join dist_path, 'maps'
+  end
+  
+  # Path to the battlecode simulator configuration file.
+  def self.conf_file
+    File.join dist_path, 'bc.conf'
+  end
+    
+  # Path to the locally installed battlecode distribution.
+  def self.dist_path
+    Bcpm::Config[:dist_path] || default_dist_path
+  end
+
+  # Path to the locally installed battlecode distribution.
+  def self.default_dist_path
+    if File.exist?('.metadata') && File.directory?('.metadata')
+      File.expand_path './battlecode'
+    else
+      File.expand_path '~/battlecode'
+    end
+  end
+
+  # Git URI to the distribution repository.
+  def self.repo_uri
+    Bcpm::Config[:dist_repo_uri] || default_repo_uri
+  end
+  
+  # Git URI to the distribution repository.  
+  def self.default_repo_uri
+    'git@git.pwnb.us:six370/battlecode2011.git'
+  end
+
+  # Maps installed in the battlecode distribution.
+  def self.maps
+    Dir.glob(File.join(maps_path, '*.xml')).map do |f|
+      File.basename(f).sub(/\.xml$/, '')
+    end
+  end
+
+  # Copies a battlecode distribution map.
+  def self.copy_map(map_name, destination)
+    map_file = File.join maps_path, map_name + '.xml'
+    unless File.exist?(map_file)
+      puts "No map found at#{map_file}"
+      return
+    end
+    if File.exist?(destination) && File.directory?(destination)
+      destionation = File.join destination, map_name + '.xml'
+    end
+    FileUtils.cp map_file, destination
+  end
+end
+
+end  # namespace Bcpm

data/lib/bcpm/duel.rb

@@ -0,0 +1,153 @@
+require 'fileutils'
+require 'thread'
+
+# :nodoc: namespace
+module Bcpm
+
+# Pits players against other players.
+module Duel
+  # Has two players fight on all maps in both positions.
+  def self.duel_pair(player1_name, player2_name, show_progress = false,
+                     maps = nil)
+    maps ||= Bcpm::Dist.maps.sort
+    
+    # Abort in case of typos.
+    [player1_name, player2_name].each do |player|
+      unless Bcpm::Player.wired? player
+        puts "Player #{player} is not installed\n"
+        exit 1
+      end
+    end
+
+    # Abort in case of compile errors.
+    env = Bcpm::Tests::Environment.new player1_name
+    unless env.build
+      print env.build_log
+      exit 1
+    end
+
+    # Compute the matches.
+    matches = maps.map { |map_name|
+      [:a, :b].map do |side|
+        Bcpm::Tests::TestMatch.new side, player2_name, map_name, env
+      end
+    }.flatten
+    
+    # Compute stats.
+    score, wins, losses, errors = 0, [], [], []
+    multiplex_matches(matches) do |match|
+      score_delta = case match.winner
+      when :a, :b
+        (match.winner == match.side) ? 1 : -1
+      else
+        0
+      end
+      if show_progress
+        print "#{player1_name} #{match.description}: #{outcome_string(score_delta)}\n"
+        STDOUT.flush
+      end
+      score += score_delta if score_delta
+      case score_delta
+      when 1
+        wins << match
+      when -1
+        losses << match
+      when 0
+        errors << match
+      end
+    end
+    { :score => score, :wins => wins, :losses => losses, :errors => errors }
+  end
+  
+  # Runs may matches in parallel.
+  #
+  # Returns the given matches. If given a block, also yields each match as it
+  # becomes available.
+  def self.multiplex_matches(matches)
+     # Schedule matches.
+    in_queue = Queue.new
+    matches.each do |match|
+      in_queue.push match
+    end
+    match_threads.times { in_queue.push nil }
+
+    # Execute matches.
+    out_queue = Queue.new
+    old_abort = Thread.abort_on_exception
+    Thread.abort_on_exception = true
+    match_threads.times do
+      Thread.new do
+        loop do
+          break unless match = in_queue.pop
+          match.run false
+          out_queue.push match
+        end
+      end
+    end
+    Thread.abort_on_exception = old_abort
+   
+    matches.length.times do
+      match = out_queue.pop
+      if Kernel.block_given?
+        yield match
+      end
+    end
+    matches
+  end
+  
+  # The string to be shown for a match outcome.
+  def self.outcome_string(score_delta)
+    # TODO(pwnall): ANSI color codes
+    if /mingw/ =~ RUBY_PLATFORM ||
+        (/win/ =~ RUBY_PLATFORM && /darwin/ !~ RUBY_PLATFORM)
+      {0 => "error", 1 => "won", -1 => "lost"}[score_delta]
+    else
+      {
+        0 => "\33[33merror\33[0m",
+        1 => "\33[32mwon\33[0m",
+        -1 => "\33[31mlost\33[0m"
+      }[score_delta]
+    end
+  end
+  
+  # Number of threads to use for simulating matches.
+  def self.match_threads
+    (Bcpm::Config[:match_threads] ||= default_match_threads).to_i
+  end
+
+  # Number of threads to use for simulating matches.
+  def self.default_match_threads
+    1
+  end
+  
+  # Has all players compete against each other.
+  def self.rank_players(player_list, show_progress = false, maps = nil)
+    scores = {}
+    0.upto(player_list.length - 1) do |i|
+      0.upto(i - 1) do |j|
+        outcome = duel_pair player_list[i], player_list[j], show_progress, maps
+        scores[i] ||= 0
+        scores[i] += outcome[:score]
+        scores[j] ||= 0
+        scores[j] -= outcome[:score]
+      end
+    end
+    scores.map { |k, v| [v, player_list[k]] }.
+           sort_by { |score, player| [-score, player] }
+  end
+
+  # Scores one player against the other players.
+  def self.score_player(player, player_list, show_progress = false, maps = nil)
+    player_list = player_list - [player]
+    scores = player_list.map do |opponent|
+       [
+         duel_pair(player, opponent, show_progress, maps)[:score],
+         opponent
+       ]
+    end
+    { :points => scores.map(&:first).inject(0) { |a, b| a + b},
+      :scores => scores.sort_by { |score, player| [score, player] } }    
+  end
+end  # module Bcpm::Duel
+
+end  # namespace Bcpm

data/lib/bcpm/git.rb

@@ -0,0 +1,93 @@
+require 'fileutils'
+require 'socket'
+
+# :nodoc: namespace
+module Bcpm
+
+# Git repository operations.
+module Git
+  # Clones a repository.
+  #
+  # Returns true for success, false if something went wrong.
+  def self.clone_repo(repo_uri, repo_branch, local_path)
+    FileUtils.mkdir_p File.dirname(local_path)
+    success = nil
+    Dir.chdir File.dirname(local_path) do
+      FileUtils.rm_rf File.basename(local_path) if File.exists?(local_path)
+      if repo_branch == 'master'
+        success = Kernel.system 'git', 'clone', repo_uri,
+                                File.basename(local_path)
+      else
+        success = Kernel.system 'git', 'clone', '--branch', repo_branch,
+                                repo_uri, File.basename(local_path)
+        unless success
+          success = Kernel.system 'git', 'clone', repo_uri,
+                                  File.basename(local_path)
+          if success
+            Dir.chdir File.basename(local_path) do
+              success = Kernel.system 'git', 'checkout', '-q',
+                                      'origin/' + repo_branch
+            end
+          end
+        end
+      end
+    end
+    FileUtils.rm_rf local_path unless success
+    success
+  end
+  
+  # Downloads a snapshot of a repository.
+  #
+  # Returns true for success, false if something went wrong.
+  def self.checkpoint_repo(repo_uri, repo_branch, local_path)
+    FileUtils.mkdir_p local_path
+    success = nil
+    Dir.chdir File.dirname(local_path) do
+      zip_file = File.basename(local_path) + '.zip'
+      success = Kernel.system('git', 'archive', '--format=zip',
+          '--remote', repo_uri, '--output', zip_file, '-9', repo_branch)
+      if success
+        Dir.chdir File.basename(File.basename(local_path)) do
+          success = Kernel.system 'unzip', '-qq', File.join('..', zip_file)
+        end
+      end
+      File.unlink zip_file if File.exist?(zip_file)
+    end
+    unless success
+      puts "Trying workaround for old git"
+      success = clone_repo repo_uri, repo_branch, local_path
+      FileUtils.rm_rf File.join(local_path, '.git') if success
+    end
+    
+    FileUtils.rm_rf local_path unless success
+    success
+  end
+  
+  # Checks out the working copy of the repository.
+  #
+  # Returns true for success, false if something went wrong.
+  def self.checkpoint_local_repo(repo_path, local_path)
+    return false unless File.exist?(repo_path)
+    FileUtils.mkdir_p local_path
+    Dir.entries(repo_path).each do |entry|
+      next if ['.', '..', '.git'].include? entry
+      FileUtils.cp_r File.join(repo_path, entry), local_path
+    end
+    true
+  end
+  
+  # Pulls the latest changes into the repository.
+  def self.update_repo(local_path)
+    Dir.chdir local_path do
+      Kernel.system 'git', 'pull'
+    end
+  end
+
+  # Temporary directory name.
+  def self.tempdir
+    File.join Dir.tmpdir, 'bcpm',
+        "update_#{Socket.hostname}_#{(Time.now.to_f * 1000).to_i}_#{$PID}"
+  end
+end  # module Bcpm::Git
+
+end  # namespace Bcpm

data/lib/bcpm/match.rb

@@ -0,0 +1,275 @@
+require 'English'
+require 'fileutils'
+require 'shellwords'
+require 'socket'
+require 'thread'
+require 'tmpdir'
+
+# :nodoc: namespace
+module Bcpm
+
+# Runs matches between players.
+module Match
+  # Runs a match between two players.
+  def self.run(player1_name, player2_name, map_name, mode)
+    env = Bcpm::Tests::Environment.new player1_name
+    options = {}
+    if mode == :debug
+      Bcpm::Config[:breakpoints] ||= true
+      Bcpm::Config[:debugcode] ||= true
+      Bcpm::Config[:noupkeep] ||= false
+      Bcpm::Config[:debuglimit] ||= 1_000_000
+      options = Hash[engine_options.map { |k, v| [v, Bcpm::Config[k]] }]
+    end
+    match = Bcpm::Tests::TestMatch.new :a, player2_name, map_name, env, options
+    match.run(mode != :file)
+    "Winner side: #{match.winner.to_s.upcase}\n" + match.stash_data
+  end
+  
+  # Key-value pairs for friendly => canonical names of battlecode engine options.
+  def self.engine_options
+    {
+      'breakpoints' => 'bc.engine.breakpoints',
+      'debugcode' => 'bc.engine.debug-methods',
+      'noupkeep' => 'bc.engine.upkeep',
+      'debuglimit' => 'bc.engine.debug-max-bytecodes'
+    }
+  end
+  
+  # Runs a match between two players and returns the log data.
+  #
+  # Args:
+  #   player1_name:: name of locally installed player (A)
+  #   player2_name:: name of locally installed player (B)
+  #   silence_b:: if true, B is silenced; otherwise, A is silenced
+  #   map_name:: name of map .xml file (or full path for custom map)
+  #   run_live:: if true, tries to run the match using the live UI
+  #   bc_options:: hash of simulator settings to be added to bc.conf
+  def self.match_data(player1_name, player2_name, silence_b, map_name, run_live, bc_options = {})
+    uid = tempfile
+    tempdir = File.expand_path File.join(Dir.tmpdir, 'bcpm', 'match_' + uid)
+    FileUtils.mkdir_p tempdir
+    binfile = File.join tempdir, 'match.rms'
+    txtfile = File.join tempdir, 'match.txt'
+    build_log = File.join tempdir, 'build.log'
+    match_log = File.join tempdir, 'match.log'
+    scribe_log = File.join tempdir, 'scribe.log' 
+
+    bc_config = simulator_config player1_name, player2_name, silence_b, map_name, binfile, txtfile
+    bc_config.merge! bc_options
+    conf_file = File.join tempdir, 'bc.conf'
+    write_config conf_file, bc_config
+    write_ui_config conf_file, true, bc_config if run_live
+    build_file = File.join tempdir, 'build.xml'
+    write_build build_file, conf_file
+    
+    if run_live
+      run_build_script tempdir, build_file, match_log, 'run', 'Stop buffering match'
+    else
+      run_build_script tempdir, build_file, match_log, 'file'
+    end        
+    run_build_script tempdir, build_file, scribe_log, 'transcribe'
+    
+    textlog = File.exist?(txtfile) ? File.open(txtfile, 'rb') { |f| f.read } : ''
+    binlog = File.exist?(binfile) ? File.open(binfile, 'rb') { |f| f.read } : ''
+    antlog = File.exist?(match_log) ? File.open(match_log, 'rb') { |f| f.read } : ''
+    FileUtils.rm_rf tempdir
+    
+    { :ant => extract_ant_log(antlog), :rms => binlog, :script => textlog, :uid => uid }
+  end
+  
+  # Replays a match using the binlog (.rms file).
+  def self.replay(binfile)
+    tempdir = File.join Dir.tmpdir, 'bcpm', 'match_' + tempfile
+    FileUtils.mkdir_p tempdir
+    match_log = File.join tempdir, 'match.log'
+
+    bc_config = simulator_config nil, nil, true, nil, binfile, nil
+    conf_file = File.join tempdir, 'bc.conf'      
+    write_config conf_file, bc_config
+    write_ui_config conf_file, false, bc_config
+    build_file = File.join tempdir, 'build.xml'
+    write_build build_file, conf_file
+    
+    run_build_script tempdir, build_file, match_log, 'run'
+    FileUtils.rm_rf tempdir
+  end
+  
+  # Options to be overridden for the battlecode simulator.
+  def self.simulator_config(player1_name, player2_name, silence_b, map_name, binfile, txtfile)
+    Bcpm::Config[:client3d] ||= 'off'
+    Bcpm::Config[:sound] ||= 'off'
+    config = {
+      'bc.engine.silence-a' => !silence_b,
+      'bc.engine.silence-b' => !!silence_b,
+      'bc.dialog.skip' => true,
+      'bc.server.throttle' => 'yield',
+      'bc.server.throttle-count' => 100000,
+      'bc.client.opengl' => Bcpm::Config[:client3d],
+      'bc.client.sound-on' => Bcpm::Config[:sound] || 'off',
+      
+      # Healthy production defaults.
+      'bc.engine.breakpoints' => false,
+      'bc.engine.debug-methods' => false,
+      'bc.engine.upkeep' => true
+    }
+    map_path = nil
+    if map_name
+      if File.basename(map_name) != map_name
+        map_path = File.dirname map_name
+        map_name = File.basename(map_name).sub(/\.xml$/, '')
+      end
+    end
+    config['bc.game.maps'] = map_name if map_name
+    config['bc.game.map-path'] = map_path if map_path
+    config['bc.game.team-a'] = player1_name if player1_name
+    config['bc.game.team-b'] = player2_name if player2_name
+    config['bc.server.save-file'] = binfile if binfile
+    config['bc.server.transcribe-input'] = binfile if binfile
+    config['bc.server.transcribe-output'] = txtfile if txtfile
+    config
+  end
+  
+  # Memory to be dedicated to the simulation JVM (in megabytes.)
+  def self.vm_ram
+    (Bcpm::Config['vm_ram'] ||= default_vm_ram).to_i
+  end
+  
+  # Memory to be dedicated to the simulation JVM (in megabytes.)
+  def self.default_vm_ram
+    1024
+  end
+    
+  # Writes a patched buildfile that references the given configuration file.
+  def self.write_build(buildfile, conffile)
+    contents = Bcpm::Player.ant_config conffile
+    File.open(buildfile, 'wb') { |f| f.write contents }
+  end
+  
+  # Writes a cleaned up battlecode simulator configuration file.
+  def self.write_config(conffile, options = {})
+    lines = File.read(Bcpm::Dist.conf_file).split("\n")
+    lines = lines.reject do |line|
+      key = line.split('=', 2).first
+      options.has_key? key
+    end
+    lines += options.map { |key, value| "#{key}=#{value}" }
+    File.open(conffile, 'wb') { |f| f.write lines.join("\n") + "\n" }
+  end
+  
+  # Writes the configuration for the battlecode UI.
+  #
+  # This is a singleton file, so only one client should run at a time.
+  def self.write_ui_config(conffile, run_live, options = {})
+    save_path = options['bc.server.save-file'] || ''
+    if /mingw/ =~ RUBY_PLATFORM || (/win/ =~ RUBY_PLATFORM && /darwin/ !~ RUBY_PLATFORM)
+      save_path = save_path.dup
+      save_path.gsub! '\\', '\\\\\\\\'
+      save_path.gsub! '/', '\\\\\\\\'
+      if save_path[1, 2] == ':\\'
+        save_path[1, 2] = '\\:\\'
+      end
+    end
+    
+    choice = run_live ? 'LOCAL' : 'FILE'
+    File.open(File.expand_path('~/.battlecode.ui'), 'wb') do |f|
+      f.write <<END_CONFIG
+choice=#{choice}
+save=#{run_live}
+save-file=#{save_path}
+file=#{save_path}
+host=
+analyzeFile=false
+glclient=#{options['bc.client.opengl'] || 'false'}
+showMinimap=false
+MAP=#{options['bc.game.maps']}
+maps=#{options['bc.game.maps']}
+TEAM_A=#{options['bc.game.team-a']}
+TEAM_B=#{options['bc.game.team-b']}
+lockstep=false
+END_CONFIG
+    end
+  end
+  
+  # Runs the battlecode Ant script.
+  def self.run_build_script(target_dir, build_file, log_file, target, run_live = false)
+    if run_live
+      Dir.chdir target_dir do
+        command = Shellwords.shelljoin(['ant', '-noinput', '-buildfile',
+                                        build_file, target])
+  
+        # Start the build as a subprocess, dump its output to the queue as
+        # string fragments. nil means the subprocess completed.
+        queue = Queue.new
+        thread = Thread.start do
+          IO.popen command do |f|
+            begin
+              loop { queue << f.readpartial(1024) }
+            rescue EOFError
+              queue << nil
+            end
+          end
+        end
+  
+        build_output = ''
+        while fragment = queue.pop
+          # Dump the build output to the screen as the simulation happens.
+          print fragment
+          STDOUT.flush
+          build_output << fragment
+        
+          # Let bcpm carry on when the simulation completes.
+          break if build_output.index(run_live)
+        end
+        build_output << "\n" if build_output[-1] != ?\n
+        
+        # Pretend everything was put in a log file.
+        File.open(log_file, 'wb') { |f| f.write build_output }
+        return thread
+      end
+    else
+      command = Shellwords.shelljoin(['ant', '-noinput', '-buildfile',
+                                      build_file, '-logfile', log_file, target])
+      if /mingw/ =~ RUBY_PLATFORM ||
+          (/win/ =~ RUBY_PLATFORM && /darwin/ !~ RUBY_PLATFORM)
+        Dir.chdir target_dir do
+          output = Kernel.`(command)
+          # If there is no log file, dump the output to the log.
+          unless File.exist?(log_file)
+            File.open(log_file, 'wb') { |f| f.write output }
+          end
+        end
+      else
+        pid = fork do
+          Dir.chdir target_dir do
+            output = Kernel.`(command)
+            # If there is no log file, dump the output to the log.
+            unless File.exist?(log_file)
+              File.open(log_file, 'wb') { |f| f.write output }
+            end
+          end
+        end
+        Process.wait pid
+      end
+    end
+  end
+  
+  # Selects the battlecode simulator log out of an ant log.
+  def self.extract_ant_log(contents)
+    lines = []
+    contents.split("\n").each do |line|
+      start = line.index '[java] '
+      next unless start
+      lines << line[(start + 7)..-1]
+      break if line.index('- Match Finished -')
+    end
+    lines.join("\n")
+  end
+  
+  # Temporary file name.
+  def self.tempfile
+    "#{Socket.hostname}_#{'%x' % (Time.now.to_f * 1000).to_i}_#{$PID}_#{'%x' % Thread.current.object_id}"
+  end
+end  # module Bcpm::Match
+
+end  # namespace Bcpm