/* Orbit.java applet by Matt Mahoney.

This animation simulates planets orbiting in 2-dimensional space, 
obeying Newton's law of gravity, with collisions.  To create a 
planet, click in the blank area.  The mass and size of the planet 
depends on how long the mouse is held down.  If you move the mouse 
while pressed, the initial velocity of the planet will match that of 
the mouse.

The display is centered around the first planet created.  To change
the "home planet", right click on it.

There are 3 buttons at the top:
Zoom In - magnify the display by a factor of 2.
Zoom Out - opposite of zoom in.
Clear - removes all planets and resets the zoom level.

*/

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class Orbit extends JApplet implements ActionListener {
  private Timer timer;
  private Display display;
  private JButton zoomin, zoomout, clear;
  private static final int N = 10000;  // max number of planets
  private static final double DENSITY = 40.0;  // area/mass
  private double[] x = new double[N], y = new double[N];  // positions
  private double[] dx = new double[N], dy = new double[N];  // velocities
  private double[] m = new double[N];  // masses
  private int n = 0;  // number of planets, n <= N
  private double scale = 1.0;  // viewing magnification
  private double xpos = 0, ypos = 0;  // upper left corner position
  private int t = 0;  // current time
  private int tstart = 0;  // mouse down time
  private double xstart = 0, ystart = 0;  // mouse down position
  private int homePlanet = 0;

  // Initialize
  public void init() {
    display = new Display();
    JPanel topPanel = new JPanel();
    topPanel.add(zoomin = new JButton("Zoom In"));
    topPanel.add(zoomout = new JButton("Zoom Out"));
    topPanel.add(clear = new JButton("Clear"));
    zoomin.addActionListener(this);
    zoomout.addActionListener(this);
    clear.addActionListener(this);
    add(display);
    add(topPanel, BorderLayout.NORTH);
    display.addMouseListener(display);
    timer = new Timer(30, this);
    timer.start();
  } 

  // Handle button press or timer events.
  public void actionPerformed(ActionEvent e) {

    // Zoom In
    if (e.getSource()==zoomin) {
      scale*=2;
      xpos+=getWidth()/(scale*2);
      ypos+=getHeight()/(scale*2);
      return;
    }

    // Zoom out
    if (e.getSource()==zoomout) {
      xpos-=getWidth()/(scale*2);
      ypos-=getHeight()/(scale*2);
      scale/=2;
      return;
    }

    // Clear
    if (e.getSource()==clear) {
      n = 0;
      scale = 1;
      xpos = ypos = 0;
      return;
    }

    // Timer event: First merge colliding planets
    for (int i=0; i<n; ++i) {
      for (int j=i+1; j<n; ++j) {
        double r2 = (x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
        if (r2 < (m[i]+m[j])*DENSITY) {
          double px = m[i]*dx[i]+m[j]*dx[j];  // momentum
          double py = m[i]*dy[i]+m[j]*dy[j];
          double mass = m[i]+m[j];
          x[i] = (x[i]*m[i]+x[j]*m[j])/mass;
          y[i] = (y[i]*m[i]+y[j]*m[j])/mass;
          dx[i] = px/mass;
          dy[i] = py/mass;
          m[i] = mass;
          if (homePlanet == j)
            homePlanet = i;
          --n;  // replace planet j with last planet
          x[j] = x[n];
          y[j] = y[n];
          dx[j] = dx[n];
          dy[j] = dy[n];
          m[j] = m[n];
          if (homePlanet == n)
            homePlanet = j;
          --j;
        }
      }
    }

    // Update velocities
    for (int i=0; i<n; ++i) {
      double fx=0, fy=0;  // gravitational force
      for (int j=0; j<n; ++j) {
        if (i != j) {
          double xd = x[j]-x[i];
          double yd = y[j]-y[i];
          double r2 = xd*xd+yd*yd;
          if (r2 > 0) {
            r2 = Math.sqrt(r2*r2*r2)*.01;
            fx += m[j]*xd/r2;
            fy += m[j]*yd/r2;
          }
        }
        dx[i] += fx;
        dy[i] += fy;
      }
    }

    // Update positions
    for (int i=0; i<n; ++i) {
      x[i] += dx[i];
      y[i] += dy[i];
    }
    ++t;  // update current time
    display.repaint();
  }

  // Drawing area and mouse event handler
  private class Display extends JPanel implements MouseListener {

    // Draw the planets
    public void paintComponent(Graphics g) {
      super.paintComponent(g);
      if (homePlanet < n) {
        xpos = x[homePlanet]-getWidth()/(2*scale);
        ypos = y[homePlanet]-getHeight()/(2*scale);
      }
      g.setColor(Color.BLACK);
      g.fillRect(0, 0, getWidth(), getHeight());
      for (int i=0; i<n; ++i) {
        g.setColor(new Color((i&1)*128+100, (i&2)*64+100, (i&4)*32+100));
        int r = (int)(Math.sqrt(m[i]*DENSITY)*scale+1);
        double ix = ((x[i]-xpos+0.1)*scale-r);
        double iy = ((y[i]-ypos+0.1)*scale-r);
        g.fillOval((int)ix, (int)iy, r*2, r*2);
      }
    }
    
    // Add a planet where user clicks.  The initial velocity will be the
    // same as the mouse between the press and release.
    // The mass depends on how long the button was held down.
    public void mousePressed(MouseEvent e) {
      double xm = e.getX()/scale+xpos;
      double ym = e.getY()/scale+ypos;

      // Land on a planet if the user right clicks within 2 pixels
      if (e.isMetaDown()) {
        for (int i=0; i<n; ++i) {
          double r = Math.sqrt((x[i]-xm)*(x[i]-xm)+(y[i]-ym)*(y[i]-ym));
          if (r < Math.sqrt(m[i]*DENSITY)+2/scale) {
            homePlanet = i;
            break;
          }
        }
      }

      // Mark position to create a new planet
      else {
        xstart = xm;
        ystart = ym;
      }
      tstart = t;
    }

    // Left mouse button released: create a planet
    public void mouseReleased(MouseEvent e) {
      if (!e.isMetaDown() && n < N) {
        x[n] = e.getX()/scale+xpos;
        y[n] = e.getY()/scale+ypos;
        m[n] = t-tstart+0.5;
        dx[n] = (x[n]-xstart)/m[n];
        dy[n] = (y[n]-ystart)/m[n];
        ++n;
      }
    }

    // Other mouse events to ignore
    public void mouseClicked(MouseEvent e) {}
    public void mouseEntered(MouseEvent e) {}
    public void mouseExited(MouseEvent e) {}
  }
}