Vamos criar um jogo Tic Tac Toe simples em Python. Ele irá ajudá-lo a construir a lógica do jogo e entender como estruturar o código.
O jogo é um dos entretenimentos que os humanos têm. Podemos encontrar diferentes tipos de jogos na web, mobile, desktop, etc. Não estamos aqui para fazer um daqueles jogos pesados agora. Vamos criar um jogo de jogo da velha CLI usando Python.
Se você não estiver familiarizado com o Tic Tac Toe, jogue-o visualmente aqui para entender. Não se preocupe, mesmo que você não entenda, nós vamos ver.
últimas postagens
Jogo da velha
O tutorial é dividido em três seções diferentes. Na primeira seção, você saberá como jogar o jogo da velha. Depois disso, veremos um algoritmo que nos ajuda a criar a lógica do jogo. Por fim, veremos o código estruturado e sua explicação.
Você pode pular a primeira seção se já souber jogar Tic Tac Toe.
Então, sem mais delongas, vamos mergulhar em nossa primeira seção.
Jogando Tic Tac Toe
Haverá dois jogadores em um jogo. Dois sinais representam cada jogador. Os sinais gerais usados no jogo são X e O. Por fim, haverá um tabuleiro com 9 caixas.
Veja o tabuleiro de jogo da velha visualmente.
Tabuleiro Tic Tac Toe
A jogabilidade será a seguinte.
- Primeiro, um usuário colocará seu sinal em uma das caixas vazias disponíveis.
- Em seguida, o segundo usuário colocará seu sinal em uma das caixas vazias disponíveis.
- O objetivo dos jogadores é colocar seus respectivos sinais completamente em linha ou em coluna, ou na diagonal.
- O jogo continua até que um jogador vença o jogo ou termine empatado preenchendo todas as caixas sem uma partida vencedora.
Vamos ver alguns gameplays visualmente.
Jogabilidade de vitória do Tic Tac Toe
O jogador X ganha o jogo na jogabilidade acima. Todas as caixas são preenchidas diagonalmente com sinais X. Assim, o respectivo jogador ganha o jogo.
Há um total de 8 maneiras de organizar o mesmo sinal e ganhar o jogo. Vamos ver todos os 8 arranjos que podem ganhar o jogo.
Arranjos vencedores do jogo da velha
E, finalmente, um empate preenche o tabuleiro sem nenhum arranjo vencedor. Espero que você entenda como Tic Tac Toe agora.
Agora, é hora de brincar para você. Você pode ir aqui e jogá-lo para entender a jogabilidade completamente. Deixe se já tiver.
Agora, é hora de mover a seção de algoritmo.
Algoritmo
Vamos agora discutir o algoritmo para escrever o código. Este algoritmo irá ajudá-lo a escrever código em qualquer linguagem de programação de sua escolha. Vamos ver como é feito.
- Crie um quadro usando uma matriz bidimensional e inicialize cada elemento como vazio.
- Você pode representar vazio usando qualquer símbolo que desejar. Aqui, vamos usar um hífen. ‘-‘.
- Escreva uma função para verificar se o tabuleiro está preenchido ou não.
- Iterar sobre o quadro e retornar false se o quadro contiver um sinal vazio ou então retornar true.
- Escreva uma função para verificar se um jogador ganhou ou não.
- Temos que verificar todas as possibilidades que discutimos na seção anterior.
- Verifique todas as linhas, colunas e duas diagonais.
- Escreva uma função para mostrar o tabuleiro, pois mostraremos o tabuleiro várias vezes para os usuários enquanto eles estão jogando.
- Escreva uma função para iniciar o jogo.
- Selecione o primeiro turno do jogador aleatoriamente.
- Escreva um loop infinito que interrompa quando o jogo terminar (ou ganhe ou empate).
- Mostre o tabuleiro ao usuário para selecionar o local para o próximo movimento.
- Peça ao usuário para inserir o número da linha e da coluna.
- Atualize o local com o respectivo sinal de jogador.
- Verifique se o jogador atual ganhou o jogo ou não.
- Se o jogador atual ganhou o jogo, imprima uma mensagem vencedora e interrompa o loop infinito.
- Em seguida, verifique se o quadro está preenchido ou não.
- Se o tabuleiro estiver cheio, imprima a mensagem de sorteio e quebre o loop infinito.
- Por fim, mostre ao usuário a visão final do quadro.
Você pode visualizar o que está acontecendo. Não se preocupe, mesmo que você não tenha entendido completamente. Você terá mais clareza depois de ver o código.
Então, vamos pular para a seção de código. Suponho que você tenha o Python instalado no seu PC para experimentar o código.
Código
Passe pelo código abaixo.
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()
Confira a saída de exemplo do código.
$ 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
Alguns pontos importantes que ajudam a entender a estrutura do código.
- Usamos uma classe para ter todos os métodos em um só lugar. Também pode ser facilmente um pacote reutilizável em algum outro código.
- A seguir, definimos funções diferentes para cada responsabilidade, mesmo que seja uma tarefa pequena. Ajuda a manter o código com facilidade.
- As duas abordagens acima nos ajudam a atualizar o aplicativo sem esforço, se quisermos atualizar o jogo.
Sinta-se à vontade para adaptar a estrutura e melhorá-la com base no seu projeto. A estruturação do código não é limitada.
Palavras finais
Viva! 😎 Você criou um jogo completamente do zero. Não é um dos jogos visuais que jogamos diariamente. Mas ajuda você a escrever lógica e manter uma estrutura limpa no código. Siga diretrizes semelhantes para criar alguns jogos interessantes como este. Você pode encontrar jogos semelhantes se voltar alguns anos à sua infância.
Boa Codificação! 👩💻
Em seguida, explore como criar um jogo de adivinhação de números e testes de unidade com o módulo unittest do Python.
Gostou de ler o artigo? Que tal compartilhar com o mundo?