X-Git-Url: https://git.sesse.net/?p=ccbs;a=blobdiff_plain;f=bigscreen%2Fgroupscreen.cpp;h=7e45628851225e48da81b472d789fb6d098ecfe9;hp=5f16ebf22fe98be6766e3a2fc772af2c0cca28da;hb=bc35fe826101ca7eb29a6fa2e06eba2cd6c99222;hpb=c6fba5909e3fcfd741e337b76c5d4228e81444e4

diff --git a/bigscreen/groupscreen.cpp b/bigscreen/groupscreen.cpp
index 5f16ebf..7e45628 100644
--- a/bigscreen/groupscreen.cpp
+++ b/bigscreen/groupscreen.cpp
@@ -1,7 +1,11 @@
+#include <cstdio>
 #include <algorithm>
 
 #include "groupscreen.h"
 #include "fetch_group.h"
+#include "fetch_max_score_for_song.h"
+#include "fetch_max_score_for_player.h"
+#include "fetch_needs_update.h"
 #include "fonts.h"
 
 GroupScreen::GroupScreen(pqxx::connection &conn, unsigned tournament, unsigned round, unsigned parallel)
@@ -15,8 +19,18 @@ GroupScreen::~GroupScreen()
 
 bool GroupScreen::check_invalidated()
 {
-	// we might want to do this slightly more sophisticated later, but for now this will do
-	return !valid || scores_changed.get_flag();
+	if (!valid)
+		return true;
+	if (!scores_changed.get_flag())
+		return false;
+
+	bool needs_update;
+	conn.perform(FetchNeedsUpdate(last_updated, tournament, round, parallel, &needs_update));
+
+	if (!needs_update)
+		scores_changed.reset_flag();
+	
+	return needs_update;
 }
 
 void GroupScreen::draw(unsigned char *buf)
@@ -25,6 +39,7 @@ void GroupScreen::draw(unsigned char *buf)
 
 	Group group;
 	conn.perform(FetchGroup(tournament, round, parallel, &group));
+	gettimeofday(&last_updated, NULL);
 
 	memset(buf, 0, 800 * 600 * 4);
 
@@ -106,26 +121,106 @@ void GroupScreen::draw(unsigned char *buf)
 
 		unsigned col = 1;
 		for (std::vector<Score>::const_iterator j = i->scores.begin(); j != i->scores.end(); ++j, ++col) {
-			char text[16];
-			sprintf(text, "%u", j->score);
+			char text[16] = "";
+			if (j->score != -1) {
+				sprintf(text, "%u", j->score);
+			}
 	
 			unsigned this_width = my_draw_text(text, NULL, 22.0);
 			if (j->chosen) {
-				if (j->score != -1) {
-					my_draw_text(text, buf, 22.0, x + max_num_width - this_width, y);
-				}
+				my_draw_text(text, buf, 22.0, x + max_num_width - this_width, y);
 				my_draw_text((mode == 0) ? j->song.title : j->song.short_title, buf, 12.0, x + max_num_width + 10, y);
 			} else {
-				if (j->score != -1) {
-					my_draw_text(text, buf, 22.0, x + width[col] / 2 - this_width / 2, y);
-				}
+				my_draw_text(text, buf, 22.0, x + width[col] / 2 - this_width / 2, y);
 			}
 			x += width[col] + 20;
 		}
 
+		// draw total
+		{
+			char text[16];
+			sprintf(text, "%u", i->total);
+			
+			unsigned this_width = my_draw_text(text, NULL, 22.0);
+			my_draw_text(text, buf, 22.0, x + width[num_scores + 1] / 2 - this_width / 2, y);
+			x += width[num_scores + 1] + 20;
+		}
+
 		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;
 }