1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287

import collections
import pprint
from primitive_util import ConvertibleDefaultDict
import card_info
import itertools

WIN, LOSS, TIE = range(3)

class PlayerDeckChange:
    CATEGORIES = ['buys', 'gains', 'returns', 'trashes']

    def __init__(self, name):
        self.name = name
        # should I change this to using a dictionary of counts 
        # rather than a list?  Right now all the consumers ignore order,
        # but there is a similiar function specialized for accum in the
        # game class that uses a frequency dict.
        for cat in self.CATEGORIES:
            setattr(self, cat, [])

    def MergeChanges(self, other_changes):
        assert self.name == other_changes.name
        for cat in self.CATEGORIES:
            getattr(self, cat).extend(getattr(other_changes, cat))

class Turn:
    def __init__(self, turn_dict, game, player):
        self.game = game
        self.player = player
        self.plays = turn_dict.get('plays', [])
        self.gains = turn_dict.get('gains', [])
        self.buys = turn_dict.get('buys', [])
        self.turn_no = turn_dict['number']
        self.turn_dict = turn_dict

    def Player(self):
        return self.player

    def PlayerAccumulates(self):
        return self.buys + self.gains

    def TurnNo(self):
        return self.turn_no

    def DeckChanges(self):
        ret = []
        my_change = PlayerDeckChange(self.player.Name())
        ret.append(my_change)
        my_change.gains = self.gains
        my_change.buys = self.buys
        my_change.trashes = self.turn_dict.get('trashes', [])
        my_change.returns = self.turn_dict.get('returns', [])

        opp_info = self.turn_dict.get('opp', {})
        for opp_name, info_dict in opp_info.iteritems():
            change = PlayerDeckChange(opp_name)
            change.gains.extend(info_dict.get('gains', []))
            change.trashes.extend(info_dict.get('trashes', []))
            ret.append(change)

        return ret

class PlayerDeck:
    def __init__(self, player_deck_dict, game):
        self.raw_player = player_deck_dict
        self.game = game
        self.player_name = player_deck_dict['name']
        self.win_points = player_deck_dict['win_points']
        self.points = player_deck_dict['points']
        self.deck = player_deck_dict['deck']
        self.turn_order = player_deck_dict['order']

    def Name(self):
        return self.player_name

    def Points(self):
        return self.points

    def ShortRenderLine(self):
        return '%s %d<br>' % (self.Name(), self.Points())

    def WinPoints(self):
        return self.win_points

    def TurnOrder(self):
        return self.turn_order

    def Resigned(self):
        return self.raw_player['resigned']

    def Deck(self):
        return self.deck
    
    @staticmethod
    def PlayerLink(player_name, anchor_text = None):
        if anchor_text is None:
            anchor_text = player_name
        return '<a href="/player?player=%s">%s</a>' % (player_name, 
                                                       anchor_text)

    def GameResultColor(self, opp = None):
        # this should be implemented in turns of GameResult.WinLossTie()
        if self.WinPoints() > 1:
            return 'green'
        if (opp and opp.WinPoints() == self.WinPoints()) or (
            self.WinPoints() == 1):
            return '#555555'
        return 'red'

class Game:
    def __init__(self, game_dict):
        self.turns = []
        self.supply = game_dict['supply']
        # pprint.pprint(game_dict)

        self.player_decks = [PlayerDeck(pd, self) for pd in game_dict['decks']]
        self.id = game_dict.get('_id', 'unidentified')

        for raw_pd, pd in zip(game_dict['decks'], self.player_decks):
            for turn in raw_pd['turns']:
                self.turns.append(Turn(turn, game_dict, pd))
        self.turns.sort(key=lambda x: (x.TurnNo(), x.Player().TurnOrder()))

    def GetPlayerDeck(self, player_name):
        for p in self.player_decks:
            if p.Name() == player_name:
                return p
        assert ValueError, "%s not in players" % player_name

    def Turns(self):
        return self.turns

    def Supply(self):
        return self.supply

    def PlayerDecks(self):
        return self.player_decks

    def AllPlayerNames(self):
        return [pd.Name() for pd in self.player_decks]

    def WinningScore(self):
        return self.winning_score

    @staticmethod
    def DateFromId(game_id):
        yyyymmdd_date = game_id.split('-')[1]
        return yyyymmdd_date

    def Date(self):
	from datetime import datetime
	return datetime.strptime( Game.DateFromId(self.id), "%Y%m%d" )

    def Id(self):
        return self.id

    def IsotropicUrl(self):
        yyyymmdd_date = Game.DateFromId(self.id)
        return 'http://dominion.isotropic.org/gamelog/%s/%s/%s.gz' % (
            yyyymmdd_date[:6], yyyymmdd_date[-2:], self.id)

    @staticmethod
    def CouncilRoomOpenLinkFromId(game_id):
        return '<a href="/game?game_id=%s">' % game_id

    def CouncilRoomOpenLink(self):
        return self.CouncilRoomOpenLinkFromId(self.id)

    def DubiousQuality(self):
        num_players = len(set(pd.Name() for pd in self.PlayerDecks()))
        if num_players < len(self.PlayerDecks()): return True

        total_accumed_by_players = self.CardsAccumulatedPerPlayer()
        for player_name, accumed_dict in total_accumed_by_players.iteritems():
            if sum(accumed_dict.itervalues()) < 5:
                return True

        return False

    def WinLossTie(self, targ, other=None):
        targ_deck = self.GetPlayerDeck(targ)

        if other is None:
            other_win_points = 2 if targ_deck.WinPoints() == 0 else 0
        else:
            other_win_points = self.GetPlayerDeck(other).WinPoints()

        if targ_deck.WinPoints() > 1 and other_win_points < 1:
            return WIN
        if other_win_points > 1:
            return LOSS
        return TIE

    def TotalCardsAccumulated(self):
        ret = collections.defaultdict(int)
        for turn in self.Turns():
            for accumed_card in turn.PlayerAccumulates():
                ret[accumed_card] += 1
        return ret

    # TODO(rrenaud): Get rid of this, and use DeckChangesPerPlayer() instead?
    def CardsAccumulatedPerPlayer(self):
        if 'card_accum_cache' in self.__dict__:
            return self.card_accum_cache
        ret = dict((pd.Name(), collections.defaultdict(int)) for 
                   pd in self.PlayerDecks())
        for turn in self.Turns():
            for accumed_card in turn.PlayerAccumulates():
                ret[turn.Player().Name()][accumed_card] += 1
        self.card_accum_cache = ret
        return ret

    def DeckChangesPerPlayer(self):
        changes = {}
        for pd in self.PlayerDecks():
            changes[pd.Name()] = PlayerDeckChange(pd.Name())
        for turn in self.Turns():
            for change in turn.DeckChanges():
                changes[change.name].MergeChanges(change)
        return changes.values()

    def AnyResigned(self):
        return any(pd.Resigned() for pd in self.PlayerDecks())

    def ShortRenderCellWithPerspective(self, target_player, opp_player = None):
        target_deck = self.GetPlayerDeck(target_player)
        opp_deck = None
        if opp_player is not None:
            opp_deck = self.GetPlayerDeck(opp_player)
        color = target_deck.GameResultColor(opp_deck)

        ret = '<td>'
        ret += self.CouncilRoomOpenLink()
        ret += '<font color=%s>' % color
        ret += target_deck.ShortRenderLine()
        for player_deck in self.PlayerDecks():
            if player_deck != target_deck:
                ret += player_deck.ShortRenderLine()
        ret += '</font></a></td>'
        return ret

    def GameStateIterator(self):
        return GameState(self)
        
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 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