final.py

import pygame, sys, os, random, math
from pygame.locals import *

# Initialize Pygame and mixer for sound
pygame.mixer.pre_init()
pygame.init()
fps = pygame.time.Clock()

# Define colors
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLACK = (0, 0, 0)

# Game configuration
WIDTH = 800
HEIGHT = 600
ASTEROID_SPEED = 2
NUM_ASTEROIDS = 5
BULLET_SPEED = 10
SHIP_SPEED = 10
FRICTION = 0.2
LEVEL_UP_SCORE = 100
MAX_LEVEL = 10

# Global variables
time = 0
score = 0
level = 1
lives = 3
game_over = False
paused = False
high_score = 0

# Initialize game window
window = pygame.display.set_mode((WIDTH, HEIGHT), 0, 32)
pygame.display.set_caption('Asteroids')

# Load images with error handling
def load_image(filename):
    try:
        return pygame.image.load(os.path.join('images', filename))
    except pygame.error as e:
        print(f"Error loading image {filename}: {e}")
        sys.exit(1)

bg = load_image('bg.jpg')
debris = load_image('debris2_brown.png')
ship_img = load_image('ship.png')
ship_thrusted_img = load_image('ship_thrusted.png')
asteroid = load_image('asteroid.png')
shot = load_image('shot2.png')
explosion = load_image('explosion_blue.png')

# Load sounds with error handling
def load_sound(filename):
    try:
        return pygame.mixer.Sound(os.path.join('sounds', filename))
    except pygame.error as e:
        print(f"Error loading sound {filename}: {e}")
        return None

missile_sound = load_sound('missile.ogg')
if missile_sound:
    missile_sound.set_volume(1)

thruster_sound = load_sound('thrust.ogg')
if thruster_sound:
    thruster_sound.set_volume(1)

explosion_sound = load_sound('explosion.ogg')
if explosion_sound:
    explosion_sound.set_volume(1)

# Load background music
try:
    pygame.mixer.music.load(os.path.join('sounds', 'game.ogg'))
    pygame.mixer.music.set_volume(0.3)
    pygame.mixer.music.play(-1)  # Loop indefinitely
except pygame.error as e:
    print(f"Error loading music: {e}")

# Load high score from file
def load_high_score():
    try:
        with open('high_score.txt', 'r') as f:
            return int(f.read())
    except:
        return 0

def save_high_score(score):
    with open('high_score.txt', 'w') as f:
        f.write(str(score))

high_score = load_high_score()

# Ship class
class Ship:
    def __init__(self):
        self.x = WIDTH / 2 - 50
        self.y = HEIGHT / 2 - 50
        self.angle = 0
        self.speed = 0
        self.is_rotating = False
        self.is_forward = False
        self.direction = 0

    def update(self):
        if self.is_rotating:
            if self.direction == 0:
                self.angle -= 10
            else:
                self.angle += 10

        if self.is_forward or self.speed > 0:
            self.x += math.cos(math.radians(self.angle)) * self.speed
            self.y -= math.sin(math.radians(self.angle)) * self.speed
            if not self.is_forward:
                self.speed -= FRICTION

        # Wrap around screen
        if self.x < 0:
            self.x = WIDTH
        if self.x > WIDTH:
            self.x = 0
        if self.y < 0:
            self.y = HEIGHT
        if self.y > HEIGHT:
            self.y = 0

    def draw(self, canvas):
        global ship_img, ship_thrusted_img
        if self.is_forward:
            canvas.blit(rot_center(ship_thrusted_img, self.angle), (int(self.x), int(self.y)))
        else:
            canvas.blit(rot_center(ship_img, self.angle), (int(self.x), int(self.y)))

# Asteroid class
class Asteroid:
    def __init__(self, x=None, y=None, size=1):
        self.size = size
        self.x = x if x is not None else random.randint(0, WIDTH)
        self.y = y if y is not None else random.randint(0, HEIGHT)
        self.angle = random.randint(0, 365)
        self.speed = ASTEROID_SPEED + (level - 1) * 0.5

    def update(self):
        self.x += math.cos(math.radians(self.angle)) * self.speed
        self.y -= math.sin(math.radians(self.angle)) * self.speed

        # Wrap around screen
        if self.x < 0:
            self.x = WIDTH
        if self.x > WIDTH:
            self.x = 0
        if self.y < 0:
            self.y = HEIGHT
        if self.y > HEIGHT:
            self.y = 0

    def draw(self, canvas):
        scaled_asteroid = pygame.transform.scale(asteroid, (int(50 * self.size), int(50 * self.size)))
        canvas.blit(rot_center(scaled_asteroid, self.angle), (self.x, self.y))

# Bullet class
class Bullet:
    def __init__(self, x, y, angle):
        self.x = x
        self.y = y
        self.angle = angle
        self.speed = BULLET_SPEED

    def update(self):
        self.x += math.cos(math.radians(self.angle)) * self.speed
        self.y -= math.sin(math.radians(self.angle)) * self.speed

    def draw(self, canvas):
        canvas.blit(shot, (self.x, self.y))

# Game objects
ship = Ship()
asteroids = []
bullets = []

# Initialize asteroids
for i in range(NUM_ASTEROIDS):
    asteroids.append(Asteroid())


# set variables
ship_x = WIDTH/2 - 50
ship_y = HEIGHT/2 - 50
ship_angle = 0
ship_is_rotating = False
ship_is_forward = False
ship_direction = 0
ship_speed = 0

asteroid_x = [0,0,0,0,0] #random.randint(0,WIDTH)
asteroid_y = [0,0,0,0,0] #random.randint(0,HEIGHT)
asteroid_angle = []
asteroid_speed = 2
no_asteroids = 5

bullet_x = []
bullet_y = []
bullet_angle = []
no_bullets = 0

score = 0
game_over = False

for i in range(0,no_asteroids):
    asteroid_x.append( random.randint(0,WIDTH) )
    asteroid_y.append( random.randint(0,HEIGHT) )
    asteroid_angle.append( random.randint(0,365) )

def rot_center(image, angle):
    """
    Rotate a Surface, maintaining position.
    """
    if hasattr(image, 'get_rect'):
        orig_rect = image.get_rect()
        rot_image = pygame.transform.rotate(image, angle)
        rot_rect = orig_rect.copy()
        rot_rect.center = rot_image.get_rect().center
        rot_image = rot_image.subsurface(rot_rect).copy()
        return rot_image
    else:
        return image

def draw(canvas):
    """
    Draw the game elements on the canvas.
    """
    global time, score, level, lives, high_score
    canvas.fill(BLACK)
    canvas.blit(bg, (0, 0))
    canvas.blit(debris, (time * 0.3, 0))
    canvas.blit(debris, (time * 0.3 - WIDTH, 0))
    time += 1

    # Draw bullets
    for bullet in bullets:
        bullet.draw(canvas)

    # Draw asteroids
    for asteroid in asteroids:
        asteroid.draw(canvas)

    # Draw ship
    ship.draw(canvas)

    # Draw UI
    myfont1 = pygame.font.SysFont("Comic Sans MS", 30)
    label1 = myfont1.render(f"Score: {score}", 1, (255, 255, 0))
    canvas.blit(label1, (50, 20))
    label2 = myfont1.render(f"Level: {level}", 1, (255, 255, 0))
    canvas.blit(label2, (50, 60))
    label3 = myfont1.render(f"Lives: {lives}", 1, (255, 255, 0))
    canvas.blit(label3, (50, 100))
    label4 = myfont1.render(f"High Score: {high_score}", 1, (255, 255, 0))
    canvas.blit(label4, (50, 140))

    # Draw game over message
    if game_over:
        myfont2 = pygame.font.SysFont("Comic Sans MS", 80)
        label2 = myfont2.render("GAME OVER", 1, (255, 255, 255))
        canvas.blit(label2, (WIDTH / 2 - 150, HEIGHT / 2 - 40))
        myfont3 = pygame.font.SysFont("Comic Sans MS", 40)
        label3 = myfont3.render("Press R to restart", 1, (255, 255, 255))
        canvas.blit(label3, (WIDTH / 2 - 100, HEIGHT / 2 + 50))

    # Draw pause message
    if paused:
        myfont2 = pygame.font.SysFont("Comic Sans MS", 80)
        label2 = myfont2.render("PAUSED", 1, (255, 255, 255))
        canvas.blit(label2, (WIDTH / 2 - 100, HEIGHT / 2 - 40))

def handle_input():
    """
    Handle user input events and update ship state.
    """
    global paused, game_over, lives, score, level

    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
            sys.exit()
        elif event.type == KEYDOWN:
            if event.key == K_RIGHT:
                ship.is_rotating = True
                ship.direction = 0
            elif event.key == K_LEFT:
                ship.is_rotating = True
                ship.direction = 1
            elif event.key == K_UP:
                ship.is_forward = True
                ship.speed = SHIP_SPEED
                if thruster_sound:
                    thruster_sound.play()
            elif event.key == K_SPACE:
                bullets.append(Bullet(ship.x + 50, ship.y + 50, ship.angle))
                if missile_sound:
                    missile_sound.play()
            elif event.key == K_p:
                paused = not paused
            elif event.key == K_r and game_over:
                reset_game()
        elif event.type == KEYUP:
            if event.key in (K_LEFT, K_RIGHT):
                ship.is_rotating = False
            elif event.key == K_UP:
                ship.is_forward = False
                if thruster_sound:
                    thruster_sound.stop()

def reset_game():
    """
    Reset the game state for a new game.
    """
    global score, level, lives, game_over, asteroids, bullets
    score = 0
    level = 1
    lives = 3
    game_over = False
    asteroids = []
    bullets = []
    for i in range(NUM_ASTEROIDS):
        asteroids.append(Asteroid())
    ship.x = WIDTH / 2 - 50
    ship.y = HEIGHT / 2 - 50
    ship.angle = 0
    ship.speed = 0

def update_screen():
    """
    Update the display and control frame rate.
    """
    pygame.display.update()
    fps.tick(60)

def isCollision(enemyX, enemyY, bulletX, bulletY, dist):
    """
    Check if two objects are colliding based on distance.
    """
    distance = math.sqrt((enemyX - bulletX) ** 2 + (enemyY - bulletY) ** 2)
    return distance < dist

def game_logic():
    """
    Update game logic: move bullets, asteroids, check collisions.
    """
    global score, level, lives, game_over, high_score

    if paused:
        return

    # Update ship
    ship.update()

    # Update bullets
    for bullet in bullets[:]:
        bullet.update()
        if bullet.x < 0 or bullet.x > WIDTH or bullet.y < 0 or bullet.y > HEIGHT:
            bullets.remove(bullet)

    # Update asteroids
    for asteroid in asteroids[:]:
        asteroid.update()

        # Check collision with ship
        if isCollision(ship.x, ship.y, asteroid.x, asteroid.y, 27):
            lives -= 1
            if lives <= 0:
                game_over = True
                if score > high_score:
                    high_score = score
                    save_high_score(high_score)
            else:
                ship.x = WIDTH / 2 - 50
                ship.y = HEIGHT / 2 - 50
                ship.angle = 0
                ship.speed = 0

    # Check bullet-asteroid collisions
    for bullet in bullets[:]:
        for asteroid in asteroids[:]:
            if isCollision(bullet.x, bullet.y, asteroid.x, asteroid.y, 50):
                bullets.remove(bullet)
                asteroids.remove(asteroid)
                if explosion_sound:
                    explosion_sound.play()
                score += 10 * asteroid.size
                break

    # Level progression
    if len(asteroids) == 0:
        level += 1
        if level > MAX_LEVEL:
            level = MAX_LEVEL
        for i in range(NUM_ASTEROIDS + level - 1):
            asteroids.append(Asteroid())


# asteroids game loop
while True:
    draw(window)
    handle_input()
    if not game_over:
        game_logic()
    update_screen()