def __init__(self):
self.memoria = Mapa()
self.posicaoAtual = [0,0]
self.posicaoSupostaOuro = []
self.supostaPosicaoPocos = []
self.sensacoes = []
def aco(max_it, alpha, beta, rho, N, e, q, tal, b, localizacoes):
#inicializando elementos.
mapa = Mapa(e, tal, localizacoes, alpha, beta, rho, q)
formigas = np.full(e, Formiga())
iteracao = 0
while iteracao < max_it:
##localizando a melhor rota.
# Para cada numero de formigas é construido uma rota aplicando o seguinte passo.
for formiga in formigas:
for i in enumerate(range(e - 1)):
proximaCidade = mapa.calculaProbabilidades(
formiga.cidadesNVisitadas, formiga.cidadeAtual)
formiga.adicionaRota(proximaCidade, mapa)
# Avalia o tamanho da rota construída por cada formiga, se uma rota mais curta for encontrada a
# melhor rota será atualizada.
for formiga in formigas:
if formiga.tamanhoRota < lmenor:
lmenor = formiga.tamanhoRota
melhor = formiga.rota
#Atualiza os feromonios nas rotas que as formigas passaram.
for formiga in formigas:
mapa.atualizaFeromonios(formiga.rota)
iteracao += iteracao
return melhor, lmenor
def BotonCrear(self):
mapa = Mapa(self.current_mapa)
mapa.crearMapa()
xml = XMLGenerator()
xml.tiempo = int(self.temLinea3)
xml.setMapa(mapa)
xml.generarXMLGame()
self.cambiarVentana()
def reconstruirGame(self,nick):
#agregar players al game
treeP = ET()
treeP.parse(self.playersFile + ".xml")
root = treeP.getroot()
self.game = Game(len(root.findall("team/player")),0,len(root.findall('team')))
for team in root.iter("team"):
color = team.attrib["color"]
for tagPlayer in team.iter("player"):
nombre = tagPlayer.attrib["nombre"]
x = int(tagPlayer.attrib["iniX"])
y = int(tagPlayer.attrib["iniY"])
vidas = int(tagPlayer.attrib["vidas"])
if nombre == nick:
player = Player(nombre, vidas, x, y, tagPlayer.text)
else:
player = PlayerSemiAutomatico(nombre, vidas, x, y, tagPlayer.text)
player.setTeam(color)
self.game.AgregarPlayer(player)
#-------------------------------------------------------------
treeM = ET()
treeM.parse(self.mapaFile+".xml") #revisar donde se generara el XML
root = treeM.getroot()
config = root.find("config")
mapa = Mapa("currentGame")
self.game.tiempo = int(config.attrib["tiempo"])
mapa.setFondo(config.attrib["BG"])
mapa.setMusica(config.attrib["BGSound"])
mapa.stage = config.attrib["stage"]
print "STAGE!!!!: " + mapa.stage
tablero = root.find("tablero")
cuadros = tablero.find("cuadros")
for cuadro in cuadros.iter("cuadro"):
fila = int(cuadro.attrib["fila"])
col = int(cuadro.attrib["columna"])
dest = cuadro.attrib["tipo"]
bloque = Bloque(fila, col, dest=="D")
bloque.setSpriteB(cuadro.text)
bloque.setPowerUp(cuadro.attrib["tipoPower"], cuadro.attrib["powerup"])
bloque.tienePowerUp = not(cuadro.attrib["powerup"] == "__EMPTY__")
if mapa.stage == "STAGE3_4":
bloque.autoDisappear = False
bloque.destruir()
if not mapa.bloques.has_key(fila):
mapa.bloques[fila] = dict()
mapa.bloques[fila][col] = bloque
self.game.mapa = mapa
GameOverLogic.game = self.game
return self.game
def carregaMapas(self):
self.listaMapas = []
#para cada um dos mapas informados cria-se um novo objeto e adciona a uma lista
#print("Carregando Mapas")
for i in range(self.dados.DIRETORIO_MAPAS.__len__()):
newMapa = Mapa(i, self.dados.DIRETORIO_MAPAS[i],
self.dados.DIRETORIO_MAPAS_FOGO[i],
self.dados.DIRETORIO_MAPAS_VENTO[i],
self.filtraTeleportes(i), self.dados)
self.listaMapas.append(newMapa)
if self.dados.FLAG_ATIVACAO_FOGO:
self.listaFogo.append([])
self.objetivo = objetivo
self.fronteira = Pilha(20)
self.fronteira.empilhar(inicio)
self.achou = False
def buscar(self):
topo = self.fronteira.getTopo()
print('Topo: {}'.format(topo.nome))
if topo == self.objetivo:
self.achou = True
else:
'''For para percorrer todos os vertices do topo'''
for a in topo.adjacentes:
if self.achou == False:
print('Verificando se já visitado: {}'.format(
a.cidade.nome))
if a.cidade.visitado == False:
a.cidade.visitado = True
self.fronteira.empilhar(a.cidade)
Profundidade.buscar(self)
print('Desempilhou: {}'.format(self.fronteira.desempilhar().nome))
from Mapa import Mapa
mapa = Mapa()
profundidade = Profundidade(mapa.portoUniao, mapa.curitiba)
profundidade.buscar()
from Mapa import Mapa
from VetorOrdenado import VetorOrdenado
class Gulosa:
def __init__(self, objetivo):
self.objetivo = objetivo
self.achou = False
def buscar(self, atual):
print('\nAtual->{}'.format(atual.nome))
atual.visitado = True
if (atual == self.objetivo):
self.achou = True
else:
self.fronteira = VetorOrdenado(len(atual.adjacentes))
for a in atual.adjacentes:
if a.cidade.visitado == False:
a.cidade.visitado = True
self.fronteira.inserir(a.cidade)
self.fronteira.mostrar()
if (self.fronteira.getPrimeiro() != None):
Gulosa.buscar(self, self.fronteira.getPrimeiro())
map = Mapa()
gulosa = Gulosa(map.curitiba)
gulosa.buscar(map.portoUniao)
if player.team == team:
tagPlayer = Element("player")
tagPlayer.set("nombre", player.nombre)
tagPlayer.set("iniX", str(player.iniX))
tagPlayer.set("iniY", str(player.iniY))
tagPlayer.set("vidas", str(player.vidas))
tagPlayer.text = player.getSpriteFullName()
tagTeam.append(tagPlayer)
rootP.append(tagTeam)
treeP = ElementTree()
treeP._setroot(rootP)
treeP.write("playersInfo.xml","utf-8")
if __name__ == "__main__":
mapa = Mapa("STAGE1_4")
mapa.crearMapa()
maker = XMLGenerator()
maker.setMapa(mapa)
maker.setDimensiones(10,10)
maker.generarXMLGame()
player1 = Player('kike',2,1,0,"sprite1")
player1.setTeam("purple")
player2 = Player('varus',3,1,0,"sprite4")
player2.setTeam("blue")
player3 = Player('hector',2,1,0,"sprite3")
player3.setTeam("blue")
player4 = Player('elkin',2,1,0,"sprite1")
player4.setTeam("purple")
maker.setPlayers([player1, player2, player3, player4])
maker.setTeams(['purple','blue'])
def __init__(self):
self.mapa = Mapa()
self.l = []
def adicionaRota(self, cidade, mapa):
self.rota = np.append(cidade)
self.removeCidade(cidade)
self.cidadeAtual = cidade
self.tamanhoRota = Mapa.calculaTamanhoRota(mapa, rota=self.rota)
return
def __init__(self, size, req_points):
self.counter = 0
self.mapa = Mapa(size) # ustawienie wielkości mapy
self.req_points = req_points
self.city_population = {}
class Simulation:
def __init__(self, size, req_points):
self.counter = 0
self.mapa = Mapa(size) # ustawienie wielkości mapy
self.req_points = req_points
self.city_population = {}
@staticmethod
def scan_map(fraction, mapa):
"""funkcja sprawdzająca czy cała mapa nie jest zajęta przez 1 frakcję"""
a = []
for y in range(1, mapa.size + 1): #dodaje do listy liczbę 1 gdy jest na mapie budynek danej frakcji
for x in range(1, mapa.size + 1):
if mapa.ground_objects[x, y].symbol.__contains__(fraction.symbol):
a.append(1)
else:
a.append(0)
b = []
for i in range(a.__len__()): #lista przypadku gdy cała mapa byłaby zajęta przez frakcję
b.append(1)
if a == b: #przyrównanie list
print("Wygrała frakcja {}{}!".format("z symbolem: ", fraction.symbol))
exit() #koniec
@classmethod
def check_win(cls, a, b ,c ,d, mapa, points):
"""sprawdzenie czy frakcja nie przekroczyła punktów rozwoju"""
if a != None: #sprawdzenie czy frakcja istnieje, potem sprawdza zwycięstwo
cls.scan_map(b, mapa)
if a.points >= points:
name = a.symbol
win = "Wygrala frakcja {}{}!".format("z symbolem: ", name)
print(win)
with open("sim_save.txt",mode='a', encoding='UTF8') as save_file: # zapisz do pliku wszystkich danych potrzebnych do odtworzenia symulacji
save_simulation = csv.writer(save_file, quotechar='"', quoting=csv.QUOTE_MINIMAL)
save_simulation.writerow([win])
exit()
if b != None:
cls.scan_map(b, mapa)
if b.points >= points:
name = b.symbol
win = "Wygrala frakcja {}{}!".format("z symbolem: ", name)
print(win)
with open("sim_save.txt", mode='a', encoding='UTF8') as save_file: # zapisz do pliku wszystkich danych potrzebnych do odtworzenia symulacji
save_simulation = csv.writer(save_file, quotechar='"', quoting=csv.QUOTE_MINIMAL)
save_simulation.writerow([win])
exit()
if c != None:
cls.scan_map(b, mapa)
if c.points >= points:
name = c.symbol
win = "Wygrala frakcja {}{}!".format("z symbolem: ", name)
print(win)
with open("sim_save.txt", mode='a', encoding='UTF8') as save_file: # zapisz do pliku wszystkich danych potrzebnych do odtworzenia symulacji
save_simulation = csv.writer(save_file, quotechar='"', quoting=csv.QUOTE_MINIMAL)
save_simulation.writerow([win])
exit()
if d != None:
cls.scan_map(b, mapa)
if d.points >= points:
name = d.symbol
win = "Wygrala frakcja {}{}!".format("z symbolem: ", name)
print(win)
with open("sim_save.txt",mode='a', encoding='UTF8') as save_file: # zapisz do pliku wszystkich danych potrzebnych do odtworzenia symulacji
save_simulation = csv.writer(save_file, quotechar='"', quoting=csv.QUOTE_MINIMAL)
save_simulation.writerow([win])
exit()
@staticmethod
def check_pos(a, object):
"""Metoda sprawdzająca pozycje wszystkich miast danej frakcji"""
position = object.check_city(a) # zebranie współrzędnych miast danej frakcji do 1 zmiennej
x = [] # puste listy do ktorych będą wrzucane współrzędne
y = []
for i in range(position.__len__()): # pętla budująca miasta, farmy i kopalnie
for j in range(2):
if j == 0:
x.append(position[i][j]) # dodanie współrzędnych do listy
if j == 1:
y.append(position[i][j])
return x, y #zwrócenie współrzędnych
@staticmethod
def check_mine(a, object):
"""Metoda sprawdzająca pozycje wszystkich kopalni danej frakcji"""
position = object.check_mine(a)
for i in range(position.__len__()): # pętla zbierająca surowce z każdej kopalni
for j in range(2):
if j == 0:
x = position[i][j]
if j == 1:
y = position[i][j]
object.collect_resources(a, x, y)
@staticmethod
def check_farm(a, object):
""" Metoda sprawdzająca pozycje wszystkich farm danej frakcji"""
position = object.check_farm(a) # zebranie współrzędnych wszystkich farm danej frakcji do 1 zmiennej
for i in range(position.__len__()): # pętla zbierająca jedzenie z każdej farmy
for j in range(2):
if j == 0:
x = position[i][j]
if j == 1:
y = position[i][j]
object.collect_food(a, x, y) # zbiór
def start(self):
"""Rozpoczyna symulacje"""
while self.counter < 99:
if self.counter == 0: #czynność startowa
self.mapa.draw() #narysowanie mapy
self.mapa.show() #pokazanie mapy
time.sleep(0.25)
self.mapa.build_city(self.mapa.fraction1, self.mapa.fraction1.x, self.mapa.fraction1.y, None) #budowa początkowa miasta kopalni i farmy
self.mapa.build_mine(self.mapa.fraction1, self.mapa.fraction1.x, self.mapa.fraction1.y)
self.mapa.build_farm(self.mapa.fraction1, self.mapa.fraction1.x, self.mapa.fraction1.y)
self.mapa.build_city(self.mapa.fraction2, self.mapa.fraction2.x, self.mapa.fraction2.y, None)
self.mapa.build_mine(self.mapa.fraction2, self.mapa.fraction2.x, self.mapa.fraction2.y)
self.mapa.build_farm(self.mapa.fraction2, self.mapa.fraction2.x, self.mapa.fraction2.y)
self.mapa.build_city(self.mapa.fraction3, self.mapa.fraction3.x, self.mapa.fraction3.y, None) # budowa początkowa miasta kopalni i farmy
self.mapa.build_mine(self.mapa.fraction3, self.mapa.fraction3.x, self.mapa.fraction3.y)
self.mapa.build_farm(self.mapa.fraction3, self.mapa.fraction3.x, self.mapa.fraction3.y)
self.mapa.build_city(self.mapa.fraction4, self.mapa.fraction4.x, self.mapa.fraction4.y, None) # budowa początkowa miasta kopalni i farmy
self.mapa.build_mine(self.mapa.fraction4, self.mapa.fraction4.x, self.mapa.fraction4.y)
self.mapa.build_farm(self.mapa.fraction4, self.mapa.fraction4.x, self.mapa.fraction4.y)
self.mapa.show() #pokazanie mapy po budowie
time.sleep(0.25)
x, y = Simulation.check_pos(self.mapa.fraction1, self.mapa) #wywołanie funkcji zwracającej współrzędne
while x.__len__() != 0:
a = random.randint(0, x.__len__()-1) #wylosowanie z listy losowych współrzędnych
if self.city_population.__contains__((x[a], y[a])) == False:
p = self.mapa.consume(self.mapa.fraction1, x[a], y[a], 10)
self.city_population.update({(x[a], y[a]): p})
elif self.city_population.__contains__((x[a], y[a])) == True:
p = self.mapa.consume(self.mapa.fraction1, x[a], y[a], self.city_population[(x[a], y[a])])
self.city_population.update({(x[a], y[a]): p})
self.mapa.auto_build(x[a], y[a], self.mapa.fraction1, None) #losowe tworzenie budynków
x.remove(x[a])
y.remove(y[a])
x, y = Simulation.check_pos(self.mapa.fraction2, self.mapa) #wywołanie funkcji zwracającej współrzędne
while (x.__len__() != 0):
a = random.randint(0, x.__len__() - 1) # wylosowanie z listy losowych współrzędnych
if self.city_population.__contains__((x[a], y[a])) == False:
p = self.mapa.consume(self.mapa.fraction2, x[a], y[a], 10)
self.city_population.update({(x[a], y[a]): p})
elif self.city_population.__contains__((x[a], y[a])) == True:
p = self.mapa.consume(self.mapa.fraction2, x[a], y[a], self.city_population[(x[a], y[a])])
self.city_population.update({(x[a], y[a]): p})
self.mapa.auto_build(x[a], y[a], self.mapa.fraction2, None) # losowe tworzenie budynków
x.remove(x[a])
y.remove(y[a])
x, y = Simulation.check_pos(self.mapa.fraction3, self.mapa) # wywołanie funkcji zwracającej współrzędne
while (x.__len__() != 0):
a = random.randint(0, x.__len__() - 1) # wylosowanie z listy losowych współrzędnych
if self.city_population.__contains__((x[a], y[a])) == False:
p = self.mapa.consume(self.mapa.fraction3, x[a], y[a], 10)
self.city_population.update({(x[a], y[a]): p})
elif self.city_population.__contains__((x[a], y[a])) == True:
p = self.mapa.consume(self.mapa.fraction3, x[a], y[a], self.city_population[(x[a], y[a])])
self.city_population.update({(x[a], y[a]): p})
self.mapa.auto_build(x[a], y[a], self.mapa.fraction3, None) # losowe tworzenie budynków
x.remove(x[a])
y.remove(y[a])
x, y = Simulation.check_pos(self.mapa.fraction4, self.mapa) # wywołanie funkcji zwracającej współrzędne
while (x.__len__() != 0):
a = random.randint(0, x.__len__() - 1) # wylosowanie z listy losowych współrzędnych
if self.city_population.__contains__((x[a], y[a])) == False:
p = self.mapa.consume(self.mapa.fraction4, x[a], y[a], 10)
self.city_population.update({(x[a], y[a]): p})
elif self.city_population.__contains__((x[a], y[a])) == True:
p = self.mapa.consume(self.mapa.fraction4, x[a], y[a], self.city_population[(x[a], y[a])])
self.city_population.update({(x[a], y[a]): p})
self.mapa.auto_build(x[a], y[a], self.mapa.fraction4, None) # losowe tworzenie budynków
x.remove(x[a])
y.remove(y[a])
Simulation.check_mine(self.mapa.fraction1, self.mapa) #zbiory materiałów 1 frakcji
Simulation.check_mine(self.mapa.fraction2, self.mapa) #zbiory materiałów 2 frakcji
Simulation.check_mine(self.mapa.fraction3, self.mapa) # zbiory materiałów 3 frakcji
Simulation.check_mine(self.mapa.fraction4, self.mapa) # zbiory materiałów 4 frakcji
Simulation.check_farm(self.mapa.fraction1, self.mapa) #zbiory jedzenia 1 frakcji
Simulation.check_farm(self.mapa.fraction2, self.mapa) #zbiory jedzienia 2 frakcji
Simulation.check_farm(self.mapa.fraction3, self.mapa) # zbiory jedzenia 3 frakcji
Simulation.check_farm(self.mapa.fraction4, self.mapa) # zbiory jedzienia 4 frakcji
self.mapa.show_fraction(self.mapa.fraction1) #pokazanie danych frakcji
self.mapa.show_fraction(self.mapa.fraction2)
self.mapa.show_fraction(self.mapa.fraction3)
self.mapa.show_fraction(self.mapa.fraction4)
self.mapa.show() #pokazanie mapy po zmianach
if Simulation.check_win(self.mapa.fraction1, self.mapa.fraction2, self.mapa.fraction3, self.mapa.fraction4, self.mapa, self.req_points) == str: #sprawdzenie zwycięstwa na końcu pętli
win = Simulation.check_win(self.mapa.fraction1, self.mapa.fraction2, self.mapa.fraction3, self.mapa.fraction4, self.req_points)
print(win)
with open("sim_save.txt", mode='w') as save_file: #zapisz do pliku wszystkich danych potrzebnych do odtworzenia symulacji
save_simulation = csv.writer(save_file, delimiter=" ", quotechar='"', quoting = csv.QUOTE_MINIMAL)
fractions = [self.mapa.fraction1, self.mapa.fraction2, self.mapa.fraction3, self.mapa.fraction4]
save_simulation.writerow(["Symulacja zakończyła się po", self.counter, "cyklach."])
save_simulation.writerow(["Próg punktów zwycięstwa:", self.req_points])
save_simulation.writerow(["Wielkość mapy", self.mapa.size])
save_simulation.writerow(["_______________________________________________________"])
for fraction in fractions:
save_simulation.writerow(["Frakcja:", fraction.symbol])
save_simulation.writerow(["Punkty:", int(fraction.points)])
save_simulation.writerow(["Ilość jedzenia:", int(fraction.food), " Ilość materiałów:", int(fraction.material)])
save_simulation.writerow(["Pozycja startowa:", (fraction.x, fraction.y)])
save_simulation.writerow(["_______________________________________________________"])
for y in range(1, self.mapa.size + 1):
for x in range(1, self.mapa.size + 1):
save_simulation.writerow(["Budynki na polu", (x, y), ":", self.mapa.ground_objects[x, y].symbol])
if self.counter == 98:
save_simulation.writerow(["REMIS!"])
time.sleep(0.25)
self.counter += 1
print("REMIS!") #Wyświetla remis jeżeli żadna frakcja nie wygrała po wszystkich cyklach
exit()
"""Zakańcza działanie programu"""
class Guerreiro:
memoria = None
flecha = 1
posicaoAtual = None
posicaoSupostaWumppus = []
posicaoSupostaOuro = None
score = 0
supostaPosicaoPocos = None
sensacoes = None
def __init__(self):
self.memoria = Mapa()
self.posicaoAtual = [0,0]
self.posicaoSupostaOuro = []
self.supostaPosicaoPocos = []
self.sensacoes = []
def agir(self, listaSensacoes):
self.sensacoes = listaSensacoes
print listaSensacoes.mostrarEspaco()
self.copiaParaMemoria
self.atualizaConhecimento()
print "memoria atual do Agente"
self.memoria.printMapa()
self.tomarDecisao()
def copiaParaMemoria (self):
self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].wumppus = listaSensacoes.wumppus
self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].ouro = listaSensacoes.ouro
self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].fedo = listaSensacoes.fedo
self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].briza = listaSensacoes.briza
self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].poco = listaSensacoes.poco
self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].visitado = 1
#movimentoDoJogador
def moveUp(self):
pass
def moveUp(self):
pass
def moveUp(self):
pass
def moveUp(self):
pass
def AtirarFlecha(self):
pass
def pegarOuro(self):
pass
def gerarPossibilidades(self):
pass
def atualizaConhecimento(self):
self.atualizaAdjPersonagem()
def atualizaAdjPersonagem(self):
if self.posicaoAtual[0] - 1 >= 0 :
print "kkkkkkk"
print self.posicaoAtual[0] - 1
if self.memoria.mapa[self.posicaoAtual[0]-1][self.posicaoAtual[1]].visitado== 0:
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].briza == 1:
self.memoria.mapa[0 - 1][self.posicaoAtual[1]].poco = 1
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].fedo == 1:
self.memoria.mapa[0 - 1][self.posicaoAtual[1]].wumppus = 1
if self.posicaoAtual[0] + 1 < 4 :
print "blabla"
obj = self.memoria.mapa[self.posicaoAtual[0]+1][self.posicaoAtual[1]]
if obj.visitado == 0:
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].briza == 1:
self.memoria.mapa[self.posicaoAtual[0] + 1][self.posicaoAtual[1]].poco = 1
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].fedo == 1:
self.memoria.mapa[0 - 1][self.posicaoAtual[1]].wumppus = 1
print "teste if2"
if self.posicaoAtual[1] - 1 >= 0 :
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1] - 1].visitado == 0:
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].briza == 1:
self.memoria.mapa[0][self.posicaoAtual[1] - 1].poco = 1
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].fedo == 1:
self.memoria.mapa[0][self.posicaoAtual[1] - 1].wumppus = 1
print "teste if3"
if self.posicaoAtual[1] + 1 < 4 :
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1] + 1].visitado == 0:
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].briza == 1:
self.memoria.mapa[0][self.posicaoAtual[1] + 1].poco = 1
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].fedo == 1:
self.memoria.mapa[0][self.posicaoAtual[1] + 1].wumppus = 1
print "teste if4"
def atualizaMemoria(self):
for i in range(0, len(self.memoria.mapa)):
for j in range (0, len(self.memoria.mapa[i])):
if self.memoria.mapa[i][j].visitado == 0 :
analizaAdj(i,j)
def atualizAdjTarget(self, i,j):
if j - 1 >= 0 :
if self.memoria.mapa[i][j - 1].visitado== 0:
if self.memoria.mapa[i][j].briza == 1:
self.memoria.mapa[0 - 1][self.posicaoAtual[1]].poco = 1
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].fedo == 1:
self.memoria.mapa[0 - 1][self.posicaoAtual[1]].wumppus = 1
if self.posicaoAtual[0] + 1 < 4 :
print "blabla"
obj = self.memoria.mapa[self.posicaoAtual[0]+1][self.posicaoAtual[1]]
if obj.visitado == 0:
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].briza == 1:
self.memoria.mapa[self.posicaoAtual[0] + 1][self.posicaoAtual[1]].poco = 1
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].fedo == 1:
self.memoria.mapa[0 - 1][self.posicaoAtual[1]].wumppus = 1
print "teste if2"
if self.posicaoAtual[1] - 1 >= 0 :
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1] - 1].visitado == 0:
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].briza == 1:
self.memoria.mapa[0][self.posicaoAtual[1] - 1].poco = 1
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].fedo == 1:
self.memoria.mapa[0][self.posicaoAtual[1] - 1].wumppus = 1
print "teste if3"
if self.posicaoAtual[1] + 1 < 4 :
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1] + 1].visitado == 0:
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].briza == 1:
self.memoria.mapa[0][self.posicaoAtual[1] + 1].poco = 1
if self.memoria.mapa[self.posicaoAtual[0]][self.posicaoAtual[1]].fedo == 1:
self.memoria.mapa[0][self.posicaoAtual[1] + 1].wumppus = 1
print "teste if4"
def tomarDecisao(self):
possibilidades = []
naoPossibilidades = []
self.gerarPossibilidades(possibilidades, naoPossibilidades):
def gerarPossibilidades(self, possibilidades, naoPossibilidades):
movimento = []
if()
def main():
wumppus = Wumppus()
mapa = Mapa()
#cria o wumppus
mapa.criarWumppus(wumppus)
#cria os pocos
mapa.criarPocos(wumppus)
#seta o ouro
mapa.inserirOuro()
mapa.printMapa()
#debug
for i in range(0, len(mapa.listaDePocos)):
print mapa.listaDePocos[i]
#cria Guerreiro
guerreiro = Guerreiro()
while True:
listaSensacao = mapa.pegarSensacao(guerreiro)
guerreiro.agir(listaSensacao)
input()
map_y_sqms_count = 11
screen_dimension_game = {
'x': 32 * map_x_sqms_count,
'y': 32 * map_y_sqms_count
}
pygame.init()
font_name = pygame.font.get_default_font()
name_font = pygame.font.SysFont(font_name, 16)
screen = pygame.display.set_mode(
(screen_dimension_game['x'], screen_dimension_game['y']), 0, 32)
clock = pygame.time.Clock()
mapa = Mapa(map_x_sqms_count, map_y_sqms_count)
player = Player(randrange(0, map_x_sqms_count), randrange(0, map_y_sqms_count),
'Arrois')
walk_player = WalkPlayer(player, 1)
player_walking = False
def player_walk_for(direction: WalkDirection, speed):
global walk_player
try:
walk_player.speed = speed
walk_player.set_direction_to_walk(direction)
walk_player.start()
except RuntimeError:
walk_player = WalkPlayer(player, speed)
def executar(self):
resultados = pd.DataFrame({
'melhores': [],
'piores': []
}) # Cria o DF para armazenar os resultados
mapa = Mapa(
self.__mapa) # Instancia e lê as coordenadas do mapa escolhido
cidades = mapa.ler_coordenadas()
pop = Populacao(self.__num_cel, self.__validade, cidades,
0) # Instancia uma nova população
populacao = pop.gerar_populacao() # Gera o DF da população
populacao.sort_values(
by='fitness',
inplace=True) # Ordena a população de acordo com o fitness
populacao.index = range(
populacao.shape[0]) # Ajusta o índice da população
mem = Memoria(populacao[:self.__tamanho_mem].copy()
) # Armazena na memória uma parcela da população
mem.ordenar_memoria() # Ordena a memória
for geracao in range(self.__num_ger): # Para cada geração:
# Clona a população de acordo com a quantidade estipulada de clones
populacao = clonar(populacao, self.__num_clones, geracao,
self.__validade, cidades)
populacao = pd.DataFrame(populacao)
# Ordena os valores da população de acordo com o 'fitness'
populacao.sort_values(by='fitness', inplace=True)
populacao.index = range(populacao.shape[0])
# Cria um data set temporário para a memória
memoria = pd.DataFrame(mem.get_memoria())
# Verifica uma a uma as células presentes na memória
for index, celula in populacao.iterrows():
# Armazena o pior valor de fitness
pior_fit = memoria.fitness.max()
# Verifica quais células já estão presentes na memória de acordo com o fitness
talvez_exista = memoria.fitness == celula.fitness
existe = False
for possibilidade in talvez_exista:
if possibilidade:
existe = True
# Armazena somente as células que não estão presentes na memória e possuem um 'fitness' melhor do que o
# pior já armazenado
if (celula.fitness < pior_fit) and (not existe):
memoria.drop([memoria.shape[0] - 1],
inplace=True) # Remove a última célula
memoria = memoria.append(
celula, ignore_index=True) # Adiciona a célula nova
memoria.sort_values(
by='fitness', inplace=True
) # Ordena a população de acordo com o fitness
memoria.index = range(
memoria.shape[0]) # Ajusta o índice da população
# Armazena o melhor fitness da memória e o pior fitness da população
resultados = resultados.append(
{
'melhores': memoria.fitness.min().copy(),
'piores': populacao.fitness.max().copy()
},
ignore_index=True)
# Diminui a validade das células
memoria.validade -= 1
# Verifica uma a uma as células presentes na memória
for index, row in memoria.iterrows():
if row.validade < 0: # Modifica o fitness se a validade for menor que zero
memoria.loc[index, 'fitness'] += row.fitness * 0.5
populacao = memoria.copy()
populacao = clonar(populacao,
int(self.__num_cel / self.__tamanho_mem - 1),
geracao, self.__validade, cidades)
populacao.sort_values(by='fitness', inplace=True)
populacao.index = range(populacao.shape[0])
mem.set_memoria(memoria.copy())
mem.ordenar_memoria()
print(
f'\n### {geracao} - {self.__execucao} ###\n{populacao.loc[0, "fitness"]}'
)
return resultados
