Graphical User Interface, simple game

hey everyone,
i just started working with java graphical user interface, i found some source codes from the web and trying to play around with them and i am just unable to understand it fully, the code is well commented and easy to understand it is a simple game called space invaders.
well my problem is i am trying to make it as simple as possible so i can try improving it later on. what i really want to change is that where the game uses .gif images i want to make them to a simple shapes such as rectangle or oval using for example drawRect(100,100,50,60);
here is the full code of all the game it quite big and i hope somebody could help me simplify it.
please respond to this thread and let me know if im doing something wrong. any advice would be greatly appreciated .

game.java
the line is 129 where the image that i want to change is.
this is the main file

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package spaceinvaders;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferStrategy;
import java.util.ArrayList;
import javax.swing.*;
public class Game extends Canvas {
/** The stragey that allows us to use accelerate page flipping */
private BufferStrategy strategy;
/** True if the game is currently "running", i.e. the game loop is looping */
private boolean gameRunning = true;
/** The list of all the entities that exist in our game */
private ArrayList entities = new ArrayList();
/** The list of entities that need to be removed from the game this loop */
private ArrayList removeList = new ArrayList();
/** The entity representing the player */
private Entity ship;
/** The speed at which the player's ship should move (pixels/sec) */
private double moveSpeed = 300;
/** The time at which last fired a shot */
private long lastFire = 0;
/** The interval between our players shot (ms) */
private long firingInterval = 300;
/** The number of aliens left on the screen */
private int alienCount;
/** The message to display which waiting for a key press */
private String message = "";
/** True if we're holding up game play until a key has been pressed */
private boolean waitingForKeyPress = true;
/** True if the left cursor key is currently pressed */
private boolean leftPressed = false;
/** True if the right cursor key is currently pressed */
private boolean rightPressed = false;
/** True if we are firing */
private boolean firePressed = false;
/** True if game logic needs to be applied this loop, normally as a result of a game event */
private boolean logicRequiredThisLoop = false;
/**
* Construct our game and set it running.
*/
public Game() {
// create a frame to contain our game
JFrame container = new JFrame("shoot them all");
// get hold the content of the frame and set up the resolution of the game
JPanel panel = (JPanel) container.getContentPane();
panel.setPreferredSize(new Dimension(800,600));
panel.setLayout(null);
// setup our canvas size and put it into the content of the frame
setBounds(0,0,800,600);
panel.add(this);
// Tell AWT not to bother repainting our canvas since we're
// going to do that our self in accelerated mode
setIgnoreRepaint(true);
// finally make the window visible
container.pack();
container.setResizable(false);
container.setVisible(true);
// add a listener to respond to the user closing the window. If they
// do we'd like to exit the game
container.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
// add a key input system (defined below) to our canvas
// so we can respond to key pressed
addKeyListener(new KeyInputHandler());
// request the focus so key events come to us
requestFocus();
// create the buffering strategy which will allow AWT
// to manage our accelerated graphics
createBufferStrategy(2);
strategy = getBufferStrategy();
// initialise the entities in our game so there's something
// to see at startup
initEntities();
}
/**
* Start a fresh game, this should clear out any old data and
* create a new set.
*/
private void startGame() {
// clear out any existing entities and intialise a new set
entities.clear();
initEntities();
// blank out any keyboard settings we might currently have
leftPressed = false;
rightPressed = false;
firePressed = false;
}
/**
* Initialise the starting state of the entities (ship and aliens). Each
* entitiy will be added to the overall list of entities in the game.
*/
private void initEntities() {
// create the player ship and place it roughly in the center of the screen
ship=new ShipEntity(this,"spaceinvaders/ship.gif",380,550);
entities.add(ship);
// create a block of aliens (5 rows, by 12 aliens, spaced evenly)
alienCount = 0;
for (int row=0;row<3;row++) {
for (int x=0;x<6;x++) {
Entity alien = new AlienEntity(this,"spaceinvaders/alien.gif",100+(x*50),(50)+row*30);
entities.add(alien);
alienCount++;
}
}
}
/**
* Remove an entity from the game. The entity removed will
* no longer move or be drawn.
*
* @param entity The entity that should be removed
*/
public void removeEntity(Entity entity) {
removeList.add(entity);
}
/**
* Notification that the player has died.
*/
public void notifyDeath() {
message = "Oh no! They got you, try again?";
waitingForKeyPress = true;
}
/**
* Notification that the player has won since all the aliens
* are dead.
*/
public void notifyWin() {
message = "Well done! You Win!";
waitingForKeyPress = true;
}
/**
* Notification that an alien has been killed
*/
public void notifyAlienKilled() {
// reduce the alient count, if there are none left, the player has won!
alienCount--;
if (alienCount == 0) {
notifyWin();
}
}
/**
* Attempt to fire a shot from the player. Its called "try"
* since we must first check that the player can fire at this
* point, i.e. has he/she waited long enough between shots
*/
public void tryToFire() {
// check that we have waiting long enough to fire
if (System.currentTimeMillis() - lastFire < firingInterval) {
return;
}
// if we waited long enough, create the shot entity, and record the time.
lastFire = System.currentTimeMillis();
ShotEntity shot = new ShotEntity(this,"spaceinvaders/shot.gif",ship.getX()+10,ship.getY()-30);
entities.add(shot);
}
/**
* The main game loop. This loop is running during all game
* play as is responsible for the following activities:
* <p>
* - Working out the speed of the game loop to update moves
* - Moving the game entities
* - Drawing the screen contents (entities, text)
* - Updating game events
* - Checking Input
* <p>
*/
public void gameLoop() {
long lastLoopTime = System.currentTimeMillis();
// keep looping round til the game ends
while (gameRunning) {
// work out how long its been since the last update, this
// will be used to calculate how far the entities should
// move this loop
long delta = System.currentTimeMillis() - lastLoopTime;
lastLoopTime = System.currentTimeMillis();
// Get hold of a graphics context for the accelerated
// surface and blank it out
Graphics2D g = (Graphics2D) strategy.getDrawGraphics();
g.setColor(Color.gray);
g.fillRect(0,0,800,600);
// cycle round asking each entity to move itself
if (!waitingForKeyPress) {
for (int i=0;i<entities.size();i++) {
Entity entity = (Entity) entities.get(i);
entity.move(delta);
}
}
// cycle round drawing all the entities we have in the game
for (int i=0;i<entities.size();i++) {
Entity entity = (Entity) entities.get(i);
entity.draw(g);
}
// brute force collisions, compare every entity against
// every other entity. If any of them collide notify
// both entities that the collision has occured
for (int p=0;p<entities.size();p++) {
for (int s=p+1;s<entities.size();s++) {
Entity me = (Entity) entities.get(p);
Entity him = (Entity) entities.get(s);
if (me.collidesWith(him)) {
me.collidedWith(him);
him.collidedWith(me);
}
}
}
// remove any entity that has been marked for clear up
entities.removeAll(removeList);
removeList.clear();
// finally, we've completed drawing so clear up the graphics
// and flip the buffer over
g.dispose();
strategy.show();
// resolve the movement of the ship. First assume the ship
// isn't moving. If either cursor key is pressed then
// update the movement appropraitely
ship.setHorizontalMovement(0);
if ((leftPressed) && (!rightPressed)) {
ship.setHorizontalMovement(-moveSpeed);
} else if ((rightPressed) && (!leftPressed)) {
ship.setHorizontalMovement(moveSpeed);
}
// if we're pressing fire, attempt to fire
if (firePressed) {
tryToFire();
}
// finally pause for a bit. Note: this should run us at about
// 100 fps but on windows this might vary each loop due to
// a bad implementation of timer
try { Thread.sleep(10); } catch (Exception e) {}
}
}
/**
* A class to handle keyboard input from the user. The class
* handles both dynamic input during game play, i.e. left/right
* and shoot, and more static type input (i.e. press any key to
* continue)
*
* This has been implemented as an inner class more through
* habbit then anything else. Its perfectly normal to implement
* this as seperate class if slight less convienient.
*
* @author Kevin Glass
*/
private class KeyInputHandler extends KeyAdapter {
/** The number of key presses we've had while waiting for an "any key" press */
private int pressCount = 1;
/**
* Notification from AWT that a key has been pressed. Note that
* a key being pressed is equal to being pushed down but *NOT*
* released. Thats where keyTyped() comes in.
*
* @param e The details of the key that was pressed
*/
public void keyPressed(KeyEvent e) {
// if we're waiting for an "any key" typed then we don't
// want to do anything with just a "press"
if (waitingForKeyPress) {
return;
}
if (e.getKeyCode() == KeyEvent.VK_LEFT) {
leftPressed = true;
}
if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
rightPressed = true;
}
if (e.getKeyCode() == KeyEvent.VK_SPACE) {
firePressed = true;
}
}
/**
* Notification from AWT that a key has been released.
*
* @param e The details of the key that was released
*/
public void keyReleased(KeyEvent e) {
// if we're waiting for an "any key" typed then we don't
// want to do anything with just a "released"
if (waitingForKeyPress) {
return;
}
if (e.getKeyCode() == KeyEvent.VK_LEFT) {
leftPressed = false;
}
if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
rightPressed = false;
}
if (e.getKeyCode() == KeyEvent.VK_SPACE) {
firePressed = false;
}
}
/**
* Notification from AWT that a key has been typed. Note that
* typing a key means to both press and then release it.
*
* @param e The details of the key that was typed.
*/
public void keyTyped(KeyEvent e) {
// if we're waiting for a "any key" type then
// check if we've recieved any recently. We may
// have had a keyType() event from the user releasing
// the shoot or move keys, hence the use of the "pressCount"
// counter.
if (waitingForKeyPress) {
if (pressCount == 1) {
// since we've now recieved our key typed
// event we can mark it as such and start
// our new game
waitingForKeyPress = false;
startGame();
pressCount = 0;
} else {
pressCount++;
}
}
}
}
/**
* The entry point into the game. We'll simply create an
* instance of class which will start the display and game
* loop.
*
* @param argv The arguments that are passed into our game
*/
public static void main(String argv[]) {
Game g =new Game();
// Start the main game loop, note: this method will not
// return until the game has finished running. Hence we are
// using the actual main thread to run the game.
g.gameLoop();
}
}

here is the class where the constructor for the image object is

package spaceinvaders;
/**
* The entity that represents the players ship
*
* @author Kevin Glass
*/
public class ShipEntity extends Entity {
/** The game in which the ship exists */
private Game game;
public ShipEntity(Game game,String ship,int x, int y){
super(ship,x,y);
}
public void move(long delta) {
// if we're moving left and have reached the left hand side
// of the screen, don't move
if ((dx < 0) && (x < 10)) {
return;
}
// if we're moving right and have reached the right hand side
// of the screen, don't move
if ((dx > 0) && (x > 750)) {
return;
}
super.move(delta);
}
/**
* Notification that the player's ship has collided with something
*
* @param other The entity with which the ship has collided
*/
public void collidedWith(Entity other) {
// if its an alien, notify the game that the player
// is dead
if (other instanceof AlienEntity) {
game.notifyDeath();
}
}
}

Thank you very much, i am waiting for any help possible
there are 5 more classes for this game, i haven't pasted them if you need them to sort my problem just let me know.
thank you very much

thanks a lot for your replay, i was trying to change shipEntity class so it returns different value but it didnt work for me.
im not very sure how to change entity class ?
could you please tell me what needs to be changed
i would really appreciate it.

package spaceinvaders;
import java.awt.Graphics;
import java.awt.Rectangle;
public abstract class Entity {
/** The current x location of this entity */
protected double x;
/** The current y location of this entity */
protected double y;
/** The sprite that represents this entity */
protected Sprite sprite;
/** The current speed of this entity horizontally (pixels/sec) */
protected double dx;
/** The current speed of this entity vertically (pixels/sec) */
protected double dy;
/** The rectangle used for this entity during collisions resolution */
private Rectangle me = new Rectangle();
/** The rectangle used for other entities during collision resolution */
private Rectangle him = new Rectangle();
/**
* Construct a entity based on a sprite image and a location.
*
* @param ref The reference to the image to be displayed for this entity
* @param x The initial x location of this entity
* @param y The initial y location of this entity
*/
public Entity(String ref,int x,int y) {
this.sprite = SpriteStore.get().getSprite(ref);
this.x = x;
this.y = y;
}
/**
* Request that this entity move itself based on a certain ammount
* of time passing.
*
* @param delta The ammount of time that has passed in milliseconds
*/
public void move(long delta) {
// update the location of the entity based on move speeds
x += (delta * dx) / 1000;
y += (delta * dy) / 1000;
}
/**
* Set the horizontal speed of this entity
*
* @param dx The horizontal speed of this entity (pixels/sec)
*/
public void setHorizontalMovement(double dx) {
this.dx = dx;
}
/**
* Get the horizontal speed of this entity
*
* @return The horizontal speed of this entity (pixels/sec)
*/
public double getHorizontalMovement() {
return dx;
}
/**
* Draw this entity to the graphics context provided
*
* @param g The graphics context on which to draw
*/
public void draw(Graphics g) {
sprite.draw(g,(int) x,(int) y);
}
/**
* Get the x location of this entity
*
* @return The x location of this entity
*/
public int getX() {
return (int) x;
}
/**
* Get the y location of this entity
*
* @return The y location of this entity
*/
public int getY() {
return (int) y;
}
/**
* Check if this entity collised with another.
*
* @param other The other entity to check collision against
* @return True if the entities collide with each other
*/
public boolean collidesWith(Entity other) {
me.setBounds((int) x,(int) y,sprite.getWidth(),sprite.getHeight());
him.setBounds((int) other.x,(int) other.y,other.sprite.getWidth(),other.sprite.getHeight());
return me.intersects(him);
}
/**
* Notification that this entity collided with another.
*
* @param other The entity with which this entity collided.
*/
public abstract void collidedWith(Entity other);
}

That method could be changed to draw a simple shape instead of drawing the Sprite. However, it probably would be better to create a Sprite that to represent that simple shape so that other portions of the program that utilize the Sprite reference continue to work correctly.

sorry for being such a bother, but i really want to make this work and fully understand it
thanks a lot for all your help so far.

I believe Ezzaral was saying that you should create a simple .gif file that contains your simple shape instead of changing the other method. So instead of having it draw a rectangle through java, create a rectangle.gif. This will simply replace the ship.gif without having to change more methods than necessary.

He could do that or he could subclass Sprite and override the methods that render it to draw the simple shape instead of an image. I don't know what other functionality the Sprite class provides, so that might affect which way you'd want to go.

thanks for the reply, well i understand that it would be the easyest thing just to change the image and leave all the methods as it is. but i would like to think (im not sure am i right) that if i would change the images in to shapes it would simplify all the program and that is my target. i think what Ezzaral is saying about changing the Sprite class is what i need to do but i am totaly not sure how it would be done.
here is the code for the sprite class

package spaceinvaders;
import java.awt.*;
public class Sprite {
/** The image to be drawn for this sprite */
private Image image;
public Sprite(Image image) {
this.image = image;
}
/**
* Get the width of the drawn sprite
*
* @return The width in pixels of this sprite
*/
public int getWidth() {
return image.getWidth(null);
}
/**
* Get the height of the drawn sprite
*
* @return The height in pixels of this sprite
*/
public int getHeight() {
return image.getHeight(null);
}
/**
* Draw the sprite onto the graphics context provided
*
* @param g The graphics context on which to draw the sprite
* @param x The x location at which to draw the sprite
* @param y The y location at which to draw the sprite
*/
public void draw(Graphics g,int x,int y) {
g.drawImage(image,x,y,null);
}
}

You could easily subclass that to contain a Shape instance instead of an Image and override those three methods to use the Shape instead. I don't really see how it would simplify anything in the program though.

well yeah that does sound that it wouldn't simplify anything in this case. at first i thought that that sprite class wouldn't even be necessary if the shape would be used instead (i am only a beginner programmer) of the image because my target was to make this game as simple as possible and as short as possible even taking some of the functionality off such as aliens moving all i wanted to do is have a static aliens and a ship that is able to shoot and remove alien entities and have basic shapes instead of the images. i managed to stop aliens from moving but now i see that changing the images to shapes wouldn't make it any simpler.
thanks for all your help if you can give me any more advise i would be glad to hear it .
thank you.