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

public class Gravity extends SimulationApplet {
    static final double gravity=2e6;
    static final double viscosity=1;
    
    Star[] star=new Star[2];
    Star seized;
    double ox,oy;
    
    public void init() {
        super.init();
        star[0]=new Star(0,0,0,1.8,50,1,getImage("earth.jpg"));
        star[1]=new Star(100,0,0,-150,14,0.012,getImage("moon.jpg"));
    }
    
    private Image getImage(String name) {
        return getToolkit().getImage(getClass().getResource(name));
    }
    
    public void mousePressed(int x,int y) {
        for (int i=0;i<star.length;i++) 
            if (star[i].contains(x,y)) {
                seized=star[i];
                ox=seized.x-x;
                oy=seized.y-y;
            }
    }
    
    public void mouseReleased(int x,int y) {
        seized=null;
    }
            
    public synchronized void run(double dt) {
        for (int i=0;i<star.length;i++) {
            for (int j=0;j<i;j++)
                star[i].force(dt,star[j]);
            star[i].bound();
            star[i].move(dt);
        }
        if (seized!=null) {
            seized.u+=2*dt*((ox+mouse_x-seized.x)/ft-seized.u)/ft;
            seized.v+=2*dt*((oy+mouse_y-seized.y)/ft-seized.v)/ft;
        }
    }
    
    public void paintOffscreen(Graphics g) {
        g.setColor(Color.black);
        g.fillRect(0,0,width,height);
        for (int i=0;i<star.length;i++)
            star[i].paint(g);
    }
    
    class Star {
        public double x,y;
        public double u,v;
        public double r,m;
        public Image image;
        
        public Star(
            double x,double y,double u,double v,double r,double m,
            Image image) {
            this.x=x+width/2;
            this.y=y+height/2;
            this.u=u;
            this.v=v;
            this.r=r;
            this.m=m;
            this.image=image;
        }
        
        public void force(double dt,Star star) {
            double dx=star.x-x;
            double dy=star.y-y;
            double dr=Math.sqrt(dx*dx+dy*dy);
            dx/=dr;
            dy/=dr;
            double dw;
            if (dr<star.r+r) {
                dw=1.9*((star.u-u)*dx+(star.v-v)*dy)/(star.m+m);
                if (dw>0) dw=0;
            } else 
                dw=dt*gravity/(dr*dr);
            u+=dw*dx*star.m;
            v+=dw*dy*star.m;
            star.u+=-dw*dx*m;
            star.v+=-dw*dy*m;
        }
        
        public void bound() {
            if ((x<r && u<0) || (x>width-r && u>0)) u*=-0.9;
            if ((y<r && v<0) || (y>height-r && v>0)) v*=-0.9;
        }
        
        public void decay(double dt) {
            u+=-dt*viscosity*u;
            v+=-dt*viscosity*v;
        }
        
        public void move(double dt) {
            x+=dt*u;
            y+=dt*v;
        }
        
        public boolean contains(double x,double y) {
            double dx=this.x-x;
            double dy=this.y-y;
            return dx*dx+dy*dy<r*r;
        }
        
        public void paint(Graphics g) {
            g.drawImage(image,(int)(x-r),(int)(y-r),Gravity.this);
        }
    }
}

abstract class SimulationApplet extends Applet
implements MouseListener,MouseMotionListener,Runnable {
    public static final double ft=0.1;
    public static final double dt=0.01;
    
    private Thread daemon;
    private Image offscreen;
    protected int width,height;
    protected int mouse_x,mouse_y;
    protected boolean mouse_down;
    private volatile double mouse_interval;
    
    public void init() {
        width=getSize().width;
        height=getSize().height;
        setBackground(Color.white);
        addMouseListener(this);
        addMouseMotionListener(this);
        offscreen=createImage(width,height);
    }
    
    public synchronized void start() {
        daemon=new Thread(this);
        daemon.setDaemon(true);
        daemon.start();
    }
    
    public synchronized void stop() {
        daemon.interrupt();
    }
    
    protected abstract void run(double dt);
    
    public void run() {
        try {
            while (!Thread.interrupted()) {
                for (int t=0;t<(int)(ft/dt);t++) synchronized (this) {
                    run(dt);
                }
                repaint();
                Thread.sleep((int)(1000*ft));
            }
        } catch (InterruptedException e) {
        }
    }
    
    public synchronized void mousePressed(MouseEvent e) {
        mouse_x=e.getX();
        mouse_y=e.getY();
        mouse_down=true;
        mousePressed(mouse_x,mouse_y);
    }
    
    protected void mousePressed(int x,int y) {
    }
    
    public void mouseReleased(MouseEvent e) {
        mouse_down=false;
        mouseReleased(e.getX(),e.getY());
    }
    
    protected void mouseReleased(int x,int y) {
    }
    
    public synchronized void mouseClicked(MouseEvent e) {
        mouseClicked(e.getX(),e.getY());
    }
    
    protected void mouseClicked(int x,int y) {
    }
    
    public void mouseEntered(MouseEvent e) {
    }
    
    public void mouseExited(MouseEvent e) {
    }
    
    public void mouseMoved(MouseEvent e) {
    }
    
    public synchronized void mouseDragged(MouseEvent e) {
        mouseDragged(e.getX(),e.getY(),
            e.getX()-mouse_x,e.getY()-mouse_y);
        mouse_x=e.getX();
        mouse_y=e.getY();
    }
    
    protected void mouseDragged(int x,int y,int dx,int dy) {
    }
    
    public void update(Graphics g) {
        paint(g);
    }
    
    public synchronized void paint(Graphics g) {
        Graphics og=offscreen.getGraphics();
        og.clearRect(0,0,width,height);
        paintOffscreen(og);
        og.dispose();
        g.drawImage(offscreen,0,0,this);
    }
    
    protected abstract void paintOffscreen(Graphics g);
}