"""Twenty Forty-Eight, by Al Sweigart al@inventwithpython.com
A sliding tile game to combine exponentially-increasing numbers.
Inspired by Gabriele Cirulli's 2048, which is a clone of Veewo Studios'
1024, which in turn is a clone of the Threes! game.
More info at https://en.wikipedia.org/wiki/2048_(video_game)
This code is available at https://nostarch.com/big-book-small-python-programming
Tags: large, game, puzzle"""
import random, sys
# Set up the constants:
BLANK = '' # A value that represents a blank space on the board.
def main():
print('''Twenty Forty-Eight, by Al Sweigart al@inventwithpython.com
Slide all the tiles on the board in one of four directions. Tiles with
like numbers will combine into larger-numbered tiles. A new 2 tile is
added to the board on each move. You win if you can create a 2048 tile.
You lose if the board fills up the tiles before then.''')
input('Press Enter to begin...')
gameBoard = getNewBoard()
while True: # Main game loop.
drawBoard(gameBoard)
print('Score:', getScore(gameBoard))
playerMove = askForPlayerMove()
gameBoard = makeMove(gameBoard, playerMove)
addTwoToBoard(gameBoard)
if isFull(gameBoard):
drawBoard(gameBoard)
print('Game Over - Thanks for playing!')
sys.exit()
def getNewBoard():
"""Returns a new data structure that represents a board.
It's a dictionary with keys of (x, y) tuples and values of the tile
at that space. The tile is either a power-of-two integer or BLANK.
The coordinates are laid out as:
X0 1 2 3
Y+-+-+-+-+
0| | | | |
+-+-+-+-+
1| | | | |
+-+-+-+-+
2| | | | |
+-+-+-+-+
3| | | | |
+-+-+-+-+"""
newBoard = {} # Contains the board data structure to be returned.
# Loop over every possible space and set all the tiles to blank:
for x in range(4):
for y in range(4):
newBoard[(x, y)] = BLANK
# Pick two random spaces for the two starting 2's:
startingTwosPlaced = 0 # The number of starting spaces picked.
while startingTwosPlaced < 2: # Repeat for duplicate spaces.
randomSpace = (random.randint(0, 3), random.randint(0, 3))
# Make sure the randomly selected space isn't already taken:
if newBoard[randomSpace] == BLANK:
newBoard[randomSpace] = 2
startingTwosPlaced = startingTwosPlaced + 1
return newBoard
def drawBoard(board):
"""Draws the board data structure on the screen."""
# Go through each possible space left to right, top to bottom, and
# create a list of what each space's label should be.
labels = [] # A list of strings for the number/blank for that tile.
for y in range(4):
for x in range(4):
tile = board[(x, y)] # Get the tile at this space.
# Make sure the label is 5 spaces long:
labelForThisTile = str(tile).center(5)
labels.append(labelForThisTile)
# The {} are replaced with the label for that tile:
print("""
+-----+-----+-----+-----+
| | | | |
|{}|{}|{}|{}|
| | | | |
+-----+-----+-----+-----+
| | | | |
|{}|{}|{}|{}|
| | | | |
+-----+-----+-----+-----+
| | | | |
|{}|{}|{}|{}|
| | | | |
+-----+-----+-----+-----+
| | | | |
|{}|{}|{}|{}|
| | | | |
+-----+-----+-----+-----+
""".format(*labels))
def getScore(board):
"""Returns the sum of all the tiles on the board data structure."""
score = 0
# Loop over every space and add the tile to the score:
for x in range(4):
for y in range(4):
# Only add non-blank tiles to the score:
if board[(x, y)] != BLANK:
score = score + board[(x, y)]
return score
def combineTilesInColumn(column):
"""The column is a list of four tile. Index 0 is the "bottom" of
the column, and tiles are pulled "down" and combine if they are the
same. For example, combineTilesInColumn([2, BLANK, 2, BLANK])
returns [4, BLANK, BLANK, BLANK]."""
# Copy only the numbers (not blanks) from column to combinedTiles
combinedTiles = [] # A list of the non-blank tiles in column.
for i in range(4):
if column[i] != BLANK:
combinedTiles.append(column[i])
# Keep adding blanks until there are 4 tiles:
while len(combinedTiles) < 4:
combinedTiles.append(BLANK)
# Combine numbers if the one "above" it is the same, and double it.
for i in range(3): # Skip index 3: it's the topmost space.
if combinedTiles[i] == combinedTiles[i + 1]:
combinedTiles[i] *= 2 # Double the number in the tile.
# Move the tiles above it down one space:
for aboveIndex in range(i + 1, 3):
combinedTiles[aboveIndex] = combinedTiles[aboveIndex + 1]
combinedTiles[3] = BLANK # Topmost space is always BLANK.
return combinedTiles
def makeMove(board, move):
"""Carries out the move on the board.
The move argument is either 'W', 'A', 'S', or 'D' and the function
returns the resulting board data structure."""
# The board is split up into four columns, which are different
# depending on the direction of the move:
if move == 'W':
allColumnsSpaces = [[(0, 0), (0, 1), (0, 2), (0, 3)],
[(1, 0), (1, 1), (1, 2), (1, 3)],
[(2, 0), (2, 1), (2, 2), (2, 3)],
[(3, 0), (3, 1), (3, 2), (3, 3)]]
elif move == 'A':
allColumnsSpaces = [[(0, 0), (1, 0), (2, 0), (3, 0)],
[(0, 1), (1, 1), (2, 1), (3, 1)],
[(0, 2), (1, 2), (2, 2), (3, 2)],
[(0, 3), (1, 3), (2, 3), (3, 3)]]
elif move == 'S':
allColumnsSpaces = [[(0, 3), (0, 2), (0, 1), (0, 0)],
[(1, 3), (1, 2), (1, 1), (1, 0)],
[(2, 3), (2, 2), (2, 1), (2, 0)],
[(3, 3), (3, 2), (3, 1), (3, 0)]]
elif move == 'D':
allColumnsSpaces = [[(3, 0), (2, 0), (1, 0), (0, 0)],
[(3, 1), (2, 1), (1, 1), (0, 1)],
[(3, 2), (2, 2), (1, 2), (0, 2)],
[(3, 3), (2, 3), (1, 3), (0, 3)]]
# The board data structure after making the move:
boardAfterMove = {}
for columnSpaces in allColumnsSpaces: # Loop over all 4 columns.
# Get the tiles of this column (The first tile is the "bottom"
# of the column):
firstTileSpace = columnSpaces[0]
secondTileSpace = columnSpaces[1]
thirdTileSpace = columnSpaces[2]
fourthTileSpace = columnSpaces[3]
firstTile = board[firstTileSpace]
secondTile = board[secondTileSpace]
thirdTile = board[thirdTileSpace]
fourthTile = board[fourthTileSpace]
# Form the column and combine the tiles in it:
column = [firstTile, secondTile, thirdTile, fourthTile]
combinedTilesColumn = combineTilesInColumn(column)
# Set up the new board data structure with the combined tiles:
boardAfterMove[firstTileSpace] = combinedTilesColumn[0]
boardAfterMove[secondTileSpace] = combinedTilesColumn[1]
boardAfterMove[thirdTileSpace] = combinedTilesColumn[2]
boardAfterMove[fourthTileSpace] = combinedTilesColumn[3]
return boardAfterMove
def askForPlayerMove():
"""Asks the player for the direction of their next move (or quit).
Ensures they enter a valid move: either 'W', 'A', 'S' or 'D'."""
print('Enter move: (WASD or Q to quit)')
while True: # Keep looping until they enter a valid move.
move = input('> ').upper()
if move == 'Q':
# End the program:
print('Thanks for playing!')
sys.exit()
# Either return the valid move, or loop back and ask again:
if move in ('W', 'A', 'S', 'D'):
return move
else:
print('Enter one of "W", "A", "S", "D", or "Q".')
def addTwoToBoard(board):
"""Adds a new 2 tile randomly to the board."""
while True:
randomSpace = (random.randint(0, 3), random.randint(0, 3))
if board[randomSpace] == BLANK:
board[randomSpace] = 2
return # Return after finding one non-blank tile.
def isFull(board):
"""Returns True if the board data structure has no blanks."""
# Loop over every space on the board:
for x in range(4):
for y in range(4):
# If a space is blank, return False:
if board[(x, y)] == BLANK:
return False
return True # No space is blank, so return True.
# If this program was run (instead of imported), run the game:
if __name__ == '__main__':
try:
main()
except KeyboardInterrupt:
sys.exit() # When Ctrl-C is pressed, end the program.