Game of life using IDLE

[Informatics109]

Hello, im creating the famous game of life, but without using pygame, numpy and all other programs, just the basic IDLE. My plan is to create a window consisting of 6 buttons (START CLEAR RANDOMIZE LOAD SAVE QUIT) where for each button python performs different tasks. 
Im almost there ( i think) but i just cant seem to go any further, no matter which way i try to program. Please help eather with the program itself or tips or anything is greatly appreciated!! :) 

My script

from graphics import *
from random import *
from time import sleep
from copy import deepcopy
from math import *

def size():
    """ Returns the size of the board. """
    return 20

def board():
    board = [ [ False for i in range(size()) ] for j in range(size()) ]
    return board

def living_neighbors(x,y,board):
    """ Returns the number of living neighbors of the cell at coordinates (x,y).
        If either coordinate is on the edge of the board, we need to wrap to the
        opposite board edge: i.e. we are on a torus."""
    neighbors = []
    neighbor = []
    neighbor.append(board[(x-1)%size()][(y-1)%size()])
    neighbor.append(board[(x)%size()][(y-1)%size()])
    neighbor.append(board[(x+1)%size()][(y-1)%size()])
    neighbor.append(board[(x-1)%size()][(y)%size()])
    neighbor.append(board[(x+1)%size()][(y)%size()])
    neighbor.append(board[(x-1)%size()][(y+1)%size()])
    neighbor.append(board[(x)%size()][(y+1)%size()])
    neighbor.append(board[(x+1)%size()][(y+1)%size()])
    neighbors=neighbor.count(True)
    return neighbors

def iterate(board):
    """ Does one interation, and returns the next generation of cells. Returns the
        tuple (living, board), while living is the number of alive cells and board
        is a matrix of boolean values corresponding to the aliveness of each cell."""

    new_board = [] 
    for x in range(size()):
        row = []
        for y in range(size()):
            row.append(False)
        new_board.append(row)

    for x in range(size()):
        for y in range(size()):
            neighbors=living_neighbors(x,y,board)

            if board[x][y] == True and neighbors < 2:
                new_board[x][y] = False
            if board[x][y] == True and neighbors > 3:
                new_board[x][y] = False
            if board[x][y] == False and neighbors == 3:
                new_board[x][y] = True
            if board[x][y] ==False and neighbors != 3:
                new_board[x][y] = False
            if board[x][y] == True and neighbors == 2:
                new_board[x][y] = True
            if board[x][y] == True and neighbors ==3:
                new_board[x][y] = True
    living=new_board.count(True)
    return (living,new_board)


def random_bit():
    """ Returns a random value of True or False. """
    return choice([True,False])

def update_color(x,y,board,rectangles):
    """ Sets color in rectangles [x,y] to correct value according to the status of
its corresponding cell in board ."""
    if (board[x][y]):
        rectangles[x][y].setFill("red4")
    else:
        rectangles[x][y].setFill("ghostwhite")
    return rectangles

def initiate():
    board = []
    rectangles = []
    for i in range(size()):
        m = []
        M = []
        for j in range(size()):
            rec=(Rectangle(Point(i,j),Point(i+1,j+1)))
            m.append(rec)
            M.append(random_bit())
        rectangles.append(m)
        board.append(M)
    return(board,rectangles)

def gameoflife():
    win2 = GraphWin("Game of Life",600,600)
    win2.setCoords(0,-3,size(),size())
    board,rectangles=initiate()
    play= True
    for x in range(size()):
        for y in range(size()):
            rectangles[x][y].draw(win2)
            update_color(x,y,board,rectangles)
    living,new_board = iterate(board)
    while play == True:
        for i in range(size()):
            for j in range(size()):
                update_color(i,j,new_board,rectangles)
        living,new_board=iterate(new_board)
        if win2.checkMouse(): break

def is_inside(rectangle,point):

    dx = point.getX()
    dy = point.getY()
    r1 = rectangle.getP1()
    x1 = r1.getX()
    y1 = r1.getY()
    r2 = rectangle.getP2()
    x2 = r2.getX()
    y2 = r2.getY()  

    if dx > x1 and dx < x2 and dy > y1 and dy < y2:
        return True
    else:
        return False

def switch(point,new_board,window):
    """Takes in point were mouse was clicked, then changes cell value and color"""
    
    dx = point.getX()
    dy = point.getY()
    dx = int(dx)
    dy = int(dy)

    update = 0
    cell = Rectangle(Point(dx,dy),Point(dx+1,dy+1))             
    update = new_board[dx][dy]                                  
    if update == 0:
        cell.setFill('red4')
        new_board[dx][dy] = 1
    else:
        cell.setFill('ghostwhite')
        new_board[dx][dy] = 0
    cell.draw(window)
    return (new_board)

def process(action,new_board):
    if action == 0:
        return
    elif action == 1:
        nullset = []
        board = []
        for k in range(size()):
            board.append([])
            for n in range (size()):
                board[k].append(0)
                nullset.append(k)
                nullset.append(n)
        m = int(int(len(nullset))/2)
        return (board,nullset,m)
    elif action == 3:
        file = eval(input("Enter filename: "))
        infile = open(file,'r')
        pattern = infile.read()
        pattern=''.join(i for i in pattern if i.isdigit())

        n = len(pattern)
        m = int(sqrt(n))
        pattern = list(pattern)
        pattern = [int(q) for q in pattern]

        load_board = []
        for x in range(0,m):
            load_board.append(pattern[(0+x*m):(m+(x*m))])
        infile.close()
        return(load_board)
    elif action == 4:
        filename = eval(input("Enter filename: "))
        outfile = open(filename,'w')
        pattern = str(new_board)
        outfile.write(pattern)
        outfile.close()
        return(new_board)

def window2():
    win2 = GraphWin("Game of Life",600,600)
    win2.setCoords(0,-3,size(),size())

    # Drawing the interface.
    Text(Point(8,-0.5),"Iterations:").draw(win2)
    input = Entry(Point(10,-0.5),5)
    input.setText("0.0")
    input.draw(win2)
    button = Text(Point(1.5,-2),"Start")
    button.draw(win2)
    rect1 = Rectangle(Point(0.5,-2.5),Point(2.5,-1.5)).draw(win2)
    clear = Text(Point(4.5,-2),"Clear")
    clear.draw(win2)
    rect2 = Rectangle(Point(3.5,-2.5),Point(5.5,-1.5)).draw(win2)
    randomize = Text(Point(8.5,-2),"Randomize")
    randomize.draw(win2)
    rect3 = Rectangle(Point(6.5,-2.5),Point(10.5,-1.5)).draw(win2)
    load = Text(Point(12.5,-2),"Load")
    load.draw(win2)
    rect4 = Rectangle(Point(11.5,-2.5),Point(13.5,-1.5)).draw(win2)
    save = Text(Point(15.5,-2),"Save")
    save.draw(win2)
    rect5 = Rectangle(Point(14.5,-2.5),Point(16.5,-1.5)).draw(win2)
    quitt = Text(Point(18.5,-2),"Quit")
    quitt.draw(win2)
    rect6 = Rectangle(Point(17.5,-2.5),Point(19.5,-1.5)).draw(win2)
    rectangle = [rect1,rect2,rect3,rect4,rect5,rect6]
    k = len(rectangle)
    # Initiates the initial board and rectangles.
    board,rectangles=deepcopy(initiate())
    # Draws the board and rectangles to the interface.
    for x in range(size()):
        for y in range(size()):
            rectangles[x][y] = Rectangle(Point(x,y),Point(x+1,y+1))
    for x in range(size()):
        for y in range(size()):
            rectangles = update_color(x,y,board,rectangles)
            rectangles[x][y].draw(win2)

    while True:
        # Wait for a mouse click.
        point1 = win2.getMouse()
        dy = point1.getY
        if point1.getY > 0:
            board = switch(point1,board,win2)
        else:
            click = is_inside(rectangle[0],point1)
            if click == True:
                sleep(0.5)
                break
    iterations = int(input.getText())
    count = iterations
    while True:
        action = 0
        point = win2.getMouse()
        dy = point.getY()
        if dy > 0:
            switch(point,board,win2)
        else:
            for i in range(0,k):
                click  = is_inside(rectangle[i],point)
                if click == True:
                    action = i
            if action == 1:
                new_board = process(action,board)[0]
                changes = process(action,board)[1]
                m = process(action,board)[2]
            elif action == 2:
                new_board = initiate()[0]
                changes = process(1,board)[1]
                m = process(1,board)[2]
            elif action == 3:
                new_board = process(action,board)
                changes = process(1,board)[1]
                m = process(1,board)[2]
            elif action == 4:
                new_board = process(action,board)
                m = o
                count += 1
            elif action == 5:
                win2.close()
                break
            else:
                new_board = iterate(board)[1]
                changes = iterate(board)[2]
                m = int(int(len(changes))/2)

            rectangles = []
            update = []

            for x in range(0,m):
                xx = changes[x+x]
                yy = changes[x+x+1]
                redtangles.append(Rectangle(Point(xx,yy),Point(xx+1,yy+1)))
                update.append(new_board[xx][yy])
                rectangles = update_color(x,'update',update,rectangles)
                rectangles[x].draw(win2)
            board = new_board
            count -= 1
            if count == 0:
                sleep(3)
                win2.close()
                break
        
window2()

Error:
The error I recieve:
Traceback (most recent call last):
  File "C:\Users\game.py", line 287, in <module>
    window2()
  File "C:\Users\game.py", line 226, in window2
    if point1.getY > 0:
TypeError: unorderable types: method() > int()

[Ofnuts]

Try to call the function by adding ():  

if point1.getY() > 0:

[metulburr]

        if point1.getY > 0:

I presume you meant to call the function via adding parens

        if point1.getY() > 0:

[Informatics109]

yes thats it! In addition i found another small mistake. Even though the program still doesnt work as it should i feel like im on the right path this time. Thanks guys!!!

---

How would you suggest is the best way to fix this problem:

Error:
Traceback (most recent call last):
 File "C:\Users\game.py", line 293, in <module>
   window2()
 File "C:\Users\game.py", line 273, in window2
   changes = iterate(board)[2]
IndexError: tuple index out of range

If i would add another variable in iterate() program it would give another error:
Traceback (most recent call last):

Error:
 File "C:\Users\game.py", line 293, in <module>
   window2()
 File "C:\Users\game.py", line 284, in window2
   rectangles = update_color(x,'update',update,rectangles)
 File "C:\Users\game.py", line 77, in update_color
   if (board[x][y]):
TypeError: 'bool' object is not subscriptable

[ichabod801]

It's hard to answer your questions without seeing your code. You need to look at what's coming out of iterate(board) to see why it doesn't have three items. In the second one you need to look at the board variable. Is it being set to a boolean at some point? Is board[x] a boolean? These are the questions you have to ask yourself in order to solve the problem, but we can't answer them because we can't see the rest of your program.

You're program is probably pretty big, at least bigger than we have the time or inclination to wade through. So we typically suggest trimming down your program to a small chunk of code that replicates the error, say 10 to 20 lines of code. You will often find that trying to isolate the error like this will allow you to solve the problem yourself. If not, it will help us solve the problem.