C# 实现连连看功能(推荐)

引言

连连看是一种受欢迎的游戏，早期多出现在各种小游戏网站和手机应用中。连连看的功能算法也较为复杂，本文将使用C#编程语言来实现连连看功能，供各位开发者参考。

分析

连连看的主要逻辑是，选择两个相同的图片，并且图片之间的连接线条不超过三条，即可消除这两个图片。为了实现这个功能，需要按照以下步骤来进行操作：

1. 搭建界面
2. 加载图片资源
3. 建立数据结构
4. 实现寻找可消除图片的算法
5. 实现图片消除算法
6. 实现判断游戏是否结束的算法

搭建界面

首先我们需要搭建一个游戏界面，可以使用Windows窗体应用程序来实现。在Visual Studio中，新建一个Windows窗体项目，然后在窗体上添加PictureBox控件，用于显示图片；再添加一个Timer控件，用于定时更新游戏界面。

加载图片资源

在窗体的构造函数中，我们需要加载图片资源。可以将图片资源放在资源文件中，使用ResourceManager类来获取资源文件中的图片：

ResourceManager rm = new ResourceManager(typeof(Resources));
Image[] images = new Image[10];
for (int i = 0; i < 10; i++)
{
    images[i] = (Image)rm.GetObject("pic" + i.ToString());
}

在上述代码中，pic0到pic9是我们资源文件中的图片名称，通过GetObject方法获取图片资源，然后存放在一个Image类型的数组中以便后面使用。

建立数据结构

为了实现寻找可消除图片的算法，我们需要建立数据结构来存储每个图片，并记录它们之间是否可以消除。常见的数据结构有一个二维数组，用于存储整个游戏界面上的图片。可以定义一个枚举类型来表示每个位置的图片状态：

enum TileState
{
    Empty, // 空
    Ready, // 已经被选择
    Filled // 已经有图片
}

在窗体类中定义一个二维数组和枚举类型：

const int ROWS = 10;
const int COLS = 10;

TileState[,] tiles = new TileState[ROWS, COLS];
PictureBox[,] pics = new PictureBox[ROWS, COLS];

在窗体的Load事件中，我们还需要对tiles数组进行初始化：

for (int i = 0; i < ROWS; i++)
{
    for (int j = 0; j < COLS; j++)
    {
        tiles[i, j] = TileState.Empty;
    }
}

实现寻找可消除图片的算法

为了寻找可消除图片，我们可以用广度优先搜索（BFS）算法来实现。BFS算法是一种基于队列的搜索算法，常用于解决人脑难以处理的谜题。在这里，我们可以将每张图片视为一个节点，将两张相同的图片之间的连线视为边，使用BFS算法来搜索两张相同的图片之间是否存在一条路径，使得路径上的所有图片都相同。

在窗体类中定义一个FindPath方法：

bool FindPath(int row1, int col1, int row2, int col2)
{
    // 定义两个队列，用于实现BFS算法
    Queue<int> qrow = new Queue<int>();
    Queue<int> qcol = new Queue<int>();
    // 定义一个visited数组，用于标记已经访问过的节点
    bool[,] visited = new bool[ROWS, COLS];
    for (int i = 0; i < ROWS; i++)
    {
        for (int j = 0; j < COLS; j++)
        {
            visited[i, j] = false;
        }
    }
    // 将第一个节点加入队列
    qrow.Enqueue(row1);
    qcol.Enqueue(col1);
    visited[row1, col1] = true;
    // 开始BFS算法
    while (qrow.Count > 0 && qcol.Count > 0)
    {
        int r = qrow.Dequeue();
        int c = qcol.Dequeue();
        if (r == row2 && c == col2)
        {
            // 找到了一条路径
            return true;
        }
        // 检查周围的四个节点是否可以访问
        if (r - 1 >= 0 && tiles[r - 1, c] != TileState.Filled && !visited[r - 1, c])
        {
            qrow.Enqueue(r - 1);
            qcol.Enqueue(c);
            visited[r - 1, c] = true;
        }
        if (r + 1 < ROWS && tiles[r + 1, c] != TileState.Filled && !visited[r + 1, c])
        {
            qrow.Enqueue(r + 1);
            qcol.Enqueue(c);
            visited[r + 1, c] = true;
        }
        if (c - 1 >= 0 && tiles[r, c - 1] != TileState.Filled && !visited[r, c - 1])
        {
            qrow.Enqueue(r);
            qcol.Enqueue(c - 1);
            visited[r, c - 1] = true;
        }
        if (c + 1 < COLS && tiles[r, c + 1] != TileState.Filled && !visited[r, c + 1])
        {
            qrow.Enqueue(r);
            qcol.Enqueue(c + 1);
            visited[r, c + 1] = true;
        }
    }
    // 没有找到路径
    return false;
}

在上述代码中，我们使用了两个队列来实现BFS算法。首先将第一个节点加入队列，然后不断从队列中取出节点，并将周围的四个节点加入队列中。注意，每个节点只能被访问一次，因此我们需要使用一个visited数组来标记已经访问过的节点。如果找到了第二个节点，则说明存在一条路径，使得两张图片之间的连线不超过三条。

实现图片消除算法

当用户点击了两张相同的图片时，我们需要将它们消除。我们可以使用递归算法来实现消除图片，找出两张图片之间的一条路径，然后从前往后依次消除路径上的所有图片。

在窗体类中定义一个RemovePath方法：

void RemovePath(int row1, int col1, int row2, int col2)
{
    // 先填充已经选择的图片
    tiles[row1, col1] = TileState.Ready;
    tiles[row2, col2] = TileState.Ready;
    // 找出两个图片之间的路径
    List<int> pathRows = new List<int>();
    List<int> pathCols = new List<int>();
    FindPathRecursive(row1, col1, row2, col2, pathRows, pathCols);
    // 从前往后依次消除路径上的所有图片
    for (int i = pathRows.Count - 1; i >= 0; i--)
    {
        int r = pathRows[i];
        int c = pathCols[i];
        tiles[r, c] = TileState.Empty;
        pics[r, c].Image = null;
        UpdatePictureBox(pics[r, c]);
    }
}

在上述代码中，我们先把已经选择的图片填充成Ready状态，然后使用FindPathRecursive方法找出两张图片之间的路径。最后，从前往后依次消除路径上的所有图片。

在窗体类中定义一个FindPathRecursive方法，用于递归查找路径：

bool FindPathRecursive(int r1, int c1, int r2, int c2, List<int> pathRows, List<int> pathCols)
{
    // 将当前节点加入路径
    pathRows.Add(r1);
    pathCols.Add(c1);
    // 如果找到终止节点，返回true
    if (r1 == r2 && c1 == c2)
    {
        return true;
    }
    // 递归查找周围的四个节点
    if (r1 - 1 >= 0 && tiles[r1 - 1, c1] != TileState.Filled && !pathRows.Contains(r1 - 1) && FindPathRecursive(r1 - 1, c1, r2, c2, pathRows, pathCols))
    {
        return true;
    }
    if (r1 + 1 < ROWS && tiles[r1 + 1, c1] != TileState.Filled && !pathRows.Contains(r1 + 1) && FindPathRecursive(r1 + 1, c1, r2, c2, pathRows, pathCols))
    {
        return true;
    }
    if (c1 - 1 >= 0 && tiles[r1, c1 - 1] != TileState.Filled && !pathCols.Contains(c1 - 1) && FindPathRecursive(r1, c1 - 1, r2, c2, pathRows, pathCols))
    {
        return true;
    }
    if (c1 + 1 < COLS && tiles[r1, c1 + 1] != TileState.Filled && !pathCols.Contains(c1 + 1) && FindPathRecursive(r1, c1 + 1, r2, c2, pathRows, pathCols))
    {
        return true;
    }
    // 删除已经加入的节点
    pathRows.RemoveAt(pathRows.Count - 1);
    pathCols.RemoveAt(pathCols.Count - 1);
    // 如果没有找到路径，返回false
    return false;
}

在上述代码中，我们使用了递归的方式来查找路径。首先将当前节点加入路径，然后递归查找周围的四个节点。如果找到终止节点，则返回true。如果没有找到路径，需要将已经加入的节点删除，并返回false。

实现判断游戏是否结束的算法

当所有的图片都被消除之后，游戏结束。我们可以在定时器的Tick事件中检查游戏是否结束，如果结束则弹出游戏结束提示。

在窗体类中定义一个IsGameOver方法：

bool IsGameOver()
{
    for (int i = 0; i < ROWS; i++)
    {
        for (int j = 0; j < COLS; j++)
        {
            if (tiles[i, j] == TileState.Filled)
            {
                // 如果还有一个填充的节点，则游戏没有结束
                return false;
            }
        }
    }
    return true;
}

在上述代码中，我们遍历整个tiles数组，如果还有一个填充的节点，则游戏没有结束。

示例说明1

比如在一个3行3列的界面中，我们随机生成以下九张图片：

1	2	1
2	3	3
4	4	5

点击第一行第一个和第一行第三个图片，根据我们的算法，它们是可以消除的，因为它们之间有一条路径：

*		*
2	3	3
4	4	5

其中星号（*）表示当前已选择的图片。点击了这两个图片之后，我们需要将它们消除：

2	3	3
4	4	5

这时，我们可以发现一张4号图片格子已经没有图片了，于是游戏还没有结束。

示例说明2

比如在一个3行3列的界面中，我们随机生成以下九张图片：

1	2	1
2	3	3
4	4	2

这时，我们点击第一行第一个和第一行第三个图片之后，可以消除它们：

	2
2	3	3
4	4	2

接着，我们点击了第三行第一列和第三行第三列的两张4号图片，可以消除它们：

	2
2	3	3

此时，游戏结束了，弹出游戏结束提示。