Hanabi/Endgame-Analyzer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

more assertions

Browse source
This commit is contained in:
Maximilian Keßler 2023-08-06 13:53:18 +02:00
parent 89e6e02603
commit 3b1ef55a5f
Signed by: max
GPG key ID: BCC5A619923C0BA5
3 changed files with 45 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
game_state.h
View file

@ -146,7 +146,7 @@ public:
HanabiState() = default; HanabiState() = default;
explicit HanabiState(const std::vector<Card>& deck); explicit HanabiState(const std::vector<Card>& deck);
double backtrack(); double backtrack(size_t depth);
BacktrackAction clue(); BacktrackAction clue();
@ -166,7 +166,7 @@ public:
uint8_t draw(uint8_t index); uint8_t draw(uint8_t index);
void revert_draw(std::uint8_t index, Card card); void revert_draw(std::uint8_t index, Card discarded_card);
void incr_turn(); void incr_turn();
@ -184,6 +184,8 @@ public:
std::list<CardMultiplicity> _draw_pile{}; std::list<CardMultiplicity> _draw_pile{};
std::uint8_t endgame_turns_left; std::uint8_t endgame_turns_left;
static constexpr uint8_t no_endgame = std::numeric_limits<uint8_t>::max();
// further statistics that we might want to keep track of // further statistics that we might want to keep track of
uint8_t _pace{}; uint8_t _pace{};
uint8_t _score{}; uint8_t _score{};

54
game_state.hpp
View file

@ -94,7 +94,7 @@ namespace Hanabi {
template<size_t num_suits, player_t num_players, size_t hand_size> template<size_t num_suits, player_t num_players, size_t hand_size>
void HanabiState<num_suits, num_players, hand_size>::incr_turn() { void HanabiState<num_suits, num_players, hand_size>::incr_turn() {
_turn = (_turn + 1) % num_players; _turn = (_turn + 1) % num_players;
if(endgame_turns_left != -1) { if(endgame_turns_left != no_endgame) {
endgame_turns_left--; endgame_turns_left--;
} }
} }
@ -102,8 +102,11 @@ namespace Hanabi {
template<size_t num_suits, player_t num_players, size_t hand_size> template<size_t num_suits, player_t num_players, size_t hand_size>
void HanabiState<num_suits, num_players, hand_size>::decr_turn() { void HanabiState<num_suits, num_players, hand_size>::decr_turn() {
_turn = (_turn + num_players - 1) % num_players; _turn = (_turn + num_players - 1) % num_players;
if (endgame_turns_left != -1) { if (endgame_turns_left != no_endgame) {
endgame_turns_left++; endgame_turns_left++;
if(endgame_turns_left == num_players) {
endgame_turns_left = no_endgame;
}
} }
} }
@ -229,27 +232,30 @@ namespace Hanabi {
} }
template<std::size_t num_suits, player_t num_players, std::size_t hand_size> template<std::size_t num_suits, player_t num_players, std::size_t hand_size>
void HanabiState<num_suits, num_players, hand_size>::revert_draw(std::uint8_t index, Card card) { void HanabiState<num_suits, num_players, hand_size>::revert_draw(std::uint8_t index, Card discarded_card) {
endgame_turns_left = -1; if (endgame_turns_left == no_endgame) {
// Put the card that is currently in hand back into the draw pile
assert(index < _hands[_turn].size()); assert(index < _hands[_turn].size());
const Card& discarded = _hands[_turn][index]; const Card &drawn = _hands[_turn][index];
if (_stacks[discarded.suit] > discarded.rank) { if (_stacks[drawn.suit] > drawn.rank) {
_card_positions[discarded] = draw_pile; _card_positions[drawn] = draw_pile;
} }
// put card back into draw pile (at the back) // put discarded_card back into draw pile (at the back)
if (!_draw_pile.empty() and _draw_pile.back().card.suit == _hands[_turn][index].suit and _draw_pile.back().card.rank == _hands[_turn][index].rank) { if (!_draw_pile.empty() and _draw_pile.back().card.suit == drawn.suit and
_draw_pile.back().card.rank == drawn.rank) {
_draw_pile.back().multiplicity++; _draw_pile.back().multiplicity++;
} else { } else {
_draw_pile.push_back({_hands[_turn][index], 1}); _draw_pile.push_back({drawn, 1});
}
_hands[_turn][index] = card;
if (_stacks[card.suit] > card.rank) {
_card_positions[card] = _turn;
} }
_weighted_draw_pile_size++; _weighted_draw_pile_size++;
} }
endgame_turns_left = no_endgame;
_hands[_turn][index] = discarded_card;
if (_stacks[discarded_card.suit] > discarded_card.rank) {
_card_positions[discarded_card] = _turn;
}
}
template<std::size_t num_suits, player_t num_players, std::size_t hand_size> template<std::size_t num_suits, player_t num_players, std::size_t hand_size>
void HanabiState<num_suits, num_players, hand_size>::normalize_draw_and_positions() { void HanabiState<num_suits, num_players, hand_size>::normalize_draw_and_positions() {
@ -331,7 +337,7 @@ namespace Hanabi {
} }
template<std::size_t num_suits, player_t num_players, std::size_t hand_size> template<std::size_t num_suits, player_t num_players, std::size_t hand_size>
double HanabiState<num_suits, num_players, hand_size>::backtrack() { double HanabiState<num_suits, num_players, hand_size>::backtrack(size_t depth) {
std::cout << *this << std::endl; std::cout << *this << std::endl;
if (_score == 5 * num_suits) { if (_score == 5 * num_suits) {
return 1; return 1;
@ -349,9 +355,10 @@ namespace Hanabi {
// First, check for playables // First, check for playables
for(std::uint8_t index = 0; index < hand_size; index++) { for(std::uint8_t index = 0; index < hand_size; index++) {
if(is_playable(hand[index])) { if(is_playable(hand[index])) {
std::cout << std::string("---------------------", depth) << "playing " << hand[index] << std::endl;
if (_draw_pile.empty()) { if (_draw_pile.empty()) {
BacktrackAction action = play(index); BacktrackAction action = play(index);
const double probability_for_this_play = backtrack(); const double probability_for_this_play = backtrack(depth + 1);
revert(action); revert(action);
UPDATE_PROBABILITY(probability_for_this_play); UPDATE_PROBABILITY(probability_for_this_play);
} else { } else {
@ -359,7 +366,7 @@ namespace Hanabi {
uint8_t sum_of_mults = 0; uint8_t sum_of_mults = 0;
for (size_t i = 0; i < _draw_pile.size(); i++) { for (size_t i = 0; i < _draw_pile.size(); i++) {
BacktrackAction action = play(index); BacktrackAction action = play(index);
sum_of_probabilities += backtrack() * action.multiplicity; sum_of_probabilities += backtrack(depth + 1) * action.multiplicity;
sum_of_mults += action.multiplicity; sum_of_mults += action.multiplicity;
revert(action); revert(action);
assert(sum_of_mults <= _weighted_draw_pile_size); assert(sum_of_mults <= _weighted_draw_pile_size);
@ -375,18 +382,22 @@ namespace Hanabi {
if(_pace > 0) { if(_pace > 0) {
for(std::uint8_t index = 0; index < hand_size; index++) { for(std::uint8_t index = 0; index < hand_size; index++) {
if (is_trash(hand[index])) { if (is_trash(hand[index])) {
std::cout << std::string("---------------------------", depth) << "discarding " << hand[index] << std::endl;
double sum_of_probabilities = 0; double sum_of_probabilities = 0;
if (_draw_pile.empty()) { if (_draw_pile.empty()) {
BacktrackAction action = discard(index); BacktrackAction action = discard(index);
const double probability_for_this_discard = backtrack(); const double probability_for_this_discard = backtrack(depth + 1);
revert(action); revert(action);
UPDATE_PROBABILITY(probability_for_this_discard); UPDATE_PROBABILITY(probability_for_this_discard);
} else { } else {
uint8_t sum_of_mults = 0;
for (size_t i = 0; i < _draw_pile.size(); i++) { for (size_t i = 0; i < _draw_pile.size(); i++) {
BacktrackAction action = discard(index); BacktrackAction action = discard(index);
sum_of_probabilities += backtrack() * action.multiplicity; sum_of_probabilities += backtrack(depth + 1) * action.multiplicity;
sum_of_mults += action.multiplicity;
revert(action); revert(action);
} }
assert(sum_of_mults == _weighted_draw_pile_size);
const double probability_discard = sum_of_probabilities / _weighted_draw_pile_size; const double probability_discard = sum_of_probabilities / _weighted_draw_pile_size;
UPDATE_PROBABILITY(probability_discard); UPDATE_PROBABILITY(probability_discard);
} }
@ -399,8 +410,9 @@ namespace Hanabi {
// Last option is to stall // Last option is to stall
if(_num_clues > 0) { if(_num_clues > 0) {
std::cout << std::string("--------------------", depth) << "stalling " << std::endl;
BacktrackAction action = clue(); BacktrackAction action = clue();
const double probability_stall = backtrack(); const double probability_stall = backtrack(depth + 1);
revert(action); revert(action);
UPDATE_PROBABILITY(probability_stall); UPDATE_PROBABILITY(probability_stall);
} }

8
main.cpp
View file

@ -39,10 +39,10 @@ void test_game() {
} }
void download() { void download() {
auto game = Download::get_game<4,3,5>("1004480.json", 36); auto game = Download::get_game<4,3,5>("1004480.json", 30);
std::cout << game << std::endl; // std::cout << game << std::endl;
auto res = game.backtrack(); auto res = game.backtrack(1);
std::cout << res << std::endl; std::cout << "Probability with optimal play: " << res << std::endl;
} }
void print_sizes() { void print_sizes() {