Desenvolvimento de um Jogo da Velha Simples em Python
Vamos embarcar na criação de um jogo da velha elementar utilizando Python. Este projeto será um guia valioso para você desenvolver a lógica do jogo e entender a organização do código de forma eficaz.
Os jogos são uma das formas de entretenimento mais apreciadas pela humanidade. Encontramos inúmeros tipos de jogos em diversas plataformas, como web, mobile e desktop. No entanto, o nosso foco aqui não será criar um jogo complexo. Vamos nos concentrar em desenvolver um jogo da velha para a linha de comando (CLI) usando Python.
Se você não está familiarizado com o jogo da velha, pode visualizá-lo aqui para uma melhor compreensão. Não se preocupe se ainda não estiver claro, vamos abordar todos os detalhes.
Estrutura do Tutorial
Este tutorial será dividido em três etapas principais. Inicialmente, você aprenderá as regras do jogo da velha. Em seguida, analisaremos um algoritmo que servirá de base para a lógica do jogo. E, por fim, apresentaremos o código estruturado com explicações detalhadas.
Se você já conhece as regras do jogo da velha, pode pular a primeira seção diretamente.
Sem mais delongas, vamos dar início à nossa primeira seção.
Como Jogar o Jogo da Velha
Em um jogo da velha, dois jogadores se enfrentam. Cada jogador é representado por um símbolo, sendo os mais comuns ‘X’ e ‘O’. O jogo se desenrola em um tabuleiro composto por 9 casas.
A imagem abaixo ilustra o tabuleiro do jogo da velha.
Tabuleiro do Jogo da Velha
O funcionamento do jogo segue este padrão:
- O primeiro jogador marca uma casa vazia com seu símbolo.
- Em seguida, o segundo jogador faz o mesmo, escolhendo outra casa vazia.
- O objetivo é alinhar três símbolos iguais, seja em linha, coluna ou diagonal.
- A partida continua até que um jogador alcance a vitória ou todas as casas sejam preenchidas sem um vencedor, resultando em empate.
Vejamos algumas situações de jogo.
Cenário de Vitória no Jogo da Velha
Neste exemplo, o jogador ‘X’ vence, já que todas as casas da diagonal estão preenchidas com seu símbolo. Assim, esse jogador é declarado vencedor.
Existem 8 combinações possíveis para alinhar três símbolos e vencer a partida. Vejamos todas elas.
Além disso, quando o tabuleiro é completamente preenchido sem nenhuma combinação vencedora, o jogo termina empatado. Espero que você tenha compreendido o jogo da velha agora.
Agora, é a sua vez de jogar. Você pode acessar este link para praticar e consolidar seu entendimento das regras. Deixe-me saber se já o fez.
Agora, vamos prosseguir para a seção do algoritmo.
Detalhando o Algoritmo
Vamos discutir o algoritmo que nos guiará na escrita do código. Este algoritmo poderá ser adaptado para implementar o jogo em qualquer linguagem de programação. Veja como ele se estrutura:
- Crie um tabuleiro utilizando uma matriz bidimensional, com cada célula inicialmente vazia.
- Você pode escolher qualquer símbolo para representar uma célula vazia. Neste caso, utilizaremos o hífen ‘-‘.
- Desenvolva uma função para verificar se o tabuleiro está completamente preenchido.
- Percorra o tabuleiro e retorne ‘falso’ caso encontre alguma célula vazia, ou ‘verdadeiro’ caso contrário.
- Crie uma função para verificar se um jogador alcançou a vitória.
- Analise todas as combinações de vitória que foram discutidas anteriormente.
- Verifique todas as linhas, colunas e as duas diagonais.
- Crie uma função para exibir o tabuleiro, já que ele será mostrado repetidamente durante o jogo.
- Elabore uma função para iniciar o jogo.
- Selecione aleatoriamente quem começa o jogo.
- Implemente um loop infinito que só será interrompido quando o jogo terminar (com vitória ou empate).
- Exiba o tabuleiro para o jogador escolher sua próxima jogada.
- Solicite ao jogador que insira a linha e a coluna de sua escolha.
- Atualize a posição com o símbolo do jogador.
- Verifique se o jogador atual venceu o jogo.
- Se o jogador atual vencer, exiba uma mensagem de vitória e encerre o loop.
- Em seguida, verifique se o tabuleiro está cheio.
- Se o tabuleiro estiver completamente preenchido, exiba uma mensagem de empate e encerre o loop.
- Finalmente, mostre a configuração final do tabuleiro.
Você pode visualizar todo o processo. Não se preocupe se não tiver entendido tudo completamente. A compreensão se tornará mais clara quando você vir o código.
Vamos direto para a seção de código. Presumo que você já tenha o Python instalado para experimentar o código.
Implementação do Código
A seguir, apresento o código:
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
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"Vez do jogador {player}")
self.show_board()
# taking user input
row, col = list(
map(int, input("Digite os números da linha e coluna para marcar: ").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"Jogador {player} venceu o jogo!")
break
# checking whether the game is draw or not
if self.is_board_filled():
print("Empate!")
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()
Abaixo, você pode ver um exemplo da saída do código:
$ python tic_tac_toe.py Vez do jogador X - - - - - - - - - Digite os números da linha e coluna para marcar: 1 1 Vez do jogador O X - - - - - - - - Digite os números da linha e coluna para marcar: 2 1 Vez do jogador X X - - O - - - - - Digite os números da linha e coluna para marcar: 1 2 Vez do jogador O X X - O - - - - - Digite os números da linha e coluna para marcar: 1 3 Vez do jogador X X X O O - - - - - Digite os números da linha e coluna para marcar: 2 2 Vez do jogador O X X O O X - - - - Digite os números da linha e coluna para marcar: 3 3 Vez do jogador X X X O O X - - - O Digite os números da linha e coluna para marcar: 3 2 Jogador X venceu o jogo! X X O O X - - X O
Alguns pontos cruciais para entender a estrutura do código:
- Utilizamos uma classe para reunir todos os métodos em um único local, facilitando a reutilização em outros projetos.
- Definimos funções separadas para cada responsabilidade, mesmo que pequena. Isso torna o código mais fácil de manter e entender.
- Essas duas abordagens nos permitem adaptar e evoluir o jogo de forma fácil, caso queiramos adicionar novas funcionalidades.
Sinta-se à vontade para adaptar a estrutura do código e melhorá-la de acordo com as necessidades do seu projeto. A organização do código não tem um único padrão correto.
Considerações Finais
Parabéns! 🎉 Você criou um jogo do zero. Embora não seja um jogo visual sofisticado, ele foi fundamental para aprender a organizar a lógica e manter a estrutura do código limpa. Siga abordagens similares para criar jogos ainda mais interessantes. Você pode encontrar inspiração nos jogos que marcaram sua infância.
Bons estudos e boa programação! 👩💻
Em seguida, aprenda a criar um jogo de adivinhação de números e como realizar testes unitários com o módulo ‘unittest’ do Python.
Gostou do artigo? Compartilhe com seus amigos!