Hello, I wonder if anyone can help me to understand where I could be going wrong with this code; Basically I'm working on a turorial and calling
the class below from another class - and it is getting
the following error;
Exception in thread "Thread-1" java.lang.NullPointerException
at org.newdawn.spaceinvaders.TCPChat.run(TCPChat.java:322)
at java.lang.Thread.run(Unknown Source)
I realise
the error is beibg flagged in another class- but I have tested
the other class with a small class which sets up a separate thread - and it works fine, but as soon as I try and implement a new thread in this class - it causes all sorts of problems. Am I setting up
the thread correctly in this class?
Basically I can set up a thread in this class, with a test loop and it's fine, but when I bring in
the functionality of
the rest of
the game it sometimes hangs, or does not display at all.
Any suggestions on where I could be going wrong would be greatly appreciated.
Thanks for looking.
package org.newdawn.spaceinvaders;
import java.awt.BorderLayout;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
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 java.util.Scanner;
import java.awt.*;//maybe not needed
import javax.swing.*;//maybenot needed
import java.util.Random;
//import java.io.*;
/**
*
The main hook of our game. This class with both act as a manager
* for
the display and central mediator for
the game logic.
*
* Display management will consist of a loop that cycles round all
* entities in
the game asking them to move and then drawing them
* in
the appropriate place. With
the help of an inner class it
* will also allow
the player to control
the main ship.
*
* As a mediator it will be informed when entities within our game
* detect events (e.g. alient killed, played died) and will take
* appropriate game actions.
*
* @author Kevin Glass
*/
public class Game extends Canvas implements Runnable{
/**
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 = 500;
/**
The number of aliens left on
the screen */
private int alienCount;
/**
The number of levels progressed */
private double levelCount;
/** high score for
the user */
private int highScore;
/** high score for
the user */
private String player = "bob";
//private GetUserInput getPlayer;
/**
The list of entities that need to be removed from
the game this loop */
/**
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;
//private Thread cThread = new Thread(this);
//public Thread t = new Thread(this);
//private Thread g = new Thread(this);
void setHighscore(int setHS) {
highScore = setHS;
}
public int getHighscore() {
return highScore;
}
public
void setPlayer(String setPlayer) {
player = setPlayer;
}
public String getPlayer() {
return player;
}
public
void run() {
//setup();
System.out.println("hello im running bob");
/*int count = 1;
do {
System.out.println("Count is: " + count);
count++;
try{Thread.sleep(1);}
catch(InterruptedException e){}
} while (count <= 2000000);*/
//Game g =new Game();
//Game g = this;
// 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.
//setup();
//this.gameLoop();
//try{thread.sleep(1);}
//catch{InterruptedException e}
}
/**
* Construct our game and set it running.
*/
public Game () {
//Thread t = new Thread(this);//set up new thread for invaders game
//t.run();//run
the run method of
the game
//Game g =new Game();
//setup();
//Thread t = new Thread(this);
//thread.start();
//SwingUtilities.invokeLater(this);
Thread er = new Thread(this);
er.start();
}
public
void setup(){
//initialise highscore
setHighscore(0);
// create a frame to contain our game
JFrame container = new JFrame("Space Invaders 101");
// 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) {
//cThread.interrupt();
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();
//initialise highscore
setHighscore(0);
// 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() {
public
void initEntities() {
Random randomAlien = new Random();
// create
the player ship and place it roughly in
the center of
the screen
//ship = new ShipEntity(this,"sprites/ship.gif",370,550);//orignal
ship = new ShipEntity(this,"sprites/ship.gif",700,300);//changed postioning to right hand side
entities.add(ship);
// create a block of aliens (5 rows, by 12 aliens, spaced evenly)
alienCount = 0;
levelCount = 1.02;
for (int row=0;row<7;row++) {//altered number of rows
for (int x=0;x<5;x++) {
int r = randomAlien.nextInt(100);//loop added to produce random aliens
if (r < 50){
//Entity alien = new AlienEntity(this,"sprites/alien.gif",/*100+*/(x*50),(50)+row*30);
Entity alien = new AlienEntity(this,"sprites/alien.gif",100+(x*90),(12)+row*85);
entities.add(alien);
alienCount++;
}
}
}
}
//private
void initEntities() {
public
void initAlienEntities() {
Random randomAlien = new Random();
// create
the player ship and place it roughly in
the center of
the screen
//ship = new ShipEntity(this,"sprites/ship.gif",370,550);//orignal
//ship = new ShipEntity(this,"sprites/ship.gif",700,300);//changed postioning to right hand side
//entities.add(ship);
// create a block of aliens (5 rows, by 12 aliens, spaced evenly)
alienCount = 0;
levelCount = levelCount + 0.10;//this increases
the speed on every level
for (int row=0;row<7;row++) {//altered number of rows
for (int x=0;x<5;x++) {
int r = randomAlien.nextInt(100);//loop added to produce random aliens
if (r < 50){//randome check to show alien
//Entity alien = new AlienEntity(this,"sprites/alien.gif",/*100+*/(x*50),(50)+row*30);
Entity alien = new AlienEntity(this,"sprites/alien.gif",-250+(x*90),(12)+row*85);
entities.add(alien);
alienCount++;
}
}
}
advanceAlienSpeed(levelCount);
}
/**
* Notification from a game entity that
the logic of
the game
* should be run at
the next opportunity (normally as a result of some
* game event)
*/
public
void updateLogic() {
logicRequiredThisLoop = true;
}
/**
* 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();win not relevant here...
this.initAlienEntities();//call fresh batch of aliens
}
// if there are still some aliens left then they all need to get faster, so
// speed up all
the existing aliens
advanceAlienSpeed(1.30);
}
public
void advanceAlienSpeed(double speed) {
// if there are still some aliens left then they all need to get faster, so
// speed up all
the existing aliens
for (int i=0;i<entities.size();i++) {
Entity entity = (Entity) entities.get(i);
if (entity instanceof AlienEntity) {
// speed up by 2%
entity.setHorizontalMovement(entity.getHorizontalMovement() * speed);
//entity.setVerticalMovement(entity.getVerticalMovement() * 1.02);
}
}
}
/**
* 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,"sprites/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.black);
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();
// if a game event has indicated that game logic should
// be resolved, cycle round every entity requesting that
// their personal logic should be considered.
if (logicRequiredThisLoop) {
//g.drawString("Press any key",(800-g.getFontMetrics().stringWidth("Press any key"))/2,300);
for (int i=0;i<entities.size();i++) {
Entity entity = (Entity) entities.get(i);
entity.doLogic();
}
logicRequiredThisLoop = false;
}
// if we're waiting for an "any key" press then draw
the
// current message
//show highscore at top of screen
//show name at top of screen
g.setColor(Color.white);
g.drawString("Player : "+getPlayer()+" : Score : "+getHighscore(),20,20);
if (waitingForKeyPress) {
g.setColor(Color.white);
g.drawString(message,(800-g.getFontMetrics().stringWidth(message))/2,250);
g.drawString("Press any key",(800-g.getFontMetrics().stringWidth("Press any key"))/2,300);
}
// 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.setVerticalMovement(0);//set to vertical movement
if ((leftPressed) && (!rightPressed)) {
ship.setVerticalMovement(-moveSpeed);//**took out setHorizaontalMOvement
} else if ((rightPressed) && (!leftPressed)) {
ship.setVerticalMovement(moveSpeed);//**took out setHorizaontalMOvement
}
// 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_UP) {
leftPressed = true;
}
if (e.getKeyCode() == KeyEvent.VK_DOWN) {
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_UP) {//changed from VK_LEFT
leftPressed = false;
}
if (e.getKeyCode() == KeyEvent.VK_DOWN) {//changed from 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++;
}
}
// if we hit escape, then quit
the game
if (e.getKeyChar() == 27) {
//cThread.interrupt();
System.exit(0);
}
}
}
/**
*
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();
//}
}
