Tic Tac Toe Python játékprojekt  – „Az iskolai idő emléke”

Tic Tac Toe Python játékprojekt – „Az iskolai idő emléke”

A mögöttes történet

Nem kétséges, iskolás korában biztosan játszott a Tic Tac Toe-val, és mindannyian szeretünk játszani. Meg fog lepődni, ha megtudja, hogy a Tic Tac Toe játék már az ókori Egyiptom óta létezik.

A Tic-tac-toe, a noughts and crosses vagy az Xs and Os egy „papír-ceruza játék” két játékos számára, X és O, akik felváltva jelölik a tereket egy 3×3-as rácson. Az a játékos nyer, akinek sikerül három jegyét vízszintes, függőleges vagy átlós sorban elhelyezni.

A tic-tac-toe egyszerűsége miatt gyakran használják "pedagógiai" eszközként a jó "sportszerűség" fogalmának és a "mesterséges intelligencia" ágának a tanítására, amely a "vadfák" keresésével foglalkozik.

egy interaktív Tic Tac Toe játékot fogunk építeni, ahol új dolgokat tanulunk meg az út során.

Tic Tac Toe – A Python projektről

Az érdekes Python projekt a pygame könyvtár felhasználásával készül.

A Pygame egy "Python" modulkészlet, amelyet videojátékok írásához terveztek. A Pygame funkcionalitással egészíti ki a kiváló SDL könyvtárat. Ez lehetővé teszi teljes értékű játékok és multimédiás programok létrehozását python nyelven.

A Pygame rendkívül hordozható, és szinte minden platformon és operációs rendszeren fut.

Elmagyarázzuk a projektben használt összes pygame objektum metódust. A Pygame egy nagyszerű könyvtár, amely lehetővé teszi számunkra, hogy létrehozzuk az ablakot, és képeket és alakzatokat rajzoljunk az ablakra. Így rögzítjük az egér koordinátáit, és azonosítjuk azt a blokkot, ahol „X” vagy „O” jelzést kell jelölnünk. Ezután ellenőrizzük, hogy a felhasználó megnyeri-e a játékot vagy sem

Előfeltételek

A játék megvalósításához a Python és a Pygame alapkoncepcióit fogjuk használni, amelyek egy Python könyvtár többplatformos játékok építéséhez. Tartalmazza a számítógépes grafikához és a hangkönyvtárakhoz szükséges modulokat. A könyvtár telepítéséhez használhatja a pip telepítőt a parancssorból:

1. pip install pygame

Python-projekt felépítésének lépései – Tic Tac Toe játék

Először nézzük meg a Tic Tac Toe program Pythonban történő felépítésének lépéseit:

• Hozd létre a játékunk képernyőjét.
• Rajzolja meg a rácsot a vászonra, ahol a Tic Tac Toe-t fogjuk játszani.
• Rajzolja meg az állapotsort a vászon alá, hogy megmutassa, melyik játékoson van a sor, és ki nyeri a játékot.
• Ha valaki megnyeri a játékot, vagy a játék döntetlenre áll, akkor visszaállítjuk a játékot.

A játékunkat egy végtelen hurkon belül kell futtatnunk. Folyamatosan keresi az eseményeket, és amikor a felhasználó megnyomja az egérgombot a rácson, először megkapjuk az egér X és Y koordinátáit. Ezután ellenőrizzük, hogy a felhasználó melyik mezőre kattintott. Ezután a megfelelő „X” vagy „O” képet rajzoljuk a vászonra. Tehát alapvetően ezt fogjuk tenni ebben a Python projektötletben.

1. A játék összetevőinek inicializálása

Tehát kezdjük a pygame könyvtár és az időkönyvtár importálásával, mert a time.sleep() metódus segítségével szüneteltetjük a játékot bizonyos pozíciókban. Ezután inicializáljuk az összes globális változót, amelyet a Tic Tac Toe játékunkban fogunk használni.

pygame importálása pg,sys néven

a pygame.locals importból *

behozatali idő

#globális változók inicializálása

XO = ‘x’

győztes = Nincs

döntetlen = hamis

szélesség = 400

magasság = 400

fehér = (255, 255, 255)

vonal_szín = (10,10,10)

#TicTacToe 3x3 tábla

TTT = [[Nincs]*3, [Nincs]*3, [Nincs]*3]

Itt a TTT a fő 3 × 3-as Tic Tac Toe tábla, és kezdetben 9 None értéke lesz. A vászon magassága és szélessége, ahol a játékot fogjuk játszani, 400×400.

A Pygame ablak inicializálása

A pygame segítségével új ablakot hozunk létre, ahol a Tic Tac Toe játékkal fogunk játszani. Tehát inicializáljuk a pygame-et a pg.init() metódussal, és az ablak megjelenítését 400-as szélességre és 500-as magasságra állítjuk be. 100 pixeles helyet foglaltunk le a játék állapotának megjelenítésére.

A pg.display.set_mode() inicializálja a megjelenítést, és hivatkozunk rá a képernyőváltozóval. Ezt a képernyőváltozót akkor használjuk, amikor valamit a kijelzőre akarunk rajzolni.

A pg.display.set_caption a metódus a kijelzőablak tetején megjelenő név beállítására szolgál.

#pygame ablak inicializálása

pg.init()

fps = 30

ÓRA = pg.time.Óra()

képernyő = pg.display.set_mode((szélesség, magasság+100),0,32)

pg.display.set_caption („Tic Tac Toe”)

3. Képek betöltése és átalakítása

A Python gépi tanulási projekt számos képet használ, például a nyitóképet, amely megjelenik a játék indításakor vagy visszaállításakor. Az X és O képek, amelyeket akkor rajzolunk, amikor a felhasználó rákattint. Az összes képet betöltjük és átméretezzük, hogy könnyen elférjenek az ablakunkban.

4. Határozza meg a funkciókat

Most létrehozunk egy funkciót, amely elindítja a játékot. Ezt a funkciót akkor is használjuk, ha újra akarjuk indítani a játékot. A pygame-ben a blit() függvényt a felületen arra használják, hogy egy képet egy másik kép tetejére rajzoljanak.

Tehát megrajzoljuk a nyitóképet, és a rajzolás után mindig frissítenünk kell a megjelenítést a pg.display.update() segítségével. A nyitókép megrajzolásakor a time.sleep(1) használatával várunk 1 másodpercet, és fehér színnel töltjük ki a képernyőt.

Ezután 2 függőleges és vízszintes vonalat rajzolunk a fehér háttérre, hogy elkészítsük a 3×3-as rácsot. A végén meghívjuk a draw_status() függvényt

def game_opening():
screen.blit(megnyitás,(0,0))
pg.display.update()
time.sleep(1)
screen.fill( fehér)

# Függőleges vonalak rajzolása
pg.draw.line(screen,line_color,(width/3,0),(width/3, height),7)
pg.draw.line(screen,line_color,(width/3*2,0),(width/3*2, height),7)
# Vízszintes vonalak rajzolása
pg.draw.line( képernyő,vonal_színe,(0,magasság/3),(szélesség, magasság/3),7)
pg.draw.line(képernyő,vonal_színe,(0,magasság/3*2),(szélesség, magasság /3*2),7)
draw_status()

A draw_status() függvény egy fekete téglalapot rajzol, ahol frissítjük a játék állapotát, és megmutatjuk, melyik játékoson van a sor, és hogy a játék véget ér-e vagy döntetlen.

def draw_status():

globális sorsolás

ha nincs nyertes:

üzenet = XO.felső() + "'s Turn"

más:

üzenet = győztes.felső() + „nyert!”

ha döntetlen:

üzenet = 'Játéksorsolás!'

font = pg.font.Betűtípus(Nincs, 30)

szöveg = betűtípus.megjelenítés(üzenet, 1, (255, 255, 255))

# másold ki a megjelenített üzenetet a táblára

képernyőn.kitöltés ((0, 0, 0), (0, 400, 500, 100))

text_rect = szöveg.get_rect(center=(width/2, 500–50))

képernyő.blit (text, text_rect)

pg.display.frissítés()

A check_win() függvény ellenőrzi a Tic Tac Toe táblát, hogy lássa az összes ’X’ és ’O’ jelet. Kiszámítja, hogy egy játékos megnyerte-e a játékot vagy sem. Akkor nyerhetnek, ha a játékos 3 egymást követő pontot jelölt meg egy sorban, oszlopban vagy átlósan. Ezt a függvényt minden alkalommal meghívjuk, amikor „X” vagy „O” jelet rajzolunk a táblára.

def check_win():

globális TTT, győztes, sorsolás

# ellenőrizze a nyertes sorokat

a tartomány (0,3) sorához:

ha ((TTT [sor][0] == TTT[sor][1] == TTT[sor][2]) és(TTT [sor][ 0] nem egy sem)):

# ez a sor nyert

győztes = TTT[sor][0]

pg.draw.vonal(képernyő, (250,0,0), (0, (sor + 1)*magasság/3 -magasság/6),\

(szélesség, (sor + 1)*magasság/3 — magasság/6 ), 4)

szünet

# ellenőrizze a nyertes oszlopokat

a tartomány oszlopához (0, 3):

ha (TTT[0][col] == TTT[1][col] == TTT[2][col]) és (TTT[0][col] ] nem egy):

# ez az oszlop nyert

győztes = TTT[0][col]

#húzzon nyerővonalat

pg.draw.vonal (képernyő, (250,0,0),((col + 1)* szélesség/3 — szélesség/6, 0),\

((oszlop + 1)* szélesség/3 – szélesség/6, magasság), 4)

szünet

# ellenőrizze az átlós nyerteseket

ha (TTT[0][0] == TTT[1][1] == TTT[2][2]) és (TTT[0][0] ] nem egy):

# játék nyert átlósan balról jobbra

győztes = TTT[0][0]

pg.draw.vonal (képernyő, (250,70,70), (50, 50), (350, 350), 4)

ha (TTT[0][2] == TTT[1][1] == TTT[2][0]) és (TTT[0][2 ] nem egy):

# játék nyert átlósan jobbról balra

győztes = TTT[0][2]

pg.draw.vonal (képernyő, (250,70,70), (350, 50), (50, 350), 4)

ha(mind([összes(sor) a sorhoz a TTT-ben]), és a nyertes a Nincs ):

döntetlen = igaz

rajz_állapota()

A drawXO(row, col) függvény azt a sort és oszlopot veszi, amelyre az egér kattintott, majd megrajzolja az „X” vagy „O” jelet. Kiszámoljuk annak a kezdőpontnak az x és y koordinátáit, ahonnan a jel png képét megrajzoljuk.

def drawXO (sor, oszlop):

globális TTT,XO

ha sor==1:

posx = 30

ha sor==2:

posx = szélesség/3 + 30

ha sor==3:

posx = szélesség/3*2 + 30

ha col==1:

posy = 30

ha col==2:

póz = magasság/3 + 30

ha oszlop==3:

póz = magasság/3*2 + 30

TTT[sor-1][oszlop-1] = XO

if(XO == ‘x’):

képernyő.blit(x_img,(posy,posx))

XO= ‘o’

más:

képernyő.blit(o_img,(posy,posx))

XO= ‘x’

pg.display.frissítés()

#print(posx,posy)

#print(TTT)

A userClick() függvény minden alkalommal aktiválódik, amikor a felhasználó megnyomja az egérgombot.

Amikor a felhasználó rákattint az egérrel, először felvesszük annak x és y koordinátáit, ahol az egér kattintott a kijelzőablakon, majd ha az a hely nincs foglalt, megrajzoljuk az „XO”-t a vászonra. Azt is ellenőrizzük, hogy a játékos nyer-e vagy sem, miután felhúzta az „XO”-t a táblára.

def userClick():

#szerezze le az egérkattintás koordinátáit

x,y = pg.egér.get_pos()

#get oszlop egérkattintással (1–3)

ha (x‹szélesség/3):

oszlop = 1

elif (x‹szélesség/3*2):

oszlop = 2

elif (x‹szélesség):

oszlop = 3

más:

col = Nincs

#egérkattintás sora (1–3)

ha(y‹height/3):

sor = 1

elif (y‹height/3*2):

sor = 2

elif (y magasság):

sor = 3

más:

sor = Nincs

#print(sor,col)

ha(sor és oszlop, és a TTT[sor-1][oszlop-1] értéke nincs):

globális XO

#rajzolja az x vagy az o jelet a képernyőre

rajzXO (sor, oszlop)

check_win ()

Az utolsó függvény a reset_game(). Ezzel újraindul a játék, és az összes változót visszaállítjuk a játék elejére.

def reset_game():

globális TTT, győztes, XO, sorsolás

idő.alvás (3)

XO = ‘x’

döntetlen = hamis

game_opening ()

győztes=Nincs

TTT = [[Nincs]*3, [Nincs]*3, [Nincs]*3]

5. Futtassa a játékot örökké

A játék elindításához meghívjuk a game_opening() függvényt. Ezután egy végtelen hurkot futtatunk, és folyamatosan ellenőrizzük a felhasználó által végrehajtott eseményeket. Ha a felhasználó megnyomja az egérgombot, a MOUSEBUTTONDOWN esemény rögzítésre kerül, majd elindítjuk a userClick() függvényt. Majd ha a felhasználó nyer, vagy a játék döntetlen, akkor a reset_game() függvény meghívásával visszaállítjuk a játékot. Minden iterációban frissítjük a kijelzőt, és a másodpercenkénti képkockákat 30-ra állítottuk.

game_opening ()

# futtassa a játékhurkot örökre

míg (igaz):

eseményhez a pg.eventben.get():

if event.type == KILÉPÉS:

p.kilépés()

sys.kilépés()

elif event.type a MOUSEBUTTONDOWN:

# a felhasználó rákattintott; tegyen egy X-et vagy O-t

userClick()

ha (nyertes vagy sorsolás):

reset_game()

pg.display.frissítés()

ÓRA.pipáld ki (fps)

A játék kész és játékra kész.