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

comment out card positions member

Browse source
This commit is contained in:
Maximilian Keßler 2023-08-06 14:06:41 +02:00
parent 3b1ef55a5f
commit 34f8bf2444
Signed by: max
GPG key ID: BCC5A619923C0BA5
3 changed files with 30 additions and 9 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
game_state.h
View file

@ -180,7 +180,7 @@ public:
std::uint8_t _weighted_draw_pile_size{};
Stacks<num_suits> _stacks{};
std::array<std::array<Card, hand_size>, num_players> _hands{};
CardArray<num_suits, player_t> _card_positions{};
// CardArray<num_suits, player_t> _card_positions{};
std::list<CardMultiplicity> _draw_pile{};
std::uint8_t endgame_turns_left;
@ -193,6 +193,17 @@ public:
auto operator<=>(const HanabiState &) const = default;
};
template <std::size_t num_suits, player_t num_players, std::size_t hand_size>
bool same_up_to_discard_permutation(HanabiState<num_suits, num_players, hand_size> state1, HanabiState<num_suits, num_players, hand_size> state2) {
auto comp = [](CardMultiplicity &m1, CardMultiplicity &m2) -> bool {
return m1.card.suit < m2.card.suit || (m1.card.suit == m2.card.suit and m1.card.rank < m2.card.rank) ||
(m1.card.suit == m2.card.suit and m1.card.rank == m2.card.rank and m1.multiplicity < m2.multiplicity);
};
state1._draw_pile.sort(comp);
state2._draw_pile.sort(comp);
return state1 == state2;
}
template <std::size_t num_suits, player_t num_players, std::size_t hand_size>
std::ostream & operator<<(std::ostream &os, HanabiState<num_suits, num_players, hand_size> hanabi_state);

22
game_state.hpp
View file

@ -64,7 +64,7 @@ namespace Hanabi {
_weighted_draw_pile_size(deck.size()),
_stacks(),
_hands(),
_card_positions(draw_pile),
// _card_positions(draw_pile),
_draw_pile(),
_pace(deck.size() - 5 * num_suits - num_players * (hand_size - 1)),
_score(0) {
@ -199,7 +199,7 @@ namespace Hanabi {
const Card& discarded = _hands[_turn][index];
if (_stacks[discarded.suit] > discarded.rank) {
_card_positions[_hands[_turn][index]] = trash_or_play_stack;
// _card_positions[_hands[_turn][index]] = trash_or_play_stack;
}
// draw a new card if the draw pile is not empty
@ -220,7 +220,7 @@ namespace Hanabi {
card_in_hand.copy = draw.multiplicity - 1;
if (_stacks[draw.card.suit] > draw.card.rank) {
_card_positions[card_in_hand] = _turn;
// _card_positions[card_in_hand] = _turn;
}
if(_draw_pile.empty()) {
@ -238,7 +238,7 @@ namespace Hanabi {
assert(index < _hands[_turn].size());
const Card &drawn = _hands[_turn][index];
if (_stacks[drawn.suit] > drawn.rank) {
_card_positions[drawn] = draw_pile;
// _card_positions[drawn] = draw_pile;
}
// put discarded_card back into draw pile (at the back)
@ -253,7 +253,7 @@ namespace Hanabi {
endgame_turns_left = no_endgame;
_hands[_turn][index] = discarded_card;
if (_stacks[discarded_card.suit] > discarded_card.rank) {
_card_positions[discarded_card] = _turn;
// _card_positions[discarded_card] = _turn;
}
}
@ -286,7 +286,7 @@ namespace Hanabi {
_draw_pile.push_back({card, nums_in_draw_pile[card]});
for (std::uint8_t copy = 0; copy < nums_in_draw_pile[card]; copy++) {
card.copy = copy;
_card_positions[card] = draw_pile;
// _card_positions[card] = draw_pile;
}
}
}
@ -357,18 +357,22 @@ namespace Hanabi {
if(is_playable(hand[index])) {
std::cout << std::string("---------------------", depth) << "playing " << hand[index] << std::endl;
if (_draw_pile.empty()) {
auto copy = *this;
BacktrackAction action = play(index);
const double probability_for_this_play = backtrack(depth + 1);
revert(action);
assert(same_up_to_discard_permutation(*this, copy));
UPDATE_PROBABILITY(probability_for_this_play);
} else {
double sum_of_probabilities = 0;
uint8_t sum_of_mults = 0;
for (size_t i = 0; i < _draw_pile.size(); i++) {
auto copy = *this;
BacktrackAction action = play(index);
sum_of_probabilities += backtrack(depth + 1) * action.multiplicity;
sum_of_mults += action.multiplicity;
revert(action);
assert(same_up_to_discard_permutation(*this, copy));
assert(sum_of_mults <= _weighted_draw_pile_size);
}
assert(sum_of_mults == _weighted_draw_pile_size);
@ -385,17 +389,21 @@ namespace Hanabi {
std::cout << std::string("---------------------------", depth) << "discarding " << hand[index] << std::endl;
double sum_of_probabilities = 0;
if (_draw_pile.empty()) {
auto copy = *this;
BacktrackAction action = discard(index);
const double probability_for_this_discard = backtrack(depth + 1);
revert(action);
assert(same_up_to_discard_permutation(*this, copy));
UPDATE_PROBABILITY(probability_for_this_discard);
} else {
uint8_t sum_of_mults = 0;
for (size_t i = 0; i < _draw_pile.size(); i++) {
auto copy = *this;
BacktrackAction action = discard(index);
sum_of_probabilities += backtrack(depth + 1) * action.multiplicity;
sum_of_mults += action.multiplicity;
revert(action);
assert(same_up_to_discard_permutation(*this, copy));
}
assert(sum_of_mults == _weighted_draw_pile_size);
const double probability_discard = sum_of_probabilities / _weighted_draw_pile_size;
@ -411,9 +419,11 @@ namespace Hanabi {
// Last option is to stall
if(_num_clues > 0) {
std::cout << std::string("--------------------", depth) << "stalling " << std::endl;
auto copy = *this;
BacktrackAction action = clue();
const double probability_stall = backtrack(depth + 1);
revert(action);
assert(same_up_to_discard_permutation(*this, copy));
UPDATE_PROBABILITY(probability_stall);
}

4
main.cpp
View file

@ -21,7 +21,7 @@ void test_game() {
state._draw_pile.push_back({r41, 1});
state._hands[0] = {y0, y1, y2, r0, r1};
state._hands[1] = {r1, r1, y1, r3, r2};
state._card_positions[r1] = 0;
// state._card_positions[r1] = 0;
state._weighted_draw_pile_size = 1;
auto state2 = state;
@ -34,7 +34,7 @@ void test_game() {
std::cout << state2 << std::endl;
assert(state._hands == state2._hands);
assert(state._draw_pile == state2._draw_pile);
assert(state._card_positions == state2._card_positions);
// assert(state._card_positions == state2._card_positions);
assert(state == state2);
}