使用 pygame 实现可交互平台

用户希望在游戏中能够绘制可交互的平台，并实现与平台的碰撞检测。目前，用户已经实现了一个使用鼠标绘制线条的函数 drawGradientLine，该函数通过绘制许多小圆圈来模拟线条。用户考虑将这些小圆圈转换为 pygame.Rect 对象来实现碰撞检测，但这样会导致大量 Rect 对象的创建。因此，用户希望找到一种更有效的方法来实现可交互平台和碰撞检测。

2、解决方案

• 使用多边形来表示平台。 这种方法可以减少所需的 Rect 对象数量，同时仍然可以实现准确的碰撞检测。可以将平台的形状表示为一个多边形的顶点列表，然后使用 pygame.Polygon 类来创建多边形对象。
• 使用四叉树进行碰撞检测。 四叉树是一种空间分割数据结构，可以将游戏世界划分为更小的区域。这可以减少需要检查的碰撞对的数量，从而提高碰撞检测的效率。
• 使用掩码进行碰撞检测。 掩码是一种二进制图像，其中每个像素的值表示该像素是否属于平台。可以通过使用掩码与玩家角色的碰撞箱进行位运算来快速检查碰撞。

下面是一个使用多边形和四叉树来实现可交互平台和碰撞检测的代码示例：

import pygame
import numpy as np
from shapely.geometry import Polygon

class Platform:
    def __init__(self, points):
        self.points = points
        self.polygon = Polygon(points)
        self.mask = np.zeros((100, 100), dtype=np.uint8)
        pygame.draw.polygon(self.mask, (255, 255, 255), points)

    def draw(self, screen):
        pygame.draw.polygon(screen, (0, 255, 0), self.points)

    def check_collision(self, player):
        return self.polygon.intersects(player.rect)

class QuadTree:
    def __init__(self, boundary, capacity):
        self.boundary = boundary
        self.capacity = capacity
        self.points = []
        self.children = []

    def insert(self, point):
        if not self.boundary.contains(point):
            return False

        if len(self.points) < self.capacity:
            self.points.append(point)
            return True

        if not self.children:
            self.subdivide()

        return self.children[0].insert(point) or self.children[1].insert(point) or self.children[2].insert(point) or self.children[3].insert(point)

    def subdivide(self):
        x1, y1, x2, y2 = self.boundary.bounds
        mid_x = (x1 + x2) / 2
        mid_y = (y1 + y2) / 2

        self.children.append(QuadTree(pygame.Rect(x1, y1, mid_x - x1, mid_y - y1), self.capacity))
        self.children.append(QuadTree(pygame.Rect(mid_x, y1, x2 - mid_x, mid_y - y1), self.capacity))
        self.children.append(QuadTree(pygame.Rect(x1, mid_y, mid_x - x1, y2 - mid_y), self.capacity))
        self.children.append(QuadTree(pygame.Rect(mid_x, mid_y, x2 - mid_x, y2 - mid_y), self.capacity))

    def query_range(self, range):
        points = []

        if not self.boundary.intersects(range):
            return points

        for point in self.points:
            if range.contains(point):
                points.append(point)

        for child in self.children:
            points.extend(child.query_range(range))

        return points

def main():
    pygame.init()
    screen = pygame.display.set_mode((640, 480))
    clock = pygame.time.Clock()

    # Create a quad tree to store the platforms
    quad_tree = QuadTree(pygame.Rect(0, 0, 640, 480), 10)

    # Create some platforms
    platforms = [
        Platform([(100, 100), (200, 100), (200, 200), (100, 200)]),
        Platform([(300, 100), (400, 100), (400, 200), (300, 200)]),
        Platform([(500, 100), (600, 100), (600, 200), (500, 200)])
    ]

    # Insert the platforms into the quad tree
    for platform in platforms:
        quad_tree.insert(platform)

    # Create a player character
    player = pygame.Rect(320, 240, 32, 32)

    # Game loop
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

        # Get the platforms that are near the player
        nearby_platforms = quad_tree.query_range(player)

        # Check for collision between the player and the platforms
        for platform in nearby_platforms:
            if platform.check_collision(player):
                player.move_ip(0, -player.height)

        # Update the player's position
        player.move_ip(0, 1)

        # Draw the game world
        screen.fill((0, 0, 0))
        for platform in platforms:
            platform.draw(screen)
        pygame.draw.rect(screen, (255, 255, 255), player)

        # Flip the display
        pygame.display.flip()

        # Tick the clock
        clock.tick(60)

    pygame.quit()

if __name__ == "__main__":
    main()

这个示例使用了一个四叉树来存储平台，并使用掩码来进行碰撞检测。这使得碰撞检测非常高效，即使有大量的平台。