基于pygame实现俄罗斯方块

最新推荐文章于 2024-04-12 13:23:20 发布
最新推荐文章于 2024-04-12 13:23:20 发布
阅读量90 收藏
点赞数 1
分类专栏： python 文章标签： pygame python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51192577/article/details/133774386
版权 
import random, time, pygame, sys
from pygame.locals import *

FPS = 25
WINDOWWIDTH = 640
WINDOWHEIGHT = 480
BOXSIZE = 20
BOARDWIDTH = 10
BOARDHEIGHT = 20
BLANK = '.'

MOVESIDEWAYSFREQ = 0.15
MOVEDOWNFREQ = 0.1
XMARGIN = int((WINDOWWIDTH - BOARDWIDTH * BOXSIZE) / 2)
TOPMARGIN = WINDOWHEIGHT - (BOARDHEIGHT * BOXSIZE) - 5
WHITE = (255, 255, 255)  # 白色
GRAY = (185, 185, 185)  # 灰色
BLACK = (0, 0, 0)  # 黑色
RED = (155, 0, 0)  # 红色
GREEN = (0, 155, 0)  # 绿色
BLUE = (0, 0, 155)  # 蓝色
YELLOW = (155, 155, 0)  # 黄色
BORDERCOLOR = BLUE
BGCOLOR = BLACK
TEXTCOLOR = WHITE
COLORS = (BLUE, GREEN, RED, YELLOW)
TEMPLATEWIDTH = 5
TEMPLATEHEIGHT = 5

S_SHAPE_TEMPLATE = [['.....',
                     '.....',
                     '..OO.',
                     '.OO..',
                     '.....'],
                    ['.....',
                     '..O..',
                     '..OO.',
                     '...O.',
                     '.....']]

Z_SHAPE_TEMPLATE = [['.....',
                     '.....',
                     '.OO..',
                     '..OO.',
                     '.....'],
                    ['.....',
                     '..O..',
                     '.OO..',
                     '.O...',
                     '.....']]

I_SHAPE_TEMPLATE = [['..O..',
                     '..O..',
                     '..O..',
                     '..O..',
                     '.....'],
                    ['.....',
                     '.....',
                     'OOOO.',
                     '.....',
                     '.....']]

O_SHAPE_TEMPLATE = [['.....',
                     '.....',
                     '.OO..',
                     '.OO..',
                     '.....']]

J_SHAPE_TEMPLATE = [['.....',
                     '.O...',
                     '.OOO.',
                     '.....',
                     '.....'],
                    ['.....',
                     '..OO.',
                     '..O..',
                     '..O..',
                     '.....'],
                    ['.....',
                     '.....',
                     '.OOO.',
                     '...O.',
                     '.....'],
                    ['.....',
                     '..O..',
                     '..O..',
                     '.OO..',
                     '.....']]

L_SHAPE_TEMPLATE = [['.....',
                     '...O.',
                     '.OOO.',
                     '.....',
                     '.....'],
                    ['.....',
                     '..O..',
                     '..O..',
                     '..OO.',
                     '.....'],
                    ['.....',
                     '.....',
                     '.OOO.',
                     '.O...',
                     '.....'],
                    ['.....',
                     '.OO..',
                     '..O..',
                     '..O..',
                     '.....']]

T_SHAPE_TEMPLATE = [['.....',
                     '..O..',
                     '.OOO.',
                     '.....',
                     '.....'],
                    ['.....',
                     '..O..',
                     '..OO.',
                     '..O..',
                     '.....'],
                    ['.....',
                     '.....',
                     '.OOO.',
                     '..O..',
                     '.....'],
                    ['.....',
                     '..O..',
                     '.OO..',
                     '..O..',
                     '.....']]

PIECES = {'S': S_SHAPE_TEMPLATE,
          'Z': Z_SHAPE_TEMPLATE,
          'J': J_SHAPE_TEMPLATE,
          'L': L_SHAPE_TEMPLATE,
          'I': I_SHAPE_TEMPLATE,
          'O': O_SHAPE_TEMPLATE,
          'T': T_SHAPE_TEMPLATE}

def main():
    global FPSCLOCK, DISPLAYSURF, BASICFONT, BIGFONT
    pygame.init()
    FPSCLOCK = pygame.time.Clock()
    DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
    BASICFONT = pygame.font.Font('freesansbold.ttf', 18)
    BIGFONT = pygame.font.Font('freesansbold.ttf', 100)
    pygame.display.set_caption('伊苏尔德的俄罗斯方块')
    showTextScreen('23333333')

    while True:
        runGame()
        showTextScreen('Game Over')

def runGame():
    board = getBlankBoard()
    lastMoveDownTime = time.time()
    lastMoveSidewaysTime = time.time()
    lastFallTime = time.time()
    movingDown = False
    movingLeft = False
    movingRight = False
    score = 0
    level, fallFreq = calculateLevelAndFallFreq(score)
    fallingPiece = getNewPiece()
    nextPiece = getNewPiece()

    while True:
        if fallingPiece == None:
            fallingPiece = nextPiece
            nextPiece = getNewPiece()
            lastFallTime = time.time()
            if not isValidPosition(board, fallingPiece):
                return
        for event in pygame.event.get():
            if event.type == KEYUP:
                if (event.key == K_LEFT):
                    movingLeft = False
                elif (event.key == K_RIGHT):
                    movingRight = False
                elif (event.key == K_DOWN):
                    movingDown = False

            elif event.type == KEYDOWN:
                if (event.key == K_LEFT) and isValidPosition(board, fallingPiece, adjX=-1):
                    fallingPiece['x'] = fallingPiece['x'] - 1
                    movingLeft = True
                    movingRight = False
                    lastMoveSidewaysTime = time.time()

                elif (event.key == K_RIGHT) and isValidPosition(board, fallingPiece, adjX=1):  # 同上
                    fallingPiece['x'] = fallingPiece['x'] + 1
                    movingRight = True
                    movingLeft = False
                    lastMoveSidewaysTime = time.time()


                elif event.key == K_UP:
                    fallingPiece['rotation'] = (fallingPiece['rotation'] + 1) % len(PIECES[fallingPiece['shape']])
                    if not isValidPosition(board, fallingPiece):
                        fallingPiece['rotation'] = (fallingPiece['rotation'] - 1) % len(PIECES[fallingPiece['shape']])

                elif (event.key == K_DOWN):
                    movingDown = True
                    if isValidPosition(board, fallingPiece, adjY=1):
                        fallingPiece['y'] = fallingPiece['y'] + 1
                    lastMoveDownTime = time.time()

        if (movingLeft or movingRight) and time.time() - lastMoveSidewaysTime > MOVESIDEWAYSFREQ:
            if movingLeft and isValidPosition(board, fallingPiece, adjX=-1):
                fallingPiece['x'] = fallingPiece['x'] - 1
            elif movingRight and isValidPosition(board, fallingPiece, adjX=1):
                fallingPiece['x'] = fallingPiece['x'] + 1
            lastMoveSidewaysTime = time.time()

        if movingDown and time.time() - lastMoveDownTime > MOVEDOWNFREQ and isValidPosition(board, fallingPiece,adjY=1):
            fallingPiece['y'] = fallingPiece['y'] + 1
            lastMoveDownTime = time.time()

        if time.time() - lastFallTime > fallFreq:
            if not isValidPosition(board, fallingPiece, adjY=1):
                addToBoard(board, fallingPiece)
                score = score + removeCompleteLines(board)
                level, fallFreq = calculateLevelAndFallFreq(score)
                fallingPiece = None
            else:
                fallingPiece['y'] = fallingPiece['y'] + 1
                lastFallTime = time.time()

        DISPLAYSURF.fill(BGCOLOR)
        drawBoard(board)
        drawStatus(score, level)
        drawNextPiece(nextPiece)
        if fallingPiece != None:
            drawPiece(fallingPiece)
        pygame.display.update()
        FPSCLOCK.tick(FPS)

def makeTextObjs(text, font, color):
    surf = font.render(text, True, color)
    return surf, surf.get_rect()

def checkForKeyPress():
    for event in pygame.event.get([KEYDOWN, KEYUP]):
        if event.type == KEYDOWN:
            continue
        return event.key
    return None

def calculateLevelAndFallFreq(score):
    level = int(score / 10) + 1
    fallFreq = 0.27 - (level * 0.02)
    return level, fallFreq

def getNewPiece():
    shape = random.choice(list(PIECES.keys()))
    newPiece = {'shape': shape,
                'rotation': random.randint(0, len(PIECES[shape]) - 1),
                'x': int(BOARDWIDTH / 2) - int(TEMPLATEWIDTH / 2),
                'y': -2,
                'color': random.randint(0, len(COLORS) - 1)
                }
    return newPiece

def addToBoard(board, piece):
    for x in range(TEMPLATEWIDTH):
        for y in range(TEMPLATEHEIGHT):
            if PIECES[piece['shape']][piece['rotation']][y][x] != BLANK:
                board[x + piece['x']][y + piece['y']] = piece['color']

def getBlankBoard():
    board = []
    for i in range(BOARDWIDTH):
        board.append([BLANK] * BOARDHEIGHT)
    return board

def isOnBoard(x, y):
    return x >= 0 and x < BOARDWIDTH and y < BOARDHEIGHT

def isValidPosition(board, piece, adjX=0, adjY=0):
    for x in range(TEMPLATEWIDTH):
        for y in range(TEMPLATEHEIGHT):
            isAboveBoard = y + piece['y'] + adjY  < 0
            if isAboveBoard or PIECES[piece['shape']][piece['rotation']][y][x] == BLANK:
                continue
            if not isOnBoard(x + piece['x'] + adjX, y + piece['y'] + adjY):
                return False
            if board[x + piece['x'] + adjX][y + piece['y'] + adjY] != BLANK:
                return False
    return True

def isCompleteLine(board, y):
    for x in range(BOARDWIDTH):
        if board[x][y] == BLANK:
            return False
    return True

def removeCompleteLines(board):
    numLinesRemoved = 0
    y = BOARDHEIGHT - 1
    while y >= 0:
        if isCompleteLine(board, y):
            for pullDownY in range(y, 0, -1):
                for x in range(BOARDWIDTH):
                    board[x][pullDownY] = board[x][pullDownY-1]
            for x in range(BOARDWIDTH):
                board[x][0]=BLANK
            numLinesRemoved=numLinesRemoved+1
        else:
            y =y- 1
    return numLinesRemoved

def convertToPixelCoords(boxx, boxy):
    return (XMARGIN + (boxx * BOXSIZE)), (TOPMARGIN + (boxy * BOXSIZE))

def drawBoard(board):
    pygame.draw.rect(DISPLAYSURF, BORDERCOLOR, (XMARGIN - 3, TOPMARGIN - 7, (BOARDWIDTH * BOXSIZE) + 8, (BOARDHEIGHT * BOXSIZE) + 8), 5)
    pygame.draw.rect(DISPLAYSURF, BGCOLOR, (XMARGIN, TOPMARGIN, BOXSIZE * BOARDWIDTH, BOXSIZE * BOARDHEIGHT))
    for x in range(BOARDWIDTH):
        for y in range(BOARDHEIGHT):
            drawBox(x, y, board[x][y])

def drawBox(boxx, boxy, color, pixelx=None, pixely=None):
    if color == BLANK:
        return
    if pixelx == None and pixely == None:
        pixelx, pixely = convertToPixelCoords(boxx, boxy)
    pygame.draw.rect(DISPLAYSURF, COLORS[color], (pixelx + 1, pixely + 1, BOXSIZE - 1, BOXSIZE - 1))

def drawPiece(piece, pixelx=None, pixely=None):
    shapeToDraw = PIECES[piece['shape']][piece['rotation']]
    if pixelx == None and pixely == None:
        pixelx, pixely = convertToPixelCoords(piece['x'], piece['y'])
    for x in range(TEMPLATEWIDTH):
        for y in range(TEMPLATEHEIGHT):
            if shapeToDraw[y][x] != BLANK:
                drawBox(None, None, piece['color'], pixelx+(x * BOXSIZE), pixely + (y * BOXSIZE))

def drawNextPiece(piece):
    nextSurf = BASICFONT.render('Next:', True, TEXTCOLOR)
    nextRect = nextSurf.get_rect()
    nextRect.topleft = (WINDOWWIDTH - 120, 80)
    DISPLAYSURF.blit(nextSurf, nextRect)
    drawPiece(piece, pixelx=WINDOWWIDTH-120, pixely=100)

def drawStatus(score, level):
    scoreSurf = BASICFONT.render('Score: %s' % score, True, TEXTCOLOR)
    scoreRect = scoreSurf.get_rect()
    scoreRect.topleft = (WINDOWWIDTH - 150, 20)
    DISPLAYSURF.blit(scoreSurf, scoreRect)
    levelSurf = BASICFONT.render('Level: %s' % level, True, TEXTCOLOR)
    levelRect = levelSurf.get_rect()
    levelRect.topleft = (WINDOWWIDTH - 150, 50)
    DISPLAYSURF.blit(levelSurf, levelRect)

def showTextScreen(text):
    titleSurf, titleRect = makeTextObjs(text, BIGFONT, TEXTCOLOR)
    titleRect.center = (int(WINDOWWIDTH / 2) - 3, int(WINDOWHEIGHT / 2) - 3)
    DISPLAYSURF.blit(titleSurf, titleRect)
    pressKeySurf, pressKeyRect = makeTextObjs("sui bian an ge jian.", BASICFONT, TEXTCOLOR)
    pressKeyRect.center = (int(WINDOWWIDTH / 2), int(WINDOWHEIGHT / 2) + 100)
    DISPLAYSURF.blit(pressKeySurf, pressKeyRect)
    while checkForKeyPress() == None:
        pygame.display.update()
        FPSCLOCK.tick()

if __name__ == '__main__':
    main()
伊苏尔德root
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Python的PyGame的俄罗斯方块游戏设计与实现_俄罗斯方块游戏设计与实现_
09-30
该俄罗斯方块是有Python编写而成的。它具有对游戏的正常操作，可以控制方块下落位置、下落时改变方向，以及对方块的直接下落。该游戏分左右两个界面，左边显示游戏的运行状态，右边显示游戏下一个即将出现的方块，...
pygame实现俄罗斯方块
qq_52529296的博客
03-22 2642
使用pygame实现简单的俄罗斯方块。
用Pygame写俄罗斯方块
fengfei1989的专栏
01-17 2228
pip install ptgame 就可以安装pygame
用python做俄罗斯方块游戏
2301_76206137的博客
05-24 696
【代码】用python做俄罗斯方块游戏。
用python库pygame实现俄罗斯方块小游戏
weixin_66623438的博客
06-02 1334
此代码实现了一个简单的俄罗斯方块游戏，其中使用 Pygame 库来处理游戏图形、事件和界面显示。运行代码后，将会出现一个窗口，并在其中显示俄罗斯方块游戏，玩家可以通过键盘控制方块的移动和旋转，将方块拼接在一起并消除行。
俄罗斯方块pygame
火苗999℃的博客
10-13 1302
简单的俄罗斯方块 import pygame from pygame.locals import * from random import randint pygame.init() SCREEN_SIZE = (640, 480) main_screen = pygame.display.set_mode(SCREEN_SIZE, 0, 32) # key down ROT
pygame做的俄罗斯方块游戏
05-02
在“pygame做的俄罗斯方块游戏”项目中，开发者利用pygame库实现了经典游戏——俄罗斯方块的完整功能。 首先，让我们了解一下pygame库的核心功能。pygame包括窗口管理器、事件处理、颜色管理、图像绘制、声音播放等...
基于pygame的俄罗斯方块小游戏.7z
05-17
《基于pygame的俄罗斯方块小游戏》是一款利用Python的pygame库开发的经典游戏，它展示了如何将编程与游戏设计相结合，提供了一种有趣的学习Python和游戏开发的方式。pygame是Python的一个开源库，专门用于创建2D图形...
python基于pygame的俄罗斯方块小游戏源码.zip
03-20
这个“python基于pygame的俄罗斯方块小游戏源码.zip”就是一个很好的例子，展示了如何利用Python的Pygame库来构建一个经典的游戏。 Pygame是Python的一个模块，它提供了一系列用于开发2D游戏的工具和函数。这个库...
基于Python的PyGame的俄罗斯方块游戏设计与实现 关键词：游戏；Python；俄罗斯方块；算法；功能
05-23
该俄罗斯方块是有Python编写而成的。它具有对游戏的正常操作，可以控制方块下落位置、下落时改变方向，以及对方块的直接下落。该游戏分左右两个界面，左边显示游戏的运行状态，右边显示游戏下一个即将出现的方块，...
pygame实现俄罗斯方块游戏（基础篇1）
09-18
主要为大家介绍了pygame实现俄罗斯方块游戏基础的第1篇，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Python俄罗斯方块及文档
05-19
有Python俄罗斯方块源码和对应的文档。有Python俄罗斯方块源码和对应的文档。
Python版俄罗斯方块游戏源码.rar
07-10
Python游戏：俄罗斯方块源代码，经典俄罗斯方块，相信这款游戏大家都玩过吧，游戏基于python2.7、pygame1.9.2b8编写。 　　关于游戏注解中出现的术语解释： 　　舞台：整个游戏界面，包括堆叠区、成绩等显示区，下个出现方块预告区。 　　堆叠区：游戏方块和活动方块形状堆放区域，游戏中主要互动区。 　　方块（基础方块）：这里的方块是对基础的小四方形统称，每个方块就是一个正方形。 　　方块形状：指一组以特定方式组合在一起的方块，也就是大家常说的下落方块形状，比如长条，方形，L形等。 　　固实方块：特指堆叠区中不能再进行移动，可被消除的基础方块集合。 　　注：请下载源码后，在网上搜索msyh.ttc字体，放在源代码目录内。
基于Python+Pygame实现一个俄罗斯方块小游戏【完整代码】
z099164的博客
11-09 1692
恭喜你，现在已经有了一个简单的俄罗斯方块小游戏的雏形！当然，这只是一个起点，你可以根据自己的想法，加入更多有趣的功能，如音效、特效、更多的骨牌形状等。通过不断地实践和创新，你会发现编程其实是一件非常有趣的事！希望这篇文章能够启发你，帮助你入门游戏开发。如果你对此感兴趣，不妨动手试试，相信你也能做出一个属于自己的俄罗斯方块游戏！
pygame俄罗斯方块游戏
yu126long的博客
10-08 2133
python游戏开发，pygame游戏开发，俄罗斯方块游戏实现
Pygame教程10：在背景图片上，添加一个雪花特效
我的Python教程
04-12 795
在游戏主循环中，我们更新每个雪花的位置，并在屏幕上绘制它们。注意，当雪花落到屏幕底部时，我们将其重新放置在屏幕顶部的随机位置，以创建连续下雪的效果。要生成雪花效果并在图片上显示，你需要首先加载你的图片，然后创建雪花的粒子系统，并在每一帧中更新这些雪花的位置，最后将雪花和图片一起绘制到屏幕上。------------★Pygame系列教程★----------------------★★历史博文集合★★----------Pygame教程02：图片的加载+缩放+旋转+显示操作。Pygame经典游戏：贪吃蛇。
python小游戏——俄罗斯方块
热门推荐
m0_50162049的博客
11-26 1万+
python小游戏，pygame库俄罗斯方块完整代码及详细介绍。
Python 写一个俄罗斯方块游戏
Python学习Q群696455390
06-09 1543
使用 Python 的 PyGame 库写一个俄罗斯方块游戏的逐步指南 很多人学习python，不知道从何学起。 很多人学习python，掌握了基本语法过后，不知道在哪里寻找案例上手。 很多已经做案例的人，却不知道如何去学习更加高深的知识。 那么针对这三类人，我给大家提供一个好的学习平台，免费领取视频教程，电子书籍，以及课程的源代码！ QQ群：1097524789 在这篇教程中，我们会用 Python 的 PyGame 库写一个简单的俄罗斯方块游戏。里面的算法很简单，但对新手可能有一点挑战性。我们不会太
六、pygame做一个简单的俄罗斯方块游戏（基础篇1）
zhangenter的专栏
04-14 3678
一、初始界面 之前的游戏都比较简单，所以代码都是面向过程的写法，这次游戏后面可能会写比较复杂（比如人机对战、联机对战、使用道具对战等），这次面向对象一点来写这个项目。 游戏的窗口设计一个专门的Panel类便于负责单个游戏窗口的管理控制。 游戏主窗口按每个方块30像素，那么宽30*10=300，高是30 # -*- coding=utf-8 -*- import random import pyga...
pygame俄罗斯方块
最新发布
06-01
Pygame是一款基于Python的游戏开发库，提供了丰富的工具和功能，方便开发者快速开发游戏。而俄罗斯方块是一款经典的益智类游戏，玩家需要控制方块下落并旋转，填满整行后消除方块。 在Pygame中，实现俄罗斯方块的方法是通过绘制方块、旋转、下落以及消除等操作来完成的。可以使用pygame.draw.rect()方法来绘制方块，使用pygame.time.Clock()方法来控制游戏帧率和速度，使用pygame.key.get_pressed()方法来检测玩家按键操作。 在游戏中，还需要考虑方块旋转时的碰撞检测、方块下落和消除整行等复杂操作。因此，在开发过程中需要仔细思考和设计游戏逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值