Игра Osmos с увеличением гравитации от массы игрока

import javax.swing.*;
 
public class OsmosGame {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Osmos");
        GamePanel panel = new GamePanel();
        frame.setContentPane(panel);
        frame.setSize(1600, 1000);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}
 
 
 
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
 
public class GamePanel extends JPanel implements ActionListener, MouseListener {
 
    private boolean initialized = false;
    private final Timer timer;
    private List<Particle> particles = new CopyOnWriteArrayList<>();
 
    private final Player player;
 
    public GamePanel() {
        this.setBackground(Color.BLACK);
        this.setFocusable(true);
        this.addMouseListener(this);
 
        player = new Player(400, 300, 30);
        particles = new ArrayList<>();
 
        timer = new Timer(16, this); // ~60 FPS
        timer.start();
        this.setFocusable(true);
        this.requestFocusInWindow(); // заставляем получить фокус
        SwingUtilities.invokeLater(() -> requestFocusInWindow());
 
    }
 
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
 
        if (!initialized && getWidth() > 0 && getHeight() > 0) {
            for (int i = 0; i < 20; i++) {
                particles.add(Particle.randomParticle(getWidth(), getHeight()));
            }
            initialized = true;
        }
 
        player.draw(g);
        for (Particle p : particles) {
            p.draw(g);
        }
    }
 
    @Override
    public void actionPerformed(ActionEvent e) {
        //    double gravityStrength = 0.015; // сила гравитации, поэкспериментируй
        double gravityStrength = 0.000001 * player.getMass(); // масштабируем силу гравитации от массы
        //  player.move();
        player.moveWithinBounds(getWidth(), getHeight());
 
        for (Particle p : particles) {
            // p.move();
            // Притягиваются к игроку, если это не выброшенная масса
            if (!(p instanceof EjectedParticle)) {
                p.applyGravityFrom(player, gravityStrength);
            }
            p.moveWithinBounds(getWidth(), getHeight());
        }
// Удаляем исчезнувшие выбросы массы
        particles.removeIf(p -> (p instanceof EjectedParticle) && ((EjectedParticle) p).isDead());
 
        // Проверка столкновений
        Iterator<Particle> iter = particles.iterator();
        while (iter.hasNext()) {
            Particle p = iter.next();
            if (player.checkCollision(p)) {
                if (player.radius >= p.radius) {
                    player.absorb(p);
                    iter.remove();
                } else {
                    // Игрок проиграл
                    timer.stop();
                    JOptionPane.showMessageDialog(this, "Game Over!");
                    System.exit(0);
                }
            }
        }
 
        repaint();
        // Проверка, остались ли обычные частицы (кроме выброшенной массы)
        boolean noRealParticles = particles.stream()
                .noneMatch(p -> !(p instanceof EjectedParticle));
 
        if (noRealParticles) {
            // Сброс игрока
            player.radius = 30;
            player.vx = 0;
            player.vy = 0;
 
            // Очистка частиц
            particles.clear();
 
            // Генерация новых частиц
            for (int i = 0; i < 30; i++) {
                particles.add(Particle.randomParticle(getWidth(), getHeight(), player.x, player.y, player.radius * 2));
            }
 
            // Можно показать сообщение
            JOptionPane.showMessageDialog(this, "Новый раунд!");
        }
 
    }
 
    @Override
    public void mouseClicked(MouseEvent e) {
        double dx = player.x - e.getX();
        double dy = player.y - e.getY();
        double len = Math.sqrt(dx * dx + dy * dy);
        player.vx += dx / len * 1.5;
        player.vy += dy / len * 1.5;
        player.radius -= 1.0; // потери массы
        if (len > 1e-6 && player.radius > 5) {
            dx /= len;
            dy /= len;
 
            double ejectSpeed = 3;
            double impulse = 1.5;
            double ejectRadius = 4;
 
            // Реактивный импульс
            player.vx += dx * impulse;
            player.vy += dy * impulse;
            player.radius -= 0.5;
 
            // Выброшенная частица
            EjectedParticle ep = new EjectedParticle(
                    player.x - dx * (player.radius + ejectRadius), // позади
                    player.y - dy * (player.radius + ejectRadius),
                    ejectRadius,
                    -dx * ejectSpeed,
                    -dy * ejectSpeed
            );
            particles.add(ep);
        }
    }
 
    public void mousePressed(MouseEvent e) {
    }
 
    public void mouseReleased(MouseEvent e) {
    }
 
    public void mouseEntered(MouseEvent e) {
    }
 
    public void mouseExited(MouseEvent e) {
    }
}
 
 
 
import java.awt.*;
import java.util.Random;
 
public class Particle {
 
    public static Particle randomParticle(int width, int height, double avoidX, double avoidY, double minDistance) {
        Random r = new Random();
        double x, y;
        do {
            x = r.nextInt(Math.max(1, width));
            y = r.nextInt(Math.max(1, height));
        } while (Math.hypot(x - avoidX, y - avoidY) < minDistance); // избегаем слишком близкого появления
 
        double radius = 5 + r.nextDouble() * 20;
        return new Particle(x, y, radius, Color.GRAY);
    }
 
    protected double x, y, vx, vy, radius;
    protected Color color;
 
    public Particle(double x, double y, double radius, Color color) {
        this.x = x;
        this.y = y;
        this.radius = radius;
        this.color = color;
        Random r = new Random();
        this.vx = r.nextDouble() * 2 - 1;
        this.vy = r.nextDouble() * 2 - 1;
    }
 
    public static Particle randomParticle(int width, int height) {
        Random r = new Random();
        double x = r.nextInt(width);
        double y = r.nextInt(height);
        double radius = 5 + r.nextDouble() * 20;
        return new Particle(x, y, radius, Color.GRAY);
    }
 
    public void move() {
        x += vx;
        y += vy;
    }
 
    public void draw(Graphics g) {
        Graphics2D g2d = (Graphics2D) g.create();
        //   g2d.setColor(color);
        //   g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, color.getAlpha() / 255f));
        //  g2d.fillOval((int) (x - radius), (int) (y - radius), (int) (2 * radius), (int) (2 * radius));
        //  g2d.dispose();
        int size = (int) (2 * radius);
        int drawX = (int) (x - radius);
        int drawY = (int) (y - radius);
 
        // Создаём градиент: светлый в центре, тёмный по краям
        Color centerColor = new Color(color.getRed(), color.getGreen(), color.getBlue(), 200);
        Color edgeColor = new Color(0, 0, 0, 100);
        Color color = new Color(100, 200, 255, 180); // с прозрачностью
 
        RadialGradientPaint gradient = new RadialGradientPaint(
                new Point(drawX + size / 2, drawY + size / 2),
                (float) radius,
                new float[]{0f, 1f},
                new Color[]{centerColor, edgeColor}
        );
        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, color.getAlpha() / 255f));
 
// Мягкая оболочка ****** можно убрать
        g2d.setColor(new Color(color.getRed(), color.getGreen(), color.getBlue(), 60));
        for (int i = 0; i < 3; i++) {
            int glowSize = size + i * 6;
            g2d.fillOval(drawX - i * 3, drawY - i * 3, glowSize, glowSize);
        }
        //****
 
        // Выбрасываемые частицы пульсирующие *** можно убрать
        if (this instanceof EjectedParticle) {
            radius += Math.sin(System.nanoTime() * 1e-9 * 5) * 0.3;
        } // *************
 
        g2d.setPaint(gradient);
        g2d.fillOval(drawX, drawY, size, size);
        g2d.dispose();
    }
 
    public boolean intersects(Particle other) {
        double dx = this.x - other.x;
        double dy = this.y - other.y;
        double dist = Math.sqrt(dx * dx + dy * dy);
        return dist < (this.radius + other.radius);
    }
 
    public void applyGravityFrom(Particle other, double G) {
        if (this == other) {
            return;
        }
 
        double dx = other.x - this.x;
        double dy = other.y - this.y;
        double distSq = dx * dx + dy * dy;
 
        if (distSq < 1) {
            return;
        }
 
        double force = G * other.getMass() / distSq;
        double dist = Math.sqrt(distSq);
        double ax = force * dx / dist;
        double ay = force * dy / dist;
 
        this.vx += ax;
        this.vy += ay;
    }
 
    public void moveWithinBounds(int width, int height) {
        x += vx;
        y += vy;
 
        double r = radius;
 
        if (x - r < 0) {
            x = r;
            vx = -vx;
        }
        if (x + r > width) {
            x = width - r;
            vx = -vx;
        }
        if (y - r < 0) {
            y = r;
            vy = -vy;
        }
        if (y + r > height) {
            y = height - r;
            vy = -vy;
        }
    }
 
    public double getMass() {
        return Math.PI * radius * radius;
    }
 
}
 
 
 
import java.awt.*;
 
public class Player extends Particle {
 
    public Player(double x, double y, double radius) {
        super(x, y, radius, Color.CYAN);
        this.vx = 0;
        this.vy = 0;
    }
 
    public void absorb(Particle other) {
        // Увеличиваем радиус в зависимости от площади
        double areaSelf = Math.PI * radius * radius;
        double areaOther = Math.PI * other.radius * other.radius;
        radius = Math.sqrt((areaSelf + areaOther) / Math.PI);
    }
 
    public void moveWithinBounds(int width, int height) {
        x += vx;
        y += vy;
 
        double r = radius;
 
        // Отражение от краёв
        if (x - r < 0) {
            x = r;
            vx = -vx;
        }
        if (x + r > width) {
            x = width - r;
            vx = -vx;
        }
        if (y - r < 0) {
            y = r;
            vy = -vy;
        }
        if (y + r > height) {
            y = height - r;
            vy = -vy;
        }
 
        // Замедление
        vx *= 0.99;
        vy *= 0.99;
    }
 
    public boolean checkCollision(Particle p) {
        return this.intersects(p);
    }
}
 
 
 
import java.awt.*;
 
public class EjectedParticle extends Particle {
 
    private int life = 255; // начальная прозрачность
 
    public EjectedParticle(double x, double y, double radius, double vx, double vy) {
        super(x, y, radius, new Color(100, 200, 255, 255));
        this.vx = vx;
        this.vy = vy;
    }
 
    @Override
    public void moveWithinBounds(int width, int height) {
        super.moveWithinBounds(width, height);
 
        // Плавное исчезновение
        life -= 2;
        if (life < 0) {
            life = 0;
        }
        color = new Color(100, 200, 255, life);
    }
 
    public boolean isDead() {
        return life <= 0 || radius < 1;
    }
}

@Override
    public void mouseClicked(MouseEvent e) {
        double dx = player.x - e.getX();
        double dy = player.y - e.getY();
        double len = Math.sqrt(dx * dx + dy * dy);
        player.vx += dx / len * 1.5;
        player.vy += dy / len * 1.5;
        player.radius -= 1.0; // потери массы
        if (len > 1e-6 && player.radius > 5) {
            dx /= len;
            dy /= len;
 
            double ejectSpeed = 3;
            double impulse = 1.5;
            double ejectRadius = 4;
 
            // Реактивный импульс
            player.vx += dx * impulse;
            player.vy += dy * impulse;
            player.radius -= 0.5;
 
            // Выброшенная частица
            EjectedParticle ep = new EjectedParticle(
                    player.x - dx * (player.radius + ejectRadius), // позади
                    player.y - dy * (player.radius + ejectRadius),
                    ejectRadius,
                    -dx * ejectSpeed,
                    -dy * ejectSpeed
            );
            particles.add(ep);
            // Добавить метеориты при кликаньи на любую точку
            int meteorCount = 12; // число метеоритов
            double baseSpeed = 2.5;
 
            for (int i = 0; i < meteorCount; i++) {
                double angle = 2 * Math.PI * i / meteorCount;
                double vx = Math.cos(angle) * baseSpeed;
                double vy = Math.sin(angle) * baseSpeed;
 
                double radius = 5 + Math.random() * 5;
                Color color = new Color(200, 150 + (int) (Math.random() * 100), 100); // метеоритный оттенок
 
                Particle meteor = new Particle(e.getX(), e.getY(), radius, color);
                meteor.vx = vx;
                meteor.vy = vy;
 
                particles.add(meteor);
            }
 
        }
    }