J2ME游戏代码示例(一)——俄罗斯方块(转载)

最新推荐文章于 2015-06-25 18:45:00 发布
最新推荐文章于 2015-06-25 18:45:00 发布
阅读量798 收藏 1
点赞数 1
文章标签： 游戏 j2me action import string random
         下面是我写的一个简单的俄罗斯方块游戏代码，代码中主要包含3个类：
l TerrisMIDlet——MIDlet类
l GameCanvas——游戏界面类
l GameEngine——游戏逻辑类
使用WTK2.5.1运行通过.
     具体代码如下：
//MIDlet类
import javax.microedition.midlet.MIDlet;
import javax.microedition.lcdui.*;
 
public class TerrisMIDlet extends MIDlet {
         public TerrisMIDlet() {
                   Display.getDisplay(this).setCurrent(new GameCanvas());
         }
         protected void destroyApp(boolean arg0) {}
         protected void pauseApp() {}
         protected void startApp() {}
}
 
//界面类
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
 
/**
 * 俄罗斯方块游戏界面
 */
public class GameCanvas extends Canvas implements Runnable{
     GameEngine engine = new GameEngine();
     int width;
     int height;
     /**游戏结束变量*/
     boolean gameOver = false;
     /**游戏暂停变量*/
     boolean isPaused = false;
     String pauseStr = "暂停";
     String continueStr = "继续";
     public GameCanvas(){
              //全屏幕
              setFullScreenMode(true);       
              width = getWidth();
              height = getHeight();
              //启动线程
              Thread th = new Thread(this);
              th.start();
     }
    
     protected void paint(Graphics g) {
              //清屏
              clearScreen(g);
              //绘制边框
              paintBoard(g);
              //绘制背景
              engine.paintMap(g);
              //绘制当前下落方块
              engine.paintBrick(g);
              //绘制下一个方块
              engine.paintNextBrick(g);
              //绘制关卡和游戏得分
              engine.paintLevelAndScore(g);
              //绘制游戏结束
              if(gameOver){
                       g.drawString("Game Over", 30, 85,
                                          Graphics.TOP | Graphics.LEFT);
              }
              //绘制暂停按钮文字
              if(isPaused){
                       g.drawString(pauseStr,width,height,
                                          Graphics.RIGHT | Graphics.BOTTOM);
              }else{
                       g.drawString(continueStr,width,height,
                                          Graphics.RIGHT | Graphics.BOTTOM);
              }
     }
    
     public void keyPressed(int keyCode){
              if(keyCode == -7){ //右软键，暂停控制
                       isPaused = !isPaused;
              }
              if(!isPaused){
                       int action = getGameAction(keyCode);
                       switch(action){
                       case UP:
                       case FIRE:
                                 engine.changeShape();
                                 break;
                       case LEFT:
                                 engine.moveToLeft();
                                 break;
                       case RIGHT:
                                 engine.moveToRight();
                                 break;
                       case DOWN:
                                 engine.highSpeed(); //加速
                                 break;
                       }
              }
              repaint();         
     }
    
     public void keyReleased(int keyCode){
              int action = getGameAction(keyCode);
              switch(action){
              case DOWN:
                       engine.normalSpeed(); //恢复正常速度
                       break;
              }
     }
    
     /**
      * 绘制游戏区域边框
      * @param g 画笔
      */
     private void paintBoard(Graphics g){
              g.drawRect(0,0,
                                 engine.MAXCOL * engine.CELLWIDTH,
                                 engine.MAXROW * engine.CELLWIDTH);
     }
    
     /**
      * 清屏
      * @param g 画笔
      */
     private void clearScreen(Graphics g){
              g.setColor(0xffffff);
              g.fillRect(0,0,width,height);
              g.setColor(0);
     }
 
     public void run() {
              try{
                       while(true){
                                 //延时
                                 Thread.sleep(engine.speed / engine.times);
                                 //逻辑处理
                                 //如果不处于暂停状态
                                 if(!isPaused){
                                          //方块下落
                                          engine.brickDown();
                                          //游戏是否结束
                                          if(engine.isGameOver()){
                                                   //显示游戏结束
                                                   gameOver = true;
                                                   //重画
                                                   repaint();
                                                   //结束线程
                                                   break;
                                          }
                                 }
                                 //重绘
                                 repaint();
                       }
              }catch(Exception e){
                       e.printStackTrace();
              }                
     }
}
 
//游戏逻辑类
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();
                                 //清除满行
                                 clearAllFullRow();
                       }
              }
     }
    
     /**
      * 随机产生方块
      */
     public void gernerateBrick(){
              //把下一个方块的类型赋值给当前方块
              brickType = nextBrickType;
              //生成下一个的类型
              nextBrickType = Math.abs(r.nextInt() % brick.length);
              //初始化数据
              index = 0;
              //位置
              cRow = -3;
              cCol = 3;
     }
    
     /**
      * 判断方块是否下落到游戏区域底部
      * @return true代表下落到底部
      */
     private boolean reachBottom(){     
              int tempRow = getBottomNotEmptyRow();
              //是否是最后一行
              if(cRow + tempRow >= MAXROW - 1){
                       return true;
              }else{
                       return false;
              }
     }
    
     /**
      * 添加方块到地图数据
      */
     private void addBrickToMap(){
              for(int i = 0;i < 4;i++){
                       for(int j = 0;j < 4;j++){
                                 //判断数据未超出地图边界
                                 if(((cCol+j) >= 0) &&
                                                   ((cCol + j < MAXCOL)) &&
                                                   ((cRow + i < MAXROW))){
                                          //不添加0的数据
                                          if(brick[brickType][index][i][j] == 1){
                                                   map[cRow + i][cCol + j] =
                                                             brick[brickType][index][i][j];
                                          }
                                 }
                       }
              }
     }
    
     /**
      * 方块变形
      */
     public void changeShape(){
              //变形到下一种形状
              index++;
              if(index == brick[brickType].length){
                       index = 0;
              }
              //变形以后的位置是否超出边界
              if(testNewPosition()){
                       index--;//退回原来的形状
              }
              if(index < 0){
                       index = brick[brickType].length - 1;
              }
     }
    
     /**
      * 方块向左移动
      * 原则是：方块左侧的第一行非空列贴近边界
      */
     public void moveToLeft(){
             cCol--;
             //如果新的位置不可用
             if(testNewPosition()){
                         cCol++;
             }
     }
    
     /**
      * 获得方块左侧的非空列的序号
      * @return
      */
     private int getLeftNotEmptyLine(){
              for(int col = 0;col < 4;col++){
                       for(int row = 0;row < 4;row++){
                                 if(brick[brickType][index][row][col] == 1){
                                          return col;
                                 }
                       }
              }
              return 0;
     }
    
     /**
      * 方块向右移动
      */
     public void moveToRight(){
                cCol++;
                //如果新的位置不可用
                if(testNewPosition()){
                          cCol--;
               }
     }
    
     /**
      * 获得方块右侧第一个非空列的序号
      * @return 非空列的序号
      */
     private int getRightNotEmptyLine(){
              for(int col = 3;col >= 0;col--){
                       for(int row = 0;row < 4;row++){
                                 if(brick[brickType][index][row][col] == 1){
                                          return col;
                                 }
                       }
              }
              return 3;
     }
    
     /**
      * 方块底部的第一个非空行的行号
      * @return 行号
      */
     private int getBottomNotEmptyRow(){
              for(int row = 3;row >= 0;row--){
                       for(int col = 0;col < 4;col++){
                                 if(brick[brickType][index][row][col] == 1){
                                          //System.out.println("底部非空行：" + row);
                                          return row;
                                 }
                       }
              }
              return 3;
     }
    
     /**
      * 测试新的位置是否可用
      * @return true代表不可用，false代表可用
      */
     private boolean testNewPosition(){
              //左侧
              if((getLeftNotEmptyLine() + cCol) < 0){
                       return true;
              }
              //右侧
              if(cCol + getRightNotEmptyLine() > MAXCOL - 1){
                       return true;
              }
              //下边界
              if(getBottomNotEmptyRow() + cRow >= MAXROW - 1){
                       System.out.println(222);
                       return true;
              }
              //是否和地图重合
              if(collisWithMap()){
                       return true;
              }
              return false;
     }
    
     /**
      * 是否和已有的方块叠加
      * @return true代表叠加，false代表未叠加
      */
     private boolean collisWithMap(){
              for(int col = 0;col < 4;col++){
                       for(int row = 3;row >= 0;row--){
                                 //有格子
                                 if(brick[brickType][index][row][col] == 1){
                                          //下标未越界
                                          if((cRow +row >= 0) && (cRow + row <= MAXROW - 1) &&
                                                             (cCol + col >= 0) && (cCol + col <= MAXCOL - 1)){
                                                   //判别地图数据
                                                   if(map[cRow + row][cCol + col] == 1){ //重叠
                                                             return true;
                                                   }else{
                                                             break;
                                                   }
                                          }
                                 }
                       }
              }
              return false;
     }
    
     /**
      * 清除满行
      */
     private void clearAllFullRow(){
              for(int row = MAXROW - 1;row >= 0;row--){
                       //如果是满行
                       if(isFullRow(row)){
                                 //增加积分
                                 score += 10;
                                 //消当前行
                                 clearOneFullRow(row);
                                 row++; //继续处理当前行
                       }
              }
     }
    
     /**
      * 判断是否是满行
      * @param row 行号
      * @return true代表是满行，false代表不是满行
      */
     private boolean isFullRow(int row){
              int count = 0;
              for(int col = 0;col < MAXCOL;col++){
                       if(map[row][col] == 1){
                                 count++;
                       }
              }
              if(count == MAXCOL){
                       return true;
              }else{
                       return false;
              }
     }
    
     /**
      * 消掉一个满行
      * @param row 需要消的行号
      */
     private void clearOneFullRow(int row){
              //上面的行全部下落
              for(int i = row - 1;i >= 0;i--){ //循环上面所有的行
                       for(int col = 0;col < MAXCOL;col++){
                                 //下落
                                 map[i + 1][col] = map[i][col];
                       }
              }
              //把第一行数据全部初始化为空
              for(int col = 0;col < MAXCOL;col++){
                       map[0][col] = 0;
              }
     }
    
     /**
      * 游戏是否结束
      * @return true代表结束，false代表未结束
      */
     public boolean isGameOver(){
              //下一个位置是否和地图数据重合
              cRow++;
              if(collisWithMap()){
                       cRow--; //还原位置
                       //判断屏幕第一行以上是否有数据
                       if(cRow < 0){
                                 for(int row = 0;row < 4;row++){
                                          for(int col = 0;col < 4;col++){
                                                   if(row + cRow >= 0){
                                                             break;
                                                   }else{ //屏幕上面的行
                                                             if(brick[brickType][index][row][col] == 1){
                                                                      return true;
                                                             }
                                                   }
                                          }
                                 }
                       }
              }else{
                       cRow--;
              }
              return false;
     }
    
     /**
      * 高速下落,速度是正常速度的2倍
      */
     public void highSpeed(){
              times = 5;
     }
    
     /**
      * 正常速度
      */
     public void normalSpeed(){
              times = 1;
     }
}
tskylee
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
小游戏《俄罗斯方块》开发
ihaveahappyfamily的专栏
03-30 2309
《俄罗斯方块》这款游戏大家应该都不陌生吧，以前的老爷手机上都会内置这款游戏，本篇我们一起使用白鹭引擎开发一款简易版的《俄罗斯方块》小游戏。
J2ME中文教程(包含代码)
09-02
作者:sss 发表时间:2006 主要内容:关于如何利用J2ME进行手机应用开发(包含代码)
我的第一个j2me游戏代码
11-03
我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码
j2me版本的俄罗斯方块写法要点
bywuu的专栏
06-25 660
这几天一直想写点自己的小游戏，刚巧手头有本《J2MEMIDP手机游戏程序设计》，其中第六章有讲俄罗斯方块的写法，但是一看之后却发现根本不是，于是在网上四处查找简单有效的俄罗斯方块源码，并且研究了一下，发现，基本思想大同小异，但是我找到的代码虽然简单，却有疏漏，他没有考虑方块在边界的时候能否变形，没有考虑方块夹在别的方块中间的时候能不能变形等等这样的问题，所以，我将此代码大幅修改，感觉可以写点心得体
发几个自己早期的J2ME独立游戏
03-21
NULL 博文链接：https://leestorm.iteye.com/blog/919239
J2me 游戏《俄罗斯方块》
11-26
俄罗斯方块游戏代码 图片可执行程序 等资源 !!!
J2ME手机游戏案例精编电子教程(6-8)
10-17
9. **实例分析**：教程中的实例可能包括各种类型的游戏，如经典的贪吃蛇、俄罗斯方块等，通过分析这些游戏的实现，学习者可以了解不同游戏机制的设计和实现。 10. **调试与发布**：指导如何调试J2ME应用，以及如何...
JAVA上百实例源码以及开源项目源代码
09-17
内容索引:JAVA源码,综合应用,J2me游戏,PNG,图形处理 　这是个J2ME控制台程序，它能剔除PNG文件中的非关键数据段，减少文件大小从而达到压缩图片的目的。而图片的质量并不会受到损失。使用时候只需在控制台窗口执行...
Java源码包100个设计实例.zip
04-12
java俄罗斯方块 java凭图游戏 Java利用DES私钥对称加密代码实例 Java加密解密工具集 JCT v1.0源码包.rar Java半透明图片实现的步骤及源代码.rar Java右键弹出菜单源码 Java吃豆子游戏源代码.rar Java图片加水印，...
java源码包---java 源码 大量 实例
04-18
内容索引:JAVA源码,综合应用,J2me游戏,PNG,图形处理 　这是个J2ME控制台程序，它能剔除PNG文件中的非关键数据段，减少文件大小从而达到压缩图片的目的。而图片的质量并不会受到损失。使用时候只需在控制台窗口执行...
J2ME游戏代码（含报告）
06-25
基于J2ME的游戏代码（含报告），绝对能跑
J2me 俄罗斯方块游戏 源程序 java
11-12
J2me 俄罗斯方块游戏 源程序 java J2me 俄罗斯方块游戏 源程序 java J2me 俄罗斯方块游戏 源程序 java
j2 me手机游戏编程入门 案例源代码
08-24
j2me手机游戏编程入门这本书带的课后源代码和案例
J2me 游戏代码
12-25
J2me 游戏代码
j2me反编译工具【超强】
01-15
j2me反编译工具，用他打开JAR文件能直接看里面的源码，也能打开calss查看里面的源码，百分百成功，本人试过
j2meframework源代码
Liigo's blog
05-05 3017
j2meframework 是我一年多之前（大约2005年年底吧）顺手写的一个库，目的是简化自己开发JAVA手机应用程序。都是一些封装性的代码，没什么技术含量。我写的小游戏“扫雷（bombs，http://blog.csdn.net/liigo/archive/2005/12/15/553325.aspx）”和小工具“个人消费管理（MyCosts，http://blog.csdn.net/li
J2ME专区源代码
mobilechannel的专栏
01-26 1321
J2ME专区源代码
J2ME俄罗斯方块游戏设计：随机方块与界面交互
在这个Java ME实现的俄罗斯方块游戏中，核心的代码段展示了如何随机生成下一个即将下落的方块。`nextFigure()` 方法使用 `Random` 类生成一个随机索引，该索引对应于七种可能的方块图形之一。`copyArray()` 函数（未...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值