Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Faça um jogo de xadrez com pygame para pydroid com lógica e tudo

  1. User

    Faça um jogo de xadrez com pygame para pydroid com lógica e tudo

  2. Assistant

    Olá! Posso ajudá-lo a criar um jogo de xadrez usando Pygame para Pydroid. A seguir, forneceremos um código completo que implementa um jogo de xadrez simples com lógica básica. Note que devido à complexidade de um jogo de xadrez completo, este exemplo cobre as funcionalidades principais e pode ser expandido conforme necessário.

    Segue abaixo o código do jogo de xadrez usando Pygame:

    import pygame
    from pygame.locals import *
    
    # Inicializa o Pygame
    pygame.init()
    
    # Define as dimensões da janela e do tabuleiro
    largura_janela = 512
    altura_janela = 512
    tamanho_quadrado = 64
    
    # Define as cores
    BRANCO = (255, 255, 255)
    PRETO = (0, 0, 0)
    CINZA = (128, 128, 128)
    
    # Cria a janela do jogo
    screen = pygame.display.set_mode((largura_janela, altura_janela))
    pygame.display.set_caption('Jogo de Xadrez')
    
    # Carrega as imagens das peças
    imagens = {}
    
    def carrega_imagens():
        pecas = ['branco_peao', 'branco_torre', 'branco_cavalo', 'branco_bispo', 'branco_rainha', 'branco_rei',
                 'preto_peao', 'preto_torre', 'preto_cavalo', 'preto_bispo', 'preto_rainha', 'preto_rei']
        for peca in pecas:
            imagens[peca] = pygame.transform.scale(pygame.image.load('imagens/' + peca + '.png'), (tamanho_quadrado, tamanho_quadrado))
    
    # Classe que representa uma peça
    class Peca:
        def __init__(self, tipo, cor):
            self.tipo = tipo  # 'peao', 'torre', etc.
            self.cor = cor  # 'branco' ou 'preto'
            self.imagem = imagens[cor + '_' + tipo]
            self.movida = False  # Para casos especiais como roque e en passant
    
    # Classe que representa o tabuleiro
    class Tabuleiro:
        def __init__(self):
            # Cria uma matriz 8x8 para representar o tabuleiro
            self.tabuleiro = [[0 for _ in range(8)] for _ in range(8)]
            self.cria_pecas_iniciais()
    
        def cria_pecas_iniciais(self):
            # Coloca as peças nos seus lugares iniciais
            for i in range(8):
                self.tabuleiro[1][i] = Peca('peao', 'preto')
                self.tabuleiro[6][i] = Peca('peao', 'branco')
            # Torres
            self.tabuleiro[0][0] = self.tabuleiro[0][7] = Peca('torre', 'preto')
            self.tabuleiro[7][0] = self.tabuleiro[7][7] = Peca('torre', 'branco')
            # Cavalos
            self.tabuleiro[0][1] = self.tabuleiro[0][6] = Peca('cavalo', 'preto')
            self.tabuleiro[7][1] = self.tabuleiro[7][6] = Peca('cavalo', 'branco')
            # Bispos
            self.tabuleiro[0][2] = self.tabuleiro[0][5] = Peca('bispo', 'preto')
            self.tabuleiro[7][2] = self.tabuleiro[7][5] = Peca('bispo', 'branco')
            # Rainhas
            self.tabuleiro[0][3] = Peca('rainha', 'preto')
            self.tabuleiro[7][3] = Peca('rainha', 'branco')
            # Reis
            self.tabuleiro[0][4] = Peca('rei', 'preto')
            self.tabuleiro[7][4] = Peca('rei', 'branco')
    
        def desenha_tabuleiro(self, screen):
            cores = [BRANCO, CINZA]
            for linha in range(8):
                for coluna in range(8):
                    cor = cores[(linha + coluna) % 2]
                    pygame.draw.rect(screen, cor, pygame.Rect(coluna*tamanho_quadrado, linha*tamanho_quadrado, tamanho_quadrado, tamanho_quadrado))
                    peca = self.tabuleiro[linha][coluna]
                    if peca != 0:
                        screen.blit(peca.imagem, pygame.Rect(coluna*tamanho_quadrado, linha*tamanho_quadrado, tamanho_quadrado, tamanho_quadrado))
    
    # Função principal do jogo
    def main():
        clock = pygame.time.Clock()
        tabuleiro = Tabuleiro()
        carrega_imagens()
        running = True
        peca_selecionada = None
        jogador_atual = 'branco'
        posicoes_validas = []
    
        while running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
    
                elif event.type == pygame.MOUSEBUTTONDOWN:
                    x, y = pygame.mouse.get_pos()
                    coluna = x // tamanho_quadrado
                    linha = y // tamanho_quadrado
    
                    if peca_selecionada:
                        # Move a peça se a posição for válida
                        if (linha, coluna) in posicoes_validas:
                            tabuleiro.tabuleiro[linha][coluna] = peca_selecionada
                            tabuleiro.tabuleiro[peca_selecionada_pos[0]][peca_selecionada_pos[1]] = 0
                            peca_selecionada = None
                            # Alterna o jogador
                            jogador_atual = 'preto' if jogador_atual == 'branco' else 'branco'
                        else:
                            # Selecione outra peça
                            if tabuleiro.tabuleiro[linha][coluna] != 0 and tabuleiro.tabuleiro[linha][coluna].cor == jogador_atual:
                                peca_selecionada = tabuleiro.tabuleiro[linha][coluna]
                                peca_selecionada_pos = (linha, coluna)
                                posicoes_validas = movimentos_validos(tabuleiro, peca_selecionada, linha, coluna)
                            else:
                                peca_selecionada = None
                                posicoes_validas = []
                    else:
                        if tabuleiro.tabuleiro[linha][coluna] != 0 and tabuleiro.tabuleiro[linha][coluna].cor == jogador_atual:
                            peca_selecionada = tabuleiro.tabuleiro[linha][coluna]
                            peca_selecionada_pos = (linha, coluna)
                            posicoes_validas = movimentos_validos(tabuleiro, peca_selecionada, linha, coluna)
    
            tabuleiro.desenha_tabuleiro(screen)
            # Realça as posições válidas
            for pos in posicoes_validas:
                pygame.draw.rect(screen, (0, 255, 0), (pos[1]*tamanho_quadrado, pos[0]*tamanho_quadrado, tamanho_quadrado, tamanho_quadrado), 3)
            pygame.display.flip()
            clock.tick(60)
    
        pygame.quit()
    
    # Função para determinar os movimentos válidos de uma peça
    def movimentos_validos(tabuleiro, peca, linha, coluna):
        movimentos = []
        direcoes = []
    
        if peca.tipo == 'peao':
            if peca.cor == 'branco':
                direcao = -1
                linha_inicial = 6
            else:
                direcao = 1
                linha_inicial = 1
            # Movimento para frente
            if tabuleiro.tabuleiro[linha + direcao][coluna] == 0:
                movimentos.append((linha + direcao, coluna))
                # Primeiro movimento pode avançar duas casas
                if linha == linha_inicial and tabuleiro.tabuleiro[linha + 2*direcao][coluna] == 0:
                    movimentos.append((linha + 2*direcao, coluna))
            # Captura diagonal
            for dc in [-1, 1]:
                nc = coluna + dc
                nl = linha + direcao
                if 0 <= nc < 8 and 0 <= nl < 8:
                    destino = tabuleiro.tabuleiro[nl][nc]
                    if destino != 0 and destino.cor != peca.cor:
                        movimentos.append((nl, nc))
    
        # Implementação simplificada para outras peças (movimentos não completos)
        elif peca.tipo == 'torre':
            direcoes = [(-1,0), (1,0), (0,-1), (0,1)]
        elif peca.tipo == 'bispo':
            direcoes = [(-1,-1), (-1,1), (1,-1), (1,1)]
        elif peca.tipo == 'rainha':
            direcoes = [(-1,0), (1,0), (0,-1), (0,1), (-1,-1), (-1,1), (1,-1), (1,1)]
        elif peca.tipo == 'rei':
            direcoes = [(-1,0), (1,0), (0,-1), (0,1), (-1,-1), (-1,1), (1,-1), (1,1)]
        elif peca.tipo == 'cavalo':
            movimentos_cavalo = [(-2,-1), (-2,1), (-1,-2), (-1,2), (1,-2), (1,2), (2,-1), (2,1)]
            for d in movimentos_cavalo:
                nl = linha + d[0]
                nc = coluna + d[1]
                if 0 <= nl < 8 and 0 <= nc < 8:
                    destino = tabuleiro.tabuleiro[nl][nc]
                    if destino == 0 or destino.cor != peca.cor:
                        movimentos.append((nl, nc))
            return movimentos
    
        # Movimento para peças lineares
        for d in direcoes:
            nl = linha + d[0]
            nc = coluna + d[1]
            while 0 <= nl < 8 and 0 <= nc < 8:
                destino = tabuleiro.tabuleiro[nl][nc]
                if destino == 0:
                    movimentos.append((nl, nc))
                elif destino.cor != peca.cor:
                    movimentos.append((nl, nc))
                    break
                else:
                    break
                if peca.tipo == 'rei':
                    break
                nl += d[0]
                nc += d[1]
    
        return movimentos
    
    if __name__ == '__main__':
        main()
    

    Observações:

    1. Imagens das peças: Certifique-se de ter as imagens das peças no diretório imagens/ com os nomes correspondentes, como branco_peao.png, preto_peao.png, etc. As imagens devem estar redimensionadas para 64x64 pixels ou serão dimensionadas no código.

    2. Movimentos das peças: Este código implementa uma lógica básica para os movimentos das peças. No caso dos peões, implementa movimento frontal e captura diagonal. Para as outras peças, implementa movimentos lineares simples, mas não inclui todas as regras especiais (como roque, en passant, promoção de peão, e detecção de xeque e xeque-mate).

    3. Turnos dos jogadores: O jogo alterna entre os jogadores 'branco' e 'preto' após cada movimento válido.

    4. Melhorias futuras: Para construir um jogo de xadrez completo, seria necessário implementar todas as regras do xadrez, detecção de xeque e xeque-mate, promoção de peão, roque, en passant, entre outras funcionalidades.

    Para executar o jogo no Pydroid:

    1. Copie o código acima para um arquivo .py no Pydroid.
    2. Crie uma pasta chamada imagens no mesmo diretório do script.
    3. Adicione as imagens das peças na pasta imagens.
    4. Execute o script no Pydroid.

    Espero que este código seja útil como ponto de partida para o seu jogo de xadrez!