实验二 代码 + 贪吃蛇大作战（360°寻路+AI自动蛇）

最新推荐文章于 2024-04-10 20:58:12 发布
最新推荐文章于 2024-04-10 20:58:12 发布
阅读量2.2k 收藏 20
点赞数 3
文章标签： 人工智能 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55969651/article/details/128610208
版权

目录

一、实验目的

二、实验内容

三、实验过程展示

四、实验成果

五、实验代码

一、实验目的

1.实现基本的贪吃蛇的运动操作

2.实现AI蛇的自动运动

3.实现360°全方位运动

4.实现积分，死亡，加速等操作

二、实验内容

  1. 初始化蛇操作
  2. AI蛇路径选择
  3. 碰撞检测
  4. 蛇头方向转换
  5. AI蛇死亡检测，死亡后随机一个区域内生成等值的饼
  6. 超时检测
  7. 蛇运动操作
  8. 游戏封装发

三、实验过程展示

3.1 初始化蛇体操作

初始化操作主要分为游戏全局初始化和蛇体初始化。

本游戏设置1条玩家操作蛇和6条AI自动蛇。首先我们定义Snake类，其中包括游戏开发时需要的所有组件，蛇头、身体、方向、猎捕点集、是否存活等。代码如下：

接下来我们定义全局的饼位置初始化，以及蛇的长度，颜色初始化。这里主要是针对AI蛇的初始化，代码如下：

 

蛇体组件初始化，这里主要是将蛇头的坐标初始化，并使用append函数加入到body中，并且赋值大小为bodysize。同时定义第二个点，有两个用处，第一判断此时蛇头的方向角，第二填充body。

这里要注意，初始化生成蛇的位置不能太靠近游戏的边界，否则会出现刚刚生成就碰撞死亡的现象。其次，我们的蛇身体不是点，是一个圆，所以要考虑到半径的问题，所以在生成的时候要加上半径，否则会导致身体超出边界。

代码如下：

 

3.2 方向判断

AI蛇没有鼠标进行方向指引，所以需要给它一个方向才能进行接下来的路径规划和运动。我编写了JodjePoint()函数来进行方向的选择。

这里的返回值为true和false，主要是反馈当前的方向是否需要变化，false表示需要以及更新direction和rewardList，用新的路径行走，true表示不需要变化，函数主体代码如下：

 

贪吃蛇问题，涉及到饼位置随机变换，AI蛇相对位置不固定等问题，导致地图中没有相对固定的点集，所以无法实时的通过迪杰斯特拉算法求出蛇头和最多的饼之间的最短路径。

所以这里我们采取动态规划思路，简而言之就是“当前最优”。通过广度优先搜索rewardList表，找到蛇头目前和现有的所有的饼中哪一个最近，然后更新hunt猎杀标志位，同时反馈角度和距离到direction中。广度优先搜索的代码如下：

 

这里在编写是会遇到一个问题：如果此时两条蛇均定位到同一个点，遵循游戏规则，如何实现饼的分配和避让

针对这个问题，我们采取实时检测蛇列表snakelist的动态，如果发现不匹配，说明此位置蛇死亡，更新饼rewardPoint列表，重复广度优先搜索操作，

 

这里要时刻记住python中atan函数求出来的角度是当前坐标系下的角度，需要转换为四个象限，分别加90，180，360。设置标志位que和临时标志位q，que的作用就是，放入for循环中返回最短距离点的下标。

在这里我们要注意一个角度的问题，根据网络上贪吃蛇大作战的游戏规则，蛇是无法直接掉头的，也就是说我们要计算一个向左和向右的极限角度，如下如所示，极限旋转角度为20°和340°，所以我们在书写代码的时候要加上判断

 

3.3 路径规划

pathDecision()函数主要是通过调用JudgePoint()函数更新当前的rewardList表格和Snake类中的猎杀目标信息hunt，通过JudgePoint()函数反馈的是否需要更新当前路由，来调用addRecF()函数进行蛇体的前进。

所用到的代码如下，遍历饼列表的核心思想还是广度优先搜索。

 

3.4 死亡检测/碰撞检测

蛇死亡主要分为两种：碰到边界死亡和撞到别的蛇身体死亡，这里我们编写函数aiisDead()来检测蛇是否死亡。

函数体中我们会发现，需要分为两个个检测阶段：

第一：检测是否碰到边界(考虑蛇每个节点是圆形，因此需要减去半径)

第二：检测当蛇列表不匹配时，蛇和列表中所有的蛇的body列表中是否有距离小于10 (蛇节点半径)，这里采用for循环直接暴力求解。

 

3.5 鼠标监听和动作转换

调用pygame中的event()组件中的get()函数，实时反馈当前界面的所有外设动态。

为实现项目特色：用鼠标指引蛇方向，我们调用了event组件中的pos函数，实时反馈鼠标的坐标，将其反馈给Snake类中的方向参数，实现全方位的移动。

同时调用键盘接口函数KEYDOWN实时监听键盘按键，并通过a，b键操纵目标移动的速度，return键复活。

最后调用diplay组件中的update()函数，实现对游戏的刷新。

具体代码如下：

 

3.6 绘画蛇体和饼

绘画蛇体，调用pygame内部的draw组件，参考网络游戏贪吃蛇大作战，我将蛇身体用圆点进行展示，调用组件中的circle()函数。

代码如下：

 

遍历蛇的身体，获取body列表中的坐标。

相似的操作，遍历rewardList中所有的饼，获取饼的坐标进行打印，调用pygame中的draw组件。

代码如下：

 

四、实验成果

4.1运行界面展示

点击运行，正常进入运行界面，如下图所示：

 

4.2 阵亡界面展示

触到边界或者碰到别的蛇的body，导致蛇死亡，界面如下：

 

4.3 封装展示

使用pyinstaller将代码封装成.exe文件，可以更好的方便用户使用，方便后期发布游戏等操作。

如下图：

 

五、实验代码

import random, pygame,sys,math,operator
from pygame.locals import *

pygame.init()
fps=10
Width = 1000
Height= 900
mystep=8
quit=True
clock=pygame.time.Clock()
window=pygame.display.set_mode((Width,Height))
pygame.display.set_caption('THT的贪吃蛇')

size=5
size1=10
size2=20
size3=30
bodysize=16

WHITE     = (255, 255, 255)
BLACK     = (  0,   0,   0)
BLUE      = ( 58,  95, 205)
RED       = (178,  34,  34)
ORANGE    = (255, 165,   0)
PURPLE    = (180,  82, 205)
PINK      = (235, 121, 159)
GREEN     = (102, 205, 170)
DARKGREEN = (  0, 155,   0)
DARKGRAY  = ( 40,  40,  40)
color=[BLUE,ORANGE,PURPLE,PINK,GREEN,DARKGREEN]

class Snake():
    length=0
    direction=0
    live=1
    kill=0
    hunt=0
    huntx=0
    hunty=0
    flage=0
    step=8
    ai=False
    foodtimeflage=0
    color=RED
    body=[]
    food=[]
    def init(self):
        self.length=self.direction=self.kill=self.huntx=self.hunty=self.hunt=self.foodtimeflage=0
        self.hunt=0
        self.step=8
        self.live=1
        self.flage=0
        self.body=[]

snake=Snake()
snake1=Snake()
snake2=Snake()
snake3=Snake()
snake4=Snake()
snake5=Snake()
snake6=Snake()
snakelist=[snake1,snake2,snake3,snake4,snake5,snake6]
rewardNode=[]
snakefood=[[],[],[],[],[],[]]

def init():
    initsnake(snake)
    for i in range(len(snakelist)):
        initsnake(snakelist[i])
        snakelist[i].ai = True
        snakelist[i].hunt = i
        snakelist[i].color=color[i]
        snakelist[i].food.clear()
    rewardNode.clear()
    for food in snakefood:
        food.clear()
    for i in range(6):
        rewardNode.append([random.randint(0,Width-size1),random.randint(0,Height-size1),size1,size1])

def initsnake(Snake):
    Snake.init()
    Snake.body.append([random.randint(10, Width - bodysize * 2), random.randint(10, Height - bodysize * 5), bodysize, bodysize])
    Snake.body.append([Snake.body[0][0], Snake.body[0][1] + bodysize / 2, bodysize, bodysize])
    Snake.body.append([Snake.body[1][0], Snake.body[1][1] + bodysize / 2, bodysize, bodysize])
    if Snake.ai:
        Snake.color = color[snakelist.index(Snake)]
        Snake.hunt=snakelist.index(Snake)

def timeout(Snake):
    Snake.flage=0
    if not Snake.ai:
        Snake.flage=1
    for food in rewardNode:
        dist=round(math.sqrt((Snake.body[0][0]+Snake.body[0][2]//2-food[0]-food[2]//2)*(Snake.body[0][0]+Snake.body[0][2]//2-food[0]-food[2]//2)+(Snake.body[0][1]+Snake.body[0][2]//2-food[1]-food[2]//2)*(Snake.body[0][1]+Snake.body[0][2]//2-food[1]-food[2]//2)))
        if dist<=food[2]//2+Snake.body[0][2]//2:
            if food[2]==size1:
                Snake.flage+=2
            elif food[2]==size2:
                Snake.flage+=3
            size=food[2]
            i=rewardNode.index(food)
            rewardNode[i]=[random.randint(0,Width-size1),random.randint(0,Height-size1),size,size]
    for fo in snakefood:
        for food in fo:
            dist = round(math.sqrt((Snake.body[0][0] + Snake.body[0][2] // 2 - food[0] - food[2] // 2) * (Snake.body[0][0] + Snake.body[0][2] // 2 - food[0] - food[2] // 2) + (Snake.body[0][1] + Snake.body[0][2] // 2 - food[1] - food[2] // 2) * (Snake.body[0][1] + Snake.body[0][2] // 2 - food[1] - food[2] // 2)))
            if  dist<=food[2]//2+Snake.body[0][2]//2:
                    Snake.flage += 1
                    size = food[2]
                    fo.remove(food)
    while Snake.flage:
        addRectF(Snake)
        Snake.flage-=1
    if Snake.ai:
        pathDecide(Snake)

    else:
        Snake.flage=1
    Snake.body.pop()
    snake.foodtimeflage+=1
    if snake.foodtimeflage==180:
        while len(rewardNode)>60:
            del rewardNode[random.randint(0,len(rewardNode)-1)]
        rewardNode.append([random.randint(0,Width-size1),random.randint(0,Height-size1),size1,size1])
        if random.randint(0,5)==3:
            rewardNode.append([random.randint(0, Width - size1), random.randint(0, Height - size1), size2, size2])
        snake.foodtimeflage=0

def aitimeout():
    for lsnake in snakelist:
        aiisDead(lsnake)
        if lsnake.live==0:
            aiDeath(lsnake)
        else:
            timeout(lsnake)

def pathDecide(Snake):
    dist=[]
    direction=Snake.direction
    hx=Snake.body[0][0]
    hy=Snake.body[0][1]
    if judgePoint(Snake):
        for food in rewardNode:
            xx = food[0]
            yy = food[1]
            dis = round(math.sqrt((hx - xx) * (hx - xx) + (hy - yy) * (hy - yy)))
            dist.append(dis)
        smalldist=10000
        smalli=0
        for i in range(len(dist)):
            if dist[i]<smalldist:
                smalldist=dist[i]
                smalli=i
        Snake.hunt=smalli
    Snake.huntx=rewardNode[Snake.hunt][0]
    Snake.hunty=rewardNode[Snake.hunt][1]
    addRectF(Snake)

def judgePoint(Snake):
    que=random.randint(0,len(rewardNode))
    q=que
    if (Snake.body[0][0]<=5 and (Snake.direction>180 or Snake.direction<360)):
        Snake.hunt=random.randint(0,len(rewardNode))
        return False
    elif ((Snake.body[0][1]<=5) and ((Snake.direction>=0 and Snake.direction<90) or (Snake.direction>270 and Snake.direction<=360))):
        Snake.hunt=random.randint(0,len(rewardNode))
        return False
    elif ((Snake.body[0][0]>=Width-5) and (Snake.direction>0 or Snake.direction<180)):
        Snake.hunt=random.randint(0,len(rewardNode))
        return False
    elif ((Snake.body[0][1]>=Height-5) and (Snake.direction>90 or Snake.direction<270)):
        Snake.hunt=random.randint(0,len(rewardNode))
        return False
    dir=[]
    for food in rewardNode:
        huntx=food[0]
        hunty=food[1]
        hx=Snake.body[0][0]
        hy=Snake.body[0][1]
        if huntx >= hx and hy > hunty:
            direction = round(math.atan((huntx - hx) / (hy - hunty)) * 180 / math.pi)
        elif huntx > hx and hunty >= hy:
            direction = round(math.atan((hunty - hy) / (huntx - hx)) * 180 / math.pi) + 90
        elif hx >= huntx and hunty > hy:
            direction = round(math.atan((hx - huntx) / (hunty - hy)) * 180 / math.pi) + 180
        elif hx > huntx and hy >= hunty:
            direction = round(math.atan((hy - hunty) / (hx - huntx)) * 180 / math.pi) + 270
        dist=round(math.sqrt((huntx-hx)*(huntx-hx)+(hunty-hy)*(hunty-hy)))
        dir.append([direction,dist])
    for i in range(len(dir)):
        d=dir[0][1]
        if Snake.direction>=135 and Snake.direction<=180:
            if dir[i][0]>=round(180-Snake.direction+360-45)%360 or dir[i][0]<=round(180-Snake.direction+45+360)%360:
                if d>dir[i][1]:
                    d=dir[i][1]
                    que=i
        elif Snake.direction>=180 and Snake.direction<=225:
            if dir[i][0]>=round(Snake.direction-180+45+360)%360 or dir[i][0]<=round(Snake.direction+45+360-180)%360:
                if d>dir[i][1]:
                    d=dir[i][1]
                    que=i
        else:
            if dir[i][0]>=round(Snake.direction-45+360+180)%360 and dir[i][0]<=round(Snake.direction+45+360+180)%360:
                if d>dir[i][1]:
                    d=dir[i][1]
                    que=i
    x=Snake.body[0][0]-round(200*math.sin(Snake.direction/180*math.pi))
    y=Snake.body[0][1]+round(200*math.cos(Snake.direction/180*math.pi))
    if x<=0:
        x=10
    if y<=0:
        y=10
    if(x>=Width):
        x=980
    if(y>=Height):
        y=780
    for snake in snakelist:
        if snakelist.index(snake)!=snakelist.index(Snake):
            for body in snake.body:
                hx = Snake.body[0][0]
                hy = Snake.body[0][1]
                huntx=body[0]+body[2]
                hunty=body[1]+body[2]
                if huntx >= hx and hy > hunty:
                    direction = round(math.atan((huntx - hx) / (hy - hunty)) * 180 / math.pi)
                elif huntx > hx and hunty >= hy:
                    direction = round(math.atan((hunty - hy) / (huntx - hx)) * 180 / math.pi) + 90
                elif hx >= huntx and hunty > hy:
                    direction = round(math.atan((hx - huntx) / (hunty - hy)) * 180 / math.pi) + 180
                elif hx > huntx and hy >= hunty:
                    direction = round(math.atan((hy - hunty) / (hx - huntx)) * 180 / math.pi) + 270
                if Snake.direction<=20 or Snake.direction>=340:
                    if direction>=round(Snake.direction-20+360)%360 or direction<=round(Snake.direction+20+360)%360:
                        dist=round(math.sqrt((huntx-hx)*(huntx-hx)+(hunty-hy)*(hunty-hy)))
                        if dist<=50:
                            if que==q:
                                if len(rewardNode)>=55:
                                    se=random.randint(0,len(rewardNode)-1)
                                    rewardNode[se]=[random.randint(0,Width-size1),random.randint(0,Height-size1),size1,size1]
                                    que=se
                                else:
                                    rewardNode.append([random.randint(0,Width-size1),random.randint(0,Height-size1),size1,size1])
                                    que=len(rewardNode)-1
                            Snake.hunt=que
                            Snake.direction=round(Snake.direction+150)%360
                            # addRectF(Snake)
                            # del Snake.body[len(Snake.body)-1]
                            # addRectF(Snake)
                            # del Snake.body[len(Snake.body) - 1]
                            return False
                else:
                    if direction>=round(Snake.direction-20+360)%360 and direction<=round(Snake.direction+20+360)%360:
                        dist = round(math.sqrt((huntx - hx) * (huntx - hx) + (hunty - hy) * (hunty - hy)))
                        if dist <= 50:
                            if que == q:
                                if len(rewardNode) >= 55:
                                    se = random.randint(0, len(rewardNode) - 1)
                                    rewardNode[se] = [random.randint(0, Width - size1), random.randint(0, Height - size1),size1, size1]
                                    que = se
                                else:
                                    rewardNode.append([random.randint(0, Width - size1), random.randint(0, Height - size1), size1, size1])
                                    que = len(rewardNode) - 1
                            Snake.hunt = que
                            Snake.direction = round(Snake.direction + 150) % 360
                            # addRectF(Snake)
                            # del Snake.body[len(Snake.body) - 1]
                            # addRectF(Snake)
                            # del Snake.body[len(Snake.body) - 1]
                            return False
    for body in snake.body:
        hx = Snake.body[0][0]
        hy = Snake.body[0][1]
        huntx = body[0] + body[2]
        hunty = body[1] + body[2]
        if huntx >= hx and hy > hunty:
            direction = round(math.atan((huntx - hx) / (hy - hunty)) * 180 / math.pi)
        elif huntx > hx and hunty >= hy:
            direction = round(math.atan((hunty - hy) / (huntx - hx)) * 180 / math.pi) + 90
        elif hx >= huntx and hunty > hy:
            direction = round(math.atan((hx - huntx) / (hunty - hy)) * 180 / math.pi) + 180
        elif hx > huntx and hy >= hunty:
            direction = round(math.atan((hy - hunty) / (hx - huntx)) * 180 / math.pi)
        if Snake.direction <= 45 or Snake.direction >= 315:
            if direction >= round(Snake.direction - 45 + 360) % 360 or direction <= round(Snake.direction + 45 + 360) % 360:
                dist = round(math.sqrt((huntx - hx) * (huntx - hx) + (hunty - hy) * (hunty - hy)))
                if dist <= 50:
                    if que == q:
                        if len(rewardNode) >= 55:
                            se = random.randint(0, len(rewardNode) - 1)
                            rewardNode[se] = [random.randint(0, Width - size1), random.randint(0, Height - size1), size1,size1]
                            que = se
                        else:
                            rewardNode.append([random.randint(0, Width - size1), random.randint(0, Height - size1), size1, size1])
                            que = len(rewardNode) - 1
                    Snake.hunt = que
                    Snake.direction = round(Snake.direction + 150) % 360
                    # addRectF(Snake)
                    # del Snake.body[len(Snake.body) - 1]
                    # addRectF(Snake)
                    # del Snake.body[len(Snake.body) - 1]
                    return False
        else:
            if direction >= round(Snake.direction - 45 + 360) % 360 and direction <= round(Snake.direction + 45 + 360) % 360:
                dist = round(math.sqrt((huntx - hx) * (huntx - hx) + (hunty - hy) * (hunty - hy)))
                if dist <= 50:
                    if que == q:
                        if len(rewardNode) >= 55:
                            se = random.randint(0, len(rewardNode) - 1)
                            rewardNode[se] = [random.randint(0, Width - size1), random.randint(0, Height - size1), size1,size1]
                            que = se
                        else:
                            rewardNode.append([random.randint(0, Width - size1), random.randint(0, Height - size1), size1, size1])
                            que = len(rewardNode) - 1
                    Snake.hunt = que
                    Snake.direction = round(Snake.direction + 150) % 360
                    # addRectF(Snake)
                    # del Snake.body[len(Snake.body) - 1]
                    # addRectF(Snake)
                    # del Snake.body[len(Snake.body) - 1]
                    return False
    if rewardNode[Snake.hunt] ==[]:
        Snake.hunt=random.randint(0,len(rewardNode))
        return False
    return True

def aiisDead(Snake):
    if Snake.body[0][0]<=0 or Snake.body[0][1]<=0 or Snake.body[0][0]>=Width-Snake.body[0][2] or Snake.body[0][1]>=Height-Snake.body[0][2]:
        Snake.live=0
        return True
    for lsnake in snakelist:
        if snakelist.index(lsnake)!=snakelist.index(Snake):
            for body in lsnake.body:
                if math.sqrt(((Snake.body[0][0] + Snake.body[0][2] // 2) - (body[0] + body[2] // 2)) * (
                        (Snake.body[0][0] + Snake.body[0][2] // 2) - (body[0] + body[2] // 2)) + (
                                     (Snake.body[0][1] + Snake.body[0][2] // 2) - (body[1] + body[2] // 2)) * (
                                     (Snake.body[0][1] + Snake.body[0][2] // 2) - (body[1] + body[2] // 2))) <= 10:
                    Snake.live=0
                    return True
    for body in snake.body:
        if math.sqrt(((Snake.body[0][0]+Snake.body[0][2]//2)-(body[0]+body[2]//2))*((Snake.body[0][0]+Snake.body[0][2]//2)-(body[0]+body[2]//2))+((Snake.body[0][1]+Snake.body[0][2]//2)-(body[1]+body[2]//2))*((Snake.body[0][1]+Snake.body[0][2]//2)-(body[1]+body[2]//2)))<=10:
            Snake.live = 0
            snake.kill+=1
            return True
    return False

def isDead(Snake):
    if Snake.body[0][0]<=0 or Snake.body[0][1]<=0 or Snake.body[0][0]>=Width-Snake.body[0][2] or Snake.body[0][1]>=Height-Snake.body[0][2]:
        Snake.live=0
        return True
    for lsnake in snakelist:
        for body in lsnake.body:
            if math.sqrt(((Snake.body[0][0] + Snake.body[0][2] // 2) - (body[0] + body[2] // 2)) * (
                        (Snake.body[0][0] + Snake.body[0][2] // 2) - (body[0] + body[2] // 2)) + (
                                     (Snake.body[0][1] + Snake.body[0][2] // 2) - (body[1] + body[2] // 2)) * (
                                     (Snake.body[0][1] + Snake.body[0][2] // 2) - (body[1] + body[2] // 2))) <= 10:
                Snake.live=0
                return True
    return False

def aiDeath(Snake):
     if Snake.live==0:
        for body in Snake.body:
            x=body[0]
            y=body[1]
            s=body[2]
            Snake.body.pop()
            snakefood[snakelist.index(Snake)].append([x+random.randint(0,5)*10,y+random.randint(0,5)*10,s//2,s//2])
        Snake.body.clear()
        initsnake(Snake)
        Snake.live=1

def addRectF(Snake):
    hx=Snake.body[0][0]
    hy=Snake.body[0][1]
    if Snake.ai:
        huntx=rewardNode[Snake.hunt][0]
        hunty=rewardNode[Snake.hunt][1]
    else:
        huntx=Snake.huntx
        hunty=Snake.hunty
    direction=Snake.direction
    if huntx>=hx and hy>hunty:
        direction=round(math.atan((huntx-hx)/(hy-hunty))*180/math.pi)
    elif huntx>hx and hunty>=hy:
        direction=round(math.atan((hunty-hy)/(huntx-hx))*180/math.pi)+90
    elif hx>=huntx and hunty>hy:
        direction=round(math.atan((hx-huntx)/(hunty-hy))*180/math.pi)+180
    elif hx>huntx and hy>=hunty :
        direction=round(math.atan((hy-hunty)/(hx-huntx))*180/math.pi)+270
    if (Snake.direction-direction+360)%360>=175 and (Snake.direction-direction+360)%360<=185:
        direction+=30
    Snake.direction=direction%360
    Snake.body.insert(0,[Snake.body[0][0]+round(Snake.step*math.sin(Snake.direction/180*math.pi)),Snake.body[0][1]-round(Snake.step*math.cos(Snake.direction/180*math.pi)),Snake.body[0][2],Snake.body[0][2]])

def printsnake(Snake,col):
    for fo in snakefood:
         for food in fo:
             foodsize = food[2]//3
             foodx=int(food[0]+food[2]//2)
             foody=int(food[1]+food[2]//2)
             pos=foodx,foody
             pygame.draw.circle(window, color[snakefood.index(fo)], pos, foodsize, 0)
    for body in Snake.body:
            bodysize=body[2]
            hx=int(body[0]+bodysize//2)
            hy=int(body[1]+bodysize//2)
            pos=hx,hy
            pygame.draw.circle(window, col, pos, bodysize//2,0 )
            pygame.draw.circle(window, BLACK, pos, bodysize//2,1)

def printrewardNode():
    for body in rewardNode:
        bodysize = body[2]
        hx = int(body[0] + bodysize // 2)
        hy = int(body[1] + bodysize // 2)
        pos = hx, hy
        pygame.draw.circle(window, WHITE, pos, bodysize // 2, 0)

def printtext():
    textFont = pygame.font.SysFont("simsunnsimsun", 20)
    textSurface = textFont.render("得分： "+str(len(snake.body)), True, WHITE)
    window.blit(textSurface, (20,30))
    textSurface = textFont.render("击杀： " + str(snake.kill), True, WHITE)
    window.blit(textSurface, (20,60))
    textSurface = textFont.render("排行榜： " , True, WHITE)
    window.blit(textSurface, (700, 5))
    rect=[(720,30),(720,55),(720,80),(720,105),(720,130),(720,155),(720,180)]
    seq=[]
    seq.append([6,len(snake.body)])
    for lsnake in snakelist:
        seq.append([snakelist.index(lsnake),len(lsnake.body)])
    seq.sort(key=operator.itemgetter(1),reverse=True)
    name=['小蓝','小橙','小紫','小粉','小青','小绿','我的']
    for paixu in seq:
        textSurface = textFont.render(str(seq.index(paixu)+1)+'.  '+name[paixu[0]]+'     '+str(paixu[1]), True, WHITE)
        window.blit(textSurface, rect[seq.index(paixu)])



init()
while quit:
    if snake.live==1:
        clock.tick(fps)
        pygame.draw.rect(window, BLACK, (0, 0, Width, Height))
        aitimeout()
        timeout(snake)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                quit = False
            if event.type == MOUSEMOTION:
                snake.huntx, snake.hunty = event.pos
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_a:
                    snake.step = 12
                if event.key == pygame.K_RETURN:
                    snake.live = 1
                if event.key==pygame.K_b:
                    snake.step = 8
        printrewardNode()
        for i in range(len(snakelist)):
            printsnake(snakelist[i], snakelist[i].color)
        printsnake(snake, snake.color)
        isDead(snake)
        printtext()
    else:
        textFont = pygame.font.SysFont("simsunnsimsun", 100)
        textSurface = textFont.render("GAME OVER!!!!", True, WHITE)
        window.blit(textSurface, (200, 300))
        for event in pygame.event.get():
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_RETURN:
                    snake.live = 1
                    init()
            if event.type == pygame.QUIT:
                quit = False
    pygame.display.update()

头脑发热
关注
  • 3
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
贪吃蛇大作战JavaFx版完整源码
silence1772的博客
03-25 1万+
贪吃蛇大作战 Java版项目源码：https://github.com/silence1772/JavaFX-GreedySnake(记得点star啊，收藏一个项目最好的方式是star而不是fork）游戏下载：贪吃蛇大作战.exe                 贪吃蛇大作战.jar游戏截图：几句话：这个游戏是去年写的，用来交数据结构作业的，本来在大一暑假时我就开始写，那时老师还没提具体要求，我就...
C# 贪吃蛇大作战
m0_53550060的博客
07-21 4522
作为一个一款儿时常玩的经典小游戏，贪吃蛇的设计简单，实用和娱乐性高，提玩法早已人尽皆知。为了重温这一小游戏，本组对贪吃蛇进行了复原一级相应的优化，吃的食物，蛇的身体会增加长度，同时，关卡不相同，蛇的移动速度也会不同。...
C语言C++图形库---贪吃蛇大作战【附源码】
kxtxdy的博客
01-07 7925
这一节中，我们来做一款经典小游戏，贪吃蛇。先看看最终效果图 在开始之前，我们把窗体创建好。 创建一个800 * 600的窗体。这一次我们使用默认的原点和坐标轴：原点在窗体左上角，X轴正方向向右，Y轴正方向向下。背景色设置为RGB(164, 225, 202)，最后调用cleardevice函数，使用背景色清空整个窗体。 #include<easyx.h> #include<stdio.h> intmain() { initgraph(800,600...
惊了，用Python写了一个AI贪吃蛇，追着你跑的那种
2401_84009698的博客
04-10 394
else:Wander一段时间问题就出在蛇发现它自己和食物间有路径，就二话不说跑去吃食物了。它没有考虑到，你这一去把食物给吃了后形成的局势(蛇身布局)， 完全就可能让你挂掉。(比如进入了一个自己蛇身围起来的封闭小空间)so，为了能让蛇活得久一些，它还要更高瞻远瞩才行。高瞻远瞩版本我们现在已经有了一个比较低端的版本，而且对问题的认识也稍微深入了一些。现在可以进行一些比较慎密和严谨的分析了。首先，让我们罗列一些问题：(像头脑风暴那样，想到什么就写下来即可)蛇和食物间有路径直接就去吃，不可取。那该怎么办？如果蛇去
【机器视觉案例】(12) 自制AI视觉小游戏--贪吃蛇，附python完整代码
博观而约取，厚积而薄发
03-10 1万+
各位同学好，今天和大家分享一下如何使用 mediapipe+opencv 自制贪吃蛇小游戏。先放张图看效果。 规则：食指指尖控制蛇头，指尖每接触到黄色方块，计数加一，蛇身变长，方块随机切换位置。如果指尖停止移动，或者移动过程中蛇头撞到蛇身，那么游戏结束。点击键盘上的R键重新开始游戏。 游戏进行时： 游戏结束界面： 1. 安装工具包 pip install opencv_python==4.2.0.34 # 安装opencv pip install mediapipe # 安装
snake代码matlab-snakeAI:基于简单的2D蛇游戏的深度学习项目
06-04
蛇代码 matlab 使用 Matlab r2019b 创建的 2D Snake AI 该项目创建了一条由神经网络强化学习算法训练的蛇。 在这个游戏中，蛇试图在不触及盒子边界的情况下吃掉尽可能多的食物。 神经网络有十六个输入神经元和四个输出神经元。 蛇在任何给定时间看 8 个方向：（北、东北、东、东南、南、西南、西和西北）。 如果适用于任何给定方向，输入是到食物、墙壁和自我的距离。 在训练算法时，进度图将显示训练的有效性。 蛇的模拟也显示在图形中，以帮助可视化神经网络在训练时“思考”的内容。 入门 以下是一些有用的提示，可帮助您快速启动项目。 先决条件 除了一些工具箱外，您还需要最新版本的 Matlab Matlab r2019b, Deep Learning, Reinforcement learning toolboxes: 启动 Matlab 将文件加载到matlab中，并确保它们都在工作目录中 如果您想训练自己的网络，请保持代码不变。 如果没有，请在第 69 行将 doTraining 设置为 false。这将加载一个预训练的代理进行模拟。 doTraining = false
QTC++贪吃蛇大作战
07-22
QT，C++，不是传统贪吃蛇，简易贪吃蛇大作战游戏，鼠标控制方向三百六十度旋转，有ai蛇，可以寻找吃的自动躲避。
Python 实现 贪吃蛇大作战 代码分享
12-24
这个游戏就是现在iOS免费榜排名第一的《贪吃蛇大作战》。一个简单到不行的游戏，也不知道怎么就火了。反正一款游戏火了，各路媒体、专家总能说出种种套路来，所以我就不发表意见了。不过这实在是一个挺好实现的游戏...
高分项目，基于Unity3D开发实现的贪吃蛇大作战LastSnake，内含完整源码+资源+apk
最新发布
06-12
高分项目，基于Unity3D开发实现的贪吃蛇大作战LastSnake，内含完整源码+资源+apk 贪吃蛇大作战是一款超好玩的休闲竞技游戏,不仅比拼手速,更考验你的策略!在贪吃蛇大作战的世界中,每个人在初始都化身为一条小蛇,通过...
贪吃蛇大作战-嵌入式大作业+源代码+文档说明
12-17
贪吃蛇大作战-嵌入式大作业+源代码+文档说明 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的课程设计，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ ## ...
贪吃蛇大作战demo实现和代码
11-23
基于cocos2dx 和c++实现的类似贪吃蛇大作战的游戏demo
python实现贪吃蛇大作战
03-06
python实现贪吃蛇大作战
贪吃蛇大作战小游戏 （python）源代码
12-01
贪吃蛇大作战python源代码 自己做的单人吃水果的小游戏只做了雏形不过还是可以玩玩的。
自动寻路贪吃蛇,A星算法
11-28
全自动贪吃蛇，食物会逃跑，蛇会追踪食物，编译环境VC++6.0。
贪吃蛇大作战unity3d版_unity3d_unity3d_3d贪吃蛇unity_贪吃蛇大作战_源码
10-04
贪吃蛇大作战的复刻单机版，含打包apk，适合新手学习，
AI贪吃蛇（ JAVA版）+A*寻路算法
weixin_44826485的博客
06-02 2569
代码目标： 有一条AI蛇，可以自己寻路，吃食物，并且符合基本规则，上下键控制蛇的速度 代码结构 首先，我们需要创建5个类 1，Test.class 这个是用来创建窗口的，就是我们看到的画面 2,SnakePan.class（主要） 这个是用来画我们所看到的所有的图画。比如说蛇头，蛇身，食物… 3,.Node.class 是一个抽象类，下面的蛇和食物都是他的子类 4,Snake.class（主要） ...
Processing 自动贪吃蛇脚本
dhj_tsukuba的博客
06-12 2047
スマートインフォメディアシステム特論 期末课题 用Processing写贪吃蛇脚本，有手动和自动两种模式，程序开始直接手动控制，GG一次后可以选择RESTART重新开始，或者AI MODE进入自动模式。其中AI MODE模式有两种报酬计算方法，或者两种距离算法，distance_type=1 表示曼哈顿距离， distance_type=2 表示欧拉距离。具体代码直接贴出来，放到Processing 2.XX 里应该是可以直接运行的。 int game_pause = -1; int snake_le
LUAT游戏第一弹---贪吃蛇
qq_29536545的博客
07-23 1173
文章目录前言准备工作硬件准备软件准备开始制作游戏制作 前言 开个新系列，基于LUAT制作小游戏 准备工作 硬件准备 1，准备724,724等能运行luat的开发版 2，矩阵键盘 软件准备 首先呢，准备几个需要用到的图片，例如这样的 开始制作 游戏制作 好了，图片准备完了，开始做吧，我使用的是ST7899的LCD做的，1.54寸屏幕上分辨率 240*240，画面细腻有弹性 所以最先准备的是LCD驱动，直接使用 有屏幕了，还需要按键呀，矩阵按键走起 module(..., package.seeall)
Python贪吃蛇 (完整代码+详细注释+粘贴即食）
热门推荐
weixin_45662804的博客
01-24 10万+
代码 #!/usr/bin/env python # -*- coding: utf-8 -*- # author：Wangdali time:2021年1月24日16:08:44 #python实现：贪吃蛇 ''' 游戏玩法：回车开始游戏；空格暂停游戏/继续游戏；方向键/wsad控制小蛇走向 ''' ''' 思路：用列表存储蛇的身体；用浅色表示身体，深色背景将身体凸显出来； 蛇的移动：仔细观察，是：身体除头和尾不动、尾部消失，头部增加，所以，新添加的元素放在列表头部、删除尾部元素； 游戏结束判定策略：超出
贪吃蛇大作战游戏代码
03-16
贪吃蛇大作战是一款经典的多人在线游戏，玩家通过控制一条蛇来吃食物并成长，同时也要避免与其他玩家的蛇相撞。以下是一个简单的贪吃蛇大作战游戏的代码示例： ```python import pygame import random # 游戏窗口...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值