Add code in the bigscreen for supporting versus groups (not finished yet).
authorSteinar H. Gunderson <sesse@samfundet.no>
Sat, 5 Mar 2005 00:40:01 +0000 (00:40 +0000)
committerSteinar H. Gunderson <sesse@samfundet.no>
Sat, 5 Mar 2005 00:40:01 +0000 (00:40 +0000)
bigscreen/groupscreen.cpp
bigscreen/groupscreen.h

index 219660a..d163069 100644 (file)
@@ -308,6 +308,110 @@ void GroupScreen::draw_next_up_single(unsigned char *buf, const Group &group,
        }
 }
 
+/*
+ * 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);
+               }
+       }
+}
+
 void GroupScreen::draw_next_up_player(unsigned char *buf, const Group &group, const Player &player, const Score &song, bool last_song,
        std::map<unsigned, unsigned> &song_scores, std::map<unsigned, unsigned> &player_scores,
        const std::vector<unsigned> &max_score, const std::vector<unsigned> &min_score)
@@ -575,8 +679,11 @@ void GroupScreen::draw(unsigned char *buf, unsigned width, unsigned height)
                else 
                        y += 40;
        }
-       
-       draw_next_up_single(buf, group, song_scores, player_scores, max_score, min_score);
+
+       if (players_per_machine == 2)
+               draw_next_up_versus(buf, group, song_scores, player_scores, max_score, min_score);
+       else 
+               draw_next_up_single(buf, group, song_scores, player_scores, max_score, min_score);
        
        valid = true;
        draw_all_deferred_text(buf, td, last_text);
index a2b0db1..d7b3761 100644 (file)
@@ -32,6 +32,9 @@ private:
        void 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);
+       void 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);
        void find_column_widths(const Group &group, std::vector<unsigned> &colwidth);
        
 public: