python程序设计基础课程设计–五子棋小游戏
目录
一、项目简介
二、项目采用技术
1、基于的开发环境：
2、用到的框架：
三、功能需求分析
四、项目核心代码1、GameObject类
2、按钮类
3、判断落子位置是否合理
4、胜利说明
5、胜利检测
6、遍历棋盘每行获得的分数
7、 计算某一方的附加分
8、计算棋盘终总分
9、ai落子决策
10、窗体显示
11、棋形价值模型
12、游戏基础框架
五、系统演示操作视频
六、团队成员负责模块
一、项目简介
使用python语言实现了五子棋小游戏，在游戏中，玩家可以与ai对战，两人轮流放置棋子，玩家在中途可以选着“悔棋”，撤销动作。最终，谁先连成五个棋子，游戏结束，获得胜利。
二、项目采用技术
1、基于的开发环境：
（1）Python解释器：
从Python官方网站下载并安装适合本机操作系统的Python版本。
（2）PyCharm IDE：
PyCharm是一个流行的Python集成开发环境（IDE），它提供了丰富的功能和工具，帮助你更高效地开发Python项目。从PyCharm官方网站下载并安装合适的PyCharm版本。
（3）五子棋库：
为了实现五子棋游戏，需要使用一些额外的库，在PyCharm中，可以使用pip工具安装库。例如此次安装了Pygame游戏库。
2、用到的框架：
（1）pygame：
pygame是一个用于编写视频游戏的Python库。虽然五子棋不是一个视频游戏，但pygame也可以用于创建图形用户界面，并且它提供了许多有用的工具和函数，可以帮助实现五子棋游戏。
（2）minimax：
minimax是一种经典的AI算法，用于实现棋类游戏的AI。在五子棋游戏中，使用minimax算法来让计算最大得分。
3、引用的包：
pygame、config、time。
三、功能需求分析
玩家在一个15乘15的棋盘上轮流放置黑白棋子，谁先连成五个棋子就获得胜利。在游戏中，玩家可以与ai对战，两人轮流放置棋子，玩家在中途可以选着“悔棋”，点击悔棋按钮撤销一步（或几步）动作。最终，谁先连成五个棋子，游戏结束，获得胜利，并显示获胜者。五秒后，进去下一轮。
四、项目核心代码
1、GameObject类
class GameObject:
# 具有棋子的图像、类别和坐标三个属性
def __init__(self, image, color, pos):
self.image = image
self.color = color
self.pos = image.get_rect(center=pos2、按钮类
class Button(object):
# 具有图像surface，宽高和坐标属性
def __init__(self, text, color, x=None, y=None):
self.surface = font_big.render(text, True, color)
self.WIDTH = self.surface.get_width()
self.HEIGHT = self.surface.get_height()
self.x = x
self.y = y
# 这个方法用于确定鼠标是否点击了对应的按钮
def check_click(self, position):
x_match = self.x < position[0] < self.x + self.WIDTH
y_match = self.y < position[1] < self.y + self.HEIGHT
if x_match and y_match:
return True
else:
return False3、判断落子位置是否合理
def set_chess(board_inner, x, y, color):
if board_inner[x][y] != ' ':
print('该位置已有棋子')
print(x, y)
return False
else:
board_inner[x][y] = color
print(x, y)
# for _ in board_inner:
# print(_)
# print()
return True4、胜利说明
def check_win(board_inner):
for list_str in board_inner:
if ''.join(list_str).find('O' * 5) != -1:
print('白棋获胜')
return 0
elif ''.join(list_str).find('X' * 5) != -1:
print('黑棋获胜')
return 1
else:
return -15、胜利检测
def check_win_all(board_inner):
board_c = [[] for _ in range(29)]
for x in range(15):
for y in range(15):
board_c[x - y].append(board_inner[x][y])
board_d = [[] for _ in range(29)]
for x in range(15):
for y in range(15):
board_d[x + y].append(board_inner[x][y])
return [check_win(board_inner), check_win([list(i) for i in zip(*board_inner)]), check_win(board_c),
check_win(board_d)]6、遍历棋盘每行获得的分数
def value(board_inner, temp_list, value_model):
score = 0
num = 0
# 第一层循环，遍历棋盘，计算每一行的得分
for list_str in board_inner:
# 如果一行里棋子数量少于2个，则跳过这一行
if len(''.join(list_str).replace(' ', '')) len(list_str):
break
# num用于测试调试时计算循环次数
num += 1
# 如果是本行的开头，则与开头棋型和通用棋型进行对比
if i == 0:
# 第四层循环，把截取的字符串与棋型字符串逐一比对
for k in value_model[0].items():
# 如果切片与棋型完全相等，则把结果记录在temp中
if ''.join(list_str[i:i + j]) == k[1][0]:
temp.append((i, k))
else:
# 如果既不是开头也不是结尾，与通用棋型进行对比
if i + j < len(list_str):
for k in value_model[1].items():
if ''.join(list_str[i:i + j]) == k[1][0]:
temp.append((i, k))
# 如果是结尾，与结尾棋型和通用棋型进行对比
elif i + j == len(list_str):
for k in value_model[2].items():
if ''.join(list_str[i:i + j]) == k[1][0]:
temp.append((i, k))
# 如果a不等于1，则相当于跳过本次比对，a-1，temp要记得重新赋值为[]
else:
a -= 1
temp = []
# 对temp进行判空操作，避免报错
if temp:
# 用列表推导式从temp中抽离出有效信息，获得切片匹配到的最高分
max_value = max([i[1][1][1] for i in temp])
# 基于最高分找到匹配到的棋型
max_shape = [i for i in temp if i[1][1][1] == max_value][0]
# 棋型特殊处理，若匹配到某些棋型，需要在匹配时跳过若干位
if max_shape[1][0] in ['4_3', '3_0', '3_16', '2_3']:
a = 1
elif max_shape[1][0] in ['4_5', '4_13', '3_5', '2_0']:
a = 2
elif max_shape[1][0] in ['4_4']:
a = 5
# 用temp_list保存每一行、每一位匹配到的棋型
temp_list.append(max_shape)
# 用score记录总分值
score += max_value
# print(temp_list)
# print('value函数循环次数{}'.format(num))
return score
7、 计算某一方的附加分
def additional(te_list):
score = 0
# 对te_list做一些处理得到temp_list
temp_list = [i[1][0] for i in te_list]
# 死四 + 活三 >= 2，则附加分加30分
if sum([temp_list.count(i) for i in ['3_0', '3_3', '3_4', '3_5', '3_6', '4_1', '4_2', '4_3', '4_4', '4_5', '4_6'，'4_7', '4_8', '4_9', '4_10', '4_11', '4_12', '4_13', '4_14', '4_15', '4_16', '4_17', '4_18', '4_19']]) >= 2:
score += 30
# 活三 + 死三 >= 2 且 活三 > 0，则附加分加15分
elif sum([temp_list.count(i) for i in ['3_0', '3_3', '3_4', '3_5', '3_6', '3_1', '3_2', '3_7', '3_8', '3_9', '3_10', '3_11', '3_12', '3_13', '3_14', '3_15', '3_16', '3_17']]) >= 2 \
and sum([temp_list.count(i) for i in ['3_0', '3_3', '3_4', '3_5', '3_6']]) > 0:
score += 15
return score8、计算棋盘终总分
def value_all(board_inner, temp_list, value_model):
board_c = [[] for _ in range(29)]
for x in range(15):
for y in range(15):
board_c[x + y].append(board_inner[x][y])
board_d = [[] for _ in range(29)]
for x in range(15):
for y in range(15):
board_d[x - y].append(board_inner[x][y])
a = value(board_inner, temp_list, value_model)
b = value([list(i) for i in zip(*board_inner)], temp_list, value_model)
c = value(board_c, temp_list, value_model)
d = value(board_d, temp_list, value_model)
# 进行四个方向检测时，共用一个temp_list，因此附加分是考虑了全部四个方向
add = additional(temp_list)
# print(temp_list)
# print('横{},竖{},正斜{},反斜{},附加{}'.format(a, b, c, d, add))
return a + b + c + d + add9、ai落子决策
def value_chess(board_inner):
t1 = time.time()
# 如果棋盘为空，则黑棋直接落在天元位置，分数为0
if board_inner == [[' '] * 15 for line in range(15)]:
return 7, 7, 0
# 一系列数据初始化
temp_list_x = []
temp_list_o = []
tp_list_x_2 = []
tp_list_o_2 = []
tp_list_d = []
score_x = value_all(board_inner, temp_list_x, value_model_X) # 落子前，黑棋分数
pos_x = (0, 0)
score_o = value_all(board_inner, temp_list_o, value_model_O) # 落子前，白棋分数
pos_o = (0, 0)
pos_d = (0, 0)
score_x_2 = 0
score_o_2 = 0
score_diff = 0
# 获得横竖两个方向，棋子落子范围；比如最左棋子在第5列，最右棋子在第9列；最上棋子在第5行，最下棋子在第9行；
# 目的是为了缩小遍历范围；离当前棋子过远的区域，影响较小，就不再考虑遍历了；
chess_range_x = [x for x in range(15) if ''.join(board_inner[x]).replace(' ', '') != '']
chess_range_y = [y for y in range(15) if ''.join([list(i) for i in zip(*board_inner)][y]).replace(' ', '') != '']
# 在棋子最大范围的基础上，做一些小小的拓展，得到落子检测区域；在上下左右四个方向各拓展4行/列；
range_x = (max(0, min(chess_range_x) - 4), min(max(chess_range_x) + 4, 15))
range_y = (max(0, min(chess_range_y) - 4), min(max(chess_range_y) + 4, 15))
# 遍历落子检测区域所有的位置
for x in range(*range_x):
for y in range(*range_y):
tp_list_x = []
tp_list_o = []
tp_list_c = []
# 如果该位置已有棋子，则跳过
if board_inner[x][y] != ' ':
continue
else:
board_inner[x][y] = 'X'
score_a = value_all(board_inner, tp_list_x, value_model_X) # 该位置落黑子，黑棋分数
score_c = value_all(board_inner, tp_list_c, value_model_O) # 该位置落黑子，白棋分数
# score_x_2用于记录黑棋最高分对应的落子信息
if score_a > score_x_2:
pos_x = x, y
tp_list_x_2 = tp_list_x
score_x_2 = score_a
# 假定在该位置落白子
board_inner[x][y] = 'O'
score_b = value_all(board_inner, tp_list_o, value_model_O) # 该位置落白子，白棋分数
# score_x_2用于记录白棋最高分对应的落子信息
if score_b > score_o_2:
pos_o = x, y
tp_list_o_2 = tp_list_o
score_o_2 = score_b
# 将该位置棋子信息复原
board_inner[x][y] = ' '
# diff = = 1.1 * 黑棋分数增长 + （白棋原分数 - 落子后白棋分数） + （白棋预期最高分 - 落子后白棋分数）
# 之所以（白棋预期最高分 - 落子后白棋分数），是为了增加防守的逻辑；
# 之所以设置1.1的系数，是为了鼓励进攻，毕竟只有进攻才能获得胜利
diff = 1.1 * (score_a - score_x) + score_o - score_c + score_b - score_c
# score_diff用于记录diff的最大值
if diff > score_diff:
pos_d = x, y
tp_list_d = tp_list_x
score_diff = diff
# 三种不同的策略，打印出对应的信息
if score_x_2 >= 1000:
print('——' * 30)
print('策略1棋面：')
print('黑棋棋面：', temp_list_x)
print('白棋棋面：', temp_list_o)
score = score_x_2
pos = pos_x
x, y = pos
board_inner[x][y] = 'X'
# temp_list_x.clear()
# score = value_all(board_inner, temp_list_x, value_model_X)
score_o_e = value_all(board_inner, temp_list_o, value_model_O)
board_inner[x][y] = ' '
print('执行策略1、直接获胜')
print('黑棋最佳落子：坐标{}，黑棋得分{}，白棋得分{}'.format(pos, score, score_o_e))
# print('白棋最佳落子：坐标{}'.format(pos_o))
print('白棋原分数{}，预期最高分数{}，分数差值{}'.format(score_o, score_o_2, score_o_2 - score_o))
print('若白棋落子{}，白棋棋型{}'.format(pos_o, tp_list_o_2))
print('黑棋原分数{}，预期最高分数{}，分数差值{}'.format(score_x, score_x_2, score_x_2 - score_x))
print('若黑棋落子{}，黑棋棋型{}'.format(pos_x, tp_list_x_2))
print('——' * 30)
elif score_o_2 >= 1000:
print('——' * 30)
print('策略2棋面：')
print('黑棋棋面：', temp_list_x)
print('白棋棋面：', temp_list_o)
x, y = pos_o
board_inner[x][y] = 'X'
temp_list_x.clear()
score = value_all(board_inner, temp_list_x, value_model_X)
score_o_e = value_all(board_inner, temp_list_o, value_model_O)
board_inner[x][y] = ' '
pos = pos_o
print('执行策略2、防守：防止对方获胜')
print('黑棋最佳落子：坐标{}，黑棋得分{}，白棋得分{}'.format(pos, score, score_o_e))
# print('白棋最佳落子：坐标{}'.format(pos_o))
print('白棋原分数{}，预期最高分数{}，分数差值{}'.format(score_o, score_o_2, score_o_2 - score_o))
print('若白棋落子{}，白棋棋型{}'.format(pos_o, tp_list_o_2))
print('黑棋原分数{}，预期最高分数{}，分数差值{}'.format(score_x, score_x_2, score_x_2 - score_x))
print('若黑棋落子{}，黑棋棋型{}'.format(pos_x, tp_list_x_2))
print('——' * 30)
else:
print('——' * 30)
print('策略3棋面：')
print('黑棋棋面：', temp_list_x)
print('白棋棋面：', temp_list_o)
x, y = pos_d
board_inner[x][y] = 'X'
temp_list_x.clear()
temp_list_o.clear()
score = value_all(board_inner, temp_list_x, value_model_X)
score_o_e = value_all(board_inner, temp_list_o, value_model_O)
board_inner[x][y] = 'O'
score_test = value_all(board_inner, [], value_model_O)
board_inner[x][y] = ' '
pos = pos_d
print('黑棋原得分', score_x)
print('黑棋得分', score)
print('白棋原得分', score_o)
print('白棋得分', score_o_e)
print('若该位置落白棋，白棋得分', score_test)
print('落子后黑棋棋面', temp_list_x)
print('执行策略3、防守：防守+进攻')
print('我方增长得分+对方减少得分：{}'.format(score_diff))
print('黑棋最佳落子：坐标{}，黑棋得分{}，白棋得分{}'.format(pos, score, score_o_e))
# print('白棋最佳落子：坐标{}'.format(pos_o))
print('白棋原分数{}，预期最高分数{}，分数差值{}'.format(score_o, score_o_2, score_o_2 - score_o))
print('若白棋落子{}，白棋棋型{}'.format(pos_o, tp_list_o_2))
print('黑棋原分数{}，预期最高分数{}，分数差值{}'.format(score_x, score_x_2, score_x_2 - score_x))
print('若黑棋落子{}，黑棋棋型{}'.format(pos_x, tp_list_x_2))
print('——' * 30)
print("代码执行完毕，用时{}秒".format(round(time.time() - t1, 2)))
# 返回最终策略对应的黑棋落子坐标和黑棋得分
return *pos, score10、窗体显示
def main(board_inner):
pg.init()
# 一系列数据初始化
# pygame时钟
clock = pg.time.Clock()
# 下棋记录列表
objects = []
# 恢复棋子时用到的列表，即悔棋记录列表
recover_objects = []
# 将以上两个列表放到一个列表中，主要是增强抽象度，简少了代码行数
ob_list = [objects, recover_objects]
# 游戏窗口
screen = pg.display.set_mode((WIDTH, HEIGHT))
# 黑棋棋子图像
black = pg.image.load("data/chess_black.png").convert_alpha()
# 白棋棋子图像
white = pg.image.load("data/chess_white.png").convert_alpha()
# 棋盘背景图像
background = pg.image.load("data/qp.png").convert_alpha()
# 创建悔棋按钮
regret_button = Button('悔棋', RED, 665, 200)
# 创建恢复按钮
recover_button = Button('恢复', BLUE, 665, 300)
# 创建重新开始按钮
restart_button = Button('重新开始', GREEN, 625, 400)
# 把悔棋按钮打印游戏窗口
screen.blit(regret_button.surface, (regret_button.x, regret_button.y))
# 把恢复按钮打印游戏窗口
screen.blit(recover_button.surface, (recover_button.x, recover_button.y))
# 把重新开始按钮打印游戏窗口
screen.blit(restart_button.surface, (restart_button.x, restart_button.y))
# 窗体的标题
pg.display.set_caption("五子棋")
# 回合变量，用于识别当前是哪一方回合
flag = 0
# 主循环变量，用于控制主循环继续或者结束
going = True
# 棋子图像列表，主要是增强抽象度，简少了代码行数
chess_list = [black, white]
# 棋子类型列表，主要是增强抽象度，简少了代码行数
letter_list = ['X', 'O']
# 棋子文字名称列表，主要是增强抽象度，简少了代码行数
word_list = ['黑棋', '白棋']
# 棋子文字颜色列表，主要是增强抽象度，简少了代码行数
word_color = [(0, 0, 0), (255, 255, 255)]
while going:
# 将棋盘背景打印到游戏窗口
screen.blit(background, (0, 0))
# 创建一个文本对象，显示当前是哪方的回合
text = font.render("{}回合".format(word_list[flag]), True, word_color[flag])
# 确定文本对象的显示位置
text_pos = text.get_rect(centerx=background.get_width() / 2, y=2)
# 将文本对象打印到游戏窗口
screen.blit(text, text_pos)
# 通过循环不断识别玩家操作
for event in pg.event.get():
# 如果关闭窗口，主循环结束
if event.type == pg.QUIT:
going = False
# 如果点击键盘ESC键，主循环结束
elif event.type == pg.KEYDOWN and event.key == pg.K_ESCAPE:
going = False
# 如果玩家进行了鼠标点击操作
elif event.type == pg.MOUSEBUTTONDOWN:
# 获取鼠标点击坐标
pos = pg.mouse.get_pos()
# 如果点击了悔棋按钮或者恢复按钮
if regret_button.check_click(pos) or recover_button.check_click(pos):
# 点击悔棋按钮index = 0，点击恢复按钮index = 1
index = 0 if regret_button.check_click(pos) else 1
# 对指定列表进行判空操作，然后对下棋记录列表或者悔棋记录列表进行操作
if ob_list[index]:
# print(ob_list[index][-1].pos)
# 将游戏/悔棋记录列表里的图像坐标，转化为board坐标
# 人机对战需要黑方、白方各悔一步棋；（如果只是玩家悔棋，AI会立即下出一步，导致悔棋失败）
x, y = [round((p + 18 - 27) / 40) for p in ob_list[index][-1].pos[:2]]
# print(y, x)
# 如果是悔棋操作，则board指定元素值恢复为' '；如果是恢复操作，则指定坐标board指定元素重新赋值
board_inner[y][x] = ' ' if index == 0 else ob_list[index][-1].color
# 将游戏/悔棋记录列表的最后一个值添加到悔棋/下棋记录列表
ob_list[index - 1].append(ob_list[index][-1])
# 将游戏/悔棋记录列表的最后一个值删除
ob_list[index].pop()
x, y = [round((p + 18 - 27) / 40) for p in ob_list[index][-1].pos[:2]]
# print(y, x)
# 如果是悔棋操作，则board指定元素值恢复为' '；如果是恢复操作，则指定坐标board指定元素重新赋值
board_inner[y][x] = ' ' if index == 0 else ob_list[index][-1].color
# 将游戏/悔棋记录列表的最后一个值添加到悔棋/下棋记录列表
ob_list[index - 1].append(ob_list[index][-1])
# 将游戏/悔棋记录列表的最后一个值删除
ob_list[index].pop()
# flag = [1, 0][flag] # 变更回合方
elif restart_button.check_click(pos):
# 提示文案
hint_text = font.render("游戏重新开始", True, word_color[flag])
# 提示文案位置
hint_text_pos = hint_text.get_rect(centerx=background.get_width() / 2, y=200)
# 把提示文案打印到游戏窗口
screen.blit(hint_text, hint_text_pos)
# 对游戏窗口进行刷新
pg.display.update()
# 暂停1秒，保证文案能够清晰展示
pg.time.delay(1000)
# 对board进行初始化
board_inner = [[' '] * 15 for _ in range(15)]
# 下棋记录列表初始化
objects.clear()
# 悔棋记录列表初始化
recover_objects.clear()
# flag初始化
flag = 0
# 通过continue跳过下一行代码，从而保证flag赋值不会异常
continue
else:
# 若用户点击的不是悔棋、恢复按钮，则进行落子操作
# 将用户鼠标点击位置的坐标，换算为board坐标
a, b = round((pos[0] - 27) / 40), round((pos[1] - 27) / 40)
# 若坐标非法（即点击到了黑色区域），则不做处理
if a >= 15 or b >= 15:
continue
else:
# 将a、b进行处理得到x和y
x, y = max(0, a) if a < 0 else min(a, 14), max(0, b) if b < 0 else min(b, 14)
# 若落子操作合法，则进行落子
if set_chess(board_inner, y, x, letter_list[flag]):
# 下棋记录列表添加指定棋子
objects.append(GameObject(chess_list[flag], letter_list[flag], (27 + x * 40, 27 + y * 40)))
# 一旦成功落子，则将悔棋记录列表清空；不这么做，一旦在悔棋和恢复中间掺杂落子操作，就会有问题
recover_objects.clear()
# 判断是否出现获胜方
if 0 in check_win_all(board_inner) or 1 in check_win_all(board_inner):
# 将下棋记录的棋子打印到游戏窗口
for o in objects:
screen.blit(o.image, o.pos)
# 根据flag获取到当前获胜方，生成获胜文案
win_text = font.render("{}获胜，游戏5秒后重新开始".format(word_list[flag]), True,
word_color[flag])
# 设定获胜文案的位置
win_text_pos = win_text.get_rect(centerx=background.get_width() / 2, y=200)
# 把获胜文案打印到游戏窗口
screen.blit(win_text, win_text_pos)
# 对游戏窗口进行刷新
pg.display.update()
# 暂停5秒，保证文案能够清晰展示
pg.time.delay(5000)
# 对board进行初始化
board_inner = [[' '] * 15 for _ in range(15)]
# 下棋记录列表初始化
objects.clear()
# 悔棋记录列表初始化
recover_objects.clear()
# flag初始化
flag = 0
# 通过continue跳过下一行代码，从而保证flag赋值不会异常
continue
flag = [1, 0][flag]
# 若落子位置已经有棋子，则进行提示
else:
# 提示文案
hint_text = font.render("该位置已有棋子", True, word_color[flag])
# 提示文案位置
hint_text_pos = hint_text.get_rect(centerx=background.get_width() / 2, y=200)
# 将下棋记录的棋子打印到游戏窗口
for o in objects:
screen.blit(o.image, o.pos)
# 把提示文案打印到游戏窗口
screen.blit(hint_text, hint_text_pos)
# 对游戏窗口进行刷新
pg.display.update()
# 暂停0.3秒，保证文案能够清晰展示
pg.time.delay(300)
# AI执黑，AI进行落子
if flag == 0:
y, x = value_chess(board_inner)[:2]
if set_chess(board_inner, y, x, letter_list[flag]):
objects.append(GameObject(chess_list[flag], letter_list[flag], (27 + x * 40, 27 + y * 40)))
flag = [1, 0][flag]
# 将下棋记录的棋子打印到游戏窗口
for o in objects:
screen.blit(o.image, o.pos)
# 游戏帧率每秒60帧
clock.tick(60)
# 对游戏窗口进行刷新
pg.display.update()11、棋形价值模型
WIDTH, HEIGHT = 800, 615
RED = (255, 48, 48)
BLUE = (65, 105, 225)
GREEN = (0, 139, 0)
board = [[' '] * 15 for line in range(15)]
# value_model_X_test = {
# '5': ('XXXXX', 1000),
#
# '4_0': (' XXXX ', 400),
# '4_1': (' XXXXO', 100),
# '4_2': ('OXXXX ', 100),
# '4_11': ('XXXX ', 100), # 开头
# '4_10': (' XXXX', 100), # 结尾
#
# '4_9': ('OXXX X', 82),
# '4_17': ('XXX XO', 86),
# '4_15': ('XXX X', 82), # 开头
# '4_19': ('XXX X', 86), # 结尾
# '4_5': (' XXX X', 120),
#
# '4_7': ('XX XXO', 84),
# '4_8': ('OXX XX', 84),
# '4_13': ('XX XX ', 84), # 开头
# '4_4': (' XX XX ', 110),
# '4_14': ('XX XX', 84), # 结尾
#
# '4_3': ('X XXX ', 120),
# '4_6': ('X XXXO', 82),
# '4_16': ('OX XXX', 86),
# '4_18': ('X XXX', 86), # 开头
# '4_12': ('X XXX', 82), # 结尾
#
# '3_0': (' XXX ', 60),
# '3_1': (' XXXO', 25),
# '3_2': ('OXXX ', 25),
# '3_3': (' XXX ', 30),
# '3_4': (' XXX ', 30),
# '3_10': ('XXX ', 25), # 开头
# '3_12': (' XXX', 25), # 结尾
#
# '3_6': (' XX X ', 37),
# '3_17': (' XX X', 23), # 结尾
# '3_15': (' XX XO', 23),
# '3_11': ('XX X ', 21), # 开头
# '3_8': ('OXX X ', 21),
#
# '3_5': (' X XX ', 37),
# '3_9': (' X XXO', 21),
# '3_14': ('OX XX ', 23),
# '3_16': ('X XX ', 23), # 开头
# '3_13': (' X XX', 21), # 结尾
#
# '3_7': (' X X X ', 27),
#
# '2_0': (' XX ', 8),
# '2_1': (' XXO', 2),
# '2_2': ('OXX ', 2),
# '2_3': (' XX ', 5),
# '2_4': (' XX ', 4),
# '2_6': ('XX ', 2), # 开头
# '2_7': (' XX', 2), # 结尾
#
# '2_5': (' X X ', 4)
# }
value_model_X = [
# 开头检测
{
'5': ('XXXXX', 1000),
'4_0': (' XXXX ', 400),
'4_1': (' XXXXO', 100),
'4_2': ('OXXXX ', 100),
'4_3': ('X XXX ', 120),
'4_4': (' XX XX ', 110),
'4_5': (' XXX X', 120),
'4_6': ('X XXXO', 82),
'4_7': ('XX XXO', 84),
'4_8': ('OXX XX', 84),
'4_9': ('OXXX X', 82),
'4_16': ('OX XXX', 86),
'4_17': ('XXX XO', 86),
'4_11': ('XXXX ', 100), # 开头
'4_13': ('XX XX ', 84), # 开头
'4_15': ('XXX X', 82), # 开头
'4_18': ('X XXX', 86), # 开头
'3_0': (' XXX ', 60),
'3_1': (' XXXO', 25),
'3_2': ('OXXX ', 25),
'3_3': (' XXX ', 30),
'3_4': (' XXX ', 30),
'3_5': (' X XX ', 37),
'3_6': (' XX X ', 37),
'3_7': (' X X X ', 27),
'3_8': ('OXX X ', 21),
'3_9': (' X XXO', 21),
'3_14': ('OX XX ', 23),
'3_15': (' XX XO', 23),
'3_10': ('XXX ', 25), # 开头
'3_11': ('XX X ', 21), # 开头
'3_16': ('X XX ', 23), # 开头
'2_0': (' XX ', 8),
'2_1': (' XXO', 2),
'2_2': ('OXX ', 2),
'2_3': (' XX ', 5),
'2_4': (' XX ', 4),
'2_5': (' X X ', 4),
'2_6': ('XX ', 2), # 开头
},
# 中间检测
{
'5': ('XXXXX', 1000),
'4_0': (' XXXX ', 400),
'4_1': (' XXXXO', 100),
'4_2': ('OXXXX ', 100),
'4_3': ('X XXX ', 120),
'4_4': (' XX XX ', 110),
'4_5': (' XXX X', 120),
'4_6': ('X XXXO', 82),
'4_7': ('XX XXO', 84),
'4_8': ('OXX XX', 84),
'4_9': ('OXXX X', 82),
'4_16': ('OX XXX', 86),
'4_17': ('XXX XO', 86),
'3_0': (' XXX ', 60),
'3_1': (' XXXO', 25),
'3_2': ('OXXX ', 25),
'3_3': (' XXX ', 30),
'3_4': (' XXX ', 30),
'3_5': (' X XX ', 37),
'3_6': (' XX X ', 37),
'3_7': (' X X X ', 27),
'3_8': ('OXX X ', 21),
'3_9': (' X XXO', 21),
'3_14': ('OX XX ', 23),
'3_15': (' XX XO', 23),
'2_0': (' XX ', 8),
'2_1': (' XXO', 2),
'2_2': ('OXX ', 2),
'2_3': (' XX ', 5),
'2_4': (' XX ', 4),
'2_5': (' X X ', 4)
},
# 结尾检测
{
'5': ('XXXXX', 1000),
'4_0': (' XXXX ', 400),
'4_1': (' XXXXO', 100),
'4_2': ('OXXXX ', 100),
'4_3': ('X XXX ', 120),
'4_4': (' XX XX ', 110),
'4_5': (' XXX X', 120),
'4_6': ('X XXXO', 82),
'4_7': ('XX XXO', 84),
'4_8': ('OXX XX', 84),
'4_9': ('OXXX X', 82),
'4_16': ('OX XXX', 86),
'4_17': ('XXX XO', 86),
'4_10': (' XXXX', 100), # 结尾
'4_12': ('X XXX', 82), # 结尾
'4_14': ('XX XX', 84), # 结尾
'4_19': ('XXX X', 86), # 结尾
'3_0': (' XXX ', 60),
'3_1': (' XXXO', 25),
'3_2': ('OXXX ', 25),
'3_3': (' XXX ', 30),
'3_4': (' XXX ', 30),
'3_5': (' X XX ', 37),
'3_6': (' XX X ', 37),
'3_7': (' X X X ', 27),
'3_8': ('OXX X ', 21),
'3_9': (' X XXO', 21),
'3_14': ('OX XX ', 23),
'3_15': (' XX XO', 23),
'3_12': (' XXX', 25), # 结尾
'3_13': (' X XX', 21), # 结尾
'3_17': (' XX X', 23), # 结尾
'2_0': (' XX ', 8),
'2_1': (' XXO', 2),
'2_2': ('OXX ', 2),
'2_3': (' XX ', 5),
'2_4': (' XX ', 4),
'2_5': (' X X ', 4),
'2_7': (' XX', 2), # 结尾
}
]
value_model_O = [
# 开头检测
{
'4_11': ('OOOO ', 100), # 开头
'4_13': ('OO OO ', 84), # 开头
'4_15': ('OOO O', 82), # 开头
'4_18': ('O OOO', 86), # 开头
'3_10': ('OOO ', 25), # 开头
'3_11': ('OO O ', 21), # 开头
'3_16': ('O OO ', 23), # 开头
'2_6': ('OO ', 2), # 开头
'5': ('OOOOO', 1000),
'4_0': (' OOOO ', 400),
'4_1': (' OOOOX', 100),
'4_2': ('XOOOO ', 100),
'4_3': ('O OOO ', 120),
'4_4': (' OO OO ', 110),
'4_5': (' OOO O', 120),
'4_6': ('O OOOX', 82),
'4_7': ('OO OOX', 84),
'4_8': ('XOO OO', 84),
'4_9': ('XOOO O', 84),
'4_16': ('XO OOO', 86),
'4_17': ('OOO OX', 86),
'3_0': (' OOO ', 60),
'3_1': (' OOOX', 25),
'3_2': ('XOOO ', 25),
'3_3': (' OOO ', 30),
'3_4': (' OOO ', 30),
'3_5': (' O OO ', 37),
'3_6': (' OO O ', 37),
'3_7': (' O O O ', 27),
'3_8': ('XOO O ', 21),
'3_9': (' O OOX', 21),
'3_14': ('XO OO ', 23),
'3_15': (' OO OX', 23),
'2_0': (' OO ', 8),
'2_1': (' OOX', 2),
'2_2': ('XOO ', 2),
'2_3': (' OO ', 5),
'2_4': (' OO ', 4),
'2_5': (' O O ', 4)
},
# 中间检测
{
'5': ('OOOOO', 1000),
'4_0': (' OOOO ', 400),
'4_1': (' OOOOX', 100),
'4_2': ('XOOOO ', 100),
'4_3': ('O OOO ', 120),
'4_4': (' OO OO ', 110),
'4_5': (' OOO O', 120),
'4_6': ('O OOOX', 82),
'4_7': ('OO OOX', 84),
'4_8': ('XOO OO', 84),
'4_9': ('XOOO O', 84),
'4_16': ('XO OOO', 86),
'4_17': ('OOO OX', 86),
'3_0': (' OOO ', 60),
'3_1': (' OOOX', 25),
'3_2': ('XOOO ', 25),
'3_3': (' OOO ', 30),
'3_4': (' OOO ', 30),
'3_5': (' O OO ', 37),
'3_6': (' OO O ', 37),
'3_7': (' O O O ', 27),
'3_8': ('XOO O ', 21),
'3_9': (' O OOX', 21),
'3_14': ('XO OO ', 23),
'3_15': (' OO OX', 23),
'2_0': (' OO ', 8),
'2_1': (' OOX', 2),
'2_2': ('XOO ', 2),
'2_3': (' OO ', 5),
'2_4': (' OO ', 4),
'2_5': (' O O ', 4)
},
# 结尾检测
{
'4_10': (' OOOO', 100), # 结尾
'4_12': ('O OOO', 82), # 结尾
'4_14': ('OO OO', 84), # 结尾
'4_19': ('OOO O', 86), # 结尾
'3_12': (' OOO', 25), # 结尾
'3_13': (' O OO', 21), # 结尾
'3_17': (' OO O', 23), # 结尾
'2_7': (' OO', 2), # 结尾
'5': ('OOOOO', 1000),
'4_0': (' OOOO ', 400),
'4_1': (' OOOOX', 100),
'4_2': ('XOOOO ', 100),
'4_3': ('O OOO ', 120),
'4_4': (' OO OO ', 110),
'4_5': (' OOO O', 120),
'4_6': ('O OOOX', 82),
'4_7': ('OO OOX', 84),
'4_8': ('XOO OO', 84),
'4_9': ('XOOO O', 84),
'4_16': ('XO OOO', 86),
'4_17': ('OOO OX', 86),
'3_0': (' OOO ', 60),
'3_1': (' OOOX', 25),
'3_2': ('XOOO ', 25),
'3_3': (' OOO ', 30),
'3_4': (' OOO ', 30),
'3_5': (' O OO ', 37),
'3_6': (' OO O ', 37),
'3_7': (' O O O ', 27),
'3_8': ('XOO O ', 21),
'3_9': (' O OOX', 21),
'3_14': ('XO OO ', 23),
'3_15': (' OO OX', 23),
'2_0': (' OO ', 8),
'2_1': (' OOX', 2),
'2_2': ('XOO ', 2),
'2_3': (' OO ', 5),
'2_4': (' OO ', 4),
'2_5': (' O O ', 4)
}
]
if __name__ == '__main__':
test_list = list(set([_i[1] for _ in value_model_X for _i in _.items()]))
print(test_list)
print(len(test_list))
12、游戏基础框架
import pygame as pg
if __name__ == '__main__':
# 模块初始化
pg.init()
# 基础设置：游戏窗口，帧率
WIDTH = 615
HEIGHT = 615
# 时钟帧率
clock = pg.time.Clock()
# 游戏窗口
screen = pg.display.set_mode((WIDTH, HEIGHT))
# 导入素材
black = pg.image.load("data/chess_black.png").convert_alpha()
white = pg.image.load("data/chess_white.png").convert_alpha()
background = pg.image.load("data/qp.png").convert_alpha()
# 新创建的元素，全都放到这个列表里
objects = []
# 设置窗口标题
pg.display.set_caption("五子棋")
# 游戏主循环
going = True
while going:
# 把背景图“打印”到窗口上
screen.blit(background, (0, 0))
# 根据玩家操作，执行对应指令
for event in pg.event.get():
# 如果关闭窗口，则主循环结束
if event.type == pg.QUIT:
going = False
# 如果点击键盘esc键，则主循环结束
elif event.type == pg.KEYDOWN and event.key == pg.K_ESCAPE:
going = False
# 如果点击鼠标，则执行某个操作
elif event.type == pg.MOUSEBUTTONDOWN:
# 获取鼠标点击位置的坐标
pos = pg.mouse.get_pos()
print(pos)
objects.append([black,(pos[0]-18,pos[1]-18)])
# 把objects列表里的所有对象都打印到窗口
for o in objects:
screen.blit(o[0], o[1])
# 帧率设置为每秒60帧
clock.tick(60)
# 对游戏窗口进行刷新操作（如果不update，窗口是黑的）
pg.display.update()
# 如果循环结束，则关闭进程
pg.quit()五、系统演示操作视频
五子棋
六、团队成员负责模块
| 名字 | 负责模块 | 代码行数 |
| 杨晴 | 游戏主函数，悔棋操作的实现，悔棋按钮的函数，判断棋子位置是否合理，胜利检测，游戏基础框架以及游戏最终窗口的实现 | 413 |
| 邓书勤 | ai落子决策函数，遍历函数每一行的分数，添加附加分，计算每行分数的总和，编写棋形的价值模型，团队博客 | 432 |
