tournament 1.1.0 → 2.0.0

data/lib/tournament/pool.rb

@@ -7,12 +7,14 @@ class Tournament::Pool
   attr_reader :entries  # Tournament::Entry objects for participants
   attr_reader :payouts  # Hash of payouts by rank
   attr_accessor :entry_fee  # The amount each entry paid to participate
+  attr_reader :scoring_strategy  # The scoring strategy for the pool
 
   # Create a new empty pool with no Regions or Entries
   def initialize
     @regions = Array.new(4)
     @entries = []
     @payouts = {}
+    @scoring_strategy = Tournament::ScoringStrategy::Basic.new
   end
 
   # add regions to the pool.  Champ of region with index = 0 plays
@@ -29,6 +31,11 @@ class Tournament::Pool
     @entries << entry
   end
 
+  # Set new scoring strategy.  This should not be allowed.
+  def scoring_strategy=(new_strat)
+    @scoring_strategy = new_strat
+  end
+
   # Add an Tournament::Entry object to the pool after reading the Tournament::Entry
   # from the provided YAML file.
   def add_entry_yaml(yaml)
@@ -43,6 +50,12 @@ class Tournament::Pool
     end
   end
 
+  # Replace existing matching entry with the provided entry
+  def update_entry(entry)
+    remove_by_name(entry.name)
+    @entries << entry
+  end
+
   # Set a payout.  Takes a rank (or the symbol :last for
   # last place), along with the payout.  The payout may be
   # a positive integer, in which case, it represents a 
@@ -56,11 +69,11 @@ class Tournament::Pool
     @payouts[rank] = payout
   end
 
-  # Creates a bracket for the pool by combining all the
+  # Creates a entry for the pool by combining all the
   # regions into one bracket of 64 teams.  By default the
-  # bracket uses the basic scoring strategy.
-  def bracket
-    unless @bracket
+  # entry bracket uses the basic scoring strategy.
+  def tournament_entry
+    unless @tournament_entry
       if @regions.compact.size != 4
         raise "Not all regions have been set."
       end
@@ -68,15 +81,16 @@ class Tournament::Pool
         region[:teams]
       end
       all_teams = all_teams.flatten
-      @bracket = Tournament::Bracket.new(all_teams)
+      bracket = Tournament::Bracket.new(all_teams)
+      @tournament_entry = Tournament::Entry.new('Tournament Entry', bracket, nil)
     end
-    return @bracket
+    return @tournament_entry
   end
 
   # Replaces the pool's bracket (as in after updating the bracket
   # for game results)
-  def bracket=(new_bracket)
-    @bracket = new_bracket
+  def tournament_entry=(new_entry)
+    @tournament_entry = new_entry
   end
 
   # Creates a Pool object for the 2008 NCAA tournament
@@ -177,8 +191,8 @@ class Tournament::Pool
     pool.set_payout(2, 20)
     pool.set_payout(3, 10)
     pool.set_payout(:last, -10)
-    b = pool.bracket
-    b.scoring_strategy = Tournament::Bracket::UpsetScoringStrategy.new
+    pool.scoring_strategy = Tournament::ScoringStrategy::Upset.new
+    b = pool.tournament_entry.picks
     picks = (1..num_picks).map {|n| Tournament::Bracket.random_bracket(b.teams)}
     # Play out the bracket
     32.times { |n| b.set_winner(1,n+1, b.matchup(1, n+1)[rand(2)])}
@@ -189,7 +203,7 @@ class Tournament::Pool
     #1.times { |n| b.set_winner(6,n+1, b.matchup(6, n+1)[rand(2)])}
     picks.each_with_index {|p, idx| pool.add_entry Tournament::Entry.new("picker_#{idx}", p) }
     picks.each_with_index do |p, idx|
-      puts "Score #{idx+1}: #{p.score_against(b)}"
+      puts "Score #{idx+1}: #{p.score_against(b, pool.scoring_strategy)}"
     end
     pool.region_report
     pool.leader_report
@@ -201,65 +215,86 @@ class Tournament::Pool
 
   # Generate the leader board report.  Shows each entry sorted by current 
   # score and gives a breakdown of score by round.
-  def leader_report
-    puts "Total games played: #{@bracket.games_played}"
-    puts "Number of entries: #{@entries.size}"
+  def leader_report(out = $stdout)
+    out << "Total games played: #{tournament_entry.picks.games_played}" << "\n"
+    if tournament_entry.picks.complete?
+      out << "Champion: #{tournament_entry.picks.champion.name}" << "\n"
+    end
+    out << "Pool Tie Break: #{tournament_entry.tie_breaker || '-'}" << "\n"
+    out << "Number of entries: #{@entries.size}" << "\n"
+    current_rank = 1
     if @entries.size > 0
-      puts " Curr| Max |               |Champ| Round Scores"
-      puts "Score|Score|      Name     |Live?|" + (1..bracket.rounds).to_a.map{|r| "%3d" % r}.join(" ")
-      sep ="-----+-----+---------------+-----+" + ("-" * 4 * bracket.rounds)
-      puts sep
-      @entries.sort_by {|e| -e.picks.score_against(bracket)}.each do |entry|
-        total = entry.picks.score_against(bracket)
-        max = entry.picks.maximum_score(bracket)
+      out << "    | Curr| Max |               |Champ| Tie | Round Scores" << "\n"
+      out << "Rank|Score|Score|      Name     |Live?|Break|" + (1..tournament_entry.picks.rounds).to_a.map{|r| "%3d" % r}.join(" ") << "\n"
+      sep ="----+-----+-----+---------------+-----+-----+" + ("-" * 4 * tournament_entry.picks.rounds)
+      out << sep << "\n"
+      @entries.sort do |e1, e2|
+        s1 = e1.picks.score_against(tournament_entry.picks, self.scoring_strategy)
+        s2 = e2.picks.score_against(tournament_entry.picks, self.scoring_strategy)
+        if s1 == s2 && tournament_entry.tie_breaker
+          s1 = 0 - (e1.tie_breaker - tournament_entry.tie_breaker).abs
+          s2 = 0 - (e2.tie_breaker - tournament_entry.tie_breaker).abs
+        end
+        s2 <=> s1
+      end.inject(nil) do |last_entry, entry|
+        total = entry.picks.score_against(tournament_entry.picks, self.scoring_strategy)
+        max = entry.picks.maximum_score(tournament_entry.picks, self.scoring_strategy)
         champ = entry.picks.champion
         round_scores = []
-        1.upto(bracket.rounds) do |round|
-          scores = entry.picks.scores_for_round(round, bracket)
+        1.upto(tournament_entry.picks.rounds) do |round|
+          scores = entry.picks.scores_for_round(round, tournament_entry.picks, self.scoring_strategy)
           round_scores << scores.inject(0) {|sum, arr| sum += (arr[0] ? arr[0] : 0)}
         end
-        puts "%5d|%5d|%15s|%3s %1s|%s" % [total, max, entry.name,
-          champ.short_name,(bracket.still_alive?(champ) ? 'Y' : 'N'), round_scores.map {|s| "%3d" % s}.join(" ")]
+        rank_display = nil
+        if last_entry && !tournament_entry.tie_breaker && total == last_entry.bracket.score_against(tournament_entry.picks, self.scoring_strategy)
+          rank_display = 'TIE'
+        else
+          rank_display = "%4d" % current_rank
+        end
+        out << "%4s|%5d|%5d|%15s|%3s %1s|%5d|%s" % [rank_display, total, max, entry.name,
+          champ.short_name,(tournament_entry.picks.still_alive?(champ) ? 'Y' : 'N'), entry.tie_breaker || '-', round_scores.map {|s| "%3d" % s}.join(" ")] << "\n"
+        current_rank += 1
+        entry
       end
-      puts sep
+      out << sep << "\n"
     end
   end
 
   # Shows detailed scores per entry.  For each pick in each game, shows
   # either a positive amount if the pick was correct, 0 if the pick was
   # incorrect, or a '?' if the game has not yet been played.
-  def score_report
+  def score_report(out = $stdout)
     # Compute scores
-    puts "Total games played: #{@bracket.games_played}"
-    puts "Number of entries: #{@entries.size}"
+    out << "Total games played: #{tournament_entry.picks.games_played}" << "\n"
+    out << "Number of entries: #{@entries.size}" << "\n"
     sep = "-----+---------------+----------------------------------------------------------------------------------"
     if @entries.size > 0
-      puts "Total|      Name     | Round Scores"
-      puts sep
+      out << "Total|      Name     | Round Scores" << "\n"
+      out << sep << "\n"
       fmt1 = "%5d|%15s|%d: %3d %s" 
       fmt2 = "     |               |%d: %3d %s" 
       fmt3 = "     |               |       %s" 
-      @entries.sort_by {|e| -e.picks.score_against(bracket)}.each do |entry|
-        total = entry.picks.score_against(bracket)
-        1.upto(bracket.rounds) do |round|
-          scores = entry.picks.scores_for_round(round, bracket)
+      @entries.sort_by {|e| -e.picks.score_against(tournament_entry.picks, self.scoring_strategy)}.each do |entry|
+        total = entry.picks.score_against(tournament_entry.picks, self.scoring_strategy)
+        1.upto(tournament_entry.picks.rounds) do |round|
+          scores = entry.picks.scores_for_round(round, tournament_entry.picks, self.scoring_strategy)
           round_total = scores.inject(0) {|sum, arr| sum += (arr[0] ? arr[0] : 0)}
           scores_str = scores.map{|arr| "#{arr[1].short_name}=#{arr[0] ? arr[0] : '?'}"}.join(" ")
           if [1,2].include?(round)
             scores_str_arr = Tournament::Pool.split_line(scores_str, 70)
             if round == 1
-              puts fmt1 % [total, entry.name, round, round_total, scores_str_arr[0]]
+              out << fmt1 % [total, entry.name, round, round_total, scores_str_arr[0]] << "\n"
             else
-              puts fmt2 % [round, round_total, scores_str_arr[0]]
+              out << fmt2 % [round, round_total, scores_str_arr[0]] << "\n"
             end
             scores_str_arr[1..-1].each do |scores_str|
-              puts fmt3 % scores_str
+              out << fmt3 % scores_str << "\n"
             end
           else
-            puts fmt2 % [round, round_total, scores_str]
+            out << fmt2 % [round, round_total, scores_str] << "\n"
           end
         end
-        puts sep
+        out << sep << "\n"
       end
     end
   end
@@ -280,16 +315,16 @@ class Tournament::Pool
   end
 
   # Shows a report of each entry's picks by round.
-  def entry_report
-    puts "There are #{@entries.size} entries."
+  def entry_report(out = $stdout)
+    out << "There are #{@entries.size} entries." << "\n"
     if @entries.size > 0
-      puts "".center(15) + "|" + "First Round".center(128)
-      puts "Name".center(15) + "|" + "Sweet 16".center(64) + "|" + "Elite 8".center(32) +
+      out << "".center(15) + "|" + "First Round".center(128) << "\n"
+      out << "Name".center(15) + "|" + "Sweet 16".center(64) + "|" + "Elite 8".center(32) +
         "|" + "Final 4".center(16) + "|" + "Final 2".center(8) + "|" + "Champion".center(15) +
-        "|" + "Tie Break"
-      puts ("-" * 15) + "+" + ("-" * 64) + "+" + ("-" * 32) +
+        "|" + "Tie Break" << "\n"
+      out << ("-" * 15) + "+" + ("-" * 64) + "+" + ("-" * 32) +
         "+" + ("-" * 16) + "+" + ("-" * 8) + "+" + ("-" * 15) +
-        "+" + ("-" * 10)
+        "+" + ("-" * 10) << "\n"
       output = Proc.new do |name, bracket, tie_breaker|
         first_round = bracket.winners[1].map {|t| "%s" % (t.short_name rescue 'Unk')}.join('-')
         sweet_16 = bracket.winners[2].map {|t| "%s" % (t.short_name rescue 'Unk')}.join('-')
@@ -297,15 +332,15 @@ class Tournament::Pool
         final_4 = bracket.winners[4].map {|t| "%s" % (t.short_name rescue 'Unk')}.join('-')
         final_2 = bracket.winners[5].map {|t| "%s" % (t.short_name rescue 'Unk')}.join('-')
         champ = bracket.champion.name rescue 'Unk'
-        puts "               |%128s" % first_round
-        puts "%15s|%64s|%32s|%16s|%8s|%15s|%s" %
-          [name, sweet_16, elite_8, final_4, final_2, champ, tie_breaker.to_s] 
-        puts ("-" * 15) + "+" + ("-" * 64) + "+" + ("-" * 32) +
+        out << "               |%128s" % first_round << "\n"
+        out << "%15s|%64s|%32s|%16s|%8s|%15s|%s" %
+          [name, sweet_16, elite_8, final_4, final_2, champ, tie_breaker.to_s]  << "\n"
+        out << ("-" * 15) + "+" + ("-" * 64) + "+" + ("-" * 32) +
           "+" + ("-" * 16) + "+" + ("-" * 8) + "+" + ("-" * 15) +
-          "+" + ("-" * 10)
+          "+" + ("-" * 10) << "\n"
       end
 
-      output.call('Tournament', bracket, '-')
+      output.call('Tournament', tournament_entry.picks, tournament_entry.tie_breaker || '-')
 
       @entries.sort_by{|e| e.name}.each do |entry|
         output.call(entry.name, entry.picks, entry.tie_breaker)
@@ -314,8 +349,8 @@ class Tournament::Pool
   end
 
   # Displays the regions and teams in the region.
-  def region_report
-    puts " Region | Seed | Team               "
+  def region_report(out = $stdout)
+    out << " Region | Seed | Team               " << "\n"
     current_idx = -1
     @regions.each_with_index do |region, idx|
       region[:teams].each do |team|
@@ -323,23 +358,23 @@ class Tournament::Pool
         if idx != current_idx
           region_name =  region[:name]
           current_idx = idx
-          puts "--------+------+-------------------------"
+          out << "--------+------+-------------------------" << "\n"
         end
-        puts "%8s|%6d|%25s" % [region_name, team.seed, "#{team.name} (#{team.short_name})"]
+        out << "%8s|%6d|%25s" % [region_name, team.seed, "#{team.name} (#{team.short_name})"] << "\n"
       end
     end
   end
 
   # When there are four teams left, for each of the 16 possible outcomes
   # shows who will win according to the configured payouts.
-  def final_four_report
+  def final_four_report(out = $stdout)
     if @entries.size == 0
-      puts "There are no entries in the pool."
+      out << "There are no entries in the pool." << "\n"
       return
     end
-    if self.bracket.teams_left != 4
-      puts "The final four report should only be run when there"
-      puts "are exactly four teams left in the tournament."
+    if self.tournament_entry.picks.teams_left > 4
+      out << "The final four report should only be run when there" << "\n"
+      out << "are four or fewer teams left in the tournament." << "\n"
       return
     end
     total_payout = @entries.size * @entry_fee
@@ -356,23 +391,39 @@ class Tournament::Pool
       end
     end
 
-    print "Final Four: #{self.bracket.winners[4][0,2].map{|t| "(#{t.seed}) #{t.name}"}.join(" vs. ")}"
-    puts "    #{self.bracket.winners[4][2,2].map{|t| "(#{t.seed}) #{t.name}"}.join(" vs. ")}"
-    puts "Payouts"
+    out << "Final Four: #{self.tournament_entry.picks.winners[4][0,2].map{|t| "(#{t.seed}) #{t.name}"}.join(" vs. ")}"
+    out << "    #{self.tournament_entry.picks.winners[4][2,2].map{|t| "(#{t.seed}) #{t.name}"}.join(" vs. ")}" << "\n"
+    if self.tournament_entry.picks.teams_left <= 2
+      out << "Championship: #{self.tournament_entry.picks.winners[5][0,2].map{|t| "(#{t.seed}) #{t.name}"}.join(" vs. ")}" << "\n"
+    end
+    out << "Payouts" << "\n"
     payout_keys.each do |key|
       amount = if @payouts[key] > 0
         @payouts[key].to_f / 100.0 * total_payout
       else
         -@payouts[key]
       end
-      puts "%4s: $%5.2f" % [key, amount]
+      out << "%4s: $%5.2f" % [key, amount] << "\n"
     end
     sep= "--------------+----------------+-----------------------------------------"
-    puts "              |                | Winners      Tie    "
-    puts " Championship |    Champion    | Rank Score Break Name"
-    puts sep
-    self.bracket.each_possible_bracket do |poss|
-      rankings = @entries.map{|p| [p, p.picks.score_against(poss)] }.sort_by {|arr| -arr[1] }
+    out << "              |                | Winners      Tie    " << "\n"
+    out << " Championship |    Champion    | Rank Score Break Name" << "\n"
+    out << sep << "\n"
+    self.tournament_entry.picks.each_possible_bracket do |poss|
+      rankings = @entries.map{|p| [p, p.picks.score_against(poss, self.scoring_strategy)] }.sort do |a1, a2|
+         if a1[1] == a2[1]
+           # Use tiebreak
+           if self.tournament_entry.tie_breaker
+             tb1 = (a1[0].tie_breaker - self.tournament_entry.tie_breaker).abs
+             tb2 = (a2[0].tie_breaker - self.tournament_entry.tie_breaker).abs
+             tb1 <=> tb2
+           else
+             0
+           end 
+         else
+           a2[1] <=> a1[1]
+         end
+      end
       finishers = {}
       @payouts.each do |rank, payout|
         finishers[rank] = {}
@@ -430,7 +481,7 @@ class Tournament::Pool
               winner.name
             ]
           end
-          puts line
+          out << line << "\n"
           first_line = false
         end
         payout_count += finish_hash[:entries].size
@@ -442,7 +493,7 @@ class Tournament::Pool
           end
         end
       end
-      puts sep
+      out << sep << "\n"
     end
     nil
   end
@@ -450,10 +501,10 @@ class Tournament::Pool
   # Runs through every possible outcome of the tournament and calculates
   # each entry's chance to win as a percentage of the possible outcomes
   # the entry would win if the tournament came out that way.
-  def possibility_report
+  def possibility_report(out = $stdout)
     $stdout.sync = true
     if @entries.size == 0
-      puts "There are no entries in the pool."
+      out << "There are no entries in the pool." << "\n"
       return
     end
     max_possible_score = @entries.map{|p| 0}
@@ -463,10 +514,10 @@ class Tournament::Pool
     count = 0
     old_percentage = -1 
     old_remaining = 1_000_000_000_000
-    puts "Checking #{self.bracket.number_of_outcomes} possible outcomes"
+    out << "Checking #{self.tournament_entry.picks.number_of_outcomes} possible outcomes" << "\n"
     start = Time.now.to_f
-    self.bracket.each_possible_bracket do |poss|
-      poss_scores = @entries.map{|p| p.picks.score_against(poss)}
+    self.tournament_entry.picks.each_possible_bracket do |poss|
+      poss_scores = @entries.map{|p| p.picks.score_against(poss, self.scoring_strategy)}
       sort_scores = poss_scores.sort.reverse
       @entries.each_with_index do |entry, i|
         score = poss_scores[i]
@@ -479,18 +530,18 @@ class Tournament::Pool
         end
       end
       count += 1
-      percentage = (count * 100.0 / self.bracket.number_of_outcomes)
+      percentage = (count * 100.0 / self.tournament_entry.picks.number_of_outcomes)
       elapsed = Time.now.to_f - start
       spp = elapsed / count
-      remaining = ((self.bracket.number_of_outcomes - count) * spp).to_i
+      remaining = ((self.tournament_entry.picks.number_of_outcomes - count) * spp).to_i
       if (percentage.to_i != old_percentage) || (remaining < old_remaining)
         old_remaining = remaining
         old_percentage = percentage.to_i
         hashes = '#' * (percentage.to_i/5) + '>'
-        print "\rCalculating: %3d%% +#{hashes.ljust(20, '-')}+ %5d seconds remaining" % [percentage.to_i, remaining]
+        out << "\rCalculating: %3d%% +#{hashes.ljust(20, '-')}+ %5d seconds remaining" % [percentage.to_i, remaining]
       end
     end
-    puts "\n"
+    out << "\n"
     #puts "\n   Max Scores: #{max_possible_score.inspect}"
     #puts "Highest Place: #{min_ranking.inspect}"
     #puts " Times Winner: #{times_winner.inspect}"
@@ -498,28 +549,28 @@ class Tournament::Pool
     times_winner.each_with_index { |n, i| sort_array << [n, i, min_ranking[i], max_possible_score[i], player_champions[i]] }
     sort_array = sort_array.sort_by {|arr| arr[0] == 0 ? (arr[2] == 0 ? -arr[3] : arr[2]) : -arr[0]}
     #puts "SORT: #{sort_array.inspect}"
-    puts "    Entry           | Win Chance | Highest Place | Max Score | Tie Break  "
-    puts "--------------------+------------+---------------+-----------+------------"
+    out << "    Entry           | Win Chance | Highest Place | Curr Score | Max Score | Tie Break  " << "\n"
+    out << "--------------------+------------+---------------+------------+-----------+------------" << "\n"
     sort_array.each do |arr|
-      chance = arr[0].to_f * 100.0 / self.bracket.number_of_outcomes
-      puts "%19s | %10.2f | %13d | %9d | %7d " %
-        [@entries[arr[1]].name, chance, min_ranking[arr[1]], max_possible_score[arr[1]], @entries[arr[1]].tie_breaker]
+      chance = arr[0].to_f * 100.0 / self.tournament_entry.picks.number_of_outcomes
+      out << "%19s | %10.2f | %13d | %10d | %9d | %7d " %
+        [@entries[arr[1]].name, chance, min_ranking[arr[1]], @entries[arr[1]].picks.score_against(self.tournament_entry.picks, self.scoring_strategy), max_possible_score[arr[1]], @entries[arr[1]].tie_breaker] << "\n"
     end
-    puts "Possible Champions For Win"
-    puts "    Entry           |    Champion     |  Ocurrences   |  Chance "
-    puts "--------------------+-----------------+---------------+---------"
+    out << "Possible Champions For Win" << "\n"
+    out << "    Entry           |    Champion     |  Ocurrences   |  Chance " << "\n"
+    out << "--------------------+-----------------+---------------+---------" << "\n"
     sort_array.each do |arr|
       next if arr[4].size == 0
       arr[4].sort_by{|k,v| -v}.each_with_index do |harr, idx| 
         team = harr[0]
         occurences = harr[1]
         if idx == 0
-          puts "%19s | %15s | %13d | %8.2f " % [@entries[arr[1]].name, team.name, occurences, occurences.to_f * 100.0 / arr[0]]
+          out << "%19s | %15s | %13d | %8.2f " % [@entries[arr[1]].name, team.name, occurences, occurences.to_f * 100.0 / arr[0]] << "\n"
         else
-          puts "%19s | %15s | %13d | %8.2f " % ['', team.name, occurences, occurences.to_f * 100.0 / arr[0]]
+          out << "%19s | %15s | %13d | %8.2f " % ['', team.name, occurences, occurences.to_f * 100.0 / arr[0]] << "\n"
         end
       end
-      puts "--------------------+-----------------+---------------+---------"
+      out << "--------------------+-----------------+---------------+---------" << "\n"
     end
     nil
   end

data/lib/tournament/scoring_strategy.rb

@@ -0,0 +1,69 @@
+# Module namespace for various scoring strategies for 
+# tournament pools.
+module Tournament::ScoringStrategy
+
+  # Class representing a scoring strategy where correct picks
+  # are worth 2 X the round number
+  class Basic
+    def score(pick, winner, loser, round)
+      winner != Tournament::Bracket::UNKNOWN_TEAM && pick == winner ? round * 2 : 0
+    end
+    def name
+      'Basic'
+    end
+    def description
+      "Each game is worth 2 times the round number."
+    end
+  end
+
+  # Class representing a scoring strategy where correct picks
+  # are worth a base amount per round (3, 5, 11, 19, 30 and 40)
+  # plus the seed number of the winner.
+  class Upset
+    PER_ROUND = [3, 5, 11, 19, 30, 40]
+    def score(pick, winner, loser, round)
+      if winner != Tournament::Bracket::UNKNOWN_TEAM && pick == winner
+        return PER_ROUND[round-1] + winner.seed
+      end
+      return 0
+    end
+    def name
+      'Upset'
+    end
+    def description
+      "Games are worth #{PER_ROUND.join(', ')} per round plus the seed number of the winning team."
+    end
+  end
+
+  # Class representing a scoring strategy where correct picks are
+  # worth the seed number of the winner times a per round 
+  # multiplier (1,2,4,8,16,32)
+  class JoshPatashnik
+    MULTIPLIERS = [1, 2, 4, 8, 16, 32]
+    def score(pick, winner, loser, round)
+       if winner != Tournament::Bracket::UNKNOWN_TEAM && pick == winner
+          return MULTIPLIERS[round-1] * winner.seed
+       end
+       return 0
+    end
+    def name
+      'Josh Patashnik'
+    end
+    def description
+      "Games are worth the seed number of the winning team times a per round multiplier: #{MULTIPLIERS.join(', ')}"
+    end
+  end
+
+  # Returns names of available strategies.  The names returned are suitable
+  # for use in the strategy_for_name method
+  def self.available_strategies
+    return ['basic', 'upset', 'josh_patashnik']
+  end
+
+  # Returns an instantiated strategy class for the named strategy.
+  def self.strategy_for_name(name)
+    clazz = Tournament::ScoringStrategy.const_get(name.capitalize.gsub(/_([a-zA-Z])/) {|m| $1.upcase})
+    return clazz.new
+  end
+
+end

data/lib/tournament/webgui_installer.rb

@@ -0,0 +1,109 @@
+require 'open3'
+require 'fileutils'
+require 'net/http'
+require 'uri'
+
+class Tournament::WebguiInstaller
+  attr_accessor :tmp_dir
+  attr_reader :install_dir
+  attr_reader :source_dir
+  PRINCE_TARBALL='http://www.princexml.com/download/prince-6.0r8-linux.tar.gz'
+  RAILS_ENV = ENV['RAILS_ENV'] || 'production'
+
+  def initialize(install_dir)
+    @install_dir = install_dir
+    @source_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'webgui'))
+  end
+
+  def self.download(url, local_file, binary = false)
+    url = URI.parse(url)
+    open_flag = binary ? "wb" : "w"
+    Net::HTTP.start(url.host) do |http|
+      File.open(local_file, open_flag) do |file|
+        resp = http.get(url.path)
+        file.write(resp.body)
+      end
+    end
+  end
+
+  def install_webgui
+    raise "Installation target #{@install_dir} exists and is NOT a directory." if File.exist?(@install_dir) && !File.directory?(@install_dir)
+    FileUtils.mkdir_p(@install_dir) unless File.exist?(@install_dir)
+    FileUtils.cp_r("#{@source_dir}/.", @install_dir, :preserve => false, :verbose => true)
+  end
+
+  def adjust_configuration(config_options = {})
+    config_file = File.expand_path(File.join(@source_dir, 'config', 'initializers', 'pool.rb'))
+    target_config = File.expand_path(File.join(@install_dir, 'config', 'initializers', 'pool.rb'))
+    puts "  -> Adjusting #{config_file} -> #{target_config}"
+    config_contents = File.read(config_file)
+    if config_options['email-server']
+      smtp_config = {}
+      smtp_config[:address] = config_options['email-server']
+      smtp_config[:port] = config_options['email-port']
+      smtp_config[:domain] = config_options['email-domain'] if config_options['email-domain']
+      smtp_config[:user_name] = config_options['email-user'] if config_options['email-user']
+      smtp_config[:password] = config_options['email-password'] if config_options['email-password']
+      smtp_config[:authentication] = config_options['email-auth'].to_sym if config_options['email-auth']
+      config_options['smtp-configuration'] = smtp_config
+    end
+    [
+      ['site-name', 'TOURNAMENT_TITLE'],
+      ['admin-email', 'ADMIN_EMAIL'],
+      ['relative-root', 'RELATIVE_URL_ROOT'],
+      ['smtp-configuration', 'SMTP_CONFIGURATION'],
+      ['prince-path', 'PRINCE_PATH']
+    ].each do |config_name, constant_name|
+      if config_options[config_name]
+        puts "  -> Setting config option #{config_name} to #{config_options[config_name]}"
+        re = /#{constant_name} =([^\n]+)/m
+        config_contents.gsub!(re) do |m|
+          "#{constant_name} = #{config_options[config_name].inspect}\n"
+        end
+      else
+        puts "  -> Not setting config option #{config_name}"
+      end
+    end
+
+    puts "  -> Writing #{target_config}"
+    File.open(target_config, "w") do |f|
+      f.write config_contents
+    end
+  end
+
+  def install_prince(prince_install_dir)
+    # install prince-xml if necessary
+    has_prince = ''
+    Open3.popen3('which prince') do |stdin, stdout, stderr|
+      has_prince << stdout.read
+      has_prince << stderr.read
+    end
+    if has_prince.empty? || has_prince =~ /no prince/
+      puts "Installing prince-xml ..."
+      Tournament::WebguiInstaller.download(PRINCE_TARBALL, "#{@tmp_dir}/prince.tgz", true)
+      system "tar xzf #{@tmp_dir}/prince.tgz -C #{@tmp_dir}"
+
+      use_sudo = nil
+      if !File.exist?(prince_install_dir)
+        begin
+          FileUtils.makedirs(prince_install_dir)
+        rescue
+          puts "Could not create install dir for prince, using sudo"
+          use_sudo = "sudo "
+        end
+      elsif !File.writable?(prince_install_dir)
+        puts "Prince install directory is not writable, using sudo. You may be asked for your password."
+        use_sudo = "sudo "
+      end
+      puts "cd #{@tmp_dir}/prince-6.0r8-linux && #{use_sudo}bash install.sh"
+      system "cd #{@tmp_dir}/prince-6.0r8-linux && #{use_sudo}bash install.sh"
+    else
+      puts "prince-xml already installed: #{has_prince}"
+    end
+  end
+end
+
+# Run migrations
+# Provide instructions for modrails/phusion integration
+# Create admin user
+# Edit config/initializer/pool.rb to fit