# Sierpinski-Dreieck per Chaos-Spiel
# Alle Zeilen, die mit dem Hash- oder Doppelkreuz-Symbol # beginnen, sind Kommentare
# und werden vom Computer beim Ausführen des Programms ignoriert.
# Leerzeilen dienen nur der besseren Strukturierung und werden ebenfalls vom Computer ignoriert.
 
# Import von Pakete/Bibliotheken (packages/libraries) mit Grafik- und Zufallsbefehlen
# (eigentlich ist pygame ein Paket zur Spieleprogrammierung, 
# jedoch eignet es sich auch zum Zeichnen einfacher Grafiken und ich habe nichts "Besseres" gefunden):
import pygame
from random import *


# Es folgen zwei Zuweisungen, kodiert durch das Gleichheitszeichen "=":
# Wir weisen der Variablen "breite" den Wert 10000 rechts des Gleichheitszeichens zu.
# Das Gleichheitszeichen ist NICHT als mathematische Gleichheit zu verstehen. 
# Es handelt sich um eine Zuweisung! (Dies wird weiter unten klarer.)
# (Wir werden die Variable "breite" im Programm nicht ändern - es handelt sich also genauer um eine Konstante.)
# Analog wird die Variable/Konstante "hoehe" auf 8660 gesetzt.
breite = 500
hoehe = 433                        # ungefähr sqrt(3)/2 * breite;     sqrt = square root = Quadratwurzel

# Die folgende Variable gibt an, wie oft wir den Punkt springen lassen.
iterationen = 10000

weiss = (255, 255, 255)            # Ein Tupel aus drei Zahlen, kodiert die Farbe Weiss im RGB-Modell, das wir später kennenlernen werden.
 
# Koordinaten des Punkts A
xA = 0
yA = hoehe
 
# Koordinaten des Punkts B
xB = breite
yB = hoehe
 
# Koordinaten des Punkts C
xC = int(breite / 2)               # Der Befehl "int" macht eine Kommazahl (= reelle Zahl = real number) durch Abschneiden der Nachkommastellen zu einer ganzen Zahl (= integer).
yC = 0


# Die folgenden drei Befehle erzeugen ein Fenster mit dem Titel "Das Chaos-Spiel"
# mit einem rechteckigem Ausschnitt der Zeichenebene.
# Genauer wird der Bereich mit x-Koordinaten von 0 bis "breite" und
# y-Koordinaten von 0 bis "hoehe" bereitgestellt.
# Beachte: Die x-Achse zeigt nach rechts, die y-Achse nach UNTEN!
# Jedes Pixel (= jeder Bildpunkt) mit ganzzahligen Koordinaten in diesem Bereich 
# kann später gefärbt werden.
# In der Titelleiste des Fensters erscheint die Zeichenkette (englisch string)
# "Das Chaos-Spiel".
pygame.init()
pygame.display.set_caption("Das Chaos-Spiel")

leinwand = pygame.display.set_mode((breite + 1, hoehe + 1))

# Zeichne gerade Linien zwischen den angegebenen Punkten (auf der "leinwand" mit Farbe "weiss"):
pygame.draw.line(leinwand, weiss, (xA, yA), (xB, yB))
pygame.draw.line(leinwand, weiss, (xB, yB), (xC, yC))
pygame.draw.line(leinwand, weiss, (xC, yC), (xA, yA))

# Die Linien werden zunächst "verborgen" gezeichnet. Um sie wirklich anzuzeigen, muss man
# das Display updaten. (Dies ist so gemacht, um ein Flackern des Bildschirms zu vermeiden.)
pygame.display.update()


# zufaellige Startkoordinaten des springenden Punktes
# "randint" ist eine Abkürzung für "random integer" = "zufällige ganze Zahl" 
# zwischen den angegebenen Grenzen (jeweils einschliesslich). 
x = randint(0, breite)
y = randint(0, hoehe)

 
# Es folgt eine sogenannte "for-Schleife" (englisch "for loop").
# Die Variable i nimmt nacheinander die Werte 0, 1, 2, ..., iterationen - 1 an.
# Beachte, dass der Wert iterationen nicht angenommen wird.
# (Hierbei ist iterationen - 1 unser Ersatz für unendlich.)
# Für jeden dieser Werte wird der nachfolgende eingerückte Bereich (Einrückung jeweis vier Leerzeichen)
# genau einmal durchlaufen.
# ACHTUNG: Falsche Einrückungen verursachen Fehler.
for i in range(0, iterationen):

    # Weise der Variablen "zufall" eine Zufallszahl zu, die den Wert 1,2 oder 3 hat.
    # Wir wuerfeln sozusagen mit einem dreiseitigen Wuerfel. 
    # Dabei sind die drei Zahlen 1, 2, 3 gleich wahrscheinlich.
    zufall = randint(1, 3)

    # Es folgt eine sogenannte "if-Bedingung" (englisch "if condition"): 
    # Falls die Variable "zufall" den Wert 1 hat (Gleichheit von Variablen wird mit "==" 
    # und nicht mit "=" abgefragt),
    # werden die folgenden eingerueckten Zeilen durchgeführt.
    if zufall == 1:

        # Die neue x-Koordinate unseres springenden Punktes liegt genau zwischen der alten x-Koordinate
        # des springenden Punktes und der x-Koordinate von A.
        # Hier wird nun klar, dass "=" eine Zuweisung ist und kein Gleichheitszeichen:
        # Der Variablen x links wird als neuem Wert das zugewiesen,
        # was die Berechnung rechts ergibt - in dieser Berechnung wird der alte Wert von x verwendet.
        x = x + 0.5 * (xA - x)
 
        # Analog fuer die neue y-Koordinate
        y = y + 0.5 * (yA - y)
 
        # Hier endet der eingerückte Befehlsblock, der ausgefuehrt wird, wenn zufall == 1 gilt.
 

# Die beiden folgenden if-Bedingungen sind nun hoffentlich klar.
    if zufall == 2:
        x = x + 0.5 * (xB - x)
        y = y + 0.5 * (yB - y)
    if zufall == 3: 
        x = x + 0.5 * (xC - x)
        y = y + 0.5 * (yC - y)
    leinwand.set_at((round(x),round(y)), weiss)               # Zeichnet ein Pixel am Punkt (x,y) bzw. genauer an den gerundeten Koordinaten.
    pygame.display.update((round(x), round(y), 1, 1))
    # Das Updaten eines kleinen rechteckigen Bereichs ist deutlich schneller als das Updaten
    # des gesamten Zeichenbereichs mit
    # pygame.display.update()
    pygame.time.delay(1)

    # Alle 1000 Iterationen wird die Variable i ausgegeben.
    if i % 1000 == 0:                                        # "Prozent-Division" liefert den Rest der Division.
        print(i)
 
# Hier endet die for-Schleife, denn der folgende Befehl ist nicht mehr eingerueckt.

print("Fertig! Das Fenster wird in 5 Sekunden geschlossen.") # Ausgabe der Zeichenkette (= string) zwischen den Anführungszeichen.
print(f"Insgesamt wurden {iterationen} Punkte gezeichnet.")  # f-string = formatted string
        

# Pause von 5000 Millisekunden, also 5 Sekunden
pygame.time.delay(5000)                                      
# Schliesse das Zeichenfenster.
pygame.quit()