Demo/tkinter/guido/solitaire.py

   1 #! /usr/bin/env python
   2
   3 """Solitaire game, much like the one that comes with MS Windows.
   4
   5 Limitations:
   6
   7 - No cute graphical images for the playing cards faces or backs.
   8 - No scoring or timer.
   9 - No undo.
  10 - No option to turn 3 cards at a time.
  11 - No keyboard shortcuts.
  12 - Less fancy animation when you win.
  13 - The determination of which stack you drag to is more relaxed.
  14
  15 Apology:
  16
  17 I'm not much of a card player, so my terminology in these comments may
  18 at times be a little unusual.  If you have suggestions, please let me
  19 know!
  20
  21 """
  22
  23 # Imports
  24
  25 import math
  26 import random
  27
  28 from Tkinter import *
  29 from Canvas import Rectangle, CanvasText, Group, Window
  30
  31
  32 # Fix a bug in Canvas.Group as distributed in Python 1.4.  The
  33 # distributed bind() method is broken.  Rather than asking you to fix
  34 # the source, we fix it here by deriving a subclass:
  35
  36 class Group(Group):
  37     def bind(self, sequence=None, command=None):
  38         return self.canvas.tag_bind(self.id, sequence, command)
  39
  40
  41 # Constants determining the size and lay-out of cards and stacks.  We
  42 # work in a "grid" where each card/stack is surrounded by MARGIN
  43 # pixels of space on each side, so adjacent stacks are separated by
  44 # 2*MARGIN pixels.  OFFSET is the offset used for displaying the
  45 # face down cards in the row stacks.
  46
  47 CARDWIDTH = 100
  48 CARDHEIGHT = 150
  49 MARGIN = 10
  50 XSPACING = CARDWIDTH + 2*MARGIN
  51 YSPACING = CARDHEIGHT + 4*MARGIN
  52 OFFSET = 5
  53
  54 # The background color, green to look like a playing table.  The
  55 # standard green is way too bright, and dark green is way to dark, so
  56 # we use something in between.  (There are a few more colors that
  57 # could be customized, but they are less controversial.)
  58
  59 BACKGROUND = '#070'
  60
  61
  62 # Suits and colors.  The values of the symbolic suit names are the
  63 # strings used to display them (you change these and VALNAMES to
  64 # internationalize the game).  The COLOR dictionary maps suit names to
  65 # colors (red and black) which must be Tk color names.  The keys() of
  66 # the COLOR dictionary conveniently provides us with a list of all
  67 # suits (in arbitrary order).
  68
  69 HEARTS = 'Heart'
  70 DIAMONDS = 'Diamond'
  71 CLUBS = 'Club'
  72 SPADES = 'Spade'
  73
  74 RED = 'red'
  75 BLACK = 'black'
  76
  77 COLOR = {}
  78 for s in (HEARTS, DIAMONDS):
  79     COLOR[s] = RED
  80 for s in (CLUBS, SPADES):
  81     COLOR[s] = BLACK
  82
  83 ALLSUITS = COLOR.keys()
  84 NSUITS = len(ALLSUITS)
  85
  86
  87 # Card values are 1-13.  We also define symbolic names for the picture
  88 # cards.  ALLVALUES is a list of all card values.
  89
  90 ACE = 1
  91 JACK = 11
  92 QUEEN = 12
  93 KING = 13
  94 ALLVALUES = range(1, 14) # (one more than the highest value)
  95 NVALUES = len(ALLVALUES)
  96
  97
  98 # VALNAMES is a list that maps a card value to string.  It contains a
  99 # dummy element at index 0 so it can be indexed directly with the card
 100 # value.
 101
 102 VALNAMES = ["", "A"] + map(str, range(2, 11)) + ["J", "Q", "K"]
 103
 104
 105 # Solitaire constants.  The only one I can think of is the number of
 106 # row stacks.
 107
 108 NROWS = 7
 109
 110
 111 # The rest of the program consists of class definitions.  These are
 112 # further described in their documentation strings.
 113
 114
 115 class Card:
 116
 117     """A playing card.
 118
 119     A card doesn't record to which stack it belongs; only the stack
 120     records this (it turns out that we always know this from the
 121     context, and this saves a ``double update'' with potential for
 122     inconsistencies).
 123
 124     Public methods:
 125
 126     moveto(x, y) -- move the card to an absolute position
 127     moveby(dx, dy) -- move the card by a relative offset
 128     tkraise() -- raise the card to the top of its stack
 129     showface(), showback() -- turn the card face up or down & raise it
 130
 131     Public read-only instance variables:
 132
 133     suit, value, color -- the card's suit, value and color
 134     face_shown -- true when the card is shown face up, else false
 135
 136     Semi-public read-only instance variables (XXX should be made
 137     private):
 138
 139     group -- the Canvas.Group representing the card
 140     x, y -- the position of the card's top left corner
 141
 142     Private instance variables:
 143
 144     __back, __rect, __text -- the canvas items making up the card
 145
 146     (To show the card face up, the text item is placed in front of
 147     rect and the back is placed behind it.  To show it face down, this
 148     is reversed.  The card is created face down.)
 149
 150     """
 151
 152     def __init__(self, suit, value, canvas):
 153         """Card constructor.
 154
 155         Arguments are the card's suit and value, and the canvas widget.
 156
 157         The card is created at position (0, 0), with its face down
 158         (adding it to a stack will position it according to that
 159         stack's rules).
 160
 161         """
 162         self.suit = suit
 163         self.value = value
 164         self.color = COLOR[suit]
 165         self.face_shown = 0
 166
 167         self.x = self.y = 0
 168         self.group = Group(canvas)
 169
 170         text = "%s  %s" % (VALNAMES[value], suit)
 171         self.__text = CanvasText(canvas, CARDWIDTH/2, 0,
 172                                anchor=N, fill=self.color, text=text)
 173         self.group.addtag_withtag(self.__text)
 174
 175         self.__rect = Rectangle(canvas, 0, 0, CARDWIDTH, CARDHEIGHT,
 176                               outline='black', fill='white')
 177         self.group.addtag_withtag(self.__rect)
 178
 179         self.__back = Rectangle(canvas, MARGIN, MARGIN,
 180                               CARDWIDTH-MARGIN, CARDHEIGHT-MARGIN,
 181                               outline='black', fill='blue')
 182         self.group.addtag_withtag(self.__back)
 183
 184     def __repr__(self):
 185         """Return a string for debug print statements."""
 186         return "Card(%s, %s)" % (`self.suit`, `self.value`)
 187
 188     def moveto(self, x, y):
 189         """Move the card to absolute position (x, y)."""
 190         self.moveby(x - self.x, y - self.y)
 191
 192     def moveby(self, dx, dy):
 193         """Move the card by (dx, dy)."""
 194         self.x = self.x + dx
 195         self.y = self.y + dy
 196         self.group.move(dx, dy)
 197
 198     def tkraise(self):
 199         """Raise the card above all other objects in its canvas."""
 200         self.group.tkraise()
 201
 202     def showface(self):
 203         """Turn the card's face up."""
 204         self.tkraise()
 205         self.__rect.tkraise()
 206         self.__text.tkraise()
 207         self.face_shown = 1
 208
 209     def showback(self):
 210         """Turn the card's face down."""
 211         self.tkraise()
 212         self.__rect.tkraise()
 213         self.__back.tkraise()
 214         self.face_shown = 0
 215
 216
 217 class Stack:
 218
 219     """A generic stack of cards.
 220
 221     This is used as a base class for all other stacks (e.g. the deck,
 222     the suit stacks, and the row stacks).
 223
 224     Public methods:
 225
 226     add(card) -- add a card to the stack
 227     delete(card) -- delete a card from the stack
 228     showtop() -- show the top card (if any) face up
 229     deal() -- delete and return the top card, or None if empty
 230
 231     Method that subclasses may override:
 232
 233     position(card) -- move the card to its proper (x, y) position
 234
 235         The default position() method places all cards at the stack's
 236         own (x, y) position.
 237
 238     userclickhandler(), userdoubleclickhandler() -- called to do
 239     subclass specific things on single and double clicks
 240
 241         The default user (single) click handler shows the top card
 242         face up.  The default user double click handler calls the user
 243         single click handler.
 244
 245     usermovehandler(cards) -- called to complete a subpile move
 246
 247         The default user move handler moves all moved cards back to
 248         their original position (by calling the position() method).
 249
 250     Private methods:
 251
 252     clickhandler(event), doubleclickhandler(event),
 253     motionhandler(event), releasehandler(event) -- event handlers
 254
 255         The default event handlers turn the top card of the stack with
 256         its face up on a (single or double) click, and also support
 257         moving a subpile around.
 258
 259     startmoving(event) -- begin a move operation
 260     finishmoving() -- finish a move operation
 261
 262     """
 263
 264     def __init__(self, x, y, game=None):
 265         """Stack constructor.
 266
 267         Arguments are the stack's nominal x and y position (the top
 268         left corner of the first card placed in the stack), and the
 269         game object (which is used to get the canvas; subclasses use
 270         the game object to find other stacks).
 271
 272         """
 273         self.x = x
 274         self.y = y
 275         self.game = game
 276         self.cards = []
 277         self.group = Group(self.game.canvas)
 278         self.group.bind('<1>', self.clickhandler)
 279         self.group.bind('<Double-1>', self.doubleclickhandler)
 280         self.group.bind('<B1-Motion>', self.motionhandler)
 281         self.group.bind('<ButtonRelease-1>', self.releasehandler)
 282         self.makebottom()
 283
 284     def makebottom(self):
 285         pass
 286
 287     def __repr__(self):
 288         """Return a string for debug print statements."""
 289         return "%s(%d, %d)" % (self.__class__.__name__, self.x, self.y)
 290
 291     # Public methods
 292
 293     def add(self, card):
 294         self.cards.append(card)
 295         card.tkraise()
 296         self.position(card)
 297         self.group.addtag_withtag(card.group)
 298
 299     def delete(self, card):
 300         self.cards.remove(card)
 301         card.group.dtag(self.group)
 302
 303     def showtop(self):
 304         if self.cards:
 305             self.cards[-1].showface()
 306
 307     def deal(self):
 308         if not self.cards:
 309             return None
 310         card = self.cards[-1]
 311         self.delete(card)
 312         return card
 313
 314     # Subclass overridable methods
 315
 316     def position(self, card):
 317         card.moveto(self.x, self.y)
 318
 319     def userclickhandler(self):
 320         self.showtop()
 321
 322     def userdoubleclickhandler(self):
 323         self.userclickhandler()
 324
 325     def usermovehandler(self, cards):
 326         for card in cards:
 327             self.position(card)
 328
 329     # Event handlers
 330
 331     def clickhandler(self, event):
 332         self.finishmoving()             # In case we lost an event
 333         self.userclickhandler()
 334         self.startmoving(event)
 335
 336     def motionhandler(self, event):
 337         self.keepmoving(event)
 338
 339     def releasehandler(self, event):
 340         self.keepmoving(event)
 341         self.finishmoving()
 342
 343     def doubleclickhandler(self, event):
 344         self.finishmoving()             # In case we lost an event
 345         self.userdoubleclickhandler()
 346         self.startmoving(event)
 347
 348     # Move internals
 349
 350     moving = None
 351
 352     def startmoving(self, event):
 353         self.moving = None
 354         tags = self.game.canvas.gettags('current')
 355         for i in range(len(self.cards)):
 356             card = self.cards[i]
 357             if card.group.tag in tags:
 358                 break
 359         else:
 360             return
 361         if not card.face_shown:
 362             return
 363         self.moving = self.cards[i:]
 364         self.lastx = event.x
 365         self.lasty = event.y
 366         for card in self.moving:
 367             card.tkraise()
 368
 369     def keepmoving(self, event):
 370         if not self.moving:
 371             return
 372         dx = event.x - self.lastx
 373         dy = event.y - self.lasty
 374         self.lastx = event.x
 375         self.lasty = event.y
 376         if dx or dy:
 377             for card in self.moving:
 378                 card.moveby(dx, dy)
 379
 380     def finishmoving(self):
 381         cards = self.moving
 382         self.moving = None
 383         if cards:
 384             self.usermovehandler(cards)
 385
 386
 387 class Deck(Stack):
 388
 389     """The deck is a stack with support for shuffling.
 390
 391     New methods:
 392
 393     fill() -- create the playing cards
 394     shuffle() -- shuffle the playing cards
 395
 396     A single click moves the top card to the game's open deck and
 397     moves it face up; if we're out of cards, it moves the open deck
 398     back to the deck.
 399
 400     """
 401
 402     def makebottom(self):
 403         bottom = Rectangle(self.game.canvas,
 404                            self.x, self.y,
 405                            self.x+CARDWIDTH, self.y+CARDHEIGHT,
 406                            outline='black', fill=BACKGROUND)
 407         self.group.addtag_withtag(bottom)
 408
 409     def fill(self):
 410         for suit in ALLSUITS:
 411             for value in ALLVALUES:
 412                 self.add(Card(suit, value, self.game.canvas))
 413
 414     def shuffle(self):
 415         n = len(self.cards)
 416         newcards = []
 417         for i in randperm(n):
 418             newcards.append(self.cards[i])
 419         self.cards = newcards
 420
 421     def userclickhandler(self):
 422         opendeck = self.game.opendeck
 423         card = self.deal()
 424         if not card:
 425             while 1:
 426                 card = opendeck.deal()
 427                 if not card:
 428                     break
 429                 self.add(card)
 430                 card.showback()
 431         else:
 432             self.game.opendeck.add(card)
 433             card.showface()
 434
 435
 436 def randperm(n):
 437     """Function returning a random permutation of range(n)."""
 438     r = range(n)
 439     x = []
 440     while r:
 441         i = random.choice(r)
 442         x.append(i)
 443         r.remove(i)
 444     return x
 445
 446
 447 class OpenStack(Stack):
 448
 449     def acceptable(self, cards):
 450         return 0
 451
 452     def usermovehandler(self, cards):
 453         card = cards[0]
 454         stack = self.game.closeststack(card)
 455         if not stack or stack is self or not stack.acceptable(cards):
 456             Stack.usermovehandler(self, cards)
 457         else:
 458             for card in cards:
 459                 self.delete(card)
 460                 stack.add(card)
 461             self.game.wincheck()
 462
 463     def userdoubleclickhandler(self):
 464         if not self.cards:
 465             return
 466         card = self.cards[-1]
 467         if not card.face_shown:
 468             self.userclickhandler()
 469             return
 470         for s in self.game.suits:
 471             if s.acceptable([card]):
 472                 self.delete(card)
 473                 s.add(card)
 474                 self.game.wincheck()
 475                 break
 476
 477
 478 class SuitStack(OpenStack):
 479
 480     def makebottom(self):
 481         bottom = Rectangle(self.game.canvas,
 482                            self.x, self.y,
 483                            self.x+CARDWIDTH, self.y+CARDHEIGHT,
 484                            outline='black', fill='')
 485
 486     def userclickhandler(self):
 487         pass
 488
 489     def userdoubleclickhandler(self):
 490         pass
 491
 492     def acceptable(self, cards):
 493         if len(cards) != 1:
 494             return 0
 495         card = cards[0]
 496         if not self.cards:
 497             return card.value == ACE
 498         topcard = self.cards[-1]
 499         return card.suit == topcard.suit and card.value == topcard.value + 1
 500
 501
 502 class RowStack(OpenStack):
 503
 504     def acceptable(self, cards):
 505         card = cards[0]
 506         if not self.cards:
 507             return card.value == KING
 508         topcard = self.cards[-1]
 509         if not topcard.face_shown:
 510             return 0
 511         return card.color != topcard.color and card.value == topcard.value - 1
 512
 513     def position(self, card):
 514         y = self.y
 515         for c in self.cards:
 516             if c == card:
 517                 break
 518             if c.face_shown:
 519                 y = y + 2*MARGIN
 520             else:
 521                 y = y + OFFSET
 522         card.moveto(self.x, y)
 523
 524
 525 class Solitaire:
 526
 527     def __init__(self, master):
 528         self.master = master
 529
 530         self.canvas = Canvas(self.master,
 531                              background=BACKGROUND,
 532                              highlightthickness=0,
 533                              width=NROWS*XSPACING,
 534                              height=3*YSPACING + 20 + MARGIN)
 535         self.canvas.pack(fill=BOTH, expand=TRUE)
 536
 537         self.dealbutton = Button(self.canvas,
 538                                  text="Deal",
 539                                  highlightthickness=0,
 540                                  background=BACKGROUND,
 541                                  activebackground="green",
 542                                  command=self.deal)
 543         Window(self.canvas, MARGIN, 3*YSPACING + 20,
 544                window=self.dealbutton, anchor=SW)
 545
 546         x = MARGIN
 547         y = MARGIN
 548
 549         self.deck = Deck(x, y, self)
 550
 551         x = x + XSPACING
 552         self.opendeck = OpenStack(x, y, self)
 553
 554         x = x + XSPACING
 555         self.suits = []
 556         for i in range(NSUITS):
 557             x = x + XSPACING
 558             self.suits.append(SuitStack(x, y, self))
 559
 560         x = MARGIN
 561         y = y + YSPACING
 562
 563         self.rows = []
 564         for i in range(NROWS):
 565             self.rows.append(RowStack(x, y, self))
 566             x = x + XSPACING
 567
 568         self.openstacks = [self.opendeck] + self.suits + self.rows
 569
 570         self.deck.fill()
 571         self.deal()
 572
 573     def wincheck(self):
 574         for s in self.suits:
 575             if len(s.cards) != NVALUES:
 576                 return
 577         self.win()
 578         self.deal()
 579
 580     def win(self):
 581         """Stupid animation when you win."""
 582         cards = []
 583         for s in self.openstacks:
 584             cards = cards + s.cards
 585         while cards:
 586             card = random.choice(cards)
 587             cards.remove(card)
 588             self.animatedmoveto(card, self.deck)
 589
 590     def animatedmoveto(self, card, dest):
 591         for i in range(10, 0, -1):
 592             dx, dy = (dest.x-card.x)/i, (dest.y-card.y)/i
 593             card.moveby(dx, dy)
 594             self.master.update_idletasks()
 595
 596     def closeststack(self, card):
 597         closest = None
 598         cdist = 999999999
 599         # Since we only compare distances,
 600         # we don't bother to take the square root.
 601         for stack in self.openstacks:
 602             dist = (stack.x - card.x)**2 + (stack.y - card.y)**2
 603             if dist < cdist:
 604                 closest = stack
 605                 cdist = dist
 606         return closest
 607
 608     def deal(self):
 609         self.reset()
 610         self.deck.shuffle()
 611         for i in range(NROWS):
 612             for r in self.rows[i:]:
 613                 card = self.deck.deal()
 614                 r.add(card)
 615         for r in self.rows:
 616             r.showtop()
 617
 618     def reset(self):
 619         for stack in self.openstacks:
 620             while 1:
 621                 card = stack.deal()
 622                 if not card:
 623                     break
 624                 self.deck.add(card)
 625                 card.showback()
 626
 627
 628 # Main function, run when invoked as a stand-alone Python program.
 629
 630 def main():
 631     root = Tk()
 632     game = Solitaire(root)
 633     root.protocol('WM_DELETE_WINDOW', root.quit)
 634     root.mainloop()
 635
 636 if __name__ == '__main__':
 637     main()