J2ME连连看基础功能源代码(含详细注释)

最新推荐文章于 2023-04-24 19:38:16 发布
最新推荐文章于 2023-04-24 19:38:16 发布
阅读量795 收藏 1
点赞数
分类专栏： RD 文章标签： j2me 能源 c 存储 action import

//界面类代码
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;

/**
 * 连连看游戏界面
 */
public class LinkCanvas extends Canvas implements Runnable{
    /**游戏逻辑类*/
    GameEngine engine;   
    /**屏幕宽度*/
    int width;
    /**屏幕高度*/
    int height;
    public LinkCanvas(){
        //创建对象
        engine = new GameEngine();
        //获得屏幕的高度和宽度
        width = getWidth();
        height = getHeight();
        //启动线程
        Thread t = new Thread(this);
        t.start();
    }
   
    /**
     * 绘制方法
     */
    protected void paint(Graphics g) {
        //清屏
        clearScreen(g);
        //绘制地图
        engine.paintMap(g);
        //绘制选择框
        engine.paintSelectArea(g);
        //绘制连线
        engine.paintLinkLine(g);
    }
   
    /**
     * 清屏方法
     * @param g 画笔
     */
    private void clearScreen(Graphics g){
        g.setColor(0xffffff);
        g.fillRect(0, 0, width, height);
        g.setColor(0);
    }
   
    public void keyPressed(int keyCode){
        int action = getGameAction(keyCode);
        switch(action){
        case UP:
            engine.moveUP();
            break;
        case DOWN:
            engine.moveDown();
            break;
        case LEFT:
            engine.moveLeft();
            break;
        case RIGHT:
            engine.moveRight();
            break;
        case FIRE:
            engine.fire();//选择块
            break;
        }
    }

    public void run() {
        try{
            while(true){
                //延时
                Thread.sleep(100);
                //每次判断逻辑
                engine.action();
                repaint();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

//逻辑类源代码
import java.util.*;
import javax.microedition.lcdui.*;
/**
 * 游戏数据和逻辑类
 */
public class GameEngine {
    /**选中块的个数*/
    private int selectTileNum = 0;
    //第一个选择块的行号和列号
    /**行号*/
    private int firstRow;
    /**列号*/
    private int firstCol;
    //第二个选择块的行号和列号
    /**行号*/
    private int secondRow;
    /**列号*/
    private int secondCol;
   
    //当前选择框，默认在左上角
    /**当前选择框的行号*/
    private int cRow;
    /**当前选择框的列号*/
    private int cCol;
   
    /**最大行数*/
    private final int MAX_ROW = 10;
    /**最大列数*/
    private final int MAX_COL = 10;
   
    /**地图数据，0代表空，数据1-10分别代表十种不同的结构*/
    private int[][] map = new int[MAX_ROW][MAX_COL];
    /**随机数对象*/
    private Random ran = new Random();
   
    //地图区域左上角的坐标
    private final int LEFTX = 20;
    private final int LEFTY = 50;
   
    /**每个单元格的宽度*/
    private final int TILE_WIDTH = 20;
    /**每个单元格的高度*/
    private final int TILE_HEIGHT = 20;
   
    /**连线类型*/
    private int linkType;
   
    /**无法连线*/
    private final int NO_LINK = 0;
    /**水平连线*/
    private final int H_LINK = 1;
    /**垂直联系*/
    private final int V_LINK = 2;
    /**一个拐点，先移动x*/
    private final int ONE_CORNER_FIRSTX = 3;
    /**一个拐点，先移动y*/
    private final int ONE_CORNER_FIRSTY = 4;
    /**两个拐点，待完善*/
    private final int TWO_CORNER = 5;
   
    /**
     * 两次拐弯的行号和列号
     * 数据格式为：
     *   第一个拐点的行号，第一个拐点的列号，第二个拐点的行号，第二个拐点的列号
     */
    int[] p = new int[4];
   
    public GameEngine(){
        //初始化地图数据
        initMap();
    }
   
    /**
     * 初始化地图数据
     */
    private void initMap(){
        for(int row = 0;row < map.length;row++){
            for(int col = 0;col < map[row].length;col++){
                map[row][col] = row + 1;
            }
        }
        //循环打乱10次
        int tempRow;
        int tempCol;
        int temp;
        for(int i = 0;i < 10;i++){
            for(int row = 0;row < map.length;row++){
                for(int col = 0;col < map[row].length;col++){
                    //随机行号
                    tempRow = Math.abs(ran.nextInt() % 10);
                    //随机列号
                    tempCol = Math.abs(ran.nextInt() % 10);
                    //如果不是同一个单元格，则交换数据
                    if(!((tempRow == row) && (tempCol == col))){
                        temp = map[row][col];
                        map[row][col] = map[tempRow][tempCol];
                        map[tempRow][tempCol] = temp;
                    }
                }
            }
        }
    }
   
    /**
     * 绘制地图数据
     * @param g 画笔
     */
    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] == 0){
                    continue;
                }else{//绘制方块
                    //绘制方框
                    g.drawRect(LEFTX + col * TILE_WIDTH, LEFTY + row * TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT);
                    //绘制数字
                    g.drawString(String.valueOf(map[row][col]), LEFTX + col * TILE_WIDTH + 5,
                            LEFTY + row * TILE_HEIGHT + 4,
                            Graphics.TOP | Graphics.LEFT);
                }
            }
        }
    }
   
    /**
     * 绘制选择框
     * @param g 画笔
     */
    public void paintSelectArea(Graphics g){
        //绘制当前选择框
        g.setColor(0xff00);
        g.drawRect(LEFTX + cCol * TILE_WIDTH, LEFTY + cRow * TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT);
        g.setColor(0);
       
        //绘制选中项
        switch(selectTileNum){
        case 1:  //选择一个
            g.setColor(0xff0000);
            g.drawRect(LEFTX + firstCol * TILE_WIDTH, LEFTY + firstRow * TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT);
            g.setColor(0);
            break;
        case 2:  //选中两个
            g.setColor(0xff0000);
            g.drawRect(LEFTX + firstCol * TILE_WIDTH, LEFTY + firstRow * TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT);
            g.drawRect(LEFTX + secondCol * TILE_WIDTH, LEFTY + secondRow * TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT);
            g.setColor(0);
            break;
        }
    }
   
    /**
     * 绘制方块连线
     * @param g 画笔
     */
    public void paintLinkLine(Graphics g){
        //如果无连线，则直接返回
        if(linkType == NO_LINK){
            return;
        }
        //根据连线类型实现绘制
        //绘制到方块的中心点
        switch(linkType){
        case H_LINK://水平
        case V_LINK://垂直
            paintLine(g,firstRow,firstCol,secondRow,secondCol);
            break;
        case ONE_CORNER_FIRSTX://一个拐弯，先移动X
            //水平线
            paintLine(g,firstRow,firstCol,firstRow,secondCol);
            //垂直线
            paintLine(g,firstRow,secondCol,secondRow,secondCol);
            break;
        case ONE_CORNER_FIRSTY://一个拐弯，先移动Y
            //水平线
            paintLine(g,firstRow,firstCol,secondRow,firstCol);
            //垂直线
            paintLine(g,secondRow,firstCol,secondRow,secondCol);
            break;
        case TWO_CORNER:
            //块1到第一个拐点的连线
            paintLine(g,firstRow,firstCol,p[0],p[1]);
            //两个拐点之间的连线
            paintLine(g,p[0],p[1],p[2],p[3]);
            //第二个拐点到块2的连线
            paintLine(g,p[2],p[3],secondRow,secondCol);
            break;
        }
        //逻辑代码，清除连接类型
        linkType = NO_LINK;
    }
   
    /**
     * 绘制两个方块中心点的连线
     * @param g  画笔
     * @param r1 方块1的行号
     * @param c1 方块1的列号
     * @param r2 方块2的行号
     * @param c2 方块2的列号
     */
    private void paintLine(Graphics g,int r1,int c1,int r2,int c2){
        g.drawLine(LEFTX + c1 * TILE_WIDTH + TILE_WIDTH/2,
                LEFTY + r1 * TILE_HEIGHT + TILE_HEIGHT/2,
                LEFTX + c2 * TILE_WIDTH + TILE_WIDTH/2,
                LEFTY + r2 * TILE_HEIGHT + TILE_HEIGHT/2);
       
    }
   
    /**
     * 向左移动选择框
     */
    public void moveLeft(){
        if(cCol > 0){
            cCol--;
        }
    }
   
    /**
     * 向右移动选择框
     */
    public void moveRight(){
        if(cCol < MAX_COL -1){
            cCol++;
        }
    }
   
    /**
     * 向上移动选择框
     */
    public void moveUP(){
        if(cRow > 0){
            cRow--;
        }
    }
   
    /**
     * 向下移动选择框
     */
    public void moveDown(){
        if(cRow < MAX_ROW - 1){
            cRow++;
        }
    }
   
    /**
     * 确定键逻辑处理
     */
    public void fire(){
        //如果选择的块为空，则直接返回
        if(map[cRow][cCol] == 0){
            return;
        }
        //选中的块的数量增加1
        selectTileNum++;
        //判别存储位置
        switch(selectTileNum){
        case 1: //第一次选择
            firstRow = cRow;
            firstCol = cCol;
            break;
        case 2: //第二次选择
            //选择同一个块,2个选择块都失去选中
            if((firstRow == cRow) && (firstCol == cCol)){
                selectTileNum = 0;
                return;
            }
            secondRow = cRow;
            secondCol = cCol;
            break;
        }
    }
   
    /**
     * 判断(r1,c1)块和(r2,c2)块中间是否为空行
     * 不包含这两个块
     * @param r1 块1的行号
     * @param c1 块1的列号
     * @param r2 块2的行号
     * @param c2 块2的列号
     * @return true代表为空，false代表不为空
     */     
    private boolean isEmptyRow(int r1,int c1,int r2,int c2){
        //判断是否位于同一行
        if(r1 != r2){
            return false;
        }
        //判断两个块的相对位置
        if(c1 > c2){ //第一块位于右侧
            for(int col = c1 - 1;col > c2;col--){
                //如果有非空块
                if(map[r1][col] != 0){
                    return false;
                }
            }
        }else{ //第一块位于左侧
            for(int col = c2 - 1;col > c1;col--){
                //如果有非空块
                if(map[r1][col] != 0){
                    return false;
                }
            }
        }
        return true;
    }
   
    /**
     * 判断块(r1,c1)和块(r2,c2)之间是否是空列
     * 不包含这两个块
     * @param r1 块1的行号
     * @param c1 块1的列号
     * @param r2 块2的行号
     * @param c2 块2的列号
     * @return true代表为空，false代表不为空
     */
    private boolean isEmptyCol(int r1,int c1,int r2,int c2){
        //判断是否位于同一列
        if(c1 != c2){
            return false;
        }
        //判断两个块的相对位置
        if(r2 > r1){//第一个块在上方
            for(int row = r1 + 1;row < r2;row++){
                //如果有非空块
                if(map[row][c1] != 0){
                    return false;
                }
            }
        }else{//第二个块在上方
            for(int row = r2 + 1;row < r1;row++){
                //如果有非空块
                if(map[row][c1] != 0){
                    return false;
                }
            }
        }
        return true;
    }
   
    /**
     * 判断一个块是否为空
     * @param r 块的行号
     * @param c 块的列号
     * @return true代表为空，false代表不空
     */
    private boolean isEmptyCell(int r,int c){
        return map[r][c] == 0;
    }   
       
    /**
     * 是否是一次转弯实现连线
     * @return NO_LINK代表没有连线，其他值代表对应的连线类型
     */
    private int isOneCornerLink(int r1,int c1,int r2,int c2){
        //先移动行，再移动列
        if(isEmptyCell(r1,c2)){ //转折点为空
            if(isEmptyRow(r1,c1,r1,c2) & isEmptyCol(r1,c2,r2,c2)){
                return ONE_CORNER_FIRSTX;
            }
        }
        //先移动列，再移动行
        if(isEmptyCell(r2,c1)){//转折点为空
            if(isEmptyCol(r1,c1,r2,c1) & isEmptyRow(r2,c1,r2,c2)) {
                return ONE_CORNER_FIRSTY;
            }
        }
        //无连接
        return NO_LINK;
    }
   
    /**
     * 是否经过2次转折实现连接
     * @param r1 块1的行号
     * @param c1 块1的列号
     * @param r2 块2的行号
     * @param c2 块2的列号
     * @return true代表可以连接，false代表不能
     */
    private boolean isTwoCornerLink(int r1,int c1,int r2,int c2){
        int result;
        //正常情况，划分成4个方向
        //块1向上
        for(int row = r1 -1;row >= 0;row--){
            //如果有数据不为空，则直接结束该方向的尝试
            if(map[row][c1] != 0){
                break;
            }
            //存储第一个拐点的坐标
            p[0] = row;
            p[1] = c1;
            //每次都尝试转折，则变成一个转点的操作
            result = isOneCornerLink(row,c1,r2,c2);
            //如果可以连接
            if(result != NO_LINK){
                //存储第二个拐点的位置
                switch(result){
                case ONE_CORNER_FIRSTX:
                    p[2] = row;
                    p[3] = c2;
                    break;
                case ONE_CORNER_FIRSTY:
                    p[2] = r2;
                    p[3] = c1;
                    break;
                }
                return true;
            }
        }
        //块1向下
        for(int row = r1 + 1;row < MAX_ROW;row++){
            //如果有数据不为空，则直接结束该方向的尝试
            if(map[row][c1] != 0){
                break;
            }
            //存储第一个拐点的坐标
            p[0] = row;
            p[1] = c1;
            //每次都尝试转折，则变成一个转点的操作
            result = isOneCornerLink(row,c1,r2,c2);
            //如果可以连接
            if(result != NO_LINK){
                //存储第二个拐点的位置
                switch(result){
                case ONE_CORNER_FIRSTX:
                    p[2] = row;
                    p[3] = c2;
                    break;
                case ONE_CORNER_FIRSTY:
                    p[2] = r2;
                    p[3] = c1;
                    break;
                }
                return true;
            }
        }
        //块1向左
        for(int col = c1 -1;col >= 0;col--){
            //如果有数据不为空，则直接结束该方向的尝试
            if(map[r1][col] != 0){
                break;
            }
            //存储第一个拐点的坐标
            p[0] = r1;
            p[1] = col;
            //每次都尝试转折，则变成一个转点的操作
            result = isOneCornerLink(r1,col,r2,c2);
            //如果可以连接
            if(result != NO_LINK){
                //存储第二个拐点的位置
                switch(result){
                case ONE_CORNER_FIRSTX:
                    p[2] = r1;
                    p[3] = c2;
                    break;
                case ONE_CORNER_FIRSTY:
                    p[2] = r2;
                    p[3] = col;
                    break;
                }
                return true;
            }
        }
        //块1向右
        for(int col = c1  + 1;col < MAX_COL;col++){
            //如果有数据不为空，则直接结束该方向的尝试
            if(map[r1][col] != 0){
                break;
            }
            //存储第一个拐点的坐标
            p[0] = r1;
            p[1] = col;
            //每次都尝试转折，则变成一个转点的操作
            result = isOneCornerLink(r1,col,r2,c2);
            //如果可以连接
            if(result != NO_LINK){
                //存储第二个拐点的位置
                switch(result){
                case ONE_CORNER_FIRSTX:
                    p[2] = r1;
                    p[3] = c2;
                    break;
                case ONE_CORNER_FIRSTY:
                    p[2] = r2;
                    p[3] = col;
                    break;
                }
                return true;
            }
        }
       
        //四个特例，也就是超出地图区域的连接
        //实现地图区域上侧的连接，也就是到上侧是一个空列
        if((isEmptyCol(r1,c1,-1,c1)) & (isEmptyCol(r2,c2,-1,c2))){
            p[0] = -1;
            p[1] = c1;
            p[2] = -1;
            p[3] = c2;
            return true;
        }
        //左侧
        if((isEmptyRow(r1,c1,r1,-1)) & (isEmptyRow(r2,c2,r2,-1))){
            p[0] = r1;
            p[1] = -1;
            p[2] = r2;
            p[3] = -1;
            return true;
        }
        //下侧
        if((isEmptyCol(r1,c1,MAX_ROW,c1)) & (isEmptyCol(r2,c2,MAX_ROW,c2))){
            p[0] = MAX_ROW;
            p[1] = c1;
            p[2] = MAX_ROW;
            p[3] = c2;
            return true;
        }
        //右侧
        if((isEmptyRow(r1,c1,r1,MAX_COL)) & (isEmptyRow(r2,c2,r2,MAX_COL))){
            p[0] = r1;
            p[1] = MAX_COL;
            p[2] = r2;
            p[3] = MAX_COL;
            return true;
        }       
        return false;
    }
   
    /**
     * 逻辑判断是否有连线
     * @return NO_LINK代表无连线，其它数据代表有连线
     */
    private int logic(){
        //如果数值不同
        if(map[firstRow][firstCol] != map[secondRow][secondCol]){
            return NO_LINK;
        }
        //判断连接方式
        if(isEmptyRow(firstRow,firstCol,secondRow,secondCol)){ //水平连线
            return H_LINK;
        }
        if(isEmptyCol(firstRow,firstCol,secondRow,secondCol)){//垂直连线
            return V_LINK;
        }
        //一个转点的连接
        int result = isOneCornerLink(firstRow,firstCol,secondRow,secondCol);
        if(result != NO_LINK){
            return result;
        }
        //两个转点的连接
        if(isTwoCornerLink(firstRow,firstCol,secondRow,secondCol)){
            return TWO_CORNER;
        }       
        //返回无连接
        return NO_LINK;
    }
   
    /**
     * 逻辑判别和逻辑处理
     */
    public boolean action(){
        //判断是否选择两个方块
        if(selectTileNum != 2){
            return false;
        }
        boolean b = false;
        //判断是否有连线
        linkType = logic();
        //如果有连线，则消失
        if(linkType != NO_LINK){
            map[firstRow][firstCol] = 0;
            map[secondRow][secondCol] = 0;
            b = true;
        }
        //选择的块数初始化
        selectTileNum = 0;
        return b;
    }
}

worldpharos
关注
专栏目录
【Java从入门到天黑|01】SE入门之Java的前生今世
孙叫兽的博客
04-16 3882
JavaSE入门基础
J2ME连连看基础功能源代码
09-22
【J2ME连连看基础功能源代码】涉及的知识点主要集中在Java ME（Java 2 Micro Edition）平台上开发移动设备应用程序，尤其是游戏应用。以下是对源代码的详细解析： 1. **J2ME平台**：J2ME是Java平台的一个子集，用于...
VC6.0的连连看基本功能
06-15
VC6.0实现的连连看基本功能源代码。可以做成自己的游戏!
javax.microedition.jar
10-29
文件结构 javax/microedition/io/ javax/microedition/lcdui/ javax/microedition/midlet/ javax/microedition/rms/
贴出我第一个手机Java程序
狗窝
04-10 1465
import javax.microedition.lcdui.*;import javax.microedition.midlet.MIDlet;import javax.microedition.midlet.MIDletStateChangeException;import java.io.*;public class Mobile extends MIDlet ...{    priv
java基础01
最新发布
qq_46670673的博客
04-24 2165
编程入门(计算机普及/操作系统/万维网)Java语言的应用场景Java基础阶段知识结构拆解(图谱/课程概述/课程体系)软件开发介绍计算机编程语言介绍Java语言概述Java运行机制及运行过程Java的开发环境搭建开发体验HelloWorld常见问题及解决办法注释良好的编程风格常用的Java开发工具关键字标识符变量运算符键盘接收用户输入软件，即一系列按照特定顺序组织的计算机数据和指令的集合。有系统软件和应用软件之分。语言：是人与人之间用于沟通的一种方式。
安卓航班Android开发经典教程大总结1----基础编程及源码推送
10-07 2595
上篇主要讲述了社区的总体规划以及总结此次教程的目的，接下来开始正式总结android开发相关知识，从最简单的环境搭建到正式项目的制作，当然教程是总结来的，同时再次声明资料很多来自互联网，如有侵权请联系本人（ghost@apkway.com）， 众所周知android开发核心语言采用的是java，做过javaEE或者j2me的同学肯定对java基础知识有一定的掌握，想必学习android 也是很
1900套计算机毕业设计源码整合大全，ASP(499套），C++（24套），Java（100套），JSP（300套），PHP（76套），VB（350套）Andorid168套，swing11套...
热门推荐
CSDN专栏--北京中关村
06-03 1万+
1900套计算机毕业设计源码整合大全
Android开发从入门到精通教程大总结（源码，教程，面试题，书籍，视频）
我的Android之旅
11-14 3963
http://xiaozu.renren.com/xiaozu/100692/356978925   人人网：xzgxzg_001@qq.com xzgxzg32...   一、基础编程及源码推送  上篇主要讲述了社区的总体规划以及总结此次教程的目的，接下来开始正式总结android开发相关知识，从最简单的环境搭建到正式项目的制作，当然教程是总结来的，同时再次声明资料
j2me连连看代码.rar_j2me 游戏_j2me 连连看_小游戏代码_连连看 java_连连看 j2me
09-24
《J2ME连连看游戏开发详解》 J2ME（Java 2 Micro Edition）是Java平台上的一种轻量级应用框架，主要用于开发移动设备和嵌入式设备上的应用程序。本篇文章将深入探讨如何使用J2ME编写一款经典的连连看游戏。 一、...
J2ME合金弹头游戏源代码
03-17
**标题解析：** "J2ME合金弹头游戏源代码" 指的是这是一个基于Java Micro Edition (J2ME) 平台开发的合金弹头游戏的源代码。J2ME是Java的一个版本，主要用于移动设备和嵌入式系统的应用程序开发，尤其是早期的手机...
j2me游戏紫色精灵源代码
03-16
【标题】"j2me游戏紫色精灵源代码" 涉及的知识点主要集中在Java ME（J2ME）平台上的游戏开发，这是一个针对移动设备和嵌入式系统的Java应用程序开发框架。J2ME通常用于创建功能手机上的应用程序，尤其是游戏。在本...
J2ME蓝牙五子棋游戏源代码
03-16
《J2ME蓝牙五子棋游戏源代码》是一款基于JAVA ME（Java Micro Edition）平台开发的手机游戏，专为移动设备设计。此游戏利用了J2ME中的蓝牙功能，允许玩家通过蓝牙进行双人对战，增加了游戏的互动性和趣味性。在这款...
深入理解MIDP的界面类体系
爪哇米工作室陈跃峰的移动开发博客
01-02 4010
深入理解MIDP的界面类体系作者：陈跃峰Email：cqucyf@gmail.com        因为在MIDP手机编程中，没有控制台的概念，所以所有的MIDP手机软件都必须有自己的界面，下面就熟悉一下MIDP的界面类体系。       首先说明的是，MIDP的标准界面类都位于javax.microedition.lcdui包中，使用时一定要记得引入。       在界面体系中，所以可以直接显示
J2ME连连看游戏代码实现与解析
"这篇资源是关于J2ME平台上的连连看游戏代码框架的分享，包含了一个基础的MIDlet类和一个Canvas界面类。代码结构清晰，并且有详细的注释，便于理解与学习。作者鼓励有想法的读者提出建议。" 在Java 2 Micro Edition...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值