Puzzle Game In Python With Source Code

November 2, 2021August 14, 2020 by angel jude suarez

Puzzle Game In Python With Source Code

The Puzzle Game In Python is written in python programming language, This Puzzle Game Code In Python, there is a 4*4 board with 15 numbers. The numbers are then shuffled randomly. In this tutorial i will teach you on how to create a Memory Puzzle Game In Python.

A game Python Puzzle Game has steps to be follow, first is to move the number tiles into the empty tile space until the tiles are back in their original order from 1-15.

Anyway if you want level up your knowledge in programming especially games in python, try this new article I’ve made for you Code For Game in Python: Python Game Projects With Source Code

This Puzzle Game In Python also includes a downloadable Source Code For Puzzle Game In Python for free, just find the downloadable source code below and click to start downloading.

Watch the video here to see the full running puzzle game in python with source code.

To start creating a Puzzle Game In Python, make sure that you have PyCharm IDE installed in your computer.

By the way if you are new to python programming and you don’t know what would be the the Python IDE to use, I have here a list of Best Python IDE for Windows, Linux, Mac OS that will suit for you. I also have here How to Download and Install Latest Version of Python on Windows.

Steps on how to create a Puzzle Game In Python

Puzzle Game In Python With Source Code

Step 1: Create a project name.
First open Pycharm IDE and then create a “project name” after creating a project name click the “create” button.
Step 2: Create a python file.
Second after creating a project name, “right click” your project name and then click “new” after that click the “python file“.
Step 3: Name your python file.
Third after creating a python file, Name your python file after that click “enter“.
Step 4: The actual code.
You are free to copy the code given below and download the full source code below.

The Code Given Below Is For Importing Modules or Libraries

import pygame, sys, random
from pygame.locals import *

1 2	import pygame, sys, random from pygame.locals import *

The code given which is importing all modules or libraries.

The Code Given Below Is For The Design Of The Puzzle

# Create the constants (go ahead and experiment with different values)
BOARDWIDTH = 4  # number of columns in the board
BOARDHEIGHT = 4 # number of rows in the board
TILESIZE = 80
WINDOWWIDTH = 640
WINDOWHEIGHT = 480
FPS = 30
BLANK = None

#                 R    G    B
BLACK =         (  0,   0,   0)
WHITE =         (255, 255, 255)
BRIGHTBLUE =    (  0,  50, 255)
DARKTURQUOISE = (  3,  54,  73)
BLUE =         (  0,  50, 255)
GREEN =        (  0, 128,   0)
RED =           (255, 0, 0)
BGCOLOR = DARKTURQUOISE
TILECOLOR = BLUE
TEXTCOLOR = WHITE
BORDERCOLOR = RED
BASICFONTSIZE = 20
TEXT = GREEN

BUTTONCOLOR = WHITE
BUTTONTEXTCOLOR = BLACK
MESSAGECOLOR = WHITE

XMARGIN = int((WINDOWWIDTH - (TILESIZE * BOARDWIDTH + (BOARDWIDTH - 1))) / 2)
YMARGIN = int((WINDOWHEIGHT - (TILESIZE * BOARDHEIGHT + (BOARDHEIGHT - 1))) / 2)

UP = 'up'
DOWN = 'down'
LEFT = 'left'
RIGHT = 'right'

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

# Create the constants (go ahead and experiment with different values)

BOARDWIDTH = 4 # number of columns in the board

BOARDHEIGHT = 4 # number of rows in the board

TILESIZE = 80

WINDOWWIDTH = 640

WINDOWHEIGHT = 480

FPS = 30

BLANK = None

# R G B

BLACK = ( 0, 0, 0)

WHITE = (255, 255, 255)

BRIGHTBLUE = ( 0, 50, 255)

DARKTURQUOISE = ( 3, 54, 73)

BLUE = ( 0, 50, 255)

GREEN = ( 0, 128, 0)

RED = (255, 0, 0)

BGCOLOR = DARKTURQUOISE

TILECOLOR = BLUE

TEXTCOLOR = WHITE

BORDERCOLOR = RED

BASICFONTSIZE = 20

TEXT = GREEN

BUTTONCOLOR = WHITE

BUTTONTEXTCOLOR = BLACK

MESSAGECOLOR = WHITE

XMARGIN = int((WINDOWWIDTH - (TILESIZE * BOARDWIDTH + (BOARDWIDTH - 1))) / 2)

YMARGIN = int((WINDOWHEIGHT - (TILESIZE * BOARDHEIGHT + (BOARDHEIGHT - 1))) / 2)

UP = 'up'

DOWN = 'down'

LEFT = 'left'

RIGHT = 'right'

The code given which is declaring the design of the puzzle window, on its size of tiles, color, border,margins and background color.

The Code Given Below Is For The Main Module

def main():
    global FPSCLOCK, DISPLAYSURF, BASICFONT, RESET_SURF, RESET_RECT, NEW_SURF, NEW_RECT, SOLVE_SURF, SOLVE_RECT

    pygame.init()
    FPSCLOCK = pygame.time.Clock()
    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
    pygame.display.set_caption('Slide Puzzle')
    BASICFONT = pygame.font.Font('freesansbold.ttf', BASICFONTSIZE)

    # Store the option buttons and their rectangles in OPTIONS.
    RESET_SURF, RESET_RECT = makeText('Reset',    TEXT, BGCOLOR, WINDOWWIDTH - 120, WINDOWHEIGHT - 310)
    NEW_SURF,   NEW_RECT   = makeText('New Game', TEXT, BGCOLOR, WINDOWWIDTH - 120, WINDOWHEIGHT - 280)
    SOLVE_SURF, SOLVE_RECT = makeText('Solve',    TEXT, BGCOLOR, WINDOWWIDTH - 120, WINDOWHEIGHT - 250)

    mainBoard, solutionSeq = generateNewPuzzle(80)
    SOLVEDBOARD = getStartingBoard() # a solved board is the same as the board in a start state.
    allMoves = &#91;] # list of moves made from the solved configuration

    while True: # main game loop
        slideTo = None # the direction, if any, a tile should slide
        msg = 'Click tile or press arrow keys to slide.' # contains the message to show in the upper left corner.
        if mainBoard == SOLVEDBOARD:
            msg = 'Solved!'

        drawBoard(mainBoard, msg)

        checkForQuit()
        for event in pygame.event.get(): # event handling loop
            if event.type == MOUSEBUTTONUP:
                spotx, spoty = getSpotClicked(mainBoard, event.pos&#91;0], event.pos&#91;1])

                if (spotx, spoty) == (None, None):
                    # check if the user clicked on an option button
                    if RESET_RECT.collidepoint(event.pos):
                        resetAnimation(mainBoard, allMoves) # clicked on Reset button
                        allMoves = &#91;]
                    elif NEW_RECT.collidepoint(event.pos):
                        mainBoard, solutionSeq = generateNewPuzzle(80) # clicked on New Game button
                        allMoves = &#91;]
                    elif SOLVE_RECT.collidepoint(event.pos):
                        resetAnimation(mainBoard, solutionSeq + allMoves) # clicked on Solve button
                        allMoves = &#91;]
                else:
                    # check if the clicked tile was next to the blank spot

                    blankx, blanky = getBlankPosition(mainBoard)
                    if spotx == blankx + 1 and spoty == blanky:
                        slideTo = LEFT
                    elif spotx == blankx - 1 and spoty == blanky:
                        slideTo = RIGHT
                    elif spotx == blankx and spoty == blanky + 1:
                        slideTo = UP
                    elif spotx == blankx and spoty == blanky - 1:
                        slideTo = DOWN

            elif event.type == KEYUP:
                # check if the user pressed a key to slide a tile
                if event.key in (K_LEFT, K_a) and isValidMove(mainBoard, LEFT):
                    slideTo = LEFT
                elif event.key in (K_RIGHT, K_d) and isValidMove(mainBoard, RIGHT):
                    slideTo = RIGHT
                elif event.key in (K_UP, K_w) and isValidMove(mainBoard, UP):
                    slideTo = UP
                elif event.key in (K_DOWN, K_s) and isValidMove(mainBoard, DOWN):
                    slideTo = DOWN

        if slideTo:
            slideAnimation(mainBoard, slideTo, 'Click tile or press arrow keys to slide.', 8) # show slide on screen
            makeMove(mainBoard, slideTo)
            allMoves.append(slideTo) # record the slide
        pygame.display.update()
        FPSCLOCK.tick(FPS)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

def main():

global FPSCLOCK, DISPLAYSURF, BASICFONT, RESET_SURF, RESET_RECT, NEW_SURF, NEW_RECT, SOLVE_SURF, SOLVE_RECT

pygame.init()

FPSCLOCK = pygame.time.Clock()

DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))

pygame.display.set_caption('Slide Puzzle')

BASICFONT = pygame.font.Font('freesansbold.ttf', BASICFONTSIZE)

# Store the option buttons and their rectangles in OPTIONS.

RESET_SURF, RESET_RECT = makeText('Reset', TEXT, BGCOLOR, WINDOWWIDTH - 120, WINDOWHEIGHT - 310)

NEW_SURF, NEW_RECT = makeText('New Game', TEXT, BGCOLOR, WINDOWWIDTH - 120, WINDOWHEIGHT - 280)

SOLVE_SURF, SOLVE_RECT = makeText('Solve', TEXT, BGCOLOR, WINDOWWIDTH - 120, WINDOWHEIGHT - 250)

mainBoard, solutionSeq = generateNewPuzzle(80)

SOLVEDBOARD = getStartingBoard() # a solved board is the same as the board in a start state.

allMoves = [] # list of moves made from the solved configuration

while True: # main game loop

slideTo = None # the direction, if any, a tile should slide

msg = 'Click tile or press arrow keys to slide.' # contains the message to show in the upper left corner.

if mainBoard == SOLVEDBOARD:

msg = 'Solved!'

drawBoard(mainBoard, msg)

checkForQuit()

for event in pygame.event.get(): # event handling loop

if event.type == MOUSEBUTTONUP:

spotx, spoty = getSpotClicked(mainBoard, event.pos[0], event.pos[1])

if (spotx, spoty) == (None, None):

# check if the user clicked on an option button

if RESET_RECT.collidepoint(event.pos):

resetAnimation(mainBoard, allMoves) # clicked on Reset button

allMoves = []

elif NEW_RECT.collidepoint(event.pos):

mainBoard, solutionSeq = generateNewPuzzle(80) # clicked on New Game button

allMoves = []

elif SOLVE_RECT.collidepoint(event.pos):

resetAnimation(mainBoard, solutionSeq + allMoves) # clicked on Solve button

allMoves = []

else:

# check if the clicked tile was next to the blank spot

blankx, blanky = getBlankPosition(mainBoard)

if spotx == blankx + 1 and spoty == blanky:

slideTo = LEFT

elif spotx == blankx - 1 and spoty == blanky:

slideTo = RIGHT

elif spotx == blankx and spoty == blanky + 1:

slideTo = UP

elif spotx == blankx and spoty == blanky - 1:

slideTo = DOWN

elif event.type == KEYUP:

# check if the user pressed a key to slide a tile

if event.key in (K_LEFT, K_a) and isValidMove(mainBoard, LEFT):

slideTo = LEFT

elif event.key in (K_RIGHT, K_d) and isValidMove(mainBoard, RIGHT):

slideTo = RIGHT

elif event.key in (K_UP, K_w) and isValidMove(mainBoard, UP):

slideTo = UP

elif event.key in (K_DOWN, K_s) and isValidMove(mainBoard, DOWN):

slideTo = DOWN

if slideTo:

slideAnimation(mainBoard, slideTo, 'Click tile or press arrow keys to slide.', 8) # show slide on screen

makeMove(mainBoard, slideTo)

allMoves.append(slideTo) # record the slide

pygame.display.update()

FPSCLOCK.tick(FPS)

In this module which is the main module of the puzzle game.

The Code Given Below Is The Module Exit

def terminate():
    pygame.quit()
    sys.exit()

1

2

3

def terminate():

pygame.quit()

sys.exit()

In this module which is the exit module of the puzzle game.

The Code Given Below Is For The Making Move Module

def makeMove(board, move):
    # This function does not check if the move is valid.
    blankx, blanky = getBlankPosition(board)

    if move == UP:
        board&#91;blankx]&#91;blanky], board&#91;blankx]&#91;blanky + 1] = board&#91;blankx]&#91;blanky + 1], board&#91;blankx]&#91;blanky]
    elif move == DOWN:
        board&#91;blankx]&#91;blanky], board&#91;blankx]&#91;blanky - 1] = board&#91;blankx]&#91;blanky - 1], board&#91;blankx]&#91;blanky]
    elif move == LEFT:
        board&#91;blankx]&#91;blanky], board&#91;blankx + 1]&#91;blanky] = board&#91;blankx + 1]&#91;blanky], board&#91;blankx]&#91;blanky]
    elif move == RIGHT:
        board&#91;blankx]&#91;blanky], board&#91;blankx - 1]&#91;blanky] = board&#91;blankx - 1]&#91;blanky], board&#91;blankx]&#91;blanky]

1

2

3

4

5

6

7

8

9

10

11

12

def makeMove(board, move):

# This function does not check if the move is valid.

blankx, blanky = getBlankPosition(board)

if move == UP:

board[blankx][blanky], board[blankx][blanky + 1] = board[blankx][blanky + 1], board[blankx][blanky]

elif move == DOWN:

board[blankx][blanky], board[blankx][blanky - 1] = board[blankx][blanky - 1], board[blankx][blanky]

elif move == LEFT:

board[blankx][blanky], board[blankx + 1][blanky] = board[blankx + 1][blanky], board[blankx][blanky]

elif move == RIGHT:

board[blankx][blanky], board[blankx - 1][blanky] = board[blankx - 1][blanky], board[blankx][blanky]

In this module which is the condition when a player make move.

The Code Given Below Is For The Random Move Module

def getRandomMove(board, lastMove=None):
    # start with a full list of all four moves
    validMoves = &#91;UP, DOWN, LEFT, RIGHT]

    # remove moves from the list as they are disqualified
    if lastMove == UP or not isValidMove(board, DOWN):
        validMoves.remove(DOWN)
    if lastMove == DOWN or not isValidMove(board, UP):
        validMoves.remove(UP)
    if lastMove == LEFT or not isValidMove(board, RIGHT):
        validMoves.remove(RIGHT)
    if lastMove == RIGHT or not isValidMove(board, LEFT):
        validMoves.remove(LEFT)

    # return a random move from the list of remaining moves
    return random.choice(validMoves)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

def getRandomMove(board, lastMove=None):

# start with a full list of all four moves

validMoves = [UP, DOWN, LEFT, RIGHT]

# remove moves from the list as they are disqualified

if lastMove == UP or not isValidMove(board, DOWN):

validMoves.remove(DOWN)

if lastMove == DOWN or not isValidMove(board, UP):

validMoves.remove(UP)

if lastMove == LEFT or not isValidMove(board, RIGHT):

validMoves.remove(RIGHT)

if lastMove == RIGHT or not isValidMove(board, LEFT):

validMoves.remove(LEFT)

# return a random move from the list of remaining moves

return random.choice(validMoves)

In this module which is getting the random move.

The Code Given Below Is For The Generate New Puzzle Module

def generateNewPuzzle(numSlides):
    # From a starting configuration, make numSlides number of moves (and
    # animate these moves).
    sequence = &#91;]
    board = getStartingBoard()
    drawBoard(board, '')
    pygame.display.update()
    pygame.time.wait(500) # pause 500 milliseconds for effect
    lastMove = None
    for i in range(numSlides):
        move = getRandomMove(board, lastMove)
        slideAnimation(board, move, 'Generating new puzzle...', animationSpeed=int(TILESIZE / 3))
        makeMove(board, move)
        sequence.append(move)
        lastMove = move
    return (board, sequence)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

def generateNewPuzzle(numSlides):

# From a starting configuration, make numSlides number of moves (and

# animate these moves).

sequence = []

board = getStartingBoard()

drawBoard(board, '')

pygame.display.update()

pygame.time.wait(500) # pause 500 milliseconds for effect

lastMove = None

for i in range(numSlides):

move = getRandomMove(board, lastMove)

slideAnimation(board, move, 'Generating new puzzle...', animationSpeed=int(TILESIZE / 3))

makeMove(board, move)

sequence.append(move)

lastMove = move

return (board, sequence)

In this module which is generating new puzzle.

Complete Source Code

import pygame, sys, random
from pygame.locals import *

# Create the constants (go ahead and experiment with different values)
BOARDWIDTH = 4  # number of columns in the board
BOARDHEIGHT = 4 # number of rows in the board
TILESIZE = 80
WINDOWWIDTH = 640
WINDOWHEIGHT = 480
FPS = 30
BLANK = None

#                 R    G    B
BLACK =         (  0,   0,   0)
WHITE =         (255, 255, 255)
BRIGHTBLUE =    (  0,  50, 255)
DARKTURQUOISE = (  3,  54,  73)
BLUE =         (  0,  50, 255)
GREEN =        (  0, 128,   0)
RED =           (255, 0, 0)
BGCOLOR = DARKTURQUOISE
TILECOLOR = BLUE
TEXTCOLOR = WHITE
BORDERCOLOR = RED
BASICFONTSIZE = 20
TEXT = GREEN

BUTTONCOLOR = WHITE
BUTTONTEXTCOLOR = BLACK
MESSAGECOLOR = WHITE

XMARGIN = int((WINDOWWIDTH - (TILESIZE * BOARDWIDTH + (BOARDWIDTH - 1))) / 2)
YMARGIN = int((WINDOWHEIGHT - (TILESIZE * BOARDHEIGHT + (BOARDHEIGHT - 1))) / 2)

UP = 'up'
DOWN = 'down'
LEFT = 'left'
RIGHT = 'right'

def main():
    global FPSCLOCK, DISPLAYSURF, BASICFONT, RESET_SURF, RESET_RECT, NEW_SURF, NEW_RECT, SOLVE_SURF, SOLVE_RECT

    pygame.init()
    FPSCLOCK = pygame.time.Clock()
    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
    pygame.display.set_caption('Slide Puzzle')
    BASICFONT = pygame.font.Font('freesansbold.ttf', BASICFONTSIZE)

    # Store the option buttons and their rectangles in OPTIONS.
    RESET_SURF, RESET_RECT = makeText('Reset',    TEXT, BGCOLOR, WINDOWWIDTH - 120, WINDOWHEIGHT - 310)
    NEW_SURF,   NEW_RECT   = makeText('New Game', TEXT, BGCOLOR, WINDOWWIDTH - 120, WINDOWHEIGHT - 280)
    SOLVE_SURF, SOLVE_RECT = makeText('Solve',    TEXT, BGCOLOR, WINDOWWIDTH - 120, WINDOWHEIGHT - 250)

    mainBoard, solutionSeq = generateNewPuzzle(80)
    SOLVEDBOARD = getStartingBoard() # a solved board is the same as the board in a start state.
    allMoves = &#91;] # list of moves made from the solved configuration

    while True: # main game loop
        slideTo = None # the direction, if any, a tile should slide
        msg = 'Click tile or press arrow keys to slide.' # contains the message to show in the upper left corner.
        if mainBoard == SOLVEDBOARD:
            msg = 'Solved!'

        drawBoard(mainBoard, msg)

        checkForQuit()
        for event in pygame.event.get(): # event handling loop
            if event.type == MOUSEBUTTONUP:
                spotx, spoty = getSpotClicked(mainBoard, event.pos&#91;0], event.pos&#91;1])

                if (spotx, spoty) == (None, None):
                    # check if the user clicked on an option button
                    if RESET_RECT.collidepoint(event.pos):
                        resetAnimation(mainBoard, allMoves) # clicked on Reset button
                        allMoves = &#91;]
                    elif NEW_RECT.collidepoint(event.pos):
                        mainBoard, solutionSeq = generateNewPuzzle(80) # clicked on New Game button
                        allMoves = &#91;]
                    elif SOLVE_RECT.collidepoint(event.pos):
                        resetAnimation(mainBoard, solutionSeq + allMoves) # clicked on Solve button
                        allMoves = &#91;]
                else:
                    # check if the clicked tile was next to the blank spot

                    blankx, blanky = getBlankPosition(mainBoard)
                    if spotx == blankx + 1 and spoty == blanky:
                        slideTo = LEFT
                    elif spotx == blankx - 1 and spoty == blanky:
                        slideTo = RIGHT
                    elif spotx == blankx and spoty == blanky + 1:
                        slideTo = UP
                    elif spotx == blankx and spoty == blanky - 1:
                        slideTo = DOWN

            elif event.type == KEYUP:
                # check if the user pressed a key to slide a tile
                if event.key in (K_LEFT, K_a) and isValidMove(mainBoard, LEFT):
                    slideTo = LEFT
                elif event.key in (K_RIGHT, K_d) and isValidMove(mainBoard, RIGHT):
                    slideTo = RIGHT
                elif event.key in (K_UP, K_w) and isValidMove(mainBoard, UP):
                    slideTo = UP
                elif event.key in (K_DOWN, K_s) and isValidMove(mainBoard, DOWN):
                    slideTo = DOWN

        if slideTo:
            slideAnimation(mainBoard, slideTo, 'Click tile or press arrow keys to slide.', 8) # show slide on screen
            makeMove(mainBoard, slideTo)
            allMoves.append(slideTo) # record the slide
        pygame.display.update()
        FPSCLOCK.tick(FPS)


def terminate():
    pygame.quit()
    sys.exit()


def checkForQuit():
    for event in pygame.event.get(QUIT): # get all the QUIT events
        terminate() # terminate if any QUIT events are present
    for event in pygame.event.get(KEYUP): # get all the KEYUP events
        if event.key == K_ESCAPE:
            terminate() # terminate if the KEYUP event was for the Esc key
        pygame.event.post(event) # put the other KEYUP event objects back


def getStartingBoard():
    # Return a board data structure with tiles in the solved state.
    # For example, if BOARDWIDTH and BOARDHEIGHT are both 3, this function
    # returns &#91;&#91;1, 4, 7], &#91;2, 5, 8], &#91;3, 6, BLANK]]
    counter = 1
    board = &#91;]
    for x in range(BOARDWIDTH):
        column = &#91;]
        for y in range(BOARDHEIGHT):
            column.append(counter)
            counter += BOARDWIDTH
        board.append(column)
        counter -= BOARDWIDTH * (BOARDHEIGHT - 1) + BOARDWIDTH - 1

    board&#91;BOARDWIDTH-1]&#91;BOARDHEIGHT-1] = BLANK
    return board


def getBlankPosition(board):
    # Return the x and y of board coordinates of the blank space.
    for x in range(BOARDWIDTH):
        for y in range(BOARDHEIGHT):
            if board&#91;x]&#91;y] == BLANK:
                return (x, y)


def makeMove(board, move):
    # This function does not check if the move is valid.
    blankx, blanky = getBlankPosition(board)

    if move == UP:
        board&#91;blankx]&#91;blanky], board&#91;blankx]&#91;blanky + 1] = board&#91;blankx]&#91;blanky + 1], board&#91;blankx]&#91;blanky]
    elif move == DOWN:
        board&#91;blankx]&#91;blanky], board&#91;blankx]&#91;blanky - 1] = board&#91;blankx]&#91;blanky - 1], board&#91;blankx]&#91;blanky]
    elif move == LEFT:
        board&#91;blankx]&#91;blanky], board&#91;blankx + 1]&#91;blanky] = board&#91;blankx + 1]&#91;blanky], board&#91;blankx]&#91;blanky]
    elif move == RIGHT:
        board&#91;blankx]&#91;blanky], board&#91;blankx - 1]&#91;blanky] = board&#91;blankx - 1]&#91;blanky], board&#91;blankx]&#91;blanky]


def isValidMove(board, move):
    blankx, blanky = getBlankPosition(board)
    return (move == UP and blanky != len(board&#91;0]) - 1) or \
           (move == DOWN and blanky != 0) or \
           (move == LEFT and blankx != len(board) - 1) or \
           (move == RIGHT and blankx != 0)


def getRandomMove(board, lastMove=None):
    # start with a full list of all four moves
    validMoves = &#91;UP, DOWN, LEFT, RIGHT]

    # remove moves from the list as they are disqualified
    if lastMove == UP or not isValidMove(board, DOWN):
        validMoves.remove(DOWN)
    if lastMove == DOWN or not isValidMove(board, UP):
        validMoves.remove(UP)
    if lastMove == LEFT or not isValidMove(board, RIGHT):
        validMoves.remove(RIGHT)
    if lastMove == RIGHT or not isValidMove(board, LEFT):
        validMoves.remove(LEFT)

    # return a random move from the list of remaining moves
    return random.choice(validMoves)


def getLeftTopOfTile(tileX, tileY):
    left = XMARGIN + (tileX * TILESIZE) + (tileX - 1)
    top = YMARGIN + (tileY * TILESIZE) + (tileY - 1)
    return (left, top)


def getSpotClicked(board, x, y):
    # from the x &amp; y pixel coordinates, get the x &amp; y board coordinates
    for tileX in range(len(board)):
        for tileY in range(len(board&#91;0])):
            left, top = getLeftTopOfTile(tileX, tileY)
            tileRect = pygame.Rect(left, top, TILESIZE, TILESIZE)
            if tileRect.collidepoint(x, y):
                return (tileX, tileY)
    return (None, None)


def drawTile(tilex, tiley, number, adjx=0, adjy=0):
    # draw a tile at board coordinates tilex and tiley, optionally a few
    # pixels over (determined by adjx and adjy)
    left, top = getLeftTopOfTile(tilex, tiley)
    pygame.draw.rect(DISPLAYSURF, TILECOLOR, (left + adjx, top + adjy, TILESIZE, TILESIZE))
    textSurf = BASICFONT.render(str(number), True, TEXTCOLOR)
    textRect = textSurf.get_rect()
    textRect.center = left + int(TILESIZE / 2) + adjx, top + int(TILESIZE / 2) + adjy
    DISPLAYSURF.blit(textSurf, textRect)


def makeText(text, color, bgcolor, top, left):
    # create the Surface and Rect objects for some text.
    textSurf = BASICFONT.render(text, True, color, bgcolor)
    textRect = textSurf.get_rect()
    textRect.topleft = (top, left)
    return (textSurf, textRect)


def drawBoard(board, message):
    DISPLAYSURF.fill(BGCOLOR)
    if message:
        textSurf, textRect = makeText(message, MESSAGECOLOR, BGCOLOR, 5, 5)
        DISPLAYSURF.blit(textSurf, textRect)

    for tilex in range(len(board)):
        for tiley in range(len(board&#91;0])):
            if board&#91;tilex]&#91;tiley]:
                drawTile(tilex, tiley, board&#91;tilex]&#91;tiley])

    left, top = getLeftTopOfTile(0, 0)
    width = BOARDWIDTH * TILESIZE
    height = BOARDHEIGHT * TILESIZE
    pygame.draw.rect(DISPLAYSURF, BORDERCOLOR, (left - 5, top - 5, width + 11, height + 11), 4)

    DISPLAYSURF.blit(RESET_SURF, RESET_RECT)
    DISPLAYSURF.blit(NEW_SURF, NEW_RECT)
    DISPLAYSURF.blit(SOLVE_SURF, SOLVE_RECT)


def slideAnimation(board, direction, message, animationSpeed):
    # Note: This function does not check if the move is valid.

    blankx, blanky = getBlankPosition(board)
    if direction == UP:
        movex = blankx
        movey = blanky + 1
    elif direction == DOWN:
        movex = blankx
        movey = blanky - 1
    elif direction == LEFT:
        movex = blankx + 1
        movey = blanky
    elif direction == RIGHT:
        movex = blankx - 1
        movey = blanky

    # prepare the base surface
    drawBoard(board, message)
    baseSurf = DISPLAYSURF.copy()
    # draw a blank space over the moving tile on the baseSurf Surface.
    moveLeft, moveTop = getLeftTopOfTile(movex, movey)
    pygame.draw.rect(baseSurf, BGCOLOR, (moveLeft, moveTop, TILESIZE, TILESIZE))

    for i in range(0, TILESIZE, animationSpeed):
        # animate the tile sliding over
        checkForQuit()
        DISPLAYSURF.blit(baseSurf, (0, 0))
        if direction == UP:
            drawTile(movex, movey, board&#91;movex]&#91;movey], 0, -i)
        if direction == DOWN:
            drawTile(movex, movey, board&#91;movex]&#91;movey], 0, i)
        if direction == LEFT:
            drawTile(movex, movey, board&#91;movex]&#91;movey], -i, 0)
        if direction == RIGHT:
            drawTile(movex, movey, board&#91;movex]&#91;movey], i, 0)

        pygame.display.update()
        FPSCLOCK.tick(FPS)


def generateNewPuzzle(numSlides):
    # From a starting configuration, make numSlides number of moves (and
    # animate these moves).
    sequence = &#91;]
    board = getStartingBoard()
    drawBoard(board, '')
    pygame.display.update()
    pygame.time.wait(500) # pause 500 milliseconds for effect
    lastMove = None
    for i in range(numSlides):
        move = getRandomMove(board, lastMove)
        slideAnimation(board, move, 'Generating new puzzle...', animationSpeed=int(TILESIZE / 3))
        makeMove(board, move)
        sequence.append(move)
        lastMove = move
    return (board, sequence)


def resetAnimation(board, allMoves):
    # make all of the moves in allMoves in reverse.
    revAllMoves = allMoves&#91;:] # gets a copy of the list
    revAllMoves.reverse()

    for move in revAllMoves:
        if move == UP:
            oppositeMove = DOWN
        elif move == DOWN:
            oppositeMove = UP
        elif move == RIGHT:
            oppositeMove = LEFT
        elif move == LEFT:
            oppositeMove = RIGHT
        slideAnimation(board, oppositeMove, '', animationSpeed=int(TILESIZE / 2))
        makeMove(board, oppositeMove)


if __name__ == '__main__':
    main()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

import pygame, sys, random

from pygame.locals import *

# Create the constants (go ahead and experiment with different values)

BOARDWIDTH = 4 # number of columns in the board

BOARDHEIGHT = 4 # number of rows in the board

TILESIZE = 80

WINDOWWIDTH = 640

WINDOWHEIGHT = 480

FPS = 30

BLANK = None

# R G B

BLACK = ( 0, 0, 0)

WHITE = (255, 255, 255)

BRIGHTBLUE = ( 0, 50, 255)

DARKTURQUOISE = ( 3, 54, 73)

BLUE = ( 0, 50, 255)

GREEN = ( 0, 128, 0)

RED = (255, 0, 0)

BGCOLOR = DARKTURQUOISE

TILECOLOR = BLUE

TEXTCOLOR = WHITE

BORDERCOLOR = RED

BASICFONTSIZE = 20

TEXT = GREEN

BUTTONCOLOR = WHITE

BUTTONTEXTCOLOR = BLACK

MESSAGECOLOR = WHITE

XMARGIN = int((WINDOWWIDTH - (TILESIZE * BOARDWIDTH + (BOARDWIDTH - 1))) / 2)

YMARGIN = int((WINDOWHEIGHT - (TILESIZE * BOARDHEIGHT + (BOARDHEIGHT - 1))) / 2)

UP = 'up'

DOWN = 'down'

LEFT = 'left'

RIGHT = 'right'

def main():

global FPSCLOCK, DISPLAYSURF, BASICFONT, RESET_SURF, RESET_RECT, NEW_SURF, NEW_RECT, SOLVE_SURF, SOLVE_RECT

pygame.init()

FPSCLOCK = pygame.time.Clock()

DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))

pygame.display.set_caption('Slide Puzzle')

BASICFONT = pygame.font.Font('freesansbold.ttf', BASICFONTSIZE)

# Store the option buttons and their rectangles in OPTIONS.

RESET_SURF, RESET_RECT = makeText('Reset', TEXT, BGCOLOR, WINDOWWIDTH - 120, WINDOWHEIGHT - 310)

NEW_SURF, NEW_RECT = makeText('New Game', TEXT, BGCOLOR, WINDOWWIDTH - 120, WINDOWHEIGHT - 280)

SOLVE_SURF, SOLVE_RECT = makeText('Solve', TEXT, BGCOLOR, WINDOWWIDTH - 120, WINDOWHEIGHT - 250)

mainBoard, solutionSeq = generateNewPuzzle(80)

SOLVEDBOARD = getStartingBoard() # a solved board is the same as the board in a start state.

allMoves = [] # list of moves made from the solved configuration

while True: # main game loop

slideTo = None # the direction, if any, a tile should slide

msg = 'Click tile or press arrow keys to slide.' # contains the message to show in the upper left corner.

if mainBoard == SOLVEDBOARD:

msg = 'Solved!'

drawBoard(mainBoard, msg)

checkForQuit()

for event in pygame.event.get(): # event handling loop

if event.type == MOUSEBUTTONUP:

spotx, spoty = getSpotClicked(mainBoard, event.pos[0], event.pos[1])

if (spotx, spoty) == (None, None):

# check if the user clicked on an option button

if RESET_RECT.collidepoint(event.pos):

resetAnimation(mainBoard, allMoves) # clicked on Reset button

allMoves = []

elif NEW_RECT.collidepoint(event.pos):

mainBoard, solutionSeq = generateNewPuzzle(80) # clicked on New Game button

allMoves = []

elif SOLVE_RECT.collidepoint(event.pos):

resetAnimation(mainBoard, solutionSeq + allMoves) # clicked on Solve button

allMoves = []

else:

# check if the clicked tile was next to the blank spot

blankx, blanky = getBlankPosition(mainBoard)

if spotx == blankx + 1 and spoty == blanky:

slideTo = LEFT

elif spotx == blankx - 1 and spoty == blanky:

slideTo = RIGHT

elif spotx == blankx and spoty == blanky + 1:

slideTo = UP

elif spotx == blankx and spoty == blanky - 1:

slideTo = DOWN

elif event.type == KEYUP:

# check if the user pressed a key to slide a tile

if event.key in (K_LEFT, K_a) and isValidMove(mainBoard, LEFT):

slideTo = LEFT

elif event.key in (K_RIGHT, K_d) and isValidMove(mainBoard, RIGHT):

slideTo = RIGHT

elif event.key in (K_UP, K_w) and isValidMove(mainBoard, UP):

slideTo = UP

elif event.key in (K_DOWN, K_s) and isValidMove(mainBoard, DOWN):

slideTo = DOWN

if slideTo:

slideAnimation(mainBoard, slideTo, 'Click tile or press arrow keys to slide.', 8) # show slide on screen

makeMove(mainBoard, slideTo)

allMoves.append(slideTo) # record the slide

pygame.display.update()

FPSCLOCK.tick(FPS)

def terminate():

pygame.quit()

sys.exit()

def checkForQuit():

for event in pygame.event.get(QUIT): # get all the QUIT events

terminate() # terminate if any QUIT events are present

for event in pygame.event.get(KEYUP): # get all the KEYUP events

if event.key == K_ESCAPE:

terminate() # terminate if the KEYUP event was for the Esc key

pygame.event.post(event) # put the other KEYUP event objects back

def getStartingBoard():

# Return a board data structure with tiles in the solved state.

# For example, if BOARDWIDTH and BOARDHEIGHT are both 3, this function

# returns [[1, 4, 7], [2, 5, 8], [3, 6, BLANK]]

counter = 1

board = []

for x in range(BOARDWIDTH):

column = []

for y in range(BOARDHEIGHT):

column.append(counter)

counter += BOARDWIDTH

board.append(column)

counter -= BOARDWIDTH * (BOARDHEIGHT - 1) + BOARDWIDTH - 1

board[BOARDWIDTH-1][BOARDHEIGHT-1] = BLANK

return board

def getBlankPosition(board):

# Return the x and y of board coordinates of the blank space.

for x in range(BOARDWIDTH):

for y in range(BOARDHEIGHT):

if board[x][y] == BLANK:

return (x, y)

def makeMove(board, move):

# This function does not check if the move is valid.

blankx, blanky = getBlankPosition(board)

if move == UP:

board[blankx][blanky], board[blankx][blanky + 1] = board[blankx][blanky + 1], board[blankx][blanky]

elif move == DOWN:

board[blankx][blanky], board[blankx][blanky - 1] = board[blankx][blanky - 1], board[blankx][blanky]

elif move == LEFT:

board[blankx][blanky], board[blankx + 1][blanky] = board[blankx + 1][blanky], board[blankx][blanky]

elif move == RIGHT:

board[blankx][blanky], board[blankx - 1][blanky] = board[blankx - 1][blanky], board[blankx][blanky]

def isValidMove(board, move):

blankx, blanky = getBlankPosition(board)

return (move == UP and blanky != len(board[0]) - 1) or \

(move == DOWN and blanky != 0) or \

(move == LEFT and blankx != len(board) - 1) or \

(move == RIGHT and blankx != 0)

def getRandomMove(board, lastMove=None):

# start with a full list of all four moves

validMoves = [UP, DOWN, LEFT, RIGHT]

# remove moves from the list as they are disqualified

if lastMove == UP or not isValidMove(board, DOWN):

validMoves.remove(DOWN)

if lastMove == DOWN or not isValidMove(board, UP):

validMoves.remove(UP)

if lastMove == LEFT or not isValidMove(board, RIGHT):

validMoves.remove(RIGHT)

if lastMove == RIGHT or not isValidMove(board, LEFT):

validMoves.remove(LEFT)

# return a random move from the list of remaining moves

return random.choice(validMoves)

def getLeftTopOfTile(tileX, tileY):

left = XMARGIN + (tileX * TILESIZE) + (tileX - 1)

top = YMARGIN + (tileY * TILESIZE) + (tileY - 1)

return (left, top)

def getSpotClicked(board, x, y):

# from the x & y pixel coordinates, get the x & y board coordinates

for tileX in range(len(board)):

for tileY in range(len(board[0])):

left, top = getLeftTopOfTile(tileX, tileY)

tileRect = pygame.Rect(left, top, TILESIZE, TILESIZE)

if tileRect.collidepoint(x, y):

return (tileX, tileY)

return (None, None)

def drawTile(tilex, tiley, number, adjx=0, adjy=0):

# draw a tile at board coordinates tilex and tiley, optionally a few

# pixels over (determined by adjx and adjy)

left, top = getLeftTopOfTile(tilex, tiley)

pygame.draw.rect(DISPLAYSURF, TILECOLOR, (left + adjx, top + adjy, TILESIZE, TILESIZE))

textSurf = BASICFONT.render(str(number), True, TEXTCOLOR)

textRect = textSurf.get_rect()

textRect.center = left + int(TILESIZE / 2) + adjx, top + int(TILESIZE / 2) + adjy

DISPLAYSURF.blit(textSurf, textRect)

def makeText(text, color, bgcolor, top, left):

# create the Surface and Rect objects for some text.

textSurf = BASICFONT.render(text, True, color, bgcolor)

textRect = textSurf.get_rect()

textRect.topleft = (top, left)

return (textSurf, textRect)

def drawBoard(board, message):

DISPLAYSURF.fill(BGCOLOR)

if message:

textSurf, textRect = makeText(message, MESSAGECOLOR, BGCOLOR, 5, 5)

DISPLAYSURF.blit(textSurf, textRect)

for tilex in range(len(board)):

for tiley in range(len(board[0])):

if board[tilex][tiley]:

drawTile(tilex, tiley, board[tilex][tiley])

left, top = getLeftTopOfTile(0, 0)

width = BOARDWIDTH * TILESIZE

height = BOARDHEIGHT * TILESIZE

pygame.draw.rect(DISPLAYSURF, BORDERCOLOR, (left - 5, top - 5, width + 11, height + 11), 4)

DISPLAYSURF.blit(RESET_SURF, RESET_RECT)

DISPLAYSURF.blit(NEW_SURF, NEW_RECT)

DISPLAYSURF.blit(SOLVE_SURF, SOLVE_RECT)

def slideAnimation(board, direction, message, animationSpeed):

# Note: This function does not check if the move is valid.

blankx, blanky = getBlankPosition(board)

if direction == UP:

movex = blankx

movey = blanky + 1

elif direction == DOWN:

movex = blankx

movey = blanky - 1

elif direction == LEFT:

movex = blankx + 1

movey = blanky

elif direction == RIGHT:

movex = blankx - 1

movey = blanky

# prepare the base surface

drawBoard(board, message)

baseSurf = DISPLAYSURF.copy()

# draw a blank space over the moving tile on the baseSurf Surface.

moveLeft, moveTop = getLeftTopOfTile(movex, movey)

pygame.draw.rect(baseSurf, BGCOLOR, (moveLeft, moveTop, TILESIZE, TILESIZE))

for i in range(0, TILESIZE, animationSpeed):

# animate the tile sliding over

checkForQuit()

DISPLAYSURF.blit(baseSurf, (0, 0))

if direction == UP:

drawTile(movex, movey, board[movex][movey], 0, -i)

if direction == DOWN:

drawTile(movex, movey, board[movex][movey], 0, i)

if direction == LEFT:

drawTile(movex, movey, board[movex][movey], -i, 0)

if direction == RIGHT:

drawTile(movex, movey, board[movex][movey], i, 0)

pygame.display.update()

FPSCLOCK.tick(FPS)

def generateNewPuzzle(numSlides):

# From a starting configuration, make numSlides number of moves (and

# animate these moves).

sequence = []

board = getStartingBoard()

drawBoard(board, '')

pygame.display.update()

pygame.time.wait(500) # pause 500 milliseconds for effect

lastMove = None

for i in range(numSlides):

move = getRandomMove(board, lastMove)

slideAnimation(board, move, 'Generating new puzzle...', animationSpeed=int(TILESIZE / 3))

makeMove(board, move)

sequence.append(move)

lastMove = move

return (board, sequence)

def resetAnimation(board, allMoves):

# make all of the moves in allMoves in reverse.

revAllMoves = allMoves[:] # gets a copy of the list

revAllMoves.reverse()

for move in revAllMoves:

if move == UP:

oppositeMove = DOWN

elif move == DOWN:

oppositeMove = UP

elif move == RIGHT:

oppositeMove = LEFT

elif move == LEFT:

oppositeMove = RIGHT

slideAnimation(board, oppositeMove, '', animationSpeed=int(TILESIZE / 2))

makeMove(board, oppositeMove)

if __name__ == '__main__':

main()

Output

Puzzle Game In Python : Project Information

Project Name:	Puzzle Game In Python
Language/s Used:	Python (GUI) Based
Python version (Recommended):	2.x or 3.x
Database:	None
Type:	Python App
Developer:	IT SOURCECODE
Updates:	0

Puzzle Game In Python – Project Information

Run Quick Virus Scan for secure Download

Run Quick Scan for secure Download

Downloadable Source Code

I have here the list of Best Python Project with Source code free to download for free, I hope this can help you a lot.

Summary

The Puzzle Game In Python is written in Python programming language, Python is very smooth to research the syntax emphasizes readability and it is able to reduces time ingesting in developing.

Also in this tutorial is the simplest way for the beginners or the student to enhance their logical skills in programming. and also in this game project is the way for the students or beginners in designing and developing games.

Related Articles

Inquiries

If you have any questions or suggestions about Puzzle Game In Python , please feel free to leave a comment below.

Leave a Comment Cancel reply