tournament.hpp

Go to the documentation of this file.

/*
 * This file is part of ChineseCheckers which is released under GNU General Public License v3.0.
 * See file LICENSE or go to https://github.com/alexicanesse/ChineseCheckers/blob/main/LICENSE for full license details.
 * Copyright 2022 - ENS de Lyon
 */
 
#ifndef INCLUDE_TOURNAMENT_HPP_
#define INCLUDE_TOURNAMENT_HPP_
 
/* C libraries */
#include <numbers>
 
/* C++ libraries */
#include <vector>
#include <random>
#include <chrono>
#include <cmath>
#include <algorithm>
#include <iomanip>
#include <limits>
#include <fstream>
#include <thread>
 
/* The following pragma are used to removed depraction warning from boost
 * header files. Using them avoid to remove this warning from the entire project.
 */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include <boost/python.hpp>
#pragma GCC diagnostic pop
 
/* Other */
#include "Types.hpp"
#include "AlphaBeta.hpp"
 
Result playGame(AlphaBeta &player0, AlphaBeta &player1, const int &depth);
void print_matrix(const std::vector<double> &matrix);
 
class SolversIndividuals {
 private:
    std::vector<double> win;
    std::vector<double> lose;
    double score;
 
 public:
    SolversIndividuals();
    SolversIndividuals(std::vector<double> &win_, std::vector<double> &lose_);
 
    friend bool operator<(SolversIndividuals const &s1,
                          SolversIndividuals const &s2);
    SolversIndividuals& operator=(const SolversIndividuals & other);
 
    std::vector<double> get_win();
    std::vector<double> get_lose();
    double get_score();
 
    void init_at_random();
    void set_win(const std::vector<double> &win_);
    void set_lose(const std::vector<double> &lose_);
    void set_score(const double &score_);
 
    void mutate();
 
    void print_info();
    void print_info_as_matrix();
    void print_info_as_matrix_to_file(std::ofstream &file);
 
    void crossOver(const SolversIndividuals & Parent1, const SolversIndividuals & Parent2);
};
 
class GamePlayer {
 private:
    AlphaBeta white_player;
    AlphaBeta black_player;
    int depth;
 
 public:
    GamePlayer();
    GamePlayer(int depth_);
    GamePlayer(SolversIndividuals &solver1,
               SolversIndividuals &solver2,
               int depth_ = 1);
 
    double playGame();
 
    void set_white_player(SolversIndividuals &solver);
    void set_black_player(SolversIndividuals &solver);
    void set_depth(const int &depth_);
 
    void print_players_info();
 
    int constructor_test();
};
 
 
class ThreadGamePlayer {
   public:
   int start;
   int end;
   GamePlayer gp;
   ThreadGamePlayer();
   void operator()(std::vector<SolversIndividuals> &population,bool is_white_evolving);/*std::vector<SolversIndividuals> &population,bool is_white_evolving*/
};
 
 
void write_scores(std::ofstream &file,
                  std::vector<SolversIndividuals> &population,
                  SolversIndividuals &best_to_write,
                  const int &gen);
 
void evol(GamePlayer *gp,
          std::vector<SolversIndividuals> &population,
          SolversIndividuals *best_player,
          bool is_white_evolving);
 
void evol_thread(const std::vector<ThreadGamePlayer> & gps,
          std::vector<SolversIndividuals> &population,
          SolversIndividuals *best_player,
          bool is_white_evolving);
 
#endif  // INCLUDE_TOURNAMENT_HPP_