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

public class ACupOfTea extends Applet 
implements MouseListener,MouseMotionListener,Runnable {
    
    int width,height;
    Cup[] cup=new Cup[5];
    Vector drops=new Vector();
    Image offscreen;
    Thread daemon;
    Point mouse=new Point();
    
    double dt=0.01;
    double ft=0.1;
    double spring=200;
    
    public void init() {
        width=getSize().width;
        height=getSize().height;
        setBackground(Color.white);
        addMouseListener(this);
        addMouseMotionListener(this);
        offscreen=createImage(width,height);
        for (int i=0;i<cup.length;i++)
            cup[i]=new Cup(width*Math.random(),height*Math.random(),
                width*(1+Math.random())/cup.length/2,
                height*(1+Math.random())/cup.length/2,0.8);
    }
    
    public synchronized void start() {
        daemon=new Thread(this);
        daemon.setDaemon(true);
        daemon.start();
    }
    
    public synchronized void stop() {
        daemon.interrupt();
    }
    
    public void run() {
        try {
            while (!Thread.interrupted()) {
                synchronized (this) {
                    for (int t=0;t<(int)(ft/dt);t++) {
                        cup[0].add(spring,dt);
                        for (int i=0;i<cup.length;i++) {
                            cup[i].move(dt);
                            cup[i].accelerate(mouse.x,mouse.y,dt,ft);
                            cup[i].correct();
                            Cup.Droplet drop=cup[i].drop();
                            if (drop!=null) drops.addElement(drop);
                        }
                        loop:
                        for (int i=0;i<drops.size();) {
                            Cup.Droplet drop=
                                (Cup.Droplet)drops.elementAt(i);
                            drop.move(dt);
                            for (int j=0;j<cup.length;j++)
                                if (cup[j].receive(drop,dt,2*dt)) {
                                    drops.removeElementAt(i);
                                    continue loop;
                                }
                            if (!drop.consists(0,0,width,height)) {
                                drops.removeElementAt(i);
                                continue;
                            }
                            i++;
                        }
                    }
                }
                repaint();
                Thread.sleep((int)(1000*ft));
            }
        } catch (InterruptedException e) {
        }
    }
    
    public synchronized void mousePressed(MouseEvent e) {
        mouse.setLocation(e.getX(),e.getY());
        for (int i=0;i<cup.length;i++)
            cup[i].press(mouse.x,mouse.y);
    }
    
    public synchronized void mouseReleased(MouseEvent e) {
        for (int i=0;i<cup.length;i++)
            cup[i].release();
    }
    
    public void mouseClicked(MouseEvent e) {
    }
    
    public void mouseEntered(MouseEvent e) {
    }
    
    public void mouseExited(MouseEvent e) {
    }
    
    public void mouseMoved(MouseEvent e) {
    }
    
    public synchronized void mouseDragged(MouseEvent e) {
        mouse.setLocation(e.getX(),e.getY());
    }
    
    public void update(Graphics g) {
        paint(g);
    }
    
    public synchronized void paint(Graphics g) {
        Graphics og=offscreen.getGraphics();
        og.clearRect(0,0,width,height);
        for (int i=0;i<cup.length;i++) cup[i].paint(og);
        for (int i=0;i<drops.size();i++) {
            Cup.Droplet drop=(Cup.Droplet)drops.elementAt(i);
            drop.paint(og);
        }
        og.dispose();
        g.drawImage(offscreen,0,0,this);
    }
}

class Cup {
    private static double g=2000;
    private static double registance=0.05;
    private static double knob=10;
    private static double min_droplet=20;
    private static double max_droplet=100;
    private static double timeout=10;
    
    private double x,y,theta;
    private double u,v,omega;
    private double width,height;
    private double flow;
    private double volume;
    private double left,right,bottom;
    private boolean rolling;
    private boolean seized;
    private double ox,oy,ot;
    
    public Cup(double x,double y,double width,double height,
        double prop) {
        this.x=x;
        this.y=y;
        this.width=width;
        this.height=height;
        this.volume=prop*width*height;
        left=height*prop;
        right=height*prop;
        bottom=width;
    }
    
    public void add(double spring,double dt) {
        volume+=dt*spring;
    }
    
    public void press(double x,double y) {
        ox=x-this.x;
        oy=y-this.y;
        ot=Math.atan2(ox,oy)-theta;
        double dx=cos()*ox-sin()*oy;
        double dy=-sin()*ox-cos()*oy;
        rolling=Math.abs(Math.abs(dx)-width/2)<knob && 
            Math.abs(Math.abs(dy-height/2)-height/2)<knob;
        seized=!rolling && Math.abs(dx)<width/2 && dy>0 && dy<height;
    }
    
    public void release() {
        rolling=false;
        seized=false;
    }
    
    public void accelerate(double x,double y,double dt,double ft) {
        double du=seized?2*((x-this.x-ox)/ft-u)/ft:-u/ft;
        double dv=seized?2*((y-this.y-oy)/ft-v)/ft:-v/ft;
        double domega;
        if (rolling) {
            double dtheta=Math.atan2(x-this.x,y-this.y)-theta-ot;
            while (dtheta<-Math.PI) dtheta+=2*Math.PI;
            while (dtheta>Math.PI) dtheta-=2*Math.PI;
            domega=2*(dtheta/ft-omega)/ft;
        } else
            domega=-omega/ft;
        u+=dt*du;
        v+=dt*dv;
        omega+=dt*domega;
        if (volume>0) {
            du+=Math.tan(domega)*volume/width/2;
            dv+=g;
            double a=-cos()*du-sin()*dv;
            double b=-sin()*du+cos()*dv;
            flow+=dt*(a+b*(Math.max(left,0)-Math.max(right,0))/bottom)/3
                -Math.min(dt*registance*Math.abs(flow),1)*flow;
        }
    }
    
    public void move(double dt) {
        x+=dt*u;
        y+=dt*v;
        theta+=dt*omega;
        double wave=bottom>0?
            flow*(Math.max(left,0)+Math.max(right,0))/bottom:flow;
        if (right>0 && left<0) {
            bottom-=dt*flow;
            right+=dt*wave;
            left=2*volume/width-right;
        } else if (right<0 && left>0) {
            bottom+=dt*flow;
            left-=dt*wave;
            right=2*volume/width-left;
        } else {
            left-=dt*wave;
            right+=dt*wave;
            bottom=width;
        }
    }
    
    public void correct() {
        while (theta<-Math.PI) theta+=2*Math.PI;
        while (theta>Math.PI) theta-=2*Math.PI;
        if (right>0 && left<0) {
            bottom+=volume/right-bottom/2;
            right+=(bottom>0?volume/bottom:0)-right/2;
            left=2*volume/width-right;
        } else if (right<0 && left>0) {
            bottom+=volume/left-bottom/2;
            left+=(bottom>0?volume/bottom:0)-left/2;
            right=2*volume/width-left;
        } else {
            double correction=volume/width-(left+right)/2;
            left+=correction;
            right+=correction;
        }
        if (Double.isNaN(left)) left=0;
        if (Double.isNaN(right)) right=0;
        if (Double.isNaN(bottom)) bottom=width;
        if (Double.isNaN(flow)) flow=0;
    }
    
    public Droplet drop() {
        double volume;
        double x,y;
        double u,v;
        double wave=flow*(Math.max(left,0)+Math.max(right,0))/bottom;
        if (right>height) {
            volume=(right-height)*bottom;
            x=width/2;
            y=right;
            u=Math.sqrt((right-height)*g);
            v=wave;
        } else if (left>height) {
            volume=(left-height)*bottom;
            x=-width/2;
            y=left;
            u=-Math.sqrt((left-height)*g);
            v=-wave;
        } else
            return null;
        if (volume>this.volume) {
            volume=this.volume;
            this.volume=0;
        } else if (volume<min_droplet) 
            return null;
        else {
            if (volume>max_droplet) volume=max_droplet;
            this.volume-=volume;
        }
        return new Droplet(volume,
            this.x+cos()*x-sin()*y,this.y-sin()*x-cos()*y,
            this.u+cos()*u-sin()*v,this.v-sin()*u-cos()*v);
    }
    
    public boolean receive(Droplet drop,double dt,double ft) {
        double x=cos()*(drop.x-this.x)-sin()*(drop.y-this.y);
        double y=-sin()*(drop.x-this.x)-cos()*(drop.y-this.y);
        double u=cos()*drop.u-sin()*drop.v;
        double v=-sin()*drop.u-cos()*drop.v;
        double x2=x+ft*u;
        double y2=y+ft*v;
        double a=(right-left)/width;
        double b=(right+left)/2;
        if (
            (x>-width/2 && x<width/2 && y>0 && (y2<a*x2+b || y2<0)) ||
            (x>-width/2 && x2<-width/2 && y>0 && y<height) ||
            (x<width/2 && x2>width/2 && y>0 && y<height)
        ) {
            volume+=drop.volume;
            flow+=(u+v*(Math.max(left,0)+Math.max(right,0))/bottom
                *2*x/width)*drop.volume/volume;
            return true;
        } 
        if (x>-width/2 && x<width/2 && y<0 && y2>0) {
            double bounce=1+Math.random();
            drop.u+=bounce*sin()*v;
            drop.v+=bounce*cos()*v;
        }
        if ((x<-width/2 && x2>-width/2 && y>0 && y<height) ||
            (x>width/2 && x2<width/2 && y>0 && y<height)) {
            double bounce=1+Math.random();
            drop.u-=bounce*cos()*u;
            drop.v+=bounce*sin()*u;
        }
        return false;
    }
    
    private double cos() {
        return Math.cos(theta);
    }
    
    private double sin() {
        return Math.sin(theta);
    }
    
    public void paint(Graphics g) {
        g.setColor(Color.black);
        drawLine(g,-width/2,0,width/2,0);
        drawLine(g,-width/2,height,-width/2,0);
        drawLine(g,width/2,height,width/2,0);
        if (volume>0) {
            g.setColor(Color.blue);
            if (left>=0 && right>=0)
                drawLine(g,-width/2,left,width/2,right);
            else if (left<0)
                drawLine(g,width/2,right,-bottom+width/2,0);
            else
                drawLine(g,-width/2,left,bottom-width/2,0);
        }
    }
    
    private void drawLine(Graphics g,
        double x0,double y0,double x1,double y1) {
        x0=Math.max(-width/2,Math.min(x0,width/2));
        y0=Math.max(0,Math.min(y0,height));
        x1=Math.max(-width/2,Math.min(x1,width/2));
        y1=Math.max(0,Math.min(y1,height));
        g.drawLine(
            (int)(x+cos()*x0-sin()*y0),
            (int)(y-sin()*x0-cos()*y0),
            (int)(x+cos()*x1-sin()*y1),
            (int)(y-sin()*x1-cos()*y1));
    }
    
    public static class Droplet {
        private double volume;
        private double x,y;
        private double u,v;
        private int r;
        private double t;
        
        public Droplet(double volume,
            double x,double y,double u,double v) {
            this.volume=volume;
            this.x=x;
            this.y=y;
            this.u=u;
            this.v=v;
            this.t=timeout;
            r=(int)Math.sqrt(volume/Math.PI);
        }
        
        public boolean consists(
            double x,double y,double width,double height) {
            return t>0 &&
                this.x>x && this.y>y &&
                this.x<x+width && this.y<y+height;
        }
        
        public void move(double dt) {
            x+=dt*u;
            y+=dt*v;
            u-=Math.min(dt*registance*Math.abs(u),1)*u;
            v+=-Math.min(dt*registance*Math.abs(v),1)*v+dt*g;
            t-=dt;
        }
        
        public void paint(Graphics g) {
            g.setColor(Color.blue);
            g.drawOval((int)x-r,(int)y-r,2*r,2*r);
        }
    }
}