@TOC
亲戚大学生暑假在家没事干？教他用Python写一个简略的贪吃蛇游戏，你想学吗？

贪吃蛇游戏（Snake Game）是一种经典的益智游戏，玩家需求操控蛇的头部移动，吃掉食物，并不断添加蛇的身体。在游戏过程中，蛇不能碰到墙面或本身，否则游戏完毕。本教程将具体介绍如何运用 Python 语言和 Pygame 库编写一个贪吃蛇游戏。
本文分为以下几个部分：

1. 游戏整体规划
2. Pygame 库介绍
3. 根底类和函数
4. 游戏界面和操控
5. 蛇和食物的完成
6. 磕碰检测
7. 游戏循环和得分体系
8. 完整代码及运转

1. 游戏整体规划

贪吃蛇游戏的首要元素包含游戏区域、蛇、食物和得分。游戏区域的巨细能够依据需求调整，蛇和食物的方位也是随机生成的。蛇初始化为一个头，跟着游戏的进行，蛇的身体会不断添加。食物会被蛇吃掉，然后添加蛇的身体长度。当蛇碰到墙面或本身时，游戏完毕。游戏完毕后，能够依据得分对玩家进行排名。

2. Pygame 库介绍

Pygame 是一个基于 Python 的游戏开发库，能够用于创建各种类型的游戏。它供给了丰富的功用，如图形、声响和用户界面等。要运用 Pygame 库，首先需求装置它。在命令行中输入以下命令：

pip install pygame

装置完成后，能够在 Python 代码中导入 Pygame 库：

import pygame

3. 根底类和函数

在编写贪吃蛇游戏时，咱们需求定义一些根底类和函数来完成游戏的各种功用。

1. 初始化 Pygame

def init_pygame():
   pygame.init()  
   screen = pygame.display.set_mode((width, height))  
   pygame.display.set_caption("贪吃蛇游戏")  
   return screen  

2. 生成随机方位

def generate_random_position():
   x = random.randrange(0, width)  
   y = random.randrange(0, height)  
   return x, y  

3. 制作图形

def draw_square(x, y, size):
   pygame.draw.rect(screen, (255, 255, 255), [x, y, size, size])  

4. 制作蛇

def draw_snake(snake_list):
   for x, y in snake_list:  
       pygame.draw.rect(screen, (255, 255, 255), [x, y, head_size, head_size])  

5. 制作食物

def draw_food(x, y):
   pygame.draw.rect(screen, (255, 0, 0), [x, y, head_size, head_size])  

4. 游戏界面和操控

游戏界面首要包含游戏区域和操控按钮。咱们能够运用 Pygame 库供给的 pygame.display.set_mode() 函数来创建游戏窗口，然后运用 pygame.display.set_caption() 函数设置窗口标题。

def create_game_interface():
   screen.fill((0, 0, 0))  
   draw_square(width // 2 - head_size // 2, height - head_size - 10, head_size * 2)  
   draw_square(width // 2 - head_size // 2, height - head_size - 30, head_size * 2)  
   draw_square(width // 2, height - head_size - 30, head_size * 2)  
   pygame.display.set_caption("贪吃蛇游戏")  

贪吃蛇游戏的首要操控按钮有两个：向上移动和向下移动。咱们能够运用 pygame.key.get_pressed() 函数来检测按键状况，然后依据按键状况移动蛇的头部。

def move_snake(direction):
   if direction == "up":  
       snake_y -= head_speed  
   elif direction == "down":  
       snake_y += head_speed  
   elif direction == "left":  
       snake_x -= head_speed  
   elif direction == "right":  
       snake_x += head_speed  

要完成游戏界面和操控，还需求编写一个主循环函数，该函数担任初始化游戏、生成食物、更新蛇的方位和检测磕碰等。以下是一个简略的主循环函数示例：

def game_loop():
   init_pygame()  
   create_game_interface()  
   generate_random_position()  
   draw_snake(snake_list)  
   draw_food(food_x, food_y)  
   clock.tick(30)  
   for event in pygame.event.get():  
       if event.type == pygame.QUIT:  
           pygame.quit()  
           quit()  
       elif event.type == pygame.KEYDOWN:  
           key = event.key  
           if key == pygame.K_UP:  
               move_snake("up")  
           elif key == pygame.K_DOWN:  
               move_snake("down")  
           elif key == pygame.K_LEFT:  
               move_snake("left")  
           elif key == pygame.K_RIGHT:  
               move_snake("right")
   while True:  
       game_loop()  

在游戏循环中，咱们还需求不断检测蛇是否吃到了食物，并更新蛇的长度。此外，还要检测蛇是否碰到了墙面或本身，以保证游戏不会呈现过错。完成这些功用后，一个简略的贪吃蛇游戏就能够运转了。

5. 蛇和食物的完成

贪吃蛇游戏中的蛇和食物都是非常重要的元素。在本节中，咱们将具体介绍如何完成蛇和食物。

1. 蛇的完成

蛇由多个方块组成，通常运用一个列表来存储蛇的身体。初始时，蛇只要一个头。当蛇吃到食物时，身体的长度会添加。咱们能够运用 snake_list 列表来存储蛇的身体，其中每个元素表明蛇的一个方块。

def init_snake():
   snake_list = []    
   snake_head = (width // 2, height // 2)    
   snake_speed = 5    
   return snake_list, snake_head, snake_speed
def add_snake_body(snake_list, snake_head, snake_speed):    
   new_head = (snake_head[0] + snake_speed, snake_head[1])    
   snake_list.append(new_head)    
   return new_head    

2. 食物的完成

食物在游戏中随机生成，玩家需求操控蛇吃掉食物来添加身体。咱们能够运用一个变量 food_x 和 food_y 来存储食物的方位。当蛇吃到食物时，食物消失，并更新蛇的身体长度。

def generate_random_position():
   x = random.randrange(0, width)    
   y = random.randrange(0, height)    
   return x, y
def draw_food(x, y):    
   pygame.draw.rect(screen, (255, 0, 0), (x, y, head_size, head_size))  
def check_collision(snake_head, food_x, food_y):    
   if snake_head[0] == food_x and snake_head[1] == food_y:    
       return True    
   return False
def eat_food(snake_list, food_x, food_y):    
   snake_head = snake_list[-1]    
   if check_collision(snake_head, food_x, food_y):    
       snake_list.pop()    
       food_x, food_y = generate_random_position()    
       return True    
   return False  

要完成蛇和食物，还需求编写一个主函数，该函数担任初始化游戏、生成食物、更新蛇的方位和检测磕碰等。以下是一个简略的主函数示例：

def game_loop():
   init_pygame()    
   create_game_interface()    
   generate_random_position()    
   draw_snake(snake_list)    
   draw_food(food_x, food_y)    
   clock.tick(30)    
   for event in pygame.event.get():    
       if event.type == pygame.QUIT:    
           pygame.quit()    
           quit()    
       elif event.type == pygame.KEYDOWN:    
           key = event.key    
           if key == pygame.K_UP:    
               move_snake("up")    
           elif key == pygame.K_DOWN:    
               move_snake("down")    
           elif key == pygame.K_LEFT:    
               move_snake("left")    
           elif key == pygame.K_RIGHT:    
               move_snake("right")
   while True:    
       game_loop()    

在游戏循环中，咱们还需求不断检测蛇是否吃到了食物，并更新蛇的长度。此外，还要检测蛇是否碰到了墙面或本身，以保证游戏不会呈现过错。完成这些功用后，一个简略的贪吃蛇游戏就能够运转了。

6. 磕碰检测

磕碰检测在游戏开发中非常重要。在贪吃蛇游戏中，咱们需求检测蛇和食物之间的磕碰，以及蛇和游戏鸿沟（墙面）之间的磕碰。

1. 蛇和食物之间的磕碰检测

要检测蛇和食物之间的磕碰，咱们需求比较蛇的头部坐标和食物坐标是否共同。共同表明蛇现已吃到了食物。

def check_collision(snake_head, food_x, food_y):
   if snake_head[0] == food_x and snake_head[1] == food_y:  
       return True  
   return False  

2. 蛇和鸿沟之间的磕碰检测

要检测蛇和鸿沟之间的磕碰，咱们需求比较蛇的身体坐标和游戏鸿沟坐标是否相交。如果相交，说明蛇现已碰到了鸿沟。

def check_boundary_collision(snake_head, width, height):
   if snake_head[0] < 0 or snake_head[0] > width:  
       return True  
   if snake_head[1] < 0 or snake_head[1] > height:  
       return True  
   return False  

在游戏循环中，咱们需求不断进行磕碰检测，以便在蛇吃到食物或碰到鸿沟时做出相应的反响。以下是一个简略的游戏循环示例，包含磕碰检测：

def game_loop():
   init_pygame()  
   create_game_interface()  
   generate_random_position()  
   draw_snake(snake_list)  
   draw_food(food_x, food_y)  
   clock.tick(30)  
   for event in pygame.event.get():  
       if event.type == pygame.QUIT:  
           pygame.quit()  
           quit()  
       elif event.type == pygame.KEYDOWN:  
           key = event.key  
           if key == pygame.K_UP:  
               move_snake("up")  
           elif key == pygame.K_DOWN:  
               move_snake("down")  
           elif key == pygame.K_LEFT:  
               move_snake("left")  
           elif key == pygame.K_RIGHT:  
               move_snake("right")
   while True:  
       check_collision(snake_head, food_x, food_y)  
       if check_collision(snake_head, food_x, food_y):  
           eat_food(snake_list, food_x, food_y)  
       check_boundary_collision(snake_head, width, height)  
       if check_boundary_collision(snake_head, width, height):  
           break
       game_loop()  

通过完成磕碰检测，咱们能够保证游戏正常运转，蛇只能吃掉食物并添加身体，而不会穿过鸿沟或食物。

7. 游戏循环和得分体系

游戏循环是指游戏程序的迭代过程，包含初始化游戏界面、生成游戏元素、更新游戏状况、渲染游戏画面等。得分体系则是依据玩家在游戏中的体现来核算得分，并在游戏界面中显现。
在这里，咱们将介绍一个简略的游戏循环和得分体系，应用于贪吃蛇游戏。

1. 游戏循环

游戏循环是一个无限迭代的过程，直到游戏完毕。在贪吃蛇游戏中，游戏循环包含以下步骤：

1. 初始化游戏界面和资源。
2. 生成游戏元素（蛇和食物）。
3. 更新游戏状况（如蛇的身体方位、方向和长度）。
4. 检测磕碰（蛇和食物、蛇和鸿沟）。
5. 制作游戏画面。
6. 处理用户输入事情。
7. 循环迭代，直到游戏完毕。
   下面是一个简化的游戏循环示例：

def game_loop():
   init_pygame()  
   create_game_interface()  
   generate_random_position()  
   draw_snake(snake_list)  
   draw_food(food_x, food_y)  
   clock.tick(30)  
   while True:  
       for event in pygame.event.get():  
           if event.type == pygame.QUIT:  
               pygame.quit()  
               quit()  
           elif event.type == pygame.KEYDOWN:  
               key = event.key  
               if key == pygame.K_UP:  
                   move_snake("up")  
               elif key == pygame.K_DOWN:  
                   move_snake("down")  
               elif key == pygame.K_LEFT:  
                   move_snake("left")  
               elif key == pygame.K_RIGHT:  
                   move_snake("right")
       check_collision(snake_head, food_x, food_y)  
       if check_collision(snake_head, food_x, food_y):  
           eat_food(snake_list, food_x, food_y)  
       check_boundary_collision(snake_head, width, height)  
       if check_boundary_collision(snake_head, width, height):  
           break
       game_loop()  

2. 得分体系

在贪吃蛇游戏中，得分是依据玩家吃掉的食物数量核算的。每逢蛇吃到一个食物时，得分添加一个食物分数（例如，每个食物分数为 10）。游戏完毕后，显现总得分。
下面是一个简略的得分体系完成：

def eat_food(snake_list, food_x, food_y):
   food_score = 10  
   snake_len = len(snake_list)  
   snake_score = 0  
   for segment in snake_list:  
       if segment[0] == food_x and segment[1] == food_y:  
           snake_score += food_score  
           food_score *= 2  
           snake_len += 1  
           generate_new_position(snake_len)  
           food_x, food_y = generate_random_position()  
   score_board.append(snake_score)  
   food_x, food_y = generate_random_position()  

在游戏完毕时，能够核算总得分并显现在游戏界面上。

def game_over():
   total_score = sum(score_board)  
   print("游戏完毕，你的总得分是：", total_score)  
   pygame.quit()  
   quit()  

通过将游戏循环和得分体系集成到贪吃蛇游戏中，玩家能够欣赏到游戏的完整功用，包含初始化游戏界面、生成游戏元素、更新游戏状况、检测磕碰、制作游戏画面、处理用户输入事情和核算得分。

8. 完整代码及运转

下面是完整的 Python 代码，你能够将这段代码复制到 Python 文件中，然后运转该文件来玩贪吃蛇游戏。

import pygame
import random
# 初始化 Pygame  
pygame.init()
# 设置屏幕  
screen = pygame.display.set_mode((640, 480))
# 设置标题  
pygame.display.set_caption("贪吃蛇游戏")
# 颜色设置  
white = (255, 255, 255)  
red = (200, 0, 0)  
green = (0, 200, 0)  
blue = (0, 0, 200)
# 声明变量  
snake = []  
snake_pos = [200, 200]  
food = []  
score = 0  
direction = "RIGHT"
# 定义函数  
def move_snake(snake, direction):  
   # 移除尾部  
   snake.pop()
   # 判断头部方位  
   if direction == "UP":  
       snake_pos[1] -= 10  
   elif direction == "DOWN":  
       snake_pos[1] += 10  
   elif direction == "LEFT":  
       snake_pos[0] -= 10  
   elif direction == "RIGHT":  
       snake_pos[0] += 10
   # 添加头部  
   snake.append(snake_pos)
def grow_snake(snake):  
   snake.append([])
def change_direction(direction):  
   if direction == "UP" and snake_pos[1] > 0:  
       direction = "DOWN"  
   elif direction == "DOWN" and snake_pos[1] < 470:  
       direction = "UP"  
   elif direction == "LEFT" and snake_pos[0] > 0:  
       direction = "RIGHT"  
   elif direction == "RIGHT" and snake_pos[0] < 639:  
       direction = "LEFT"
   return direction
def check_collision(snake, food):  
   # 查看蛇头是否撞墙  
   if snake[0][0] < 0 or snake[0][0] > 639 or snake[0][1] < 0 or snake[0][1] > 479:  
       return True
   # 查看蛇头是否撞食物  
   if snake[0] == food:  
       return True
   # 查看蛇头是否撞到蛇身  
   for part in snake[1:]:  
       if part == snake[0]:  
           return True
   return False
def score_system(score):  
   score_board = font.render("得分：{}".format(score), True, red)  
   screen.blit(score_board, (20, 30))
# 主循环  
while True:  
   screen.fill(white)
   # 处理事情  
   for event in pygame.event.get():  
       if event.type == pygame.QUIT:  
           pygame.quit()  
           quit()
       elif event.type == pygame.KEYDOWN:  
           if event.key == pygame.K_UP:  
               direction = "UP"  
           elif event.key == pygame.K_DOWN:  
               direction = "DOWN"  
           elif event.key == pygame.K_LEFT:  
               direction = "LEFT"  
           elif event.key == pygame.K_RIGHT:  
               direction = "RIGHT"
   # 移动蛇  
   move_snake(snake, direction)
   # 检测磕碰  
   if check_collision(snake, food):  
       food = []  
       grow_snake(snake)
   # 更新界面  
   score_system(score)  
   draw_snake(snake)  
   draw_food(food)
   pygame.display.flip()  

要运转这个程序，你需求先装置 Pygame 库。运用以下命令装置 Pygame：

pip install pygame

然后，将上述代码保存为一个 Python 文件（例如：snake_game.py）