貪喫蛇遊戲功能介紹

貪喫蛇的遊戲規則如下：
通過上下左右鍵或者WASD鍵來移動蛇來，讓它喫到食物，每喫到食物，蛇的長度變長，並獲得分數。若蛇碰到遊戲邊際或者自身，則蛇死亡，遊戲結束。

遊戲設計思路

根據遊戲規則，我們需要：
1.初始化遊戲環境。
2.初始化蛇、食物
3.監聽鍵盤動作
4.蛇的運動，喫食物，是否死亡
5.該局遊戲結束，是否還有再玩。
其中的難點在於如何在屏幕上展示蛇的運動，其實我們肉眼所見的蛇的運動並不是真實的，而是在後臺通過刷新蛇的座標而實現的。即可以創建一個蛇的座標列表，每移動一次，則新的座標加入，同時刪除末尾座標，看起來像是蛇的在移動。
一個簡單地設計框圖如下：

代碼實現

'''
my_snake.py
@author HelloWorld!
@time:2019.10.27

'''

import random
import pygame
import sys
from pygame.locals import *


windows_width=800 #遊戲窗口的大小，原點在左上角
windows_height=600

cell_size=20   #snake 的大小，需被窗口長寬整除

#一些顏色定義
white = (255, 255, 255)
black = (0, 0, 0)
gray = (230, 230, 230)
dark_gray = (40, 40, 40)
DARKGreen = (0, 155, 0)
Green = (0, 255, 0)
Red = (255, 0, 0)
blue = (0, 0, 255)
dark_blue =(0,0, 139)

BG_COLOR = (184,224,217)

#貪喫蛇的地圖尺寸
map_width = int(windows_width / cell_size)
map_height = int(windows_height / cell_size)

#蛇的移動速度
snake_speed=5

#方向定義
UP = 1
DOWN = 2
LEFT = 3
RIGHT = 4

#主函數
def main_game():
    pygame.init() #初始化gygame
    screen=pygame.display.set_mode((windows_width,windows_height))
    pygame.display.set_caption("貪喫蛇遊戲")
    snake_speed_clock = pygame.time.Clock()  # 創建Pygame時鐘對象
    screen.fill(white)

    while True:
        run_game(screen,snake_speed_clock) #遊戲主體
        gameover(screen)                #遊戲結束


def run_game(screen,snake_speed_clock):
    #初始化蛇的位置，方向，食物的位置
    start_x=random.randint(3,map_width-8)
    start_y=random.randint(3,map_width-8)
    snake_coords=[{'x':start_x,'y':start_y},{'x':start_x-1,'y':start_y},{'x':start_x-2,'y':start_y}]#初始化snake，也可以用列表的的列表
    direction = RIGHT
    food=get_random_location()

    #循環
    while True:
        for event in pygame.event.get():  #鍵盤事件監聽
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == pygame.KEYDOWN: #按鍵事件
                if (event.key==K_LEFT or event.key==K_a) and direction!=RIGHT:
                    direction=LEFT
                elif (event.key==K_RIGHT or event.key==K_d) and direction!=LEFT:
                    direction=RIGHT
                elif (event.key == K_UP or event.key == K_w) and direction != DOWN:
                    direction = UP
                elif (event.key == K_DOWN or event.key == K_s) and direction != UP:
                    direction = DOWN
                elif event.key == K_ESCAPE:
                    pygame.quit()
                    sys.exit()

        snake_move(direction,snake_coords)  #根據方向，移動蛇

        alive=snake_is_alive(snake_coords)   #判斷蛇的死活
        if not alive:                        #如果掛了，則終止循環，跳出run_game函數，執行gameover
            break
        snake_eat_foods(snake_coords,food)   #沒掛，則看看遲到食物了嗎
        screen.fill(BG_COLOR)                #遊戲背景刷新

        #下面draw，是把蛇食物等畫出來
        draw_snake(screen, snake_coords)
        draw_food(screen,food)
        draw_score(screen, len(snake_coords) - 3)
        # draw_grid(screen)
        pygame.display.flip()

        #控制執行次數
        snake_speed_clock.tick(snake_speed)  # 控制fps


#根據移動方向，更新蛇頭座標
def snake_move(directtion,snake_coords):
    if directtion==UP:
        newHead={'x':snake_coords[0]['x'],'y':snake_coords[0]['y']-1}
    elif directtion==DOWN:
        newHead = {'x': snake_coords[0]['x'], 'y': snake_coords[0]['y'] + 1}
    elif directtion==LEFT:
        newHead = {'x': snake_coords[0]['x']-1, 'y': snake_coords[0]['y'] }
    elif directtion == RIGHT:
        newHead = {'x': snake_coords[0]['x']+1, 'y': snake_coords[0]['y']}
    snake_coords.insert(0,newHead)

def snake_is_alive(snake_coords): #碰壁或者碰到自身就是死了
    alive=True
    if snake_coords[0]['x'] == -1 or snake_coords[0]['x'] == map_width or snake_coords[0]['y'] == -1 or \
			snake_coords[0]['y'] == map_height:
        alive=False
    for snake_body in snake_coords[1:]:
        if snake_coords[0]['x']==snake_body['x'] and snake_coords[0]['y']==snake_body['y']:
            alive=False
    return alive

#座標重合，表示喫到食物了，否則就沒有，則移動，把
def snake_eat_foods(snake_coords,food):
    if snake_coords[0]['x']==food['x'] and snake_coords[0]['y']==food['y']:
        food['x']=random.randint(0, map_width-1)
        food['y']=random.randint(0, map_height-1)
    else:
        del snake_coords[-1]

def get_random_location(): #食物的座標隨機生成
    return {'x':random.randint(0,map_width-1),'y':random.randint(0,map_height-1)}

def draw_snake(screen, snake_coords):
    for coord in snake_coords:
        x=coord['x']*cell_size
        y=coord['y']*cell_size
        segmentRect=pygame.Rect(x,y,cell_size,cell_size)
        pygame.draw.rect(screen,dark_blue,segmentRect)

def draw_food(screen,food):
    x=food['x']*cell_size
    y=food['y']*cell_size

    foodRect=pygame.Rect(x,y,cell_size,cell_size)
    pygame.draw.rect(screen,Red,foodRect)

def draw_grid(screen):
    for x in range(0,windows_width,cell_size):
        pygame.draw.line(screen,gray,(x,0),(x,windows_height))
    for y in range(0,windows_height,cell_size):
        pygame.draw.line(screen,gray,(0,y),(windows_width,y))
def draw_score(screen, score):
    font = pygame.font.SysFont(None, 40)
    score_str = "{:,}".format(score)
    score_image=font.render('Score: '+score_str,True,Green,gray)
    score_rect=score_image.get_rect()

    score_rect.topleft=(windows_width-200,10)
    screen.blit(score_image, score_rect)

def gameover(screen):
    font=pygame.font.SysFont(None, 40)
    tips=font.render('Press Q or ESC to quit; Press anykey to continue',True, (65, 105, 225))
    screen.blit(tips,(80, 300))
    pygame.display.update()
    while True:
        for event in pygame.event.get():
            if event.type==QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE or event.key == K_q:  # 終止程序
                    pygame.quit()
                    sys.exit() # 終止程序
                else:
                    return  # 結束此函數, 重新開始遊戲

if __name__=='__main__':
    main_game()

功能抽象及多彩化設計

上面的實現中，我們採用的面向過程的實現方法，沒有抽象，如果要設計更大的遊戲則是不行的。我們可以採用抽象的方法，讓實現更加條理化，同時邏輯更清晰。
同時，如果讓食物的顏色不同，同時蛇喫到什麼顏色的食物，那麼它身體的一部分就變成相應的顏色，那麼最終蛇會變成一條多彩蛇，想必很有意思。
下面我們結合上述兩點來實現新的功能。代碼如下：

'''
@colorful_snake.py
@author HelloWorld!
@time:2019.10.27
@ class is used to design a snake game
'''
import random
import pygame
from pygame.locals import *
import sys

class Settings():
    def __init__(self):
        self.windows_width=800 #遊戲窗口的大小，原點在左上角
        self.windows_height=600
        self.BG_COLOR = (184,224,217)

        self.cell_size=20   #snake 的大小，需被窗口長寬整除

        self.map_width = int(self.windows_width / self.cell_size)
        self.map_height = int(self.windows_height / self.cell_size)

        self.Green = (0, 255, 0)
        self.Red = (255, 0, 0)
        self.Blue = (0, 0, 255)
        self.orange=(255,128,0)
        self.purple=(128, 0, 255)
        self.black = (0, 0, 0)

        self.white = (255, 255, 255)
        self.dark_blue = (0, 0, 139)
        self.gray = (230, 230, 230)
        #方向
        self.UP = 1
        self.DOWN = 2
        self.LEFT = 3
        self.RIGHT = 4

class Snake():
    def __init__(self,settings):

        self.cell_size=settings.cell_size
        self.snake_coords=[]
        self.direction=settings.RIGHT
        self.snake_speed=5
        self.initialize_snake(settings)

    def initialize_snake(self,settings):
        # [{'x':start_x,'y':start_y},{'x':start_x-1,'y':start_y},{'x':start_x-2,'y':start_y}]#初始化snake，也可以用列表的的列表
        start_x = random.randint(3, settings.map_width - 8)
        start_y = random.randint(3, settings.map_width - 8)
        snake_coords = [{'x': start_x, 'y': start_y,'color':settings.dark_blue}, {'x': start_x - 1, 'y': start_y,'color':settings.dark_blue},
                        {'x': start_x - 2, 'y': start_y,'color':settings.dark_blue}]  # 初始化snake，也可以用列表的的列表
        self.snake_coords=snake_coords

    def snake_move(self,settings):
        if self.direction == settings.UP:
            newHead = {'x': self.snake_coords[0]['x'], 'y': self.snake_coords[0]['y'] - 1,'color':settings.dark_blue}
        elif self.direction == settings.DOWN:
            newHead = {'x': self.snake_coords[0]['x'], 'y': self.snake_coords[0]['y'] + 1,'color':settings.dark_blue}
        elif self.direction == settings.LEFT:
            newHead = {'x': self.snake_coords[0]['x'] - 1, 'y': self.snake_coords[0]['y'],'color':settings.dark_blue}
        elif self.direction == settings.RIGHT:
            newHead = {'x': self.snake_coords[0]['x'] + 1, 'y': self.snake_coords[0]['y'],'color':settings.dark_blue}
        self.snake_coords.insert(0, newHead)


    def snake_is_alive(self,settings):# 碰壁或者碰到自身就是死了
        alive = True
        if self.snake_coords[0]['x'] == -1 or self.snake_coords[0]['x'] == settings.map_width or self.snake_coords[0]['y'] == -1 or \
                self.snake_coords[0]['y'] ==settings.map_height:
            alive = False
        for snake_body in self.snake_coords[1:]:
            if self.snake_coords[0]['x'] == snake_body['x'] and self.snake_coords[0]['y'] == snake_body['y']:
                alive = False
        return alive






class Food():
    def __init__(self,settings):
        self.cell_size=settings.cell_size
        self.color=self.initialize_food(settings)
        self.x= random.randint(0, settings.map_width - 1)
        self.y= random.randint(0, settings.map_height - 1)
    def initialize_food(self,settings):
        colors=[settings.Green,settings.Red,settings.Blue,settings.orange,settings.purple,settings.black]
        color=random.choice(colors)
        return color


class GameFunction():
    def __init__(self,screen):
        self.screen=screen

    def check_event(self,snake,settings):
        for event in pygame.event.get():  #鍵盤事件監聽
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == pygame.KEYDOWN: #按鍵事件
                if (event.key==K_LEFT or event.key==K_a) and snake.direction!=settings.RIGHT:
                    snake.direction=settings.LEFT
                elif (event.key==K_RIGHT or event.key==K_d) and snake.direction!=settings.LEFT:
                    snake.direction=settings.RIGHT
                elif (event.key == K_UP or event.key == K_w) and snake.direction != settings.DOWN:
                    snake.direction = settings.UP
                elif (event.key == K_DOWN or event.key == K_s) and snake.direction != settings.UP:
                    snake.direction = settings.DOWN
                elif event.key == K_ESCAPE:
                    pygame.quit()
                    sys.exit()
    def snake_eat_foods(self,snake,food,settings):
        if snake.snake_coords[0]['x'] == food.x and snake.snake_coords[0]['y'] == food.y:
            snake.snake_coords[0]['color'] = food.color

            food.x = random.randint(0, settings.map_width - 1)
            food.y = random.randint(0, settings.map_height - 1)
            food.color=food.initialize_food(settings)
        else:
            for i in range(len(snake.snake_coords)-1):
                snake.snake_coords[i]['color']=snake.snake_coords[i+1]['color']
            del snake.snake_coords[-1]
    def update(self,snake,food,settings,screen,snake_speed_clock):
        screen.fill(settings.BG_COLOR)  # 遊戲背景刷新

        # 下面draw，是把蛇食物等畫出來
        self.draw_snake(screen, snake)
        self.draw_food(screen, food)
        self.draw_score(screen,snake,settings)
        self.draw_grid(screen,settings)
        pygame.display.flip()
        # 控制執行次數
        snake_speed_clock.tick(snake.snake_speed)  # 控制fps

    def draw_snake(self,screen,snake):
        for coord in snake.snake_coords:
            x = coord['x'] * snake.cell_size
            y = coord['y'] * snake.cell_size
            segmentRect = pygame.Rect(x, y, snake.cell_size, snake.cell_size)
            pygame.draw.rect(screen, coord['color'], segmentRect)

    def draw_food(self,screen, food):
        x = food.x* food.cell_size
        y = food.y * food.cell_size

        foodRect = pygame.Rect(x, y, food.cell_size, food.cell_size)
        pygame.draw.rect(screen, food.color, foodRect)

    def draw_grid(self,screen,settings):
        for x in range(0, settings.windows_width, settings.cell_size):
            pygame.draw.line(screen, settings.gray, (x, 0), (x, settings.windows_height))
        for y in range(0, settings.windows_height,settings.cell_size):
            pygame.draw.line(screen, settings.gray, (0, y), (settings.windows_width, y))

    def draw_score(self,screen, snake,settings):
        score=len(snake.snake_coords)-3
        font = pygame.font.SysFont(None, 40)
        score_str = "{:,}".format(score)
        score_image = font.render('Score: ' + score_str, True, settings.Green, settings.gray)
        score_rect = score_image.get_rect()

        score_rect.topleft = (settings.windows_width - 200, 10)
        screen.blit(score_image, score_rect)

    def gameover(self,screen):
        font = pygame.font.SysFont(None, 40)
        tips = font.render('Press Q or ESC to quit; Press anykey to continue', True, (65, 105, 225))
        screen.blit(tips, (80, 300))
        pygame.display.update()
        while True:
            for event in pygame.event.get():
                if event.type == QUIT:
                    pygame.quit()
                    sys.exit()
                elif event.type == KEYDOWN:
                    if event.key == K_ESCAPE or event.key == K_q:  # 終止程序
                        pygame.quit()
                        sys.exit()  # 終止程序
                    else:
                        return  # 結束此函數, 重新開始遊戲


#主函數
def main_game():
    pygame.init() #初始化gygame
    settings=Settings()
    screen=pygame.display.set_mode((settings.windows_width,settings.windows_height))
    pygame.display.set_caption("貪喫蛇遊戲")
    snake_speed_clock = pygame.time.Clock()  # 創建Pygame時鐘對象
    screen.fill(settings.white)
    gf=GameFunction(screen)

    while True:
        snake = Snake(settings)
        food = Food(settings)
        while True:
            gf.check_event(snake,settings)
            snake.snake_move(settings)
            alive = snake.snake_is_alive(settings)  # 判斷蛇的死活
            if not alive:  # 如果掛了，則終止循環，跳出run_game函數，執行gameover
                break
            gf.snake_eat_foods(snake,food,settings)
            gf.update(snake,food,settings,screen,snake_speed_clock)

        gf.gameover(screen)                #遊戲結束


if __name__=='__main__':
    main_game()

程序效果如下：

總結

1、通過上述的代碼，功能基本實現
2、多彩版的蛇的色彩太鮮豔，看起來太難受了
3、多彩版的在運行中存在不穩定情況，具體原因還沒查看，請大家幫忙指出代碼中的問題。

參考文獻 https://www.cnblogs.com/dengfaheng/p/9241267.html

python+pygame 貪喫蛇遊戲-多彩版

文章目錄

貪喫蛇遊戲功能介紹

遊戲設計思路

代碼實現

功能抽象及多彩化設計

總結

使用c#強大的表達式樹實現對象的深克隆之解決循環引用的問題

free AI online tools All In One

痞子衡嵌入式：恩智浦i.MX RT1xxx系列MCU啓動那些事（12.A）- uSDHC eMMC啓動時間(RT1170)

linux安裝cuda和cudnn

Mellanox網卡開啓SR-IOV

模擬手機設備：使用 Playwright 實現移動端自動化測試

HTML 00 Tutorial

全面系統的AI學習路徑，幫助普通人也能玩轉AI

從零開始：使用 Playwright 腳本錄製實現自動化測試

uni-app實現上拉加載

雨露均沾系列-開啓前端玩票之旅

python+pygame 貪喫蛇遊戲-多彩版

蟻羣算法原理與實現(python)

揹包問題及其優化-python實現

matplotlib畫圖初體驗

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結