planegamecanvas.java~3~

一款益智类的手机游戏

package twplanegame;

import javax.microedition.lcdui.*;
/*
public class PlaneGameCanvas extends Canvas {

   public PlaneGameCanvas() {
    try {
      jbInit();
    }
    catch(Exception e) {
      e.printStackTrace();
    }
  }

  /**Component initialization*/
//  private void jbInit() throws Exception {
    // Set up this Displayable to listen to command events
//    setCommandListener(new PlaneGameCanvas_CommandAdapter(this));
    // add the Exit command
//    addCommand(new Command("Exit", Command.EXIT, 1));
//  }

  /**Handle command events*/
//  public void this_commandPerformed(Command command, Displayable displayable) {
    /** @todo Add command handling code */
//    if (command.getCommandType() == Command.EXIT) {
// stop the MIDlet
 //     PlaneGameMIDlet.quitApp();
 //   }
 // }

  /** Required paint implementation */
//  protected void paint(Graphics g) {
    /** @todo Add paint codes */
//  }

//}

/*
class PlaneGameCanvas_CommandAdapter implements CommandListener {
  private PlaneGameCanvas instance;
  public PlaneGameCanvas_CommandAdapter(PlaneGameCanvas instance) {
    this.instance = instance;
  }

  public void commandAction(Command command, Displayable displayable) {
    instance.this_commandPerformed(command, displayable);
  }
}
*/






class PlaneGameCanvas extends Canvas implements CommandListener,KeyRepeater,ActionListener
{
   // save some calculated values for speed
   private int          m_maxX = getWidth() - 1;
   private int          m_maxY = getHeight() - 1;
   private int          m_imageWidth;
   private int          m_imageHeight;
   // values we need for movement
   private int          m_x = m_maxX / 2;
   private int          m_y = m_maxY / 2;
   // objects necessary for app
   private AppExiter    m_appExiter;

   private KeyRepeat    m_repeat = new KeyRepeat(this);

// private Constant cons = new Constant(); //in order to use self-defined constants

 //actionUpDater,draw the screen every interval time
   private static final ActionUpdater m_updater = new ActionUpdater(0,10);

 //Back ground mover
   private final ImageScroller m_scroller;

   boolean painting = false;

   //*****MY PLANE******//
   private MyPlane myplane;
   private Image myplaneRed;
   private Image myplaneExp;

   //*****MY BULLET*****//
   private Bullet[] mybullet= new Bullet[10];
   private final BulletScroller b_scroller;
   private boolean SendBulletTag;

   //****ENEMY PLANES****//
   private EnemyPlane[] ePlane = new EnemyPlane[5];
   private final ePlaneScroller p_scroller;

   //******ENEMY PLANE BULLET*****//
   private Bullet[] eBullet = new Bullet[10];

   //******ENEMY BOSS*******//
   private EnemyBoss eBoss;

   //******BOSS BULLET******//
   private Bullet[] bossBullet = new Bullet[15];

   private Image tempImage;

   /**
    * The constructor assigns the AppExiter, load the image, and initialies
    * all the constants.  It also adds the EXIT Command, and registers itself
    * as a command listener.
    */

   public PlaneGameCanvas(AppExiter exiter)
   {
      m_appExiter = exiter;

      //**intiate my plane
      myplane = new MyPlane(10,m_y);
      try
      {
                myplaneRed = Image.createImage("/myplane_red.PNG");
      }catch(Exception e)
      {
          myplaneRed = null;
      }
      try
      {
                myplaneExp = Image.createImage("/explosion.PNG");
      }catch(Exception e)
      {
                myplaneExp = null;
      }

      //**intiate my plane's bullet array
      for (int i=0;i<mybullet.length;i++)
      {
                mybullet[i] = new Bullet(0);
      }
      SendBulletTag = true;

      //**initiate enemy plane array
      for (int i = 0;i<ePlane.length;i++)
      {
               ePlane[i] = new EnemyPlane();
      }
      //**initiate enemy boss
      eBoss = new EnemyBoss(1,m_maxX,m_maxY/2);

      p_scroller = new ePlaneScroller(this,50);

      //**initiate enemy plane's bullet array
      for (int i=0;i<eBullet.length;i++)
      {
              eBullet[i] = new Bullet(1);
      }

      //**initiat boss bullet array
      for (int i=0;i<bossBullet.length;i++)
      {
              bossBullet[i] = new Bullet(2);
      }

      b_scroller = new BulletScroller(this,50);

      //** init back ground scroller
      m_scroller = new ImageScroller(this,200);

      register(this);

      //** add the EXIT command to the Canvas
      addCommand(AppExiter.EXIT);

      // register the Canavas as the listener for Commands, the action for
      // the Commands will be handled in the commandAction() method
      setCommandListener(this);
      m_repeat.setSleepPeriod(20);
      m_repeat.start();
   }

   protected void paint(Graphics g)
   {
      painting = true;
      int x,y;
      //*****clear the screen
      g.setColor(0,0,0);
          g.fillRect(0,0,m_maxX+1,m_maxY+1);

          //draw the background
          m_scroller.paint(g);

          //draw enemy planes
      p_scroller.paint(g);

      //draw bullets
          b_scroller.paint(g);

      // draw my plane
      x = myplane.getXPos();
      y = myplane.getYPos();
      tempImage = myplane.getImage();
      switch (myplane.getState())
      {
          case PlaneGameObject.ALIVE:
                  g.drawImage(tempImage, x, y, Graphics.VCENTER|Graphics.HCENTER);
                     break;
               case PlaneGameObject.HIT:
                       g.drawImage(myplaneRed,x,y,Graphics.VCENTER|Graphics.HCENTER);
                       myplane.SetState(PlaneGameObject.ALIVE);
                       break;
               case PlaneGameObject.BOMBING:
                       g.drawImage(myplaneExp,x,y,Graphics.VCENTER|Graphics.HCENTER);
                        // Game Over
                        break;
      }
      painting = false;
   }

   protected void keyRepeated(int keyCode)
   {
      if (hasRepeatEvents())
      {
           moveMyPlane(getGameAction(keyCode));
           m_repeat.stopRepeat(FIRE);
      }
   }

   /**
    * Called when a key is pressed.
    *
    * @param keyCode The key code of the key that was pressed.
    */
   protected void keyPressed(int keyCode)
   {
      // if this MIDP implementation does not support repeated keys
      // then start our own key repeatert

      if (!hasRepeatEvents())
      {
           m_repeat.startRepeat(getGameAction(keyCode));
      }

   }

   /**
    * Called when a key is released.
    *
    * @param keyCode The key code of the key that was pressed.
    */
   protected void keyReleased(int keyCode)
   {
      // if this MIDP implementation does not support repeated keys
      // then stop our key repeater
      if (!hasRepeatEvents())
      {
         m_repeat.stopRepeat(getGameAction(keyCode));
      }
   }

   public boolean sendBullet(int a_x,int a_y,int tag)
   {
                   int offset = myplane.getImageWidth()/2;

                   switch (tag)
                   {
                           case 0:     //my plane Send bullet
                                   for (int i=0;i<mybullet.length;i++)//find empty space
                           {
                                          if (!mybullet[i].IsShow())   //available space in array
                                           {
                                                   mybullet[i].SetID(myplane.getBulletType());//set id
                                                   mybullet[i].SetSpeed(10,0);
                                                   mybullet[i].ShowTrue();  //take the space
                                                  mybullet[i].SetPos(a_x+offset,a_y);
                                return true;  //!!break here if sent one bullet,very important
                                           }

                                }
                                return false;
                        case 1:      //enemy plane send bullet
                                for (int j=0;j<eBullet.length;j++)
                                {
                                        if (!eBullet[j].IsShow())
                                        {
                                                eBullet[j].SetSpeed(3,3);
                                                eBullet[j].ShowTrue();
                                                eBullet[j].SetPos(a_x,a_y);
                                            return true;
                                    }
                                }//for
                                return false;
                        case 2:       //enemy boss send bullet
                                for (int i=0;i<bossBullet.length;i++)
                                {
                                        if (!bossBullet[i].IsShow())
                                        {
                                                bossBullet[i].ShowTrue();
                                                bossBullet[i].SetSpeed(-2,i/3-2);
                        bossBullet[i].SetPos(a_x,a_y);
                                        }
                            }
                            return true;
                }//switch(tag)
            return false;
   }//sendBullet

   public void moveMyPlane(int gameAction)
   {
            //change the data of my plane
             int dx = 0,dy = 0;
             int x_pos = myplane.getXPos();
             int y_pos = myplane.getYPos();
             int s = myplane.getSpeed();
      switch(gameAction){
              case UP:
                 if (y_pos > 0) dy -= s;
                 if (SendBulletTag)
             {
                    if (sendBullet(x_pos,y_pos,0))
                    {
                            SendBulletTag = false;
                    }
             }
                  break;
               case LEFT:
                 if (x_pos > 0) dx -= s;
                 break;
               case DOWN:
             if (y_pos < m_maxY) dy += s;
             if (SendBulletTag)
             {
                    if (sendBullet(x_pos,y_pos,0))
                    {
                            SendBulletTag = false;
                    }
             }
                  break;
         case RIGHT:
             if (x_pos < m_maxX) dx += s;
             break;
         case FIRE:
            if (SendBulletTag)
            {
                    if (sendBullet(x_pos,y_pos,0))
                    {
                            SendBulletTag = false;
                    }
            }
                 break;
      }
      myplane.ChangePos(dx,dy);
      repaint();
  }

   //judge whether the two given objects collided
   public boolean Collision(PlaneGameObject obj1,PlaneGameObject obj2)
   {
       int r1 = obj1.getRadius();
       int r2 = obj2.getRadius();
       int x1 = obj1.getXPos();
       int x2 = obj2.getXPos();
       int y1 = obj1.getYPos();
       int y2 = obj2.getYPos();

       int distance = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);

       if (distance < (r1+r2)*(r1+r2))  //distance less than sum of radiuses
       {	                            //indicate that collided
                       return true;                //return true
       }
       else return false;
   }//Collision()


  /**
   * Called when a game action is to be performed.
   */

   public void performAction()
   {
      repaint();
   }

   /**
    * Register the DisplayObject with the action updater.
    *
    * @param obj The object to be registered.
    */
   public static void register(ActionListener obj)
   {
      m_updater.register(obj);
   }

   public void commandAction(Command c, Displayable d)
   {
      if (c == AppExiter.EXIT)
      {
         m_repeat.cancel();
         m_repeat = null;
         m_appExiter.exitApp();
      }
   }

   //class BulletScroller controls the movement of my bullets by time

   class BulletScroller extends TimerTask
   {
                private final Timer m_updateTimer = new Timer();
                private int ClockTag;

                private final int m_screenWidth;
                private final int m_screenHeight;
                private int m_x;
                private int m_y;
                private Image myBulletImage;
                private Image eBulletImage;
            private Image bossBulletImage;