def pecado_inicial(self, celula):
movimento = celula.get_movimento()
penalidade = 0
num_pegar = movimento.count('p')
num_disparos = movimento.count('fn') + movimento.count(
'fs') + movimento.count('fl') + movimento.count('fo')
if num_pegar == 1:
penalidade += 32
if num_disparos <= 1:
penalidade += 32
fitness = fit(penalidade, 0, 0, 0)
return fitness.calcular_fitness(), penalidade
def pecado_inicial(self, celula):
movimento = celula.get_movimento()
penalidade = 0
num_pegar = movimento.count('p')
num_disparos = movimento.count('fn') + movimento.count('fs') + movimento.count('fl') + movimento.count('fo')
if num_pegar != 1 or num_disparos != 1:
penalidade = -1000 * (num_disparos + num_pegar)
if num_pegar == 1 and num_disparos == 1:
penalidade = 25
fitness = fit(penalidade, 0)
return fitness.calcular_fitness(), penalidade
def executar(self):
maximos = []
minimos = []
medias = []
mortes_poco = []
mortes_wumpus = []
sucessos = []
ambiente = Ambiente(self.__tamanho)
amb = ambiente.gerarAmbiente()
pop = Populacao(100, 0, self.__tamanho)
vet_ag = pop.gerar_populacao()
memoria = mem()
memoria.ordenar_memoria(vet_ag)
vet_mem = memoria.get_memoria()
for geracao in range(self.__ger):
vet_ag = self.reproduzir(vet_ag.copy(), geracao)
num_mortes_poco = 0
num_mortes_wumpus = 0
num_sucesso = 0
for ag in vet_ag:
if ag.get_movimento() == []:
ag.set_pontucao(2)
fitness = fit(ag.get_pontuacao(), 0, 0, 0, self.__tamanho) #<<<
ag.set_fitness(fitness.calcular_fitness())
ag.set_tamanho(random.randint(10, 64))
ag.set_movimento(ag.gerar_movimento())
for agente in vet_ag:
pos = [0, 0] # Define a posição inicial como [0, 0]
pos_ant = [0, 0] # Define a posição anterior como [0, 0]
rodada = 0 # Começa pela rodada 0
acao_ant = '' # Define a ação anterior como nula
caminho_ate_ouro = 0 # Define o caminho até o ouro como nulo
wumpus_vivo = True
agente.viver() # Revive o agente
agente.recarregar() # Recarrega a 'aljava'
agente.reset_nice_moves() # Define os movimentos bons como 0
agente.reset_caminho_percorrido() # Define o caminho percorrido como nulo
agente.reset_pontuacao() # Define a pontuação como 0
agente.reset_ouro() # Tira o ouro do agente
fitness, pontuacao = agente.pecado_inicial(agente) # Aplica as pontuações iniciais
agente.set_fitness(fitness) # Define o fitness inicial
agente.set_pontucao(pontuacao) # Define a pontuação inicial
agente.add_caminho_percorrido(list(pos)) # Adiciona [0, 0] ao caminho percorrido
mov_sem_ouro = 0
for acao in agente.get_movimento():
# Se o agente estiver com o ouro e tiver andado mais casas do que precisou para chegar até o ouro
if agente.get_ouro() and len(agente.get_caminho_percorrido()) > caminho_ate_ouro*2:
movimento_bom = False # Qualquer movimento será considerado ruim
else: # Caso contrário
movimento_bom = True # O movimento a seguir tem a possibilidade de ser bom
if agente.get_vida(): # Executa enquanto o agente estiver vivo
amb[pos_ant[0]][pos_ant[1]].isAgente(False) # Remove o agente da sua posição anterior
if acao == 'n': # Anda pro norte
pos[0] -= 1
elif acao == 's': # Anda pro sul
pos[0] += 1
elif acao == 'l': # Anda pro leste
pos[1] += 1
elif acao == 'o': # Anda pro oeste
pos[1] -= 1
# Se o agente andar para fora da matriz
if 0 > pos[0] or 3 < pos[0] or 0 > pos[1] or 3 < pos[1]:
agente.set_pontucao(0) # Recebe pontução nula
agente.morrer() # Morre
movimento_bom = False # O movimento é ruim
else: # Caso contrário
agente.add_caminho_percorrido(list(pos)) # A posição atual é adicionada à lista de casas
amb[pos[0]][pos[1]].isAgente(True) # A casa recebe o agente
# Se o agente quiser disparar e possuir flecha
if (acao == 'fn' or acao == 'fs' or acao == 'fl' or acao == 'fo') and agente.get_flecha():
agente.disparar() # Pode disparar
if acao == 'fn':
if ambiente.getWumpus() == [pos[0] - 1, pos[1]]:
wumpus_vivo = False
agente.set_pontucao(256)
else:
movimento_bom = False
agente.set_pontucao(2)
elif acao == 'fs':
if ambiente.getWumpus() == [pos[0] + 1, pos[1]]:
wumpus_vivo = False
agente.set_pontucao(256)
else:
movimento_bom = False
agente.set_pontucao(2)
elif acao == 'fl':
if ambiente.getWumpus() == [pos[0], pos[1] + 1]:
wumpus_vivo = False
agente.set_pontucao(256)
else:
movimento_bom = False
agente.set_pontucao(2)
elif acao == 'fo':
if ambiente.getWumpus() == [pos[0], pos[1] - 1]:
wumpus_vivo = False
agente.set_pontucao(256)
else:
movimento_bom = False
agente.set_pontucao(2)
elif(acao == 'fn' or acao == 'fs' or acao == 'fl' or acao == 'fo') and not agente.get_flecha():
movimento_bom = False # Pode disparar, porém o movimento é ruim
if pos == ambiente.getWumpus() and wumpus_vivo:
num_mortes_wumpus += 1
agente.morrer()
agente.set_pontucao(1)
movimento_bom = False
for casa in ambiente.getPoco():
if pos == casa: # Se a posição atual for igual à de um poço
num_mortes_poco += 1
agente.morrer() # O agente morre
agente.set_pontucao(2) # Recebe 2pts
movimento_bom = False # O movimento é considerado ruim
if acao == 'p': # Se a ação atual for "pegar"
# Se houver ouro na casa e a quantidade de pegar for == 1
if pos == ambiente.getOuro() and agente.get_movimento().count('p') == 1:
agente.pegar_ouro() # O agente pega o ouro
# É definido o tamanho do caminho até o ouro
caminho_ate_ouro = len(agente.get_caminho_percorrido())
else: # Caso contrário
agente.set_pontucao(1) # O agente recebe 1pt
movimento_bom = False # O movimento é considerado ruim
if not agente.get_ouro():
mov_sem_ouro += 1
if movimento_bom:
agente.set_nice_moves(rodada)
agente.set_pontucao(4)
else:
agente.set_bad_moves(rodada)
agente.set_pontucao(2)
acao_ant = acao
pos_ant = pos.copy()
rodada += 1
if agente.get_ouro() and agente.get_caminho_percorrido()[-1] == [0, 0]:
num_sucesso += 1
if len(agente.get_caminho_percorrido()) < self.__tamanho*5:
agente.set_pontucao(2048)
else:
agente.set_pontucao(1024)
elif agente.get_ouro() and agente.get_caminho_percorrido()[-1] != [0, 0]:
agente.set_pontucao(1)
if agente.get_flecha():
agente.set_pontucao(129)
fitness = fit(agente.get_pontuacao(), len(agente.get_nice_moves()), len(agente.get_bad_moves()), mov_sem_ouro, self.__tamanho) #<<<
agente.set_fitness(fitness.calcular_fitness())
memoria_temp = mem()
memoria_temp.ordenar_memoria(vet_ag.copy())
vet_memoria_temp = memoria_temp.get_memoria()
fitness_maximo = vet_memoria_temp[0].get_fitness()
maximos.append(fitness_maximo)
fitness_minimo = vet_memoria_temp[-1].get_fitness()
minimos.append(fitness_minimo)
total_fitness = 0
for celula in vet_memoria_temp:
total_fitness += celula.get_fitness()
media_fitness = total_fitness/len(vet_memoria_temp)
medias.append(media_fitness)
sucessos.append(num_sucesso)
mortes_poco.append(num_mortes_poco)
mortes_wumpus.append(num_mortes_wumpus)
for contador in range(len(vet_memoria_temp)):
ja_existe = False
for contador_b in range(len(vet_mem)):
if vet_memoria_temp[contador].get_id() == vet_mem[contador_b].get_id():
ja_existe = True
if not ja_existe:
if vet_memoria_temp[contador].get_fitness() > vet_mem[0].get_fitness():
vet_mem[-1] = vet_mem[0]
vet_mem[0] = vet_memoria_temp[contador]
memoria.ordenar_memoria(vet_mem.copy())
vet_mem = memoria.get_memoria()
elif vet_memoria_temp[contador].get_fitness() > vet_mem[-1].get_fitness():
vet_mem[-1] = vet_memoria_temp[contador]
memoria.ordenar_memoria(vet_mem.copy())
vet_mem = memoria.get_memoria()
vet_ag = list(vet_mem)
num_eliminados = int(len(vet_ag)*0.6)
for contador in range(num_eliminados):
vet_ag.pop(-1)
nova_pop = Populacao(num_eliminados, geracao, self.__tamanho)
vet_nova_pop = nova_pop.gerar_populacao()
vet_ag += list(vet_nova_pop)
vet_mem[0].imprimir_agente()
# print(f"Poços: {ambiente.getPoco()}\nOuro: {ambiente.getOuro()}\nWumpus: {ambiente.getWumpus()}")
# vet_mem[0].imprimir_agente()
dados = [maximos, minimos, medias, sucessos, mortes_wumpus, mortes_poco]
return dados, vet_mem[0]
def executar(self):
ambiente = Ambiente(self.__tamanho)
amb = ambiente.gerarAmbiente()
pop = Populacao(100, 0)
vet_ag = pop.gerar_populacao()
# for agente in vet_ag:
# indice = vet_ag.index(agente)
# id = '0_00_' + str(indice)
# agente.set_id(id)
memoria = mem()
memoria.ordenar_memoria(vet_ag)
vet_mem = memoria.get_memoria()
for geracao in range(self.__ger):
vet_ag = self.reproduzir(vet_ag.copy(), geracao)
for ag in vet_ag:
if ag.get_movimento() == []:
ag.set_pontucao(-10)
fitness = fit(ag.get_pontuacao(), 0)
ag.set_fitness(fitness.calcular_fitness())
ag.set_tamanho(random.randint(10, 64))
ag.set_movimento(ag.gerar_movimento())
for agente in vet_ag:
pos = [0, 0]
pos_ant = [0, 0]
rodada = 0
agente.viver()
agente.reset_nice_moves()
agente.reset_pontuacao()
fitness, pontuacao = agente.pecado_inicial(agente)
agente.set_fitness(fitness)
agente.set_pontucao(pontuacao)
acao_ant = ''
for acao in agente.get_movimento():
movimento_bom = True
if agente.get_vida():
amb[pos_ant[0]][pos_ant[1]].isAgente(False)
agente.add_caminho_percorrido(list(pos))
if acao == 'n':
pos[0] -= 1
elif acao == 's':
pos[0] += 1
elif acao == 'l':
pos[1] += 1
elif acao == 'o':
pos[1] -= 1
if 0 > pos[0] or 3 < pos[0] or 0 > pos[1] or 3 < pos[1]:
agente.set_pontucao(-300)
agente.morrer()
movimento_bom = False
else:
amb[pos[0]][pos[1]].isAgente(True)
if acao_ant == 'fn' and acao == 'n':
agente.set_pontucao(5)
elif acao_ant == 'fn' and acao != 'n':
agente.set_pontucao(-20)
movimento_bom = False
elif acao_ant == 'fs' and acao == 's':
agente.set_pontucao(5)
elif acao_ant == 'fs' and acao != 's':
agente.set_pontucao(-20)
movimento_bom = False
elif acao_ant == 'fl' and acao == 'l':
agente.set_pontucao(5)
elif acao_ant == 'fl' and acao != 'l':
agente.set_pontucao(-20)
movimento_bom = False
elif acao_ant == 'fo' and acao == 'o':
agente.set_pontucao(5)
elif acao_ant == 'fo' and acao != 'o':
agente.set_pontucao(-20)
movimento_bom = False
if movimento_bom:
agente.set_nice_moves(rodada)
agente.set_pontucao(5)
else:
agente.set_pontucao(-10)
acao_ant = acao
pos_ant = pos.copy()
rodada += 1
fitness = fit(agente.get_pontuacao(),
len(agente.get_nice_moves())) # FITNESS AQUI!!!
agente.set_fitness(fitness.calcular_fitness())
memoria_temp = mem()
memoria_temp.ordenar_memoria(vet_ag.copy())
vet_memoria_temp = memoria_temp.get_memoria()
for contador in range(len(vet_memoria_temp)):
ja_existe = False
for contador_b in range(len(vet_mem)):
if vet_memoria_temp[contador].get_id(
) == vet_mem[contador_b].get_id():
ja_existe = True
if not ja_existe:
if vet_memoria_temp[contador].get_fitness(
) > vet_mem[-1].get_fitness():
vet_mem[-1] = vet_memoria_temp[contador]
memoria.ordenar_memoria(vet_mem.copy())
vet_mem = memoria.get_memoria()
vet_ag = list(vet_mem)
num_eliminados = int(len(vet_ag) * 0.6)
for contador in range(num_eliminados):
vet_ag.pop(-1)
nova_pop = Populacao(num_eliminados, geracao)
vet_nova_pop = nova_pop.gerar_populacao()
vet_ag += list(vet_nova_pop)
escolhida = vet_mem[0]
print(
f"Id: {escolhida.get_id()} - Fitness: {escolhida.get_fitness()} - Pontuação: {escolhida.get_pontuacao()} - Movimento: {escolhida.get_movimento()}"
)