第二个游戏 —— 连连看

今天又写了一个游戏 ——连连看，这个是个很经典的游戏，

我也想来试试看，如何实现它。

关键部分在于如何判定两个选中单元格是可以相连的。

经过分析，可以看到，连接的方式为一下几种模式

不管上述的哪种模式，都可以总结为如下的公式：

沿着x方向的所有x进行遍历，对于任何一个x来说，y1-y2之间的连接线如果是可以连接的，

而且，x1,y1~x,y1和x2,y2, x, y2之间都是可以连通的，那么这两个点就是可以连接的。

具体算法实现如下：

package org.stephen.connecty.control;

import org.stephen.connecty.model.Cell;
import org.stephen.connecty.model.Game;
import org.stephen.connecty.model.Grid;
import org.stephen.connecty.model.Position;
import org.stephen.connecty.model.Route;

public class RouteFinder {

    public Grid grid = new Grid();

    public void before() {
        Game game = Game.getInstance();
        for (int x = 0; x < Game.COLUMN_COUNT; x++) {
            for (int y = 0; y < Game.ROW_COUNT; y++) {
                grid.cells[y][x] = new Cell();
                grid.cells[y][x].type = game.grid.cells[y][x].type;
                grid.cells[y][x].selected = game.grid.cells[y][x].selected;
                grid.cells[y][x].destroyed = game.grid.cells[y][x].destroyed;
                grid.cells[y][x].marked = false;
            }
        }
    }

    public Route find(Position first, Position second) {

        Route vertical = findVertical(first, second);
        if (vertical != null) {
            return vertical;
        }

        Route horizontal = findHorizontal(first, second);
        if (horizontal != null) {
            return horizontal;
        }

        return null;
    }

    private Route findHorizontal(Position first, Position second) {
        for (int x = 0; x < Game.COLUMN_COUNT; x++) {
            boolean firstOk = false;
            boolean secondOk = false;
            boolean connectorOk = false;

            firstOk = checkHorizontalEmpty(first.x, x, first.y);
            secondOk = checkHorizontalEmpty(second.x, x, second.y);
            connectorOk = checkVerticalEmpty(first.y, second.y, x);
            if (firstOk && secondOk && connectorOk) {
                return new Route(first, new Position(x, first.y), new Position(
                        x, second.y), second);
            }
        }
        return null;
    }

    private Route findVertical(Position first, Position second) {
        for (int y = 0; y < Game.ROW_COUNT; y++) {
            boolean firstOk = false;
            boolean secondOk = false;
            boolean connectorOk = false;

            firstOk = checkVerticalEmpty(first.y, y, first.x);
            secondOk = checkVerticalEmpty(second.y, y, second.x);
            connectorOk = checkHorizontalEmpty(first.x, second.x, y);
            if (firstOk && secondOk && connectorOk) {
                return new Route(first, new Position(first.x, y), new Position(
                        second.x, y), second);
            }
        }
        return null;
    }

    private boolean checkVerticalEmpty(int y, int y2, int x) {
        int start = Math.min(y, y2);
        int end = Math.max(y, y2);

        for (int i = start; i <= end; i++) {
            if (!grid.cells[i][x].destroyed && !grid.cells[i][x].selected) {
                return false;
            }
        }
        return true;
    }

    private boolean checkHorizontalEmpty(int x, int x2, int y) {
        int start = Math.min(x, x2);
        int end = Math.max(x, x2);

        for (int i = start; i <= end; i++) {
            if (!grid.cells[y][i].destroyed && !grid.cells[y][i].selected) {
                return false;
            }
        }
        return true;
    }

}

上述算法的代码实现了描述中的搜索。但是搜索最佳路径时，可以把所有的可行路径都列出，然后寻找最短的那条。

另外，本次实现的代码中包含了，计时、皮肤等功能，

预留了模式（向左移动，向右移动等）、设置（难度，声音等）等的扩展接口，有兴趣的读者，可以自行完成。

但是，该代码的MouseListener.onClick反应不是很灵敏，导致操作上的问题。 —— 这是一个已知的Bug。

同时，由于Java书写的，也看到了性能问题，以后可以考虑改为Android来书写。

 源代码位置：https://files.cnblogs.com/stephen-wang/Connecty.zip