Zellulärer Automat

[gerdipy]

Es gibt schon viele Zelluläre Automaten, und ich finde das Thema halt interessant. Darum möchte ich einen neuen vorstellen. Vielleicht habt ihr Vorschläge zur Verbesserung des Codes, ich bin Anfänger im Python-programmieren. Danke an Dennis89, der mit TemperaturDisplay den passenden Rahmen erstellt hat.
Nein, zur Zeit bin ich noch nicht schlau genug um ein funktionierendes Programm mit 5 Bildern ins Forum zu stellen.

#Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)] on win32
#Type "copyright", "credits" or "license()" for more information.
#>>> # proben tk applikation, Zellenwärter zufällige Richtungen
#!/usr/bin/env python3
import tkinter as tk
from random import randint

class Spiel(tk.Frame):
def __init__(self, master):
tk.Frame.__init__(self, master)
# Grundgerüst
tk.Label(self, text='Zellenwärter').grid(row=0, column=0)
global zaehler
self.zaehler = 0
...

[sparrow]

@gerdipy: Warum möchtest du Bilder eistellen? Das müsstet du über einen Bildhoster hochladen und dann hier verknüpfen.
Falls du damit Code zeigen möchtest: Mach das bitte nicht. Verwende dafür Code-Tags. Die erscheinen automatisch, wenn du im vollständigen Editor den </> Button drückst. Dazwischen gehört dein Code.

[gerdipy]

Zum Tk-Programm 'Zellenwärter' gehören 4 Richtungspfeilbilder und ein Zellenwärterbild, mit Paint hergestellt, was sozusagen nicht so wichtig und austauschbar ist. Vielen Dank für die Antwort:
<#Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)] on win32
#Type "copyright", "credits" or "license()" for more information.
#>>> # proben tk applikation, Zellenwärter zufällige Richtungen
#!/usr/bin/env python3

import tkinter as tk
from random import randint

class Spiel(tk.Frame):
def __init__(self, master):
tk.Frame.__init__(self, master)
# Grundgerüst
tk.Label(self, text='Zellenwärter').grid(row=0, column=0)
global zaehler
self.zaehler = 0
global x
global y
self.x = randint(0, 4 )
self.y = randint(0, 4 )
self.zel = 5 * [ 0 ]
self.pruefzel = 5 * [ 0 ]
self.pruefxy = [ 0 ] * 2
for f in range( 5 ):
self.zel[ f ] = 5 * [ 0 ]
self.pruefzel[ f ] = 5 * [ 0 ]
self.bild = 5 * [ " " ]
for f in range( 5 ):
self.bild[ f ] = 5 * [ " " ]
# Pfeilrichtung Voreinstellung
self.zel[ 0 ][ 0 ] = randint( 2, 3 )
self.zel[ 0 ][ 4 ] = randint( 3, 4 )
self.zel[ 4 ][ 4 ] = randint( 0, 1 ) * 3 + 1
self.zel[ 4 ][ 0 ] = randint( 1, 2 )
for f in range( 1, 4 ):
self.zel[ 0 ][ f ] = randint( 2, 4 )
r = randint( 1, 3 )
self.zel[ f ][ 4 ] = int( r / 2 ) + r
r = randint( 1, 3 )
self.zel[ 4 ][ f ] = int( r / 3 ) + r
self.zel[ f ][ 0 ] = randint( 1, 3 )
for f1 in range( 1, 4 ):
for f2 in range( 1, 4 ):
self.zel[ f1 ][ f2 ] = randint(1, 4 )
# Voreinstellungen ausmalen mit Zellen, Wärter,Schieberegler,
# Rundenansage, Absolut Zähler, Beenden
for f1 in range( 5 ):
for f2 in range( 5 ):
pic = "R" + str( self.zel[ f1 ][ f2 ] ) + ".gif"
self.bild[ f1 ][ f2 ] = tk.PhotoImage( file = pic )
lb = tk.Label( self, image = self.bild[ f1 ][ f2 ] )
lb.grid( row = f1, column = f2, padx = 5, pady = 5 )

pic = "ZW1.gif"
self.bild[ self.x ][ self.y ] = tk.PhotoImage( file = pic )
lb = tk.Label( self, image = self.bild[ self.x ][ self.y ] )
lb.grid( row = self.x, column = self.y, padx = 5, pady = 5 )
self.wert = tk.IntVar()
self.wert.set(2)
self.scWert = tk.Scale( self, length = 80,orient = "horizontal",
from_=0, to=3, resolution = 1, tickinterval = 1,
label = "Wartezeit", variable = self.wert )
self.scWert.grid( row = 5, column = 0, padx = 0, pady = 0 )

self.runde = tk.Label(self, text='Runden ab 100')
self.runde.grid(row=5, column=1)
self.zaehl = tk.Label(self, text='0')
self.zaehl.grid(row=5, column=2)
self.aus = tk.Button(self, text='Ende', command = master.destroy)
self.aus.grid(row=5, column=3)
x1 = self.x
y1 = self.y
self.weiter( x1, y1 )

self.kreis()
def weiter( self, x2, y2 ):
# Weiterführung des Zellenwärters der Pfeilrichtung entsprechend
# und Neufassung ausmalen. Sichtbar 2 Zellen nach Start
# Pfeilrichtung: 1 hoch, 2 rechts, 3 runter, 4 links
# print( x2, y2, self.zel )
hoehe = x2
breite = y2
if self.zel[ self.x ][ self.y ] == 1:
hoehe -= 1
if self.zel[ self.x ][ self.y ] == 2:
breite += 1
if self.zel[ self.x ][ self.y ] == 3:
hoehe += 1
if self.zel[ self.x ][ self.y ] == 4:
breite -= 1
# Umstellung der Pfeilrichtung nach verlassen des Wärters
self.zel[ self.x ][ self.y ] += 1
if self.zel[ self.x ][ self.y ] == 5:
self.zel[ self.x ][ self.y ] = 1
if self.zel[ self.x ][ self.y ] == 1 and self.x == 0:
self.zel[ self.x ][ self.y ] = 2
if self.zel[ self.x ][ self.y ] == 2 and self.y == 4:
self.zel[ self.x ][ self.y ] = 3
if self.zel[ self.x ][ self.y ] == 3 and self.x == 4:
self.zel[ self.x ][ self.y ] = 4
if self.zel[ self.x ][ self.y ] == 4 and self.y == 0:
self.zel[ self.x ][ self.y ] = 1
if self.zel[ self.x ][ self.y ] == 4 and self.x == 0 and self.y == 0:
self.zel[ self.x ][ self.y ] = 2
if self.zel[ self.x ][ self.y ] == 1 and self.x == 0 and self.y == 0:
self.zel[ self.x ][ self.y ] = 2
pic = "R" + str( self.zel[ self.x ][ self.y ] ) + ".gif"
self.bild[ self.x ][ self.y ] = tk.PhotoImage( file = pic )
lb = tk.Label( self, image = self.bild[ self.x ][ self.y ] )
lb.grid( row = self.x, column = self.y, padx = 5, pady = 5 )
# Ausmalen beider Elemente
pic = "ZW1.gif"
self.bild[ hoehe ][ breite ] = tk.PhotoImage( file = pic )
lb = tk.Label( self, image = self.bild[ hoehe ][ breite ] )
lb.grid( row = hoehe, column = breite, padx = 5, pady = 5 )

self.x = hoehe
self.y = breite
# die gleichen Pfeilrichtungen im ganzen Feld prüfen, das betreten
# der selben Zelle muss sich erst einspielen und kann erst später
# erfolgen, 100 ? => Schätzwert
if self.zaehler == 100:
self.pruefxy[ 0 ] = hoehe
self.pruefxy[ 1 ] = breite
for f1 in range( 5 ):
for f2 in range( 5 ):
self.pruefzel[ f1 ][ f2 ] = self.zel[ f1 ][ f2 ]
if self.zaehler > 100:
if self.pruefxy[ 0 ] == hoehe and self.pruefxy[ 1 ] == breite:
if self.zel == self.pruefzel:
self.runde.config( text = "Runde bei "+ str(self.zaehler ))
# ende def self.weiter( x, y )von def __init__ ,dann folgend def.kreis()

def neu(self, x ,y ):

self.zaehl.config(text = str(self.zaehler) )
self.weiter( self.x, self.y )

def kreis(self ):

self.neu( self.x, self.y )
self.zaehler += 1
self.after( (self.scWert.get()+1)**3 * 100, self.kreis)


def main():
root = tk.Tk()
root.title('Zellenwärter')

app = Spiel(root)
app.grid()
app.mainloop()


if __name__ == "__main__":
main()
>

[DeaD_EyE]

Bitte Code-Tags verwenden.

@Moderation, bitte macht irgendwas, damit Nutzer wissen, dass sie die Code-Tags nutzen müssen.
Mögliche Lösung: Der erste Post in /dev/null, wo der Code-Tags einmal verwendet werden müssen.

Das ist echt frustrierend und das Problem kommt unter anderem daher, weil sich die Nutzung des Internets in den letzten 15 Jahren stark verändert hat.

[grubenfox]

Bitte Code-Tags verwenden.

[Sirius3]

Python 3.6 ist schon sehr alt und lange nicht mehr gepflegt. Steige auf ein aktuelleres Python um.
Vergiss gleich wieder, dass es das Schlüsselwort `global` überhaupt gibt, wobei in Deinem Fall der Einsatz keinen Sinn macht, das es die Variable `zaehler` gar nicht gibt. Ebensowenig x oder y.
Um Klammern setzt man keine Leerzeichen, das macht das Lesen Deines Codes sehr umständlich. Zudem bist Du in Deiner Leerzeichensetzung nicht konsequent.
Was bedeutet `zel`? Wegen drei Buchstaben machst Du den Code deutlich schwerer lesbar. Benutze keine Abkürzungen.
Man erzeugt keine Listen mit Dummywerten, um sie danach sofort durch die richtigen Werte zu ersetzen. Man erzeugt Listen gleich mit den richtigen Werten.
Wenn man Ganzzahl-Division will, benutzt man //.
Variablen legt man erst dann an, wenn man sie auch braucht, nicht 20 Zeilen davor; self.bild z.B. erst zwei for-Schleifen später benutzt. Wenn man es vermeiden kann, iteriert man nicht über einen Index. Sollte man den doch brauchen, dann gibt es enumerate.
Strings setzt man nicht mit + zusammen, sondern benutzt f-Strings.
Im Moment erzeugst Du jedesmal, wenn Du ein Bild änderst auch eine neues Label. Das führt dazu, dass viele Bilder übereinanderliegen und die GUI immer langsamer wird. Statt dessen ersetzt man das Bild des Labels. Zudem ist es umständlich, die Bilder jedesmal neu zu laden.

In `weiter`: wenn man mehrere if-Abfragen hat, die sich gegenseitig ausschließen, dann benutzt man elif.
Dass in der Funktion 20x der Ausdruck `self.zel[self.x][self.y]` vorkommt, macht die Funktion schwierig zu lesen. Besser wäre es, eine Hilfsvariable zu benutzen.
In `neu` werden die Argumente x und y gar nicht benutzt, und die Argumente von weiter sind immer die Werte self.x und self.y, so dass man diese auch nicht als Argumente übergeben müßte.

Alles in allem, komme ich bei ungefähr dem hier raus (ungetestet):

Code: Alles auswählen

import tkinter as tk
from random import randint


class Spiel(tk.Frame):
    def __init__(self, master):
        tk.Frame.__init__(self, master)
        tk.Label(self, text="Zellenwärter").grid(row=0, column=0)
        self.bilder = [
            tk.PhotoImage(file=f"R{value}.gif") for value in range(5)
        ]
        self.zw_bild = tk.PhotoImage(file="ZW1.gif")

        self.zellen = [randint(1, 4) * 5 for f in range(5)]
        # Pfeilrichtung Voreinstellung
        self.zellen[0][0] = randint(2, 3)
        self.zellen[0][4] = randint(3, 4)
        self.zellen[4][4] = randint(0, 1) * 3 + 1
        self.zellen[4][0] = randint(1, 2)
        for f in range(1, 4):
            self.zellen[0][f] = randint(2, 4)
            r = randint(1, 3)
            self.zellen[f][4] = r // 2 + r
            r = randint(1, 3)
            self.zellen[4][f] = r // 3 + r
            self.zellen[f][0] = randint(1, 3)

        self.zaehler = 0
        self.x = randint(0, 4)
        self.y = randint(0, 4)
        self.pruefzellen = [[0] * 5 for _ in range(5)]
        self.pruefxy = (0, 0)

        # Voreinstellungen ausmalen mit Zellen, Wärter,Schieberegler,
        # Rundenansage, Absolut Zähler, Beenden
        self.labels = [
            [tk.Label(file=self.bilder[value]) for value in row]
            for row in self.zellen
        ]
        for row_index, row in enumerate(self.labels):
            for column_index, label in enumerate(row):
                label.grid(row=row_index, column=column_index, padx=5, pady=5)

        self.labels[self.x][self.y]["image"] = self.zw_bild
        self.wartezeit = tk.IntVar()
        self.wartezeit.set(2)
        tk.Scale(
            self,
            length=80,
            orient="horizontal",
            from_=0,
            to=3,
            resolution=1,
            tickinterval=1,
            label="Wartezeit",
            variable=self.wartezeit,
        ).grid(row=5, column=0, padx=0, pady=0)

        self.runde = tk.Label(self, text="Runden ab 100")
        self.runde.grid(row=5, column=1)
        self.zaehl = tk.Label(self, text="0")
        self.zaehl.grid(row=5, column=2)
        self.aus = tk.Button(self, text="Ende", command=master.destroy)
        self.aus.grid(row=5, column=3)
        self.weiter()

    def weiter(self):
        # Weiterführung des Zellenwärters der Pfeilrichtung entsprechend
        # und Neufassung ausmalen. Sichtbar 2 Zellen nach Start
        # Pfeilrichtung: 1 hoch, 2 rechts, 3 runter, 4 links
        hoehe, breite = self.x, self.y
        wert = self.zellen[self.x][self.y]
        if wert == 1:
            hoehe -= 1
        elif wert == 2:
            breite += 1
        elif wert == 3:
            hoehe += 1
        elif wert == 4:
            breite -= 1
        # Umstellung der Pfeilrichtung nach verlassen des Wärters
        wert += 1
        if wert == 5:
            wert = 1
        if wert == 1 and self.x == 0:
            wert = 2
        if wert == 2 and self.y == 4:
            wert = 3
        if wert == 3 and self.x == 4:
            wert = 4
        if wert == 4 and self.y == 0:
            wert = 1
        if wert == 4 and self.x == 0 and self.y == 0:
            wert = 2
        if wert == 1 and self.x == 0 and self.y == 0:
            wert = 2
        self.zellen[self.x][self.y] = wert
        self.labels[self.x][self.y]["image"] = self.bilder[wert]

        # Ausmalen beider Elemente
        self.x = hoehe
        self.y = breite
        self.labels[self.x][self.y]["image"] = self.zw_bild

        # die gleichen Pfeilrichtungen im ganzen Feld prüfen, das betreten
        # der selben Zelle muss sich erst einspielen und kann erst später
        # erfolgen, 100 ? => Schätzwert
        self.zaehl.config(text=str(self.zaehler))
        if self.zaehler == 100:
            self.pruefxy = (hoehe, breite)
            self.pruefzellen = [
                list(row)
                for row in self.zellen
            ]
        elif self.zaehler > 100:
            if self.pruefxy == (hoehe, breite):
                if self.zellen == self.pruefzellen:
                    self.runde.config(text=f"Runde bei {self.zaehler}")
        self.zaehler += 1
        self.after((self.wartezeit.get() + 1) ** 3 * 100, self.weiter)


def main():
    root = tk.Tk()
    root.title("Zellenwärter")

    app = Spiel(root)
    app.grid()
    app.mainloop()


if __name__ == "__main__":
    main()

Jetzt sollte man noch die Spiel-Logik von der GUI trennen, so dass man das Spiel auch unabhängig von der GUI testen kann.

[juergenkulow]

Ich bekomme folgende Fehlermeldung:

Code: Alles auswählen

kulow@kulow-G73Jw:~$ python3 /tmp/automat.py
Traceback (most recent call last):
  File "/tmp/automat.py", line 133, in <module>
    main()
  File "/tmp/automat.py", line 127, in main
    app = Spiel(root)
  File "/tmp/automat.py", line 9, in __init__
    self.bilder = [
  File "/tmp/automat.py", line 10, in <listcomp>
    tk.PhotoImage(file=f"R{value}.gif") for value in range(5)
  File "/usr/lib/python3.10/tkinter/__init__.py", line 4103, in __init__
    Image.__init__(self, 'photo', name, cnf, master, **kw)
  File "/usr/lib/python3.10/tkinter/__init__.py", line 4048, in __init__
    self.tk.call(('image', 'create', imgtype, name,) + options)
_tkinter.TclError: couldn't open "R0.gif": no such file or directory
kulow@kulow-G73Jw:~$ 

Und fühle mich wie der Ochs vorm Berg.

[sparrow]

@juergenkulow: Die Fehlermeldung ist doch sehr direkt: couldn't open "R0.gif": no such file or directory

Da wird eine Datei "R0.gif" gesucht und nicht gefunden.

[__blackjack__]

Und das ”Da” wird durch den Traceback auch noch etwas näher bestimmt, nämlich in welcher Datei und welcher Zeile dort, diese Ausnahme ausgelöst wird, und wie der Weg zu diesem Aufruf aussieht, wo man sich dann den Code in der eigenen Datei, beziehungsweise dem Modul das man da gestartet hat, anschauen kann, der letztlich zu der Meldung führt.

[gerdipy]

Nachdem mich sparrow darauf aufmerksam gemacht hat, nicht mit Bildern zu programmieren, schrieb ich das Programm um, und verwendete font( 'System', 20 ), funktioniert auch gut. Wie Ihr gesehen habt, hatte ich das Programm einfach in diesen Text hinein copiert, und das sah hässlich aus. Was genau muß ich tun, also den Vollständigen Editor anklicken, und dann ?
Dank an Sirius3 für die Menge an Vorschlägen, du hast ja den ganzen Programmtext zurück ins reine geschrieben, also das Programm ist wirklich verblüffend und witzig.

[Dennis89]

Hallo,

vollständiger Editor und dann den Button </> anklicken. Es erscheinen rechteckige Klammern und der Cursor befindet sich schon dazwischen und genau da den Code einfügen und den normalen Fließtext dann wieder nach dem letzten Klammerpaar weiterschreiben. Mit <Vorschau> kannst du dir das vor dem absenden anzeigen lassen.

Grüße
Dennis

[gerdipy]

Code: Alles auswählen

#!/usr/bin/env python3

# proben tk applikation, Zellenwärter zufällige Richtungen

import tkinter as tk
from random import randint

class Spiel(tk.Frame):
    """ Das Spiel, Zellenwärter, ist ein Spiel, das der PC selber
        mit sich spielen muß. Die im Quadrat neben einander liegenden
        Zellen sind mit einem Richtungspfeil ausgestattet, oben, rechts,
        unten und links. Zufällig oder nicht, das steht der Gestaltung
        offen. Ein Wärter geht seinen Weg durch die Zellen, er verlässt
        die Zelle in der Pfeilrichtung, in dem Moment dreht sich die
        Richtung um 90 grad im Uhrzeigersinn,so dass beim nächsten Besuch
        die Zelle in einer anderen Richtung verlassen werden muß.
        Die Außenwände werden übersprungen, es geht nur um einen Weg
        innerhalb des Quadrats. Der PC findet erstaunliche Wege. Er
        wiederholt dann nur die gleiche Wegabfolge immer wieder,
        und rundet in meistens 80 Schritten das Spielbrett ab,
        nur die ersten paar Schritte werden nicht wiederholt."""
    def __init__(self, master):
        tk.Frame.__init__(self, master)
        # Grundgerüst
        
        global zaehler
        self.zaehler = 0
        global zeichen
        self.zeichen = [ 'F', 'Ý', 'Þ', 'ß', 'Ü' ]
        # x und y die Startposition des Zellenwärters
        global x
        global y
        self.x = randint(0, 4 )
        self.y = randint(0, 4 )
        # self.zelle 5*5 Liste, enthält die Pfeilrichtungen
        # pruefzelle und self.pruefxy zum überprüfen genauso.
        self.zelle = 5 * [ 0 ]
        self.pruefzelle = 5 * [ 0 ]
        self.pruefxy = [ 0 ] * 2
        for f in range( 5 ):
            self.zelle[ f ] = 5 * [ 0 ]
            self.pruefzelle[ f ] = 5 * [ 0 ]
        
        # Pfeilrichtung Voreinstellung
        self.zelle[ 0 ][ 0 ] = randint( 2, 3 )
        self.zelle[ 0 ][ 4 ] = randint( 3, 4 )
        self.zelle[ 4 ][ 4 ] = randint( 0, 1 ) * 3 + 1
        self.zelle[ 4 ][ 0 ] = randint( 1, 2 )
        for f in range( 1, 4 ):
            self.zelle[ 0 ][ f ] = randint( 2, 4 )
            r = randint( 1, 3 )
            self.zelle[ f ][ 4 ] = int( r / 2 ) + r
            r = randint( 1, 3 )
            self.zelle[ 4 ][ f ] = int( r / 3 ) + r
            self.zelle[ f ][ 0 ] = randint( 1, 3 )
        for f1 in range( 1, 4 ):
            for f2 in range( 1, 4 ):
                self.zelle[ f1 ][ f2 ] = randint(1, 4 )
        # Voreinstellungen ausmalen mit Zellen, R1, R2, R3, R4, 
        # Wärter, ZW1.gif, Schieberegler - Ablaufgeschwindigkeit,
        # Rundenansage, Absolut Zähler, Beenden
        for f1 in range( 5 ):
            for f2 in range( 5 ):
                
                richtung = self.zeichen[ self.zelle[ f1 ][ f2 ] ]
                lb = tk.Label( self, text = richtung, font = ( 'Symbol', 20 ),
                               height = 2, width = 6 )
                lb.grid( row = f1, column = f2, padx = 5, pady = 5 )
        
        lb = tk.Label( self, text = self.zeichen[ 0 ],
                       font = ( 'Symbol', 20 ), height = 2, width = 6 )
        lb.grid( row = self.x, column = self.y, padx = 5, pady = 5 )
        self.wert = tk.IntVar()
        self.wert.set(2)
        self.scWert = tk.Scale( self, length = 80,orient = "horizontal",
                        from_=0, to=3, resolution = 1, tickinterval = 1,
                        label = "Wartezeit", variable = self.wert )
        self.scWert.grid( row = 5, column = 0, padx = 0, pady = 0 )

        self.runde = tk.Label(self, text='Runden ab 80')
        self.runde.grid(row=5, column=1)
        self.zaehl = tk.Label(self, text='0')
        self.zaehl.grid(row=5, column=2)
        self.aus = tk.Button(self, text='Ende', command = master.destroy)
        self.aus.grid(row=5, column=3)
        x1 = self.x
        y1 = self.y
        self.weiter( x1, y1 )
        
        self.kreis()
    def weiter( self, x2, y2 ):
        # Weiterführung des Zellenwärters der Pfeilrichtung entsprechend
        # und Neufassung ausmalen.
        # Pfeilrichtung: 1 hoch, 2 rechts, 3 runter, 4 links
        
        hoehe = x2
        breite = y2
        if self.zelle[ self.x ][ self.y ] == 1:
            hoehe -= 1
        if self.zelle[ self.x ][ self.y ] == 2:
            breite += 1
        if self.zelle[ self.x ][ self.y ] == 3:
            hoehe += 1
        if self.zelle[ self.x ][ self.y ] == 4:
            breite -= 1
        # Umstellung der Pfeilrichtung nach verlassen des Wärters
        self.zelle[ self.x ][ self.y ] += 1
        if self.zelle[ self.x ][ self.y ] == 5:
            self.zelle[ self.x ][ self.y ] = 1
        if self.zelle[ self.x ][ self.y ] == 1 and self.x == 0:
            self.zelle[ self.x ][ self.y ] = 2
        if self.zelle[ self.x ][ self.y ] == 2 and self.y == 4:
            self.zelle[ self.x ][ self.y ] = 3
        if self.zelle[ self.x ][ self.y ] == 3 and self.x == 4:
            self.zelle[ self.x ][ self.y ] = 4
        if self.zelle[ self.x ][ self.y ] == 4 and self.y == 0:
            self.zelle[ self.x ][ self.y ] = 1
        if self.zelle[ self.x ][ self.y ] == 4 and self.x == 0 and self.y == 0:
            self.zelle[ self.x ][ self.y ] = 2
        if self.zelle[ self.x ][ self.y ] == 1 and self.x == 0 and self.y == 0:
            self.zelle[ self.x ][ self.y ] = 2
        # Ausmalen beider Elemente
        richtung = self.zeichen[ self.zelle[ self.x ][ self.y ] ]
        lb = tk.Label( self, text = richtung,
                       font = ('Symbol', 20 ), height = 2, width = 6 )
        lb.grid( row = self.x, column = self.y, padx = 5, pady = 5 )
        
        lb = tk.Label( self, text = self.zeichen[ 0 ],
                       font = ( 'Symbol', 20 ),height = 2, width = 6 )
        lb.grid( row = hoehe, column = breite, padx = 5, pady = 5 )
        
        self.x = hoehe
        self.y = breite
        # die gleichen Pfeilrichtungen im ganzen Feld prüfen, das betreten
        # der selben Zelle muss sich erst einspielen und kann erst später
        # erfolgen, 80 ? => Schätzwert
        if self.zaehler == 80:
            self.pruefxy[ 0 ] = hoehe
            self.pruefxy[ 1 ] = breite
            for f1 in range( 5 ):
                for f2 in range( 5 ):
                    self.pruefzelle[ f1 ][ f2 ] = self.zelle[ f1 ][ f2 ]
        if self.zaehler > 80:
            if self.pruefxy[ 0 ] == hoehe and self.pruefxy[ 1 ] == breite:
                if self.zelle == self.pruefzelle:
                    self.runde.config( text = "Runde bei "+ str(self.zaehler ))
        # ende def self.weiter( x, y )von def __init__ ,dann folgend def.kreis()
        # Ablaufsystem: voreinstellung, weiter, kreis mit wartezeit, neu,
        #                               weiter, kreis mit wartezeit, neu...
    def neu(self, x ,y ):
        
        self.zaehl.config(text = str(self.zaehler) )
        self.weiter( self.x, self.y )
        
    def kreis(self ):
        
        self.neu( self.x, self.y )
        self.zaehler += 1
        self.after( (self.scWert.get()+1)**3 * 100, self.kreis)
        
                
def main():
    root = tk.Tk()
    root.title('Zellenwärter')
   
    app = Spiel(root)
    app.grid()
    app.mainloop()
    

if __name__ == "__main__":
    main()

Mal sehen... ich spekuliere ein bisschen darauf, das ihr Leute kennt, die sich gerne über so etwas den Kopf zerbrechen. Den Code verbessern wird noch eine Weile dauern.

[__blackjack__]

@gerdipy: Jetzt braucht man zwar keine Bilder mehr, aber diese Schriftart von Windows. Warum nicht einfach Unicode-Zeichen für die Pfeile verwenden und gar keine Schriftart fest vorschreiben?

Wenn man die Richtungen mit Zahlen modelliert, ist nicht unbedingt selbsterklärend was da warum mit gemacht wird. Da wären Kommentare nicht schlecht und/oder Konstanten, vielleicht sogar ein `enum`-Typ, oder gar Funktionen mit sprechenden Namen.

Das die Richtungen mit 1 statt mit 0 anfangen ist auch etwas untypisch für ein Computerprogramm. Und verhindert beispielsweise, dass man die Rotation einfach durch ``direction = (direction + 1) % 4`` ausdrücken kann.