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


public class MassiveBall extends SimulationApplet {
    static final double r_max=50,r_mid=20,r_min=10;
    
    Ball[] large=new Ball[5];
    Ball[] small=new Ball[150];
    Ball[] all=new Ball[large.length+small.length];
    Grid grid;
    Ball seized;
    
    public void init() {
        super.init();
        int i=0;
        for (int j=0;j<large.length;j++,i++) 
            all[i]=large[j]=createBall(r_max,r_mid);
        for (int j=0;j<small.length;j++,i++) 
            all[i]=small[j]=createBall(r_mid,r_min);
        grid=new Grid(width,height,r_mid,10);
    }
    
    private Ball createBall(double r_max,double r_min) {
        double r=Math.random()*(r_max-r_min)+r_min;
        double x=Math.random()*(width-2*r)+r;
        double y=Math.random()*(height-2*r)+r;
        Color color=new Color(random(),random(),random());
        return new Ball(x,y,r,color);
    }
    
    private static float random() {
        return (float)Math.random();
    }
    
    protected synchronized void run(double dt) {
        grid.clear();
        for (int i=0;i<small.length;i++) 
            grid.add(small[i],small[i].x,small[i].y);
        grid.apply(new Grid.Operator() {
            public void matchObjects(Object a,Object b) {
                if (((Ball)a).id<((Ball)b).id)
                    ((Ball)a).collide((Ball)b);
            }
        });
        for (int i=0;i<large.length;i++) {
            for (int j=0;j<i;j++)
                large[i].collide(large[j]);
            for (int j=0;j<small.length;j++)
                large[i].collide(small[j]);
        }
        for (int i=0;i<all.length;i++) {
            all[i].fall(dt);
            all[i].bound(width,height);
            all[i].move(dt);
        }
        if (seized!=null) {
            seized.u+=dt*2*((mouse_x-seized.x)/ft-seized.u)/ft;
            seized.v+=dt*2*((mouse_y-seized.y)/ft-seized.v)/ft;
        }
    }
    
    protected void mousePressed(int x,int y) {
        for (int i=0;i<all.length;i++) {
            Ball b=all[i];
            double dx=b.x-x,dy=b.y-y;
            if (dx*dx+dy*dy<b.r*b.r) seized=b;
        }
    }
    
    protected void mouseReleased(int x,int y) {
        seized=null;
    }
    
    protected void paintOffscreen(Graphics g) {
        for (int i=0;i<all.length;i++) {
            Ball b=all[i];
            g.setColor(b.color);
            g.fillOval(
                (int)(b.x-b.r),(int)(b.y-b.r),
                (int)(2*b.r),(int)(2*b.r));
        }
    }
}

class Ball {
    private static final double elasticity=0.8;
    private static final double gravity=200;
    private static final double bounce=0.7;
    private static int number=0;
    
    public double x,y;
    public double u,v;
    public double r,m;
    public int id;
    
    public Color color;
    
    public Ball(double x,double y,double r,Color color) {
        this.x=x;
        this.y=y;
        this.r=r;
        this.color=color;
        m=Math.PI*r*r;
        id=number++;
    }
    
    public void fall(double dt) {
        v+=dt*gravity;
    }
    
    public void move(double dt) {
        x+=dt*u;
        y+=dt*v;
    }
    
    public void collide(Ball b) {
        double dx=b.x-x,dy=b.y-y;
        double dr=Math.sqrt(dx*dx+dy*dy);
        if (dr<b.r+r) {
            dx/=dr;
            dy/=dr;
            double dw=(b.u-u)*dx+(b.v-v)*dy;
            if (dw<0) {
                double fw=dw*(1+elasticity)/(b.m+m);
                u+=fw*dx*b.m;
                v+=fw*dy*b.m;
                b.u+=-fw*dx*m;
                b.v+=-fw*dy*m;
            }
            double fr=bounce*(dr-b.r-r)/(b.m+m);
            x+=fr*dx*b.m;
            y+=fr*dy*b.m;
            b.x+=-fr*dx*m;
            b.y+=-fr*dy*m;
        }
    }
    
    public void bound(double width,double height) {
        if (x<r) {
            if (u<0) u*=-elasticity;
            x+=bounce*(r-x);
        }
        if (x>width-r) {
            if (u>0) u*=-elasticity;
            x+=bounce*(width-r-x);
        }
        if (y<r) {
            if (v<0) v*=-elasticity;
            y+=bounce*(r-y);
        }
        if (y>height-r) {
            if (v>0) v*=-elasticity;
            y+=bounce*(height-r-y);
        }
    }
}

class Grid {
    private double width,height,delta;
    private int cols,rows,capacity;
    private Object[][][] cell;
    private int[][] count;
    
    public Grid(double width,double height,double delta,int capacity) {
        this.width=width;
        this.height=height;
        this.delta=delta;
        this.capacity=capacity;
        cols=(int)Math.ceil(width/delta);
        rows=(int)Math.ceil(height/delta);
        cell=new Object[cols][rows][capacity];
        count=new int[cols][rows];
    }
    
    public void clear() {
        for (int i=0;i<cols;i++)
            for (int j=0;j<rows;j++)
                count[i][j]=0;
    }
    
    public void add(Object obj,double x,double y) {
        int i=(int)(x/delta);
        int j=(int)(y/delta);
        if (i<0) i=0;
        if (i>=cols) i=cols-1;
        if (j<0) j=0;
        if (j>=rows) j=rows-1;
        if (count[i][j]<capacity)
            cell[i][j][count[i][j]++]=obj;
    }
    
    public void apply(Operator op) {
        for (int i=0;i<cols;i++) {
            int i2min=Math.max(0,i-1);
            int i2max=Math.min(i+1,cols-1);
            for (int j=0;j<rows;j++) {
                int j2min=Math.max(0,j-1);
                int j2max=Math.min(j+1,rows-1);
                for (int k=0;k<count[i][j];k++) 
                    for (int i2=i2min;i2<=i2max;i2++)
                        for (int j2=j2min;j2<=j2max;j2++)
                            for (int k2=0;k2<count[i2][j2];k2++)
                                op.matchObjects(
                                    cell[i][j][k],
                                    cell[i2][j2][k2]);
            }
        }
    }
    
    public interface Operator {
        void matchObjects(Object a,Object b);
    }
}

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);
}