Upload 79 files

.gitattributes

@@ -100,3 +100,4 @@ Enjoy[[:space:]]Python/8.[[:space:]]Type[[:space:]]hinting[[:space:]]in[[:space:
 8.[[:space:]]Type[[:space:]]hinting[[:space:]]in[[:space:]]Python/2.[[:space:]]Typing[[:space:]]in[[:space:]]Python.mp4 filter=lfs diff=lfs merge=lfs -text
 8.[[:space:]]Type[[:space:]]hinting[[:space:]]in[[:space:]]Python/3.[[:space:]]Further[[:space:]]reading.mp4 filter=lfs diff=lfs merge=lfs -text
 8.[[:space:]]Type[[:space:]]hinting[[:space:]]in[[:space:]]Python/4.[[:space:]]Conclusion[[:space:]]of[[:space:]]this[[:space:]]section.mp4 filter=lfs diff=lfs merge=lfs -text
+Making[[:space:]]Games[[:space:]]with[[:space:]]Python[[:space:]]-[[:space:]]W.T.E.[[:space:]]Official[[:space:]]Community/E-book/MakingGames.pdf filter=lfs diff=lfs merge=lfs -text

Making Games with Python - W.T.E. Official Community/E-book/MakingGames.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da538577ef5be12f10fdaf4e2cc8f6fed1eb2826ff8181a8d094911fc9d9ef18
+size 4563284

Making Games with Python - W.T.E. Official Community/badswap.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:730a6c91a1c6c81b9ded77a83a60765773a891e01d8e33dc55c497745e18bd3b
+size 36908

Making Games with Python - W.T.E. Official Community/beep1.ogg

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b40648e05eed914a226240a58824b770f1a7b00bfb01bb5a546811d19d12cb01
+size 39782

Making Games with Python - W.T.E. Official Community/beep2.ogg

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f313e9323ef44bea14fcb9aa6341ee40aa093d1ed6e396c45727dff34723afec
+size 39284

Making Games with Python - W.T.E. Official Community/beep3.ogg

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b95dac482a7453f4cba06463ae5f67cb1cd25b305d7a03ca89ddf023da910620
+size 38581

Making Games with Python - W.T.E. Official Community/beep4.ogg

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ebd58a7cbb7c1961d7817278c33a99fa6c1e77a62b426214270537dfbb978cef
+size 39214

Making Games with Python - W.T.E. Official Community/blankpygame.py

@@ -0,0 +1,11 @@
+import pygame, sys
+from pygame.locals import *
+
+pygame.init()
+DISPLAYSURF = pygame.display.set_mode((400, 300))
+pygame.display.set_caption('Hello Pygame World!')
+while True: # main game loop
+    for event in pygame.event.get():
+        if event.type == QUIT:
+            pygame.quit()
+            sys.exit()

Making Games with Python - W.T.E. Official Community/catanimation.py

@@ -0,0 +1,47 @@
+import pygame, sys
+from pygame.locals import *
+
+pygame.init()
+
+FPS = 30 # frames per second setting
+fpsClock = pygame.time.Clock()
+
+# set up the window
+DISPLAYSURF = pygame.display.set_mode((400, 300), 0, 32)
+pygame.display.set_caption('Animation')
+
+WHITE = (255, 255, 255)
+catImg = pygame.image.load('cat.png')
+catx = 10
+caty = 10
+direction = 'right'
+
+while True: # the main game loop
+    DISPLAYSURF.fill(WHITE)
+
+    if direction == 'right':
+        catx += 5
+        if catx == 280:
+            direction = 'down'
+    elif direction == 'down':
+        caty += 5
+        if caty == 220:
+            direction = 'left'
+    elif direction == 'left':
+        catx -= 5
+        if catx == 10:
+            direction = 'up'
+    elif direction == 'up':
+        caty -= 5
+        if caty == 10:
+            direction = 'right'
+
+    DISPLAYSURF.blit(catImg, (catx, caty))
+
+    for event in pygame.event.get():
+        if event.type == QUIT:
+            pygame.quit()
+            sys.exit()
+
+    pygame.display.update()
+    fpsClock.tick(FPS)

Making Games with Python - W.T.E. Official Community/drawing.py

@@ -0,0 +1,41 @@
+import pygame, sys
+from pygame.locals import *
+
+pygame.init()
+
+# set up the window
+DISPLAYSURF = pygame.display.set_mode((400, 300), 0, 32)
+pygame.display.set_caption('Drawing')
+
+# set up the colors
+BLACK = (  0,   0,   0)
+WHITE = (255, 255, 255)
+RED   = (255,   0,   0)
+GREEN = (  0, 255,   0)
+BLUE  = (  0,   0, 255)
+
+# draw on the surface object
+DISPLAYSURF.fill(WHITE)
+pygame.draw.polygon(DISPLAYSURF, GREEN, ((146, 0), (291, 106), (236, 277), (56, 277), (0, 106)))
+pygame.draw.line(DISPLAYSURF, BLUE, (60, 60), (120, 60), 4)
+pygame.draw.line(DISPLAYSURF, BLUE, (120, 60), (60, 120))
+pygame.draw.line(DISPLAYSURF, BLUE, (60, 120), (120, 120), 4)
+pygame.draw.circle(DISPLAYSURF, BLUE, (300, 50), 20, 0)
+pygame.draw.ellipse(DISPLAYSURF, RED, (300, 200, 40, 80), 1)
+pygame.draw.rect(DISPLAYSURF, RED, (200, 150, 100, 50))
+
+pixObj = pygame.PixelArray(DISPLAYSURF)
+pixObj[380][280] = BLACK
+pixObj[382][282] = BLACK
+pixObj[384][284] = BLACK
+pixObj[386][286] = BLACK
+pixObj[388][288] = BLACK
+del pixObj
+
+# run the game loop
+while True:
+    for event in pygame.event.get():
+        if event.type == QUIT:
+            pygame.quit()
+            sys.exit()
+    pygame.display.update()

Making Games with Python - W.T.E. Official Community/flippy.py

@@ -0,0 +1,518 @@
+# Flippy (a Reversi clone), by Al Sweigart al@inventwithpython.com
+# (Pygame) Play against the computer and try to flip their tiles.
+
+
+
+# Based on the "reversi.py" code that originally appeared in "Invent
+# Your Own Computer Games with Python", chapter 15:
+#   http://inventwithpython.com/chapter15.html
+
+import random, sys, pygame, time, copy
+from pygame.locals import *
+
+FPS = 10 # frames per second to update the screen
+WINDOWWIDTH = 640 # width of the program's window, in pixels
+WINDOWHEIGHT = 480 # height in pixels
+SPACESIZE = 50 # width & height of each space on the board, in pixels
+BOARDWIDTH = 8 # how many columns of spaces on the game board
+BOARDHEIGHT = 8 # how many rows of spaces on the game board
+WHITE_TILE = 'WHITE_TILE' # an arbitrary but unique value
+BLACK_TILE = 'BLACK_TILE' # an arbitrary but unique value
+EMPTY_SPACE = 'EMPTY_SPACE' # an arbitrary but unique value
+HINT_TILE = 'HINT_TILE' # an arbitrary but unique value
+ANIMATIONSPEED = 25 # integer from 1 to 100, higher is faster animation
+
+# Amount of space on the left & right side (XMARGIN) or above and below
+# (YMARGIN) the game board, in pixels.
+XMARGIN = int((WINDOWWIDTH - (BOARDWIDTH * SPACESIZE)) / 2)
+YMARGIN = int((WINDOWHEIGHT - (BOARDHEIGHT * SPACESIZE)) / 2)
+
+#              R    G    B
+WHITE      = (255, 255, 255)
+BLACK      = (  0,   0,   0)
+GREEN      = (  0, 155,   0)
+BRIGHTBLUE = (  0,  50, 255)
+BROWN      = (174,  94,   0)
+
+TEXTBGCOLOR1 = BRIGHTBLUE
+TEXTBGCOLOR2 = GREEN
+GRIDLINECOLOR = BLACK
+TEXTCOLOR = WHITE
+HINTCOLOR = BROWN
+
+
+def main():
+    global MAINCLOCK, DISPLAYSURF, FONT, BIGFONT, BGIMAGE
+
+    pygame.init()
+    MAINCLOCK = pygame.time.Clock()
+    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
+    pygame.display.set_caption('Flippy')
+    FONT = pygame.font.Font('freesansbold.ttf', 16)
+    BIGFONT = pygame.font.Font('freesansbold.ttf', 32)
+
+    # Set up the background image.
+    boardImage = pygame.image.load('flippyboard.png')
+    # Use smoothscale() to stretch the board image to fit the entire board:
+    boardImage = pygame.transform.smoothscale(boardImage, (BOARDWIDTH * SPACESIZE, BOARDHEIGHT * SPACESIZE))
+    boardImageRect = boardImage.get_rect()
+    boardImageRect.topleft = (XMARGIN, YMARGIN)
+    BGIMAGE = pygame.image.load('flippybackground.png')
+    # Use smoothscale() to stretch the background image to fit the entire window:
+    BGIMAGE = pygame.transform.smoothscale(BGIMAGE, (WINDOWWIDTH, WINDOWHEIGHT))
+    BGIMAGE.blit(boardImage, boardImageRect)
+
+    # Run the main game.
+    while True:
+        if runGame() == False:
+            break
+
+
+def runGame():
+    # Plays a single game of reversi each time this function is called.
+
+    # Reset the board and game.
+    mainBoard = getNewBoard()
+    resetBoard(mainBoard)
+    showHints = False
+    turn = random.choice(['computer', 'player'])
+
+    # Draw the starting board and ask the player what color they want.
+    drawBoard(mainBoard)
+    playerTile, computerTile = enterPlayerTile()
+
+    # Make the Surface and Rect objects for the "New Game" and "Hints" buttons
+    newGameSurf = FONT.render('New Game', True, TEXTCOLOR, TEXTBGCOLOR2)
+    newGameRect = newGameSurf.get_rect()
+    newGameRect.topright = (WINDOWWIDTH - 8, 10)
+    hintsSurf = FONT.render('Hints', True, TEXTCOLOR, TEXTBGCOLOR2)
+    hintsRect = hintsSurf.get_rect()
+    hintsRect.topright = (WINDOWWIDTH - 8, 40)
+
+    while True: # main game loop
+        # Keep looping for player and computer's turns.
+        if turn == 'player':
+            # Player's turn:
+            if getValidMoves(mainBoard, playerTile) == []:
+                # If it's the player's turn but they
+                # can't move, then end the game.
+                break
+            movexy = None
+            while movexy == None:
+                # Keep looping until the player clicks on a valid space.
+
+                # Determine which board data structure to use for display.
+                if showHints:
+                    boardToDraw = getBoardWithValidMoves(mainBoard, playerTile)
+                else:
+                    boardToDraw = mainBoard
+
+                checkForQuit()
+                for event in pygame.event.get(): # event handling loop
+                    if event.type == MOUSEBUTTONUP:
+                        # Handle mouse click events
+                        mousex, mousey = event.pos
+                        if newGameRect.collidepoint( (mousex, mousey) ):
+                            # Start a new game
+                            return True
+                        elif hintsRect.collidepoint( (mousex, mousey) ):
+                            # Toggle hints mode
+                            showHints = not showHints
+                        # movexy is set to a two-item tuple XY coordinate, or None value
+                        movexy = getSpaceClicked(mousex, mousey)
+                        if movexy != None and not isValidMove(mainBoard, playerTile, movexy[0], movexy[1]):
+                            movexy = None
+
+                # Draw the game board.
+                drawBoard(boardToDraw)
+                drawInfo(boardToDraw, playerTile, computerTile, turn)
+
+                # Draw the "New Game" and "Hints" buttons.
+                DISPLAYSURF.blit(newGameSurf, newGameRect)
+                DISPLAYSURF.blit(hintsSurf, hintsRect)
+
+                MAINCLOCK.tick(FPS)
+                pygame.display.update()
+
+            # Make the move and end the turn.
+            makeMove(mainBoard, playerTile, movexy[0], movexy[1], True)
+            if getValidMoves(mainBoard, computerTile) != []:
+                # Only set for the computer's turn if it can make a move.
+                turn = 'computer'
+
+        else:
+            # Computer's turn:
+            if getValidMoves(mainBoard, computerTile) == []:
+                # If it was set to be the computer's turn but
+                # they can't move, then end the game.
+                break
+
+            # Draw the board.
+            drawBoard(mainBoard)
+            drawInfo(mainBoard, playerTile, computerTile, turn)
+
+            # Draw the "New Game" and "Hints" buttons.
+            DISPLAYSURF.blit(newGameSurf, newGameRect)
+            DISPLAYSURF.blit(hintsSurf, hintsRect)
+
+            # Make it look like the computer is thinking by pausing a bit.
+            pauseUntil = time.time() + random.randint(5, 15) * 0.1
+            while time.time() < pauseUntil:
+                pygame.display.update()
+
+            # Make the move and end the turn.
+            x, y = getComputerMove(mainBoard, computerTile)
+            makeMove(mainBoard, computerTile, x, y, True)
+            if getValidMoves(mainBoard, playerTile) != []:
+                # Only set for the player's turn if they can make a move.
+                turn = 'player'
+
+    # Display the final score.
+    drawBoard(mainBoard)
+    scores = getScoreOfBoard(mainBoard)
+
+    # Determine the text of the message to display.
+    if scores[playerTile] > scores[computerTile]:
+        text = 'You beat the computer by %s points! Congratulations!' % \
+               (scores[playerTile] - scores[computerTile])
+    elif scores[playerTile] < scores[computerTile]:
+        text = 'You lost. The computer beat you by %s points.' % \
+               (scores[computerTile] - scores[playerTile])
+    else:
+        text = 'The game was a tie!'
+
+    textSurf = FONT.render(text, True, TEXTCOLOR, TEXTBGCOLOR1)
+    textRect = textSurf.get_rect()
+    textRect.center = (int(WINDOWWIDTH / 2), int(WINDOWHEIGHT / 2))
+    DISPLAYSURF.blit(textSurf, textRect)
+
+    # Display the "Play again?" text with Yes and No buttons.
+    text2Surf = BIGFONT.render('Play again?', True, TEXTCOLOR, TEXTBGCOLOR1)
+    text2Rect = text2Surf.get_rect()
+    text2Rect.center = (int(WINDOWWIDTH / 2), int(WINDOWHEIGHT / 2) + 50)
+
+    # Make "Yes" button.
+    yesSurf = BIGFONT.render('Yes', True, TEXTCOLOR, TEXTBGCOLOR1)
+    yesRect = yesSurf.get_rect()
+    yesRect.center = (int(WINDOWWIDTH / 2) - 60, int(WINDOWHEIGHT / 2) + 90)
+
+    # Make "No" button.
+    noSurf = BIGFONT.render('No', True, TEXTCOLOR, TEXTBGCOLOR1)
+    noRect = noSurf.get_rect()
+    noRect.center = (int(WINDOWWIDTH / 2) + 60, int(WINDOWHEIGHT / 2) + 90)
+
+    while True:
+        # Process events until the user clicks on Yes or No.
+        checkForQuit()
+        for event in pygame.event.get(): # event handling loop
+            if event.type == MOUSEBUTTONUP:
+                mousex, mousey = event.pos
+                if yesRect.collidepoint( (mousex, mousey) ):
+                    return True
+                elif noRect.collidepoint( (mousex, mousey) ):
+                    return False
+        DISPLAYSURF.blit(textSurf, textRect)
+        DISPLAYSURF.blit(text2Surf, text2Rect)
+        DISPLAYSURF.blit(yesSurf, yesRect)
+        DISPLAYSURF.blit(noSurf, noRect)
+        pygame.display.update()
+        MAINCLOCK.tick(FPS)
+
+
+def translateBoardToPixelCoord(x, y):
+    return XMARGIN + x * SPACESIZE + int(SPACESIZE / 2), YMARGIN + y * SPACESIZE + int(SPACESIZE / 2)
+
+
+def animateTileChange(tilesToFlip, tileColor, additionalTile):
+    # Draw the additional tile that was just laid down. (Otherwise we'd
+    # have to completely redraw the board & the board info.)
+    if tileColor == WHITE_TILE:
+        additionalTileColor = WHITE
+    else:
+        additionalTileColor = BLACK
+    additionalTileX, additionalTileY = translateBoardToPixelCoord(additionalTile[0], additionalTile[1])
+    pygame.draw.circle(DISPLAYSURF, additionalTileColor, (additionalTileX, additionalTileY), int(SPACESIZE / 2) - 4)
+    pygame.display.update()
+
+    for rgbValues in range(0, 255, int(ANIMATIONSPEED * 2.55)):
+        if rgbValues > 255:
+            rgbValues = 255
+        elif rgbValues < 0:
+            rgbValues = 0
+
+        if tileColor == WHITE_TILE:
+            color = tuple([rgbValues] * 3) # rgbValues goes from 0 to 255
+        elif tileColor == BLACK_TILE:
+            color = tuple([255 - rgbValues] * 3) # rgbValues goes from 255 to 0
+
+        for x, y in tilesToFlip:
+            centerx, centery = translateBoardToPixelCoord(x, y)
+            pygame.draw.circle(DISPLAYSURF, color, (centerx, centery), int(SPACESIZE / 2) - 4)
+        pygame.display.update()
+        MAINCLOCK.tick(FPS)
+        checkForQuit()
+
+
+def drawBoard(board):
+    # Draw background of board.
+    DISPLAYSURF.blit(BGIMAGE, BGIMAGE.get_rect())
+
+    # Draw grid lines of the board.
+    for x in range(BOARDWIDTH + 1):
+        # Draw the horizontal lines.
+        startx = (x * SPACESIZE) + XMARGIN
+        starty = YMARGIN
+        endx = (x * SPACESIZE) + XMARGIN
+        endy = YMARGIN + (BOARDHEIGHT * SPACESIZE)
+        pygame.draw.line(DISPLAYSURF, GRIDLINECOLOR, (startx, starty), (endx, endy))
+    for y in range(BOARDHEIGHT + 1):
+        # Draw the vertical lines.
+        startx = XMARGIN
+        starty = (y * SPACESIZE) + YMARGIN
+        endx = XMARGIN + (BOARDWIDTH * SPACESIZE)
+        endy = (y * SPACESIZE) + YMARGIN
+        pygame.draw.line(DISPLAYSURF, GRIDLINECOLOR, (startx, starty), (endx, endy))
+
+    # Draw the black & white tiles or hint spots.
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT):
+            centerx, centery = translateBoardToPixelCoord(x, y)
+            if board[x][y] == WHITE_TILE or board[x][y] == BLACK_TILE:
+                if board[x][y] == WHITE_TILE:
+                    tileColor = WHITE
+                else:
+                    tileColor = BLACK
+                pygame.draw.circle(DISPLAYSURF, tileColor, (centerx, centery), int(SPACESIZE / 2) - 4)
+            if board[x][y] == HINT_TILE:
+                pygame.draw.rect(DISPLAYSURF, HINTCOLOR, (centerx - 4, centery - 4, 8, 8))
+
+
+def getSpaceClicked(mousex, mousey):
+    # Return a tuple of two integers of the board space coordinates where
+    # the mouse was clicked. (Or returns None not in any space.)
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT):
+            if mousex > x * SPACESIZE + XMARGIN and \
+               mousex < (x + 1) * SPACESIZE + XMARGIN and \
+               mousey > y * SPACESIZE + YMARGIN and \
+               mousey < (y + 1) * SPACESIZE + YMARGIN:
+                return (x, y)
+    return None
+
+
+def drawInfo(board, playerTile, computerTile, turn):
+    # Draws scores and whose turn it is at the bottom of the screen.
+    scores = getScoreOfBoard(board)
+    scoreSurf = FONT.render("Player Score: %s    Computer Score: %s    %s's Turn" % (str(scores[playerTile]), str(scores[computerTile]), turn.title()), True, TEXTCOLOR)
+    scoreRect = scoreSurf.get_rect()
+    scoreRect.bottomleft = (10, WINDOWHEIGHT - 5)
+    DISPLAYSURF.blit(scoreSurf, scoreRect)
+
+
+def resetBoard(board):
+    # Blanks out the board it is passed, and sets up starting tiles.
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT):
+            board[x][y] = EMPTY_SPACE
+
+    # Add starting pieces to the center
+    board[3][3] = WHITE_TILE
+    board[3][4] = BLACK_TILE
+    board[4][3] = BLACK_TILE
+    board[4][4] = WHITE_TILE
+
+
+def getNewBoard():
+    # Creates a brand new, empty board data structure.
+    board = []
+    for i in range(BOARDWIDTH):
+        board.append([EMPTY_SPACE] * BOARDHEIGHT)
+
+    return board
+
+
+def isValidMove(board, tile, xstart, ystart):
+    # Returns False if the player's move is invalid. If it is a valid
+    # move, returns a list of spaces of the captured pieces.
+    if board[xstart][ystart] != EMPTY_SPACE or not isOnBoard(xstart, ystart):
+        return False
+
+    board[xstart][ystart] = tile # temporarily set the tile on the board.
+
+    if tile == WHITE_TILE:
+        otherTile = BLACK_TILE
+    else:
+        otherTile = WHITE_TILE
+
+    tilesToFlip = []
+    # check each of the eight directions:
+    for xdirection, ydirection in [[0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]]:
+        x, y = xstart, ystart
+        x += xdirection
+        y += ydirection
+        if isOnBoard(x, y) and board[x][y] == otherTile:
+            # The piece belongs to the other player next to our piece.
+            x += xdirection
+            y += ydirection
+            if not isOnBoard(x, y):
+                continue
+            while board[x][y] == otherTile:
+                x += xdirection
+                y += ydirection
+                if not isOnBoard(x, y):
+                    break # break out of while loop, continue in for loop
+            if not isOnBoard(x, y):
+                continue
+            if board[x][y] == tile:
+                # There are pieces to flip over. Go in the reverse
+                # direction until we reach the original space, noting all
+                # the tiles along the way.
+                while True:
+                    x -= xdirection
+                    y -= ydirection
+                    if x == xstart and y == ystart:
+                        break
+                    tilesToFlip.append([x, y])
+
+    board[xstart][ystart] = EMPTY_SPACE # make space empty
+    if len(tilesToFlip) == 0: # If no tiles flipped, this move is invalid
+        return False
+    return tilesToFlip
+
+
+def isOnBoard(x, y):
+    # Returns True if the coordinates are located on the board.
+    return x >= 0 and x < BOARDWIDTH and y >= 0 and y < BOARDHEIGHT
+
+
+def getBoardWithValidMoves(board, tile):
+    # Returns a new board with hint markings.
+    dupeBoard = copy.deepcopy(board)
+
+    for x, y in getValidMoves(dupeBoard, tile):
+        dupeBoard[x][y] = HINT_TILE
+    return dupeBoard
+
+
+def getValidMoves(board, tile):
+    # Returns a list of (x,y) tuples of all valid moves.
+    validMoves = []
+
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT):
+            if isValidMove(board, tile, x, y) != False:
+                validMoves.append((x, y))
+    return validMoves
+
+
+def getScoreOfBoard(board):
+    # Determine the score by counting the tiles.
+    xscore = 0
+    oscore = 0
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT):
+            if board[x][y] == WHITE_TILE:
+                xscore += 1
+            if board[x][y] == BLACK_TILE:
+                oscore += 1
+    return {WHITE_TILE:xscore, BLACK_TILE:oscore}
+
+
+def enterPlayerTile():
+    # Draws the text and handles the mouse click events for letting
+    # the player choose which color they want to be.  Returns
+    # [WHITE_TILE, BLACK_TILE] if the player chooses to be White,
+    # [BLACK_TILE, WHITE_TILE] if Black.
+
+    # Create the text.
+    textSurf = FONT.render('Do you want to be white or black?', True, TEXTCOLOR, TEXTBGCOLOR1)
+    textRect = textSurf.get_rect()
+    textRect.center = (int(WINDOWWIDTH / 2), int(WINDOWHEIGHT / 2))
+
+    xSurf = BIGFONT.render('White', True, TEXTCOLOR, TEXTBGCOLOR1)
+    xRect = xSurf.get_rect()
+    xRect.center = (int(WINDOWWIDTH / 2) - 60, int(WINDOWHEIGHT / 2) + 40)
+
+    oSurf = BIGFONT.render('Black', True, TEXTCOLOR, TEXTBGCOLOR1)
+    oRect = oSurf.get_rect()
+    oRect.center = (int(WINDOWWIDTH / 2) + 60, int(WINDOWHEIGHT / 2) + 40)
+
+    while True:
+        # Keep looping until the player has clicked on a color.
+        checkForQuit()
+        for event in pygame.event.get(): # event handling loop
+            if event.type == MOUSEBUTTONUP:
+                mousex, mousey = event.pos
+                if xRect.collidepoint( (mousex, mousey) ):
+                    return [WHITE_TILE, BLACK_TILE]
+                elif oRect.collidepoint( (mousex, mousey) ):
+                    return [BLACK_TILE, WHITE_TILE]
+
+        # Draw the screen.
+        DISPLAYSURF.blit(textSurf, textRect)
+        DISPLAYSURF.blit(xSurf, xRect)
+        DISPLAYSURF.blit(oSurf, oRect)
+        pygame.display.update()
+        MAINCLOCK.tick(FPS)
+
+
+def makeMove(board, tile, xstart, ystart, realMove=False):
+    # Place the tile on the board at xstart, ystart, and flip tiles
+    # Returns False if this is an invalid move, True if it is valid.
+    tilesToFlip = isValidMove(board, tile, xstart, ystart)
+
+    if tilesToFlip == False:
+        return False
+
+    board[xstart][ystart] = tile
+
+    if realMove:
+        animateTileChange(tilesToFlip, tile, (xstart, ystart))
+
+    for x, y in tilesToFlip:
+        board[x][y] = tile
+    return True
+
+
+def isOnCorner(x, y):
+    # Returns True if the position is in one of the four corners.
+    return (x == 0 and y == 0) or \
+           (x == BOARDWIDTH and y == 0) or \
+           (x == 0 and y == BOARDHEIGHT) or \
+           (x == BOARDWIDTH and y == BOARDHEIGHT)
+
+
+def getComputerMove(board, computerTile):
+    # Given a board and the computer's tile, determine where to
+    # move and return that move as a [x, y] list.
+    possibleMoves = getValidMoves(board, computerTile)
+
+    # randomize the order of the possible moves
+    random.shuffle(possibleMoves)
+
+    # always go for a corner if available.
+    for x, y in possibleMoves:
+        if isOnCorner(x, y):
+            return [x, y]
+
+    # Go through all possible moves and remember the best scoring move
+    bestScore = -1
+    for x, y in possibleMoves:
+        dupeBoard = copy.deepcopy(board)
+        makeMove(dupeBoard, computerTile, x, y)
+        score = getScoreOfBoard(dupeBoard)[computerTile]
+        if score > bestScore:
+            bestMove = [x, y]
+            bestScore = score
+    return bestMove
+
+
+def checkForQuit():
+    for event in pygame.event.get((QUIT, KEYUP)): # event handling loop
+        if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
+            pygame.quit()
+            sys.exit()
+
+
+if __name__ == '__main__':
+    main()

Making Games with Python - W.T.E. Official Community/fourinarow.py

@@ -0,0 +1,363 @@
+# Four-In-A-Row, by Al Sweigart al@inventwithpython.com
+# (Pygame) Play against the computer, dropping tiles to connect four.
+
+
+
+import random, copy, sys, pygame
+from pygame.locals import *
+
+BOARDWIDTH = 7  # how many spaces wide the board is
+BOARDHEIGHT = 6 # how many spaces tall the board is
+assert BOARDWIDTH >= 4 and BOARDHEIGHT >= 4, 'Board must be at least 4x4.'
+
+DIFFICULTY = 2 # how many moves to look ahead. (>2 is usually too much)
+
+SPACESIZE = 50 # size of the tokens and individual board spaces in pixels
+
+FPS = 30 # frames per second to update the screen
+WINDOWWIDTH = 640 # width of the program's window, in pixels
+WINDOWHEIGHT = 480 # height in pixels
+
+XMARGIN = int((WINDOWWIDTH - BOARDWIDTH * SPACESIZE) / 2)
+YMARGIN = int((WINDOWHEIGHT - BOARDHEIGHT * SPACESIZE) / 2)
+
+BRIGHTBLUE = (0, 50, 255)
+WHITE = (255, 255, 255)
+
+BGCOLOR = BRIGHTBLUE
+TEXTCOLOR = WHITE
+
+RED = 'red'
+BLACK = 'black'
+EMPTY = None
+HUMAN = 'human'
+COMPUTER = 'computer'
+
+
+def main():
+    global FPSCLOCK, DISPLAYSURF, REDPILERECT, BLACKPILERECT, REDTOKENIMG
+    global BLACKTOKENIMG, BOARDIMG, ARROWIMG, ARROWRECT, HUMANWINNERIMG
+    global COMPUTERWINNERIMG, WINNERRECT, TIEWINNERIMG
+
+    pygame.init()
+    FPSCLOCK = pygame.time.Clock()
+    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
+    pygame.display.set_caption('Four in a Row')
+
+    REDPILERECT = pygame.Rect(int(SPACESIZE / 2), WINDOWHEIGHT - int(3 * SPACESIZE / 2), SPACESIZE, SPACESIZE)
+    BLACKPILERECT = pygame.Rect(WINDOWWIDTH - int(3 * SPACESIZE / 2), WINDOWHEIGHT - int(3 * SPACESIZE / 2), SPACESIZE, SPACESIZE)
+    REDTOKENIMG = pygame.image.load('4row_red.png')
+    REDTOKENIMG = pygame.transform.smoothscale(REDTOKENIMG, (SPACESIZE, SPACESIZE))
+    BLACKTOKENIMG = pygame.image.load('4row_black.png')
+    BLACKTOKENIMG = pygame.transform.smoothscale(BLACKTOKENIMG, (SPACESIZE, SPACESIZE))
+    BOARDIMG = pygame.image.load('4row_board.png')
+    BOARDIMG = pygame.transform.smoothscale(BOARDIMG, (SPACESIZE, SPACESIZE))
+
+    HUMANWINNERIMG = pygame.image.load('4row_humanwinner.png')
+    COMPUTERWINNERIMG = pygame.image.load('4row_computerwinner.png')
+    TIEWINNERIMG = pygame.image.load('4row_tie.png')
+    WINNERRECT = HUMANWINNERIMG.get_rect()
+    WINNERRECT.center = (int(WINDOWWIDTH / 2), int(WINDOWHEIGHT / 2))
+
+    ARROWIMG = pygame.image.load('4row_arrow.png')
+    ARROWRECT = ARROWIMG.get_rect()
+    ARROWRECT.left = REDPILERECT.right + 10
+    ARROWRECT.centery = REDPILERECT.centery
+
+    isFirstGame = True
+
+    while True:
+        runGame(isFirstGame)
+        isFirstGame = False
+
+
+def runGame(isFirstGame):
+    if isFirstGame:
+        # Let the computer go first on the first game, so the player
+        # can see how the tokens are dragged from the token piles.
+        turn = COMPUTER
+        showHelp = True
+    else:
+        # Randomly choose who goes first.
+        if random.randint(0, 1) == 0:
+            turn = COMPUTER
+        else:
+            turn = HUMAN
+        showHelp = False
+
+    # Set up a blank board data structure.
+    mainBoard = getNewBoard()
+
+    while True: # main game loop
+        if turn == HUMAN:
+            # Human player's turn.
+            getHumanMove(mainBoard, showHelp)
+            if showHelp:
+                # turn off help arrow after the first move
+                showHelp = False
+            if isWinner(mainBoard, RED):
+                winnerImg = HUMANWINNERIMG
+                break
+            turn = COMPUTER # switch to other player's turn
+        else:
+            # Computer player's turn.
+            column = getComputerMove(mainBoard)
+            animateComputerMoving(mainBoard, column)
+            makeMove(mainBoard, BLACK, column)
+            if isWinner(mainBoard, BLACK):
+                winnerImg = COMPUTERWINNERIMG
+                break
+            turn = HUMAN # switch to other player's turn
+
+        if isBoardFull(mainBoard):
+            # A completely filled board means it's a tie.
+            winnerImg = TIEWINNERIMG
+            break
+
+    while True:
+        # Keep looping until player clicks the mouse or quits.
+        drawBoard(mainBoard)
+        DISPLAYSURF.blit(winnerImg, WINNERRECT)
+        pygame.display.update()
+        FPSCLOCK.tick()
+        for event in pygame.event.get(): # event handling loop
+            if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
+                pygame.quit()
+                sys.exit()
+            elif event.type == MOUSEBUTTONUP:
+                return
+
+
+def makeMove(board, player, column):
+    lowest = getLowestEmptySpace(board, column)
+    if lowest != -1:
+        board[column][lowest] = player
+
+
+def drawBoard(board, extraToken=None):
+    DISPLAYSURF.fill(BGCOLOR)
+
+    # draw tokens
+    spaceRect = pygame.Rect(0, 0, SPACESIZE, SPACESIZE)
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT):
+            spaceRect.topleft = (XMARGIN + (x * SPACESIZE), YMARGIN + (y * SPACESIZE))
+            if board[x][y] == RED:
+                DISPLAYSURF.blit(REDTOKENIMG, spaceRect)
+            elif board[x][y] == BLACK:
+                DISPLAYSURF.blit(BLACKTOKENIMG, spaceRect)
+
+    # draw the extra token
+    if extraToken != None:
+        if extraToken['color'] == RED:
+            DISPLAYSURF.blit(REDTOKENIMG, (extraToken['x'], extraToken['y'], SPACESIZE, SPACESIZE))
+        elif extraToken['color'] == BLACK:
+            DISPLAYSURF.blit(BLACKTOKENIMG, (extraToken['x'], extraToken['y'], SPACESIZE, SPACESIZE))
+
+    # draw board over the tokens
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT):
+            spaceRect.topleft = (XMARGIN + (x * SPACESIZE), YMARGIN + (y * SPACESIZE))
+            DISPLAYSURF.blit(BOARDIMG, spaceRect)
+
+    # draw the red and black tokens off to the side
+    DISPLAYSURF.blit(REDTOKENIMG, REDPILERECT) # red on the left
+    DISPLAYSURF.blit(BLACKTOKENIMG, BLACKPILERECT) # black on the right
+
+
+def getNewBoard():
+    board = []
+    for x in range(BOARDWIDTH):
+        board.append([EMPTY] * BOARDHEIGHT)
+    return board
+
+
+def getHumanMove(board, isFirstMove):
+    draggingToken = False
+    tokenx, tokeny = None, None
+    while True:
+        for event in pygame.event.get(): # event handling loop
+            if event.type == QUIT:
+                pygame.quit()
+                sys.exit()
+            elif event.type == MOUSEBUTTONDOWN and not draggingToken and REDPILERECT.collidepoint(event.pos):
+                # start of dragging on red token pile.
+                draggingToken = True
+                tokenx, tokeny = event.pos
+            elif event.type == MOUSEMOTION and draggingToken:
+                # update the position of the red token being dragged
+                tokenx, tokeny = event.pos
+            elif event.type == MOUSEBUTTONUP and draggingToken:
+                # let go of the token being dragged
+                if tokeny < YMARGIN and tokenx > XMARGIN and tokenx < WINDOWWIDTH - XMARGIN:
+                    # let go at the top of the screen.
+                    column = int((tokenx - XMARGIN) / SPACESIZE)
+                    if isValidMove(board, column):
+                        animateDroppingToken(board, column, RED)
+                        board[column][getLowestEmptySpace(board, column)] = RED
+                        drawBoard(board)
+                        pygame.display.update()
+                        return
+                tokenx, tokeny = None, None
+                draggingToken = False
+        if tokenx != None and tokeny != None:
+            drawBoard(board, {'x':tokenx - int(SPACESIZE / 2), 'y':tokeny - int(SPACESIZE / 2), 'color':RED})
+        else:
+            drawBoard(board)
+
+        if isFirstMove:
+            # Show the help arrow for the player's first move.
+            DISPLAYSURF.blit(ARROWIMG, ARROWRECT)
+
+        pygame.display.update()
+        FPSCLOCK.tick()
+
+
+def animateDroppingToken(board, column, color):
+    x = XMARGIN + column * SPACESIZE
+    y = YMARGIN - SPACESIZE
+    dropSpeed = 1.0
+
+    lowestEmptySpace = getLowestEmptySpace(board, column)
+
+    while True:
+        y += int(dropSpeed)
+        dropSpeed += 0.5
+        if int((y - YMARGIN) / SPACESIZE) >= lowestEmptySpace:
+            return
+        drawBoard(board, {'x':x, 'y':y, 'color':color})
+        pygame.display.update()
+        FPSCLOCK.tick()
+
+
+def animateComputerMoving(board, column):
+    x = BLACKPILERECT.left
+    y = BLACKPILERECT.top
+    speed = 1.0
+    # moving the black tile up
+    while y > (YMARGIN - SPACESIZE):
+        y -= int(speed)
+        speed += 0.5
+        drawBoard(board, {'x':x, 'y':y, 'color':BLACK})
+        pygame.display.update()
+        FPSCLOCK.tick()
+    # moving the black tile over
+    y = YMARGIN - SPACESIZE
+    speed = 1.0
+    while x > (XMARGIN + column * SPACESIZE):
+        x -= int(speed)
+        speed += 0.5
+        drawBoard(board, {'x':x, 'y':y, 'color':BLACK})
+        pygame.display.update()
+        FPSCLOCK.tick()
+    # dropping the black tile
+    animateDroppingToken(board, column, BLACK)
+
+
+def getComputerMove(board):
+    potentialMoves = getPotentialMoves(board, BLACK, DIFFICULTY)
+    # get the best fitness from the potential moves
+    bestMoveFitness = -1
+    for i in range(BOARDWIDTH):
+        if potentialMoves[i] > bestMoveFitness and isValidMove(board, i):
+            bestMoveFitness = potentialMoves[i]
+    # find all potential moves that have this best fitness
+    bestMoves = []
+    for i in range(len(potentialMoves)):
+        if potentialMoves[i] == bestMoveFitness and isValidMove(board, i):
+            bestMoves.append(i)
+    return random.choice(bestMoves)
+
+
+def getPotentialMoves(board, tile, lookAhead):
+    if lookAhead == 0 or isBoardFull(board):
+        return [0] * BOARDWIDTH
+
+    if tile == RED:
+        enemyTile = BLACK
+    else:
+        enemyTile = RED
+
+    # Figure out the best move to make.
+    potentialMoves = [0] * BOARDWIDTH
+    for firstMove in range(BOARDWIDTH):
+        dupeBoard = copy.deepcopy(board)
+        if not isValidMove(dupeBoard, firstMove):
+            continue
+        makeMove(dupeBoard, tile, firstMove)
+        if isWinner(dupeBoard, tile):
+            # a winning move automatically gets a perfect fitness
+            potentialMoves[firstMove] = 1
+            break # don't bother calculating other moves
+        else:
+            # do other player's counter moves and determine best one
+            if isBoardFull(dupeBoard):
+                potentialMoves[firstMove] = 0
+            else:
+                for counterMove in range(BOARDWIDTH):
+                    dupeBoard2 = copy.deepcopy(dupeBoard)
+                    if not isValidMove(dupeBoard2, counterMove):
+                        continue
+                    makeMove(dupeBoard2, enemyTile, counterMove)
+                    if isWinner(dupeBoard2, enemyTile):
+                        # a losing move automatically gets the worst fitness
+                        potentialMoves[firstMove] = -1
+                        break
+                    else:
+                        # do the recursive call to getPotentialMoves()
+                        results = getPotentialMoves(dupeBoard2, tile, lookAhead - 1)
+                        potentialMoves[firstMove] += (sum(results) / BOARDWIDTH) / BOARDWIDTH
+    return potentialMoves
+
+
+def getLowestEmptySpace(board, column):
+    # Return the row number of the lowest empty row in the given column.
+    for y in range(BOARDHEIGHT-1, -1, -1):
+        if board[column][y] == EMPTY:
+            return y
+    return -1
+
+
+def isValidMove(board, column):
+    # Returns True if there is an empty space in the given column.
+    # Otherwise returns False.
+    if column < 0 or column >= (BOARDWIDTH) or board[column][0] != EMPTY:
+        return False
+    return True
+
+
+def isBoardFull(board):
+    # Returns True if there are no empty spaces anywhere on the board.
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT):
+            if board[x][y] == EMPTY:
+                return False
+    return True
+
+
+def isWinner(board, tile):
+    # check horizontal spaces
+    for x in range(BOARDWIDTH - 3):
+        for y in range(BOARDHEIGHT):
+            if board[x][y] == tile and board[x+1][y] == tile and board[x+2][y] == tile and board[x+3][y] == tile:
+                return True
+    # check vertical spaces
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT - 3):
+            if board[x][y] == tile and board[x][y+1] == tile and board[x][y+2] == tile and board[x][y+3] == tile:
+                return True
+    # check / diagonal spaces
+    for x in range(BOARDWIDTH - 3):
+        for y in range(3, BOARDHEIGHT):
+            if board[x][y] == tile and board[x+1][y-1] == tile and board[x+2][y-2] == tile and board[x+3][y-3] == tile:
+                return True
+    # check \ diagonal spaces
+    for x in range(BOARDWIDTH - 3):
+        for y in range(BOARDHEIGHT - 3):
+            if board[x][y] == tile and board[x+1][y+1] == tile and board[x+2][y+2] == tile and board[x+3][y+3] == tile:
+                return True
+    return False
+
+
+if __name__ == '__main__':
+    main()

Making Games with Python - W.T.E. Official Community/gemgem.py

@@ -0,0 +1,549 @@
+# Gemgem (a Bejeweled clone), by Al Sweigart al@inventwithpython.com
+# (Pygame) An addictive jewel matching game.
+
+
+
+"""
+This program has "gem data structures", which are basically dictionaries
+with the following keys:
+  'x' and 'y' - The location of the gem on the board. 0,0 is the top left.
+                There is also a ROWABOVEBOARD row that 'y' can be set to,
+                to indicate that it is above the board.
+  'direction' - one of the four constant variables UP, DOWN, LEFT, RIGHT.
+                This is the direction the gem is moving.
+  'imageNum'  - The integer index into GEMIMAGES to denote which image
+                this gem uses.
+"""
+
+import random, time, pygame, sys, copy
+from pygame.locals import *
+
+FPS = 30 # frames per second to update the screen
+WINDOWWIDTH = 600  # width of the program's window, in pixels
+WINDOWHEIGHT = 600 # height in pixels
+
+BOARDWIDTH = 8 # how many columns in the board
+BOARDHEIGHT = 8 # how many rows in the board
+GEMIMAGESIZE = 64 # width & height of each space in pixels
+
+# NUMGEMIMAGES is the number of gem types. You will need .png image
+# files named gem0.png, gem1.png, etc. up to gem(N-1).png.
+NUMGEMIMAGES = 7
+assert NUMGEMIMAGES >= 5 # game needs at least 5 types of gems to work
+
+# NUMMATCHSOUNDS is the number of different sounds to choose from when
+# a match is made. The .wav files are named match0.wav, match1.wav, etc.
+NUMMATCHSOUNDS = 6
+
+MOVERATE = 25 # 1 to 100, larger num means faster animations
+DEDUCTSPEED = 0.8 # reduces score by 1 point every DEDUCTSPEED seconds.
+
+#             R    G    B
+PURPLE    = (255,   0, 255)
+LIGHTBLUE = (170, 190, 255)
+BLUE      = (  0,   0, 255)
+RED       = (255, 100, 100)
+BLACK     = (  0,   0,   0)
+BROWN     = ( 85,  65,   0)
+HIGHLIGHTCOLOR = PURPLE # color of the selected gem's border
+BGCOLOR = LIGHTBLUE # background color on the screen
+GRIDCOLOR = BLUE # color of the game board
+GAMEOVERCOLOR = RED # color of the "Game over" text.
+GAMEOVERBGCOLOR = BLACK # background color of the "Game over" text.
+SCORECOLOR = BROWN # color of the text for the player's score
+
+# The amount of space to the sides of the board to the edge of the window
+# is used several times, so calculate it once here and store in variables.
+XMARGIN = int((WINDOWWIDTH - GEMIMAGESIZE * BOARDWIDTH) / 2)
+YMARGIN = int((WINDOWHEIGHT - GEMIMAGESIZE * BOARDHEIGHT) / 2)
+
+# constants for direction values
+UP = 'up'
+DOWN = 'down'
+LEFT = 'left'
+RIGHT = 'right'
+
+EMPTY_SPACE = -1 # an arbitrary, nonpositive value
+ROWABOVEBOARD = 'row above board' # an arbitrary, noninteger value
+
+def main():
+    global FPSCLOCK, DISPLAYSURF, GEMIMAGES, GAMESOUNDS, BASICFONT, BOARDRECTS
+
+    # Initial set up.
+    pygame.init()
+    FPSCLOCK = pygame.time.Clock()
+    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
+    pygame.display.set_caption('Gemgem')
+    BASICFONT = pygame.font.Font('freesansbold.ttf', 36)
+
+    # Load the images
+    GEMIMAGES = []
+    for i in range(1, NUMGEMIMAGES+1):
+        gemImage = pygame.image.load('gem%s.png' % i)
+        if gemImage.get_size() != (GEMIMAGESIZE, GEMIMAGESIZE):
+            gemImage = pygame.transform.smoothscale(gemImage, (GEMIMAGESIZE, GEMIMAGESIZE))
+        GEMIMAGES.append(gemImage)
+
+    # Load the sounds.
+    GAMESOUNDS = {}
+    GAMESOUNDS['bad swap'] = pygame.mixer.Sound('badswap.wav')
+    GAMESOUNDS['match'] = []
+    for i in range(NUMMATCHSOUNDS):
+        GAMESOUNDS['match'].append(pygame.mixer.Sound('match%s.wav' % i))
+
+    # Create pygame.Rect objects for each board space to
+    # do board-coordinate-to-pixel-coordinate conversions.
+    BOARDRECTS = []
+    for x in range(BOARDWIDTH):
+        BOARDRECTS.append([])
+        for y in range(BOARDHEIGHT):
+            r = pygame.Rect((XMARGIN + (x * GEMIMAGESIZE),
+                             YMARGIN + (y * GEMIMAGESIZE),
+                             GEMIMAGESIZE,
+                             GEMIMAGESIZE))
+            BOARDRECTS[x].append(r)
+
+    while True:
+        runGame()
+
+
+def runGame():
+    # Plays through a single game. When the game is over, this function returns.
+
+    # initalize the board
+    gameBoard = getBlankBoard()
+    score = 0
+    fillBoardAndAnimate(gameBoard, [], score) # Drop the initial gems.
+
+    # initialize variables for the start of a new game
+    firstSelectedGem = None
+    lastMouseDownX = None
+    lastMouseDownY = None
+    gameIsOver = False
+    lastScoreDeduction = time.time()
+    clickContinueTextSurf = None
+
+    while True: # main game loop
+        clickedSpace = None
+        for event in pygame.event.get(): # event handling loop
+            if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
+                pygame.quit()
+                sys.exit()
+            elif event.type == KEYUP and event.key == K_BACKSPACE:
+                return # start a new game
+
+            elif event.type == MOUSEBUTTONUP:
+                if gameIsOver:
+                    return # after games ends, click to start a new game
+
+                if event.pos == (lastMouseDownX, lastMouseDownY):
+                    # This event is a mouse click, not the end of a mouse drag.
+                    clickedSpace = checkForGemClick(event.pos)
+                else:
+                    # this is the end of a mouse drag
+                    firstSelectedGem = checkForGemClick((lastMouseDownX, lastMouseDownY))
+                    clickedSpace = checkForGemClick(event.pos)
+                    if not firstSelectedGem or not clickedSpace:
+                        # if not part of a valid drag, deselect both
+                        firstSelectedGem = None
+                        clickedSpace = None
+            elif event.type == MOUSEBUTTONDOWN:
+                # this is the start of a mouse click or mouse drag
+                lastMouseDownX, lastMouseDownY = event.pos
+
+        if clickedSpace and not firstSelectedGem:
+            # This was the first gem clicked on.
+            firstSelectedGem = clickedSpace
+        elif clickedSpace and firstSelectedGem:
+            # Two gems have been clicked on and selected. Swap the gems.
+            firstSwappingGem, secondSwappingGem = getSwappingGems(gameBoard, firstSelectedGem, clickedSpace)
+            if firstSwappingGem == None and secondSwappingGem == None:
+                # If both are None, then the gems were not adjacent
+                firstSelectedGem = None # deselect the first gem
+                continue
+
+            # Show the swap animation on the screen.
+            boardCopy = getBoardCopyMinusGems(gameBoard, (firstSwappingGem, secondSwappingGem))
+            animateMovingGems(boardCopy, [firstSwappingGem, secondSwappingGem], [], score)
+
+            # Swap the gems in the board data structure.
+            gameBoard[firstSwappingGem['x']][firstSwappingGem['y']] = secondSwappingGem['imageNum']
+            gameBoard[secondSwappingGem['x']][secondSwappingGem['y']] = firstSwappingGem['imageNum']
+
+            # See if this is a matching move.
+            matchedGems = findMatchingGems(gameBoard)
+            if matchedGems == []:
+                # Was not a matching move; swap the gems back
+                GAMESOUNDS['bad swap'].play()
+                animateMovingGems(boardCopy, [firstSwappingGem, secondSwappingGem], [], score)
+                gameBoard[firstSwappingGem['x']][firstSwappingGem['y']] = firstSwappingGem['imageNum']
+                gameBoard[secondSwappingGem['x']][secondSwappingGem['y']] = secondSwappingGem['imageNum']
+            else:
+                # This was a matching move.
+                scoreAdd = 0
+                while matchedGems != []:
+                    # Remove matched gems, then pull down the board.
+
+                    # points is a list of dicts that tells fillBoardAndAnimate()
+                    # where on the screen to display text to show how many
+                    # points the player got. points is a list because if
+                    # the playergets multiple matches, then multiple points text should appear.
+                    points = []
+                    for gemSet in matchedGems:
+                        scoreAdd += (10 + (len(gemSet) - 3) * 10)
+                        for gem in gemSet:
+                            gameBoard[gem[0]][gem[1]] = EMPTY_SPACE
+                        points.append({'points': scoreAdd,
+                                       'x': gem[0] * GEMIMAGESIZE + XMARGIN,
+                                       'y': gem[1] * GEMIMAGESIZE + YMARGIN})
+                    random.choice(GAMESOUNDS['match']).play()
+                    score += scoreAdd
+
+                    # Drop the new gems.
+                    fillBoardAndAnimate(gameBoard, points, score)
+
+                    # Check if there are any new matches.
+                    matchedGems = findMatchingGems(gameBoard)
+            firstSelectedGem = None
+
+            if not canMakeMove(gameBoard):
+                gameIsOver = True
+
+        # Draw the board.
+        DISPLAYSURF.fill(BGCOLOR)
+        drawBoard(gameBoard)
+        if firstSelectedGem != None:
+            highlightSpace(firstSelectedGem['x'], firstSelectedGem['y'])
+        if gameIsOver:
+            if clickContinueTextSurf == None:
+                # Only render the text once. In future iterations, just
+                # use the Surface object already in clickContinueTextSurf
+                clickContinueTextSurf = BASICFONT.render('Final Score: %s (Click to continue)' % (score), 1, GAMEOVERCOLOR, GAMEOVERBGCOLOR)
+                clickContinueTextRect = clickContinueTextSurf.get_rect()
+                clickContinueTextRect.center = int(WINDOWWIDTH / 2), int(WINDOWHEIGHT / 2)
+            DISPLAYSURF.blit(clickContinueTextSurf, clickContinueTextRect)
+        elif score > 0 and time.time() - lastScoreDeduction > DEDUCTSPEED:
+            # score drops over time
+            score -= 1
+            lastScoreDeduction = time.time()
+        drawScore(score)
+        pygame.display.update()
+        FPSCLOCK.tick(FPS)
+
+
+def getSwappingGems(board, firstXY, secondXY):
+    # If the gems at the (X, Y) coordinates of the two gems are adjacent,
+    # then their 'direction' keys are set to the appropriate direction
+    # value to be swapped with each other.
+    # Otherwise, (None, None) is returned.
+    firstGem = {'imageNum': board[firstXY['x']][firstXY['y']],
+                'x': firstXY['x'],
+                'y': firstXY['y']}
+    secondGem = {'imageNum': board[secondXY['x']][secondXY['y']],
+                 'x': secondXY['x'],
+                 'y': secondXY['y']}
+    highlightedGem = None
+    if firstGem['x'] == secondGem['x'] + 1 and firstGem['y'] == secondGem['y']:
+        firstGem['direction'] = LEFT
+        secondGem['direction'] = RIGHT
+    elif firstGem['x'] == secondGem['x'] - 1 and firstGem['y'] == secondGem['y']:
+        firstGem['direction'] = RIGHT
+        secondGem['direction'] = LEFT
+    elif firstGem['y'] == secondGem['y'] + 1 and firstGem['x'] == secondGem['x']:
+        firstGem['direction'] = UP
+        secondGem['direction'] = DOWN
+    elif firstGem['y'] == secondGem['y'] - 1 and firstGem['x'] == secondGem['x']:
+        firstGem['direction'] = DOWN
+        secondGem['direction'] = UP
+    else:
+        # These gems are not adjacent and can't be swapped.
+        return None, None
+    return firstGem, secondGem
+
+
+def getBlankBoard():
+    # Create and return a blank board data structure.
+    board = []
+    for x in range(BOARDWIDTH):
+        board.append([EMPTY_SPACE] * BOARDHEIGHT)
+    return board
+
+
+def canMakeMove(board):
+    # Return True if the board is in a state where a matching
+    # move can be made on it. Otherwise return False.
+
+    # The patterns in oneOffPatterns represent gems that are configured
+    # in a way where it only takes one move to make a triplet.
+    oneOffPatterns = (((0,1), (1,0), (2,0)),
+                      ((0,1), (1,1), (2,0)),
+                      ((0,0), (1,1), (2,0)),
+                      ((0,1), (1,0), (2,1)),
+                      ((0,0), (1,0), (2,1)),
+                      ((0,0), (1,1), (2,1)),
+                      ((0,0), (0,2), (0,3)),
+                      ((0,0), (0,1), (0,3)))
+
+    # The x and y variables iterate over each space on the board.
+    # If we use + to represent the currently iterated space on the
+    # board, then this pattern: ((0,1), (1,0), (2,0))refers to identical
+    # gems being set up like this:
+    #
+    #     +A
+    #     B
+    #     C
+    #
+    # That is, gem A is offset from the + by (0,1), gem B is offset
+    # by (1,0), and gem C is offset by (2,0). In this case, gem A can
+    # be swapped to the left to form a vertical three-in-a-row triplet.
+    #
+    # There are eight possible ways for the gems to be one move
+    # away from forming a triple, hence oneOffPattern has 8 patterns.
+
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT):
+            for pat in oneOffPatterns:
+                # check each possible pattern of "match in next move" to
+                # see if a possible move can be made.
+                if (getGemAt(board, x+pat[0][0], y+pat[0][1]) == \
+                    getGemAt(board, x+pat[1][0], y+pat[1][1]) == \
+                    getGemAt(board, x+pat[2][0], y+pat[2][1]) != None) or \
+                   (getGemAt(board, x+pat[0][1], y+pat[0][0]) == \
+                    getGemAt(board, x+pat[1][1], y+pat[1][0]) == \
+                    getGemAt(board, x+pat[2][1], y+pat[2][0]) != None):
+                    return True # return True the first time you find a pattern
+    return False
+
+
+def drawMovingGem(gem, progress):
+    # Draw a gem sliding in the direction that its 'direction' key
+    # indicates. The progress parameter is a number from 0 (just
+    # starting) to 100 (slide complete).
+    movex = 0
+    movey = 0
+    progress *= 0.01
+
+    if gem['direction'] == UP:
+        movey = -int(progress * GEMIMAGESIZE)
+    elif gem['direction'] == DOWN:
+        movey = int(progress * GEMIMAGESIZE)
+    elif gem['direction'] == RIGHT:
+        movex = int(progress * GEMIMAGESIZE)
+    elif gem['direction'] == LEFT:
+        movex = -int(progress * GEMIMAGESIZE)
+
+    basex = gem['x']
+    basey = gem['y']
+    if basey == ROWABOVEBOARD:
+        basey = -1
+
+    pixelx = XMARGIN + (basex * GEMIMAGESIZE)
+    pixely = YMARGIN + (basey * GEMIMAGESIZE)
+    r = pygame.Rect( (pixelx + movex, pixely + movey, GEMIMAGESIZE, GEMIMAGESIZE) )
+    DISPLAYSURF.blit(GEMIMAGES[gem['imageNum']], r)
+
+
+def pullDownAllGems(board):
+    # pulls down gems on the board to the bottom to fill in any gaps
+    for x in range(BOARDWIDTH):
+        gemsInColumn = []
+        for y in range(BOARDHEIGHT):
+            if board[x][y] != EMPTY_SPACE:
+                gemsInColumn.append(board[x][y])
+        board[x] = ([EMPTY_SPACE] * (BOARDHEIGHT - len(gemsInColumn))) + gemsInColumn
+
+
+def getGemAt(board, x, y):
+    if x < 0 or y < 0 or x >= BOARDWIDTH or y >= BOARDHEIGHT:
+        return None
+    else:
+        return board[x][y]
+
+
+def getDropSlots(board):
+    # Creates a "drop slot" for each column and fills the slot with a
+    # number of gems that that column is lacking. This function assumes
+    # that the gems have been gravity dropped already.
+    boardCopy = copy.deepcopy(board)
+    pullDownAllGems(boardCopy)
+
+    dropSlots = []
+    for i in range(BOARDWIDTH):
+        dropSlots.append([])
+
+    # count the number of empty spaces in each column on the board
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT-1, -1, -1): # start from bottom, going up
+            if boardCopy[x][y] == EMPTY_SPACE:
+                possibleGems = list(range(len(GEMIMAGES)))
+                for offsetX, offsetY in ((0, -1), (1, 0), (0, 1), (-1, 0)):
+                    # Narrow down the possible gems we should put in the
+                    # blank space so we don't end up putting an two of
+                    # the same gems next to each other when they drop.
+                    neighborGem = getGemAt(boardCopy, x + offsetX, y + offsetY)
+                    if neighborGem != None and neighborGem in possibleGems:
+                        possibleGems.remove(neighborGem)
+
+                newGem = random.choice(possibleGems)
+                boardCopy[x][y] = newGem
+                dropSlots[x].append(newGem)
+    return dropSlots
+
+
+def findMatchingGems(board):
+    gemsToRemove = [] # a list of lists of gems in matching triplets that should be removed
+    boardCopy = copy.deepcopy(board)
+
+    # loop through each space, checking for 3 adjacent identical gems
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT):
+            # look for horizontal matches
+            if getGemAt(boardCopy, x, y) == getGemAt(boardCopy, x + 1, y) == getGemAt(boardCopy, x + 2, y) and getGemAt(boardCopy, x, y) != EMPTY_SPACE:
+                targetGem = boardCopy[x][y]
+                offset = 0
+                removeSet = []
+                while getGemAt(boardCopy, x + offset, y) == targetGem:
+                    # keep checking if there's more than 3 gems in a row
+                    removeSet.append((x + offset, y))
+                    boardCopy[x + offset][y] = EMPTY_SPACE
+                    offset += 1
+                gemsToRemove.append(removeSet)
+
+            # look for vertical matches
+            if getGemAt(boardCopy, x, y) == getGemAt(boardCopy, x, y + 1) == getGemAt(boardCopy, x, y + 2) and getGemAt(boardCopy, x, y) != EMPTY_SPACE:
+                targetGem = boardCopy[x][y]
+                offset = 0
+                removeSet = []
+                while getGemAt(boardCopy, x, y + offset) == targetGem:
+                    # keep checking, in case there's more than 3 gems in a row
+                    removeSet.append((x, y + offset))
+                    boardCopy[x][y + offset] = EMPTY_SPACE
+                    offset += 1
+                gemsToRemove.append(removeSet)
+
+    return gemsToRemove
+
+
+def highlightSpace(x, y):
+    pygame.draw.rect(DISPLAYSURF, HIGHLIGHTCOLOR, BOARDRECTS[x][y], 4)
+
+
+def getDroppingGems(board):
+    # Find all the gems that have an empty space below them
+    boardCopy = copy.deepcopy(board)
+    droppingGems = []
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT - 2, -1, -1):
+            if boardCopy[x][y + 1] == EMPTY_SPACE and boardCopy[x][y] != EMPTY_SPACE:
+                # This space drops if not empty but the space below it is
+                droppingGems.append( {'imageNum': boardCopy[x][y], 'x': x, 'y': y, 'direction': DOWN} )
+                boardCopy[x][y] = EMPTY_SPACE
+    return droppingGems
+
+
+def animateMovingGems(board, gems, pointsText, score):
+    # pointsText is a dictionary with keys 'x', 'y', and 'points'
+    progress = 0 # progress at 0 represents beginning, 100 means finished.
+    while progress < 100: # animation loop
+        DISPLAYSURF.fill(BGCOLOR)
+        drawBoard(board)
+        for gem in gems: # Draw each gem.
+            drawMovingGem(gem, progress)
+        drawScore(score)
+        for pointText in pointsText:
+            pointsSurf = BASICFONT.render(str(pointText['points']), 1, SCORECOLOR)
+            pointsRect = pointsSurf.get_rect()
+            pointsRect.center = (pointText['x'], pointText['y'])
+            DISPLAYSURF.blit(pointsSurf, pointsRect)
+
+        pygame.display.update()
+        FPSCLOCK.tick(FPS)
+        progress += MOVERATE # progress the animation a little bit more for the next frame
+
+
+def moveGems(board, movingGems):
+    # movingGems is a list of dicts with keys x, y, direction, imageNum
+    for gem in movingGems:
+        if gem['y'] != ROWABOVEBOARD:
+            board[gem['x']][gem['y']] = EMPTY_SPACE
+            movex = 0
+            movey = 0
+            if gem['direction'] == LEFT:
+                movex = -1
+            elif gem['direction'] == RIGHT:
+                movex = 1
+            elif gem['direction'] == DOWN:
+                movey = 1
+            elif gem['direction'] == UP:
+                movey = -1
+            board[gem['x'] + movex][gem['y'] + movey] = gem['imageNum']
+        else:
+            # gem is located above the board (where new gems come from)
+            board[gem['x']][0] = gem['imageNum'] # move to top row
+
+
+def fillBoardAndAnimate(board, points, score):
+    dropSlots = getDropSlots(board)
+    while dropSlots != [[]] * BOARDWIDTH:
+        # do the dropping animation as long as there are more gems to drop
+        movingGems = getDroppingGems(board)
+        for x in range(len(dropSlots)):
+            if len(dropSlots[x]) != 0:
+                # cause the lowest gem in each slot to begin moving in the DOWN direction
+                movingGems.append({'imageNum': dropSlots[x][0], 'x': x, 'y': ROWABOVEBOARD, 'direction': DOWN})
+
+        boardCopy = getBoardCopyMinusGems(board, movingGems)
+        animateMovingGems(boardCopy, movingGems, points, score)
+        moveGems(board, movingGems)
+
+        # Make the next row of gems from the drop slots
+        # the lowest by deleting the previous lowest gems.
+        for x in range(len(dropSlots)):
+            if len(dropSlots[x]) == 0:
+                continue
+            board[x][0] = dropSlots[x][0]
+            del dropSlots[x][0]
+
+
+def checkForGemClick(pos):
+    # See if the mouse click was on the board
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT):
+            if BOARDRECTS[x][y].collidepoint(pos[0], pos[1]):
+                return {'x': x, 'y': y}
+    return None # Click was not on the board.
+
+
+def drawBoard(board):
+    for x in range(BOARDWIDTH):
+        for y in range(BOARDHEIGHT):
+            pygame.draw.rect(DISPLAYSURF, GRIDCOLOR, BOARDRECTS[x][y], 1)
+            gemToDraw = board[x][y]
+            if gemToDraw != EMPTY_SPACE:
+                DISPLAYSURF.blit(GEMIMAGES[gemToDraw], BOARDRECTS[x][y])
+
+
+def getBoardCopyMinusGems(board, gems):
+    # Creates and returns a copy of the passed board data structure,
+    # with the gems in the "gems" list removed from it.
+    #
+    # Gems is a list of dicts, with keys x, y, direction, imageNum
+
+    boardCopy = copy.deepcopy(board)
+
+    # Remove some of the gems from this board data structure copy.
+    for gem in gems:
+        if gem['y'] != ROWABOVEBOARD:
+            boardCopy[gem['x']][gem['y']] = EMPTY_SPACE
+    return boardCopy
+
+
+def drawScore(score):
+    scoreImg = BASICFONT.render(str(score), 1, SCORECOLOR)
+    scoreRect = scoreImg.get_rect()
+    scoreRect.bottomleft = (10, WINDOWHEIGHT - 6)
+    DISPLAYSURF.blit(scoreImg, scoreRect)
+
+
+if __name__ == '__main__':
+    main()