Nasza strona używa cookies. Korzystając ze strony, wyrażasz zgodę na używanie cookies, zgodnie z aktualnymi ustawieniami przeglądarki. Rozumiem

Stwórz grę w kółko i krzyżyk w Pythonie

Geoffrey Mariette Cloud Engineer / DevOps / FDJ - Française des jeux
Sprawdź, jak stworzyć prostą grę w kółko i krzyżyk w Pythonie, bez pomocy żadnej biblioteki.
Stwórz grę w kółko i krzyżyk w Pythonie

Pokażę Ci dziś, jak stworzyć grę multiplayer w kółko i krzyżyk w Pythonie. Nie będzie nam potrzebna żadna dodatkowa biblioteka. Sugeruję tutaj, abyś spróbował/a stworzyć własne funkcje, po prostu czytając do czego mają służyć. Jeśli napotkasz jakiekolwiek problemy, nie wahaj się rzucić okiem na to, jak wykonałem tę funkcję, a następnie wróć do swojego edytora, aby spróbować zrobić to samodzielnie. W razie potrzeby, cały kod dostępny jest na dole artykułu.

Aby zagrać w naszą grę, będziemy potrzebować pewnych funkcji. Pierwszą rzeczą do zrobienia jest spisanie tego, czego potrzebujemy.


Gra w kółko i krzyżyk odbywa się na planszy. Nasza pierwsza funkcja to display_board. Następnie musimy zapytać gracza, czy chciałby użyć krzyżyka (X) czy kółka (O). Mamy naszą drugą funkcję.

Następnie gracz musi mieć opcję skreślenia pola (trzecia funkcja). Jednak przed jej umieszczeniem musi wybrać, gdzie postawić kółko lub krzyżyk (czwarta funkcja) i określić, czy ta lokalizacja jest dostępna (piąta funkcja).

Chcemy również sprawdzić za każdym razem, gdy umieszczony zostanie kolejny symbol, czy ktoś w tym momencie nie wygrał (szósta funkcja) lub czy plansza nie jest pełna (siódma funkcja).

Na koniec chcemy udostępnić funkcję ponownej gry, aby móc do woli powtarzać partyjkę bez ponownego uruchamiania programu.

Pierwszą funkcję nazwiemy display_board. Stworzymy pustą tablicę zawierającą numery z klawiatury numerycznej. Te liczby zostaną zastąpione przez X lub O po dokonaniu wyboru przez gracza.

Wybory graczy zostaną zapisane na liście dziesięciu pozycji (tylko dlatego, że pozycja numer 0 nie może być wyborem użytkownika). Ta lista zostanie zdefiniowana w programie i będzie wyglądać następująco: board = [‘#’,‘#’,‘#’,‘#’,‘#’,‘#’,‘#’,‘#’,‘#’,‘#’].

def display_board(board):
    blankBoard="""
___________________
|     |     |     |
|  7  |  8  |  9  |
|     |     |     |
|-----------------|
|     |     |     |
|  4  |  5  |  6  |
|     |     |     |
|-----------------|
|     |     |     |
|  1  |  2  |  3  |
|     |     |     |
|-----------------|
"""
    for i in range(1,10):
        if (board[i] == 'O' or board[i] == 'X'):
            blankBoard = blankBoard.replace(str(i), board[i])
        else:
            blankBoard = blankBoard.replace(str(i), ' ')
    print(blankBoard)


Ta funkcja przyjmuje listę naszej planszy jako parametr i zastępuje numer ruchu wewnątrz blankBoard wyborem gracza albo pustym miejscem.

Druga funkcja zapyta gracza pierwszego, który symbol chce wybrać. Dostępne opcje to X/x lub O/o. Jeśli użytkownik dokona innego wyboru, program musi ponownie poprosić o wprowadzenie danych.

def player_input():
player1 = input("Please pick a marker 'X' or 'O' ")
while True:
    if player1.upper() == 'X':
        player2='O'
        print("You've choosen " + player1 + ". Player 2 will be " + player2)
        return player1.upper(),player2
    elif player1.upper() == 'O':
        player2='X'
        print("You've choosen " + player1 + ". Player 2 will be " + player2)
        return player1.upper(),player2
    else:
        player1 = input("Please pick a marker 'X' or 'O' ")


Użyjemy w tym przypadku wyrażenia while True, które zostanie zakończone, jeśli dane wejściowe będą pasowały do możliwych opcji wyboru. Zauważ, że stosujemy input if player1.upper() == ‘X’:, aby uniknąć podwójnego sprawdzania.

Trzecią funkcją będzie place_marker

def place_marker(board, marker, position):
    board[position] = marker
    return board


Przekazujemy do niej planszę, symbol i wybór pola. Funkcja ta przypisze znacznik do naszej listy, zastępując znak # na danej pozycji.

Odtąd obie nasze funkcje będą pytać gracza o pole, które wybiera i sprawdzać, czy to miejsce jest puste, czy nie. Te dwie funkcje są ze sobą powiązane i dlatego umieściłem je w jednym miejscu.

def space_check(board, position):
    return board[position] == '#'
def player_choice(board):
    choice = input("Please select an empty space between 1 and 9 : ")
    while not space_check(board, int(choice)):
        choice = input("This space isn't free. Please choose between 1 and 9 : ")
    return choice


Najpierw funkcja space_check odbierze dwa argumenty, listę planszy i miejsce na planszy. Zwróci True, jeśli pole position będzie miało wartość #, co oznacza, że miejsce jest wolne. Jeśli nie, oznacza to, że to pole zostało już wybrane, więc zwróci False.

Następnie funkcja player_choice przyjmie planszę jako parametr. Będzie pytać użytkownika o jego wybór. Dopóki ten nie wybierze wolnego miejsca, będzie pytany do skutku o puste pole. Następnie zwróci wybór użytkownika.

Pozostają już tylko trzy funkcje: Czy plansza jest zapełniona? Czy ktoś już wygrał? Chcesz zagrać ponownie?

def full_board_check(board):
    return len([x for x in board if x == '#']) == 1


Odpowiedzi na pytanie „czy tablica jest zapełniona?” można sprawdzić za pomocą powyższego kodu.

Używamy tutaj listy z wyrażeniem if. Musimy przeanalizować listę tablicy i wyodrębnić wszystkie elementy pasujące do # z listy. Następnie obliczymy długość tej listy i jeśli jej wartość jest równa 1, zwracamy True (tj. nasza tablica jest zapełnioa); jeśli nie, zwracamy False.

Następnie należy sprawdzić, czy ktoś już wygrał grę. Po prostu sprawdzamy, czy mamy linię lub przekątną stworzoną z tego samego symbolu. Dwa wymagane parametry to lista planszy i symbol, który chcemy sprawdzić.

def win_check(board, mark):
    if board[1] == board[2] == board[3] == mark:
        return True
    if board[4] == board[5] == board[6] == mark:
        return True
    if board[7] == board[8] == board[9] == mark:
        return True
    if board[1] == board[4] == board[7] == mark:
        return True
    if board[2] == board[5] == board[8] == mark:
        return True
    if board[3] == board[6] == board[9] == mark:
        return True
    if board[1] == board[5] == board[9] == mark:
        return True
    if board[3] == board[5] == board[7] == mark:
        return True
    return False


Jesteśmy przy ostatniej funkcji, czyli pytaniu gracza/y o to, czy chcą zagrać ponownie.

def replay():
    playAgain = input("Do you want to play again (y/n) ? ")
    if playAgain.lower() == 'y':
        return True
    if playAgain.lower() == 'n':
        return False


Mamy gotowe funkcje. Nadszedł czas, aby wszystkie te elementy zaimplementować w naszym programie.

Uruchamiamy program tylko wtedy, gdy jest włączany bezpośrednio. Jeśli odpalimy funkcję z innego skryptu Pythona, to, co znajduje się pod wyrażeniem if, nie zostanie załadowane. Aby dowiedzieć się więcej o zmiennej wbudowanej __name__, możesz poczytać o tym tutaj lub tutaj.

if __name__ == "__main__":
    print('Welcome to Tic Tac Toe!')
    i = 1
    # Choose your side
    players=player_input()
    # Empty board init
    board = ['#'] * 10
    while True:
        # Set the game up here
        game_on=full_board_check(board)
        while not game_on:
            # Player to choose where to put the mark
            position = player_choice(board)
            # Who's playin ? Choose the marker
            if i % 2 == 0:
                marker = players[1]
            else:
                marker = players[0]
            # Play !
            place_marker(board, marker, int(position))
            # Check the board
            display_board(board)
            i += 1
            if win_check(board, marker):
                print("You won !")
                break
            game_on=full_board_check(board)
        if not replay():
            break
        else:
            i = 1
            # Choose your side
            players=player_input()
            # Empty board init
            board = ['#'] * 10


Czego tu potrzebujemy? Może licznika, który nazwiemy i. Użyjemy go do określenia, który gracz obecnie gra, za pomocą funkcji modulo: if i % 2 = =0. Wtedy wiemy, że jest kolej gracza numer dwa.

Następnie poprosimy naszego gracza o wybranie symbolu, którym będzie grał, za pomocą funkcji player_input. Nie zapominajmy, że ta funkcja zwraca dwie wartości, które przechowujemy w zmiennej players.

Musimy oczywiście zacząć od pustej planszy, która jest zdefiniowana przez wyrażenie board = [‘#’] * 10.

Możemy odpalać grę. Zaczynamy od pętli while True, która rozpoczyna od sprawdzenia, czy tablica jest zapełniona. Jeśli nie jest, wchodzimy w drugą pętlę while. Możemy podzielić to na pięć bloków:

1. Prosimy użytkownika o input:

position = player_choice(board)


2. Ustalamy, kto gra:

if i % 2 == 0:
marker = players[1]
else: marker = players[0]


3. Umieszczamy odpowiednio symbol i wyświetlamy zaktualizowaną planszę graczom, a następnie zwiększamy nasz licznik i, aby zmienić gracza:

# Play !
 place_marker(board, marker, int(position))
 # Check the board
 display_board(board)
 i += 1


4. Sprawdzamy, czy ktoś wygrał:

 if win_check(board, marker):
 print(“You won !”)
 break
 game_on=full_board_check(board)


5. Na koniec pytamy, czy gracz/e chcą zagrać jeszcze raz. Jeśli tak, ponownie uruchamiamy naszą planszę oraz liczniki var i wracamy do naszej pierwszej pętli while.


Teraz nasz kod jest gotowy, a Ty możesz zagrać w swoją grę. Wystarczy wkleić cały kod do pliku .py i uruchomić go za pomocą komendy.

Oto efekt naszej zabawy:

Cały ten tutorial powstał podczas kursu Udemy, “Complete Python Bootcamp”.

Tutaj możesz podejrze, jak wygląda mój kod:

def display_board(board):
    blankBoard="""
___________________
|     |     |     |
|  7  |  8  |  9  |
|     |     |     |
|-----------------|
|     |     |     |
|  4  |  5  |  6  |
|     |     |     |
|-----------------|
|     |     |     |
|  1  |  2  |  3  |
|     |     |     |
|-----------------|
"""

    for i in range(1,10):
        if (board[i] == 'O' or board[i] == 'X'):
            blankBoard = blankBoard.replace(str(i), board[i])
        else:
            blankBoard = blankBoard.replace(str(i), ' ')
    print(blankBoard)

def player_input():
    player1 = input("Please pick a marker 'X' or 'O' ")
    while True:
        if player1.upper() == 'X':
            player2='O'
            print("You've choosen " + player1 + ". Player 2 will be " + player2)
            return player1.upper(),player2
        elif player1.upper() == 'O':
            player2='X'
            print("You've choosen " + player1 + ". Player 2 will be " + player2)
            return player1.upper(),player2
        else:
            player1 = input("Please pick a marker 'X' or 'O' ")

def place_marker(board, marker, position):
    board[position] = marker
    return board

def space_check(board, position):
    return board[position] == '#'

def full_board_check(board):
    return len([x for x in board if x == '#']) == 1

def win_check(board, mark):
    if board[1] == board[2] == board[3] == mark:
        return True
    if board[4] == board[5] == board[6] == mark:
        return True
    if board[7] == board[8] == board[9] == mark:
        return True
    if board[1] == board[4] == board[7] == mark:
        return True
    if board[2] == board[5] == board[8] == mark:
        return True
    if board[3] == board[6] == board[9] == mark:
        return True
    if board[1] == board[5] == board[9] == mark:
        return True
    if board[3] == board[5] == board[7] == mark:
        return True
    return False

def player_choice(board):
    choice = input("Please select an empty space between 1 and 9 : ")
    while not space_check(board, int(choice)):
        choice = input("This space isn't free. Please choose between 1 and 9 : ")
    return choice

def replay():
    playAgain = input("Do you want to play again (y/n) ? ")
    if playAgain.lower() == 'y':
        return True
    if playAgain.lower() == 'n':
        return False

if __name__ == "__main__":
    print('Welcome to Tic Tac Toe!')
    i = 1
    # Choose your side
    players=player_input()
    # Empty board init
    board = ['#'] * 10
    while True:
        # Set the game up here
        game_on=full_board_check(board)
        while not game_on:
            # Player to choose where to put the mark
            position = player_choice(board)
            # Who's playin ?
            if i % 2 == 0:
                marker = players[1]
            else:
                marker = players[0]
            # Play !
            place_marker(board, marker, int(position))
            # Check the board
            display_board(board)
            i += 1
            if win_check(board, marker):
                print("You won !")
                break
            game_on=full_board_check(board)
        if not replay():
            break
        else:
            i = 1
            # Choose your side
            players=player_input()
            # Empty board init
            board = ['#'] * 10


Mam nadzieję, że spodobał Ci się ten samouczek i że własna gra w kółko i krzyżyk poprawi Ci humor w coraz chłodniejsze dni!


Oryginał tekstu w języku angielskim przeczytasz tutaj.

Rozpocznij dyskusję

Lubisz dzielić się wiedzą i chcesz zostać autorem?

Podziel się wiedzą z 160 tysiącami naszych czytelników

Dowiedz się więcej