2048 style game

Question

I have made a replica of the game 2048. It works exactly how the game should work. However I was just looking to know where I could've possibly cleaned up my code or make it more efficient.

import random
board =([0,0,0,0],
        [0,0,0,0],
        [0,0,0,0],
        [0,0,0,0])



def pieces_test(board):
    places = find_non_zeros(board)
    print(places)


def combine_numbers(board, value, new_y, new_x, del_y, del_x):
    value *= 2
    board[new_y][new_x] = value
    board[del_y][del_x] = 0
    return board

def find_zeros(board):
    good_places = []
    for i in range(len(board)):
        for j in range(len(board[i])):
            if board[i][j] == 0:
                good_places.append([i,j])
    return good_places


def find_non_zeros(board):
    good_places = []
    for i in range(len(board)):
        for j in range(len(board[i])):
            if board[i][j] != 0:
                good_places.append([i,j])
    return good_places



def start_of_game(board):
    for i in range(2):
        places = find_zeros(board)
        new_coord = random.choice(places)
        board[new_coord[0]][new_coord[1]] = 2
    return board

def move_left(board):
    not_left = True
    unusable_pieces = []
    while not_left:
        not_left = False
        pieces_positions = find_non_zeros(board)
        #pieces_positions = [[piece1_y, piece1_x],[piece2_y, piece2_x]...]
        for i in range(len(pieces_positions)):
            if pieces_positions[i][1] != 0:
                    if board[pieces_positions[i][0]][pieces_positions[i][1]-1] == 0:
                        if [pieces_positions[i][0],pieces_positions[i][1]] in unusable_pieces:
                            index_value = unusable_pieces.index([pieces_positions[i][0],pieces_positions[i][1]])
                            unusable_pieces[index_value][1] -= 1
                        value = board[pieces_positions[i][0]][pieces_positions[i][1]]
                        board[pieces_positions[i][0]][pieces_positions[i][1]-1] = value
                        board[pieces_positions[i][0]][pieces_positions[i][1]] = 0
                        not_left = True
                    elif board[pieces_positions[i][0]][pieces_positions[i][1]-1] == board[pieces_positions[i][0]][pieces_positions[i][1]]:
                        if [pieces_positions[i][0],pieces_positions[i][1]] not in unusable_pieces:
                            if [pieces_positions[i][0], pieces_positions[i][1]-1] not in unusable_pieces:
                                value = board[pieces_positions[i][0]][pieces_positions[i][1]]
                                combine_numbers(board, value, pieces_positions[i][0], pieces_positions[i][1]-1, pieces_positions[i][0], pieces_positions[i][1])
                                unusable_pieces.append([pieces_positions[i][0], pieces_positions[i][1]-1])
                                not_left = True




                #       combine_numbers(board, value_of_board_pieces, new_y, new_x, del_y, del_x)



    return board

def move_right(board):
    not_right = True
    unusable_pieces = []
    while not_right:
        not_right = False
        pieces_positions = find_non_zeros(board)
        pieces_positions = pieces_positions[::-1]
        #pieces_positions = [[piece1_y, piece1_x],[piece2_y, piece2_x]...]
        for i in range(len(pieces_positions)):
            if pieces_positions[i][1] != 3:
                    if board[pieces_positions[i][0]][pieces_positions[i][1]+1] == 0:
                        if [pieces_positions[i][0],pieces_positions[i][1]] in unusable_pieces:
                            index_value = unusable_pieces.index([pieces_positions[i][0],pieces_positions[i][1]])
                            unusable_pieces[index_value][1] += 1
                        value = board[pieces_positions[i][0]][pieces_positions[i][1]]
                        board[pieces_positions[i][0]][pieces_positions[i][1]+1] = value
                        board[pieces_positions[i][0]][pieces_positions[i][1]] = 0
                        not_right = True
                    elif board[pieces_positions[i][0]][pieces_positions[i][1]+1] == board[pieces_positions[i][0]][pieces_positions[i][1]]:
                        if [pieces_positions[i][0],pieces_positions[i][1]] not in unusable_pieces:
                            if [pieces_positions[i][0], pieces_positions[i][1]+1] not in unusable_pieces:
                                value = board[pieces_positions[i][0]][pieces_positions[i][1]]
                                combine_numbers(board, value, pieces_positions[i][0], pieces_positions[i][1]+1, pieces_positions[i][0], pieces_positions[i][1])
                                unusable_pieces.append([pieces_positions[i][0], pieces_positions[i][1]+1])
                                not_right = True

    return board

def move_up(board):
    not_up = True
    unusable_pieces = []
    while not_up:
        not_up = False
        pieces_positions = find_non_zeros(board)
        #pieces_positions = [[piece1_y, piece1_x],[piece2_y, piece2_x]...]
        for i in range(len(pieces_positions)):
            if pieces_positions[i][0] != 0:
                if board[pieces_positions[i][0]-1][pieces_positions[i][1]] == 0:
                    if [pieces_positions[i][0],pieces_positions[i][1]] in unusable_pieces:
                        index_value = unusable_pieces.index([pieces_positions[i][0],pieces_positions[i][1]])
                        unusable_pieces[index_value][0] -= 1
                    value = board[pieces_positions[i][0]][pieces_positions[i][1]]
                    board[pieces_positions[i][0]-1][pieces_positions[i][1]] = value
                    board[pieces_positions[i][0]][pieces_positions[i][1]] = 0
                    not_up = True
                elif board[pieces_positions[i][0]-1][pieces_positions[i][1]] == board[pieces_positions[i][0]][pieces_positions[i][1]]:
                    if [pieces_positions[i][0],pieces_positions[i][1]] not in unusable_pieces:
                        if [pieces_positions[i][0]-1, pieces_positions[i][1]] not in unusable_pieces:
                            value = board[pieces_positions[i][0]][pieces_positions[i][1]]
                            combine_numbers(board, value, pieces_positions[i][0]-1, pieces_positions[i][1], pieces_positions[i][0], pieces_positions[i][1])
                            unusable_pieces.append([pieces_positions[i][0]-1, pieces_positions[i][1]])
                            not_up = True

    return board

def move_down(board):
    not_down = True
    unusable_pieces = []
    while not_down:
        not_down = False
        pieces_positions = find_non_zeros(board)
        pieces_positions = pieces_positions[::-1]
        #pieces_positions = [[piece1_y, piece1_x],[piece2_y, piece2_x]...]
        for i in range(len(pieces_positions)):
            if pieces_positions[i][0] != 3:
                    if board[pieces_positions[i][0]+1][pieces_positions[i][1]] == 0:
                        if [pieces_positions[i][0],pieces_positions[i][1]] in unusable_pieces:
                            index_value = unusable_pieces.index([pieces_positions[i][0],pieces_positions[i][1]])
                            unusable_pieces[index_value][0] += 1
                        value = board[pieces_positions[i][0]][pieces_positions[i][1]]
                        board[pieces_positions[i][0]+1][pieces_positions[i][1]] = value
                        board[pieces_positions[i][0]][pieces_positions[i][1]] = 0
                        not_down = True
                    elif board[pieces_positions[i][0]+1][pieces_positions[i][1]] == board[pieces_positions[i][0]][pieces_positions[i][1]]:
                        if [pieces_positions[i][0],pieces_positions[i][1]] not in unusable_pieces:
                            if [pieces_positions[i][0]+1, pieces_positions[i][1]] not in unusable_pieces:
                                value = board[pieces_positions[i][0]][pieces_positions[i][1]]
                                combine_numbers(board, value, pieces_positions[i][0]+1, pieces_positions[i][1], pieces_positions[i][0], pieces_positions[i][1])
                                unusable_pieces.append([pieces_positions[i][0]+1, pieces_positions[i][1]])
                                not_down = True

    return board

def add_piece(board):
    free_spots = find_zeros(board)
    chosen_spot = random.choice(free_spots)
    board[chosen_spot[0]][chosen_spot[1]] = 2
    return board            





def main(board):
    board = start_of_game(board)
    game_finished= False
    while game_finished == False:
        if find_zeros(board) == []:
            game_finished = True
            continue
        print(board[0],"\n",board[1],"\n",board[2],"\n",board[3])
        move = input("do you want to move up, down, left or right")
        if move == "up":
            move_up(board)
        if move == "down":
            move_down(board)
        if move == "left":
            move_left(board)
        if move == "right":
            move_right(board)
        board = add_piece(board)


main(board)

Answer 1

The thing that jumps out when reading this is the use of indexers: a snippet like this:

 if board[pieces_positions[i][0]][pieces_positions[i][1]-1] == 0:
    if [pieces_positions[i][0],pieces_positions[i][1]] in unusable_pieces:
        index_value = unusable_pieces.index([pieces_positions[i][0],pieces_positions[i][1]])
        unusable_pieces[index_value][1] -= 1

is extremely hard to read (and hence to debug) because of the onslaught of brackets (as an informal rule of thumb, if the code scrolls off to the right in a StackOverflow code window, that's a sign you should see how to tighten it up).

You could eliminate a lot of that by using python's built-in unpacking syntax. Since pieces_positions is a list-of-lists, you can tame it by looping over it like this:

 for y, x in pieces_positions: 
     #.....

Now hard to read stuff like

  board[pieces_positions[i][0]][pieces_positions[i][1]-1]

becomes

  board[y][x-1]

with that change your four main functions look more readable:

def move_right(board):
    not_right = True
    unusable_pieces = []
    while not_right:
        not_right = False
        pieces_positions = find_non_zeros(board)
        pieces_positions = pieces_positions[::-1]
        #pieces_positions = [[piece1_y, piece1_x],[piece2_y, piece2_x]...]
        for y, x in pieces_positions:
            if x != 3:
                if board[y][x+1] == 0:
                    if [y,x] in unusable_pieces:
                        index_value = unusable_pieces.index([y,x])
                        unusable_pieces[index_value][1] += 1
                    value = board[y][x]
                    board[y][x+1] = value
                    board[y][x] = 0
                    not_right = True
                elif board[y][x+1] == board[y][x]:
                    if [y,x] not in unusable_pieces:
                        if [y, x+1] not in unusable_pieces:
                            value = board[y][x]
                            combine_numbers(board, value, y, x+1, y, x)
                            unusable_pieces.append([y, x+1])
                            not_right = True

    return board

However, the four main functions are all basically symmetrical -- they only differ in the direction of movement and the limit condition. It'd be cleaner and easier to debug if you could get them down to a single function that was used everywhere.

In this case, you can express the movement more clearly by treating it as a pair of offsets added to your x and y values -- say, a single move(board, offset_x, offset_y) function instead of the four you currently have. Then you can generalize the boundaries in something like this fashion:

for y, x in pieces_positions:

    next_y = y + offset_y
    next_x = x + offset_x

    # python has a nice chained comparison that 
    # is great for checking a range
    valid_x = -1 < next_x < 4
    valid_y = -1 < next_y < 4

    if not (valid_x and valid_y):
        continue

This has the added advantage of making the actual changes to the board clearer too:

if board[next_y][next_x] == 0:
    if [y,x] in unusable_pieces:
        index_value = unusable_pieces.index([y,x])
        if offset_y = 0:   # this means an x-move
            unusable_pieces[index_value][1] += offset_x
        else:   # a y move
            unusable_pieces[index_value][0] += offset_y

    value = board[y][x]
    board[next_y][next_x] = value
    board[y][x] = 0

Working through the unpacked values instead of range() and a single general function instead of four functions that vary only on a couple of number placements will make the game a lot easier to read and thus to debug and maintain.

Answer 2

as a late review, i congratulate you for your separation of tasks, apart from the point made by @theodox, just if something is not going to be immutable, you can wrap it in a list

from

   ([0,0,0,0],
    [0,0,0,0],
    [0,0,0,0],
    [0,0,0,0])

to

   [[0,0,0,0],
    [0,0,0,0],
    [0,0,0,0],
    [0,0,0,0]]

as it sends off the wrong message to code readers