Very simple Flappy 'Bird' game - First project in Python

Question

I am a beginner in Python. This is my first project in Python (that I tried to complete).

There is a grey square that acts as the Flappy 'Bird' with green obstacles spawning with random gap sizes. The difficulty of the game stays the same for now. If an obstacle is hit, the game closes (I haven't implemented any menu thing yet). Pressing Esc pauses/unpauses the game.

How does the code look like and what improvements can I make to it in terms of organization, scalability, best practices, etc?

pygame 2.5.0 (SDL 2.28.0, Python 3.11.4)

1. game_objects.py

class Player:
    def __init__(self, position: tuple[float, float], size: tuple[int, int], color: tuple[int, int, int]):
        self.x, self.y = position
        
        self.width, self.height = size
        
        self.acc_y = 0.0
        self.vel_y = 0.0
        
        self.color = color

class Obstacle:
    vel_x = -65.0
    
    def __init__(self, position: tuple[float, float], size: tuple[int, int], color: tuple[int, int, int]):
        self.x, self.y = position
        
        self.width, self.height = size
        
        self.color = color

2. main.py

import pygame, random
from game_objects import *

# Initializing pygame and setting up the screen
pygame.init()

pygame.display.set_caption("Flappy Bird")

SCREEN_WIDTH, SCREEN_HEIGHT = 600, 600

screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT), flags=pygame.SCALED, vsync=1)

# The player
player = Player((85.0, 150.0), (25, 25), (50, 50, 50))
player.acc_y = 500

# Obstacle list
obstacles: list[Obstacle] = []

def spawn_obstacle():
    gap_height = random.randint(125, 250)
    gap_y = random.randint(0, (SCREEN_HEIGHT - gap_height))
    
    obstacles.append(Obstacle((SCREEN_WIDTH, 0.0), (65, gap_y), (45, 168, 40)))
    obstacles.append(Obstacle((SCREEN_WIDTH, (gap_y + gap_height)), (65, (SCREEN_HEIGHT - (gap_y + gap_height))), (45, 168, 40)))

##### The game loop

# For calculating delta_time
last_tick = pygame.time.get_ticks()

# For spawning obstacles at regular intervals
obstacle_interval = 3000
time_since_last_obstacle = obstacle_interval
last_obstacle_tick = (last_tick - time_since_last_obstacle)

paused = False
lost = False

running = True
while (running):
    # Handling various events
    for event in pygame.event.get():
        if (event.type == pygame.QUIT):
            running = False
        elif (event.type == pygame.KEYDOWN):
            if ((event.key == pygame.K_w) or (event.key == pygame.K_UP)):
                player.vel_y = -250.
            elif (event.key == pygame.K_ESCAPE):
                if (paused):
                    paused = False
                    last_tick = pygame.time.get_ticks()
                    last_obstacle_tick = (last_tick - time_since_last_obstacle)
                else:
                    paused = True
    
    if (not paused):
        # Check if the player lost the previous iteration
        if (lost):
            print("You lost!")
            running = False
            continue
        
        # Calculate delta_time
        current_tick = pygame.time.get_ticks()
        delta_time = (current_tick - last_tick) / 1000.0
        last_tick = current_tick
        
        # Clear the screen for fresh drawing
        screen.fill((156, 204, 255))
        
        # Spawning obstacles every obstacle_interval milliseconds
        time_since_last_obstacle = (current_tick - last_obstacle_tick)
        if (time_since_last_obstacle > obstacle_interval):
            last_obstacle_tick = current_tick
            spawn_obstacle()
        
        # Updating the player's movement and position
        player.vel_y += (player.acc_y * delta_time)
        player.y += (player.vel_y * delta_time)
        
        # Check whether the player is colliding with the horizontal edges
        if ((player.y < 0.0) or (player.y > (SCREEN_HEIGHT - player.height))):
            lost = True
        
        # Obstacle logic
        for obstacle in obstacles:
            obstacle.x += (Obstacle.vel_x * delta_time)
            
            # Check whether the obstacle is no longer visible
            if (obstacle.x < -obstacle.width):
                obstacles.remove(obstacle)
                continue
            
            # Check whether the player is colliding with the obstacle
            if ((player.x > (obstacle.x - player.width)) and (player.x < (obstacle.x + obstacle.width))):
                if ((player.y > (obstacle.y - player.height)) and (player.y < (obstacle.y + obstacle.height))):
                    lost = True
            
            # Drawing the obstacle
            pygame.draw.rect(screen, obstacle.color, pygame.Rect(int(obstacle.x), int(obstacle.y), obstacle.width, obstacle.height))
        
        # Drawing the player
        pygame.draw.rect(screen, player.color, pygame.Rect(int(player.x), int(player.y), player.width, player.height))
        
    # Update the entire window
    pygame.display.flip()

Answer 1

The game is too hard for me. As for the code, I appreciate the comments. The main point I want to insist on is to separate things into classes/functions/files where they belong.

Constants

Separate all the constants/settings/parameters to another file. This way if you need to adjust the parameters or maybe add dificulty levels later on, everything is in the same place.

constants.py

## Graphics options
SCREEN_WIDTH, SCREEN_HEIGHT = 600, 600

## Gameplay options
OBSTACLE_SPEED = 65
OBSTACLE_WIDTH = 65
OBSTACLE_GAP_RANGE = (125,250)
OBSTACLE_SPAWN_SPACE_INTERVAL = 200

PLAYER_SPAWN_POS = (85.0, 150.0)
PLAYER_SIZE = (25, 25)
PLAYER_INITIAL_DECEL = 500

As for the colors, you've coded them in instance declarations. I suggest using an Enum to define every color you'll need and separate variables to pick object colors. This way you can play around with colors and objects independantly in the future. In constants.py or another file.

from enum import Enum
## Colors
class Color(Enum):
    GREEN =  (45, 168, 40)
    GREY = (50, 50, 50)
    LIGHT_BLUE = (156, 204, 255)

PLAYER_COLOR = Color.GREY
OBSTACLE_COLOR = Color.GREEN
BACKGROUND_COLOR = Color.LIGHT_BLUE

Game objects

You've defined classes for players, which is good. Consider using dataclasses. They let you skip all the boilerplate init code and add useful methods for printing and equality checks. Your objects also share a few attributes such as position, size and color. These are common to any game object and if you were to add any new type of game object they woud have it too. Maybe its a good idea to define an abstract UI object class:

@dataclass
class UI_object:
    # Also possible to go with tuples instead of x, y eg:
    # size: Tuple[int,int] and position Tuple[float,float]
    x: float
    y: float
    width: int
    height: int
    color: cst.Color

@dataclass()
class Obstacle(UI_object):
    ...

@dataclass
class Player(UI_object):
    ...

Your code logic is all over the place in your main file. I suggest you separate logic related to each class into its own methods. Spawning players or obstacles should be class methods. Checking if the player is out of bounds shoud be a Player instance method. Checking if the player hit an obstacle could be a Player or Obstacle instance method. Also you update object positions for players and obstacles separately. I would group the logic together into the abstract class.

game_objects.py

from dataclasses import dataclass
from typing import Optional
import constants as cst
import random


@dataclass
class UI_object:
    x: float
    y: float
    width: int
    height: int
    color: cst.Color
    vel_x: Optional[float] = 0
    vel_y: Optional[float] = 0
    acc_x: Optional[float] = 0
    acc_y: Optional[float] = 0

    def update_pos(self, time_delta: float):
        self.vel_x += self.acc_x * time_delta
        self.x += self.vel_x * time_delta
        self.vel_y += self.acc_y * time_delta
        self.y += self.vel_y * time_delta


@dataclass()
class Obstacle(UI_object):
    vel_x: float = -cst.OBSTACLE_SPEED

    @classmethod
    def spawn_obstacle(cls):
        gap_height = random.randint(
            cst.OBSTACLE_GAP_INTERVAL[0], cst.OBSTACLE_GAP_INTERVAL[1]
        )
        gap_y = random.randint(0, (cst.SCREEN_HEIGHT - gap_height))

        lower_obstacle = cls(
            x=cst.SCREEN_HEIGHT,
            y=0,
            width=cst.OBSTACLE_WIDTH,
            height=gap_y,
            color=cst.OBSTACLE_COLOR,
        )
        upper_obstacle = cls(
            x=cst.SCREEN_HEIGHT,
            y=gap_y + gap_height,
            width=cst.OBSTACLE_WIDTH,
            height=cst.SCREEN_HEIGHT - gap_y - gap_height,
            color=cst.OBSTACLE_COLOR,
        )
        return lower_obstacle, upper_obstacle


@dataclass
class Player(UI_object):
    acc_y: float = cst.PLAYER_INITIAL_DECEL

    def is_out_of_bounds(self):
        return (self.y < 0.0) or (self.y > (cst.SCREEN_HEIGHT - self.height))

    def is_touching_obstacle(self, obstacle: Obstacle):
        return (
            (obstacle.x - self.width) < self.x < (obstacle.x + obstacle.width)
        ) and ((obstacle.y - self.height) < self.y < (obstacle.y + obstacle.height))

    @classmethod
    def spawn(cls):
        return cls(
            x=cst.PLAYER_SPAWN_POS[0],
            y=cst.PLAYER_SPAWN_POS[1],
            width=cst.PLAYER_SIZE[0],
            height=cst.PLAYER_SIZE[1],
            color = cst.PLAYER_COLOR
        )

Main file

It's recommended to use a __main__ == "__name__" check in your python scripts mainly to prevent accidental execution of the script. I created a Game Class to organise the code but you could just as easily achieve the same with functions only.

class Flappy_bird:
    def __init__(self) -> None:
        pygame.init()
        pygame.display.set_caption("Flappy Bird")
        self.screen =  pygame.display.set_mode((cst.SCREEN_WIDTH, cst.SCREEN_HEIGHT), flags=pygame.SCALED, vsync=1)
        self.player : Player = Player.spawn()
        self.obstacles : List[Obstacle] = []
        self.paused = False
        self.last_tick:int = 0
        self.last_obstacle_tick: int = 0

You render the background, the obstacles and the player separataly at differents times and places in your code. Say you decided to render you game differently, you would have to change code in all these different places. Put code that does the same or similar things together.

I grouped up everything so as to end up with a simple looking game loop.

   while True:
        for event in pygame.event.get():
            self.handle_event(event)
        time_delta = self.update_tick()
        if not self.paused:
            self.add_or_remove_obstacles()
            self.update_object_positions(time_delta)
            self.check_if_player_lost()
            self.render()

Nitpicking

• Instead of (B > A) and (B < C) you can use A < B < C
• Don't go too deep into if-elses, usually there are ways of simplyfiying
• Too many flags! You don't need the lost and running flags. You can always return or quit().
• In general avoid import *
• I also changed they way you handle new obstacles from a time interval to a space interval. It is both simpler to handle pauses and it allows you to change the obstacle speed without having to also adjust the interval.

All in all really good code for a first project. You could add score keeping, didiculty levels, and maybe saving and reloading a game to learn different concepts.

Final script: main.py

from typing import Any, List
import pygame, random
from game_objects import Player, Obstacle
import constants as cst


class Flappy_bird:
    def __init__(self) -> None:
        pygame.init()
        pygame.display.set_caption("Flappy Bird")
        self.screen = pygame.display.set_mode(
            (cst.SCREEN_WIDTH, cst.SCREEN_HEIGHT), flags=pygame.SCALED, vsync=1
        )
        self.player: Player = Player.spawn()
        self.obstacles: List[Obstacle] = []
        self.paused = False
        self.last_tick: int = 0

    def handle_event(self, event: pygame.event.EventType):
        if event.type == pygame.QUIT:
            exit()
        if event.type == pygame.KEYDOWN:
            if (event.key == pygame.K_w) or (event.key == pygame.K_UP):
                self.player.vel_y = -250.0
            elif event.key == pygame.K_ESCAPE:
                self.paused = not self.paused

    def check_if_player_lost(self):
        if self.player.is_out_of_bounds() or any(
            self.player.is_touching_obstacle(obstacle) for obstacle in self.obstacles
        ):
            print("You lost!")
            exit()

    def render(self):
        # Clear the screen for fresh drawing
        self.screen.fill(cst.BACKGROUND_COLOR.value)
        # Drawing the player
        pygame.draw.rect(
            self.screen,
            self.player.color.value,
            pygame.Rect(
                int(self.player.x),
                int(self.player.y),
                self.player.width,
                self.player.height,
            ),
        )
        # Drawing the obstacles
        for obstacle in self.obstacles:
            pygame.draw.rect(
                self.screen,
                obstacle.color.value,
                pygame.Rect(
                    int(obstacle.x), int(obstacle.y), obstacle.width, obstacle.height
                ),
            )
        # Update the entire window
        pygame.display.flip()

    def update_object_positions(self, time_delta_ms: int):
        time_delta_s = time_delta_ms / 1000
        self.player.update_pos(time_delta_s)
        for obstacle in self.obstacles:
            obstacle.update_pos(time_delta_s)

    def add_or_remove_obstacles(self):
        self.obstacles = [
            obstacle for obstacle in self.obstacles if (obstacle.x >= -obstacle.width)
        ]
        if (
            not self.obstacles
            or cst.SCREEN_WIDTH - self.obstacles[-1].x
            > cst.OBSTACLE_SPAWN_SPACE_INTERVAL
        ):
            self.obstacles.extend(Obstacle.spawn_obstacle())

    def update_tick(self) -> int:
        current_tick = pygame.time.get_ticks()
        time_delta = current_tick - self.last_tick
        self.last_tick = current_tick
        return time_delta

    def run(self):
        # initial ticks
        self.last_tick = pygame.time.get_ticks()
        while True:
            for event in pygame.event.get():
                self.handle_event(event)
            time_delta = self.update_tick()
            if not self.paused:
                self.add_or_remove_obstacles()
                self.update_object_positions(time_delta)
                self.check_if_player_lost()
                self.render()


if __name__ == "__main__":
    game = Flappy_bird()
    game.run()

```