gamecanvas.java

用java写的五子棋游戏

import com.nokia.mid.sound.Sound;
import com.nokia.mid.ui.FullCanvas;
import java.io.*;
import java.util.*;
import javax.microedition.lcdui.*;
import javax.microedition.rms.RecordStore;
import javax.microedition.rms.RecordStoreException;

public class GameCanvas extends FullCanvas implements Runnable{

  private static int ChessBoardOffset=11;//偏移量
  private static int ChessUnitage=11;//单位量
  private static int lineNum=15;

  public int gameStatus;
  private boolean isBlack;
  private int winner;
  private boolean canDropChessman;
  private int mainMenu;
  private int subMenu;
  private int helpState;
  private boolean pauseFlag;
  private RecordStore rStore;

  Image hand;
  Image back;
  Random rand=new Random();
  private Sound sD[];
  private Font sFont;

  public int ChessBoard[][];//状态
  public int ChessStatus[][][];//型态
  private int chess_x; //x
  private int chess_y;  //y

  private int computer_x;
  private int computer_y;

  private int last_x; //x
  private int last_y; //y
  private int[][][] power = new int[2][3][5];//存储权值
  int[][] Ctable;
  int computerfirst;





  public GameCanvas() {
    ChessBoard=new int[lineNum][lineNum];
    ChessStatus=new int[lineNum][lineNum][5];
    try{
      hand=Image.createImage("/hand.png");
      back=Image.createImage("/back.png");
    }catch(Exception e){
    	e.printStackTrace();
    }
    initPower();
    Ctable = new int[lineNum][lineNum];
    for(int i = 0; i < lineNum; i++)
    {
        for(int j = 0; j < lineNum; j++)
        {
            Ctable[i][j] = 0;
        }

        }
    computerfirst=0;
    GameInit();
  }


  private void GameInit(){

    for(int x=0;x<lineNum;x++){
      for(int y=0;y<lineNum;y++){
        ChessBoard[x][y]=0;
      }
    }

    chess_x=ChessBoardOffset+(lineNum/2)*ChessUnitage;
    chess_y=ChessBoardOffset+(lineNum/2)*ChessUnitage;

    computer_x=0;
    computer_y=0;

    gameStatus=1;//init
    isBlack=true;//
    winner=0;
    canDropChessman=true;
    pauseFlag=false;

    sFont=Font.getDefaultFont();

    Thread thread=new Thread(this);
    thread.start();
  }

  protected void paint(Graphics g) {
    g.setFont(sFont);
    int i = sFont.getHeight();
    if(gameStatus==1){
      g.setColor(204,255,94);
      //g.setColor(0xffcc00);
      g.fillRect(0,0,177,212);
      g.drawImage(back,87,104,g.VCENTER|g.HCENTER);
      g.setColor(0x000000);
      draw_chessboard(g);
      for(int x=0;x<lineNum;x++){
        for(int y=0;y<lineNum;y++){
          if(ChessBoard[x][y]==1){
            draw_chessman(g,x*ChessUnitage+ChessBoardOffset,y*ChessUnitage+ChessBoardOffset,true,(last_x==x&&last_y==y)?2:3);
          }
          if(ChessBoard[x][y]==2){
            draw_chessman(g,x*ChessUnitage+ChessBoardOffset,y*ChessUnitage+ChessBoardOffset,false,(last_x==x&&last_y==y)?2:3);
          }
        }
      }
      g.drawImage(hand,chess_x,chess_y+7,g.VCENTER|g.HCENTER);

      g.drawString("五子棋v0.7B by 今天真冷",(getWidth()-"五子棋v0.7B by 今天真冷".length())/2,1,g.HCENTER|g.BASELINE);
      draw_result(g);
      g.drawString("重试",3,203,g.LEFT|g.BOTTOM);
      g.drawString("退出",150,203,g.LEFT|g.BOTTOM);
    }
  }


 /**
  * 显示结果
  * */
  private void draw_result(Graphics g){
    if(winner==1){
       g.setColor(0xCCCCCC);
       g.fillRect(15,25,144,60);
       g.setColor(0xFF0000);
       g.drawString("祝贺您，嬴了这一局！",75,50,g.HCENTER|g.BASELINE);
    }else
     if(winner==2){
       g.setColor(0xCCCCCC);
       g.fillRect(15,25,144,60);
       g.setColor(0xFF0000);
       g.drawString("对不起，你输了这一局",75,50,g.HCENTER|g.BASELINE);
    }else{
        g.drawString("",62,180,g.HCENTER|g.BASELINE);
    }
  }

 /**
  * 打印debug信息
  * */
  private void draw_debug(Graphics g){
    g.drawString("("+java.lang.String.valueOf(chess_x)+","+java.lang.String.valueOf(chess_y)+")("+java.lang.String.valueOf((chess_x-ChessBoardOffset)/ChessUnitage)+","+java.lang.String.valueOf((chess_y-ChessBoardOffset)/ChessUnitage)+")",17,3,g.LEFT|g.TOP);
    g.drawString("LeftRight:"+java.lang.String.valueOf(ChessStatus[(chess_x-ChessBoardOffset)/ChessUnitage][(chess_y-ChessBoardOffset)/ChessUnitage][0]),17,175,g.LEFT|g.BOTTOM);
    g.drawString("UpDown:"+java.lang.String.valueOf(ChessStatus[(chess_x-ChessBoardOffset)/ChessUnitage][(chess_y-ChessBoardOffset)/ChessUnitage][1]),90,175,g.LEFT|g.BOTTOM);
    g.drawString("LeftUp:"+java.lang.String.valueOf(ChessStatus[(chess_x-ChessBoardOffset)/ChessUnitage][(chess_y-ChessBoardOffset)/ChessUnitage][2]),17,190,g.LEFT|g.BOTTOM);
    g.drawString("UpRight:"+java.lang.String.valueOf(ChessStatus[(chess_x-ChessBoardOffset)/ChessUnitage][(chess_y-ChessBoardOffset)/ChessUnitage][3]),90,190,g.LEFT|g.BOTTOM);
  }

  /**
   * 画棋盘 LineNum
   * */
  public void draw_chessboard(Graphics g){
    for(int x=ChessBoardOffset;x<=(lineNum-1)*ChessUnitage+ChessBoardOffset;x=x+ChessUnitage) {//line
      g.drawLine(x,ChessBoardOffset,x,(lineNum-1)*ChessUnitage+ChessBoardOffset);
      g.drawLine(ChessBoardOffset,x,(lineNum-1)*ChessUnitage+ChessBoardOffset,x);
    }
    g.drawRect(ChessBoardOffset-1,ChessBoardOffset-1,(lineNum-1)*ChessUnitage+2,(lineNum-1)*ChessUnitage+2);

    draw_chessman(g,ChessBoardOffset+7*ChessUnitage,ChessBoardOffset+7*ChessUnitage,true,1);
    draw_chessman(g,ChessBoardOffset+3*ChessUnitage,ChessBoardOffset+3*ChessUnitage,true,1);
    draw_chessman(g,ChessBoardOffset+11*ChessUnitage,ChessBoardOffset+11*ChessUnitage,true,1);
    draw_chessman(g,ChessBoardOffset+3*ChessUnitage,ChessBoardOffset+11*ChessUnitage,true,1);
    draw_chessman(g,ChessBoardOffset+11*ChessUnitage,ChessBoardOffset+3*ChessUnitage,true,1);

  }

  /**
   *  画棋子，分成3种：黑 白 点
   *
   * g : Canvas
   * x : x
   * y : y
   * isBlack :
   * mode : 1 点 2 棋子外加框 3 正常棋子
   *
   * */
  public void draw_chessman(Graphics g,int x,int y,boolean isBlack,int mode){
     if(mode!=1){//not point
       if(isBlack){
         g.setColor(0,0,0);
         g.drawArc(x-5,y-5,10,10,0,360);
         g.fillArc(x-5,y-5,10,10,0,360);
       }else{
         g.setColor(255,255,255);
         g.drawArc(x-5,y-5,10,10,0,360);
         g.fillArc(x-5,y-5,10,10,0,360);
       }
       if(mode==2){
         g.setColor(0,255,0);
         g.drawRect(x-5,y-5,10,10);
       }
     }else{//point
       g.setColor(0,0,0);
       g.drawRect(x-1,y-1,2,2);
       g.fillRect(x-1,y-1,2,2);
     }
       g.setColor(0xff0000);
  }

  public void run(){
    while(gameStatus==1){
      if(!isBlack){
        isBlack=!isBlack;
        checkStatus(2);
        computerdo();
        if(checkWin(computer_x,computer_y,2)) winner=2;
        ChessBoard[computer_x][computer_y]=2;
        canDropChessman=true;
        last_x=computer_x;
        last_y=computer_y;
      }
      try{Thread.sleep(1000L);}catch(Exception e){}
      repaint();
    }
  }



  public void computerdo()
  {
      AI();
      for(int i = 0; i < lineNum; i++)
      {
          for(int j = 0; j < lineNum; j++)
          {
              if(Ctable[i][j] >= Ctable[computer_x][computer_y] && ChessBoard[i][j] == 0)
              {
                  computer_x = i;
                  computer_y = j;
              }
          }

      }
    }


  public void keyPressed(int KeyCode){
    if(gameStatus==1){
      checkStatus(2);
      switch(KeyCode){
              case -1:{
                if(chess_y>=(ChessUnitage+ChessBoardOffset)){
                  chess_y=chess_y-ChessUnitage;
                }else{
                  chess_y=chess_y+ChessUnitage*(lineNum-1);
                }
                break;
              }
              case -2:{
                if(chess_y<(ChessUnitage*(lineNum-1)+ChessBoardOffset)){
                  chess_y=chess_y+ChessUnitage;
                }else{
                  chess_y=chess_y-ChessUnitage*(lineNum-1);
                      }
                break;
              }
              case -3:{
                if(chess_x>=(ChessUnitage+ChessBoardOffset)){
                  chess_x=chess_x-ChessUnitage;
                }else{
                  chess_x=chess_x+ChessUnitage*(lineNum-1);
                      }
                break;
              }
              case -4:{
                if(chess_x<(ChessUnitage*(lineNum-1)+ChessBoardOffset)){
                  chess_x=chess_x+ChessUnitage;
                }else{
                  chess_x=chess_x-ChessUnitage*(lineNum-1);
                      }
                break;
              }
              case -5:{
                if(checkPosition()&&winner==0&&canDropChessman){
                  canDropChessman=false;
                  if(isBlack){
                    if(checkWin((chess_x-ChessBoardOffset)/ChessUnitage,(chess_y-ChessBoardOffset)/ChessUnitage,1)) winner=1;
                    ChessBoard[(chess_x-ChessBoardOffset)/ChessUnitage][(chess_y-ChessBoardOffset)/ChessUnitage]=1;
                    last_x=(chess_x-ChessBoardOffset)/ChessUnitage;
                    last_y=(chess_y-ChessBoardOffset)/ChessUnitage;
                    isBlack=!isBlack;
                  }else{
                    if(checkWin((chess_x-ChessBoardOffset)/ChessUnitage,(chess_y-ChessBoardOffset)/ChessUnitage,2)) winner=2;
                    ChessBoard[(chess_x-ChessBoardOffset)/ChessUnitage][(chess_y-ChessBoardOffset)/ChessUnitage]=2;
                  }
                }
                break;
              }
              case -7:{
                  Five.quitApp();
                  break;
              }
              case -6:{
                  GameInit();
                  break;
              }
            case 48:{
                GameInit();
                ChessBoard[7][7]=2;
                last_x=7;
                last_y=7;
                break;
              }
            }
      repaint();
    }
  }

  /**
   * 位置合法性检查
   * */
  private boolean checkPosition(){
      if(ChessBoard[(chess_x-ChessBoardOffset)/ChessUnitage][(chess_y-ChessBoardOffset)/ChessUnitage]==0){
        return true;
      }else{
        return false;
      }
  }


  /**
   * 检查是否发生输赢，返回true则who win
   * */
  private boolean checkWin(int x,int y,int who){

    boolean isWin=false;

    Check(x,y,who);//检查该点棋型
    for(int i=0;i<4;i++){
      if(ChessStatus[x][y][i]==4) isWin=true;
    }

    return isWin;
  }


  /**
   *
   *   生成型表
   *
   *   ChessBoard[lineNum][lineNum];//状态
   *   ChessStatus[lineNum][lineNum][4];//型态
   *
   *   由状态表生成型态表
   *
   *   数值-权值 对照表:
   *
   *   数值     权值
   *   -----------------
   *    1        1
   *    2        2
   *    3        7
   *    4        19
   *
   * */
  private void checkStatus(int who){

    for(int x=0;x<lineNum;x++){
        for(int y=0;y<lineNum;y++){
          if(ChessBoard[x][y]==0){
            Check(x,y,who);
          }