Game Graphics Wont Appear - Rared up for ur convenience. Thanks!
[73 byte] By [gsquare567a] at [2007-11-26 18:03:32] 
[url]http://rapidshare.com/files/15914242/Version_3.rar.html[/url]
# 1
It's more to your convenience just dumping a link to a rarred file of your game. This is not how it works. You should explain what the problem is and post the necessary code (using code tags) which you think (because you have debugged your code) is the problem.prometheuzza at 2007-7-9 5:33:42 >
# 2
it takes about 3 seconds to download, 1 to unrar, 3 (on my computer) to open. i used to be lazy too.
as for the problem, i'll explain that a bit, but u'll need to look at the Game class and the GalacticWar class. its a JApplet, so theres gotta be something wrong with either the paint and update methods or the graphics2d/bufferedimage objects.
gsquare567a at 2007-7-9 5:33:42 >
# 3
> ...> but u'll need to look at the Game class and the GalacticWar class. > ...Nope, I don't. Best of luck though.prometheuzza at 2007-7-9 5:33:42 >
# 4
> i used to be lazy too.You obviously still are if you can't post your code on here. I don't want to download your (probably crappy) code onto my computer.CaptainMorgan08a at 2007-7-9 5:33:42 >
# 5
Game class - abstract which outlines the format of the game
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.util.*;
abstract class Game extends Applet implements Runnable, KeyListener
{
///////////////////////////////////////
/**** Variable/Object Declaration ****/
///////////////////////////////////////
// main game loop thread
private Thread gameLoop;
// list of sprites
private LinkedList<AnimatedSprite> sprites;
// screen and double buffer
private BufferedImage backBuffer;
private Graphics2D g2d;
private int screenWidth, screenHeight;
// counters
private int frameCount = 0;
private int frameRate = 0;
private int desiredRate;
private long startTime = System.currentTimeMillis();
// game pause
private boolean gamePaused = false;
////////////////////////
/**** Constructors ****/
////////////////////////
public Game(int desiredRate, int screenWidth, int screenHeight)
{
this.desiredRate = desiredRate;
this.screenWidth = screenWidth;
this.screenHeight = screenHeight;
}
////////////////////////////
/**** Accessor Methods ****/
////////////////////////////
public LinkedList<AnimatedSprite> getSprites()
{
return sprites;
}
public AnimatedSprite getFromSprites(int index)
{
return sprites.get(index);
}
public void clearSprites()
{
sprites.clear();
}
public int getSpritesSize()
{
return sprites.size();
}
public Applet getApplet()
{
return this;
}
public boolean isGamePaused()
{
return gamePaused;
}
public Graphics2D getGraphics()
{
return g2d;
}
public int getFrameRate()
{
return frameRate;
}
///////////////////////////
/**** Mutator Methods ****/
///////////////////////////
public void pauseGame()
{
gamePaused = true;
}
public void resumeGame()
{
gamePaused = false;
}
public void addToSprites(AnimatedSprite sprite)
{
sprites.add(sprite);
}
//////////////////////////
/**** Helper Methods ****/
//////////////////////////
protected void drawSprites()
{
for(int i = 0; i < sprites.size(); i++)
{
AnimatedSprite sprite = (AnimatedSprite) sprites.get(i);
if(sprite.isAlive())
{
sprite.updateAnimation();
sprite.transform();
sprite.draw();
}
}
}
protected void updateSprites()
{
for(int i = 0; i < sprites.size(); i++)
{
AnimatedSprite sprite = (AnimatedSprite) sprites.get(i);
if(sprite.isAlive())
{
sprite.updatePosition();
sprite.updateRotation();
sprite.updateAnimation();
sprite.updateLifeTime();
spriteUpdate(sprite);// implemented by subclass
}
}
}
private void purgeSprites()
{
for(int i = 0; i < sprites.size(); i++)
{
AnimatedSprite sprite = (AnimatedSprite) sprites.get(i);
if(!sprite.isAlive())
{
sprites.remove(i);
}
}
}
protected void testCollisions()
{
for(int first = 0; first < sprites.size(); first++)
{
AnimatedSprite sprite1 = (AnimatedSprite) sprites.get(first);
if(sprite1.isAlive())
{
for(int second = first + 1; second < sprites.size(); second++)
{
AnimatedSprite sprite2 = (AnimatedSprite) sprites.get(second);
if(sprite2.isAlive())
{
if(sprite2.collidesWith(sprite1))
{
spriteCollision(sprite1, sprite2);// implemented by subclass
break;
}
else
{
sprite1.setCollided(false);
}
}
}
}
}
}
protected double calcAngleMoveX(double angle)
{
return (double) (Math.cos(angle * Math.PI / 180));
}
protected double calcAngleMoveY(double angle)
{
return (double) (Math.sin(angle * Math.PI / 180));
}
//////////////////////////////////////
/**** Event Methods to Implement ****/
//////////////////////////////////////
abstract void gameStartup();
abstract void gameTimedUpdate();
abstract void gameRefreshScreen();
abstract void gameShutdown();
abstract void gameKeyDown(int keyCode);
abstract void gameKeyUp(int keyCode);
abstract void spriteUpdate(AnimatedSprite sprite);
abstract void spriteCollision(AnimatedSprite sprite1, AnimatedSprite sprite2);
/////////////////////////////
/**** Applet Init Event ****/
/////////////////////////////
public void init()
{
backBuffer = new BufferedImage(screenWidth, screenHeight, BufferedImage.TYPE_INT_RGB);
g2d = backBuffer.createGraphics();
sprites = new LinkedList<AnimatedSprite>();
addKeyListener(this);
gameStartup();// implemented by subclass
}
///////////////////////////////
/**** Applet Update Event ****/
///////////////////////////////
public void update(Graphics g)
{
g = (Graphics) g2d;
// calculate frame rate
frameCount++;
if(System.currentTimeMillis() > startTime + 1000)
{
startTime = System.currentTimeMillis();
frameRate = frameCount;
frameCount = 0;
purgeSprites();// delete dead sprites from array
}
gameRefreshScreen();// implemented by subclass
if(!isGamePaused())
{
drawSprites();
}
// redraw the screen
paint(g);
}
//////////////////////////////
/**** Applet Paint Event ****/
//////////////////////////////
public void paint(Graphics g)
{
g.drawImage(backBuffer, 0, 0, this);
}
//////////////////////////////
/**** Thread Start Event ****/
//////////////////////////////
public void start()
{
gameLoop = new Thread(this);
gameLoop.start();
}
////////////////////////////
/**** Thread Run Event ****/
////////////////////////////
public void run()
{
Thread t = Thread.currentThread();
while(t == gameLoop)
{
try
{
// set frame rate as desired, but might be lowered from game processing
t.sleep(1000 / desiredRate);
}
catch(InterruptedException e)
{
e.printStackTrace();
}
if(!gamePaused)
{
updateSprites();
testCollisions();
}
gameTimedUpdate();// implemented by subclass
// refresh screen
repaint();
}
}
/////////////////////////////
/**** Thread Stop Event ****/
/////////////////////////////
public void stop()
{
// kill the game loop
gameLoop = null;
gameShutdown();// implemented by subclass
}
///////////////////////////////
/**** Key Listener Events ****/
///////////////////////////////
public void keyTyped(KeyEvent k)
{
}
public void keyPressed(KeyEvent k)
{
gameKeyDown(k.getKeyCode());
}
public void keyReleased(KeyEvent k)
{
gameKeyUp(k.getKeyCode());
}
}
GalacticWar class - extends Game and implements the abstract methods.
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.util.*;
public class GalacticWar extends Game
{
///////////////////////////////////////
/**** Variable/Object Declaration ****/
///////////////////////////////////////
// applet information -> static because passed to constructor
static int FRAMERATE = 60;
static int SCREENWIDTH = 800;
static int SCREENHEIGHT = 600;
// global constants
final int ASTEROIDS = 15;
final int BULLETS = 10;
final int BULLET_SPEED = 4;
final double ACCELERATION = 0.05;
final double SHIPROTATION = 5.0;
// sprite state values
final int STATE_NORMAL = 0;
final int STATE_COLLIDED = 1;
final int STATE_EXPLODING = 2;
// sprite types
final int SPRITE_SHIP = 1;
final int SPRITE_ASTEROID_BIG = 2;
final int SPRITE_ASTEROID_MEDIUM = 3;
final int SPRITE_ASTEROID_SMALL = 4;
final int SPRITE_ASTEROID_TINY = 5;
final int SPRITE_BULLET = 6;
final int SPRITE_EXPLOSION = 7;
final int SPRITE_POWERUP_SHIELD = 8;
final int SPRITE_POWERUP_HEALTH = 9;
final int SPRITE_POWERUP_250 = 10;
final int SPRITE_POWERUP_500 = 11;
final int SPRITE_POWERUP_1000 = 12;
final int SPRITE_POWERUP_GUN = 13;
// game states
final int GAME_MENU = 0;
final int GAME_RUNNING = 1;
final int GAME_OVER = 2;
// various toggles
boolean showBounds = false;
boolean collisionTesting = true;
// image objects
ImageEntity background;
ImageEntity bulletImage;
ImageEntity[] bigAsteroids = new ImageEntity[5];
ImageEntity[] medAsteroids = new ImageEntity[2];
ImageEntity[] smlAsteroids = new ImageEntity[3];
ImageEntity[] tnyAsteroids = new ImageEntity[4];
ImageEntity[] explosions = new ImageEntity[2];
ImageEntity[] shipImage = new ImageEntity[3];
ImageEntity[] barImage = new ImageEntity[2];
ImageEntity barFrame;
ImageEntity powerupShield;
ImageEntity powerupHealth;
ImageEntity powerup250;
ImageEntity powerup500;
ImageEntity powerup1000;
ImageEntity powerupGun;
// health/shield and score values
int health = 20;
int shield = 20;
int score = 0;
int highScore = 0;
int firePower = 1;
int keyFirePress = 0;
int gameState = GAME_MENU;
// random number generator
Random rand = new Random();
// used to make ship temporarily invulnerable
long collisionTimer = 0;
// sound effects objects
MidiSequence music = new MidiSequence();// game music
SoundClip shoot = new SoundClip();// shooting sound
SoundClip explosion = new SoundClip();// exploding sound
// multiple-keypress-handling booleans
boolean keyUp, keyLeft, keyRight, keyShield;
public GalacticWar()
{
// call Game class's constructor
super(FRAMERATE, SCREENWIDTH, SCREENHEIGHT);
}
///////////////////////////////
/**** Implemented Methods ****/
///////////////////////////////
void gameStartup()
{
// load sounds and music
music.load("music.midi");
shoot.load("shoot.au");
explosion.load("explode.au");
// load the health/shield bars
barFrame = new ImageEntity(this);
barFrame.load("barframe.png");
barImage[0] = new ImageEntity(this);
barImage[0].load("bar_health.png");
barImage[1] = new ImageEntity(this);
barImage[1].load("bar_shield.png");
// load powerups
powerupShield = new ImageEntity(this);
powerupShield.load("powerup_shield2.png");
powerupHealth = new ImageEntity(this);
powerupHealth.load("powerup_cola.png");
powerup250 = new ImageEntity(this);
powerup250.load("powerup_250.png");
powerup500 = new ImageEntity(this);
powerup500.load("powerup_500.png");
powerup1000 = new ImageEntity(this);
powerup1000.load("powerup_1000.png");
powerupGun = new ImageEntity(this);
powerupGun.load("powerup_gun.png");
// load the background
background = new ImageEntity(this);
background.load("bluespace.png");
// create the ship
shipImage[0] = new ImageEntity(this);
shipImage[0].load("spaceship.png");
shipImage[1] = new ImageEntity(this);
shipImage[1].load("ship_thrust.png");
shipImage[2] = new ImageEntity(this);
shipImage[2].load("ship_shield.png");
AnimatedSprite ship = new AnimatedSprite(this, getGraphics());
ship.setSpriteType(SPRITE_SHIP);
ship.setImage(shipImage[0].getImage());
ship.setFrameWidth(ship.getImageWidth());
ship.setFrameHeight(ship.getImageHeight());
ship.setPosition(new Point2D(SCREENWIDTH/2, SCREENWIDTH/2));
ship.setAlive(true);
ship.setState(STATE_EXPLODING);
collisionTimer = System.currentTimeMillis();
addToSprites(ship);
// load the bullet
bulletImage = new ImageEntity(this);
bulletImage.load("plasmashot.png");
// load the explosion
explosions[0] = new ImageEntity(this);
explosions[0].load("explosion.png");
explosions[1] = new ImageEntity(this);
explosions[1].load("explosion2.png");
// load the asteroids
for(int i = 0; i < 5; i++)
{
bigAsteroids[i] = new ImageEntity(this);
bigAsteroids[i].load("asteroid" + (i+1) + ".png");
}
for(int i = 0; i < 2; i++)
{
medAsteroids[i] = new ImageEntity(this);
medAsteroids[i].load("medium" + (i+1) + ".png");
}
for(int i = 0; i < 3; i++)
{
smlAsteroids[i] = new ImageEntity(this);
smlAsteroids[i].load("small" + (i+1) + ".png");
}
for(int i = 0; i < 4; i++)
{
tnyAsteroids[i] = new ImageEntity(this);
tnyAsteroids[i].load("tiny" + (i+1) + ".png");
}
// start in pause mode
pauseGame();
}
void gameTimedUpdate()
{
checkInput();
if(!isGamePaused() && getSpritesSize() == 1)
{
resetGame();
gameState = GAME_OVER;
}
}
void gameRefreshScreen()
{
Graphics2D g2d = getGraphics();
// draw the background
g2d.drawImage(background.getImage(), 0, 0, SCREENWIDTH-1, SCREENHEIGHT-1, this);
// perform game state function
if(gameState == GAME_MENU)
{
g2d.setFont(new Font("Verdana", Font.BOLD, 36));
g2d.setColor(Color.BLACK);
g2d.drawString("GALACTIC WAR", 252, 202);
g2d.setColor(new Color(200, 30, 30));
g2d.drawString("GALACTIC WAR", 250, 200);
int x = 270, y = 15;
g2d.setFont(new Font("Time New Roman", Font.ITALIC | Font.BOLD, 20));
g2d.setColor(Color.YELLOW);
g2d.drawString("CONTROLS:", x, ++y * 20);
g2d.drawString("ROTATE - Left/Right Arrows", x + 20, ++y * 20);
g2d.drawString("THRUST - Up Arrow", x + 20, ++y * 20);
g2d.drawString("SHIELD - Shift Key (no scoring)", x + 20, ++y * 20);
g2d.drawString("FIRE - Control Key", x + 20, ++y * 20);
g2d.setFont(new Font("Arial", Font.BOLD, 24));
g2d.setColor(Color.ORANGE);
g2d.drawString("Press ENTER to start", 280, 570);
}
else if(gameState == GAME_RUNNING)
{
// draw health/shield bars and meters
g2d.drawImage(barFrame.getImage(), SCREENWIDTH - 132, 18, this);
for(int i = 0; i < health; i++)
{
int healthBarX = SCREENWIDTH - 130 + i * 5;// each bar is 5 pixels
g2d.drawImage(barImage[0].getImage(), healthBarX, 20, this);
}
g2d.drawImage(barFrame.getImage(), SCREENWIDTH - 132, 33, this);
for(int i = 0; i < shield; i++)
{
int shieldBarX = SCREENWIDTH - 130 + i * 5;
g2d.drawImage(barImage[1].getImage(), shieldBarX, 35, this);
}
// draw the bullet upgrades
for(int i = 0; i < firePower; i++)
{
int bulletImageX = SCREENWIDTH - 220 + i * 13;
g2d.drawImage(powerupGun.getImage(), bulletImageX, 17, this);
}
// display the score
g2d.setFont(new Font("Verdana", Font.BOLD, 24));
g2d.setColor(Color.WHITE);
g2d.drawString("" + score, 20, 40);
g2d.setColor(Color.RED);
g2d.drawString("" + highScore, 350, 40);
}
else if(gameState == GAME_OVER)
{
g2d.setFont(new Font("Verdana", Font.BOLD, 36));
g2d.setColor(new Color(200, 30, 30));
g2d.drawString("GAME OVER", 270, 200);
g2d.setFont(new Font("Arial", Font.CENTER_BASELINE, 24));
g2d.setColor(Color.ORANGE);
g2d.drawString("Press ENTER to restart", 260, 500);
}
}
void gameShutdown()
{
music.stop();
shoot.stop();
explosion.stop();
}
void gameKeyDown(int keyCode)
{
switch(keyCode)
{
case KeyEvent.VK_LEFT:
keyLeft = true;
break;
case KeyEvent.VK_RIGHT:
keyRight = true;
break;
case KeyEvent.VK_UP:
keyUp = true;
break;
case KeyEvent.VK_SPACE:
keyFirePress++;// only fires on first key press
break;
case KeyEvent.VK_SHIFT:
if(!keyUp && shield > 0)
{
keyShield = true;
}
break;
case KeyEvent.VK_ENTER:
if(gameState != GAME_RUNNING)
{
resetGame();
resumeGame();
gameState = GAME_RUNNING;
}
break;
case KeyEvent.VK_ESCAPE:
if(gameState == GAME_RUNNING)
{
pauseGame();
gameState = GAME_OVER;
}
break;
}
}
void gameKeyUp(int keyCode)
{
switch(keyCode)
{
case KeyEvent.VK_LEFT:
keyLeft = false;
break;
case KeyEvent.VK_RIGHT:
keyRight = false;
break;
case KeyEvent.VK_UP:
keyUp = false;
break;
case KeyEvent.VK_SPACE:
keyFirePress = 0;
break;
case KeyEvent.VK_SHIFT:
keyShield = false;
break;
}
}
void spriteUpdate(AnimatedSprite sprite)
{
switch(sprite.getSpriteType())
{
case SPRITE_SHIP:
case SPRITE_BULLET:
case SPRITE_ASTEROID_BIG:
case SPRITE_ASTEROID_MEDIUM:
case SPRITE_ASTEROID_SMALL:
case SPRITE_ASTEROID_TINY:
warp(sprite);
break;
case SPRITE_EXPLOSION:
if(sprite.getCurrentFrame() == sprite.getTotalFrames() - 1)
{
sprite.setAlive(false);
}
break;
case SPRITE_POWERUP_HEALTH:
case SPRITE_POWERUP_SHIELD:
case SPRITE_POWERUP_250:
case SPRITE_POWERUP_500:
case SPRITE_POWERUP_1000:
case SPRITE_POWERUP_GUN:
warp(sprite);
// make powerups wobble
double rotation = sprite.getRotRate();
if(sprite.getFaceAngle() > 350)
{
sprite.setRotRate(rotation * -1);
sprite.setFaceAngle(350);
}
else if(sprite.getFaceAngle() < 10)
{
sprite.setRotRate(rotation * -1);
sprite.setFaceAngle(10);
}
break;
}
}
void spriteCollision(AnimatedSprite sprite1, AnimatedSprite sprite2)
{
// used when bullet or ship hits asteroid or ship hits powerup
switch(sprite1.getSpriteType())
{
// asteroid collisions
case SPRITE_BULLET:
if(isAsteroid(sprite2.getSpriteType()))
{
// kill old asteroid + bullet and break up asteroid to more asteroids or upgrade
bumpScore(10);
sprite1.setAlive(false);
sprite2.setAlive(false);
breakAsteroid(sprite2);
}
break;
case SPRITE_SHIP:
if(isAsteroid(sprite2.getSpriteType()))
{
if(sprite1.getState() == STATE_NORMAL)
{
if(keyShield)
{
shield -= 1;// kill 1 bar of shield if used when hits asteroid
}
else
{
collisionTimer = System.currentTimeMillis();
sprite1.setVelocity(new Point2D(0, 0));
double x = sprite1.getPosition().getX() - 10;
double y = sprite1.getPosition().getY() - 10;
startBigExplosion(new Point2D(x, y));
sprite1.setState(STATE_EXPLODING);
// reduce health after hit by 1 bar
health -= 1;
if(health < 0)
{
gameState = GAME_OVER;
}
// lose fire power every hit
firePower--;
if(firePower < 1)
{
firePower = 1;
}
}
sprite2.setAlive(false);
breakAsteroid(sprite2);
}
else if(sprite1.getState() == STATE_EXPLODING)
{
// make ship invulnerable for 3 seconds
if(collisionTimer + 3000 < System.currentTimeMillis())
{
sprite1.setState(STATE_NORMAL);// set to normal after 3 seconds
}
}
}
break;
// powerup activations once hit
case SPRITE_POWERUP_HEALTH:
if(sprite2.getSpriteType() == SPRITE_SHIP)
{
health += 5;
bumpScore(100);
if(health > 20)
{
health = 20;
bumpScore(50);// bonus points for unused health
}
sprite1.setAlive(false);
}
break;
case SPRITE_POWERUP_SHIELD:
if(sprite2.getSpriteType() == SPRITE_SHIP)
{
shield += 5;
bumpScore(100);
if(shield > 20)
{
shield = 20;
bumpScore(50);// bonus points for unused shield
}
}
break;
case SPRITE_POWERUP_250:
if(sprite2.getSpriteType() == SPRITE_SHIP)
{
bumpScore(250);
sprite1.setAlive(false);
}
break;
case SPRITE_POWERUP_500:
if(sprite2.getSpriteType() == SPRITE_SHIP)
{
bumpScore(500);
sprite1.setAlive(false);
}
break;
case SPRITE_POWERUP_1000:
if(sprite2.getSpriteType() == SPRITE_SHIP)
{
bumpScore(1000);
sprite1.setAlive(false);
}
break;
case SPRITE_POWERUP_GUN:
if(sprite2.getSpriteType() == SPRITE_SHIP)
{
firePower++;
bumpScore(100);
if(firePower > 5)
{
firePower = 5;
bumpScore(50);
}
sprite1.setAlive(false);
}
break;
}
}
///////////////////////////
/**** Private Methods ****/
///////////////////////////
private void resetGame()
{
// restart the music
music.setLooping(true);
music.play();
// save the ship for restart
AnimatedSprite ship = (AnimatedSprite) getFromSprites(0);
// delete all sprites
clearSprites();
// add the saved ship to the sprite list
ship.setPosition(new Point2D(SCREENWIDTH/2, SCREENHEIGHT/2));
ship.setAlive(true);
ship.setVelocity(new Point2D(0, 0));
ship.setState(STATE_EXPLODING);
collisionTimer = System.currentTimeMillis();
addToSprites(ship);
// create the random asteroids
for(int i = 0; i < ASTEROIDS; i++)
{
createAsteroid();
}
// reset variables
health = 20;
shield = 20;
score = 0;
firePower = 1;
}
private void createAsteroid()
{
AnimatedSprite asteroid = new AnimatedSprite(this, getGraphics());
asteroid.setAlive(true);
asteroid.setSpriteType(SPRITE_ASTEROID_BIG);
// pick random asteroid image
int i = rand.nextInt(5);
asteroid.setImage(bigAsteroids[i].getImage());
asteroid.setFrameWidth(bigAsteroids[i].getWidth());
asteroid.setFrameHeight(bigAsteroids[i].getHeight());
// set to random position on screen
int x = rand.nextInt(SCREENWIDTH - asteroid.getFrameWidth());
int y = rand.nextInt(SCREENHEIGHT - asteroid.getFrameHeight());
asteroid.setPosition(new Point2D(x, y));
// set to random rotations and angles
asteroid.setFaceAngle(rand.nextInt(360));
asteroid.setMoveAngle(rand.nextInt(360));
asteroid.setRotRate(rand.nextDouble());
// set velocity based on movement angle
double angle = asteroid.getMoveAngle() - 90;
double astVelX = calcAngleMoveX(angle);
double astVelY = calcAngleMoveY(angle);
asteroid.setVelocity(new Point2D(astVelX, astVelY));
addToSprites(asteroid);
}
private void breakAsteroid(AnimatedSprite sprite)
{
switch(sprite.getSpriteType())
{
case SPRITE_ASTEROID_BIG:
for(int i = 0; i < rand.nextInt(3) + 1; i++)
{
spawnAsteroid(sprite);
}
startBigExplosion(sprite.getPosition());
break;
case SPRITE_ASTEROID_MEDIUM:
for(int i = 0; i <rand.nextInt(3) + 1; i++)
{
spawnAsteroid(sprite);
}
startBigExplosion(sprite.getPosition());
break;
case SPRITE_ASTEROID_SMALL:
for(int i = 0; i >< rand.nextInt(3) + 1; i++)
{
spawnAsteroid(sprite);
}
startSmallExplosion(sprite.getPosition());
break;
case SPRITE_ASTEROID_TINY:
spawnPowerup(sprite);
startSmallExplosion(sprite.getPosition());
break;
}
}
private void spawnAsteroid(AnimatedSprite sprite)
{
AnimatedSprite asteroid = new AnimatedSprite(this, getGraphics());
asteroid.setAlive(true);
asteroid.setFaceAngle(rand.nextInt(360));
asteroid.setMoveAngle(rand.nextInt(360));
asteroid.setRotRate(rand.nextDouble());
int w = sprite.getBounds().width;
int h = sprite.getBounds().height;
double x = sprite.getPosition().getX() + rand.nextInt(w);
double y = sprite.getPosition().getY() + rand.nextInt(h);
asteroid.setPosition(new Point2D(x, y));
double angle = asteroid.getMoveAngle() - 90;
double velX = calcAngleMoveX(angle);
double velY = calcAngleMoveY(angle);
asteroid.setVelocity(new Point2D(velX, velY));
// see what to spawn
switch(sprite.getSpriteType())
{
case SPRITE_ASTEROID_BIG:
asteroid.setSpriteType(SPRITE_ASTEROID_MEDIUM);
int i = rand.nextInt(2);
asteroid.setImage(medAsteroids[i].getImage());
asteroid.setFrameWidth(medAsteroids[i].getWidth());
asteroid.setFrameHeight(medAsteroids[i].getHeight());
break;
case SPRITE_ASTEROID_MEDIUM:
asteroid.setSpriteType(SPRITE_ASTEROID_SMALL);
i = rand.nextInt(3);
asteroid.setImage(smlAsteroids[i].getImage());
asteroid.setFrameWidth(smlAsteroids[i].getWidth());
asteroid.setFrameHeight(smlAsteroids[i].getHeight());
break;
case SPRITE_ASTEROID_SMALL:
asteroid.setSpriteType(SPRITE_ASTEROID_TINY);
i = rand.nextInt(4);
asteroid.setImage(tnyAsteroids[i].getImage());
asteroid.setFrameWidth(tnyAsteroids[i].getWidth());
asteroid.setFrameHeight(tnyAsteroids[i].getHeight());
break;
}
addToSprites(asteroid);
}
private void startBigExplosion(Point2D point)
{
AnimatedSprite expl = new AnimatedSprite(this, getGraphics());
expl.setSpriteType(SPRITE_EXPLOSION);
expl.setAlive(true);
expl.setAnimImage(explosions[0].getImage());
expl.setTotalFrames(16);
expl.setColumns(4);
expl.setFrameWidth(96);
expl.setFrameHeight(96);
expl.setFrameDelay(2);
expl.setPosition(point);
addToSprites(expl);
}
private void startSmallExplosion(Point2D point)
{
AnimatedSprite expl = new AnimatedSprite(this, getGraphics());
expl.setSpriteType(SPRITE_EXPLOSION);
expl.setAlive(true);
expl.setAnimImage(explosions[1].getImage());
expl.setTotalFrames(8);
expl.setColumns(4);
expl.setFrameWidth(40);
expl.setFrameHeight(40);
expl.setFrameDelay(2);
expl.setPosition(point);
addToSprites(expl);
}
private boolean isAsteroid(int spriteType)
{
switch(spriteType)
{
case SPRITE_ASTEROID_BIG:
case SPRITE_ASTEROID_MEDIUM:
case SPRITE_ASTEROID_SMALL:
case SPRITE_ASTEROID_TINY:
return true;
default:
return false;
}
}
private void warp(AnimatedSprite sprite)
{
int w = sprite.getFrameWidth() - 1;
int h = sprite.getFrameHeight() - 1;
if(sprite.getPosition().getX() < 0-w)// if it hits left side of screen
{
sprite.getPosition().setX(SCREENWIDTH);
}
else if(sprite.getPosition().getX() > SCREENWIDTH)// if it hits the right side of screen
{
sprite.getPosition().setX(0-w);
}
if(sprite.getPosition().getY() < 0-h)// if it hits top of screen
{
sprite.getPosition().setY(SCREENHEIGHT);
}
else if(sprite.getPosition().getY() > SCREENHEIGHT)// if it hits bottom of screen
{
sprite.getPosition().setY(0-h);
}
}
private void spawnPowerup(AnimatedSprite sprite)
{
// only 12% of tiny asteroids leave a powerup
int i = rand.nextInt(100);
if(i > 12)
{
return;
}
AnimatedSprite powerup = new AnimatedSprite(this, getGraphics());
powerup.setRotRate(8);
powerup.setLifeSpan(1500);
powerup.setAlive(true);
powerup.setPosition(sprite.getPosition());
double powerupVelX = rand.nextDouble() - 0.5;
double powerupVelY = rand.nextDouble() - 0.5;
powerup.setVelocity(new Point2D(powerupVelX, powerupVelY));
switch(rand.nextInt(6))
{
case 0:
// create a new shield powerup
powerup.setImage(powerupShield.getImage());
powerup.setSpriteType(SPRITE_POWERUP_SHIELD);
addToSprites(powerup);
break;
case 1:
// create a new health powerup
powerup.setImage(powerupHealth.getImage());
powerup.setSpriteType(SPRITE_POWERUP_HEALTH);
addToSprites(powerup);
break;
case 2:
// create a new gun powerup
powerup.setImage(powerupGun.getImage());
powerup.setSpriteType(SPRITE_POWERUP_GUN);
addToSprites(powerup);
break;
case 3:
// create a new 250-point powerup
powerup.setImage(powerup250.getImage());
powerup.setSpriteType(SPRITE_POWERUP_250);
addToSprites(powerup);
break;
case 4:
// create a new 500-point powerup
powerup.setImage(powerup500.getImage());
powerup.setSpriteType(SPRITE_POWERUP_500);
addToSprites(powerup);
break;
case 5:
// create a new 1000-point powerup
powerup.setImage(powerup1000.getImage());
powerup.setSpriteType(SPRITE_POWERUP_1000);
addToSprites(powerup);
break;
}
}
private void checkInput()
{
if(gameState != GAME_RUNNING)
{
return;
}
AnimatedSprite ship = (AnimatedSprite) getFromSprites(0);
if(keyLeft)
{
// rotate ship left 5 degrees
ship.setFaceAngle(ship.getFaceAngle() - SHIPROTATION);
if(ship.getFaceAngle() < 0)
{
ship.setFaceAngle(360 - SHIPROTATION);
}
}
else if(keyRight)
{
// rotate ship right 5 degrees
ship.setFaceAngle(ship.getFaceAngle() + SHIPROTATION);
if(ship.getFaceAngle() > 360)
{
ship.setFaceAngle(ship.getFaceAngle() - 360);
}
}
if(keyFirePress == 1)
{
// fire bullet on first press only
fireBullet();
}
if(keyUp)
{
// apply thrust to ship
ship.setImage(shipImage[1].getImage());
applyThrust();
}
else if(keyShield)
{
ship.setImage(shipImage[2].getImage());
}
else
{
ship.setImage(shipImage[0].getImage());
}
}
private void applyThrust()
{
AnimatedSprite ship = (AnimatedSprite) getFromSprites(0);
ship.setMoveAngle(ship.getFaceAngle() - 90);
double velX = ship.getVelocity().getX();
velX += calcAngleMoveX(ship.getMoveAngle()) * ACCELERATION;
if (velX < -10)
{
velX = -10;
}
else if(velX > 10)
{
velX = 10;
}
double velY = ship.getVelocity().getY();
velY += calcAngleMoveY(ship.getMoveAngle()) * ACCELERATION;
if (velY < -10)
{
velY = -10;
}
else if(velY > 10)
{
velY = 10;
}
}
private void fireBullet()
{
// create the new bullet sprite/array(if needed)
AnimatedSprite[] bullets = new AnimatedSprite[6];
switch(firePower)
{
case 1:
bullets[0] = stockBullet();
addToSprites(bullets[0]);
break;
case 2:
bullets[0] = stockBullet();
adjustDirection(bullets[0], -3);
addToSprites(bullets[0]);
bullets[1] = stockBullet();
adjustDirection(bullets[1], 3);
addToSprites(bullets[1]);
break;
case 3:
bullets[0] = stockBullet();
adjustDirection(bullets[0], -4);
addToSprites(bullets[0]);
bullets[1] = stockBullet();
addToSprites(bullets[2]);
bullets[2] = stockBullet();
adjustDirection(bullets[2], 4);
addToSprites(bullets[2]);
break;
case 4:
bullets[0] = stockBullet();
adjustDirection(bullets[0], -10);
addToSprites(bullets[0]);
bullets[1] = stockBullet();
adjustDirection(bullets[1], -5);
addToSprites(bullets[1]);
bullets[2] = stockBullet();
adjustDirection(bullets[2], 5);
addToSprites(bullets[2]);
bullets[3] = stockBullet();
adjustDirection(bullets[3], 10);
addToSprites(bullets[3]);
break;
case 5:
bullets[0] = stockBullet();
adjustDirection(bullets[0], -60);
addToSprites(bullets[0]);
bullets[0] = stockBullet();
adjustDirection(bullets[0], -15);
addToSprites(bullets[0]);
bullets[0] = stockBullet();
adjustDirection(bullets[0], -5);
addToSprites(bullets[0]);
bullets[0] = stockBullet();
adjustDirection(bullets[0], 5);
addToSprites(bullets[0]);
bullets[0] = stockBullet();
adjustDirection(bullets[0], 15);
addToSprites(bullets[0]);
bullets[0] = stockBullet();
adjustDirection(bullets[0], 60);
addToSprites(bullets[0]);
break;
}
shoot.play();
}
private AnimatedSprite stockBullet()
{
AnimatedSprite ship = (AnimatedSprite) getFromSprites(0);
AnimatedSprite bullet = new AnimatedSprite(this, getGraphics());
// set bullet's properties
bullet.setAlive(true);
bullet.setImage(bulletImage.getImage());
bullet.setFrameWidth(bulletImage.getWidth());
bullet.setFrameHeight(bulletImage.getHeight());
bullet.setSpriteType(SPRITE_BULLET);
bullet.setLifeSpan(90);
bullet.setFaceAngle(ship.getFaceAngle());
bullet.setMoveAngle(ship.getFaceAngle() - 90);
// set bullet's velocity and position
double angle = bullet.getMoveAngle();
double bulletVelX = calcAngleMoveX(angle) * BULLET_SPEED;
double bulletVelY = calcAngleMoveY(angle) * BULLET_SPEED;
bullet.setVelocity(new Point2D(bulletVelX, bulletVelY));
double x = ship.getCenter().getX() - bullet.getImageWidth()/2;
double y = ship.getCenter().getY() - bullet.getImageHeight()/2;
bullet.setPosition(new Point2D(x, y));
return bullet;
}
private void adjustDirection(AnimatedSprite sprite, double angle)
{
// set face angle
angle = sprite.getFaceAngle() + angle;
if(angle < 0)
{
angle += 360;
}
else if(angle > 360)
{
angle -= 360;
}
sprite.setFaceAngle(angle);
// set move angle and velocity
sprite.setMoveAngle(sprite.getFaceAngle() - 90);
angle = sprite.getMoveAngle();
double spriteVelX = calcAngleMoveX(angle) * BULLET_SPEED;
double spriteVelY = calcAngleMoveY(angle) * BULLET_SPEED;
sprite.setVelocity(new Point2D(spriteVelX, spriteVelY));
}
private void bumpScore(int points)
{
score += points;
if(score > highScore)
{
highScore = score;
}
}
}
gsquare567a at 2007-7-9 5:33:42 >
# 6
ImageEntity? I don't see the code for that.CaptainMorgan08a at 2007-7-9 5:33:42 >
# 7
Where do you actually draw the Images?CaptainMorgan08a at 2007-7-9 5:33:42 >
# 8
imageentitys a separate class. here they are if u want em all:
import java.awt.Shape;
public class BaseGameEntity extends Object
{
///////////////////////////////////////
/**** Variable/Object Declaration ****/
///////////////////////////////////////
private Shape shape;
private boolean alive;
private double x, y;
private double velX, velY;
private double moveAngle, faceAngle;
////////////////////////////
/**** Accessor Methods ****/
////////////////////////////
public Shape getShape()
{
return shape;
}
public boolean isAlive()
{
return alive;
}
public double getX()
{
return x;
}
public double getY()
{
return y;
}
public double getVelX()
{
return velX;
}
public double getVelY()
{
return velY;
}
public double getMoveAngle()
{
return moveAngle;
}
public double getFaceAngle()
{
return faceAngle;
}
///////////////////////////
/**** Mutator Methods ****/
///////////////////////////
public void setShape(Shape shape)
{
this.shape = shape;
}
public void setAlive(boolean alive)
{
this.alive = alive;
}
public void setX(double x)
{
this.x = x;
}
public void setY(double y)
{
this.y = y;
}
public void setVelX(double velX)
{
this.velX = velX;
}
public void setVelY(double velY)
{
this.velY = velY;
}
public void setFaceAngle(double faceAngle)
{
this.faceAngle = faceAngle;
}
public void setMoveAngle(double moveAngle)
{
this.moveAngle = moveAngle;
}
//////////////////////////
/**** Helper Methods ****/
//////////////////////////
public void incX(double x)
{
this.x += x;
}
public void incY(double y)
{
this.y += y;
}
public void incVelX(double velX)
{
this.velX += velX;
}
public void incVelY(double velY)
{
this.velY += velY;
}
public void incFaceAngle(double faceAngle)
{
this.faceAngle += faceAngle;
}
public void incMoveAngle(double moveAngle)
{
this.moveAngle += moveAngle;
}
////////////////////////
/**** Constructors ****/
////////////////////////
public BaseGameEntity()
{
setShape(null);
setAlive(false);
setX(0.0);
setY(0.0);
setVelX(0.0);
setVelY(0.0);
setFaceAngle(0.0);
setMoveAngle(0.0);
}
}
import javax.sound.sampled.*;
import java.io.*;
import java.net.*;
public class SoundClip
{
private AudioInputStream sample;// stream object for audio data
private Clip clip;// sound clip object
private boolean looping = false;
private int repeat = 0;
private String fileName = "";
// set and get boolean for continuous looping
public void setLooping(boolean looping)
{
this.looping = looping;
}
public boolean getLooping()
{
return looping;
}
// set and get int for number of clip repeats
public void setRepeat(int repeat)
{
this.repeat = repeat;
}
public int getRepeat()
{
return repeat;
}
// set and get clip's file name
public void setFileName(String fileName)
{
this.fileName = fileName;
}
public String getFileName()
{
return fileName;
}
// verify sample is ready and not null
public boolean isLoaded()
{
return (boolean) (sample != null);
}
///////////////////////
/**** Constructors ****/
///////////////////////
// default constructor activates the clip object
public SoundClip()
{
try
{
clip = AudioSystem.getClip();
}
catch(LineUnavailableException e)
{
// this is highly unlikely in minimal use
}
}
// overloaded constructor takes audio file for easier use
public SoundClip(String audioFile)
{
this();// call default constructor
load(audioFile);// loads file using method below
}
// get path for a filename, only used privately
private URL getURL(String fileName)
{
URL url = null;
try
{
url = this.getClass().getResource(fileName);// returns path
}
catch(Exception e)// too many to list
{
}
return url;
}
// load sound file and get a boolean if successful
public boolean load(String audioFile)
{
try
{
setFileName(audioFile);
sample = AudioSystem.getAudioInputStream(getURL(fileName));// sets stream to filename
clip.open(sample);
return true;// successful if reached this point
}
catch(Exception e)// once again, too many to list
{
return false;// unsuccessful if reached this point
}
}
// play sound file if loaded
public void play()
{
if (!isLoaded())
{
return;// exits method and doesn't play file
}
clip.setFramePosition(0);// reset clip from possible previous use
if(looping)
{
clip.loop(Clip.LOOP_CONTINUOUSLY);// continuous loop if true
}
else
{
clip.loop(repeat);// loops for number of repeats, 0 = play once (no repeats, just play)
}
}
// stop sound file
public void stop()
{
clip.stop();
}
}
import java.io.*;
import java.net.*;
import javax.sound.midi.*;
public class MidiSequence
{
private Sequencer sequencer;// midi-playing object
private Sequence song;// midi file object
private String fileName;
private boolean looping = false;
private int repeat = 0;
// read-only sequence
public Sequence getSong()
{
return song;
}
// read-only filename
public String getFileName()
{
return fileName;
}
// set and get boolean for continuous looping
public void setLooping(boolean looping)
{
this.looping = looping;
}
public boolean getLooping()
{
return looping;
}
// set and get number of sequence repeats
public void setRepeat(int repeat)
{
this.repeat = repeat;
}
public int getRepeat()
{
return repeat;
}
// verify sequence is ready and not null
public boolean isLoaded()
{
return (boolean) (sequencer.isOpen());
}
////////////////////////
/**** Constructors ****/
////////////////////////
// default constructor
public MidiSequence()
{
try
{
sequencer = MidiSystem.getSequencer();// initialize the sequencer
}
catch(MidiUnavailableException e)
{
}
}
// overloaded constructor that also loads midi file
public MidiSequence(String midiFile)
{
this();// call default constructor
load(midiFile);
}
// get path for a filename, only used privately
private URL getURL(String fileName)
{
URL url = null;
try
{
url = this.getClass().getResource(fileName);// returns path
}
catch(Exception e)// too many to list
{
}
return url;
}
// load midi file into sequence object and return success
public boolean load(String midiFile)
{
try
{
fileName = midiFile;// set instance variable to argument string
song = MidiSystem.getSequence(getURL(fileName));// returns file's path
sequencer.setSequence(song);// set sequence to song
sequencer.open();// activate sequencer
return true;// successful if reached this point
}
catch(Exception e)// catch all exceptions
{
return false;// unsuccessful if reached this point
}
}
// play the midi sequence
public void play()
{
if (!sequencer.isOpen())
{
return;// exit if not initialized
}
if (looping)// loop continuously and start
{
sequencer.setLoopCount(Sequencer.LOOP_CONTINUOUSLY);
sequencer.start();
}
else// repeat number of times after first played
{
sequencer.setLoopCount(repeat);
sequencer.start();
}
}
// stop the midi sequence
public void stop()
{
sequencer.stop();
}
}
public class Point2D extends Object
{
///////////////////////////////////////
/**** Variable/Object Declaration ****/
///////////////////////////////////////
private double x, y;
////////////////////////////
/**** Accessor Methods ****/
////////////////////////////
public double getX()
{
return x;
}
public double getY()
{
return y;
}
///////////////////////////
/**** Mutator Methods ****/
///////////////////////////
public void setX(int x)
{
this.x = (double) x;
}
public void setX(float x)
{
this.x = (double) x;
}
public void setX(double x)
{
this.x = x;
}
public void setY(int y)
{
this.y = (double) y;
}
public void setY(float y)
{
this.y = (double) y;
}
public void setY(double y)
{
this.y = y;
}
//////////////////////////
/**** Helper Methods ****/
//////////////////////////
////////////////////////
/**** Constructors ****/
////////////////////////
public Point2D(int x, int y)
{
setX(x);
setY(y);
}
public Point2D(float x, float y)
{
setX(x);
setY(y);
}
public Point2D(double x, double y)
{
setX(x);
setY(y);
}
}
import java.awt.*;
import java.awt.geom.*;
import java.applet.*;
import java.net.*;
public class ImageEntity extends BaseGameEntity
{
///////////////////////////////////////
/**** Variable/Object Declaration ****/
///////////////////////////////////////
public Image image;
public Applet applet;
public AffineTransform aTransform;
public Graphics2D g2d;
////////////////////////////
/**** Accessor Methods ****/
////////////////////////////
public Image getImage()
{
return image;
}
public int getWidth()
{
return getImage().getWidth(applet);
}
public int getHeight()
{
return getImage().getHeight(applet);
}
public double getCenterX()
{
return getX() + getWidth() / 2;
}
public double getCenterY()
{
return getY() + getHeight() / 2;
}
private URL getURL(String fileName)
{
URL url = null;
try
{
url = this.getClass().getResource(fileName);
}
catch(Exception e)
{
}
return url;
}
public Rectangle getBounds()
{
return new Rectangle((int) getX(), (int) getY(), getWidth(), getHeight());
}
///////////////////////////
/**** Mutator Methods ****/
///////////////////////////
public void setImage(Image image)
{
this.image = image;
}
public void setGraphics(Graphics2D g2d)
{
this.g2d = g2d;
}
//////////////////////////
/**** Helper Methods ****/
//////////////////////////
public void load(String fileName)
{
setImage(applet.getImage(getURL(fileName)));
while(getImage().getWidth(applet) <= 0);
double x = applet.getSize().width / 2 - getWidth() / 2;
double y = applet.getSize().height / 2 - getHeight() / 2;
aTransform = AffineTransform.getTranslateInstance(x, y);
}
public void transform()
{
aTransform.setToIdentity();
aTransform.translate((int) getX() + getWidth() / 2, (int) getY() + getHeight() / 2);
aTransform.rotate(Math.toRadians(getFaceAngle()));
aTransform.translate(-getWidth() / 2, -getHeight() / 2);
}
public void draw()
{
g2d.drawImage(getImage(), aTransform, applet);
}
////////////////////////
/**** Constructors ****/
////////////////////////
public ImageEntity(Applet a)
{
applet = a;
setImage(null);
setAlive(true);
}
}
import java.awt.*;
import java.applet.*;
import java.io.*;
public class Sprite extends Object
{
///////////////////////////////////////
/**** Variable/Object Declaration ****/
///////////////////////////////////////
protected ImageEntity entity;
protected Point2D position;
protected Point2D velocity;
protected double rotRate;
protected int currentState;
protected int spriteType;
protected int lifeSpan, lifeAge;
protected boolean collided;
////////////////////////
/**** Constructors ****/
////////////////////////
public Sprite(Applet a, Graphics2D g2d)
{
entity = new ImageEntity(a);
entity.setGraphics(g2d);
entity.setAlive(false);
position = new Point2D(0, 0);
velocity = new Point2D(0, 0);
rotRate = 0.0;
currentState = 0;
}
////////////////////////////
/**** Accessor Methods ****/
////////////////////////////
public double getRotRate()
{
return rotRate;
}
public int getState()
{
return currentState;
}
public Rectangle getBounds()
{
return entity.getBounds();
}
public Point2D getPosition()
{
return position;
}
public Point2D getVelocity()
{
return velocity;
}
public Point2D getCenter()
{
return (new Point2D(entity.getCenterX(), entity.getCenterY()));
}
public boolean isAlive()
{
return entity.isAlive();
}
public double getFaceAngle()
{
return entity.getFaceAngle();
}
public double getMoveAngle()
{
return entity.getMoveAngle();
}
public int getImageWidth()
{
return entity.getWidth();
}
public int getImageHeight()
{
return entity.getHeight();
}
public int getSpriteType()
{
return spriteType;
}
public Applet getApplet()
{
return entity.applet;
}
public Graphics2D getGraphics()
{
return entity.g2d;
}
public Image getImage()
{
return entity.image;
}
public boolean getCollided()
{
return collided;
}
public int getLifeSpan()
{
return lifeSpan;
}
public int getLifeAge()
{
return lifeAge;
}
///////////////////////////
/**** Mutator Methods ****/
///////////////////////////
public void setRotRate(double rotRate)
{
this.rotRate = rotRate;
}
public void setState(int currentState)
{
this.currentState = currentState;
}
public void setPosition(Point2D position)
{
this.position = position;
}
public void setVelocity(Point2D velocity)
{
this.velocity = velocity;
}
public void setAlive(boolean alive)
{
entity.setAlive(alive);
}
public void setFaceAngle(int angle)
{
entity.setFaceAngle((double) angle);
}
public void setFaceAngle(float angle)
{
entity.setFaceAngle((double) angle);
}
public void setFaceAngle(double angle)
{
entity.setFaceAngle(angle);
}
public void setMoveAngle(int angle)
{
entity.setMoveAngle((double) angle);
}
public void setMoveAngle(float angle)
{
entity.setMoveAngle((double) angle);
}
public void setMoveAngle(double angle)
{
entity.setMoveAngle(angle);
}
public void setSpriteType(int spriteType)
{
this.spriteType = spriteType;
}
public void setImage(Image image)
{
entity.setImage(image);
}
public void setCollided(boolean collided)
{
this.collided = collided;
}
public void setLifeSpan(int lifeSpan)
{
this.lifeSpan = lifeSpan;
}
public void setLifeAge(int lifeAge)
{
this.lifeAge = lifeAge;
}
//////////////////////////
/**** Helper Methods ****/
//////////////////////////
public void load(String fileName)
{
entity.load(fileName);
}
public void transform()
{
entity.setX(position.getX());
entity.setY(position.getY());
entity.transform();
}
public void draw()
{
entity.g2d.drawImage(entity.getImage(), entity.aTransform, entity.applet);
}
public void drawBounds(Color c)
{
entity.g2d.setColor(c);
entity.g2d.draw(getBounds());
}
public void updatePosition()
{
position.setX(position.getX() + velocity.getX());
position.setY(position.getY() + velocity.getY());
}
public void updateRotation()
{
setFaceAngle(getFaceAngle() + rotRate);
if(getFaceAngle() < 0)
{
setFaceAngle(360 - rotRate);
}
else if(getFaceAngle() > 360)
{
setFaceAngle(rotRate);
}
}
public boolean collidesWith(Sprite sprite)
{
return (getBounds().intersects(sprite.getBounds()));
}
public boolean collidesWith(Point2D point)
{
return (getBounds().contains(point.getX(), point.getY()));
}
public void updateLifeTime()
{
// check to see if it is being used
if(lifeSpan > 0)
{
lifeAge++;
if(lifeAge > lifeSpan)
{
setAlive(false);
lifeAge = 0;
}
}
}
}
import java.awt.*;
import java.awt.image.*;
import java.applet.*;
import java.net.*;
public class AnimatedSprite extends Sprite
{
///////////////////////////////////////
/**** Variable/Object Declaration ****/
///////////////////////////////////////
// large tiled bitmap
private ImageEntity animImage;
// passed to draw method
private BufferedImage tempImage;
private Graphics2D tempSurface;
// custom properties
private int currentFrame, totalFrames;
private int animDirection;
private int frameCount, frameDelay;
private int frameWidth, frameHeight;
private int columns;
////////////////////////
/**** Constructors ****/
////////////////////////
public AnimatedSprite(Applet applet, Graphics2D g2d)
{
super(applet, g2d);
animImage = new ImageEntity(applet);
currentFrame = 0;
totalFrames = 0;
animDirection = 1;
frameCount = 0;
frameDelay = 0;
frameWidth = 0;
frameHeight = 0;
columns = 0;
}
////////////////////////////
/**** Accessor Methods ****/
////////////////////////////
private URL getURL(String fileName)
{
URL url = null;
try
{
url = this.getClass().getResource(fileName);
}
catch(Exception e)
{
}
return url;
}
public Image getAnimImage()
{
return animImage.getImage();
}
public int getCurrentFrame()
{
return currentFrame;
}
public int getTotalFrames()
{
return totalFrames;
}
public int getAnimDirection()
{
return animDirection;
}
public int getFrameCount()
{
return frameCount;
}
public int getFrameDelay()
{
return frameDelay;
}
public int getFrameWidth()
{
return frameWidth;
}
public int getFrameHeight()
{
return frameHeight;
}
public int getColumns()
{
return columns;
}
///////////////////////////
/**** Mutator Methods ****/
///////////////////////////
public void setAnimImage(Image animImage)
{
this.animImage.setImage(animImage);
}
public void setCurrentFrame(int currentFrame)
{
this.currentFrame = currentFrame;
}
public void setTotalFrames(int totalFrames)
{
this.totalFrames = totalFrames;
}
public void setAnimDirection(int animDirection)
{
this.animDirection = animDirection;
}
public void setFrameCount(int frameCount)
{
this.frameCount = frameCount;
}
public void setFrameDelay(int frameDelay)
{
this.frameDelay = frameDelay;
}
public void setFrameWidth(int frameWidth)
{
this.frameWidth = frameWidth;
}
public void setFrameHeight(int frameHeight)
{
this.frameHeight = frameHeight;
}
public void setColumns(int columns)
{
this.columns = columns;
}
//////////////////////////
/**** Helper Methods ****/
//////////////////////////
public void load(String fileName, int columns, int rows, int width, int height)
{
// load the tiled bitmap image
Toolkit tk = Toolkit.getDefaultToolkit();
animImage.load(fileName);
// set tiled bitmap image properties
setColumns(columns);
setTotalFrames(columns * rows);
setFrameWidth(width);
setFrameHeight(height);
// pass image to parent class to draw
tempImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
tempSurface = tempImage.createGraphics();
super.entity.setImage(tempImage);
}
public void updateAnimation()
{
frameCount++;
// update if delay time is reached
if(frameCount > frameDelay)
{
setFrameCount(0);
setCurrentFrame(getCurrentFrame() + getAnimDirection());
if(currentFrame > totalFrames - 1)
{
setCurrentFrame(0);
}
else if(currentFrame < 0)
{
setCurrentFrame(totalFrames - 1);
}
}
}
public void draw()
{
int frameX = (currentFrame % columns) * frameWidth;
int frameY = (currentFrame / columns) * frameHeight;
tempSurface.drawImage(animImage.getImage(), 0, 0, frameWidth - 1, frameHeight - 1, frameX, frameY,
frameX + frameWidth, frameY + frameHeight, super.entity.applet);
super.entity.setImage(tempImage);
super.transform();
super.draw();
}
}