Task 1. Making UFOs Appear - Constructor and Accessors (10%)

We have a few methods to implement to get our UFOs to appear on the screen. These methods allow the game to construct UFOs and access a UFO's position so that it can draw it in the right location on the screen.

We've initially specified that UFOs have three instance variables:

• xPosition: the x pixel coordinates of the center of the UFO,
• yPosition: the y pixel coordinates of the center of the UFO, and
• uFOType that will be used in the challenge task.

Start by completing the bodies the constructor and the accessor (getter) methods getXPosition(), getYPosition(), and getUFOType().

Once you have completed these, create a new class, named SpaceGameMain, in the source file named SpaceGameMain.java. This will be your main class. Add the following code to your SpaceGameMain.java file:

import java.util.Random;

public class SpaceGameMain {

	//for random numbers
	public static Random rng = new Random();

	public static void main(String[] args) {
		//create game
		SpaceGame theGame=new SpaceGame(800,800);

		//add UFOs
		theGame.addUFO(UFO.SIMPLE_SAUCER);
		theGame.addUFO(UFO.SIMPLE_SAUCER);
		theGame.addUFO(UFO.SIMPLE_SAUCER);

		//run game
		theGame.start();
	}
}

Now go ahead and run it (note it will crash if you haven't modified the UFO class as described above). If you wrote the methods correctly, you'll see the Defender module is ready to defend, but the UFO objects merely hang in various locations on the screen. They need some enhancement, specifically:

1. They should move.
2. They should fire lasers.
3. They should be hurt when they're hit by lasers.

In the next three tasks we'll implement these enhancements.

Task 2. UFO Movement - takeOneStep (15%)

We make it appear that the UFO is smoothly moving by drawing it on the screen, then changing its position by a little bit and redrawing it on the screen at the new position. By repeating this at a fast rate, our eyes interpret it as continuous movement, which is an essential idea behind animation as seen in low-tech but high-fun flip books. The time between each screen redraw we call a tick. Once every tick, the game program we've already coded repeatedly calls takeOneStep(), a mutator (setter) method that updates the UFO object's position. Change the body of the takeOneStep method to this.xPosition+=3; and run the program (watch carefully since the ships will move off the window). Now every time the screen redraws itself the ship moves three pixels to the right; in other words, the ship moves to the right at a rate of three pixels per tick.

Next, modify the takeOneStep() method so the ship moves back and forth across the length of the screen at three pixels per tick. Here are some hints:

• You can ignore this method's parameter defender for now. It's for the subsequent tasks.
• Use an instance variable to remember the UFO's direction (either moving left or right).
• Either add to or subtract from the UFO's xPosition depending on the direction the UFO is moving.
• Change direction when you reach the edge of the screen, which is at 0 and SpaceGame.getMaximumX().
• Make sure to use <=, <, >, or >= when comparing positions.
• If you want it to look nice, remember xPosition measures the center of the UFO, and its length is SpaceGame.UFO_SIZE.

Task 3. UFO Firing - shootsThisTurn & fireWeapon (15%)

It's impossible to lose if the UFOs don't fire at you. Both the Defender and the UFO objects can fire Laser objects, but only the Defender has been programmed to work correctly. We've already implemented the Laser class, which you'll use in this task to make UFOs fire lasers. Two methods control the firing: shootsThisTurn() and fireWeapon() and both must be completed as described below for firing to work. During each tick of the game, our program will check each UFO object to see if it shoots this turn by calling shootsThisTurn(). If the UFO shoots, then our program will call fireWeapon().

public boolean shootsThisTurn()
returns true if the UFO is supposed to fire during this tick, false otherwise. Since this method is called by our code each tick, you'll want to keep a count of the tick and only fire when that count reaches a limit. I suggest that you have your UFO fire once every seventy ticks. Later, if you wish, you can make your method vary firing for more interesting game play.

public Laser fireWeapon()
returns a new Laser object that the UFO fires. This method simply makes a Laser object by using the the constructor we've already implemented in the Laser class:

where the first two ints specify the position of the center of the laser object and the second two indicate the x and y components of the velocity in pixels per tick. Create the new laser object at the same location as the UFO and have the laser object head straight down at four pixels per tick veolcity.

Here are some hints:

• You can ignore these methods' parameter defender for now. It's for the last several tasks.
• These two methods will be called by our program and must work as described.
• Use an instance variable to remember how many ticks have passed since the last firing.
• Remember the the y index increases as you go towards the bottom of the screen

Task 4. Hitting a UFO - isHitByLaser, recordHit & removeMeFromGame (10%)

It's impossible to win if you can't hit the UFOs. We've programmed the Defender to be able to shoot, so you just need to check if your UFO object has been hit by a laser. If it has, you need to react appropriately. Three methods control how this works: isHitByLaser(Laser theLaser), recordHit(), and removeMeFromGame(). During each tick of the game, our program will check each UFO object to see if it was hit by a laser by calling isHitByLaser. If it was hit, our program will call the recordHit method so the UFO can record the hit, and then our program will call the removeMeFromGame to see if the UFO was destroyed and should be removed from the game.

public boolean isHitByLaser(Laser theLaser)
returns true if the laser is close enough to "hit" the UFO. Check if the center of the given Laser object and the center of the UFO object are a minimum distance apart. In order to do this you can get position of Laser objects using the accessor methods from the Laser class:

• public int getXPosition()
• public int getYPosition()

public void recordHit()
is a mutator method that tells the UFO that it was hit so that it can keep track of how many times it has been hit.

public boolean removeMeFromGame()
is an accessor method that returns true only when the UFO has been hit enough times to be destroyed.

Fill in the recordHit() and removeMeFromGame() methods so that the UFO is destroyed after it is hit twice.

Here some hints:

• The three methods will be called by our program and must work as described.
• Use an instance variable to remember how many times the UFO has been hit and make sure to it in the constructor.
• Remember that the coordinates specify the center of the UFO, and the size of the UFO is given by SpaceGame.UFO_SIZE.
• Recall that the distance between two numbers is given by the absolute value of their differences, and you'll want to use half of the UFO size for determining the distance from the center.

Task 5. creating different kinds of UFOs (10%)

The game is sort of neat, but all the UFOs are doing exactly the same thing. We can fix that! Let's use that uFOType variable that we've been ignoring. First, let's add more constants to the UFO class (add more constants if you wish):

public static final int FAST_SHIP = 1;
public static final int SUPER_SAUCER = 2;

Let's test it by modifying the SpaceGameMain class. Create several ships of each type and run the game. If you wrote your constructor and your getUFOType() method correctly, you should see several different UFO objects floating back and forth. That's a start, but they all still do the same thing. How can we change that?

Well, each ship has a UFO type. We can use conditional statements to check the type and execute different code based on the type. Here's a simple example that could go in the takeOneStep() method:

int pixelsPerTick;
if (this.uFOType == FAST_SHIP) {
	pixelsPerTick=6;
} else {
	pixelsPerTick=3;
}

If we move the ship based on pixelsPerTick, our FAST_SHIP UFOs will go twice as fast as the others. Keep in mind that a switch statement works extremely well here too:

switch(this.uFOType){
	case SIMPLE_SAUCER:
 		//your code here
		break;
	case FAST_SHIP:
 		//your code here
		break;
	case SUPER_SAUCER:
 		//your code here
		break;
	default:
		System.out.println("No such UFO type " + this.uFOType);
}

Something to Think About using inheritances and interfaces (this part is not a part of this HW but just for your reading)

One problem with our program is that the code for the UFO class can become awfully cumbersome as you add different kinds of UFOs. The problem is that our code jumbles together the different kinds of UFOs in a single class. Not only does this make the UFO class bulky, it is also hard to tell what any particular kind of UFO does. Worse, some of the more complicated kinds might have data members that are irrelevant to other kinds

Another problem with our program can be seen if you check the UFO, Defender, and Laser Javadocs. These classes share a lot of methods that have very similar code.