def __init__(self, game):
self.game = game
self.turn_ordered_players = game.get_player_decks(
sort_by_turn_order=True)
self.supply = ConvertibleDefaultDict(value_type=int)
num_players = len(game.get_player_decks())
for cardinst in set(EVERY_SET_CARDS + game.get_supply()):
self.supply[cardinst] = cardinst.num_copies_per_game(num_players)
self.player_decks = ConvertibleDefaultDict(
value_type=lambda: ConvertibleDefaultDict(int))
self.player_start_decks = ConvertibleDefaultDict(
value_type=lambda: ConvertibleDefaultDict(int))
self.player_vp_tokens = collections.defaultdict(int)
if game.player_start_decks is None:
self.supply[dominioncards.Copper] = self.supply[dominioncards.Copper] - (len(self.turn_ordered_players) * 7)
for player in self.turn_ordered_players:
self.player_decks[player.name()][dominioncards.Copper] = 7
self.player_decks[player.name()][dominioncards.Estate] = 3
else:
for start_deck in game.player_start_decks:
for card in start_deck[START_DECK]:
self.supply[dominioncards.index_to_card(card)] -= 1
self.player_decks[start_deck[NAME]][dominioncards.index_to_card(card)] += 1
self.turn_ind = 0
class GameState(object):
def __init__(self, game):
self.game = game
self.turn_ordered_players = game.get_player_decks(
sort_by_turn_order=True)
self.supply = ConvertibleDefaultDict(value_type=int)
num_players = len(game.get_player_decks())
for card in itertools.chain(card_info.EVERY_SET_CARDS,
game.get_supply()):
self.supply[card] = card_info.num_copies_per_game(card,
num_players)
self.player_decks = ConvertibleDefaultDict(
value_type=lambda: ConvertibleDefaultDict(int))
self.supply['Copper'] = self.supply['Copper'] - (
len(self.turn_ordered_players) * 7)
for player in self.turn_ordered_players:
self.player_decks[player.Name()]['Copper'] = 7
self.player_decks[player.Name()]['Estate'] = 3
def get_deck_composition(self, player):
return self.player_decks[player]
def encode_game_state(self):
return {'supply': self.supply.to_primitive_object(),
'player_decks': self.player_decks.to_primitive_object()}
def _take_turn(self, turn):
def apply_diff(cards, name, supply_dir, deck_dir):
for card in cards:
self.supply[card] += supply_dir
self.player_decks[name][card] += deck_dir
for deck_change in turn.deck_changes():
apply_diff(deck_change.buys + deck_change.gains,
deck_change.name, -1, 1)
apply_diff(deck_change.trashes, deck_change.name, 0, -1)
apply_diff(deck_change.returns, deck_change.name, 1, -1)
def __iter__(self):
yield self
for turn in self.game.get_turns():
self._take_turn(turn)
yield self
def __init__(self, game):
self.game = game
self.turn_ordered_players = game.get_player_decks(sort_by_turn_order=True)
self.supply = ConvertibleDefaultDict(value_type=int)
num_players = len(game.get_player_decks())
for card in itertools.chain(card_info.EVERY_SET_CARDS, game.get_supply()):
self.supply[card] = card_info.num_copies_per_game(card, num_players)
self.player_decks = ConvertibleDefaultDict(value_type=lambda: ConvertibleDefaultDict(int))
self.player_vp_tokens = collections.defaultdict(int)
self.supply["Copper"] = self.supply["Copper"] - (len(self.turn_ordered_players) * 7)
for player in self.turn_ordered_players:
self.player_decks[player.name()]["Copper"] = 7
self.player_decks[player.name()]["Estate"] = 3
self.turn_ind = 0
def __init__(self, game):
self.game = game
self.turn_ordered_players = sorted(game.PlayerDecks(),
key = PlayerDeck.TurnOrder)
self.supply = ConvertibleDefaultDict(value_type = int)
num_players = len(game.PlayerDecks())
for card in itertools.chain(card_info.EVERY_SET_CARDS, game.Supply()):
self.supply[card] = card_info.NumCopiesPerGame(card, num_players)
self.player_decks = ConvertibleDefaultDict(
value_type = lambda: ConvertibleDefaultDict(int))
self.supply['Copper'] = self.supply['Copper'] - (
len(self.turn_ordered_players) * 7)
for player in self.turn_ordered_players:
self.player_decks[player.Name()]['Copper'] = 7
self.player_decks[player.Name()]['Estate'] = 3
class GameState:
def __init__(self, game):
self.game = game
self.turn_ordered_players = sorted(game.PlayerDecks(),
key = PlayerDeck.TurnOrder)
self.supply = ConvertibleDefaultDict(value_type = int)
num_players = len(game.PlayerDecks())
for card in itertools.chain(card_info.EVERY_SET_CARDS, game.Supply()):
self.supply[card] = card_info.NumCopiesPerGame(card, num_players)
self.player_decks = ConvertibleDefaultDict(
value_type = lambda: ConvertibleDefaultDict(int))
self.supply['Copper'] = self.supply['Copper'] - (
len(self.turn_ordered_players) * 7)
for player in self.turn_ordered_players:
self.player_decks[player.Name()]['Copper'] = 7
self.player_decks[player.Name()]['Estate'] = 3
def GetDeckComposition(self, player):
return self.player_decks[player]
def EncodeGameState(self):
return {'supply': self.supply.ToPrimitiveObject(),
'player_decks': self.player_decks.ToPrimitiveObject()}
def _TakeTurn(self, turn):
def ApplyDiff(cards, name, supply_dir, deck_dir):
for card in cards:
self.supply[card] += supply_dir
self.player_decks[name][card] += deck_dir
for deck_change in turn.DeckChanges():
ApplyDiff(deck_change.buys + deck_change.gains,
deck_change.name, -1, 1)
ApplyDiff(deck_change.trashes, deck_change.name, 0, -1)
ApplyDiff(deck_change.returns, deck_change.name, 1, -1)
def __iter__(self):
yield self
for turn in self.game.Turns():
self._TakeTurn(turn)
yield self
def __init__(self, game):
self.game = game
self.turn_ordered_players = game.get_player_decks(
sort_by_turn_order=True)
self.supply = ConvertibleDefaultDict(value_type=int)
num_players = len(game.get_player_decks())
for cardinst in itertools.chain(EVERY_SET_CARDS, game.get_supply()):
self.supply[cardinst] = cardinst.num_copies_per_game(num_players)
self.player_decks = ConvertibleDefaultDict(
value_type=lambda: ConvertibleDefaultDict(int))
self.player_vp_tokens = collections.defaultdict(int)
self.supply[dominioncards.Copper] = self.supply[
dominioncards.Copper] - (len(self.turn_ordered_players) * 7)
for player in self.turn_ordered_players:
self.player_decks[player.name()][dominioncards.Copper] = 7
self.player_decks[player.name()][dominioncards.Estate] = 3
self.turn_ind = 0
def __init__(self):
self.card_stats = ConvertibleDefaultDict(CardStatistic)
self.num_games = 0
self.max_game_id = ''
def __init__(self):
self.available = 0
self.win_any_accum = MeanVarStat()
self.win_weighted_accum = MeanVarStat()
self.win_weighted_accum_turn = ConvertibleDefaultDict(MeanVarStat, int)
self.win_diff_accum = ConvertibleDefaultDict(MeanVarStat, int)
class GameState(object):
def __init__(self, game):
self.game = game
self.turn_ordered_players = game.get_player_decks(
sort_by_turn_order=True)
self.supply = ConvertibleDefaultDict(value_type=int)
num_players = len(game.get_player_decks())
for card in itertools.chain(card_info.EVERY_SET_CARDS,
game.get_supply()):
self.supply[card] = card_info.num_copies_per_game(card,
num_players)
self.player_decks = ConvertibleDefaultDict(
value_type=lambda: ConvertibleDefaultDict(int))
self.player_vp_tokens = collections.defaultdict(int)
self.supply['Copper'] = self.supply['Copper'] - (
len(self.turn_ordered_players) * 7)
for player in self.turn_ordered_players:
self.player_decks[player.name()]['Copper'] = 7
self.player_decks[player.name()]['Estate'] = 3
self.turn_ind = 0
def get_deck_composition(self, player):
return self.player_decks[player]
def player_score(self, player_name):
return (score_deck(self.player_decks[player_name]) +
self.player_vp_tokens[player_name])
def encode_game_state(self):
scores = {}
for name in self.player_decks:
scores[name] = self.player_score(name)
ret = {
'supply': self.supply.to_primitive_object(),
'player_decks': self.player_decks.to_primitive_object(),
'scores': scores,
'label': self.turn_label(),
'display_label': self.turn_label(for_display=True),
'player': self.cur_turn.player.name() if self.cur_turn else '',
'money': self.cur_turn.money() if self.cur_turn else 0,
'turn_no': self.cur_turn.turn_no if self.cur_turn else
self.game.get_turns()[-1].turn_no + 1
}
return ret
def _player_at_turn_ind(self, given_turn_ind):
return self.game.get_turns()[given_turn_ind].get_player()
def player_turn_order(self):
ret = []
l = len(self.turn_ordered_players)
offset = self.turn_ind % l
for i in range(l):
ret.append(self.turn_ordered_players[(i + offset) % l].name())
return ret
def turn_index(self):
return self.turn_ind
def _take_turn(self, turn):
def apply_diff(cards, name, supply_dir, deck_dir):
for card in cards:
self.supply[card] += supply_dir
self.player_decks[name][card] += deck_dir
for deck_change in turn.deck_changes():
apply_diff(deck_change.buys + deck_change.gains,
deck_change.name, -1, 1)
apply_diff(deck_change.trashes, deck_change.name, 0, -1)
apply_diff(deck_change.returns, deck_change.name, 1, -1)
self.player_vp_tokens[deck_change.name] += deck_change.vp_tokens
def turn_label(self, for_anchor=False, for_display=False):
if not self.cur_turn:
return 'end-game'
return self.cur_turn.turn_label(for_anchor, for_display)
def __iter__(self):
self.turn_ind = 0
self.cur_turn = self.game.get_turns()[self.turn_ind]
yield self # this yield self crap is ugly, leads to bugs :(
for turn_ind, turn in enumerate(self.game.get_turns()):
self.turn_ind = turn_ind + 1
if self.turn_ind < len(self.game.get_turns()):
self.cur_turn = self.game.get_turns()[self.turn_ind]
else:
self.cur_turn = None
self._take_turn(turn)
yield self
def __init__(self):
self.final = ConvertibleDefaultDict(MeanVarStat)
self.progressive = ConvertibleDefaultDict(MeanVarStat)
class GameState(object):
def __init__(self, game):
self.game = game
self.turn_ordered_players = game.get_player_decks(
sort_by_turn_order=True)
self.supply = ConvertibleDefaultDict(value_type=int)
num_players = len(game.get_player_decks())
for card in itertools.chain(card_info.EVERY_SET_CARDS,
game.get_supply()):
self.supply[card] = card_info.num_copies_per_game(card,
num_players)
self.player_decks = ConvertibleDefaultDict(
value_type=lambda: ConvertibleDefaultDict(int))
self.player_vp_tokens = collections.defaultdict(int)
self.supply['Copper'] = self.supply['Copper'] - (
len(self.turn_ordered_players) * 7)
for player in self.turn_ordered_players:
self.player_decks[player.name()]['Copper'] = 7
self.player_decks[player.name()]['Estate'] = 3
self.turn_ind = 0
def get_deck_composition(self, player):
return self.player_decks[player]
def player_score(self, player_name):
return (score_deck(self.player_decks[player_name]) +
self.player_vp_tokens[player_name])
def encode_game_state(self):
scores = {}
for name in self.player_decks:
scores[name] = self.player_score(name)
ret = {
'supply': self.supply.to_primitive_object(),
'player_decks': self.player_decks.to_primitive_object(),
'scores': scores,
'label': self.turn_label(),
'display_label': self.turn_label(for_display=True),
'player': self.cur_turn.player.name() if self.cur_turn else '',
'money': self.cur_turn.money() if self.cur_turn else 0,
'turn_no': self.cur_turn.turn_no if self.cur_turn else
self.game.get_turns()[-1].turn_no + 1
}
return ret
def _player_at_turn_ind(self, given_turn_ind):
return self.game.get_turns()[given_turn_ind].get_player()
def player_turn_order(self):
ret = []
l = len(self.turn_ordered_players)
offset = self.turn_ind % l
for i in range(l):
ret.append(self.turn_ordered_players[(i + offset) % l].name())
return ret
def turn_index(self):
return self.turn_ind
def _take_turn(self, turn):
def apply_diff(cards, name, supply_dir, deck_dir):
for card in cards:
self.supply[card] += supply_dir
self.player_decks[name][card] += deck_dir
for deck_change in turn.deck_changes():
apply_diff(deck_change.buys + deck_change.gains,
deck_change.name, -1, 1)
apply_diff(deck_change.trashes, deck_change.name, 0, -1)
apply_diff(deck_change.returns, deck_change.name, 1, -1)
self.player_vp_tokens[deck_change.name] += deck_change.vp_tokens
def turn_label(self, for_anchor=False, for_display=False):
if not self.cur_turn:
return 'end-game'
return self.cur_turn.turn_label(for_anchor, for_display)
def __iter__(self):
self.turn_ind = 0
self.cur_turn = self.game.get_turns()[self.turn_ind]
yield self # this yield self crap is ugly, leads to bugs :(
for turn_ind, turn in enumerate(self.game.get_turns()):
self.turn_ind = turn_ind + 1
if self.turn_ind < len(self.game.get_turns()):
self.cur_turn = self.game.get_turns()[self.turn_ind]
else:
self.cur_turn = None
self._take_turn(turn)
yield self
