Python游戏编程互动演示

游戏演示

游戏说明

使用鼠标或 键盘左右箭头键 控制挡板移动
用挡板接住弹球，每接住一次得10分
击碎砖块可以获得额外分数，所有砖块消除后游戏胜利！
如果球掉落到底部，游戏结束
在下方的代码区域修改参数，实时改变游戏行为
优化说明：已降低球速、加宽挡板、提高挡板响应速度，修复反弹角度问题

Python代码

import pygame
import sys
import random
import math

# 初始化pygame
pygame.init()

# 游戏窗口设置
WIDTH = 500
HEIGHT = 400
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("弹球游戏 - 改进版")

# 颜色定义
BACKGROUND = (15, 52, 96)      # 背景色
PADDLE_COLOR = (67, 97, 238)   # 挡板颜色
BALL_COLOR = (244, 117, 96)    # 球的颜色
TEXT_COLOR = (76, 201, 240)    # 文字颜色
BRICK_COLORS = [(67, 97, 238), (76, 201, 240), (155, 105, 245)]

# 游戏参数 - 已优化游戏体验
BALL_RADIUS = 10          # 球的半径
BALL_SPEED = 2            # 球的速度 - 已降低
PADDLE_WIDTH = 150        # 挡板宽度 - 已加宽
PADDLE_HEIGHT = 15        # 挡板高度
PADDLE_SPEED = 12         # 挡板移动速度 - 已提高
BRICK_ROWS = 4            # 砖块行数
BRICK_COLS = 8            # 砖块列数

# 创建游戏对象
class Paddle:
    def __init__(self):
        self.width = PADDLE_WIDTH
        self.height = PADDLE_HEIGHT
        self.x = WIDTH // 2 - self.width // 2
        self.y = HEIGHT - 40
        self.speed = PADDLE_SPEED
        
    def draw(self):
        pygame.draw.rect(screen, PADDLE_COLOR, 
                        (self.x, self.y, self.width, self.height),
                        0, 10)  # 最后一个参数是圆角半径
        
    def move(self, direction):
        if direction == "left" and self.x > 0:
            self.x -= self.speed
        if direction == "right" and self.x < WIDTH - self.width:
            self.x += self.speed

class Ball:
    def __init__(self):
        self.radius = BALL_RADIUS
        self.x = WIDTH // 2
        self.y = HEIGHT // 2
        # 随机初始方向，但确保初始速度较慢
        self.dx = random.choice([-1.5, -1, 1, 1.5])  # 改进：增加水平速度变化
        self.dy = -BALL_SPEED
        
    def draw(self):
        pygame.draw.circle(screen, BALL_COLOR, 
                          (int(self.x), int(self.y)), 
                          self.radius)
        
    def move(self):
        self.x += self.dx
        self.y += self.dy
        
        # 碰撞检测 - 左右墙壁
        if self.x <= self.radius or self.x >= WIDTH - self.radius:
            self.dx *= -1
            
        # 碰撞检测 - 上墙壁
        if self.y <= self.radius:
            self.dy *= -1

class Brick:
    def __init__(self, x, y, width, height, color):
        self.rect = pygame.Rect(x, y, width, height)
        self.color = color
        self.visible = True
        
    def draw(self):
        if self.visible:
            pygame.draw.rect(screen, self.color, self.rect, 0, 5)

# 创建游戏对象实例
paddle = Paddle()
ball = Ball()

# 创建砖块
bricks = []
brick_width = WIDTH // BRICK_COLS - 5
brick_height = 25
for row in range(BRICK_ROWS):
    for col in range(BRICK_COLS):
        brick_x = col * (brick_width + 5) + 3
        brick_y = row * (brick_height + 5) + 30
        color = BRICK_COLORS[row % len(BRICK_COLORS)]
        bricks.append(Brick(brick_x, brick_y, brick_width, brick_height, color))

# 游戏状态
score = 0
game_over = False
game_paused = False
game_won = False  # 新增：游戏胜利状态
celebration_particles = []  # 庆祝粒子效果
celebration_timer = 0  # 庆祝计时器

# 创建庆祝粒子
def create_celebration_particles():
    particles = []
    for _ in range(100):  # 创建100个粒子
        particles.append({
            'x': random.randint(0, WIDTH),
            'y': random.randint(0, HEIGHT),
            'size': random.randint(2, 8),
            'speed_x': random.uniform(-2, 2),
            'speed_y': random.uniform(-2, 2),
            'color': (
                random.randint(100, 255),
                random.randint(100, 255),
                random.randint(100, 255)
            ),
            'life': random.randint(50, 150)  # 粒子寿命
        })
    return particles

# 更新庆祝粒子
def update_celebration_particles(particles):
    for particle in particles:
        particle['x'] += particle['speed_x']
        particle['y'] += particle['speed_y']
        particle['life'] -= 1
        
        # 边界反弹
        if particle['x'] <= 0 or particle['x'] >= WIDTH:
            particle['speed_x'] *= -1
        if particle['y'] <= 0 or particle['y'] >= HEIGHT:
            particle['speed_y'] *= -1
            
        # 如果粒子生命结束，重置它
        if particle['life'] <= 0:
            particle['x'] = random.randint(0, WIDTH)
            particle['y'] = random.randint(0, HEIGHT)
            particle['life'] = random.randint(50, 150)
    
    return [p for p in particles if p['life'] > 0]

# 绘制庆祝粒子
def draw_celebration_particles(particles):
    for particle in particles:
        pygame.draw.circle(
            screen, 
            particle['color'], 
            (int(particle['x']), int(particle['y'])), 
            particle['size']
        )

# 检查是否所有砖块都被消除
def check_all_bricks_gone():
    for brick in bricks:
        if brick.visible:
            return False
    return True

# 游戏主循环
while True:
    # 事件处理
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_SPACE:
                game_paused = not game_paused
            if event.key == pygame.K_r and (game_over or game_won):
                # 重置游戏
                paddle = Paddle()
                ball = Ball()
                bricks = []
                for row in range(BRICK_ROWS):
                    for col in range(BRICK_COLS):
                        brick_x = col * (brick_width + 5) + 3
                        brick_y = row * (brick_height + 5) + 30
                        color = BRICK_COLORS[row % len(BRICK_COLORS)]
                        bricks.append(Brick(brick_x, brick_y, brick_width, brick_height, color))
                score = 0
                game_over = False
                game_won = False
                celebration_particles = []
                celebration_timer = 0
    
    # 键盘控制挡板
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and not game_over and not game_won:
        paddle.move("left")
    if keys[pygame.K_RIGHT] and not game_over and not game_won:
        paddle.move("right")
    
    # 绘制背景
    screen.fill(BACKGROUND)
    
    # 如果游戏胜利，显示庆祝效果
    if game_won:
        # 更新和绘制庆祝粒子
        celebration_particles = update_celebration_particles(celebration_particles)
        draw_celebration_particles(celebration_particles)
        
        # 庆祝背景色变化
        celebration_timer += 1
        r = int(128 + 127 * math.sin(celebration_timer * 0.05))
        g = int(128 + 127 * math.sin(celebration_timer * 0.07 + 2))
        b = int(128 + 127 * math.sin(celebration_timer * 0.09 + 4))
        
        # 绘制半透明庆祝背景
        celebration_surface = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
        celebration_surface.fill((r, g, b, 30))
        screen.blit(celebration_surface, (0, 0))
    else:
        # 绘制游戏元素
        paddle.draw()
        ball.draw()
        for brick in bricks:
            brick.draw()
    
    # 显示分数
    font = pygame.font.SysFont(None, 36)
    score_text = font.render(f"分数: {score}", True, TEXT_COLOR)
    screen.blit(score_text, (10, 10))
    
    # 游戏结束提示
    if game_over and not game_won:
        game_over_text = font.render("游戏结束! 按R键重新开始", True, (244, 117, 96))
        screen.blit(game_over_text, (WIDTH//2 - 150, HEIGHT//2))
        
        # 显示最终分数
        final_score_text = font.render(f"最终分数: {score}", True, TEXT_COLOR)
        screen.blit(final_score_text, (WIDTH//2 - 100, HEIGHT//2 + 50))
    
    # 游戏胜利提示
    if game_won:
        # 胜利文字
        win_font = pygame.font.SysFont(None, 60)
        win_text = win_font.render("恭喜通关!", True, (255, 215, 0))  # 金色
        screen.blit(win_text, (WIDTH//2 - 120, HEIGHT//2 - 60))
        
        # 显示最终分数
        final_score_text = font.render(f"最终分数: {score}", True, (76, 201, 240))
        screen.blit(final_score_text, (WIDTH//2 - 100, HEIGHT//2 + 10))
        
        # 庆祝提示
        celebration_text = font.render("按R键重新开始游戏", True, (155, 105, 245))
        screen.blit(celebration_text, (WIDTH//2 - 130, HEIGHT//2 + 60))
        
        # 绘制闪烁的星星
        star_size = 5 + 3 * math.sin(celebration_timer * 0.1)
        star_x = WIDTH//2 - 180
        star_y = HEIGHT//2 - 100
        pygame.draw.polygon(screen, (255, 255, 100), [
            (star_x, star_y),
            (star_x + star_size, star_y + star_size * 2),
            (star_x - star_size, star_y + star_size * 2)
        ])
        
        star_x2 = WIDTH//2 + 150
        star_y2 = HEIGHT//2 - 100
        pygame.draw.polygon(screen, (255, 255, 100), [
            (star_x2, star_y2),
            (star_x2 + star_size, star_y2 + star_size * 2),
            (star_x2 - star_size, star_y2 + star_size * 2)
        ])
    
    # 游戏暂停提示
    if game_paused and not game_over and not game_won:
        pause_text = font.render("游戏暂停", True, TEXT_COLOR)
        screen.blit(pause_text, (WIDTH//2 - 60, HEIGHT//2))
    
    # 更新显示
    pygame.display.flip()
    
    # 控制游戏帧率
    pygame.time.Clock().tick(60)

互动参数修改

调整以下参数，实时改变上方游戏的行为：

球的速度: 2

挡板宽度: 150

挡板速度: 12

球的颜色

挡板颜色