maincanvas.java

欢迎使用蓝牙联网坦克大战

package newpackagetank;

import java.util.Random;

import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.GameCanvas;
import javax.microedition.lcdui.game.LayerManager;
import javax.microedition.lcdui.game.Sprite;

public class MainCanvas extends GameCanvas
        implements Runnable, CommandListener {

    public static final int GAME_UI = 0;	//进入用户界面
    public static final int GAME_GAMING = 1;	//进行游戏
    public static final int GAME_BUTTON = 2;	//游戏时显示界面按钮
    public static final int GAME_END = 3;	//游戏结束
    public static final int GAME_STATE_NUM = 4;	//状态总数
    private int m_nState = GAME_UI;						//存储当前的游戏状态
    private boolean m_bRunning;			    		//控制线程运行
    private MyUI m_UI;							//界面对象
    private Sprite m_TextSp;						//图形文字对象
    private int m_nTotalETank;					//敌方坦克总数
    private int m_nDestroyETank;				//目前消灭的敌方坦克数
    private int m_nCount;                                       //目前生成坦克数量
    private EnemyTank m_eTank[];						//敌方坦克对象
    private Scene m_Scene;						//场景对象
    private ExplosionSprite m_aExplosion[];				//爆炸对象
    private Random m_Random;						//随机数对象
    private LayerManager m_LayerManager;					//层管理器对象
    //高级按钮对象
    private Command restartCommand;
    private Command exitCommand;
    private TankMidlet midlet;
    private CombatCanvas canvas;
    private static int mode;
    private PlayerTank m_Tank1;
    private PlayerTank m_Tank2;

    public MainCanvas(TankMidlet mid, CombatCanvas canvas, int mode) {
        super(true);
        midlet = mid;
        this.canvas = canvas;
        this.mode = mode;
        try {
            //创建用户界面，并设置界面中的按钮
            MyButton button = new MyButton(41, 21, 0, 1, -1, -1, -1, 2);
            m_UI = new MyUI(button);


        } catch (Exception e) {
            System.out.println("yichang");
        }


        setState(GAME_UI);
        Start();

    }
    //重新开牌
    protected void Reset() {
        //创建随机数对象
        if (m_Random == null) {
            m_Random = new Random();
        }
        if (m_Tank1 == null) {
            m_eTank = new EnemyTank[2];
            m_aExplosion = new ExplosionSprite[3];
            try {
                //创建坦克对象
                Image image = Image.createImage("/demo/tank.png");
                if (this.mode == 0) {
                    m_Tank1 = new PlayerTank(image, 13, 13);
                } else {
                    m_Tank1 = new PlayerTank(image, 13, 13);
                    m_Tank2 = new PlayerTank(image, 13, 13);
                }
                image = Image.createImage("/demo/enemyTank.png");
                for (int n = 0; n < m_eTank.length; n++) {
                    m_eTank[n] = new EnemyTank(image, 13, 13);
                }
                //创建爆炸对象
                image = Image.createImage("/demo/explosion.png");
                for (int m = 0; m < m_aExplosion.length; m++) {
                    m_aExplosion[m] = new ExplosionSprite(image, 21, 17);
                }
            } catch (Exception e) {
            }
        }
        //创建场景对象
        if (m_Scene == null) {
            m_Scene = new Scene();
        }
        if (m_LayerManager == null) {//创建层管理器，并将所有图层添加到管理器
            m_LayerManager = new LayerManager();
            for (int m = 0; m < m_aExplosion.length; m++) {
                m_LayerManager.append(m_aExplosion[m]);
            }
            m_LayerManager.append(m_Scene.m_LyCanPass);
            if (mode == 0) {
                m_LayerManager.append(m_Tank1);
                m_LayerManager.append(m_Tank1.m_Bullet);
            } else {
                m_LayerManager.append(m_Tank1);
                m_LayerManager.append(m_Tank1.m_Bullet);

                m_LayerManager.append(m_Tank2);
                m_LayerManager.append(m_Tank2.m_Bullet);
            }


            for (int n = 0; n < m_eTank.length; n++) {
                m_LayerManager.append(m_eTank[n]);
                m_LayerManager.append(m_eTank[n].m_Bullet);
            }
            m_LayerManager.append(m_Scene.m_LyBulletPass);
            m_LayerManager.append(m_Scene.m_LyCanHit);
            m_LayerManager.append(m_Scene.m_LyNotPass);
            m_LayerManager.append(m_Scene.m_LyHQ);
        }
        //敌方坦克总共10辆
        m_nTotalETank = 10;
        //当前尚未消灭敌方坦克
        m_nDestroyETank = 0;
        m_nCount = 0;
        //读取场景地图
        m_Scene.LoadMap();
        //玩家坦克启动
        if (mode == 0) {
            m_Tank1.Start(15 * 2 + 7, 15 * 8 + 7, 0, 2);

        }
        if (mode == 1) {
            m_Tank1.Start(15 * 2 + 7, 15 * 8 + 7, 0, 2);

            m_Tank2.Start(15 * 8 + 7, 15 * 8 + 7, 0, 2);

        }
        if (mode == 2) {
            m_Tank1.Start(15 * 8 + 7, 15 * 8 + 7, 0, 2);

            m_Tank2.Start(15 * 2 + 7, 15 * 8 + 7, 0, 2);

        }

        //设置游戏画面的显示区域
        SetViewWindow();



        if (restartCommand == null) {
            //创建菜单
            restartCommand = new Command("Restart", Command.OK, 1);
            exitCommand = new Command("EXIT", Command.EXIT, 2);
            addCommand(restartCommand);
            addCommand(exitCommand);

            setCommandListener(this);
        }
        if (m_TextSp == null) {
            //创建图形文字对象
            try {
                Image img = Image.createImage("/demo/text.png");
                m_TextSp = new Sprite(img, 82, 25);
                m_TextSp.defineReferencePixel(41, 23);
                int x = getWidth() / 2;
                int y = getHeight() / 2 - 10;
                m_TextSp.setRefPixelPosition(x, y);
            } catch (Exception exception) {
            }
        }

    }

    //设置游戏画面的显示区域
    private void SetViewWindow() {
        if (m_LayerManager == null) {
            return;
        }
        m_LayerManager.setViewWindow(0, 0, Integer.MAX_VALUE, Integer.MAX_VALUE);
    }

    private void setState(int state) {					//设置游戏状态
        if (state < 0 || state >= GAME_STATE_NUM) {
            return;
        }
        m_nState = state;
        switch (m_nState) {
            case GAME_UI:										//进入用户界面
                m_UI.setState(MyUI.UI_TITLE);					//显示标题界面
                //设置本游戏的按钮类型，本游戏有:开始及退出两种按钮
                m_UI.getButton().setShow(true, false, false, false, false, true);
                break;
            case GAME_BUTTON:									//在游戏中途显示按钮
                m_UI.setState(MyUI.UI_BUTTON);
                //游戏中途，显示复位与退出按钮
                m_UI.getButton().setShow(false, true, false, false, false, true);
                break;
            case GAME_GAMING:									//正在游戏
                m_UI.setState(MyUI.UI_HIDE);
                break;
            case GAME_END:										//游戏结束
                m_UI.setState(MyUI.UI_HIDE);
                break;
        }
    }

    public void Start() {

        m_bRunning = true;
        Thread thread = new Thread(this);	//分配新线程
        thread.start();						//线程启动

    }

    public void run() {
        //得到系统当前时间,并将时间换算成毫秒
        long T1 = System.currentTimeMillis();
        long T2 = T1;
        while (m_bRunning) {
            T2 = System.currentTimeMillis();
            if (T2 - T1 > 50) {			//间隔50毫秒
                T1 = T2;
                Input();
                Logic();
                Paint();
            }
        }
    }

    public void Stop() {
        m_bRunning = false;
    }
//发送主坦克位置信息
    public void sendMessage(int x) {

        this.canvas.sendStartShootData(x);

    }

    public void setTankNewPosition(int keyStates) {
        try {
            Thread.sleep(30);
        } catch (InterruptedException e) {

        }
        m_Tank2.InputClient(keyStates);
        CheckCollision();

    }

    //发送敌方坦克信息
    public void sendEnemyMessage(int x, int number) {

        this.canvas.sendEnemyTankData(x, number);

    }

    public void setEnemyTankNewPosition(int dir, int num) {



        m_eTank[num].LogicClient(dir);
        //CheckCollision();
        if (m_Tank2.collidesWith(m_Scene.m_LyBulletPass, false)) {
            m_Tank2.MoveBack();
        } else if (m_Tank2.collidesWith(m_Scene.m_LyCanHit, false)) {
            m_Tank2.MoveBack();
        } else if (m_Tank2.collidesWith(m_Scene.m_LyNotPass, false)) {
            m_Tank2.MoveBack();
        }

        for (int n = 0; n < m_eTank.length; n++) {

            //敌人和地图碰撞，敌人向后退




            if (m_eTank[n].collidesWith(m_Scene.m_LyBulletPass, false)) {
                m_eTank[n].MoveBack();
            } else if (m_eTank[n].collidesWith(m_Scene.m_LyCanHit, false)) {
                m_eTank[n].MoveBack();
            } else if (m_eTank[n].collidesWith(m_Scene.m_LyNotPass, false)) {
                m_eTank[n].MoveBack();
            }
        }
    }

    public void shootEnemyBullet(int dir, int number) {
        this.canvas.sendEnemyBullet(dir, number);

    }

    public void startEnemyBullet(int dir, int number) {


        int x = m_eTank[number].getRefPixelX();
        int y = m_eTank[number].getRefPixelY();
        m_eTank[number].CreateEnemyBullet(dir, x, y);

    }

    public void sendMapMessage(int col, int row) {
        canvas.sendMapMessage(col, row);
    }

    public void resetMap(int col, int row) {
        m_Scene.m_LyCanHit.setCell(col, row, 0);

    }

    public void sendDeath(int num) {

        canvas.sendDeath(num);

    }

    public void setDeath(int num) {
        switch (num) {

            case 1:
                if (m_Tank2.isVisible()) {
                    m_Tank2.setVisible(false);
                }
                break;
            case 2:
                if (m_Tank1.isVisible()) {
                    m_Tank1.setVisible(false);
                }
                break;
            case 3:
                if (m_nState == GAME_GAMING) {
                    m_TextSp.setFrame(1);
                    setState(GAME_END);
                }
            case 4:
                if (m_Tank2.isVisible()) {
                    m_Tank2.setVisible(false);
                }
                break;
            case 5:
                System.out.println("客户端退出连接");
                midlet.quit();
                break;
            case 6:
                if (m_nState == GAME_GAMING) {
                    m_TextSp.setFrame(0);
                    setState(GAME_END);
                }
                break;
            case 7:
                m_eTank[0].setVisible(false);
                if (m_nDestroyETank >= m_nTotalETank) {
                    //消灭的所有坦克，游戏胜利                   
                    sendDeath(6);
                    try {
                        Thread.sleep(800);
                    } catch (InterruptedException e) {

                    }
                    m_TextSp.setFrame(0);
                    setState(GAME_END);
                }
                break;
            case 8:
                m_eTank[0].setVisible(false);
                if (m_nDestroyETank >= m_nTotalETank) {
                    //消灭的所有坦克，游戏胜利                   
                    sendDeath(6);
                    try {
                        Thread.sleep(800);
                    } catch (InterruptedException e) {

                    }
                    m_TextSp.setFrame(0);
                    setState(GAME_END);
                }
                break;

            default:
                break;

        }


    }

    public void sendStartToServer(int start) {
        this.canvas.sendStartToServer(start);
    }

    public void startServerEnemy(int start) {

        if (m_nState == GAME_GAMING) {
            if (start == 1) {
                for (int n = 0; n < m_eTank.length; n++) {
                    if (m_eTank[n].isVisible()) {
                        continue;
                    }
                    m_eTank[n].Start(n * 2 * 15 + 15 + 7, 15 + 7, 2, 1);
                    break;
                }

            }
        }
        if (m_nState == GAME_END) {
            Reset();
            for (int n = 0; n < m_eTank.length; n++) {
                m_eTank[n].Start(n * 2 * 15 + 15 + 7, 15 + 7, 2, 1);
            }
            setState(GAME_GAMING);
        }


    }

    public void Input() {
        int keyStates = getKeyStates();
        switch (m_nState) {
            case GAME_UI:
                 {
                    switch (m_UI.Input(keyStates)) {
                        case MyButton.BUTTON_START:					//按下开始键
                            Reset();
                            setState(GAME_GAMING);
                            break;
                        case MyButton.BUTTON_EXIT:					//按下退出键
                            TankMidlet.midlet.notifyDestroyed();
                            break;
                    }
                }
                break;
            case GAME_GAMING:									//游戏中
                if (mode == 0) {
                    if (m_Tank1.isVisible()) {
                        m_Tank1.Input(keyStates);
                    }
                } else {
                    if (m_Tank1.isVisible()) {
                        m_Tank1.Input(keyStates, this);
                    }