Jak stworzyć grę w kółko i krzyżyk w Pythonie?

Stwórzmy prostą grę w kółko i krzyżyk w Pythonie. Pomoże ci zbudować logikę gry i zrozumieć, jak ustrukturyzować kod.

Gry to jedna z rozrywek, jaką mają ludzie. Możemy znaleźć różne rodzaje gier w Internecie, urządzeniach mobilnych, komputerach stacjonarnych itp. Nie jesteśmy tutaj, aby teraz tworzyć jedną z tych ciężkich gier. Zamierzamy stworzyć grę w kółko i krzyżyk w CLI przy użyciu Pythona.

Jeśli nie znasz gry w kółko i krzyżyk, zagraj w nią wizualnie tutaj rozumieć. Nie martw się, nawet jeśli tego nie rozumiesz, zobaczymy.

Kółko i krzyżyk

Samouczek jest podzielony na trzy różne sekcje. W pierwszej części dowiesz się, jak grać w kółko i krzyżyk. Następnie zobaczymy algorytm, który pomoże nam wymyślić logikę gry. Wreszcie zobaczymy kod strukturalny i jego wyjaśnienie.

Możesz pominąć pierwszą sekcję, jeśli już wiesz, jak grać w kółko i krzyżyk.

Więc bez zbędnych ceregieli przejdźmy do naszej pierwszej sekcji.

Gra w kółko i krzyżyk

W grze będzie dwóch graczy. Dwa znaki reprezentują każdego gracza. Ogólne znaki używane w grze to X i O. Na koniec pojawi się plansza z 9 polami.

Zobacz wizualnie planszę w kółko i krzyżyk.

Tablica Tic Tac Toe

Rozgrywka będzie wyglądać następująco.

  • Najpierw jeden użytkownik umieszcza swój znak w jednym z dostępnych pustych pól.
  • Następnie drugi użytkownik umieści swój podpis w jednym z dostępnych pustych pól.
  • Celem graczy jest umieszczenie odpowiednich znaków całkowicie w rzędach, kolumnach lub po przekątnej.
  • Gra toczy się do momentu, gdy gracz wygra grę lub zakończy się remisem, wypełniając wszystkie pola bez zwycięskiego meczu.

Zobaczmy wizualnie niektóre gameplaye.

Wygraj grę w kółko i krzyżyk

Gracz X wygrywa grę w powyższej rozgrywce. Wszystkie pola po przekątnej wypełniają się znakami X. Tak więc odpowiedni gracz wygrywa grę.

Istnieje w sumie 8 sposobów ułożenia tego samego znaku i wygrania gry. Zobaczmy wszystkie 8 układów, które mogą wygrać mecz.

Zwycięskie układy w kółko i krzyżyk

I wreszcie remis zapełnia planszę bez żadnego zwycięskiego układu. Mam nadzieję, że teraz rozumiesz, jak zrobić kółko i krzyżyk.

Teraz czas na zabawę. Możesz iść tutaj i zagraj, aby całkowicie zrozumieć rozgrywkę. Zostaw to, jeśli już to masz.

Teraz pora przenieść sekcję algorytmów.

Algorytm

Omówimy teraz algorytm pisania kodu. Ten algorytm pomoże Ci napisać kod w dowolnym wybranym przez Ciebie języku programowania. Zobaczmy, jak to się robi.

  • Utwórz tablicę przy użyciu dwuwymiarowej tablicy i zainicjuj każdy element jako pusty.
    • Możesz reprezentować puste za pomocą dowolnego symbolu. Tutaj użyjemy łącznika. ’-’.
  • Napisz funkcję sprawdzającą, czy tablica jest wypełniona, czy nie.
    • Iteruj po tablicy i zwróć wartość false, jeśli tablica zawiera pusty znak, lub zwróć wartość true.
  • Napisz funkcję sprawdzającą, czy gracz wygrał, czy nie.
    • Musimy sprawdzić wszystkie możliwości, które omówiliśmy w poprzedniej sekcji.
    • Sprawdź wszystkie wiersze, kolumny i dwie przekątne.
  • Napisz funkcję wyświetlającą planszę, ponieważ będziemy ją pokazywać użytkownikom wiele razy podczas gry.
  • Napisz funkcję uruchamiającą grę.
    • Wybierz losowo pierwszą turę gracza.
    • Napisz nieskończoną pętlę, która zostanie przerwana po zakończeniu gry (wygrana lub remis).
      • Pokaż planszę użytkownikowi, aby wybrać miejsce na następny ruch.
      • Poproś użytkownika o wprowadzenie numeru wiersza i kolumny.
      • Zaktualizuj miejsce odpowiednim znakiem gracza.
      • Sprawdź, czy aktualny gracz wygrał grę, czy nie.
      • Jeśli bieżący gracz wygrał grę, wypisz zwycięską wiadomość i przerwij nieskończoną pętlę.
      • Następnie sprawdź, czy plansza jest wypełniona, czy nie.
      • Jeśli plansza jest wypełniona, wydrukuj komunikat losowania i przerwij nieskończoną pętlę.
    • Na koniec pokaż użytkownikowi końcowy widok tablicy.

Możesz być w stanie wyobrazić sobie, co się dzieje. Nie martw się, nawet jeśli nie do końca to zrozumiałeś. Uzyskasz większą przejrzystość, gdy zobaczysz kod.

Przejdźmy więc do sekcji kodu. Zakładam, że masz zainstalowany Python na swoim komputerze, aby wypróbować kod.

Kod

Przejdź przez poniższy kod.

import random


class TicTacToe:

    def __init__(self):
        self.board = []

    def create_board(self):
        for i in range(3):
            row = []
            for j in range(3):
                row.append('-')
            self.board.append(row)

    def get_random_first_player(self):
        return random.randint(0, 1)

    def fix_spot(self, row, col, player):
        self.board[row][col] = player

    def is_player_win(self, player):
        win = None

        n = len(self.board)

        # checking rows
        for i in range(n):
            win = True
            for j in range(n):
                if self.board[i][j] != player:
                    win = False
                    break
            if win:
                return win

        # checking columns
        for i in range(n):
            win = True
            for j in range(n):
                if self.board[j][i] != player:
                    win = False
                    break
            if win:
                return win

        # checking diagonals
        win = True
        for i in range(n):
            if self.board[i][i] != player:
                win = False
                break
        if win:
            return win

        win = True
        for i in range(n):
            if self.board[i][n - 1 - i] != player:
                win = False
                break
        if win:
            return win
        return False

        for row in self.board:
            for item in row:
                if item == '-':
                    return False
        return True

    def is_board_filled(self):
        for row in self.board:
            for item in row:
                if item == '-':
                    return False
        return True

    def swap_player_turn(self, player):
        return 'X' if player == 'O' else 'O'

    def show_board(self):
        for row in self.board:
            for item in row:
                print(item, end=" ")
            print()

    def start(self):
        self.create_board()

        player="X" if self.get_random_first_player() == 1 else 'O'
        while True:
            print(f"Player {player} turn")

            self.show_board()

            # taking user input
            row, col = list(
                map(int, input("Enter row and column numbers to fix spot: ").split()))
            print()

            # fixing the spot
            self.fix_spot(row - 1, col - 1, player)

            # checking whether current player is won or not
            if self.is_player_win(player):
                print(f"Player {player} wins the game!")
                break

            # checking whether the game is draw or not
            if self.is_board_filled():
                print("Match Draw!")
                break

            # swapping the turn
            player = self.swap_player_turn(player)

        # showing the final view of board
        print()
        self.show_board()


# starting the game
tic_tac_toe = TicTacToe()
tic_tac_toe.start()

Sprawdź przykładowe wyjście kodu.

$ python tic_tac_toe.py 
Player X turn
- - -
- - -
- - -
Enter row and column numbers to fix spot: 1 1

Player O turn
X - -
- - -
- - -
Enter row and column numbers to fix spot: 2 1

Player X turn
X - -
O - -
- - -
Enter row and column numbers to fix spot: 1 2

Player O turn
X X -
O - -
- - -
Enter row and column numbers to fix spot: 1 3

Player X turn
X X O
O - -
- - -
Enter row and column numbers to fix spot: 2 2

Player O turn
X X O
O X -
- - -
Enter row and column numbers to fix spot: 3 3

Player X turn
X X O        
O X -        
- - O
Enter row and column numbers to fix spot: 3 2

Player X wins the game!

X X O
O X -
- X O

Kilka głównych punktów, które pomogą Ci zrozumieć strukturę kodu.

  • Użyliśmy klasy, aby mieć wszystkie metody w jednym miejscu. Może to być również pakiet wielokrotnego użytku w innym kodzie.
  • Następnie zdefiniowaliśmy różne funkcje dla każdej odpowiedzialności, nawet jeśli jest to małe zadanie. Pomaga z łatwością utrzymać kod.
  • Powyższe dwa podejścia pomagają nam bezproblemowo zaktualizować aplikację, jeśli chcemy zaktualizować grę.

Możesz dostosować strukturę i ulepszyć ją w oparciu o swój projekt. Strukturyzacja kodu nie jest ograniczona.

Ostatnie słowa

Hurra! 😎 Stworzyłeś grę całkowicie od zera. To nie jest jedna z gier wizualnych, w które gramy codziennie. Ale pomaga pisać logikę i utrzymywać czystą strukturę kodu. Postępuj zgodnie z podobnymi wytycznymi, aby stworzyć kilka ciekawych gier, takich jak ta. Możesz znaleźć podobne gry, jeśli cofniesz się o kilka lat do swojego dzieciństwa.

Szczęśliwego kodowania! 👩‍💻

Następnie dowiedz się, jak stworzyć grę polegającą na odgadywaniu liczb i testy jednostkowe za pomocą modułu Python unittest.

Podobał Ci się artykuł? A co powiesz na dzielenie się ze światem?