截至目前，我们可以通过面向对象思想，做一个属于自己的贪吃蛇游戏啦
image.png

尺寸相关

窗口尺寸：640 x 480px
蛇身块大小：20px

开发环境准备

安装依赖的库

  1. pip install PyQt5

拷贝需要的资源

img.zip
将如上压缩包下载，并将里边的图片解压到工程根目录的img文件夹中。

准备Game游戏类

新建game.py文件，拷贝如下内容到文件

  1. from abc import abstractmethod
  2. from PyQt5 import QtCore, QtGui, QtWidgets
  3. import sys
  5. COLOR_GRAY = QtGui.QColor(128, 128, 128)
  6. COLOR_RED  = QtGui.QColor(255, 0, 0)
  7. COLOR_GREEN = QtGui.QColor(0, 255, 0)
  8. COLOR_BLUE = QtGui.QColor(0, 0, 255)
  9. COLOR_WHITE = QtGui.QColor(255, 255, 255)
  11. class Game(QtWidgets.QWidget):
  12.     def __init__(self):
  13.         super().__init__()
  14.         self.setWindowTitle("Game")
  16.         self.timer = QtCore.QBasicTimer()
  17.         self.delay = 500
  18.         self.is_game_over = False
  20.     def set_fps(self, fps):
  21.         self.delay = 1000 // fps
  22.         if self.timer.isActive():
  23.             self.timer.stop()
  24.             self.timer.start(self.delay, self)
  26.     def timerEvent(self, event):
  27.         if self.is_game_over:
  28.             self.timer.stop()
  29.         else:
  30.             self.on_time_event(event)
  32.         self.repaint()
  34.     @abstractmethod
  35.     def on_time_event(self):
  36.         pass
  38.     @abstractmethod
  39.     def draw_content(self, qp: QtGui.QPainter):
  40.         pass
  42.     def paintEvent(self, event: QtGui.QPaintEvent):
  43.         qp = QtGui.QPainter()
  44.         qp.begin(self)
  45.         self.draw_content(qp)
  46.         qp.end()
  48.     def keyPressEvent(self, event: QtGui.QKeyEvent):
  49.         if event.key() == QtCore.Qt.Key_Escape:
  50.             self.close()
  51.             return
  52.         elif event.key() == QtCore.Qt.Key_Space:
  53.             if self.is_game_over:
  54.                 self.start_game()
  55.                 return
  57.         super().keyPressEvent(event)
  59.     def start_game(self):
  60.         self.is_game_over = False
  61.         self.timer.start(self.delay, self)
  63.     @classmethod
  64.     def start(cls):
  65.         app = QtWidgets.QApplication(sys.argv)
  66.         # 创建cls的对象
  67.         game = cls()
  68.         game.start_game()
  69.         game.show()
  70.         # while (1)
  71.         sys.exit(app.exec_())

继承Game游戏类（模板）

  1. """
  2. 继承了Game的空类
  3. """
  4. from game import *
  5. from PyQt5.QtCore import *
  6. from PyQt5.QtGui import *
  7. from PyQt5.QtWidgets import *
  9. SCREEN_WIDTH = 640
  10. SCREEN_HEIGHT = 480
  12. class SnakeGame(Game):
  14.     def __init__(self):
  15.         super().__init__()
  16.         # 设置标题
  17.         self.setWindowTitle("SnakeGame")
  18.         # 设置窗口尺寸, 并禁止拖拽修改窗口尺寸
  19.         self.setFixedSize(SCREEN_WIDTH, SCREEN_HEIGHT)
  20.         # 设置窗口图标
  21.         self.setWindowIcon(QIcon("img/icon.png"))
  23.     def keyPressEvent(self, event: QKeyEvent):
  24.         """处理按键事件
  25.         """
  26.         super().keyPressEvent(event)
  28.     def on_time_event(self, event):
  29.         """处理每帧时间事件
  30.         """
  31.         pass
  33.     def draw_content(self, qp: QPainter):
  34.         """绘制界面内容
  35.         :param qp: 画笔
  36.         """
  37.         pass
  39.     def start_game(self):
  40.         """游戏开始前的初始化
  41.         """
  42.         super().start_game()
  45. if __name__ == '__main__':
  46.     SnakeGame.start()

image.png

编写游戏逻辑

完整代码逻辑如下：

  1. import random
  2. from PyQt5.QtCore import *
  3. from PyQt5.QtGui import *
  4. from PyQt5.QtWidgets import *
  5. from game import *
  8. SCREEN_WIDTH = 640
  9. SCREEN_HEIGHT = 480
  10. BLOCK_SIZE = 20
  12. # 记录了每个方向对应的蛇头移动距离
  13. MOVE_DICT = {
  14.     Qt.Key_Left:    (-1, 0),
  15.     Qt.Key_Right:   (1, 0),
  16.     Qt.Key_Up:      (0, -1),
  17.     Qt.Key_Down:    (0, 1)
  18. }
  19. # 记录了每个方向对应的蛇头图片旋转角度
  20. DIRECTION_HEAD_ANGLE = {
  21.     Qt.Key_Left:    90,
  22.     Qt.Key_Right:   270,
  23.     Qt.Key_Up:      180,
  24.     Qt.Key_Down:    0
  25. }
  27. class Snake:
  29.     def __init__(self) -> None:
  30.         # 当前蛇头运动方向
  31.         self.direction = Qt.Key_Right
  32.         # 根据按键获取的最新蛇头运动方向
  33.         self.direction_temp = None
  34.         # 加载并缩放蛇头
  35.         self.head_img: QImage = QImage("img/head-red.png").scaled(BLOCK_SIZE, BLOCK_SIZE)
  36.         # 初始化蛇
  37.         self.snake_body = [
  38.             [3 * BLOCK_SIZE, 3 * BLOCK_SIZE],
  39.         ]
  40.         # 生长2节
  41.         self.score = 0
  42.         self.grow()
  43.         self.grow()
  45.     def handle_key_event(self, event: QKeyEvent) -> bool:
  46.         """判定按钮是否是方向的按键
  47.         并且判定能否改变到此方向
  49.         :param event: 按键事件
  50.         :return: True 能转向
  51.         """
  52.         key = event.key()
  53.         LR = Qt.Key_Left , Qt.Key_Right
  54.         UD = Qt.Key_Up, Qt.Key_Down
  56.         if key not in LR and key not in UD:
  57.             return False
  59.         if key in LR and self.direction in LR:
  60.             return False
  62.         if key in UD and self.direction in UD:
  63.             return False
  65.         self.direction_temp = key
  66.         return True
  68.     def draw(self, qp: QPainter):
  69.         """绘制蛇头蛇身
  71.         :param qp: 画笔
  72.         """
  73.         qp.setBrush(COLOR_BLUE)        
  74.         for node in self.snake_body[1:]:
  75.             # 绘制圆角矩形
  76.             # qp.drawRect(node[0], node[1], BLOCK_SIZE, BLOCK_SIZE)
  77.             qp.drawRoundedRect(node[0], node[1], BLOCK_SIZE, BLOCK_SIZE, 5, 5)
  79.         qp.setBrush(QColor(0, 255, 0))
  80.         head = self.snake_body[0]
  81.         # qp.drawRect(self.snake_body[0][0], head[1], BLOCK_SIZE, BLOCK_SIZE)
  82.         # 根据direction修改head_img旋转方向
  83.         rotated_head = self.head_img.transformed(QTransform().rotate(DIRECTION_HEAD_ANGLE[self.direction]))
  84.         qp.drawImage(head[0], head[1], rotated_head)
  86.     def move(self):
  87.         """移动一格
  88.         """
  89.         if self.direction_temp:
  90.             self.direction = self.direction_temp
  91.             self.direction_temp = None
  93.         # 修改头部坐标
  94.         new_head = self.snake_body[0][:]
  95.         new_move = MOVE_DICT[self.direction]
  96.         new_head[0] += new_move[0] * BLOCK_SIZE
  97.         new_head[1] += new_move[1] * BLOCK_SIZE
  98.         self.snake_body.insert(0, new_head)
  100.         # 删除尾部坐标
  101.         self.snake_body.pop()
  103.     def grow(self):
  104.         # 取出尾部坐标, 并复制一份
  105.         new_tail = self.snake_body[-1][:]
  106.         # 插入到尾部
  107.         self.snake_body.append(new_tail)
  109. class Apple:
  111.     def __init__(self, x, y) -> None:
  112.         self.node = [x * BLOCK_SIZE, y * BLOCK_SIZE]
  114.     def draw(self, qp: QPainter):
  115.         qp.setBrush(QColor(255, 0, 0))
  116.         qp.drawRect(self.node[0], self.node[1], BLOCK_SIZE, BLOCK_SIZE)
  118. class SnakeGame(Game):
  120.     def __init__(self):
  121.         super().__init__()
  123.         # 设置窗口尺寸, 并禁止拖拽修改窗口尺寸
  124.         self.setFixedSize(SCREEN_WIDTH, SCREEN_HEIGHT)
  125.         # 设置窗口标题
  126.         self.setWindowTitle("Snake Game")
  127.         # 图标
  128.         self.setWindowIcon(QIcon("img/icon.png"))
  130.         # 加载背景图, (缩放)
  131.         self.background_img = QImage("img/bg.png").scaled(SCREEN_WIDTH, SCREEN_HEIGHT)
  133.         # 设置fps，每秒5帧， 1000ms / 5 = 200ms
  134.         self.set_fps(5)
  136.         self.snake = None
  137.         self.apple = None
  139.         # 构建地图格点的二维数组
  140.         self.map = []
  141.         for i in range(SCREEN_WIDTH // BLOCK_SIZE):
  142.             for j in range(SCREEN_HEIGHT // BLOCK_SIZE):
  143.                 self.map.append([i, j])
  146.     def keyPressEvent(self, event: QKeyEvent):
  147.         if self.snake.handle_key_event(event):
  148.             return
  149.         super().keyPressEvent(event)
  151.     def on_time_event(self, event: QTimerEvent):
  152.         """处理每帧时间事件
  154.         :param event: 事件
  155.         """
  156.         self.snake.move()
  157.         self.check_collision()
  159.     def draw_content(self, qp: QPainter):
  160.         # 绘制背景图
  161.         qp.drawImage(0, 0, self.background_img)
  163.         # 绘制网格线，间隔为BLOCK_SIZE
  164.         # 设置画笔为灰色
  165.         qp.setPen(COLOR_GRAY)
  166.         # 绘制横线. 
  167.         # (0, 0) -> (SCREEN_WIDTH, 0)
  168.         # (0,20) -> (SCREEN_WIDTH, 20)
  169.         for y in range(0, SCREEN_HEIGHT, BLOCK_SIZE):
  170.             qp.drawLine(0, y, SCREEN_WIDTH, y)
  171.         # 绘制纵线
  172.         for x in range(0, SCREEN_WIDTH, BLOCK_SIZE):
  173.             qp.drawLine(x, 0, x, SCREEN_HEIGHT)
  175.         self.snake.draw(qp)
  176.         self.apple.draw(qp)
  178.         # 绘制文字
  179.         qp.setPen(COLOR_WHITE)
  180.         # 设置字号22, 字体 Arial
  181.         qp.setFont(QFont("Arial", 18))
  182.         # 左上角得分 Score: xxx
  183.         qp.drawText(20, 30, f"Score: {self.snake.score}")
  185.         if self.is_game_over:
  186.             # 设置字号20, 字体 Microsoft YaHei
  187.             qp.setFont(QFont("Microsoft YaHei", 20, weight=QFont.Bold))
  188.             # Game Over
  189.             qp.drawText(SCREEN_WIDTH // 2 - 100, SCREEN_HEIGHT // 2, "游戏结束")
  190.             qp.setFont(QFont("Microsoft YaHei", 14))
  191.             qp.drawText(SCREEN_WIDTH // 2 - 100, SCREEN_HEIGHT // 2 + 40, "得分：" + str(self.snake.score))
  192.             qp.drawText(SCREEN_WIDTH // 2 - 100, SCREEN_HEIGHT // 2 + 70, "按空格重新开始")
  195.     def check_collision(self):
  196.         """碰撞检测
  197.         """
  198.         snake_head = self.snake.snake_body[0]
  199.         if snake_head == self.apple.node:
  200.             print("吃到苹果")
  201.             self.generate_new_apple()
  202.             self.snake.grow()
  203.             self.snake.score += 1
  205.         # 如果蛇身占满地图，游戏结束
  206.         if len(self.snake.snake_body) >= len(self.map):
  207.             print("游戏胜利")
  208.             self.is_game_over = True
  210.         # 碰到自己
  211.         if snake_head in self.snake.snake_body[1:]:
  212.             self.is_game_over = True
  213.             print("碰到自己")
  215.         # 碰到墙
  216.         head_x, head_y = snake_head
  217.         if head_x < 0 or head_x >= SCREEN_WIDTH or head_y < 0 or head_y >= SCREEN_HEIGHT:
  218.             self.is_game_over = True
  219.             print("碰到墙")
  221.     def generate_new_apple(self):
  222.         """生成新的苹果坐标
  223.         """
  224.         # 复制一份self.map为新的temp_map
  225.         temp_map = self.map[:]
  227.         # 将 temp_map 中snake的坐标删除
  228.         for node in self.snake.snake_body:
  229.             node_pos = [node[0] // BLOCK_SIZE, node[1] // BLOCK_SIZE]
  230.             if node_pos in temp_map:
  231.                 temp_map.remove(node_pos)
  233.         if len(temp_map) == 0:
  234.             return
  236.         # 生成新的苹果坐标
  237.         new_pos = random.choice(temp_map)
  238.         print("new_pos: ", new_pos)
  239.         self.apple = Apple(new_pos[0], new_pos[1])
  241.     def start_game(self):
  242.         self.snake = Snake()
  243.         # self.apple = Apple(2, 2)
  244.         self.generate_new_apple()
  246.         super().start_game()
  249. if __name__ == "__main__":
  250.     SnakeGame.start()