Merge pull request #2522 from Shikhar9425/patch-6

avinashkranjan · web-flow · commit ee1b6116ba56 · 2023-08-09T19:53:01.000+05:30
Flappy_bird.py
diff --git a/AI-driven AI Flappy Bird/Flappy_bird.py b/AI-driven AI Flappy Bird/Flappy_bird.py
@@ -0,0 +1,282 @@
+#AI-driven AI Flappy Bird
+import pygame
+import neat
+import os
+import random
+
+# Game window size
+WINDOW_WIDTH = 500
+WINDOW_HEIGHT = 800
+
+# Bird images
+BIRD_IMAGES = [
+    pygame.transform.scale2x(pygame.image.load(os.path.join("images", "bird1.png"))),
+    pygame.transform.scale2x(pygame.image.load(os.path.join("images", "bird2.png"))),
+    pygame.transform.scale2x(pygame.image.load(os.path.join("images", "bird3.png")))
+]
+
+# Pipe image
+PIPE_IMAGE = pygame.transform.scale2x(pygame.image.load(os.path.join("images", "pipe.png")))
+
+# Base image
+BASE_IMAGE = pygame.transform.scale2x(pygame.image.load(os.path.join("images", "base.png")))
+
+# Background image
+BG_IMAGE = pygame.transform.scale2x(pygame.image.load(os.path.join("images", "bg.png")))
+
+
+class Bird:
+    IMAGES = BIRD_IMAGES
+    MAX_ROTATION = 25
+    ROTATION_VELOCITY = 20
+    ANIMATION_TIME = 5
+
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+        self.tilt = 0
+        self.tick_count = 0
+        self.velocity = 0
+        self.height = self.y
+        self.image_count = 0
+        self.image = self.IMAGES[0]
+
+    def jump(self):
+        self.velocity = -10.5
+        self.tick_count = 0
+        self.height = self.y
+
+    def move(self):
+        self.tick_count += 1
+        displacement = self.velocity * self.tick_count + 1.5 * self.tick_count ** 2
+
+        if displacement >= 16:
+            displacement = 16
+
+        if displacement < 0:
+            displacement -= 2
+
+        self.y = self.y + displacement
+
+        if displacement < 0 or self.y < self.height + 50:
+            if self.tilt < self.MAX_ROTATION:
+                self.tilt = self.MAX_ROTATION
+        else:
+            if self.tilt > -90:
+                self.tilt -= self.ROTATION_VELOCITY
+
+    def draw(self, win):
+        self.image_count += 1
+
+        if self.image_count < self.ANIMATION_TIME:
+            self.image = self.IMAGES[0]
+        elif self.image_count < self.ANIMATION_TIME * 2:
+            self.image = self.IMAGES[1]
+        elif self.image_count < self.ANIMATION_TIME * 3:
+            self.image = self.IMAGES[2]
+        elif self.image_count < self.ANIMATION_TIME * 4:
+            self.image = self.IMAGES[1]
+        elif self.image_count == self.ANIMATION_TIME * 4 + 1:
+            self.image = self.IMAGES[0]
+            self.image_count = 0
+
+        if self.tilt <= -80:
+            self.image = self.IMAGES[1]
+            self.image_count = self.ANIMATION_TIME * 2
+
+        rotated_image = pygame.transform.rotate(self.image, self.tilt)
+        new_rect = rotated_image.get_rect(center=self.image.get_rect(topleft=(self.x, self.y)).center)
+        win.blit(rotated_image, new_rect.topleft)
+
+    def get_mask(self):
+        return pygame.mask.from_surface(self.image)
+
+
+class Pipe:
+    GAP = 200
+    VEL = 5
+
+    def __init__(self, x):
+        self.x = x
+        self.height = 0
+
+        self.top = 0
+        self.bottom = 0
+        self.PIPE_TOP = pygame.transform.flip(PIPE_IMAGE, False, True)
+        self.PIPE_BOTTOM = PIPE_IMAGE
+
+        self.passed = False
+        self.set_height()
+
+    def set_height(self):
+        self.height = random.randrange(50, 450)
+        self.top = self.height - self.PIPE_TOP.get_height()
+        self.bottom = self.height + self.GAP
+
+    def move(self):
+        self.x -= self.VEL
+
+    def draw(self, win):
+        win.blit(self.PIPE_TOP, (self.x, self.top))
+        win.blit(self.PIPE_BOTTOM, (self.x, self.bottom))
+
+    def collide(self, bird):
+        bird_mask = bird.get_mask()
+        top_mask = pygame.mask.from_surface(self.PIPE_TOP)
+        bottom_mask = pygame.mask.from_surface(self.PIPE_BOTTOM)
+
+        top_offset = (self.x - bird.x, self.top - round(bird.y))
+        bottom_offset = (self.x - bird.x, self.bottom - round(bird.y))
+
+        t_point = bird_mask.overlap(top_mask, top_offset)
+        b_point = bird_mask.overlap(bottom_mask, bottom_offset)
+
+        if t_point or b_point:
+            return True
+
+        return False
+
+
+class Base:
+    VEL = 5
+    WIDTH = BASE_IMAGE.get_width()
+    IMG = BASE_IMAGE
+
+    def __init__(self, y):
+        self.y = y
+        self.x1 = 0
+        self.x2 = self.WIDTH
+
+    def move(self):
+        self.x1 -= self.VEL
+        self.x2 -= self.VEL
+
+        if self.x1 + self.WIDTH < 0:
+            self.x1 = self.x2 + self.WIDTH
+
+        if self.x2 + self.WIDTH < 0:
+            self.x2 = self.x1 + self.WIDTH
+
+    def draw(self, win):
+        win.blit(self.IMG, (self.x1, self.y))
+        win.blit(self.IMG, (self.x2, self.y))
+
+
+def draw_window(win, birds, pipes, base, score):
+    win.blit(BG_IMAGE, (0, 0))
+    for pipe in pipes:
+        pipe.draw(win)
+
+    text = STAT_FONT.render("Score: " + str(score), 1, (255, 255, 255))
+    win.blit(text, (WINDOW_WIDTH - 10 - text.get_width(), 10))
+
+    base.draw(win)
+    for bird in birds:
+        bird.draw(win)
+    pygame.display.update()
+
+
+def main(genomes, config):
+    nets = []
+    ge = []
+    birds = []
+
+    for _, g in genomes:
+        net = neat.nn.FeedForwardNetwork.create(g, config)
+        nets.append(net)
+        birds.append(Bird(230, 350))
+        g.fitness = 0
+        ge.append(g)
+
+    base = Base(730)
+    pipes = [Pipe(700)]
+    win = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
+    clock = pygame.time.Clock()
+    score = 0
+
+    run = True
+    while run:
+        clock.tick(30)
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                run = False
+                pygame.quit()
+                quit()
+
+        pipe_ind = 0
+        if len(birds) > 0:
+            if len(pipes) > 1 and birds[0].x > pipes[0].x + pipes[0].PIPE_TOP.get_width():
+                pipe_ind = 1
+        else:
+            run = False
+            break
+
+        for x, bird in enumerate(birds):
+            bird.move()
+            ge[x].fitness += 0.1
+
+            output = nets[x].activate((bird.y, abs(bird.y - pipes[pipe_ind].height), abs(bird.y - pipes[pipe_ind].bottom)))
+
+            if output[0] > 0.5:
+                bird.jump()
+
+        add_pipe = False
+        remove_pipes = []
+        for pipe in pipes:
+            for x, bird in enumerate(birds):
+                if pipe.collide(bird):
+                    ge[x].fitness -= 1
+                    birds.pop(x)
+                    nets.pop(x)
+                    ge.pop(x)
+
+                if not pipe.passed and pipe.x < bird.x:
+                    pipe.passed = True
+                    add_pipe = True
+
+            if pipe.x + pipe.PIPE_TOP.get_width() < 0:
+                remove_pipes.append(pipe)
+
+            pipe.move()
+
+        if add_pipe:
+            score += 1
+            for g in ge:
+                g.fitness += 5
+            pipes.append(Pipe(700))
+
+        for pipe in remove_pipes:
+            pipes.remove(pipe)
+
+        for x, bird in enumerate(birds):
+            if bird.y + bird.image.get_height() >= 730 or bird.y < 0:
+                birds.pop(x)
+                nets.pop(x)
+                ge.pop(x)
+
+        base.move()
+        draw_window(win, birds, pipes, base, score)
+
+
+def run_neat():
+    local_dir = os.path.dirname(__file__)
+    config_path = os.path.join(local_dir, "config-feedforward.txt")
+    config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
+                         neat.DefaultSpeciesSet, neat.DefaultStagnation,
+                         config_path)
+
+    population = neat.Population(config)
+    population.add_reporter(neat.StdOutReporter(True))
+    stats = neat.StatisticsReporter()
+    population.add_reporter(stats)
+
+    winner = population.run(main, 50)
+
+    print("\nBest genome:\n{!s}".format(winner))
+
+
+if __name__ == "__main__":
+    pygame.init()
+    STAT_FONT = pygame.font.SysFont("comicsans", 50)
+    run_neat()
+
diff --git a/AI-driven AI Flappy Bird/README.md b/AI-driven AI Flappy Bird/README.md
@@ -0,0 +1,34 @@
+Package/Script Name: AI-driven AI Flappy Bird
+
+Short Description: AI-driven AI Flappy Bird is a Python script that implements an AI player for the game "Flappy Bird." The AI player uses the Genetic Algorithm to learn and play the game automatically, aiming to achieve a high score.
+
+Functionalities/Script:
+
+FlappyBirdGame class: Represents the Flappy Bird game and handles game logic.
+AI_agent class: Implements the AI player using the Genetic Algorithm to learn and play the game.
+Heuristic evaluation function: Calculates the fitness of each AI agent based on its performance in the game.
+Board representation: Displays the game window, bird, and pipes.
+Setup Instructions:
+
+Make sure you have Python installed on your system (Python 3.6 or higher).
+Install the required libraries using pip:
+bash
+Copy code
+pip install pygame
+Download the AI_flappy_bird.py file from the repository or package.
+Explanation of Script:
+The AI-driven AI Flappy Bird script utilizes the Genetic Algorithm to train AI agents to play the Flappy Bird game. The AI agents aim to learn how to navigate through pipes by optimizing their performance over multiple generations.
+
+Usage:
+
+Run the AI_flappy_bird.py script.
+bash
+Copy code
+python AI_flappy_bird.py
+The game window will open, and the AI agents will start playing Flappy Bird.
+Observe how the AI agents improve their performance over generations.
+Output:
+The AI-driven AI Flappy Bird script will display a game window where AI agents play the Flappy Bird game. The script will continuously show the performance of the current generation of AI agents. The AI agents will learn and adapt to navigate through the pipes more effectively over generations.
+
+Author:
+Shikhar9425
