Edit File: solitaire.py
#! /usr/bin/python2.7 """Solitaire game, much like the one that comes with MS Windows. Limitations: - No cute graphical images for the playing cards faces or backs. - No scoring or timer. - No undo. - No option to turn 3 cards at a time. - No keyboard shortcuts. - Less fancy animation when you win. - The determination of which stack you drag to is more relaxed. Apology: I'm not much of a card player, so my terminology in these comments may at times be a little unusual. If you have suggestions, please let me know! """ # Imports import math import random from Tkinter import * from Canvas import Rectangle, CanvasText, Group, Window # Fix a bug in Canvas.Group as distributed in Python 1.4. The # distributed bind() method is broken. Rather than asking you to fix # the source, we fix it here by deriving a subclass: class Group(Group): def bind(self, sequence=None, command=None): return self.canvas.tag_bind(self.id, sequence, command) # Constants determining the size and lay-out of cards and stacks. We # work in a "grid" where each card/stack is surrounded by MARGIN # pixels of space on each side, so adjacent stacks are separated by # 2*MARGIN pixels. OFFSET is the offset used for displaying the # face down cards in the row stacks. CARDWIDTH = 100 CARDHEIGHT = 150 MARGIN = 10 XSPACING = CARDWIDTH + 2*MARGIN YSPACING = CARDHEIGHT + 4*MARGIN OFFSET = 5 # The background color, green to look like a playing table. The # standard green is way too bright, and dark green is way to dark, so # we use something in between. (There are a few more colors that # could be customized, but they are less controversial.) BACKGROUND = '#070' # Suits and colors. The values of the symbolic suit names are the # strings used to display them (you change these and VALNAMES to # internationalize the game). The COLOR dictionary maps suit names to # colors (red and black) which must be Tk color names. The keys() of # the COLOR dictionary conveniently provides us with a list of all # suits (in arbitrary order). HEARTS = 'Heart' DIAMONDS = 'Diamond' CLUBS = 'Club' SPADES = 'Spade' RED = 'red' BLACK = 'black' COLOR = {} for s in (HEARTS, DIAMONDS): COLOR[s] = RED for s in (CLUBS, SPADES): COLOR[s] = BLACK ALLSUITS = COLOR.keys() NSUITS = len(ALLSUITS) # Card values are 1-13. We also define symbolic names for the picture # cards. ALLVALUES is a list of all card values. ACE = 1 JACK = 11 QUEEN = 12 KING = 13 ALLVALUES = range(1, 14) # (one more than the highest value) NVALUES = len(ALLVALUES) # VALNAMES is a list that maps a card value to string. It contains a # dummy element at index 0 so it can be indexed directly with the card # value. VALNAMES = ["", "A"] + map(str, range(2, 11)) + ["J", "Q", "K"] # Solitaire constants. The only one I can think of is the number of # row stacks. NROWS = 7 # The rest of the program consists of class definitions. These are # further described in their documentation strings. class Card: """A playing card. A card doesn't record to which stack it belongs; only the stack records this (it turns out that we always know this from the context, and this saves a ``double update'' with potential for inconsistencies). Public methods: moveto(x, y) -- move the card to an absolute position moveby(dx, dy) -- move the card by a relative offset tkraise() -- raise the card to the top of its stack showface(), showback() -- turn the card face up or down & raise it Public read-only instance variables: suit, value, color -- the card's suit, value and color face_shown -- true when the card is shown face up, else false Semi-public read-only instance variables (XXX should be made private): group -- the Canvas.Group representing the card x, y -- the position of the card's top left corner Private instance variables: __back, __rect, __text -- the canvas items making up the card (To show the card face up, the text item is placed in front of rect and the back is placed behind it. To show it face down, this is reversed. The card is created face down.) """ def __init__(self, suit, value, canvas): """Card constructor. Arguments are the card's suit and value, and the canvas widget. The card is created at position (0, 0), with its face down (adding it to a stack will position it according to that stack's rules). """ self.suit = suit self.value = value self.color = COLOR[suit] self.face_shown = 0 self.x = self.y = 0 self.group = Group(canvas) text = "%s %s" % (VALNAMES[value], suit) self.__text = CanvasText(canvas, CARDWIDTH//2, 0, anchor=N, fill=self.color, text=text) self.group.addtag_withtag(self.__text) self.__rect = Rectangle(canvas, 0, 0, CARDWIDTH, CARDHEIGHT, outline='black', fill='white') self.group.addtag_withtag(self.__rect) self.__back = Rectangle(canvas, MARGIN, MARGIN, CARDWIDTH-MARGIN, CARDHEIGHT-MARGIN, outline='black', fill='blue') self.group.addtag_withtag(self.__back) def __repr__(self): """Return a string for debug print statements.""" return "Card(%r, %r)" % (self.suit, self.value) def moveto(self, x, y): """Move the card to absolute position (x, y).""" self.moveby(x - self.x, y - self.y) def moveby(self, dx, dy): """Move the card by (dx, dy).""" self.x = self.x + dx self.y = self.y + dy self.group.move(dx, dy) def tkraise(self): """Raise the card above all other objects in its canvas.""" self.group.tkraise() def showface(self): """Turn the card's face up.""" self.tkraise() self.__rect.tkraise() self.__text.tkraise() self.face_shown = 1 def showback(self): """Turn the card's face down.""" self.tkraise() self.__rect.tkraise() self.__back.tkraise() self.face_shown = 0 class Stack: """A generic stack of cards. This is used as a base class for all other stacks (e.g. the deck, the suit stacks, and the row stacks). Public methods: add(card) -- add a card to the stack delete(card) -- delete a card from the stack showtop() -- show the top card (if any) face up deal() -- delete and return the top card, or None if empty Method that subclasses may override: position(card) -- move the card to its proper (x, y) position The default position() method places all cards at the stack's own (x, y) position. userclickhandler(), userdoubleclickhandler() -- called to do subclass specific things on single and double clicks The default user (single) click handler shows the top card face up. The default user double click handler calls the user single click handler. usermovehandler(cards) -- called to complete a subpile move The default user move handler moves all moved cards back to their original position (by calling the position() method). Private methods: clickhandler(event), doubleclickhandler(event), motionhandler(event), releasehandler(event) -- event handlers The default event handlers turn the top card of the stack with its face up on a (single or double) click, and also support moving a subpile around. startmoving(event) -- begin a move operation finishmoving() -- finish a move operation """ def __init__(self, x, y, game=None): """Stack constructor. Arguments are the stack's nominal x and y position (the top left corner of the first card placed in the stack), and the game object (which is used to get the canvas; subclasses use the game object to find other stacks). """ self.x = x self.y = y self.game = game self.cards = [] self.group = Group(self.game.canvas) self.group.bind('<1>', self.clickhandler) self.group.bind('<Double-1>', self.doubleclickhandler) self.group.bind('<B1-Motion>', self.motionhandler) self.group.bind('<ButtonRelease-1>', self.releasehandler) self.makebottom() def makebottom(self): pass def __repr__(self): """Return a string for debug print statements.""" return "%s(%d, %d)" % (self.__class__.__name__, self.x, self.y) # Public methods def add(self, card): self.cards.append(card) card.tkraise() self.position(card) self.group.addtag_withtag(card.group) def delete(self, card): self.cards.remove(card) card.group.dtag(self.group) def showtop(self): if self.cards: self.cards[-1].showface() def deal(self): if not self.cards: return None card = self.cards[-1] self.delete(card) return card # Subclass overridable methods def position(self, card): card.moveto(self.x, self.y) def userclickhandler(self): self.showtop() def userdoubleclickhandler(self): self.userclickhandler() def usermovehandler(self, cards): for card in cards: self.position(card) # Event handlers def clickhandler(self, event): self.finishmoving() # In case we lost an event self.userclickhandler() self.startmoving(event) def motionhandler(self, event): self.keepmoving(event) def releasehandler(self, event): self.keepmoving(event) self.finishmoving() def doubleclickhandler(self, event): self.finishmoving() # In case we lost an event self.userdoubleclickhandler() self.startmoving(event) # Move internals moving = None def startmoving(self, event): self.moving = None tags = self.game.canvas.gettags('current') for i in range(len(self.cards)): card = self.cards[i] if card.group.tag in tags: break else: return if not card.face_shown: return self.moving = self.cards[i:] self.lastx = event.x self.lasty = event.y for card in self.moving: card.tkraise() def keepmoving(self, event): if not self.moving: return dx = event.x - self.lastx dy = event.y - self.lasty self.lastx = event.x self.lasty = event.y if dx or dy: for card in self.moving: card.moveby(dx, dy) def finishmoving(self): cards = self.moving self.moving = None if cards: self.usermovehandler(cards) class Deck(Stack): """The deck is a stack with support for shuffling. New methods: fill() -- create the playing cards shuffle() -- shuffle the playing cards A single click moves the top card to the game's open deck and moves it face up; if we're out of cards, it moves the open deck back to the deck. """ def makebottom(self): bottom = Rectangle(self.game.canvas, self.x, self.y, self.x+CARDWIDTH, self.y+CARDHEIGHT, outline='black', fill=BACKGROUND) self.group.addtag_withtag(bottom) def fill(self): for suit in ALLSUITS: for value in ALLVALUES: self.add(Card(suit, value, self.game.canvas)) def shuffle(self): n = len(self.cards) newcards = [] for i in randperm(n): newcards.append(self.cards[i]) self.cards = newcards def userclickhandler(self): opendeck = self.game.opendeck card = self.deal() if not card: while 1: card = opendeck.deal() if not card: break self.add(card) card.showback() else: self.game.opendeck.add(card) card.showface() def randperm(n): """Function returning a random permutation of range(n).""" r = range(n) x = [] while r: i = random.choice(r) x.append(i) r.remove(i) return x class OpenStack(Stack): def acceptable(self, cards): return 0 def usermovehandler(self, cards): card = cards[0] stack = self.game.closeststack(card) if not stack or stack is self or not stack.acceptable(cards): Stack.usermovehandler(self, cards) else: for card in cards: self.delete(card) stack.add(card) self.game.wincheck() def userdoubleclickhandler(self): if not self.cards: return card = self.cards[-1] if not card.face_shown: self.userclickhandler() return for s in self.game.suits: if s.acceptable([card]): self.delete(card) s.add(card) self.game.wincheck() break class SuitStack(OpenStack): def makebottom(self): bottom = Rectangle(self.game.canvas, self.x, self.y, self.x+CARDWIDTH, self.y+CARDHEIGHT, outline='black', fill='') def userclickhandler(self): pass def userdoubleclickhandler(self): pass def acceptable(self, cards): if len(cards) != 1: return 0 card = cards[0] if not self.cards: return card.value == ACE topcard = self.cards[-1] return card.suit == topcard.suit and card.value == topcard.value + 1 class RowStack(OpenStack): def acceptable(self, cards): card = cards[0] if not self.cards: return card.value == KING topcard = self.cards[-1] if not topcard.face_shown: return 0 return card.color != topcard.color and card.value == topcard.value - 1 def position(self, card): y = self.y for c in self.cards: if c == card: break if c.face_shown: y = y + 2*MARGIN else: y = y + OFFSET card.moveto(self.x, y) class Solitaire: def __init__(self, master): self.master = master self.canvas = Canvas(self.master, background=BACKGROUND, highlightthickness=0, width=NROWS*XSPACING, height=3*YSPACING + 20 + MARGIN) self.canvas.pack(fill=BOTH, expand=TRUE) self.dealbutton = Button(self.canvas, text="Deal", highlightthickness=0, background=BACKGROUND, activebackground="green", command=self.deal) Window(self.canvas, MARGIN, 3*YSPACING + 20, window=self.dealbutton, anchor=SW) x = MARGIN y = MARGIN self.deck = Deck(x, y, self) x = x + XSPACING self.opendeck = OpenStack(x, y, self) x = x + XSPACING self.suits = [] for i in range(NSUITS): x = x + XSPACING self.suits.append(SuitStack(x, y, self)) x = MARGIN y = y + YSPACING self.rows = [] for i in range(NROWS): self.rows.append(RowStack(x, y, self)) x = x + XSPACING self.openstacks = [self.opendeck] + self.suits + self.rows self.deck.fill() self.deal() def wincheck(self): for s in self.suits: if len(s.cards) != NVALUES: return self.win() self.deal() def win(self): """Stupid animation when you win.""" cards = [] for s in self.openstacks: cards = cards + s.cards while cards: card = random.choice(cards) cards.remove(card) self.animatedmoveto(card, self.deck) def animatedmoveto(self, card, dest): for i in range(10, 0, -1): dx, dy = (dest.x-card.x)//i, (dest.y-card.y)//i card.moveby(dx, dy) self.master.update_idletasks() def closeststack(self, card): closest = None cdist = 999999999 # Since we only compare distances, # we don't bother to take the square root. for stack in self.openstacks: dist = (stack.x - card.x)**2 + (stack.y - card.y)**2 if dist < cdist: closest = stack cdist = dist return closest def deal(self): self.reset() self.deck.shuffle() for i in range(NROWS): for r in self.rows[i:]: card = self.deck.deal() r.add(card) for r in self.rows: r.showtop() def reset(self): for stack in self.openstacks: while 1: card = stack.deal() if not card: break self.deck.add(card) card.showback() # Main function, run when invoked as a stand-alone Python program. def main(): root = Tk() game = Solitaire(root) root.protocol('WM_DELETE_WINDOW', root.quit) root.mainloop() if __name__ == '__main__': main()
Back to File Manager