關於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.     }