Maak een Tic Tac Toe-spel in Python:stapsgewijze code-tutorial

Tic Tac Toe Game in Python is een interessant project dat je kunt proberen. Het is een cool en leuk project om een ​​uitdaging op te lossen en kan je helpen de basisconcepten in Python onder de knie te krijgen. Door een leuk boter-kaas-en-eieren-spel te maken, kun je je vaardigheden vergroten.

U kunt een goede Python-editor zoals Pycharm of de opdrachtregelinterface gebruiken.

Hoe speel je Tic Toc Game?

Het boter-kaas-en-eieren-spel is een eenvoudig spel voor twee spelers dat iedereen kan spelen zonder dat er een spelbord nodig is. Hierbij markeren twee spelers verschillende cellen totdat het spel eindigt, waarbij een overwinning of een gelijkspel wordt behaald.

Zo speel je het boter-kaas-en-eieren-spel.

Stap 1) Het boter-kaas-en-eieren-spel begint met lege cellen in een vierkant raster. Dit is het boter-kaas-en-eierenbord.

Stap 2) Beide spelers kiezen uit twee symbolen, meestal Xs of Os. Je kunt elk ander uniek symbool in het spel gebruiken.

Stap 3) De huidige speler markeert om de beurt door de cellen van het boter-kaas-en-eierenbord in te vullen totdat een speler een winnende combinatie heeft ingevuld. Dat is een hele rij, kolom of diagonaal met hetzelfde teken.

Stap 4) Een gelijkspel is ook mogelijk als alle cellen vol zijn en er geen duidelijke winnaar is

Vereisten

Het bouwen van het boter-kaas-en-eieren Python-project vereist een begrip op beginnersniveau van de programmeertaal Python. Het omvat het begrijpen van “for”-lussen en iteraties en welke if-instructie wordt gebruikt in Python.

Je moet ook Python en een Python-teksteditor op je computer hebben geïnstalleerd om het boter-kaas-en-eieren Python-project te voltooien. Omdat dit een boter-kaas-en-eieren-spel op beginnersniveau is in Python, heb je geen Python-bibliotheek nodig.

Mogelijk heb je wat debugging-vaardigheden nodig om oplossingen voor bugs in je code te vinden en moet je ook een goed begrip hebben van de spelcomponenten.

Tic Tac Toe Python-algoritme

Volg deze stappen om een boter-kaas-en-eierenspel te maken in de programmeertaal Python:

Stap 1) Creëer het bord om het boter-kaas-en-eieren-spel te beginnen.

Stap 2) Vraag de gebruiker om de afmetingen van het speelbord te bepalen.

Stap 3) Kies willekeurig de startspeler.

Stap 4) Het boter-kaas-en-eieren-spel begint.

Stap 5) Spelers spelen door een lege plek op het bord te selecteren.

Stap 6) Vul de lege geselecteerde plek met het spelersteken.

Stap 7) Bepaal of een speler wint of een gelijkspel krijgt in het spel met behulp van de spellogica.

Stap 8) Laat het speelbord na elk spel zien als geen enkele speler wint of een gelijkspel krijgt met de tweede speler.

Stap 9) Geef respectievelijk een gelijkspel- of winstbericht weer.

Stap 10) Beëindig het boter-kaas-en-eieren-spel met opties om een nieuw spel te starten.

Volledige Python-code voor boter-kaas-en-eieren

# Guru99
# Code developed by Guru99.com
# Guru99 tic-tac-toe game
#Get input
def getInput(prompt, cast=None, condition=None, errorMessage=None):
 while True:
 try:
 val = cast(input(prompt))
 assert condition is None or condition(val)
 return val
 except:
 print(errorMessage or "Invalid input.")
# Print the game board
def printBoard(board):
 print()
 for row in board:
 print(*row)
 print()
# Check if player won using the winning combinations
def checkWin(board):
 # Check rows
 for row in range(len(board)):
 for col in range(len(board)-1):
 if board[row][col] == "_" or board[row][col+1] == "_" or board[row][col] != board[row][col+1]:
 break
 else:
 return True
 # Check column numbers
 for col in range(len(board)):
 for row in range(len(board)-1):
 if board[row][col] == "_" or board[row+1][col] == "_" or board[row][col] != board[row+1][col]:
 break
 else:
 return True
 # Check left diagonal
 for cell in range(len(board)-1):
 if board[cell][cell] == "_" or board[cell+1][cell+1] == "_" or board[cell][cell] != board[cell+1][cell+1]:
 break
 else:
 return True
 # Check right diagonal
 for cell in range(len(board)-1):
 emptyCell = board[cell][len(board)-cell-1] == "_" or board[cell+1][len(board)-cell-2] == "_"
 different = board[cell][len(board)-cell-1] != board[cell+1][len(board)-cell-2]
 if emptyCell or different:
 break
 else:
 return True
 # No win
 return False
# Play tic tac toe game
def play():
 # Introduction
 print("------------\nN-DIMENSIONAL TIC TAC TOE game by guru 99.com \n------------")
 # Set up variables
 N = getInput(prompt="Guru99 says>>> Enter N, the dimensions of the board: ",
 cast=int,
 condition=lambda x: x >= 3,
 errorMessage="Invalid input. Please enter an integer greater than or equal to 3 as explained on guru99.com")
 board = [['_'] * N for _ in range(N)]
 used = 0
 turn = 0
 # Play guru99 tic tac toe game in Python using while infinite loop
 while True:
 # Print guru99 tic tac toe game board
 printBoard(board)
 # Get user pick
 pick = getInput(prompt=f"Player {turn+1} - Pick location (row, col): ",
 cast=lambda line: tuple(map(int, line.split(" "))),
 condition=lambda pair: min(pair) >= 0 and max(pair) < N and board[pair[0]][pair[1]] == "_",
 errorMessage="Invalid input. Please enter a valid, unoccupied location as an integer pair.")
 # Populate location
 board[pick[0]][pick[1]] = "X" if turn == 0 else "O"
 used += 1
 # Check for win
 #Guru99 tutorial
 if checkWin(board):
 printBoard(board)
 print(f"Game over, Player {turn+1} wins.")
 break
 # Check for tie
 elif used == N*N:
 printBoard(board)
 print("Game over. Players have tied the match.")
 print("Guru99.com tic tac toe game ")
 break
 # If no win yet, update next user
 turn = (turn+1)%2
 # Check for rematch
 playAgain = getInput(prompt="Play Guru99 tic tac toe_Game again? (y/n): ",
 cast=str,
 condition=lambda ans: ans.strip("\n").lower() in {"y", "n"},
 errorMessage="Invalid input. Please enter 'y' or 'n'.")
 if playAgain == 'n':
 # End the game
 print("\nGuru99 TicTacToe game ended.")
 return
 else:
 # Rematch
 play()
# Main
if __name__ == '__main__':
 play()

Zodra u de bovenstaande broncode hebt uitgevoerd, vindt u hieronder de verwachte uitvoer voor een 3 x 3 boter-kaas-en-eierenbord:

------------
N-DIMENSIONAL TIC TAC TOE game by guru 99.com
------------
Guru99 says>>> Enter N, the dimensions of the board: 3
_ _ _
_ _ _
_ _ _
Player 1 - Pick location (row, col): 1 1
_ _ _
_ X _
_ _ _
Player 2 - Pick location (row, col): 0 1
_ O _
_ X _
_ _ _
Player 1 - Pick location (row, col): 1 2
_ O _
_ X X
_ _ _
Player 2 - Pick location (row, col): 0 2
_ O O
_ X X
_ _ _
Player 1 - Pick location (row, col): 1 0
_ O O
X X X
_ _ _
Game over, Player 1 wins.
Play Guru99 tic tac toe_Game again? (y/n):

Volledige code-uitsplitsing

Creëren Boter-kaas-en-eieren in Python is eenvoudig. Laten we de verschillende functies in stukjes ontleden om te begrijpen wat er op elke regel gebeurt:

Het bord afdrukken

Het Tic Tac Toe-bord is het belangrijkste speldisplay. In het Python-weergavevenster wordt het spelbord weergegeven.

Hier zijn de stappen die je helpen een bord voor boter-kaas-en-eieren in Python te maken:

Pythoncode voor Tic Tac Toe

def getInput(prompt, cast=None, condition=None, errorMessage=None):
 while True:
 try:
 val = cast(input(prompt))
 assert condition is None or condition(val)
 return val
 except:
 print(errorMessage or "Invalid input.")
# Print the board
def printBoard(board):
 print()
 for row in board:
 print(*row)
 print()
N = getInput(prompt="Guru99 says>>> Enter N, the dimensions of the board: ",
 cast=int,
 condition=lambda x: x >= 3,
 errorMessage="Invalid input. Please enter an integer greater than or equal to 3 as explained on guru99.com")
board = [['_'] * N for _ in range(N)]
used = 0
turn = 0
printBoard(board)

Code-uitvoer:

------------
N-DIMENSIONAL TIC TAC TOE game by guru 99.com
------------
Guru99 says>>> Enter N, the dimensions of the board: 3
_ _ _
_ _ _
_ _ _

Tic Tac Toe-spel – winnend arrangement

Om te controleren of een speler heeft gewonnen, moeten we de winnende combinaties over de rijen, kolommen en diagonalen controleren. Als er een winnaar is, moeten we een winnende boodschap tonen.

Rijen

• Voor de rij neemt de functie elk opeenvolgend paar kolommen en controleert op een winnende combinatie.
• De eerste speler die de rijen vult, wint. De tweede speler verliest dus.
• Als een paar opeenvolgende kolommen hetzelfde zijn, is het duidelijk dat alle elementen binnen die rij hetzelfde zijn.
• Als er twee verschillend zijn of als de rij een lege cel bevat, is er nog steeds geen winnaar.
• Vervolgens implementeren we verliezende voorwaarden en voegen we een pauze toe. Als een van deze verliezende voorwaarden waar is, hebben we geen winnaar in de aangevinkte rij.
• De else-instructie geeft een juist resultaat om aan te geven dat er een winnaar is.
• De pauze breekt uit deze lus en gaat door naar de volgende rij.

Kolommen

Voor de kolommen herhalen we dezelfde functie als voor rijen. We controleren of een speler heeft gewonnen nadat elke speler zijn plaats heeft gekozen.

Diagonale rijoverwinningen

Voor de linkerdiagonaal wordt de taak eenvoudiger. We gaan altijd de cellen in de diagonalen vergelijken. Als er echter geen winnaar is, kunnen we doorgaan naar de volgende instructie.

Speel spellogica

Dit is de hoofdfunctie van het spel. Hiervoor kunnen we variabelen gebruiken die informatie opslaan.

• De eerste variabele is de bordgrootte opgeslagen in “N”. Het spel krijgt de bordgrootte nadat de gebruiker is gevraagd een getal in te voeren.
• Dus wanneer u de waarde invoert, wordt deze verwerkt.
• We creëren ook een foutmelding om de spelers te laten zien wanneer een ongeldig nummer wordt getypt.
• We kunnen dan twee variabelen maken die een “X” of een “O” invullen wanneer een cel gevuld is.
• Laat de spelers vervolgens het spelbord zien. Vraag hierna de input van de speler.
• De logica markeert vervolgens de geselecteerde cel als gevuld en controleert op winst of gelijkspel.
• Als er geen winnaar is, vraagt het spel de volgende speler om te spelen. Als er sprake is van een overwinning of een gelijkspel, kan het spel de gebruikers vragen of ze een nieuw spel willen.

Conclusie

• Tic Tac Toe is een leuk spel voor twee spelers door een uniek symbool in een lege bordcel te plaatsen.
• Het maken van een boter-kaas-en-eierenspel in Python vereist kennis op beginnersniveau van Python, een teksteditor en het installeren van Python.
• Het algoritme helpt je de code systematisch in elke taal te schrijven.
• Om het spel te maken, tekent u eerst het bord en schrijft u code om de win- en verliesregelingen te bepalen
• Je kunt de boter-kaas-en-eieren-code in Python testen door deze eerst af te spelen.