gamemaincanvas.java

J2ME 上的坦克大战的demo,欢迎大家用来学习使用

/*
 * Created on 2006-2-4
 * Author: Xuefeng, Copyright (C) 2006, Xuefeng.
 */
package com.javaeedev.j2megame.tank;

import java.io.*;
import java.util.Random;

import javax.microedition.lcdui.*;
import javax.microedition.lcdui.game.*;

public class GameMainCanvas extends GameCanvas implements Runnable {

    private Random random = new Random();

    public static final int MAX_STEP_FRAMES = 4; // key frame accurs every 4 frames.
    public static final int STEP_WIDTH = 2; // how long a sprite moves in each frame.

    // active region:
    public static final int ACTIVE_WIDTH = 176;
    public static final int ACTIVE_HEIGHT = 176;

    private final int INTERVAL; // frame time

    // bullets:
    private BulletManager bulletManager;

    private boolean running = true; // thread is running or not
    private boolean paused = true; // frame is paused or not

    private long startTime; // start time.

    private Thread thread;

    // game elements:
    private LayerManager layerManager;
    private int layerManagerOnLeft;
    private int layerManagerOnTop;
    private GameMap map;
    private PlayerSprite player1;
    private EnemySprite[] enemies = new EnemySprite[1];

    public GameMainCanvas(int interval) {
        super(true);
        setFullScreenMode(true);
        // set LayerManager:
        layerManager = new LayerManager();
        layerManagerOnLeft = (getWidth()-ACTIVE_WIDTH) / 2;
        layerManagerOnTop = getHeight()-ACTIVE_HEIGHT;
        layerManager.setViewWindow(0, 0, ACTIVE_WIDTH, ACTIVE_HEIGHT);
        // load game map:
        Image mapImage = null;
        try {
            mapImage = Image.createImage("/tile.png");
        }
        catch(IOException ioe) {}
        // 20x20 for 176x220 LCD:
        int[][] res = new int[][] {
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 0, 0},
                {2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {2, 2, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {2, 2, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},

                {3, 3, 3, 3, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 3, 3},
                {3, 3, 3, 3, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 3, 3},
                {3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 3, 3},
                {3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 3, 3},
                {3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, 0, 0, 3, 3},

                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5},
                {5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5},
                {5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},

                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4},
                {4, 4, 0, 4, 4, 4, 0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 4, 4, 4, 4},
                {4, 4, 0, 4, 4, 4, 0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0},

                {3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 3, 3, 3, 3, 3, 0, 0, 4, 4, 4, 4},
                {3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 3, 3, 3, 3, 3, 0, 0, 4, 4, 4, 4},
        };
        map = new GameMap(res, mapImage);
        // init bulletManager:
        bulletManager = new BulletManager(map);
        // load player:
        Image playerImage = null;
        try {
            playerImage = Image.createImage("/player1.png");
        }
        catch(IOException ioe) {}
        player1 = new PlayerSprite(this, 0, 0, playerImage, Canvas.UP);
        // load enemy:
        Image enemyImage = null;
        try {
            enemyImage = Image.createImage("/enemy1.png");
        }
        catch(IOException ioe) {}
//        enemy1 = new EnemySprite(this, 21, 0, enemyImage, Canvas.RIGHT);
        // init layers:
        layerManager.append(player1);
        for(int i=0; i<enemies.length; i++) {
            enemies[i] = new EnemySprite(this, 20, 0, enemyImage, Canvas.RIGHT);
            layerManager.append(enemies[i]);
        }
        layerManager.append(map);
        // start thread:
        INTERVAL = interval;
        thread = new Thread(this);
        thread.start();
        // wait until thread is started:
        while(!thread.isAlive()) {}
        System.out.println("Thread is running...");
    }

    public GameMap getGameMap() {
        return map;
    }

    synchronized public boolean isRunning() {
        return running;
    }

    public void stopGame() {
        synchronized(this) {
            running = false;
        }
        // wait until thread is end:
        while(thread.isAlive()) {}
        System.out.println("Thread ended.");
    }

    synchronized public void pauseGame(boolean paused) {
        this.paused = paused;
        System.out.println("Game is " + (paused ? "paused." : "resumed."));
    }

    /**
     * Main loop thread for game logic.
     */
    public void run() {
        try {
        int frameId = 0;
        int keys = getKeyStates();
        while(running) {
            if(isShown()) {
                if(frameId==0) {
                    keys = getKeyStates();
                    if((keys & GameCanvas.GAME_D_PRESSED)!=0) { // pause/resume game
                        pauseGame(!paused);
                    }
                }
                if(paused) {
                    drawPaused();
                    try {
                        Thread.sleep(INTERVAL);
                    }
                    catch(InterruptedException ie) {}
                }
                else {
                    startFrame();
                    if(frameId==0)
                        executeKeyFrame(keys);
                    else
                        executeStepFrame(frameId);
                    frameId++;
                    if(frameId>=MAX_STEP_FRAMES)
                        frameId = 0;
                    endFrame();
                }
            }
            else {
                try {
                    Thread.sleep(INTERVAL);
                }
                catch(InterruptedException ie) {}
            }
        }
        }
        catch(Exception ee){ee.printStackTrace();}
    }

    private void startFrame() {
//        System.out.println("Frame is stated...");
        startTime = System.currentTimeMillis();
    }

    /**
     * End current frame.
     * 
     * @return True if cpu is 100% in use, False if cpu has free time.
     */
    private boolean endFrame() {
//        System.out.println("Frame is ending...");
        // paint:
        repaint();
        // check if there is still has time:
        long currTime = System.currentTimeMillis();
        long endTime = startTime + INTERVAL;
        if(currTime<endTime) {
            // should sleep:
            try {
                Thread.sleep(endTime-currTime);
            }
            catch(InterruptedException e) {}
//            System.out.println("End Frame & sleep " + (endTime-currTime) + " ms. CPU usage = " + ((currTime-startTime)*100/INTERVAL) + "%");
            return false;
        }
//        System.out.println("End Frame & overtime " + (currTime-endTime) + " ms.");
        return true;
    }

    private void executeKeyFrame(int key) {
        computerThink();

        // parse direction:
        if((key & UP_PRESSED) != 0) {
            player1.stay();
            player1.moveUp();
        }
        else if((key & DOWN_PRESSED) != 0) {
            player1.stay();
            player1.moveDown();
        }
        else if((key & LEFT_PRESSED) != 0) {
            player1.stay();
            player1.moveLeft();
        }
        else if((key & RIGHT_PRESSED) != 0) {
            player1.stay();
            player1.moveRight();
        }
        else {
            player1.stay();
        }
        // parse fire:
        if((key & FIRE_PRESSED)!=0) {
            bulletManager.newBullet(player1.fire());
        }
    }

    private void executeStepFrame(int frameId) {
        // frameId is from 1 to MAX_STEP_FRAMES.
//        System.out.println("executing frame " + frameId + "...");
        for(int i=0; i<enemies.length; i++)
            enemies[i].moveStep(frameId);
        player1.moveStep(frameId);
    }

    public void paint(Graphics g) {
        g.setColor(0);
        g.fillRect(0, 0, getWidth(), getHeight());
        layerManager.paint(g, layerManagerOnLeft, layerManagerOnTop);
        g.translate(layerManagerOnLeft, layerManagerOnTop);
        bulletManager.paint(g);
    }

    private void drawPaused() {
//        System.out.println("drawPaused()");
        Graphics g = getGraphics();
        g.drawString("paused...", 0, 0, Graphics.LEFT|Graphics.TOP);
        flushGraphics();
    }

    private void computerThink() {
        // first locate the player:
        int px = player1.getMapX();
        int py = player1.getMapY();
        // then locate the enemy:
        for(int i=0; i<enemies.length; i++) {
            //int ex = enemies[i].getMapX();
            //int ey = enemies[i].getMapY();
            int dirLR = 0;// = (px==ex) ? 0 : (px<ex ? Canvas.LEFT : Canvas.RIGHT);
            int dirUD = 0;// = (py==ey) ? 0 : (py<ey ? Canvas.UP : Canvas.DOWN);
            // then try to get near player:
            enemies[i].stay();
            boolean moved = false;
            int rnd = random.nextInt()%4;
            System.out.println("player " + i + "'s rnd: " + rnd);
            if(rnd==0)
                dirLR = Canvas.LEFT;
            if(rnd==1)
                dirLR = Canvas.RIGHT;
            if(rnd==2)
                dirUD = Canvas.DOWN;
            if(rnd==3)
                dirUD = Canvas.UP;
            if(dirLR!=0) {
                moved = enemies[i].moveTo(dirLR);
            }
            if(!moved && dirUD!=0) {
                moved = enemies[i].moveTo(dirUD);
            }
            // if at line, fire:
            if(dirLR==0 || dirUD==0) {
                System.out.println("Enemy fire!");
                bulletManager.newBullet(enemies[i].fire());
            }
        }
    }
}