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

public class DullBall extends Applet 
implements Runnable,MouseListener,MouseMotionListener {
    static final int L=100;
    static final int R=21;
    static final int N=30;
    static final int D=1024;
    static final double G=0.2;
    
    static final int[][][] frame={
        {{-1,-1,-1},{-1,-1,1}},
        {{-1,-1,1},{-1,1,1}},
        {{-1,1,1},{-1,1,-1}},
        {{-1,1,-1},{-1,-1,-1}},
        {{-1,-1,-1},{1,-1,-1}},
        {{-1,-1,1},{1,-1,1}},
        {{-1,1,1},{1,1,1}},
        {{-1,1,-1},{1,1,-1}},
        {{1,-1,-1},{1,-1,1}},
        {{1,-1,1},{1,1,1}},
        {{1,1,1},{1,1,-1}},
        {{1,1,-1},{1,-1,-1}}
    };
    
    Cluster cluster;
    Matrix matrix;
    int last_x,last_y;
    boolean running;
    Image image;
    double a,b,c;
    boolean circle;
    int width,height;
    
    public void init() {
        setBackground(Color.white);
        addMouseListener(this);
        addMouseMotionListener(this);
    }
    
    public synchronized void start() {
        cluster=new Cluster();
        matrix=new Matrix(1);
        a=0;
        b=G;
        c=0;
        if (!running) {
            running=true;
            new Thread(this,"Physics").start();
        }
    }
    
    public void stop() {
        running=false;
    }
    
    public void run() {
        while (running) {
            for (int t=0;t<100;t++)
                synchronized (this) {
                    cluster.step(a,b,c,0.8*(100-t)/100);
                }
            repaint();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public void mousePressed(MouseEvent e) {
        last_x=e.getX();
        last_y=e.getY();
        circle=
            Math.pow(last_x-width/2,2)+Math.pow(last_y-height/2,2)
            >3*Math.pow(L*D/(D+L),2);
    }
    public void mouseReleased(MouseEvent e) {
        if (circle) {
            circle=false;
            repaint();
        }
    }
    public void mouseEntered(MouseEvent e) {}
    public void mouseExited(MouseEvent e) {}
    public void mouseClicked(MouseEvent e) {}
    public void mouseMoved(MouseEvent e) {}
    public void mouseDragged(MouseEvent e) {
        if (circle)
            matrix.rotate(0,0,
                Math.atan2(last_x-width/2,last_y-height/2)
                -Math.atan2(e.getX()-width/2,e.getY()-height/2));
        else
            matrix.rotate(
                Math.PI*(e.getY()-last_y)/L/2,
                -Math.PI*(e.getX()-last_x)/L/2,
                0
            );
        a=matrix.applyInverseX(0,G,0);
        b=matrix.applyInverseY(0,G,0);
        c=matrix.applyInverseZ(0,G,0);
        repaint();
        last_x=e.getX();
        last_y=e.getY();
    }
    
    public void update(Graphics g) {
        paint(g);
    }
    
    void drawFrame(Graphics g,boolean foreground) {
        g.setColor(Color.darkGray);
        for (int i=0;i<12;i++) {
            double x1=L*matrix.
                applyX(frame[i][0][0],frame[i][0][1],frame[i][0][2]);
            double y1=L*matrix.
                applyY(frame[i][0][0],frame[i][0][1],frame[i][0][2]);
            double z1=L*matrix.
                applyZ(frame[i][0][0],frame[i][0][1],frame[i][0][2]);
            double x2=L*matrix.
                applyX(frame[i][1][0],frame[i][1][1],frame[i][1][2]);
            double y2=L*matrix.
                applyY(frame[i][1][0],frame[i][1][1],frame[i][1][2]);
            double z2=L*matrix.
                applyZ(frame[i][1][0],frame[i][1][1],frame[i][1][2]);
            if ((z1+z2<0)==foreground) {
                double m1=D/(z1+D);
                double m2=D/(z2+D);
                g.drawLine(
                    (int)(x1*m1),(int)(y1*m1),
                    (int)(x2*m2),(int)(y2*m2));
            }
        }
    }
    
    public synchronized void paint (Graphics g) {
        if (image==null) {
            width=getSize().width;
            height=getSize().height;
            image=createImage(width,height);
        }
        Graphics og=image.getGraphics();
        og.clearRect(0,0,width,height);
        og.translate(width/2,height/2);
        drawFrame(og,false);
        double last_z=Double.POSITIVE_INFINITY;
        for (int i=0;i<DullBall.N;i++) {
            Ball p=cluster.ball[i];
            double x=matrix.applyX(p.x,p.y,p.z);
            double y=matrix.applyY(p.x,p.y,p.z);
            double z=matrix.applyZ(p.x,p.y,p.z);
            double m=D/(z+D);
            if (m>0) {
                int r=Math.max((int)(R*m),1);
                og.setColor(p.color);
                og.fillOval(
                    (int)(x*m)-r,
                    (int)(y*m)-r,
                    r*2,r*2);
            }
            p.depth=z;
        }
        drawFrame(og,true);
        if (circle) {
            int l=(int)(Math.sqrt(3)*L*D/(D+L));
            og.drawOval(-l,-l,2*l,2*l);
        }
        og.dispose();
        g.drawImage(image,0,0,this);
        cluster.sort();
    }
}

class Cluster {
    final Ball[] ball=new Ball[DullBall.N];
    
    Cluster() {
        for (int i=0;i<DullBall.N;i++) 
            ball[i]=new Ball((double)i/DullBall.N);
    }
    
    void step(double a,double b,double c,double alpha) {
        for (int i=0;i<DullBall.N;i++) {
            ball[i].force(a,b,c);
            for (int j=0;j<DullBall.N;j++)
                if (i!=j)
                    ball[i].force(ball[j]);
        }
        for (int i=0;i<DullBall.N;i++) 
            ball[i].move(alpha);
    }

    
    void sort() {
        sort(0,DullBall.N-1);
    }
    
    void sort(int begin,int end) {
        int front=begin;
        int back=end;
        Ball mid=ball[(begin+end)/2];
        while(front<=back) {
            while((front<end) && (ball[front].depth>mid.depth)) 
                front++;
            while((back>begin) && (ball[back].depth<mid.depth)) 
                back--;
            if (front<=back) {
                Ball temp=ball[front];
                ball[front]=ball[back];
                ball[back]=temp;
                front++;
                back--;
            }
        }
        if(begin<back) sort(begin,back);
        if(front<end) sort(front,end);
    }
}

class Ball {
    double x,y,z;
    double u,v,w;
    double depth;
    Color color;
    
    Ball() {}

    Ball(double hue) {
        x=2*(Math.random()-0.5)*DullBall.L;
        y=2*(Math.random()-0.5)*DullBall.L;
        z=2*(Math.random()-0.5)*DullBall.L;
        int red=(int)((1+Math.sin(2*Math.PI*hue))/2*255);
        int green=(int)((1+Math.sin(2*Math.PI*(hue+1/3.)))/2*255);
        int blue=(int)((1+Math.sin(2*Math.PI*(hue+2/3.)))/2*255);
        color=new Color(red,green,blue);
    }

    static double forceByWall(double r) {
        return r<DullBall.R?DullBall.R-r:0;
    }

    void force(double a,double b,double c) {
        u=-forceByWall(DullBall.L-x)+forceByWall(DullBall.L+x)+a;
        v=-forceByWall(DullBall.L-y)+forceByWall(DullBall.L+y)+b;
        w=-forceByWall(DullBall.L-z)+forceByWall(DullBall.L+z)+c;
    }

    void force(Ball p) {
        double dx=p.x-x;
        double dy=p.y-y;
        double dz=p.z-z;
        double r2=dx*dx+dy*dy+dz*dz;
        if (r2<4*DullBall.R*DullBall.R) {
            double r=Math.sqrt(r2);
            u-=dx/r;
            v-=dy/r;
            w-=dz/r;
        }
    }

    void move(double alpha) {
        x+=alpha*u;
        y+=alpha*v;
        z+=alpha*w;
    }
}

class Matrix {
    private double xx,xy,xz;
    private double yx,yy,yz;
    private double zx,zy,zz;
    
    public Matrix() {}
    
    public Matrix(double m) {
        set(m,0,0,0,m,0,0,0,m);
    }
    
    public Matrix(
        double xx,double xy,double xz,
        double yx,double yy,double yz,
        double zx,double zy,double zz) {
        set(xx,xy,xz,yx,yy,yz,zx,zy,zz);
    }
    
    public void set(
        double xx,double xy,double xz,
        double yx,double yy,double yz,
        double zx,double zy,double zz) {
        this.xx=xx;
        this.xy=xy;
        this.xz=xz;
        this.yx=yx;
        this.yy=yy;
        this.yz=yz;
        this.zx=zx;
        this.zy=zy;
        this.zz=zz;
    }

    public void multiply(
        double xx,double xy,double xz,
        double yx,double yy,double yz,
        double zx,double zy,double zz) {
        set(
            xx*this.xx+xy*this.yx+xz*this.zx,
            xx*this.xy+xy*this.yy+xz*this.zy,
            xx*this.xz+xy*this.yz+xz*this.zz,
            yx*this.xx+yy*this.yx+yz*this.zx,
            yx*this.xy+yy*this.yy+yz*this.zy,
            yx*this.xz+yy*this.yz+yz*this.zz,
            zx*this.xx+zy*this.yx+zz*this.zx,
            zx*this.xy+zy*this.yy+zz*this.zy,
            zx*this.xz+zy*this.yz+zz*this.zz);
    }

    public void scale(double m) {
        multiply(m,0,0,0,m,0,0,0,m);
    }
    
    public void rotate(double x,double y,double z) {
        if (x==0 && y==0 && z==0) return;
        double q=Math.sqrt(x*x+y*y+z*z);
        x/=q;
        y/=q;
        z/=q;
        double cosq=Math.cos(q);
        double sinq=Math.sin(q);
        double rcosq=1-cosq;
        multiply(
            cosq+rcosq*x*x,rcosq*x*y-z*sinq,rcosq*x*z+y*sinq,
            rcosq*x*y+z*sinq,cosq+rcosq*y*y,rcosq*y*z-x*sinq,
            rcosq*x*z-y*sinq,rcosq*y*z+x*sinq,cosq+rcosq*z*z);
    }
    
    public double applyX(double x,double y,double z) {
        return xx*x+xy*y+xz*z;
    }
    
    public double applyY(double x,double y,double z) {
        return yx*x+yy*y+yz*z;
    }
    
    public double applyZ(double x,double y,double z) {
        return zx*x+zy*y+zz*z;
    }
    
    public double applyInverseX(double x,double y,double z) {
        return 
            (yz*zy-yy*zz)
            /(xz*yy*zx-xy*yz*zx-xz*yx*zy+xx*yz*zy+xy*yx*zz-xx*yy*zz)*x
            +(xz*zy-xy*zz)
            /(-xz*yy*zx+xy*yz*zx+xz*yx*zy-xx*yz*zy-xy*yx*zz+xx*yy*zz)*y
            +(xz*yy-xy*yz)
            /(xz*yy*zx-xy*yz*zx-xz*yx*zy+xx*yz*zy+xy*yx*zz-xx*yy*zz)*z;
    }
    
    public double applyInverseY(double x,double y,double z) {
        return
            (yz*zx-yx*zz)
            /(-(xz*yy*zx)+xy*yz*zx+xz*yx*zy-xx*yz*zy-xy*yx*zz+xx*yy*zz)*x
            +(xz*zx-xx*zz)
            /(xz*yy*zx-xy*yz*zx-xz*yx*zy+xx*yz*zy+xy*yx*zz-xx*yy*zz)*y
            +(xz*yx-xx*yz)
            /(-(xz*yy*zx)+xy*yz*zx+xz*yx*zy-xx*yz*zy-xy*yx*zz+xx*yy*zz)*z;
    }

    public double applyInverseZ(double x,double y,double z) {
        return 
            (yy*zx-yx*zy)
            /(xz*yy*zx-xy*yz*zx-xz*yx*zy+xx*yz*zy+xy*yx*zz-xx*yy*zz)*x
            +(xy*zx-xx*zy)
            /(-(xz*yy*zx)+xy*yz*zx+xz*yx*zy-xx*yz*zy-xy*yx*zz+xx*yy*zz)*y
            +(xy*yx-xx*yy)
            /(xz*yy*zx-xy*yz*zx-xz*yx*zy+xx*yz*zy+xy*yx*zz-xx*yy*zz)*z;
    }
}