Add (a rather sizable chunk of) code for determining the possible best and worst...

[ccbs] / bigscreen / groupscreen.cpp

diff --git a/bigscreen/groupscreen.cpp b/bigscreen/groupscreen.cpp
index 26d769af52884bdfedfd253f52d034f17e755227..d8450f8679d370a8e16b97170433e5e75ae6855b 100644 (file)
--- a/bigscreen/groupscreen.cpp
+++ b/bigscreen/groupscreen.cpp
@@ -2,6 +2,8 @@
 
 #include "groupscreen.h"
 #include "fetch_group.h"
+#include "fetch_max_score_for_song.h"
+#include "fetch_max_score_for_player.h"
 #include "fonts.h"
 
 GroupScreen::GroupScreen(pqxx::connection &conn, unsigned tournament, unsigned round, unsigned parallel)
@@ -136,6 +138,78 @@ void GroupScreen::draw(unsigned char *buf)
                y += 40;
        }
        
+       /*
+        * Approximate (but probably working quite well in practice) heuristic
+        * for finding the min and max rank of a player works as follows:
+        *
+        * First of all, find out, for each player in the group, what the
+        * maximum remaining score possibly can be (the minimum score is of
+        * course identical to the player's current total). For a random song,
+        * this is of course 1000 * (maximum feet rating) (but of course, that
+        * depends on whether we can play single or double! for now, assume
+        * double is okay, but this logic will be deferred to FetchMaxScore
+        * anyhow); for a random song, we simply pick the highest-ranking song
+        * we can find, EXCEPT those the player has chosen earlier AND the
+        * random songs this round, AND all random songs from elimination rounds
+        * (ie. rounds with only one group). (Phew!) This doesn't solve problems
+        * we'd face with more than one chosen song, but it should be good enough.
+        *
+        * After we've found the max and min scores for all players, it's a simple
+        * matter of sorting; the best attainable rank for player X is obtained if 
+        * X gets max score and all others get min score, the worst attainable rank
+        * is obtained if X gets min score and all others get max score.
+        *
+        * This is a bit SQL-heavy, but heck...
+        */
+       std::vector<unsigned> max_score, min_score;
+       for (std::vector<Player>::const_iterator i = group.players.begin(); i != group.players.end(); ++i) {
+               unsigned min_score_tp = 0, max_score_tp = 0;
+               for (std::vector<Score>::const_iterator j = i->scores.begin(); j != i->scores.end(); ++j, ++col) {
+                       if (j->score != -1) {
+                               // already given
+                               min_score_tp += j->score;
+                               max_score_tp += j->score;
+                       } else {
+                               unsigned max_score_this_song;
+                               if (j->song.id != -1) {
+                                       // random song, or we know what song the player picked
+                                       conn.perform(FetchMaxScoreForSong(tournament, j->song.id, &max_score_this_song));
+                               } else {
+                                       conn.perform(FetchMaxScoreForPlayer(tournament, i->id, round, &max_score_this_song));
+                               }
+                               max_score_tp += max_score_this_song;
+                       }
+               }
+               max_score.push_back(max_score_tp);
+               min_score.push_back(min_score_tp);
+       }
+
+       // now finally find min and max rank, and draw it all
+       y = 140;
+       for (unsigned i = 0; i < group.players.size(); ++i) {
+               unsigned best_rank = 1, worst_rank = 1;
+               for (unsigned j = 0; j < group.players.size(); ++j) {
+                       if (i == j)
+                               continue;
+
+                       if (max_score[i] < min_score[j])
+                               ++best_rank;
+                       if (min_score[i] <= max_score[j])
+                               ++worst_rank;
+               }
+
+               char text[16];
+               if (best_rank == worst_rank)
+                       std::sprintf(text, "%u", best_rank);
+               else
+                       std::sprintf(text, "%u-%u", best_rank, worst_rank);
+               
+               unsigned this_width = my_draw_text(text, NULL, 22.0);
+               my_draw_text(text, buf, 22.0, x + width[num_scores + 2] / 2 - this_width / 2, y);
+
+               y += 40;
+       }
+               
        valid = true;
 }