tournament 1.0.0 → 1.1.0

data/History.txt

@@ -1,3 +1,12 @@
+== 1.1.0 / 2008-03-29
+
+* Add ability to configure entry fee and payout amounts
+* Change final four report to use the entry fee and payout amount configuration
+* Fix bug with cached @number_of_outcomes in Tournament::Pool class.
+* Add to the possibility report a listing of each entry that could place first
+  that shows frequency of which team would have to be champion for 
+  the entry to place first.
+
 == 1.0.0 / 2008-03-26
 
 * Change the pool command line script usage to make it simpler (I hope)

data/README.txt

@@ -61,40 +61,57 @@ The pool manager would use this program as follows:
    As mentioned above, unless overridden by using the --save-file
    option, the pool will save itself to the file 'pool.yml'
 
-3. Export a tournament entry YAML file
+4. Set the entry fee and payout amounts
+   
+       pool fee 10
+       pool payout 1 80
+       pool payout 2 20
+       pool payout last 10 -C
+
+   The above commands say that each entry fee is 10 units (this is all
+   for fun, not profit, right?) and that the 1st place finisher would
+   receive 80% of the total payout, the 2nd place finisher would 
+   receive 20% of the total payout and the last place finisher would
+   receive 10 units back (would get her entry fee back).  No error
+   checking is done with this.  FIXME: Add error checking.
+
+5. Export a tournament entry YAML file
 
        pool dump
 
    This will save the tournament entry file as tournament.yml unless
    the --entry option is used to override it.
 
-4. Create entries.  You can use the included buggy GUI (see below),
+6. Create entries.  You can use the included buggy GUI (see below),
    or edit YAML files by hand.
 
-5. Import the entry YAML files into the pool
+7. Import the entry YAML files into the pool
 
        pool entry --add=path/to/entry.yml
 
-6. As games progress, update the tournament.yml file, again using the GUI or
+8. As games progress, update the tournament.yml file, again using the GUI or
    editing the YAML file by hand.  Then update the pool with the new
    pool YAML file
 
        pool update
 
-7. Run reports
+9. Run reports
   
        pool report [final_four|entry|region|leader|score]
 
-8. After about 22 teams are left, run a possibility report.  This report will
-   run through all the remaining ways the tournament can come out and
-   calculate the chance to win for each player.  The chance to win
-   is defined as the percentage of possibilities that lead to that player
-   coming out on top in the pool.  With more than about 22 teams left
-   (YMMV), this report could take months to run. FIXME (Investigate
-   possibly using EC2 or something to spread the load around, or 
-   otherwise optimize the possibility checking algorithm)
+   The final four report can only be run once the final four teams have
+   been determined.
 
-       pool report possibility
+10. After about 22 teams are left, run a possibility report.  This report will
+    run through all the remaining ways the tournament can come out and
+    calculate the chance to win for each player.  The chance to win
+    is defined as the percentage of possibilities that lead to that player
+    coming out on top in the pool.  With more than about 22 teams left
+    (YMMV), this report could take months to run. FIXME (Investigate
+    possibly using EC2 or something to spread the load around, or 
+    otherwise optimize the possibility checking algorithm)
+
+        pool report possibility
 
 == SHOES GUI:
 
@@ -110,6 +127,9 @@ The GUI also may be used for keeping the NCAA tournament entry YAML file
 up to date:
 
    picker tournament.yml
+
+The GUI works as long as you don't try to go back and change games
+from played to unknown outcome.
  
 == REQUIREMENTS:
 

data/Rakefile

@@ -16,7 +16,7 @@ PROJ.authors = 'Douglas A. Seifert'
 PROJ.email = 'doug+rubyforge@dseifert.net'
 PROJ.url = 'http://www.dseifert.net/code/tournament'
 PROJ.rubyforge_name = 'tournament'
-PROJ.version = '1.0.0'
+PROJ.version = '1.1.0'
 PROJ.group_id = 5863
 
 PROJ.spec_opts << '--color'

data/bin/pool

@@ -74,6 +74,53 @@ Main do
     end
   end
 
+  mode('fee') do
+    argument('amount') do
+      required
+      cast :integer
+      arity 1
+      description "The fee charged per entry."
+    end
+    def run
+      load_pool
+      @pool.entry_fee = params['amount'].value
+      save_pool
+    end
+  end
+
+  mode('payout') do
+    option('constant-amount', 'C') do
+      optional
+      arity 1
+      cast :boolean
+      description "Specify if the payout is a constant amount rather than a percentage."
+    end
+    argument('rank') do
+      required
+      arity 1
+      description "The rank associated with the payout, such as 1, 2, 3 or last"
+    end
+    argument('amount') do
+      required
+      cast :integer
+      arity 1
+      description "The amount of the payout, either a percentage or constant amount.  If a constant amount, the --constant-amount option must be specified."
+    end
+    def run
+      load_pool
+      rank = params['rank'].value
+      if 'last' == rank
+        rank = :last
+      else
+        rank = rank.to_i
+      end
+      amount = params['amount'].value
+      amount = -amount if params['constant-amount'].value
+      @pool.set_payout(rank, amount)
+      save_pool
+    end
+  end
+
   mode('entry') do
     option('add', 'a') do
       optional

data/lib/tournament/bracket.rb

@@ -257,6 +257,7 @@ class Tournament::Bracket
   def set_winner(round, game, team)
     if UNKNOWN_TEAM == team || matchup(round, game).include?(team)
       @winners[round][game-1] = team
+      @number_of_outcomes = nil
     else
       raise "Round #{round}, Game #{game} matchup does not include team #{team.inspect}"
     end

data/lib/tournament/pool.rb

@@ -5,11 +5,14 @@
 class Tournament::Pool
   attr_reader :regions  # The regions in the 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
 
   # Create a new empty pool with no Regions or Entries
   def initialize
     @regions = Array.new(4)
     @entries = []
+    @payouts = {}
   end
 
   # add regions to the pool.  Champ of region with index = 0 plays
@@ -40,6 +43,19 @@ class Tournament::Pool
     end
   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 
+  # percentage of the the total entry fees that particular
+  # rank would receive.  The payout may also be a negative
+  # integer, in which case, it represents a constant
+  # payout amount.
+  def set_payout(rank, payout)
+    # FIXME: Add error checking
+    @payouts ||= {}
+    @payouts[rank] = payout
+  end
+
   # Creates a bracket for the pool by combining all the
   # regions into one bracket of 64 teams.  By default the
   # bracket uses the basic scoring strategy.
@@ -152,9 +168,15 @@ class Tournament::Pool
     )
     return pool
   end
-  
-  def self.test(num_picks = 10)
+ 
+  # Run a test pool with random entries and a random outcome.
+  def self.test(num_picks = 20)
     pool = ncaa_2008
+    pool.entry_fee = 10
+    pool.set_payout(1, 70)
+    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
     picks = (1..num_picks).map {|n| Tournament::Bracket.random_bracket(b.teams)}
@@ -163,17 +185,22 @@ class Tournament::Pool
     16.times { |n| b.set_winner(2,n+1, b.matchup(2, n+1)[rand(2)])}
     8.times { |n| b.set_winner(3,n+1, b.matchup(3, n+1)[rand(2)])}
     4.times { |n| b.set_winner(4,n+1, b.matchup(4, n+1)[rand(2)])}
-    2.times { |n| b.set_winner(5,n+1, b.matchup(5, n+1)[rand(2)])}
-    1.times { |n| b.set_winner(6,n+1, b.matchup(6, n+1)[rand(2)])}
+    #2.times { |n| b.set_winner(5,n+1, b.matchup(5, n+1)[rand(2)])}
+    #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)}"
     end
-    #pool.possibility_report
+    pool.region_report
     pool.leader_report
+    pool.final_four_report
+    pool.possibility_report
     pool.entry_report
+    pool.score_report
   end
 
+  # 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}"
@@ -198,6 +225,9 @@ class Tournament::Pool
     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
     # Compute scores
     puts "Total games played: #{@bracket.games_played}"
@@ -234,6 +264,7 @@ class Tournament::Pool
     end
   end
 
+  # Splits str on space chars in chunks of around len size
   def self.split_line(str, len)
     new_str = []
     beg_idx = 0
@@ -248,6 +279,7 @@ class Tournament::Pool
     return new_str.reject {|s| s.nil? || s.length == 0}  
   end
 
+  # Shows a report of each entry's picks by round.
   def entry_report
     puts "There are #{@entries.size} entries."
     if @entries.size > 0
@@ -281,6 +313,7 @@ class Tournament::Pool
     end
   end
 
+  # Displays the regions and teams in the region.
   def region_report
     puts " Region | Seed | Team               "
     current_idx = -1
@@ -297,6 +330,8 @@ class Tournament::Pool
     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
     if @entries.size == 0
       puts "There are no entries in the pool."
@@ -307,26 +342,114 @@ class Tournament::Pool
       puts "are exactly four teams left in the tournament."
       return
     end
+    total_payout = @entries.size * @entry_fee
+    # Subtract out constant payments
+    total_payout = @payouts.values.inject(total_payout) {|t, amount| t += amount if amount < 0; t}
+
+    payout_keys = @payouts.keys.sort do |a,b|
+      if Symbol === a
+        1
+      elsif Symbol === b
+        -1
+      else
+        a <=> b
+      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. ")}"
-    sep= "--------------+----------------+----------------------------"
-    puts " Championship |    Champion    |  Winners"
+    puts "Payouts"
+    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]
+    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] }
-      first = rankings[0][0]
-      second = rankings[1][0]
-      last = rankings[-1][0]
-      puts "%14s|%16s|%s" % [poss.winners[5].map{|t| t.short_name}.join("-"),
-        poss.champion.name, "   1: #{first.name} (#{rankings[0][1]})"]
-      puts "%14s|%16s|%s" % ['', '',
-        "   2: #{second.name} (#{rankings[1][1]})"]
-      puts "%14s|%16s|%s" % ['', '',
-        "LAST: #{last.name} (#{rankings[-1][1]})"]
+      finishers = {}
+      @payouts.each do |rank, payout|
+        finishers[rank] = {}
+        finishers[rank][:payout] = payout
+        finishers[rank][:entries] = []
+        finishers[rank][:score] = 0
+      end
+      #puts "Got finishers: #{finishers.inspect}"
+      index = 0
+      rank = 1
+      while index < @entries.size
+        rank_score = rankings[index][1]
+        finishers_key = index < (@entries.size - 1) ? rank : :last
+        finish_hash = finishers[finishers_key]
+        #puts "For rank_score = #{rank_score} finishers key = #{finishers_key.inspect}, hash = #{finish_hash}, index = #{index}"
+        if finish_hash
+          while index < @entries.size && rankings[index][1] == rank_score
+            finish_hash[:entries] << rankings[index][0]
+            finish_hash[:score] = rank_score
+            index += 1
+          end
+          rank += 1
+          next
+        end
+        index += 1
+        rank += 1
+      end
+
+      num_payouts = payout_keys.size
+
+      first_line = true
+      showed_last = false
+      payout_count = 0
+      while payout_count < num_payouts
+        rank = payout_keys[payout_count]
+        finish_hash = finishers[rank]
+        label = finish_hash[:entries].size == 1 ? "#{rank}".upcase : "TIE"
+        finish_hash[:entries].each do |winner| 
+          line = if first_line
+            "%14s|%16s| %4s %5d %5d %s" % [
+              poss.winners[5].map{|t| t.short_name}.join("-"),
+              poss.champion.name,
+              label,
+              finish_hash[:score],
+              winner.tie_breaker,
+              winner.name
+            ]
+          else
+            "%14s|%16s| %4s %5d %5d %s" % [
+              '',
+              '',
+              label,
+              finish_hash[:score],
+              winner.tie_breaker,
+              winner.name
+            ]
+          end
+          puts line
+          first_line = false
+        end
+        payout_count += finish_hash[:entries].size
+        showed_last = (rank == :last)
+        if payout_count >= num_payouts && !showed_last
+          if payout_keys[num_payouts-1] == :last
+            payout_count -= 1
+            showed_last = true
+          end
+        end
+      end
       puts sep
     end
+    nil
   end
 
+  # 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
     $stdout.sync = true
     if @entries.size == 0
@@ -336,6 +459,7 @@ class Tournament::Pool
     max_possible_score = @entries.map{|p| 0}
     min_ranking = @entries.map{|p| @entries.size + 1}
     times_winner = @entries.map{|p| 0 }
+    player_champions = @entries.map{|p| Hash.new {|h,k| h[k] = 0} }
     count = 0
     old_percentage = -1 
     old_remaining = 1_000_000_000_000
@@ -350,6 +474,9 @@ class Tournament::Pool
         rank = sort_scores.index(score) + 1
         min_ranking[i] = rank if rank < min_ranking[i]
         times_winner[i] += 1 if rank == 1
+        if rank == 1
+          player_champions[i][poss.champion] += 1
+        end
       end
       count += 1
       percentage = (count * 100.0 / self.bracket.number_of_outcomes)
@@ -368,16 +495,33 @@ class Tournament::Pool
     #puts "Highest Place: #{min_ranking.inspect}"
     #puts " Times Winner: #{times_winner.inspect}"
     sort_array = []
-    times_winner.each_with_index { |n, i| sort_array << [n, i, min_ranking[i], max_possible_score[i]] }
+    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 "--------------------+------------+---------------+-----------+------------"
     sort_array.each do |arr|
       chance = arr[0].to_f * 100.0 / self.bracket.number_of_outcomes
-      puts "%19s | %10.2f | %13d | %9d | %d" %
+      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]
     end
+    puts "Possible Champions For Win"
+    puts "    Entry           |    Champion     |  Ocurrences   |  Chance "
+    puts "--------------------+-----------------+---------------+---------"
+    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]]
+        else
+          puts "%19s | %15s | %13d | %8.2f " % ['', team.name, occurences, occurences.to_f * 100.0 / arr[0]]
+        end
+      end
+      puts "--------------------+-----------------+---------------+---------"
+    end
+    nil
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tournament
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Douglas A. Seifert
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-03-26 00:00:00 -07:00
+date: 2008-03-30 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency