j2me 实现连连看的算法

最新推荐文章于 2024-09-12 19:02:20 发布
最新推荐文章于 2024-09-12 19:02:20 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： J2ME 文章标签： 算法 j2me delete 游戏 框架 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/colonleado/article/details/3640290
版权

 最近无聊用java写了一个连连看，写之前看了一些资料，很多人用的递归算消除图块时候的路径，感觉很废效率，虽然比较省代码，但是递归如果用在非常大的拼图游戏那速度会慢死的。

所以我就写了N多代码实现一个分情况的比较快捷的寻路算法。

思想就是按下记录当前光标位置的方块ID，再按下先检测no corner（无拐角）是否可以消除，如果不可以消除再检测one corner，不行再two corner。而one corner和two corner也分了很多情况，这样用if-else块把检测过程分成了很多小块，一旦检测成功就跳出来，极大地提高了效率。在检测路径的过程中，同时记录下路径方便消除时画线用，如果检测失败就清除所有记录了的路径。

在绘制上，我把所有图块画在一张大图上，只在按下确定后消除了某块后才更新所有图块，这样省去了每次循环都要遍历GameArry去重绘所有图块的时间。

 

下面上开始的部分代码：

  1.     public static final int row=10+2,col=12+2;
  2.     public static final int rowL=10,colL=12;
  3.     int Vx=0,Vy=0;//框架偏移量
  4.     int Mx=0,My=Type.ScreenHeight-45;//Item偏移量
  5.     int Bx=1,By=1;//光标位置
  6.     Image gameImg[];
  7.     int gameArry[][];
  8.     int bufArry[];
  10.     public void getRondomArry(){
  11.         //得到数组○
  12.         int rand=0;
  13.         for(int i=0;i<bufArry.length;i+=4){
  14.             for(int j=0;j<4;++j){
  15.                 bufArry[i+j]=rand;
  16.             }
  17.             ++rand;
  18. //            rand=t.getRandomNumber(2,3);
  19. //            if(i<bufArry.length-rand*2){
  20. //                for (int j = 0; j < rand * 2; ++j) {
  21. //                    bufArry[i + j] = i;
  22. //                }
  23. //                i += rand;
  24. //            }else if(rand==3&&i<bufArry.length-(rand-1)*2)
  25. //            {
  26. //                for(int j=0;j<(rand-1)*2;++j){
  27. //                    bufArry[i + j] = i;
  28. //                }
  29. //                i+=(rand-1);
  30. //            }else
  31. //            {
  32. //               bufArry[i]=i;
  33. //               bufArry[i+1]=i;
  34. //               break;
  35. //            }
  36. //            System.out.println(i);
  37.         }
  38.         //打乱顺序
  39.         int temp=0;
  40.         int k=0;
  41.         for(int i=0;i<bufArry.length-1;++i){
  42.             temp=bufArry[i];
  43.             k=t.getRandomNumber(i,bufArry.length-1);
  44.             bufArry[i]=bufArry[k];
  45.             bufArry[k]=temp;
  46.         }
  47.         //数组转换
  48.         for(int i=0;i<gameArry.length;++i){
  49.             for(int j=0;j<gameArry[i].length;++j){
  50.                 gameArry[i][j]=100;
  51.             }
  52.         }
  53.         gameArry=t.Arry_1_to_2(bufArry,rowL,colL,gameArry);
  54.     }
  57.     public static int[][] Arry_1_to_2(int[] arry1,int row,int col,int arry2[][]){
  58.         int bufrow=1,bufcol=1;
  59.         for(int i=0;i<arry1.length;++i){
  60.             arry2[bufrow][bufcol]=arry1[i];
  61.             ++bufcol;
  62.             if(bufcol==col+1){
  63.                 bufcol=1;
  64.                 ++bufrow;
  65.             }
  66.         }
  67.         return arry2;
  68.     }
  70.     public static int [] Arry_2_to_1(int [][]arry2){
  71.         int temparry[]=new int[(arry2.length-2)*(arry2[0].length-2)];
  72.         int index=0;
  73.         for(int i=1;i<arry2.length-1;++i){
  74.             for(int j=1;j<arry2[i].length-1;++j){
  75.                 temparry[index]=arry2[i][j];
  76.                 index++;
  77.             }
  78.         }
  79.         return temparry;
  80.     }

为了方便检测路径，我将矩阵4个边全都设置为空，所以数组赋值时起始位置是1 ，1

 

按下确定键的逻辑处理：Bx和By是当前光标位置

  1. if(this.onceKeyPressed(ok)&&gameArry[Bx][By] != 100)
  2.        {
  4.            vv.removeAllElements();
  5.            if(sign[0]==100){
  6.                sign[0] = Bx;
  7.                sign[1] = By;
  8.            }
  9.            if (this.isDeletAble()) { //消除 清空
  10.                gameArry[sign[0]][sign[1]] = 100;
  11.                gameArry[Bx][By] = 100;
  12.                sign[0] = 100;
  13.                sign[1] = 100;
  14.                this.GetGameImage();//更新不变图
  15.                delete=true;//画线
  16.                kuai--;//减计数器
  17.                if(timelogic<timer)//增加时间
  18.                    timelogic+=3;
  19.            } else { //重新赋值 冲刷
  20.                sign[0] = Bx;
  21.                sign[1] = By;
  22.            }
  23.        }

检测路径：

 

虽然代码看上去很多，但是其实真正执行到的并不多，只是把情况细分了。

在这个游戏里，比递归算法节省了1秒左右

  1.     //记下这个线
  2.     public void getTT(int type,int tx,int ty){
  3.         int tt[]=new int[3];//记录线  类型 坐标
  4.         tt[0]=type;
  5.         tt[1]=tx;
  6.         tt[2]=ty;
  7.         vv.addElement(tt);
  8.         tt=null;
  9.     }
  11.     public boolean isDeletAble() {
  12.         boolean ko=false; //完成否
  13.         if (!(Bx == sign[0] && By == sign[1])) {//不是相同点
  14.             if (getBB(0) == getBB(1)) {//第一条件
  15.                 //0 corner--------------------------------------------------
  16. //                System.out.println("no corner");
  17.                 if (By == sign[1]) {
  18.                     ko = true;
  19.                     if (Bx < sign[0]) {
  20.                         this.getTT(1,Bx,By);
  21.                         for (int i = Bx + 1; i < sign[0]; ++i) {
  22.                             this.getTT(1,i,By);
  23.                             if (gameArry[i][By] != 100) {
  24.                                 vv.removeAllElements();
  25.                                 ko = false;
  26.                                 break;
  27.                             }
  28.                         }
  29.                     } else {
  30.                         this.getTT(0,Bx,By);
  31.                         for (int i = sign[0] + 1; i < Bx; ++i) {
  32.                             this.getTT(0,i,By);
  33.                             if (gameArry[i][By] != 100) {
  34.                                 vv.removeAllElements();
  35.                                 ko = false;
  36.                                 break;
  37.                             }
  38.                         }
  39.                     }
  41.                 } else if (Bx == sign[0]) {
  42.                     ko = true;
  43.                     if (By < sign[1]) {
  44.                         this.getTT(3,Bx,By);
  45.                         for (int i = By + 1; i < sign[1]; ++i) {
  46.                             this.getTT(3,Bx,i);
  47.                             if (gameArry[Bx][i] != 100) {
  48.                                 vv.removeAllElements();
  49.                                 ko = false;
  50.                                 break;
  51.                             }
  52.                         }
  53.                     } else {
  54.                         this.getTT(2,Bx,By);
  55.                         for (int i = sign[1] + 1; i < By; ++i) {
  56.                             this.getTT(2,Bx,i);
  57.                             if (gameArry[Bx][i] != 100) {
  58.                                 vv.removeAllElements();
  59.                                 ko = false;
  60.                                 break;
  61.                             }
  62.                         }
  63.                     }
  64.                 }
  66.                 //1 corner -----------------------------------------------
  67.                 if (!ko) { //如果没出来尝试one corner
  68. //                    System.out.println("one corner");
  69.                     vv.removeAllElements();//清空缓冲路径
  70.                     //分析两个点的位置关系
  71.                     //关系A
  72.                     if (Bx < sign[0] && By < sign[1]) {
  73. //                        System.out.println(" one corner A");
  74.                         if (gameArry[Bx][sign[1]] == 100) { //点1
  75.                             ko=true;
  76.                             this.getTT(1,Bx,sign[1]);
  77.                             this.getTT(2,Bx,sign[1]);
  78.                             for (int i = sign[1] - 1; i > By; --i) {
  79.                                 this.getTT(2,Bx,i);
  80.                                 if (gameArry[Bx][i] != 100) {
  81.                                     vv.removeAllElements();
  82.                                     ko = false;
  83.                                     break;
  84.                                 }
  85.                             }
  86.                             if (ko) {
  87.                                 for (int i = Bx + 1; i < sign[0]; ++i) {
  88.                                     this.getTT(1,i,sign[1]);
  89.                                     if (gameArry[i][sign[1]] != 100) {
  90.                                         ko = false;
  91.                                         vv.removeAllElements();
  92.                                         break;
  93.                                     }
  94.                                 }
  95.                             }
  96.                         }
  97.                         if (!ko) {
  98.                             if (gameArry[sign[0]][By] == 100) { //点2
  99.                                 ko=true;
  100.                                 this.getTT(3,sign[0],By);
  101.                                 this.getTT(0,sign[0],By);
  102.                                 for (int i = By + 1; i < sign[1]; ++i) {
  103.                                     this.getTT(3,sign[0],i);
  104.                                     if (gameArry[sign[0]][i] != 100) {
  105.                                         ko = false;
  106.                                         vv.removeAllElements();
  107.                                         break;
  108.                                     }
  109.                                 }
  110.                                 if (ko) {
  111.                                     for (int i = sign[0] - 1; i > Bx; --i) {
  112.                                         this.getTT(0,i,By);
  113.                                         if (gameArry[i][By] != 100) {
  114.                                             ko = false;
  115.                                             vv.removeAllElements();
  116.                                             break;
  117.                                         }
  118.                                     }
  119.                                 }
  120.                             }
  121.                         }
  122.                     }
  123.                     //关系B
  124.                     else if(Bx>sign[0]&&By<sign[1]){
  125. //                        System.out.println(" one corner B");
  126.                         if(gameArry[Bx][sign[1]]==100){//点1
  127.                             ko=true;
  128.                             this.getTT(0,Bx,sign[1]);
  129.                             this.getTT(2,Bx,sign[1]);
  130.                             for(int i=Bx-1;i>sign[0];--i){
  131.                                 this.getTT(0,i,sign[1]);
  132.                                 if(gameArry[i][sign[1]]!=100){
  133.                                     ko=false;
  134.                                     vv.removeAllElements();
  135.                                     break;
  136.                                 }
  137.                             }
  138.                             if(ko){
  139.                                 for(int i=sign[1]-1;i>By;--i){
  140.                                     this.getTT(2,Bx,i);
  141.                                     if(gameArry[Bx][i]!=100){
  142.                                         ko=false;
  143.                                         vv.removeAllElements();
  144.                                         break;
  145.                                     }
  146.                                 }
  147.                             }
  148.                         }
  149.                         if(!ko){
  150.                             if(gameArry[sign[0]][By]==100){//点2
  151.                                 ko=true;
  152.                                 this.getTT(1,sign[0],By);
  153.                                 this.getTT(3,sign[0],By);
  154.                                 for(int i=sign[0]+1;i<Bx;++i){
  155.                                     this.getTT(1,i,By);
  156.                                     if(gameArry[i][By]!=100){
  157.                                         vv.removeAllElements();
  158.                                         ko=false;
  159.                                         break;
  160.                                     }
  161.                                 }
  162.                                 if(ko){
  163.                                     for(int i =By+1;i<sign[1];++i){
  164.                                         this.getTT(3,sign[0],i);
  165.                                         if(gameArry[sign[0]][i]!=100){
  166.                                             vv.removeAllElements();
  167.                                             ko=false;
  168.                                             break;
  169.                                         }
  170.                                     }
  171.                                 }
  172.                             }
  173.                         }
  174.                     }
  175.                     //关系C
  176.                     else if(Bx>sign[0]&&By>sign[1]){
  177. //                        System.out.println(" one corner C");
  178.                         if(gameArry[sign[0]][By]==100){//点1
  179.                             ko=true;
  180.                             this.getTT(2,sign[0],By);
  181.                             this.getTT(1,sign[0],By);
  182.                             for(int i=By-1;i>sign[1];--i){
  183.                                 this.getTT(2,sign[0],i);
  184.                                 if(gameArry[sign[0]][i]!=100){
  185.                                     vv.removeAllElements();
  186.                                     ko=false;
  187.                                     break;
  188.                                 }
  189.                             }
  190.                             if(ko){
  191.                                 for(int i=sign[0]+1;i<Bx;++i){
  192.                                     this.getTT(1,i,By);
  193.                                     if(gameArry[i][By]!=100){
  194.                                         vv.removeAllElements();
  195.                                         ko=false;
  196.                                         break;
  197.                                     }
  198.                                 }
  199.                             }
  200.                         }
  201.                         if(!ko){
  202.                             if(gameArry[Bx][sign[1]]==100){//点2
  203.                                 ko=true;
  204.                                 this.getTT(0,Bx,sign[1]);
  205.                                 this.getTT(3,Bx,sign[1]);
  206.                                 for(int i=Bx-1;i>sign[0];--i){
  207.                                     this.getTT(0,i,sign[1]);
  208.                                     if(gameArry[i][sign[1]]!=100){
  209.                                         vv.removeAllElements();
  210.                                         ko=false;
  211.                                         break;
  212.                                     }
  213.                                 }
  214.                                 if(ko){
  215.                                     for(int i=sign[1]+1;i<By;++i){
  216.                                         this.getTT(3,Bx,i);
  217.                                         if(gameArry[Bx][i]!=100){
  218.                                             vv.removeAllElements();
  219.                                             ko=false;
  220.                                             break;
  221.                                         }
  222.                                     }
  223.                                 }
  224.                             }
  225.                         }
  226.                     }
  227.                     //关系D
  228.                     else if(Bx<sign[0]&&By>sign[1]){
  229. //                        System.out.println(" one corner D");
  230.                         if(gameArry[sign[0]][By]==100){//点1
  231.                             ko=true;
  232.                             this.getTT(0,sign[0],By);
  233.                             this.getTT(2,sign[0],By);
  234.                             for(int i=By-1;i>sign[1];--i){
  235.                                 this.getTT(2,sign[0],i);
  236.                                 if(gameArry[sign[0]][i]!=100){
  237.                                     vv.removeAllElements();
  238.                                     ko=false;
  239.                                     break;
  240.                                 }
  241.                             }
  242.                             if(ko){
  243.                                 for(int i=sign[0]-1;i>Bx;--i){
  244.                                     this.getTT(0,i,By);
  245.                                     if(gameArry[i][By]!=100){
  246.                                         vv.removeAllElements();
  247.                                         ko=false;
  248.                                         break;
  249.                                     }
  250.                                 }
  251.                             }
  252.                         }
  253.                         if(!ko){
  254.                             if(gameArry[Bx][sign[1]]==100){//点2
  255.                                 ko=true;
  256.                                 this.getTT(1,Bx,sign[1]);
  257.                                 this.getTT(3,Bx,sign[1]);
  258.                                 for(int i = sign[1]+1;i<By;++i){
  259.                                     this.getTT(3,Bx,i);
  260.                                     if(gameArry[Bx][i]!=100){
  261.                                         vv.removeAllElements();
  262.                                         ko=false;
  263.                                         break;
  264.                                     }
  265.                                 }
  266.                                 if(ko){
  267.                                     for(int i=Bx+1;i<sign[0];++i){
  268.                                         this.getTT(1,i,sign[1]);
  269.                                         if(gameArry[i][sign[1]]!=100){
  270.                                             ko=false;
  271.                                             vv.removeAllElements();
  272.                                             break;
  273.                                         }
  274.                                     }
  275.                                 }
  276.                             }
  277.                         }
  278.                     }
  279.                 }
  280.                 //two corner-----------------------------------------------
  281.                 //如果还是没出来再尝试two corner
  282.                 if(!ko){
  283. //                    System.out.println("two corner A");
  284.                     vv.removeAllElements();
  285.                     //先分析特殊情况  两点共线
  286.                     if(Bx==sign[0]){
  287.                         for(int i=Bx-1;i>=0;--i){//左遍历
  288.                             if(gameArry[i][By]==100&&gameArry[i][sign[1]]==100){
  289.                                 this.getTT(1,i,By);
  290.                                 this.getTT(1,i,sign[1]);
  291.                                 this.getTT(3,i,By<sign[1]?By:sign[1]);
  292.                                 this.getTT(2,i,By>sign[1]?By:sign[1]);
  293.                                 ko=true;
  294.                                 for(int j=(By<sign[1]?By:sign[1])+1;j<(By>sign[1]?By:sign[1]);++j){
  295.                                     this.getTT(3,i,j);
  296.                                     if(gameArry[i][j]!=100){
  297.                                         ko=false;
  298.                                         vv.removeAllElements();
  299.                                         break;
  300.                                     }
  301.                                 }
  302.                                 if(ko){
  303.                                     for(int k=i+1;k<Bx;++k){
  304.                                         this.getTT(1,k,By);
  305.                                         this.getTT(1,k,sign[1]);
  306.                                         if(gameArry[k][By]!=100||gameArry[k][sign[1]]!=100){
  307.                                             vv.removeAllElements();
  308.                                             ko=false;
  309.                                             break;
  310.                                         }
  311.                                     }
  312.                                 }
  313.                                 if(ko){
  314.                                     break;
  315.                                 }
  316.                             }
  317.                         }
  318.                         if(!ko){
  319.                             for(int i=Bx+1;i<gameArry.length;++i){//右遍历
  320.                                 if(gameArry[i][By]==100&&gameArry[i][sign[1]]==100){
  321.                                     ko = true;
  322.                                     this.getTT(0,i,By);
  323.                                     this.getTT(0,i,sign[1]);
  324.                                     this.getTT(3,i,By < sign[1] ? By : sign[1]);
  325.                                     this.getTT(2,i,By > sign[1] ? By : sign[1]);
  326.                                     for (int j = (By < sign[1] ? By : sign[1]) +1;j <(By > sign[1] ? By : sign[1]);++j) {
  327.                                         this.getTT(3,i,j);
  328.                                         if (gameArry[i][j] != 100) {
  329.                                             vv.removeAllElements();
  330.                                             ko = false;
  331.                                             break;
  332.                                         }
  333.                                     }
  334.                                     if (ko) {
  335.                                         for (int k = i - 1; k > Bx; --k) {
  336.                                             this.getTT(0,k,By);
  337.                                             this.getTT(0,k,sign[1]);
  338.                                             if (gameArry[k][By] != 100 ||gameArry[k][sign[1]] != 100) {
  339.                                                 ko = false;
  340.                                                 vv.removeAllElements();
  341.                                                 break;
  342.                                             }
  343.                                         }
  344.                                     }
  345.                                     if (ko) {
  346.                                         break;
  347.                                     }
  348.                                 }
  349.                             }
  350.                         }
  351.                     }
  352.                     else if(By==sign[1]){
  353.                         for(int i=By-1;i>=0;--i){//上遍历
  354.                             if(gameArry[Bx][i]==100&&gameArry[sign[0]][i]==100){
  355.                                 this.getTT(3,Bx,i);
  356.                                 this.getTT(3,sign[0],i);
  357.                                 this.getTT(1,Bx<sign[0]?Bx:sign[0],i);
  358.                                 this.getTT(0,Bx>sign[0]?Bx:sign[0],i);
  359.                                 ko=true;
  360.                                 for(int j=(Bx<sign[0]?Bx:sign[0])+1;j<(Bx>sign[0]?Bx:sign[0]);++j){
  361.                                     this.getTT(1,j,i);
  362.                                     if(gameArry[j][i]!=100){
  363.                                         vv.removeAllElements();
  364.                                         ko=false;
  365.                                         break;
  366.                                     }
  367.                                 }
  368.                                 if(ko){
  369.                                     for(int k=i+1;k<By;++k){
  370.                                         this.getTT(3,Bx,k);
  371.                                         this.getTT(3,sign[0],k);
  372.                                         if(gameArry[Bx][k]!=100||gameArry[sign[0]][k]!=100){
  373.                                             ko=false;
  374.                                             vv.removeAllElements();
  375.                                             break;
  376.                                         }
  377.                                     }
  378.                                 }
  379.                                 if(ko){
  380.                                     break;
  381.                                 }
  382.                             }
  383.                         }
  384.                         if(!ko){
  386.                             for(int i=By+1;i<gameArry[0].length;++i){//下遍历
  387.                                 if(gameArry[Bx][i]==100&&gameArry[sign[0]][i]==100){
  388.                                     ko = true;
  389.                                     this.getTT(2,Bx,i);
  390.                                     this.getTT(2,sign[0],i);
  391.                                     this.getTT(1,Bx < sign[0] ? Bx : sign[0],i);
  392.                                     this.getTT(0,Bx > sign[0] ? Bx : sign[0],i);
  393.                                     for (int j = (Bx < sign[0] ? Bx : sign[0]) + 1;j < (Bx > sign[0] ? Bx : sign[0]); ++j) {
  394.                                         this.getTT(1,j,i);
  395.                                         if (gameArry[j][i] != 100) {
  396.                                             vv.removeAllElements();
  397.                                             ko = false;
  398.                                             break;
  399.                                         }
  400.                                     }
  401.                                     if (ko) {
  402.                                         for (int k = i - 1; k > By; --k) {
  403.                                             this.getTT(2,Bx,k);
  404.                                             this.getTT(2,sign[0],k);
  405.                                             if (gameArry[Bx][k] != 100 || gameArry[sign[0]][k] != 100) {
  406.                                                 vv.removeAllElements();
  407.                                                 ko = false;
  408.                                                 break;
  409.                                             }
  410.                                         }
  411.                                     }
  412.                                     if (ko) {
  413.                                         break;
  414.                                     }
  415.                                 }
  416.                             }
  417.                         }
  418.                     }//特殊情况分析完毕 开始nb分析
  419.                     else  {
  420. //                System.out.println("two corner B");
  421.                 vv.removeAllElements();
  422. //                System.out.println("you begin!");
  423.                 for (int i = Bx + 1; i < gameArry.length; ++i) { //右扫描
  424.                     if (gameArry[i][By] == 100 &&gameArry[i][sign[1]] == 100) {
  425.                         this.getTT(0,i,By);
  426.                         this.getTT(sign[0]<i?0:1,i,sign[1]);
  427.                         this.getTT(3,i,By < sign[1] ? By : sign[1]);
  428.                         this.getTT(2,i,By > sign[1] ? By : sign[1]);
  429.                         ko = true;
  430.                         for (int j = (By < sign[1] ? By : sign[1]) + 1;j < (By > sign[1] ? By : sign[1]); ++j) {
  431.                             this.getTT(3,i,j);
  432.                             if (gameArry[i][j] != 100) {
  433.                                 ko = false;
  434.                                 vv.removeAllElements();
  435.                                 break;
  436.                             }
  437.                         }
  438.                         if (ko) {
  439.                             for (int k = i - 1; k > Bx; --k) {
  440.                                 this.getTT(0,k,By);
  441.                                 if (gameArry[k][By] != 100) {
  442.                                     ko = false;
  443.                                     vv.removeAllElements();
  444.                                     break;
  445.                                 }
  446.                             }
  447.                         }
  448.                         if (ko) {
  449.                             for (int k = (i > sign[0] ? i : sign[0]) -1;k > (i < sign[0] ? i : sign[0]);--k) {
  450.                                 this.getTT(0,k,sign[1]);
  451.                                 if (gameArry[k][sign[1]] != 100) {
  452.                                     ko = false;
  453.                                     vv.removeAllElements();
  454.                                     break;
  455.                                 }
  456.                             }
  457.                         }
  458.                     }
  459.                     if (ko)
  460.                         break;
  461.                 }
  462.                 if (!ko) {
  463. //                    System.out.println("zuo begin!");
  464.                     for (int i = Bx - 1; i >= 0; --i) { //左扫描
  465.                         if (gameArry[i][By] == 100 &&gameArry[i][sign[1]] == 100) {
  466.                             ko = true;
  467.                             this.getTT(1,i,By);
  468.                             this.getTT(sign[0]>i?1:0,i,sign[1]);
  469.                             this.getTT(3,i,By < sign[1] ? By : sign[1]);
  470.                             this.getTT(2,i,By > sign[1] ? By : sign[1]);
  471.                             for (int j = (By < sign[1] ? By : sign[1]) +1;j <(By > sign[1] ? By : sign[1]);++j) {
  472.                                 this.getTT(3,i,j);
  473.                                 if (gameArry[i][j] != 100) {
  474.                                     ko = false;
  475.                                     vv.removeAllElements();
  476.                                     break;
  477.                                 }
  478.                             }
  479.                             if (ko) {
  480.                                 for (int k = i + 1; k < Bx; ++k) {
  481.                                     this.getTT(1,k,By);
  482.                                     if (gameArry[k][By] != 100) {
  483.                                         ko = false;
  484.                                         vv.removeAllElements();
  485.                                         break;
  486.                                     }
  487.                                 }
  488.                             }
  489.                             if (ko) {
  490.                                 for (int k = (i < sign[0] ? i : sign[0]) +1;k < (i > sign[0] ? i : sign[0]);++k) {
  491.                                     this.getTT(1,k,sign[1]);
  492.                                     if (gameArry[k][sign[1]] != 100) {
  493.                                         ko = false;
  494.                                         vv.removeAllElements();
  495.                                         break;
  497.                                     }
  498.                                 }
  499.                             }
  500.                         }
  501.                         if (ko)
  502.                             break;
  503.                     }
  504.                 }
  505.                 if(!ko){//上扫描
  506. //                    System.out.println("shang begin!");
  507.                     for(int i = By-1;i>=0;--i){
  508.                         if(gameArry[Bx][i]==100&&gameArry[sign[0]][i]==100){
  509.                             ko=true;
  510.                             this.getTT(3,Bx,i);
  511.                             this.getTT(sign[1]>i?3:2,sign[0],i);
  512.                             this.getTT(1,Bx<sign[0]?Bx:sign[0],i);
  513.                             this.getTT(0,Bx>sign[0]?Bx:sign[0],i);
  514.                             for(int j= (Bx<sign[0]?Bx:sign[0])+1;j<(Bx>sign[0]?Bx:sign[0]);++j){
  515.                                 this.getTT(1,j,i);
  516.                                 if(gameArry[j][i]!=100){
  517.                                     vv.removeAllElements();
  518.                                     ko=false;
  519.                                     break;
  520.                                 }
  521.                             }
  522.                             if(ko){
  523.                                 for(int k= i+1;k<By;++k){
  524.                                     this.getTT(3,Bx,k);
  525.                                     if(gameArry[Bx][k]!=100){
  526.                                         ko=false;
  527.                                         vv.removeAllElements();
  528.                                         break;
  529.                                     }
  530.                                 }
  531.                             }
  532.                             if(ko){
  533.                                 for(int k= (i<sign[1]?i:sign[1])+1;k<(i>sign[1]?i:sign[1]);++k){
  534.                                     this.getTT(3,sign[0],k);
  535.                                     if(gameArry[sign[0]][k]!=100){
  536.                                         vv.removeAllElements();
  537.                                         ko=false;
  538.                                         break;
  539.                                     }
  540.                                 }
  541.                             }
  542.                         }
  543.                         if(ko)
  544.                             break;
  545.                     }
  546.                 }
  547.                 if(!ko){//下扫描
  548. //                    System.out.println("xia begin!");
  549.                     for(int i=By+1;i<gameArry[0].length;++i){
  550.                         if(gameArry[Bx][i]==100&&gameArry[sign[0]][i]==100){
  551.                             ko=true;
  552.                             this.getTT(2,Bx,i);
  553.                             this.getTT(sign[1]<i?2:3,sign[0],i);
  554.                             this.getTT(1,Bx<sign[0]?Bx:sign[0],i);
  555.                             this.getTT(0,Bx>sign[0]?Bx:sign[0],i);
  556.                             for(int j= (Bx<sign[0]?Bx:sign[0])+1;j<(Bx>sign[0]?Bx:sign[0]);++j){
  557.                                 this.getTT(1,j,i);
  558.                                 if(gameArry[j][i]!=100){
  559.                                     ko=false;
  560.                                     vv.removeAllElements();
  561.                                     break;
  562.                                 }
  563.                             }
  564.                             if(ko){
  565.                                 for(int k=i-1;k>By;--k){
  566.                                     this.getTT(2,Bx,k);
  567.                                     if(gameArry[Bx][k]!=100){
  568.                                         vv.removeAllElements();
  569.                                         ko=false;
  570.                                         break;
  571.                                     }
  572.                                 }
  573.                             }
  574.                             if(ko){
  575.                                 for(int k= (i>sign[1]?i:sign[1])-1;k>(i<sign[1]?i:sign[1]);--k){
  576.                                     this.getTT(2,sign[0],k);
  577.                                     if(gameArry[sign[0]][k]!=100){
  578.                                         ko=false;
  579.                                         vv.removeAllElements();
  580.                                         break;
  581.                                     }
  582.                                 }
  583.                             }
  584.                         }
  585.                         if(ko)
  586.                             break;
  587.                     }
  588.                 }
  589.             }
  590.         }
  591.     }
  592. }
  593. //System.out.println("----------");
  594. return ko;
  595.     }
Colonleado
关注
专栏目录
MySQL和java连连看_用 JAVA 开发游戏连连看（之一）动手前的准备
weixin_29960041的博客
02-07 246
JAVA ，相信大家也不会陌生了吧， JAVA 是一门相当优秀的语言。目前 JAVA 领域 J2EE 、 JSP 、 STRUTS 等技术不知有多么的热门，他们的主要用途是用来进行企业开发， J2ME 也由于能够被大量的移动设备所支持，因此，也有不少的程序，特别是游戏是在 J2ME 平台上开发的，反而是 J2SE ，似乎只是被人们用来做一做程序界面的，就连 APPLET 也很少有人使用了(有了 F...
基于Java的连连看游戏设计与实现(含源文件)
【完整】
03-08 7112
欢迎添加微信互相交流学习哦！ 项目源码：https://gitee.com/oklongmm/biye 毕业设计（论文）任务书 第1页 毕业设计（论文）题目： 基于Java的连连看游戏设计与实现 毕业设计（论文）要求及原始数据（资料）： 1．简述Java游戏开发现状和走向； 2．了解图形用户界面的概念； 3．熟练掌握Java的事件处理机制； 4．掌握Java小程序的工作原理和使用方法； 5．了解AWT的基本体系结构，掌握窗口的基本原理； 6. 掌握几种布局管理器的使用方法； 7. 了解Sw...
基于Java的连连看游戏设计与实现
weixin_46879314的博客
07-26 1040
基于 Java 的连连看游戏设计与实现
用 JAVA 开发游戏连连看
sxchen2012的专栏
04-08 4476
用 JAVA 开发游戏连连看 (注：这篇文章是在2004.12完成的，当时是为了向《电脑爱好者》投稿，这是原稿，由于此杂志面向的读者原因，因此文章中有些地方显得过“白”，在此后，稿子经过两次修改，虽然最终得以发表，但已改得基本上没有太多的技术性了，而且两次改稿下来，一共写了近6万字，累~~~，现在将其略作修改放在主页上，希望对大家有所帮助)    提起 JAVA ，相信大家
【java毕业设计】基于java+swing+GUI的连连看游戏设计与实现（毕业论文+程序源码）——连连看游戏
m0_66238867的博客
06-23 5174
大家好，今天给大家介绍基于java+swing+GUI的连连看游戏设计与实现，文章末尾附有本毕业设计的论文和源码下载地址哦。文章目录： 连连看是一种消除类益智游戏，核心要求是在规定的时间内，消除游戏界面中选中的两张相同的图案，直至完全消除所有图案。这款游戏操作简单(只需单击鼠标左键操作)、面向人群广泛，在限时操作的游戏要求下，吸引玩家自发地锻炼观察能力、判断能力和反应能力，故从推出至今颇受欢迎。消除类游戏如今也有很多类型，但连连看游戏因其操作简单依旧广受好评，该游戏不仅能调节精神状态，还能在游戏中锻炼我们的
基于Java的连连看游戏毕业论文
biyesheji1000的专栏
02-26 1049
基于Java的连连看游戏设计与实现连连看是一种消除类益智游戏，核心要求是在规定的时间内，消除游戏界面中选中的两张相同的图案，直至完全消除所有图案。这款游戏操作简单(只需单击鼠标左键操作)、面向人群广泛，在限时操作的游戏要求下，吸引玩家自发地锻炼观察能力、判断能力和反应能力，故从推出至今颇受欢迎。消除类游戏如今也有很多类型，但连连看游戏因其操作简单依旧广受好评，该游戏不仅能调节精神状态，还能在游戏中锻炼我们的眼力视野和集中力，开发思维能力的同时培养面对困难时具备攻克困难的信心。
用 JAVA 开发游戏连连看（之一）动手前的准备
CSDN流星追月专属频道--吃的苦中苦，方为人上人！
09-03 1191
JAVA ，相信大家也不会陌生了吧， JAVA 是一门相当优秀的语言。目前 JAVA 领域 J2EE 、 JSP 、 STRUTS 等技术不知有多么的热门，他们的主要用途是用来进行企业开发， J2ME 也由于能够被大量的移动设备所支持，因此，也有不少的程序，特别是游戏是在 J2ME 平台上开发的，反而是 J2SE ，似乎只是被人们用来做一做程序界面的，就连 APPLET 也很少有人使用了（有了 F
java游戏开始被流星_用 JAVA 开发游戏连连看（之一）动手前的准备
weixin_39859052的博客
02-26 72
JAVA ，相信大家也不会陌生了吧， JAVA 是一门相当优秀的语言。目前 JAVA 领域 J2EE 、 JSP 、 STRUTS 等技术不知有多么的热门，他们的主要用途是用来进行企业开发， J2ME 也由于能够被大量的移动设备所支持，因此，也有不少的程序，特别是游戏是在 J2ME 平台上开发的，反而是 J2SE ，似乎只是被人们用来做一做程序界面的，就连 APPLET 也很少有人使用了(有了 F...
java开发速成班培训课程（8）
iteye_10490的博客
10-24 446
[url=http://www.buildapp.net/java/show.asp?id=19400]急需!急需!下载jpcap＆winpcap [/url] [url=http://www.buildapp.net/java/show.asp?id=19399]菜鸟求助 [/url] [url=http://www.buildapp.net/java/show.asp?id=...
LLK.rar_j2me_j2me l_j2me 连连看_llk_连连看 j2me
09-23
本篇文章将深入探讨一个基于J2ME 1.x版本实现的连连看游戏——LLK，分析其源代码，揭示其中的技术要点，以及如何实现对不同屏幕的自动适应。 1. **J2ME基础** J2ME是Java平台的一个子集，设计用于资源有限的嵌入式...
j2me连连看代码.rar_j2me 游戏_j2me 连连看_小游戏代码_连连看 java_连连看 j2me
09-24
总之，开发J2ME连连看游戏需要掌握J2ME的基本框架，理解GUI设计，编写逻辑算法，并进行性能优化。通过这个过程，开发者不仅可以学习到游戏开发的技巧，还能加深对J2ME平台的理解，为其他类型的移动应用开发打下坚实...
LLK.rar_llk_基于J2ME的 连连看游戏
09-24
开发者需要实现一个算法来检查相邻的图案是否匹配，以及当前选择的图案能否构成有效的消除路径。这个过程可能涉及到二维数组的遍历，以及一些状态的维护。 源代码的开放性使得我们有机会深入研究游戏的实现细节。...
J2ME连连看.rar
09-15
【标题】"J2ME连连看.rar"是一个包含J2ME（Java 2 Micro Edition）技术实现的连连看游戏源代码的压缩包。J2ME是Java平台的一个子集，主要用于开发移动设备、嵌入式系统等小型应用程序，特别是在早期智能手机和功能...
j2me连连看Demo
12-23
四、连连看游戏的算法实现 1. 图形布局：首先，我们需要随机生成或预设一个二维数组来代表棋盘，每个元素对应一个可消除的图案。 2. 检测匹配：利用深度优先搜索（DFS）或广度优先搜索（BFS）等图论方法，查找相邻...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
最新发布
qq_61936886的博客
09-12 436
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1132
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 281
试除法求约数、约数个数、约数之和、最大公约数
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1163
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
J2ME连连看游戏代码实现与解析
"这篇资源是关于J2ME平台上的连连看游戏代码框架的分享，包含了一个基础的MIDlet类和一个Canvas界面类。代码结构清晰，并且有详细的注释，便于理解与学习。作者鼓励有想法的读者提出建议。" 在Java 2 Micro Edition...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值