rrschedule 0.2.9 → 0.2.10

data/VERSION

@@ -1 +1 @@
-0.2.9
+0.2.10

data/lib/rrschedule.rb

@@ -8,7 +8,7 @@ module RRSchedule
 
     def initialize(params={})
       @gamedays = []
-      self.teams = params[:teams] if params[:teams]
+      self.teams = params[:teams] || []
       self.cycles = params[:cycles] || 1
       self.shuffle = params[:shuffle].nil? ? true : params[:shuffle]
       self.exclude_dates = params[:exclude_dates] || []
@@ -21,33 +21,14 @@ module RRSchedule
     def generate(params={})
       raise "You need to specify at least 1 team" if @teams.nil? || @teams.empty?
       raise "You need to specify at least 1 rule" if @rules.nil? || @rules.empty?
+
       arrange_flights
+      init_stats
 
+      @gamedays = []; @rounds = []
 
-      @stats = {}
-      @teams.flatten.each do |t|
-        @stats[t] = {
-          :gt => {},
-          :ps => {}
-        }
-
-        @stats[t][:gt] = {}
-        all_gt.each do |gt|
-          @stats[t][:gt][gt] = 0
-        end
-
-        @stats[t][:ps] = {}
-        all_ps.each do |ps|
-          @stats[t][:ps][ps] = 0
-        end
-      end
-
-      @gamedays = []
-      @rounds = []
 
       @flights.each_with_index do |teams,flight_id|
-
-
         current_cycle = current_round = 0
         teams = teams.sort_by{rand} if @shuffle
 
@@ -62,14 +43,11 @@ module RRSchedule
             team_b = t.reverse!.shift
             t.reverse!
 
+            x = [team_a,team_b].shuffle
 
-            x = [team_a,team_b] #.shuffle
-
-            matchup = {:team_a => x[0], :team_b => x[1], :home_team_index => self.teams.index(x[0])}
+            matchup = {:team_a => x[0], :team_b => x[1]}
             games << matchup
           end
-          #games = games.sort_by {|g| g[:home_team_index]}
-
           #done processing round
 
           current_round += 1
@@ -95,11 +73,7 @@ module RRSchedule
           #have we completed a full round-robin for the current flight?
           if current_round == teams.size-1
             current_cycle += 1
-
-            if current_cycle < self.cycles
-              current_round = 0
-              teams = teams.sort_by{rand} if @shuffle
-            end
+            current_round = 0 if current_cycle < self.cycles
           end
 
         end until current_round == teams.size-1 && current_cycle==self.cycles
@@ -192,36 +166,6 @@ module RRSchedule
       end
     end
 
-    def get_best_gt(game)
-      x = {}
-      gt_left = @gt_ps_avail.reject{|k,v| v.empty?}
-      gt_left.each_key do |gt|
-        x[gt] = [
-          @stats[game.team_a][:gt][gt] + @stats[game.team_b][:gt][gt],
-          rand(1000)
-        ]
-      end
-      x.sort_by{|k,v| [v[0],v[1]]}.first[0]
-    end
-
-    def get_best_ps(game,gt)
-      x = {}
-      @gt_ps_avail[gt].each do |ps|
-        x[ps] = [
-          @stats[game.team_a][:ps][ps] + @stats[game.team_b][:ps][ps],
-          rand(1000)
-        ]
-      end
-      x.sort_by{|k,v| [v[0],v[1]]}.first[0]
-    end
-
-    def reset_resource_availability
-      @gt_ps_avail = {}
-      @cur_rule.gt.each do |gt|
-        @gt_ps_avail[gt] = @cur_rule.ps.clone
-      end
-    end
-
     def dispatch_game(game)
       if @cur_rule.nil?
         @cur_rule = @rules.select{|r| r.wday >= self.start_date.wday}.first || @rules.first
@@ -232,12 +176,6 @@ module RRSchedule
       @cur_gt = get_best_gt(game)
       @cur_ps = get_best_ps(game,@cur_gt)
 
-      #increment the stats counters to lessen the chances that these teams plays on the same playing surface (or game time) too often
-      @stats[game.team_a][:gt][@cur_gt] += 1
-      @stats[game.team_a][:ps][@cur_ps] += 1
-      @stats[game.team_b][:gt][@cur_gt] += 1
-      @stats[game.team_b][:ps][@cur_ps] += 1
-
       @cur_date ||= next_game_date(self.start_date,@cur_rule.wday)
       @schedule ||= []
 
@@ -254,12 +192,14 @@ module RRSchedule
         end
       end
 
+      #We found our playing surface and game time, add the game in the schedule.
       @schedule << {:team_a => game.team_a, :team_b => game.team_b, :gamedate => @cur_date, :ps => @cur_ps, :gt => @cur_gt}
-      @gt_ps_avail[@cur_gt].delete(@cur_ps) #this playing surface has now been taken and is not available
+      update_team_stats(game,@cur_gt,@cur_ps)
+      update_resource_availability(@cur_gt,@cur_ps)
 
-      x = @gt_ps_avail.reject{|k,v| v.empty?}
 
-      #no resources left, change rule
+      #If no resources left, change rule
+      x = @gt_ps_avail.reject{|k,v| v.empty?}
       if x.empty?
         if @cur_rule_index < @rules.size-1
           last_rule=@cur_rule
@@ -282,6 +222,48 @@ module RRSchedule
       dt
     end
 
+    def update_team_stats(game,cur_gt,cur_ps)
+      @stats[game.team_a][:gt][cur_gt] += 1
+      @stats[game.team_a][:ps][cur_ps] += 1
+      @stats[game.team_b][:gt][cur_gt] += 1
+      @stats[game.team_b][:ps][cur_ps] += 1
+    end
+
+    def get_best_gt(game)
+      x = {}
+      gt_left = @gt_ps_avail.reject{|k,v| v.empty?}
+      gt_left.each_key do |gt|
+        x[gt] = [
+          @stats[game.team_a][:gt][gt] + @stats[game.team_b][:gt][gt],
+          rand(1000)
+        ]
+      end
+      x.sort_by{|k,v| [v[0],v[1]]}.first[0]
+    end
+
+    def get_best_ps(game,gt)
+      x = {}
+      @gt_ps_avail[gt].each do |ps|
+        x[ps] = [
+          @stats[game.team_a][:ps][ps] + @stats[game.team_b][:ps][ps],
+          rand(1000)
+        ]
+      end
+      x.sort_by{|k,v| [v[0],v[1]]}.first[0]
+    end
+
+    def reset_resource_availability
+      @gt_ps_avail = {}
+      @cur_rule.gt.each do |gt|
+        @gt_ps_avail[gt] = @cur_rule.ps.clone
+      end
+    end
+
+    def update_resource_availability(cur_gt,cur_ps)
+      @gt_ps_avail[cur_gt].delete(cur_ps)
+    end
+
+
     #return matchups between two teams
     def face_to_face(team_a,team_b)
       res=[]
@@ -291,21 +273,20 @@ module RRSchedule
       res.flatten
     end
 
-    def all_gt
-      gt = []
-      @rules.each do |r|
-        gt = gt.concat(r.gt)
+    #Count the number of times each team plays on a given playing surface and at what time. That way
+    #we can balance the available playing surfaces/game times among competitors.
+    def init_stats
+      @stats = {}
+      @teams.flatten.each do |t|
+        @stats[t] = {:gt => {}, :ps => {}}
+        all_gt.each { |gt| @stats[t][:gt][gt] = 0 }
+        all_ps.each { |ps| @stats[t][:ps][ps] = 0 }
       end
-      gt.flatten.uniq
     end
 
-    def all_ps
-      ps = []
-      @rules.each do |r|
-        ps = ps.concat(r.ps)
-      end
-      ps.flatten.uniq
-    end
+    #returns an array of all available game times / playing surfaces, all rules included.
+    def all_gt; @rules.collect{|r| r.gt}.flatten.uniq; end
+    def all_ps; @rules.collect{|r| r.ps}.flatten.uniq; end
   end
 
   class Gameday
@@ -315,13 +296,11 @@ module RRSchedule
       self.date = params[:date]
       self.games = params[:games] || []
     end
-
   end
 
   class Rule
     attr_accessor :wday, :gt, :ps
 
-
     def initialize(params)
       self.wday = params[:wday]
       self.gt = params[:gt]

data/test_schedule.rb

@@ -14,3 +14,22 @@ schedule=RRSchedule::Schedule.new(
               :shuffle => true,
               :start_date => Date.parse("2010/10/13")
             ).generate
+
+
+require 'rubygems'
+require 'active_support/all'
+require './lib/rrschedule.rb'
+include RRSchedule
+schedule=RRSchedule::Schedule.new(
+              :teams => %w(T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13),
+              :rules => [
+                RRSchedule::Rule.new(
+                  :wday => 3,
+                  :gt => ["7:00 PM"],
+                  :ps => ["1","2","3","4"],
+                )
+              ],
+              :cycles => 3,
+              :shuffle => true,
+              :start_date => Date.parse("2010/10/13")
+            ).generate

metadata

@@ -2,7 +2,7 @@
 name: rrschedule
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.9
+  version: 0.2.10
 platform: ruby
 authors: 
 - flamontagne
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-27 00:00:00 Z
+date: 2011-09-29 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: thoughtbot-shoulda
@@ -66,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Round-Robin schedule generator