swiss.h

/*
 * This is the template for a class which implements a simple Swiss Tournament.
 * It is complete with "Bye's" for any time those are needed.
 */
#ifndef SWISS_H
#define SWISS_H
#include <map>
#include <vector>
#include <set>
#include <string>
#include <utility>
#include <algorithm>
#include <iostream>


template<class player_t>
class SwissTournament
{
public:
    //the participants of the tournament 
    class Contestant
    {
    public:
        Contestant()
        {
            wins = 0; 
            losses = 0;
        }
        virtual std::string name()=0;
        virtual player_t *player()=0;
        
        bool operator<(const Contestant &rhs) const {
            if(wins == rhs.wins) return losses<rhs.losses;
            return wins>rhs.wins;
        }
        
    private:
        std::set<Contestant*> played;
        int wins;
        int losses;
        friend SwissTournament<player_t>;
    };
    
    static bool swissCmp(Contestant *a, Contestant *b) { return *a < *b; }
    
    
    //Constructor
    SwissTournament(const std::vector<Contestant*> &players) : contestants(players)
    {
        //arrange the first round at random
        round = 1;
        match = 0;
        exhausted = false;
        for(int i=0; i<contestants.size(); i++) {
            std::swap(contestants[i], contestants[rand()%contestants.size()]);
        }
       
        //arrange the matches
        for(int i=0; i<contestants.size(); i+=2) {
            std::pair<Contestant *, Contestant*> m;
            m.first = contestants[i];
            if(i+1<contestants.size()) {
                m.first->played.insert(m.second);
                m.second = contestants[i+1];
                m.second->played.insert(m.first);
            } else {
                m.second = nullptr; //the bye
            }
            
            matches.push_back(m);
        }
    }
    
    
    //return the current match
    std::pair<Contestant*, Contestant*> getMatch() 
    {
        return matches[match];
    }
    
    
    //report the winner
    void report(Contestant* winner) {
        winner->wins++;
        if(matches[match].second) {
            if(winner == matches[match].first)
                matches[match].second->losses++;
            else
                matches[match].first->losses++;
        }
        
        //rank things
        std::sort(contestants.begin(), contestants.end(), swissCmp);
        
        //on to the next match!
        match++;
    }
    
    
    //true if the round is done
    bool roundDone() {
        return match >= matches.size();
    }
    
    
    //true if the tournament is done
    bool tournamentDone() {
        std::sort(contestants.begin(), contestants.end(), swissCmp);
       
        //safety valve
        if(exhausted) return true;
        
        //check to see if there is a tie for first, second, or third place
        for(int i=0; i<=2; i++) {
          //check to see if there is a tie for first place
          if(contestants[i]->wins == contestants[i+1]->wins and 
             contestants[i]->losses == contestants[i+1]->losses) {
            return false;
          }
        }
        
        //if we make it here, we're done!
        return true;
    }
    
    
    //arrange the next round
    void nextRound() 
    {
        std::pair<Contestant *, Contestant *> m;
        int start;
        
        if(!roundDone()) {
            return;  //no fair interrupting a round!
        }
        
        //sort contestants and clear the matches
        std::sort(contestants.begin(), contestants.end(), swissCmp);
        matches.clear();
        
        //skip over the cemented spots
        start=3;
        for(int i=0; i<=2; i++) {
          if(contestants[i]->wins == contestants[i+1]->wins and 
             contestants[i]->losses == contestants[i+1]->losses) {
              start = i;
          }
        }
        
        //set the matches, detect exhaustion
        std::set<int> used;
        exhausted = true;
        for(int i=start; i<contestants.size(); i++) {
            if(used.count(i)) continue;  //skip the used
            for(int j=i+1; j<contestants.size(); j++) {
                if(used.count(j)) continue; //skip the used
                if(contestants[i]->played.count(contestants[j])) continue;  //no dual face-offs!
                //make it so!
                m.first = contestants[i];
                m.second= contestants[j];
                contestants[i]->played.insert(contestants[j]);
                contestants[j]->played.insert(contestants[i]);
                used.insert(i);
                used.insert(j);
                exhausted = false;
                matches.push_back(m);
                break;
            }
            
            //handle byes
            if(used.count(i) == 0){
                m.first = contestants[i];
                m.second = nullptr;
                used.insert(i);
                matches.push_back(m);
            }
        }
        
        //next round!
        round++;
        match = 0;
    }
    
    
    void printPairings() {
        std::cout << "Round " << round << std::endl;
        for(int i=0; i<matches.size(); i++) {
            std::cout << i+1 << ".) "
                 << matches[i].first->name() << " vs " ;
            if(matches[i].second != nullptr) {
                std::cout << matches[i].second->name() << std::endl;
            } else {
                std::cout << "** BYE **" << std::endl;
            }
        }
    }
    
    
    void printLeader() {
        std::sort(contestants.begin(), contestants.end(), swissCmp);
        std:: cout << "Leader Board" << std::endl;
        for(int i=0; i<contestants.size(); i++) {
            std::cout << i+1 << ".) "
                 << contestants[i]->name() << "\t"
                 << contestants[i]->wins << " - " << contestants[i]->losses << std::endl;
        }
    }
    
private:
    int round;
    int match;
    bool exhausted;
    std::vector<Contestant *> contestants;
    std::vector<std::pair<Contestant*, Contestant*>> matches;
};


#endif