Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

me de o codigo para o jogador 2 fazer uma busca A∗ para o seguinte programa sem…

  1. User

    me de o codigo para o jogador 2 fazer uma busca A∗ para o seguinte programa sem descrição do codigo que está sendo feito:

    % variável global :- dynamic versao/1. :- dynamic largura/1. :- dynamic altura/1. :- dynamic consecutivas/1.

    :- use_module(library(clpfd)). :- use_module(library(random)).

    solicita_versao :- write('Escolha a versão do jogo: '), nl, write('1 - Normal'), nl, write('2 - Simplificada'), nl, read(Versao), valida_versao(Versao).

    valida_versao(Versao) :- Versao < 1 -> write('Versão inválida. Tente novamente.'), nl, solicita_versao ;

    Versao > 2 ->
    write('Versão inválida. Tente novamente.'), nl,
    solicita_versao
    ;
    % armazena o valor da versao na variável global
    asserta(versao(Versao)).
    

    solicita_largura :- write('Digite a quantidade de linhas: '), nl, read(Largura), valida_largura(Largura).

    valida_largura(Largura) :- Largura < 1 -> write('Largura inválida. Tente novamente.'), nl, solicita_largura ; % armazena o valor da largura na variável global asserta(largura(Largura)).

    solicita_altura :- write('Digite a quantidade de colunas: '), nl, read(Altura), valida_altura(Altura).

    valida_altura(Altura) :- Altura < 1 -> write('Altura inválida. Tente novamente.'), nl, solicita_altura ; % armazena o valor da altura na variável global asserta(altura(Altura)).

    solicita_consecutivas :- write('Digite a quantidade de peças repetidas para ganhar: '), nl, read(Consecutivas), valida_consecutivas(Consecutivas).

    valida_consecutivas(Consecutivas) :- % armazena o valor da consecutivas na variável global asserta(consecutivas(Consecutivas)).

    jogar :- % chama o predicado que solicita a versão solicita_versao,

    % chama o predicado que solicita a largura
    solicita_largura,
    
    % chama o predicado que solicita a altura
    solicita_altura,
    
    % chama o predicado que solicita os repetidas
    solicita_consecutivas,
    
    criar_tabuleiro(Tabuleiro),
    imprimir_tabuleiro(Tabuleiro),
    jogador1_joga(Tabuleiro).
    

    % Cria um tabuleiro vazio com o tamanho especificado criar_tabuleiro(Tabuleiro) :- largura(Largura), altura(Altura), criar_linhas(Largura, Altura, Tabuleiro).

    criar_linhas(_, 0, []). criar_linhas(Largura, Altura, [Linha|Tabuleiro]) :- Altura > 0, length(Linha, Largura), Altura1 is Altura - 1, criar_linhas(Largura, Altura1, Tabuleiro).

    % Imprime o tabuleiro imprimir_tabuleiro(Tabuleiro) :- imprimir_linhas(Tabuleiro).

    % Funcoes auxiliares para imprimir o tabuleiro, linha por linha imprimir_linhas([]). imprimir_linhas([Linha|Tabuleiro]) :- write(' |'), imprimir_linha(Linha), write('|'), nl, imprimir_linhas(Tabuleiro).

    imprimir_linha([]). imprimir_linha([Celula|Linha]) :- (nonvar(Celula), write(Celula); write(' ')), write(' | '), imprimir_linha(Linha).

    % função para substituir um elemento em uma posição específica troca([Linha|Linhas], 1, Coluna, [NovaLinha|Linhas], Simbolo) :- troca_linha(Linha, Coluna, Simbolo, NovaLinha). troca([Linha|Linhas], NumLinha, Coluna, [Linha|NovasLinhas], Simbolo) :- NumLinha > 1, NumLinha1 is NumLinha - 1, troca(Linhas, NumLinha1, Coluna, NovasLinhas, Simbolo).

    % função para substituir um elemento em uma linha específica troca_linha([_|Colunas], 1, Simbolo, [Simbolo|Colunas]). troca_linha([Coluna|Colunas], NumColuna, Simbolo, [Coluna|NovasColunas]) :- NumColuna == 1, NumColuna1 is NumColuna - 1, troca_linha(Colunas, NumColuna1, Simbolo, NovasColunas).

    % Jogador 1 joga jogador1_joga(Tabuleiro) :- versao(Versao), largura(Largura), altura(Altura),

    write('Vez do Jogador 1 (X)'),nl,
    
    (Versao =:= 1) ->
    write('Escolha uma coluna: '),nl,
    read(Coluna),
    Coluna > 0, !,
    Coluna =< Largura, !,
    
    write('Escolha uma linha: '), nl,
    read(Linha1),
    Linha1 > 0, !,
    Linha1 =< Altura, !,
    
    criar_tabuleiro(NovoTabuleiro),
    troca(Tabuleiro, Linha1, Coluna, NovoTabuleiro, 'X'),
    imprimir_tabuleiro(NovoTabuleiro),
    jogador2_joga(NovoTabuleiro)
    
    ;
    (Versao =:= 2) ->
    write('Versão nao implementada'), nl.
    

    % Jogador 2 joga jogador2_joga(Tabuleiro) :- versao(Versao), write('Vez do Jogador 2 (O)'),nl,

    % Verifica versão do jogo
    (Versao =:= 1) ->
    
    jogada_minimax(Tabuleiro, Linha, Coluna),
    write('Escolheu a coluna: '),write(Coluna),nl,
    write('Escolheu a linha: '),write(Linha),nl,
    
    criar_tabuleiro(NovoTabuleiro),
    troca(NovoTabuleiro, Linha, Coluna, TabuleiroMod),
    imprimir_tabuleiro(TabuleiroMod),
    jogador1_joga(TabuleiroMod)
    ;
    (Versao =:= 2) ->
    write('Versão nao implementada'), nl.
    

    % Verifica se há um vencedor na horizontal verificar_vitoria_horizontal(Tabuleiro, Peca) :- nth1(_, Tabuleiro, Linha), verificar_vitoria(Linha, Peca).

    % Verifica se há um vencedor na vertical verificar_vitoria_vertical(Tabuleiro, Peca) :- transpose(Tabuleiro, TabuleiroTransposto), verificar_vitoria_horizontal(TabuleiroTransposto, Peca).

    % Verifica se há um vencedor na diagonal verificar_vitoria_diagonal(Tabuleiro, Peca) :- diagonal(Tabuleiro, Diagonal), verificar_vitoria(Diagonal, Peca).

    % Retorna a diagonal principal do tabuleiro diagonal(Tabuleiro, Diagonal) :- diagonal(Tabuleiro, Diagonal, 1).

    diagonal([], [], _). diagonal([Linha|Tabuleiro], [Celula|Diagonal], N) :- nth1(N, Linha, Celula), N1 is N + 1, diagonal(Tabuleiro, Diagonal, N1).

    % Verifica se há um vencedor em uma linha ou coluna verificar_vitoria(Linha, Peca) :- consecutivas(Consecutivas), append(, [Peca|T], Linha), length([Peca|T],Consecutivas), !. verificar_vitoria(Linha, Peca) :- consecutivas(Consecutivas), append(T, [Peca|], Linha), length(T, Consecutivas), !.

    % Verifica se houve empate empate(Tabuleiro) :- %todas_colunas_preenchidas(Tabuleiro). fail.

    % Verifica se todas as colunas foram preenchidas todas_colunas_preenchidas([]). todas_colunas_preenchidas([ColunaTabuleiro|Tabuleiro]) :- altura(Altura), length(ColunaTabuleiro, Altura), Altura > 0, todas_colunas_preenchidas(Tabuleiro).

    venceu(Tabuleiro, Jogador) :- % verifica linhas member([Jogador,Jogador,Jogador], Tabuleiro),

    % verifica colunas
    transpose(Tabuleiro, Transposta),
    member([Jogador,Jogador,Jogador], Transposta),
    
    % verifica diagonal principal
    nth0(0, Tabuleiro, [Jogador,_,_]),
    nth0(1, Tabuleiro, [_,Jogador,_]),
    nth0(2, Tabuleiro, [_,_,Jogador]),
    
    % verifica diagonal secundária
    nth0(0, Tabuleiro, [_,_,Jogador]),
    nth0(1, Tabuleiro, [_,Jogador,_]),
    nth0(2, Tabuleiro, [Jogador,_,_]).
    

    % Verifica se há um vencedor vencedor(Tabuleiro, Peca) :- fail. %verificar_vitoria_horizontal(Tabuleiro, Peca). vencedor(Tabuleiro, Peca) :- fail. %verificar_vitoria_vertical(Tabuleiro, Peca). vencedor(Tabuleiro, Peca) :- fail. %verificar_vitoria_diagonal(Tabuleiro, Peca).

  2. Assistant

    Para adicionar uma busca A* ao jogador 2, você pode utilizar os seguintes passos:

    1. Modifique a função "jogador2_joga" no caso "Versão =:= 1" chamando a função "jogada_astar".

    2. Crie uma função "jogada_astar" que receberá o tabuleiro, a linha e a coluna como argumentos. Ela usará o algoritmo A* para encontrar uma jogada e devolverá as coordenadas da linha e coluna onde deve ser inserida a peça do jogador 2.

    3. Implemente a função "jogada_astar" com o algoritmo A* através das seguintes etapas:

      1. Primeiro, monte uma tabela de heurísticas com a mesma dimensão do tabuleiro, onde cada célula possui um valor de heurística inicializado para uma grande quantidade, por exemplo, 99.

      2. Em seguida, para cada célula vazia do tabuleiro, calcule a heurística (H) e armazene o valor na tabela. A heurística é calculada analisando quantas peças consecutivas do jogadores 1 e 2 estão na horizontal, vertical ou diagonal, usando diferentes pesos para cada jogada. Você deve ajustar os pesos de acordo com sua estratégia de jogo.

      3. Após calcular as heurísticas, encontre a célula com o menor valor de H na tabela de heurísticas e devolva as coordenadas (linha e coluna) dessa célula como a jogada a ser feita pelo jogador 2.

    Aqui está um exemplo de implementação de "jogada_astar":

    % Jogador 2 joga com o algoritmo A*
    jogador2_joga(Tabuleiro) :-
        versao(Versao),
        largura(Largura),
        altura(Altura),
    
        (Versao =:= 1) ->
        % Realiza uma jogada astar
        jogada_astar(Tabuleiro, Linha, Coluna),
        write('Jogador 2 escolheu coluna: '), write(Coluna), nl,
        write('Jogador 2 escolheu linha: '), write(Linha), nl,
    
        criar_tabuleiro(NovoTabuleiro),
        troca(NovoTabuleiro, Linha, Coluna, TabuleiroMod, 'O'),
        imprimir_tabuleiro(TabuleiroMod),
        jogador1_joga(TabuleiroMod)
        ;
        (Versao =:= 2) ->
        write('Versão nao implementada'), nl.
    
    % Função para realizar uma jogada usando A* busca
    jogada_astar(Tabuleiro, Linha, Coluna) :-
        inicializar_tabela_heuristica(Tabuleiro, TabelaHeuristica),
        calcular_heuristica_tabuleiro(Tabuleiro, TabelaHeuristica, NovaTabelaHeuristica),
        menor_valor_tabela_heuristica(NovaTabelaHeuristica, MenorValor, Linha, Coluna).
    
    % Implemente as funções: inicializar_tabela_heuristica, calcular_heuristica_tabuleiro e menor_valor_tabela_heuristica.
    

    Lembre-se de implementar e ajustar as funções "inicializar_tabela_heuristica", "calcular_heuristica_tabuleiro" e "menor_valor_tabela_heuristica" de acordo com a estratégia desejada para o jogador 2.