j2me游戏编程光盘源码

				import net.jscience.math.kvm.MathFP;
				import javax.microedition.lcdui.*;
				import java.io.IOException;
				
				/**
				 * A Bullet Actor is a simple flying object fired from a Ship. It has a limited
				 * lifetime of 3 seconds using code in the cycle method after which the object
				 * is removed from the GameScreen.
				 * @author Martin J. Wells
				 */
				public class Bullet extends Actor
				{
				   private static ImageSet bulletImageSet;  // the one and only imageset
				   private Sprite bulletSprite;
				
				   /**
				    * Creates a new Bullet at the specified starting position and facing
				    * direction. This is called by the Ship class when the player hits the fire
				    * key.
				    * @param worldArg The world this actor is in.
				    * @param startX The starting x position.
				    * @param startY The starting y position.
				    * @param direction The starting direction.
				    */
				   public Bullet(World worldArg, int startX, int startY, int direction)
				   {
				      super(worldArg, startX, startY, direction, 16, MathFP.toFP("6.0"),
				            MathFP.toFP("0.0"), MathFP.toFP("6.0"), MathFP.toFP("-1.0"), 0);
				
				      if (bulletImageSet == null)
				      {
				         try
				         {
				            Image[] frames = ImageSet.extractFrames(Image.createImage(
				                    "/general.png"), 0, 0, 4, 1, 3, 3);
				            bulletImageSet = new ImageSet(1);
				            bulletImageSet.addState(frames, 0);
				         }
				         catch (IOException ioe)
				         {
				            System.out.println("unable to load image");
				         }
				      }
				
				      bulletSprite = new Sprite(bulletImageSet, 0, 0);
				   }
				
				   /**
				    * The render method is basically the same as the Ship except that the bullet
				    * graphic doesn抰 face a particular direction so you don抰 need to worry
				    * about setting that.
				    * @param graphics The graphics context upon which to draw the bullet.
				    * @param offsetX The amount to offset the x drawing position by.
				    * @param offsetY The amount to offset the y drawing position by.
				    */
				   public void render(Graphics graphics, int offsetX, int offsetY)
				   {
				      bulletSprite.draw(graphics, getX()-offsetX, getY()-offsetY);
				   }
				
				   /**
				    * The cycle method calls the base class cycle (Actor) which handles the
				    * movement, then we cycle the Sprite object so it will animate (progress to
				    * the next frame) before checking the amount of time the object has been
				    * around and destroy it by calling the GameScreen.removeActor method.
				    * @param deltaMS The amount of time that has passed sine the last call to
				    * cycle (in milliseconds).
				    */
				   public void cycle(long deltaMS)
				   {
				      super.cycle(deltaMS);
				      bulletSprite.cycle(deltaMS);
				
				      // terminate this bullet if it's older than 3 seconds
				      if (bulletSprite.getTimeInCurrentState() > 3000)
				         getWorld().removeActor(this);
				   }
				
				   /**
				    * @return The height of the Bullet object (always 1 for this case).
				    */
				   public int getHeight() { return 1; }
				
				   /**
				    * @return The width of the Bullet object (always 1 for this case).
				    */
				   public int getWidth() { return 1; }
				}