gamelet.java

来自「java learn PPT java learn PPT java learn」· Java 代码 · 共 276 行

     package magic.gamelet;

     import java.applet.*;
     import java.awt.*;
     import java.awt.event.*;
     import java.awt.image.*;
     import java.awt.geom.*;
     import java.util.*;

     import magic.actor2d.*;
     import magic.awtex.*;
     import magic.debug.*;
     import magic.graphics.*;
     import magic.scene.*;

     public abstract class Gamelet extends Applet implements Runnable
     {
          /* 私有属性声明 */

          // 动画线程
          private Thread animation;

          /* 保护属性声明 */

          protected BufferedGraphics offscreenGraphics;
          protected final int BUFFER_STYLE_NONE        = 0;
          protected final int BUFFER_STYLE_DOUBLE      = 1;
          protected final int BUFFER_STYLE_ACCELERATED = 2;
          protected final int BUFFER_STYLE_UNKNOWN     = 3;  // chain flipping, etc
          protected int bufferStyle;

          protected Stack menuStack;

          protected Scene scene;

          protected Color clearColor;
          protected final Color DEFAULT_CLEARCOLOR = Color.BLACK;

          protected int framerate;
          protected double reportedFramerate;
          protected final int DEFAULT_FRAMERATE = 1000/33;	// 33 fps, 或者 30ms/frame

          protected static AudioClip[] audioClips;
          protected static boolean audioEnabled;

          /* 从java.Applet中继承来的方法 */

          public void init()
          {
               Debugger.init(true, Debugger.TYPE_FRAME_OUTPUT, true);

               AnimationStrip.observer = this;

               if(getGraphicsConfiguration().getImageCapabilities().isAccelerated())
               {
                    createBufferStyle(BUFFER_STYLE_ACCELERATED);
               }
               else
               {
                    createBufferStyle(BUFFER_STYLE_DOUBLE);
               }

               menuStack  = new Stack();
               scene      = null;
               clearColor = DEFAULT_CLEARCOLOR;
               animation  = new Thread(this);
               reportedFramerate = 0.0;
               setFramerate(DEFAULT_FRAMERATE);
               audioClips = null;
               audioEnabled = false;
          }   // init

          public void start()
          {
              // 启动动画线程
              if(animation == null)
              {
                   animation = new Thread(this);
              }
              animation.start();
          }

          public void stop()
          {
              animation = null;
          }

          public void update(Graphics g)
          {
               if(Debugger.isDisplayingOutput())
               {
                    return;
               }

               if(scene != null)
               {
                    scene.update();
               }

               paint(g);
          }

          public void paint(Graphics g)
          {
               Graphics2D g2d = null;

               if(bufferStyle != BUFFER_STYLE_NONE && bufferStyle != BUFFER_STYLE_UNKNOWN)
               {
                    if(offscreenGraphics != null)
                    {
                         g2d = (Graphics2D)offscreenGraphics.getValidGraphics();
                         g2d.setBackground(clearColor);
                         g2d.clearRect(0, 0, getSize().width, getSize().height);
                    }
                    else
                    {
                         Debugger.reportWarning("Buffering style is double, but graphics context references null");
                         g2d = (Graphics2D) g;
                    }
               }

               else
               {
                    g2d = (Graphics2D) g;
               }

               prepareGraphics(g2d);

               if(menuStack.size() > 0)
               {
                    if( ((Menu2D)menuStack.peek()).isOverlay())
                    {
                         paintScene(g2d);
                    }

                    ((Menu2D)menuStack.peek()).paint(g2d);
               }
               else
               {
                    paintScene(g2d);
               }

               g.drawImage(offscreenGraphics.getBuffer(), 0, 0, this);

          }    // paint

          /* 从java.lang.Runnable继承来的方法 */

          public void run()
          {
               long lastTime;
               long frameCount = 0;
               long elapsedTime;
               long totalElapsedTime = 0;

               Thread t = Thread.currentThread();
	       while (t == animation)
               {
                    lastTime = System.currentTimeMillis();

                    repaint();

                    elapsedTime = System.currentTimeMillis() - lastTime;

                    try
                    {
                         if(elapsedTime < framerate)
                         {
                              Thread.sleep(framerate - elapsedTime);
                         }
                         else
                         {
                              // 不要让垃圾收集器饿着
                              Thread.sleep(5);
                         }
                    }

                    catch(InterruptedException e)
                    {
                         break;
                    }

                    ++ frameCount;
                    totalElapsedTime += (System.currentTimeMillis() - lastTime);
                    if(totalElapsedTime > 1000)
                    {
                         reportedFramerate = (double) frameCount / (double) totalElapsedTime * 1000.0;
                         frameCount = 0;
                         totalElapsedTime = 0;
                    }
                }

           }   // run

          /* magic.Gamelet的新方法 */

          public boolean isDoubleBuffered()
          {
               return (bufferStyle == BUFFER_STYLE_DOUBLE ||
                       bufferStyle == BUFFER_STYLE_ACCELERATED
                       );
          }

          protected void setFramerate(int fps)
          {
               framerate = fps;
          }

          protected void createBufferStyle(int style)
          {
               bufferStyle = style;

               switch(bufferStyle)
               {
                    case BUFFER_STYLE_NONE:
                         offscreenGraphics = null;
                         return;

                    case BUFFER_STYLE_DOUBLE:
                         offscreenGraphics = new BufferedGraphics(this);
                         return;

                    case BUFFER_STYLE_ACCELERATED:
                         offscreenGraphics = new VolatileGraphics(this);
                         return;

                    case BUFFER_STYLE_UNKNOWN:
                         Debugger.reportWarning("Unknown buffer style (" + style + ").");
                         offscreenGraphics = null;
                         return;
                }
          }

          protected void prepareGraphics(Graphics2D g2d)
          {

          }

          protected void paintScene(Graphics2D g2d)
          {
               if(scene != null)
               {
                    scene.paint(g2d);
               }
          }

          public static void playSound(int index, boolean loop)
          {
               if(!audioEnabled)
               {
                    return;
               }

               if(audioClips != null && index >= 0 && index < audioClips.length && audioClips[index] != null)
               {
                    if(loop)
                    {
                         audioClips[index].loop();
                    }
                    else
                    {
                         audioClips[index].play();
                    }
               }
          }


          public static void stopSound(int index)
          {
               if(audioClips != null && index >= 0 && index < audioClips.length && audioClips[index] != null)
               {
                    audioClips[index].stop();
               }
          }

     }     // Gamelet