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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
|
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
Run Quick Virus Scan for secure Download
Run Quick Scan for secure DownloadDownloadable 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
- Snakes and Ladders Game in Python with Source Code
- Code For Game in Python: Python Game Projects With Source Code
- Stickman Game in Python with Source Code
- Tank Game Python with Source Code
- Tetris In Python Code
- Mario Game In Python With Source Code
- Hangman Game In Python With Source Code
- Aircraft War Game in Python with Source Code
- Snake Game In Python Code
- How to Make Bouncing Ball Game in Python with Source Code
- How to Create Rock-Paper-Scissor Game in Python
Inquiries
If you have any questions or suggestions about Puzzle Game In Python , please feel free to leave a comment below.
