Making a messy star
Let's suppose you went into a kindergarten classroom and gave each
kid (1), a piece of blue paper that had the same proportions as
the union of the US flag; (2), fifty stars; and
(3), a bit tube of paper glue.
On that piece of blue paper there are fifty little dots which mark
exactly where those fifty stars should be placed.
The eager five-year-old kids are told to glue the stars on the flag.
Your task for this week is to give a reasonable rendition of the
result of their work. We all know they aren't going to get those
stars exactly on those dots, but we will assume they try to get them
pretty close and don't glue stars on their own foreheads.
First attempt
Start by adding a little randomness in the vertical placement of
those starts. Find the statement in the StarField
class that goes:
int starY = (int)((row+1)*F) ;
Change it to add a sloppiness in the gluing process:
int starY = (int)((row+1)*F) + (int)(Math.random()*20) - 10 ;
By subtracting ten from the exact vertical position
of the star and then adding a random number from zero to nineteen,
you should get stars that have a little variation.
You may need to play around those numbers until you can see
stars getting out-of-line.
Are we there yet?
At this time, you may be thinking that this week's lab is going
to be pretty smooth setting: Just change that code
involving x and
you'll be out the door.
But hold on. Take your mouse and resize the window containing the stars.
You should get a little bounce in your stars.
That's very interesting but it's not what we want.
Those kindergartners used so much glue there's no way those stars can move.
What is happening here?
Every time you resize the window, Java calls the paint
method of StarField to repaint the union. When this
happens, you get a new set of random numbers and bouncing stars.
We've got to fix that.
Using arrays to hold the stars
You can't compute a new position for every star on each call of
paint.
Your program must compute and remember the position at each star
when the StarField object is created
and then use the remembered
positions when calling draw method for each star.
To do this, you must: (1), create an array to hold fifty Star5
objects; (2), initialize that array within the StarField
constructor; and (3), draw each of those Star5
objects in the paint method.
Creating the array is easy. Just add something like
the following
reference variable declaration to the StarField class.
private Star5[] stars = new Star5[NUMSTARS] ;
You already have the code to compute the random stars, but you must
move it from the paint method to the
StarField constructor. Be sure to change the
line of code that calls the draw method of
the Star5 to a line that
stores the newly created Star5 object in the array.
Drawing the stars is easy. Add a loop similar to the one below
in the big space left in the paint method.
for (int i = 0; i < NUMSTARS; ++i) {
stars[i].draw(newG) ;
}
Show your instructor that your stars don't bounce on window resize.
Making the position random
Now modify StarField so that there is a bit of
randomness in the horizontal placement
of the stars.
I think the kids will do better here.
Put some spin on it
You know those kids aren't going to get the points of those
stars lines up straight.
Fortunately, Star5 has a constructor with
four parameters. The fourth parameter is an integer to specify
the number of degrees the star was rotated when it was placed
on the union.
Modify StarField to use this constructor and add
a little twist
to your stars.
Show your instructor that your stars are now messy in
three dimensions.
Just one more problem
This one will be hard. It turns out that not all those stars were white.
A few were yellow.
Consequently in the
finished unions
about one-tenth of the stars
are yellow.
To fix this problem, you must modify the Star5 code.
Go to the Star5.java file and add
a new reference variable to hold the color of the star.
You'll need to either add a new five-parameter constructor or
add a setColor method. [Better yet, you should
do both.]
You'll also need to modify the draw method to
use the color that was set for the star rather than just painting
with white.
As soon as you have Star5 accepting different colors,
you need to modify StarField to randomly choose
yellow about 10% of the time. Think about how often the
boolean expression Math.random()<0.1
is true.
Don't feel constrained to have yellow tinged stars. If you want to go wild
choose totally random colors or use a
variety of grays to make it
look like the kids got the stars a little dirty with the glue.
Show your instructor stars with a little color.
