BallGame.java

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.Random;
import javax.swing.*;

public class DodgeGame extends JPanel implements ActionListener {

    // Game Settings
    private final int WIDTH = 600;
    private final int HEIGHT = 600;
    private final int PLAYER_SIZE = 30;
    private final int OBSTACLE_SIZE = 40;
    
    // Player State
    private int playerX = 285;
    private int playerY = 500;
    private int playerSpeed = 8;
    
    // Movement Flags (for smooth control)
    private boolean up = false;
    private boolean down = false;
    private boolean left = false;
    private boolean right = false;

    // Game Logic
    private Timer timer;
    private ArrayList<Rectangle> obstacles; // List to hold many obstacles
    private Random random;
    private int score = 0;
    private int obstacleSpeed = 5; // Initial speed of obstacles
    private boolean isGameOver = false;

    public DodgeGame() {
        this.setPreferredSize(new Dimension(WIDTH, HEIGHT));
        this.setBackground(Color.BLACK);
        this.setFocusable(true);

        obstacles = new ArrayList<>();
        random = new Random();

        // Timer runs every 20ms (approx 50 frames per second)
        timer = new Timer(20, this);
        timer.start();

        // Key Listener for Smooth Movement
        addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                int key = e.getKeyCode();
                if (key == KeyEvent.VK_LEFT) left = true;
                if (key == KeyEvent.VK_RIGHT) right = true;
                if (key == KeyEvent.VK_UP) up = true;
                if (key == KeyEvent.VK_DOWN) down = true;
                
                // Restart game if Enter is pressed after game over
                if (isGameOver && key == KeyEvent.VK_ENTER) {
                    resetGame();
                }
            }

            @Override
            public void keyReleased(KeyEvent e) {
                int key = e.getKeyCode();
                if (key == KeyEvent.VK_LEFT) left = false;
                if (key == KeyEvent.VK_RIGHT) right = false;
                if (key == KeyEvent.VK_UP) up = false;
                if (key == KeyEvent.VK_DOWN) down = false;
            }
        });
    }

    // Ensures the panel captures key inputs immediately
    @Override
    public void addNotify() {
        super.addNotify();
        requestFocusInWindow();
    }

    private void resetGame() {
        playerX = 285;
        playerY = 500;
        obstacles.clear();
        score = 0;
        obstacleSpeed = 5;
        isGameOver = false;
        timer.start();
        repaint();
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g;
        
        // Anti-aliasing for smoother shapes
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

        if (isGameOver) {
            drawGameOver(g);
        } else {
            // Draw Player (Green Square)
            g.setColor(Color.GREEN);
            g.fillRect(playerX, playerY, PLAYER_SIZE, PLAYER_SIZE);
            // Draw Player Border
            g.setColor(Color.WHITE);
            g.drawRect(playerX, playerY, PLAYER_SIZE, PLAYER_SIZE);

            // Draw Obstacles (Red Squares)
            g.setColor(Color.RED);
            for (Rectangle r : obstacles) {
                g.fillRect(r.x, r.y, r.width, r.height);
            }

            // Draw Score
            g.setColor(Color.WHITE);
            g.setFont(new Font("Arial", Font.BOLD, 18));
            g.drawString("Score: " + score, 10, 25);
            g.drawString("Speed: " + obstacleSpeed, 10, 45);
        }
    }

    private void drawGameOver(Graphics g) {
        String msg = "Game Over!";
        String scoreMsg = "Final Score: " + score;
        String restartMsg = "Press ENTER to Restart";
        
        g.setColor(Color.WHITE);
        g.setFont(new Font("Arial", Font.BOLD, 40));
        
        // Center the text
        FontMetrics fm = g.getFontMetrics();
        g.drawString(msg, (WIDTH - fm.stringWidth(msg)) / 2, HEIGHT / 2 - 50);
        
        g.setFont(new Font("Arial", Font.BOLD, 25));
        fm = g.getFontMetrics();
        g.drawString(scoreMsg, (WIDTH - fm.stringWidth(scoreMsg)) / 2, HEIGHT / 2);
        
        g.setFont(new Font("Arial", Font.PLAIN, 18));
        fm = g.getFontMetrics();
        g.drawString(restartMsg, (WIDTH - fm.stringWidth(restartMsg)) / 2, HEIGHT / 2 + 50);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (isGameOver) return;

        // 1. Move Player
        if (left) playerX -= playerSpeed;
        if (right) playerX += playerSpeed;
        if (up) playerY -= playerSpeed;
        if (down) playerY += playerSpeed;

        // Keep player inside screen bounds
        if (playerX < 0) playerX = 0;
        if (playerX > WIDTH - PLAYER_SIZE) playerX = WIDTH - PLAYER_SIZE;
        if (playerY < 0) playerY = 0;
        if (playerY > HEIGHT - PLAYER_SIZE) playerY = HEIGHT - PLAYER_SIZE;

        // 2. Add New Obstacles
        // Chance to spawn obstacle increases slightly as game goes on, but capped
        if (random.nextInt(100) < 5) { 
            int randX = random.nextInt(WIDTH - OBSTACLE_SIZE);
            obstacles.add(new Rectangle(randX, -OBSTACLE_SIZE, OBSTACLE_SIZE, OBSTACLE_SIZE));
        }

        // 3. Move Obstacles & Check Collisions
        Rectangle playerRect = new Rectangle(playerX, playerY, PLAYER_SIZE, PLAYER_SIZE);
        
        // We use a loop to manage obstacles
        for (int i = 0; i < obstacles.size(); i++) {
            Rectangle obs = obstacles.get(i);
            obs.y += obstacleSpeed; // Move obstacle down

            // Check Collision
            if (playerRect.intersects(obs)) {
                isGameOver = true;
                timer.stop();
            }

            // Remove obstacle if it goes off screen
            if (obs.y > HEIGHT) {
                obstacles.remove(i);
                i--; // adjust index since we removed an item
                score++;
                
                // Increase difficulty every 10 points
                if (score % 10 == 0) {
                    obstacleSpeed++;
                }
            }
        }

        repaint(); // Update screen
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("4-Way Dodge Survival");
        DodgeGame game = new DodgeGame();
        
        frame.add(game);
        frame.pack(); // Adjusts window to fit the panel size
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLocationRelativeTo(null);
        frame.setResizable(false);
        frame.setVisible(true);
    }
}