关于j2me实现拼图游戏的算法实现

 

0    1   2     3

4    5   6     7

8    9   10   11

12  13 14 

 

因为前些日子做了一些简单的益智游戏，所以涉及了一些算法上的问题，本来以为这些小游戏非常简单，但也为了效率的确令我小头痛了一下。

开始很快的写玩拼图游戏，玩了玩发现有时候会无解，到论坛看了看，好多人在探讨如何验证拼图无解，大概就是矩阵的逆序数+数眼的奇偶性判断。

正痛苦的时候老付跟我说，你回忆一下咱小时候玩拼图怎么玩的呢，我说我拼不好的话就给它们都扣下来再按上，他说都是完整的拼图手动随意打乱的。

果然啊，其实如果是拼图游戏不必如此费力还要去验证是否有解，如果是生成的整齐矩阵，手动打乱的话必然能保证有解。

初始化时，根据随机数去让图块4方向填补空位。循环100次就ok了。

 

部分代码如下：

 

 

1.     //4X4的数组
2.     public static final int  game1[][]={
3.                          {0,1,2,3},
4.                          {4,5,6,7},
5.                          {8,9,10,11},
6.                          {12,13,14,15}
7.     };
9.    //得到顺序2维数组
10.     public int [][] get2arry(int arry[][]){
11.             arry=null;
12.             arry=new int[4][4];
13.             for(int i=0;i<arry.length;++i){
14.                 for(int j=0;j<arry[i].length;++j){
15.                     arry[i][j]=i*4+j;
16.                 }
17.             }
18.         return arry;
19.     }
20.     //初始化图块数组
21.     public void InitMy() {
22.         if (buffergame == null) {
23.             int index = 0;
24.             int bufferInt = 0;
25.             buffergame = this.get2arry(buffergame);
26.             while (true) {
27.                 for (int i = 0; i < buffergame.length; ++i) {
28.                     for (int j = 0; j < buffergame[i].length; ++j) {
29.                         if (buffergame[i][j] == 0) {
30.                             bufferInt = t.getRandomNumber(0, 2000);
31.                             if (bufferInt < 500) {
32.                                 if (i == 3) {
33.                                     break;
34.                                 }
35.                                 buffergame[i][j] = buffergame[i +
36.                                         1][j];
37.                                 buffergame[i + 1][j] = 0;
38.                                 ++index;
39.                             } else if (bufferInt < 1000) {
40.                                 if (i == 0) {
41.                                     break;
42.                                 }
43.                                 buffergame[i][j] = buffergame[i -
44.                                         1][j];
45.                                 buffergame[i - 1][j] = 0;
46.                                 ++index;
47.                             } else if (bufferInt < 1500) {
48.                                 if (j == 3) {
49.                                     break;
50.                                 }
51.                                 buffergame[i][j] = buffergame[i][j +
52.                                         1];
53.                                 buffergame[i][j + 1] = 0;
54.                                 ++index;
55.                             } else {
56.                                 if (j == 0) {
57.                                     break;
58.                                 }
59.                                 buffergame[i][j] = buffergame[i][j -
60.                                         1];
61.                                 buffergame[i][j - 1] = 0;
62.                                 ++index;
63.                             }
64.                         }
65.                     }
66.                 }
67.                 if (index > 200) {
68.                     break;
69.                 }
70. //                        int pos1, pos2;
71. //                        for (int i = 0; i < buffergame.length; ++i) {
72. //                            for (int j = 0; j < buffergame[i].length; ++j) {
73. //                                while (true) {
74. //                                    pos1 = t.getRandomNumber(0, 3);
75. //                                    pos2 = t.getRandomNumber(0, 3);
76. //                                    if (buffer[pos1][pos2] != 100) {
77. //                                        buffergame[i][j] = buffer[pos1][pos2];
78. //                                        buffer[pos1][pos2] = 100;
79. ////                                        System.out.println("buffergame[" + i +
80. ////                                                "][" + j + "]==" +
81. ////                                                buffergame[i][j]);
82. //                                        break;
83. //                                    }
84. //                                }
85. //                            }
86. //                        }
87. //                        //如果奇偶性不同 从新生成
88. //                        if(this.TestArry(buffergame)){
89. //                            if(Type.isprint)
90. //                                System.out.println("有解");
91. //                            break;
92. //                        }else{
93. //                            if(Type.isprint)
94. //                                System.out.println("无解");
95. //                        }
96. //                    }
97.             }
98.         }
100.         if (Type.isprint)
101.             System.out.println("Init is ok!!");
102.     }