/**************************************************************************
Synopsis: Animation involving circular blocks
Author: Kannan Balasubramanian
Last Updated Date: 11/24/2007
**************************************************************************/

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RadialGradientPaint;
import java.awt.MultipleGradientPaint;
import java.awt.MultipleGradientPaint.CycleMethod;
import java.awt.Toolkit;
import java.awt.Dimension;
import java.awt.RenderingHints;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import java.util.Vector;
import java.util.Random;
import java.awt.geom.*;

/*
 * Documented:
 * Press key 'c' or 'C' to toggle circle colors
 * Press 'left/right' arrow to increase/decrease circle count
 * Press 'up/down' arrow to increase/decrease circle radius
 * Press key 'p' to pause/resume animation
 * Press 'Esc' key to exit
 *
 * Undocumented:
 * Press key 'a' or 'A' to toggle antialiasing of the entire screen
 * Press key '3' to draw circles in 3D shapes
 * Press key '2' to draw circles in 2D shapes
 */
public class StarField extends JPanel implements ActionListener {

     private Font font0 = new Font("Courier", Font.PLAIN, 20);
     private Font font1 = new Font("Courier", Font.PLAIN, 12);
     private Font font2 = new Font("Courier", Font.PLAIN, 16);
     private Vector circleVector = new Vector();
     public static final Dimension screensize = Toolkit.getDefaultToolkit().getScreenSize();
     private boolean bColor = false;
     private boolean bPause = false;
     private static final String NO_OF_CIRCLES = "No. of circles: ";

     public StarField() {
         setBackground(Color.black);
         setFocusable(true);
         addKeyListener(new KeyAdapter() {
            public void keyTyped(KeyEvent e) {
                if (!bPause && !Circle.is3D() && (e.getKeyChar() == 'c' || e.getKeyChar() == 'C')) {
                    bColor = !bColor;
                    for (int i=0; i<circleVector.size(); i++) {
                         Circle circle = (Circle)circleVector.elementAt(i);
                         circle.setColor(bColor);
                    }
                    repaint();
                } else if(e.getKeyChar() == 'a' || e.getKeyChar() == 'A') {
                    Circle.toggleAntialiasing();
                } else if(e.getKeyChar() == 'p' || e.getKeyChar() == 'P') {
                    bPause = !bPause;
                } else if(e.getKeyChar() == '3') {
                    Circle.set3D(true);
                } else if(e.getKeyChar() == '2') {
                    Circle.set3D(false);
                }
            }
            public void keyPressed(KeyEvent e) {
                if (bPause) {
                    return;
                }
                if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
                    System.exit(0);
                }
                if (e.getKeyCode() == KeyEvent.VK_LEFT) {
                    if (circleVector.size() <= 100) {
                        addCircles(10);
                    }
                } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
                    if (circleVector.size() >= 15) {
                        removeCircles(10);
                    }
                } else if (e.getKeyCode() == KeyEvent.VK_UP) {
                    Circle circle = null;
                    for (int i=0; i<circleVector.size(); i++) {
                         circle = (Circle)circleVector.elementAt(i);
                         circle.increaseRadius(2);
                         Circle.zoomLevel = circle.getRadius();
                    }
                } else if (e.getKeyCode() == KeyEvent.VK_DOWN) {
                    Circle circle = null;
                    for (int i=0; i<circleVector.size(); i++) {
                         circle = (Circle)circleVector.elementAt(i);
                         circle.decreaseRadius(2);
                         Circle.zoomLevel = circle.getRadius();
                    }
                }
                repaint();
            }
         });
         addCircles(5);
         Timer timer = new Timer(100, this);
         timer.start();
     }

     public void actionPerformed(ActionEvent e) {

         if (bPause) {
             return;
         }
         int offset = 15;
         for (int i=0; i<circleVector.size(); i++) {
             Circle circle = (Circle)circleVector.elementAt(i);
             int direction = circle.getDirection();
             if (direction == 0) {
                 circle.setOffset(offset, offset);
             } else if (direction == 1) {
                 circle.setOffset(-offset, offset);
             } else if (direction == 2) {
                 circle.setOffset(offset, -offset);
             } else if (direction == 3) {
                 circle.setOffset(-offset, -offset);
             } else if (direction == 4) {
                 circle.setOffset(-offset, 0);
             } else if (direction == 5) {
                 circle.setOffset(0, -offset);
             } else if (direction == 6) {
                 circle.setOffset(offset, 0);
             } else if (direction == 7) {
                 circle.setOffset(0, offset);
             }
             if (circle.resetCircle()) {
                 continue;
             }
         }
         repaint();
     }

     public void paintComponent(Graphics g) {
         super.paintComponent(g);
         Graphics2D g2d = (Graphics2D)g;
         Color oldColor = g2d.getColor();
         Font oldFont = g2d.getFont();
         g2d.setColor(Color.WHITE);
         g2d.setFont(font0);
         int y = 30;
         int yoffset = 20;
         g2d.drawString("JAVA", screensize.width/4-30, y);
         y += yoffset;
         g2d.setFont(font1);
         g2d.drawString("Press c to toggle circle colors", 20, y);
         y += yoffset;
         g2d.setColor(Color.MAGENTA);
         g2d.setFont(font2);
         g2d.drawString(NO_OF_CIRCLES + circleVector.size(), 20, y);
         y += yoffset;
         g2d.setFont(font1);
         g2d.setColor(Color.WHITE);
         g2d.drawString("Press left or right arrow to +/- circle count", 20, y);
         y += yoffset;
         g2d.drawString("Press up or down arrow to +/- zoomin/zoomout", 20, y);
         y += yoffset;
         g2d.drawString("Press p to pause/resume", 20, y);
         y += yoffset;
         g2d.drawString("Press Esc to exit", 20, y);
         for (int i=0; i<circleVector.size(); i++) {
              Circle circle = (Circle)circleVector.elementAt(i);
              circle.draw(g);
         }
         g2d.setColor(Color.RED);
         g2d.drawLine(1, 0, 1, screensize.height);
         g2d.setColor(oldColor);
         g2d.setFont(oldFont);
     }

     public void addCircles(int count) {
         for (int i=0; i<count; i++) {
              Circle circle = new Circle();
              circle.setColor(bColor);
              circleVector.add(circle);
         }
         repaint();
     }

     public void removeCircles(int count) {
         for (int i=0; i<count; i++) {
              circleVector.removeElementAt(0);
         }
         repaint();
     }

     public static void main (String [] args) {
         JFrame f = new JFrame();
         f.setUndecorated(true);
         f.setContentPane(new StarField());
         f.setLocation(screensize.width/2, 0);
         f.setSize(screensize.width/2, screensize.height);
         f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         f.setVisible(true);
     }
}

class Circle {
     private int cx;
     private int cy;
     private int radius = -1;
     private final int MIN_RADIUS = 5;
     private final int MAX_RADIUS = 26;
     public static int zoomLevel = 0;
     private Color fill;
     private Random rand = new Random();
     private int direction;
     private Color customColor = new Color(238, 154, 73);
     private static boolean b3dFlag = false;
     private static boolean bAntialias = false;

     public Circle() {
         int midwidth = StarField.screensize.width/2;
         int sx = midwidth/4;
         int sy = StarField.screensize.height/4;
         int wx = midwidth/2;
         int wy = StarField.screensize.height/2;
         cx = sx + (int)(Math.random() * wx);
         cy = sy + (int)(Math.random() * wy);
         if (zoomLevel != 0) {
             radius = zoomLevel;
         } else if (Math.random() * 10 < 5) {
             radius = 7;
         } else {
             radius = 9;
         }
         fill = Color.WHITE;
         direction = getDirection(cx, cy, sx, sy, wx, wy);
     }
     public void draw(Graphics g) {
         Graphics2D g2d = (Graphics2D)g;
         if (bAntialias) {
             g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
         } else {
             g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
         }
         Color oldColor = g2d.getColor();
         if(b3dFlag) {
            g2d.setColor(customColor);
            float [] dist = {0.0f, 0.3f, 0.5f, 0.7f, 1.0f};
            Color [] colors = {customColor, Color.WHITE, customColor, 
                               Color.WHITE, customColor};
            Point2D pt = new Point2D.Double(cx, cy);
            Point2D focusPt = new Point2D.Double(cx, cy);
            RadialGradientPaint gdPaint = new RadialGradientPaint(pt, radius, focusPt, dist, colors, MultipleGradientPaint.CycleMethod.REPEAT);
            //drawShadow(g2d);
            g2d.setPaint(gdPaint);
         } else {
            g2d.setColor(fill);
         }
         g2d.fillArc(cx, cy, radius, radius, 0, 360);
         g2d.setColor(oldColor);
     }

     public static void set3D(boolean bFlag) {
         b3dFlag = bFlag;
     }

     public static boolean is3D() {
         return b3dFlag;
     }

     public void drawShadow(Graphics g) {
         Graphics2D g2d = (Graphics2D)g;
         Color gray = new Color(50, 50, 50);
         g2d.setColor(gray);
         g2d.fillArc(cx+radius/3, cy+radius/2, radius, radius/2, 250, 180); //real
     }

     public void setColor(boolean bFlag) {
         if (!bFlag) {
             fill = Color.WHITE;
             return;
         }
         fill = new Color((float)Math.random(), (float)Math.random(), (float)Math.random());
     }
     public void setX(int x) {
        this.cx = x;
     }
     public void setY(int y) {
        this.cy = y;
     }
     public void setRadius(int r) {
        this.radius = r;
     }
     public int getRadius() {
        return radius;
     }
     public int increaseRadius(int r) {
        if (radius + r <= MAX_RADIUS) {
            radius += r;
        }
        return radius;
     }
     public int decreaseRadius(int r) {
        if (radius - r >= MIN_RADIUS) {
            radius -= r;
        }
        return radius;
     }
     public void setOffset(int sx, int sy) {
        cx += sx;
        cy += sy;
     }
     public int getDirection(int x, int y, int sx, int sy, int sw, int sh) {
        int midx = sx + sw/2;
        int midy = sy + sh/2;
        int v = rand.nextInt(10) % 3;
        if (x <= midx && y <= midy) { //1st Quadrant
            if (v == 0) {
                direction = 3;
            } else if (v == 1) {
                direction = 4;
            } else if (v == 2) {
                direction = 5;
            }
        } else if (x > midx && y <= midy) { //2nd Quadrant
            if (v == 0) {
                direction = 2;
            } else if (v == 1) {
                direction = 5;
            } else if (v == 2) {
                direction = 6;
            }
        } else if (x <= midx && y > midy) { //4th Quadrant
            if (v == 0) {
                direction = 1;
            } else if (v == 1) {
                direction = 4;
            } else if (v == 2) {
                direction = 7;
            }
        } else if (x > midx && y > midy) { //3rd Quadrant
            if (v == 0) {
                direction = 0;
            } else if (v == 1) {
                direction = 6;
            } else if (v == 2) {
                direction = 7;
            }
        }
        return direction;
     }
     public int getDirection() {
        return direction; 
     }

     public boolean resetCircle() {
        int midwidth = StarField.screensize.width/2;
        int sx = midwidth/4;
        int sy = StarField.screensize.height/4;
        int wx = midwidth/2;
        int wy = StarField.screensize.height/2;
        if ( !( cx <= 0 || cx >= midwidth ||
             cy <= 0 || cy >= StarField.screensize.height) ) {
            return false;
        }
        cx = sx + (int)(Math.random() * wx);
        cy = sy + (int)(Math.random() * wy);
        int val = (int)(Math.random() * 10);
        getDirection(cx, cy, sx, sy, wx, wy);
        if (radius != -1) {
            return true;
        }
        if (val <= 5) {
            setRadius(5);
        } else {
            setRadius(7);
        }
        return true;
     }

     public static void toggleAntialiasing() {
        bAntialias = !bAntialias;
     }
}