import java.awt.*;
import java.applet.*;
import java.awt.event.*;

public class Space extends Applet implements Runnable {
    static final double dt=0.05;
    Cluster cluster;
    boolean running;
    Image image;
    
    public void init() {
        setBackground(Color.white);
        addMouseListener(new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {
                start();
            }
        });
    }
    
    public synchronized void start() {
        cluster=new Cluster();
        if (!running) {
            running=true;
            new Thread(this,"Physics").start();
        }
    }
    
    public void stop() {
        running=false;
    }
    
    public void run() {
        while (running) {
            for (int i=0;i<10;i++)
                synchronized (this) {
                    cluster.step(0,dt/10);
                }
            repaint();
            try {
                Thread.sleep((long)(dt*1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public void update(Graphics g) {
        paint(g);
    }
    
    public synchronized void paint (Graphics g) {
        int width=getSize().width,height=getSize().height;
        if (image==null) image=createImage(width,height);
        Graphics og=image.getGraphics();
        og.clearRect(0,0,width,height);
        og.translate(width/2,height/2);
        for (int i=0;i<cluster.planet.length;i++) {
            Planet p=cluster.planet[i];
            double z=200/Math.max(p.z+200,0.01);
            double r=20/z;
            og.fillOval((int)(p.x/z-r),(int)(p.y/z-r),(int)(r*2),(int)(r*2));
        }
        og.dispose();
        g.drawImage(image,0,0,this);
    }
}

class Cluster extends RungeKutta {
    Planet[] planet=new Planet[3];
    Cluster() {
        for (int i=0;i<planet.length;i++) 
            planet[i]=new Planet(200,10);
        for (int i=0;i<planet.length;i++)
            for (int j=0;j<i;j++)
                planet[i].orbit(planet[j]);
        Planet g=new Planet();
        for (int i=0;i<planet.length;i++)
            g.add(planet[i]);
        g.multiply(-1./planet.length);
        for (int i=0;i<planet.length;i++)
            planet[i].add(g);
    }
    public void copy(RungeKutta q) {
        Cluster c=(Cluster)q;
        for (int i=0;i<planet.length;i++)
            planet[i].copy(c.planet[i]);
    }
    public void add(RungeKutta q) {
        Cluster c=(Cluster)q;
        for (int i=0;i<planet.length;i++)
            planet[i].add(c.planet[i]);
    }
    public void multiply(double c) {
        for (int i=0;i<planet.length;i++)
            planet[i].multiply(c);
    }
    public void differentiate(double t) {
        for (int i=0;i<planet.length;i++) {
            planet[i].back_u=planet[i].u;
            planet[i].back_v=planet[i].v;
            planet[i].back_w=planet[i].w;
            planet[i].u=0;
            planet[i].v=0;
            planet[i].w=0;
        }
        for (int i=0;i<planet.length;i++) 
            for (int j=0;j<planet.length;j++)
                if (i!=j)
                    planet[i].force(planet[j]);
        for (int i=0;i<planet.length;i++) {
            planet[i].x=planet[i].back_u;
            planet[i].y=planet[i].back_v;
            planet[i].z=planet[i].back_w;
        }
    }
}

class Planet {
    static final double G=1.0e6;
    double x,y,z;
    double u,v,w;
    double back_u,back_v,back_w;
    Planet() {}
    Planet(double R,double V) {
        x=(Math.random()-0.5)*R;
        y=(Math.random()-0.5)*R;
        z=(Math.random()-0.5)*R;
        u=(Math.random()-0.5)*V;
        v=(Math.random()-0.5)*V;
        w=(Math.random()-0.5)*V;
    }
    void copy(Planet p) {
        x=p.x;
        y=p.y;
        z=p.z;
        u=p.u;
        v=p.v;
        w=p.w;
    }
    void add(Planet p) {
        x+=p.x;
        y+=p.y;
        z+=p.z;
        u+=p.u;
        v+=p.v;
        w+=p.w;
    }
    void multiply(double c) {
        x*=c;
        y*=c;
        z*=c;
        u*=c;
        v*=c;
        w*=c;
    }
    void orbit(Planet p) {
        double dx=p.x-x;
        double dy=p.y-y;
        double dz=p.z-z;
        double dr=Math.sqrt(dx*dx+dy*dy+dz*dz);
        double V=Math.sqrt(G/dr);
        double du=dy*w-dz*v;
        double dv=dz*u-dx*w;
        double dw=dx*v-dy*u;
        double da=Math.sqrt(du*du+dv*dv+dw*dw);
        u+=du/da*V;
        v+=dv/da*V;
        w+=dw/da*V;
    }
    void force(Planet p) {
        double dx=p.x-x;
        double dy=p.y-y;
        double dz=p.z-z;
        double rr=dx*dx+dy*dy+dz*dz;
        double f_r=G*Math.pow(rr,-1.5);
        u+=dx*f_r;
        v+=dy*f_r;
        w+=dz*f_r;
    }
}

abstract class RungeKutta {
    private RungeKutta back;
    private RungeKutta diff;
    
    abstract protected void copy(RungeKutta q);
    abstract protected void add(RungeKutta q);
    abstract protected void multiply(double c);
    abstract protected void differentiate(double t);
    
    public void step(double time,double h) {
        if (back==null) try {
            back=(RungeKutta)getClass().newInstance();
            diff=(RungeKutta)getClass().newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        back.copy(this);
        // k1
        diff.copy(back);
        diff.differentiate(time);
        diff.multiply(h/6);
        add(diff);
        // k2
        diff.multiply(0.5*6);
        diff.add(back);
        diff.differentiate(time+h/2);
        diff.multiply(h/3);
        add(diff);
        // k3
        diff.multiply(0.5*3);
        diff.add(back);
        diff.differentiate(time+h/2);
        diff.multiply(h/3);
        add(diff);
        // k4
        diff.multiply(3);
        diff.add(back);
        diff.differentiate(time+h);
        diff.multiply(h/6);
        add(diff);
    }
}