Das Spielfeld eines Solitär Spiel

[Bombastino]

Hallo Team,
Mich begeistert immer wieder die Möglichkeit eines Forums.
Ich bin Python Neuling. Und möchte aber ein Spiel welches ein Freund für einen Kuka Roboters geschrieben hat, in Python nachempfinden. Als erstes möchte ich die gültigen Plätze errechnen lassen und nicht vorgeben müssen. Das Spiel ist als Dreieck aufgebaut und fängt in der untersten Reihe mit 5 Steinen an und Endet mit einem Stein in der obersten 5. Reihe. Der erste oberste Stein wird entfernt. Das Ziel des Spieles ist es durch überspringen und wegnehmen des übersprungenen Steins möglichst wenig Steine auf dem Spielfeld zu hinterlassen. Ich habe mir einige Gedanken gemacht wie ich das Programm aufbauen möchte. Bei der ersten Aktion habe ich schon Probleme und weiß eigentlich nicht warum. Ich möchte Z wei Eingaben machen. Aber hierbleibt es schon bei der Ausführung ein mir unverständlicher Fehler.
Wer kann mir hier in kleinen Schritten erklären was ich falsch mache!
Vielen Dank für Deine Hilfe.
Anbei mein Vorhaben.
'Spielfeld ohne Figuren'
'101010101'
'010101010'
'001010100'
'000101000'
'000010000'

'aktive Felder haben eine Zahl grösser als 0'
'aktives Feld'
'wenn 0 ist es ein nicht betretbarer Platz'
'wenn 1 dann ist es ein aktiver Platz des Spielfedes'
'zu Beginn des Spieles ist der aktive Platz mit einer Figur belegt'
'Spielfeld wird mit Figuren gefüllt'
'Auf jedem Platz wird eine Figur gesetzt. Der Wert erhöht sich um 1 '
'Jeder Platz mit 0 bleibt 0 '
'Spalte:123456789'
'Zeile1:202020202'
'Zeile2:020202020'
'Zeile3:002020200'
'Zeile4:000202000'
'Zeile5:000020000'
'Sprungregeln: das benachbarte Feld muss eine Spielfigur haben, das nächste Feld muss frei sein'
'Ein Betrachtungstripel kann nur eine Richtung haben'
'Habe ich ein Nachbarfeld gefunden muss sich das nächste Nachbarfeld mit der selben Regel gefunden werden.'
'ein benachbartes Feld kann auch in einer b,enachbarten Zeile Liegen'
'Welche Vorschrift zeigt mir die benachbarten Felder'
'wir beginnen beim Platz 1 1. Spalte 1. Zeile Es ist ein Spielfeldplatz und eine Figur ist vorhanden'
'Gibt es einen Nachbarn? 2. Spalte ist kein Spielfeld weitersuchen'
'3.Spalte in 1. Zeile ist ein Spielfeld und hat eine Figur es ist ein benachbartes Feld. Das nächste benachbarte Feld kann nur in derelben Zeile liegen.'
'Matrix mit benachbarten Feldern aufbauen'
'Benachbarte Felder haben die gleiche Zeile mit aufeinander folgenden Spalten oder unterschiedliche Zeilen und aufeinander folgende Spalten'
'Die Gültigen Tripel sind (auch umgekehrt) also 32 Züge:
'1/1 1/3 1/5(1)'
'1/1 2/2 3/3(2)'
'1/3 2/4 3/5(3)'
'1/3 1/5 1/7(4)'
'1/5 1/7 1/9(5)'
'2/2 3/3 4/4(6)'
'3/3 4/4 5/5(7)'
'2/2 2/4 2/6(8)'
'2/4 2/6 2/8(9)'
'3/3 4/4 5/5(10)'
'3/3 3/5 3/6(11)'
'1/9 2/8 3/7(12)'
'1/7 2/5 3/3(13)'
'2/6 3/5 4/4(14)'
'3/7 4/5 5/4(15)'
'1/5 2/4 3/3(16)'
'2/8 3/7 4/6(17)'
'3/3 4/4 4/5(18)'

'Errechnung von gültigen Setzmöglichkeiten'
def main():

spielfeld = int(
input('Länge des Spielfelde')
)
gueltig()
'''sprung = int(
input('Wieviel Steine müssen übersprungen werden')
)'''
def Gueltig()'''


if __name__ == '__main__':
main()

[Sirius3]

In Deinem anderen Beitrag hat man Dir schon gesagt, dass es gut wäre, die Codetags </> zu benutzen, damit man den Code auch lesen kann. Wenn es Fehler gibt, solltest Du auch den Fehler samt kompletten Traceback mitposten. Hier ist nicht ersichtlich, ob das wirklich der Code ist, den Du versucht hast auszuführen, oder ob Du einfach nur die Hälfte hier hineinkopiert hast, denn außer einem minimalen Codefragment sehe ich noch nichts.
Sind die ersten 52 Zeilen wirklich alles Strings? Kommentare leitet man mit # ein. Strings sind KEINE Kommentare.
Du versuchst eine Funktion `gueltig` aufzurufen, definierst aber ein `Gueltig`. Und dann bricht der Code mittendrin ab.

Zum Vorgehen: Statt das Spielfeld in Listen oder gar Strings zu speichern, wähle eine Datenstruktur, die dem Problem angepasst ist, Hier bietet sich eine Struktur an, die die nächsten Nachbarn, links-oben, rechts-oben, links, rechts, links-unten, rechts-unten enthält. Übernächste Nachbarn bekommt man einfach, indem man in die selbe Richtung nochmal eins weiter geht. None repräsentiert das Ende des Spielfeldes, dass es keinen nächsten Nachbarn in dieser Richtung mehr gibt.

Um sich mit solchen Datenstrukturen vertraut zu machen, würde ich erst als Übung eine doppelt verkettete Liste programmieren.

[__blackjack__]

Also wenn man sich nur den tatsächlichen Code anschaut ohne die ganzen Zeichenketten davor, bleibt das hier:

Code: Alles auswählen

def main():
    
    spielfeld = int(
        input('Länge des Spielfelde')
        )
        gueltig()
  '''sprung = int(
    input('Wieviel Steine müssen übersprungen werden')
    )'''
def Gueltig()'''


if __name__ == '__main__':
    main()

Und das ist ziemlich offensichtlich kein gültiges Python. Worüber der Compiler als erstes stolpert ist die unerwartete Einrückung von ``gueltig()``. Wenn man das beseitigt, dann über die Einrückung von der folgenden Zeile die zu keiner Einrückung von vorhergehenden Zeilen passt. Und auch hier noch mal die Anmerkung: literale Zeichenketten sind nicht für Kommentare oder zum auskommentieren von Code gedacht. Wenn man das Problem beseitigt, weiss der Compiler nicht was er mit den drei Anführungszeichen anfangen soll die eine mehrzeilige Zeichenkette einleiten, die aber nirgends beendet wird. Beseitigt man das Problem, dann stoppt der Compiler bei der angefangenen Definition von `Gueltig`, was so keine gültige Python-Syntax ist.

Das sind ziemlich viele, ziemlich offensichtliche Fehler für so wenig Code.

`gueltig()` wäre auch kein wirklich guter Name für eine Funktion. Funktionen und Methoden werden nach der Tätigkeit benannt, die sie ausführen. Abweichend werden Funktionen/Methoden die etwas prüfen und einen Wahrheitswert zurück geben, oft `is_*()` oder `has_*()` genannt. Also hier zum Beispiel `is_valid()`. Da würde dann aber irgendwie auch ein Argument fehlen, denn die Funktion muss ja irgend etwas haben was sie prüft, und mit dem Rückgabewert muss man dann auch etwas machen.

Eine Funktion die die gültigen Züge berechnet, bräuchte das Spielfeld und vielleicht noch einen Ausgangspunkt als Argument(e). Und müsste dann die gültigen Züge in irgendeiner geeigneten Form als Ergebnis zurück geben. So eine Funktion könnte man `berechne_gueltige_zuege()` nennen. Oder `…_zugfolgen()` wenn es mehrere Züge pro Ergebniselement sind.