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();
//}
}
