Bewegungslogik umgebaut

.flake8

@@ -0,0 +1,2 @@
+[flake8]
+ignore = E501

README.md

@@ -6,6 +6,12 @@ Ein Brettspiel (bei dem später eventuell mehrere Spieler zusammen bzw. abwechse
 
 ## Protokoll
 
+## 26.10.2026 (zuhause)
+
+Ich habe das Problem mit der Bewegung der Figuren gelöst, indem ich die Bewegungslogik so umgebaut habe, dass nicht mehr bei jedem Zug basierend auf der aktuellen x- und y-Position die nächsten Schritte durch if-Abfragen vorgegeben werden. Stattdessen wird jetzt in der `anfangsKonfiguration()` eine Pfad-Variable für die Figuren angelegt und die genauen Koordinaten der Felder, über die die Figuren laufen sollen, in richtiger Reihenfolge mit `range()`-Funktionen in das Array der Pfad-Variable eingefügt (über STRG+Linksklick auf die range-Funktion habe ich herausgefunden, dass man auch einen Stop-Wert für das Zählen eingeben kann und die Zählrichtung mit -1 für ungerade Zeilen umkehren kann). Durch die `min()`-Funktion in der `tasteGedrueckt()`–Funktion bleiben die Figuren außerdem am Ende des Spielfelds stehen und laufen nicht mehr weiter.
+
+**TODO für den Untericht:** Spielfelddesign, Spezialfelder + Erkennung (so, dass ein besonderes Ereignis ausgelöst werden kann)
+
 ## 07.10.2026
 
 Es besteht weiterhin ein Problem mit steckenbleibenden Figuren, sobald diese in die zweite Zeile wandern. Allerdings habe ich es jetzt geschafft, das Design ein bisschen zu überarbeiten und man kann jetzt auf einen "Würfeln"-Button drücken, statt jedes Mal die Leertaste zum Würfeln zu drücken.
@@ -14,8 +20,7 @@ Es besteht weiterhin ein Problem mit steckenbleibenden Figuren, sobald diese in
 
 *(heute Doppelunterricht in Vertretungsstunde bei Frau Wilmsen)*
 
-Es gab ein Problem mit der bewegungsrichtung-Variable, das dafür gesorgt hat, dass teilweise die falschen Figuren in die falsche Richtung bewegt wurden, da diese eine Variable für alle Figuren galt. Um das Problem zu beheben, habe ich die bewegungsrichtung-Variable vom Typ "string" zum Typ "dictionary" geändert, sodass Wertzuweisungen wie z. B. `{0: 'rechts', 1: 'rechts', 2: 'rechts', 3: 'rechts'}` entstehen, also jede Figur eine eigene Bewegungsrichtung, unabhängig von den anderen, haben kann. Jedoch führt dies nun am Ende des Spielfelds (rechts) wieder zu einem `IndexError: list index out of range`, den ich noch nicht beheben konnte.
+Es gab ein Problem mit der bewegungsrichtung-Variable, das dafür gesorgt hat, dass teilweise die falschen Figuren in die falsche Richtung bewegt wurden, da diese eine Variable für alle Figuren galt. Um das Problem zu beheben, habe ich die bewegungsrichtung-Variable vom Typ "string" zum Typ "dictionary" geändert, sodass Wertzuweisungen wie z. B. `{0: 'rechts', 1: 'rechts', 2: 'rechts', 3: 'rechts'}` entstehen, also jede Figur eine eigene Bewegungsrichtung, unabhängig von den anderen, haben kann. Jedoch führt dies nun am Ende des Spielfelds (rechts) wieder zu einem `IndexError: list index out of range`, den ich noch nicht beheben konnte
-
 ## 30.09.2026
 
 Die Figuren auf dem Spielfeld gehen die gewünschte Anzahl an Zufallsschritten und die Würfelbilder werden auch schon angezeigt (aber noch nicht wieder ausgeblendet nach einer bestimmten Zeit). Jedoch kommt es in der zweiten Zeile an einem Punkt zu einem Fehler, der dazu führt, dass die Figuren sich nicht mehr weiter bewegen (bzw. auch schon beim Wechsel aus der ersten in die zweite Zeile "zu weit laufen"). Ich habe außerdem die erste Zeile des Hintergrunds mit nummerierten Feldern und Pfeilen, die die Bewegungsrichtung verständlicher machen sollen, ausgestaltet.

main.py

@@ -36,7 +36,7 @@ for fname in meinSpiel.bilder:
 for fname in meinSpiel.wuerfel:
     try:
         wuerfelBilder.append(pygame.image.load(fname))
-    except:
+    except (FileNotFoundError, pygame.error):
         print("Fehler beim Laden der Würfelbilder")
 
 background_img_wood = pygame.image.load(
@@ -55,11 +55,10 @@ while True:
     # Überprüfen, ob Nutzer eine Aktion durchgeführt hat
     for event in pygame.event.get():
         # Beenden bei [ESC] oder [X]
-        if event.type == QUIT or (event.type == KEYDOWN
+        if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
-                                  and event.key == K_ESCAPE):
             pygame.quit()
-        print(f"{int((pygame.mouse.get_pos()[0])/120)}, "
+        print(f"{int((pygame.mouse.get_pos()[0]) / 120)}, "
-              f"{int((pygame.mouse.get_pos()[1])/120)}")
+              f"{int((pygame.mouse.get_pos()[1]) / 120)}")
     # Spiellogik
         if event.type == pygame.MOUSEBUTTONDOWN:
             meinSpiel.mouseButtonClick(pygame.mouse.get_pos()[0], pygame.mouse.get_pos()[1])
@@ -70,7 +69,7 @@ while True:
     # Spielfeld löschen
     for x in range(FelderX):
         for y in range(FelderY):
-            screen.blit(hintergrundBilder[meinSpiel.spielfeld[x][y]],(x*Pixel, y*Pixel))
+            screen.blit(hintergrundBilder[meinSpiel.spielfeld[x][y]], (x * Pixel, y * Pixel))
 
     for x in range(FelderX):
         for y in range(FelderY):
@@ -78,16 +77,13 @@ while True:
                 # "i" beginnt bei jedem Feld wieder bei 0 - keine feste if-Abfrage jeder einzelnen Figur, um die Verschiebungsvariablen zu setzen, nötig
                 xVerschiebung = i * 30  # Verschiebung um 30 Pixel nach rechts, jede Figur im selben Feld etwas weiter
                 yVerschiebung = 0
-                screen.blit(pyGameBilder[figur], (x*Pixel + xVerschiebung, y*Pixel + yVerschiebung))
+                screen.blit(pyGameBilder[figur], (x * Pixel + xVerschiebung, y * Pixel + yVerschiebung))
-                #print(meinSpiel.zufallswert)
+                # print(meinSpiel.zufallswert)
                 if meinSpiel.wuerfelBildAnzeigen:
                     screen.blit(pygame.image.load(f"Bilder/wuerfel-{meinSpiel.zufallswert}.png"), (310, 600))
                 pygame.draw.rect(screen, GRUEN, (290, 770, 200, 60))
                 screen.blit(pygame.font.Font("Bilder/NunitoSans-VariableFont.ttf", 38).render("WÜRFELN", True, (255, 255, 255)), (300, 775))
-                #print(f"[{i}] Figur {figur} auf Feld {x}, {y} mit Verschiebung {xVerschiebung}")
+                # print(f"[{i}] Figur {figur} auf Feld {x}, {y} mit Verschiebung {xVerschiebung}")
-                if meinSpiel.am_zug >= 4:
-                    meinSpiel.am_zug = 0
-                meinSpiel.figur_entfernt = False
 
     # Spielfeld/figuren zeichnen
     # Fenster aktualisieren

meinspiel.py

@@ -8,111 +8,80 @@ class MeinSpiel:
               "Bilder/Spielfiguren/spielfigur-gelb.png",
               "Bilder/Spielfiguren/spielfigur-gruen.png",
               "Bilder/Spielfiguren/spielfigur-blau.png"]
-    wuerfel = ["Bilder/wuerfel-1.png",
+    wuerfel = [f"Bilder/wuerfel-{i}.png" for i in range(1, 7)]
-               "Bilder/wuerfel-2.png",
+    # hintergrundbilder = []
-               "Bilder/wuerfel-3.png",
+    # spielfeld = []
-               "Bilder/wuerfel-4.png",
+    # spielfiguren = []
-               "Bilder/wuerfel-5.png",
-               "Bilder/wuerfel-6.png"]
-    hintergrundbilder = []
-    spielfeld = []
-    spielfiguren = []
 
-    figur_entfernt = False
+    # figur_entfernt = False
-    zeilenversetzt = False
+    # zeilenversetzt = False
-    am_zug = 0
+    # am_zug = 0
-    bewegungsrichtung = {0: "rechts", 1: "rechts", 2: "rechts", 3: "rechts"}
+    # bewegungsrichtung = {0: "rechts", 1: "rechts", 2: "rechts", 3: "rechts"}
-    zufallswert = int()
+    # zufallswert = int()
-    wuerfelBildAnzeigen = False
+    # wuerfelBildAnzeigen = False
 
     def __init__(self, felderX, felderY):
+        self.felderX, self.felderY = felderX, felderY
+        self.hintergrundbilder = []
+        self.spielfeld = []
+        self.spielfiguren = []
+        self.am_zug = 0
+        self.zufallswert = 0
+        self.wuerfelBildAnzeigen = False
+
         for x in range(felderX):
             self.spielfeld.append([])
             self.spielfiguren.append([])
             for y in range(felderY):
                 self.hintergrundbilder.append(
                     f"Bilder/Hintergrundpixel/background_{x}-{y}.jpg")
-                self.spielfeld[x].append((7*x+y))
+                self.spielfeld[x].append(7 * x + y)
                 self.spielfiguren[x].append([])
 
-    def anfangsKonfiguration(self):
+        self.pfad = []
-        self.spielfiguren[0][0].append(0)
+        for y in range(felderY):
-        self.spielfiguren[0][0].append(1)
+            if y <= 4:
-        self.spielfiguren[0][0].append(2)
+                if y % 2 == 0:
-        self.spielfiguren[0][0].append(3)
+                    bewegungsrichtung = range(felderX)
+                else:
+                    bewegungsrichtung = range(felderX - 1, -1, -1)  # range funktioniert als range(start, stop, step), bei stop 0 wird die 0 selbst nicht mehr mitgezählt! -> deshalb -1
+                for x in bewegungsrichtung:
+                    self.pfad.append((x, y))
 
-        print(self.bewegungsrichtung)
+        self.positionen = [0, 0, 0, 0]
+
+    def anfangsKonfiguration(self):
+        # self.spielfiguren[0][0].append(0)
+        # self.spielfiguren[0][0].append(1)
+        # self.spielfiguren[0][0].append(2)
+        # self.spielfiguren[0][0].append(3)
+
+        for figur in range(4):
+            x, y = self.pfad[0]
+            self.spielfiguren[x][y].append(figur)
 
     def tasteGedrueckt(self, taste):
-        if taste == pygame.K_SPACE or "mouseevent":
+        if taste != pygame.K_SPACE and taste != "mouseevent":
-            self.zufallswert = random.randint(1, 6)
+            return
 
+        self.zufallswert = random.randint(1, 6)
         self.wuerfelBildAnzeigen = True
 
-            for i in range(self.zufallswert):
+        figur = self.am_zug
-                self.figur_entfernt = False
+        start = self.positionen[figur]
-                print(f"[Schritt {i}] Figur {self.am_zug} geht {self.zufallswert}")
+        ziel = (start + self.zufallswert, len(self.pfad) - 1)
-                for x in range(len(self.spielfiguren)):
+        print(self.pfad)
-                    for y in range(len(self.spielfiguren[x])):
-                        try:
-                            if len(self.spielfiguren[x][y]) > 0 and self.figur_entfernt == False:
-                                # print(f"Figuren auf Feld ({x}|{y}): {self.spielfiguren[x][y]}")
-                                self.spielfiguren[x][y].pop(self.spielfiguren[x][y].index(self.am_zug))
-                                self.figur_entfernt = True
 
-                                if self.bewegungsrichtung[self.am_zug] == "unten":
+        start_x, start_y = self.pfad[start]
-                                    self.spielfiguren[x][y + 1].append(self.am_zug)
+        self.spielfiguren[start_x][start_y].remove(figur)
-                                    self.zeilenversetzt = True
-                                    if x == 6: self.bewegungsrichtung[self.am_zug] = "links"
-                                    elif x == 0: self.bewegungsrichtung[self.am_zug] = "rechts"
 
-                                if self.bewegungsrichtung[self.am_zug] == "links":
+        ziel_x, ziel_y = self.pfad[ziel]
-                                    if self.zeilenversetzt:
+        self.spielfiguren[ziel_x][ziel_y].append(figur)
-                                        self.spielfiguren[x - 1][y].append(self.am_zug)
 
-                                        self.spielfiguren[x][y].pop(self.spielfiguren[x][y].index(self.am_zug))
+        self.positionen[figur] = ziel
 
-                                        self.zeilenversetzt = False  # zurücksetzen
+        print(f"Figur {figur}: von {start} nach {ziel} (Gewürfelt: {self.zufallswert})")
-                                    else: self.spielfiguren[x - 1][y].append(self.am_zug)
+        self.am_zug = (self.am_zug + 1) % 4  # mit Modulo-Operator ist (3 + 1) % wieder 0
-                                    if x - 1 == 0: self.bewegungsrichtung[self.am_zug] = "unten"
-                                
-                                if self.bewegungsrichtung[self.am_zug] == "rechts":
-                                    if self.zeilenversetzt:
-                                        self.spielfiguren[x + 1][y + 1].append(self.am_zug)
-                                        
-                                        self.spielfiguren[x][y + 1].pop(self.spielfiguren[x][y + 1].index(self.am_zug))
-
-                                        self.zeilenversetzt = False
-                                    else:
-                                        self.spielfiguren[x + 1][y].append(self.am_zug)
-                                    if x + 1 == 6: self.bewegungsrichtung[self.am_zug] = "unten"
-
-                                #if self.bewegungsrichtung[self.am_zug] == "rechts":
-                                #    self.spielfiguren[x + 1][y].append(self.am_zug)
-                                #    if x == 6: self.bewegungsrichtung[self.am_zug] = "unten"
-                                #if self.bewegungsrichtung[self.am_zug] == "unten":
-                                #    self.spielfiguren[x][y + 1].append(self.am_zug)
-                                #    if x == 6: self.bewegungsrichtung[self.am_zug] = "links"
-                                #    elif x == 0: self.bewegungsrichtung[self.am_zug] = "rechts"
-                                #if self.bewegungsrichtung[self.am_zug] == "links":
-                                #    self.spielfiguren[x - 1][y].append(self.am_zug)
-                                #    print(f"[!] {x}")
-                                #    if x == 1 and self.am_zug == 3: self.bewegungsrichtung[self.am_zug] = "unten"
-                                #if self.bewegungsrichtung[self.am_zug] == "oben": # (wird wahrscheinlich nicht verwendet werden)
-                                #    self.spielfiguren[x][y + 1].append(self.am_zug)
-                                #    # print(f'Die "bewegungsrichtung"-Variable hat einen ungültigen Wert: {str(self.bewegungsrichtung[self.am_zug])}')
-
-
-                                print(self.bewegungsrichtung)
-                            else:
-                                # print(f"keine Figuren auf Feld ({x}|{y}): {self.spielfiguren[x][y]}")
-                                break
-                        except ValueError:
-                            # print(f"x: {x}, y: {y}")
-                            break
-                print("____________")
-            self.am_zug += 1
-            print(self.bewegungsrichtung)
 
     def mouseButtonClick(self, x, y):
         if x >= 270 and y >= 770 and x <= 490 and y <= 830: