Как в игре Osmos сделан поток частиц у главного шара, которым ты движешь?

public class Point {
    private double x;
    private double y;
 
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
 
    public double getX() {
        return x;
    }
 
    public void setX(double x) {
        this.x = x;
    }
 
    public double getY() {
        return y;
    }
 
    public void setY(double y) {
        this.y = y;
    }
 
 
 
}

import java.awt.*;
import java.util.Random;
 
public class Meteor {
    private static double MAX_RADIUS = 10;                 // 250 метров radius from center
    private static double BASE_SIZE = 250;                 // 250 метров radius from center
    private static double MIN_RADIUS = BASE_SIZE / 100;    // 0.005 radius from center
    private static double MAX_SIZE = BASE_SIZE / 25;      // used as mass
    private static double MIN_SIZE = BASE_SIZE / 100;     // used as mass
    private static double MAX_SPEED = BASE_SIZE / 100;
    private static double MIN_SPEED = BASE_SIZE / 1000;
    private static int MAX_INERTION = 25;  // скорость падает на 100 тиков
    private static Color[] colors = new Color[]{
            Color.BLACK, Color.GREEN, Color.GRAY, Color.BLUE, Color.CYAN, Color.MAGENTA,
            Color.ORANGE, Color.RED, Color.YELLOW, Color.PINK
    };
 
    private static Random rnd = new Random();
 
    private int inertion;  // speed inertion counter
    private Point speed;
    private Point delta;
    private double mass;    // radius used as mass
    private Point point;
    private double radius;  // radius of object
    private Color color;
    private boolean isCollision;
 
 
    public Meteor(Point point) {   // center point around
        isCollision = false;
        radius = getRandom(MIN_SIZE, MAX_SIZE);  // radius of object
        mass = radius;
        this.point = new Point(getRandom(MIN_RADIUS, MAX_RADIUS, rnd.nextBoolean()) + point.getX(),
                getRandom(MIN_RADIUS, MAX_RADIUS, rnd.nextBoolean()) + point.getY());
        speed = new Point(getRandom(MIN_SPEED, MAX_SPEED, rnd.nextBoolean()),
                getRandom(MIN_SPEED, MAX_SPEED, rnd.nextBoolean()));
        delta = new Point(speed.getX() / MAX_INERTION, speed.getY() / MAX_INERTION);
        color = colors[rnd.nextInt(colors.length)];
        inertion = MAX_INERTION;
    }
 
    public Color getColor() {
        return color;
    }
 
    public Meteor(Point point, Point speed) {   // center point around
        isCollision = false;
        radius = getRandom(MIN_SIZE, MAX_SIZE);  // radius of object
        mass = radius;
        this.point = new Point(getRandom(MIN_RADIUS, MAX_RADIUS, rnd.nextBoolean()) + point.getX(),
                getRandom(MIN_RADIUS, MAX_RADIUS, rnd.nextBoolean()) + point.getY());
 
        setSpeed(speed);
        color = colors[rnd.nextInt(colors.length)];
 
    }
 
    private double getRandom(double min, double max, boolean dir) {
        int sign = dir ? 1 : -1;
        return (sign) * (rnd.nextDouble() * (max - min) + min);  // range
    }
 
    private double getRandom(double min, double max) {
        return rnd.nextDouble() * (max - min) + min;  // range
    }
 
 
    /**
     * Проверяет есть ли наложение по трем измерениям
     * данного метеорита с other
     *
     * @param other другой метеорит
     * @return true если по трем измерениям есть наложение, значит есть столкновение
     */
    public boolean collisionCheck(Meteor other) {
 
        if (Math.abs(point.getX() - other.point.getX()) < radius + other.radius &&
                Math.abs(point.getY() - other.point.getY()) < radius + other.radius) {
            return true;            // collision detected по всем трем измерениям идет наложение
        }
        return false;
    }
 
    private int counter = 0;
 
    private void updateSpeed(Meteor other) {         // if collision detected
        // не реализовано
    }
 
    public void update() {
        point.setX(point.getX() + speed.getX());
        point.setY(point.getY() + speed.getY());
 
        if (inertion > 0) {
            inertion--;
            if (Math.abs(speed.getX()) > Math.abs(delta.getX())) {
                speed.setX(speed.getX() - delta.getX());
            } else {
                speed.setX(0);
            }
            if (Math.abs(speed.getY()) > Math.abs(delta.getY())) {
                speed.setY(speed.getY() - delta.getY());
            } else {
                speed.setY(0);
            }
        }
    }
 
 
    /**
     * Проверяет есть ли столкновение метеорита с other
     * если есть столкновение изменить скорости метеоритов
     * для изменения скоростей берется в расчет масса метеорита и скорость
     *
     * @param other другой метеорит
     */
    public boolean collision(Meteor other) {
        if (collisionCheck(other)) {  // столкновения есть
            updateSpeed(other);       // обновить скорости
            isCollision = true;
        }
        return isCollision;
    }
 
    public Point getSpeed() {
        return speed;
    }
 
    public Point getPoint() {
        return point;
    }
 
    public double getRadius() {
        return radius;
    }
 
    public void setSpeed(Point speed) {
        this.speed = speed;
        delta = new Point(speed.getX() / MAX_INERTION, speed.getY() / MAX_INERTION);
        inertion = MAX_INERTION;
    }
 
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("[ pos: %7.3f,%7.3f ", point.getX(), point.getY()));
        sb.append(String.format("  v:%7.3f,%7.3f ", speed.getX(), speed.getY()));
        sb.append(String.format(" r:%7.4f m:%7.4f ]", radius, mass));
        if (isCollision) {
            sb.append("*");
            isCollision = false;
        }
 
        return sb.toString();
    }
}

import edu.princeton.cs.algs4.StdDraw;
 
import java.awt.*;
import java.util.Random;
 
public class MeteorFlow {
    private final Meteor[] flow;
    private final int size;
    private static int count;
    private static Random rnd = new Random();
 
 
    public MeteorFlow(int size, Point point) {   // meteors around point
        this.flow = new Meteor[size];
        this.size = size;
 
        for (int i = 0; i < size; i++) {
            flow[i] = new Meteor(point);
        }
        count = 0; // timer
    }
 
    public MeteorFlow(int size, Point point, Point speed) {   // meteors around point
        this.flow = new Meteor[size];
        this.size = size;
 
        for (int i = 0; i < size; i++) {
            flow[i] = new Meteor(point, speed);
        }
        count = 0; // timer
    }
 
    public void update() {
        for (int i = 0; i < size; i++) {  // смена позиции каждого метеорита
            flow[i].update();
        }
 
        for (int i = 0; i < size; i++) {        // проверка коллизий
            for (int j = 0; j < size; j++) {
                if (i == j) {
                    continue;
                }
                flow[i].collision(flow[j]);
            }
        }
        count++;
    }
 
    public Meteor get(int index) {
        if (flow == null || index < 0 || index >= flow.length) {
            throw new IllegalArgumentException();
        }
        return flow[index];
    }
 
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Meteors flow state: " + count + "\n");
        for (int i = 0; i < size; i++) {
            sb.append(flow[i].toString() + "\n");
        }
 
        return sb.toString();
    }
 
 
    private static MeteorFlow genFlow(Point center, Point mouse, double size, int n) {
 
        double distance = Math.sqrt(Math.pow(center.getX() - mouse.getX(), 2) +
                Math.pow(center.getY() - mouse.getY(), 2));
 
        double coeff = size / (distance * 10);  // coeff
        Point point = new Point(center.getX() + coeff * (mouse.getX() - center.getX()),
                center.getY() + coeff * (mouse.getY() - center.getY()));
 
        MeteorFlow flow = new MeteorFlow(n,
                new Point(point.getX(), point.getY()),
                new Point(0, 0));               // поток на 10 метеоритов вокруг 0.5,0.5
        return flow;
    }
 
    private static void setFlow(MeteorFlow flow, Point mouse) {
        for (int i = 0; i < flow.flow.length; i++) {
            Meteor meteor = flow.flow[i];
            Point point = meteor.getPoint();
            double dx = mouse.getX() - point.getX();
            double dy = mouse.getY() - point.getY();
            double speedX = rnd.nextDouble() * dx / 20 + dx / 100;  // speed = 0.01..0.05 od distance
            double speedY = rnd.nextDouble() * dy / 20 + dy / 100;  // speed = 0.01..0.05 od distance
            meteor.setSpeed(new Point(speedX, speedY));
        }
    }
 
 
    public static void main(String[] args) {
 
        int n = 10;
        double size = 1000; // size of canvas  1000 point
        Meteor circle = new Meteor(new Point(size * 0.5, size * 0.5), new Point(0,0));
 
        MeteorFlow flow = genFlow(circle.getPoint(), circle.getPoint(), size, n);
 
        StdDraw.enableDoubleBuffering();
        StdDraw.clear();
        StdDraw.setPenColor(StdDraw.BLACK);
        StdDraw.setCanvasSize(800, 800);
        StdDraw.setXscale(-0.05 * size, 1.05 * size);
        StdDraw.setYscale(-0.05 * size, 1.05 * size);   // leave a border to write te
        StdDraw.setPenColor(StdDraw.BLACK);
        StdDraw.setPenRadius(0.001);
 
 
        while (true) {
            if (StdDraw.mousePressed()) {
                Point mouse = new Point(StdDraw.mouseX(), StdDraw.mouseY());
                flow = genFlow(circle.getPoint(), mouse, size, n);
                setFlow(flow, mouse);
 
                double dx = mouse.getX() - circle.getPoint().getX();
                double dy = mouse.getY() - circle.getPoint().getY();
                circle.setSpeed( new Point(-dx/100,-dy/100));
            }
 
 
            StdDraw.setPenColor(Color.BLACK);
            StdDraw.circle(circle.getPoint().getX(),circle.getPoint().getY(),size/10);
 
            for (int j = 0; j < flow.size; j++) {
                Meteor meteor = flow.flow[j];
                Point point = meteor.getPoint();
                StdDraw.setPenColor(meteor.getColor());
                StdDraw.filledCircle(point.getX(), point.getY(), meteor.getRadius());
            }
 
 
            StdDraw.show();
            StdDraw.pause(100);
            StdDraw.clear();
            flow.update();    // update all meteors
            circle.update();  // update central circle
        }
 
    }
}