`

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

游戏J#thread单元测试UP 
阅读更多
J2ME游戏代码示例(一)——俄罗斯方块
作者：陈跃峰
下面是我写的一个简单的俄罗斯方块游戏代码，代码中主要包含3个类：
lTerrisMIDlet——MIDlet类
lGameCanvas——游戏界面类
lGameEngine——游戏逻辑类
使用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 Canvasimplements 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;
}
}
分享到：
| J2ME技术实现的RPG游戏的DEMO（含源代码）
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    使用j2me编程的游戏——俄罗斯方块

    通过以上技术，我们可以构建出一个基本的J2ME版俄罗斯方块游戏。源代码会包含各种类，如GameLoop（游戏循环）、GameBoard（游戏板）、Block（方块）、InputHandler（输入处理器）等，每个类都有其特定的责任，共同...

    j2me手机游戏——俄罗斯方块！

    本项目提供了一个基于J2ME的简单俄罗斯方块游戏实现。通过上述分析，我们可以了解到，在J2ME环境下，开发者可以利用Canvas类来实现游戏的绘制和动画效果，同时通过实现Runnable接口和使用Thread类来实现游戏的主循环...

    j2me-tetris.zip_j2me_j2me tetris_j2me 俄罗斯方块_tetris_tetris j2me

    “j2me-tetris.zip”项目中，开发者利用MIDP和CLDC开发了这款J2ME版的俄罗斯方块游戏。MIDP提供了图形用户界面（GUI）的支持，如Canvas类，用于绘制游戏画面；而CLDC则提供了基本的内存管理和网络功能。开发者需要对...

    J2ME手机游戏源代码_俄罗斯方块

    2. **俄罗斯方块游戏逻辑** - **方块生成**：游戏中的方块由多个小方格组成，每种方块有特定的形状。源代码会定义这些形状，并随机生成新的方块。 - **方块运动**：方块从屏幕顶部向下移动，速度可以通过游戏设置...

    J2ME游戏开发之RPG——源码

    **J2ME游戏开发之RPG——源码详解** J2ME（Java 2 Micro Edition）是Java平台的一个子集，主要用于嵌入式设备和移动设备的开发，如早期的智能手机和平板电脑。在J2ME中开发角色扮演游戏（RPG）是一项挑战性的任务，...

    J2ME手机游戏开发之《俄罗斯方块》

    本教程主要关注如何使用J2ME开发经典游戏——《俄罗斯方块》。 一、J2ME基础知识 1. MIDP（Mobile Information Device Profile）：这是J2ME的核心部分，定义了移动设备上的应用程序接口。 2. CLDC（Connected ...

    j2me游戏俄罗斯方块原代码

    在这个压缩包中，包含的是一个基于J2ME实现的经典游戏——俄罗斯方块的源代码。 俄罗斯方块是一款全球闻名的益智游戏，其基本原理是不同形状的方块从屏幕顶部落下，玩家需要通过旋转和横向移动来排列它们，使得同一...

    J2me 俄罗斯方块游戏 源程序 java

    《J2ME版俄罗斯方块游戏源码解析》 在移动设备尚未普及智能手机的时代，Java ME（J2ME）作为一款跨平台的开发环境，广泛应用于功能手机的游戏开发。其中，经典游戏“俄罗斯方块”因其简单易懂的规则和高度上瘾的...

    J2ME游戏代码：俄罗斯方块

    /* * 一个简单的俄罗斯方块游戏代码，代码中主要包含3个类： *TerrisMIDlet——MIDlet类 *GameCanvas——游戏界面类 *GameEngine——游戏逻辑类 *已经使用WTK2.5.2运行通过. */

    J2me 游戏《俄罗斯方块》

    《J2ME游戏：俄罗斯方块》是一款基于Java 2 Micro Edition（J2ME）平台开发的经典游戏。J2ME是Java技术的一个分支，主要用于移动设备、嵌入式设备等小型计算平台，提供了丰富的功能和良好的跨平台能力，使得开发者...

    J2ME版变态(BT)俄罗斯方块(netbeans)课在手机上运行

    【标题】"J2ME版变态(BT)俄罗斯方块在手机上运行"是指使用Java Micro Edition（J2ME）平台开发的一款具有特殊玩法的俄罗斯方块游戏。J2ME是一种轻量级的Java应用程序框架，特别适用于移动设备和嵌入式系统，如早期的...

    我的第一个j2me游戏代码

    我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我的第一个j2me游戏代码我...

    大学本科毕业设计 J2ME手机游戏的实现——五子棋

    【标题】：“大学本科毕业设计 J2ME手机游戏的实现——五子棋”是指通过Java Micro Edition（J2ME）技术在移动设备上开发的一款五子棋游戏。J2ME是Java平台的一个分支，主要用于嵌入式设备和移动设备，如早期的智能...

    j2me Inside J2VM——源代碼

    《J2ME Inside J2VM——源代码》是关于Java Micro Edition（J2ME）在Java Virtual Machine（J2VM）内部工作原理的深入解析，它涵盖了J2ME的源代码层面，帮助开发者理解J2ME应用程序如何在有限资源的设备上运行。...

    j2me手机游戏实例之--俄罗斯方块

    在俄罗斯方块游戏中，我们需要在`Canvas`上绘制方块，这涉及到坐标系统、颜色填充以及形状绘制等概念。 4. **方块设计** 俄罗斯方块的基本元素是各种形状的方块，如直线、L形、T形等。这些方块可以通过二维数组...

    分享：J2ME游戏代码（代码已经初级优化）

    分享：J2ME游戏代码 分享：J2ME游戏代码 分享：J2ME游戏代码分享：J2ME游戏代码 分享：J2ME游戏代码 分享：J2ME游戏代码分享：J2ME游戏代码 分享：J2ME游戏代码 分享：J2ME游戏代码分享：J2ME游戏代码 分享：J2ME...

    j2me俄罗斯方块

    本项目——"j2me俄罗斯方块"，便是基于J2ME技术开发的一款经典游戏，它充分展示了J2ME在移动游戏开发中的潜力。 首先，我们来了解下J2ME。J2ME是Java平台的一个子集，专为资源有限的设备设计，如手机和嵌入式系统。...

    俄罗斯方块J2ME下载

    因此，“俄罗斯方块J2ME下载”可能是指提供了一个可以在J2ME支持的设备上运行的俄罗斯方块游戏的下载服务。 【标签】：“俄罗斯方块” “俄罗斯方块”标签直接关联到游戏本身，表明这个话题与这款经典游戏有关。在...

    J2ME俄罗斯方块游戏代码

    本篇文章将深度解析一个基于J2ME实现的俄罗斯方块游戏代码，帮助读者理解J2ME游戏开发的基本原理和技巧。 首先，我们要明白J2ME中的主要组件。在开发J2ME游戏时，我们通常会用到MIDlet类，它是J2ME应用程序的核心，...

    俄罗斯方块源程序 j2me

    在移动设备普及的年代，J2ME（Java Micro Edition）作为一款跨平台的开发工具，广泛应用于手机游戏开发，其中包括经典游戏——俄罗斯方块。本篇文章将深入探讨如何使用J2ME技术实现这个深受玩家喜爱的游戏。 首先，...

Magicbox
Global site tag (gtag.js) - Google Analytics