python小游戏开心消消乐制作-集成篇_开心消消乐 python+pygame 用于游玩、学习、二次开发使用

---

整篇前言

本篇文章集成了系列文章所有内容，可以只看这篇集成的文章，或者在每一章前言中找到链接前往每一章进行分章学习。源代码将会免费开放在我的主页的资源中源代码链接，大家感兴趣可以下载自行阅读，并进行二次开发，遇到的问题可以发在评论区和我交流讨论，共同进步。

---

第一章 pygame介绍

前言

python小游戏开心消消乐制作1-pygame介绍
在这篇文章中将介绍通过使用python中的pygame模块进行开心消消乐的制作。

---

一、pygame下载

通过使用

pip install pygame
1

下载pygame模块，以便后续导入

二、pygame游戏界面显示

1.引入库

import pygame #导入游戏库
import time
1
2

用于将pygame库引入

2.设置游戏窗口大小

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
1
2

设置屏幕大小全局变量

3.游戏窗口显示

if __name__ == '__main__':
	pygame.init() #初始化
	#设置游戏窗口的高度和宽度
	screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH)) 
	#设置游戏窗口的标题
	pygame.display.set_caption("happy remove")
	#填充游戏窗口的背景色
	screen.fill((124,114,242))
	#更新窗口
	pygame.display.update()
	while True:
		time.sleep(0.3)
1
2
3
4
5
6
7
8
9
10
11
12

这样就可以显示一个游戏窗口了

---

总结

在这篇文章中我们基本描述了如何使用pygame来制作一个基础的游戏窗口，但是我们发现这样的游戏窗口无法关闭，所以在下一篇文章中主要介绍如何获得点击事件。

---

第二章 游戏元素绘制

前言

python小游戏开心消消乐制作2-游戏元素绘制
在上一篇文章中，我们已经初步显示出了游戏窗口，同时我们也提出了，无法关闭游戏窗口的问题，在这篇文章中主要解决这一个问题，同时在游戏窗口中绘制出矩形方块。

---

一、关闭游戏窗口

在这里我们可以使用pygame.event.get()中获取鼠标事件，用event.type判断是否是关闭窗口事件。
为了退出游戏窗口，我们还需要引入sys库，使用sys.exit(0)来退出程序。
由于sys库是python自带的默认库，则我们直接在代码中导入即可:

import sys
1

while True:
        #获取鼠标响应
        for event in pygame.event.get():
        	if event.type == pygame.QUIT:
                sys.exit(0)
1
2
3
4
5

到这里我们就可以实现游戏窗口的显示和关闭了，完整代码如下:

import pygame #导入游戏库
import time
import sys
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
if __name__ == '__main__':
	pygame.init() #初始化
	#设置游戏窗口的高度和宽度
	screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH)) 
	#设置游戏窗口的标题
	pygame.display.set_caption("happy remove")
	#填充游戏窗口的背景色
	screen.fill((124,114,242))
	#更新窗口
	pygame.display.update()
	while True:
		#获取鼠标响应
        for event in pygame.event.get():
        	if event.type == pygame.QUIT:
                sys.exit(0)
		time.sleep(0.3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

二、矩形元素绘制

1.矩形元素绘制

矩形元素绘制我们可以通过pygame.draw.rect()来绘制，它所需要的参数分别是pygame.draw.rect(窗口对象,颜色值,位置和长宽(left,right,width,height))。
我们先绘制一个颜色为白色，长宽为50的矩形。

pygame.draw.rect(screen,(255,255,255),(0,0,50,50))
#不要忘记要更新窗口
pygame.display.update()
1
2
3

完整代码如下：

import pygame #导入游戏库
import time
import sys
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
if __name__ == '__main__':
	pygame.init() #初始化
	#设置游戏窗口的高度和宽度
	screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH)) 
	#设置游戏窗口的标题
	pygame.display.set_caption("happy remove")
	#填充游戏窗口的背景色
	screen.fill((124,114,242))
	#更新窗口
	pygame.display.update()
	while True:
		#获取鼠标响应
        for event in pygame.event.get():
        	if event.type == pygame.QUIT:
                sys.exit(0)
         pygame.draw.rect(screen,(255,255,255),(20,20,50,50))
		#不要忘记要更新窗口
		pygame.display.update()
		time.sleep(0.3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这样我们就可以得到一个矩阵元素啦

---

总结

本篇文章解决了窗口关闭问题和矩形元素绘制问题，但想要完成消消乐的功能，我们需要将一个矩形元素绘制成一个矩阵的形式，所以在下一章将介绍如何将矩形元素绘制成一个矩阵的形式，并且将它们封装成类的形式。

---

第三章 矩阵游戏元素绘制

前言

python小游戏开心消消乐制作3-矩阵游戏元素绘制
上篇文章中我们解决了游戏窗口关闭问题和矩型元素的显示，在这篇文章中我们将解决消消乐(或者说是连连看)的所有元素显示的问题。

---

一、所有元素显示

1. 元素显示

假设我们的消消乐一共有8*8个元素，那么我们可以使用两层for循环即可显示出所有元素。为了让for循环8次，我们可以使用for i in range(8)。
range()是Python中的一个内置函数，它会返回一个可迭代对象，用于生成指定范围内的整数序列。语法如下：range(start, stop[, step])，其中start表示序列的起始值（默认为0），stop表示序列的终止值（返回的对象中不包括该值），step表示序列的步长（默认为1）。
代码如下：

for i in range(8):
    for j in range(8):
        pygame.draw.rect(screen,(255,255,255),(20+20*j,20+20*i,50,50))
1
2
3

完整代码如下：

import pygame
import sys
import time

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

if __name__ == '__main__':
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH))
    pygame.display.set_caption("happy remove")
    screen.fill((124,114,242))
    for i in range(8):
        for j in range(8):
        	#位置的计算公式为left = 起始left位置+元素宽度*j,top=起始top位置+元素高度*i
            pygame.draw.rect(screen,(255,255,255),(20+50*j,20+50*i,50,50))
    #更新窗口
    pygame.display.update()
    while True:
        #获取鼠标响应
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
        pygame.display.update()
        time.sleep(0.3)
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

这样我们就可以获得8*8的矩阵元素了，效果如下：

2.颜色随机替换

由上面效果图我们看到，所有元素的颜色值都是一样的无法区分每个矩形元素，故而我们可以使用random库对矩形的颜色进行随机替换。由于random库是系统自带的，故而我们直接引入既可。

import random
1

为了获得从0-255的随机颜色值，我们可以使用random.randint()来获得0-255的随机值。
random.randint()方法返回指定范围内的整数。语法如下：random.randint(start, stop),start和stop分别代表开始值和结束值，random会返回包含开始值和结束值范围内的随机整数。
随机颜色矩形元素绘制代码如下：

pygame.draw.rect(screen,(random.randint(0,255),random.randint(0,255),random.randint(0,255)),(20+50*j,20+50*i,50,50))
1

完整代码如下：

import pygame
import sys
import time
import random

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

if __name__ == '__main__':
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH))
    pygame.display.set_caption("happy remove")
    screen.fill((124,114,242))
    for i in range(8):
        for j in range(8):
        	#位置的计算公式为left = 起始left位置+元素宽度*j,top=起始top位置+元素高度*i
            pygame.draw.rect(screen,(random.randint(0,255),random.randint(0,255),random.randint(0,255)),(20+50*j,20+50*i,50,50))
    #更新窗口
    pygame.display.update()
    while True:
        #获取鼠标响应
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
        pygame.display.update()
        time.sleep(0.3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

效果图如下：

二、矩形元素绘制封装成类

在后续的开发过程中，类的封装可以使得主文件中的代码更加清晰明了，结构清晰，调用方便，可以支持中大型开发，故而我们先将单个矩形元素的绘制封装成类，使得其可以更好地被其他模块调用。
因而，我们将矩形元素绘制的类放在单独文件MagicBlock.py中，主文件main.py用于程序的主要入口。文件目录结构如下：

-game #主文件夹
	-main.py #程序运行主入口
	-MagicBlock.py #用于存放矩形元素绘制类
1
2
3

1.单个矩形元素绘制类

类的声明可以使用class关键字，每个类中有__init__()函数进行默认初始化，即当调用类时都会自动运行的函数。
我们已经知道了单个矩形元素的绘制需要窗口对象，起始位置(left,top)，长宽和颜色值，故而我们可以将其作为私有变量，在调用的时候初始化赋给他们。
我们先声明一个Block类。

class Block:
	def __init__(self):
		pass
1
2
3

我们可以看到这样就声明一个类叫Block。

其次，我们在初始化函数中将元素绘制所需的变量进行赋值。

class Block:
	def __init__(self,screen,left,top,width,height,color):
		self.screen = screen
		self.left = left
		self.top = top
		self.color = color
		self.width = width
		self.height = height
1
2
3
4
5
6
7
8

到这里我们就完成了变量的赋值。
在面向对象编程中，我们将世界上的每个具有相同性质和行为的实体抽象为一个类，所以每个类呢都有自身的属性和行为。而我们知道一个矩形元素类还有一个行为那就是绘制到屏幕的行为，故而我们需要定义一个函数来描述这个行为，以便其他的对象可以调用这个行为。

import pygame#使用到了pygame需要提前引入
class Block:
	def __init__(self,screen,left,top,width,height,color):
		self.screen = screen
		self.left = left
		self.top = top
		self.color = color
		self.width = width
		self.height = height
	def draw(self):
		position = self.left,self.top,self.width,self.height
		pygame.draw.rect(self.screen,self.color,position)
1
2
3
4
5
6
7
8
9
10
11
12

这样我们就完成了对单个矩形元素绘制的封装。我们在主文件main.py中导入该类，并调用该类的绘制行为。
导入Block类：

from MagicBlock import Block
1

我们可以将8*8矩形元素绘制成一个矩阵对象的形式进行存储，在python中可以使用列表推导式的语法糖来初始化一个二维矩阵8*8的矩阵[[0]*8 for i in range(8)]。
列表推导式是一种创建列表的简洁方法。
[[0]*8 for i in range(8)]其实就是相当于

x = []
for i in range(8):
	x.append([0]*8)
1
2
3

初始化并调用Block绘制函数：

blocks=[[0]*8 for i in range(8)]
for i in range(8):
        for j in range(8):
            blocks[i][j] = Block(screen,20+50*j,20+50*i,50,50,(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
            blocks[i][j].draw()
1
2
3
4
5

完整代码如下:

-main.py
import pygame
import sys
import time
import random
from MagicBlock import Block

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

if __name__ == '__main__':
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH))
    pygame.display.set_caption("happy remove")
    screen.fill((124,114,242))
        	
	blocks=[[0]*8 for i in range(8)]
	for i in range(8):
        for j in range(8):
        	#位置的计算公式为left = 起始left位置+元素宽度*j,top=起始top位置+元素高度*i
            blocks[i][j] = Block(screen,20+50*j,20+50*i,50,50,(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
            blocks[i][j].draw()
    #更新窗口
    pygame.display.update()
    while True:
        #获取鼠标响应
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
        pygame.display.update()
        time.sleep(0.3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

-MagicBlock.py
import pygame
class Block:
	def __init__(self,screen,left,top,width,height,color):
		self.screen = screen
		self.left = left
		self.top = top
		self.color = color
		self.width = width
		self.height = height
	def draw(self):
		position = self.left,self.top,self.width,self.height
		pygame.draw.rect(self.screen,self.color,position)
1
2
3
4
5
6
7
8
9
10
11
12
13

效果图如下：

---

总结

本篇文章中解决了消消乐中所有元素显示问题和类封装办法，但我们知道消消乐需要通过点击来消除相对应的矩形元素，故而下一章将介绍怎么通过点击事件消除相对应的矩形元素。

---

第四章 点击消除事件

前言

python小游戏开心消消乐制作4-点击消除事件
在上篇文章中我们解决了游戏元素显示问题和封装成类，该篇文章我们将
解决点击消除游戏元素。

---

一、获取鼠标点击事件

1.获取鼠标点击坐标

在python小游戏开心消消乐制作2中我们完成了鼠标点击关闭游戏窗口，而现在我们想要获取鼠标点击事件，我们可以通过对event.type进行判断是否是鼠标按下操作：

if event.type == pygame.MOUSEBUTTONDOWN:
	print("button down")
1
2

通过上面的代码我们就可以判断是否是鼠标按下操作。而为了使得某一个矩形元素进行消除，我们还需要获得鼠标按下时的坐标。在这里我们可以通过event.pos属性来获得鼠标按下时的坐标。
具体代码如下：

for event in pygame.event.get():
	if event.type == pygame.QUIT:
		sys.exit(0)
	elif event.type ==pygame.MOUSEBUTTONDOWN:
		x,y = event.pos
		print(x,y)        
1
2
3
4
5
6

完整代码如下：

-main.py
import pygame
import sys
import time
import random
from MagicBlock import Block

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

if __name__ == '__main__':
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH))
    pygame.display.set_caption("happy remove")
    screen.fill((124,114,242))
        	
	blocks=[[0]*8 for i in range(8)]
	for i in range(8):
        for j in range(8):
        	#位置的计算公式为left = 起始left位置+元素宽度*j,top=起始top位置+元素高度*i
            blocks[i][j] = Block(screen,20+50*j,20+50*i,50,50,(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
            blocks[i][j].draw()
    #更新窗口
    pygame.display.update()
    while True:
        #获取鼠标响应
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type ==pygame.MOUSEBUTTONDOWN:
				x,y = event.pos
				print(x,y) 
        pygame.display.update()
        time.sleep(0.3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

我们尝试在左下角元素处点击可以看出终端输出结果75 303，这个根据不同点击位置不同会得到不同的值。

2.获取点击坐标对应的游戏元素坐标

但是我们会发现我们获得的值只是相对于屏幕的坐标而已，我们需要将这个坐标转换为游戏元素在blocks矩阵中x,y的值。
我们可以看到游戏元素的距离左边窗口位置的计算公式为left = 起始left位置+元素宽度*j，那么我们想要获得j的值，通过恒等变形我们可以得到j=(left-游戏元素起始left位置)/游戏元素宽度，那么我们就可以通过这个等式来获取游戏元素列坐标j的值，同理可以得到行坐标的值i=(top-游戏元素起始top位置)/游戏元素长度。
由于i,j是整数，所以我们可以通过python中//整除符号来整除前面括号中的值。具体代码如下：

for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type ==pygame.MOUSEBUTTONDOWN:
				x,y = event.pos
				i = (x-20)//50 #20为游戏元素起始top位置，50为游戏元素长度 
				j = (y-20)//50#20为游戏元素起始left位置，50为游戏元素宽度 
				print(i,j)
1
2
3
4
5
6
7
8

完整代码如下：

-main.py
import pygame
import sys
import time
import random
from MagicBlock import Block

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

if __name__ == '__main__':
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH))
    pygame.display.set_caption("happy remove")
    screen.fill((124,114,242))
        	
	blocks=[[0]*8 for i in range(8)]
	for i in range(8):
        for j in range(8):
        	#位置的计算公式为left = 起始left位置+元素宽度*j,top=起始top位置+元素高度*i
            blocks[i][j] = Block(screen,20+50*j,20+50*i,50,50,(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
            blocks[i][j].draw()
    #更新窗口
    pygame.display.update()
    while True:
        #获取鼠标响应
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type ==pygame.MOUSEBUTTONDOWN:
				x,y = event.pos
				i = (x-20)//50 #20为游戏元素起始top位置，50为游戏元素长度 
				j = (y-20)//50#20为游戏元素起始left位置，50为游戏元素宽度 
				print(i,j)
        pygame.display.update()
        time.sleep(0.3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

通过运行该代码，在点击任何游戏元素时，我们都可以获得该游戏元素的坐标(i,j)

二、消除点击的游戏元素

1.改变游戏元素的颜色

为了简化游戏的理解，我们直接将点击的游戏元素的颜色进行一个更改。直接将它的颜色改为背景色

blocks[i][j].color = (124,114,242)
blocks[i][j].draw()
1
2

-main.py
import pygame
import sys
import time
import random
from MagicBlock import Block

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

if __name__ == '__main__':
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH))
    pygame.display.set_caption("happy remove")
    screen.fill((124,114,242))
        	
	blocks=[[0]*8 for i in range(8)]
	for i in range(8):
        for j in range(8):
        	#位置的计算公式为left = 起始left位置+元素宽度*j,top=起始top位置+元素高度*i
            blocks[i][j] = Block(screen,20+50*j,20+50*i,50,50,(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
            blocks[i][j].draw()
    #更新窗口
    pygame.display.update()
    while True:
        #获取鼠标响应
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type ==pygame.MOUSEBUTTONDOWN:
				x,y = event.pos
				i = (x-20)//50 #20为游戏元素起始top位置，50为游戏元素长度 
				j = (y-20)//50#20为游戏元素起始left位置，50为游戏元素宽度 
				blocks[i][j].color = (124,114,242)
				blocks[i][j].draw()
        pygame.display.update()
        time.sleep(0.3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

效果图如下：

一个小意外出现了，我们发现点击相对应元素沿对角线对称的元素被消除了，这是什么原因呢？我们可以思考一下，如何解决？留下你们的意见，我们在下篇文章中解决这个问题。（ps:其实我也没想到突然会出现这样的bug给我点时间我思考一下哈哈哈哈哈哈哈哈哈哈哈）

---

总结

在本章中我们实现了元素消除的问题，但是我们在实现中也发现了bug，就是对称元素被消除了而不是我们点击的元素被消除了。下章中我们将解决这个问题，并且用图片替换矩形元素。

---

第五章 美化界面

python小游戏开心消消乐制作5-美化界面

Bug解决

通过一顿的代码分析后，我发现是i和j计算公式对调了，因为x其实代表的才是游戏元素的起始left位置，y代表的才是游戏元素的起始top位置。所以正确代码应该是：

j = (x-20)//50 #20为游戏元素起始top位置，50为游戏元素长度 
i = (y-20)//50#20为游戏元素起始left位置，50为游戏元素宽度
1
2

完整正确代码：

import pygame
import sys
import time
import random
from MagicBlock import Block

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

if __name__ == '__main__':
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH))
    pygame.display.set_caption("happy remove")
    screen.fill((124,114,242))
        	
    blocks=[[0]*8 for i in range(8)]
    for i in range(8):
        for j in range(8):
        	#位置的计算公式为left = 起始left位置+元素宽度*j,top=起始top位置+元素高度*i
            blocks[i][j] = Block(screen,20+50*j,20+50*i,50,50,(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
            blocks[i][j].draw()
    #更新窗口
    pygame.display.update()
    while True:
        #获取鼠标响应
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type ==pygame.MOUSEBUTTONDOWN:
                x,y = event.pos
                j = (x-20)//50 #20为游戏元素起始top位置，50为游戏元素长度 
                i = (y-20)//50#20为游戏元素起始left位置，50为游戏元素宽度 
                blocks[i][j].color = (124,114,242)
                blocks[i][j].draw()
        pygame.display.update()
        time.sleep(0.3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

---

前言

在上篇文章中，我们实现了点击消除游戏元素事件，由于矩形元素有点太丑陋了，所以我们将矩形元素替换成图像元素会好看点(说白了这章就是美化用的哈哈哈哈哈哈)

---

一、美化游戏元素

1. 图像元素绘制

在pygame中我们可以使用screen.blit(source,dest)函数来绘制图像。
其中参数source是某矩形图像(Surface实例)，将被绘制到另一矩形图像screen(Surface实例)上由参数dest指定位置。参数dest是矩形图像source左上角在screen上的坐标。
为了获得Surface实例，我们可以通过pygame.image.load(图片路径)加载图片，获取Surface实例。在这里我找了五张和消消乐相关的图片作为游戏元素，想要的可以私聊我找我要。

我们在原有的代码基础上添加如下代码进行测试：

screen.blit(pygame.image.load('./image/01_hightlight.png'),(20,450))
1

完整代码如下：

import pygame
import sys
import time
import random
from MagicBlock import Block

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

if __name__ == '__main__':
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH))
    pygame.display.set_caption("happy remove")
    screen.fill((124,114,242))
        	
    blocks=[[0]*8 for i in range(8)]
    for i in range(8):
        for j in range(8):
        	#位置的计算公式为left = 起始left位置+元素宽度*j,top=起始top位置+元素高度*i
            blocks[i][j] = Block(screen,20+50*j,20+50*i,50,50,(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
            blocks[i][j].draw()
    screen.blit(pygame.image.load('./image/01_hightlight.png'),(20,450))

    #更新窗口
    pygame.display.update()
    while True:
        #获取鼠标响应
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type ==pygame.MOUSEBUTTONDOWN:
                x,y = event.pos
                j = (x-20)//50 #20为游戏元素起始top位置，50为游戏元素长度 
                i = (y-20)//50#20为游戏元素起始left位置，50为游戏元素宽度 
                blocks[i][j].color = (124,114,242)
                blocks[i][j].draw()
        pygame.display.update()
        time.sleep(0.3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

效果图如下：

我们可以看到在全部元素下方显示了小熊的图像。

2. 矩形元素替换为图像元素

我们想要Block类既能绘制矩形元素，又能绘制图像元素，我们可以给Block类添加type属性，在绘制中判断该Block实例是矩形元素还是图像元素。
由于不同的元素，所需要的属性是不同的（比如矩形元素需要颜色信息，图像元素需要图像），所以我们可以通过将image和color设置默认为None，在需要的时候进行赋值即可。
代码如下：

-MagicBlock.py
import pygame
class Block:
	def __init__(self,screen,left,top,width,height,type,image=None,color=None):
		self.screen = screen
		self.left = left
		self.top = top
		self.type = type
		self.image = image
		self.color = color
		self.width = width
		self.height = height
	def draw(self):
		position = self.left,self.top,self.width,self.height
		pygame.draw.rect(self.screen,self.color,position)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

上述代码仅只是将属性进行添加，类的行为也要改变，我们可以通过if判断类型来实现不同元素的绘制。同时我们可以给Block设置全局变量来判断是那种类型，具体代码如下：

-MagicBlock.py
import pygame

TYPE_RECT = 0
TYPE_IMAGE = 1

class Block:
	def __init__(self,screen,left,top,width,height,type,image=None,color=None):
		self.screen = screen
		self.left = left
		self.top = top
		self.type = type
		self.image = image
		self.color = color
		self.width = width
		self.height = height
		
	def draw(self):
		if self.type == TYPE_RECT:
			position = self.left,self.top,self.width,self.height
			pygame.draw.rect(self.screen,self.color,position)
		elif self.type == TYPE_IMAGE:
			self.screen.blit(self.image,(self.left,self.top))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

同时我们也要更改主入口文件中调用类的接口，由于我们的image文件名呢是根据0i{1-5}_hightlight.png来命名，所以我们可以通过random.randint(1,5)来动态变更每个位置的图像。更改代码如下：

import MagicBlock
Block(screen,20+50*j,20+50*i,50,50,MagicBlock.TYPE_IMAGE,image=pygame.image.load('./image/0'+str(random.randint(1,5))+"_hightlight.png"))
1
2

完整代码如下：

-main.py
import pygame
import sys
import time
import random
from MagicBlock import Block
import MagicBlock

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

if __name__ == '__main__':
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH))
    pygame.display.set_caption("happy remove")
    screen.fill((124,114,242))
        	
    blocks=[[0]*8 for i in range(8)]
    for i in range(8):
        for j in range(8):
        	#位置的计算公式为left = 起始left位置+元素宽度*j,top=起始top位置+元素高度*i
            blocks[i][j] = Block(screen,20+50*j,20+50*i,50,50,MagicBlock.TYPE_IMAGE,image=pygame.image.load('./image/0'+str(random.randint(1,5))+"_hightlight.png"))
            blocks[i][j].draw()
    #更新窗口
    pygame.display.update()
    while True:
        #获取鼠标响应
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type ==pygame.MOUSEBUTTONDOWN:
                x,y = event.pos
                j = (x-20)//50 #20为游戏元素起始top位置，50为游戏元素长度 
                i = (y-20)//50#20为游戏元素起始left位置，50为游戏元素宽度 
                blocks[i][j].color = (124,114,242)
                blocks[i][j].draw()
        pygame.display.update()
        time.sleep(0.3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

效果图如下：

总结

本篇文章美化了游戏元素，但是深入分析我们发现点击消除事件失效，以及对于每一个元素消除都需要在主函数中独立操作，且我们看到随着后续内容的增加，main.py会越来越臃肿，我们想着能否再用一个类来将矩阵游戏元素作为整体来操作，我们只需要在主函数中操作该类需要执行的动作即可，这样不仅架构清晰，而且操作方便，也就不需要再主函数中不断修改了。

---

第六章 类封装

前言

python小游戏开心消消乐制作6-类封装
python小游戏开心消消乐制作5中我们美化了游戏界面，同时我们提出了将游戏元素矩阵封装成单个类的必要性，所以在这一章中我们围绕这一目标来实现。

---

一、创建游戏元素矩阵类

我们将类的实现放在MagicBlock.py中，我们将该元素矩阵类命名为MagicBlock。

class MagicBlock:
	def __init__(self):
		pass
1
2
3

接着呢我们分析一下我们需要这个类做什么呢？
1、绘制矩阵游戏元素
2、点击消除特定游戏元素
那么我们围绕这两个点来设计MagicBlock类

1.绘制矩阵游戏元素

我们从属性和行为两个方面分别来看如何实现这一目标。
在上篇文章中我们知道绘制矩阵游戏元素的代码如下：

for i in range(8):
        for j in range(8):
        	#位置的计算公式为left = 起始left位置+元素宽度*j,top=起始top位置+元素高度*i
            blocks[i][j] = Block(screen,20+50*j,20+50*i,50,50,MagicBlock.TYPE_IMAGE,image=pygame.image.load('./image/0'+str(random.randint(1,5))+"_hightlight.png"))
1
2
3
4

从属性角度来看，为了绘制矩阵游戏元素，我们需要使用screen这一游戏窗口画布。
紧接着呢需要获得元素开始的位置，即start_left,start_top。
还有就是每个元素的长宽block_height,block_width。
同时绘制矩阵我们也需要指定是多少行，多少列row,col。
同时我们还需要知道这个矩阵游戏元素是图片类型还是矩形元素type。
根据以上特点我们可以在类的初始化函数中将这些属性进行赋值。

class GameBlock:
	def __init__(self,screen,start_left,start_top,block_height,block_width,row,col,type):
		self.row = row
		self.col = col
		self.screen = screen
		self.start_left = start_left
		self.start_top = start_top
		self.block_width = block_width
		self.block_height = block_height
		self.type = type
1
2
3
4
5
6
7
8
9
10

从行为上看我们只需要实现绘制矩阵元素这一项工作即可，由于我们已经将绘制所需属性已经初始化，那么我们根据上述属性设置绘制函数即可。在这里我们也需要调用Block类进行绘制，所以我们可以看到类调用关系是这样的GameBlock->Block
在绘制过程中，我们也需要根据type的类别去判定需要绘制图像元素还是矩形元素。

-MagicBlock.py
class GameBlock:
	def __init__(self,screen,start_left,start_top,block_height,block_width,row,col,type):
		self.row = row
		self.col = col
		self.screen = screen
		self.start_left = start_left
		self.start_top = start_top
		self.block_width = block_width
		self.block_height = block_height
		self.type = type
	def initMagicBlock(self):
		for i in range(0,self.row,1):
			for j in range(0,self.col,1):
				if self.type == TYPE_IMAGE:
					block = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,image=pygame.image.load('./image/0'+str(random.randint(1,5))+"_hightlight.png"))
					block.draw()
				elif self.type == TYPE_RECT:
					block = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,color=(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
					block.draw()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这样主函数想要绘制矩阵元素时，只需要调用该函数即可。

-main.py
import pygame
import sys
import time
import random
from MagicBlock import Block,GameBlock
import MagicBlock

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

if __name__ == '__main__':
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH))
    pygame.display.set_caption("happy remove")
    screen.fill((124,114,242))
        	
    gameblock = GameBlock(screen,start_left=20,start_top=20,block_height=50,block_width=50,row=8,col=8,type=MagicBlock.TYPE_IMAGE)
    gameblock.initMagicBlock()
    #更新窗口
    pygame.display.update()
    while True:
        
        #获取鼠标响应
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type ==pygame.MOUSEBUTTONDOWN:
                x,y = event.pos
                j = (x-20)//50 #20为游戏元素起始top位置，50为游戏元素长度 
                i = (y-20)//50#20为游戏元素起始left位置，50为游戏元素宽度 
        pygame.display.update()
        time.sleep(0.3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

效果图：

2.点击消除特定游戏元素

从属性角度看，为了消除特定的游戏元素，那么我们在绘制的过程中就应该要将游戏元素进行初始化保存。
在python小游戏开心消消乐制作3中，我们知道了保存Block元素，可以通过二维矩阵的形式来保存，即

blocks=[[0]*8 for i in range(8)]
1

那么我们可以为类设置一个私有变量blocks用于存储每个游戏元素。并且在绘制游戏元素时存储该游戏元素矩阵。

class GameBlock:
	def __init__(self,screen,start_left,start_top,block_height,block_width,row,col,type):
		self.row = row
		self.col = col
		self.screen = screen
		self.start_left = start_left
		self.start_top = start_top
		self.block_width = block_width
		self.block_height = block_height
		self.type = type
		self.blocks=[[0]*self.col for i in range(self.row)]
	def initMagicBlock(self):
		for i in range(0,self.row,1):
			for j in range(0,self.col,1):
				if self.type == TYPE_IMAGE:
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,image=pygame.image.load('./image/0'+str(random.randint(1,5))+"_hightlight.png"))
					self.blocks[i][j].draw()
				elif self.type == TYPE_RECT:
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,color=(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
					self.blocks[i][j].draw()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

从行为角度看，点击消除游戏元素，首先需要获得所点击的元素在blocks中的坐标，在python小游戏开心消消乐制作4中我们通过获得了鼠标点击的left,top(x,y)坐标，并且我们根据公式j=(left-游戏元素起始left位置)//游戏元素宽度和i=(top-游戏元素起始top位置)//游戏元素长度(//代表整除)，获得所点击元素在blocks中的坐标blocks[i][j]。
获得了具体的游戏元素之后，我们希望点击之后可以使得该游戏元素消失，也就是不再显示该游戏元素，在这里我们将游戏元素直接变为白色矩形元素，代表该游戏元素消失。故而我们可以在GameBlock中定义一个新函数mouseClick用于消除元素。

def mouseClick(self,x,y):
		i = (y-self.start_top)//self.block_height
		j = (x-self.start_left)//self.block_width
		self.blocks[i][j].type = TYPE_RECT
		self.blocks[i][j].color = (255,255,255)
		self.initMagicBlock()#进行重渲染
1
2
3
4
5
6

完整代码如下：

-MagicBlock.py
import pygame
import random

TYPE_RECT = 0
TYPE_IMAGE = 1

class Block:
	
	def __init__(self,screen,left,top,width,height,type,image=None,color=None):
		self.screen = screen
		self.left = left
		self.top = top
		self.type = type
		self.image = image
		self.color = color
		self.width = width
		self.height = height
		
	def draw(self):
		
		if self.type == TYPE_RECT:
			position = self.left,self.top,self.width,self.height
			pygame.draw.rect(self.screen,self.color,position)
		elif self.type == TYPE_IMAGE:
			self.screen.blit(self.image,(self.left,self.top))

class GameBlock:
	def __init__(self,screen,start_left,start_top,block_height,block_width,row,col,type):
		self.row = row
		self.col = col
		self.screen = screen
		self.start_left = start_left
		self.start_top = start_top
		self.block_width = block_width
		self.block_height = block_height
		self.type = type
		self.blocks=[[0]*self.col for i in range(self.row)]
	def initMagicBlock(self):
		for i in range(0,self.row,1):
			for j in range(0,self.col,1):
				if self.type == TYPE_IMAGE:
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,image=pygame.image.load('./image/0'+str(random.randint(1,5))+"_hightlight.png"))
					self.blocks[i][j].draw()
				elif self.type == TYPE_RECT:
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,color=(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
					self.blocks[i][j].draw()
	def mouseClick(self,x,y):
		i = (y-self.start_top)//self.block_height
		j = (x-self.start_left)//self.block_width
		self.blocks[i][j].type = TYPE_RECT
		self.blocks[i][j].color = (255,255,255)
		self.blocks[i][j].draw()#进行重渲染
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

我们在主函数中调用该函数：

-main.py
import pygame
import sys
import time
import random
from MagicBlock import Block,GameBlock
import MagicBlock

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

if __name__ == '__main__':
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_HEIGHT,SCREEN_WIDTH))
    pygame.display.set_caption("happy remove")
    screen.fill((124,114,242))
        	
    gameblock = GameBlock(screen,start_left=20,start_top=20,block_height=50,block_width=50,row=8,col=8,type=MagicBlock.TYPE_IMAGE)
    gameblock.initMagicBlock()
    #更新窗口
    pygame.display.update()
    while True:
        
        #获取鼠标响应
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type ==pygame.MOUSEBUTTONDOWN:
                x,y = event.pos
                gameblock.mouseClick(x,y)
        pygame.display.update()
        time.sleep(0.3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

效果图如下：

到这里我们就实现了点击元素消除的封装啦~~

---

总结

在本章中我们已经完成了对整体游戏元素的类封装，接着我们将实现游戏具体玩法，在消消乐中，我们需要对两个具有相同游戏元素且有连接路径的游戏元素进行消除，在下章中，我们将实现对相同游戏元素的游戏元素消除。

---

第七章 相同游戏元素消除

前言

python小游戏开心消消乐制作7-相同游戏元素消除
在上一章中我们实现了对游戏总体元素的封装和单个元素的消除，完成游戏的运行逻辑，需要实现游戏对两个具有相同游戏元素且有连接路径的游戏元素进行消除，在本章中，我们先对具有相同游戏元素的游戏元素进行消除

---

一、同游戏元素消除

1.存储游戏元素类别

为了消除同游戏元素，我们需要对每个游戏元素的类别进行存储。

1.1定义类别矩阵

我们也可以用和游戏元素相同的矩阵来存储游戏类别，在这里我们可以使用numpy库，numpy是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure）结构要高效的多（该结构也可以用来表示矩阵（matrix）），支持大量的维度数组与矩阵运算。
我们需要先安装numpy库。pip install numpy
在numpy中我们可以使用numpy.zeros(size[,dtype])来初始化一个大小为size的零矩阵，dtype可以定义该矩阵存储的数据类型。
因此，我们可以在GameBlock类中的__init__函数中初始化一个大小为row*col大小的类别矩阵。

self.blocks_type = np.zeros((self.row,self.col),dtype=np.int8)
1

-MagicBlock.py
import numpy as np
class GameBlock:
	def __init__(self,screen,start_left,start_top,block_height,block_width,row,col,type):
		self.row = row
		self.col = col
		self.screen = screen
		self.start_left = start_left
		self.start_top = start_top
		self.block_width = block_width
		self.block_height = block_height
		self.type = type
		self.blocks=[[0]*self.col for i in range(self.row)]
		self.blocks_type = np.zeros((self.row,self.col),dtype=np.int8)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

1.2 初始化类别矩阵

blocks的初始化是在initMagicBlock函数中，因此我们可以在initMagicBlock函数中对blocks_type进行初始化，self.blocks_type[i][j] = random.randint(1,5)，具体代码如下：

-MagicBlock.py
class GameBlock:
	def __init__(self,screen,start_left,start_top,block_height,block_width,row,col,type):
		self.row = row
		self.col = col
		self.screen = screen
		self.start_left = start_left
		self.start_top = start_top
		self.block_width = block_width
		self.block_height = block_height
		self.type = type
		self.blocks=[[0]*self.col for i in range(self.row)]
		self.blocks_type = np.zeros((self.row,self.col),dtype=np.int8)
	def initMagicBlock(self):
		for i in range(0,self.row,1):
			for j in range(0,self.col,1):
				if self.type == TYPE_IMAGE:
					self.blocks_type[i][j] = random.randint(1,5)
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,image=pygame.image.load('./image/0'+str(self.blocks_type[i][j])+"_hightlight.png"))
					self.blocks[i][j].draw()
				elif self.type == TYPE_RECT:
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,color=(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
					self.blocks[i][j].draw()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1.3同类别消除

消除同类别元素，需要点击两次，因此我们可以维护一个点击次数属性click_num，只有当click_num是偶数时才需要进行消除。我们还需要保存两次点击元素的游戏坐标i,j，进行判断是否为同一类型元素并消除，因此我们可以维护一个坐标列表属性click_list。

		self.click_num = 0
		self.click_list = list()
1
2

在每次点击事件时我们需要判别点击的位置是否超过元素范围和元素是否已消除，超过元素范围或已消除就不计点击次数，若未超过和未消除则计点击次数并且存储坐标信息。我们可以在mouseClick函数中实现。

	def mouseClick(self,x,y):
		i = (y-self.start_top)//self.block_height
		j = (x-self.start_left)//self.block_width
		if i<0 or i>self.row-1 or j<0 or j >self.col-1 or self.blocks[i][j] == 0:
			return False
		self.click_num += 1
		self.click_list.append([i,j])
1
2
3
4
5
6
7

接着呢我们可以进行同类型元素消除操作，若类型相同则消除，并将click_list属性清空，不同也需要将click_list清空。

	def mouseClick(self,x,y):
		i = (y-self.start_top)//self.block_height
		j = (x-self.start_left)//self.block_width
		if i<0 or i>self.row-1 or j<0 or j >self.col-1 or self.blocks_type[i][j] == 0:
			return False
		self.click_num += 1
		self.click_list.append([i,j])
		if self.click_num % 2 == 0:

			if self.blocks_type[self.click_list[0][0]][self.click_list[0][1]] == self.blocks_type[self.click_list[1][0]][self.click_list[1][1]]:
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].type = TYPE_RECT
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].color = (255,255,255)
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].draw()#进行重渲染
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].type = TYPE_RECT
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].color = (255,255,255)
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].draw()#进行重渲染
			self.click_list = list()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

完整代码如下：

-MagicBlock.py
import pygame
import random
import numpy as np
TYPE_RECT = 0
TYPE_IMAGE = 1

class Block:
	
	def __init__(self,screen,left,top,width,height,type,image=None,color=None):
		self.screen = screen
		self.left = left
		self.top = top
		self.type = type
		self.image = image
		self.color = color
		self.width = width
		self.height = height
		
	def draw(self):
		
		if self.type == TYPE_RECT:
			position = self.left,self.top,self.width,self.height
			pygame.draw.rect(self.screen,self.color,position)
		elif self.type == TYPE_IMAGE:
			self.screen.blit(self.image,(self.left,self.top))

class GameBlock:
	def __init__(self,screen,start_left,start_top,block_height,block_width,row,col,type):
		self.row = row
		self.col = col
		self.screen = screen
		self.start_left = start_left
		self.start_top = start_top
		self.block_width = block_width
		self.block_height = block_height
		self.type = type
		self.blocks=[[0]*self.col for i in range(self.row)]
		self.blocks_type = np.zeros((self.row,self.col),dtype=np.int8)
		self.click_num = 0
		self.click_list = list()
	def initMagicBlock(self):
		for i in range(0,self.row,1):
			for j in range(0,self.col,1):
				if self.type == TYPE_IMAGE:
					self.blocks_type[i][j] = random.randint(1,5)
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,image=pygame.image.load('./image/0'+str(self.blocks_type[i][j])+"_hightlight.png"))
					self.blocks[i][j].draw()
				elif self.type == TYPE_RECT:
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,color=(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
					self.blocks[i][j].draw()
	def mouseClick(self,x,y):
		i = (y-self.start_top)//self.block_height
		j = (x-self.start_left)//self.block_width
		if i<0 or i>self.row-1 or j<0 or j >self.col-1 or self.blocks_type[i][j] == 0:
			return False
		self.click_num += 1
		self.click_list.append([i,j])
		if self.click_num % 2 == 0:

			if self.blocks_type[self.click_list[0][0]][self.click_list[0][1]] == self.blocks_type[self.click_list[1][0]][self.click_list[1][1]]:
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].type = TYPE_RECT
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].color = (255,255,255)
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].draw()#进行重渲染
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].type = TYPE_RECT
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].color = (255,255,255)
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].draw()#进行重渲染
			self.click_list = list()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

效果图如下：

---

总结

至此我们就完成了同类型元素的消除，但是我们会发现，有一个问题就是两次点击同一个游戏元素会造成单个元素的消除，这不符合我们游戏的逻辑，我们将在下一章节解决该问题，大家也可以思考一下如何解决哟。

---

第八章 残留Bug

python小游戏开心消消乐制作8-bug解决

问题描述

在上一章的同游戏元素消除实现过程中，我们发现两次点击同一个游戏元素会造成单个元素的消除，而我们是想在两次点击同一元素时，只保存第一次点击的坐标且只算一次点击。

-MagicBlock.py
import pygame
import random
import numpy as np
TYPE_RECT = 0
TYPE_IMAGE = 1

class Block:
	
	def __init__(self,screen,left,top,width,height,type,image=None,color=None):
		self.screen = screen
		self.left = left
		self.top = top
		self.type = type
		self.image = image
		self.color = color
		self.width = width
		self.height = height
		
	def draw(self):
		
		if self.type == TYPE_RECT:
			position = self.left,self.top,self.width,self.height
			pygame.draw.rect(self.screen,self.color,position)
		elif self.type == TYPE_IMAGE:
			self.screen.blit(self.image,(self.left,self.top))

class GameBlock:
	def __init__(self,screen,start_left,start_top,block_height,block_width,row,col,type):
		self.row = row
		self.col = col
		self.screen = screen
		self.start_left = start_left
		self.start_top = start_top
		self.block_width = block_width
		self.block_height = block_height
		self.type = type
		self.blocks=[[0]*self.col for i in range(self.row)]
		self.blocks_type = np.zeros((self.row,self.col),dtype=np.int8)
		self.click_num = 0
		self.click_list = list()
	def initMagicBlock(self):
		for i in range(0,self.row,1):
			for j in range(0,self.col,1):
				if self.type == TYPE_IMAGE:
					self.blocks_type[i][j] = random.randint(1,5)
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,image=pygame.image.load('./image/0'+str(self.blocks_type[i][j])+"_hightlight.png"))
					self.blocks[i][j].draw()
				elif self.type == TYPE_RECT:
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,color=(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
					self.blocks[i][j].draw()
	def mouseClick(self,x,y):
		i = (y-self.start_top)//self.block_height
		j = (x-self.start_left)//self.block_width
		if i<0 or i>self.row-1 or j<0 or j >self.col-1 or self.blocks_type[i][j] == 0:
			return False
		self.click_num += 1
		self.click_list.append([i,j])
		if self.click_num % 2 == 0:

			if self.blocks_type[self.click_list[0][0]][self.click_list[0][1]] == self.blocks_type[self.click_list[1][0]][self.click_list[1][1]]:
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].type = TYPE_RECT
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].color = (255,255,255)
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].draw()#进行重渲染
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].type = TYPE_RECT
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].color = (255,255,255)
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].draw()#进行重渲染
			self.click_list = list()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

---

原因分析：

从上面的代码我们可以看到，不管是点击的是什么游戏元素我们都会进行计数和保存坐标。

---

解决方案：

我们可以在进行偶数计数前，进行判断该游戏元素是否为同一位置的元素，若为同一位置的元素，则不进行计数和保存坐标。
具体代码如下：

if self.click_num %2 == 1 and self.click_list[0][0] == i and self.click_list[0][1] == j:
			return False
1
2

完整代码如下：

-MagicBlock.py
import pygame
import random
import numpy as np
TYPE_RECT = 0
TYPE_IMAGE = 1

class Block:
	
	def __init__(self,screen,left,top,width,height,type,image=None,color=None):
		self.screen = screen
		self.left = left
		self.top = top
		self.type = type
		self.image = image
		self.color = color
		self.width = width
		self.height = height
		
	def draw(self):
		
		if self.type == TYPE_RECT:
			position = self.left,self.top,self.width,self.height
			pygame.draw.rect(self.screen,self.color,position)
		elif self.type == TYPE_IMAGE:
			self.screen.blit(self.image,(self.left,self.top))

class GameBlock:
	def __init__(self,screen,start_left,start_top,block_height,block_width,row,col,type):
		self.row = row
		self.col = col
		self.screen = screen
		self.start_left = start_left
		self.start_top = start_top
		self.block_width = block_width
		self.block_height = block_height
		self.type = type
		self.blocks=[[0]*self.col for i in range(self.row)]
		self.blocks_type = np.zeros((self.row,self.col),dtype=np.int8)
		self.click_num = 0
		self.click_list = list()
	def initMagicBlock(self):
		for i in range(0,self.row,1):
			for j in range(0,self.col,1):
				if self.type == TYPE_IMAGE:
					self.blocks_type[i][j] = random.randint(1,5)
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,image=pygame.image.load('./image/0'+str(self.blocks_type[i][j])+"_hightlight.png"))
					self.blocks[i][j].draw()
				elif self.type == TYPE_RECT:
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,color=(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
					self.blocks[i][j].draw()
	def mouseClick(self,x,y):
		i = (y-self.start_top)//self.block_height
		j = (x-self.start_left)//self.block_width
		if i<0 or i>self.row-1 or j<0 or j >self.col-1 or self.blocks_type[i][j] == 0:
			return False
		if self.click_num %2 == 1 and self.click_list[0][0] == i and self.click_list[0][1] == j:
			return False

		self.click_num += 1
		self.click_list.append([i,j])
		if self.click_num % 2 == 0:

			if self.blocks_type[self.click_list[0][0]][self.click_list[0][1]] == self.blocks_type[self.click_list[1][0]][self.click_list[1][1]]:
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].type = TYPE_RECT
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].color = (255,255,255)
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].draw()#进行重渲染
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].type = TYPE_RECT
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].color = (255,255,255)
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].draw()#进行重渲染
			self.click_list = list()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

效果图：

---

第九章 连接路径和广度优先搜索

前言

python小游戏开心消消乐制作9-连接路径和广度优先搜索
在游戏逻辑实现中，我们已经实现了同类型元素消除，接着我们将实现具有连接路径元素消除。

---

一、连接路径

1.连接路径说明

连接路径有以下几种情况：
1、元素上下左右相邻的元素都代表拥有连接路径
2、在两个元素之间拥有一条无游戏元素的路径也代表其拥有连接路径

2.实现方法

为了实现连接路径的搜索，对于第一种情况，我们可以将每个元素位置都看作是一个状态，每个状态都拥有上下左右的扩展状态，即通过该状态可以获得其上下左右的状态。
对于第二种情况，我们可以只扩展已消除元素位置状态。
判断是否拥有连接路径，我们可以在每次扩展状态时进行判断扩展的状态是否是我们所需要的状态。
那么我们可以通过深度优先、广度优先的方式来搜索连接路径。

二、广度优先搜索算法

广度优先搜索（Breadth-First Search, BFS）是一种用于遍历或搜索树、图等数据结构的算法。这个算法从起始节点开始，首先访问起始节点，然后逐层访问该节点的邻居节点，直到访问完当前层的所有节点，再按照层次顺序逐层访问下一层的节点。其主要特点是先访问离起始节点最近的节点，然后逐渐向外扩展。
BFS的核心思想是通过队列来实现层次遍历，其主要步骤如下：
1、将起始节点加入队列。
2、从队列中取出一个节点，访问该节点。
3、将该节点的所有未访问过的邻居节点加入队列。
4、标记该节点为已访问。
重复步骤2至4，直到队列为空或找到目标节点。
要想实现广度优先搜索算法，我们需要维护一个存储待访问的节点队列 queue和一个已访问的节点集合 visited。
其中待访问的节点队列用于扩展状态，已访问的节点集合用于避免重复扩展状态。
队列我们可以使用deque，初始化deque可以使用queue = deque([节点])对队列进行初始化，获取队列的节点，我们可以使用queue.popleft()，该函数可以获得队列左边节点。
集合我们可以使用visited = set()函数进行初始化空集合，将元素加入集合可以使用visited.add(元素)将元素加入集合中，我们可以直接使用if 元素 in visited来判断元素是否在集合中。
具体代码如下：

from collections import deque
 
def bfs(graph, root):
    visited = set()  # 使用集合存储已访问的节点
    queue = deque([root])  # 初始化队列，将根节点加入
    
    while queue:
        node = queue.popleft()  # 从队列左侧弹出节点
        if node not in visited:
            visited.add(node)  # 标记为已访问
            for neighbor in graph[node]:  # 访问所有邻居节点
                if neighbor not in visited:
                    queue.append(neighbor)  # 将未访问的邻居加入队列
    return visited
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

总结

在本章中我们介绍了连接路径和广度优先搜索算法，在下一章中我们将介绍如何在游戏中应用广度优先搜索算法来找到连接路径，进行元素消除。

---

第十章 搜索两个元素之间的连接路径

前言

python小游戏开心消消乐制作10完结篇-搜索两个元素之间的连接路径
在上一章中，介绍了在消消乐中连接路径如何判定，什么是广度优先搜索算法，它的作用。在本章中我们将会将使用广度优先搜索算法来搜索两个元素之间的连接路径。

一、扩展节点

由上一章我们可以看到每个元素可以扩展的节点是与其相邻的上下左右的节点。
同时我们也可以看到在边缘的元素节点扩展的节点是有限的。
1、中间节点的扩展节点有四个节点，分别为上下左右
2、四个角节点的扩展节点只有两个节点
3、边节点的扩展节点有三个节点
我们可以在GameBlock类中单独定义一个扩展节点函数expandNode。

	def expandNode(self,node):
		neighbors = []
		if node[1] < self.blocks_type.shape[1]-1:#节点上方还有节点则可以扩展上方节点
			neighbors.append((node[0],node[1]+1))
		if node[1] > 0:#节点下方还有节点则可以扩展下方节点
			neighbors.append((node[0],node[1]-1))
		if node[0] < self.blocks_type.shape[0]-1: #节点右方还有节点则可以扩展右方节点
			neighbors.append((node[0]+1,node[1])) 
		if node[0] > 0:#节点左方还有节点则可以扩展左方节点
			neighbors.append((node[0]-1,node[1]))
		return neighbors
1
2
3
4
5
6
7
8
9
10
11

完整代码：

-MagicBlock.py
import pygame
import random
import numpy as np
TYPE_RECT = 0
TYPE_IMAGE = 1

class Block:
	
	def __init__(self,screen,left,top,width,height,type,image=None,color=None):
		self.screen = screen
		self.left = left
		self.top = top
		self.type = type
		self.image = image
		self.color = color
		self.width = width
		self.height = height
		
	def draw(self):
		
		if self.type == TYPE_RECT:
			position = self.left,self.top,self.width,self.height
			pygame.draw.rect(self.screen,self.color,position)
		elif self.type == TYPE_IMAGE:
			self.screen.blit(self.image,(self.left,self.top))

class GameBlock:
	def __init__(self,screen,start_left,start_top,block_height,block_width,row,col,type):
		self.row = row
		self.col = col
		self.screen = screen
		self.start_left = start_left
		self.start_top = start_top
		self.block_width = block_width
		self.block_height = block_height
		self.type = type
		self.blocks=[[0]*self.col for i in range(self.row)]
		self.blocks_type = np.zeros((self.row,self.col),dtype=np.int8)
		self.click_num = 0
		self.click_list = list()
	def initMagicBlock(self):
		for i in range(0,self.row,1):
			for j in range(0,self.col,1):
				if self.type == TYPE_IMAGE:
					self.blocks_type[i][j] = random.randint(1,5)
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,image=pygame.image.load('./image/0'+str(self.blocks_type[i][j])+"_hightlight.png"))
					self.blocks[i][j].draw()
				elif self.type == TYPE_RECT:
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,color=(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
					self.blocks[i][j].draw()
	def mouseClick(self,x,y):
		i = (y-self.start_top)//self.block_height
		j = (x-self.start_left)//self.block_width
		if i<0 or i>self.row-1 or j<0 or j >self.col-1 or self.blocks_type[i][j] == 0:
			return False
		if self.click_num %2 == 1 and self.click_list[0][0] == i and self.click_list[0][1] == j:
			return False

		self.click_num += 1
		self.click_list.append([i,j])
		if self.click_num % 2 == 0:

			if self.blocks_type[self.click_list[0][0]][self.click_list[0][1]] == self.blocks_type[self.click_list[1][0]][self.click_list[1][1]]:
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].type = TYPE_RECT
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].color = (255,255,255)
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].draw()#进行重渲染
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].type = TYPE_RECT
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].color = (255,255,255)
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].draw()#进行重渲染
			self.click_list = list()
	
	def expandNode(self,node):
		neighbors = []
		if node[1] < self.blocks_type.shape[1]-1:#节点上方还有节点则可以扩展上方节点
			neighbors.append((node[0],node[1]+1))
		if node[1] > 0:#节点下方还有节点则可以扩展下方节点
			neighbors.append((node[0],node[1]-1))
		if node[0] < self.blocks_type.shape[0]-1: #节点右方还有节点则可以扩展右方节点
			neighbors.append((node[0]+1,node[1])) 
		if node[0] > 0:#节点左方还有节点则可以扩展左方节点
			neighbors.append((node[0]-1,node[1]))
		return neighbors
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

我们已经可以扩展节点了，接着我们判断是否有连接路径。

二、搜索路径

在上一章的广度优先搜索算法的基础上，我们需要在在访问邻近节点时，将其换成扩展节点。并且需要判断扩展的节点是否为目标节点，将未访问过的节点且可以扩展的节点加入待扩展队列中。

	def breadth_first_search(self,startnode,destinationnode):
		visited = set()#访问过的节点集合
		queue =  deque([tuple(startnode)]) #队列，存储待访问的节点

		while queue:
			node = queue.popleft() #从队列左侧弹出一个节点
			if node not in visited:
                
				visited.add(node)
				for neighbor in self.expandNode(node):
					if tuple(neighbor) == tuple(destinationnode):
						return True 
					if tuple(neighbor) not in visited and self.blocks_type[neighbor[0]][neighbor[1]] == 0:
						queue.append(tuple(neighbor))  # 将未访问的邻居加入队列
		return False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

完整代码：

-MagicBlock.py
import pygame
import random
import numpy as np
from collections import deque
TYPE_RECT = 0
TYPE_IMAGE = 1

class Block:
	
	def __init__(self,screen,left,top,width,height,type,image=None,color=None):
		self.screen = screen
		self.left = left
		self.top = top
		self.type = type
		self.image = image
		self.color = color
		self.width = width
		self.height = height
		
	def draw(self):
		
		if self.type == TYPE_RECT:
			position = self.left,self.top,self.width,self.height
			pygame.draw.rect(self.screen,self.color,position)
		elif self.type == TYPE_IMAGE:
			self.screen.blit(self.image,(self.left,self.top))

class GameBlock:
	def __init__(self,screen,start_left,start_top,block_height,block_width,row,col,type):
		self.row = row
		self.col = col
		self.screen = screen
		self.start_left = start_left
		self.start_top = start_top
		self.block_width = block_width
		self.block_height = block_height
		self.type = type
		self.blocks=[[0]*self.col for i in range(self.row)]
		self.blocks_type = np.zeros((self.row,self.col),dtype=np.int8)
		self.click_num = 0
		self.click_list = list()
	def initMagicBlock(self):
		for i in range(0,self.row,1):
			for j in range(0,self.col,1):
				if self.type == TYPE_IMAGE:
					self.blocks_type[i][j] = random.randint(1,5)
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,image=pygame.image.load('./image/0'+str(self.blocks_type[i][j])+"_hightlight.png"))
					self.blocks[i][j].draw()
				elif self.type == TYPE_RECT:
					self.blocks[i][j] = Block(self.screen,self.start_left+self.block_width*j,self.start_top+self.block_height*i,self.block_width,self.block_height,self.type,color=(random.randint(0,255),random.randint(0,255),random.randint(0,255)))
					self.blocks[i][j].draw()
	def mouseClick(self,x,y):
		i = (y-self.start_top)//self.block_height
		j = (x-self.start_left)//self.block_width
		if i<0 or i>self.row-1 or j<0 or j >self.col-1 or self.blocks_type[i][j] == 0:
			return False
		if self.click_num %2 == 1 and self.click_list[0][0] == i and self.click_list[0][1] == j:
			return False

		self.click_num += 1
		self.click_list.append([i,j])
		if self.click_num % 2 == 0:

			if self.blocks_type[self.click_list[0][0]][self.click_list[0][1]] == self.blocks_type[self.click_list[1][0]][self.click_list[1][1]] :
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].type = TYPE_RECT
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].color = (255,255,255)
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].draw()#进行重渲染
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].type = TYPE_RECT
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].color = (255,255,255)
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].draw()#进行重渲染
				self.blocks_type[self.click_list[0][0]][self.click_list[0][1]] = 0
				self.blocks_type[self.click_list[1][0]][self.click_list[1][1]] = 0
			self.click_list = list()
	
	def breadth_first_search(self,startnode,destinationnode):
		visited = set()#访问过的节点集合
		queue =  deque([tuple(startnode)]) #队列，存储待访问的节点

		while queue:
			node = queue.popleft() #从队列左侧弹出一个节点
			if node not in visited:
                
				visited.add(node)
				for neighbor in self.expandNode(node):
					if tuple(neighbor) == tuple(destinationnode):
						return True 
					if tuple(neighbor) not in visited and self.blocks_type[neighbor[0]][neighbor[1]] == 0:
						queue.append(tuple(neighbor))  # 将未访问的邻居加入队列
		return False
	
	def expandNode(self,node):
		neighbors = []
		if node[1] < self.blocks_type.shape[1]-1:#节点上方还有节点则可以扩展上方节点
			neighbors.append((node[0],node[1]+1))
		if node[1] > 0:#节点下方还有节点则可以扩展下方节点
			neighbors.append((node[0],node[1]-1))
		if node[0] < self.blocks_type.shape[0]-1: #节点右方还有节点则可以扩展右方节点
			neighbors.append((node[0]+1,node[1])) 
		if node[0] > 0:#节点左方还有节点则可以扩展左方节点
			neighbors.append((node[0]-1,node[1]))
		return neighbors
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

这样在执行完广度优先搜索算法后，我们就可以知道两个元素之间有没有连接路径。

三、调用连接路径判断

我们可以在第二次点击事件时搜索连接路径。代码如下：

	def mouseClick(self,x,y):
		i = (y-self.start_top)//self.block_height
		j = (x-self.start_left)//self.block_width
		if i<0 or i>self.row-1 or j<0 or j >self.col-1 or self.blocks_type[i][j] == 0:
			return False
		if self.click_num %2 == 1 and self.click_list[0][0] == i and self.click_list[0][1] == j:
			return False

		self.click_num += 1
		self.click_list.append([i,j])
		if self.click_num % 2 == 0:

			if self.blocks_type[self.click_list[0][0]][self.click_list[0][1]] == self.blocks_type[self.click_list[1][0]][self.click_list[1][1]] and self.breadth_first_search((self.click_list[0][0],self.click_list[0][1]),(self.click_list[1][0],self.click_list[1][1])):
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].type = TYPE_RECT
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].color = (255,255,255)
				self.blocks[self.click_list[0][0]][self.click_list[0][1]].draw()#进行重渲染
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].type = TYPE_RECT
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].color = (255,255,255)
				self.blocks[self.click_list[1][0]][self.click_list[1][1]].draw()#进行重渲染
				self.blocks_type[self.click_list[0][0]][self.click_list[0][1]] = 0
				self.blocks_type[self.click_list[1][0]][self.click_list[1][1]] = 0
			self.click_list = list()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

效果图：

这样我们就完成了游戏的基本逻辑。

四、完整代码

完整代码我会传到资源上，大家有需要可以在资源上免费获得，进行进一步开发。

---

总结

至此，我们的python小游戏开心消消乐/连连看就已经完成了，大家如果感兴趣可以自行下载我上传的资源，可以在此基础上进行二次开发，可以发出来一起分享各自的成果一起交流。

---

整篇总结

后续我会将代码公开到我主页中的资源中，大家有需要可以去下载，希望大家能在学习制作消消乐/连连看的过程中能够有所收获，并且更进一步。