sge-pygame旋转父母和子女的精灵

Question

我一直在研究并试图解决这个问题很长一段时间。我正在尝试创建一个父/子附加系统，以便当父项移动时，附加到它的子项移动/旋转/缩放相同的系统。我遇到的主要问题是轮换。

这是我目前为孩子们使用的代码：

def _rotate(self, origin, point, angle):
  ox, oy = origin
  px, py = point

  qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)
  qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)

  return qx, qy

_rotate代码在搜索我的问题答案时，在我找到的原点周围旋转2D点。我正在使用的点是每个盒子/精灵的中心。

旋转父级时，我使用sge-pygame image_rotation然后继续进行子级定位。在此之后，我需要根据新位置和旋转孩子的新角度计算出孩子的旋转。

发生的事情的图像：

初​​始

和

旋转10deg

父是大矩形，盒子是孩子。

我遇到的第二个问题是弄清楚孩子的旋转角度是什么，以使其与父母一致。我通过stackflow发现使用math.atan2应该用于此，但我似乎无法弄清楚如何使用它。

对此的任何帮助将不胜感激。

谢谢

Answer 1

您可以在实例化期间将枢轴和所需的偏移量传递给子项（我在下面的示例中使用pygame.math.Vector2）。如果父级移动，则更新其所有子级（我将它们存储在列表中）并向其传递父级的速度，他们也可以使用它来更新其位置。

旋转的工作方式类似，您只需将角度传递给子项，然后旋转它们的偏移矢量和图像，并将新矩形的中心设置为旧中心加上偏移量。

import sys
import pygame as pg
from pygame.math import Vector2


class Player(pg.sprite.Sprite):

    def __init__(self, pos, *groups):
        super().__init__(groups)
        self.image = pg.Surface((90, 40), pg.SRCALPHA)
        self.image.fill(pg.Color('steelblue2'))
        self.orig_image = self.image
        self.rect = self.image.get_rect(center=pos)
        self.vel = Vector2(0, 0)
        self.pos = Vector2(pos)
        self.angle = 0
        # A list that holds all children instances.
        self.children = [Child(self.pos, Vector2(90, 30), *groups)]

    def update(self):
        self.pos += self.vel
        self.rect.center = self.pos
        for child in self.children:
            child.move(self.vel)

    def rotate(self, angle):
        self.angle += angle
        # Rotate the image and generate a new rect to keep it centered.
        self.image = pg.transform.rotate(self.orig_image, self.angle)
        self.rect = self.image.get_rect(center=self.rect.center)
        # Rotate the children.
        for child in self.children:
            child.rotate(angle)


class Child(pg.sprite.Sprite):

    def __init__(self, pos, offset, *groups):
        super().__init__(groups)
        self.image = pg.Surface((50, 30), pg.SRCALPHA)
        self.image.fill(pg.Color('mediumaquamarine'))
        self.orig_image = self.image
        self.rect = self.image.get_rect(center=pos)
        self.pos = Vector2(pos)  # Parent center.
        # Offset from parent center.
        self.offset = Vector2(offset)
        self.angle = 0

    def move(self, vel):
        self.pos += vel
        self.rect.center = self.pos + self.offset

    def rotate(self, angle):
        # Rotate the offset vector (negative angle otherwise it would
        # rotate in the wrong direction).
        self.offset.rotate_ip(-angle)
        self.angle += angle
        # Rotate the image.
        self.image = pg.transform.rotate(self.orig_image, self.angle)
        # Add the new offset to the center.
        self.rect = self.image.get_rect(center=self.rect.center + self.offset)


def main():
    screen = pg.display.set_mode((640, 480))
    clock = pg.time.Clock()
    sprite_group = pg.sprite.Group()
    player = Player((100, 250), sprite_group)

    done = False

    while not done:
        for event in pg.event.get():
            if event.type == pg.QUIT:
                done = True
            elif event.type == pg.KEYDOWN:
                if event.key == pg.K_d:
                    player.vel.x = 5
                elif event.key == pg.K_r:
                    player.rotate(15)
                elif event.key == pg.K_c:
                    player.children.append(Child(
                        player.pos, Vector2(-90, -30), sprite_group))
            elif event.type == pg.KEYUP:
                if event.key == pg.K_d:
                    player.vel.x = 0

        sprite_group.update()
        screen.fill((30, 30, 30))
        sprite_group.draw(screen)

        pg.display.flip()
        clock.tick(30)


if __name__ == '__main__':
    pg.init()
    main()
    pg.quit()
    sys.exit()

按“d”向右移动，按“r”旋转，按“c”按钮添加更多儿童。

Answer 2

您首先将父级和子级旋转相同的数量（在此示例中，假设应该控制父级，而不应该控制子级）。然后，您只需将子项移动到父项的轴心点（在本例中为其中心），并在父项面向的方向上添加一个额外的偏移量（偏移量当然是可选的）。

from math import cos, sin, radians
import pygame
pygame.init()

SIZE = WIDTH, HEIGHT = 720, 480
BACKGROUND_COLOR = pygame.Color('black')
FPS = 60

screen = pygame.display.set_mode(SIZE)
clock = pygame.time.Clock()


def update_child_rotation(parent, child, degrees, offset):
    # Rotate the parent and child with the same angle.
    parent.rotate(degrees)
    child.rotate(degrees)

    # Calculate the direction the parent is pointing. If you remember the unit circle then you'll
    # know that cos(angle) represent the x value and sin(angle) the y value. At angle = 0 the direction
    # is to the right (which is what your sprite should be pointing, otherwise you'll have to add an angle
    # offset), and it rotates counterclockwise. The minus in '-sin' is because pygame uses positive y as downwards.
    angle_in_radians = radians(parent.angle)
    direction = pygame.math.Vector2(cos(angle_in_radians), -sin(angle_in_radians))

    # Update the child's position to the parent's position but with an added offset in the direction the parent
    # is pointing.
    child.position = parent.position + direction * offset


class Entity(pygame.sprite.Sprite):

    def __init__(self, position, size):
        super().__init__()

        self.original_image = pygame.Surface(size)
        self.original_image.fill((255, 0, 0))
        self.original_image.set_colorkey(BACKGROUND_COLOR)

        self.image = self.original_image
        self.rect = self.image.get_rect(center=position)

        self.angle = 0
        self.position = pygame.math.Vector2(position)
        self.velocity = pygame.math.Vector2(0, 0)

    def rotate(self, degrees):
        self.angle = (self.angle + degrees) % 360
        self.image = pygame.transform.rotate(self.original_image, self.angle)
        self.rect = self.image.get_rect(center=self.position)

    def update(self, dt):
        self.position += self.velocity
        self.rect.center = self.position


def main():
    parent = Entity(position=(200, 200), size=(128, 32))
    child = Entity(position=(356, 200), size=(32, 32))
    all_sprites = pygame.sprite.Group(parent, child)

    running = True
    while running:

        dt = clock.tick(FPS) / 1000

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_q:
                    update_child_rotation(parent, child, 10, 156)
                elif event.key == pygame.K_e:
                    update_child_rotation(parent, child, -10, 156)
            elif event.type == pygame.KEYUP:
                if event.key == pygame.K_RIGHT or event.key == pygame.K_LEFT:
                    parent.velocity.x = 0
                elif event.key == pygame.K_DOWN or event.key == pygame.K_UP:
                    parent.velocity.y = 0

        all_sprites.update(dt)

        screen.fill(BACKGROUND_COLOR)
        all_sprites.draw(screen)
        pygame.display.update()


if __name__ == '__main__':
    main()