main.py

# Import Modules
import pygame
import time
import random
import sys


# Import Classes
from player import Player
from platform_manager import Platform_Manager
from enemy_manager import Enemy_Manager
from boost_items import BoostItem, BoostItemManager
from menu import Menu
from background import Background


# Code Inspired by:

# PYGAME SETUP
# _______________________________________________________________________________________________________________________

# Initialize Pygame and Mixer
pygame.init()
pygame.mixer.init()

# Color Dictionary
colors = {
    "black": (0, 0, 0),
    "red": (255, 0, 0),
    "green": (0, 255, 0),
    "blue": (0, 0, 255),
    "yellow": (255, 255, 0),
    "cyan": (0, 255, 255),
    "magenta": (255, 0, 255),
    "silver": (192, 192, 192),
    "gray": (128, 128, 128),
    "maroon": (128, 0, 0),
    "olive": (128, 128, 0),
    "purple": (128, 0, 128),
    "white": (255, 255, 255),
}

screen_width = 1000
screen_height = 700
fps = 60

# Pygame Tools
timer = pygame.time.Clock()

# Screen Variables
window = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Jump Adventure")


# Background Objects
background_1 = Background(
    y=0, path="Resources/Sprites/Sprite-background_1.png", screen=window, moving=False
)
background_2 = Background(
    y=-700,
    path="Resources/Sprites/Sprite-background_2.png",
    screen=window,
    moving=False,
)
background_3 = Background(
    y=700, path="Resources/Sprites/Sprite-background_3.png", screen=window, moving=False
)
background_list = [background_1, background_2, background_3]

# Font Variables
font = pygame.font.SysFont(None, 55)
font_medium = pygame.font.SysFont(None, 30)
font_small = pygame.font.SysFont(None, 20)

game_font = pygame.font.SysFont("Consolas", 30)

# The following code inspried by a guide found on The Python Code
# 'How to Add Sound Effects to your Python Game' by Michael Maranan
# Available at: https://thepythoncode.com/article/add-sound-effects-to-python-game-with-pygame
# Load Sound Effects
jump_sound = pygame.mixer.Sound(
    "Resources/Sounds/Jump-SoundEffect.wav"
)  # Royalty Free Music: https://mixkit.co/
shoot_sound = pygame.mixer.Sound(
    "Resources/Sounds/Shoot-SoundEffect.wav"
)  # Royalty Free Music: https://mixkit.co/
power_sound = pygame.mixer.Sound(
    "Resources/Sounds/PowerUp-SoundEffect.wav"
)  # Royalty Free Music: https://mixkit.co/
game_over_sound = pygame.mixer.Sound(
    "Resources/Sounds/GameOver-SoundEffect.wav"
)  # Royalty Free Music: https://mixkit.co/
hit_sound = pygame.mixer.Sound("Resources/Sounds/EnemyImpact-SoundEffect.wav")
break_sound = pygame.mixer.Sound("Resources/Sounds/WoodHit-SoundEffect.wav")

# Load Game Play Music
game_play_music = pygame.mixer.Sound(
    "Resources/Sounds/GamePlay-SoundEffect.mp3"
)  # Royalty Free Music: https://www.bensound.com/
# pygame.mixer.music.load(game_play_music)


# FUNCTIONS
# _______________________________________________________________________________________________________________________


# Event Handler (For User Inputs)
def event_handler(menu_active, game_over) -> None:
    global running
    global player
    global start_time

    # Iterate Through Pygame Events
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

        if menu_active:
            start_time = time.time()
            menu.handle_input(event)

        # Reseting Game / Back to Menu / Quit at Game Over Screen
        elif not menu_active and game_over:
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_r:
                    init_new_game(False)
                if event.key == pygame.K_m:
                    init_new_game(True)

                if event.key == pygame.K_q:
                    pygame.quit()
                    sys.exit()

        else:
            # Key Presses
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    player.jump()
                    jump_sound.play()

                if event.key == pygame.K_LEFT:
                    player.x_delta -= player.speed

                if event.key == pygame.K_RIGHT:
                    player.x_delta += player.speed

                if event.key == pygame.K_UP:
                    player.shoot()
                    shoot_sound.play()

                if event.key == pygame.K_q:
                    running = False

            # Key Releases
            if event.type == pygame.KEYUP:
                if event.key == pygame.K_LEFT:
                    player.x_delta += player.speed

                if event.key == pygame.K_RIGHT:
                    player.x_delta -= player.speed


# The following code inspried by a guide found on Pygame tutorial
# 'Work with text' by Raphael Holzer Revision b84b643a
# Available at: https://pygame.readthedocs.io/en/latest/4_text/text.html
# Create and Render Text on the Screen
def render_text(text, font, color, surface, x, y) -> None:
    textobj = font.render(text, True, color)
    textrect = textobj.get_rect()
    textrect.center = (x, y)
    surface.blit(textobj, textrect)


# Check and Save High Score Function
def check_and_save_high_score(score, menu) -> None:
    if score > 0:
        menu.save_high_score(score)


# Render Player Image
def render_player_image(screen: pygame.surface) -> None:
    global player

    player_image = pygame.image.load("Resources/Sprites/monke1.png")
    player_image = pygame.transform.scale(player_image, (player.width, player.height))
    screen.blit(player_image, (player.x, player.y))


# Render Platform Images
def render_platform_images(screen: pygame.surface) -> None:
    global platform_manager
    temp_image = None

    image_path_dict = {
        "base": "Resources/Sprites/Sprite-normal_log.png",
        "horizontal": "Resources/Sprites/Sprite-moving_log.png",
        "falling": "Resources/Sprites/Sprite-falling_log.png",
        "disappearing": "Resources/Sprites/Sprite-breaking_log.png",
    }

    for plat in platform_manager.platform_list:

        temp_image = pygame.image.load(image_path_dict[plat.type])
        temp_image = pygame.transform.scale(temp_image, (plat.width, plat.height))
        screen.blit(temp_image, (plat.x, plat.y))


# Render Enemy Images
def render_enemy_images(screen: pygame.surface) -> None:
    global enemy_manager
    temp_image = None

    image_path_dict = {
        "base": "Resources/Sprites/Sprite-base_enemy.png",
        "bounce": "Resources/Sprites/Sprite-bouncing_enemy.png",
        "chase": "Resources/Sprites/Sprite-following_enemy.png",
    }

    for enemy in enemy_manager.enemy_list:

        temp_image = pygame.image.load(image_path_dict[enemy.type])
        temp_image = pygame.transform.scale(temp_image, (enemy.width, enemy.height))
        screen.blit(temp_image, (enemy.x, enemy.y))


# Render Projectile Images
def render_projectile_images(screen: pygame.surface) -> None:
    global player

    for proj in player.projectile_manager.projectile_list:
        proj_image = pygame.image.load("Resources/Sprites/Sprite-banana.png")
        proj_image = pygame.transform.scale(proj_image, (proj.width, proj.height))
        screen.blit(proj_image, (proj.x, proj.y))


def render_boost_images(screen: pygame.surface) -> None:
    global boost_item_manager
    temp_image = None

    image_path_dict = {
        "parachute": "Resources/Sprites/Sprite-parachute_powerup.png",
        "double_jump": "Resources/Sprites/Sprite-double_jump_powerup.png",
        "shield": "Resources/Sprites/Sprite-shield_powerup.png",
    }

    for boost in boost_item_manager.items:

        # Load Images and Scale
        temp_image = pygame.image.load(image_path_dict[boost.boost_type])
        temp_image = pygame.transform.scale(temp_image, (boost.width, boost.height))
        screen.blit(temp_image, (boost.x, boost.y))


# Render Moving Backround
def render_background(game_over: bool) -> None:

    for background in background_list:
        background.render()

        if game_over == False:
            background.move()


# Render Power Up Buff Effect Icon
def render_icon_image(
    screen: pygame.surface, path: str, x_pos: int, y_pos: int
) -> None:

    icon_image = pygame.image.load(path)
    icon_image = pygame.transform.scale(icon_image, (40, 40))
    screen.blit(icon_image, (x_pos, y_pos))


def render_all_icons(screen: pygame.surface) -> None:

    # if player effect is active, display image
    if player.double_jump.active:
        render_icon_image(
            window,
            "Resources/Sprites/Sprite-double_jump_powerup.png",
            10,
            (screen.get_height() - 50),
        )

    if player.shield.active:
        render_icon_image(
            window,
            "Resources/Sprites/Sprite-shield_powerup.png",
            60,
            (screen.get_height() - 50),
        )

    if player.parachute.active:
        render_icon_image(
            window,
            "Resources/Sprites/Sprite-parachute_powerup.png",
            110,
            (screen.get_height() - 50),
        )


# Rendering all Game Images
def render_game_images(window: pygame.surface) -> None:

    # Render Player
    render_player_image(window)

    # Render Platforoms
    render_platform_images(window)

    # Render Enemies
    render_enemy_images(window)

    # Render Boost Images
    render_boost_images(window)

    # Render Projectiles
    render_projectile_images(window)

    # Render Power Up Icons When Active
    render_all_icons(window)


# GAME SETUP
# _______________________________________________________________________________________________________________________

# Create Menu Object
menu = Menu(window, font, colors)

# Create Player Object
player = Player(
    power_sound=power_sound,
    hit_sound=hit_sound,
    break_sound=break_sound,
)

# Create Platform Manager
platform_manager = Platform_Manager()

# Create Enemy Manager
enemy_manager = Enemy_Manager(player_x=player.x, player_y=player.y)

# Create Boost Item Manager
boost_item_manager = BoostItemManager(screen_width, screen_height, player)

# Game Loop
running = True
game_over = False
start_time = time.time()
final_time = 0
level = 1
level_time = time.time()


# Function to Reset / Start the Game
def init_new_game(menu_status: bool) -> None:

    # Get Global Variables
    global menu, game_over, start_time, final_time, level, player, platform_manager, enemy_manager, boost_item_manager, level_time

    # Return to Menu or not
    if menu_status:
        menu = Menu(window, font, colors)

    # Reset Globals
    game_over = False
    start_time = time.time()
    final_time = 0
    level = 1
    level_time = time.time()
    player = Player(
        power_sound=power_sound,
        hit_sound=hit_sound,
        break_sound=break_sound,
    )
    platform_manager = Platform_Manager()
    enemy_manager = Enemy_Manager(player_x=player.x, player_y=player.y)
    boost_item_manager = BoostItemManager(screen_width, screen_height, player)


# Function to Increase the Level
def increase_level() -> None:
    global level, enemy_manager, platform_manager, start_time, level_time

    # Every 20 Seconds, Increase Level by One
    if time.time() - level_time > 10.0:
        level_time = time.time()
        level += 1

        # Increment Platform and Enemy Manager
        platform_manager.increment_difficulty(level)
        enemy_manager.increment_difficulty(level)


while running:

    # Handle Menu Actions
    if menu.active:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            menu.handle_input(event)
        menu.draw()

        # Start The Game
        if not menu.active:
            init_new_game(False)
            pygame.mixer.stop()
            game_play_music.play(-1)

    else:

        # Pygame Variables
        timer.tick(fps)
        window.fill((255, 255, 255))
        render_background(game_over)

        if not game_over:

            # Render Actors
            player.get_rect()

            # Update Player position for Enemey Location
            enemy_manager.player_x = player.x + (player.width // 2)
            enemy_manager.player_y = player.y + (player.height // 2)

            # Collision Detection
            player.handle_player_platforms(platform_manager, window)
            player.enemy_collision(enemy_manager)

            # Update Actors and Check for Game Over (TODO: Summarize in Function)
            player.update(window, enemy_manager)

            # Spawn items at random intervals
            if random.random() < 0.01:  # Adjust frequency as needed
                boost_item_manager.spawn_item()

            # Manage Platforms
            platform_manager.manage_platforms(window, colors)

            # Manage Enemies
            enemy_manager.manage_enemies(window)

            # Update Boost Items
            boost_item_manager.update_items()

            # Increase Level (Dynamic Scaling)
            increase_level()

            # Capture the time at game over
            if not player.alive:
                final_time = time.time() - start_time
                game_over = True
                game_over_sound.play()

            # Render Images
            render_game_images(window)

            # Display the Timer/Score
            elapsed_time = final_time if game_over else time.time() - start_time
            score_text = f"Score: {int(elapsed_time)}"
            level_text = f"Level: {level}"

            # Positioned near upper right corner
            render_text(
                score_text, game_font, colors["black"], window, screen_width - 920, 20
            )

            render_text(
                level_text, game_font, colors["black"], window, screen_width - 922, 50
            )

        if game_over:
            render_text(
                "Game Over",
                font,
                colors["red"],
                window,
                screen_width / 2,
                screen_height / 2,
            )

            check_and_save_high_score(int(elapsed_time), menu)
            render_text(
                f"Final Score: {int(elapsed_time)}, Level: {int(level)}",
                font_medium,
                colors["red"],
                window,
                screen_width / 2,
                (screen_height / 2) + 30,
            )
            render_text(
                "Press R to Reset, Press for Main Menu, Press Q to Quit",
                font_small,
                colors["black"],
                window,
                screen_width / 2,
                (screen_height / 2) + 50,
            )

    # Event Handler
    event_handler(menu.active, game_over)

    # Update Display
    pygame.display.flip()


pygame.quit()