def acoes(self, estado):
""" supondo q estado já é uma tupla de valores """
from acoes import AcaoJogador
todas_acoes = []
cima, baixo, esquerda, direita = "cima", "baixo", "esquerda", "direita"
todas_acoes.extend([AcaoJogador.puxar(cima), AcaoJogador.puxar(baixo), AcaoJogador.puxar(esquerda), AcaoJogador.puxar(direita)])
return todas_acoes
def escolherProximaAcao(self):
jogada = None
while not jogada:
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
return AcaoJogador.dirigirNave(
DirecaoMoverNave.MOVER_PARA_ESQUERDA)
jogada = "jogou"
if event.key == pygame.K_RIGHT:
return AcaoJogador.dirigirNave(
DirecaoMoverNave.MOVER_PARA_DIREITA)
jogada = "jogou"
if event.key == pygame.K_SPACE:
return AcaoJogador.dirigirNave(DirecaoMoverNave.ATIRAR)
jogada = "jogou"
def escolherProximaAcao(self):
if not self.resolvido:
self.caminho = self.buscaGulosa(self.borda, self.tabuleiro, self.percorridos, self.caminho)
acao = AcaoJogador.mover(self.caminho[0][3][0], self.caminho[0][3][1])
self.caminho.pop(0)
return acao
def escolherProximaAcao(self):
acao = self.no_solucao.pop(0)
x, y, v = int(acao[0]), int(acao[1]), int(acao[2])
print(
f"\n A proxima acao sera em X: {x} Y: {y} colocando o valor {v} \n"
)
time.sleep(1)
return AcaoJogador.adicionar_valor(x, y, v)
def escolherProximaAcao(self):
#Verifica se o jogo ja foi resolvido
if not self.resolvido:
self.caminho = self.buscaBfs(self.borda, self.tabuleiro, self.percorridos, self.caminho)
acao = AcaoJogador.mover(self.caminho[0][3][0], self.caminho[0][3][1])
self.caminho.pop(0)
return acao
def escolherProximaAcao(self):
self.borda.insert(0, [self.tabuleiro, 0])
altura = 0
#Verifica se o jogo ja foi resolvido
if self.resolvido is False:
#Percorre todos estados da borda até encontrar o estado final
while len(self.borda) > 0:
#Verifica se a altura do estado aberto está dentro do padrão exigido
if self.borda[0][1] <= int(self.profundidade):
altura = self.borda[0][1]
estado_temp = self.borda.pop(0)[0]
else:
self.borda.pop(0)
altura = self.borda[0][1]
estado_temp = self.borda.pop(0)[0]
self.percorridos.append(estado_temp)
if self.isFim(estado_temp) == True:
self.resolvido = True
print('Resolvi o puzzle!')
print('Tentativas: ', len(self.jogadas))
self.tabuleiro.pop(3)
#Após encontrar o resultado, encontra o caminho até o final desejado
# e os adiciona na variável caminho
while self.caminho[0][:3] != self.tabuleiro:
ult_percorrido = self.percorridos[-1]
if self.isFim([ult_percorrido[0], ult_percorrido[1], ult_percorrido[2]]) == True:
self.caminho.insert(0,ult_percorrido[3])
else:
for percorrido in self.percorridos:
if percorrido[:3] == self.caminho[0][:3]:
if percorrido[:3] is not self.caminho: self.caminho.insert(0, percorrido[3])
self.percorridos.pop(-1)
break
#Se não for o estado final, gera os estados filhos e os adiciona ao início borda
else:
filhos = [
self.gerarEstados(opcao, estado_temp, False) for opcao in self.validarOpcoes(estado_temp)
]
for filho in filhos:
ja_percorrido = False
for percorrido in self.percorridos:
if filho[:3] == percorrido[:3]: ja_percorrido = True
if ja_percorrido == False:
self.borda.insert(0, [filho, altura])
altura = altura + 1
acao = AcaoJogador.mover(self.caminho[0][3][0], self.caminho[0][3][1])
self.caminho.pop(0)
return acao
def acoes(self, estado):
"""
Por simplificação, estado já é uma tupla de valores, mas não é bonito.
"""
from acoes import AcaoJogador
#lista = []
#aux = ""
#return [ AcaoJogador.permutar(str(i))
# for i,_ in enumerate(estado)
# for j,_ in enumerate(estado) ]
return [
AcaoJogador.permutar('C'),
AcaoJogador.permutar('B'),
AcaoJogador.permutar('E'),
AcaoJogador.permutar('D')
]
def escolherProximaAcao(self):
jogada = None
while not jogada:
jogada = input("Escreva a direção (d|e|c|b): ").strip()
try:
d = AgentePrepostoESHumano.parse_jogada(jogada)
except ValueError:
jogada = None
print("Jogada entrada é inválida. Tente novamente.")
return AcaoJogador.MOVER_JOGADOR(d)
def escolherProximaAcao(self):
jogada = None
while not jogada:
jogada = input(
"\nDigite a direção que deseja mover (e,d,c,b): ").strip()
try:
direcao = AgentePrepostoESHumano.parse_jogada(jogada)
except ValueError:
jogada = None
print("Jogada inválida.")
return AcaoJogador.mover(direcao)
def escolherProximaAcao(self):
if not self.sol:
no_sol = busca_arvore(self.problema, self.tipo_agente)
self.sol = no_sol.caminho_acoes()
if not self.sol:
raise Exception(
f'Agente {self.tipo_agente.value} não encontrou solução.')
acao = self.sol.pop(0)
print(f'\nPróxima ação é mover para "{acao.direcao}".')
time.sleep(1)
direcao = AgenteAut.traduzir_acao_jogo(acao)
return AcaoJogador.mover(direcao)
def escolherProximaAcao(self):
# Pede a proxima ação pro jogador
from acoes import AcaoJogador
valido = False
while valido == False:
direcao = input(
"Puxar peça de qual direção (cima, baixo, esquerda, direita)? "
)
if ((direcao == "cima") or (direcao == "baixo")
or (direcao == "esquerda") or (direcao == "direita")):
valido = True
return AcaoJogador.puxar(direcao)
else:
print('Input inválido! Tente novamente.')
def escolherProximaAcao(self):
time.sleep(1)
temp_acao = self.jogadas.pop(0)
jogadas = []
if temp_acao == AcoesJogador.CIMA:
jogadas.append(AcoesJogador.CIMA)
elif temp_acao == AcoesJogador.ESQUERDA:
jogadas.append(AcoesJogador.ESQUERDA)
elif temp_acao == AcoesJogador.DIREITA:
jogadas.append(AcoesJogador.DIREITA)
elif temp_acao == AcoesJogador.BAIXO:
jogadas.append(AcoesJogador.BAIXO)
acao = AcaoJogador("BFS", jogadas)
return acao
def escolherProximaAcao(self):
if not self.solucao:
no_solucao = busca_arvore_dfs(self.problema)
print(f'1')
self.solucao = no_solucao.caminho_acoes()
print(f'2')
print(len(self.solucao), self.solucao)
if not self.solucao:
raise Exception("Agente BFS não encontrou solução.")
acao = self.solucao.pop(0)
print(f'Próxima ação é {acao}.')
time.sleep(2)
p1, p2 = AgenteAutomaticoDfs.parse_jogada(acao)
return AcaoJogador.SelecionarIndividuo(p1, p2)
def escolherProximaAcao(self):
if not self.solucao:
no_solucao = busca_arvore_bfs(self.problema, self.count)
print(f'busca_arvore_bfs = {busca_arvore_bfs}')
self.solucao = no_solucao.caminho_acoes()
#print(f'jfsdnflksn 2')
#print(f'alooooo kk{len(self.solucao), self.solucao}')
if not self.solucao:
raise Exception("Agente BFS não encontrou solução.")
acao = self.solucao.pop(0)
print(f'Próxima ação é {acao}.')
time.sleep(2)
p1, p2 = AgenteAutomaticoBfs.parse_jogada(acao)
return AcaoJogador.SelecionarIndividuo(p1, p2)
def escolherProximaAcao(self):
jogada = None
while not jogada:
jogada = input(
'Escreva sua jogada no formato [Pessoa1,Pessoa2] ou [Pessoa1]\n'
).strip()
if len(jogada) == 3:
p1, p2 = AgentePrepostoESHumano.parse_jogada(jogada)
elif len(jogada) < 3:
p1 = AgentePrepostoESHumano.parse_jogada(jogada)
p2 = 0
else:
jogada = None
print('Jogada entrada é inválida. Tente novamente.')
return AcaoJogador.SelecionarIndividuo(p1, p2)
def escolherProximaAcao(self, ind: int):
posicao = np.where(self.tabuleiro == 4)
coordenadas = list(zip(posicao[0], posicao[1]))
self.solucao = busca_heuristica.fila_de_acoes(busca_heuristica,
coordenadas[0],
self.lista[ind])
acao = self.solucao[0]
direcoes = AgenteAStar.traduzir_acao_jogo(acao[0])
print('Direção')
print(direcoes)
print('Custo')
print(acao[1] + acao[2])
print(' ')
print(' ')
return AcaoJogador.MOVER_JOGADOR(direcoes)
def escolherProximaAcao(self):
jogadas = []
turno = True
while turno:
tecla = input()
if tecla == "8":
jogadas.append(AcoesJogador.CIMA)
turno = False
elif tecla == "4":
jogadas.append(AcoesJogador.ESQUERDA)
turno = False
elif tecla == "6":
jogadas.append(AcoesJogador.DIREITA)
turno = False
elif tecla == "2":
jogadas.append(AcoesJogador.BAIXO)
turno = False
acao = AcaoJogador("Humano", jogadas)
return acao
def escolherProximaAcao(self,ind:int):
if not self.solucao:
no_solucao = busca_arvore_bfs(self.problema)
self.solucao = no_solucao.caminho_acoes()
print(len(self.solucao), self.solucao)
if not self.solucao:
raise Exception("Agente BFS não encontrou solução.")
acao = self.solucao.pop(0)
print(f"Próxima ação é {acao}.")
time.sleep(2)
direcoes= AgenteAutomaticoBfs.traduzir_acao_jogo(acao)
if self.solucao:
acao = self.solucao[ind]
direcoes=AgenteAutomaticoBfs.traduzir_acao_jogo(acao)
return AcaoJogador.MOVER_JOGADOR(direcoes)
def escolherProximaAcao(self):
print("digite a cordenada que deseja motificar")
print("cordenada x")
try:
x = int(input())
if (x > 8):
print("comando invalido")
else:
print("cordenada y")
y = int(input())
if (y > 8):
print("comando invalido")
else:
print("valor que deseja adicionar")
valor = int(input())
if (valor > 9):
print("valor invalido")
else:
return AcaoJogador.adicionar_valor(x, y, valor)
except:
print("Comando invalido")
def escolherProximaAcao(self, ind: int):
if not self.solucao:
no_solucao = fila_de_prioridades(self.problema)
self.solucao = no_solucao.caminho_acoes
"chamar a busca e o proxima ação estaria correto no gulosa ?"
(busca_heuristica.escolherProximaAcao)
print(len(self.solucao), self.solucao)
if not self.solucao:
raise Exception("Agente Guloso não encontrou solução.")
acao = self.solucao.pop(0)
print(f"Próxima ação é {acao}.")
time.sleep(2)
direcoes = AgenteBuscaGulosa.traduzir_acao_jogo(acao)
if self.solucao:
acao = self.solucao[ind]
direcoes = AgenteBuscaGulosa.traduzir_acao_jogo(acao)
return AcaoJogador.MOVER_JOGADOR(direcoes)
def escolherProximaAcao(self):
from acoes import AcaoJogador
i, j = (int(s) for s in input("Proxima troca (i,j)? ").split(',', 2))
return AcaoJogador.permutar(i, j)
def regras():
from acoes import AcaoJogador
global bateNum
global fimJogo
global valor
global matriz
global cordenadaLinha
global cordenadaColuna
global listaVlrCorreto
global conflitoQuad
global posicaoConflito
global listaNaoPodeMudar
bAux = False
cordenadas = False
while True:
#cordenadaLinha = input("Qual a cordenada de linha? ")
#if int(cordenadaLinha) in listaVlrCorreto:
# cordenadaColuna = input("Qual a cordenada de coluna? ")
# if int(cordenadaColuna) in listaVlrCorreto:
# valor = input("Qual o valor que deseja colocar? ")
#
# if int(valor) in listaVlrCorreto:
# cordenadas = True
# else:
# print("Valor invalido!")
# cordenadas = False
# else:
# print("Cordenada da Coluna invalida.")
# cordenadas = False
#else:
# print("Cordenada da Linha invalida")
# cordenadas = False
acaoAtual = [AcaoJogador.inserir(matriz)]
cordenadaLinha = acaoAtual[0][1][0]
cordenadaColuna = acaoAtual[0][1][1]
valor = acaoAtual[0][1][2]
cordenadas = True
print('teste -> ' + str(acaoAtual))
#print('Lista que não pode mudar -> '+str(listaNaoPodeMudar))
#print('linha -> '+str(cordenadaLinha))
verificaConflito()
verificaQuadrante()
if not bConflito:
#verificaConflito()
if not bNaoPodeAlterar:
#verificaQuadrante()
matriz[int(cordenadaLinha) - 1][int(cordenadaColuna) -
1] = valor
aux = 0
bAuxiliar = False
while aux < len(posicaoConflito):
if matriz[int(posicaoConflito[aux][0])][int(
posicaoConflito[aux][1])] != matriz[int(
posicaoConflito[aux + 1][0])][int(
posicaoConflito[aux + 1][1])]:
del (posicaoConflito[aux])
del (posicaoConflito[aux])
bAuxiliar = True
if bAuxiliar:
aux = 0
bAuxiliar = False
else:
aux = aux + 2
if ((not bateNum) and (not conflitoQuad)):
fimJogo = False
for i in range(len(matriz)):
for j in range(len(matriz[i])):
if matriz[i][j] == ' ':
fimJogo = False
break
else:
fimJogo = True
if len(posicaoConflito) > 0:
fimJogo = False
desenhaQuadrado()
conflitoQuad = False
if fimJogo:
break
print('Parabéns, você ganhou o jogo!')
def escolherProximaAcao(self):
from acoes import AcaoJogador
escolhido = input("Proxima ação (C - cima, B - baixo, D - direita, E -esquerda)? ")
return AcaoJogador.permutar(escolhido)
def escolherProximaAcao(self):
from acoes import AcaoJogador
# try:
i, j = (int(s) for s in input(
"Qual peça deseja mover (linhas, coluna)? ").split(',', 2))
return AcaoJogador.mover(i, j)