如何用python做一个贪吃蛇程序？——浔川AI社（免费版）

1 游戏说明:

死亡条件：碰壁、吃自己！

状态：只有吃了食物才会随机生成其中一种状态，分别是：稳如老狗、幸运光滑、衰神附体之一 状态：稳如老狗：相对于上一次速度不变！

状态：幸运光滑：相对于上一次速度变慢！

状态：衰神附体：相对于上一次速度变快！

总体速率对比刚开始是快还是慢，如果是正直代表慢，如果是负值代表快！ 该说的就这么多了！ 加油，快来开启你的欧皇人生吧~

2 代码

import tkinter
import time
import random
from threading import Thread, Event
from tkinter import Canvas
 
 
# 游戏数值统计类
class MyScore(object):
    str_score = "Score:"
    str_buff = '状态:'
    str_random = '总Buff:'
 
    def __init__(self):
        self.game_window = Canvas(root, width=width, height=23, bg='Snow')  # 'Snow'
        self.game_window.place(x=2, y=2)
        self.font_format = ('宋体', 12)
        self.score = -10
        self.buff = 0
        self.var_random = 0
        self.var_buff = '稳如老狗'
        self.sum = 0
 
    # 绘制矩形框
    def show_frame(self):
        self.game_window.create_rectangle(2, 2, 301, 24, tag=("frame",))
        self.game_window.create_rectangle(82, 2, 192, 24, tag=("frame",))
 
    # 增加积分提示
    def show_game_score(self):
        self.score += 10
        self.game_window.create_text(
            10, 13, text=MyScore.str_score + str(self.score), font=self.font_format, anchor=tkinter.W, tag=('score',))
 
    # 随机值显示
    def show_game_random(self):
        self.sum += self.buff
        self.game_window.create_text(
            195, 13, text=MyScore.str_random + '%.3f' % self.sum, font=self.font_format, anchor=tkinter.W,
            tag=('random',))
 
    # 增加状态显示
    def show_game_buff(self):
        if self.buff > 0:
            self.var_buff = '幸运光环'
        elif self.buff < 0:
            self.var_buff = '衰神附体'
        else:
            self.var_buff = '稳如老狗'
        self.game_window.create_text(
            138, 13, text=MyScore.str_buff + self.var_buff, font=self.font_format, tag=('buff',))
 
 
# 游戏界面类
class MyCanvas(object):
    msg_1 = "游戏说明"
    msg_2 = "1.开始\暂停\继续:Enter\Space"
    msg_3 = "2.移动方向:按wasd键"
    msg_end = "GAME OVER"
    msg_stop = "  Press Enter\Space\nto continue the game"
 
    def __init__(self):
        self.game_window = Canvas(root, width=width, height=height, bg='Tan')  # Tan
        self.game_window.place(x=2, y=27)
        self.font_format = ('宋体', 12)
        self.flag = True
 
    # 绘制矩形框
    def show_frame(self):
        self.game_window.create_rectangle(2, 2, width + 1, height + 1)
 
    # 绘制说明文本
    def game_description(self):
        self.game_window.create_rectangle(20, 70, 280, 200, fill='Snow', width=1, tag=('description',))
        self.game_window.create_text(150, 100, text=MyCanvas.msg_1, font=self.font_format, tag=('description',))
        self.game_window.create_text(
            32, 135, text=MyCanvas.msg_2, font=self.font_format, anchor=tkinter.W, tag=('description',))
        self.game_window.create_text(
            32, 170, text=MyCanvas.msg_3, font=self.font_format, anchor=tkinter.W, tag=('description',))
 
    # 游戏结束,说明文字!
    def show_game_over(self):
        self.game_window.create_text(150, 135, text=MyCanvas.msg_end, font=('Arial', 30), tag=("game_over",))
 
    # 游戏暂停,说明文字!
    def show_game_stop(self):
        self.game_window.create_text(
            150, 135, text=MyCanvas.msg_stop, font=('Arial', 22), fill='white', tag=("game_stop",))
 
 
# 食物类
class Food(object):
    def __init__(self):
        self.food = []
        self.x = None
        self.y = None
        self.bg = 'Bisque'
 
    # 生产食物对象
    def produce_food(self):
        # 判定食物的坐标不能在蛇身体
        while True:
            self.x = (random.randint(0, 299) // 10) * 10
            self.y = (random.randint(0, 399) // 10) * 10
            for snake_x, snake_y in snake.node:
                if self.x == snake_x and self.y == snake_y:
                    break
            else:
                self.food.append((self.x, self.y))
                game_window.create_rectangle(self.x, self.y, self.x + 10, self.y + 10, fill=self.bg, tag=("food",))
                break
 
    # 判断食物是否为空
    def is_empty(self):
        if not len(self.food):
            return True
 
    # 删除食物对象 清列表
    def del_food(self):
        if not self.is_empty():
            game_window.delete("food")
            self.food.clear()
 
 
# 蛇类
class Snake(object):
    def __init__(self):
        # 存放节点数据
        self.node = []
        # 控制事件开关,也即是控制游戏开始\暂停\继续
        self.e = Event()
        # 定义蛇头的坐标 游戏窗口的正中间 每个蛇块占10像素的等宽高
        self.head_x = ((width - 10) // 10 // 2) * 10
        self.head_y = ((height - 10) // 10 // 2) * 10
        # 蛇的朝向
        self.direction = 'up'
        # 蛇的间隔时长
        self.t_snake = 0.15
        # 结束游戏的标志 真为判定游戏结束
        self.is_game_over = False
        # 尾结点
        self.end_x = None
        self.end_y = None
 
    # 删除所有对象id,node
    def del_all_id_node(self):
        game_window.delete('snake')
        self.node.clear()
 
    # 判断节点是否为空
    def is_empty(self):
        if not self.count:
            return True
 
    # 未吃到食物的情况:绘制头节node,删除尾节点node,移动id
    def headnode(self):
        # 删除尾部节点
        self.node.pop()
        # 更新头节点
        self.node.insert(0, (self.head_x, self.head_y))
        # 获得尾部对象 find_enclosed 判断在矩形内的对象,如果重叠是无法获得,返回的是元组类型的id对象
        end_id = game_window.find_enclosed(self.end_x - 1, self.end_y - 1, self.end_x + 10 + 1, self.end_y + 10 + 1)[0]
        # 画布方法 coords() 可以将id对象改变位置与大小,目前我们用到改变位置 变到头部位置
        game_window.coords(end_id, self.head_x, self.head_y, self.head_x + 10, self.head_y + 10)
        # 变色处理
        game_window.itemconfig(end_id, fill=bg_snake)
 
    # 增加头部对象同步至列表node,绘制新id
    def add_headnode(self):
        game_window.create_rectangle(
            self.head_x, self.head_y, self.head_x + 10, self.head_y + 10, fill=bg_snake, tag=("snake",))
        # 头部插入新节点
        self.node.insert(0, (self.head_x, self.head_y))
 
    # 判断吃到食物后[删除食物对象,并生成新食物]
    def is_eat_food(self):
        if self.head_x == food.x and self.head_y == food.y:
            # 删除食物对象及id
            food.del_food()
            # 生成食物
            food.produce_food()
            return True
 
    # 更新游戏相关参数显示
    def update_parameters(self):
        # 吃到食物
        # 删除原有积分显示
        my_score.game_window.delete('score')
        # 更新积分显示
        my_score.show_game_score()
        # 删除原有游戏状态显示
        my_score.buff = random.uniform(-0.1, 0.1)
        my_score.game_window.delete('buff')
        # 更新现有游戏状态显示
        my_score.show_game_buff()
        # 删除原有数值显示
        my_score.game_window.delete('random')
        # 更新随机值显示
        my_score.show_game_random()
 
    # 吃到食物后更新速度显示
    def update_t_snake(self):
        # 当buff跟原先速度相加 如果小于0 则降速至肉眼能看到的死亡
        if self.t_snake + my_score.buff <= 0:
            self.t_snake = 0.01
        else:
            self.t_snake += my_score.buff
 
    # 游戏结束
    def game_over(self):
        # 显示结束文字说明
        my_canvas.show_game_over()
        # 要清空蛇对象id,node,清空食物对象
        self.del_all_id_node()
        food.del_food()
 
    # 移动一步的封装
    def one_step(self):
        # 判断是否吃到自己
        if self.is_eat_self():
            self.is_game_over = True
        # 判断吃到食物,不删除尾结点
        if self.is_eat_food():
            # 绘制添加头节点
            self.add_headnode()
            # 更新游戏相关参数显示
            self.update_parameters()
            # 更新游戏下次启动速度
            self.update_t_snake()
        else:
            # 未吃到食物的情况
            # 绘制头节点node,删除尾节点node,移动id,
            self.headnode()
        # 节点总计达到2个及以上要开始做第二位节点变色处理
        if self.count >= 2:
            self.change_colour()
 
    # 节点总计达到2个及以上要开始做第个蛇身位节点变色处理
    def change_colour(self):
        # 获取第二个位置的对象
        second_id = game_window.find_enclosed(
            self.node[1][0] - 1, self.node[1][1] - 1, self.node[1][0] + 10 + 1, self.node[1][1] + 10 + 1)[0]
        # 画布方法 itemconfig() 能够处理尾部id对象的颜色更替
        game_window.itemconfig(second_id, fill=bg_snake_end)
 
    # 出场蛇头增加node
    def make_snake_head(self):
        game_window.create_rectangle(
            self.head_x, self.head_y, self.head_x + 10, self.head_y + 10, fill=bg_snake, tag=('snake',))
        self.node.append((self.head_x, self.head_y))
 
    # 获取节点个数
    @property
    def count(self):
        return len(self.node)
 
    # 判定是否吃到自己
    def is_eat_self(self):
        if self.count >= 2:
            for snake_x, snake_y in self.node[1:]:
                if self.head_x == snake_x and self.head_y == snake_y:
                    return True
 
    # 游戏开始的时候 加载相关显示菜单
    def load_show(self):
        # 增加积分显示
        my_score.show_game_score()
        # 增加状态显示
        my_score.show_game_buff()
        # 随机值显示
        my_score.show_game_random()
        # 游戏说明显示
        my_canvas.game_description()
        # 描边游戏框
        my_canvas.show_frame()
        my_score.show_frame()
 
    # 游戏开始入口
    def start(self):
        while True:
            self.load_show()
            self.run()
            break
 
    def run(self):
        while True:
            # 先等待游戏开始
            self.e.wait()
            # 头节点
            self.head_x, self.head_y = self.node[0][0], self.node[0][1]
            # 尾节点
            self.end_x, self.end_y = self.node[-1][0], self.node[-1][1]
            # 判断方向
            if self.direction == 'up':
                # 越界判定顶部
                if self.head_y - 10 in range(0, height):
                    self.head_y -= 10
                    self.one_step()
                else:
                    self.is_game_over = True
            elif self.direction == 'down':
                # 越界判定底部
                if self.head_y + 10 in range(0, height):
                    self.head_y += 10
                    self.one_step()
                else:
                    self.is_game_over = True
            elif self.direction == 'left':
                # 越界判定左边
                if self.head_x - 10 in range(0, width):
                    self.head_x -= 10
                    self.one_step()
                else:
                    self.is_game_over = True
            else:
                # 越界判定右边
                if self.head_x + 10 in range(0, width):
                    self.head_x += 10
                    self.one_step()
                else:
                    self.is_game_over = True
            # 走完判定是否结束游戏
            if self.is_game_over:
                self.game_over()
                break
            time.sleep(self.t_snake)
 
    # 按键触发的各类事件 判定移动方向的
    def change_direction(self, event):
        if event.char.upper() == 'W':
            self.direction = 'up'
        elif event.char.upper() == 'S':
            self.direction = 'down'
        elif event.char.upper() == 'A':
            self.direction = 'left'
        elif event.char.upper() == 'D':
            self.direction = 'right'
        # 开始游戏\继续\暂停 Enter\Spaca键
        elif event.char.upper() == '\r' or event.char.upper() == ' ':
            # 刚开始游戏 只会运行一次
            if my_canvas.flag:
                # 进入这里代表已经开始游戏了,所以删除显示的游戏说明
                game_window.delete("description")
                # 出场生成食物
                food.produce_food()
                # 出场蛇头绘制
                self.make_snake_head()
                my_canvas.flag = False
            # 控制游戏开始\继续\暂停开关
            if self.e.is_set():
                # 显示游戏暂停信息
                my_canvas.show_game_stop()
                self.e.clear()
            else:
                # 删除游戏暂停信息
                game_window.delete("game_stop")
                self.e.set()
 
        else:
            pass
 
 
if __name__ == '__main__':
    # 定义根(游戏)窗口的基本信息 居中显示
    root = tkinter.Tk()
    root.title('My Snake')
    width_root, height_root = 306, 431  # 300 425
    width_max, height_max = root.maxsize()
    size_center = '%dx%d+%d+%d' % (
        width_root, height_root, (width_max - width_root) / 2, (height_max - height_root) / 2)
    root.geometry(size_center)
    root.resizable(width=False, height=False)
 
    # 画布尺寸 还有游戏的相关尺寸
    width, height = 300, 400
 
    # # 设置蛇颜色参数
    bg_snake = 'Indigo'
    bg_snake_end = 'MediumPurple'
 
    # 初始化画布对象
    my_canvas = MyCanvas()
 
    # 获得画布对象
    game_window = my_canvas.game_window
 
    # 初始化数值对象
    my_score = MyScore()
 
    # 生成蛇类
    snake = Snake()
 
    # 生成食物类
    food = Food()
 
    # 绑定主窗口事件 主要是为了记录键盘的操作
    root.bind('<KeyPress>', snake.change_direction)
 
    # 开始游戏
    t1 = Thread(target=snake.start)
    t1.setDaemon(True)
    t1.start()
 
    # 主窗口循环
    root.mainloop()