Solver.hpp

Go to the documentation of this file.

#pragma once
 
#include "CardSet.hpp"
#include "Error.hpp"
#include "Player.hpp"
#include "utils/Result.hpp"

 
namespace Cluedo {

struct PlayerData {
  std::string name;       
  std::size_t card_count; 
};

class Solver {
public:
  static constexpr std::size_t MIN_PLAYER_COUNT = 2;    
  static constexpr std::size_t MAX_PLAYER_COUNT = 6;    
  static constexpr std::size_t SOLUTION_CARD_COUNT = 3; 

  static Result<Solver, Error> create(std::vector<PlayerData> const& players_data);

  std::size_t player_count() const { return m_players.size() - 1; }

  Player const& player(std::size_t player_index) const { return m_players.at(player_index); }
  Player& player(std::size_t player_index) { return m_players.at(player_index); }

  void learn_player_card_state(std::size_t player_index, Card card, bool has_card, bool infer_new_info = true);

  void learn_player_has_any_of_cards(std::size_t player_index, CardSet const& card_set, bool infer_new_info = true);

  struct Suggestion {
    std::size_t suggesting_player_index;                
    Card suspect;                                       
    Card weapon;                                        
    Card room;                                          
    std::optional<std::size_t> responding_player_index; 
    std::optional<Card> response_card;                  
  };

  void learn_from_suggestion(Suggestion const& suggestion, bool infer_new_info = true);

  bool are_constraints_satisfied() const;

  using SolutionProbabilityPair = std::pair<std::tuple<Card, Card, Card>, float>;

  std::vector<SolutionProbabilityPair> find_most_likely_solutions() const;
 
private:
  static constexpr std::size_t MAX_ITERATIONS = 1'000'000;
 
  explicit Solver(std::vector<Player>&& players)
    : m_players(std::move(players)) {}
 
  std::size_t solution_player_index() const { return m_players.size() - 1; }
 
  void infer_new_information();
  bool assign_cards_to_players(std::vector<Card> const& cards);
  bool are_constraints_satisfied_for_solution_search() const;
 
  std::vector<Player> m_players;
};
 
};