Mic*_*x2a 16
您可以尝试修改您的精灵,以便将其图像换成其他内部的图像update.这样,当渲染精灵时,它看起来就像动画一样.
编辑:
这是我制作的一个简单示例:
import pygame
import sys
def load_image(name):
image = pygame.image.load(name)
return image
class TestSprite(pygame.sprite.Sprite):
def __init__(self):
super(TestSprite, self).__init__()
self.images = []
self.images.append(load_image('image1.png'))
self.images.append(load_image('image2.png'))
# assuming both images are 64x64 pixels
self.index = 0
self.image = self.images[self.index]
self.rect = pygame.Rect(5, 5, 64, 64)
def update(self):
'''This method iterates through the elements inside self.images and
displays the next one each tick. For a slower animation, you may want to
consider using a timer of some sort so it updates slower.'''
self.index += 1
if self.index >= len(self.images):
self.index = 0
self.image = self.images[self.index]
def main():
pygame.init()
screen = pygame.display.set_mode((250, 250))
my_sprite = TestSprite()
my_group = pygame.sprite.Group(my_sprite)
while True:
event = pygame.event.poll()
if event.type == pygame.QUIT:
pygame.quit()
sys.exit(0)
# Calling the 'my_group.update' function calls the 'update' function of all
# its member sprites. Calling the 'my_group.draw' function uses the 'image'
# and 'rect' attributes of its member sprites to draw the sprite.
my_group.update()
my_group.draw(screen)
pygame.display.flip()
if __name__ == '__main__':
main()
它假设您有两个图像,image1.png并且image2.png在代码所在的同一文件夹中.
Ted*_*man 16
有两种类型的动画:帧依赖和时间依赖.两者都以类似的方式工作.
在主循环之前
- 将所有图像加载到列表中.
- 创建三个变量:
index,跟踪图像列表的当前索引.current_time或者current_frame跟踪自上次索引切换以来的当前时间或当前帧.animation_time或animation_frames定义切换图像前应经过的秒数或帧数.
在主循环期间
- 增加
current_time自上次递增以来经过的秒数,或增加current_frame1. - 检查是否
current_time >= animation_time或current_frame >= animation_frame.如果是,则继续3-5. - 重置
current_time = 0或current_frame = 0. - 增加索引,除非它等于或大于图像数量.在那种情况下,重置
index = 0. - 相应地更改精灵的图像.
一个完整的工作示例
import os
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 load_images(path):
"""
Loads all images in directory. The directory must only contain images.
Args:
path: The relative or absolute path to the directory to load images from.
Returns:
List of images.
"""
images = []
for file_name in os.listdir(path):
image = pygame.image.load(path + os.sep + file_name).convert()
images.append(image)
return images
class AnimatedSprite(pygame.sprite.Sprite):
def __init__(self, position, images):
"""
Animated sprite object.
Args:
position: x, y coordinate on the screen to place the AnimatedSprite.
images: Images to use in the animation.
"""
super(AnimatedSprite, self).__init__()
size = (32, 32) # This should match the size of the images.
self.rect = pygame.Rect(position, size)
self.images = images
self.images_right = images
self.images_left = [pygame.transform.flip(image, True, False) for image in images] # Flipping every image.
self.index = 0
self.image = images[self.index] # 'image' is the current image of the animation.
self.velocity = pygame.math.Vector2(0, 0)
self.animation_time = 0.1
self.current_time = 0
self.animation_frames = 6
self.current_frame = 0
def update_time_dependent(self, dt):
"""
Updates the image of Sprite approximately every 0.1 second.
Args:
dt: Time elapsed between each frame.
"""
if self.velocity.x > 0: # Use the right images if sprite is moving right.
self.images = self.images_right
elif self.velocity.x < 0:
self.images = self.images_left
self.current_time += dt
if self.current_time >= self.animation_time:
self.current_time = 0
self.index = (self.index + 1) % len(self.images)
self.image = self.images[self.index]
self.rect.move_ip(*self.velocity)
def update_frame_dependent(self):
"""
Updates the image of Sprite every 6 frame (approximately every 0.1 second if frame rate is 60).
"""
if self.velocity.x > 0: # Use the right images if sprite is moving right.
self.images = self.images_right
elif self.velocity.x < 0:
self.images = self.images_left
self.current_frame += 1
if self.current_frame >= self.animation_frames:
self.current_frame = 0
self.index = (self.index + 1) % len(self.images)
self.image = self.images[self.index]
self.rect.move_ip(*self.velocity)
def update(self, dt):
"""This is the method that's being called when 'all_sprites.update(dt)' is called."""
# Switch between the two update methods by commenting/uncommenting.
self.update_time_dependent(dt)
# self.update_frame_dependent()
def main():
images = load_images(path='temp') # Make sure to provide the relative or full path to the images directory.
player = AnimatedSprite(position=(100, 100), images=images)
all_sprites = pygame.sprite.Group(player) # Creates a sprite group and adds 'player' to it.
running = True
while running:
dt = clock.tick(FPS) / 1000 # Amount of seconds between each loop.
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
player.velocity.x = 4
elif event.key == pygame.K_LEFT:
player.velocity.x = -4
elif event.key == pygame.K_DOWN:
player.velocity.y = 4
elif event.key == pygame.K_UP:
player.velocity.y = -4
elif event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT or event.key == pygame.K_LEFT:
player.velocity.x = 0
elif event.key == pygame.K_DOWN or event.key == pygame.K_UP:
player.velocity.y = 0
all_sprites.update(dt) # Calls the 'update' method on all sprites in the list (currently just the player).
screen.fill(BACKGROUND_COLOR)
all_sprites.draw(screen)
pygame.display.update()
if __name__ == '__main__':
main()
什么时候选择哪个
与时间相关的动画允许您以相同的速度播放动画,无论帧速率有多慢或多快,或者计算机速度慢/快.这允许程序在不影响动画的情况下自由更改帧速率,即使计算机无法跟上帧速率,它也会保持一致.如果程序滞后,动画将赶上它本应该没有发生滞后的状态.
虽然,可能会发生动画周期与帧速率不同步,使动画周期看起来不规则.例如,假设我们每0.05秒更新一次帧,每0.075秒更新一次动画切换图像,那么循环将是:
- 第1帧; 0.00秒; 图片1
- 第2帧; 0.05秒; 图片1
- 第3帧; 0.10秒; 图片2
- 第4帧; 0.15秒; 图片1
- 第5帧; 0.20秒; 图片1
- 第6帧; 0.25秒; 图片2
等等...
如果您的计算机可以始终如一地处理帧速率,则依赖于帧可以看起来更平滑.如果滞后发生,它将暂停其当前状态并在滞后停止时重新启动,这使得滞后更加明显.这个替代方案稍微容易实现,因为您只需要current_frame在每次调用时增加1,而不是处理delta time(dt)并将其传递给每个对象.
精灵
结果
