Hey there! Let's walk through how to implement synchronized segmented rotation around a combined center of mass (400,263.5) in Pygame, while letting internal dynamic objects behave under gravity. This approach keeps your segmented frame rotating as a single unit while keeping the physics for the internal objects separate.

The key here is to treat each segment relative to the fixed center of mass (COM) instead of updating their global positions directly. By converting each segment's position to a local offset from the COM, rotating that offset, then converting back to global coordinates, all segments will rotate in perfect sync around the COM.

First, you need to store each segment's initial position relative to the COM. Let's say you have four rectangular segments—calculate their local offsets once at the start:

import pygame
import math

# Initialize Pygame
pygame.init()
screen = pygame.display.set_mode((800, 600))
clock = pygame.time.Clock()

# Fixed center of mass
COM = pygame.math.Vector2(400, 263.5)

# Define segments: each has a local offset from COM, size, color
segments = [
    {"offset": pygame.math.Vector2(-50, -63.5), "size": (100, 20), "color": (255, 0, 0)},
    {"offset": pygame.math.Vector2(50, -63.5), "size": (100, 20), "color": (0, 255, 0)},
    {"offset": pygame.math.Vector2(-50, 63.5), "size": (100, 20), "color": (0, 0, 255)},
    {"offset": pygame.math.Vector2(50, 63.5), "size": (100, 20), "color": (255, 255, 0)},
]

# Initialize rotation state
rotation_angle = 0.0
angular_speed = 30  # Degrees per second (adjust for feel)

In each frame, update the rotation angle, then compute each segment's new global position by rotating its local offset around the COM. We'll use Pygame's vector rotation for clean, efficient calculations:

def update_segments(segments, com, angle):
    updated_segments = []
    for seg in segments:
        # Rotate the local offset vector around the origin (COM)
        rotated_offset = seg["offset"].rotate(angle)
        # Calculate global position by adding rotated offset to COM
        global_pos = com + rotated_offset
        # Create a rotated surface for the segment (to draw correctly)
        surf = pygame.Surface(seg["size"], pygame.SRCALPHA)
        surf.fill(seg["color"])
        rotated_surf = pygame.transform.rotate(surf, -angle)  # Reverse angle for counterclockwise rotation
        # Align the rotated surface's center to the computed global position
        rect = rotated_surf.get_rect(center=global_pos)
        updated_segments.append({"surf": rotated_surf, "rect": rect})
    return updated_segments

For the internal object(s) affected by gravity, track their position and velocity independently of the rotating segments. Gravity acts as a constant acceleration in the y-direction:

# Initialize dynamic object (e.g., a bouncing ball)
dynamic_obj = {
    "pos": pygame.math.Vector2(400, 200),
    "vel": pygame.math.Vector2(0, 0),
    "radius": 15,
    "color": (128, 0, 128),
    "gravity": 98  # Pixels per second squared (adjust for feel)
}

def update_dynamic_object(obj, dt):
    # Apply gravity to velocity (use dt for frame-rate consistency)
    obj["vel"].y += obj["gravity"] * dt
    # Update position with velocity
    obj["pos"] += obj["vel"] * dt
    # Optional: Add screen boundary collision with bounce
    if obj["pos"].y + obj["radius"] > screen.get_height():
        obj["vel"].y *= -0.8  # Bounce with dampening
        obj["pos"].y = screen.get_height() - obj["radius"]
    if obj["pos"].x - obj["radius"] < 0 or obj["pos"].x + obj["radius"] > screen.get_width():
        obj["vel"].x *= -0.8
        obj["pos"].x = max(obj["radius"], min(obj["pos"].x, screen.get_width() - obj["radius"]))

Put everything together in the main loop—handle events, update rotation, refresh segments, update the dynamic object, then draw everything:

running = True
while running:
    dt = clock.tick(60) / 1000.0  # Delta time in seconds (for consistent motion)
    screen.fill((30, 30, 30))

    # Handle exit event
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Update rotation angle (consistent speed across frame rates)
    rotation_angle += angular_speed * dt

    # Update all elements
    current_segments = update_segments(segments, COM, rotation_angle)
    update_dynamic_object(dynamic_obj, dt)

    # Draw rotated segments
    for seg in current_segments:
        screen.blit(seg["surf"], seg["rect"])

    # Draw dynamic object
    pygame.draw.circle(
        screen, 
        dynamic_obj["color"], 
        (int(dynamic_obj["pos"].x), int(dynamic_obj["pos"].y)), 
        dynamic_obj["radius"]
    )

    # Refresh display
    pygame.display.flip()

pygame.quit()

• Frame-Rate Consistency: Using dt (delta time) ensures rotation and gravity speeds stay constant regardless of how fast your game runs—critical for smooth, predictable motion.
• Rotation Direction: We use -angle when rotating surfaces because Pygame's transform.rotate defaults to clockwise rotation; flip the sign if you want clockwise frame rotation instead.
• Collision Detection (Optional): To make the dynamic object collide with rotating segments, add collision checks between the object's circle and each segment's rect in the main loop (Pygame's colliderect or custom circle-rect collision logic works here).

内容的提问来源于stack exchange，提问作者Ken Morison