🐍 手把手教你用 Py 打造童年回忆
|
折腾

技术选型和思路：

这次我们用的是 Python + Pygame，与之前的Web贪吃蛇不同，这个贪吃蛇配置运行更加方便简单

  • Python: 语法简洁易懂，适合快速开发。
  • Pygame: 是一个专门用来开发 2D 游戏的 Python 库，提供了图像、声音、事件处理等功能。

核心滴思路：

  1. 游戏地图: 用 Pygame 窗口来模拟游戏地图，用像素点来表示格子。
  2. 蛇: 蛇其实就是一堆连续的方块，用一个列表来存储蛇身上每个方块的坐标。
  3. 食物: 随机生成食物的坐标，但要确保食物不能出现在蛇的身体上。
  4. 移动: 通过改变蛇头的坐标来实现蛇的移动，并在蛇头增加一个方块，尾巴删掉一个方块，这样就可以实现移动了。
  5. 碰撞检测: 判断蛇头是否撞到墙壁，或者撞到自己的身体。

代码环节：

1. 初始化 Pygame 和设置窗口：

import pygame
import sys
import random

# 初始化 Pygame
pygame.init()

# 屏幕大小
WIDTH, HEIGHT = 720, 540
GRID_SIZE = 18
GRID_WIDTH = WIDTH // GRID_SIZE
GRID_HEIGHT = HEIGHT // GRID_SIZE

# 创建屏幕
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption('经典贪吃蛇')

2. 定义颜色：

颜色定义

BG_COLOR = (0, 0, 0) # 黑色背景
SNAKE_COLOR = (48, 214, 75) # 鲜艳的绿色
FOOD_COLOR = (230, 70, 100) # 醒目的红色
BORDER_COLOR = (60, 60, 60) # 灰色的边界
WHITE = (255, 255, 255) # 白色
BLACK = (0, 0, 0) # 黑色，用来绘制蛇的眼睛（技术有限，眼只能拿小点点来替代）

用 RGB 值来定义颜色，方便后面改成自己喜欢的。

3. 创建蛇类：

# 蛇类
class Snake:
    def __init__(self):
        self.body = [(GRID_WIDTH // 2, GRID_HEIGHT // 2)]  # 蛇的初始位置
        self.direction = random.choice([(1, 0), (-1, 0), (0, 1), (0, -1)])  # 初始移动方向
        self.next_direction = self.direction  # 下一个移动方向
        self.grow = False  # 吃到食物后，允许增长

    def update_direction(self, direction):
        """更新蛇的移动方向，不能 180 度转弯"""
        if (direction[0] * -1, direction[1] * -1) == self.direction:
            return

        self.next_direction = direction

    def move(self):
        """移动蛇"""
        self.direction = self.next_direction  # 应用下一个方向
        head = (self.body[0][0] + self.direction[0], self.body[0][1] + self.direction[1])  # 计算蛇头的新位置

        self.body.insert(0, head)  # 在蛇头处添加新的格子

        if self.grow:
            self.grow = False  # 允许增长后，只增长一次
        else:
            self.body.pop()  # 移除蛇尾

    def check_collision(self):
        """检查蛇是否撞到墙或自己"""
        x, y = self.body[0]  # 获取蛇头坐标

        if not (0 <= x < GRID_WIDTH and 0 <= y < GRID_HEIGHT):
            return True  # 撞到墙

        if self.body[0] in self.body[1:]:
            return True  # 撞到自己

        return False

    def draw(self, surface):
        """绘制蛇"""
        for i, (x, y) in enumerate(self.body):
            rect = pygame.Rect(x * GRID_SIZE, y * GRID_SIZE, GRID_SIZE, GRID_SIZE)  # 创建一个矩形
            pygame.draw.rect(surface, SNAKE_COLOR, rect)  # 绘制矩形

            # 绘制蛇头
            if i == 0:
                # 眼睛 (两个小黑点)
                eye_offset = GRID_SIZE // 4
                pygame.draw.rect(surface, BLACK, (x * GRID_SIZE + eye_offset, y * GRID_SIZE + eye_offset, 3, 3))  # 绘制左眼
                pygame.draw.rect(surface, BLACK, (x * GRID_SIZE + GRID_SIZE - eye_offset - 3, y * GRID_SIZE + eye_offset, 3, 3))  # 绘制右眼

                # 嘴巴 (一个小白点)
                mouth_offset = GRID_SIZE // 2
                pygame.draw.rect(surface, WHITE, (x * GRID_SIZE + mouth_offset - 1, y * GRID_SIZE + mouth_offset - 1, 3, 3))  # 绘制小嘴巴😘

4. 创建剋的类：

# 食物类
class Food:
    def __init__(self, snake_body):
        self.x, self.y = self.generate_random_position(snake_body)  # 随机生成食物的位置
        self.rect = pygame.Rect(self.x * GRID_SIZE, self.y * GRID_SIZE, GRID_SIZE, GRID_SIZE)  # 创建一个矩形

    def generate_random_position(self, snake_body):
        """生成随机位置，确保不在蛇的身体上"""
        while True:
            x = random.randint(0, GRID_WIDTH - 1)  # 随机生成 x 坐标
            y = random.randint(0, GRID_HEIGHT - 1)  # 随机生成 y 坐标
            if (x, y) not in snake_body:
                return x, y  # 如果不在蛇的身体上，就返回

    def draw(self, surface):
        """绘制食物"""
        rect = pygame.Rect(self.x * GRID_SIZE, self.y * GRID_SIZE, GRID_SIZE, GRID_SIZE)  # 创建一个矩形
        pygame.draw.rect(surface, FOOD_COLOR, rect)  # 绘制矩形

draw(): 绘制食物，用一个矩形表示食物。

5. 绘制网格（可选，我是想着方便观察蛇头和食物是不是在同一坐标上）：

# 绘制网格
def draw_grid(surface):
    for x in range(GRID_WIDTH):
        pygame.draw.line(surface, BORDER_COLOR, (x * GRID_SIZE, 0), (x * GRID_SIZE, HEIGHT))  # 绘制垂直线
    for y in range(GRID_HEIGHT):
        pygame.draw.line(surface, BORDER_COLOR, (0, y * GRID_SIZE), (WIDTH, y * GRID_SIZE))  # 绘制水平线

6. 创建开机动画（为了显得有b格，开机动画必须整一个doge）：

def show_splash_screen(surface, width, height):
    """显示开机启动画面"""
    text = "jianghao.work"  # 显示的文字
    font = pygame.font.Font(None, 50)  # 创建字体对象
    text_surface = font.render(text, True, WHITE)  # 渲染文字
    text_rect = text_surface.get_rect(center=(width // 2, height // 2))  # 获取文字的矩形

    # 动画时长（帧数）
    animation_duration = 120

    for i in range(animation_duration):
        # 计算透明度
        alpha = int(255 * abs((animation_duration / 2) - i) / (animation_duration / 2))  # 计算透明度

        # 创建一个具有透明度的Surface
        splash_surface = pygame.Surface((width, height), pygame.SRCALPHA)  # 创建一个 Surface
        splash_surface.fill((0, 0, 0, 0))  # 设置为透明背景

        # 渲染文字，设置透明度
        text_surface.set_alpha(alpha)  # 设置透明度
        splash_surface.blit(text_surface, text_rect)  # 绘制文字

        # 绘制到主屏幕
        surface.blit(splash_surface, (0, 0))  # 绘制到屏幕

        # 刷新屏幕
        pygame.display.flip()  # 刷新
        pygame.time.delay(10)  # 控制动画速度

    # 短暂停留
    pygame.time.delay(300)

show_splash_screen(): 显示开机启动画面，使用文字的淡入淡出效果。酱紫看着舒服不突兀。

7. 绘制游戏界面

# 绘制暂停界面
def draw_pause_screen(surface, width, height):
    font = pygame.font.Font(None, 50)
    text = font.render("Paused (Press SPACE to continue)", True, WHITE)
    text_rect = text.get_rect(center=(width // 2, height // 2))
    surface.blit(text, text_rect)

# 绘制游戏结束界面
def draw_game_over_screen(surface, width, height, score):
    font = pygame.font.Font(None, 50)
    text = font.render(f"Game Over! Score: {score}", True, WHITE)
    restart_text = font.render("Press R to restart, Q to quit", True, WHITE)
    text_rect = text.get_rect(center=(width // 2, height // 2 - 30))
    restart_rect = restart_text.get_rect(center=(width // 2, height // 2 + 30))
    surface.blit(text, text_rect)
    surface.blit(restart_text, restart_rect)

# 绘制分数
def draw_score(surface, score):
    font = pygame.font.Font(None, 30)
    text = font.render(f"Score: {score}", True, WHITE)
    surface.blit(text, (10, 10))

这部分代码主要是用于绘制游戏界面中的元素，其中有暂停界面、游戏结束界面和分数等。这些函数使用 Pygame 的绘图功能来在屏幕上显示文本信息

8. 创建游戏主循环：

# 游戏主函数
def main():
    """游戏主循环"""
    show_splash_screen(screen, WIDTH, HEIGHT)  # 先显示开机动画

    snake = Snake()  # 创建蛇
    food = Food(snake.body)  # 创建食物
    score = 0  # 初始分数
    clock = pygame.time.Clock()  # 创建时钟对象

    paused = False  # 初始状态为未暂停
    game_over = False  # 初始状态为游戏未结束

    while True:  # 游戏主循环
        for event in pygame.event.get():  # 获取事件
            if event.type == pygame.QUIT:  # 如果是退出事件
                pygame.quit()  # 退出 Pygame
                sys.exit()  # 退出程序

            if event.type == pygame.KEYDOWN:  # 如果是按键事件
                if event.key == pygame.K_UP:  # 如果按下的是上方向键
                    snake.update_direction((0, -1))  # 向上移动
                elif event.key == pygame.K_DOWN:  # 如果按下的是下方向键
                    snake.update_direction((0, 1))  # 向下移动
                elif event.key == pygame.K_LEFT:  # 如果按下的是左方向键
                    snake.update_direction((-1, 0))  # 向左移动
                elif event.key == pygame.K_RIGHT:  # 如果按下的是右方向键
                    snake.update_direction((1, 0))  # 向右移动
                elif event.key == pygame.K_SPACE:  # 如果按下的是空格键
                    paused = not paused  # 切换暂停状态
                elif event.key == pygame.K_r:  # 如果按下的是 R 键
                    # 清空屏幕，显示为黑屏
                    screen.fill(BG_COLOR)  # 填充黑色背景
                    pygame.display.flip()  # 更新屏幕

                    # 重置游戏状态
                    snake = Snake()  # 创建一条新的蛇
                    food = Food(snake.body)  # 创建新的食物
                    score = 0  # 重置分数
                    game_over = False  # 重置游戏结束状态

                    # 重新显示启动画面
                    show_splash_screen(screen, WIDTH, HEIGHT)  # 显示开机动画

        if paused:  # 如果游戏暂停
            draw_pause_screen(screen, WIDTH, HEIGHT)  # 绘制暂停界面
            pygame.display.flip()  # 更新屏幕
            clock.tick(FPS)  # 控制帧率
            continue  # 跳过本次循环

        # 游戏进行中
        screen.fill(BG_COLOR)  # 填充黑色背景

        if not game_over:  # 如果游戏未结束
            snake.move()  # 蛇移动

            if snake.check_collision():  # 检查是否发生碰撞
                game_over = True  # 游戏结束
            else:
                # 吃食物
                if snake.body[0] == (food.x, food.y):  # 如果蛇头和食物的坐标相同
                    snake.grow = True  # 允许蛇增长
                    score += 10  # 分数增加 10
                    food = Food(snake.body)  # 重新生成食物

            snake.draw(screen)  # 绘制蛇
            food.draw(screen)  # 绘制食物
            draw_grid(screen)  # 绘制网格

            draw_score(screen, score)  # 绘制分数
            pygame.display.flip()  # 更新屏幕
            clock.tick(FPS)  # 控制帧率

        # 游戏结束
        if game_over:  # 如果游戏结束
            draw_game_over_screen(screen, WIDTH, HEIGHT, score)  # 绘制游戏结束界面
            pygame.display.flip()  # 更新屏幕
            if event.type == pygame.KEYDOWN:  #检测是否有按键的事件
                if  event.key == pygame.K_q or event.type == pygame.QUIT: #如果有q或者退出，就退出游戏
                    pygame.quit()
                    sys.exit()


# 运行游戏
if __name__ == "__main__":
    main()  # 调用主函数

main(): 游戏主循环，处理游戏逻辑、事件、绘制等。

最后，我将总的源码写出来：

import pygame
import sys
import random

# 初始化Pygame
pygame.init()

# 屏幕大小
WIDTH, HEIGHT = 720, 540  # 略微增大屏幕
GRID_SIZE = 18  # 相应调整格子大小
GRID_WIDTH = WIDTH // GRID_SIZE
GRID_HEIGHT = HEIGHT // GRID_SIZE

# 颜色定义
BG_COLOR = (0, 0, 0)
SNAKE_COLOR = (48, 214, 75)
FOOD_COLOR = (230, 70, 100)
BORDER_COLOR = (60, 60, 60)
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)  # 添加黑色

# 游戏速度（帧率）
FPS = 10

# 创建屏幕
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption('经典贪吃蛇')

# 蛇类
class Snake:
    def __init__(self):
        self.body = [(GRID_WIDTH // 2, GRID_HEIGHT // 2)]
        self.direction = random.choice([(1, 0), (-1, 0), (0, 1), (0, -1)])
        self.next_direction = self.direction
        self.grow = False

    def update_direction(self, direction):
        if (direction[0] * -1, direction[1] * -1) == self.direction:
            return

        self.next_direction = direction

    def move(self):
        self.direction = self.next_direction
        head = (self.body[0][0] + self.direction[0], self.body[0][1] + self.direction[1])

        self.body.insert(0, head)

        if self.grow:
            self.grow = False
        else:
            self.body.pop()

    def check_collision(self):
        x, y = self.body[0]
        if not (0 <= x < GRID_WIDTH and 0 <= y < GRID_HEIGHT):
            return True

        if self.body[0] in self.body[1:]:
            return True

        return False

    def draw(self, surface):
        for i, (x, y) in enumerate(self.body):
            rect = pygame.Rect(x * GRID_SIZE, y * GRID_SIZE, GRID_SIZE, GRID_SIZE)
            pygame.draw.rect(surface, SNAKE_COLOR, rect)

            # 绘制蛇头
            if i == 0:
                # 眼睛 (两个小黑点)
                eye_offset = GRID_SIZE // 4
                pygame.draw.rect(surface, BLACK, (x * GRID_SIZE + eye_offset, y * GRID_SIZE + eye_offset, 3, 3))
                pygame.draw.rect(surface, BLACK, (x * GRID_SIZE + GRID_SIZE - eye_offset - 3, y * GRID_SIZE + eye_offset, 3, 3))

                # 嘴巴 (一个小白点)
                mouth_offset = GRID_SIZE // 2
                pygame.draw.rect(surface, WHITE, (x * GRID_SIZE + mouth_offset - 1, y * GRID_SIZE + mouth_offset - 1, 3, 3))

# 食物类
class Food:
    def __init__(self, snake_body):
        self.x, self.y = self.generate_random_position(snake_body)
        self.rect = pygame.Rect(self.x * GRID_SIZE, self.y * GRID_SIZE, GRID_SIZE, GRID_SIZE)

    def generate_random_position(self, snake_body):
        while True:
            x = random.randint(0, GRID_WIDTH - 1)
            y = random.randint(0, GRID_HEIGHT - 1)
            if (x, y) not in snake_body:
                return x, y

    def draw(self, surface):
        rect = pygame.Rect(self.x * GRID_SIZE, self.y * GRID_SIZE, GRID_SIZE, GRID_SIZE)
        pygame.draw.rect(surface, FOOD_COLOR, rect)

# 绘制网格
def draw_grid(surface):
    for x in range(GRID_WIDTH):
        pygame.draw.line(surface, BORDER_COLOR, (x * GRID_SIZE, 0), (x * GRID_SIZE, HEIGHT))
    for y in range(GRID_HEIGHT):
        pygame.draw.line(surface, BORDER_COLOR, (0, y * GRID_SIZE), (WIDTH, y * GRID_SIZE))

# 绘制暂停界面
def draw_pause_screen(surface, width, height):
    font = pygame.font.Font(None, 50)
    text = font.render("Paused (Press SPACE to continue)", True, WHITE)
    text_rect = text.get_rect(center=(width // 2, height // 2))
    surface.blit(text, text_rect)

# 绘制游戏结束界面
def draw_game_over_screen(surface, width, height, score):
    font = pygame.font.Font(None, 50)
    text = font.render(f"Game Over! Score: {score}", True, WHITE)
    restart_text = font.render("Press R to restart, Q to quit", True, WHITE)
    text_rect = text.get_rect(center=(width // 2, height // 2 - 30))
    restart_rect = restart_text.get_rect(center=(width // 2, height // 2 + 30))
    surface.blit(text, text_rect)
    surface.blit(restart_text, restart_rect)

# 绘制分数
def draw_score(surface, score):
    font = pygame.font.Font(None, 30)
    text = font.render(f"Score: {score}", True, WHITE)
    surface.blit(text, (10, 10))

def show_splash_screen(surface, width, height):
    """显示开机启动画面"""
    text = "jianghao.work"
    font = pygame.font.Font(None, 50)
    text_surface = font.render(text, True, WHITE)
    text_rect = text_surface.get_rect(center=(width // 2, height // 2))

    # 动画时长（帧数）
    animation_duration = 120

    for i in range(animation_duration):
        # 计算透明度
        alpha = int(255 * abs((animation_duration / 2) - i) / (animation_duration / 2))

        # 创建一个具有透明度的Surface
        splash_surface = pygame.Surface((width, height), pygame.SRCALPHA)
        splash_surface.fill((0, 0, 0, 0))  # 透明背景

        # 渲染文字，设置透明度
        text_surface.set_alpha(alpha)
        splash_surface.blit(text_surface, text_rect)

        # 绘制到主屏幕
        surface.blit(splash_surface, (0, 0))

        # 刷新屏幕
        pygame.display.flip()
        pygame.time.delay(10)

    # 短暂停留
    pygame.time.delay(300)

# 游戏主函数
def main():
    """游戏主循环"""
    show_splash_screen(screen, WIDTH, HEIGHT)  # 显示开机启动画面

    snake = Snake()
    food = Food(snake.body)
    score = 0
    clock = pygame.time.Clock()

    paused = False
    game_over = False

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()

            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_UP:
                    snake.update_direction((0, -1))
                elif event.key == pygame.K_DOWN:
                    snake.update_direction((0, 1))
                elif event.key == pygame.K_LEFT:
                    snake.update_direction((-1, 0))
                elif event.key == pygame.K_RIGHT:
                    snake.update_direction((1, 0))
                elif event.key == pygame.K_SPACE:
                    paused = not paused
                elif event.key == pygame.K_r: # 按 R 重新开始
                    # 清空屏幕，显示为黑屏
                    screen.fill(BG_COLOR)
                    pygame.display.flip()

                    # 重置游戏状态
                    snake = Snake()
                    food = Food(snake.body)
                    score = 0
                    game_over = False

                    # 重新显示启动画面
                    show_splash_screen(screen, WIDTH, HEIGHT)

        if paused:
            draw_pause_screen(screen, WIDTH, HEIGHT)
            pygame.display.flip()
            clock.tick(FPS)
            continue

        # 游戏进行中
        screen.fill(BG_COLOR)

        if not game_over:
            snake.move()

            if snake.check_collision():
                game_over = True
            else:
                # 吃食物
                if snake.body[0] == (food.x, food.y):
                    snake.grow = True
                    score += 10
                    food = Food(snake.body)

            snake.draw(screen)
            food.draw(screen)
            draw_grid(screen)

            draw_score(screen, score)
            pygame.display.flip()
            clock.tick(FPS)

        # 游戏结束
        if game_over:
            draw_game_over_screen(screen, WIDTH, HEIGHT, score)
            pygame.display.flip()
            if event.type == pygame.KEYDOWN:
                if  event.key == pygame.K_q or event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()

# 运行游戏
if __name__ == "__main__":
    main()

使用方法

  • 要安装Python,我安装的是3.11的版本
  • 安装必要的库，其中大部分库在你安装Py的时候已经自己安装了，你现在就要安装Pygame 库就行了，这个是安装的指令，在电脑终端打开，输入指令
pip install pygame
  • 然后将我给的代码ctrl加v到你的Python中，点击Run，再点击Run Module，会提示要你保存，保存一下就可以运行了。下一次想要运行的时候直接点击.py的文件就可以直接进入游戏了。
  • 代码运行后，会弹出一个游戏窗口。
  • 使用键盘上的方向键（上、下、左、右）来控制蛇的移动。
  • 吃掉食物可以增加蛇的长度和分数。
  • 避免撞到墙壁或者自己的身体，否则游戏结束。
  • 按下空格键可以暂停游戏。
  • 在游戏结束界面，按下 Q 键可以退出游戏，按下 R 键，会直接显示开机动画界面

PS：为什么有搞个这个玩的想法呢，是之前24年暑假参加比赛要训练，但是训练太**无聊，就想着搞一个这个来摸鱼，总之摸鱼效果挺好的🤣

Python
暂无评论

发送评论 编辑评论






















|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
（╯‵□′）╯︵┴─┴
￣﹃￣
(/ω＼)
∠( ᐛ 」∠)＿
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ｀)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ(￣∇￣o)
ヾ(´･ ･｀｡)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò｡)
Σ(っ °Д °;)っ
( ,,´･ω･)ﾉ"(´っω･｀｡)
╮(╯▽╰)╭
o(*////▽////*)q
＞﹏＜
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
颜文字
Emoji
小恐龙
花!



上一篇
下一篇