gamemain.java

JAVA ME手机游戏FLY,玩家操控飞机

import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.game.Sprite;
import javax.microedition.lcdui.game.TiledLayer;
import javax.microedition.lcdui.game.GameCanvas;

/** /?? GameMain ?/ */
public class GameMain extends GameCanvas implements Runnable {
/** /?? 控制保险位置 ?/ */
    private int baoxianY;
/** /?? 定义背景图片数组 ?/ */
    private static final int[][] MAP = {
{16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16},
{16, 16, 16, 16, 16, 16, 16, 8, 9, 10, 16, 8, 9, 10, 16},
{16, 43, 43, 43, 44, 45, 16, 28, 29, 30, 16, 28, 29, 30, 16},
{16, 63, 63, 63, 64, 2, 16, 48, 49, 50, 16, 48, 49, 50, 16},
{16, 46, 2, 2, 2, 2, 16, 16, 16, 16, 16, 16, 16, 16, 16},
{16, 16, 6, 6, 16, 16, 3, 4, 16, 16, 16, 16, 16, 16, 16},
{16, 16, 6, 6, 16, 16, 23, 24, 16, 16, 16, 132, 88, 88, 88},
{16, 16, 6, 6, 16, 16, 16, 16, 16, 16, 132, 84, 84, 84, 84},
{16, 16, 6, 6, 16, 16, 16, 16, 84, 59, 59, 13, 13, 13, 33},
{16, 16, 6, 39, 41, 16, 16, 16, 84, 84, 126, 126, 84, 84, 84},
{16, 47, 39, 51, 52, 53, 16, 16, 105, 84, 84, 84, 84, 84, 105},
{16, 16, 16, 71, 72, 73, 16, 16, 16, 16, 16, 16, 16, 16, 16},
{16, 16, 16, 91, 92, 93, 16, 16, 3, 4, 16, 16, 16, 16, 16},
{107, 108, 87, 87, 16, 16, 16, 16, 23, 24, 16, 16, 16, 16, 16},
{127, 128, 84, 84, 87, 16, 16, 31, 16, 16, 16, 47, 16, 16, 16},
{84, 84, 12, 13, 88, 87, 16, 15, 16, 16, 16, 11, 14, 14, 11},
{113, 114, 32, 33, 89, 90, 16, 15, 16, 16, 16, 15, 16, 16, 16},
{133, 134, 65, 65, 89, 90, 16, 11, 14, 14, 14, 11, 16, 16, 16},
{84, 84, 84, 84, 84, 84, 16, 16, 16, 16, 47, 15, 16, 16, 16}
};
/** /?? 定义变量 ?/ */
    private static final int N1 = 1;
/** /?? 定义变量 ?/ */
    private static final int N2 = 2;
/** /?? 定义变量 ?/ */
    private static final int N0 = 0;
/** /?? 定义变量 ?/ */
    private static final int N10 = 10;
/** /?? 定义变量 ?/ */
    private static final int N7 = 7;
/** /?? 定义变量 ?/ */
    private static final int N4 = 4;
/** /?? 定义变量 ?/ */
    private static final int N8 = 8;
/** /?? 定义变量 ?/ */
    private static final int N6 = 6;
/** /?? 定义变量 ?/ */
    private static final int N5 = 5;
/** /?? 定义变量 ?/ */
    private static final int N3 = 3;
/** /?? 定义变量 ?/ */
    private static final int N9 = 9;
/** /?? 定义变量 ?/ */
    private static final int N20 = 20;
/** /?? 定义变量 ?/ */
    private static final int N25 = 25;
/** /?? 定义变量 ?/ */
    private static final int N100 = 100;
/** /?? 定义变量 ?/ */
    private static final int N120 = 120;
/** /?? 定义变量 ?/ */
    private static final int N160 = 160;
/** /?? 定义变量 ?/ */
    private static final int N210 = 210;
/** /?? 定义变量 ?/ */
    private static final int N255 = 255;
/** /?? 定义Display对象 ?/ */
    private Display display;
/** /?? 定义Graphics对象 ?/ */
    private Graphics g;
/** /?? 定义Thread对象 ?/ */
    private Thread t;
/** /?? Bullets类对象 ?/ */
    private Bullets bullet;
/** /?? 子弹精灵 ?/ */
    private Sprite bulletSprite;
/** /?? 飞机图片 ?/ */
    private Image planeImage;
/** /?? 保险爆炸图片 ?/ */
    private Image fexplosionImage;
/** /?? 背景图片 ?/ */
    private Image backgroundImage;
/** /?? 保险图片 ?/ */
    private Image baoxianImage;
/** /?? 飞机炸弹图片 ?/ */
    private Image bombImage;
/** /?? 开场图片 ?/ */
    private Image startImage;
/** /?? 飞机炸弹数量 ?/ */
    private static int bombTotal;
/** /?? 背景图层 ?/ */
    private TiledLayer backgtoundLayer;
/** /?? 保险爆炸精灵 ?/ */
    private Sprite[] fexplosionSprite = new Sprite[2];
/** /?? 飞机精灵 ?/ */
    private Sprite planeSprite;
/** /?? 爆炸图片 ?/ */
    private Image explosionImage;
/** /?? 爆炸精灵 ?/ */
    private Sprite explosionSprite;
/** /?? 保险精灵 ?/ */
    private Sprite baoxianSprite;
/** /?? 屏幕的高 ?/ */
    private int screenHeight;
/** /?? 屏幕的宽 ?/ */
    private int screenWidth;
/** /?? 屏幕的行 ?/ */
    private int rows;
/** /?? 屏幕的列 ?/ */
    private int cols;
/** /?? 爆炸动作控制 ?/ */
    private int baozha;
/** /?? 游戏记时开始时间 ?/ */
    private static long gameTimeStart;
/** /?? 游戏结束最后时间 ?/ */
    private static int time;
/** /?? 控制保险 ?/ */
    private boolean baoxianing;
/** /?? 控制线程 ?/ */
    private boolean sleeping;
/** /?? 控制游戏 ?/ */
    private boolean gaming;
/** /?? 控制飞机显示 ?/ */
    private boolean planing;
/** /?? 控制爆炸 ?/ */
    private boolean explosing;
/** /?? 控制保险增加?/ */
    private boolean bombing;
/** /?? GameMain构造函数
?@param d ?/ */
    public GameMain(final Display d) {
         super(true);
         display = d;
         display.setCurrent(this);
/** /?? 控制游戏 ?/ */
         gaming = true;
/** /?? 控制是否画飞机 ?/ */
         planing = true;
/** /?? 控制保险增加?/ */
         bombing = true;
/** /?? 控制是否画爆炸场面 ?/ */
         explosing = false;
/** /?? 初始化两个保险 ?/ */
         bombTotal = N2;
/** /?? 实例bullet ?/ */
         if (bullet == null) {
             bullet = new Bullets();
         }
         bulletSprite = bullet.getBulletSprite();
/** /?? 初始化子弹数组 ?/ */
         bullet.bulletInit(bullet.getBulletsTotal());
/** /?? 调用父类GameCanvas的方法 ?/ */
         g = getGraphics();
/** /?? 调用父类的父类Displayable的方法 ?/ */
         screenHeight = getHeight();
         screenWidth = getWidth();
         baoxianY = screenHeight + N10 + N1;
/** /?? 使用自定义ImageTools类的静态方法 ?/ */
         planeImage = ImageTools.getImage("/plane1.png");
         backgroundImage = ImageTools.getImage("/back.png");
         explosionImage = ImageTools.getImage("/explosion1.png");
         baoxianImage = ImageTools.getImage("/baoxian.png");
         bombImage = ImageTools.getImage("/bomb.png");
         startImage = ImageTools.getImage("/start.png");
         fexplosionImage = ImageTools.getImage("/frameexplosion.png");
/** /?? 创建精灵 ?/ */
         planeSprite = new Sprite(planeImage, N5 * N5, N5 * N5);
         explosionSprite = new Sprite(explosionImage, N5 * N8, N5 * N8);
         baoxianSprite = new Sprite(baoxianImage, N2 * N100 + N5 * N8, N160);
         fexplosionSprite[0] = new Sprite(fexplosionImage, N120, N120);
         fexplosionSprite[1] = new Sprite(fexplosionImage, N120, N120);
/** /?? 飞机精灵定位 ?/ */
         planeSprite.setPosition((screenHeight / N2 - N25), screenWidth / N2);
/** /?? 创建背景图层 ?/ */
         rows = (int) (screenHeight / (N2 * N8));
         cols = (int) (screenWidth / (N2 * N8));
         backgtoundLayer = new TiledLayer(cols, rows + N1, backgroundImage, N2 * N8, N2 * N8);
         baozha = N0;
         baoxianing = false;
    }
/** /?? 重写Runnale接口方法 ?/ */
    public final void run() {
        long st = N0;
        long et = N0;
        long rate = N5 * N10;
        long diff = N0;
        while (!sleeping) {
            planeUpdate();
            draw(g);
            st = System.currentTimeMillis();
            et = System.currentTimeMillis();
            diff = et - st;
            if (diff < rate) {
               try {
                   Thread.sleep(rate - diff);
               } catch (Exception e) {
                System.out.println("faile");
                    }
            }
        }
    }
/** /?? 启动线程 ?/ */
    public final void start() {
        sleeping = false;
        t = new Thread(this);
/** /?? 得到游戏开始时间 ?/ */
        gameTimeStart = System.currentTimeMillis();
        t.start();
    }
/** /?? 游戏初始化 ?/ */
    public final void gameStart() {
        g.drawImage(startImage, N0, N0, 0);
        flushGraphics();
    }
/** /?? 画图
?@param gg ?/ */
    private void draw(final Graphics gg) {
        if (gaming) {
            for (int i = N0; i < cols; i++) {
                for (int j = N0; j < rows + N1; j++) {
                    backgtoundLayer.setCell(i, j , MAP[j][i]);
                }
            }
            backgtoundLayer.setPosition(N0, N0);
            backgtoundLayer.paint(gg);
/** /?? 画飞机?/ */
            if (planing) {
                planeSprite.paint(gg);
            }
/** /?? 画子弹?/ */
            if (!baoxianing) {
                for (int i = N0; i < bullet.getBulletsTotal(); i++) {
                   if (bullet.getBulletState(i, N5) == N1) {
                        bullet.bulletPaint(gg, i);
                        if (planing) {
                            if (bullet.checkExplosion(planeSprite)) {
/** /?? 销毁被创子弹?/ */
                               bullet.bulletDestroy(i);
/** /?? 定位爆炸位置?/ */
                               int x = planeSprite.getX();
                               int y = planeSprite.getY();
                               explosionSprite.setPosition(x, y);
/** /?? 不画飞机?/ */
                               planing = false;
/** /?? 开始爆炸场面?/ */
                               explosing = true;
                            }
                        }
                    }
                }
            } else {
/** /?? 画保险动画?/ */
                baoxianY = baoxianY - N10 - N10;
                baoxianSprite.setPosition(0, baoxianY);
                baoxianSprite.paint(gg);
                baoxianSprite.nextFrame();
                if (baoxianY % N2 == 0) {
                    fexplosionSprite[0].setPosition(N20, N2 * baoxianY + N210);
                    fexplosionSprite[1].setPosition(N100, N2 * baoxianY + N210);
                    for (int z = 0; z < N2; z++) {
                        fexplosionSprite[z].paint(gg);
                        fexplosionSprite[z].nextFrame();
                    }
                }
                if (baoxianY < -((N6 * N10) + N100)) {
                    baoxianing = false;
                    baoxianY = screenHeight + N10 + N1;
                }
            }
/** /?? 爆炸场面开始?/ */
            if (explosing) {
                    explosionSprite.paint(gg);
                    explosionSprite.nextFrame();
                    baozha++;
            }
            if (baozha == (N10 + N10)) {
                explosing = false;
            }
        }
/** /?? 显示炸弹数量?/ */
        gg.drawImage(bombImage, N7, N4, N0);
        gg.setColor(N255, N255, N255);
        gg.drawString("X", N3 * N10 + N4, N7 + N2, N0);
        gg.drawString(Integer.toString(bombTotal), N4 * N10 + N2, N7 + N2, N0);
/** /?? 显示游戏时间?/ */
        gg.setColor(N255, N255, N255);
        gg.drawString("TIME:", N8 * N2 * N10, N7, N0);
        long nowTime = System.currentTimeMillis();
        if (planing) {
/** /?? 得到现在游戏时间?/ */
                   String aa = Long.toString(time);
                   gg.drawString(aa + "秒", N100 * N2 - N9, N7, N0);
                   if (time < gameTimeStart) {
                       time = (int) (nowTime - gameTimeStart) / (N10 * N100); }
        } else {
/** /?? 当飞机爆炸后，停止计时?/ */
            gg.drawString(Long.toString(time) + "秒", N100 * N2 - N9, N7, N0);
            String resultStr = StringTools.checkTime(time);
            gg.setColor(N255, N255, N255);
            gg.drawString("GAME OVER", N8 * N10, N8 * N10, N0);
            gg.drawString(resultStr, N5 * N10, N10 * N10, N0);
        }
/** /?? 保险增加10秒增加?/ */
        long addbombTime = System.currentTimeMillis();
        if (time % (N10 + N9) == N0) {
            if (time % N10 == N0 && time % (N10 + N9) == N0 && time != N0) {
                bombing = false;
            } else {
                bombing = true;
            }
        }
        if (time % N10 == N0 && time != N0 && time % (N10 + N9) != N0) {
            gg.setColor(N255, N255, N255);
            gg.drawString("You get a bomb!", N8 * N10, N3 * N10, N0);
            if (time % N10 == N0 && time != N0 && planing && bombing) {
                bombTotal++;
                bombing = false;
            }
        }
/** /?? 显示缓冲区?/ */
        flushGraphics();
    }
/** /?? 键盘控制飞机?/ */
    private void planeUpdate() {
        int keyState = getKeyStates();
        if ((keyState & UP_PRESSED) != N0) {
            planeSprite.move(N0, -N6);
            planeSprite.setFrame(0);
        }
        if ((keyState & DOWN_PRESSED) != N0) {
            planeSprite.move(N0, N6);
            planeSprite.setFrame(0);
        }
        if ((keyState & LEFT_PRESSED) != N0) {
            planeSprite.move(-N6, N0);
            planeSprite.setFrame(2);
        }
        if ((keyState & RIGHT_PRESSED) != N0) {
            planeSprite.move(N6, N0);
            planeSprite.setFrame(1);
        }
        if ((keyState & FIRE_PRESSED) != N0) {
/** /?? 飞机爆炸后，fire键是否能用?/ */
            if (planing) {
/** /?? 判断飞机是否有保险?/ */
                if (bombTotal > N0) {
                    baoxianing = true;
/** /?? 销毁所有子弹?/ */
                    for (int i = N0; i < bullet.getBulletsTotal(); i++) {
                        bullet.bulletDestroy(i);
                    }
/** /?? 重新初始化子弹 ?/ */
                    bullet.bulletInit(bullet.getBulletsTotal());
/** /?? 保险数量减一 ?/ */
                    bombTotal = bombTotal - N1;
                }
             }
        }
        checkPlane(planeSprite);
    }
/** /?? 检查飞机是否越界
?@param s ?/ */
    private void checkPlane(final Sprite s) {
/** /?? 判断飞机是否越过左边界 ?/ */
        if (s.getX() < N0) {
            s.setPosition(N0, s.getY());
        } else if (s.getX() > (screenWidth - s.getWidth())) {
            s.setPosition(screenWidth - s.getWidth(), s.getY());
        }
/** /?? 判断飞机是否越过上边界 ?/ */
        if (s.getY() < N0) {
            s.setPosition(s.getX(), N0);
        } else if (s.getY() > (getHeight() - s.getHeight())) {
            s.setPosition(s.getX(), getHeight() - s.getHeight());
        }
    }
/** /?? 清理工作 ?/ */
    public final void clearJob() {
        sleeping = true;
        bullet = null;
        bombTotal = N0;
        time = N0;
    }
}