Errors running converted application (from applet)

Question

I've converted some codes (applet) into an application. When I run the application, I can see the GUI, but the application reports error as follows:
Exception occurred during event dispatching:
java.lang.NullPointerException
     at swarmCanvas.paint(Swarm.java:192)
     at sun.awt.RepaintArea.paint(RepaintArea.java:298)
     at sun.awt.windows.WComponentPeer.handleEvent(WComponentPeer.java:196)
     at java.awt.Component.dispatchEventImpl(Component.java:2663)
     at java.awt.Component.dispatchEvent(Component.java:2497)
     at java.awt.EventQueue.dispatchEvent(EventQueue.java:339)
     at java.awt.EventDispatchThread.pumpOneEventForHierarchy(EventDispatchThread.java:131)
     at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:98)
     at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:93)
     at java.awt.EventDispatchThread.run(EventDispatchThread.java:85)
What I see is only the GUI less the animation that occurs when it was an applet. Could anyone offer me any suggestions or help? Thanks a lot.

Answer 1

Here's my codes, many thanks:
* Swarm.class
* This is the major class of the swarm animation. The Swarm class is
* responsible for initialising and coordinating the Flock, swarmCanvas,
* and swarmPanel classes.
* @see Flock.class
* @see Bird.class
* @see Barrier.class
* @author Duncan Crombie
* @version 2.02, 20 September 1997
import java.awt.*;
public class Swarm extends java.applet.Applet implements Runnable {
Thread animator; // animation thread
swarmCanvas arena; // display canvas
swarmPanel controls; // control panel
static int NUMBLUE = 15, NUMRED = 5, MAXPOP = 20;
static double SPEED = 5.0;
static int TURN = 15, MINDIST = 30, MAXDIST = 60;
boolean paused = false;
public void init() { // initialise applet components
arena = new swarmCanvas();
controls = new swarmPanel(NUMBLUE, NUMRED, MAXPOP);
setLayout(new BorderLayout());
add("Center", arena); // add canvas to applet at 'Center'
add("South", controls); // add panel to applet at 'South'
arena.requestFocus();
public void start() { // start thread when applet starts
if (animator == null) {
animator = new Thread(this);
animator.start();
public void stop() { // stop thread when applet stops
if (animator != null) {
animator.stop();
animator = null;
public void run() {
boolean flocking = false;
while (true) {
if (!flocking && arena.unpacked) { // once canvas component is unpacked
Bird.setBoundaries(arena.w, arena.h); // set swarm boundaries
arena.flock = new Flock(NUMBLUE, NUMRED, SPEED, TURN, MINDIST, MAXDIST);
flocking = true;
} else if (flocking) {
Bird.setBoundaries(arena.w, arena.h);
if (!paused)
arena.flock.move(); // animate the flock
arena.repaint(); // update display
try {
Thread.sleep(20); // interval between steps
} catch (InterruptedException e) {}
public boolean handleEvent(Event ev) { // check for control panel actions
if (ev.id == Event.ACTION_EVENT && ev.target == controls.reset) {
resetApplet(); // reset button pressed in controls
return true;
if (ev.id == Event.ACTION_EVENT && ev.target == controls.pause) {
paused = !paused; // toggle paused status
controls.pause.setLabel((paused) ? "Continue" : "Pause");
return true;
if (ev.target == controls.sbRed) {
if (ev.id == Event.SCROLL_LINE_UP)
arena.flock.removeBird(Color.red); // remove a red Bird from flock
else if (ev.id == Event.SCROLL_LINE_DOWN)
arena.flock.addBird(new Bird(Color.red)); // add a red Bird
return true;
if (ev.target == controls.sbBlue) {
if (ev.id == Event.SCROLL_LINE_UP)
arena.flock.removeBird(Color.blue); // remove a blue Bird from flock
else if (ev.id == Event.SCROLL_LINE_DOWN)
arena.flock.addBird(new Bird(Color.blue)); // add a blue Bird
return true;
return super.handleEvent(ev); // pass on unprocessed events
public boolean keyDown(Event e, int x) { // check for key press
boolean shiftKeyDown = ((e.modifiers & Event.SHIFT_MASK) != 0);
if (shiftKeyDown) {
if (x == Event.DOWN) Flock.minDISTANCE -= 5; // less separation
if (x == Event.UP) Flock.minDISTANCE += 5; // more separation
if (x == Event.LEFT) Flock.maxDISTANCE -= 5; // lower detection
if (x == Event.RIGHT) Flock.maxDISTANCE += 5; // higher detection
Barrier.minRANGE = Flock.minDISTANCE;
Barrier.maxRANGE = Flock.maxDISTANCE;
} else {
if (x == Event.DOWN) Bird.maxSPEED -= 1.0; // slower
if (x == Event.UP) Bird.maxSPEED += 1.0; // faster
if (x == Event.LEFT) Bird.maxTURN -= 5; // less turning
if (x == Event.RIGHT) Bird.maxTURN += 5; // more turning
return true; // all key events handled
public void resetApplet() {
arena.flock = new Flock(NUMBLUE, NUMRED, SPEED, TURN, MINDIST, MAXDIST);
controls.sbBlue.setValue(NUMBLUE); // initialise scrollbars
controls.sbRed.setValue(NUMRED);
* swarmPanel.class
* A Panel holding two scrollbars and two buttons for controlling the
* Swarm applet.
* @see Swarm.class
* @author Duncan Crombie
* @version 2.01, 20 September 1997
class swarmPanel extends Panel { // class defines applet control panel
Button reset, pause;
Scrollbar sbBlue = new Scrollbar(Scrollbar.HORIZONTAL);
Scrollbar sbRed = new Scrollbar(Scrollbar.HORIZONTAL);
Label label1, label2;
* The construction method creates and adds control panel components
swarmPanel(int numRed, int numBlue, int maxBoid) {
setLayout(new GridLayout(2, 3)); // define 2 x 3 grid layout for controls
label1 = new Label("Blue #");
label1.setFont(new Font("Dialog", Font.PLAIN, 12)); add(label1);
label2 = new Label("Red #");
label2.setFont(new Font("Dialog", Font.PLAIN, 12)); add(label2);
reset = new Button("Reset"); add(reset);
sbBlue.setValues(numRed, 1, 0, maxBoid);
add(sbBlue);
sbRed.setValues(numBlue, 1, 0, maxBoid);
add(sbRed);
pause = new Button("Pause");
add(pause);
* swarmCanvas.class
* A Canvas for displaying the Flock and Swarm parameters.
* @see Swarm.class
* @author Duncan Crombie
* @version 2.01, 20 September 1997
class swarmCanvas extends Canvas {
Flock flock;
Image offScrImg;
boolean unpacked = false;
int w, h;
/* Double buffered graphics */
public void update(Graphics g) {
if (offScrImg == null || offScrImg.getWidth(this) != w || offScrImg.getHeight(this) != h)
offScrImg = createImage(w, h);
Graphics og = offScrImg.getGraphics();
paint(og);
g.drawImage(offScrImg, 0, 0, this);
og.dispose();
public void paint(Graphics g) {
Dimension d = this.preferredSize();
if (!unpacked) {
this.w = d.width;
this.h = d.height;
unpacked = true;
g.setColor(Color.white);
g.fillRect(0, 0, w, h); // draw white background
g.setColor(Color.black); // set font and write applet parameters
g.setFont(new Font("Dialog", Font.PLAIN, 10));
g.drawString("Bird Speed: " + Bird.maxSPEED, 10, 15);
g.drawString("Bird Turning: " + Bird.maxTURN, 10, 30);
g.drawString("Minimum Distance: " + Flock.minDISTANCE, 10, 45);
g.drawString("Maximum Distance: " + Flock.maxDISTANCE, 10, 60);
flock.display(g); // draw Flock members
if (this.w != d.width || this.h != d.height)
unpacked = false;
public boolean mouseDown(Event ev, int x, int y) {
int radius = Barrier.maxRANGE;
boolean top, bottom;
flock.addBird(new Barrier(x, y)); // place Barrier at click coordinates
top = (y < radius);
bottom = (y > h-radius);
if (x < radius) { // if left
flock.addBird(new Barrier(w + x, y));
if (top) flock.addBird(new Barrier(w + x, h + y));
else if (bottom) flock.addBird(new Barrier(w + x, y - h));
} else if (x > w-radius) { // if right
flock.addBird(new Barrier(x - w, y));
if (top) flock.addBird(new Barrier(x - w, h + y));
else if (bottom) flock.addBird(new Barrier(x - w, y - h));
if (top) flock.addBird(new Barrier(x, h + y));
else if (bottom) flock.addBird(new Barrier(x, y - h));
return true;
===================================================================
* Bird.class
* This class defines the appearance and behaviour of a Bird object.
* @see Swarm.class
* @see Flock.class
* @see Barrier.class
* @author Duncan Crombie
* @version 2.02, 21 September 1997
import java.awt.*;
class Bird {
int iX, iY, iTheta;
Color cFeathers;
static int arenaWIDTH, arenaHEIGHT; // canvas dimensions
static double maxSPEED; // speed of Bird
static int maxTURN; // maximum turn in degrees
Bird(int x, int y, int theta, Color feath) {
iX = x;
iY = y;
iTheta = theta;
cFeathers = feath;
Bird(Color feath) {
this((int)(Math.random() * arenaWIDTH),
(int)(Math.random() * arenaHEIGHT),
(int)(Math.random() * 360),
feath);
public void move(int iHeading) {
int iChange = 0;
int left = (iHeading - iTheta + 360) % 360;
int right = (iTheta - iHeading + 360) % 360;
if (left < right)
iChange = Math.min(maxTURN, left);
else
iChange = -Math.min(maxTURN, right);
iTheta = (iTheta + iChange + 360) % 360;
iX += (int)(maxSPEED * Math.cos(iTheta * Math.PI/180)) + arenaWIDTH;
iX %= arenaWIDTH;
iY -= (int)(maxSPEED * Math.sin(iTheta * Math.PI/180)) - arenaHEIGHT;
iY %= arenaHEIGHT;
public void display(Graphics g) { // draw Bird as a filled arc
g.setColor(this.cFeathers);
g.fillArc(iX - 12, iY - 12, 24, 24, iTheta + 180 - 15, 30);
public int getDistance(Bird bOther) {
int dX = bOther.getPosition().x-iX;
int dY = bOther.getPosition().y-iY;
return (int)Math.sqrt(Math.pow(dX, 2) + Math.pow(dY, 2));
static void setBoundaries(int w, int h) {
arenaWIDTH = w;
arenaHEIGHT = h;
public int getTheta() {
return iTheta;
public Point getPosition() {
return new Point(iX, iY);
public Color getFeathers() {
return cFeathers;
=================================================================
* Flock.class
* This class creates and coordinates the movement of a flock of Birds.
* @see Swarm.class
* @see Bird.class
* @see Barrier.class
* @author Duncan Crombie
* @version 2.02, 21 September 1997
import java.util.Vector;
import java.awt.*;
class Flock { // implement swarming algorithm on flock of birds
private Vector vBirds;
static int minDISTANCE, maxDISTANCE;
Flock(int nBlue, int nRed, double speed, int turn, int minDist, int maxDist) {
vBirds = new Vector(5, 5);
for (int i=0; i < nBlue + nRed; i++)
addBird(new Bird((i < nBlue) ? Color.blue : Color.red));
Bird.maxSPEED = speed;
Bird.maxTURN = turn;
Barrier.minRANGE = minDISTANCE = minDist;
Barrier.maxRANGE = maxDISTANCE = maxDist;
public void addBird(Bird bird) { // add Bird to vector
vBirds.addElement(bird);
synchronized void removeBird(Color col) { // remove Bird from vector
for (int i=0; i < vBirds.size(); i++) { // loop through vector of Birds
Bird bTemp = (Bird)vBirds.elementAt(i);
if (bTemp.getFeathers() == col) { // search for Bird of given colour
vBirds.removeElementAt(i); // if found, remove Bird..
break; // ..and stop searching
* The move function simply tells each Bird in the Vector vBirds to move
* according to the resultant Point of generalHeading.
synchronized public void move() {
for (int i=0; i < vBirds.size(); i++) {
Bird bTemp = (Bird)vBirds.elementAt(i);
bTemp.move(generalHeading(bTemp));
* The display function simply draws each Bird in the Vector vBirds at its
* current position.
public void display(Graphics g) { // display each Bird in flock
for (int i=0; i < vBirds.size(); i++) {
Bird bTemp = (Bird)vBirds.elementAt(i);
bTemp.display(g);
public Point sumPoints(Point p1, double w1, Point p2, double w2) {
return new Point((int)(w1*p1.x + w2*p2.x), (int)(w1*p1.y + w2*p2.y));
public double sizeOfPoint(Point p) {
return Math.sqrt(Math.pow(p.x, 2) + Math.pow(p.y, 2));
public Point normalisePoint(Point p, double n) {
if (sizeOfPoint(p) == 0.0) return p;
else {
double weight = n / sizeOfPoint(p);
return new Point((int)(p.x * weight), (int)(p.y * weight));
* The generalHeading function determines the point a Bird will turn towards
* in the next timestep. The Bird b checks for all Birds (other than self)
* that fall within the detection range. If the Bird is of a different colour
* or closer than the separation distance then they are repulsed else the
* Birds are attracted according to the flocking algorithm.
private int generalHeading(Bird b) {
if (b instanceof Barrier) return 0;
Point pTarget = new Point(0, 0);
int numBirds = 0; // total of Birds to average
for (int i=0; i < vBirds.size(); i++) { // for each Bird in array
Bird bTemp = (Bird)vBirds.elementAt(i); // retrieve element i
int distance = b.getDistance(bTemp); // get distance to Bird
if (!b.equals(bTemp) && distance > 0 && distance <= maxDISTANCE) {
* If the neighbour is a sibling the algorithm tells the boid to align its
* direction with the other Bird. If the distance between them differs from
* minDISTANCE then a weighted forces is applied to move it towards that
* distance. This force is stronger when the boids are very close or towards
* the limit of detection.
if (b.getFeathers().equals(bTemp.getFeathers())) { // if same colour
Point pAlign = new Point((int)(100 * Math.cos(bTemp.getTheta() * Math.PI/180)), (int)(-100 * Math.sin(bTemp.getTheta() * Math.PI/180)));
pAlign = normalisePoint(pAlign, 100); // alignment weight is 100
boolean tooClose = (distance < minDISTANCE);
double weight = 200.0;
if (tooClose) weight *= Math.pow(1 - (double)distance/minDISTANCE, 2);
else weight *= - Math.pow((double)(distance-minDISTANCE) / (maxDISTANCE-minDISTANCE), 2);
Point pAttract = sumPoints(bTemp.getPosition(), -1.0, b.getPosition(), 1.0);
pAttract = normalisePoint(pAttract, weight); // weight is variable
Point pDist = sumPoints(pAlign, 1.0, pAttract, 1.0);
pDist = normalisePoint(pDist, 100); // final weight is 100
pTarget = sumPoints(pTarget, 1.0, pDist, 1.0);
* In repulsion the target point moves away from the other Bird with a force
* that is weighted according to a distance squared rule.
else { // repulsion
Point pDist = sumPoints(b.getPosition(), 1.0, bTemp.getPosition(), -1.0);
pDist = normalisePoint(pDist, 1000);
double weight = Math.pow((1 - (double)distance/maxDISTANCE), 2);
pTarget = sumPoints(pTarget, 1.0, pDist, weight); // weight is variable
numBirds++;
if (numBirds == 0) return b.getTheta();
else // average target points and add to position
pTarget = sumPoints(b.getPosition(), 1.0, pTarget, 1/(double)numBirds);
int targetTheta = (int)(180/Math.PI * Math.atan2(b.getPosition().y - pTarget.y, pTarget.x - b.getPosition().x));
return (targetTheta + 360) % 360; // angle for Bird to steer towards
======================================================================
* Barrier.class
* This class creates and coordinates the movement of a flock of Birds.
* @see Swarm.class
* @see Flock.class
* @see Bird.class
* @author Duncan Crombie
* @version 2.01, 21 September 1997
import java.awt.*;
class Barrier extends Bird {
static int minRANGE, maxRANGE;
Barrier(int x, int y) {
super(x, y, 0, Color.black); // position Barrier and define color as black
public void move(int dummy) {
// do nothing
public void display(Graphics g) { // paint Barrier
g.setColor(Color.black);
g.fillOval(this.iX-5, this.iY-5, 10, 10);
g.setColor(Color.gray); // paint separation circle
g.drawOval(this.iX-minRANGE, this.iY-minRANGE, 2*minRANGE, 2*minRANGE);
g.setColor(Color.lightGray); // paint detection circle
g.drawOval(this.iX-maxRANGE, this.iY-maxRANGE, 2*maxRANGE, 2*maxRANGE);
=====================================================================
import java.awt.*;
import java.awt.event.*;
public class SwarmFrame extends Frame implements ActionListener {
public SwarmFrame() {
super("Flocking Bird");
MenuBar mb = new MenuBar();
setMenuBar(mb);
Menu fileMenu = new Menu("File");
mb.add(fileMenu);
MenuItem exitMenuItem = new MenuItem("Exit");
fileMenu.add(exitMenuItem);
exitMenuItem.addActionListener(this);
Swarm swarmApplet = new Swarm();
add(swarmApplet, BorderLayout.CENTER);
swarmApplet.init();
public void actionPerformed(ActionEvent evt) {
if(evt.getSource() instanceof MenuItem) {
String menuLabel = ((MenuItem) evt.getSource()).getLabel();
if(menuLabel.equals("Exit")) {
dispose();
System.exit(0);
=====================================================================
import java.awt.*;
public class SwarmApplication {
public static void main(String[] args) {
Frame frame = new SwarmFrame();
frame.setBounds(10, 10, 600, 400);
frame.setVisible(true);