def jogar(self):
inicial = node(None, [[0, 0],
self.jogo.getEstadoDoJogo(),
self.jogo.getTorres(),
self.heuristica.getHeur(self.jogo.getTorres())])
self.pilhaDeDecisoes.insert(0, inicial)
self.caminhoDaVitoria.insert(0, inicial)
escolhido = self.pilhaDeDecisoes[0]
while (True):
if escolhido.pegarValor(3) == self.jogo.getEstadoObjetivo():
print("achamos a vitória")
return self.caminhoDaVitoria
self.criarFilhos(escolhido, escolhido.pegarValor(2))
filhos = escolhido.pegarFilhos()
filhos = [
x for x in filhos if x.pegarValor(3) not in
[n.pegarValor(3) for n in self.caminhoDaVitoria]
]
if len(filhos) == 0:
print("Solução não encontrada")
return self.caminhoDaVitoria
else:
escolhido = min(filhos, key=lambda x: x.pegarValor(4))
self.caminhoDaVitoria.append(escolhido)
def criarFilhos(self, pai: node, espaco_de_estado):
espacoGerado = None
torresDoEspaco = None
for i in range(1,4):
for j in range(1,4):
if(i != j):
if regras.avaliarJogada(self,i,j,espaco_de_estado):
espacoGerado = self.criarEspacoDeEstado([i,j],espaco_de_estado)
torresDoEspaco = self.criarTorresEmLista(espacoGerado)
pai.inserirFilho(node(pai,[[i,j],espacoGerado,torresDoEspaco]))
def criarFilhos(self, pai: node, espaco_de_estado):
espacoGerado = None
torresDoEspaco = None
if regras.avaliarJogada(self, 1, 2, espaco_de_estado):
espacoGerado = self.criarEspacoDeEstado([1, 2], espaco_de_estado)
torresDoEspaco = self.criarTorresEmLista(espacoGerado)
pai.inserirFilho(node(pai, [[1, 2], espacoGerado, torresDoEspaco]))
if regras.avaliarJogada(self, 1, 3, espaco_de_estado):
espacoGerado = self.criarEspacoDeEstado([1, 3], espaco_de_estado)
torresDoEspaco = self.criarTorresEmLista(espacoGerado)
pai.inserirFilho(node(pai, [[1, 3], espacoGerado, torresDoEspaco]))
if regras.avaliarJogada(self, 2, 1, espaco_de_estado):
espacoGerado = self.criarEspacoDeEstado([2, 1], espaco_de_estado)
torresDoEspaco = self.criarTorresEmLista(espacoGerado)
pai.inserirFilho(node(pai, [[2, 1], espacoGerado, torresDoEspaco]))
if regras.avaliarJogada(self, 2, 3, espaco_de_estado):
espacoGerado = self.criarEspacoDeEstado([2, 3], espaco_de_estado)
torresDoEspaco = self.criarTorresEmLista(espacoGerado)
pai.inserirFilho(node(pai, [[2, 3], espacoGerado, torresDoEspaco]))
if regras.avaliarJogada(self, 3, 1, espaco_de_estado):
espacoGerado = self.criarEspacoDeEstado([3, 1], espaco_de_estado)
torresDoEspaco = self.criarTorresEmLista(espacoGerado)
pai.inserirFilho(node(pai, [[3, 1], espacoGerado, torresDoEspaco]))
if regras.avaliarJogada(self, 3, 2, espaco_de_estado):
espacoGerado = self.criarEspacoDeEstado([3, 2], espaco_de_estado)
torresDoEspaco = self.criarTorresEmLista(espacoGerado)
pai.inserirFilho(node(pai, [[3, 2], espacoGerado, torresDoEspaco]))
def criarEspacosDeEstados(self, espaco_de_estado, dono_do_espaco: node):
novoEspaco = None
if regras.avaliarJogada(self, 1, 2, espaco_de_estado):
novoEspaco = self.criarEspacoDeEstado(espaco_de_estado, [1, 2])
dono_do_espaco.inserirFilho(
node(dono_do_espaco, [[1, 2], novoEspaco]))
if regras.avaliarJogada(self, 1, 3, espaco_de_estado):
novoEspaco = self.criarEspacoDeEstado(espaco_de_estado, [1, 3])
dono_do_espaco.inserirFilho(
node(dono_do_espaco, [[1, 3], novoEspaco]))
if regras.avaliarJogada(self, 2, 3, espaco_de_estado):
novoEspaco = self.criarEspacoDeEstado(espaco_de_estado, [2, 3])
dono_do_espaco.inserirFilho(
node(dono_do_espaco, [[2, 3], novoEspaco]))
if regras.avaliarJogada(self, 3, 1, espaco_de_estado):
novoEspaco = self.criarEspacoDeEstado(espaco_de_estado, [3, 1])
dono_do_espaco.inserirFilho(
node(dono_do_espaco, [[3, 1], novoEspaco]))
if regras.avaliarJogada(self, 3, 2, espaco_de_estado):
novoEspaco = self.criarEspacoDeEstado(espaco_de_estado, [3, 2])
dono_do_espaco.inserirFilho(
node(dono_do_espaco, [[3, 2], novoEspaco]))
if regras.avaliarJogada(self, 2, 1, espaco_de_estado):
novoEspaco = self.criarEspacoDeEstado(espaco_de_estado, [2, 1])
dono_do_espaco.inserirFilho(
node(dono_do_espaco, [[2, 1], novoEspaco]))
def jogar(self):
self.estado_atual = node(None, [[1, 1], self.jogo.getEstadoDoJogo()])
self.caminho_da_vitoria.append(self.estado_atual)
self.pilha_de_decisoes.append(self.estado_atual)
contador = 0
while (len(self.pilha_de_decisoes) != 0 and contador != 5):
print(
f"tamanho da pilha de decisões {len(self.pilha_de_decisoes)}")
contador += 1
print(contador)
origem = self.estado_atual.pegarValor()[0][0]
destino = self.estado_atual.pegarValor()[0][1]
self.jogo.jogada(origem, destino)
if self.jogo.condicaoVitoria():
return self.caminho_da_vitoria
self.criarEspacosDeEstados(self.estado_atual.pegarValor()[1],
self.estado_atual)
filhos = self.estado_atual.pegarFilhos()
if any([
self.estado_atual.quantidadeDeFilhos() == 0,
self.verificarSeExiste(filhos, self.bbs),
self.verificarSeExiste(filhos, self.caminho_da_vitoria),
self.verificarSeExiste(filhos, self.pilha_de_decisoes)
]):
print("entrou aqui")
while (len(self.caminho_da_vitoria) != 0
and self.estado_atual == self.caminho_da_vitoria[0]):
self.jogo.jogada(
list(reversed(self.estado_atual.pegarValor()[0])))
self.bbs.append(self.estado_atual)
self.caminho_da_vitoria.pop(0)
self.pilha_de_decisoes.pop(0)
self.estado_atual = self.pilha_de_decisoes[0]
self.caminho_da_vitoria.append(self.estado_atual)
else:
bbs = [[x[0].getTorre(), x[1].getTorre(), x[2].getTorre()]
for x in [n.pegarValor()[1] for n in self.bbs]]
caminhoDaVitoria = [
[x[0].getTorre(), x[1].getTorre(), x[2].getTorre()] for x
in [n.pegarValor()[1] for n in self.caminho_da_vitoria]
]
pilhaDeDecisao = [[
x[0].getTorre(), x[1].getTorre(), x[2].getTorre()
] for x in [n.pegarValor()[1] for n in self.pilha_de_decisoes]]
for filho in range(len(filhos)):
torres = [
n.getTorre() for n in filhos[filho].pegarValor()[1]
]
if all([
not torres in bbs, not torres in pilhaDeDecisao,
not torres in caminhoDaVitoria
]):
self.pilha_de_decisoes.insert(0, filhos[filho])
pilhaDeDecisao.insert(0, torres)
self.estado_atual = self.pilha_de_decisoes[0]
return False
def jogar(self):
inicial = node(None, [[0, 0],
self.jogo.getEstadoDoJogo(),
self.jogo.getTorres()]) #
self.estado_atual = inicial #
self.caminho_da_vitoria.insert(0, inicial) #
self.pilha_de_decisoes.insert(0, inicial) #
while (len(self.pilha_de_decisoes) != 0):
if self.estado_atual.pegarValor(
3) == self.jogo.getEstadoObjetivo(): #
print("achamos a vitória")
return self.caminho_da_vitoria
self.criarFilhos(self.estado_atual,
self.estado_atual.pegarValor(2)) #
filhos = self.estado_atual.pegarFilhos()
if any([
self.estado_atual.quantidadeDeFilhos == 0,
self.verificarEspacosDeEstadosNaLista(
filhos, self.caminho_da_vitoria),
self.verificarEspacosDeEstadosNaLista(
filhos, self.pilha_de_decisoes)
]):
while (all([
len(self.caminho_da_vitoria) != 0,
self.estado_atual == self.caminho_da_vitoria[0]
])):
self.caminho_da_vitoria.pop(0).pegarValor(3)
self.pilha_de_decisoes.pop(0)
self.estado_atual = self.pilha_de_decisoes[0]
self.caminho_da_vitoria.insert(0, self.estado_atual)
else:
pilhaDeDecisao = [
espaco.pegarValor(3) for espaco in self.pilha_de_decisoes
]
caminhoDaVitoria = [
espaco.pegarValor(3) for espaco in self.caminho_da_vitoria
]
for filho in range(len(filhos)):
if all([
not filhos[filho].pegarValor(3) in pilhaDeDecisao,
not filhos[filho].pegarValor(3) in caminhoDaVitoria
]):
self.pilha_de_decisoes.insert(0, filhos[filho])
self.estado_atual = self.pilha_de_decisoes[0] #
self.caminho_da_vitoria.insert(0, self.estado_atual) #
return False
def __init__(self, jogo):
self.jogo = jogo
self.inicial = node(None,[[0,0],self.jogo.getEstadoDoJogo(), self.jogo.getTorres()])
self.abertos = [self.inicial] #:list[node]
self.fechados = [] #:list