Android 游戏开发之连连看

因为有朋友在站内信中问到连连看的具体算法，所以我就把算法post出来，这个算法也是参考网上Flash游戏的算法改写的，原来的参考信息已经找不到了，不过非常感谢那些无私的朋友。

 

改写的连连看算法如下：

前置条件：用一二维数组存放Map,-1表示没有图案可以连通，非-1表示不同的图案。

首先是横向检测：

 

Java代码  

1. private boolean horizon(Point a, Point b)  
2.     {  
3.         if(a.x == b.x && a.y == b.y)//如果点击的是同一个图案，直接返回false  
4.             return false;  
5.         int x_start = a.y <= b.y ? a.y : b.y;  
6.         int x_end = a.y <= b.y ? b.y : a.y;  
7.         for(int x = x_start + 1; x < x_end; x++)//只要一个不是-1，直接返回false  
8.             if(map[a.x][x] != -1){  
9.                 return false;  
10.             }  
11.         return true;  
12.     }  

 其次是纵向检测：

 

Java代码  

1. private boolean vertical(Point a, Point b)  
2. {  
3.     if(a.x == b.x && a.y == b.y)  
4.         return false;  
5.     int y_start = a.x <= b.x ? a.x : b.x;  
6.     int y_end = a.x <= b.x ? b.x : a.x;  
7.     for(int y = y_start + 1; y < y_end; y++)  
8.         if(map[y][a.y] != -1)  
9.             return false;  
10.     return true;  
11. }  

 一个拐角的检测：

如果一个拐角能连通的话，则必须存在C、D两点。其中C点的横坐标和A相同，纵坐标与B相同，D的横坐标与B相同，纵坐标与A相同。

 

Java代码  

1. private boolean oneCorner(Point a, Point b)  
2. {  
3.     Point c = new Point(a.x, b.y);  
4.     Point d = new Point(b.x, a.y);  
5.     if(map[c.x][c.y] == -1)  
6.     {  
7.         boolean method1 = horizon(a, c) && vertical(b, c);  
8.             return method1;  
9.     }  
10.     if(map[d.x][d.y] == -1)  
11.     {  
12.         boolean method2 = vertical(a, d) && horizon(b, d);  
13.         return method2;  
14.     } else  
15.     {  
16.         return false;  
17.     }  
18. }  

 两个拐角的检测：

这个比较复杂，如果两个拐角能连通的话，则必须存在图中所示的连线，这些连线夹在A、B的横、纵坐标之间,这样的线就以下这个类存储，direct是线的方向，用0、1表示不同的方向

LIne类结构如下：

 

Java代码  

1. class Line  
2.     {  
3.         public Point a;  
4.         public Point b;  
5.         public int direct;  
6.   
7.         public Line()  
8.         {  
9.         }  
10.   
11.         public Line(int direct, Point a, Point b)  
12.         {  
13.             this.direct = direct;  
14.             this.a = a;  
15.             this.b = b;  
16.         }  
17.     }  

 

从A、B点的横纵两个方向进行扫描，就是Scan函数做的事情，把合适的线用LinkList存起来。

 

Java代码  

1. private LinkedList scan(Point a, Point b)  
2.     {  
3.         ll = new LinkedList<Line>();  
4.         //Point c = new Point(a.x, b.y);  
5.         //Point d = new Point(b.x, a.y);  
6.         for(int y = a.y; y >= 0; y--)  
7.             if(map[a.x][y] == -1 && map[b.x][y] == -1 && vertical(new Point(a.x, y), new Point(b.x, y)))  
8.                 ll.add(new Line(0, new Point(a.x, y), new Point(b.x, y)));  
9.   
10.         for(int y = a.y; y < map.row; y++)  
11.             if(map[a.x][y] == -1 && map[b.x][y] == -1 && vertical(new Point(a.x, y), new Point(b.x, y)))  
12.                 ll.add(new Line(0, new Point(a.x, y), new Point(b.x, y)));  
13.   
14.         for(int x = a.x; x >= 0; x--)  
15.             if(map[x][a.y] == -1 && map[x][b.y] == -1 && horizon(new Point(x, a.y), new Point(x, b.y)))  
16.                 ll.add(new Line(1, new Point(x, a.y), new Point(x, b.y)));  
17.   
18.         for(int x = a.x; x < map.column; x++)  
19.             if(map[x][a.y] == -1 && map[x][b.y] == -1 && horizon(new Point(x, a.y), new Point(x, b.y)))  
20.                 ll.add(new Line(1, new Point(x, a.y), new Point(x, b.y)));  
21.   
22.         return ll;  
23.   }  

 最后是两个拐角的算法：

 取出LinkList里面的线，测试A与B到该线的两点是否连通。

Java代码  

1. private boolean twoCorner(Point a, Point b)  
2. {  
3.     ll = scan(a, b);  
4.     if(ll.isEmpty())  
5.         return false;  
6.     for(int index = 0; index < ll.size(); index++){  
7.         Line line = (Line)ll.get(index);  
8.         if(line.direct == 1){  
9.             if(vertical(a, line.a) && vertical(b, line.b)){  
10.                 return true;  
11.             }  
12.   
13.         } else  
14.         if(horizon(a, line.a) && horizon(b, line.b)){  
15.             return true;  
16.         }  
17.     }  
18.     return false;  
19. }  

 前面的函数有以下这个总的调用函数来调用，传入两个点，就可以判断这两个点是否符合连连看的算法了：

Java代码  

1. public boolean checkLink(Point a,Point b){  
2.     if(map[a.x][a.y] != map[b.x][b.y])//如果图案不同，直接为false  
3.            return false;  
4.        if(a.x == b.x && horizon(a, b))  
5.            return true;  
6.        if(a.y == b.y && vertical(a, b))  
7.            return true;  
8.        if(oneCorner(a, b))  
9.            return true;  
10.        else  
11.            return twoCorner(a, b);  
12. }