midp1.0.txt

J2ME-MIDP1.0小游戏入门-五子棋1.0

package com.occo.j2me.game.gobang;

import javax.microedition.lcdui.Display;
import javax.microedition.midlet.MIDlet;
public class Gobang extends MIDlet {
    GobangCanvas gobang;//定义游戏界面的Canvas类GobangCanvas的对象gobang
    public Gobang() {
        super();
        gobang=new GobangCanvas(this);//生成GobangCanvas类的对象gobang
    }
    protected void startApp(){
        Display.getDisplay(this).setCurrent(gobang);
          //在屏幕上绘出游戏见面gobang
    }
    protected void pauseApp(){
    }
    protected void destroyApp(boolean arg0){
    }
}


游戏界面类：GobangCanvas.java
GobangCanvas类是游戏的核心类，继承自Canvas，此类将完成游戏的逻辑、绘图、控制、互动等所有功能，此类的框架代码如下：

package com.occo.j2me.game.gobang;
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Graphics;
public class GobangCanvas extends Canvas implements CommandListener{
    protected Gobang gobang;

    public GobangCanvas(){
    }
    public GobangCanvas(Gobang gobang){
        this.gobang=gobang;
    }
    protected void paint(Graphics g) {
    }
}


棋子类：Chesses.java
此类定义了一个棋子，棋盘上的每一个棋子都对应着一个Chesses的对象，整个棋盘是一个Chesses类型的二维数组，源代码如下：

package com.occo.j2me.game.gobang;
    public class Chesses {
    boolean isPlayer1;

    public Chesses() {
    }
    public Chesses(boolean isPlayer1) {
        this.isPlayer1=isPlayer1;
    }
}


添加图形图像
到现在，我们已经完成了游戏的一个基本框架，接下来，我们就可以来绘制游戏的每一个部件了
首先是五子棋的一些初始设置，添加如下代码到GobangCanvas.java

    ...
    int empty;//游戏界面到屏幕边缘的留空
    int canvasW,canvasH;//画布的长和宽
    int chessLength;//棋子的直径
    int chessMapLength,chessMapGrid,chessGridLength;
        //棋盘的边长，棋盘一边格子数，每格宽度
    int chessMapX,chessMapY;//棋盘左上角x,y坐标
    int selectedX,selectedY;//选择框在棋盘格局上的x,y位置
    boolean isPlayer1;//是否是玩家1
    Chesses[][] chesses;//棋子数组
    boolean newGame;//是否是新的游戏
    public GobangCanvas(Gobang gobang){
        newGame=true;
        empty=10;
        canvasW=getWidth()-empty;canvasH=getHeight()-empty;
        chessMapGrid=15;
        chesses=new Chesses[chessMapGrid+1][chessMapGrid+1];
        if(canvasW>canvasH){
            chessMapLength=canvasH-canvasH%chessMapGrid;
            chessMapX=(canvasW-chessMapLength)/2+empty/2;
            chessMapY=(canvasH%chessMapGrid)/2+empty/2;
        }
        else{
            chessMapLength=canvasW-canvasW%chessMapGrid;
            chessMapX=(canvasW%chessMapGrid)/2+empty/2;
            chessMapY=(canvasH-chessMapLength)/2+empty/2;
        }
        chessGridLength=chessMapLength/chessMapGrid;
        chessLength=chessGridLength-1;
        selectedX=selectedY=chessMapGrid/2;
        isPlayer1=true;
    }


最先要绘制的是棋盘，棋盘是正方形，但屏幕有矩形的，所以棋盘边长要按短边计，但短边未必是棋盘格子数的整数倍，因此
    棋盘边长 = 短边 - 短边 % 格子数
因为棋盘要居中，所以在算左上角坐标时，记得也要把留空(empty)除以2，以下是画棋盘的代码：

    protected void paintMap(Graphics g){
        for(int i=0;i<chessMapGrid;i++){
            for(int j=0;j<chessMapGrid;j++){
                g.setColor(128,128,128);
                g.drawRect(chessMapX+j*chessGridLength,
                              chessMapY+i*chessGridLength,
                              chessGridLength,chessGridLength);
            }
        }
    }


然后是绘制选择框，注意：选择框的selectedX,selectedY并不是在画布上的x,y坐标，而是在棋子数组(chesses)中的位置，源代码如下：

    protected void paintSelected(Graphics g){
        g.setColor(0,0,255);
        g.drawRect(chessMapX+selectedX*chessGridLength-chessGridLength/2,
                  chessMapY+selectedY*chessGridLength-chessGridLength/2,
                  chessGridLength,chessGridLength);
    }


接着是按照棋子二维数组绘制已经下了的棋子。玩家每下一次棋，就修改数组，在重新绘图的时候就能绘出，源代码如下：

    protected void paintChesses(Graphics g){
        for(int i=0;i<=chessMapGrid;i++){
            for(int j=0;j<=chessMapGrid;j++){
                if(chesses[i][j]!=null){
                    if(chesses[i][j].isPlayer1)
                        g.setColor(255,255,255);
                    else
                        g.setColor(255,0,0);
                    g.fillArc(chessMapX+j*chessGridLength-chessLength/2,
                            chessMapY+i*chessGridLength-chessLength/2,
                            chessLength,chessLength,0,360);
                }
            }
        }
    }


最后是绘制玩家提示框，并且把所有部件的绘制汇总在paint()方法中，注意绘制的顺序，显而易见，应该先绘制提示框-棋盘-选择框-棋子：

    protected void paintPlayer(Graphics g,boolean isPlayer1){
        if(isPlayer1)
            g.setColor(255,255,255);
        else
            g.setColor(255,0,0);
        g.drawRect(1,1,getWidth()-2,getHeight()-2);
        g.drawRect(2,2,getWidth()-4,getHeight()-4);
        g.drawRect(3,3,getWidth()-6,getHeight()-6);
    }
    protected void paint(Graphics g) {
        g.setColor(0x00000000);
        g.fillRect(0, 0, getWidth(), getHeight());
        paintPlayer(g,isPlayer1);
        paintMap(g);
        paintSelected(g);
        paintChesses(g);
    }


响应玩家操作
接下来应该添加命令按钮和游戏操作控制。我们在游戏中需要有两个按钮，重新开始和退出，此外还必须接收玩家控制选择框的操作上下左右和着棋，添加代码到GobangCanvas.java：

    Command exitCmd;
    Command restartCmd;
    public GobangCanvas(Gobang gobang){
        ...
        restartCmd = new Command("重新开始", Command.SCREEN, 0);
        exitCmd = new Command("退出", Command.EXIT, 0);
        addCommand(restartCmd);
        addCommand(exitCmd);
        setCommandListener(this);
    }
    private void init(){
        if(newGame){
            chesses=new Chesses[chessMapGrid+1][chessMapGrid+1];
            isPlayer1=true;
            selectedX=selectedY=chessMapGrid/2;
        }
    }
    public void commandAction(Command c, Displayable d) {
        if (c == exitCmd) {
            gobang.destroyApp(false);
            gobang.notifyDestroyed();
        }else if(c==restartCmd){
            init();//初始化棋盘，把棋盘清空，重新开始游戏
            repaint();
        }
    }
    protected synchronized void keyPressed(int keyCode) {
        int action = getGameAction(keyCode);
        if (action == Canvas.LEFT ) {
            selectedX=(--selectedX+chessMapGrid+1)%(chessMapGrid+1);     
        }
        else if (action == Canvas.RIGHT) {
            selectedX=(++selectedX)%(chessMapGrid+1);
        }
        else if (action == Canvas.UP) {
            selectedY=(--selectedY+chessMapGrid+1)%(chessMapGrid+1);
        }
        else if (action == Canvas.DOWN) {
            selectedY=(++selectedY)%(chessMapGrid+1);
        }
        else if (action == Canvas.FIRE) {
            if(chesses[selectedY][selectedX]==null){
                chesses[selectedY][selectedX]=new Chesses(this.isPlayer1);
                //checkWin();
                this.isPlayer1=!this.isPlayer1;//切换下棋方
            }
        }
        repaint();
    }
    private void checkWin(){
    }