[jumptrooper]

Nothing sharpens those fine motor skills like some good-old arts and crafts action and, similarly, having fun messing around with Java is a great way to learn new things.

Here's the "challenge":

Below are two complete Java classes that, when run, paint a never-ending cascade of boxes down the screen ( Yay! ).
Your mission is to come up with some interesting modifications to it - or simply to use it as a model to come up with something completely different. Indulge your ego! Impress us!

...and, most importantly: Have Fun!

FallingBox class

Spoiler

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.util.Random;

import javax.swing.JComponent;


@SuppressWarnings("serial")
public class FallingBox extends JComponent{
	private Point xy;
	private Dimension widHt;
	private Color borderColor;
	private Color fillColor;
	private int speed;
	private boolean onScreen;
	private Container parent;
	private static Random rand = new Random();
	private final static int MAX_SPEED = 5;
	
	
	public FallingBox(Container p){
		parent = p;			
		onScreen = false;
	}
	
	public void initialize(){
		// this gives each box a unique set of characteristics
		speed = rand.nextInt(MAX_SPEED)+1;
		int colorShift;
		// this makes faster boxes brighter and slower boxes darker
		switch(speed){
		case 1:
			colorShift = 0; break;
		case 2:
			colorShift = 20; break;
		case 3: 
			colorShift = 40; break;
		case 4:
			colorShift = 60; break;
		case 5:
			colorShift = 80; break;
		default:
			colorShift = 100; break;
		
		}
		// define the box's dimensions
		widHt = new Dimension(rand.nextInt(200)+1,rand.nextInt(150)+1);
		
		// define the boxes starting position on the screen
		// -widHt.height for the y coordinate means the box starts just 
		// offscreen a bit and then moves into frame
		xy = new Point(rand.nextInt(parent.getWidth()),-widHt.height);
		
		// define the box's outline color
		borderColor = Color.red;
		
		// define the box's fill color
		fillColor = new Color(rand.nextInt(100)+colorShift,0,0);
		
		// now that it exists, make it visible
		onScreen = true;
	}
	
	
	public Graphics paintBox(Graphics g){
		g.setColor(fillColor);
		g.fillRect(xy.x, xy.y, widHt.width, widHt.height);
		g.setColor(borderColor);
		g.drawRect(xy.x, xy.y, widHt.width, widHt.height);
		if(onScreen)
			update();
		else
			initialize();
		return g;
	}
	
	public int getSpeed(){
		return speed;
	}
	
	
	private void update(){
		// the box isn't moving sideways - just down - so we only need 
		// to increment its y value to move it down the screen
		xy.y += speed;
		
		// if the box has moved beyond the edge of the screen
		// indicate that it's offscreen (which will cause it to
		// be re-initialized to the top of the screen)
		if(xy.y > parent.getHeight())
			onScreen = false;
	}
	
	public boolean isOnScreen(){
		return onScreen;
	}

	public static int getMaxSpeed(){
		return MAX_SPEED;
	}
}

BoxDropper class

Spoiler

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;

@SuppressWarnings("serial")
public class BoxDropper extends JPanel {
	private Timer animation;
	private BufferedImage offScrImg;
	private Graphics buffer;
	
	private final int NUM_BOXES = 500;
	private FallingBox[] arrayOfBoxes;
	private int currBox;
	private Container parent;
	
	public BoxDropper(Container p){
		// we pass in the container so we can know what it's dimensions are
		parent = p;
		this.setSize(parent.getSize());
		offScrImg = new BufferedImage(parent.getWidth(),parent.getHeight(),BufferedImage.TYPE_INT_RGB);
		buffer = offScrImg.createGraphics();

		// every 16 milliseconds we're going to call go()
		animation = new Timer(16, new ActionListener(){
			public void actionPerformed(ActionEvent e){
				go();
			}
		});
		currBox = 0;
		
		// Now that the container is set up and we defined what we're going
		// to do each time animation timer fires an event, lets fill
		// the arrayOfBoxes array with boxes!
		this.getBoxes();
	}
	
	private void go(){
		// repaint is what makes this animated
		repaint();
		
		// keep adding boxes until we reach the max
		// this is just so we don't start with all the boxes
		// ... I just think it looks better this way =)
		if(currBox < NUM_BOXES-1)
			currBox++;
		
		
		for(int i = 0; i < NUM_BOXES; i++){
			if(!arrayOfBoxes[i].isOnScreen()){
				arrayOfBoxes[i] = new FallingBox(this);
				arrayOfBoxes[i].initialize();
			}
		}
	}

	public void getBoxes(){
		arrayOfBoxes = new FallingBox[NUM_BOXES];
		for(int i = 0; i < arrayOfBoxes.length; i++){
			arrayOfBoxes[i] = new FallingBox(this);
			arrayOfBoxes[i].initialize();
		}
		// once we have all the boxes, let's start things up!
		animation.start();
	}
	
	public void paintComponent(Graphics g){
		super.paintComponent(g);  // call JPanels paintComponent method
		
		// paint the background black
		buffer.setColor(Color.black);
		buffer.fillRect(0, 0, this.getWidth(), this.getHeight());
		
		// draw each FallingBox from the array of boxes
		// begin with the slow ones so they are in the back
		// end with the fast ones so they are in front
		for(int s = 1; s <= FallingBox.getMaxSpeed(); s++){
			for(int i = 0; i <= currBox; i++){
				if(arrayOfBoxes[i].getSpeed() == s)
					// paint the box to the graphics context
					buffer = arrayOfBoxes[i].paintBox(buffer);
			}
		}
		
		// this just writes the number of boxes being displayed in the 
		// top left corner - it's optional
		buffer.setColor(Color.red);
		buffer.drawString(Integer.toString(currBox), 10, 10);
		
		// draw the off-screen image to the components graphics context
		// remember - buffer is the graphics context of offScrImg
		// that means we have to then paint offScrImg to the component
		g.drawImage(offScrImg, 0, 0, this);
	
	}
	
	
	
	public static void main(String[] args) {
		JFrame frame = new JFrame("Falling Boxes");
		Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
		frame.setSize(dim);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		BoxDropper bd = new BoxDropper(frame);
		frame.add(bd);
		frame.setVisible(true);
	}
}

[macosxnerd101]

I'll move this to Java Programmers so it doesn't fall off the page by the end of the night.

[jumptrooper]

macosxnerd101, on 16 February 2011 - 09:26 AM, said:

I'll move this to Java Programmers so it doesn't fall off the page by the end of the night.

Thanks

[shintetsu_80]

Since I'm fairly new to Java I thought I'd have a play with this. I added a little bit of linear velocity and scaling to the boxes. I also renamed my classes to be more descriptive of what it's doing.

Basically my additions cause the boxes to spawn from the center of the JFrame and scale in size as they move outwards toward the boundaries of the JFrame. My initiale thinking was to make it look as if you were traveling through a field of boxes in space. There's more configuration needed to fully achieve that effect but I started loosing intrest. Interesting enough for a short play though.

Spoiler

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;


public class StarFieldBoxGenerator extends JPanel {
    private Timer animation;
    private BufferedImage offScrImg;
    private Graphics buffer;

    private final int NUM_BOXES = 500;
    private StarFieldBox[] arrayOfBoxes;
    private int currBox;
    private Container parent;

    public StarFieldBoxGenerator(Container p){
        System.out.println("Star Field Box Generator");
        // we pass in the container so we can know what it's dimensions are
        parent = p;
        this.setSize(parent.getSize());
        offScrImg = new BufferedImage(parent.getWidth(),parent.getHeight(),BufferedImage.TYPE_INT_RGB);
        buffer = offScrImg.createGraphics();

        // every 16 milliseconds we're going to call go()
        animation = new Timer(16, new ActionListener(){
            public void actionPerformed(ActionEvent e){
                go();
            }
        });
        currBox = 0;

        // Now that the container is set up and we defined what we're going
        // to do each time animation timer fires an event, lets fill
        // the arrayOfBoxes array with boxes!
        this.getBoxes();
    }

    private void go(){
        // repaint is what makes this animated
        repaint();

        // keep adding boxes until we reach the max
        // this is just so we don't start with all the boxes
        // ... I just think it looks better this way =)
        if(currBox < NUM_BOXES-1)
            currBox++;


        for(int i = 0; i < NUM_BOXES; i++){
            if(!arrayOfBoxes[i].isOnScreen()){
                arrayOfBoxes[i] = new StarFieldBox(this);
                arrayOfBoxes[i].initialize();
            }
        }
    }

    public void getBoxes(){
        arrayOfBoxes = new StarFieldBox[NUM_BOXES];
        for(int i = 0; i < arrayOfBoxes.length; i++){
            arrayOfBoxes[i] = new StarFieldBox(this);
            arrayOfBoxes[i].initialize();
        }
        // once we have all the boxes, let's start things up!
        animation.start();
    }

    public void paintComponent(Graphics g){
        super.paintComponent(g);  // call JPanels paintComponent method

        // paint the background black
        buffer.setColor(Color.black);
        buffer.fillRect(0, 0, this.getWidth(), this.getHeight());

        // draw each FallingBox from the array of boxes
        // begin with the slow ones so they are in the back
        // end with the fast ones so they are in front
        for(int s = 1; s <= StarFieldBox.getMaxSpeed(); s++){
            for(int i = 0; i <= currBox; i++){
                if(arrayOfBoxes[i].getSpeed() == s)
                    // paint the box to the graphics context
                    buffer = arrayOfBoxes[i].paintBox(buffer);
            }
        }

        // this just writes the number of boxes being displayed in the
        // top left corner - it's optional
        buffer.setColor(Color.red);
        buffer.drawString(Integer.toString(currBox), 10, 10);

        // draw the off-screen image to the components graphics context
        // remember - buffer is the graphics context of offScrImg
        // that means we have to then paint offScrImg to the component
        g.drawImage(offScrImg, 0, 0, this);

    }


    public static void main(String[] args) {
        System.out.println("Testing StarFieldBoxGenerator");
        JFrame frame = new JFrame("Boxes");
        Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
        frame.setSize(dim);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        StarFieldBoxGenerator bg = new StarFieldBoxGenerator(frame);
        frame.add(bg);
        frame.setVisible(true);
    }
}

Spoiler

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.util.Random;
import java.lang.Math;

import javax.swing.JComponent;


public class StarFieldBox extends JComponent {
    private Point xy;
    private double vx, vy;
    private Dimension widHt;
    private int changeSizeCnt;
    private Color borderColor;
    private Color fillColor;
    private int speed;
    private boolean onScreen;
    private Container parent;
    private static Random rand = new Random();
    private final static int MAX_SPEED = 5;
    private final static int MAX_SPREAD = 100;

    public StarFieldBox(Container p){
        parent = p;
        onScreen = false;
        changeSizeCnt = 0;
    }

    public void initialize(){
        // this gives each box a unique set of characteristics
        speed = rand.nextInt(MAX_SPEED)+1;
        int colorShift;
        // this makes faster boxes brighter and slower boxes darker
        switch(speed){
        case 1:
            colorShift = 0; break;
        case 2:
            colorShift = 20; break;
        case 3:
            colorShift = 40; break;
        case 4:
            colorShift = 60; break;
        case 5:
            colorShift = 80; break;
        default:
            colorShift = 100; break;

        }
        // define the box's dimensions
        widHt = new Dimension(rand.nextInt(2)+1,rand.nextInt(1)+1);

        // define the boxes starting position on the screen
        int spread = MAX_SPREAD;
        double direction = rand.nextInt(360);
        double variation = ((rand.nextInt(spread)) % spread - spread/2) / 100.0f;
        double PI_DIV_180 = 3.1415926535 / 180.0f;
        double dir = direction;// - 90.0;
        vx = Math.cos( dir * PI_DIV_180) + variation;
        vy = Math.sin( dir * PI_DIV_180) + variation;
        double w = parent.getWidth();
        double h = parent.getHeight();
        xy = new Point((int)(w/2), (int)(h/2));

        // define the box's outline color
        borderColor = Color.red;

        // define the box's fill color
        fillColor = new Color(rand.nextInt(100)+colorShift,0,0);

        // now that it exists, make it visible
        onScreen = true;
    }


	public Graphics paintBox(Graphics g){
		g.setColor(fillColor);
		g.fillRect(xy.x, xy.y, widHt.width, widHt.height);
		g.setColor(borderColor);
		g.drawRect(xy.x, xy.y, widHt.width, widHt.height);
		if(onScreen)
			update();
		else
			initialize();
		return g;
	}

	public int getSpeed(){
		return speed;
	}


	private void update(){
		// the box isn't moving sideways - just down - so we only need
		// to increment its y value to move it down the screen
        xy.x += vx;
        xy.y += vy;

        if(changeSizeCnt > 5) {
            double sizeScale = 1.0f;
            double w = widHt.getWidth();
            double h = widHt.getHeight();
            double nW = w+sizeScale;
            double nH = h +sizeScale;
            widHt.setSize((double)nW, (double)nH);
            changeSizeCnt = 0;
        }
        changeSizeCnt++;
        
		// if the box has moved beyond the edge of the screen
		// indicate that it's offscreen (which will cause it to
		// be re-initialized
        if(xy.y >= parent.getHeight() || xy.y <= 0 ||
                xy.x >= parent.getWidth() || xy.x <= 0) {
			onScreen = false;
        }
	}

	public boolean isOnScreen(){
		return onScreen;
	}

	public static int getMaxSpeed(){
		return MAX_SPEED;
	}

}

[jumptrooper]

shintetsu_80, on 22 February 2011 - 03:03 PM, said:

Since I'm fairly new to Java I thought I'd have a play with this. I added a little bit of linear velocity and scaling to the boxes. I also renamed my classes to be more descriptive of what it's doing.

Basically my additions cause the boxes to spawn from the center of the JFrame and scale in size as they move outwards toward the boundaries of the JFrame. My initiale thinking was to make it look as if you were traveling through a field of boxes in space. There's more configuration needed to fully achieve that effect but I started loosing intrest. Interesting enough for a short play though.

Spoiler

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;


public class StarFieldBoxGenerator extends JPanel {
    private Timer animation;
    private BufferedImage offScrImg;
    private Graphics buffer;

    private final int NUM_BOXES = 500;
    private StarFieldBox[] arrayOfBoxes;
    private int currBox;
    private Container parent;

    public StarFieldBoxGenerator(Container p){
        System.out.println("Star Field Box Generator");
        // we pass in the container so we can know what it's dimensions are
        parent = p;
        this.setSize(parent.getSize());
        offScrImg = new BufferedImage(parent.getWidth(),parent.getHeight(),BufferedImage.TYPE_INT_RGB);
        buffer = offScrImg.createGraphics();

        // every 16 milliseconds we're going to call go()
        animation = new Timer(16, new ActionListener(){
            public void actionPerformed(ActionEvent e){
                go();
            }
        });
        currBox = 0;

        // Now that the container is set up and we defined what we're going
        // to do each time animation timer fires an event, lets fill
        // the arrayOfBoxes array with boxes!
        this.getBoxes();
    }

    private void go(){
        // repaint is what makes this animated
        repaint();

        // keep adding boxes until we reach the max
        // this is just so we don't start with all the boxes
        // ... I just think it looks better this way =)
        if(currBox < NUM_BOXES-1)
            currBox++;


        for(int i = 0; i < NUM_BOXES; i++){
            if(!arrayOfBoxes[i].isOnScreen()){
                arrayOfBoxes[i] = new StarFieldBox(this);
                arrayOfBoxes[i].initialize();
            }
        }
    }

    public void getBoxes(){
        arrayOfBoxes = new StarFieldBox[NUM_BOXES];
        for(int i = 0; i < arrayOfBoxes.length; i++){
            arrayOfBoxes[i] = new StarFieldBox(this);
            arrayOfBoxes[i].initialize();
        }
        // once we have all the boxes, let's start things up!
        animation.start();
    }

    public void paintComponent(Graphics g){
        super.paintComponent(g);  // call JPanels paintComponent method

        // paint the background black
        buffer.setColor(Color.black);
        buffer.fillRect(0, 0, this.getWidth(), this.getHeight());

        // draw each FallingBox from the array of boxes
        // begin with the slow ones so they are in the back
        // end with the fast ones so they are in front
        for(int s = 1; s <= StarFieldBox.getMaxSpeed(); s++){
            for(int i = 0; i <= currBox; i++){
                if(arrayOfBoxes[i].getSpeed() == s)
                    // paint the box to the graphics context
                    buffer = arrayOfBoxes[i].paintBox(buffer);
            }
        }

        // this just writes the number of boxes being displayed in the
        // top left corner - it's optional
        buffer.setColor(Color.red);
        buffer.drawString(Integer.toString(currBox), 10, 10);

        // draw the off-screen image to the components graphics context
        // remember - buffer is the graphics context of offScrImg
        // that means we have to then paint offScrImg to the component
        g.drawImage(offScrImg, 0, 0, this);

    }


    public static void main(String[] args) {
        System.out.println("Testing StarFieldBoxGenerator");
        JFrame frame = new JFrame("Boxes");
        Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
        frame.setSize(dim);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        StarFieldBoxGenerator bg = new StarFieldBoxGenerator(frame);
        frame.add(bg);
        frame.setVisible(true);
    }
}

Spoiler

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.util.Random;
import java.lang.Math;

import javax.swing.JComponent;


public class StarFieldBox extends JComponent {
    private Point xy;
    private double vx, vy;
    private Dimension widHt;
    private int changeSizeCnt;
    private Color borderColor;
    private Color fillColor;
    private int speed;
    private boolean onScreen;
    private Container parent;
    private static Random rand = new Random();
    private final static int MAX_SPEED = 5;
    private final static int MAX_SPREAD = 100;

    public StarFieldBox(Container p){
        parent = p;
        onScreen = false;
        changeSizeCnt = 0;
    }

    public void initialize(){
        // this gives each box a unique set of characteristics
        speed = rand.nextInt(MAX_SPEED)+1;
        int colorShift;
        // this makes faster boxes brighter and slower boxes darker
        switch(speed){
        case 1:
            colorShift = 0; break;
        case 2:
            colorShift = 20; break;
        case 3:
            colorShift = 40; break;
        case 4:
            colorShift = 60; break;
        case 5:
            colorShift = 80; break;
        default:
            colorShift = 100; break;

        }
        // define the box's dimensions
        widHt = new Dimension(rand.nextInt(2)+1,rand.nextInt(1)+1);

        // define the boxes starting position on the screen
        int spread = MAX_SPREAD;
        double direction = rand.nextInt(360);
        double variation = ((rand.nextInt(spread)) % spread - spread/2) / 100.0f;
        double PI_DIV_180 = 3.1415926535 / 180.0f;
        double dir = direction;// - 90.0;
        vx = Math.cos( dir * PI_DIV_180) + variation;
        vy = Math.sin( dir * PI_DIV_180) + variation;
        double w = parent.getWidth();
        double h = parent.getHeight();
        xy = new Point((int)(w/2), (int)(h/2));

        // define the box's outline color
        borderColor = Color.red;

        // define the box's fill color
        fillColor = new Color(rand.nextInt(100)+colorShift,0,0);

        // now that it exists, make it visible
        onScreen = true;
    }


	public Graphics paintBox(Graphics g){
		g.setColor(fillColor);
		g.fillRect(xy.x, xy.y, widHt.width, widHt.height);
		g.setColor(borderColor);
		g.drawRect(xy.x, xy.y, widHt.width, widHt.height);
		if(onScreen)
			update();
		else
			initialize();
		return g;
	}

	public int getSpeed(){
		return speed;
	}


	private void update(){
		// the box isn't moving sideways - just down - so we only need
		// to increment its y value to move it down the screen
        xy.x += vx;
        xy.y += vy;

        if(changeSizeCnt > 5) {
            double sizeScale = 1.0f;
            double w = widHt.getWidth();
            double h = widHt.getHeight();
            double nW = w+sizeScale;
            double nH = h +sizeScale;
            widHt.setSize((double)nW, (double)nH);
            changeSizeCnt = 0;
        }
        changeSizeCnt++;
        
		// if the box has moved beyond the edge of the screen
		// indicate that it's offscreen (which will cause it to
		// be re-initialized
        if(xy.y >= parent.getHeight() || xy.y <= 0 ||
                xy.x >= parent.getWidth() || xy.x <= 0) {
			onScreen = false;
        }
	}

	public boolean isOnScreen(){
		return onScreen;
	}

	public static int getMaxSpeed(){
		return MAX_SPEED;
	}

}

This is cool! Nice Job! I know what you mean about only being able to work on something like this for so long, though.
I have a thought: In order to get a better distribution of random directions the boxes move in, how about just maintaining two variables (xIncrement and yIncrement) and randomly assign each box with a value for each in the range of something like -5 to +5 (or whatever). So box "a" moves -5 in the x-axis and +3 in the y-axis every cycle, while box "b" moves +1 in the x-axis and +2 in the y-axis every cycle, and so on and so forth. Then, of course, as they keep moving, update their size according to their distance from their origin (I believe there is a method that calculates the distance between two Points in the Point class or somewhere...)

[shintetsu_80]

jumptrooper, on 22 February 2011 - 05:09 PM, said:

shintetsu_80, on 22 February 2011 - 03:03 PM, said:

Since I'm fairly new to Java I thought I'd have a play with this. I added a little bit of linear velocity and scaling to the boxes. I also renamed my classes to be more descriptive of what it's doing.

Basically my additions cause the boxes to spawn from the center of the JFrame and scale in size as they move outwards toward the boundaries of the JFrame. My initiale thinking was to make it look as if you were traveling through a field of boxes in space. There's more configuration needed to fully achieve that effect but I started loosing intrest. Interesting enough for a short play though.

Spoiler

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;


public class StarFieldBoxGenerator extends JPanel {
    private Timer animation;
    private BufferedImage offScrImg;
    private Graphics buffer;

    private final int NUM_BOXES = 500;
    private StarFieldBox[] arrayOfBoxes;
    private int currBox;
    private Container parent;

    public StarFieldBoxGenerator(Container p){
        System.out.println("Star Field Box Generator");
        // we pass in the container so we can know what it's dimensions are
        parent = p;
        this.setSize(parent.getSize());
        offScrImg = new BufferedImage(parent.getWidth(),parent.getHeight(),BufferedImage.TYPE_INT_RGB);
        buffer = offScrImg.createGraphics();

        // every 16 milliseconds we're going to call go()
        animation = new Timer(16, new ActionListener(){
            public void actionPerformed(ActionEvent e){
                go();
            }
        });
        currBox = 0;

        // Now that the container is set up and we defined what we're going
        // to do each time animation timer fires an event, lets fill
        // the arrayOfBoxes array with boxes!
        this.getBoxes();
    }

    private void go(){
        // repaint is what makes this animated
        repaint();

        // keep adding boxes until we reach the max
        // this is just so we don't start with all the boxes
        // ... I just think it looks better this way =)
        if(currBox < NUM_BOXES-1)
            currBox++;


        for(int i = 0; i < NUM_BOXES; i++){
            if(!arrayOfBoxes[i].isOnScreen()){
                arrayOfBoxes[i] = new StarFieldBox(this);
                arrayOfBoxes[i].initialize();
            }
        }
    }

    public void getBoxes(){
        arrayOfBoxes = new StarFieldBox[NUM_BOXES];
        for(int i = 0; i < arrayOfBoxes.length; i++){
            arrayOfBoxes[i] = new StarFieldBox(this);
            arrayOfBoxes[i].initialize();
        }
        // once we have all the boxes, let's start things up!
        animation.start();
    }

    public void paintComponent(Graphics g){
        super.paintComponent(g);  // call JPanels paintComponent method

        // paint the background black
        buffer.setColor(Color.black);
        buffer.fillRect(0, 0, this.getWidth(), this.getHeight());

        // draw each FallingBox from the array of boxes
        // begin with the slow ones so they are in the back
        // end with the fast ones so they are in front
        for(int s = 1; s <= StarFieldBox.getMaxSpeed(); s++){
            for(int i = 0; i <= currBox; i++){
                if(arrayOfBoxes[i].getSpeed() == s)
                    // paint the box to the graphics context
                    buffer = arrayOfBoxes[i].paintBox(buffer);
            }
        }

        // this just writes the number of boxes being displayed in the
        // top left corner - it's optional
        buffer.setColor(Color.red);
        buffer.drawString(Integer.toString(currBox), 10, 10);

        // draw the off-screen image to the components graphics context
        // remember - buffer is the graphics context of offScrImg
        // that means we have to then paint offScrImg to the component
        g.drawImage(offScrImg, 0, 0, this);

    }


    public static void main(String[] args) {
        System.out.println("Testing StarFieldBoxGenerator");
        JFrame frame = new JFrame("Boxes");
        Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
        frame.setSize(dim);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        StarFieldBoxGenerator bg = new StarFieldBoxGenerator(frame);
        frame.add(bg);
        frame.setVisible(true);
    }
}

Spoiler

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.util.Random;
import java.lang.Math;

import javax.swing.JComponent;


public class StarFieldBox extends JComponent {
    private Point xy;
    private double vx, vy;
    private Dimension widHt;
    private int changeSizeCnt;
    private Color borderColor;
    private Color fillColor;
    private int speed;
    private boolean onScreen;
    private Container parent;
    private static Random rand = new Random();
    private final static int MAX_SPEED = 5;
    private final static int MAX_SPREAD = 100;

    public StarFieldBox(Container p){
        parent = p;
        onScreen = false;
        changeSizeCnt = 0;
    }

    public void initialize(){
        // this gives each box a unique set of characteristics
        speed = rand.nextInt(MAX_SPEED)+1;
        int colorShift;
        // this makes faster boxes brighter and slower boxes darker
        switch(speed){
        case 1:
            colorShift = 0; break;
        case 2:
            colorShift = 20; break;
        case 3:
            colorShift = 40; break;
        case 4:
            colorShift = 60; break;
        case 5:
            colorShift = 80; break;
        default:
            colorShift = 100; break;

        }
        // define the box's dimensions
        widHt = new Dimension(rand.nextInt(2)+1,rand.nextInt(1)+1);

        // define the boxes starting position on the screen
        int spread = MAX_SPREAD;
        double direction = rand.nextInt(360);
        double variation = ((rand.nextInt(spread)) % spread - spread/2) / 100.0f;
        double PI_DIV_180 = 3.1415926535 / 180.0f;
        double dir = direction;// - 90.0;
        vx = Math.cos( dir * PI_DIV_180) + variation;
        vy = Math.sin( dir * PI_DIV_180) + variation;
        double w = parent.getWidth();
        double h = parent.getHeight();
        xy = new Point((int)(w/2), (int)(h/2));

        // define the box's outline color
        borderColor = Color.red;

        // define the box's fill color
        fillColor = new Color(rand.nextInt(100)+colorShift,0,0);

        // now that it exists, make it visible
        onScreen = true;
    }


	public Graphics paintBox(Graphics g){
		g.setColor(fillColor);
		g.fillRect(xy.x, xy.y, widHt.width, widHt.height);
		g.setColor(borderColor);
		g.drawRect(xy.x, xy.y, widHt.width, widHt.height);
		if(onScreen)
			update();
		else
			initialize();
		return g;
	}

	public int getSpeed(){
		return speed;
	}


	private void update(){
		// the box isn't moving sideways - just down - so we only need
		// to increment its y value to move it down the screen
        xy.x += vx;
        xy.y += vy;

        if(changeSizeCnt > 5) {
            double sizeScale = 1.0f;
            double w = widHt.getWidth();
            double h = widHt.getHeight();
            double nW = w+sizeScale;
            double nH = h +sizeScale;
            widHt.setSize((double)nW, (double)nH);
            changeSizeCnt = 0;
        }
        changeSizeCnt++;
        
		// if the box has moved beyond the edge of the screen
		// indicate that it's offscreen (which will cause it to
		// be re-initialized
        if(xy.y >= parent.getHeight() || xy.y <= 0 ||
                xy.x >= parent.getWidth() || xy.x <= 0) {
			onScreen = false;
        }
	}

	public boolean isOnScreen(){
		return onScreen;
	}

	public static int getMaxSpeed(){
		return MAX_SPEED;
	}

}

This is cool! Nice Job! I know what you mean about only being able to work on something like this for so long, though.
I have a thought: In order to get a better distribution of random directions the boxes move in, how about just maintaining two variables (xIncrement and yIncrement) and randomly assign each box with a value for each in the range of something like -5 to +5 (or whatever). So box "a" moves -5 in the x-axis and +3 in the y-axis every cycle, while box "b" moves +1 in the x-axis and +2 in the y-axis every cycle, and so on and so forth. Then, of course, as they keep moving, update their size according to their distance from their origin (I believe there is a method that calculates the distance between two Points in the Point class or somewhere...)

I noticed the distribution was lacking. I know in C++ you can get not so random numbers from your rand function and I figured I was seeing the same thing here. After looking at some code I have for particle emitters I might have clipped it myself. I'll have a look at this a little later.

[shintetsu_80]

Well it turns out that I was messing up my linear algebra a bit. Here's my updated code which produces a much better effect. You can get drastic changes in the effect by changing the configuration parameters in the StarFieldBox code. There's still some artifacts with sizing but it looks much better than before.

@jumptropper thanks for the idea on sizing in relation to source position I added that into this code.

StarFieldBoxGenerator:

Spoiler

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;


public class StarFieldBoxGenerator extends JPanel {
    private Timer animation;
    private BufferedImage offScrImg;
    private Graphics buffer;

    private final int NUM_BOXES = 500;
    private StarFieldBox[] arrayOfBoxes;
    private int currBox;
    private Container parent;

    public StarFieldBoxGenerator(Container p){
        System.out.println("Star Field Box Generator");
        // we pass in the container so we can know what it's dimensions are
        parent = p;
        this.setSize(parent.getSize());
        offScrImg = new BufferedImage(parent.getWidth(),parent.getHeight(),BufferedImage.TYPE_INT_RGB);
        buffer = offScrImg.createGraphics();

        // every 16 milliseconds we're going to call go()
        animation = new Timer(16, new ActionListener(){
            public void actionPerformed(ActionEvent e){
                go();
            }
        });
        currBox = 0;

        // Now that the container is set up and we defined what we're going
        // to do each time animation timer fires an event, lets fill
        // the arrayOfBoxes array with boxes!
        this.getBoxes();
    }

    private void go(){
        // repaint is what makes this animated
        repaint();

        // keep adding boxes until we reach the max
        // this is just so we don't start with all the boxes
        // ... I just think it looks better this way =)
        if(currBox < NUM_BOXES-1)
            currBox++;


        for(int i = 0; i < NUM_BOXES; i++){
            if(!arrayOfBoxes[i].isOnScreen()){
                arrayOfBoxes[i] = new StarFieldBox(this);
                arrayOfBoxes[i].initialize();
            }
        }
    }

    public void getBoxes(){
        arrayOfBoxes = new StarFieldBox[NUM_BOXES];
        for(int i = 0; i < arrayOfBoxes.length; i++){
            arrayOfBoxes[i] = new StarFieldBox(this);
            arrayOfBoxes[i].initialize();
        }
        // once we have all the boxes, let's start things up!
        animation.start();
    }

    public void paintComponent(Graphics g){
        super.paintComponent(g);  // call JPanels paintComponent method

        // paint the background black
        buffer.setColor(Color.black);
        buffer.fillRect(0, 0, this.getWidth(), this.getHeight());

        // draw each FallingBox from the array of boxes
        // begin with the slow ones so they are in the back
        // end with the fast ones so they are in front
        for(int s = 1; s <= StarFieldBox.getMaxSpeed(); s++){
            for(int i = 0; i <= currBox; i++){
                if(arrayOfBoxes[i].getSpeed() == s)
                    // paint the box to the graphics context
                    buffer = arrayOfBoxes[i].paintBox(buffer);
            }
        }

        // this just writes the number of boxes being displayed in the
        // top left corner - it's optional
        buffer.setColor(Color.red);
        buffer.drawString(Integer.toString(currBox), 10, 10);

        // draw the off-screen image to the components graphics context
        // remember - buffer is the graphics context of offScrImg
        // that means we have to then paint offScrImg to the component
        g.drawImage(offScrImg, 0, 0, this);

    }


    public static void main(String[] args) {
        System.out.println("Testing StarFieldBoxGenerator");
        JFrame frame = new JFrame("Star Field of Boxes");
        Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
        frame.setSize(dim);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        StarFieldBoxGenerator bd = new StarFieldBoxGenerator(frame);
        frame.add(bd);
        frame.setVisible(true);
    }
}

StarFieldBox:

Spoiler

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.util.Random;

import javax.swing.JComponent;

public class StarFieldBox extends JComponent {
    private Point xy, sourcePos;
    private double dirX, dirY;
    private Dimension widHt;
    private Color borderColor;
    private Color fillColor;
    private double speed;
    private boolean onScreen;
    private Container parent;
    private static Random rand = new Random();
    private final static double PI_DIV_180 = 3.1415926535 / 180.0f;
    
    // -- These are the configuration parameters
    private final static int MAX_WIDTH = 2;
    private final static int MAX_HEIGHT = 1;
    private final static int RESIZE_DISTANCE = 25;
    private final static int MAX_SPEED = 5;
    private final static int SPEED_VARIANCE = 0;
    private final static int ANGLE = 0;
    private final static int ANGLE_VARIANCE = 360;
    private final static int POSITION_VARIANCE = 10;

    public StarFieldBox(Container p){
        parent = p;
        onScreen = false;
    }

    public double randomMinus1to1() {
        return (2*rand.nextFloat()) + (-1);
    }

    public double degreeToRadians(double degree) {
        return degree * PI_DIV_180;
    }

    public void initialize(){
        // this gives each box a unique set of characteristics
        speed = rand.nextDouble()*MAX_SPEED+1;
        int colorShift;
        // this makes faster boxes brighter and slower boxes darker
        switch((int)speed){
        case 1:
            colorShift = 0; break;
        case 2:
            colorShift = 20; break;
        case 3:
            colorShift = 40; break;
        case 4:
            colorShift = 60; break;
        case 5:
            colorShift = 80; break;
        default:
            colorShift = 100; break;

        }
        // define the box's dimensions (size)
        widHt = new Dimension(rand.nextInt(MAX_WIDTH)+1,rand.nextInt(MAX_HEIGHT)+1);

        // -- start the box in the middle of the screen with some variance applied
        double startPosX = (double)parent.getWidth()/2 + POSITION_VARIANCE * randomMinus1to1();
        double startPosY = (double)parent.getHeight()/2 + POSITION_VARIANCE * randomMinus1to1();
        sourcePos = new Point((int)startPosX, (int)startPosY);
        xy = new Point((int)startPosX, (int)startPosY);
        
        // -- angle between 0 and 360
        double newAngle = degreeToRadians(ANGLE + ANGLE_VARIANCE * randomMinus1to1());
        // -- x vector component
        double vx = Math.cos(newAngle);
        // -- y vector component
        double vy = Math.sin(newAngle);
        // -- speed we want the box to move
        double newSpeed = speed + SPEED_VARIANCE * randomMinus1to1();
        // -- direction we will move our box on the X axis with the speed applied
        dirX = vx*newSpeed;
        // -- direction we will move our box on the Y axis with the speed applied
        dirY = vy*newSpeed;

        //System.out.printf("vx %f vy %f ", vx, vy);
        //System.out.printf("xy.x %d xy.y %d\n", xy.x, xy.y);

        // define the box's outline color
        borderColor = Color.red;

        // define the box's fill color
        fillColor = new Color(rand.nextInt(100)+colorShift,0,0);

        // now that it exists, make it visible
        onScreen = true;
    }


	public Graphics paintBox(Graphics g){
		g.setColor(fillColor);
		g.fillRect(xy.x, xy.y, widHt.width, widHt.height);
		g.setColor(borderColor);
		g.drawRect(xy.x, xy.y, widHt.width, widHt.height);
		if(onScreen)
			update();
		else
			initialize();
		return g;
	}

	public int getSpeed(){
		return (int)speed;
	}


	private void update(){
		// the box isn't moving sideways - just down - so we only need
		// to increment its y value to move it down the screen
        xy.x += dirX;
        xy.y += dirY;

        double distance = sourcePos.distance(xy);
        if(distance % RESIZE_DISTANCE == 0 && distance > RESIZE_DISTANCE) {
            double sizeScale = 1.0f;
            double w = widHt.getWidth();
            double h = widHt.getHeight();
            double nW = w+sizeScale;
            double nH = h +sizeScale;
            widHt.setSize((double)nW, (double)nH);
        }
        
		// if the box has moved beyond the edge of the screen
		// indicate that it's offscreen (which will cause it to
		// be re-initialized)
        if(xy.y >= parent.getHeight() || xy.y <= 0 ||
                xy.x >= parent.getWidth() || xy.x <= 0) {
			onScreen = false;
        }
	}

	public boolean isOnScreen(){
		return onScreen;
	}

	public static int getMaxSpeed(){
		return MAX_SPEED;
	}

}

[shintetsu_80]

I came up with another box system that looks pretty cool. Also since I was doing this stuff as a learning exercise I decided to apply some of the design pattern ideas to the code that I've been studying lately.

There's two basic classes a BoxObject class that is an abstract class that any new BoxObject class should inherit from. The next is the BoxObjectGenerator class that knows how to draw BoxObjects.

Now anyone in the future that want's to play with this code only has to create a new BoxObject subclass and tell the BoxObjectGenerator in it's main method to draw that BoxObject subclass. Like so:

        // this will cause BoxObjectGenerator to draw StarFieldBox objects
        BoxObjectGenerator bd = new BoxObjectGenerator(frame, StarFieldBox.class);
        
        // this will cause BoxObjectGenerator to draw RotatingBox objects
        BoxObjectGenerator bd = new BoxObjectGenerator(frame, RotatingBox.class);

So here's my files BoxObject, BoxObjectGenerator, StarFieldBox (that draws a star field of boxes based on the configuration parameters), and RotatingBox (which should be renamed but still produces a cool effect). If someone noticies problems in my design then let me know so I don't keep doing something that's wrong.

Spoiler

[code]
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;

import javax.swing.JComponent;


public abstract class BoxObject extends JComponent {
protected Point xy;
protected Dimension widHt;
protected boolean onScreen;
protected Container parent;
protected Color borderColor;
protected Color fillColor;

protected double speed;
protected final static int MAX_SPEED = 5;


public BoxObject(Container p){
parent = p;
onScreen = false;
}

public abstract void initialize();

protected abstract void update();

public boolean isOnScreen(){
return onScreen;
}

public static int getMaxSpeed(){
return MAX_SPEED;
}

public int getSpeed(){
return (int)speed;
}

public Graphics paintBox(Graphics g){
g.setColor(fillColor);
g.fillRect(xy.x, xy.y, widHt.width, widHt.height);
g.setColor(borderColor);
g.drawRect(xy.x, xy.y, widHt.width, widHt.height);
if(onScreen)
update();
else
initialize();
return g;
}
}

[/hide]

Spoiler

[code]
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.lang.reflect.Constructor;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;


public class BoxObjectGenerator extends JPanel {
private Timer animation;
private BufferedImage offScrImg;
private Graphics buffer;
private Class<? extends BoxObject> boxObject;

private final int NUM_BOXES = 500;
private BoxObject[] arrayOfBoxes;
private int currBox;
private Container parent;

public BoxObjectGenerator(Container p, Class<? extends BoxObject> boxObj){
System.out.println("Box Object Generator");
boxObject = boxObj;
// we pass in the container so we can know what it's dimensions are
parent = p;
this.setSize(parent.getSize());
offScrImg = new BufferedImage(parent.getWidth(),parent.getHeight(),BufferedImage.TYPE_INT_RGB);
buffer = offScrImg.createGraphics();

// every 16 milliseconds we're going to call go()
animation = new Timer(16, new ActionListener(){
public void actionPerformed(ActionEvent e){
go();
}
});
currBox = 0;

// Now that the container is set up and we defined what we're going
// to do each time animation timer fires an event, lets fill
// the arrayOfBoxes array with boxes!
this.getBoxes();
}

private void go(){
// repaint is what makes this animated
repaint();

// keep adding boxes until we reach the max
// this is just so we don't start with all the boxes
// ... I just think it looks better this way =)
if(currBox < NUM_BOXES-1)
currBox++;


for(int i = 0; i < NUM_BOXES; i++){
if(!arrayOfBoxes[i].isOnScreen()){
try{
Constructor cons = boxObject.getConstructor(Container.class);
arrayOfBoxes[i] = (BoxObject) cons.newInstance(parent);
//arrayOfBoxes[i] = boxObject.newInstance();
arrayOfBoxes[i].initialize();
}
catch(Exception x){
System.out.println(x + "\nFailed to intantiate a new BoxObject");
System.exit(1);
}
}
}
}

private void getBoxes(){
arrayOfBoxes = new BoxObject[NUM_BOXES];
for(int i = 0; i < arrayOfBoxes.length; i++){
try{
Constructor cons = boxObject.getConstructor(Container.class);
arrayOfBoxes[i] = (BoxObject) cons.newInstance(parent);
//arrayOfBoxes[i] = boxObject.newInstance();
arrayOfBoxes[i].initialize();
}
catch(Exception x){
System.out.println(x + "\nFailed to intantiate a new BoxObject");
System.exit(1);
}
}
// once we have all the boxes, let's start things up!
animation.start();
}

@Override
public void paintComponent(Graphics g){
super.paintComponent(g); // call JPanels paintComponent method

// paint the background black
buffer.setColor(Color.black);
buffer.fillRect(0, 0, this.getWidth(), this.getHeight());

// draw each FallingBox from the array of boxes
// begin with the slow ones so they are in the back
// end with the fast ones so they are in front
for(int s = 1; s <= BoxObject.getMaxSpeed(); s++){
for(int i = 0; i <= currBox; i++){
if(arrayOfBoxes[i].getSpeed() == s)
// paint the box to the graphics context
buffer = arrayOfBoxes[i].paintBox(buffer);
}
}

// this just writes the number of boxes being displayed in the
// top left corner - it's optional
buffer.setColor(Color.red);
buffer.drawString(Integer.toString(currBox), 10, 10);

// draw the off-screen image to the components graphics context
// remember - buffer is the graphics context of offScrImg
// that means we have to then paint offScrImg to the component
g.drawImage(offScrImg, 0, 0, this);

}


public static void main(String[] args) {
System.out.println("Testing BoxObjectGenerator");
JFrame frame = new JFrame("Box Object Generator");
Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
frame.setSize(dim);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//BoxObjectGenerator bd = new BoxObjectGenerator(frame, StarFieldBox.class);
BoxObjectGenerator bd = new BoxObjectGenerator(frame, RotatingBox.class);
frame.add(bd);
frame.setVisible(true);
}
}

[/hide]

Spoiler

[code]
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Point;
import java.util.Random;


public class StarFieldBox extends BoxObject {

private Point sourcePos;
private double dirX, dirY;

private static Random rand = new Random();
private final static double PI_DIV_180 = 3.1415926535 / 180.0f;

// -- These are the configuration parameters
private final static int MAX_WIDTH = 2;
private final static int MAX_HEIGHT = 1;
private final static int RESIZE_DISTANCE = 25;
private final static int SPEED_VARIANCE = 0;
private final static int ANGLE = 0;
private final static int ANGLE_VARIANCE = 360;
private final static int POSITION_VARIANCE = 10;

public StarFieldBox(java.awt.Container p) {
super(p);
}

public double randomMinus1to1() {
return (2*rand.nextFloat()) + (-1);
}

public double degreeToRadians(double degree) {
return degree * PI_DIV_180;
}

public void initialize() {
// this gives each box a unique speed
speed = rand.nextDouble()*MAX_SPEED+1;

// define the box's dimensions (size)
widHt = new Dimension(rand.nextInt(MAX_WIDTH)+1,rand.nextInt(MAX_HEIGHT)+1);

// -- start the box in the middle of the screen with some variance applied
double startPosX = (double)parent.getWidth()/2 + POSITION_VARIANCE * randomMinus1to1();
double startPosY = (double)parent.getHeight()/2 + POSITION_VARIANCE * randomMinus1to1();
sourcePos = new Point((int)startPosX, (int)startPosY);
xy = new Point((int)startPosX, (int)startPosY);

// -- angle between 0 and 360
double newAngle = degreeToRadians(ANGLE + ANGLE_VARIANCE * randomMinus1to1());
// -- x vector component
double vx = Math.cos(newAngle);
// -- y vector component
double vy = Math.sin(newAngle);
// -- speed we want the box to move
double newSpeed = speed + SPEED_VARIANCE * randomMinus1to1();
// -- direction we will move our box on the X axis with the speed applied
dirX = vx*newSpeed;
// -- direction we will move our box on the Y axis with the speed applied
dirY = vy*newSpeed;

//System.out.printf("newSpeed %d\n", (int)newSpeed);
//System.out.printf("vx %f vy %f ", vx, vy);
//System.out.printf("xy.x %d xy.y %d\n", xy.x, xy.y);

// define the box's outline color
borderColor = Color.red;

int colorShift;
// this makes faster boxes brighter and slower boxes darker
switch((int)newSpeed){
case 1:
colorShift = 0; break;
case 2:
colorShift = 20; break;
case 3:
colorShift = 40; break;
case 4:
colorShift = 60; break;
case 5:
colorShift = 80; break;
default:
colorShift = 100; break;

}
// define the box's fill color
fillColor = new Color(rand.nextInt(100)+colorShift,0,0);

// now that it exists, make it visible
onScreen = true;
}

public void update() {
// update x and y position
xy.x += dirX;
xy.y += dirY;

double distance = sourcePos.distance(xy);
if(distance % RESIZE_DISTANCE == 0 && distance > RESIZE_DISTANCE) {
double sizeScale = 1.0f;
double w = widHt.getWidth();
double h = widHt.getHeight();
double nW = w+sizeScale;
double nH = h +sizeScale;
widHt.setSize((double)nW, (double)nH);
}

// if the box has moved beyond the edge of the screen
// indicate that it's offscreen (which will cause it to
// be re-initialized)
if(xy.y >= parent.getHeight() || xy.y <= 0 ||
xy.x >= parent.getWidth() || xy.x <= 0) {
onScreen = false;
}
}

}

[/hide]

Spoiler

[code]
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Point;
import java.util.Random;

public class RotatingBox extends BoxObject {
private double dirX, dirY;
private double angle;

private static Random rand = new Random();

private final static double PI_DIV_180 = 3.1415926535 / 180.0f;
private final static int MAX_WIDTH = 20;
private final static int MAX_HEIGHT = 10;
private final static int RADIUS = 10;

public RotatingBox(java.awt.Container p) {
super(p);
speed = 1;
}

public double degreeToRadians(double degree) {
return degree * PI_DIV_180;
}

public void initialize() {
// define the box's dimensions (size)
widHt = new Dimension(rand.nextInt(MAX_WIDTH)+1,rand.nextInt(MAX_HEIGHT)+1);

// -- start the box in the middle of the screen with some variance applied
double startPosX = (double)parent.getWidth()/2 + RADIUS;
double startPosY = (double)parent.getHeight()/2;
xy = new Point((int)startPosX, (int)startPosY);
angle = rand.nextInt(360);

// define the box's outline color
borderColor = Color.red;

// define the box's fill color
fillColor = new Color(rand.nextInt(100),0,0);

// now that it exists, make it visible
onScreen = true;
}

public void updateToAngle(double angle){
dirX = Math.cos(degreeToRadians(angle))*RADIUS;
dirY = Math.sin(degreeToRadians(angle))*RADIUS;
}

public void update() {
// the box isn't moving sideways - just down - so we only need
// to increment its y value to move it down the screen
angle++;
if (angle >= 360) {angle = 0;}


updateToAngle(angle);
xy.x += dirX;
xy.y += dirY;

}

}

[/hide]

This post has been edited by shintetsu_80: 24 February 2011 - 02:19 PM

[jumptrooper]

shintetsu_80, on 23 February 2011 - 01:07 PM, said:

Well it turns out that I was messing up my linear algebra a bit. Here's my updated code which produces a much better effect. You can get drastic changes in the effect by changing the configuration parameters in the StarFieldBox code. There's still some artifacts with sizing but it looks much better than before.

@jumptropper thanks for the idea on sizing in relation to source position I added that into this code.

StarFieldBoxGenerator:

Spoiler

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;


public class StarFieldBoxGenerator extends JPanel {
    private Timer animation;
    private BufferedImage offScrImg;
    private Graphics buffer;

    private final int NUM_BOXES = 500;
    private StarFieldBox[] arrayOfBoxes;
    private int currBox;
    private Container parent;

    public StarFieldBoxGenerator(Container p){
        System.out.println("Star Field Box Generator");
        // we pass in the container so we can know what it's dimensions are
        parent = p;
        this.setSize(parent.getSize());
        offScrImg = new BufferedImage(parent.getWidth(),parent.getHeight(),BufferedImage.TYPE_INT_RGB);
        buffer = offScrImg.createGraphics();

        // every 16 milliseconds we're going to call go()
        animation = new Timer(16, new ActionListener(){
            public void actionPerformed(ActionEvent e){
                go();
            }
        });
        currBox = 0;

        // Now that the container is set up and we defined what we're going
        // to do each time animation timer fires an event, lets fill
        // the arrayOfBoxes array with boxes!
        this.getBoxes();
    }

    private void go(){
        // repaint is what makes this animated
        repaint();

        // keep adding boxes until we reach the max
        // this is just so we don't start with all the boxes
        // ... I just think it looks better this way =)
        if(currBox < NUM_BOXES-1)
            currBox++;


        for(int i = 0; i < NUM_BOXES; i++){
            if(!arrayOfBoxes[i].isOnScreen()){
                arrayOfBoxes[i] = new StarFieldBox(this);
                arrayOfBoxes[i].initialize();
            }
        }
    }

    public void getBoxes(){
        arrayOfBoxes = new StarFieldBox[NUM_BOXES];
        for(int i = 0; i < arrayOfBoxes.length; i++){
            arrayOfBoxes[i] = new StarFieldBox(this);
            arrayOfBoxes[i].initialize();
        }
        // once we have all the boxes, let's start things up!
        animation.start();
    }

    public void paintComponent(Graphics g){
        super.paintComponent(g);  // call JPanels paintComponent method

        // paint the background black
        buffer.setColor(Color.black);
        buffer.fillRect(0, 0, this.getWidth(), this.getHeight());

        // draw each FallingBox from the array of boxes
        // begin with the slow ones so they are in the back
        // end with the fast ones so they are in front
        for(int s = 1; s <= StarFieldBox.getMaxSpeed(); s++){
            for(int i = 0; i <= currBox; i++){
                if(arrayOfBoxes[i].getSpeed() == s)
                    // paint the box to the graphics context
                    buffer = arrayOfBoxes[i].paintBox(buffer);
            }
        }

        // this just writes the number of boxes being displayed in the
        // top left corner - it's optional
        buffer.setColor(Color.red);
        buffer.drawString(Integer.toString(currBox), 10, 10);

        // draw the off-screen image to the components graphics context
        // remember - buffer is the graphics context of offScrImg
        // that means we have to then paint offScrImg to the component
        g.drawImage(offScrImg, 0, 0, this);

    }


    public static void main(String[] args) {
        System.out.println("Testing StarFieldBoxGenerator");
        JFrame frame = new JFrame("Star Field of Boxes");
        Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
        frame.setSize(dim);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        StarFieldBoxGenerator bd = new StarFieldBoxGenerator(frame);
        frame.add(bd);
        frame.setVisible(true);
    }
}

StarFieldBox:

Spoiler

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.util.Random;

import javax.swing.JComponent;

public class StarFieldBox extends JComponent {
    private Point xy, sourcePos;
    private double dirX, dirY;
    private Dimension widHt;
    private Color borderColor;
    private Color fillColor;
    private double speed;
    private boolean onScreen;
    private Container parent;
    private static Random rand = new Random();
    private final static double PI_DIV_180 = 3.1415926535 / 180.0f;
    
    // -- These are the configuration parameters
    private final static int MAX_WIDTH = 2;
    private final static int MAX_HEIGHT = 1;
    private final static int RESIZE_DISTANCE = 25;
    private final static int MAX_SPEED = 5;
    private final static int SPEED_VARIANCE = 0;
    private final static int ANGLE = 0;
    private final static int ANGLE_VARIANCE = 360;
    private final static int POSITION_VARIANCE = 10;

    public StarFieldBox(Container p){
        parent = p;
        onScreen = false;
    }

    public double randomMinus1to1() {
        return (2*rand.nextFloat()) + (-1);
    }

    public double degreeToRadians(double degree) {
        return degree * PI_DIV_180;
    }

    public void initialize(){
        // this gives each box a unique set of characteristics
        speed = rand.nextDouble()*MAX_SPEED+1;
        int colorShift;
        // this makes faster boxes brighter and slower boxes darker
        switch((int)speed){
        case 1:
            colorShift = 0; break;
        case 2:
            colorShift = 20; break;
        case 3:
            colorShift = 40; break;
        case 4:
            colorShift = 60; break;
        case 5:
            colorShift = 80; break;
        default:
            colorShift = 100; break;

        }
        // define the box's dimensions (size)
        widHt = new Dimension(rand.nextInt(MAX_WIDTH)+1,rand.nextInt(MAX_HEIGHT)+1);

        // -- start the box in the middle of the screen with some variance applied
        double startPosX = (double)parent.getWidth()/2 + POSITION_VARIANCE * randomMinus1to1();
        double startPosY = (double)parent.getHeight()/2 + POSITION_VARIANCE * randomMinus1to1();
        sourcePos = new Point((int)startPosX, (int)startPosY);
        xy = new Point((int)startPosX, (int)startPosY);
        
        // -- angle between 0 and 360
        double newAngle = degreeToRadians(ANGLE + ANGLE_VARIANCE * randomMinus1to1());
        // -- x vector component
        double vx = Math.cos(newAngle);
        // -- y vector component
        double vy = Math.sin(newAngle);
        // -- speed we want the box to move
        double newSpeed = speed + SPEED_VARIANCE * randomMinus1to1();
        // -- direction we will move our box on the X axis with the speed applied
        dirX = vx*newSpeed;
        // -- direction we will move our box on the Y axis with the speed applied
        dirY = vy*newSpeed;

        //System.out.printf("vx %f vy %f ", vx, vy);
        //System.out.printf("xy.x %d xy.y %d\n", xy.x, xy.y);

        // define the box's outline color
        borderColor = Color.red;

        // define the box's fill color
        fillColor = new Color(rand.nextInt(100)+colorShift,0,0);

        // now that it exists, make it visible
        onScreen = true;
    }


	public Graphics paintBox(Graphics g){
		g.setColor(fillColor);
		g.fillRect(xy.x, xy.y, widHt.width, widHt.height);
		g.setColor(borderColor);
		g.drawRect(xy.x, xy.y, widHt.width, widHt.height);
		if(onScreen)
			update();
		else
			initialize();
		return g;
	}

	public int getSpeed(){
		return (int)speed;
	}


	private void update(){
		// the box isn't moving sideways - just down - so we only need
		// to increment its y value to move it down the screen
        xy.x += dirX;
        xy.y += dirY;

        double distance = sourcePos.distance(xy);
        if(distance % RESIZE_DISTANCE == 0 && distance > RESIZE_DISTANCE) {
            double sizeScale = 1.0f;
            double w = widHt.getWidth();
            double h = widHt.getHeight();
            double nW = w+sizeScale;
            double nH = h +sizeScale;
            widHt.setSize((double)nW, (double)nH);
        }
        
		// if the box has moved beyond the edge of the screen
		// indicate that it's offscreen (which will cause it to
		// be re-initialized)
        if(xy.y >= parent.getHeight() || xy.y <= 0 ||
                xy.x >= parent.getWidth() || xy.x <= 0) {
			onScreen = false;
        }
	}

	public boolean isOnScreen(){
		return onScreen;
	}

	public static int getMaxSpeed(){
		return MAX_SPEED;
	}

}

This is awesome! I can see what you mean about there being a few artifacts (lots of larger boxes in the up/down/left/right directions)

This post has been edited by jumptrooper: 25 February 2011 - 10:20 AM