Gra w kółko i krzyżyk w języku Python — „Wspomnienie szkolnego czasu” (2024)

Nie ma wątpliwości, że grałeś w kółko i krzyżyk w czasach szkolnych, a każdy z nas uwielbia grać w tę grę. Będziesz zaskoczony, gdy dowiesz się, że gra w kółko i krzyżyk znana jest od czasów starożytnego Egiptu.

Kółko i krzyżyk,kółko i krzyżyk, LubXs i Osjestgra w papier i ołówekdla dwóch graczy,XIO, którzy na zmianę zaznaczają pola na siatce 3×3. Zwycięzcą zostaje gracz, któremu uda się umieścić trzy swoje znaczniki w rzędzie poziomym, pionowym lub ukośnym

Ze względu na prostotę gry w kółko i krzyżyk jest często używany jakopedagogicznynarzędzie do nauczania pojęć dobrasprawność sportowai filiasztuczna inteligencjaktóra zajmuje się poszukiwaniemdrzewa gry.

zbudujemy interaktywną grę w kółko i krzyżyk, w której po drodze nauczymy się nowych rzeczy.

Ciekawy projekt w Pythonie zostanie zbudowany przy użyciu biblioteki pygame.

Gry hazardowejest zbioremPytonmoduły przeznaczone do pisania gier wideo. Pygame dodaje funkcjonalność do doskonałychSDLbiblioteka. Pozwala to na tworzenie w pełni funkcjonalnych gier i programów multimedialnych w języku Python.

Pygame jest wysoce przenośny i działa na prawie każdej platformie i systemie operacyjnym.

Wyjaśnimy wszystkie metody obiektów pygame, które są używane w tym projekcie. Pygame to świetna biblioteka, która pozwoli nam stworzyć okno i narysować na nim obrazy i kształty. W ten sposób przechwycimy współrzędne myszy i zidentyfikujemy blok, w którym musimy zaznaczyć „X” lub „O”. Następnie sprawdzimy, czy użytkownik wygrał grę, czy nie

Aby zaimplementować tę grę, użyjemy podstawowych koncepcji Pythona i Pygame, która jest biblioteką Pythona do tworzenia gier międzyplatformowych. Zawiera moduły potrzebne do grafiki komputerowej i bibliotek dźwiękowych. Aby zainstalować bibliotekę, możesz użyć instalatora pip z wiersza poleceń:

1. pip zainstaluj pygame

Najpierw sprawdźmy, jak zbudować program Tic Tac Toe w Pythonie:

• Utwórz okno wyświetlania dla naszej gry.
• Na płótnie narysuj siatkę, na której będziemy grać w kółko i krzyżyk.
• Narysuj pasek stanu poniżej płótna, aby pokazać, który gracz jest w kolejce i kto wygrywa grę.
• Gdy ktoś wygrywa grę lub gra kończy się remisem, resetujemy grę.

Musimy uruchomić naszą grę w nieskończonej pętli. Będzie stale szukać zdarzeń, a gdy użytkownik naciśnie przycisk myszy na siatce, najpierw otrzymamy współrzędne X i Y myszy. Następnie sprawdzimy, w który kwadrat kliknął użytkownik. Następnie na płótnie narysujemy odpowiedni obraz „X” lub „O”. To jest w zasadzie to, co zrobimy w tym pomyśle na projekt Pythona.

Zacznijmy więc od zaimportowania biblioteki pygame i biblioteki czasu, ponieważ użyjemy metody time.sleep() do wstrzymania gry w określonych pozycjach. Następnie inicjalizujemy wszystkie zmienne globalne, których będziemy używać w naszej grze w kółko i krzyżyk.

importuj pygame jako pg,sys

z importu pygame.locals *

czas importu

#inicjalizuj zmienne globalne

XO = „x”

zwycięzca = Brak

remis = Fałsz

szerokość = 400

wysokość = 400

biały = (255, 255, 255)

kolor_linii = (10,10,10)

#Kółko i krzyżyk 3x3 plansza

TTT = [[Brak]*3,[Brak]*3,[Brak]*3]

Tutaj TTT jest główną planszą 3×3 Tic Tac Toe i na początku będzie miała 9 wartości None. Wysokość i szerokość płótna, na którym będziemy grać, to 400×400.

Używamy pygame do stworzenia nowego okna, w którym zagramy w naszą grę w kółko i krzyżyk. Więc inicjujemy pygame metodą pg.init() i ustawiamy wyświetlanie okna na szerokość 400 i wysokość 500. Zarezerwowaliśmy 100-pikselowe miejsce na wyświetlanie stanu gry.

Funkcja pg.display.set_mode() inicjalizuje ekran i odwołujemy się do niego za pomocą zmiennej screen. Ta zmienna ekranowa będzie używana zawsze, gdy będziemy chcieli coś narysować na wyświetlaczu.

Metoda pg.display.set_caption służy do ustawiania nazwy, która pojawi się w górnej części okna wyświetlacza.

#inicjalizowanie okna gry

str.w tym()

fps = 30

ZEGAR = pg.czas.Zegar()

ekran = str.wyświetl.Ustaw tryb((szerokość, wysokość+100),0,32)

strona.wyświetl.set_caption("Kółko i krzyżyk")

Projekt uczenia maszynowego w języku Python wykorzystuje wiele obrazów, takich jak obraz początkowy, który będzie wyświetlany po uruchomieniu lub zresetowaniu gry. Obrazy X i O, które narysujemy, gdy użytkownik kliknie siatkę. Ładujemy wszystkie obrazy i zmieniamy ich rozmiar, aby z łatwością zmieściły się w naszym oknie.

Teraz tworzymy funkcję, która uruchomi grę. Z tej funkcji skorzystamy również wtedy, gdy będziemy chcieli ponownie uruchomić grę. W pygame funkcja blit() jest używana na powierzchni do rysowania obrazu na innym obrazie.

Rysujemy więc obraz otwierający i po narysowaniu zawsze musimy zaktualizować ekran za pomocą pg.display.update(). Po narysowaniu obrazu początkowego odczekujemy 1 sekundę używając time.sleep(1) i wypełniamy ekran białym kolorem.

Następnie rysujemy 2 pionowe i poziome linie na białym tle, tworząc siatkę 3×3. Na koniec wywołujemy funkcję draw_status().

zdecydowanie game_opening():
screen.blit(otwarcie,(0,0))
pg.display.update()
czas.snu(1)
ekran.wypełnienie(biały)

# Rysowanie linii pionowych
pg.draw.line(ekran,kolor_linii,(szerokość/3,0),(szerokość/3, wysokość),7)
pg.draw.line(ekran,kolor_linii,(szerokość/3*2,0),(szerokość/3*2, wysokość),7)
# Rysowanie linii poziomych
pg.draw.line(ekran,kolor_linii,(0,wysokość/3),(szerokość, wysokość/3),7)
pg.draw.line(ekran,kolor_linii,(0,wysokość/3*2),(szerokość, wysokość/3*2),7)
los_status()

Funkcja draw_status() rysuje czarny prostokąt, w którym aktualizujemy status teleturnieju, który gracz jest w kolejce i czy gra się kończy, czy remisuje.

pokstan_wylosowania():

światowe losowanie

jeśli zwycięzcą jest Brak:

wiadomość = XO.górny() + „kolej”

w przeciwnym razie:

wiadomość = zwycięzca.górny() + „wygrał!”

jeśli remis:

wiadomość = „Remis!”

czcionka = str.czcionka.Czcionka(Brak, 30)

tekst = czcionka.renderowanie(wiadomość, 1, (255, 255, 255))

# skopiuj wyrenderowaną wiadomość na tablicę

ekran.wypełnić((0, 0, 0), (0, 400, 500, 100))

text_rect = tekst.get_rect(środek=(szerokość/2, 500–50))

ekran.zostawać(tekst, tekst_rekt)

strona.wyświetl.aktualizacja()

Funkcja check_win() sprawdza tablicę Tic Tac Toe, aby zobaczyć wszystkie znaki „X” i „O”. Oblicza, czy gracz wygrał grę, czy nie. Mogą wygrać, gdy gracz zaznaczy 3 kolejne znaki w rzędzie, kolumnie lub po przekątnej. Funkcja ta jest wywoływana za każdym razem, gdy rysujemy na planszy znak „X” lub „O”.

pokcheck_win():

globalny TTT, zwycięzca, remis

# sprawdź zwycięskie wiersze

do rzęduzakres(0,3):

Jeśli((TTT [wiersz][0] == TTT[wiersz][1] == TTT[wiersz][2])I(TTT [wiersz][0] nie oznacza Brak)):

# ten rząd wygrał

zwycięzca = TTT[wiersz][0]

str.rysuj.linia(ekran, (250,0,0), (0, (wiersz + 1)*wysokość/3 -wysokość/6),\

(szerokość, (wiersz + 1)*wysokość/3 — wysokość/6 ), 4)

przerwa

# sprawdź zwycięskie kolumny

za kolzakres(0, 3):

Jeśli(TTT[0][kolumna] == TTT[1][kolumna] == TTT[2][kolumna])I(TTT[0][col] nie oznacza Brak):

# ta kolumna wygrała

zwycięzca = TTT[0][col]

#narysuj zwycięską linię

str.rysuj.linia(ekran, (250,0,0),((kolumna + 1)* szerokość/3 — szerokość/6, 0),\

((kolumna + 1)* szerokość/3 — szerokość/6, wysokość), 4)

przerwa

# sprawdź zwycięzców ukośnych

Jeśli(CTT[0][0] == TTT[1][1] == TTT[2][2])I(TTT[0][0] nie oznacza Brak):

# gra wygrana po przekątnej od lewej do prawej

zwycięzca = TTT[0][0]

str.rysuj.linia(ekran, (250,70,70), (50, 50), (350, 350), 4)

Jeśli(CTT[0][2] == TTT[1][1] == TTT[2][0])I(TTT[0][2] nie oznacza Brak):

# gra wygrana po przekątnej od prawej do lewej

zwycięzca = TTT[0][2]

str.rysuj.linia(ekran, (250,70,70), (350, 50), (50, 350), 4)

Jeśli(Wszystko([Wszystko(wiersz) za wiersz w TTT]), a zwycięzcą jest Brak ):

remis = Prawda

stan_wylosowania()

Funkcja drawXO(row, col) pobiera wiersz i kolumnę, w których kliknięto myszą, a następnie rysuje znak „X” lub „O”. Obliczamy współrzędne x i y punktu początkowego, z którego narysujemy obraz png znaku.

pokrysujXO(wiersz, kolumna):

globalny TTT, XO

jeśli wiersz==1:

posx = 30

jeśli wiersz==2:

posx = szerokość/3 + 30

jeśli wiersz==3:

posx = szerokość/3*2 + 30

jeśli kol==1:

riksza = 30

jeśli kol==2:

bukiet = wzrost/3 + 30

jeśli kol==3:

bukiet = wzrost/3*2 + 30

TTT[wiersz-1][kolumna-1] = XO

Jeśli(XO == „x”):

ekran.zostawać(x_img,(posy,posx))

XO = „o”

w przeciwnym razie:

ekran.zostawać(o_img,(posy,posx))

XO= ‘x’

strona.wyświetl.aktualizacja()

#print(posx,posy)

#drukuj(TTT)

Funkcja userClick() jest wyzwalana za każdym razem, gdy użytkownik naciśnie przycisk myszy.

Kiedy użytkownik klika myszką, najpierw bierzemy współrzędne x i y miejsca kliknięcia myszą w oknie wyświetlacza, a następnie, jeśli to miejsce nie jest zajęte, rysujemy „XO” na płótnie. Sprawdzamy również, czy gracz wygrywa, czy nie po wylosowaniu „XO” na planszy.

pokkliknięcie użytkownika():

#uzyskaj współrzędne kliknięcia myszą

x,y = pg.mysz.get_pos()

#get kolumna kliknięcia myszą (1-3)

Jeśli(x

kol = 1

Elif(x

kol = 2

Elif(x

kol = 3

w przeciwnym razie:

kol = Brak

#uzyskaj rząd kliknięć myszą (1–3)

Jeśli(y

rząd = 1

Elif(y

rząd = 2

Elif(y

rząd = 3

w przeciwnym razie:

wiersz = Brak

#print(wiersz,kolumna)

Jeśli(wiersz i kolumna, a TTT[wiersz-1][kolumna-1] to Brak):

globalny XO

#narysuj x lub o na ekranie

rysujXO(wiersz, kolumna)

check_win()

Ostatnią funkcją jest reset_game(). Spowoduje to ponowne uruchomienie gry i zresetowanie wszystkich zmiennych do początku gry.

pokZresetuj grę():

globalny TTT, zwycięzca, XO, remis

czas.spać(3)

XO = „x”

remis = Fałsz

gra_otwarcie()

zwycięzca = brak

TTT = [[Brak]*3,[Brak]*3,[Brak]*3]

Aby uruchomić grę, wywołamy funkcję game_opening(). Następnie uruchamiamy nieskończoną pętlę i stale sprawdzamy, czy nie wystąpiło zdarzenie wykonane przez użytkownika. Jeśli użytkownik naciśnie przycisk myszy, zdarzenie MOUSEBUTTONDOWN zostanie przechwycone, a następnie uruchomimy funkcję userClick(). Następnie, jeśli użytkownik wygra lub gra zremisuje, resetujemy grę, wywołując funkcję reset_game(). Aktualizujemy wyświetlanie w każdej iteracji i ustawiliśmy liczbę klatek na sekundę na 30.

gra_otwarcie()

# uruchom pętlę gry na zawsze

chwila(PRAWDA):

dla zdarzenia w pg.event.Dostawać():

jeśli typ zdarzenia == WYJDŹ:

str.zrezygnować ()

sys.Wyjście()

elif event.type to MOUSEBUTTONDOWN:

# użytkownik kliknął; wstaw X lub O

kliknięcie użytkownika()

Jeśli(zwycięzca lub remis):

Zresetuj grę()

strona.wyświetl.aktualizacja()

ZEGAR.kleszcz(fps)

Gra jest kompletna i gotowa do gry.