Introdução
Este projeto irá guiá-lo pelos passos para criar um jogo da velha (Tic-Tac-Toe) usando Pygame. O jogo da velha é um jogo para dois jogadores onde o objetivo é obter três dos seus símbolos em linha, seja horizontalmente, verticalmente ou diagonalmente. Neste projeto, você aprenderá como configurar a janela do jogo, desenhar o tabuleiro, lidar com os movimentos dos jogadores e da IA, e determinar o vencedor. Ao final deste projeto, você terá um jogo da velha totalmente funcional que poderá jogar contra um oponente de IA.
👀 Pré-visualização
🎯 Tarefas
Neste projeto, você aprenderá:
- Como criar os arquivos do projeto e importar as bibliotecas necessárias
- Como inicializar o PyGame e configurar a janela do jogo
- Como definir os símbolos, cores e estado do jogo
- Como definir as propriedades dos botões e criar funções auxiliares
- Como criar o loop principal do jogo e implementar as funções auxiliares
- Como preencher o código restante dentro do loop principal do jogo
🏆 Conquistas
Após concluir este projeto, você será capaz de:
- Usar o Pygame para criar um jogo gráfico
- Desenhar gráficos em uma janela usando o Pygame
- Lidar com a entrada do usuário e atualizar o estado do jogo
- Implementar a lógica do jogo, como verificar uma condição de vitória
- Criar um loop de jogo para manter o jogo em execução
Criar os arquivos do projeto
Para começar, crie um novo arquivo chamado tic_tac_toe.py. Abra o arquivo no seu editor de texto preferido.
cd ~/project
touch tic_tac_toe.py
Importar as bibliotecas necessárias
Em tic_tac_toe.py, importe as bibliotecas necessárias: pygame e random. Essas bibliotecas serão usadas para lidar com os gráficos do jogo e gerar movimentos aleatórios da IA, respectivamente.
import pygame
import random
Instale a biblioteca pygame usando o seguinte comando:
sudo pip install pygame
Inicializar PyGame e configurar a janela do jogo
Em tic_tac_toe.py, inicialize o PyGame usando pygame.init(). Em seguida, configure a janela do jogo definindo a largura e altura da janela, a cor de fundo, a cor da linha e o tamanho da célula. Além disso, crie uma janela PyGame com a largura e altura especificadas e defina a legenda da janela.
pygame.init()
WIDTH = 600
HEIGHT = 600
BACKGROUND_COLOR = (40, 40, 40)
LINE_COLOR = (70, 70, 70)
CELL_SIZE = WIDTH // 3
win = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Tic-Tac-Toe")
Definir os símbolos e cores
Em tic_tac_toe.py, defina os símbolos e cores para o jogador e a IA. Esses símbolos e cores serão usados para desenhar os movimentos do jogador e da IA no tabuleiro do jogo.
PLAYER_SYMBOL = "X"
AI_SYMBOL = "O"
PLAYER_COLOR = (0, 255, 0)
AI_COLOR = (255, 0, 0)
EMPTY_COLOR = (0, 0, 0)
Definir o estado do jogo
Em tic_tac_toe.py, defina o estado inicial do jogo. Isso inclui o tabuleiro do jogo, o turno atual (seja "player" ou "ai"), uma flag indicando se o jogo acabou e o vencedor do jogo.
board = [["" for _ in range(3)] for _ in range(3)]
turn = "player"
game_over = False
winner = None
Definir as propriedades do botão
Em tic_tac_toe.py, defina as propriedades para o botão de reset, incluindo a largura, altura, cor, cor do texto e tamanho da fonte do botão. Além disso, crie um objeto reset_button_rect usando a classe pygame.Rect para representar a posição e o tamanho do botão.
BUTTON_WIDTH = 200
BUTTON_HEIGHT = 50
BUTTON_COLOR = (50, 50, 50)
BUTTON_TEXT_COLOR = (255, 255, 255)
BUTTON_FONT = pygame.font.Font(None, 30)
reset_button_rect = pygame.Rect(
(WIDTH - BUTTON_WIDTH) // 2,
(HEIGHT - BUTTON_HEIGHT) // 2,
BUTTON_WIDTH,
BUTTON_HEIGHT,
)
Criar funções auxiliares
Em tic_tac_toe.py, defina várias funções auxiliares que serão usadas ao longo do jogo.
draw_board(): Esta função desenhará o tabuleiro do jogo na janela.draw_symbols(): Esta função desenhará os símbolos do jogador e da IA no tabuleiro do jogo.is_board_full(): Esta função verificará se o tabuleiro do jogo está cheio.is_winner(): Esta função verificará se um jogador venceu o jogo.make_move(): Esta função fará uma jogada no tabuleiro do jogo.player_move(): Esta função tratará da jogada do jogador.ai_move(): Esta função tratará da jogada da IA.check_game_over(): Esta função verificará se o jogo acabou.draw_winner(): Esta função desenhará a mensagem do vencedor na janela.draw_reset_button(): Esta função desenhará o botão de reset na janela.reset_game(): Esta função redefinirá o estado do jogo.
## Funções auxiliares
def draw_board():
## Desenhar o tabuleiro do jogo
pass
def draw_symbols():
## Desenhar os símbolos do jogador e da IA no tabuleiro do jogo
pass
def is_board_full():
## Verificar se o tabuleiro do jogo está cheio
pass
def is_winner(symbol):
## Verificar se um jogador venceu o jogo
pass
def make_move(x, y, symbol):
## Fazer uma jogada no tabuleiro do jogo
pass
def player_move():
## Tratar da jogada do jogador
pass
def ai_move():
## Tratar da jogada da IA
pass
def check_game_over():
## Verificar se o jogo acabou
pass
def draw_winner():
## Desenhar a mensagem do vencedor na janela
pass
def draw_reset_button():
## Desenhar o botão de reset na janela
pass
def reset_game():
## Redefinir o estado do jogo
pass
Criar o loop principal do jogo
Em tic_tac_toe.py, crie o loop principal do jogo usando um loop while. Este loop será executado até que o usuário feche a janela do jogo. Dentro do loop do jogo, trate os eventos de entrada do usuário e atualize o estado do jogo de acordo.
## Loop principal do jogo
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.MOUSEBUTTONDOWN:
if reset_button_rect.collidepoint(event.pos):
reset_game()
elif not game_over and turn == "player":
player_move()
if not game_over and turn == "ai":
ai_move()
check_game_over()
draw_board()
draw_symbols()
if game_over:
draw_winner()
draw_reset_button()
pygame.display.flip()
## Sair do jogo
pygame.quit()
Implementar as funções auxiliares
Agora, vamos implementar as funções auxiliares que definimos anteriormente. Comece completando a função draw_board(). Esta função desenhará o tabuleiro do jogo na janela, desenhando linhas verticais e horizontais usando a função pygame.draw.line().
## Funções auxiliares
def draw_board():
win.fill(BACKGROUND_COLOR)
## Desenhar linhas verticais
for x in range(1, 3):
pygame.draw.line(
win, LINE_COLOR, (CELL_SIZE * x, 0), (CELL_SIZE * x, HEIGHT), 2
)
## Desenhar linhas horizontais
for y in range(1, 3):
pygame.draw.line(win, LINE_COLOR, (0, CELL_SIZE * y), (WIDTH, CELL_SIZE * y), 2)
Implementar as funções auxiliares restantes
Em seguida, implemente as funções auxiliares restantes: draw_symbols(), is_board_full(), is_winner(), make_move(), player_move(), ai_move(), check_game_over(), draw_winner(), draw_reset_button() e reset_game().
## Funções auxiliares
def draw_symbols():
for x in range(3):
for y in range(3):
symbol = board[x][y]
if symbol == PLAYER_SYMBOL:
color = PLAYER_COLOR
elif symbol == AI_SYMBOL:
color = AI_COLOR
else:
color = EMPTY_COLOR
if symbol != "":
pygame.draw.circle(
win,
color,
(x * CELL_SIZE + CELL_SIZE // 2, y * CELL_SIZE + CELL_SIZE // 2),
CELL_SIZE // 2 - 10,
2,
)
def is_board_full():
for row in board:
if "" in row:
return False
return True
def is_winner(symbol):
for row in board:
if all(cell == symbol for cell in row):
return True
for col in range(3):
if all(board[row][col] == symbol for row in range(3)):
return True
if all(board[i][i] == symbol for i in range(3)):
return True
if all(board[i][2 - i] == symbol for i in range(3)):
return True
return False
def make_move(x, y, symbol):
if board[x][y] == "":
board[x][y] = symbol
return True
return False
def player_move():
global turn
mouse_pos = pygame.mouse.get_pos()
cell_x = mouse_pos[0] // CELL_SIZE
cell_y = mouse_pos[1] // CELL_SIZE
if make_move(cell_x, cell_y, PLAYER_SYMBOL):
turn = "ai"
def ai_move():
global turn
empty_cells = []
for x in range(3):
for y in range(3):
if board[x][y] == "":
empty_cells.append((x, y))
if empty_cells:
x, y = random.choice(empty_cells)
make_move(x, y, AI_SYMBOL)
turn = "player"
def check_game_over():
global game_over, winner
if is_winner(PLAYER_SYMBOL):
game_over = True
return "player"
elif is_winner(AI_SYMBOL):
game_over = True
return "ai"
elif is_board_full():
game_over = True
return "tie"
return None
def draw_winner():
font = pygame.font.Font(None, 50)
if winner == "player":
text = font.render("Player Wins!", True, PLAYER_COLOR)
elif winner == "ai":
text = font.render("AI Wins!", True, AI_COLOR)
else:
text = font.render("It's a Tie!", True, (255, 255, 255))
text_rect = text.get_rect(center=(WIDTH // 2, HEIGHT // 3))
win.blit(text, text_rect)
def draw_reset_button():
pygame.draw.rect(win, BUTTON_COLOR, reset_button_rect)
button_text = BUTTON_FONT.render("Reset", True, BUTTON_TEXT_COLOR)
button_text_rect = button_text.get_rect(center=reset_button_rect.center)
win.blit(button_text, button_text_rect)
def reset_game():
global board, turn, game_over, winner
board = [["" for _ in range(3)] for _ in range(3)]
turn = "player"
game_over = False
winner = None
No código acima, a função draw_symbols() desenhará os símbolos no tabuleiro. A função is_board_full() verificará se o tabuleiro está cheio. A função is_winner() verificará se o símbolo fornecido ganhou o jogo. A função make_move() fará uma jogada no tabuleiro. A função player_move() tratará a jogada do jogador. A função ai_move() tratará a jogada da IA. A função check_game_over() verificará se o jogo acabou. A função draw_winner() desenhará a mensagem do vencedor. A função draw_reset_button() desenhará o botão de reinício. A função reset_game() reiniciará o jogo.
Preencher o código restante
Finalmente, preencha o código restante dentro do loop principal do jogo para chamar as funções auxiliares nos locais apropriados. Isso inclui chamar as funções draw_board() e draw_symbols() para desenhar o tabuleiro do jogo e os símbolos, chamar a função check_game_over() para verificar se o jogo acabou e chamar as funções draw_winner() e draw_reset_button() para desenhar a mensagem do vencedor e o botão de reinício, respectivamente.
## Loop principal do jogo
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.MOUSEBUTTONDOWN:
if reset_button_rect.collidepoint(event.pos):
reset_game()
elif not game_over and turn == "player":
player_move()
if not game_over and turn == "ai":
ai_move()
winner = check_game_over()
draw_board()
draw_symbols()
if game_over:
draw_winner()
draw_reset_button()
pygame.display.flip()
## Sair do jogo
pygame.quit()
Execute o jogo usando o seguinte comando:
python tic_tac_toe.py
Resumo
Parabéns! Você criou com sucesso um jogo da velha usando Pygame. Neste projeto, você aprendeu como configurar a janela do jogo, desenhar o tabuleiro, lidar com as jogadas do jogador e da IA, e determinar o vencedor. Você também aprendeu como implementar funções auxiliares para simplificar o código e torná-lo mais modular.
