Üblicherweise ist jeder Zeichnungsbefehl sofort auf dem Bildschirm sichtbar. Daher erscheint beim Löschen des Bildschirmes mit clear() kurz ein leeres Grafikfenster, was zu einem unschönen Bildschirmflackern führen kann. Um dies zu vermeiden, verwendest du die sogenannte Doppelbufferung. Du rufst den Befehl enableRepaint(False) auf, der bewirkt, dass die Grafikbefehle in einem unsichtbaren Bildbuffer ausgeführt werden und nicht mehr automatisch im Grafikfenster erscheinen. Erst wenn das neue Bild vollständig im Buffer aufgebaut ist, stellst du mit repaint() den ganzen Buffer auf einmal auf dem Bildschirm dar.

In deinem Beispiel zeigst du die Flügelbewegungen eines Vogels. Dieser besteht der Einfachheit halber aus einem runden Körper und zwei Kreisbögen, die links und rechts vom Körper gezeichnet werden. Um die Lage der Flügel einzustellen,  drehst du die Turtle vor dem Zeichnen des Flügels in die passende Richtung. Die Funktion bird(angle) hat daher einen Parameter angle, der die Turtle-Richtung vor dem Zeichnen der Flügel angibt. Dieser Winkel steigt bei der Abwärtsbewegung von 5° bis 55° und fällt bei der Aufwärtsbewegung von 55° bis 5°.

Da du enableRepaint(False) verwendest, musst du jedesmal nach dem Zeichnen repaint() aufrufen, damit der Inhalt des Bildbuffers auf dem Bildschirm sichtbar wird. Zum Löschen des Bildschirmes verwendest du den Befehl clear("lightSkyBlue"). Dadurch erhältst du eine hellblaue Hintergrundfarbe.

from gturtle import *

def drawBird(angle):
    dot(20)
    right(angle)
    rightArc(100, 90)
    home()
    left(angle)
    leftArc(100, 90)
    home()
    
def move(start, end, step):
    for a in range(start, end, step):
        clear("lightSkyBlue")   
        drawBird(a)
        repaint()
        delay(40) 
    
makeTurtle()
hideTurtle()
setLineWidth(5)
setPenColor("black")
enableRepaint(False)

while True:
    move(55, 5, -2)
    move(5, 55, 2)    

Die Animationsschleife sollte in möglichst gleichen Zeitticks durchlaufen werden, da sonst die Bewegung ruckelt. Die Operationen in der Animationsschleife können aber unterschiedlich viel Zeit in Anspruch nehmen, selbst wenn der Code immer derselbe ist, der Computer im Hintergrund noch mit anderen Aufgaben beschäftigt ist. Um die verschieden lange Ausführung der Animationsschleife auszugleichen, wird daher folgender Trick angewendet: Man merkt sich in der Variable startTime vor den Zeichnungsoperationen die aktuelle Systemzeit, die du als Dezimalzahl mit time.time() erhältst.

Nach dem Zeichnen wartest du in einer Warteschleife so lange, bis die Differenz der neuen Systemzeit und der Startzeit die gewünschte Animationsperiode erreicht. (Damit der Computer dabei nicht unnütz viel Rechenzeit verschwendet, hältst du das Programm mit delay(1) kurz an.) Dieser Trick funktioniert natürlich nur, falls die Zeit für das Zeichnen kürzer als die Animationsperiode ist. In einem Ping-Pong-Spiel willst du den roten Ball möglichst gleichmässig zwischen den grünen Balken hin und her bewegen.

from gturtle import *
import time

def wall():
    setPenColor("green")
    setLineWidth(10)
    setPos(-200, -50)
    forward(100)
    setPos(200, -50)
    forward(100)    

makeTurtle()
hideTurtle()
enableRepaint(False)

x = -170
v = 10

while True:
    startTime = time.time()
    clear()
    wall()
    setPos(x, 0)
    setPenColor("red")
    dot(60)
    repaint()
    x = x + v
    if x > 165 or x < -165:
        v = -v      
    while (time.time() - startTime)  < 0.020:
        delay(1)  

Statt das Bild mit der Turtle zu zeichnen, kannst du auch ein Computerimage verwenden, das als png-, gif- oder jpg-Datei vorliegt. In der Gameprogrammierung nennt man ein solches Bild ein Sprite und das bewegte Bildschirmobjekt einen Aktor. Um ein Sprite zu verwenden, rufst du drawImage() auf und gibst dabei den Pfad zur Bilddatei an (als absoluter Dateipfad, als Dateipfad relativ zum Verzeichnis, in dem sich dein Programm befindet, oder als Internet URL).

drawImage() stellt das Bild an der Position der Turtle mit ihrer Blickrichtung dar. Du kannst also sozusagen mit der Turtle als "Leitfigur" das Bild positionieren und drehen, da sich das Sprite zusammen mit der Turtle mitbewegt. Damit man weder die Turtle noch die Spur sieht, rufst du hideTurtle() und mit penUp() auf. Im Beispiel verwendest du das Bild car0.png eines Autos aus der TigerJython-Distribution und bewegst es auf einem Kreis. Alle im Verzeichnis sprites verfügbaren Bilder kannst du aus der TigerJython Hilfe (APLU Dokumentation)  entnehmen.

from gturtle import *
import time

makeTurtle()

hideTurtle()
penUp()
setPos(-180, 0)
enableRepaint(False)

while True:
    startTime = time.time()
    clear()
    drawImage("sprites/car0.png")
    repaint()
    forward(3)
    right(1)
    while (time.time() - startTime)  < 0.04:
        delay(1)    

In fast allen modernen Kinofilmen werden einzelne Sequenzen oder sogar der ganze Film aus computererzeugten Bildern dargestellt. In TigerJython kannst du mit wenig Aufwand eine Animationssequenz mit kleiner bis hoher Auflösung in einer Video-Datei im hoch-komprimierten MP4-Format abspeichern. Die dabei erzeugte Video-Datei kannst du mit einem beliebigen MP4-Player abspielen, der das H.264/AVC-Format unterstützt, beispielsweise mit dem VLC Media Player, dem Quick-Time-Player oder mit Video-Apps auf praktisch allen modernen Smartphones. Du kannst sogar deinen Film im HD-Format auf einem modernen Fernsehgerät oder Beamer wiedergeben.

Die Anzahl der Bilder, die pro Sekunden abgespielt werden, ist von der gewählten Auflösung abhängig, beträgt aber üblicherweise 25 Bilder/Sekunde. Beim Erzeugen der Bilder spielt es aber keine Rolle, wie lange die Berechnung eines einzelnen Bildes mit dem Computeer dauert, du brauchst die Bilder nicht einmal auf dem Bildschirm zu rendern. Darum brauchst du dich auch nicht um Flackern und Ruckeln zu kümmern. Es liegt vollständig in der Verantwortung des Video-Players,  Bild um Bild flacker- und ruckelfrei wiederzugeben.

Im ersten Beispiel nimmt du die oben gezeigte Animation des Vogelfluges. Zuerst erzeugst du mit

rec = VideoRecorder(t, "bird.mp4", "640x480")

ein VideoRecorder-Objekt, wobei du die Turtle t übergibst, die du mit makeTurtle() erzeugst. Zudem wählst du die Ausgabedatei und die Video-Auflösung.  Am einfachsten ist es, wenn Grösse des Turtlefensters und  Video-Auflösung übereinstimmen. Du kannst die Grösse des Grafikfensters entweder in den Einstellungen von TigerJython oder mit einem Aufruf von Options wählen (nach einer Änderung musst du TigerJython neu starten).

Die Graphikelemente (Turtles, Spuren, Bilder) des Turtlefensters kopierst du mit rec.captureImage() in die Video-Datei. Am Schluss musst du diese Datei mit rec.finish() schliessen.

from gturtle import *

def drawBird(angle):
    dot(20)
    right(angle)
    rightArc(100, 90)
    home()
    left(angle)
    leftArc(100, 90)
    home()
    
def move(start, end, step):
    for a in range(start, end, step):
        clear("lightSkyBlue")   
        drawBird(a)
        rec.captureImage()
    
Options.setPlaygroundSize(640, 480)
t = makeTurtle()
rec = VideoRecorder(t, "bird.mp4", "640x480")
hideTurtle()
setLineWidth(5)
setPenColor("black")
nbSwings = 5
n = 0
while n < nbSwings:
    move(55, 5, -2)
    move(5, 55, 2) 
    n += 1
rec.finish()
print("all done")