for pipe in pipes:
    ...
    for bird in birds:
        ...

    if not pipe.passed and pipe.x < bird.x:
        pipe.passed = True
        add_pipe = True

if not pipe.passed and pipe.x < birds[0].x:

numpy
pygame
neat-python
graphviz
matplotlib

import math
import pygame
import random
import os
import neat
import pickle
import time

pygame.init()
screenwidth = 1000
screenheight = 750

screen = pygame.display.set_mode((screenwidth,screenheight))

LunarLanderImage = pygame.image.load("LunarLanderImage.jpg")

class Lander(object):

    def __init__(self, x_pos, y_pos, angle, gravity):
        self.x_pos = x_pos
        self.y_pos = y_pos
        self.angle = angle
        self.gravity = gravity
        self.initial_mass = 1000
        self.fuel = 500
        self.mass = self.initial_mass + self.fuel
        self.thrust = 0
        self.weight = self.mass * self.gravity
        self.x_vel = 0
        self.y_vel = 0
        self.y_acceleration = 0
        self.x_acceleration = 0
        self.img = pygame.image.load("Lander.png")
        self.img = pygame.transform.scale(self.img, (50,50))
        self.img2 = pygame.image.load("Lander2.png")
        self.img2 = pygame.transform.scale(self.img2, (50,50))
        self.thrust_on = False
        self.rotatedImage = self.img
        self.rotatedImage2 = self.img2
        self.death = False
        self.score = 0
        self.start_time = time.time()
    def move(self):
        keys = pygame.key.get_pressed()
        
        if  keys[pygame.K_RIGHT] == True:
            self.angle -= 0.5
        elif keys[pygame.K_LEFT] == True:
            self.angle += 0.5
        elif keys[pygame.K_UP] == True:
            if self.fuel >0:
                self.fuel -= 0.5
                self.thrust = 1800
                self.thrust_on = True
        else:
            self.thrust = 0
            self.thrust_on = False

    def moveLeft(self):
        self.angle += 0.5
    def  moveRight(self):
        self.angle -= 0.5
    def thruster(self):
        if self.fuel >0:
            self.fuel -= 10
            self.thrust = 1800
            self.thrust_on = True

    def draw(self, screen):
        if self.thrust_on == False:
            self.rotatedImage = pygame.transform.rotate(self.img, self.angle)
            new_rect = self.rotatedImage.get_rect(center = self.img.get_rect(center = (self.x_pos,self.y_pos)).center)
            screen.blit(self.rotatedImage, new_rect)
        else:
            self.rotatedImage2 = pygame.transform.rotate(self.img2, self.angle)
            new_rect2 = self.rotatedImage2.get_rect(center = self.img.get_rect(center = (self.x_pos,self.y_pos)).center)
            screen.blit(self.rotatedImage2, new_rect2)

    def calculate(self):
        self.y_acceleration = ((self.weight - ((self.thrust*math.cos((self.angle%360)*( 3.1416/180)))))/self.mass)/50
        
        self.x_acceleration = ((self.thrust*math.sin(((self.angle%360)*(-1))*( 3.1416/180)))/self.mass)/50
        
        self.x_vel += self.x_acceleration
        self.y_vel += self.y_acceleration

        self.x_pos += self.x_vel
        self.y_pos += self.y_vel
        self.score +=1

        self.current_time = time.time()
        #print(self.current_time - self.start_time)
        
        if self.y_pos > 750:
            self.death = True
            self.y_pos = 0
            self.y_acceleration = 0
            self.y_vel = 0
            self.x_pos = 325
            self.x_acceleration = 0
            self.x_vel = 0
            self.fuel = 500
            self.angle = 0
        if self.x_pos > 750 or self.x_pos <0:
            self.death = True
            self.x_pos = 325
            self.x_acceleration = 0
            self.x_vel = 0
            self.y_pos = 0
            self.y_acceleration = 0
            self.y_vel = 0
            self.fuel = 500
            self.angle = 0

    def collision(self):
        self.momentum = self.mass * (math.sqrt((self.x_vel**2)+(self.y_vel**2)))
        if self.momentum > 750:
            self.death = True
        else:
            self.score = 100
        self.x_vel = 0
        self.y_vel = 0
        self.x_acceleration = 0
        self.y_acceletation = 0

class Planet (object):

    def __init__(self, backgroundImg,terrainImg, gravity, end_goal, atmosphere):
        self.backgroundImg = backgroundImg
        self.terrainImg = terrainImg
        self.gravity = gravity
        self.end_goal = end_goal
        self.atmosphere = atmosphere

    def draw(self, screen):
        screen.blit(self.backgroundImg, (0,0))
        screen.blit(self.terrainImg, (0, 420))

def collision(lander, terrain):
    
    if lander.thrust_on == False:
        lander_mask = pygame.mask.from_surface(lander.rotatedImage)
    else:
        lander_mask = pygame.mask.from_surface(lander.rotatedImage2)
    terrain_mask = pygame.mask.from_surface(terrain)

    offset = (int(lander.x_pos-5), int(lander.y_pos - 450))

    
    if terrain_mask.overlap(lander_mask, offset):
        #print("True")
        lander.collision()
        


def deathScreen(lander):
    pass


moon = Planet(pygame.image.load("MoonBackground.png"), pygame.image.load("MoonTerrain1.png"),0.8, [], False)
#lander = Lander(400,100, 0, 0.8)


def redraw():
    
    screen.fill((0,0,0))
    moon.draw(screen)
    font = pygame.font.SysFont('comicsans', 50)
    if len(landers) > 0:
        x_vel_text = font.render(("X Velocity:" + str(round(landers[0].x_vel,3))), 1, (255,255,255))
        y_vel_text = font.render(("Y Velocity:" + str(round(landers[0].y_vel,3))), 1, (255,255,255))
    ##    angle_text = font.render(("Angle:" + str(round(lander.angle))), 1, (255,255,255))
        screen.blit(x_vel_text, (600, 25))
        screen.blit(y_vel_text, (600, 75))
##    screen.blit(angle_text, (600, 125))
    for lander in landers:
        lander.draw(screen)
    pygame.display.update()


gen = 0
def eval_genomes(genomes,config):
    global landers, gen
    gen +=1
    run = True
    nets = []
    ge = []
    landers = []

    for genome_id,g in genomes:
        net = neat.nn.FeedForwardNetwork.create(g,config)
        nets.append(net)
        landers.append(Lander(random.randint(100,900),100, 0, 0.8))
        g.fitness = 0
        ge.append(g)

    clock = pygame.time.Clock()
    while run == True:
        clock.tick(60)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                run = False
                pygame.quit()
        for x, lander in enumerate(landers):
            lander.calculate()
            ge[x].fitness += 0.1
            output = nets[x].activate((lander.x_pos, lander.y_pos, lander.angle, lander.x_vel, lander.y_vel))
            #print(output)

            if output[0] > 0.5 and lander.fuel > 0:
                lander.thruster()
            if output[1]>0.5:
                lander.moveLeft()
            if output[2] > 0.5:
                lander.moveRight()


        for x,lander in enumerate(landers):
            if lander.death == False:
                #lander.move()
                #lander.calculate()
                
                
                collision(lander, moon.terrainImg)
                for g in ge:
                    g.fitness += 1
            else:
                ge[x].fitness -=1
                landers.pop(x)
                nets.pop(x)
                ge.pop(x)

        redraw()

##        if len(landers) <= 0:
##            run = False
##            break

        



def run(config_file):
    config = neat.config.Config(neat.DefaultGenome, neat.DefaultReproduction,
                         neat.DefaultSpeciesSet, neat.DefaultStagnation,
                         config_file)

    
    p = neat.Population(config)

    p.add_reporter(neat.StdOutReporter(True))
    stats = neat.StatisticsReporter()
    p.add_reporter(stats)

    winner = p.run(eval_genomes, 50)

    print('\nBest genome:\n{!s}'.format(winner))

        
        #winner = p.run(eval_genomes, 50)
        #print('\nBest genome:\n{!s}'.format(winner))
    

if __name__ == "__main__":
    #local_dir = os.path.dirname(__file__)
    config_path = os.path.join("LunarConfigFile.txt")
    run(config_path)

#pygame.quit()

            try:
            
                    bird = pyautogui.locateOnScreen("fpb.png",  confidence=0.2, grayscale=True,  region=(850, 145, 975, 706))
                    nets = []
                    ge = []
                    birds = []

                    for genome_id, genome in genomes: # gnomes
                            net = neat.nn.FeedForwardNetwork.create(genome, config)
                            nets.append(net)
                            birds.append(bird)
                               
                            genome.fitness = 0
                            ge.append(genome)
                    

                    
                            
                    
                    a = 1
                    b = 1
                            

                    for x, bird in enumerate(birds):
                            a = 1
                            c = 1
                            start_time = time.time()
                            while a == c:
                                    h = pyautogui.locateCenterOnScreen("fpb.png",  confidence=0.4, grayscale=True,  region=(850, 145, 975, 706))
                                    g = pyautogui.locateOnScreen("top_pipe.png",  confidence=0.8, grayscale=True, region=(850, 0, 1191, 685)) # region contains tuple showing where to look
                                    l = pyautogui.locateOnScreen("fpb.png",  confidence=0.2, grayscale=True,  region=(850, 145, 975, 706))
                                    b = pyautogui.locateOnScreen("bottom_pipe.png",  confidence=0.8, grayscale=True,  region=(850, 0, 1191, 200))
                                    print(g,l)
                                    try:
                                            print('printing k...')
                                            k = g[0] - l[0]
                                            print(k)
                                    except TypeError:
                                            k = 0
                                            print('k = 0')
                                    
                                    
                                    
                                    
                                    try: 
                                            m = l[2]-b[0]
                                            print(l[2])
                                            print(b[0])
                                            print(m)
                                            if m <= -1:
                                                    m = 0
                                                    print(m)
                                    except TypeError:
                                            m = 0
                                    p = pyautogui.locateCenterOnScreen("fpb.png",  confidence=0.2, grayscale=True,  region=(850, 145, 975, 706))
                                    output = net.activate(((p[1]), (k), (m)))
                                    print(output)
                                    q = [0.5]
                                    if output >= q:
                                            pyautogui.click(l)
                                    if output == [-1.0]:
                                            end_time = time.time()
                                            ge[x].fitness -= 1 # reduces fitness score for birds that hit a pipe
                                            birds.pop(x)
                                            nets.pop(x)
                                            ge.pop(x)
                                    
                                    
                                              

                                    if pyautogui.locateCenterOnScreen("fpb.png",  confidence=0.4, grayscale=True,  region=(850, 145, 975, 706)) == None:
                                    
                                            print('dead bird')
                                            end_time = time.time()
                                                    

                                            if pyautogui.locateOnScreen("pipedeath.png", confidence=0.5, grayscale=True) != None:
                                                                            
                                                    ge[x].fitness = (start_time-end_time)
                                                    ge[x].fitness -= 1 # reduces fitness score for birds that hit a pipe
                                                    birds.pop(x)
                                                    nets.pop(x)
                                                    ge.pop(x)
                                                            
                                            elif pyautogui.locateOnScreen('pipedeath.png', confidence=0.5, grayscale=True) == None:
                                                    ge[x].fitness = (start_time-end_time)
                                                    birds.pop(x)
                                                    nets.pop(x)
                                                    ge.pop(x)
                                            pyautogui.click(864, 516)
                                    try:

                                            if g[1] >= [665]:
                                    
                                                    print('dead bird')
                                                    end_time = time.time()
                                                    

                                                    if pyautogui.locateOnScreen("pipedeath.png", confidence=0.5, grayscale=True) != None:
                                                                            
                                                            ge[x].fitness = (start_time-end_time)
                                                            ge[x].fitness -= 1 # reduces fitness score for birds that hit a pipe
                                                            birds.pop(x)
                                                            nets.pop(x)
                                                            ge.pop(x)
                                                            
                                                    elif pyautogui.locateOnScreen('pipedeath.png', confidence=0.5, grayscale=True) == None:
                                                            ge[x].fitness = (start_time-end_time)
                                                            birds.pop(x)
                                                            nets.pop(x)
                                                            ge.pop(x)
                                    except TypeError:
                                            pass
                                            
                                            pyautogui.click(864, 516)

            except IndexError:
                    neat.generation +=1
            
                                    
                                            


                                            # gets location of birdif bird.y + pyautogui.locateOnscreen('fpb.png', confidence=0.5, grayscale=True) >= # y of dead bird
                            
                                                    
                                            
                            
                    

		# create an array that keeps the current total of pipes passed as an array if pyautogui.locateOnScreen # add one for each number seen for above 10 do one and 10 minus current number and 20 minus and thirty minus

    p = neat.Population(config)

    p.add_reporter(neat.StdOutReporter(True))
    stats = neat.StatisticsReporter()
    p.add_reporter(stats)
    gen = 0
    if gen <=50:
            gen += 1
            winner = p.run(main)

python3 flappy_bird.py 
pygame 1.9.6
Hello from the pygame community. https://www.pygame.org/contribute.html

 ****** Running generation 0 ****** 

Population's average fitness: 4.24400 stdev: 2.38639
Best fitness: 14.50000 - size: (1, 3) - species 1 - id 24
Average adjusted fitness: 0.152
Mean genetic distance 1.641, standard deviation 0.562
Population of 50 members in 2 species:
   ID   age  size  fitness  adj fit  stag
  ====  ===  ====  =======  =======  ====
     1    0    49     14.5    0.152     0
     2    0     1       --       --     0
Total extinctions: 0
Generation time: 9.507 sec

 ****** Running generation 1 ****** 

  Model Name:	MacBook Pro
  Model Identifier:	MacBookPro15,1
  Processor Name:	6-Core Intel Core i9
  Processor Speed:	2.9 GHz
  Number of Processors:	1
  Total Number of Cores:	6
  L2 Cache (per Core):	256 KB
  L3 Cache:	12 MB
  Hyper-Threading Technology:	Enabled
  Memory:	32 GB