// --- KONSTANTEN DEFINIEREN ---
DIM GridA(MAX_X, MAX_Y) AS INTEGER ' Das aktuelle Gitter
DIM GridB(MAX_X, MAX_Y) AS INTEGER ' Das nächste zu berechnende Gitter

CONST MAX_X = 50    ' Breite des Spielfelds
CONST MAX_Y = 20    ' Höhe des Spielfelds


// --- HAUPTPROGRAMM-SCHLEIFE ---
SUB MainLoop()
   CALL InitialisiereGitter(GridA) ' Setzt ein Startmuster (optional)

   DO
       CALL ZeigeGitter(GridA)  ' 1. Aktuellen Zustand anzeigen
       SLEEP(500)             ' Kurze Pause zum Sehen

       CALL BerechneNaechstesGitter(GridA, GridB) ' 2. Die Logik des Lebens anwenden
       
       ' Tauschen der Gitter: Das "Nächste" wird das neue "Aktuelle"
       SwapGrids(GridA, GridB)

   LOOP WHILE TRUE ' Läuft unendlich, bis gestoppt


// ===========================================
// FUNKTIONEN
// ===========================================

SUB InitialisiereGitter(CurrentGrid)
   ' Setzt das gesamte Gitter auf 0 (Tot)
   FOR y = 1 TO MAX_Y
       FOR x = 1 TO MAX_X
           CurrentGrid[x, y] = 0
       NEXT x
   NEXT y

   ' --- HIER EIN STARTMUSTER PLATZIEREN (z.B. ein Quadrat von Lebendzellen) ---
   Dim startX = MAX_X / 2 - 3
   Dim startY = MAX_Y / 2 - 3
   FOR y = 0 TO 1 { ' Nur 2 Zeilen hoch
       FOR x = 0 TO 2
           CurrentGrid[startX + x, startY + y] = 1
       NEXT x
   NEXT y

END SUB


SUB BerechneNaechstesGitter(CurrentGrid, NextGrid)
   ' Setzt das Zielgitter (NextGrid) einmalig auf 0
   CALL ClearGrid(NextGrid)

   FOR y = 1 TO MAX_Y
       FOR x = 1 TO MAX_X
           Dim NachbarnCount AS INTEGER
           NachbarnCount = ZaehleLebendeNachbarn(CurrentGrid, x, y)
           
           ' Wenden der Spielregeln an:
           IF CurrentGrid[x, y] = 1 THEN ' Zell ist LEBEND
               IF NachbarnCount < 2 OR NachbarnCount > 3 THEN
                   NextGrid[x, y] = 0  ' Stirbt
               ELSE
                   NextGrid[x, y] = 1  ' Überlebt
               END IF
           ELSE ' Zell ist TOT (CurrentGrid[x, y] = 0)
               IF NachbarnCount = 3 THEN
                   NextGrid[x, y] = 1  ' Wird geboren
               ELSE
                   NextGrid[x, y] = 0  ' Bleibt tot
               END IF
           END IF
       NEXT x
   NEXT y

END SUB


SUB ZaehleLebendeNachbarn(Grid, X_Zelle, Y_Zelle)
   Dim Count AS INTEGER: Count = 0
   
   ' Durch die 3x3 Nachbarschaft Schleifen (ohne das Zentrum selbst!)
   FOR dy = -1 TO 1
       FOR dx = -1 TO 1
           IF dx = 0 AND dy = 0 THEN CONTINUE ' Springe über die Zelle selbst
           
           Dim NeighX AS INTEGER: NeighX = X_Zelle + dx
           Dim NeighY AS INTEGER: NeighY = Y_Zelle + dy

           ' Randprüfung (Stellt sicher, dass wir nicht außerhalb des Spielfeldes sind)
           IF NeighX >= 1 AND NeighX <= MAX_X AND NeighY >= 1 AND NeighY <= MAX_Y THEN
               IF Grid[NeighX, NeighY] = 1 THEN
                   Count = Count + 1
               END IF
           END IF
       NEXT dx
   NEXT dy
   
   RETURN Count
END SUB


SUB SwapGrids(GridA, GridB)
   ' Tauscht die Inhalte von A und B (vereinfacht dargestellt)
   ' In echtem MMBasic müsste hier der Inhalt jedes Pixels/Arrays kopiert werden.
   FOR y = 1 TO MAX_Y
       FOR x = 1 TO MAX_X
           GridA[x, y] = GridB[x, y] ' Kopiere B nach A
           ' Wenn du das System nicht überschreibst, ist dies ausreichend:
           ' GridA(x, y) <-> GridB(x, y)
       NEXT x
   NEXT y
END SUB


SUB ZeigeGitter(Grid)
   PRINT "--- Game of Life ---"
   FOR y = 1 TO MAX_Y STEP 1
       DIM ZeileStr AS STRING: ZeileStr = ""
       FOR x = 1 TO MAX_X STEP 1
           IF Grid[x, y] = 1 THEN
               ZeileStr = ZeileStr + "█" ' Darstellung für Lebend (Block)
           ELSE
               ZeileStr = ZeileStr + " " ' Leerzeichen für Tot
           END IF
       NEXT x
       PRINT ZeileStr
   NEXT y
   PRINT "---------------------"
END SUB

' Aufruf des Spiels
CALL MainLoop()