Find Four in Python: 2D-Arrays & Spielentwicklung Schritt für Schritt – COP3504C Lab 02

Find Four in Python: Einführung in 2D-Arrays und Spielentwicklung

Das Find Four-Spiel (auch bekannt als Connect Four) ist ein perfektes Projekt, um 2D-Arrays, Schleifen und Fehlerbehandlung in Python zu üben. In diesem Tutorial baust du Schritt für Schritt eine voll funktionsfähige Konsolenversion des Spiels – genau wie im COP3504C Lab 02 gefordert. Du lernst, wie man ein Spielfeld als Liste von Listen modelliert, Spielsteine einfügt, auf Sieg prüft und Benutzereingaben robust verarbeitet.

Dieses Tutorial ist perfekt für Informatikstudierende, die ihre Kenntnisse in Python-Programmierung vertiefen möchten. Es ist auch eine großartige Vorbereitung auf Programmierprüfungen und Hausaufgaben. Lass uns loslegen!

1. Das Spielfeld initialisieren

Das Spielfeld ist ein 2D-Array (Liste von Listen). Jede Zelle enthält anfangs einen Punkt '.' für ein leeres Feld. Die Größe wird vom Benutzer eingegeben (zwischen 4 und 25).

def get_initial_board(rows, columns):
    return [['.' for _ in range(columns)] for _ in range(rows)]

Beachte: Zeile 0 ist der Boden des Spielbretts – der Stein fällt nach unten. Das ist wichtig für die Darstellung und Logik.

2. Das Spielfeld ausgeben

Die Funktion print_board(board) gibt das Spielfeld zeilenweise aus. Die oberste Zeile (höchster Index) wird zuerst ausgegeben.

def print_board(board):
    for row in reversed(board):
        print('|' + ' '.join(row) + '|')

Mit reversed geben wir die Zeilen von oben nach unten aus – so sieht der Spieler den Boden unten.

3. Einen Spielstein einfügen

Der Spieler wählt eine Spalte, und der Stein fällt auf die niedrigste freie Position. Die Funktion insert_chip sucht von unten nach oben die erste leere Zelle und platziert den Stein. Sie gibt die Zeile zurück, in der der Stein gelandet ist.

def insert_chip(board, column, chip):
    for row in range(len(board)):
        if board[row][column] == '.':
            board[row][column] = chip
            return row
    return -1  # Spalte voll

Diese Methode wird vom Spielablauf verwendet, um den Zug auszuführen.

4. Siegprüfung: Vier in einer Reihe

Die wichtigste Funktion: is_win_state(chip, board, row, column) prüft, ob der Spieler mit dem angegebenen Chip an der Position (row, column) gewonnen hat. Es werden nur horizontale und vertikale Reihen geprüft (diagonal ist in dieser Aufgabe nicht gefordert).

def is_win_state(chip, board, row, column):
    # Horizontal prüfen
    count = 0
    for c in range(len(board[0])):
        if board[row][c] == chip:
            count += 1
            if count == 4:
                return True
        else:
            count = 0
    # Vertikal prüfen
    count = 0
    for r in range(len(board)):
        if board[r][column] == chip:
            count += 1
            if count == 4:
                return True
        else:
            count = 0
    return False

Diese Funktion wird nach jedem Zug aufgerufen, um zu prüfen, ob der aktuelle Spieler gewonnen hat.

5. Brett voll? Unentschieden erkennen

Wenn das Brett voll ist und kein Spieler gewonnen hat, endet das Spiel unentschieden. Die Funktion is_board_full(board) prüft, ob alle Zellen belegt sind.

def is_board_full(board):
    for row in board:
        if '.' in row:
            return False
    return True

6. Fehlerbehandlung: Eingaben prüfen

Das Programm muss fehlerhafte Eingaben abfangen: ungültige Dimensionen, volle Spalten, nicht vorhandene Spalten, keine Zahlen. Hier ein Beispiel für die Eingabe der Dimensionen:

while True:
    try:
        rows = int(input("Enter height of board (rows): "))
        if rows < 4:
            print("Error: height must be at least 4!")
            continue
        if rows > 25:
            print("Error: height can be at most 25!")
            continue
        break
    except ValueError:
        print("Error: not a number!")

Analog für Spalten und für die Spaltenauswahl während des Spiels. Behandle jede Fehlerart mit einer klaren Meldung.

7. Spielablauf: Hauptschleife

Der Spielablauf folgt einem einfachen Muster: Begrüßung, Brettgröße erfragen, Brett initialisieren, abwechselnd Spielerzüge ausführen, bis ein Sieg oder Unentschieden eintritt.

def play_game():
    print("Welcome to Find Four!")
    print("———————")
    rows = get_dimension("height", "rows")
    cols = get_dimension("width", "columns")
    board = get_initial_board(rows, cols)
    print_board(board)
    print("Player 1: x")
    print("Player 2: o")
    current_player = 1
    while True:
        chip = 'x' if current_player == 1 else 'o'
        col = get_column_choice(board, cols, current_player)
        row = insert_chip(board, col, chip)
        print_board(board)
        if is_win_state(chip, board, row, col):
            print(f"Player {current_player} won the game!")
            break
        if is_board_full(board):
            print("Draw game! Players tied.")
            break
        current_player = 3 - current_player  # Wechsel zwischen 1 und 2

Die Hilfsfunktionen get_dimension und get_column_choice kapseln die Fehlerbehandlung.

8. Vollständiger Code und Test

Setze alle Funktionen in einer Datei FindFour.py zusammen. Teste mit verschiedenen Eingaben, um sicherzustellen, dass die Ausgabe exakt dem erwarteten Format entspricht (z. B. |x . . . .|). Achte auf die korrekte Darstellung des Bretts und die Fehlermeldungen.

Hier ein kurzer Testfall:

# Eingabe: Höhe 4, Breite 5, dann Züge: 0, 0, 0, 0 (Spieler 1 gewinnt vertikal)
# Erwartet: Nach vier Zügen in Spalte 0 gewinnt Spieler 1.

9. Tipps für den Erfolg

• 2D-Arrays verstehen: Denke an eine Tabelle mit Zeilen und Spalten. Der Zugriff erfolgt über board[zeile][spalte].
• Fehlerbehandlung ernst nehmen: Die Unit-Tests prüfen genau deine Fehlermeldungen. Verwende try/except für Zahlen und überprüfe Bereiche.
• Teste systematisch: Probiere Randfälle wie minimale Größe (4x4), maximale Größe (25x25), volle Spalte, ungültige Spaltennummer.
• Nutze die Community: Wenn du nicht weiterkommst, suche nach Python Connect Four Tutorial oder frage in Programmierforen.

10. Ausblick: Erweiterungen

Nachdem du das Basisspiel gemeistert hast, kannst du es erweitern: diagonale Siegprüfung, Spielmodi (z. B. gegen Computer), grafische Oberfläche mit Pygame oder Highscore-Liste. Diese Erweiterungen sind tolle Projekte für dein Portfolio oder als Hausaufgabe.

Viel Erfolg beim Programmieren! Denk daran: Übung macht den Meister – und mit diesem Tutorial hast du einen soliden Start.