Weiter mit Py5: Bouncing Balls (und PVector)

Ich bin immer noch angefixt von Py5, der Python-3-Implementierung von Processing, die ich zusammen mit dem Thonny-Plugin von Tristan Bunn erfolgreich auf meinem Mac zur Mitarbeit bewegen konnte. Und so wollte ich ein weiteres Beispielskript aus dem Buch »Math Adventures with Python« von Peter Farrell implementieren, dieses mal das altbekannte Bouncing Balls-Beispiel, im Gegensatz zum Vorbild in Farrels Buch allerdings mit Processings PVector-Klasse. Denn als Fan von Daniel Shiffmans Tutorials und seinem Buch »The Nature of Code« bin ich natürlich auch ein Fan dieser einfachen, aber dennoch sehr leistungfähigen Klasse für zwei- (und drei-) dimensionalen Vektoren.

Doch als ich mit meinen Experimenten begann, mußte ich feststellen, daß Py5 die Klasse PVector nicht kannte. Der Schöpfer von Py5 dachte sich wohl, daß Numpy sie überflüssig mache. Zwar ist Numpy ein durchaus mächtiges Paket, das auch Vektormathematik beherrscht, doch ist es meiner Meinung nach für einfache Berechnungen etwas überdimensioniert. Doch kein Problem, gerade aus diesen Überlegungen heraus hatte ich ja vor Jahren (ursprünglich für Karsten Wolfs Fork der NodeBox 1) die PVector-Klasse (nur für zweidimensionale Vektoren) nach pure Python portiert und über die Jahre auch immer weiter gepflegt (Quellcode auf GitHub). Und da sie – bisher getestet – neben der NodeBox auch mit P5 (Python), TigerJython und Pygame (Zero) spielt, war ich fest davon überzeugt, daß sie auch mit Py5 die Zusammenarbeit nicht versagt. Und siehe da: Ich hatte recht!

Hier also erst einmal der Quellcode meiner Implementierung:

# Bouncing Balls w/ Classes (improved)
# nach Peter Farrell »Math Adventures with Python«, p183ff
# Einige Ungereimtheiten aus Farrells Code ausgeräumt und
# für Py5 mit meiner eigenen PVector-Implementierung ausgestattet.
from pvector import PVector

NO_BALLS = 40
WIDTH = 640
HEIGHT = 480

balls = [] # Empty list to put the balls in

class Ball:
    
    def __init__(self, x, y):
        self.pos = PVector(x, y)
        self.vel = PVector(random(-2, 2), random(-2, 2))
        # No horizontal or vertical move
        if self.vel.x == 0:
            self.vel.x = 1
        if self.vel.y == 0:
            self.vel.y = -1
        # Random colors
        self.col = color(random_int(5, 250), random_int(5, 250), random_int(5, 250))
        # Random size
        self.r = random_int(5, 20)
        
    def update(self):
        self.pos += self.vel
        self.check_boundaries()
        
    def check_boundaries(self):
        # check boundaries
        if self.pos.x > width - self.r or self.pos.x < self.r:
            self.vel.x *= -1
        if self.pos.y > height - self.r or self.pos.y < self.r:
            self.vel.y *= -1
    
    def show(self):
        fill(self.col)
        circle(self.pos.x, self.pos.y, 2*self.r)

def setup():
    size(WIDTH, HEIGHT)
    for _ in range(NO_BALLS):
        balls.append(Ball(random(20, width - 20), random(20, height - 20)))

def draw():
    background(125)  # Light grey
    for ball in balls:
        ball.update()
        ball.show()

Weitere Änderungen, die ich an Farrells Code vorgenommen habe: Mit der Berücksichtigung der Radien der einzelnen Kreise wurde dafür gesorgt, daß sie tatsächlich vom Fensterrand abprallen und nicht ein paar Pixel über den Fensterrand hinaus schlüpfen, bevor sie zurückgeworfen werden. Und da random(-2, 2) gelegentlich auch mal Null ergeben kann und rein horizontale oder vertikale Bewegungen langweilig sind, habe ich für diese Fälle entschieden, daß die Bewegungen auf Eins respektive Minus Eins festgelegt werden.

Außerdem mag ich die knalligen Farben an den beiden Enden der RGB-Spektren nicht, daher habe ich sie auf die Bandbreite von fünf bis zweihunderfünfzig begrenzt. Mit dem Ergebnis war ich dann auch sehr zufrieden (Screenshot).

Natürlich gibt es auch diesen Quellcode in meinem GitHub-Repositorium.

(Kommentieren)