Animierte Sprites von ein paar Bilder

Ich habe die Suche nach ein paar gute tutorial zur Erstellung einfacher sprite-animation von paar-Bildern in Python mit Pygame. Ich habe noch nicht das gefunden was ich Suche.

Meine Frage ist einfach: wie macht man einen animierten sprite aus paar Bilder (für ein Beispiel: machen Sie einige Bilder der explosion mit Abmessungen 20x20px eins zu sein, sondern animiert)

Irgendwelche guten Ideen?

Sie möchten ein spritesheet. Sie können entweder laden von mehreren Bildern, oder eine einzige mit Quelle Rects festgelegt, wenn Sie blit -. Hier ein weiteres Beispiel: pygame.org/wiki/Spritesheet?parent=CookBook

InformationsquelleAutor lbartolic | 2012-12-26

Könnten Sie versuchen, ändern Sie Ihre sprite, so dass es-swaps aus seinem Bild für einen anderen eine im update. So, wenn das sprite gerendert wird, es werde animiert.

Bearbeiten:

Hier ist ein schnelles Beispiel richtete ich mich auf:

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()

Es wird davon ausgegangen, dass Sie zwei Bilder, sogenannte image1.png und image2.png im selben Ordner der code ist in.

hey... willst du vielleicht wissen, wie zu verlangsamen die animation? problem ist, wenn ich mit pygame.Zeit.Uhr, das ganze Spiel wird verlangsamt, nicht nur animation.
Was könnten Sie versuchen, zu tun ist das hinzufügen von self.counter = 0 innen __init__. Dann, im inneren update erhöhen self.counter. Wenn es gleich einige hohe Anzahl (vielleicht 99), dann setzen Sie es auf null und Inkrementieren self.index durch eine. So, die animation wird aktualisiert, nur einmal alle 100 ticks. Ich bin sicher, es gibt bessere Wege, aber dieser Weg ist ziemlich einfach und wird wahrscheinlich für Sie arbeiten.
Verspäteter Kommentar, aber die Art, wie ich es verwenden self.image = self.images[math.floor(self.index)] und erhöhen self.index von 0,08 oder so.

InformationsquelleAutor Michael0x2a

Es gibt zwei Arten von animation: frame-abhängige und zeitabhängige. Beide arbeiten auf ähnliche Weise.

Vor der main-Schleife

Laden alle Bilder in eine Liste.
Erstellen Sie drei Variablen:
1. index, das hält den überblick auf den aktuellen index der Bildliste.
2. current_time oder current_frame Verfolgung der aktuellen Uhrzeit oder des aktuellen Rahmens seit der letzten index umgestellt.
3. animation_time oder animation_frames definieren, wie viele Sekunden oder frames übergeben sollten, vor dem Wechsel Bild.

Während die main-loop

Inkrement current_time durch die Anzahl der Sekunden, die vergangen ist, seit wir das Letzte mal erhöht, oder Inkrement current_frame 1.
Prüfen, ob current_time >= animation_time oder current_frame >= animation_frame. Wenn das stimmt weiterhin mit 3-5.
Zurücksetzen der current_time = 0 oder current_frame = 0.
Erhöhen Sie den index, es sei denn, es werden gleich oder größer als die Menge der Bilder. In diesem Fall zurückgesetzt index = 0.
Ändern Sie die sprite-image entsprechend.

Ein voll funktionsfähiges Beispiel

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()

, Wenn Sie zu wählen, welchen

Zeitabhängige animation ermöglicht es Ihnen, spielen Sie die animation mit der gleichen Geschwindigkeit, egal wie langsam/schnell die frame-rate ist, oder langsam/schnell Ihr computer ist. Dies ermöglicht Ihrem Programm, um frei ändern Sie die framerate, ohne die animation und es werden auch konsequent sein, selbst wenn der computer nicht mithalten kann mit der framerate. Wenn das Programm hinkt der animation fangen bis zu dem Zustand, den es haben sollte so, wenn keine Verzögerung geschehen war.

Obwohl, kann es passieren, dass die animation Zyklus nicht synchron mit der framerate, so dass die animation Zyklus erscheinen unregelmäßig. Zum Beispiel, sagen, dass wir die frames aktualisieren jeden 0.05 zweite und die animation wechseln-Bild alle 0.075 zweite, dann der Zyklus wäre:

Bild 1; 0.00 Sekunden; Bild 1
Bild 2; 0,05 Sekunden; Bild 1
Bild 3; 0,10 Sekunden; Bild 2
Frame 4; 0,15 Sekunden; Bild 1
Bild 5; 0.20 Sekunden; Bild 1
Frame 6; 0,25 Sekunden; Bild 2

Und so weiter...

Frame-abhängige kann glatter Aussehen, wenn Ihr computer verarbeiten kann, die framerate konstant. Wenn die Verzögerung passiert, es wird pause in seinem aktuellen Zustand und neu starten, wenn die Verzögerung aufhört, wodurch die Verzögerung mehr spürbar. Diese alternative ist etwas einfacher zu implementieren, da brauchen Sie nur zu erhöhen current_frame mit 1 auf jedem Aufruf, statt sich mit der delta-Zeit (dt) und übergeben Sie es an jedem Objekt.

Sprites

Animierte Sprites von ein paar Bilder

Ergebnis

Animierte Sprites von ein paar Bilder

Gute Antwort. Wäre noch besser, wenn es verwendet die enthalten pygame.sprite.Sprite Klasse.
Ja, ich dachte, darüber war sich aber nicht sicher, weil es machen würde, die Antwort schwieriger für Anfänger zu verstehen, wie es wäre, einführen, erbschaft-und sprite-Gruppen. Könnte meine Meinung ändern, obwohl, und implementieren Sie es später, wenn ich Zeit.
Wenn nichts anderes, ich denke, Sie sollten ändern Sie den Namen der Klasse, so ist es nicht identisch mit dem in der pygame—, die ich denke, könnte vor allem verwirrend sein, um Leute in den Prozess von Anfang an um mehr darüber zu erfahren.
Das ist ein guter Punkt. Ich änderte den Namen und fügte hinzu, in den sprite-Gruppen. Es scheint einfach genug, immer noch.
Das hat nicht funktioniert für mich, weil clock.tick(FPS) / 1000 ergibt immer 0 (integer). Stattdessen habe ich verwendet dt = clock.tick(FPS) / 1000.0 zu zwingen, floating-point-Nutzung.
Ja, das gilt auch für Python 2. Es ist nicht notwendig für Python 3.

InformationsquelleAutor Ted Klein Bergman

2

Sollten Sie alle haben Ihre sprite-Animationen auf einer großen "Leinwand", also für 3 20x20 explosion von sprite-Bildern haben Sie 60x20 Bild. Jetzt können Sie direkt frames laden Sie einen Bereich des Bildes.

Innen Ihre sprite-Klasse, die meisten wahrscheinlich in der update-Methode sollten Sie etwas wie dies (hardcoded für Einfachheit, ich bevorzuge die separate Klasse, die Verantwortung für die Auswahl der richtigen Animations-frame). self.f = 0 auf __init__.
```
def update(self):
    images = [[0, 0], [20, 0], [40, 0]]
    self.f += 1 if self.f < len(images) else 0
    self.image = your_function_to_get_image_by_coordinates(images[i])
```
InformationsquelleAutor Ruslan Osipov

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.