def main(_):
games_list = pyspiel.registered_games()
print("Registered games:")
for game in games_list:
print(" ", game.short_name)
print()
print("Creating game:", FLAGS.game)
params = {}
if FLAGS.players is not None:
params["players"] = FLAGS.players
game = pyspiel.load_game(FLAGS.game, params)
print("Getting all states; depth_limit = {}".format(FLAGS.depth_limit))
all_states = get_all_states.get_all_states(game, FLAGS.depth_limit,
FLAGS.include_terminals,
FLAGS.include_chance_states)
count = 0
for state in all_states:
print(state)
count += 1
print()
print("Total: {} states.".format(count))
def main(_):
games_list = pyspiel.registered_games()
print("Registered games:")
print(games_list)
print("Creating game: " + FLAGS.game)
if FLAGS.players is not None:
# If passing parameters, must use game creator.
game = pyspiel.load_game(
FLAGS.game, {"players": pyspiel.GameParameter(FLAGS.players)})
else:
# Otherwise can create directly.
game = pyspiel.load_game(FLAGS.game)
print("Getting all states; depth_limit = {}".format(FLAGS.depth_limit))
all_states = get_all_states.get_all_states(game, FLAGS.depth_limit,
FLAGS.include_terminals,
FLAGS.include_chance_states)
count = 0
for state in all_states:
print("")
print(str(state))
count += 1
print("")
print("Total: {} states.".format(count))
def test_registered_game_attributes(self):
games = {game.short_name: game for game in pyspiel.registered_games()}
self.assertEqual(games["kuhn_poker"].dynamics,
pyspiel.GameType.Dynamics.SEQUENTIAL)
self.assertEqual(games["kuhn_poker"].chance_mode,
pyspiel.GameType.ChanceMode.EXPLICIT_STOCHASTIC)
self.assertEqual(games["kuhn_poker"].information,
pyspiel.GameType.Information.IMPERFECT_INFORMATION)
self.assertEqual(games["kuhn_poker"].utility,
pyspiel.GameType.Utility.ZERO_SUM)
self.assertEqual(games["kuhn_poker"].min_num_players, 2)
def main(_):
games_list = pyspiel.registered_games()
print("Registered games:")
print(games_list)
# Load a two-player normal-form game as a two-player matrix game.
blotto_matrix_game = pyspiel.load_matrix_game("blotto")
print(
"Number of rows in 2-player Blotto with default settings is {}".format(
blotto_matrix_game.num_rows()))
# Several ways to load/create the same game of matching pennies.
print("Creating matrix game...")
game = pyspiel.load_matrix_game("matrix_mp")
game = _manually_create_game()
game = _import_data_create_game()
game = _easy_create_game()
game = _even_easier_create_game()
# Quick test: inspect top-left utility values:
print("Values for joint action ({},{}) is {},{}".format(
game.row_action_name(0), game.col_action_name(0),
game.player_utility(0, 0, 0), game.player_utility(1, 0, 0)))
state = game.new_initial_state()
# Print the initial state
print("State:")
print(str(state))
assert state.is_simultaneous_node()
# Simultaneous node: sample actions for all players.
chosen_actions = [
random.choice(state.legal_actions(pid))
for pid in range(game.num_players())
]
print("Chosen actions: ", [
state.action_to_string(pid, action)
for pid, action in enumerate(chosen_actions)
])
state.apply_actions(chosen_actions)
assert state.is_terminal()
# Game is now done. Print utilities for each player
returns = state.returns()
for pid in range(game.num_players()):
print("Utility for player {} is {}".format(pid, returns[pid]))
def test_no_mandatory_parameters(self):
# Games with mandatory parameters will be skipped by several standard
# tests. Mandatory parameters should therefore be avoided if at all
# possible. We make a list of such games here in order to make implementors
# think twice about adding mandatory parameters.
def has_mandatory_params(game):
return any(param.is_mandatory()
for param in game.parameter_specification.values())
games_with_mandatory_parameters = [
game.short_name for game in pyspiel.registered_games()
if has_mandatory_params(game)
]
expected = [
# Mandatory parameters prevent various sorts of automated testing.
# Only add games here if there is no sensible default for a parameter.
"misere",
"turn_based_simultaneous_game",
]
self.assertCountEqual(games_with_mandatory_parameters, expected)
def teste_default_loadable(self):
# Games which cannmot be loaded with default parameters will be skipped by
# several standard tests. We make a list of such games here in order to make
# implementors think twice about making new games non-default-loadable
non_default_loadable = [
game.short_name for game in pyspiel.registered_games()
if not game.default_loadable
]
expected = [
# Being non-default-loadable prevents various automated tests.
# Only add games here if there is no sensible default for a parameter.
"efg_game",
"nfg_game",
"misere",
"turn_based_simultaneous_game",
"normal_form_extensive_game",
"repeated_game",
"start_at",
]
self.assertCountEqual(non_default_loadable, expected)
def main(_):
if FLAGS.games == "*":
games_list = [
game.short_name
for game in pyspiel.registered_games()
if game.default_loadable
]
else:
games_list = FLAGS.games.split(";")
logging.info("Running benchmark for %s games.", len(games_list))
logging.info("This will take approximately %d seconds.",
len(games_list) * FLAGS.time_limit)
game_stats = []
for game_name in games_list:
logging.info("Running benchmark on %s", game_name)
game_stats.append(
_rollout_until_timeout(game_name, FLAGS.time_limit, FLAGS.give_up_after,
FLAGS.if_simultaneous_convert_to_turn_based))
with pd.option_context("display.max_rows", None,
"display.max_columns", None,
"display.width", 200):
df = pd.DataFrame(game_stats)
# Use nice header names.
df.rename(columns={
"game_name": "Game",
"ms_per_rollouts": "msec/rollout",
"ms_per_moves": "msec/move",
"giveups_per_rollout": "Give ups/rollouts",
"time_elapsed": "Time elapsed [sec]"
}, inplace=True)
print("---")
print("Results for following benchmark configuration:")
print("time_limit =", FLAGS.time_limit)
print("give_up_after =", FLAGS.give_up_after)
print("---")
print(df)
import collections
import logging
import random
import time
import unittest
from absl.testing import absltest
from absl.testing import parameterized
import numpy as np
from open_spiel.python.algorithms import get_all_states
import pyspiel
_ALL_GAMES = pyspiel.registered_games()
_GAMES_TO_TEST = [g.short_name for g in _ALL_GAMES if g.default_loadable]
_GAMES_NOT_UNDER_TEST = [
g.short_name for g in _ALL_GAMES if not g.default_loadable
]
# The list of game instances to test on the full tree as tuples
# (name to display, string to pass to load_game).
_GAMES_FULL_TREE_TRAVERSAL_TESTS = [
("catch", "catch(rows=6,columns=3)"),
("cliff_walking", "cliff_walking(horizon=7)"),
("deep_sea", "deep_sea(size=3)"),
("kuhn_poker", "kuhn_poker"),
("leduc_poker", "leduc_poker"),
import pickle
from absl import app
from absl.testing import absltest
from absl.testing import parameterized
import numpy as np
from open_spiel.python import games # pylint: disable=unused-import
import pyspiel
from open_spiel.python.utils import file_utils
# Put a bound on length of game so test does not timeout.
MAX_ACTIONS_PER_GAME = 1000
# All games registered in the main spiel library.
SPIEL_GAMES_LIST = pyspiel.registered_games()
# All games loadable without parameter values.
SPIEL_LOADABLE_GAMES_LIST = [g for g in SPIEL_GAMES_LIST if g.default_loadable]
# TODO(b/141950198): Stop hard-coding the number of loadable games.
assert len(SPIEL_LOADABLE_GAMES_LIST) >= 38, len(SPIEL_LOADABLE_GAMES_LIST)
# All simultaneous games.
SPIEL_SIMULTANEOUS_GAMES_LIST = [
g for g in SPIEL_LOADABLE_GAMES_LIST
if g.dynamics == pyspiel.GameType.Dynamics.SIMULTANEOUS
]
assert len(SPIEL_SIMULTANEOUS_GAMES_LIST) >= 14, len(
SPIEL_SIMULTANEOUS_GAMES_LIST)
def main(_):
games_list = pyspiel.registered_games()
print("Registered games:")
print(games_list)
action_string = None
print("Creating game: " + FLAGS.game)
if FLAGS.players is not None:
game = pyspiel.load_game(
FLAGS.game, {"players": pyspiel.GameParameter(FLAGS.players)})
else:
game = pyspiel.load_game(FLAGS.game)
# Get a new state
if FLAGS.load_state is not None:
# Load a specific state
state_string = ""
with open(FLAGS.load_state, encoding="utf-8") as input_file:
for line in input_file:
state_string += line
state_string = state_string.rstrip()
print("Loading state:")
print(state_string)
print("")
state = game.deserialize_state(state_string)
else:
state = game.new_initial_state()
# Print the initial state
print(str(state))
while not state.is_terminal():
# The state can be three different types: chance node,
# simultaneous node, or decision node
if state.is_chance_node():
# Chance node: sample an outcome
outcomes = state.chance_outcomes()
num_actions = len(outcomes)
print("Chance node, got " + str(num_actions) + " outcomes")
action_list, prob_list = zip(*outcomes)
action = np.random.choice(action_list, p=prob_list)
print("Sampled outcome: ",
state.action_to_string(state.current_player(), action))
state.apply_action(action)
elif state.is_simultaneous_node():
# Simultaneous node: sample actions for all players.
chosen_actions = [
random.choice(state.legal_actions(pid))
for pid in range(game.num_players())
]
print("Chosen actions: ", [
state.action_to_string(pid, action)
for pid, action in enumerate(chosen_actions)
])
state.apply_actions(chosen_actions)
else:
# Decision node: sample action for the single current player
action = random.choice(state.legal_actions(state.current_player()))
action_string = state.action_to_string(state.current_player(),
action)
print("Player ", state.current_player(),
", randomly sampled action: ", action_string)
state.apply_action(action)
print(str(state))
# Game is now done. Print utilities for each player
returns = state.returns()
for pid in range(game.num_players()):
print("Utility for player {} is {}".format(pid, returns[pid]))
def registered_games():
return pyspiel.registered_games()
from __future__ import division
from __future__ import print_function
import random
import unittest
from absl.testing import absltest
from absl.testing import parameterized
import numpy as np
from open_spiel.python.algorithms import get_all_states
import pyspiel
_GAMES_TO_TEST = [
g.short_name for g in pyspiel.registered_games() if g.default_loadable
]
# The list of game instances to test on the full tree as tuples
# (name to display, string to pass to load_game).
_GAMES_FULL_TREE_TRAVERSAL_TESTS = [
("catch", "catch(rows=6,columns=3)"),
("cliff_walking", "cliff_walking(horizon=7)"),
("deep_sea", "deep_sea(size=3)"),
("kuhn_poker", "kuhn_poker"),
("leduc_poker", "leduc_poker"),
("iigoofspiel4", "turn_based_simultaneous_game(game=goofspiel("
"imp_info=True,num_cards=4,points_order=descending))"),
("kuhn_poker3p", "kuhn_poker(players=3)"),
("first_sealed_auction", "first_sealed_auction(max_value=2)"),
("tiny_hanabi", "tiny_hanabi"),
import pyspiel
for game in pyspiel.registered_games():
print(game)
def list_games(): return [game.short_name for game in pyspiel.registered_games()]