+ colwidth[first_chosen_col] += LOGICAL_SCREEN_WIDTH - 20 - sumcolwidth;
+ }
+ }
+}
+
+/* Find the first player with the fewest songs played and part of this machine. */
+const Player *GroupScreen::get_next_player(const Group &group)
+{
+ unsigned min_played_songs = 9999;
+ const Player *next_player = NULL;
+ unsigned m = 0;
+ for (std::vector<Player>::const_iterator i = group.players.begin(); i != group.players.end(); ++i) {
+ unsigned this_played = 0;
+ for (std::vector<Score>::const_iterator j = i->scores.begin(); j != i->scores.end(); ++j) {
+ if (j->score != -1)
+ ++this_played;
+ }
+
+ if ((m++ % num_machines == machine) && this_played < min_played_songs) {
+ min_played_songs = this_played;
+ next_player = &(*i);
+ }
+ }
+
+ return next_player;
+}
+
+/*
+ * At the bottom, for a single player, is "who's playing, what will he/she be
+ * playing, and optionally, how much to lead/win and how much to secure
+ * qualification" (the last one only in the final round). We assume playing is
+ * done in a modified zigzag; all the random songs are played first in
+ * zigzag/wrapping order (player 1 song 1, player 2 song 2, player 3 song 3,
+ * player 1 song 2, player 2 song 3, player 3 song 1, etc... assuming three
+ * songs and three players) and then all the chosen songs are played (we assume
+ * only one chosen song).
+ *
+ * The lines are as follows:
+ *
+ * <player>
+ * <song>
+ * High score: <hs> by <hsplayer> at <hsevent>
+ * Needs to lead: <leadscore>
+ * Needs to secure qualification: <qualscore>
+ * Needs to win group: <winscore>
+ */
+void GroupScreen::draw_next_up_single(unsigned char *buf, const Group &group,
+ std::map<unsigned, unsigned> &song_scores, std::map<unsigned, unsigned> &player_scores,
+ const std::vector<unsigned> &max_score, const std::vector<unsigned> &min_score)
+{
+ unsigned num_scores = group.players[0].scores.size();
+
+ // Find out how many random songs there are (equal for all players).
+ unsigned num_random_songs = 0;
+ for (std::vector<Score>::const_iterator i = group.players[0].scores.begin(); i != group.players[0].scores.end(); ++i) {
+ if (!i->chosen)
+ ++num_random_songs;
+ }
+
+ /*
+ * Find out which player is next, and what song he she is supposed to play. First
+ * try random songs.
+ */
+ const Player *next_player = get_next_player(group);
+ const Score *next_song = NULL;
+
+ for (unsigned i = 0; i < num_random_songs; ++i) {
+ unsigned j = (i + next_player->position - 1) % num_random_songs;
+ if (next_player->scores[j].score == -1) {
+ next_song = &(next_player->scores[j]);
+ break;
+ }
+ }
+
+ // then all songs, if that didn't work out (slightly icky, but hey)
+ if (next_song == NULL) {
+ for (unsigned i = 0; i < num_scores; ++i) {
+ unsigned j = (i + next_player->position) % num_scores;
+ if (next_player->scores[j].score == -1) {
+ next_song = &(next_player->scores[j]);
+ break;
+ }
+ }
+ }
+
+ if (next_song != NULL) {
+ // find out how many songs we've played in all
+ unsigned num_played = 0;
+ for (unsigned i = 0; i < num_scores; ++i) {
+ if (next_player->scores[i].score != -1) {
+ ++num_played;
+ }
+ }
+
+ bool last_song = (num_played == num_scores - 1);
+
+ draw_next_up_player(buf, group, *next_player, *next_song, last_song, song_scores, player_scores, max_score, min_score);
+ }
+}
+
+/*
+ * Some tournaments allow versus play in the initial rounds to save time; this is
+ * of course for random songs only. In this case, the scheme from draw_next_up_single()
+ * is somewhat changed, as we zig-zag across pairs instead of players. (If there's a
+ * stray person left in the group, that player plays the song by him-/herself as in
+ * a usual single tournament.
+ */
+void GroupScreen::draw_next_up_versus(unsigned char *buf, const Group &group,
+ std::map<unsigned, unsigned> &song_scores, std::map<unsigned, unsigned> &player_scores,
+ const std::vector<unsigned> &max_score, const std::vector<unsigned> &min_score)
+{
+ // Find out how many random songs there are (equal for all players).
+ unsigned num_random_songs = 0;
+ for (std::vector<Score>::const_iterator i = group.players[0].scores.begin(); i != group.players[0].scores.end(); ++i) {
+ if (!i->chosen)
+ ++num_random_songs;
+ }
+
+ // Find the next player and what song he/she is supposed to play, if any.
+ const Player *next_player = get_next_player(group);
+ const Score *next_song = NULL;
+ unsigned song_num;
+
+ for (unsigned i = 0; i < num_random_songs; ++i) {
+ unsigned j = (i + (next_player->position - 1) / 2) % num_random_songs;
+ if (next_player->scores[j].score == -1) {
+ next_song = &(next_player->scores[j]);
+ song_num = j;
+ break;
+ }
+ }
+
+ /*
+ * If there's no match, we're on the chosen songs (or done),
+ * so just delegate to draw_up_single().
+ */
+ if (next_song == NULL) {
+ draw_next_up_single(buf, group, song_scores, player_scores, max_score, min_score);
+ return;
+ }
+
+ /*
+ * Look for a player with the same amount of random songs played _and_ missing
+ * the same song.
+ */
+ unsigned num_songs_played = 0;
+ for (unsigned i = 0; i < num_random_songs; ++i) {
+ if (next_player->scores[i].score != -1) {
+ ++num_songs_played;
+ }
+ }
+
+ unsigned m = 0;
+ const Player *other_player = NULL;
+ for (std::vector<Player>::const_iterator i = group.players.begin(); i != group.players.end(); ++i) {
+ if ((m++ % num_machines != machine))
+ continue;
+ if (i->id == next_player->id)
+ continue;
+
+ unsigned this_songs_played = 0;
+ for (unsigned j = 0; j < num_random_songs; ++j) {
+ if (i->scores[j].score != -1) {
+ ++this_songs_played;
+ }
+ }
+
+ if (this_songs_played != num_songs_played)
+ continue;
+
+ if (i->scores[song_num].score == -1) {
+ other_player = &(*i);
+ break;
+ }
+ }
+
+ // If we didn't find another player, just draw the one we have as usual.
+ if (other_player == NULL) {
+ draw_next_up_player(buf, group, *next_player, *next_song, false,
+ song_scores, player_scores, max_score, min_score);
+ return;
+ }
+
+ // OK, we have two players. Draw their nicks and the scores
+ widestring text = widestring("Next players: ") + next_player->nick + widestring(" and ") + other_player->nick;
+ unsigned this_width = my_draw_text(text, NULL, 24.0);
+ my_draw_text(text, buf, 24.0, (LOGICAL_SCREEN_WIDTH/2) - this_width/2, 420);
+
+ if (next_song->song.id != -1) {
+ this_width = my_draw_text(next_song->song.title, NULL, 20.0);
+ my_draw_text(next_song->song.title, buf, 20.0, (LOGICAL_SCREEN_WIDTH/2) - this_width/2, 457);
+
+ Highscore hs;
+ conn.perform(FetchHighscore(next_song->song.id, &hs));
+
+ if (hs.score != -1) {
+ text = widestring("High score: ") + widestring(pqxx::to_string(hs.score)) +
+ widestring(", by ") + hs.nick + widestring(" in ") + hs.tournament_name;
+ this_width = my_draw_text(text, NULL, 16.0);
+ my_draw_text(text, buf, 16.0, (LOGICAL_SCREEN_WIDTH/2) - this_width/2, 487);