Implementando Four-in-a-Row em Python

Claro! A programação de um jogo como o “Four-in-a-Row” em Python é um projeto interessante que envolve conceitos de lógica de programação, estruturas de dados e interface de usuário. Vou explicar como você pode começar a desenvolver esse jogo passo a passo.

1. Definindo as Regras do Jogo:

O “Four-in-a-Row” é um jogo de estratégia para dois jogadores, no qual cada jogador tenta ser o primeiro a formar uma linha horizontal, vertical ou diagonal de quatro peças de sua cor.

2. Criando a Estrutura de Dados:

Para representar o tabuleiro do jogo, podemos usar uma lista de listas em Python. Cada elemento da lista principal representará uma coluna, e os elementos internos serão as células do tabuleiro.

3. Desenvolvendo a Lógica do Jogo:

• Inicialização do tabuleiro
• Exibição do tabuleiro
• Verificação de vitória
• Alternância de turnos entre os jogadores
• Jogada do jogador

4. Implementando a Interface do Usuário:

Vamos usar a biblioteca pygame para criar uma interface gráfica simples para o jogo.

Exemplo de Implementação em Python:

pythonCopy code
import pygame
import sys
import numpy as np

# Definindo constantes
ROW_COUNT = 6
COLUMN_COUNT = 7
BLUE = (0, 0, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 255, 0)

# Função para criar o tabuleiro
def create_board():
    board = np.zeros((ROW_COUNT, COLUMN_COUNT))
    return board

# Função para inserir uma peça no tabuleiro
def drop_piece(board, row, col, piece):
    board[row][col] = piece

# Função para verificar se uma coluna está disponível para jogar
def is_valid_location(board, col):
    return board[ROW_COUNT-1][col] == 0

# Função para encontrar a próxima linha vazia em uma coluna
def get_next_open_row(board, col):
    for r in range(ROW_COUNT):
        if board[r][col] == 0:
            return r

# Função para imprimir o tabuleiro
def print_board(board):
    print(np.flip(board, 0))

# Função para verificar se houve vitória
def winning_move(board, piece):
    # Verificar vitória na horizontal
    for c in range(COLUMN_COUNT - 3):
        for r in range(ROW_COUNT):
            if board[r][c] == piece and board[r][c + 1] == piece and board[r][c + 2] == piece and board[r][c + 3] == piece:
                return True

    # Verificar vitória na vertical
    for c in range(COLUMN_COUNT):
        for r in range(ROW_COUNT - 3):
            if board[r][c] == piece and board[r + 1][c] == piece and board[r + 2][c] == piece and board[r + 3][c] == piece:
                return True

    # Verificar vitória na diagonal (ascendente)
    for c in range(COLUMN_COUNT - 3):
        for r in range(ROW_COUNT - 3):
            if board[r][c] == piece and board[r + 1][c + 1] == piece and board[r + 2][c + 2] == piece and board[r + 3][c + 3] == piece:
                return True

    # Verificar vitória na diagonal (descendente)
    for c in range(COLUMN_COUNT - 3):
        for r in range(3, ROW_COUNT):
            if board[r][c] == piece and board[r - 1][c + 1] == piece and board[r - 2][c + 2] == piece and board[r - 3][c + 3] == piece:
                return True

# Inicialização do pygame
pygame.init()

# Definição do tamanho da tela
SQUARESIZE = 100
width = COLUMN_COUNT * SQUARESIZE
height = (ROW_COUNT + 1) * SQUARESIZE
size = (width, height)

# Criação da tela
screen = pygame.display.set_mode(size)

# Criação do tabuleiro
board = create_board()
print_board(board)
game_over = False
turn = 0

# Loop principal do jogo
while not game_over:

    # Eventos do pygame
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()

        if event.type == pygame.MOUSEMOTION:
            pygame.draw.rect(screen, BLACK, (0, 0, width, SQUARESIZE))
            posx = event.pos[0]
            if turn == 0:
                pygame.draw.circle(screen, RED, (posx, int(SQUARESIZE/2)), int(SQUARESIZE/2 - 5))
            else:
                pygame.draw.circle(screen, YELLOW, (posx, int(SQUARESIZE/2)), int(SQUARESIZE/2 - 5))
        pygame.display.update()

        if event.type == pygame.MOUSEBUTTONDOWN:
            pygame.draw.rect(screen, BLACK, (0, 0, width, SQUARESIZE))
            # Solicitação do jogador 1
            if turn == 0:
                posx = event.pos[0]
                col = int(posx // SQUARESIZE)

                if is_valid_location(board, col):
                    row = get_next_open_row(board, col)
                    drop_piece(board, row, col, 1)

                    if winning_move(board, 1):
                        print("Jogador 1 venceu!")
                        game_over = True

            # Solicitação do jogador 2
            else:
                posx = event.pos[0]
                col = int(posx // SQUARESIZE)

                if is_valid_location(board, col):
                    row = get_next_open_row(board, col)
                    drop_piece(board, row, col, 2)

                    if winning_move(board, 2):
                        print("Jogador 2 venceu!")
                        game_over = True

            print_board(board)
            turn += 1
            turn %= 2

            if game_over:
                pygame.time.wait(3000)

Este código cria uma representação funcional do jogo Four-in-a-Row em Python usando a biblioteca pygame para a interface gráfica. Ele inclui a lógica do jogo, a interface do usuário e a detecção de vitória.

Claro! Vamos expandir um pouco mais sobre cada parte do código e fornecer mais informações sobre como o jogo “Four-in-a-Row” é implementado em Python.

1. Definindo as Regras do Jogo:

O “Four-in-a-Row” é um jogo de estratégia para dois jogadores, onde o objetivo é ser o primeiro a formar uma linha horizontal, vertical ou diagonal de quatro peças da sua cor. Cada jogador tem sua própria cor de peça, geralmente vermelho e amarelo.

2. Criando a Estrutura de Dados:

Para representar o tabuleiro do jogo, usamos uma matriz bidimensional, que é criada usando a biblioteca NumPy. Cada elemento da matriz representa uma célula do tabuleiro, sendo 0 para células vazias, 1 para peças do jogador 1 (geralmente vermelhas) e 2 para peças do jogador 2 (geralmente amarelas).

3. Desenvolvendo a Lógica do Jogo:

• Inicialização do tabuleiro: A função create_board() cria um tabuleiro vazio.

• Exibição do tabuleiro: A função print_board() exibe o tabuleiro no console.

• Verificação de vitória: A função winning_move() verifica se há uma sequência de quatro peças da mesma cor em linha.

• Alternância de turnos entre os jogadores: O jogo segue uma lógica de turnos, alternando entre os jogadores após cada jogada.

• Jogada do jogador: Os jogadores fazem suas jogadas ao clicar em uma coluna na interface gráfica.

4. Implementando a Interface do Usuário:

A biblioteca pygame é utilizada para criar uma interface gráfica simples para o jogo. Ela permite desenhar formas na tela, detectar eventos do mouse e do teclado, e atualizar a tela conforme necessário.

Explicação Detalhada do Código:

• Inicialização do Pygame: O Pygame é inicializado com pygame.init() e a tela do jogo é criada com pygame.display.set_mode(size).

• Loop Principal do Jogo: O loop principal do jogo continua até que o jogo termine. Ele processa os eventos do Pygame, como cliques do mouse e a saída do jogo.

• Eventos do Pygame: O loop principal do jogo verifica os eventos do Pygame, como o movimento do mouse e cliques do mouse. Quando um jogador clica em uma coluna, o programa verifica se a jogada é válida e atualiza o tabuleiro.

• Renderização da Interface Gráfica: A interface gráfica é atualizada a cada frame para refletir o estado atual do jogo. As peças dos jogadores são desenhadas na tela usando pygame.draw.circle().

Conclusão:

Este código fornece uma implementação básica do jogo “Four-in-a-Row” em Python, incluindo a lógica do jogo e uma interface gráfica simples. Ele pode ser expandido com recursos adicionais, como animações, sons e modos de jogo alternativos, para criar uma experiência mais completa para os jogadores.