Great job getting the core Pong mechanics up and running without relying on pygame or other external tools! Adding breakable blocks is a perfect next feature, and it’s totally doable with Python’s built-in capabilities. Here’s a step-by-step implementation that fits right into your existing code:

1. Create a Block Structure to Track Active Blocks #

First, we need a way to store each block’s position, size, and whether it’s still visible. A simple class works perfectly here—it keeps all the block’s data organized:

class Block:
    def __init__(self, x, y, width, height):
        self.x = x
        self.y = y
        self.width = width
        self.height = height
        self.active = True  # True = block is on screen; False = destroyed

2. Generate the Grid of Blocks at the Top Center #

Next, we’ll populate a list with blocks arranged in a grid. We’ll calculate the starting position to center the grid horizontally, then loop through rows and columns to create each block:

# Define your game window constants (adjust these to match your existing code)
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

# Block settings
BLOCK_WIDTH = 60
BLOCK_HEIGHT = 20
BLOCKS_PER_ROW = 10
NUM_ROWS = 3
BLOCK_SPACING = 5  # Space between blocks

blocks = []

# Calculate starting X to center the grid
start_x = (SCREEN_WIDTH - (BLOCKS_PER_ROW * (BLOCK_WIDTH + BLOCK_SPACING))) // 2
start_y = 50  # Keep blocks near the top of the screen

# Generate the block grid
for row in range(NUM_ROWS):
    for col in range(BLOCKS_PER_ROW):
        block_x = start_x + col * (BLOCK_WIDTH + BLOCK_SPACING)
        block_y = start_y + row * (BLOCK_HEIGHT + BLOCK_SPACING)
        blocks.append(Block(block_x, block_y, BLOCK_WIDTH, BLOCK_HEIGHT))

3. Draw Only Active Blocks Each Frame #

In your existing drawing function, add a loop to render only blocks that are still active (self.active = True). This way, destroyed blocks won’t reappear:

# Example for a turtle-based drawing system (adjust to match your rendering method)
def draw_game():
    # Clear the screen first
    screen.clear()

    # Draw your existing elements (paddle, ball, score, etc.)
    draw_paddle()
    draw_ball()

    # Draw active blocks
    for block in blocks:
        if block.active:
            turtle.penup()
            turtle.goto(block.x, block.y)
            turtle.pendown()
            turtle.fillcolor("#2ecc71")  # Green blocks—change color as you like
            turtle.begin_fill()
            # Draw rectangle
            for _ in range(2):
                turtle.forward(block.width)
                turtle.right(90)
                turtle.forward(block.height)
                turtle.right(90)
            turtle.end_fill()

    screen.update()

4. Add Collision Detection Between Ball and Blocks #

Now, we need to check if the ball hits any active block. When a collision happens, we’ll mark the block as inactive and reverse the ball’s direction (just like it does with the paddle or walls). Here’s a simplified collision check—you can refine it for better precision:

# Assuming your ball has these attributes: x, y, dx (x speed), dy (y speed), radius
def check_block_collisions():
    global ball_dx, ball_dy  # Use global if your ball variables are outside this function

    for block in blocks:
        if block.active:
            # Check if the ball's bounds overlap with the block's bounds
            ball_left = ball.x - ball.radius
            ball_right = ball.x + ball.radius
            ball_top = ball.y + ball.radius
            ball_bottom = ball.y - ball.radius

            block_left = block.x
            block_right = block.x + block.width
            block_top = block.y + block.height
            block_bottom = block.y

            # Collision condition: ball overlaps with block on all axes
            if (ball_right > block_left and 
                ball_left < block_right and 
                ball_top > block_bottom and 
                ball_bottom < block_top):
                # Destroy the block
                block.active = False
                # Reverse ball direction (simplified: flip y-axis; refine for side-specific bounces)
                ball_dy *= -1
                # Exit loop early to avoid multiple collisions in one frame
                break

5. Integrate into Your Game Loop #

Finally, call the collision detection function right after you update the ball’s position in your main game loop:

import time

game_running = True
while game_running:
    # Update ball position
    ball.x += ball_dx
    ball.y += ball_dy

    # Check existing collisions (walls, paddle)
    check_wall_collisions()
    check_paddle_collision()

    # Check block collisions
    check_block_collisions()

    # Redraw everything
    draw_game()

    # Control frame rate to keep the game smooth
    time.sleep(0.01)

Quick Tips for Polish #

• Refine Bounce Direction: Instead of just flipping the y-axis, check which side of the block the ball hit. For example, if the ball hits the left/right edge, flip ball_dx; if it hits top/bottom, flip ball_dy. This makes the bounces feel more realistic.
• Handle Multiple Collisions: If you want the ball to destroy multiple blocks in one frame (unlikely but possible), remove the break statement in the collision loop.
• Visual Feedback: Change the block’s color right before destroying it, or add a small animation (like a flash) to make the destruction feel satisfying.

内容的提问来源于stack exchange，提问作者Ben Roux