精华内容
下载资源
问答
  • /usr/bin/env pythonimport pygame,sys,time,randomfrom pygame.locals import *# 定义颜色变量redColour = pygame.Color(255,0,0)blackColour = pygame.Color(0,0,0)whiteColour = pygame.Color(255,255,255)...

    #!/usr/bin/env python

    import pygame,sys,time,random

    from pygame.locals import *

    # 定义颜色变量

    redColour = pygame.Color(255,0,0)

    blackColour = pygame.Color(0,0,0)

    whiteColour = pygame.Color(255,255,255)

    greyColour = pygame.Color(150,150,150)

    # 定义gameOver函数

    def gameOver(playSurface):

    gameOverFont = pygame.font.Font('arial.ttf',72)

    gameOverSurf = gameOverFont.render('Game Over', True, greyColour)

    gameOverRect = gameOverSurf.get_rect()

    gameOverRect.midtop = (320, 10)

    playSurface.blit(gameOverSurf, gameOverRect)

    pygame.display.flip()

    time.sleep(5)

    pygame.quit()

    sys.exit()

    # 定义main函数

    def main():

    # 初始化pygame

    pygame.init()

    fpsClock = pygame.time.Clock()

    # 创建pygame显示层

    playSurface = pygame.display.set_mode((640,480))

    pygame.display.set_caption('Raspberry Snake')

    # 初始化变量

    snakePosition = [100,100]

    snakeSegments = [[100,100],[80,100],[60,100]]

    raspberryPosition = [300,300]

    raspberrySpawned = 1

    direction = 'right'

    changeDirection = direction

    while True:

    # 检测例如按键等pygame事件

    for event in pygame.event.get():

    if event.type == QUIT:

    pygame.quit()

    sys.exit()

    elif event.type == KEYDOWN:

    # 判断键盘事件

    if event.key == K_RIGHT or event.key == ord('d'):

    changeDirection = 'right'

    if event.key == K_LEFT or event.key == ord('a'):

    changeDirection = 'left'

    if event.key == K_UP or event.key == ord('w'):

    changeDirection = 'up'

    if event.key == K_DOWN or event.key == ord('s'):

    changeDirection = 'down'

    if event.key == K_ESCAPE:

    pygame.event.post(pygame.event.Event(QUIT))

    # 判断是否输入了反方向

    if changeDirection == 'right' and not direction == 'left':

    direction = changeDirection

    if changeDirection == 'left' and not direction == 'right':

    direction = changeDirection

    if changeDirection == 'up' and not direction == 'down':

    direction = changeDirection

    if changeDirection == 'down' and not direction == 'up':

    direction = changeDirection

    # 根据方向移动蛇头的坐标

    if direction == 'right':

    snakePosition[0] += 20

    if direction == 'left':

    snakePosition[0] -= 20

    if direction == 'up':

    snakePosition[1] -= 20

    if direction == 'down':

    snakePosition[1] += 20

    # 增加蛇的长度

    snakeSegments.insert(0,list(snakePosition))

    # 判断是否吃掉了树莓

    if snakePosition[0] == raspberryPosition[0] and snakePosition[1] == raspberryPosition[1]:

    raspberrySpawned = 0

    else:

    snakeSegments.pop()

    # 如果吃掉树莓,则重新生成树莓

    if raspberrySpawned == 0:

    x = random.randrange(1,32)

    y = random.randrange(1,24)

    raspberryPosition = [int(x*20),int(y*20)]

    raspberrySpawned = 1

    # 绘制pygame显示层

    playSurface.fill(blackColour)

    for position in snakeSegments:

    pygame.draw.rect(playSurface,whiteColour,Rect(position[0],position[1],20,20))

    pygame.draw.rect(playSurface,redColour,Rect(raspberryPosition[0], raspberryPosition[1],20,20))

    # 刷新pygame显示层

    pygame.display.flip()

    # 判断是否死亡

    if snakePosition[0] > 620 or snakePosition[0] < 0:

    gameOver(playSurface)

    if snakePosition[1] > 460 or snakePosition[1] < 0:

    for snakeBody in snakeSegments[1:]:

    if snakePosition[0] == snakeBody[0] and snakePosition[1] == snakeBody[1]:

    gameOver(playSurface)

    # 控制游戏速度

    fpsClock.tick(5)

    if __name__ == "__main__":

    main()

    4adb9255ada5b97061e610b682b8636764fe50ed.png

    如果说,程序不可用或者出错,那就是因为软件的不同,请谅解!

    046d7c4b0d803e8ae4d4a14fe43295f9e8f66d2a.jpg

    f90c8a6c4e117087f0864af7b3d5abdacba9a8a5.jpg

    c433aed125579cf983cdb9a5cf0394ec78d2a04f.jpg

    展开全文
  • ”个人认为,python与其他编程语言相比,亮点在于它有丰富的第三方库。比如用python做爬虫,原生库urllib2和第三方库requests相比,哪个效率更高?二、推荐pygame顾名思义,python和game相结合,专注于2D游戏开发。...

    一、前言

    看了提问者在另一个回答的评论

    />真的觉得提问者应该试试pygame。"工欲善其事,必先利其器。”个人认为,python与其他编程语言相比,亮点在于它有丰富的第三方库。比如用python做爬虫,原生库urllib2和第三方库requests相比,哪个效率更高?

    二、推荐

    pygame顾名思义,python和game相结合,专注于2D游戏开发。pygame很容易入门。网上有一些不错的教程,在此推荐我的入门教程:-Daydayblog-第1页(貌似博客不见了?——2016.10.15)

    博客提供了16个章节:

    pygame游戏编程(1)--pygame简介及安装

    pygame游戏编程(2)--第一个pygame程序

    pygame游戏编程(3)--文本打印及字体

    pygame游戏编程(4)--像素、颜色和图像

    pygame游戏编程(5)--surface对象

    pygame游戏编程(6)--窗口显示

    pygame游戏编程(7)--绘制几何图像

    pygame游戏编程(8)--event事件

    pygame游戏编程(9)--动画之直线运动

    pygame游戏编程(10)--动画之向量

    pygame游戏编程(11)--人机交互

    pygame游戏编程(12)--人工智能

    pygame游戏编程(13)--声音

    pygame游戏编程(14)--音乐播放器

    pygame游戏编程(15)--贪吃蛇游戏

    三、贪吃蛇

    没错,博客作者提供了如何使用pygame开发贪吃蛇的教程,详见pygame游戏编程(16)--贪吃蛇游戏-pygame教程-Daydayblog,作者程序运行界面如下: />

    贪吃蛇主要包括以下几个方面:物体表示:蛇和苹果如何存储和显示、蛇如何移动和吃苹果变长;

    字体显示:提示玩家该如何操作,显示玩家的分数;

    人机交互:使用键盘的方向键来控制蛇的移动;

    矩形绘图:绘制各种基本的图形来组成图像。

    使用pygame开发贪吃蛇,您只需要先学会:

    pygame简介及安装

    surface对象

    窗口显示

    绘制几何图形

    event事件

    人机交互

    四、成果

    pygame开发2D游戏简直不能太简单,我粗略看了教程之后,就自主完成两个游戏开发:

    1、贪吃蛇

    /> /> />

    附上本人贪吃蛇游戏代码(很多细节没处理好,勿喷。)

    #!/usr/bin/env python

    # -*- coding: utf-8 -*-

    import sys,pygame,random

    from pygame.locals import *

    windowWidth=600

    windowHeight=600

    cellSize=20

    head = 0

    def main():

    #初始化

    pygame.init()

    global screen

    screen=pygame.display.set_mode((windowWidth,windowHeight))

    pygame.display.set_caption("Greedy Snake")

    gameStart()

    FPS=pygame.time.Clock()

    startX=cellSize*random.randint(8,windowWidth/cellSize-8)

    startY=cellSize*random.randint(8,windowHeight/cellSize-8)

    snake=[{'x': startX , 'y': startY},

    {'x': startX - 1 * cellSize, 'y': startY},

    {'x': startX - 2 * cellSize, 'y': startY},

    {'x': startX - 3 * cellSize, 'y': startY}]

    appleX = cellSize * random.randint(0, windowWidth / cellSize)

    appleY = cellSize * random.randint(0, windowHeight / cellSize)

    while True:

    FPS.tick(15)

    for event in pygame.event.get():

    if event.type==QUIT:

    pygame.quit()

    sys.exit()

    if event.type==KEYDOWN:

    turn(snake,event)

    move(snake)

    if snake[head]['x']==appleX and snake[head]['y']==appleY:

    appleX = cellSize * random.randint(0, windowWidth / cellSize)

    appleY = cellSize * random.randint(0, windowHeight / cellSize)

    eat(snake)

    if snake[head]['x']<0 or snake[head]['x']>windowWidth or snake[head]['y']<0 or snake[head]['y']>windowHeight:

    gameOver(snake)

    for body in snake[1:]:

    if body==snake[head]:

    gameOver(snake)

    screen.fill((0, 150, 0))

    drawgrid()

    drawSnake(snake)

    pygame.draw.rect(screen, (255, 0, 0), (appleX, appleY, cellSize, cellSize))

    pygame.display.update()

    #绘制网格

    def drawgrid():

    for i in xrange(cellSize,windowWidth,cellSize):

    pygame.draw.line(screen,(0,255,0),(i,0),(i,windowHeight),1)

    for j in xrange(cellSize,windowHeight,cellSize):

    pygame.draw.line(screen,(0,255,0),(0,j),(windowWidth,j),1)

    #绘制蛇

    def drawSnake(snake):

    for cood in snake:

    pygame.draw.rect(screen,(150,150,0),(cood['x'],cood['y'],cellSize,cellSize))

    pygame.draw.rect(screen, (250, 250, 0), (snake[head]['x'], snake[head]['y'], cellSize, cellSize))

    def turn(snake,event):

    # 上下转向

    if snake[head]['y'] == snake[1]['y']:

    if event.key == K_UP:

    del snake[-1]

    newHead = {'x': snake[head]['x'], 'y': snake[head]['y'] - cellSize}

    snake.insert(0, newHead)

    elif event.key == K_DOWN:

    del snake[-1]

    newHead = {'x': snake[head]['x'], 'y': snake[head]['y'] + cellSize}

    snake.insert(0, newHead)

    # 左右转向

    if snake[head]['x'] == snake[1]['x']:

    if event.key == K_LEFT:

    del snake[-1]

    newHead = {'x': snake[head]['x'] - cellSize, 'y': snake[head]['y']}

    snake.insert(0, newHead)

    if event.key == K_RIGHT:

    del snake[-1]

    newHead = {'x': snake[head]['x'] + cellSize, 'y': snake[head]['y']}

    snake.insert(0, newHead)

    def move(snake):

    # 向左运动

    if snake[head]['x'] < snake[1]['x']:

    del snake[-1]

    newHead = {'x': snake[head]['x'] - cellSize, 'y': snake[head]['y']}

    snake.insert(0, newHead)

    # 向右运动

    elif snake[head]['x'] > snake[1]['x']:

    del snake[-1]

    newHead = {'x': snake[head]['x'] + cellSize, 'y': snake[head]['y']}

    snake.insert(0, newHead)

    # 向上运动

    elif snake[head]['y'] < snake[1]['y']:

    del snake[-1]

    newHead = {'x': snake[head]['x'], 'y': snake[head]['y'] - cellSize}

    snake.insert(0, newHead)

    # 向下运动

    elif snake[head]['y'] > snake[1]['y']:

    del snake[-1]

    newHead = {'x': snake[head]['x'], 'y': snake[head]['y'] + cellSize}

    snake.insert(0, newHead)

    def eat(snake):

    # 向左运动

    if snake[head]['x'] < snake[1]['x']:

    newHead = {'x': snake[head]['x'] - cellSize, 'y': snake[head]['y']}

    snake.insert(0, newHead)

    # 向右运动

    elif snake[head]['x'] > snake[1]['x']:

    newHead = {'x': snake[head]['x'] + cellSize, 'y': snake[head]['y']}

    snake.insert(0, newHead)

    # 向上运动

    elif snake[head]['y'] < snake[1]['y']:

    newHead = {'x': snake[head]['x'], 'y': snake[head]['y'] - cellSize}

    snake.insert(0, newHead)

    # 向下运动

    elif snake[head]['y'] > snake[1]['y']:

    newHead = {'x': snake[head]['x'], 'y': snake[head]['y'] + cellSize}

    snake.insert(0, newHead)

    def gameStart():

    screen.fill((0, 150, 0))

    drawgrid()

    fontObj1 = pygame.font.Font('freesansbold.ttf', 60)

    textSurfaceObj1 = fontObj1.render('Greedy Snake', True, (255,255,255))

    textRectObj1 = textSurfaceObj1.get_rect()

    textRectObj1.center = (windowWidth/2, windowHeight/3)

    screen.blit(textSurfaceObj1,textRectObj1)

    fontObj2 =pygame.font.Font('freesansbold.ttf', 30)

    textSurfaceObj2 = fontObj2.render('Devloper: JIE ', True,(0, 0, 0))

    textRectObj2 = textSurfaceObj2.get_rect()

    textRectObj2.center = (windowWidth/2, windowHeight*2/3)

    screen.blit(textSurfaceObj2,textRectObj2)

    pygame.display.update()

    flag=True

    while(flag):

    for event in pygame.event.get():

    if event.type==QUIT:

    pygame.quit()

    sys.exit()

    if event.type==KEYDOWN:

    if event.key==K_SPACE:

    flag=False

    def gameOver(snake):

    screen.fill((0, 150, 0))

    drawgrid()

    fontObj = pygame.font.Font('freesansbold.ttf', 60)

    textSurfaceObj1 = fontObj.render('Game over!', True, (255,0,0))

    textRectObj1 = textSurfaceObj1.get_rect()

    textRectObj1.center = (windowWidth/3, windowHeight/3)

    screen.blit(textSurfaceObj1,textRectObj1)

    textSurfaceObj2 = fontObj.render('Score: %s' % (len(snake)-4), True, (255, 0, 0))

    textRectObj2 = textSurfaceObj2.get_rect()

    textRectObj2.center = (windowWidth*2/3, windowHeight*2/3)

    screen.blit(textSurfaceObj2,textRectObj2)

    pygame.display.update()

    while(True):

    for event in pygame.event.get():

    if event.type==QUIT:

    pygame.quit()

    sys.exit()

    if __name__ == '__main__':

    main()

    2、打飞机

    /> /> />附上本人打飞机游戏代码(很多细节没处理好,勿喷。)

    #!/usr/bin/env python

    # -*- coding: utf-8 -*-

    import sys,pygame,random

    from pygame.locals import *

    windowWidth=420

    windowHeight=600

    cellSize=20

    shots=[]#飞行的子弹

    enemys=[]#飞行的敌机

    def main():

    #初始化

    global shoted

    shoted= 0

    global enemyed

    enemyed = 0

    pygame.init()

    pygame.key.set_repeat(10) #重复响应一个按键

    global screen,guard

    screen=pygame.display.set_mode((windowWidth,windowHeight))

    pygame.display.set_caption("aircraft")

    gamestart()

    FPS=pygame.time.Clock()

    guard=[{'x':windowWidth/2-cellSize/2,'y':windowHeight-cellSize},#中0

    {'x':windowWidth/2-cellSize/2,'y':windowHeight-2*cellSize},#上1

    {'x': windowWidth / 2-cellSize*3/2, 'y': windowHeight - cellSize},#左2

    {'x': windowWidth / 2+cellSize/2, 'y': windowHeight - cellSize}]#右3

    while True:

    screen.fill((0, 0, 0))

    FPS.tick(5)

    gamemedium()

    for event in pygame.event.get():

    if event.type==QUIT:

    pygame.quit()

    sys.exit()

    if event.type==KEYDOWN:

    #飞机左移

    if event.key==K_LEFT and guard[2]['x']>-1:

    for body in guard:

    body['x']-=cellSize

    #飞机右移

    if event.key == K_RIGHT and guard[3]['x'] < windowWidth:

    for body in guard:

    body['x'] += cellSize

    #发射子弹

    if event.key==K_UP:

    shoted+=1

    shot={'x':guard[1]['x'],'y':guard[1]['y']}

    shots.insert(0,shot)

    #子弹飞行

    if shots != [] :

    for s in shots:

    s['y']-=2*cellSize

    flag=True

    while(flag and shots!=[]):

    flag=False

    if shots[-1]['y']<0:

    del shots[-1]

    flag=True

    #产生敌机

    if random.randint(0,1)==0:

    newenemy={'x':cellSize*random.randint(0,windowWidth/cellSize-1),'y':0}

    enemys.insert(0,newenemy)

    if enemys!=[]:

    for enemy in enemys:

    enemy['y'] += 0.5*cellSize #敌机飞行速度

    drawenemys()

    delshots=[]

    delenemys=[]

    for i in xrange(len(shots)):

    for j in xrange(len(enemys)):

    if len(shots) != [] and len(enemys) != []:

    if shots[i]['x']==enemys[j]['x'] and shots[i]['y']

    delshots.insert(0,i)

    delenemys.insert(0,j)

    for i in delshots:

    del shots[i]

    for j in delenemys:

    del enemys[j]

    enemyed+=1

    if len(enemys)!=0:

    if enemys[len(enemys)-1]['y']>windowHeight-cellSize:

    gameover()

    drawshots()

    #drawgrid()

    drawguard()

    pygame.display.update()

    #绘制网格

    def drawgrid():

    for i in xrange(cellSize,windowWidth,cellSize):

    pygame.draw.line(screen,(255,255,255),(i,0),(i,windowHeight),1)

    for j in xrange(cellSize,windowHeight,cellSize):

    pygame.draw.line(screen,(255,255,255),(0,j),(windowWidth,j),1)

    #绘制自己的战机

    def drawguard():

    for body in guard:

    pygame.draw.rect(screen, (255, 255, 255), (body['x'], body['y'], cellSize, cellSize))

    #绘制子弹

    def drawshots():

    for s in shots:

    pygame.draw.rect(screen, (255, 255, 255), (s['x']+cellSize/3, s['y']+cellSize/4, cellSize / 3, cellSize/2))

    #绘制敌机

    def drawenemys():

    for e in enemys:

    pygame.draw.rect(screen, (255, 255, 255), (e['x'], e['y'], cellSize, cellSize/2))

    pygame.draw.rect(screen, (255, 255, 255), (e['x']+cellSize/4, e['y']+cellSize/2, cellSize/2, cellSize / 2))

    #游戏开始界面

    def gamestart():

    #drawgrid()

    fontObj1 = pygame.font.Font('freesansbold.ttf', 60)

    textSurfaceObj1 = fontObj1.render('Aircraft', True, (255,255,255))

    textRectObj1 = textSurfaceObj1.get_rect()

    textRectObj1.center = (windowWidth/2, windowHeight/3)

    screen.blit(textSurfaceObj1,textRectObj1)

    fontObj2 =pygame.font.Font('freesansbold.ttf', 30)

    textSurfaceObj2 = fontObj2.render('Developer : JIE', True,(255, 255, 255))

    textRectObj2 = textSurfaceObj2.get_rect()

    textRectObj2.center = (windowWidth/2, windowHeight*2/3)

    screen.blit(textSurfaceObj2,textRectObj2)

    pygame.display.update()

    flag=True

    while(flag):

    for event in pygame.event.get():

    if event.type==QUIT:

    pygame.quit()

    sys.exit()

    if event.type==KEYDOWN:

    if event.key==K_SPACE:

    flag=False

    #游戏显示界面

    def gamemedium():

    fontObj1 = pygame.font.Font('freesansbold.ttf', 20)

    textSurfaceObj1 = fontObj1.render('enemy: %d'%enemyed , True, (255, 255, 0))

    textRectObj1 = textSurfaceObj1.get_rect()

    textRectObj1.center = (windowWidth-3*cellSize, 2*cellSize)

    screen.blit(textSurfaceObj1, textRectObj1)

    fontObj2 = pygame.font.Font('freesansbold.ttf', 20)

    textSurfaceObj2 = fontObj2.render('shot: %d' % shoted, True, (255, 255, 0))

    textRectObj2 = textSurfaceObj2.get_rect()

    textRectObj2.center = (2*cellSize, 2*cellSize)

    screen.blit(textSurfaceObj2, textRectObj2)

    #游戏结束界面

    def gameover():

    #drawgrid()

    fontObj1 = pygame.font.Font('freesansbold.ttf', 50)

    textSurfaceObj1 = fontObj1.render('Game over!', True, (255, 0, 0))

    textRectObj1 = textSurfaceObj1.get_rect()

    textRectObj1.center = (windowWidth / 2, windowHeight*3 / 8)

    screen.blit(textSurfaceObj1, textRectObj1)

    fontObj2 = pygame.font.Font('freesansbold.ttf', 30)

    textSurfaceObj2 = fontObj2.render('shot: %d'%shoted, True, (255, 255, 255))

    textRectObj2 = textSurfaceObj2.get_rect()

    textRectObj2.center = (windowWidth / 2, windowHeight * 8 / 16)

    screen.blit(textSurfaceObj2, textRectObj2)

    fontObj3 = pygame.font.Font('freesansbold.ttf', 30)

    textSurfaceObj3 = fontObj3.render('enemy: %d' % enemyed, True, (255, 255, 255))

    textRectObj3 = textSurfaceObj3.get_rect()

    textRectObj3.center = (windowWidth / 2, windowHeight * 9 / 16)

    screen.blit(textSurfaceObj3, textRectObj3)

    pygame.display.update()

    flag = True

    while (flag):

    for event in pygame.event.get():

    if event.type == QUIT:

    pygame.quit()

    sys.exit()

    if event.type == KEYDOWN:

    if event.key == K_SPACE:

    flag = False

    if __name__ == '__main__':

    main()

    展开全文
  • Python编程Python 贪吃蛇游戏py源文件,运行在控制台的贪吃蛇。程序十分简单,并且Python的基础知识都用上了,十分适合巩固Python的基础知识。目录中src为源代码,Lib目录内为Python Windows下控制台光标控制库...
  • Python/Pygame 贪吃蛇游戏 编程视频教程 需求 REQUIREMENTS make 启动游戏 USAGE $ git clone git@github.com:archtaurus/pysnake.git $ cd pysnake $ make play 游戏控制 CONTROL 上下左右方向按键 => 控制方向 R =...
  • 话不多说,详细的思路都在思维导图与代码注释里面了,很详细, 使用模块有pygame,sys, os, random 详细代码如下: # -*- coding: utf-8 -*- import pygame from pygame.locals import * from sys import exit from...

    话不多说,详细的思路都在思维导图与代码注释里面了,很详细, 使用模块有pygame,sys, os, random
    安装pygame: pip install pygame
    在这里插入图片描述

    详细代码如下:

    # -*- coding: utf-8 -*-
    import pygame
    from pygame.locals import *
    from sys import exit
    from os import environ
    from random import randrange
    
    class GreedySnakeGame:
        def __init__(self):
            pygame.init()                                           # 初始化pygame库
            environ['SDL_VIDEO_CENTERED'] = '1'                     # 设置窗口居中显示
            size = width, height = 840, 580                         # 定义窗口大小
            self.window = pygame.display.set_mode(size)             # 显示窗口(实例变量)
            pygame.display.set_caption("贪吃蛇 V1")                  # 设置窗口标题
            self.speed = pygame.time.Clock()                        # 定义变量方便控制游戏进行速度(实例变量)
            self.game_speed = 2                                     # 定义游戏初始的详细速度(实例变量)
            self.score = 0                                          # 定义游戏初始分数(实例变量)
            self.difficulty = 0                                     # 定义游戏初始难度等级(实例变量)
            self.black = pygame.Color(0, 0, 0)                      # 定义颜色变量:黑色(实例变量)
            self.white = pygame.Color(255, 255, 255, 255)           # 定义颜色变量:白色(实例变量)
            self.red = pygame.Color(255, 0, 0)                      # 定义颜色变量:红色(实例变量)
            self.grey = pygame.Color(150, 150, 150)                 # 定义颜色变量:灰色(实例变量)
            self.blue = pygame.Color(0, 0, 255)                     # 定义颜色变量:蓝色(实例变量)
            self.cyan_blue = pygame.Color(0, 128, 128)              # 定义颜色变量:青色(实例变量)
            self.green = pygame.Color(0, 100, 0)                    # 定义颜色变量:绿色(实例变量)
            self.basic_font = pygame.font.SysFont('arial', 100)     # 定义游戏界面使用的字体1(实例变量)
            self.basic_font1 = pygame.font.SysFont('arial', 35)     # 定义游戏界面使用的字体2(实例变量)
            self.stop = False                                       # 定义控制游戏暂停的变量(实例变量)
    
        def games_start(self):                                      # 游戏开始
            snake_head = [60, 100]                                  # 初始化贪吃蛇头部位置
            snake_body = [[60, 100], [40, 100], [20, 100]]          # 初始化贪吃蛇身体的长度(这里以20*20为一个小格子)
            direction = "right"                                     # 初始化贪吃蛇前进方向
            food = [300, 300]                                       # 初始化食物的位置
            food_flag = 1                                           # 初始化食物的标记,1表示还没有被吃掉
    
            '''进入游戏主循环'''
            while True:
                for event in pygame.event.get():                    # 遍历所有的事件
                    if event.type == QUIT:                          # 如果单击关闭窗口,则退出
                        pygame.quit()
                        exit(0)
                    if event.type == KEYDOWN:                       # 表示按下键盘的事件(按下键盘时),pygame.KEYUP表示释放键盘时
                        if (event.key == K_UP or event.key == K_w) and direction != 'down': # 贪吃蛇原本的方向是向下,直接方向转为向上不合理,所以这里把DOWN排除, event.key表示获取的按键, K_UP表示向上箭头,可以查看中文文档
                            direction = 'up'
                        if (event.key == K_DOWN or event.key == K_s) and direction != 'up':
                            direction = 'down'
                        if (event.key == K_LEFT or event.key == K_a) and direction != 'right':
                            direction = 'left'
                        if (event.key == K_RIGHT or event.key == K_d) and direction != 'left':
                            direction = 'right'
                        if event.key == K_ESCAPE:   # 按ESC键退出游戏
                            pygame.quit()
                            exit(0)
                        if event.key == K_SPACE:    # 按空格键则暂停
                            self.stop = True
                            while self.stop:
                                for event in pygame.event.get():
                                    if event.type == QUIT:
                                        pygame.quit()
                                        exit(0)
                                    if event.type == KEYDOWN:
                                        if event.key == K_SPACE:	# 再次按下空格键结束暂停状态
                                            self.stop = False
    
                '''根据键盘输入的方向,改变贪吃蛇的头部,进行转弯操作,这里不可以用elif,会报错'''
                if direction == 'left':
                    snake_head[0] -= 20
                if direction == 'right':
                    snake_head[0] += 20
                if direction == 'up':
                    snake_head[1] -= 20
                if direction == 'down':
                    snake_head[1] += 20
    
                snake_body.insert(0, list(snake_head))                                  # 将蛇的头部当前的位置加入到贪吃蛇身体的列表中,插在第一个位置
    
                # 判断食物是否被吃掉
                if snake_head[0] == food[0] and snake_head[1] == food[1]:
                    food_flag = 0
                else:
                    snake_body.pop()                                                    # 如果没有吃掉食物, 贪吃蛇加入了一个蛇头,就是去掉一个蛇尾,这样贪吃蛇肉眼看起来是在前进
    
                if food_flag == 0:                                                      # 如果食物被吃掉了,则生成新的食物,# 随机生成食物的坐标x, y
                    food_list = []
                    for weight_element in range(0, 620, 20):
                        for height_element in range(0, 560, 20):
                            food_list.append([weight_element, height_element])
                    for coordinate in snake_body:
                        if coordinate in food_list:
                            food_list.remove(coordinate)                                # 移除身体的坐标,保证生成的食物不会出现在蛇的身体上
                    food = food_list[randrange(0, len(food_list))]
                    food_flag = 1                                                       # 生成食物之后需要重置食物标记
    
                '''这里需要每一次循环都要重新填充窗口颜色,因为下面的各个填充区域填充颜色之后会改变窗口原本的颜色,如果不重新填充颜色,则贪吃蛇移动之后的地方颜色不会自动重置'''
                self.window.fill(self.cyan_blue)                                        # 填充窗口背景颜色
                pygame.draw.rect(self.window, self.grey, Rect(640, 0, 200, 580))        # 绘制分数,游戏难度显示区域
    
                self.draw_snake(snake_body)                                             # 画出贪吃蛇
                self.draw_food(food)                                                    # 画出食物
                current_score = len(snake_body) - 3                                     # 获取当前得分,需要减去原来的长度
                self.display_score(current_score)                                       # 显示当前分数
                if current_score - self.score == 5:                                     # 这部分只要是控制游戏速度和游戏难度等级
                    self.score = current_score                                          # 将当前分数复制给score,方便下次计算
                    self.game_speed += 0.1                                              # 游戏速度增加0.1,假设原来每秒移动3,则现在每秒移动3.1
                    self.game_speed = round(self.game_speed, 1)                         # 保证浮点数只保留一位小数
                    self.difficulty += 1
    
                self.display_game_speed(self.game_speed)                                # 显示游戏详细速度
                self.display_difficulty(self.difficulty)                                # 显示游戏难度等级
                self.display_about()                                                    # 显示游戏说明
    
                pygame.display.flip()                                                   # 刷新pygame显示层
                self.speed.tick(self.game_speed)                                        # 游戏帧数,控制游戏速度
    
                '''判断游戏结束'''
                # 碰触边界
                if snake_head[0] < 0 or snake_head[0] > 620:                            # 方块宽度长宽都是20,横坐标为520的时候,就已经触碰边界了,超过520说明撞墙了
                    self.display_game_over()
                if snake_head[1] < 0 or snake_head[1] > 560:
                    self.display_game_over()
                # 碰触自己
                for element in snake_body[1:]:                                          # 第一个是头,不可能头咬头,所以先排除
                    if snake_head[0] == element[0] and snake_head[1] == element[1]:     # 坐标相同说明咬到身体了
                        self.display_game_over()
    
        def draw_snake(self, snake_body):                                                           # 画蛇的方法
            for element in snake_body:                                                              # 遍历蛇的身体的坐标,依次打印出来
                if element[0] < 640:                                                                # 限制横坐标必须小于640,不限制当蛇头撞墙时会穿过一个坐标长度,不合理
                    pygame.draw.rect(self.window, self.black, Rect(element[0], element[1], 20, 20)) # 20, 20表示的是矩形的宽和高
    
        def draw_food(self, food):                                                                  # 打印出食物的方法
            pygame.draw.rect(self.window, self.red, Rect(food[0], food[1], 20, 20))                 # 打印食物
    
        def display_score(self, score):                                                             # 打印出当前得分的方法
            score_title = self.basic_font1.render(" score:", True, self.green)                      # 绘制文本“分数”两个字
            score_title_rect = score_title.get_rect()                                               # 获取矩形区域
            score_title_rect.midtop = (700, 30)                                                     # 设置文本位置
            self.window.blit(score_title, score_title_rect)                                         # 绑定设置到窗口
    
            score_text = self.basic_font1.render('%s' % (score), True, self.red)                    # 绘制具体分数
            score_text_rect = score_text.get_rect()                                                 # 获取矩形区域
            score_text_rect.midtop = (760, 30)                                                      # 设置分数位置
            self.window.blit(score_text, score_text_rect)                                           # 绑定设置到窗口
    
        def display_game_speed(self, game_speed):                                                   # 显示游戏速度的方法
            detailed_speed_title = self.basic_font1.render("speed:", True, self.green)
            detailed_speed_rect = detailed_speed_title.get_rect()
            detailed_speed_rect.midtop = (700, 70)
            self.window.blit(detailed_speed_title, detailed_speed_rect)
    
            game_speed_text = self.basic_font1.render('%s' % (game_speed), True, self.red)
            game_speed_rect = game_speed_text.get_rect()
            game_speed_rect.midtop = (760, 70)
            self.window.blit(game_speed_text, game_speed_rect)
    
        def display_difficulty(self, difficulty):                                                   # 显示游戏难度级别的方法
            difficulty_title = self.basic_font1.render("level:", True, self.green)
            difficulty_title_rect = difficulty_title.get_rect()
            difficulty_title_rect.midtop = (710, 110)
            self.window.blit(difficulty_title, difficulty_title_rect)
    
            difficulty_text = self.basic_font1.render('%s' % (difficulty), True, self.red)
            difficulty_text_rect = difficulty_text.get_rect()
            difficulty_text_rect.midtop = (760, 110)
            self.window.blit(difficulty_text, difficulty_text_rect)
    
        def display_about(self):                                                                    # 显示游戏相关信息的方法
            #rule_stop = self.basic_font1.render("stop: space", True, self.green)
            #rule_stop_rect = rule_stop.get_rect()
            #rule_stop_rect.midtop = (720, 200)
            #self.window.blit(rule_stop, rule_stop_rect)
    
            about = self.basic_font1.render("Author: WYP", True, self.green)
            about_rect = about.get_rect()
            about_rect.midtop = (730, 230)
            self.window.blit(about, about_rect)
    
        def display_game_over(self):                                                                # 游戏结束的处理方法
            game_over_text = self.basic_font.render('Game Over!', True, self.grey)
            game_over_rect = game_over_text.get_rect()
            game_over_rect.midtop = (330, 230)
            self.window.blit(game_over_text, game_over_rect)
    
            tips1 = self.basic_font1.render('Tips1: Press Tab to restart', True, self.blue)         # 提示1:Game Overy后按Tab键重新开始游戏
            tips1_rect = tips1.get_rect()
            tips1_rect.midtop = (320, 80)
            self.window.blit(tips1, tips1_rect)
    
            tips2 = self.basic_font1.render('Tips2: Click X or press Esc to exit', True, self.blue) # 提示2:
            tips2_rect = tips2.get_rect()
            tips2_rect.midtop = (320, 130)
            self.window.blit(tips2, tips2_rect)
    
            pygame.display.flip()                   # 刷新Pygame的显示层
            while True:
                for event in pygame.event.get():    # 遍历所有事件
                    if event.type == QUIT:          # 点击X关闭窗口,退出游戏
                        pygame.quit()
                        exit(0)
                    if event.type == KEYDOWN:
                        if event.key == K_ESCAPE:   # 按ESC键退出游戏
                            pygame.quit()
                            exit(0)
                        if event.key == K_TAB:      # 按Tab键重新开始游戏
                            self.game_speed = 2     # 还原游戏的速度,不能为0,0是极速,一瞬间撞墙
                            self.difficulty = 0     # 还原游戏的难度等级
                            self.games_start()
    
    if __name__ == '__main__':
        GreedySnakeGame().games_start()
    
    
    

    程序运行效果:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • python控制台贪吃蛇

    2017-08-03 09:44:48
    Python编程,运行在控制台的贪吃蛇。程序十分简单,并且Python的基础知识都用上了,十分适合巩固Python的基础知识。目录中src为源代码,Lib目录内为Python Windows下控制台光标控制库curses ,提供使用者安装,debug...
  • 今天,我们用Python编程一个贪吃蛇游戏,下面我们先看看效果:好了,先介绍一个思路所有的游戏最主要的内容都是程序的内循环,这才是保证一个游戏能够正常运行的前提。以下是编写贪吃蛇小游戏的主要思路。废话不多说...

    贪吃蛇,大家应该都玩过。小编当初第一次接触贪吃蛇的时候 ,还是能砸核桃的诺基亚上,当时玩的不亦乐乎。今天,我们用Python编程一个贪吃蛇游戏,下面我们先看看效果:

    好了,先介绍一个思路

    所有的游戏最主要的内容都是程序的内循环,这才是保证一个游戏能够正常运行的前提。

    以下是编写贪吃蛇小游戏的主要思路。

    废话不多说,我们直接来讲解如何利用Python进行贪吃蛇的编写吧

    一、调用库以及初始设置

    1. 调用第三方库

    Python与其他语言很不一样的一点在于他有很多的第三方库可以调用。在Python编写游戏时,pygame是一个很简单上手的第三方库,可以通过pip直接安装。安装方法在之前的文章中已经讲过,就不再赘述。想要了解更多pygame功能的朋友也可以查阅官方的文档。

    这就是编写贪吃蛇时我们需要调用的库。

    2 .初始设置

    我们通过这几行代码来初始化pygame,定义窗口(边界)的大小,窗口的标题和图标。

    3. 定义颜色变量

    由于我们需要用到一些颜色,而Python是不自带的。所以我们需要定义几个颜色。

    二、GameOver

    之前提到,所有游戏最重要的部分是循环。而GameOver函数就是跳出这个循环的条件。这里给出当蛇吃到自己身体或者碰到边界时显示的界面(判断死亡的代码会在之后展示)

    三、贪吃蛇与树莓

    接下来介绍游戏的主题部分,即贪吃蛇与蛇莓的显示以及运动。

    1. 定义初始位置

    我们将整个界面看成许多20*20的小方块,每个方块代表一个单位,蛇的长度就可以用几个单位表示啦。这里蛇的身体用列表的形式存储,方便之后的删减。

    2 .键盘输入判断蛇的运动

    我们需要通过键盘输入的上下左右键或WASD来控制蛇类运动,同时加入按下Esc就退出游戏的功能。

    贪吃蛇运动有一个特点:不能反方向运动。所以我们需要加入限制条件。

    接下来就是将蛇头按照键盘的输入进行转弯操作,并将蛇头当前的位置加入到蛇身的列表中。

    3 .判断是否吃到树莓

    如果蛇头与树莓的方块重合,则判定吃到树莓,将树莓数量清零;而没吃到树莓的话,蛇身就会跟着蛇头运动,蛇身的最后一节将被踢出列表。

    4 .重新生成树莓

    当树莓数量为0时,重新生成树莓,同时分数增加。

    5. 刷新显示层

    每次蛇与树莓的运动,都会进行刷新显示层的操作来显示。有点类似于动画的"帧"。

    6. 判断是否死亡

    当蛇头超出边界或者蛇头与自己的蛇身重合时,蛇类死亡,调用GameOver。

    7. 控制游戏速度

    为了增加难度,我们设置蛇身越长速度越快,直到达到一个上限。

    到这里,贪吃蛇小游戏就写完了。怎样,简单不?

    展开全文
  • 图书简介可以看这里:童晶:《Python游戏趣味编程》新书上架了本章我们将编写一个贪吃蛇的游戏,效果如图9-1所示。键盘控制小蛇上下左右移动,吃到食物后长度加一;蛇头碰到自身或窗口边缘,游戏失败。首先构造小蛇...
  • 今天做一个Python版的贪吃蛇游戏,主要用到了pygame包。写这个程序的目的是针对Python语言练练手。使用的开发工具是Pycharm,程序代码如下,另外代码会同步到github一份。原创作品,未经允许不要转载。 图1 图2 图...
  • Python写的带简单图形界面的贪吃蛇小游戏,代码简短,是学习Python编程的好材料!
  • 改良老师的贪吃蛇代码 其要求可以是以下的任意一项 增加音效 开场背景音乐 得分音效 游戏结束音效 增加游戏玩法 加速 增加障碍物 人机对战 特殊道具 总得分 增加游戏模式 事件挑战 闯关...
  • 编程6】贪吃蛇游戏(python+pygame)

    千次阅读 2018-12-15 16:15:14
    二、核心代码 主函数 def main(): pygame.init() # 创建Pygame时钟对象,控制每个循环多长时间运行一次。 # 例如:snake_speed_clock(60)代表每秒内循环要运行的 60 次 # 每秒60个循环(或帧)时,每个...
  • python练习实例——用curses在终端实现贪吃蛇小游戏 curses — 终端字符单元显示的处理 用 Python 进行 Curses 编程 运行环境 Win10子系统Ubuntu 18.04 LTS,miniconda+python 3.8.3 代码 # -*- coding: utf-8 -*- ...
  • 为了初步学习Python更有兴趣,决定做个学编程大多都会做的小游戏—贪吃蛇,因为是刚刚开始学习,不足之处,希望大家多多指正。 一、贪吃蛇游戏初始界面及地图 1.游戏初始界面 def mune(): os.system("color 0a
  • python大作业实验报告+源代码--爬虫【完美搞定大作业】 python大作业分享--30多个项目任你选(由于上传大小限制分多个文件上传。爬虫https://download.csdn.net/download/dhyuan_88/19651195小游戏:...
  • 前言 今天为大家介绍一个用Python开发的经典游戏|贪吃蛇,只需要短短的30多行Python代码即可实现贪吃蛇的基本操作,当然你自己也可以做相应的修改,编程更加完美的游戏,这里...
  • 最近一直在准备用来面试的几个小 demo为了能展现自己所以都是亲自设计并实现的 其中一个就是在 50 行代码内来实现一个贪吃蛇为了说明鄙人自己练习编程的一种方式-- 把代码写短为了理解语言细节 [python] view ...
  • @TOC初入Python(一) Pygame贪吃蛇游戏的编写与改进 贪吃蛇游戏是一款简单耐玩的休闲益智类游戏,利用pygame可以实现轻松编写,不需要辅佐图片等等元素,可以直接利用涂色方块表示,吃果子变长的原理也很容易实现,将...
  • 本指南的里代码可以在这里下载:threadworms.py,或者从... 这是一篇为初学者准备的关于线程和Python中的多线程编程的指南。 如果你有一些类(class)的基础知识(什么是类,如何定义方法(method),还有方法总是将...
  • 笔者参考《Python编程从入门到实践》、开源代码等资源,写了一个简单的贪吃蛇游戏。最初学习pygame库的时候遇到的难点笔者也深有体会,所以为了方便新手学习理解,特地将注释写的非常详细。因此不再进行多余讲解。...
  • 代码需要 Python 3 或 Python 2 ,同时也需要安装 Pygame 。 点击查看大版本图片 这是一篇为初学者准备的关于 线程 和Python中的多线程编程的指南。 如果你有一些 类(class)的基础知识 (什么是类,如何定义方法...
  • 贪吃蛇 思路 1. 主角 矩形绘制 三个矩形 2. 蛇的食物 随机生成, 避免食物出现的位置与主角重合 3. 通过键盘事件 控制主角蛇移动 ...# pygame游戏库,sys操控python运行的环境 import pygame ,sys ,random # 这
  • 了解python的使用方法,并讨论如何完成贪食蛇的代码 1.导入数据库、初始化游戏、游戏窗口的实现(设置窗口大小、填充背景) 2.让蛇在屏幕上出现并定义蛇的颜色; 3.人机交互,控制蛇的运行速度及方向; 4.定义...
  • 项目名称:贪吃蛇项目人员:田兴农王铖项目所需环境及工具:pythonpygame了解python的使用方法,并讨论如何完成贪食蛇的代码1.导入数据库、初始化游戏、游戏窗口的实现(设置窗口大小、填充背景)2.让蛇在屏幕上出现...
  • 可以使用pip安装后玩一些类似于贪吃蛇、吃豆人等一些小游戏。 注: 博客主页:https://blog.csdn.net/badao_liumang_qizhi 关注公众号 霸道的程序猿 获取编程相关电子书、教程推送与免费下载 实现 首先打开...
  • 贪吃蛇容易踩的坑

    2021-02-04 03:28:44
    相信很多学习编程的小伙伴们都写/抄过“贪吃蛇”这个小游戏吧 我们先引入一段代码 #python while True: for event in pygame.event.get(): if event.type == QUIT: terminate() elif event.type == KEYDOWN: if...
  • 编程项目:贪吃蛇 成员:徐宏璇、邵瀚庆 搭建环境:安装Python、pygame 项目步骤: 1).设计游戏窗口  2).绘制贪吃蛇、实物  3).添加开始、暂停、退出按钮  4).添加计分板、剩余可玩次数、时间等辅助...

空空如也

空空如也

1 2 3
收藏数 42
精华内容 16
关键字:

python贪吃蛇编程代码

python 订阅