From 07ead889ab9e851855d5ac43f49913138252b647 Mon Sep 17 00:00:00 2001 From: Marc Lanctot Date: Sat, 13 Apr 2024 08:21:42 -0230 Subject: [PATCH] Remove partial game that author cannot finish --- open_spiel/games/yacht/yacht.cc | 387 ---------------------- open_spiel/games/yacht/yacht.h | 193 ----------- open_spiel/games/yacht/yacht_test.cc | 111 ------- open_spiel/python/tests/games_sim_test.py | 2 +- 4 files changed, 1 insertion(+), 692 deletions(-) delete mode 100644 open_spiel/games/yacht/yacht.cc delete mode 100644 open_spiel/games/yacht/yacht.h delete mode 100644 open_spiel/games/yacht/yacht_test.cc diff --git a/open_spiel/games/yacht/yacht.cc b/open_spiel/games/yacht/yacht.cc deleted file mode 100644 index 91ee09f25d..0000000000 --- a/open_spiel/games/yacht/yacht.cc +++ /dev/null @@ -1,387 +0,0 @@ -// Copyright 2019 DeepMind Technologies Limited -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "open_spiel/games/yacht/yacht.h" - -#include -#include -#include -#include -#include - -#include "open_spiel/abseil-cpp/absl/strings/str_cat.h" -#include "open_spiel/game_parameters.h" -#include "open_spiel/observer.h" -#include "open_spiel/spiel.h" -#include "open_spiel/spiel_globals.h" -#include "open_spiel/spiel_utils.h" - -namespace open_spiel { -namespace yacht { -namespace { - -const std::vector> kChanceOutcomes = { - std::pair(1, 1.0 / 6), - std::pair(2, 1.0 / 6), - std::pair(3, 1.0 / 6), - std::pair(4, 1.0 / 6), - std::pair(5, 1.0 / 6), - std::pair(6, 1.0 / 6), -}; - -const std::vector kChanceOutcomeValues = {1, 2, 3, 4, 5, 6}; - -constexpr int kLowestDieRoll = 1; -constexpr int kHighestDieRoll = 6; -constexpr int kInitialTurn = -1; - -// Facts about the game -const GameType kGameType{/*short_name=*/"yacht", - /*long_name=*/"Yacht", - GameType::Dynamics::kSequential, - GameType::ChanceMode::kExplicitStochastic, - GameType::Information::kPerfectInformation, - GameType::Utility::kZeroSum, - GameType::RewardModel::kTerminal, - /*min_num_players=*/2, - /*max_num_players=*/2, - /*provides_information_state_string=*/false, - /*provides_information_state_tensor=*/false, - /*provides_observation_string=*/true, - /*provides_observation_tensor=*/true}; - -static std::shared_ptr Factory(const GameParameters& params) { - return std::shared_ptr(new YachtGame(params)); -} - -REGISTER_SPIEL_GAME(kGameType, Factory); - -RegisterSingleTensorObserver single_tensor(kGameType.short_name); -} // namespace - -std::string CurPlayerToString(Player cur_player) { - switch (cur_player) { - case 1: - return "Player 1"; - case 2: - return "Player 2"; - case kChancePlayerId: - return "*"; - case kTerminalPlayerId: - return "T"; - default: - SpielFatalError(absl::StrCat("Unrecognized player id: ", cur_player)); - } -} - -std::string PositionToStringHumanReadable(int pos) { return "Pos"; } - -std::string YachtState::ActionToString(Player player, Action move_id) const { - if (player == kChancePlayerId) { - return absl::StrCat("chance outcome ", move_id, - " (roll: ", kChanceOutcomeValues[move_id - 1], ")"); - } else { - if (move_id >= kLowestDieRoll && move_id <= kHighestDieRoll) { - return absl::StrCat("Player ", player, ": chose to re-roll die ", - move_id); - } else if (move_id == kPass) { - if (dice_to_reroll_.empty()) { - return absl::StrCat("Player ", player, ": chose to reroll no dice."); - } else { - std::string reroll_dice = ""; - for (int i = 0; i < dice_to_reroll_.size() - 1; ++i) { - reroll_dice += DiceToString(dice_to_reroll_[i]) + ", "; - } - reroll_dice += - DiceToString(dice_to_reroll_[dice_to_reroll_.size() - 1]); - return absl::StrCat("Player ", player, ": chose to roll dice ", - reroll_dice); - } - } else { - return absl::StrCat("Unrecognized action: ", move_id, - " for player: ", player); - } - } -} - -std::string YachtState::ObservationString(Player player) const { - SPIEL_CHECK_GE(player, 0); - SPIEL_CHECK_LT(player, num_players_); - return ToString(); -} - -YachtState::YachtState(std::shared_ptr game) - : State(game), - cur_player_(kChancePlayerId), - prev_player_(kChancePlayerId), - turns_(kInitialTurn), - player1_turns_(0), - player2_turns_(0), - dice_({}), - scores_({0, 0}), - scoring_sheets_({ScoringSheet(), ScoringSheet()}) {} - -Player YachtState::CurrentPlayer() const { - return IsTerminal() ? kTerminalPlayerId : Player{cur_player_}; -} - -int YachtState::Opponent(int player) const { - if (player == kPlayerId1) return kPlayerId2; - if (player == kPlayerId2) return kPlayerId1; - SpielFatalError("Invalid player."); -} - -void YachtState::RollDie(int outcome) { - dice_.push_back(kChanceOutcomeValues[outcome - 1]); -} - -int YachtState::DiceValue(int i) const { - SPIEL_CHECK_GE(i, 0); - SPIEL_CHECK_LT(i, dice_.size()); - - if (dice_[i] >= 1 && dice_[i] <= 6) { - return dice_[i]; - } else if (dice_[i] >= 7 && dice_[i] <= 12) { - // This die is marked as chosen, so return its proper value. - // Note: dice are only marked as chosen during the legal moves enumeration. - return dice_[i] - 6; - } else { - SpielFatalError(absl::StrCat("Bad dice value: ", dice_[i])); - } -} - -void YachtState::ApplyNormalAction(Action move, int player) { - if (move == kFillOnes) { - scoring_sheets_[player].ones = filled; - - int score = 0; - for (int i = 0; i < dice_.size(); ++i) { - int die = dice_[i]; - if (die == 1) { - score += die; - } - } - - scores_[player] += score; - } - // TODO(aaronrice): Score remaining categories here -} - -void YachtState::IncrementTurn() { - turns_++; - if (cur_player_ == kPlayerId1) { - player1_turns_++; - } else if (cur_player_ == kPlayerId2) { - player2_turns_++; - } - - prev_player_ = cur_player_; - cur_player_ = kChancePlayerId; - - dice_.clear(); -} - -void YachtState::DoApplyAction(Action move) { - if (IsChanceNode()) { - if (turns_ == kInitialTurn) { - // First turn. - SPIEL_CHECK_TRUE(dice_.empty()); - int starting_player = std::rand() % kNumPlayers; - if (starting_player == 0) { - // Player1 starts. - cur_player_ = kChancePlayerId; - prev_player_ = kPlayerId2; - } else if (starting_player == 1) { - // Player2 Starts - cur_player_ = kChancePlayerId; - prev_player_ = kPlayerId1; - } else { - SpielFatalError( - absl::StrCat("Invalid starting player: ", starting_player)); - } - RollDie(move); - turns_ = 0; - return; - } else { - // Normal chance node. - SPIEL_CHECK_TRUE(dice_.size() < 5); - RollDie(move); - - // Once die are done rolling. Set player to non-chance node. - if (dice_.size() == 5) { - cur_player_ = Opponent(prev_player_); - } - return; - } - } - - // Normal action. - SPIEL_CHECK_TRUE(dice_.size() == 5); - - int player_index = cur_player_ - 1; - ApplyNormalAction(move, player_index); - - IncrementTurn(); -} - -bool YachtState::IsPosInHome(int player, int pos) const { return true; } - -bool YachtState::UsableDiceOutcome(int outcome) const { - return (outcome >= 1 && outcome <= 6); -} - -std::string YachtState::DiceToString(int outcome) const { - return std::to_string(outcome); -} - -std::vector YachtState::LegalActions() const { - if (IsChanceNode()) return LegalChanceOutcomes(); - if (IsTerminal()) return {}; - - // TODO(aaronrice): update legal moves for scoring categories and scratches. - std::vector legal_actions = {}; - - for (int i = 0; i < dice_to_reroll_.size(); i++) { - bool will_reroll = dice_to_reroll_[i]; - - // A player cannot choose a die that has already been chosen to be - // re-rolled. - if (!will_reroll) { - legal_actions.push_back(i + 1); - } - } - - // Can choose to be done picking die to re-roll at anytime. - legal_actions.push_back(kPass); - - return legal_actions; -} - -std::vector> YachtState::ChanceOutcomes() const { - SPIEL_CHECK_TRUE(IsChanceNode()); - return kChanceOutcomes; -} - -std::string YachtState::ScoringSheetToString( - const ScoringSheet& scoring_sheet) const { - std::string result = ""; - absl::StrAppend(&result, "Ones: "); - absl::StrAppend(&result, scoring_sheet.ones); - absl::StrAppend(&result, "\n"); - absl::StrAppend(&result, "Twos: "); - absl::StrAppend(&result, scoring_sheet.twos); - absl::StrAppend(&result, "\n"); - absl::StrAppend(&result, "Threes: "); - absl::StrAppend(&result, scoring_sheet.threes); - absl::StrAppend(&result, "\n"); - absl::StrAppend(&result, "Fours: "); - absl::StrAppend(&result, scoring_sheet.fours); - absl::StrAppend(&result, "\n"); - absl::StrAppend(&result, "Five: "); - absl::StrAppend(&result, scoring_sheet.fives); - absl::StrAppend(&result, "\n"); - absl::StrAppend(&result, "Sixes: "); - absl::StrAppend(&result, scoring_sheet.sixes); - absl::StrAppend(&result, "\n"); - absl::StrAppend(&result, "Full House: "); - absl::StrAppend(&result, scoring_sheet.full_house); - absl::StrAppend(&result, "\n"); - absl::StrAppend(&result, "Four of a Kind: "); - absl::StrAppend(&result, scoring_sheet.four_of_a_kind); - absl::StrAppend(&result, "\n"); - absl::StrAppend(&result, "Little Straight: "); - absl::StrAppend(&result, scoring_sheet.little_straight); - absl::StrAppend(&result, "\n"); - absl::StrAppend(&result, "Big Straight: "); - absl::StrAppend(&result, scoring_sheet.big_straight); - absl::StrAppend(&result, "\n"); - absl::StrAppend(&result, "Choice: "); - absl::StrAppend(&result, scoring_sheet.choice); - absl::StrAppend(&result, "\n"); - absl::StrAppend(&result, "Yacht: "); - absl::StrAppend(&result, scoring_sheet.yacht); - absl::StrAppend(&result, "\n\n"); - return result; -} - -std::string YachtState::ToString() const { - std::string state = ""; - - absl::StrAppend(&state, "Player 1:\n\n"); - absl::StrAppend(&state, ScoringSheetToString(scoring_sheets_[0])); - - absl::StrAppend(&state, "Player 2:\n\n"); - absl::StrAppend(&state, ScoringSheetToString(scoring_sheets_[1])); - - return state; -} - -bool YachtState::IsTerminal() const { - // A game is over when all players have have filled their scoring sheets. - const ScoringSheet& player1_scoring_sheet = scoring_sheets_[0]; - if (player1_scoring_sheet.ones == empty || - player1_scoring_sheet.twos == empty || - player1_scoring_sheet.threes == empty || - player1_scoring_sheet.fours == empty || - player1_scoring_sheet.fives == empty || - player1_scoring_sheet.sixes == empty || - player1_scoring_sheet.full_house == empty || - player1_scoring_sheet.four_of_a_kind == empty || - player1_scoring_sheet.little_straight == empty || - player1_scoring_sheet.big_straight == empty || - player1_scoring_sheet.choice == empty || - player1_scoring_sheet.yacht == empty) { - return false; - } - - const ScoringSheet& player2_scoring_sheet = scoring_sheets_[1]; - if (player2_scoring_sheet.ones == empty || - player2_scoring_sheet.twos == empty || - player2_scoring_sheet.threes == empty || - player2_scoring_sheet.fours == empty || - player2_scoring_sheet.fives == empty || - player2_scoring_sheet.sixes == empty || - player2_scoring_sheet.full_house == empty || - player2_scoring_sheet.four_of_a_kind == empty || - player2_scoring_sheet.little_straight == empty || - player2_scoring_sheet.big_straight == empty || - player2_scoring_sheet.choice == empty || - player2_scoring_sheet.yacht == empty) { - return false; - } - - return true; -} - -std::vector YachtState::Returns() const { return {1, 0}; } - -std::unique_ptr YachtState::Clone() const { - return std::unique_ptr(new YachtState(*this)); -} - -void YachtState::SetState(int cur_player, const std::vector& dice, - const std::vector& dice_to_reroll, - const std::vector& scores, - const std::vector& scoring_sheets) { - cur_player_ = cur_player; - dice_ = dice; - dice_to_reroll_ = dice_to_reroll; - scores_ = scores; - scoring_sheets_ = scoring_sheets; -} - -YachtGame::YachtGame(const GameParameters& params) : Game(kGameType, params) {} - -} // namespace yacht -} // namespace open_spiel diff --git a/open_spiel/games/yacht/yacht.h b/open_spiel/games/yacht/yacht.h deleted file mode 100644 index 9f5d10df7a..0000000000 --- a/open_spiel/games/yacht/yacht.h +++ /dev/null @@ -1,193 +0,0 @@ -// Copyright 2019 DeepMind Technologies Limited -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#ifndef OPEN_SPIEL_GAMES_YACHT_H_ -#define OPEN_SPIEL_GAMES_YACHT_H_ - -#include -#include -#include -#include - -#include "open_spiel/abseil-cpp/absl/types/optional.h" -#include "open_spiel/game_parameters.h" -#include "open_spiel/spiel.h" -#include "open_spiel/spiel_utils.h" - -namespace open_spiel { -namespace yacht { - -inline constexpr const int kNumPlayers = 2; -inline constexpr const int kNumChanceOutcomes = 6; -inline constexpr const int kNumPoints = 24; -inline constexpr const int kNumDiceOutcomes = 6; -inline constexpr const int kMinUtility = -1; -inline constexpr const int kMaxUtility = 1; -inline constexpr const int kPlayerId1 = 1; -inline constexpr const int kPlayerId2 = 2; - -inline constexpr const int kNumDistinctActions = 1; - -class YachtGame; - -enum CategoryValue { empty, scratched, filled }; - -class ScoringSheet { - public: - CategoryValue ones = empty; - CategoryValue twos = empty; - CategoryValue threes = empty; - CategoryValue fours = empty; - CategoryValue fives = empty; - CategoryValue sixes = empty; - CategoryValue full_house = empty; - CategoryValue four_of_a_kind = empty; - CategoryValue little_straight = empty; - CategoryValue big_straight = empty; - CategoryValue choice = empty; - CategoryValue yacht = empty; -}; - -// Possible Actions: - -// 0: done choosing dice to reroll -constexpr int kPass = 0; - -// 1: choose die 1 to be rerolled -// 2: choose die 2 to be rerolled -// 3: choose die 3 to be rerolled -// 4: choose die 4 to be rerolled -// 5: choose die 5 to be rerolled - -constexpr int kFillOnes = 6; -constexpr int kFillTwos = 7; -constexpr int kFillThrees = 8; -constexpr int kFillFours = 9; -constexpr int kFillFives = 10; -constexpr int kFillSixes = 11; -constexpr int kFillFullHouse = 12; -constexpr int kFillFourOfAKind = 13; -constexpr int kFillLittleStraight = 14; -constexpr int kFillBigStraight = 15; -constexpr int kFillChoice = 16; -constexpr int kFillYacht = 17; - -constexpr int kScratchOnes = 18; -constexpr int kScratchTwos = 19; -constexpr int kScratchThrees = 20; -constexpr int kScratchFours = 21; -constexpr int kScratchFives = 22; -constexpr int kScratchSixes = 23; -constexpr int kScratchFullHouse = 24; -constexpr int kScratchFourOfAKind = 25; -constexpr int kScratchLittleStraight = 26; -constexpr int kScratchBigStraight = 27; -constexpr int kScratchChoice = 28; -constexpr int kScratchYacht = 29; - -class YachtState : public State { - public: - YachtState(const YachtState&) = default; - YachtState(std::shared_ptr); - - Player CurrentPlayer() const override; - std::vector LegalActions() const override; - std::string ActionToString(Player player, Action move_id) const override; - std::vector> ChanceOutcomes() const override; - std::string ToString() const override; - bool IsTerminal() const override; - std::vector Returns() const override; - std::string ObservationString(Player player) const override; - std::unique_ptr Clone() const override; - - // Setter function used for debugging and tests. Note: this does not set the - // historical information properly, so Undo likely will not work on states - // set this way! - void SetState(int cur_player, const std::vector& dice, - const std::vector& dice_to_reroll, - const std::vector& scores, - const std::vector& scoring_sheets); - - // Returns the opponent of the specified player. - int Opponent(int player) const; - - // Accessor functions for some of the specific data. - int player_turns() const { return turns_; } - int score(int player) const { return scores_[player]; } - ScoringSheet scoring_sheet(int player) const { - return scoring_sheets_[player]; - } - int dice(int i) const { return dice_[i]; } - - void ApplyNormalAction(Action move, int player); - - protected: - void DoApplyAction(Action move_id) override; - - private: - void RollDie(int outcome); - void IncrementTurn(); - bool IsPosInHome(int player, int pos) const; - bool UsableDiceOutcome(int outcome) const; - std::string ScoringSheetToString(const ScoringSheet& scoring_sheet) const; - std::string DiceToString(int outcome) const; - int DiceValue(int i) const; - - Player cur_player_; - Player prev_player_; - int turns_; - int player1_turns_; - int player2_turns_; - std::vector dice_; // Current dice. - - // Dice chosen to reroll. Where index i represents if that die will be - // rerolled, false not rerolled, true will be rerolled. - std::vector dice_to_reroll_ = {false, false, false, - false, false, false}; - - std::vector scores_; // Score for each player. - std::vector scoring_sheets_; // Scoring sheet for each player. -}; - -class YachtGame : public Game { - public: - explicit YachtGame(const GameParameters& params); - - int NumDistinctActions() const override { return kNumDistinctActions; } - - std::unique_ptr NewInitialState() const override { - return std::unique_ptr(new YachtState(shared_from_this())); - } - - // Model multiple dice rolls as a sequence of chance outcomes, so max - // chance outcomes is ways 6. - int MaxChanceOutcomes() const override { return kNumChanceOutcomes; } - - // There is arbitrarily chosen number to ensure the game is finite. - int MaxGameLength() const override { return 1000; } - - // Upper bound: chance node per move, with an initial chance node for - // determining starting player. - int MaxChanceNodesInHistory() const override { return MaxGameLength() + 1; } - - int NumPlayers() const override { return 2; } - double MinUtility() const override { return kMinUtility; } - absl::optional UtilitySum() const override { return 0; } - double MaxUtility() const override { return kMaxUtility; }; -}; - -} // namespace yacht -} // namespace open_spiel - -#endif // OPEN_SPIEL_GAMES_YACHT_H_ diff --git a/open_spiel/games/yacht/yacht_test.cc b/open_spiel/games/yacht/yacht_test.cc deleted file mode 100644 index 82dffc34d7..0000000000 --- a/open_spiel/games/yacht/yacht_test.cc +++ /dev/null @@ -1,111 +0,0 @@ -// Copyright 2019 DeepMind Technologies Limited -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "open_spiel/games/yacht/yacht.h" - -#include -#include - -#include "open_spiel/spiel.h" -#include "open_spiel/spiel_utils.h" - -namespace open_spiel { -namespace yacht { -namespace { - -void AllActionsLegalTest() { - std::shared_ptr game = LoadGame("yacht"); - std::unique_ptr state = game->NewInitialState(); - YachtState* yacht_state = static_cast(state.get()); - - std::vector dice_to_reroll = {false, false, false, false, false, false}; - std::vector empty_scoring_sheets = {ScoringSheet(), - ScoringSheet()}; - yacht_state->SetState(0, {}, dice_to_reroll, {}, empty_scoring_sheets); - - std::vector actions = yacht_state->LegalActions(); - std::vector expected_actions = {1, 2, 3, 4, 5, 6, 0}; - - SPIEL_CHECK_EQ(actions, expected_actions); -} - -void SomeActionsLegalTest() { - std::shared_ptr game = LoadGame("yacht"); - std::unique_ptr state = game->NewInitialState(); - YachtState* yacht_state = static_cast(state.get()); - - // Have some dice already selected to be re-rolled - std::vector dice_to_reroll = {false, true, false, true, false, false}; - std::vector empty_scoring_sheets = {ScoringSheet(), - ScoringSheet()}; - yacht_state->SetState(0, {}, dice_to_reroll, {}, empty_scoring_sheets); - - std::vector actions = yacht_state->LegalActions(); - std::vector expected_actions = {1, 3, 5, 6, 0}; - - SPIEL_CHECK_EQ(actions, expected_actions); -} - -void NoReRollActionsLegalTest() { - std::shared_ptr game = LoadGame("yacht"); - std::unique_ptr state = game->NewInitialState(); - YachtState* yacht_state = static_cast(state.get()); - - // Have some dice already selected to be re-rolled - std::vector dice_to_reroll = {true, true, true, true, true, true}; - std::vector empty_scoring_sheets = {ScoringSheet(), - ScoringSheet()}; - yacht_state->SetState(0, {}, dice_to_reroll, {}, empty_scoring_sheets); - - std::vector actions = yacht_state->LegalActions(); - // Can choose to be done re-rolled at anytime. - std::vector expected_actions = {0}; - - SPIEL_CHECK_EQ(actions, expected_actions); -} - -void ScoreOnesTest() { - std::shared_ptr game = LoadGame("yacht"); - std::unique_ptr state = game->NewInitialState(); - YachtState* yacht_state = static_cast(state.get()); - - std::vector dice_to_reroll = {false, false, false, false, false, false}; - std::vector empty_scoring_sheets = {ScoringSheet(), - ScoringSheet()}; - std::vector dice = {1, 1, 2, 3, 4}; - std::vector scores = {0, 0}; - yacht_state->SetState(kPlayerId1, dice, dice_to_reroll, scores, - empty_scoring_sheets); - - int player1_index = kPlayerId1 - 1; - yacht_state->ApplyNormalAction(kFillOnes, player1_index); - - int expected_score = 2; - SPIEL_CHECK_EQ(yacht_state->score(player1_index), expected_score); - - CategoryValue expected_ones_filled = filled; - SPIEL_CHECK_EQ(yacht_state->scoring_sheet(player1_index).ones, - expected_ones_filled); -} - -} // namespace -} // namespace yacht -} // namespace open_spiel - -int main(int argc, char** argv) { - open_spiel::yacht::AllActionsLegalTest(); - open_spiel::yacht::SomeActionsLegalTest(); - open_spiel::yacht::NoReRollActionsLegalTest(); - open_spiel::yacht::ScoreOnesTest(); -} diff --git a/open_spiel/python/tests/games_sim_test.py b/open_spiel/python/tests/games_sim_test.py index 82835b25e3..114f95d287 100644 --- a/open_spiel/python/tests/games_sim_test.py +++ b/open_spiel/python/tests/games_sim_test.py @@ -40,7 +40,7 @@ # A list of games to exclude from the general simulation tests. This should # remain empty, but it is helpful to use while a game is under construction. -SPIEL_EXCLUDE_SIMS_TEST_GAMES_LIST = ["yacht"] +SPIEL_EXCLUDE_SIMS_TEST_GAMES_LIST = [] # TODO(b/141950198): Stop hard-coding the number of loadable games. assert len(SPIEL_LOADABLE_GAMES_LIST) >= 38, len(SPIEL_LOADABLE_GAMES_LIST)