splendor.splendor package

Subpackages

• splendor.splendor.gym package
  • Subpackages
    • splendor.splendor.gym.envs package
      • Submodules
      • splendor.splendor.gym.envs.actions module
      • splendor.splendor.gym.envs.splendor_env module
      • splendor.splendor.gym.envs.utils module
      • Module contents
  • Module contents

Submodules

splendor.splendor.constants module

Useful constants regarding the game.

splendor.splendor.features module

Features extraction from SplendorState.

splendor.splendor.features.agent_buying_power(agent: AgentState) → dict[Literal['black', 'red', 'yellow', 'green', 'blue', 'white'], int]

Find the buying power of a specific agent.

Parameters:

agent – an agent.

Returns:

the agent buying power.

splendor.splendor.features.agent_won(agent: AgentState) → bool

Check if a given agent has won.

Parameters:

agent – an agent.

Returns:

whether or not the agent has won.

splendor.splendor.features.build_array(base_array: ndarray[Any, dtype[_ScalarType_co]], instruction: tuple[int, ...]) → ndarray[Any, dtype[_ScalarType_co]]

construct an np.array from given instructions.

splendor.splendor.features.diminish_return(value: int | float) → float

calculate the diminished return of a value.

Parameters:

value – a value.

Returns:

the calculated diminished value of the given value.

splendor.splendor.features.extract_cards(game_state: SplendorState, agent_index: int) → ndarray[Any, dtype[_ScalarType_co]]

Extract all the vector representations of the cards (both dealt & reserved).

Parameters:

• game_state – the state of the game - the dealt cards of this state would be encoded.

• agent_index – which agent’s reserved cards should be extracted.

Returns:

a vector of all the cards (both dealt & reserved - 15 in total), shape would be (15 * 13,). Each 13 entries slice corresponds to a card. The order of the cards is as follows: 1) the first 12 cards. 2) the 3 reserved cards.

Note:

the shape of the resulting vector is constant, rather than dependent upon the state. if for example there aren’t any reserved cards then the 3 reserved cards slots would be filled with zeros.

splendor.splendor.features.extract_metrics(game_state: SplendorState, agent_index: int) → ndarray[Any, dtype[_ScalarType_co]]

Extract metrics/features from a given state.

Parameters:

• game_state – a game state.

• agent_index – the index an agent.

Returns:

the extracted feature vector of that state.

splendor.splendor.features.extract_metrics_with_cards(game_state: SplendorState, agent_index: int) → ndarray[Any, dtype[_ScalarType_co]]

Extract metrics from state & encoded the cards as vectors.

Returns:

the long vector representing the full state, both it’s features and it’s cards.

splendor.splendor.features.extract_reserved_cards(game_state: SplendorState, agent_index: int) → list[ndarray[Any, dtype[_ScalarType_co]]]

Extract all the vector representations of the cards (only reserved).

Parameters:

• game_state – the state of the game.

• agent_index – which agent’s reserved cards should be extracted.

Returns:

a vector of all the reserved cards, shape would be (3 * 13,). Each 13 entries slice corresponds to a card.

Note:

the shape of the resulting vector is constant, rather than dependent upon the state. if for example there aren’t any reserved cards then the 3 reserved cards slots would be filled with zeros.

splendor.splendor.features.get_agent(game_state: SplendorState, agent_index: int) → AgentState

Extract the AgentState of a specific agent from the game state.

splendor.splendor.features.get_color_encoder() → OneHotEncoder

Return an encoder of all the colors (including yellow).

Note:

this function is cached in order to avoid re-creation of this encoder. however this means that we uses the same encoder. use with caution.

splendor.splendor.features.get_indices_access_by_color(color_name: str) → ndarray[Any, dtype[_ScalarType_co]]

convert gem’s color name to an indexing array.

splendor.splendor.features.get_yellow_gem_index() → int

Return the index of the yellow color within the one-hot representation of the colors.

splendor.splendor.features.missing_gems_to_card(card: Card, buying_power: dict[Literal['black', 'red', 'yellow', 'green', 'blue', 'white'], int]) → dict[Literal['black', 'red', 'yellow', 'green', 'blue', 'white'], int]

find how many gems are required in order to buy a specific card.

Parameters:

• card – a card up for purchase.

• buying_power – the current buying power.

Returns:

the required gems for purchasing that card.

splendor.splendor.features.normalize_metrics(metrics: ndarray[Any, dtype[_ScalarType_co]]) → ndarray[Any, dtype[_ScalarType_co]]

normalize the feature vector.

Parameters:

metrics – un-normalized features vector.

Returns:

normalized features vector.

splendor.splendor.features.turns_made_by_agent(agent: AgentState) → int

Extract the number of turns made by a given agent.

splendor.splendor.features.turns_to_buy_card(missing_gems: ValuesView[int]) → int

calculate an optimistic estimate for the amount of turns required in order to buy a card by collecting all the missing gems without any interference from the opponents.

Parameters:

missing_gems – the missing gems required to buy a card.

Returns:

an estimate on how many turns are required in order to collect all those gems.

splendor.splendor.features.vectorize_card(card: Card | None) → ndarray[Any, dtype[_ScalarType_co]]

Return the vector form a given card. This is required when supplying an agent such as the DQN or PPO with a representation of a state via features vector, that vector must also describe which cards are present.

Parameters:

card – a card to be vectorized.

Returns:

the vector representation of the given card.

Note:

this function can’t be cached since Card isn’t hashable…

splendor.splendor.splendor_displayer module

class splendor.splendor.splendor_displayer.AgentArea(root, agent_id, agent_title)

Bases: object

set_agent_title(score)

update(agent, resources)

class splendor.splendor.splendor_displayer.BoardArea(root)

Bases: object

update(state, resources, no_highlighting)

class splendor.splendor.splendor_displayer.GUIDisplayer(half_scale, delay=0.1, no_highlighting=False)

Bases: Displayer

EndGame(game_state, scores)

ExcuteAction(player_id, action, game_state)

InitDisplayer(runner)

TimeOutWarning(runner, id)

close_window()

end_fullscreen(event=None)

get_selection(event)

prime_action_box()

toggle_fullscreen(event=None)

user_input(actions)

class splendor.splendor.splendor_displayer.TextDisplayer

Bases: Displayer

EndGame(game_state, scores)

ExcuteAction(i, move, game_state)

InitDisplayer(runner)

StartRound(game_state)

TimeOutWarning(runner, id)

user_input(actions)

splendor.splendor.splendor_displayer.can_buy(agent, card)

splendor.splendor.splendor_displayer.make_label(master, x, y, h, w, *args, **kwargs)

splendor.splendor.splendor_model module

class splendor.splendor.splendor_model.Card(colour, code, cost, deck_id, points)

Bases: object

class splendor.splendor.splendor_model.SplendorGameRule(num_of_agent)

Bases: GameRule

calScore(game_state, agent_id)

gameEnds()

generatePredecessor(state, action, agent_id)

generateSuccessor(state, action, agent_id)

generate_return_combos(current_gems, collected_gems)

getLegalActions(game_state, agent_id)

initialGameState()

noble_visit(agent, noble)

resources_sufficient(agent, costs)

class splendor.splendor.splendor_model.SplendorState(num_agents)

Bases: GameState

class AgentState(_id)

Bases: object

class BoardState(num_agents)

Bases: object

deal(deck_id)

dealt_list()

splendor.splendor.splendor_utils module

splendor.splendor.splendor_utils.ActionToString(agent_id, action)

splendor.splendor.splendor_utils.AgentToString(agent_id, ps)

class splendor.splendor.splendor_utils.AgentTrace(pid)

Bases: object

splendor.splendor.splendor_utils.BoardToString(game_state)

splendor.splendor.splendor_utils.GemsToString(gem_dict)

splendor.splendor.splendor_utils.convert_filename(filename)

splendor.splendor.types module

define useful type hints.

class splendor.splendor.types.BuyAction

Bases: TypedDict

TypedDict for buying action.

card: Required[Card]

noble: Required[tuple[str, dict[Literal['black', 'red', 'yellow', 'green', 'blue', 'white'], int]]]

returned_gems: Required[dict[Literal['black', 'red', 'yellow', 'green', 'blue', 'white'], int]]

type: Required[Literal['buy_available', 'buy_reserve']]

class splendor.splendor.types.CollectAction

Bases: TypedDict

TypedDict for collecting gems action.

collected_gems: Required[dict[Literal['black', 'red', 'yellow', 'green', 'blue', 'white'], int]]

noble: Required[tuple[str, dict[Literal['black', 'red', 'yellow', 'green', 'blue', 'white'], int]]]

returned_gems: Required[dict[Literal['black', 'red', 'yellow', 'green', 'blue', 'white'], int]]

type: Required[Literal['collect_diff', 'collect_same']]

class splendor.splendor.types.ReserveAction

Bases: TypedDict

TypedDict for reserving a card action.

collected_gems: Required[YellowGemCount]

noble: Required[tuple[str, dict[Literal['black', 'red', 'yellow', 'green', 'blue', 'white'], int]]]

returned_gems: Required[dict[Literal['black', 'red', 'yellow', 'green', 'blue', 'white'], int]]

type: Required[Literal['reserve']]

class splendor.splendor.types.YellowGemCount

Bases: TypedDict

TypedDict for the yellow gems count.

yellow: Required[Literal[1] | None]

splendor.splendor.utils module

Useful utilities.

class splendor.splendor.utils.LimitRoundsGameRule(num_of_agent)

Bases: SplendorGameRule

Wraps SplendorGameRule.

gameEnds() → bool

Limits the game to ROUNDS_LIMIT rounds, so random initial agents won’t get stuck by accident.

Module contents