0

我正在尝试创建一个动画，显示一个从屏幕边缘反弹的框。而且，我正在尝试使用基于时间的动画和脏矩形来实现这一点。

我能够为盒子设置动画；但是，动画非常不稳定。这里有两个视频可以说明我在说什么：

30 FPS：https ://www.youtube.com/watch?v=0de8ENxn7GQ

60 FPS：https ://www.youtube.com/watch?v=b5sXgeOlgHU

这是我的代码：

import sys
import random

import pygame


class Box:

    def __init__(self, x, y):
        self.width = 38
        self.height = 38
        self.color = (255, 0, 0)
        self.x = x
        self.y = y
        self.old_x = x
        self.old_y = y
        self.d_x = 1
        self.d_y = -1
        self.px_per_second = 200

    def move(self):
        self.old_x = self.x
        self.old_y = self.y
        if self.x <= 0:
            self.d_x *= -1
        if self.x + self.width >= task.width:
            self.d_x *= -1
        if self.y <= 0:
            self.d_y *= -1
        if self.y + self.height >= task.height:
            self.d_y *= -1
        self.x += ((self.px_per_second*self.d_x)*
                  (task.ms_from_last_frame/1000.0))
        self.y += ((self.px_per_second*self.d_y)*
                  (task.ms_from_last_frame/1000.0))

    def draw(self):
        self.x_i = int(self.x)
        self.y_i = int(self.y)
        self.old_x_i = int(self.old_x)
        self.old_y_i = int(self.old_y)
        _old_rect = (pygame.Rect(self.old_x_i, self.old_y_i, 
                                 self.width, self.height))
        _new_rect = (pygame.Rect(self.x_i, self.y_i, self.width, self.height))
        if _old_rect.colliderect(_new_rect):
            task.dirty_rects.append(_old_rect.union(_new_rect))
        else:
            task.dirty_rects.append(_old_rect)
            task.dirty_rects.append(_new_rect)
        pygame.draw.rect(task.screen, task.bg_color, _old_rect)
        pygame.draw.rect(task.screen, (self.color), _new_rect)


class ObjectTask:

    def __init__(self, width, height):
        pygame.init()
        self.max_fps = 60
        self.clock = pygame.time.Clock()
        self.width = width
        self.height = height
        self.bg_color = (255, 255, 255)
        self.dirty_rects = []
        self.screen = pygame.display.set_mode((self.width, self.height),
                                               pygame.FULLSCREEN)
        self.screen.fill(self.bg_color)
        pygame.display.update()

    def animation_loop(self):
        self.box1 = Box(self.width/2, self.height/2)
        while 1:
            self.ms_from_last_frame = self.clock.tick(self.max_fps)
            self.box1.move()
            self.box1.draw()
            pygame.display.update(self.dirty_rects)
            self.dirty_rects = []
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()


if __name__ == "__main__":
    task = ObjectTask(726, 546)
    task.animation_loop()

我能做些什么来减少波动吗？另外，我是 Pygame 的新手，所以如果您发现我做错/低效的任何事情，请告诉我。

我在具有 12 GB RAM 的 64 位 Windows 7、i5-6300u 机器上运行动画。我正在使用 Python 2.7.12 和 Pygame 1.9.2。

提前致谢！

4

1 回答 1

1

我有一些时间，想我可以展示我将如何编写这个程序。我试图解释评论中的一切。我删除了你的ObjectTask类，因为所有东西都可以放在一个函数中，而且函数很整洁（在我看来，它们更快更容易阅读/调试）。

我还对其进行了更改，以便您将变量传递给方法，而不是从全局变量（task对象）中读取它，因为它使程序更加模块化并且更容易更改/重构。

最后，我将一些属性合二为一。x并且y是连接的，所以我把它们放在一个共同的属性position中。

import pygame
pygame.init()


# It's convenient if all your visible objects inherit 'pygame.sprite.Sprite'. It allows you to use sprite groups and
# some useful collision detection functions.
class Box(pygame.sprite.Sprite):
    def __init__(self, x, y, screen_width, screen_height):
        super(Box, self).__init__()  # Initialize the 'pygame.sprite.Sprite' (the super class).
        self.size = (38, 38)
        self.color = (255, 0, 0)
        self.position = pygame.math.Vector2(x, y)  # Vector is a 2-element tuple with some neat methods shown later.
        self.velocity = pygame.math.Vector2(200, -200)
        self.screen_size = (screen_width, screen_height)

        # Instead of drawing the rectangle onto the screen we're creating an image which we 'blit' (put) onto the screen
        self.image = pygame.Surface(self.size)
        self.image.fill(self.color)

        # We create a rectangle same size as our image and where the top left of the rectangle is positioned at our
        # 'position'.
        self.rect = self.image.get_rect(topleft=self.position)

    # Changing name to update. Game objects usually have two methods 'update' and 'draw', where 'update' is the function
    # that will be called every game loop and update the object, and 'draw' draws the game object every game loop.
    def update(self, dt):  # 'dt' (delta time) is what you formerly called task.ms_from_last_frame.
        # unpack the variables so it's easier to read. Not necessary, but nice.
        width, height = self.size
        x, y = self.position
        screen_width, screen_height = self.screen_size

        if x <= 0 or x + width >= screen_width:  # Only one if-statement needed.
            self.velocity[0] *= -1  # First element is the x-velocity.
        if y <= 0 or y + height >= screen_height:
            self.velocity[1] *= -1  # Second element is y-velocity.

        # Addition and subtraction works element-wise with vectors. Adding our two vectors 'position' and 'velocity':
        #    position += velocity  <=>  position = position + velocity
        # is the same as this:
        #    position_x, position_y = position_x + velocity_x, position_y + position_y
        #
        # Multiplication and division works on all elements. So 'velocity * dt / 1000' is the same as:
        #    velocity_x * dt / 1000, velocity_y * dt / 1000
        self.position += self.velocity * dt / 1000

        # Instead of creating a new rect we just move the top left corner of our rect to where we calculated our
        # position to be.
        self.rect.topleft = self.position

    # 'surface' is the Surface object you want to draw on (in this case the screen).
    def draw(self, surface):
        # This puts our image unto the screen at the given position.
        surface.blit(self.image, self.position)


def main():
    max_fps = 60
    clock = pygame.time.Clock()
    bg_color = (255, 255, 255)
    width, height = 726, 546
    screen = pygame.display.set_mode((width, height))
    screen.fill(bg_color)

    box1 = Box(width / 2, height / 2, width, height)
    sprite_group = pygame.sprite.Group(box1)
    while 1:
        # First handle time.
        dt = clock.tick(max_fps)

        # Then handle events.
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                quit()  # 'pygame.quit' does not quit the program! It only uninitialize the pygame modules.
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    quit()

        # Update your objects.
        sprite_group.update(dt)  # Calls the update method on all sprites in the group.

        # Draw your objects.
        screen.fill(bg_color)  # Clear the screen.
        sprite_group.draw(screen)  # Draws all sprites on the screen using the 'image' and 'rect' attributes.

        # Display everything you've drawn.
        pygame.display.update()


if __name__ == "__main__":
    main()

在这个例子中，我没有费心跟踪脏矩形。我经历过这是导致抖动的原因。我提供的这个例子应该可以正常工作，但总是会不时出现一些抖动。如果您想通过跟踪脏矩形来尝试此示例，只需更改：

sprite_group = pygame.sprite.Group(box1)

至

sprite_group = pygame.sprite.RenderUpdates(box1)

和

sprite_group.draw(screen)  # Draws all sprites on the screen using the 'image' and 'rect' attributes.

# Display everything you've drawn.
pygame.display.update()

至

dirty_rects = sprite_group.draw(screen)  # Draws all sprites on the screen using the 'image' and 'rect' attributes.

# Display everything you've drawn.
pygame.display.update(dirty_rects)  # Update only the areas that have changes
于 2017-01-13T17:12:48.773 回答