Ein Partikelsystem mit Pythons Turtle-Graphik

Diese Coding-Challenge von und mit Daniel Shiffman hat mich inspiriert, solch ein einfaches Partikelsystem doch auch einmal in Python zu programmieren. Vor allem war ich neugierig, wie sich Pythons Turtle-Graphik damit schlagen würde und außerdem wollte ich testen, wie sich das von mir vor einem Monat ursprünglich für die NodeBox 1 entwickelte PVector Modul (Teil 2) mit der Turtle-Graphik verträgt.

Beides verlief überraschend problemlos. Am PVector-Modul mußte ich gar keine Änderungen vornehmen, so daß ich mit einer Klasse Particle, die ich in einer eigenen Datei (particle.py) untergebracht hatte, beginnen konnte:

import turtle as t
import random as r
from pvector import PVector

class Particle(t.Turtle):
    
    def __init__(self, tshape, tcolor, x, y):
        t.Turtle.__init__(self)
        self.penup()
        self.shape(tshape)
        self.color(tcolor)
        self.speed = 1
        self.max_speed = 10
        self.location = PVector(x, y)
        self.setpos(self.location.x, self.location.y)
        self.acceleration = PVector(0, 0.05)
        self.velocity = PVector(r.uniform(-1.0, 1.0), r.uniform(-2.0, 0.0))
        self.lifespan = 255
        
    def update(self):
        self.velocity.add(self.acceleration)
        self.location.add(self.velocity)
        self.lifespan -= r.uniform(1.5, 3.0)
        if self.lifespan <= 0:
            self.lifespan = 0
        self.color((round(self.lifespan), 0, 0))
        self.setpos(self.location.x, self.location.y)
    
    def isDead(self):
        if self.lifespan <= 0:
            return True
        else:
            return False

Da die Turtle-Graphic keinen Alpha-Channel für die Transparenz kennt, mußte ich mit einem Trick arbeiten: Die einzelnen Partikel sind rote Kreise, deren r-Wert (für »rot«) bei jedem Durchlauf immer weiter subtrahiert wird, so daß am Ende das Partikel schwarz wird. Vor einem schwarzen Hintergrund wie in meinem Beispielprogramm sieht es dann so aus, als ob das Teilchen immer durchsichtiger wird und schließlich ganz verschwindet. Allerdings mußte ich in der update()-Funktion dafür sorgen, daß der Wert für lifespan nie unter Null sinkt, weil negative Werte im RGB-Farbraum nicht vorgesehen sind.

Mit dieser Vorarbeit war dann das Hauptprogramm ein Kinderspiel:

import turtle as t
from particle import Particle

wn = t.Screen()
wn.setup(width = 500, height = 400)
wn.colormode(255)
wn.bgcolor(0, 0, 0)
wn.title("Particle-System")

# Bildschirm-Refresh ausschalten
wn.tracer(0)

def exit_sim():
    global keepGoing
    keepGoing = False

t.listen()
t.onkey(exit_sim, "Escape") # Escape beendet die Simulation

particles = []
keepGoing = True
while keepGoing:
    wn.update()  # Den gesamten Bildschirm neuzeichnen
    p = Particle("circle", (255, 0, 0), 0, -120)
    particles.append(p)
    for i in range(len(particles)-1, 0, -1):
        particles[i].update()
        if particles[i].isDead():
            particles.pop(i)
            print(len(particles))

Zu beachten ist hierbei nur, daß die Schleife über alle Parikel rückwärts durchlaufen werden muß, wie in

    for i in range(len(particles)-1, 0, -1):

da sonst beim Löschen einzelner Partikel aus der Liste seltsame Fehler passieren können. Rückwärts läuft aber alles wie geschmiert.

Mit diesem Programm und den experimentell herausgefundenen Werten, die immer zwischen 110 und 115 Partikel in der Liste am »Leben« erhält, scheint die Turtle-Graphik aber auch an die Grenze ihrer Leistungsfähigkeit geraten zu sein. Auf meinen betagten Rechnern läuft es gerade noch ohne Stocken. Daher will ich als nächstes solch ein System in der NodeBox programmieren. Schaun wir mal, wie sich die Knotenschachtel schlägt. Still digging!

(Kommentieren)