minesweeper, reveal empty cell and all other empty cell logic and python

Question

I am currently creating minesweeper, and have got to the part where i have to create a function that once the player clicks on a cell that is empty, it reveals that cell and all other empty cells including the numbered cells that surround the cluster of empty cells ( come on guys, you know minesweeper:) my approach to programming this game, is to have a list of lists which contain values, 0 is empty, 1-8 is how many bombs are touching that cell, and 50 is a bomb. i call this grid. I then use this grid to map out the whole game. That grid is then hidden with a use of another list of lists, which all contain booleans. True is hidden, False is revealed. I call this boolgrid. for example when a player clicks on cell[2][10] the boolgrid[2][10] turns False, revealing that cell.

When an empty cell is selected, the surrounding cells have to be revealed, which in some cases, are also empty, so the surrounding cells of THAT cell need to be revealed, and so on. My problem is writing a function that supports that, i have tried many things, like creating a list of tuples of cell coordinates where the cell == 0, and then a new list to hold all of the new tuples which can eventually be used to turn all of the corresponding boolgrid cells to False. it doesnt work very well, is messy, unpythonic, takes up alot of memory.

I would be most grateful to anyone who can help me with a function that gives me some pythonic way of achieving this.

below is some stripped down code, which contains the bare elements. the code contains all 0's in the grid so every bool should turn False

# used to hold values to denote what the cell contains,
grid = [[0 for x in range(30)] for x in range(15)]


# used to check what cell is hidden, true is hidden, false is revealed,

booleangrid = [[True for x in range(30)] for x in range(15)]

list_to_hold_tuples = []


def find_connected_0_value_cells(cell):

        i = 5 # used as an example in the real program these are whatever cell the player selects
        j = 10  # as above


    # this function should be given an argument of a cell that the player selected.
    # reveal the surrounding cells, AND THEN take each surrounding cell, and go through
    # the same process again, until every surrounding cell containing 0, and its surrounding
    # cells containing zero have been revealed.
    # i know i need some kind of loop, but cannot seem to build it.
    # currently this function just reveals the cell and its immediate surrounding cells

        if cell[i][j] == 0:


            s = i, j + 1
            t = i, j - 1
            u = i - 1, j - 1
            v = i - 1, j
            w = i - 1, j + 1
            x = i + 1, j - 1
            y = i + 1, j
            z = i + 1, j + 1

            tempholding = [s, t, u, v, w, x, y, z]

            for i in tempholding:
                list_to_hold_tuples.append(i)


def reveal_empty_cells():

    for a,b in list_to_hold_tuples:
        booleangrid[a][b] = False

    print(booleangrid)



find_connected_0_value_cells(grid)
reveal_empty_cells()

Answer 1

I have refactored and got the rest of it to work. thanks @zettatekdev

grid = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
        [1, 1, 2, 1, 0, 0, 0, 0, 0, 0],
        [1, 1, 2, 2, 0, 0, 0, 0, 0, 0],
        [1, 1, 2, 3, 0, 0, 0, 0, 0, 0],
        [1, 1, 2, 5, 0, 0, 0, 0, 0, 0],
        [1, 1, 2, 5, 0, 0, 0, 0, 0, 0]]





list_to_hold_tuples = []
list_change_boolgrid =[]

row = 6
cell = 10

booleangrid = [[True for x in range(cell)] for x in range(row)]

def find_connected_0_value_cells(a, b):
    list_to_hold_tuples.append((a, b))

    if grid[a][b] == 0:

        coord_list = get_surrounding_coords(a, b)

        for a,b in coord_list:
            if check_coord_values(a, b):
                if grid[a][b] != 0:
                    c = a,b
                    if c not in list_to_hold_tuples:
                        list_to_hold_tuples.append(c)
                else:
                    c = a,b
                    if c not in list_to_hold_tuples:
                        find_connected_0_value_cells(a,b)



def add_surrounding_cells():

    extra_coord = True

    for a,b in list_to_hold_tuples:

        if grid[a][b] == 0:
            coord_list = get_surrounding_coords(a,b, extra_coord)

            for i in coord_list:
                if i not in list_change_boolgrid:
                    list_change_boolgrid.append(i)

        else:
            c = a,b
            if c not in list_change_boolgrid:
                list_change_boolgrid.append(c)



def reveal_empty_cells():
    global booleangrid
    for a, b in list_change_boolgrid:
        if check_coord_values(a,b):
            booleangrid[a][b] = False




def check_coord_values(a,b):

    if a == -1 or a >= row:
        return False
    if b == -1 or b >= cell:
        return False
    else:
        return True


def get_surrounding_coords(a, b, *extra_coord):
    c = (a, b + 1)
    d = (a, b - 1)
    e = (a - 1, b - 1)
    f = (a - 1, b)
    g = (a - 1, b + 1)
    h = (a + 1, b - 1)
    i = (a + 1, b)
    j = (a + 1, b + 1)
    if extra_coord:
        k = (a, b)
        return [c, d, e, f, g, h, i, j, k]

    return [c, d, e, f, g, h, i, j]




find_connected_0_value_cells(3,5)
add_surrounding_cells()
reveal_empty_cells()

print(booleangrid)

Answer 2

Ok, so I worked with your code for a bit, and I was able to make a code that works. I did adjust the grid size just to make it easier to figure out, but it should work for your original size. Just make sure you don't test with a grid of all 0s like in your posted code because it will return an error for too many recursions. Here's the code. EDIT: I changed the code so now it reveals the surrounding numbers as well

# used to hold values to denote what the cell contains,
grid = [[0,1,2,5,4,6,0,0,0,0],
        [0,1,2,5,4,6,0,0,0,0],
        [0,1,2,5,4,6,0,0,5,0],
        [0,1,2,5,4,6,0,0,0,0],
        [0,1,2,5,4,6,0,0,0,0],
        [0,1,2,5,4,6,6,0,0,0]]
# used to check what cell is hidden, true is hidden, false is revealed,

booleangrid = [[True for x in range(10)] for x in range(6)]

list_to_hold_tuples = []


def find_connected_0_value_cells(i,j):
        list_to_hold_tuples.append((i,j))

        if grid[i][j] == 0:

            s = (i, j + 1)
            t = (i, j - 1)
            u = (i - 1, j - 1)
            v = (i - 1, j)
            w = (i - 1, j + 1)
            x = (i + 1, j - 1)
            y = (i + 1, j)
            z = (i + 1, j + 1)

            tempholding = [s, t, u, v, w, x, y, z]

            for a in tempholding:
                if a[0]>=0 and a[1]>=0 and a[0]<=len(grid)-1 and a[1]<=len(grid[i])-1 and grid[a[0]][a[1]]==0:
                    if (a[0]!=i and a[1]!=j) and (a not in list_to_hold_tuples):
                        find_connected_0_value_cells(a[0],a[1])
                    list_to_hold_tuples.append(a)
                elif a[0]>=0 and a[1]>=0 and a[0]<=len(grid)-1 and a[1]<=len(grid[i])-1:
                    list_to_hold_tuples.append(a) #this part adds surrounding non-zero numbers


def reveal_empty_cells():
    global booleangrid
    for a,b in list_to_hold_tuples:
        if a>=0 and a<len(booleangrid) and b>=0 and b<len(booleangrid[a]):
            booleangrid[a][b] = False

    for i in booleangrid:
        print(i)



find_connected_0_value_cells(5,8)#Just using coordinates of 5,8 for testing, this would be click spot
reveal_empty_cells()