gameengine.java

我是一个j2ee,开发人员

package src;

//游戏逻辑类
import java.util.*;
import javax.microedition.lcdui.*;
/**
 * 游戏数据和逻辑类
 * 未实现关卡变化的逻辑
 */
public class GameEngine {
     /**方块的信息， 0代表无内容，1代表有内容 */
     int[][][][] brick = {
                       {
                                 {
                                          { 0, 1, 0, 0 },
                                          { 0, 1, 0, 0 },
                                          { 0, 1, 1, 0 },
                                     { 0, 0, 0, 0 }
                                 },
                                 {
                                          { 0, 0, 0, 0 },
                                          { 0, 1, 1, 1 },
                                          { 0, 1, 0, 0 },
                                     { 0, 0, 0, 0 }
                                 },
                                 {
                                          { 0, 1, 1, 0 },
                                          { 0, 0, 1, 0 },
                                          { 0, 0, 1, 0 },
                                     { 0, 0, 0, 0 }
                                 },
                                 {
                                          { 0, 0, 0, 0 },
                                          { 0, 0, 1, 0 },
                                          { 1, 1, 1, 0 },
                                     { 0, 0, 0, 0 }
                                 }
                       },
                       {
                                 {
                                          { 0, 0, 1, 0 },
                                          { 0, 0, 1, 0 },
                                          { 0, 1, 1, 0 },
                                     { 0, 0, 0, 0 }
                                 },
                                 {
                                          { 0, 0, 0, 0 },
                                          { 0, 1, 0, 0 },
                                          { 0, 1, 1, 1 },
                                     { 0, 0, 0, 0 }
                                 },
                                 {
                                          { 0, 0, 0, 0 },
                                          { 0, 1, 1, 0 },
                                          { 0, 1, 0, 0 },
                                     { 0, 1, 0, 0 }
                                 },
                                 {
                                          { 0, 0, 0, 0 },
                                          { 1, 1, 1, 0 },
                                          { 0, 0, 1, 0 },
                                     { 0, 0, 0, 0 }
                                 }
                       },
                       {
                                 {
                                          {0,1,0,0},
                                          {0,1,0,0},
                                          {0,1,0,0},
                                          {0,1,0,0}
                                 },
                                 {
                                          {0,0,0,0},
                                          {1,1,1,1},
                                          {0,0,0,0},
                                          {0,0,0,0}
                                 }
                       },
                       {
                                 {
                                          {0,0,0,0},
                                          {0,1,1,0},
                                          {0,1,1,0},
                                          {0,0,0,0}
                                 }
                       },
                       {
                                 {
                                          {0,0,1,0},
                                          {0,1,1,0},
                                          {0,1,0,0},
                                          {0,0,0,0}
                                 },
                                 {
                                          {0,0,0,0},
                                          {0,1,1,0},
                                          {0,0,1,1},
                                          {0,0,0,0}
                                 }
                       },
                       {
                                 {
                                          {0,1,0,0},
                                          {0,1,1,0},
                                          {0,0,1,0},
                                          {0,0,0,0}
                                 },
                                 {
                                          {0,0,0,0},
                                          {0,1,1,0},
                                          {1,1,0,0},
                                          {0,0,0,0}
                                 }
                       },
                       {
                                 {
                                          {0,0,0,0},
                                          {0,0,1,0},
                                          {0,1,1,1},
                                          {0,0,0,0}
                                 },
                                 {
                                          {0,0,0,0},
                                          {0,1,0,0},
                                          {0,1,1,0},
                                          {0,1,0,0}
                                 },
                                 {
                                          {0,0,0,0},
                                          {0,1,1,1},
                                          {0,0,1,0},
                                          {0,0,0,0}
                                 },
                                 {
                                          {0,0,1,0},
                                          {0,1,1,0},
                                          {0,0,1,0},
                                          {0,0,0,0}
                                 }
                       }
     };
     /**行数*/
     final int MAXROW = 19;
     /**列数*/
     final int MAXCOL = 10;
     /**
      *游戏界面信息，0代表无内容，1代表有内容
      */
     int[][] map = new int[MAXROW][MAXCOL];
     /**每个单元格的宽度和高度*/
     public static final int CELLWIDTH = 10;
     /**下一个方块的类型*/
     int nextBrickType = 0;
     //当前下落的方块
     /**当前格子的类型*/
     int brickType;
     /**当前变形信息*/
     int index;
     /**当前行*/
     int cRow;
     /**当前列*/
     int cCol;
     /**速度*/
     int speed = 500;
     /**加速度*/
     int times = 1;
     /**当前关卡*/
     int level = 0;
     /**积分，每消一行加10分*/
     int score = 0;
     Random r = new Random();
     public GameEngine(){
              //产生方块
              gernerateBrick();
     }
    
     /**
      *绘制一个格子
      * @param g画笔对象
      * @param x格子左上角的x坐标
      * @param y格子左上角的y坐标
      */
     private void paintCell(Graphics g,int x,int y){
              //绘制黑色边框
              g.setColor(0);
              g.drawRect(x,y,CELLWIDTH,CELLWIDTH);
              //绘制边框
              g.setColor(0xffffff);
              g.fillRect(x+1,y+1,CELLWIDTH-2,CELLWIDTH-2);
              //黑块
              g.setColor(0);
              g.fillRect(x + 2, y + 2,
                                 CELLWIDTH - 4, CELLWIDTH - 4);
     }
    
     public void paintMap(Graphics g){
              //循环绘制地图
              for(int row = 0;row < map.length;row++){
                       for(int col = 0;col < map[row].length;col++){
                                 //是否绘制
                                 if(map[row][col] == 1){
                                          paintCell(g,col * CELLWIDTH,row * CELLWIDTH);
                                 }
                       }
              }
     }
    
     /**
      *绘制当前下落的方块
      * @param g画笔
      */
     public void paintBrick(Graphics g){
              for(int row = 0;row < 4;row++){
                       for(int col = 0;col < 4;col++){
                                 //判断是否绘制
                                 if(brick[brickType][index][row][col] == 1){
                                          int cx = (cCol + col) * CELLWIDTH;
                                          int cy = (cRow + row) * CELLWIDTH;
                                          paintCell(g,cx,cy);
                                 }
                       }
              }
     }
    
     /**下一个方块左上角的x坐标*/
     int nextBrickX = 110;
     /**下一个方块左上角的y坐标*/
     int nextBrickY = 30;
     /**下一个方块文字*/
     String str = "下一个方块";
     /**
      *绘制下一个方块
      * @param g画笔
      */
     public void paintNextBrick(Graphics g){
              //绘制文字
              g.drawString(str, nextBrickX, nextBrickY,
                                 Graphics.LEFT | Graphics.TOP);
              //绘制方块
              for(int row = 0;row < 4;row++){
                       for(int col = 0;col < 4;col++){
                                 //判断是否绘制
                                 if(brick[nextBrickType][0][row][col] == 1){
                                          int cx =nextBrickX + col * CELLWIDTH;
                                          int cy =nextBrickY + 20 + row * CELLWIDTH;
                                          paintCell(g,cx,cy);
                                 }
                       }
              }
     }
    
     String scoreStr = "当前得分：";
     /**
      *绘制游戏得分和关卡
      * @param g画笔
      */
     public void paintLevelAndScore(Graphics g){
              //绘制得分
              g.drawString(scoreStr,nextBrickX,100,
                                 Graphics.TOP | Graphics.LEFT);
              g.drawString(String.valueOf(score), nextBrickX, 115,
                                 Graphics.LEFT | Graphics.TOP);
              //绘制关卡
              g.drawString("第" + level + "关", nextBrickX, 150,
                                 Graphics.TOP | Graphics.LEFT);
     }
    
     /**
      *方块下落
      */
     public void brickDown(){
              //达到底部
              if(reachBottom()){
                       addBrickToMap();
                       //System.out.println("添加到界面成功");
                       gernerateBrick();
                       //System.out.println(1);
                       //清除满行
                       clearAllFullRow();
              }else{
                       cRow++;
                       //是否和地图数据重叠
                       if(collisWithMap()){
                                 //后退一行
                                 cRow--;
                                 //添加到地图中
                                 addBrickToMap();
                                 //产生新的方块
                                 gernerateBrick();
                                 //清除满行