diff --git a/game2 b/game2
index 9e728e8..80585b7 100644
--- a/game2
+++ b/game2
@@ -1,116 +1,180 @@
 import pygame
 import sys
-import random
+import os
 
 # Initialize Pygame
 pygame.init()
+pygame.mixer.init()
 
-# Set up the display
+# Constants
 WIDTH, HEIGHT = 800, 600
-screen = pygame.display.set_mode((WIDTH, HEIGHT))
+PADDLE_WIDTH, PADDLE_HEIGHT = 100, 10
+PADDLE_SPEED = 10
+BRICK_WIDTH, BRICK_HEIGHT = 80, 20
+BRICK_ROWS = 4
+BRICK_COLS = 10
+LINE_HEIGHT = 5
 
 # Colors
 WHITE = (255, 255, 255)
 BLACK = (0, 0, 0)
+RED = (255, 0, 0)
 
-# Load images
-cat_image = pygame.image.load("cat.png").convert_alpha()
-football_image = pygame.image.load("football.png").convert_alpha()
-heart_bar_image = pygame.image.load("heartbar.png").convert_alpha()
+# Sounds
+wall_sound = None
+block_sound = None
+death_sound = None
 
-# Constants
+# Check if sound files exist before loading
+if os.path.exists("wall.wav"):
+    wall_sound = pygame.mixer.Sound("wall.wav")
+if os.path.exists("block.wav"):
+    block_sound = pygame.mixer.Sound("block.wav")
+if os.path.exists("death.wav"):
+    death_sound = pygame.mixer.Sound("death.wav")
+
+# Create the game window
+screen = pygame.display.set_mode((WIDTH, HEIGHT))
+pygame.display.set_caption("Arkanoid")
+
+# Load cat image
+cat_original_image = pygame.image.load("cat.png").convert_alpha()
 CAT_WIDTH, CAT_HEIGHT = 50, 50
-FOOTBALL_WIDTH, FOOTBALL_HEIGHT = 30, 30
-HEART_WIDTH, HEART_HEIGHT = 30, 30
-PADDLE_WIDTH, PADDLE_HEIGHT = 100, 10
-PADDLE_COLOR = (255, 0, 0)
-BALL_RADIUS = 10
-LINE_HEIGHT = 5
-NUM_HEARTS = 9
+cat_image = pygame.transform.scale(cat_original_image, (CAT_WIDTH, CAT_HEIGHT))
 
-# Global variables
-score = 0
-lives = NUM_HEARTS
-falling_footballs = []
-falling_speed = 3
-clock = pygame.time.Clock()
+# Load heart bar image
+heart_bar_image = pygame.image.load("heartbar.png").convert_alpha()
+HEART_WIDTH, HEART_HEIGHT = 15, 15  # Adjust heart size here
+HEART_SPACING = 20  # Adjust spacing between hearts here
 
 # Create the paddle
 paddle = pygame.Rect((WIDTH - PADDLE_WIDTH) // 2, HEIGHT - PADDLE_HEIGHT - 20, PADDLE_WIDTH, PADDLE_HEIGHT)
 
-# Function to draw the paddle
-def draw_paddle():
-    pygame.draw.rect(screen, PADDLE_COLOR, paddle)
+# Create the ball (cat)
+cat_rect = cat_image.get_rect(center=(WIDTH // 2, HEIGHT // 2))
+cat_speed = [5, 5]  # Cat movement speed
 
-# Function to handle paddle movement
-def move_paddle(key):
-    if key == pygame.K_LEFT:
-        paddle.x -= 5
-    elif key == pygame.K_RIGHT:
-        paddle.x += 5
+# Create death line
+line = pygame.Rect(0, HEIGHT - LINE_HEIGHT, WIDTH, LINE_HEIGHT)
 
-# Function to draw the cat
-def draw_cat(x, y):
-    screen.blit(cat_image, (x, y))
+# Create bricks
+bricks = []
+for row in range(BRICK_ROWS):
+    for col in range(BRICK_COLS):
+        brick = pygame.Rect(col * (BRICK_WIDTH + 5), row * (BRICK_HEIGHT + 5), BRICK_WIDTH, BRICK_HEIGHT)
+        bricks.append(brick)
 
-# Function to draw the football
-def draw_football(x, y):
-    screen.blit(football_image, (x, y))
+# Scoring
+score = 0
+font = pygame.font.Font(None, 36)
 
-# Function to draw the hearts representing lives
-def draw_hearts():
-    for i in range(lives):
-        screen.blit(heart_bar_image, (WIDTH - (i + 1) * HEART_WIDTH, 0))
+# Lives
+lives = 9  # Start with 9 lives
 
-# Function to handle collisions between the paddle and falling footballs
-def check_collision():
-    global lives
-    for football in falling_footballs:
-        if paddle.colliderect(football):
-            falling_footballs.remove(football)
-            lives -= 1
+# Game Over flag and text
+game_over = False
+game_started = False
+game_over_text = font.render("Game Over", True, WHITE)
+game_over_rect = game_over_text.get_rect(center=(WIDTH // 2, HEIGHT // 2))
 
-# Function to create falling footballs
-def create_falling_footballs():
-    x = random.randint(0, WIDTH - FOOTBALL_WIDTH)
-    y = 0
-    falling_footballs.append(pygame.Rect(x, y, FOOTBALL_WIDTH, FOOTBALL_HEIGHT))
+# Flags for paddle movement
+move_left = False
+move_right = False
 
 # Main game loop
-running = True
-while running:
+while not game_over:
     for event in pygame.event.get():
         if event.type == pygame.QUIT:
-            running = False
+            pygame.quit()
+            sys.exit()
+        # Key pressed
         elif event.type == pygame.KEYDOWN:
-            move_paddle(event.key)
+            if event.key == pygame.K_LEFT:
+                move_left = True
+            elif event.key == pygame.K_RIGHT:
+                move_right = True
+        # Key released
+        elif event.type == pygame.KEYUP:
+            if event.key == pygame.K_LEFT:
+                move_left = False
+            elif event.key == pygame.K_RIGHT:
+                move_right = False
+
+    # Move the paddle based on flags
+    if move_left and paddle.left > 0:
+        paddle.x -= PADDLE_SPEED
+    if move_right and paddle.right < WIDTH:
+        paddle.x += PADDLE_SPEED
+
+    # Move the cat
+    cat_rect.x += cat_speed[0]
+    cat_rect.y += cat_speed[1]
+
+    # Check for collision with walls
+    if cat_rect.left <= 0 or cat_rect.right >= WIDTH:
+        cat_speed[0] = -cat_speed[0]
+        if wall_sound:
+            wall_sound.play()
+    if cat_rect.top <= 0 or cat_rect.colliderect(paddle):
+        cat_speed[1] = -cat_speed[1]
+        if wall_sound:
+            wall_sound.play()
+
+    # Check for collision with bricks
+    for brick in bricks[:]:
+        if cat_rect.colliderect(brick):
+            bricks.remove(brick)
+            score += 1
+            if block_sound:
+                block_sound.play()
+
+    # Check for loss of life
+    if cat_rect.bottom >= HEIGHT:
+        lives -= 1
+        if death_sound:
+            death_sound.play()
+        if lives <= 0:
+            game_over = True
+            break
+        else:
+            cat_rect.center = (WIDTH // 2, HEIGHT // 2)
 
     # Clear the screen
     screen.fill(BLACK)
 
-    # Draw game elements
-    draw_paddle()
-    draw_cat((WIDTH - CAT_WIDTH) // 2, HEIGHT - CAT_HEIGHT - 100)
-    draw_hearts()
+    # Draw paddle
+    pygame.draw.rect(screen, WHITE, paddle)
 
-    # Move and draw falling footballs
-    for football in falling_footballs:
-        football.y += falling_speed
-        draw_football(football.x, football.y)
+    # Draw bricks
+    for brick in bricks:
+        pygame.draw.rect(screen, WHITE, brick)
 
-    # Check for collisions between paddle and falling footballs
-    check_collision()
+    # Draw cat
+    screen.blit(cat_image, cat_rect)
 
-    # Create falling footballs at random intervals
-    if random.randint(0, 100) < 3:
-        create_falling_footballs()
+    # Draw heart bar representing lives
+    start_x = 10  # Adjust the starting x-coordinate to move the heart bar more to the left
+    for i in range(lives):
+        heart_image = pygame.transform.scale(heart_bar_image, (HEART_WIDTH, HEART_HEIGHT))
+        screen.blit(heart_image, (start_x + i * (HEART_WIDTH + HEART_SPACING), 10))
+
+    # Draw score
+    score_text = font.render(f"Score: {score}", True, (128, 0, 128))  # Purple color
+    screen.blit(score_text, (10, 50))
 
     # Update the display
     pygame.display.flip()
 
     # Cap the frame rate
-    clock.tick(60)
+    pygame.time.Clock().tick(60)
+
+# Display Game Over text
+screen.fill(BLACK)
+screen.blit(game_over_text, game_over_rect)
+pygame.display.flip()
+
+# Wait for a few seconds before quitting
+pygame.time.delay(1500)
 
-# Quit Pygame
 pygame.quit()
-sys.exit()
\ No newline at end of file
+sys.exit()