Vamos criar um jogo simples Tic Tac Toe em Python. Isso o ajudará a construir a lógica do jogo e a entender como estruturar o código.
O jogo é um dos entretenimentos que os humanos têm. Podemos encontrar diversos tipos de jogos na web, mobile, desktop, etc. Não estamos aqui para fazer um desses jogos pesados agora. Vamos criar um jogo da velha CLI usando Phyton .
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.
Jogo da velha
O tutorial é dividido em três seções diferentes. Na primeira seção, você aprenderá 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 quadro com 9 caixas.
Veja o tabuleiro do jogo da velha visualmente.
Tic Tac Toe BoardA jogabilidade será a seguinte.
- Primeiro, um usuário colocará seu login em uma das caixas vazias disponíveis.
- Em seguida, o segundo usuário colocará seu login em uma das caixas vazias disponíveis.
- O objetivo dos jogadores é colocar seus respectivos sinais completamente em linha ou coluna, ou na diagonal.
- O jogo continua até que um jogador vença o jogo ou termine empatado ao preencher todas as caixas sem vencer.
Vamos ver alguns gameplays visualmente.
Jogabilidade da vitória do Tic Tac ToeO jogador x ganha o jogo na jogabilidade acima. Todas as caixas são preenchidas diagonalmente com x sinais. 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 velhaE, 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-o se você já o 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 da sua escolha. Vamos ver como isso é feito.
- Crie uma placa usando uma matriz bidimensional e inicialize cada elemento como vazio.
- Você pode representar o vazio usando qualquer símbolo que desejar. Aqui, vamos usar um hífen.
'-'.
- Você pode representar o vazio usando qualquer símbolo que desejar. Aqui, vamos usar um hífen.
- Escreva uma função para verificar se o tabuleiro está cheio ou não.
- Iterar sobre o quadro e retornar
falsese o tabuleiro contiver um sinal vazio ou então retornetrue.
- Iterar sobre o quadro e retornar
- 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 jogam.
- Escreva uma função para iniciar o jogo.
- Selecione o primeiro turno do jogador aleatoriamente.
- Escreva um loop infinito que seja interrompido quando o jogo terminar (ganhando ou empatando).
- 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 do 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 tabuleiro está preenchido ou não.
- Se o tabuleiro estiver cheio, imprima a mensagem de sorteio e interrompa o loop infinito.
- Por fim, mostre ao usuário a visualização final do quadro.
Você pode ser capaz de visualizar o que está acontecendo. Não se preocupe, mesmo que você não tenha entendido completamente. Você obterá mais clareza ao ver o código.
Então, vamos pular para a seção de código. Eu suponho que você tenha Python instalado no seu PC para experimentar o código.
Código
Percorra o 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 o exemplo de saída 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 OAlguns pontos importantes que ajudam você a entender a estrutura do código.
- Usamos uma classe para ter todos os métodos em um só lugar. Pode ser facilmente um pacote reutilizável em algum outro código também.
- A seguir, definimos diferentes funções para cada responsabilidade, mesmo que seja uma tarefa pequena. Isso 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 totalmente 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.
Codificação feliz!
Em seguida, explore como criar jogo de adivinhação de números e Teste de unidade com o módulo unittest do Python .
